Come posso confrontare due liste in python e restituire corrispondenze

Question

Voglio prendere due liste e trovare i valori che appaiono in entrambi.

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

returnMatches(a, b) 

restituirebbe [5], ad esempio.

Answer 1

Non

la più efficiente, ma di gran lunga il modo più ovvio per farlo è:

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

se l'ordine è significativo lo si può fare con la list comprehension come questo:

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

(Funziona solo con elenchi di dimensioni uguali, il che implica il significato degli ordini).

Answer 2

Il modo più semplice per farlo è quello di utilizzare sets:

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

Answer 3

Usa set.intersection(), è veloce e leggibile.

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

Answer 4

modo rapido:

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

Answer 5

Vuoi duplicati? Se non forse si dovrebbe utilizzare i set, invece:

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

Answer 6

È possibile utilizzare

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

Answer 7

>>> 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'])** 

Answer 8

preferisco il set base di risposte, ma ecco quello che funziona in ogni caso

[x for x in a if x in b] 

Answer 9

anche puoi provare questo, mantenendo gli elementi comuni in una nuova lista.

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

Answer 10

Un test di prestazione rapida che mostra la soluzione di Lutz è il migliore:

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) 

Questi sono i risultati sulla mia macchina:

# 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 

Ovviamente, qualsiasi test delle prestazioni artificiale deve essere preso con un grano di sale, ma dal momento che la risposta set().intersection() è almeno altrettanto veloce come le altre soluzioni, e anche il più readab le, dovrebbe essere la soluzione standard per questo problema comune.

Answer 11

È possibile utilizzare:

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

uscita:

set([1, 7, 9]) 

Answer 12

un altro modo un po 'più funzionale per verificare l'uguaglianza lista per lista 1 (LST1) e la lista 2 (LST2), dove gli oggetti hanno la profondità uno e che mantiene l'ordine è:

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

Answer 13

Può utilizzare anche itertools.product.

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

Answer 14

Se si desidera un valore booleano:

>>> 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 

Answer 15

Utilizzando __and__ metodo attributo funziona anche.

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

o semplicemente

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

Answer 16

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