Im Folgenden wird beschrieben, wie man in Python für jeden der folgenden Fälle feststellen kann, ob eine Liste (Array) doppelte Elemente hat (alle Elemente sind einzigartig).
- Bei einer Liste, die keine Liste im Element
- Für Listen mit Listen von Elementen (zweidimensionale Arrays, Listen von Listen, usw.)
Im folgenden Artikel erfahren Sie, wie Sie doppelte Elemente aus einer Liste entfernen oder extrahieren können.
Beachten Sie, dass Listen verschiedene Datentypen speichern können und sich streng von Arrays unterscheiden. Wenn Sie Arrays in Prozessen behandeln wollen, die Speichergröße und Speicheradressen oder numerische Verarbeitung großer Daten erfordern, verwenden Sie array (Standardbibliothek) oder NumPy.
Feststellen, ob es doppelte Elemente in der Liste gibt (wenn das Element keine Liste hat)
Wenn das Element kein aktualisierbares Objekt wie eine Liste hat, verwenden Sie den Konstruktor set() des Satzes set type.
Der Typ set ist ein Datentyp, der keine doppelten Elemente hat. Wenn eine Liste an den Konstruktor set() übergeben wird, werden doppelte Werte ignoriert und ein Objekt vom Typ set mit nur eindeutigen Werten als Elemente zurückgegeben.
Die Anzahl der Elemente in diesem Objekt vom Typ Menge und in der ursprünglichen Liste werden mit Hilfe der eingebauten Funktion len() ermittelt und verglichen.
- Wenn die Anzahl der Elemente gleich ist, gibt es keine doppelten Elemente in der ursprünglichen Liste
- Doppelte Elemente werden in die ursprüngliche Liste aufgenommen, wenn die Anzahl der Elemente unterschiedlich ist
Funktionen, die false zurückgeben, wenn es keine doppelten Elemente gibt, und true, wenn es doppelte Elemente gibt, sind folgende
def has_duplicates(seq):
return len(seq) != len(set(seq))
l = [0, 1, 2]
print(has_duplicates(l))
# False
l = [0, 1, 1, 2]
print(has_duplicates(l))
# True
Das Beispiel ist eine Liste, aber dieselbe Funktion kann auch für Tupel verwendet werden.
Veränderbare (aktualisierbare) Objekte wie Listen können keine Elemente vom Typ Menge sein. Daher führen Listen mit Listen als Elementen (zweidimensionale Arrays, Listen von Listen usw.) zu einem TypeError. Die Gegenmaßnahme ist unten dargestellt.
l_2d = [[0, 1], [1, 1], [0, 1], [1, 0]]
# print(has_duplicates(l_2d))
# TypeError: unhashable type: 'list'
Feststellen, ob es doppelte Elemente in der Liste gibt (wenn das Element eine Liste hat)
Bei einer Liste mit einer Reihe von Elementen (z. B. einer Liste von Listen) können die folgenden Funktionen verwendet werden, um festzustellen, ob es doppelte Elemente gibt.
def has_duplicates2(seq):
seen = []
unique_list = [x for x in seq if x not in seen and not seen.append(x)]
return len(seq) != len(unique_list)
l_2d = [[0, 0], [0, 1], [1, 1], [1, 0]]
print(has_duplicates2(l_2d))
# False
l_2d = [[0, 0], [0, 1], [1, 1], [1, 1]]
print(has_duplicates2(l_2d))
# True
Anstelle von set() erzeugt die Listenauffassungsnotation eine Liste, deren Elemente nur eindeutige Werte sind, und die Anzahl der Elemente wird verglichen. Siehe den folgenden Artikel für weitere Einzelheiten.
Diese Funktion ist auch für Listen gültig, die keine Liste von Elementen haben.
l = [0, 1, 2]
print(has_duplicates2(l))
# False
l = [0, 1, 1, 2]
print(has_duplicates2(l))
# True
Das bisherige Beispiel ist die Bestimmung, ob die Liste der Elemente dupliziert ist (dieselbe Liste enthält).
Ob sich die Elemente der einzelnen Listen überschneiden, lässt sich feststellen, nachdem die ursprüngliche Liste auf eine Dimension reduziert wurde.
l_2d = [[0, 1], [2, 3]]
print(sum(l_2d, []))
# [0, 1, 2, 3]
print(has_duplicates(sum(l_2d, [])))
# False
l_2d = [[0, 1], [2, 0]]
print(has_duplicates(sum(l_2d, [])))
# True
Hier wird sum() verwendet, um die Liste zu reduzieren, aber itertools.chain.from_iterable() kann auch verwendet werden. Wenn eine Liste mit drei oder mehr Dimensionen reduziert werden soll, muss außerdem eine neue Funktion definiert werden.
