Python：两个列表的交集，保留两个列表的重复项_Python_List_Duplicates_Intersection

Python：两个列表的交集，保留两个列表的重复项

python list

Python：两个列表的交集，保留两个列表的重复项,python,list,duplicates,intersection,Python,List,Duplicates,Intersection,我想有效地找到两个列表的交集，保持两个列表的重复，例如A=[1,1,2,3]，B=[1,1,2,4]应该返回[1,1,1,1,2] 我知道之前有人问过类似的问题（）但是，这对我没有帮助，因为只保留一个列表中的重复项以下作品 def intersect(A,B): C=[] for a in A: for b in B: if a==b: C.append(a) return C 然而，对于我正在

我想有效地找到两个列表的交集，保持两个列表的重复，例如A=[1,1,2,3]，B=[1,1,2,4]应该返回[1,1,1,1,2]

我知道之前有人问过类似的问题（）但是，这对我没有帮助，因为只保留一个列表中的重复项

以下作品

def intersect(A,B):
    C=[]
    for a in A:
        for b in B:
            if a==b:
                C.append(a)
    return C

然而，对于我正在做的事情来说，它的效率还不够！为了加快速度，我试着对列表进行排序

def intersect(A,B):
    A.sort()
    B.sort()
    C=[]
    i=0
    j=0
    while i<len(A) and j<len(B):
        if A[i]<=B[j]:
            if A[i]==B[j]: 
                C.append(A[i])
            i+=1
        else:
            j=j+1
    return C

def intersect（A，B）：
A.排序（）
B.排序（）
C=[]
i=0
j=0
而我这个怎么样：
a_set = set(A)
b_set = set(B)
intersect = [i for i in A if i in b_set] + [j for j in B if j in a_set]

两个列表理解连接在一起。创建A和B的集合需要一些额外的时间和内存，但是检查集合和列表中项目的成员资格的效率会抵消这些额外的时间和内存
你也可以把它修饰一下：
set_intersect = set(A) & set(B)
list_intersect = [ele for ele in A+B if ele in set_intersect]

将两个列表强制设置为集合，获取它们的交集，然后使用列表理解添加列表a和B中的所有元素（如果它们出现在集合交集中）。
如何：
a_set = set(A)
b_set = set(B)
intersect = [i for i in A if i in b_set] + [j for j in B if j in a_set]

两个列表理解连接在一起。创建A和B的集合需要一些额外的时间和内存，但是检查集合和列表中项目的成员资格的效率会抵消这些额外的时间和内存
你也可以把它修饰一下：
set_intersect = set(A) & set(B)
list_intersect = [ele for ele in A+B if ele in set_intersect]

将两个列表强制设置为集合，获取它们的交集，然后使用列表理解添加列表a和B中的所有元素（如果它们出现在集合交集中）。
以下是问题的答案：
import collections
for A,B,expected_output in (
    ([1,1,2,3], [1,1,2,4], [1,1,1,1,2]),
    ([1,1,2,3], [1,2,4], [1,1,2])):
    cntA = collections.Counter(A)
    cntB = collections.Counter(B)
    output = [
        x for x in sorted(set(A) & set(B)) for i in range(cntA[x]*cntB[x])]
    assert output == expected_output

以下是我和另外两个人最初解释的问题的答案：
import collections
A=[1,1,2,3]
B=[1,1,2,4]
expected_output = [1,1,1,1,2,2]
cntA = collections.Counter(A)
cntB = collections.Counter(B)
cnt_sum = collections.Counter(A) + collections.Counter(B)
output = [x for x in sorted(set(A) & set(B)) for i in range(cnt_sum[x])]
assert output == expected_output

您可以找到collections.Counter（）
文档collections
是一个很棒的模块，我强烈建议您阅读整个模块的文档
我意识到您实际上不需要找到集合的交集，因为根据文档，“缺少元素的计数为零”：
import collections
for A,B,expected_output in (
    ([1,1,2,3], [1,1,2,4], [1,1,1,1,2]),
    ([1,1,2,3], [1,2,4], [1,1,2])):
    cntA = collections.Counter(A)
    cntB = collections.Counter(B)
    output = [
        x for x in sorted(set(A)) for i in range(cntA[x]*cntB[x])]
    assert output == expected_output

以下是您所提问题的答案：
import collections
for A,B,expected_output in (
    ([1,1,2,3], [1,1,2,4], [1,1,1,1,2]),
    ([1,1,2,3], [1,2,4], [1,1,2])):
    cntA = collections.Counter(A)
    cntB = collections.Counter(B)
    output = [
        x for x in sorted(set(A) & set(B)) for i in range(cntA[x]*cntB[x])]
    assert output == expected_output

以下是我和另外两个人最初解释的问题的答案：
import collections
A=[1,1,2,3]
B=[1,1,2,4]
expected_output = [1,1,1,1,2,2]
cntA = collections.Counter(A)
cntB = collections.Counter(B)
cnt_sum = collections.Counter(A) + collections.Counter(B)
output = [x for x in sorted(set(A) & set(B)) for i in range(cnt_sum[x])]
assert output == expected_output

您可以找到collections.Counter（）
文档collections
是一个很棒的模块，我强烈建议您阅读整个模块的文档
我意识到您实际上不需要找到集合的交集，因为根据文档，“缺少元素的计数为零”：
import collections
for A,B,expected_output in (
    ([1,1,2,3], [1,1,2,4], [1,1,1,1,2]),
    ([1,1,2,3], [1,2,4], [1,1,2])):
    cntA = collections.Counter(A)
    cntB = collections.Counter(B)
    output = [
        x for x in sorted(set(A)) for i in range(cntA[x]*cntB[x])]
    assert output == expected_output

我很难加快你的代码，因为我不知道你在运行什么。无论在小列表还是大列表上运行它，以及有多少不同的元素，都会产生很大的差异。无论如何，这里有一些建议：
一,
二,
这将返回一个迭代器，您可以使用list（迭代器）
将其转换为列表
def intersect(a, b):
    count_a = Counter(a)
    count_b = Counter(b)
    count_mul = Counter()
    for i in count_a:
        count_mul[i] += count_a[i] * count_b[i]
    return count_mul.elements()

三,
与您的方式非常相似，但不改变列表的大小，这需要时间
def intersect(A, B):
    return [a for a in A for b in B if a == b]

我不确定这是否会对您原来的方式有任何改进，这确实取决于输入，但您的方式是O（n*m）
，而我的方式是O（n+m）

您可以使用模块timeit
检查它在您的输入上运行的速度：
from timeit import timeit
timeit('test.intersect(A, B)', 'import test; A = [1,1,2,3]; B = [1,1,2,4]')

我很难加快你的代码，因为我不知道你在运行什么。无论在小列表还是大列表上运行它，以及有多少不同的元素，都会产生很大的差异。无论如何，这里有一些建议：
一,
二,
这将返回一个迭代器，您可以使用list（迭代器）
将其转换为列表
def intersect(a, b):
    count_a = Counter(a)
    count_b = Counter(b)
    count_mul = Counter()
    for i in count_a:
        count_mul[i] += count_a[i] * count_b[i]
    return count_mul.elements()

三,
与您的方式非常相似，但不改变列表的大小，这需要时间
def intersect(A, B):
    return [a for a in A for b in B if a == b]

我不确定这是否会对您原来的方式有任何改进，这确实取决于输入，但您的方式是O（n*m）
，而我的方式是O（n+m）

您可以使用模块timeit
检查它在您的输入上运行的速度：
from timeit import timeit
timeit('test.intersect(A, B)', 'import test; A = [1,1,2,3]; B = [1,1,2,4]')

只是想澄清一下“列表的交叉点”，这里你的意思是“如果一个项目在列表A中出现N次，在列表B中出现M次，那么它在新列表中应该出现N+M次，但是如果它的N或M为零，那么它在新列表中应该出现零次”？（这是术语“交叉点”的不寻常用法。）结果中有4个1
，因为A
中有2个A
和B
中有2个，那么为什么结果中没有两个2
呢？基于您的数据，我意识到我上面的解释是不正确的。为什么在示例结果中只有一个2，但有四个1？之所以有四个1，是因为列表A中的每个1都与列表B中的1匹配，而列表A中的2与列表B中的2唯一匹配。另一个示例是A=[1,1,2,3]，B=[1,2,4]应该返回[1,1,2]您在处理大型列表吗，或者，您正在处理小列表，但有许多交叉点？列表中是否有许多重复的元素？请给出一些时间示例。为了澄清“列表交叉”的含义，您的意思是“如果一个项目在列表A中出现N次，在列表B中出现M次，那么它应该在新列表中出现N+M次，但是如果它的N或M为零，那么它应该在新列表中出现零次”？（这是术语“交叉点”的不寻常用法。）结果中有4个1
，因为A
中有2个A
和B
中有2个，那么为什么结果中没有两个2
呢？基于您的数据，我意识到我上面的解释是不正确的。为什么在示例结果中只有一个2，但有四个1？之所以有四个1，是因为列表A中的每个1都与列表B中的1匹配，而列表A中的2与列表B中的2唯一匹配。另一个示例是A=[1,1,2,3]，B=[1,2,4]应该返回[1,1,2]您在处理大型列表吗，或者，您正在处理小列表，但有许多交叉点？列表中是否有许多重复的元素？请给出一些示例。我希望代码与c的第一部分做相同的工作