Comment puis-je comparer deux listes en python et retourner des correspondances

Question

Je veux prendre deux listes et trouver les valeurs qui apparaissent dans les deux.

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

returnMatches(a, b) 

renverrait [5], par exemple.

Answer 1

Pas le plus efficace, mais de loin le moyen le plus évident de le faire est la suivante:

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

si la commande est importante, vous pouvez le faire avec la liste compréhensions comme ceci:

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

(ne fonctionne que pour des listes de taille égale, ce qui implique l'importance de l'ordre).

Answer 2

La meilleure façon de le faire est d'utiliser sets:

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

Answer 3

Utilisez set.intersection(), il est rapide et facile à lire.

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

Answer 4

façon rapide:

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

Answer 5

Voulez-vous que les doublons? Sinon, vous devriez peut-être utiliser des ensembles à la place:

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

Answer 6

Vous pouvez utiliser

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

Je préfère les Définie en fonction des réponses, mais voici ce qui fonctionne de toute façon

[x for x in a if x in b] 

Answer 9

également vous pouvez essayer ceci, en gardant les éléments communs dans une nouvelle liste.

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

Answer 10

Un test de performance rapide montrant la solution de Lutz est le meilleur:

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) 

Ce sont les résultats sur ma machine:

# 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 

De toute évidence, tout test de performance artificielle doit être prise avec un grain de sel, mais depuis la réponse set().intersection() est au moins aussi vite que les autres solutions, et aussi le plus readab le, il devrait être la solution standard pour ce problème commun.

Answer 11

Vous pouvez utiliser:

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

Sortie:

set([1, 7, 9]) 

Answer 12

une autre un peu plus de manière fonctionnelle pour vérifier la liste d'égalité pour la liste 1 (lst1) et la liste 2 (LST2) où les objets ont une profondeur un et qui conserve la commande est:

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

Answer 13

Peut aussi utiliser itertools.product.

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

Answer 14

Si vous voulez une valeur booléenne:

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

utilisant __and__ méthode d'attribut fonctionne également.

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

ou simplement

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