blocks|key|931371|text|如果顺序并不重要，并且您不需要担心重复，那么您可以使用set+intersection：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|931372|>>>+a+=+[1,2,3,4,5]
>>>+b+=+[1,3,5,6]
>>>+list(set(a)+&+set(b))
[1,+3,+5]|code-block|syntax|javascript|931373|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

If order is not important and you don't need to worry about duplicates then you can use set intersection:

<pre><code>&gt;&gt;&gt; a = [1,2,3,4,5]
&gt;&gt;&gt; b = [1,3,5,6]
&gt;&gt;&gt; list(set(a) &amp; set(b))
[1, 3, 5]
</code></pre>

blocks|key|931418|text|如果布尔和指的是出现在两个列表中的项，例如交集，那么你应该看看Python的set和frozenset类型。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|931419|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.python.org/library/stdtypes.html#set-types-set-frozenset|1^0|12|3|16|9|12|3|0|16|9|1|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@$9|T|A|U|1|V]|$9|W|A|X|1|Y]]|E|$]]|$1|F|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]|N|$5|I|J|K|E|$L|M]]]]

If, by Boolean AND, you mean items that appear in both lists, e.g. intersection, then you should look at Python's <a href="http://docs.python.org/library/stdtypes.html#set-types-set-frozenset" rel="nofollow noreferrer"><code>set</code></a> and <a href="http://docs.python.org/library/stdtypes.html#set-types-set-frozenset" rel="nofollow noreferrer"><code>frozenset</code></a> types.

blocks|key|1145955|text|如果您将两个列表中较大的一个转换为一个集合，则可以使用intersection()获得该集合与任何可迭代对象的交集|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1145956|a+=+[1,2,3,4,5]
b+=+[1,3,5,6]
set(a).intersection(b)|code-block|syntax|javascript|1145957|entityMap^0|R|E|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

If you convert the larger of the two lists into a set, you can get the intersection of that set with any iterable using <code>intersection()</code>:

<pre><code>a = [1,2,3,4,5]
b = [1,3,5,6]
set(a).intersection(b)
</code></pre>

blocks|key|931505|text|a+=+[1,2,3,4,5]
b+=+[1,3,5,6]
c+=+list(set(a).intersection(set(b)))|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|931506|应该像做梦一样工作。而且，如果可以的话，使用集合而不是列表来避免所有这些类型的改变！|unstyled|931507|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>a = [1,2,3,4,5]
b = [1,3,5,6]
c = list(set(a).intersection(set(b)))
</code></pre>

Should work like a dream. And, if you can, use sets instead of lists to avoid all this type changing!

blocks|key|931593|text|对我来说，使用列表理解是非常明显的。不确定性能，但至少事情会留在列表中。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|931594|[x+for+x+in+a+if+x+in+b]|offset|length|style|CODE|931595|或者“所有在A中的x值，如果X值在B中”。|931596|entityMap^0|0|0|O|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@$D|N|E|O|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|P|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|K|$]]

Using list comprehensions is a pretty obvious one for me. Not sure about performance, but at least things stay lists.

<code>[x for x in a if x in b]</code>

Or "all the x values that are in A, if the X value is in B".

blocks|key|931620|text|使用filter和lambda算子可以实现一种函数式的方法。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|931621|list1+=+[1,2,3,4,5,6]

list2+=+[2,4,6,9,10]

>>>+list(filter(lambda+x:x+in+list1,+list2))

[2,+4,+6]|code-block|syntax|javascript|931622|编辑:过滤掉同时存在于list1和list中的x，设置差异也可以使用：|931623|>>>+list(filter(lambda+x:x+not+in+list1,+list2))
[9,10]|931624|Edit2:+python3+filter返回一个filter对象，用list封装它会返回输出列表。|931625|entityMap^0|2|6|9|6|0|0|0|0|F|6|Z|4|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|Y|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|10|8|@$9|11|A|12|B|C]|$9|13|A|14|B|C]]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|15|8|@]|D|@]|E|$]]]|R|$]]

A functional way can be achieved using <code>filter</code> and <code>lambda</code> operator.

<pre><code>list1 = [1,2,3,4,5,6]

list2 = [2,4,6,9,10]

&gt;&gt;&gt; list(filter(lambda x:x in list1, list2))

[2, 4, 6]
</code></pre>

Edit: It filters out x that exists in both list1 and list, set difference can also be achieved using:

<pre><code>&gt;&gt;&gt; list(filter(lambda x:x not in list1, list2))
[9,10]
</code></pre>

Edit2: python3 <code>filter</code> returns a filter object, encapsulating it with <code>list</code> returns the output list.

blocks|key|931696|text|这是一个示例，当您需要结果中的每个元素出现的次数与它在两个数组中显示的次数一样多时。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|931697|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+%2B=+1


++++return+store|code-block|syntax|javascript|931698|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This is an example when you need Each element in the result should appear as many times as it shows in both arrays.

<pre><code>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) &gt;= len(nums1) else [nums2, nums1] #iterate will look into target

 if len(target) == 0:
 return []

 i = 0
 store = []
 while i &lt; len(iterate):

 element = iterate[i]

 if element in target:
 store.append(element)
 target.remove(element)

 i += 1


 return store
</code></pre>

blocks|key|931783|text|这可能会很晚，但我只是想我应该分享的情况下，你需要手动完成(显示工作-哈哈)，当你需要所有的元素出现尽可能多的次数，或者当你也需要它是唯一的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|931784|请注意，测试也是为它编写的。|931785|++++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)|code-block|syntax|javascript|931786|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

It might be late but I just thought I should share for the case where you are required to do it manually (show working - haha) OR when you need all elements to appear as many times as possible or when you also need it to be unique.

Kindly note that tests have also been written for it.

<pre><code>

 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)

</code></pre>

blocks|key|1146265|text|你也可以使用计数器！它不会保留顺序，但会考虑重复项：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1146266|>>>+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]|code-block|syntax|javascript|1146267|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You can also use a counter! It doesn't preserve the order, but it'll consider the duplicates:

<pre><code>&gt;&gt;&gt; from collections import Counter
&gt;&gt;&gt; a = [1,2,3,4,5]
&gt;&gt;&gt; b = [1,3,5,6]
&gt;&gt;&gt; d1, d2 = Counter(a), Counter(b)
&gt;&gt;&gt; c = [n for n in d1.keys() &amp; d2.keys() for _ in range(min(d1[n], d2[n]))]
&gt;&gt;&gt; print(c)
[1,3,5]
</code></pre>

blocks|key|1146291|text|这样你就得到了两个列表的交集，同时也得到了常见的副本。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1146292|>>>+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]|code-block|syntax|javascript|1146293|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This way you get the intersection of two lists and also get the common duplicates.
<pre><code>&gt;&gt;&gt; from collections import Counter
&gt;&gt;&gt; a = Counter([1,2,3,4,5])
&gt;&gt;&gt; b = Counter([1,3,5,6])
&gt;&gt;&gt; a &amp;= b
&gt;&gt;&gt; list(a.elements())
[1, 3, 5]
</code></pre>

blocks|key|931877|text|这里的大多数解决方案没有考虑列表中元素的顺序，而是将列表视为集合。另一方面，如果您想要查找两个列表中包含的最长的子序列之一，您可以尝试以下代码。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|931878|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]]+%2B+intersect(a[1:],+b[idx%2B1:])++++++++
++++++++if+len(inter_1)+<=+len(inter_2):
++++++++++++return+inter_2
++++return+inter_1|code-block|syntax|javascript|931879|对于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]的解决方案。|offset|length|style|CODE|931880|entityMap^0|0|0|2|9|C|B|S|5|10|7|1Q|3|1U|3|1Y|3|23|9|2D|9|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]|$I|T|J|U|K|L]|$I|V|J|W|K|L]|$I|X|J|Y|K|L]|$I|Z|J|10|K|L]|$I|11|J|12|K|L]|$I|13|J|14|K|L]|$I|15|J|16|K|L]|$I|17|J|18|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|19|8|@]|9|@]|A|$]]]|N|$]]

Most of the solutions here don't take the order of elements in the list into account and treat lists like sets. If on the other hand you want to find one of the longest subsequences contained in both lists, you can try the following code.
<pre><code>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) &lt;= len(inter_2):
 return inter_2
 return inter_1
</code></pre>
For <code>a=[1,2,3]</code> and <code>b=[3,1,4,2]</code> this returns <code>[1,2]</code> rather than <code>[1,2,3]</code>. Note that such a subsequence is not unique as <code>[1]</code>, <code>[2]</code>, <code>[3]</code> are all solutions for <code>a=[1,2,3]</code> and <code>b=[3,2,1]</code>.

blocks|key|1146367|text|您也可以使用numpy.intersect1d(ar1,+ar2)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1146368|它返回两个数组中的唯一值和排序值。|1146369|entityMap^0|6|R|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|M|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|N|8|@]|D|@]|E|$]]]|I|$]]

You can also use <code>numpy.intersect1d(ar1, ar2)</code>. 
It return the unique and sorted values that are in both of two arrays.

blocks|key|931936|text|在这种情况下，您有一个列表列表，map会派上用场：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|931937|>>>+lists+=+[[1,+2,+3],+[2,+3,+4],+[2,+3,+5]]
>>>+set(lists.pop()).intersection(*map(set,+lists))
{2,+3}|code-block|syntax|javascript|931938|将适用于类似的迭代器：|931939|>>>+lists+=+['ash',+'nazg']
>>>+set(lists.pop()).intersection(*map(set,+lists))
{'a'}|931940|如果列表为空，则pop将被清空，因此您可能想要包装在一个函数中：|931941|def+intersect_lists(lists):
++++try:
++++++++return+set(lists.pop()).intersection(*map(set,+lists))
++++except+IndexError:+#+pop+from+empty+list
++++++++return+set()|931942|entityMap^0|G|3|0|0|0|0|8|3|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|Y|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|10|8|@$9|11|A|12|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|H|7|13|8|@]|D|@]|E|$I|J]]|$1|S|3|-4|5|6|7|14|8|@]|D|@]|E|$]]]|T|$]]

In the case you have a list of lists <code>map</code> comes handy:
<pre><code>&gt;&gt;&gt; lists = [[1, 2, 3], [2, 3, 4], [2, 3, 5]]
&gt;&gt;&gt; set(lists.pop()).intersection(*map(set, lists))
{2, 3}
</code></pre>
would work for similar iterables:
<pre><code>&gt;&gt;&gt; lists = ['ash', 'nazg']
&gt;&gt;&gt; set(lists.pop()).intersection(*map(set, lists))
{'a'}
</code></pre>
<code>pop</code> will blow if the list is empty so you may want to wrap in a function:
<pre><code>def intersect_lists(lists):
 try:
 return set(lists.pop()).intersection(*map(set, lists))
 except IndexError: # pop from empty list
 return set()
</code></pre>

blocks|key|931987|text|当我们使用元组并且我们想要交集时|type|unstyled|depth|inlineStyleRanges|entityRanges|data|931988|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}|code-block|syntax|javascript|931989|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

when we used tuple and we want to intersection
<pre><code>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}
</code></pre>

<pre><code>a = [1,2,3,4,5]
b = [1,3,5,6]
c = a and b
print c
</code></pre>

actual output: <code>[1,3,5,6]</code>
expected output: <code>[1,3,5]</code>

How can we achieve a boolean AND operation (list intersection) on two lists?

How to find list intersection?

a = [1,2,3,4,5]b = [1,3,5,6]c = a and bprint c实际输出：[1,3,5,6]预期输出：[1,3,5]我们如何在两个列表上实现一个布尔AND操作(列表交集)？

问如何查找列表交集？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何查找列表交集？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何查找列表交集？
EN