Comparación de elementos comunes entre 2 listas

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) 

Lo tengo hasta ahora, ¡pero parece que no puede hacerlo funcionar!

¿Algunas ideas?

 >>> list1 = [1,2,3,4,5,6] >>> list2 = [3, 5, 7, 9] >>> list(set(list1).intersection(list2)) [3, 5] 

También puede usar conjuntos y obtener los puntos en común en una línea: reste el conjunto que contiene las diferencias de uno de los conjuntos.

 A = [1,2,3,4] B = [2,4,7,8] commonalities = set(A) - (set(A) - set(B)) 

Las soluciones sugeridas por S.Mark y SilentGhost generalmente le dicen cómo se debe hacer de una manera pythonica, pero pensé que también podría beneficiarse al saber por qué su solución no funciona. El problema es que tan pronto como encuentra el primer elemento común en las dos listas, devuelve solo ese elemento. Su solución podría solucionarse creando una lista de result y recostackndo los elementos comunes en esa lista:

 def common_elements(list1, list2): result = [] for element in list1: if element in list2: result.append(element) return result 

Una versión aún más corta utilizando listas de comprensión:

 def common_elements(list1, list2): return [element for element in list1 if element in list2] 

Sin embargo, como dije, esta es una forma muy ineficiente de hacer esto: los tipos de conjuntos incorporados de Python son mucho más eficientes a medida que se implementan en C internamente.

use set intersections, set (list1) y 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'] >>> >>> 

Tenga en cuenta que la lista de resultados puede ser diferente al orden con la lista original.

Las respuestas anteriores trabajan para encontrar los elementos comunes únicos, pero fallarán en explicar los elementos repetidos en las listas. Si desea que los elementos comunes aparezcan en el mismo número que se encuentran en común en las listas, puede usar la siguiente frase:

 l2, common = l2[:], [ e for e in l1 if e in l2 and (l2.pop(l2.index(e)) or True)] 

La parte or True solo es necesaria si espera que algún elemento se evalúe como False .

Puedes usar una lista de comprensión simple:

 x=[1,2,3,4] y=[3,4,5] common = [i for i in x if i in y] common: [3,4] 

1) Method1 guardando list1 es un diccionario y luego iterando cada elemento en 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) 

Encontrando elementos comunes y diferentes:

2) Método 2 utilizando set

 def findarrayset(a,b): common = set(a)&set(b) diff=set(a)^set(b) print list(common) print list(diff) 

Set es otra forma en que podemos resolver esto.

 a = [3,2,4] b = [2,3,5] set(a)&set(b) {2, 3} 

esta es mi propuesta, creo que es más fácil con conjuntos que con un bucle for

 def unique_common_items(list1, list2): # Produce the set of *unique* common items in two lists. return list(set(list1) & set(list2)) 

Hola, esta es mi propuesta (muy 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 

Aquí hay un método de fuerza bruta que se me ocurrió. Ciertamente no es el más eficiente pero es algo.

El problema que encontré con algunas de las soluciones aquí es que, o bien no da elementos repetidos o no proporciona el número correcto de elementos cuando el orden de entrada es importante.

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

Su problema es que está regresando desde dentro del bucle for, por lo que solo obtendrá la primera coincidencia. La solución es mover su retorno fuera del bucle.

 def elementosEnComunEntre(lista1,lista2): elementosEnComun = set() for e1 in lista1: if(e1 in lista2): elementosEnComun.add(e1) return list(elementosEnComun) 

Utilice un generador:

 common = (x for x in list1 if x in list2) 

La ventaja aquí es que esto regresará en un tiempo constante (casi instantáneo) incluso cuando se usan listas enormes u otros iterables grandes.

Por ejemplo,

 list1 = list(range(0,10000000)) list2=list(range(1000,20000000)) common = (x for x in list1 if x in list2) 

Todas las demás respuestas tomarán mucho tiempo con estos valores para list1 y list2.