如何找到列表交集？
Posted
技术标签:
【中文标题】如何找到列表交集？【英文标题】：How to find list intersection? 【发布时间】：2011-04-11 11:28:31 【问题描述】：a = [1,2,3,4,5]
b = [1,3,5,6]
c = a and b
print c
实际输出：[1,3,5,6]
预期输出：[1,3,5]
我们如何在两个列表上实现布尔与运算（列表交集）？
【问题讨论】：
这里的问题是a and b 的工作方式类似于以下statement from the documentation 提到它：“表达式x and y 首先计算x；如果x 为假，则它的值返回；否则，评估 y 并返回结果值。"
这能回答你的问题吗？ How can I compare two lists in python and return matches
【参考方案1】：
如果顺序不重要并且您不需要担心重复，那么您可以使用设置交集：
>>> a = [1,2,3,4,5]
>>> b = [1,3,5,6]
>>> list(set(a) & set(b))
[1, 3, 5]
【讨论】：
如果a = [1,1,2,3,4,5] 和b = [1,1,3,5,6] 的交集是[1,1,3,5] 但通过上述方法将导致只有一个1 即[1, 3, 5]那么呢？
@NItishKumarPal intersection 通常被理解为基于 set。您正在寻找一种稍有不同的动物 - 您可能需要手动执行此操作，方法是对每个列表进行排序并合并结果 - 并在合并中保持重复。
@MarkByers 这将不会有重复。
感谢 Mark Byers :) 对于读者：注意列表的顺序。在这种情况下，请查看 Lodewijk 的答案。
我认为这是一个错误的答案。这个问题明确提到了列表，而不是集合。列表可以多次包含相同的项目，因此它们确实是不同的野兽，此答案未解决。【参考方案2】：
如果，通过布尔 AND，您的意思是出现在两个列表中的项目，例如交集，那么你应该看看 Python 的 set 和 frozenset 类型。
【讨论】：
【参考方案3】：用较大的做一套：
_auxset = set(a)
那么，
c = [x for x in b if x in _auxset]
会做你想做的事（保留b 的顺序，而不是a 的——不一定能保留两者）并快速 . （使用if x in a 作为列表理解中的条件也可以，并且无需构建_auxset，但不幸的是对于相当长的列表会慢很多）。
如果您希望对结果进行排序，而不是保留任一列表的顺序，则更简洁的方法可能是：
c = sorted(set(a).intersection(b))
【讨论】：
这几乎肯定比公认的答案要慢，但其优点是不会丢失重复项。【参考方案4】：如果将两个列表中较大的一个转换为一个集合，则可以使用 intersection() 获得该集合与任何可迭代对象的交集：
a = [1,2,3,4,5]
b = [1,3,5,6]
set(a).intersection(b)
【讨论】：
这和list(set(a) & set(b))有什么不同
为什么将哪个列表转换为集合很重要（假设 n ！= m）？只将一个转换为集合有什么好处？
好像这样会更快【参考方案5】：
a = [1,2,3,4,5]
b = [1,3,5,6]
c = list(set(a).intersection(set(b)))
应该像梦一样工作。而且，如果可以的话，使用集合而不是列表来避免所有这些类型的变化！
【讨论】：
如果 a 和 b 很大，那么这比其他答案更快【参考方案6】：对我来说，使用列表推导很明显。不确定性能，但至少可以列出一些内容。
[x for x in a if x in b]
或“如果 X 值在 B 中，则 A 中的所有 x 值”。
【讨论】：
这似乎是最符合pythonic的保持秩序。不知道为什么这没有得到更高的投票！！感谢您提供出色的解决方案！ 这是一个 O(n^2) 的解决方案，而上面的解决方案是 O(n) @nareddyt - 将b 设置为一组，您将拥有 O(n)
@jcchuks 此解决方案的优点是如果您需要保留重复项。如果您可以确定唯一性，那么 O(n) 集合解决方案会更好。但是，如果不可能重复，为什么 OP 甚至开始谈论列表？列表交集的概念在数学上是荒谬的
因为检查一个项目是否在列表 b 中是 O(n)，而不是 O(1)。您对a 中的每个元素执行n 次。所以 O(n^2).【参考方案7】：
这里有一些 Python 2 / Python 3 代码，它们为基于列表和基于集合的方法生成时间信息，以查找两个列表的交集。
纯粹的列表理解算法是 O(n^2)，因为列表上的in 是线性搜索。基于集合的算法是 O(n)，因为集合搜索是 O(1)，集合创建是 O(n)（并且将集合转换为列表也是 O(n)）。因此，对于足够大的 n，基于集合的算法更快，但对于小的 n，创建集合的开销使它们比纯列表比较算法慢。
#!/usr/bin/env python
''' Time list- vs set-based list intersection
See http://***.com/q/3697432/4014959
Written by PM 2Ring 2015.10.16
'''
from __future__ import print_function, division
from timeit import Timer
setup = 'from __main__ import a, b'
cmd_lista = '[u for u in a if u in b]'
cmd_listb = '[u for u in b if u in a]'
cmd_lcsa = 'sa=set(a);[u for u in b if u in sa]'
cmd_seta = 'list(set(a).intersection(b))'
cmd_setb = 'list(set(b).intersection(a))'
reps = 3
loops = 50000
def do_timing(heading, cmd, setup):
t = Timer(cmd, setup)
r = t.repeat(reps, loops)
r.sort()
print(heading, r)
return r[0]
m = 10
nums = list(range(6 * m))
for n in range(1, m + 1):
a = nums[:6*n:2]
b = nums[:6*n:3]
print('\nn =', n, len(a), len(b))
#print('\nn = %d\n%s %d\n%s %d' % (n, a, len(a), b, len(b)))
la = do_timing('lista', cmd_lista, setup)
lb = do_timing('listb', cmd_listb, setup)
lc = do_timing('lcsa ', cmd_lcsa, setup)
sa = do_timing('seta ', cmd_seta, setup)
sb = do_timing('setb ', cmd_setb, setup)
print(la/sa, lb/sa, lc/sa, la/sb, lb/sb, lc/sb)
输出
n = 1 3 2
lista [0.082171916961669922, 0.082588911056518555, 0.0898590087890625]
listb [0.069530963897705078, 0.070394992828369141, 0.075379848480224609]
lcsa [0.11858987808227539, 0.1188349723815918, 0.12825107574462891]
seta [0.26900982856750488, 0.26902294158935547, 0.27298116683959961]
setb [0.27218389511108398, 0.27459001541137695, 0.34307217597961426]
0.305460649521 0.258469975867 0.440838458259 0.301898526833 0.255455833892 0.435697630214
n = 2 6 4
lista [0.15915989875793457, 0.16000485420227051, 0.16551494598388672]
listb [0.13000702857971191, 0.13060092926025391, 0.13543915748596191]
lcsa [0.18650484085083008, 0.18742108345031738, 0.19513416290283203]
seta [0.33592700958251953, 0.34001994132995605, 0.34146714210510254]
setb [0.29436492919921875, 0.2953648567199707, 0.30039691925048828]
0.473793098554 0.387009751735 0.555194537893 0.540689066428 0.441652573672 0.633583767462
n = 3 9 6
lista [0.27657914161682129, 0.28098297119140625, 0.28311991691589355]
listb [0.21585917472839355, 0.21679902076721191, 0.22272896766662598]
lcsa [0.22559309005737305, 0.2271728515625, 0.2323150634765625]
seta [0.36382699012756348, 0.36453008651733398, 0.36750602722167969]
setb [0.34979605674743652, 0.35533690452575684, 0.36164689064025879]
0.760194128313 0.59330170819 0.62005595016 0.790686848184 0.61710008036 0.644927481902
n = 4 12 8
lista [0.39616990089416504, 0.39746403694152832, 0.41129183769226074]
listb [0.33485794067382812, 0.33914685249328613, 0.37850618362426758]
lcsa [0.27405810356140137, 0.2745978832244873, 0.28249192237854004]
seta [0.39211201667785645, 0.39234519004821777, 0.39317893981933594]
setb [0.36988520622253418, 0.37011313438415527, 0.37571001052856445]
1.01034878821 0.85398540833 0.698928091731 1.07106176249 0.905302334456 0.740927452493
n = 5 15 10
lista [0.56792402267456055, 0.57422614097595215, 0.57740211486816406]
listb [0.47309303283691406, 0.47619009017944336, 0.47628307342529297]
lcsa [0.32805585861206055, 0.32813096046447754, 0.3349759578704834]
seta [0.40036201477050781, 0.40322518348693848, 0.40548801422119141]
setb [0.39103078842163086, 0.39722800254821777, 0.43811702728271484]
1.41852623806 1.18166313332 0.819398061028 1.45237674242 1.20986133789 0.838951479847
n = 6 18 12
lista [0.77897095680236816, 0.78187918663024902, 0.78467702865600586]
listb [0.629547119140625, 0.63210701942443848, 0.63321495056152344]
lcsa [0.36563992500305176, 0.36638498306274414, 0.38175487518310547]
seta [0.46695613861083984, 0.46992206573486328, 0.47583580017089844]
setb [0.47616910934448242, 0.47661614418029785, 0.4850609302520752]
1.66818870637 1.34819326075 0.783028414812 1.63591241329 1.32210827369 0.767878297495
n = 7 21 14
lista [0.9703209400177002, 0.9734041690826416, 1.0182771682739258]
listb [0.82394003868103027, 0.82625699043273926, 0.82796716690063477]
lcsa [0.40975093841552734, 0.41210508346557617, 0.42286920547485352]
seta [0.5086359977722168, 0.50968098640441895, 0.51014018058776855]
setb [0.48688101768493652, 0.4879908561706543, 0.49204087257385254]
1.90769222837 1.61990115188 0.805587768483 1.99293236904 1.69228211566 0.841583309951
n = 8 24 16
lista [1.204819917678833, 1.2206029891967773, 1.258256196975708]
listb [1.014998197555542, 1.0206191539764404, 1.0343101024627686]
lcsa [0.50966787338256836, 0.51018595695495605, 0.51319599151611328]
seta [0.50310111045837402, 0.50556015968322754, 0.51335406303405762]
setb [0.51472997665405273, 0.51948785781860352, 0.52113485336303711]
2.39478683834 2.01748351664 1.01305257092 2.34068341135 1.97190418975 0.990165516871
n = 9 27 18
lista [1.511646032333374, 1.5133969783782959, 1.5639569759368896]
listb [1.2461750507354736, 1.254518985748291, 1.2613379955291748]
lcsa [0.5565330982208252, 0.56119203567504883, 0.56451296806335449]
seta [0.5966339111328125, 0.60275578498840332, 0.64791703224182129]
setb [0.54694414138793945, 0.5508568286895752, 0.55375313758850098]
2.53362406013 2.08867620074 0.932788243907 2.76380331728 2.27843203069 1.01753187594
n = 10 30 20
lista [1.7777848243713379, 2.1453688144683838, 2.4085969924926758]
listb [1.5070111751556396, 1.5202279090881348, 1.5779800415039062]
lcsa [0.5954139232635498, 0.59703707695007324, 0.60746097564697266]
seta [0.61563014984130859, 0.62125110626220703, 0.62354087829589844]
setb [0.56723213195800781, 0.57257509231567383, 0.57460403442382812]
2.88774814689 2.44791645689 0.967161734066 3.13413984189 2.6567803378 1.04968299523
使用具有 2GB RAM 的 2GHz 单核机器在 Debian 风格的 Linux 上运行 Python 2.6.6（Firefox 在后台运行）生成。
这些数字只是一个粗略的指导，因为各种算法的实际速度受到两个源列表中元素比例的不同影响。
【讨论】：
【参考方案8】：使用filter 和lambda 运算符可以实现一种功能方式。
list1 = [1,2,3,4,5,6]
list2 = [2,4,6,9,10]
>>> list(filter(lambda x:x in list1, list2))
[2, 4, 6]
编辑：过滤掉list1和list中都存在的x，设置差异也可以使用：
>>> list(filter(lambda x:x not in list1, list2))
[9,10]
Edit2: python3 filter 返回一个过滤器对象，用list 封装它返回输出列表。
【讨论】：
请使用edit链接来解释这段代码是如何工作的，不要只给出代码，因为解释更有可能帮助未来的读者。另见How to Answer。 source 对于 Python3，这将返回一个过滤器对象。您需要说list(filter(lambda x:x in list1, list2)) 才能将其作为列表获取。
当列表不可散列时这非常好！【参考方案9】：
这是一个示例，当您需要时结果中的每个元素都应该出现在两个数组中的次数。
def intersection(nums1, nums2):
#example:
#nums1 = [1,2,2,1]
#nums2 = [2,2]
#output = [2,2]
#find first 2 and remove from target, continue iterating
target, iterate = [nums1, nums2] if len(nums2) >= len(nums1) else [nums2, nums1] #iterate will look into target
if len(target) == 0:
return []
i = 0
store = []
while i < len(iterate):
element = iterate[i]
if element in target:
store.append(element)
target.remove(element)
i += 1
return store
【讨论】：
【参考方案10】：可能已经晚了，但我只是想我应该分享一下你需要手动完成的情况（显示工作 - 哈哈），或者当你需要所有元素尽可能多次出现或你还需要它时是独一无二的。
请注意，我们也为它编写了测试。
from nose.tools import assert_equal
'''
Given two lists, print out the list of overlapping elements
'''
def overlap(l_a, l_b):
'''
compare the two lists l_a and l_b and return the overlapping
elements (intersecting) between the two
'''
#edge case is when they are the same lists
if l_a == l_b:
return [] #no overlapping elements
output = []
if len(l_a) == len(l_b):
for i in range(l_a): #same length so either one applies
if l_a[i] in l_b:
output.append(l_a[i])
#found all by now
#return output #if repetition does not matter
return list(set(output))
else:
#find the smallest and largest lists and go with that
sm = l_a if len(l_a) len(l_b) else l_b
for i in range(len(sm)):
if sm[i] in lg:
output.append(sm[i])
#return output #if repetition does not matter
return list(set(output))
## Test the Above Implementation
a = [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
b = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
exp = [1, 2, 3, 5, 8, 13]
c = [4, 4, 5, 6]
d = [5, 7, 4, 8 ,6 ] #assuming it is not ordered
exp2 = [4, 5, 6]
class TestOverlap(object):
def test(self, sol):
t = sol(a, b)
assert_equal(t, exp)
print('Comparing the two lists produces')
print(t)
t = sol(c, d)
assert_equal(t, exp2)
print('Comparing the two lists produces')
print(t)
print('All Tests Passed!!')
t = TestOverlap()
t.test(overlap)
【讨论】：
【参考方案11】：您也可以使用计数器！它不会保留顺序，但会考虑重复项：
>>> from collections import Counter
>>> a = [1,2,3,4,5]
>>> b = [1,3,5,6]
>>> d1, d2 = Counter(a), Counter(b)
>>> c = [n for n in d1.keys() & d2.keys() for _ in range(min(d1[n], d2[n]))]
>>> print(c)
[1,3,5]
【讨论】：
在你的例子中你可以做c = (d1 & d2).elements()。【参考方案12】：
通过这种方式，您可以获得两个列表的交集并获得常见的重复项。
>>> from collections import Counter
>>> a = Counter([1,2,3,4,5])
>>> b = Counter([1,3,5,6])
>>> a &= b
>>> list(a.elements())
[1, 3, 5]
【讨论】：
【参考方案13】：这里的大多数解决方案都没有考虑列表中元素的顺序，而是将列表视为集合。另一方面，如果您想找到两个列表中包含的最长子序列之一，您可以尝试以下代码。
def intersect(a, b):
if a == [] or b == []:
return []
inter_1 = intersect(a[1:], b)
if a[0] in b:
idx = b.index(a[0])
inter_2 = [a[0]] + intersect(a[1:], b[idx+1:])
if len(inter_1) <= len(inter_2):
return inter_2
return inter_1
对于a=[1,2,3] 和b=[3,1,4,2]，这将返回[1,2] 而不是[1,2,3]。请注意，这样的子序列不是唯一的，因为[1]、[2]、[3] 都是a=[1,2,3] 和b=[3,2,1] 的解决方案。
【讨论】：
【参考方案14】：您也可以使用numpy.intersect1d(ar1, ar2)。
它返回两个数组中唯一且已排序的值。
【讨论】：
【参考方案15】：如果你有一个列表列表map 就派上用场了：
>>> lists = [[1, 2, 3], [2, 3, 4], [2, 3, 5]]
>>> set(lists.pop()).intersection(*map(set, lists))
2, 3
适用于类似的可迭代对象：
>>> lists = ['ash', 'nazg']
>>> set(lists.pop()).intersection(*map(set, lists))
'a'
如果列表为空，pop 会爆炸，因此您可能需要包装一个函数：
def intersect_lists(lists):
try:
return set(lists.pop()).intersection(*map(set, lists))
except IndexError: # pop from empty list
return set()
【讨论】：
【参考方案16】：当我们使用元组并且我们想要交集时
a=([1,2,3,4,5,20], [8,3,9,5,1,4,20])
for i in range(len(a)):
b=set(a[i-1]).intersection(a[i])
print(b)
1, 3, 4, 5, 20
【讨论】：
这不能只用set(a[0]).intersection(*a[1:])来完成吗？以上是关于如何找到列表交集？的主要内容，如果未能解决你的问题，请参考以下文章