¿Cómo puedo comparar dos listas en python y devolver coincidencias?

Question

Quiero tomar dos listas y encontrar los valores que aparecen en ambos.

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

returnMatches(a, b) 

volvería [5], por ejemplo.

Answer 1

No

el más eficiente, pero con mucho, la forma más obvia de hacerlo es:

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

si la orden es importante que se puede hacer con las listas por comprensión como este:

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

(solo funciona para listas de igual tamaño, lo que implica significado de orden).

Answer 2

La forma más sencilla de hacerlo es utilizar sets:

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

Answer 3

Uso set.intersection(), es rápido y fácil de leer.

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

Answer 4

manera rápida:

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

Answer 5

¿Quieres duplicados? Si no es así tal vez debería utilizar conjuntos de lugar:

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

Answer 6

Usted puede utilizar

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

prefiero las respuestas basadas en conjunto, pero aquí es uno que funciona de todos modos

[x for x in a if x in b] 

Answer 9

también Puedes probar esto, manteniendo los elementos comunes en una nueva lista.

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

Answer 10

Una prueba de rendimiento rápida mostrando solución de Lutz es el mejor:

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) 

Estos son los resultados en mi máquina:

# 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 

Obviamente, cualquier prueba de rendimiento artificial debe tomarse con un grano de sal, pero desde la respuesta set().intersection() es al menos tan rápido como las otras soluciones, y también la más readab le, debería ser la solución estándar para este problema común.

Answer 11

Se puede utilizar:

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

Salida:

set([1, 7, 9]) 

Answer 12

otra manera un poco más funcional para comprobar la igualdad de la lista de la lista 1 (lst1) y la lista 2 (LST2) donde los objetos tienen la profundidad uno y que mantiene la orden es:

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

Answer 13

Puede utilizar itertools.product también.

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

Answer 14

Si desea un valor 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

Usando __and__ método atributo también funciona.

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

o simplemente

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