vez una restar recorrer otra listas lista iguales igualar entre con comparar comparacion compara como arreglos python list

una - recorrer dos listas a la vez python



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

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

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

Volvería [5] , por ejemplo.


¿Quieres duplicados? Si no, tal vez deberías usar conjuntos en su lugar:

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


Acabo de usar lo siguiente y funcionó para mí:

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)

Esto luego imprimiría 5 en su caso. Probablemente no sea un gran rendimiento, sin embargo.


La forma más fácil de hacerlo es usar sets :

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


La siguiente solución funciona para cualquier orden de elementos de lista y también admite que ambas listas tengan una longitud diferente.

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]


Manera rápida:

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


No es la 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 el orden es significativo, puede hacerlo con listas de comprensión como esta:

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

(Solo funciona para listas de igual tamaño, lo que implica la importancia del orden).


Prefiero las respuestas basadas en conjuntos, pero aquí hay una que funciona de todos modos

[x for x in a if x in b]


Puede usar itertools.product también.

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


Puedes usar

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


Puedes usar:

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


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


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)


Una prueba rápida de rendimiento que muestra la solución de Lutz es la 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 dado que la respuesta de set().intersection() es al menos tan rápida como las otras soluciones, y también la más legible, debe ser la solución estándar para esto problema comun.


Usar el método del atributo __and__ 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]) >>>



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

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


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


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


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.