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])
>>>
Use set.intersection() , es rápido y legible.
>>> set(a).intersection(b)
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.