如何将此操作矢量化

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 intersect
uni = [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 labeling of text chunks），其中每个列表元素是文档中的字符索引，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

处理大型数据集时的一种高效内存做法

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

v = zip(l0, l1)
intersec = []
uni = []
for _ in range(len(l0)):
    x = next(v)
    intersec.append(x[0] if x[0] == x[1] != 0 else 0)
    uni.append([x[0],x[1]] if x[0] != x[1] else x[0])


print(intersec)
print(uni)

输出

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

Answer 3

并集和交集的半矢量化解：

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]