una - recorrer dos listas a la vez python

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

Question

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.

Answer 1

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

Answer 2

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.

Answer 3

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

Answer 4

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]

Answer 5

Manera rápida:

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

Answer 6

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

Answer 7

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

[x for x in a if x in b]

Answer 8

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

Answer 9

Puedes usar

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

Answer 10

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

Answer 11

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

Answer 12

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 13

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.

Answer 14

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

Answer 15

Use set.intersection() , es rápido y legible.

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

Answer 16

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

Answer 17

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

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

Answer 19

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.