wake-up-neo.net

Vergleich der gemeinsamen Elemente zwischen zwei Listen

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)

Habe das soweit, aber es scheint nicht zu funktionieren! 

Irgendwelche Ideen?

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

Sie können auch Sets verwenden und die Gemeinsamkeiten in einer Zeile abrufen: Ziehen Sie das Set, das die Unterschiede enthält, von einem der Sets ab.

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

Die von S.Mark und SilentGhost vorgeschlagenen Lösungen sagen im Allgemeinen aus, wie dies auf pythonische Weise geschehen sollte, aber ich dachte, Sie könnten auch wissen, warum Ihre Lösung nicht funktioniert. Das Problem ist, dass, sobald Sie das erste gemeinsame Element in den beiden Listen finden, Sie nur dieses eine Element zurückgeben. Ihre Lösung könnte behoben werden, indem Sie eine result-Liste erstellen und die allgemeinen Elemente in dieser Liste sammeln:

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

Eine noch kürzere Version mit List Comprehensions:

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

Dies ist jedoch, wie gesagt, ein sehr ineffizienter Weg - Pythons integrierte Settypen sind viel effizienter, da sie intern in C implementiert werden.

30
Tamás

set intersections verwenden, 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']
>>>
>>>

Beachten Sie, dass die Ergebnisliste von der ursprünglichen Liste abweichen kann.

24
YOU

In den vorherigen Antworten werden alle eindeutigen gemeinsamen Elemente gesucht, aber wiederholte Elemente in den Listen werden nicht berücksichtigt. Wenn Sie möchten, dass die gemeinsamen Elemente in der gleichen Anzahl erscheinen, wie sie in den Listen gemeinsam vorkommen, können Sie den folgenden Einzeiler verwenden:

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

Der or True-Teil ist nur erforderlich, wenn Sie erwarten, dass Elemente als False ausgewertet werden.

10
Dologan

sie können ein einfaches Listenverständnis verwenden: 

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

1) Method1 Save list1 ist Wörterbuch und iteriert dann jedes Element in 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)

Gemeinsame und unterschiedliche Elemente finden:

2) Methode2 Mit set

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

das ist mein Vorschlag Ich denke es ist einfacher mit Sets als mit einer for-Schleife

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

Set ist eine andere Möglichkeit, dies zu lösen

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

Hallo, das ist mein Vorschlag (sehr einfach)

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
1
Artur Ludwik

Verwenden Sie einen Generator:

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

Der Vorteil hierbei ist, dass dies in konstanter Zeit (fast augenblicklich) zurückkehrt, selbst wenn große Listen oder andere große Iterables verwendet werden.

Zum Beispiel,

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

Alle anderen Antworten hier werden mit diesen Werten für Liste1 und Liste2 sehr lange dauern.

1
cowlinator
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)
0
kamran kausar
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)
0
Siva Kumar
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") 
0
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))
0

Ihr Problem ist, dass Sie aus der for-Schleife zurückkehren, sodass Sie nur den ersten Treffer erhalten. Die Lösung besteht darin, Ihre Rückkehr außerhalb der Schleife zu verschieben.

def elementosEnComunEntre(lista1,lista2):

    elementosEnComun = set()

    for e1 in lista1:
         if(e1 in lista2):
             elementosEnComun.add(e1)

    return list(elementosEnComun)
0
Ignacio Alvarez
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
"""

Diese Funktion bietet die Möglichkeit, zwei Listen zu vergleichen (L_1 vs. L_2). Der Parameter DIFF legt den Vergleich fest, um zwischen beiden Listen nach gemeinsamen Elementen (DIFF == True) oder verschiedenen Elementen (DIFF == False) zu suchen. Auf der nächsten Ebene wird das Verhalten der Methode durch den Parameter _UNIQUE festgelegt. _UNIQUE == True verwendet Python Mengen - in diesem Fall gibt die Methode eine sortierte Liste eindeutiger Elemente zurück, die DIFF erfüllen. Wenn _UNIQUE == False - die zurückgegebene Liste ist expliziter, d. H. Sie enthält zuerst alle Elemente von L_1, gefolgt von allen Elementen von L_2, die den DIFF erfüllen. Da die Ausgabe wiederkehrende Vorkommen von Elementen in L_1 und L_2 enthält, die DIFF erfüllen, kann der Benutzer die Häufigkeit nachzählen, mit der sich ein Element in den Listen unterscheidet oder gemeinsam ist. Da es sich bei diesem Vorschlag lediglich um eine Zusammenstellung von Code handelt, der von "cowlinator" und J.S. Method2 vorgeschlagen wurde, möchten wir Sie bitten, die Beiträge dieser Autoren zur Erörterung der Geschwindigkeit und Leistung der Berechnung zu lesen. Credits cowlinator und J.S. Methode2

0
zlATOM

Hier ist eine ziemlich brutale Methode, die ich mir ausgedacht habe. Es ist sicherlich nicht das effizienteste, aber es ist etwas. 

Das Problem, das ich bei einigen Lösungen gefunden habe, ist, dass entweder keine wiederholten Elemente angegeben werden oder dass nicht die richtige Anzahl von Elementen angegeben wird, wenn die Eingabereihenfolge wichtig ist. 

#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
0
paperhawk