我想将 1 个列表的所有元素与另一个进行 XOR。我该怎么做？ [复制]

Question

我有一堆形式为 [0,0,1,0,1...] 的列表，我想对 2 个列表进行 XOR 并将输出作为列表给出。 喜欢： [ 0, 0, 1 ] 异或 [ 0, 1, 0 ] -> [ 0, 1, 1 ]

res = []
tmp = []

for i in Employee_Specific_Vocabulary_Dict['Binary Vector']:
    for j in Course_Specific_Vocabulary_Dict['Binary Vector']:

        tmp = [i[index] ^ j[index] for index in range(len(i))]
        res.append(temp)

我的每个列表/向量的大小约为 3500 个元素，因此我需要一些东西来节省时间，因为这段代码需要 20 多分钟才能运行。

我有 3085 个列表，每个列表都需要与 4089 个其他列表进行异或运算。

如何在不显式遍历每个列表的情况下做到这一点？

Answer 1

使用map:

answer = list(map(operator.xor, lst1, lst2)).

或zip:

answer = [x ^ y for x,y in zip(lst1, lst2)]

如果您需要更快的速度，请考虑使用 NumPy 而不是 Python 列表来保存您的数据。

Answer 2

假设a 和b 的大小相同，您可以使用xor 操作（即^）和简单的列表索引：

a = [0, 0, 1]
b = [0, 1, 1]
c = [a[index] ^ b[index] for index in range(len(a))]
print(c) # [0, 1, 0]

或者您可以将zip 与xor 一起使用：

a = [0, 0, 1]
b = [0, 1, 1]
c = [x ^ y for x, y in zip(a, b)]
print(c) # [0, 1, 0]

zip 只会进入最短的列表（如果它们的大小不同）。如果它们的大小不同，并且您想转到更长的列表，可以使用zip_longest：

from itertools import zip_longest
a = [0, 0, 1, 1]
b = [0, 1, 1]
c = [x ^ y for x, y in zip_longest(a, b, fillvalue=0)]
print(c) # [0, 1, 0, 1]

Answer 3

使用numpy应该会有一些性能提升，你需要的函数是bitwise_xor，像这样：

import numpy as np
results = []
for i in Employee_Specific_Vocabulary_Dict['Binary Vector']:
    for j in Course_Specific_Vocabulary_Dict['Binary Vector']:
        results.append(np.bitwise_xor(i, j))

概念证明：

a = [1,0,0,1,1]
b = [1,1,0,0,1]
x = np.bitwise_xor(a,b)
print("a\tb\tres")
for i in range(len(a)):
    print("{}\t{}\t{}".format(a[i], b[i], x[i]))

输出：

a       b       x
1       1       0                                                                                                       
0       1       1                                                                                                       
0       0       0                                                                                                       
1       0       1                                                                                                       
1       1       0

编辑

请注意，如果您的数组大小相同，您只需执行一项操作，bitwise_xor 仍然可以工作，所以：

a = [[1,1,0], [0,0,1]]
b = [[0,1,0], [1,0,1]]
res = np.bitwise_xor(a, b)

仍然可以工作，您将拥有：

res: [[1, 0, 0], [1, 0, 0]]

在您的情况下，解决方法可能是：

results = []
n = len(Course_Specific_Vocabulary_Dict['Binary Vector'])
for a in Employee_Specific_Vocabulary_Dict['Binary Vector']:
    # Get same size array w.r.t Course_Specific_Vocabulary_Dict["Binary Vector]
    repeated_a = np.repeat([a], n, axis=0)
    results.append(np.bitwise_xor(repeated_a, Course_Specific_Vocabulary_Dict['Binary Vector']))

但是我不知道这是否真的会提高性能，有待检查；肯定会需要更多内存。