如何向量化这个操作

Question

假设我有两个列表（总是相同的长度）：l0 = [0, 4, 4, 4, 0, 0, 0, 8, 8, 0] l1 = [0, 1, 1, 1, 0, 0, 0, 8, 8, 8]在逐元素比较这些列表时，我需要应用以下交集和联合规则：# union and intersectuni = [0]*len(l0)intersec = [0]*len(l0)for i in range(len(l0)):    if l0[i] == l1[i]:        uni[i] = l0[i]        intersec[i] = l0[i]    else:        intersec[i] = 0          if l0[i] == 0:            uni[i] = l1[i]        elif l1[i] == 0:            uni[i] = l0[i]        else:            uni[i] = [l0[i], l1[i]]因此，所需的输出是：uni: [0, [4, 1], [4, 1], [4, 1], 0, 0, 0, 8, 8, 8] intersec: [0, 0, 0, 0, 0, 0, 0, 8, 8, 0]虽然这可行，但我需要使用数百个非常大的列表（每个列表包含数千个元素）来执行此操作，因此我正在寻找一种对其进行矢量化的方法。我尝试使用np.where和各种掩蔽策略，但进展不快。任何建议都将受到欢迎。* 编辑 *关于uni: [0, [4, 1], [4, 1], [4, 1], 0, 0, 0, 8, 8, 8]相对uni: [0, [4, 1], [4, 1], [4, 1], 0, 0, 0, 8, 8, [0, 8]]在我的脑海中，我仍在与 8 与 [0, 8] 作斗争。列表派生自系统注释中的 BIO 标记（请参阅文本块的 IOB 标记），其中每个列表元素是文档中的字符索引，而 vakue 是分配的枚举标签。0 表示表示没有注释的标签（即，用于确定混淆矩阵中的否定）；而非零元素表示为该字符分配的枚举标签。由于我忽略了真正的否定，我想我可以说 8 相当于 [0, 8]。至于这是否简化了事情，我还不确定。* 编辑 2 *我习惯于[0, 8]保持简单，并保持集合论的定义intersection和一致。union

Answer 1

我不会称它们为“交集”和“并集”，因为这些操作在集合上具有明确定义的含义，而您要执行的操作两者都不是。

但是，做你想做的事：

l0 = [0, 4, 4, 4, 0, 0, 0, 8, 8, 0]

l1 = [0, 1, 1, 1, 0, 0, 0, 8, 8, 8]

values = [

    (x

     if x == y else 0,

     0

     if x == y == 0

     else x if y == 0

     else y if x == 0

     else [x, y]) 

    for x, y in zip(l0, l1)

]

result_a, result_b = map(list, zip(*values))

print(result_a)

print(result_b)

这对于数千甚至数百万个元素来说已经绰绰有余，因为操作是如此基础。当然，如果我们谈论的是数十亿，那么无论如何你可能都想看看 numpy。

Answer 2

联合的半向量化解决方案和交集的完整解决方案：

import numpy as np

l0 = np.array(l0)

l1 = np.array(l1)

intersec = np.zeros(l0.shape[0])

intersec_idx = np.where(l0==l1)

intersec[intersec_idx] = l0[intersec_idx]

intersec = intersec.astype(int).tolist()

union = np.zeros(l0.shape[0])

union_idx = np.where(l0==l1)

union[union_idx] = l0[union_idx]

no_union_idx = np.where(l0!=l1)

union = union.astype(int).tolist()

for idx in no_union_idx[0]:

    union[idx] = [l0[idx], l1[idx]]

和输出：

>>> intersection

[0, 0, 0, 0, 0, 0, 0, 8, 8, 0]

>>> union  

[0, [4, 1], [4, 1], [4, 1], 0, 0, 0, 8, 8, [0, 8]]

注意：我认为您原来的联合解决方案是不正确的。查看最后的输出 8 vs [0,8]