Wie kann ich zwei Listen in Python vergleichen und Übereinstimmungen zurückgeben?

Ich möchte zwei Listen nehmen und die Werte finden, die in beiden erscheinen.

a = [1, 2, 3, 4, 5]
b = [9, 8, 7, 6, 5]

returnMatches(a, b)

würde [5]zum Beispiel zurückkehren.

Nicht der effizienteste, aber bei weitem der naheliegendste Weg, dies zu tun, ist:

>>> a = [1, 2, 3, 4, 5]
>>> b = [9, 8, 7, 6, 5]
>>> set(a) & set(b)
{5}

Wenn die Reihenfolge von Bedeutung ist, können Sie dies mit Listenverständnis wie folgt tun:

>>> [i for i, j in zip(a, b) if i == j]
[5]

(funktioniert nur für gleich große Listen, was die Reihenfolge der Bedeutung impliziert).

Verwenden Sie set.intersection () , es ist schnell und lesbar.

>>> set(a).intersection(b)
set([5])

Ein schneller Leistungstest, der die Lösung von Lutz zeigt, ist das Beste:

import time

def speed_test(func):
    def wrapper(*args, **kwargs):
        t1 = time.time()
        for x in xrange(5000):
            results = func(*args, **kwargs)
        t2 = time.time()
        print '%s took %0.3f ms' % (func.func_name, (t2-t1)*1000.0)
        return results
    return wrapper

@speed_test
def compare_bitwise(x, y):
    set_x = frozenset(x)
    set_y = frozenset(y)
    return set_x & set_y

@speed_test
def compare_listcomp(x, y):
    return [i for i, j in zip(x, y) if i == j]

@speed_test
def compare_intersect(x, y):
    return frozenset(x).intersection(y)

# Comparing short lists
a = [1, 2, 3, 4, 5]
b = [9, 8, 7, 6, 5]
compare_bitwise(a, b)
compare_listcomp(a, b)
compare_intersect(a, b)

# Comparing longer lists
import random
a = random.sample(xrange(100000), 10000)
b = random.sample(xrange(100000), 10000)
compare_bitwise(a, b)
compare_listcomp(a, b)
compare_intersect(a, b)

Dies sind die Ergebnisse auf meinem Computer:

# Short list:
compare_bitwise took 10.145 ms
compare_listcomp took 11.157 ms
compare_intersect took 7.461 ms

# Long list:
compare_bitwise took 11203.709 ms
compare_listcomp took 17361.736 ms
compare_intersect took 6833.768 ms

Natürlich sollte jeder künstliche Leistungstest mit einem Körnchen Salz durchgeführt werden. Da die set().intersection()Antwort jedoch mindestens so schnell wie die anderen Lösungen und auch am besten lesbar ist, sollte sie die Standardlösung für dieses häufig auftretende Problem sein.

Ich bevorzuge die satzbasierten Antworten, aber hier ist eine, die trotzdem funktioniert

[x for x in a if x in b]

Der einfachste Weg, dies zu tun, ist die Verwendung von Sets :

>>> a = [1, 2, 3, 4, 5]
>>> b = [9, 8, 7, 6, 5]
>>> set(a) & set(b)
set([5])

Schneller Weg:

list(set(a).intersection(set(b)))

>>> s = ['a','b','c']   
>>> f = ['a','b','d','c']  
>>> ss= set(s)  
>>> fs =set(f)  
>>> print ss.intersection(fs)   
   **set(['a', 'c', 'b'])**  
>>> print ss.union(fs)        
   **set(['a', 'c', 'b', 'd'])**  
>>> print ss.union(fs)  - ss.intersection(fs)   
   **set(['d'])**

Sie können dies auch versuchen, indem Sie gemeinsame Elemente in einer neuen Liste behalten.

new_list = []
for element in a:
    if element in b:
        new_list.append(element)

Möchten Sie Duplikate? Wenn nicht, sollten Sie stattdessen Sets verwenden:

>>> set([1, 2, 3, 4, 5]).intersection(set([9, 8, 7, 6, 5]))
set([5])

Eine andere, etwas funktionalere Möglichkeit, die Listengleichheit für Liste 1 (lst1) und Liste 2 (lst2) zu überprüfen, wenn Objekte die Tiefe eins haben und die Reihenfolge beibehalten wird, ist:

all(i == j for i, j in zip(lst1, lst2))   

a = [1, 2, 3, 4, 5]
b = [9, 8, 7, 6, 5]

lista =set(a)
listb =set(b)   
print listb.intersection(lista)   
returnMatches = set(['5']) #output 

print " ".join(str(return) for return in returnMatches ) # remove the set()   

 5        #final output 

Kann auch itertools.product verwenden.

>>> common_elements=[]
>>> for i in list(itertools.product(a,b)):
...     if i[0] == i[1]:
...         common_elements.append(i[0])

Sie können verwenden

def returnMatches(a,b):
       return list(set(a) & set(b))

Sie können verwenden:

a = [1, 3, 4, 5, 9, 6, 7, 8]
b = [1, 7, 0, 9]
same_values = set(a) & set(b)
print same_values

Ausgabe:

set([1, 7, 9])

Wenn Sie einen booleschen Wert wünschen:

>>> a = [1, 2, 3, 4, 5]
>>> b = [9, 8, 7, 6, 5]
>>> set(b) == set(a)  & set(b) and set(a) == set(a) & set(b)
False
>>> a = [3,1,2]
>>> b = [1,2,3]
>>> set(b) == set(a)  & set(b) and set(a) == set(a) & set(b)
True

Die folgende Lösung funktioniert für jede Reihenfolge von Listenelementen und unterstützt auch, dass beide Listen unterschiedlich lang sind.

import numpy as np
def getMatches(a, b):
    matches = []
    unique_a = np.unique(a)
    unique_b = np.unique(b)
    for a in unique_a:
        for b in unique_b:
            if a == b:
                matches.append(a)
    return matches
print(getMatches([1, 2, 3, 4, 5], [9, 8, 7, 6, 5, 9])) # displays [5]
print(getMatches([1, 2, 3], [3, 4, 5, 1])) # displays [1, 3]

Die Verwendung der __and__Attributmethode funktioniert ebenfalls.

>>> a = [1, 2, 3, 4, 5]
>>> b = [9, 8, 7, 6, 5]
>>> set(a).__and__(set(b))
set([5])

oder einfach

>>> set([1, 2, 3, 4, 5]).__and__(set([9, 8, 7, 6, 5]))
set([5])
>>>    

you can | for set union and & for set intersection.
for example:

    set1={1,2,3}
    set2={3,4,5}
    print(set1&set2)
    output=3

    set1={1,2,3}
    set2={3,4,5}
    print(set1|set2)
    output=1,2,3,4,5

curly braces in the answer.

Ich habe gerade Folgendes verwendet und es hat bei mir funktioniert:

group1 = [1, 2, 3, 4, 5]
group2 = [9, 8, 7, 6, 5]

for k in group1:
    for v in group2:
        if k == v:
            print(k)

Dies würde dann 5 in Ihrem Fall drucken. Wahrscheinlich keine großartige Leistung.