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.
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.
Respuestas:
No es la más eficiente, pero 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).
&
) o set(a).intersection(b)
será tan rápida o más rápida que la comprensión de la lista.
set(a) & set(b)
?
Use set.intersection () , es rápido y legible.
>>> set(a).intersection(b)
set([5])
bool(set(a).intersection(b))
para True
oFalse
difference
o union
.
.intersection()
vs &
?
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 set().intersection()
respuesta es al menos tan rápida como las otras soluciones, y también la más legible, debería ser la solución estándar para este problema común.
set
partir de uno existente list
no eliminará nada del original list
. Si desea una lógica especial para manejar duplicados dentro de una lista, creo que tendrá que hacer una nueva pregunta porque la respuesta deberá ser específica de cómo desea que se manejen los duplicados.
Prefiero las respuestas basadas en el conjunto, pero aquí hay una que funciona de todos modos
[x for x in a if x in b]
La forma más fácil de hacerlo es usar conjuntos :
>>> a = [1, 2, 3, 4, 5]
>>> b = [9, 8, 7, 6, 5]
>>> set(a) & set(b)
set([5])
Manera rápida:
list(set(a).intersection(set(b)))
>>> 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'])**
¿Quieres duplicados? Si no, tal vez debería usar conjuntos en su lugar:
>>> set([1, 2, 3, 4, 5]).intersection(set([9, 8, 7, 6, 5]))
set([5])
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
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 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
La siguiente solución funciona para cualquier orden de elementos de la 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]
np.intersect1d(list1, list2)
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.
&
operador en el set ya fue respondido por SilentGhost en la respuesta aceptada