Wie vergleicht man eine Liste von Listen / Sets in Python?

Was ist der einfachste Weg, zu vergleichen mit den 2 Listen/sets-und-Ausgabe die Unterschiede? Gibt es eingebaute Funktionen, die mir helfen, vergleichen Sie verschachtelte Listen/sets?

Eingänge:

First_list = [['Test.doc', '1a1a1a', 1111], 
              ['Test2.doc', '2b2b2b', 2222],  
              ['Test3.doc', '3c3c3c', 3333]
             ]  
Secnd_list = [['Test.doc', '1a1a1a', 1111], 
              ['Test2.doc', '2b2b2b', 2222], 
              ['Test3.doc', '8p8p8p', 9999], 
              ['Test4.doc', '4d4d4d', 4444]]

Erwartete Ausgabe:

Differences = [['Test3.doc', '3c3c3c', 3333],
               ['Test3.doc', '8p8p8p', 9999], 
               ['Test4.doc', '4d4d4d', 4444]]

InformationsquelleAutor der Frage tang | 2011-05-24

Du willst also die Differenz zwischen zwei Listen von Elementen.

first_list = [['Test.doc', '1a1a1a', 1111], 
              ['Test2.doc', '2b2b2b', 2222], 
              ['Test3.doc', '3c3c3c', 3333]]
secnd_list = [['Test.doc', '1a1a1a', 1111], 
              ['Test2.doc', '2b2b2b', 2222], 
              ['Test3.doc', '8p8p8p', 9999], 
              ['Test4.doc', '4d4d4d', 4444]]

Zuerst würde ich wiederum jede Liste von Listen in eine Liste von Tupeln, also als Tupel sind hashable (Listen nicht), so können Sie konvertieren Sie Ihre Liste von Tupeln in eine Menge von Tupeln:

first_tuple_list = [tuple(lst) for lst in first_list]
secnd_tuple_list = [tuple(lst) for lst in secnd_list]

Dann können Sie sets machen:

first_set = set(first_tuple_list)
secnd_set = set(secnd_tuple_list)

BEARBEITEN (vorgeschlagen von sdolan): Sie könnte getan haben, die letzten beiden Schritte für jede Liste in einem one-liner:

first_set = set(map(tuple, first_list))
secnd_set = set(map(tuple, secnd_list))

Hinweis: map ist eine funktionale Programmierung Befehl gilt, dass die Funktion im ersten argument (in diesem Fall die tuple - Funktion) zu jedem Element im zweiten argument (in unserem Fall eine Liste von Listen).

finden, und die symmetrische Differenz zwischen den sets:

>>> first_set.symmetric_difference(secnd_set) 
set([('Test3.doc', '3c3c3c', 3333),
     ('Test3.doc', '8p8p8p', 9999),
     ('Test4.doc', '4d4d4d', 4444)])

Hinweis first_set ^ secnd_set entspricht symmetric_difference.

Auch wenn Sie nicht wollen, zu verwenden, setzt (z.B. mit python 2.2), seine ziemlich einfach zu tun. E. g., mit Liste Verstehens:

>>> [x for x in first_list if x not in secnd_list] + [x for x in secnd_list if x not in first_list]
[['Test3.doc', '3c3c3c', 3333],
 ['Test3.doc', '8p8p8p', 9999],
 ['Test4.doc', '4d4d4d', 4444]]

oder mit der funktionellen filter Befehl und lambda Funktionen. (Sie müssen testen Sie beide Möglichkeiten und kombinieren).

>>> filter(lambda x: x not in secnd_list, first_list) + filter(lambda x: x not in first_list, secnd_list)

[['Test3.doc', '3c3c3c', 3333],
 ['Test3.doc', '8p8p8p', 9999],
 ['Test4.doc', '4d4d4d', 4444]]

InformationsquelleAutor der Antwort dr jimbob

3

Nicht sicher, ob es eine nette Funktion, aber der "manuelle" Weg, es zu tun ist nicht schwer:
```
differences = []

for list in firstList:
    if list not in secondList:
        differences.append(list)
```
InformationsquelleAutor der Antwort Sam Magura

>>> First_list = [['Test.doc', '1a1a1a', '1111'], ['Test2.doc', '2b2b2b', '2222'], ['Test3.doc', '3c3c3c', '3333']] 
>>> Secnd_list = [['Test.doc', '1a1a1a', '1111'], ['Test2.doc', '2b2b2b', '2222'], ['Test3.doc', '3c3c3c', '3333'], ['Test4.doc', '4d4d4d', '4444']] 


>>> z = [tuple(y) for y in First_list]
>>> z
[('Test.doc', '1a1a1a', '1111'), ('Test2.doc', '2b2b2b', '2222'), ('Test3.doc', '3c3c3c', '3333')]
>>> x = [tuple(y) for y in Secnd_list]
>>> x
[('Test.doc', '1a1a1a', '1111'), ('Test2.doc', '2b2b2b', '2222'), ('Test3.doc', '3c3c3c', '3333'), ('Test4.doc', '4d4d4d', '4444')]


>>> set(x) - set(z)
set([('Test4.doc', '4d4d4d', '4444')])

InformationsquelleAutor der Antwort pyfunc

ich denke, du wirst konvertieren müssen Ihre Listen setzt:

>>> a = {('a', 'b'), ('c', 'd'), ('e', 'f')}
>>> b = {('a', 'b'), ('h', 'g')}
>>> a.symmetric_difference(b)
{('e', 'f'), ('h', 'g'), ('c', 'd')}

InformationsquelleAutor der Antwort

0

http://docs.python.org/library/difflib.html ist ein guter Ausgangspunkt für das, was Sie suchen.

Wenn Sie es rekursiv auf die deltas, Sie sollten in der Lage sein zu handhaben, verschachtelte Datenstrukturen. Aber es dauert einige Arbeit.

InformationsquelleAutor der Antwort btilly
0

Mithilfe von set Verstehens, können Sie machen es zu einem one-liner. Wenn Sie wollen:

bekommen eine Menge von Tupeln, dann:
```
Differences = {tuple(i) for i in First_list} ^ {tuple(i) for i in Secnd_list}
```
Oder um eine Liste von Tupeln, dann:
```
Differences = list({tuple(i) for i in First_list} ^ {tuple(i) for i in Secnd_list})
```
Oder eine Liste von Listen (wenn Sie wirklich wollen), dann:
```
Differences = [list(j) for j in {tuple(i) for i in First_list} ^ {tuple(i) for i in Secnd_list}]
```
PS: ich lese hier: https://stackoverflow.com/a/10973817/4900095dass die map () - Funktion ist nicht pythonic Art und Weise, Dinge zu tun.

InformationsquelleAutor der Antwort Sukrit Gupta

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.