Wie man prüft, ob eine Liste in Python Duplikate enthält

Einführung

In diesem Lab werden wir untersuchen, wie man in Python prüft, ob eine Liste Duplikate enthält. Das Verständnis, wie man Duplikate erkennt, ist für die Datenbereinigung, -analyse und -optimierung von entscheidender Bedeutung.

Wir werden zwei Hauptmethoden behandeln: das Vergleichen der Länge der ursprünglichen Liste mit der Länge ihrer Mengendarstellung und die Verwendung des collections.Counter-Objekts. Das Lab beginnt damit, zu definieren, was Duplikate sind und warum es wichtig ist, sie zu identifizieren. Anschließend werden praktische Python-Codebeispiele bereitgestellt, um jede Methode zu demonstrieren, einschließlich des Erstellens einer duplicates.py-Datei und der Implementierung einer Funktion zum Finden von Duplikaten in einer Liste.

Duplikate definieren

In diesem Schritt werden wir untersuchen, was Duplikate im Kontext der Programmierung sind und wie man sie in Python erkennt. Das Verständnis von Duplikaten ist für die Datenbereinigung, -analyse und -optimierung von entscheidender Bedeutung.

Was sind Duplikate?

Duplikate sind einfach wiederholte Werte in einem Datensatz oder einer Sammlung von Elementen. Beispielsweise sind in der Liste [1, 2, 2, 3, 4, 4, 4] die Zahlen 2 und 4 Duplikate, weil sie mehr als einmal auftauchen.

Warum sollten Duplikate erkannt werden?

Das Erkennen und Behandeln von Duplikaten ist aus mehreren Gründen wichtig:

Datengenauigkeit: Duplikate können Analyseergebnisse verfälschen und zu falschen Schlussfolgerungen führen.
Speichereffizienz: Das Speichern von Duplikaten verschwendet Speicherplatz und Ressourcen.
Leistung: Die Verarbeitung von Duplikaten kann Algorithmen und Anwendungen verlangsamen.

Das Erkennen von Duplikaten in Python

Lassen Sie uns beginnen, ein Python-Skript zu erstellen, um Duplikate in einer Liste zu erkennen.

Öffnen Sie Ihren VS Code-Editor.
Erstellen Sie eine neue Datei mit dem Namen duplicates.py in Ihrem ~/project-Verzeichnis.
```
~/project/duplicates.py
```
Fügen Sie den folgenden Code zur duplicates.py-Datei hinzu:
```
def find_duplicates(data):
    seen = set()
    duplicates = []
    for item in data:
        if item in seen:
            duplicates.append(item)
        else:
            seen.add(item)
    return duplicates

numbers = [1, 2, 2, 3, 4, 4, 4, 5]
duplicate_numbers = find_duplicates(numbers)
print("Original list:", numbers)
print("Duplicate numbers:", duplicate_numbers)
```
Erklärung:
- Die find_duplicates-Funktion nimmt eine Liste data als Eingabe.
- Sie verwendet ein set namens seen, um die Elemente zu verfolgen, die sie bisher gesehen hat. Sets sind nützlich, weil sie nur eindeutige Werte speichern.
- Sie iteriert durch die data-Liste. Wenn ein Element bereits im seen-Set enthalten ist, bedeutet dies, dass es ein Duplikat ist, und es wird der duplicates-Liste hinzugefügt. Andernfalls wird das Element dem seen-Set hinzugefügt.
- Schließlich gibt die Funktion die duplicates-Liste zurück.
Führen Sie das Skript mit dem folgenden Befehl in Ihrem Terminal aus:
```
python duplicates.py
```
Sie sollten die folgende Ausgabe sehen:
```
Original list: [1, 2, 2, 3, 4, 4, 4, 5]
Duplicate numbers: [2, 4, 4]
```
Diese Ausgabe zeigt die ursprüngliche Liste und die in der Liste gefundenen Duplikate.

Vergleichen von len() mit len(set())

In diesem Schritt werden wir eine effizientere Methode zur Erkennung von Duplikaten in einer Liste mithilfe der len()-Funktion und der set()-Datenstruktur untersuchen. Diese Methode nutzt die Tatsache, dass Sets nur eindeutige Elemente speichern.

Grundlagen von len() und set()

len(): Diese Funktion gibt die Anzahl der Elemente in einer Liste oder einem anderen iterierbaren Objekt zurück.
set(): Diese Funktion wandelt eine Liste (oder ein anderes iterierbares Objekt) in ein Set um. Ein Set ist eine Sammlung von eindeutigen Elementen, was bedeutet, dass es automatisch alle Duplikate entfernt.

Funktionsweise

Die Kernidee besteht darin, die Länge der ursprünglichen Liste mit der Länge des aus dieser Liste erstellten Sets zu vergleichen. Wenn die Längen unterschiedlich sind, bedeutet dies, dass es in der ursprünglichen Liste Duplikate gab.

Beispiel

Lassen Sie uns die duplicates.py-Datei, die wir im vorherigen Schritt erstellt haben, so ändern, dass diese Methode verwendet wird.

Öffnen Sie die duplicates.py-Datei in Ihrem ~/project-Verzeichnis mit VS Code.
Ändern Sie den Code wie folgt:
```
def has_duplicates(data):
    return len(data) != len(set(data))

numbers = [1, 2, 2, 3, 4, 4, 4, 5]
if has_duplicates(numbers):
    print("The list contains duplicates.")
else:
    print("The list does not contain duplicates.")
```
Erklärung:
- Die has_duplicates-Funktion vergleicht nun einfach die Länge der ursprünglichen Liste data mit der Länge des aus data erstellten Sets.
- Wenn die Längen unterschiedlich sind, gibt die Funktion True zurück (was bedeutet, dass es Duplikate gibt), andernfalls gibt sie False zurück.
Führen Sie das Skript mit dem folgenden Befehl in Ihrem Terminal aus:
```
python duplicates.py
```
Sie sollten die folgende Ausgabe sehen:
```
The list contains duplicates.
```
Wenn Sie die numbers-Liste in [1, 2, 3, 4, 5] ändern, lautet die Ausgabe:
```
The list does not contain duplicates.
```

Diese Methode ist kürzer und oft effizienter als die vorherige Methode, insbesondere bei großen Listen.

Verwenden von collections.Counter

In diesem Schritt werden wir eine noch leistungsfähigere und pythonische Methode zur Zählung von Duplikaten mithilfe der collections.Counter-Klasse untersuchen. Diese Klasse ist speziell für die Zählung der Häufigkeit von Elementen in einer Liste oder anderen iterierbaren Objekten entwickelt.

Grundlagen von collections.Counter

Die collections.Counter-Klasse ist eine Unterklasse von dict, die speziell für die Zählung von hashbaren Objekten entwickelt wurde. Sie speichert Elemente als Wörterbuchschlüssel und ihre Anzahl als Wörterbuchwerte.

Funktionsweise

collections.Counter zählt automatisch die Vorkommen jedes Elements in einer Liste. Anschließend können Sie die Zählungen einfach abrufen, um Duplikate zu identifizieren.

Beispiel

Lassen Sie uns die duplicates.py-Datei in Ihrem ~/project-Verzeichnis so ändern, dass collections.Counter verwendet wird.

Öffnen Sie die duplicates.py-Datei in Ihrem ~/project-Verzeichnis mit VS Code.
Ändern Sie den Code wie folgt:
```
from collections import Counter

def find_duplicates_counter(data):
    counts = Counter(data)
    duplicates = [item for item, count in counts.items() if count > 1]
    return duplicates

numbers = [1, 2, 2, 3, 4, 4, 4, 5]
duplicate_numbers = find_duplicates_counter(numbers)
print("Original list:", numbers)
print("Duplicate numbers:", duplicate_numbers)
```
Erklärung:
- Wir importieren die Counter-Klasse aus dem collections-Modul.
- Die find_duplicates_counter-Funktion erstellt ein Counter-Objekt aus der Eingabeliste data. Dies zählt automatisch die Vorkommen jedes Elements.
- Anschließend verwenden wir eine Listen-Abstraktion, um eine Liste von Elementen zu erstellen, deren Anzahl größer als 1 ist (d. h. Duplikate).
Führen Sie das Skript mit dem folgenden Befehl in Ihrem Terminal aus:
```
python duplicates.py
```
Sie sollten die folgende Ausgabe sehen:
```
Original list: [1, 2, 2, 3, 4, 4, 4, 5]
Duplicate numbers: [2, 4]
```
Diese Ausgabe zeigt die ursprüngliche Liste und die in der Liste gefundenen Duplikate. Beachten Sie, dass die Counter-Methode nur die eindeutigen Duplikate zurückgibt, nicht alle Vorkommen der Duplikate.

Zusammenfassung

In diesem Lab haben wir zunächst Duplikate als wiederholte Werte in einem Datensatz definiert und deren Auswirkungen auf die Datengenauigkeit, die Speichereffizienz und die Leistung hervorgehoben. Anschließend haben wir ein Python-Skript erstellt, um Duplikate in einer Liste mithilfe einer find_duplicates-Funktion zu identifizieren.

Die Funktion durchläuft die Eingabeliste und verwendet ein set namens seen, um die bereits gefundenen Elemente zu verfolgen. Wenn ein Element bereits in seen enthalten ist, wird es als Duplikat identifiziert und der duplicates-Liste hinzugefügt. Dieser Ansatz nutzt die Eigenschaft von Sets, nur eindeutige Werte zu enthalten, um Duplikate effizient zu erkennen.