两个列表之间的公共元素比较

使用Python的设置十字路口:

>>> list1 = [1,2,3,4,5,6]
>>> list2 = [3, 5, 7, 9]
>>> list(set(list1).intersection(list2))
[3, 5]

使用set交叉，set(list1) &集(用于)

>>> def common_elements(list1, list2):
...     return list(set(list1) & set(list2))
...
>>>
>>> common_elements([1,2,3,4,5,6], [3,5,7,9])
[3, 5]
>>>
>>> common_elements(['this','this','n','that'],['this','not','that','that'])
['this', 'that']
>>>
>>>

注意，结果列表可能与原始列表顺序不同。

S.Mark和SilentGhost所建议的解决方案通常会告诉你应该如何以python的方式完成它，但我认为你也可以从知道为什么你的解决方案不起作用中受益。问题是，一旦找到两个列表中的第一个公共元素，就只返回该元素。你的解决方案可以通过创建一个result列表并收集该列表中的公共元素来修复:

def common_elements(list1, list2):
result = []
for element in list1:
if element in list2:
result.append(element)
return result

一个使用列表推导式的更简短的版本:

def common_elements(list1, list2):
return [element for element in list1 if element in list2]

然而，正如我所说，这是一种非常低效的方式——Python的内置集类型更高效，因为它们是在C内部实现的。

前面的答案都可以找到唯一的公共元素，但不能解释列表中重复的项目。如果你想让公共元素在列表中以相同的数字出现，你可以使用下面的一行代码:

l2, common = l2[:], [ e for e in l1 if e in l2 and (l2.pop(l2.index(e)) or True)]

or True部分只在你希望任何元素求值为False时才有必要。

def findarrayhash(a,b):
h1={k:1 for k in a}
for val in b:
if val in h1:
print("common found",val)
del h1[val]
else:
print("different found",val)
for key in h1.iterkeys():
print ("different found",key)

找到共同和不同的元素:

def findarrayset(a,b):
common = set(a)&set(b)
diff=set(a)^set(b)
print list(common)
print list(diff)

您还可以使用集合并在一行中获得共性:从其中一个集合中减去包含差异的集合。

A = [1,2,3,4]
B = [2,4,7,8]
commonalities = set(A) - (set(A) - set(B))

集合是另一种解法

a = [3,2,4]
b = [2,3,5]
set(a)&set(b)
{2, 3}

使用发电机:

common = (x for x in list1 if x in list2)

这样做的好处是，即使在使用庞大的列表或其他庞大的可迭代对象时，它也会在常数时间内(几乎立即)返回生成器。

例如,

list1 =  list(range(0,10000000))
list2=list(range(1000,20000000))
common = (x for x in list1 if x in list2)

对于list1和list2的这些值，这里的所有其他答案都将花费很长时间。

然后，您可以用

for i in common: print(i)

我比较了每个答案提到的每一种方法。目前，我使用python 3.6.3来实现这个功能。这是我使用的代码:

import time
import random
from decimal import Decimal




def method1():
common_elements = [x for x in li1_temp if x in li2_temp]
print(len(common_elements))




def method2():
common_elements = (x for x in li1_temp if x in li2_temp)
print(len(list(common_elements)))




def method3():
common_elements = set(li1_temp) & set(li2_temp)
print(len(common_elements))




def method4():
common_elements = set(li1_temp).intersection(li2_temp)
print(len(common_elements))




if __name__ == "__main__":
li1 = []
li2 = []
for i in range(100000):
li1.append(random.randint(0, 10000))
li2.append(random.randint(0, 10000))


li1_temp = list(set(li1))
li2_temp = list(set(li2))


methods = [method1, method2, method3, method4]
for m in methods:
start = time.perf_counter()
m()
end = time.perf_counter()
print(Decimal((end - start)))

如果你运行这段代码，你可以看到如果你使用列表或生成器(如果你迭代生成器，而不是仅仅使用它)。当我强迫生成器打印它的长度时，我这样做了)，你会得到几乎相同的性能。但是如果你使用set，你会得到更好的性能。如果你使用交叉方法你会得到更好的性能。在我的电脑中，每种方法的结果如下:

1. method1: 0.8150673999999999974619413478649221360683441
2. method2: 0.8329545000000001531148541289439890533685684
3. method3: 0.0016547000000000089414697868051007390022277
4. method4: 0.0010262999999999244948867271887138485908508

你可以使用numpy来解决这个问题:

import numpy as np


list1 = [1, 2, 3, 4, 5, 6]
list2 = [3, 5, 7, 9]


common_elements = np.intersect1d(list1, list2)
print(common_elements)

common_elements将是numpy数组:[3 5]。

这里有一些解决方案是在O(l1+l2)不计算重复项目，而缓慢的解决方案(至少O(l1*l2)，但可能更昂贵)确实考虑重复项目。

所以我想我应该添加一个O(l1*log(l1)+l2*(log(l2))解。如果列表已经排序，这尤其有用。

def common_elems_with_repeats(first_list, second_list):
first_list = sorted(first_list)
second_list = sorted(second_list)
marker_first = 0
marker_second = 0
common = []
while marker_first < len(first_list) and marker_second < len(second_list):
if(first_list[marker_first] == second_list[marker_second]):
common.append(first_list[marker_first])
marker_first +=1
marker_second +=1
elif first_list[marker_first] > second_list[marker_second]:
marker_second += 1
else:
marker_first += 1
return common

另一个更快的解决方案包括从list1创建一个item->count映射，并遍历list2，同时更新映射和计数。不需要排序。需要额外的内存，但技术上是O(l1+l2)

如果list1和list2是无序的:

使用交叉:

print((set(list1)).intersection(set(list2)))

合并列表并检查元素的出现次数是否大于1:

combined_list = list1 + list2
set([num for num in combined_list if combined_list.count(num) > 1])

类似于上面，但不使用set:

for num in combined_list:
if combined_list.count(num) > 1:
print(num)
combined_list.remove(num)

对于排序列表，没有python特殊的内置，一个O(n)解决方案

p1 = 0
p2 = 0
result = []
while p1 < len(list1) and p2 < len(list2):
if list1[p1] == list2[p2]:
result.append(list1[p1])
p1 += 1
p2 += 2
elif list1[p1] > list2[p2]:
p2 += 1
else:
p1 += 1
print(result)

我已经制定出了深度交叉口的完整解决方案

def common_items_dict(d1, d2, use_set_for_list_commons=True, use_set_for_dict_key_commons=True, append_empty=False):
result = {}
if use_set_for_dict_key_commons:
shared_keys=list(set(d1.keys()).intersection(d2.keys())) # faster, order not preserved
else:
shared_keys=common_items_list(d1.keys(), d2.keys(), use_set_for_list_commons=False)


for k in  shared_keys:
v1 = d1[k]
v2 = d2[k]
if isinstance(v1, dict) and isinstance(v2, dict):
result_dict=common_items_dict(v1, v2, use_set_for_list_commons, use_set_for_dict_key_commons, append_empty)
if len(result_dict)>0 or append_empty:
result[k] = result_dict
elif isinstance(v1, list) and isinstance(v2, list):
result_list=common_items_list(v1, v2, use_set_for_list_commons, use_set_for_dict_key_commons, append_empty)
if len(result_list)>0 or append_empty:
result[k] = result_list
elif v1 == v2:
result[k] = v1
return result


def common_items_list(d1, d2, use_set_for_list_commons=True, use_set_for_dict_key_commons=True, append_empty=False):
if use_set_for_list_commons:
result_list= list(set(d2).intersection(d1)) # faster, order not preserved, support only simple data types in list values
return result_list


result = []
for v1 in d1:
for v2 in d2:
if isinstance(v1, dict) and isinstance(v2, dict):
result_dict=common_items_dict(v1, v2, use_set_for_list_commons, use_set_for_dict_key_commons, append_empty)
if len(result_dict)>0 or append_empty:
result.append(result_dict)
elif isinstance(v1, list) and isinstance(v2, list):
result_list=common_items_list(v1, v2, use_set_for_list_commons, use_set_for_dict_key_commons, append_empty)
if len(result_list)>0 or append_empty:
result.append(result_list)
elif v1 == v2:
result.append(v1)
return result




def deep_commons(v1,v2, use_set_for_list_commons=True, use_set_for_dict_key_commons=True, append_empty=False):
"""
deep_commons
returns intersection of items of dict and list combinations recursively


this function is a starter function,
i.e. if you know that the initial input is always dict then you can use common_items_dict directly
or if it is a list you can use common_items_list directly


v1 - dict/list/simple_value
v2 - dict/list/simple_value
use_set_for_dict_key_commons - bool - using set is faster, dict key order is not preserved
use_set_for_list_commons - bool - using set is faster, list values order not preserved, support only simple data types in list values
append_empty - bool - if there is a common key, but no common items in value of key , if True it keeps the key with an empty list of dict


"""


if isinstance(v1, dict) and isinstance(v2, dict):
return common_items_dict(v1, v2, use_set_for_list_commons, use_set_for_dict_key_commons, append_empty)
elif isinstance(v1, list) and isinstance(v2, list):
return common_items_list(v1, v2, use_set_for_list_commons, use_set_for_dict_key_commons, append_empty)
elif v1 == v2:
return v1
else:
return None




needed_services={'group1':['item1','item2'],'group3':['item1','item2']}
needed_services2={'group1':['item1','item2'],'group3':['item1','item2']}


result=deep_commons(needed_services,needed_services2)


print(result)

list1=[123,324523,5432,311,23]
list2=[2343254,34234,234,322123,123,234,23]
common=[]
def common_elements(list1,list2):
for x in range(0,len(list1)):
if list1[x] in list2:
common.append(list1[x])
            

common_elements(list1,list2)
print(common)