Comparaison des éléments communs entre 2 listes
def common_elements(list1, list2):
"""
Return a list containing the elements which are in both list1 and list2
>>> common_elements([1,2,3,4,5,6], [3,5,7,9])
[3, 5]
>>> common_elements(['this','this','n','that'],['this','not','that','that'])
['this', 'that']
"""
for element in list1:
if element in list2:
return list(element)
Vous avez compris, mais n'arrivez pas à le faire fonctionner!
Des idées?
>>> list1 = [1,2,3,4,5,6]
>>> list2 = [3, 5, 7, 9]
>>> list(set(list1).intersection(list2))
[3, 5]
Vous pouvez également utiliser des ensembles et obtenir les points communs sur une seule ligne: soustrayez l’ensemble contenant les différences de l’un des ensembles.
A = [1,2,3,4]
B = [2,4,7,8]
commonalities = set(A) - (set(A) - set(B))
Les solutions suggérées par S.Mark et SilentGhost vous indiquent généralement comment procéder de manière pythonique, mais j’ai pensé que vous auriez également intérêt à savoir pourquoi votre solution ne fonctionne pas. Le problème est que dès que vous trouvez le premier élément commun dans les deux listes, vous ne renvoyez que cet élément unique. Votre solution pourrait être corrigée en créant une liste result et en collectant les éléments communs de cette liste:
def common_elements(list1, list2):
result = []
for element in list1:
if element in list2:
result.append(element)
return result
Une version encore plus courte utilisant la compréhension de liste:
def common_elements(list1, list2):
return [element for element in list1 if element in list2]
Cependant, comme je l’ai dit plus tôt, c’est une façon très inefficace de procéder: les types de jeux intégrés de Python sont bien plus efficaces car ils sont implémentés en C en interne.
utiliser set intersections, set (list1) & set (list2)
>>> def common_elements(list1, list2):
... return list(set(list1) & set(list2))
...
>>>
>>> common_elements([1,2,3,4,5,6], [3,5,7,9])
[3, 5]
>>>
>>> common_elements(['this','this','n','that'],['this','not','that','that'])
['this', 'that']
>>>
>>>
Notez que la liste de résultats peut être un ordre différent de la liste d'origine.
Les réponses précédentes permettent toutes de trouver les éléments communs uniques, mais ne parviendront pas à prendre en compte les éléments répétés dans les listes. Si vous souhaitez que les éléments communs apparaissent sous le même numéro que ceux trouvés en commun sur les listes, vous pouvez utiliser la ligne suivante:
l2, common = l2[:], [ e for e in l1 if e in l2 and (l2.pop(l2.index(e)) or True)]
La partie or True n'est nécessaire que si vous prévoyez que des éléments soient évalués à False.
vous pouvez utiliser une compréhension de liste simple:
x=[1,2,3,4]
y=[3,4,5]
common = [i for i in x if i in y]
common: [3,4]
1) Méthode1 Save list1 est un dictionnaire puis itère chaque élément de list2
def findarrayhash(a,b):
h1={k:1 for k in a}
for val in b:
if val in h1:
print("common found",val)
del h1[val]
else:
print("different found",val)
for key in h1.iterkeys():
print ("different found",key)
Trouver des éléments communs et différents:
2) Method2 Using set
def findarrayset(a,b):
common = set(a)&set(b)
diff=set(a)^set(b)
print list(common)
print list(diff)
voici ma proposition Je pense que c'est plus facile avec des ensembles qu'avec une boucle for
def unique_common_items(list1, list2):
# Produce the set of *unique* common items in two lists.
return list(set(list1) & set(list2))
Set est un autre moyen de résoudre ce problème
a = [3,2,4]
b = [2,3,5]
set(a)&set(b)
{2, 3}
Bonjour, voici mon propos (très simple)
import random
i = [1,4,10,22,44,6,12] #first random list, could be change in the future
j = [1,4,10,8,15,14] #second random list, could be change in the future
for x in i:
if x in j: #for any item 'x' from collection 'i', find the same item in collection of 'j'
print(x) # print out the results
Utilisez un générateur:
common = (x for x in list1 if x in list2)
L'avantage ici est que cela reviendra à temps constant (presque instantané) même en utilisant des listes énormes ou d'autres énormes énormes.
Par exemple,
list1 = list(range(0,10000000))
list2=list(range(1000,20000000))
common = (x for x in list1 if x in list2)
Toutes les autres réponses ici prendront très longtemps avec ces valeurs pour list1 et list2.
a_list = range(1,10)
b_list = range(5, 25)
both = []
for i in b_list:
for j in a_list:
if i == j:
both.append(i)
f_list=[1,2,3,4,5] # First list
s_list=[3,4,5,6,7,8] # Second list
# An empty list stores the common elements present in both the list
common_elements=[]
for i in f_list:
# checking if each element of first list exists in second list
if i in s_list:
#if so add it in common elements list
common_elements.append(i)
print(common_elements)
def common_member(a, b):
a_set = set(a)
b_set = set(b)
if (a_set & b_set):
print(a_set & b_set)
else:
print("No common elements")
list_1=range(0,100)
list_2=range(0,100,5)
final_list=[]
for i in list_1:
for j in list_2:
if i==j:
final_list.append(i)
print(set(final_list))
Votre problème est que vous revenez de l'intérieur de la boucle for, vous n'aurez donc que le premier match. La solution consiste à déplacer votre retour en dehors de la boucle.
def elementosEnComunEntre(lista1,lista2):
elementosEnComun = set()
for e1 in lista1:
if(e1 in lista2):
elementosEnComun.add(e1)
return list(elementosEnComun)
def list_common_elements(l_1,l_2,_unique=1,diff=0):
if not diff:
if _unique:
return list(set(l_1)&set(l_2))
if not _unique:
return list((i for i in l_1 if i in l_2))
if diff:
if _unique:
return list(set(l_1)^set(l_2))
if not _unique:
return list((i for i in l_1 if i not in l_2))
"""
Example:
l_1= [0, 1, 2, 3, 3, 4, 5]
l_2= [6, 7, 8, 8, 9, 5, 4, 3, 2]
look for diff
l_2,l_1,diff=1,_unique=1: [0, 1, 6, 7, 8, 9] sorted(unique(L_2 not in L_1) + unique(L_1 not in L_2))
l_2,l_1,diff=1,_unique=0: [6, 7, 8, 8, 9] L_2 not in L_1
l_1,l_2,diff=1,_unique=1: [0, 1, 6, 7, 8, 9] sorted(unique(L_1 not in L_2) + unique(L_2 not in L_1))
l_1,l_2,diff=1,_unique=0: [0, 1] L_1 not in L_2
look for same
l_2,l_1,diff=0,_unique=1: [2, 3, 4, 5] unique(L2 in L1)
l_2,l_1,diff=0,_unique=0: [5, 4, 3, 2] L2 in L1
l_1,l_2,diff=0,_unique=1: [2, 3, 4, 5] unique(L1 in L2)
l_1,l_2,diff=0,_unique=0: [2, 3, 3, 4, 5] L1 in L2
"""
Cette fonction permet de comparer deux listes (L_1 vs. L_2). Le paramètre DIFF définit la comparaison pour rechercher des éléments communs (DIFF == True) ou différents éléments (DIFF == False) entre les deux listes. Au niveau suivant, le comportement de la méthode est défini par le paramètre _UNIQUE. _UNIQUE == True utilisera Python sets - dans ce cas, la méthode retourne une liste triée d'éléments uniques satisfaisant DIFF. Lorsque _UNIQUE == False - la liste renvoyée est plus explicite, c’est-à-dire qu’elle contiendra d’abord tous les éléments de L_1, suivis de tous les éléments de L_2 satisfaisant le code DIFF. Etant donné que la sortie contiendra des occurrences répétitives d'éléments dans L_1 et L_2 satisfaisant le format DIFF, l'utilisateur peut post-compter le nombre de fois qu'un élément diffère ou est commun aux listes. Comme cette proposition est simplement une compilation du code proposé par “cowlinator” et J.S Method2, veuillez consulter ces publications des auteurs pour discussion sur la vitesse et la performance du calcul. Crédits cowlinator et J.S. Méthode2
Voici une méthode de force brute que je suis venu avec. Ce n'est certainement pas le plus efficace, mais c'est quelque chose.
Le problème que j'ai trouvé avec certaines des solutions ici est que cela ne donne pas d'éléments répétés ou ne donne pas le nombre correct d'éléments lorsque l'ordre de saisie est important.
#finds common elements
def common(list1, list2):
result = []
intersect = list(set(list1).intersection(list2))
#using the intersection, find the min
count1 = 0
count2 = 0
for i in intersect:
for j in list1:
if i == j:
count1 += 1
for k in list2:
if i == k:
count2 += 1
minCount = min(count2,count1)
count1 = 0
count2 = 0
#append common factor that many times
for j in range(minCount):
result.append(i)
return result