Python 通过其中一个列表中的重复元素过滤两个不规则列表

我已经在处理看似简单的问题一段时间了，我找不到一个简单的答案。考虑下面列出的两个列表：

a1 = [
    [[0.3, 1.75, 2.1, 3.3, 4.66, 8.9, 11.34],
     [0.3, 2.1, 3.3, 4.66, 8.9, 11.34],
     [0.3, 1.75, 2.1, 3.3, 4.66, 8.9, 11.34],
     [0.3, 1.75, 2.1, 3.3, 4.66, 8.9, 11.34]],
    [[0.3, 1.75, 2.1, 3.3, 4.66, 8.9, 11.34],
     [0.3, 1.75, 2.1, 3.3, 4.66, 8.9, 11.34],
     [0.3, 1.75, 2.1, 4.66, 8.9, 11.34],
     [0.3, 1.75, 2.1, 3.3, 4.66, 8.9, 11.34]]
]

a2 = [
    [[2, 3, 5, 8, 13, 21, 35],
     [2, 5, 8, 13, 21, 35],
     [2, 3, 5, 8, 13, 21, 35],
     [2, 3, 5, 8, 13, 21, 35]],
    [[2, 3, 5, 8, 13, 21, 35],
     [2, 3, 5, 8, 13, 21, 35],
     [2, 3, 5, 13, 21, 35],
     [2, 3, 5, 8, 13, 21, 35]]
]

它们的形状是

（N，M，p*）

，其中

p*

表示元素

p

的数量在所有子列表中都不相同（但对于

a2

中的子列表，其索引与

a1

中的子列表相同）。有时这两个列表将是完整的，所有子列表将包含相同的元素，即（在本例中）：

a1

中所有子列表的

0.3、1.75、2.1、3.3、4.66、8.9、11.34

，以及

a1

中所有子列表的

2、3、5、8、13、21、35

。在这种情况下，形状是

（N，M，P）

我需要一种方法，根据

a1

的所有子列表中可以找到的元素，同时过滤两个列表。在上述示例中，部分

a1

子列表中缺少元素

1.75

和

3.3

，因此结果如下：

a1_f = [0.3, 2.1, 4.66, 8.9, 11.34]
a2_f = [2, 5, 13, 21, 35]

其中

3

和

8

从

a2

中删除，因为它们链接到从

a1

中删除的非重复元素

1.75

和

3.3

我的实际列表要大得多，形状任意，所以我想要一个通用的方法。两个列表中的元素总是从最小到最大排序，但我不确定这是否有任何区别

---

任何帮助都将不胜感激。

我相信以下内容可以满足您的需要，而无需构建不必要的阵列副本：

from functools import reduce
rows = ((set(r1), set(r2)) for c1, c2 in zip(a1, a2) for r1, r2 in zip(c1, c2))
a1_f, a2_f = reduce(lambda a_f, row: (a_f[0] & row[0], a_f[1] & row[1]), rows)

它将所有列表收集到一个生成器中，一次两个，并将它们转换为集合。然后计算交点以找到最小的集合。如果需要将结果作为列表，可以使用

list（a1\u f）

等将其转换回

---

也就是说，同时过滤两个列表所得到的结果并不明显。分别执行每一项操作将使代码更简单，并且不会减慢速度。

我相信以下内容可以满足您的需要，而不会构建不必要的数组副本：

from functools import reduce
rows = ((set(r1), set(r2)) for c1, c2 in zip(a1, a2) for r1, r2 in zip(c1, c2))
a1_f, a2_f = reduce(lambda a_f, row: (a_f[0] & row[0], a_f[1] & row[1]), rows)

它将所有列表收集到一个生成器中，一次两个，并将它们转换为集合。然后计算交点以找到最小的集合。如果需要将结果作为列表，可以使用

list（a1\u f）

等将其转换回

---

也就是说，同时过滤两个列表所得到的结果并不明显。分别执行每一项操作将使代码更简单，并且不会减慢速度。

您可以使用

functools.reduce

以及

itertools.chain.from\u iterable

和

set.intersection

data = map(set, chain.from_iterable(a1))
a1_f  = reduce(set.intersection, data, next(data)))

---

您可以使用

functools.reduce

以及

itertools.chain.from\u iterable

和

set.intersection

data = map(set, chain.from_iterable(a1))
a1_f  = reduce(set.intersection, data, next(data)))

如果您希望将它们列在排序列表中：

a1_f = sorted(set.intersection(*(set(x) for x in chain.from_iterable(a1))))
a2_f = sorted(set.intersection(*(set(x) for x in chain.from_iterable(a2))))

# [0.3, 2.1, 4.66, 8.9, 11.34]
# [2, 5, 13, 21, 35]

编辑：如果您正在寻找的是在作业之前将

a1

和

a2

配对，假设数据结构保证为1对1，则可以执行以下操作：

result = sorted(set.intersection(*map(lambda x: set(zip(*x)), zip(*(chain.from_iterable(l) for l in (a1, a2))))))
# [(0.3, 2), (2.1, 5), (4.66, 13), (8.9, 21), (11.34, 35)]

a1_f, a2_f = [list(map(lambda x: x[i], result)) for i in range(2)]

a1_f
# [0.3, 2.1, 4.66, 8.9, 11.34]

a2_f
# [2, 5, 13, 21, 35]

如果您希望将它们列在排序列表中：

a1_f = sorted(set.intersection(*(set(x) for x in chain.from_iterable(a1))))
a2_f = sorted(set.intersection(*(set(x) for x in chain.from_iterable(a2))))

# [0.3, 2.1, 4.66, 8.9, 11.34]
# [2, 5, 13, 21, 35]

编辑：如果您正在寻找的是在作业之前将

a1

和

a2

配对，假设数据结构保证为1对1，则可以执行以下操作：

result = sorted(set.intersection(*map(lambda x: set(zip(*x)), zip(*(chain.from_iterable(l) for l in (a1, a2))))))
# [(0.3, 2), (2.1, 5), (4.66, 13), (8.9, 21), (11.34, 35)]

a1_f, a2_f = [list(map(lambda x: x[i], result)) for i in range(2)]

a1_f
# [0.3, 2.1, 4.66, 8.9, 11.34]

a2_f
# [2, 5, 13, 21, 35]

---

使用

zip

创建元组。使用

set.intersection

查找所有列表中的元素。。。或者在系列中使用

all

函数。我尝试使用

set.intersect

但我一直得到

TypeError:unhable type:“list”

，我猜这与我如何使用

zip

有关……使用

zip

生成元组。使用

set.intersection

查找所有列表中的元素。。。或者在该系列中使用

all

函数。我尝试使用

set.intersect

但我一直得到

TypeError:unhable type:“list”

我猜它与我如何使用

zip

有关……但这并没有扩展到也会影响

a2

。但这并没有扩展到也会影响

a2

a2

。问题在于它独立处理两个列表。

a2

列表应根据

a1

进行过滤，而不是单独过滤。根据我对您的澄清的理解，我已更新了答案。请参阅我的编辑。请注意，此解决方案不会遵循原始项目顺序。它之所以有效，是因为问题中的样本数据恰好是预排序的，因此您可以使用

排序

@blhsing>恢复顺序。这就是为什么我问数据结构是否有保证。如果顺序很重要的话，我只是循环一下。问题是它独立地处理两个列表。

a2

列表应根据

a1

进行过滤，而不是单独过滤。根据我对您的澄清的理解，我已更新了答案。请参阅我的编辑。请注意，此解决方案不会遵循原始项目顺序。它之所以有效，是因为问题中的样本数据恰好是预排序的，因此您可以使用

排序

@blhsing>恢复顺序。这就是为什么我问数据结构是否有保证。如果订单很重要的话，我还是循环一下。