Pandas Drop Duplicates: So entfernen Sie doppelte Zeilen in Python

Name

Soren Atelier

Updated on 9.2.2026

Doppelte Zeilen gehören zu den häufigsten Datenqualitätsproblemen in realen Datensätzen. Sie schleichen sich durch wiederholte API-Aufrufe, überlappende CSV-Exporte, fehlerhafte ETL-Pipelines oder einfache Copy-Paste-Fehler bei der manuellen Dateneingabe ein. Unkontrolliert aufblähen Duplikate die Zeilenzahlen, verzerren Durchschnittswerte und Summen und führen zu Verzerrungen in Machine-Learning-Modellen. Ein Datensatz, der wie 10.000 Kundendatensätze aussieht, könnte in Wirklichkeit nur 8.200 eindeutige Kunden und 1.800 Phantomeinträge enthalten, die stillschweigend jede darauf aufbauende Berechnung verfälschen.

Die pandas-Methode drop_duplicates() ist der Standardweg, um diese redundanten Zeilen zu erkennen und zu entfernen. Diese Anleitung geht jeden Parameter durch, zeigt gängige Muster für die Deduplizierung in der Praxis und behandelt Leistungsaspekte für große Datensätze. Jedes Codebeispiel ist kopierbereit und enthält die erwartete Ausgabe.

Warum Duplikate wichtig sind

Bevor wir in den Code einsteigen, lohnt es sich zu verstehen, was doppelte Zeilen genau kaputt machen:

Die Lösung ist einfach: Duplikate finden, entscheiden, welche Kopie behalten werden soll (falls überhaupt), und den Rest entfernen.

Grundlegende Syntax: df.drop_duplicates()

Der einfachste Aufruf entfernt Zeilen, bei denen jeder Spaltenwert identisch ist:

import pandas as pd
 
df = pd.DataFrame({
    'name': ['Alice', 'Bob', 'Alice', 'Charlie', 'Bob'],
    'age': [30, 25, 30, 35, 25],
    'city': ['NYC', 'LA', 'NYC', 'Chicago', 'LA']
})
 
print("Before:")
print(df)
 
df_clean = df.drop_duplicates()
 
print("\nAfter:")
print(df_clean)

Ausgabe:

Before:
      name  age     city
0    Alice   30      NYC
1      Bob   25       LA
2    Alice   30      NYC
3  Charlie   35  Chicago
4      Bob   25       LA

After:
      name  age     city
0    Alice   30      NYC
1      Bob   25       LA
3  Charlie   35  Chicago

Zeile 2 und Zeile 4 waren exakte Kopien von Zeile 0 und Zeile 1 und wurden daher entfernt. Beachten Sie, dass die ursprünglichen Indexwerte (0, 1, 3) erhalten bleiben. Wenn Sie einen sauberen sequenziellen Index möchten, verketten Sie .reset_index(drop=True).

Vollständige Methodensignatur

DataFrame.drop_duplicates(subset=None, keep='first', inplace=False, ignore_index=False)

Duplikate zuerst finden mit df.duplicated()

Bevor Sie Duplikate entfernen, möchten Sie sie oft inspizieren. Die Methode duplicated() gibt eine boolesche Series zurück, die doppelte Zeilen markiert:

df = pd.DataFrame({
    'order_id': [101, 102, 103, 101, 104, 102],
    'product': ['Widget', 'Gadget', 'Widget', 'Widget', 'Gizmo', 'Gadget'],
    'amount': [29.99, 49.99, 29.99, 29.99, 19.99, 49.99]
})
 
# Show which rows are duplicates
print(df.duplicated())

Ausgabe:

0    False
1    False
2    False
3     True
4    False
5     True
dtype: bool

Um die tatsächlichen doppelten Zeilen anzuzeigen:

duplicates = df[df.duplicated(keep=False)]
print(duplicates)

Ausgabe:

   order_id product  amount
0       101  Widget   29.99
1       102  Gadget   49.99
3       101  Widget   29.99
5       102  Gadget   49.99

Die Verwendung von keep=False markiert alle Kopien als Duplikate (nicht nur das zweite Vorkommen), sodass Sie jede an der Duplizierung beteiligte Zeile sehen können.

Duplikate zählen

Um schnell zu zählen, wie viele doppelte Zeilen existieren:

num_duplicates = df.duplicated().sum()
print(f"Number of duplicate rows: {num_duplicates}")
 
total_rows = len(df)
unique_rows = df.drop_duplicates().shape[0]
print(f"Total: {total_rows}, Unique: {unique_rows}, Duplicates: {total_rows - unique_rows}")

Ausgabe:

Number of duplicate rows: 2
Total: 6, Unique: 4, Duplicates: 2

Dies ist eine nützliche Plausibilitätsprüfung vor und nach der Bereinigung.

Der Parameter subset: Nur bestimmte Spalten prüfen

Oft möchten Sie auf Basis einer Schlüsselspalte deduplizieren, anstatt zu verlangen, dass jede Spalte übereinstimmt. Der Parameter subset ermöglicht es Ihnen, festzulegen, welche Spalten die Eindeutigkeit bestimmen:

df = pd.DataFrame({
    'email': ['alice@mail.com', 'bob@mail.com', 'alice@mail.com', 'charlie@mail.com'],
    'name': ['Alice', 'Bob', 'Alice Smith', 'Charlie'],
    'signup_date': ['2025-01-01', '2025-01-02', '2025-01-15', '2025-01-03']
})
 
print("Original:")
print(df)
 
# Deduplicate by email only
df_deduped = df.drop_duplicates(subset=['email'])
print("\nDeduplicated by email:")
print(df_deduped)

Ausgabe:

Original:
              email       name signup_date
0    alice@mail.com      Alice  2025-01-01
1      bob@mail.com        Bob  2025-01-02
2    alice@mail.com  Alice Smith  2025-01-15
3  charlie@mail.com    Charlie  2025-01-03

Deduplicated by email:
              email     name signup_date
0    alice@mail.com    Alice  2025-01-01
1      bob@mail.com      Bob  2025-01-02
3  charlie@mail.com  Charlie  2025-01-03

Zeile 2 wurde entfernt, weil alice@mail.com bereits in Zeile 0 vorkam, obwohl sich die Werte für name und signup_date unterschieden. Sie können auch mehrere Spalten übergeben: subset=['email', 'name'] würde Zeilen nur dann als Duplikate betrachten, wenn beide Spalten übereinstimmen.

Der Parameter keep: first, last oder False

Der Parameter keep steuert, welches Vorkommen erhalten bleibt:

df = pd.DataFrame({
    'sensor_id': ['S1', 'S2', 'S1', 'S2', 'S1'],
    'reading': [22.5, 18.3, 23.1, 18.3, 24.0],
    'timestamp': ['08:00', '08:00', '09:00', '09:00', '10:00']
})
 
print("keep='first' (default):")
print(df.drop_duplicates(subset=['sensor_id'], keep='first'))
 
print("\nkeep='last':")
print(df.drop_duplicates(subset=['sensor_id'], keep='last'))
 
print("\nkeep=False (drop all duplicates):")
print(df.drop_duplicates(subset=['sensor_id'], keep=False))

Ausgabe:

keep='first' (default):
  sensor_id  reading timestamp
0        S1     22.5     08:00
1        S2     18.3     08:00

keep='last':
  sensor_id  reading timestamp
3        S2     18.3     09:00
4        S1     24.0     10:00

keep=False (drop all duplicates):
Empty DataFrame
Columns: [sensor_id, reading, timestamp]
Index: []

Im obigen Beispiel gibt keep=False einen leeren DataFrame zurück, weil beide Sensor-IDs mehr als einmal vorkommen.

In-Place vs. Neuen DataFrame zurückgeben

Standardmäßig gibt drop_duplicates() einen neuen DataFrame zurück und lässt den Originalen unverändert. Das Setzen von inplace=True ändert das Original direkt:

df = pd.DataFrame({
    'id': [1, 2, 2, 3],
    'value': ['a', 'b', 'b', 'c']
})
 
# Returns new DataFrame (original unchanged)
df_new = df.drop_duplicates()
print(f"Original length: {len(df)}, New length: {len(df_new)}")
 
# Modifies in place (returns None)
df.drop_duplicates(inplace=True)
print(f"After inplace: {len(df)}")

Ausgabe:

Original length: 4, New length: 3
After inplace: 3

Der moderne Pandas-Stil empfiehlt, inplace=True zu vermeiden und stattdessen Zuweisung zu verwenden (df = df.drop_duplicates()). Dies macht den Code lesbarer und einfacher zu debuggen, insbesondere bei verketteten Operationen.

Groß-/Kleinschreibung-unabhängige Duplikaterkennung

Standardmäßig behandelt pandas "Alice" und "alice" als verschiedene Werte. Für eine Deduplizierung ohne Berücksichtigung der Groß-/Kleinschreibung normalisieren Sie zuerst die Spalte:

df = pd.DataFrame({
    'name': ['Alice', 'alice', 'ALICE', 'Bob', 'bob'],
    'score': [90, 85, 92, 78, 80]
})
 
# Create a normalized column for comparison
df['name_lower'] = df['name'].str.lower()
 
# Deduplicate on the normalized column, keep the first original-case entry
df_deduped = df.drop_duplicates(subset=['name_lower']).drop(columns=['name_lower'])
print(df_deduped)

Ausgabe:

    name  score
0  Alice     90
3    Bob     78

Dieses Muster bewahrt die ursprüngliche Schreibweise und identifiziert gleichzeitig korrekt Duplikate ohne Berücksichtigung der Groß-/Kleinschreibung.

Praxisbeispiel: Bereinigung einer Kundendatenbank

Hier ein realistisches Szenario. Sie erhalten einen Kundenexport aus einem CRM, in dem derselbe Kunde mehrfach von verschiedenen Vertriebsmitarbeitern erfasst wurde:

import pandas as pd
 
customers = pd.DataFrame({
    'customer_id': [1001, 1002, 1001, 1003, 1002, 1004],
    'name': ['Acme Corp', 'Beta Inc', 'Acme Corp', 'Gamma LLC', 'Beta Inc.', 'Delta Co'],
    'email': ['acme@mail.com', 'beta@mail.com', 'acme@mail.com', 'gamma@mail.com', 'beta@mail.com', 'delta@mail.com'],
    'revenue': [50000, 30000, 52000, 45000, 30000, 20000],
    'last_contact': ['2025-12-01', '2025-11-15', '2026-01-10', '2025-10-20', '2025-11-15', '2026-01-05']
})
 
print(f"Rows before cleaning: {len(customers)}")
print(f"Duplicate customer_ids: {customers.duplicated(subset=['customer_id']).sum()}")
 
# Sort by last_contact descending so the most recent entry is first
customers['last_contact'] = pd.to_datetime(customers['last_contact'])
customers = customers.sort_values('last_contact', ascending=False)
 
# Keep the most recent record for each customer_id
customers_clean = customers.drop_duplicates(subset=['customer_id'], keep='first')
customers_clean = customers_clean.sort_values('customer_id').reset_index(drop=True)
 
print(f"\nRows after cleaning: {len(customers_clean)}")
print(customers_clean)

Ausgabe:

Rows before cleaning: 6
Duplicate customer_ids: 2

Rows after cleaning: 4
   customer_id       name           email  revenue last_contact
0         1001  Acme Corp   acme@mail.com    52000   2026-01-10
1         1002   Beta Inc  beta@mail.com    30000   2025-11-15
2         1003  Gamma LLC  gamma@mail.com    45000   2025-10-20
3         1004   Delta Co  delta@mail.com    20000   2026-01-05

Das Schlüsselmuster hier ist zuerst sortieren, dann mit keep='first' deduplizieren. Durch das Sortieren nach last_contact in absteigender Reihenfolge vor der Deduplizierung überlebt der aktuellste Datensatz für jeden Kunden.

Praxisbeispiel: Deduplizierung von Web-Scraping-Ergebnissen

Web-Scraper erzeugen häufig Duplikate, wenn Seiten mehrfach gecrawlt werden oder sich Paginierungen überschneiden:

import pandas as pd
 
scraped = pd.DataFrame({
    'url': [
        'https://shop.com/item/101',
        'https://shop.com/item/102',
        'https://shop.com/item/101',
        'https://shop.com/item/103',
        'https://shop.com/item/102',
        'https://shop.com/item/104',
    ],
    'title': ['Blue Widget', 'Red Gadget', 'Blue Widget', 'Green Gizmo', 'Red Gadget', 'Yellow Thing'],
    'price': [19.99, 29.99, 19.99, 39.99, 31.99, 14.99],
    'scraped_at': ['2026-02-01', '2026-02-01', '2026-02-02', '2026-02-02', '2026-02-02', '2026-02-02']
})
 
print(f"Total scraped rows: {len(scraped)}")
print(f"Unique URLs: {scraped['url'].nunique()}")
 
# Keep the latest scrape for each URL (prices may have changed)
scraped['scraped_at'] = pd.to_datetime(scraped['scraped_at'])
scraped = scraped.sort_values('scraped_at', ascending=False)
products = scraped.drop_duplicates(subset=['url'], keep='first').reset_index(drop=True)
 
print(f"\nCleaned rows: {len(products)}")
print(products)

Ausgabe:

Total scraped rows: 6
Unique URLs: 4

Cleaned rows: 4
                          url        title  price scraped_at
0  https://shop.com/item/101  Blue Widget  19.99 2026-02-02
1  https://shop.com/item/102   Red Gadget  31.99 2026-02-02
2  https://shop.com/item/103  Green Gizmo  39.99 2026-02-02
3  https://shop.com/item/104  Yellow Thing  14.99 2026-02-02

Beachten Sie, dass der Preis des Red Gadget zwischen den Scrape-Durchläufen von 29,99 auf 31,99 aktualisiert wurde. Durch das Beibehalten des neuesten Eintrags erfassen wir den aktuellsten Preis.

drop_duplicates() vs groupby().first(): Wann was verwenden

Beide Ansätze können Daten deduplizieren, funktionieren aber unterschiedlich:

import pandas as pd
 
df = pd.DataFrame({
    'user_id': [1, 1, 2, 2, 3],
    'action': ['login', 'purchase', 'login', 'login', 'purchase'],
    'timestamp': ['2026-01-01', '2026-01-02', '2026-01-01', '2026-01-03', '2026-01-01']
})
 
# Method 1: drop_duplicates
result1 = df.drop_duplicates(subset=['user_id'], keep='first')
print("drop_duplicates:")
print(result1)
 
# Method 2: groupby().first()
result2 = df.groupby('user_id').first().reset_index()
print("\ngroupby().first():")
print(result2)

Ausgabe:

drop_duplicates:
   user_id    action   timestamp
0        1     login  2026-01-01
2        2     login  2026-01-01
4        3  purchase  2026-01-01

groupby().first():
   user_id    action   timestamp
0        1     login  2026-01-01
1        2     login  2026-01-01
2        3  purchase  2026-01-01

Die Ergebnisse sehen ähnlich aus, aber es gibt wichtige Unterschiede:

Faustregel: Verwenden Sie drop_duplicates(), wenn Sie einfach doppelte Zeilen entfernen möchten. Verwenden Sie groupby().first() (oder groupby().agg()), wenn Sie auch Werte aus den doppelten Zeilen aggregieren müssen -- zum Beispiel Umsätze über doppelte Kundendatensätze summieren, während der erste Name beibehalten wird.

Leistungstipps für große DataFrames

Bei der Arbeit mit Millionen von Zeilen kann die Deduplizierung zum Engpass werden. Hier sind praktische Möglichkeiten zur Beschleunigung:

1. subset-Spalten angeben

Das Prüfen aller Spalten ist langsamer als das Prüfen nur der Schlüsselspalten:

# Slower: checks every column
df.drop_duplicates()
 
# Faster: checks only the key column
df.drop_duplicates(subset=['user_id'])

2. Geeignete Datentypen verwenden

Konvertieren Sie Stringspalten in den category-Datentyp vor der Deduplizierung, wenn sie eine geringe Kardinalität haben:

df['status'] = df['status'].astype('category')
df['country'] = df['country'].astype('category')
df_clean = df.drop_duplicates(subset=['status', 'country'])

3. Nur bei Bedarf vor der Deduplizierung sortieren

Das Sortieren eines großen DataFrames nur um zu steuern, welche Zeile keep='first' auswählt, kostet erhebliche Zeit. Wenn es Ihnen egal ist, welches Duplikat überlebt, überspringen Sie die Sortierung.

4. Chunk-Verarbeitung für sehr große Dateien in Betracht ziehen

Für Dateien, die nicht in den Speicher passen, verarbeiten Sie in Chunks:

chunks = pd.read_csv('large_file.csv', chunksize=100_000)
seen = set()
clean_chunks = []
 
for chunk in chunks:
    chunk = chunk.drop_duplicates(subset=['id'])
    new_rows = chunk[~chunk['id'].isin(seen)]
    seen.update(new_rows['id'].tolist())
    clean_chunks.append(new_rows)
 
df_clean = pd.concat(clean_chunks, ignore_index=True)

5. Benchmark: Typische Leistung

Diese Werte variieren je nach Hardware und Datentypen, aber die wichtigste Erkenntnis ist, dass drop_duplicates() linear skaliert und die meisten Datensätze in unter einer Sekunde verarbeitet.

Erkunden Sie Ihre bereinigten Daten mit PyGWalker

Nach dem Entfernen von Duplikaten besteht der nächste Schritt normalerweise darin, den bereinigten Datensatz zu erkunden -- Verteilungen zu prüfen, Ausreißer zu finden und zu überprüfen, ob die Deduplizierung wie erwartet funktioniert hat. Anstatt mehrere matplotlib- oder seaborn-Aufrufe zu schreiben, können Sie PyGWalker (opens in a new tab) verwenden, eine Open-Source-Python-Bibliothek, die jeden pandas DataFrame in eine interaktive, Tableau-ähnliche Visualisierungsoberfläche direkt in Jupyter Notebook verwandelt.

import pandas as pd
import pygwalker as pyg
 
# Your cleaned customer data
customers_clean = pd.DataFrame({
    'customer_id': [1001, 1002, 1003, 1004],
    'name': ['Acme Corp', 'Beta Inc', 'Gamma LLC', 'Delta Co'],
    'revenue': [52000, 30000, 45000, 20000],
    'region': ['East', 'West', 'East', 'South']
})
 
# Launch interactive visualization
walker = pyg.walk(customers_clean)

Mit PyGWalker können Sie region auf die x-Achse und revenue auf die y-Achse ziehen, um sofort die Umsatzverteilung nach Region zu sehen. Sie können Balkendiagramme, Streudiagramme, Histogramme und Heatmaps erstellen, indem Sie Felder per Drag-and-Drop verschieben -- kein Diagramm-Code erforderlich. Es ist besonders nützlich nach der Deduplizierung, wenn Sie überprüfen möchten, ob Ihre Bereinigungslogik sinnvolle Ergebnisse geliefert hat.

Installieren Sie PyGWalker mit pip install pygwalker oder probieren Sie es in Google Colab (opens in a new tab) aus.

FAQ

Ändert drop_duplicates() den ursprünglichen DataFrame?

Nein, standardmäßig gibt drop_duplicates() einen neuen DataFrame zurück und lässt den Originalen unverändert. Um direkt zu ändern, übergeben Sie inplace=True, aber der empfohlene Ansatz ist die Verwendung von Zuweisung: df = df.drop_duplicates().

Wie entferne ich Duplikate basierend auf nur einer Spalte?

Übergeben Sie den Spaltennamen an den Parameter subset: df.drop_duplicates(subset=['email']). Dies behält die erste Zeile für jede eindeutige E-Mail und entfernt nachfolgende Zeilen mit derselben E-Mail, unabhängig von Unterschieden in anderen Spalten.

Was ist der Unterschied zwischen duplicated() und drop_duplicates()?

duplicated() gibt eine boolesche Series zurück, die markiert, welche Zeilen Duplikate sind (nützlich zur Inspektion und Zählung). drop_duplicates() gibt einen DataFrame zurück, aus dem die doppelten Zeilen entfernt wurden. Verwenden Sie duplicated() zuerst, um Ihre Daten zu verstehen, dann drop_duplicates() zur Bereinigung.

Kann ich Duplikate basierend auf einer Bedingung entfernen?

Nicht direkt mit drop_duplicates(). Sortieren Sie stattdessen Ihren DataFrame zuerst nach der Bedingungsspalte und rufen Sie dann drop_duplicates() mit keep='first' auf. Zum Beispiel, um die Zeile mit dem höchsten Umsatz für jeden Kunden zu behalten: df.sort_values('revenue', ascending=False).drop_duplicates(subset=['customer_id'], keep='first').

Wie gehe ich mit Duplikaten ohne Berücksichtigung der Groß-/Kleinschreibung um?

Erstellen Sie eine temporäre Kleinbuchstaben-Spalte, deduplizieren Sie darauf und entfernen Sie dann die Hilfsspalte: df['key'] = df['name'].str.lower() gefolgt von df.drop_duplicates(subset=['key']).drop(columns=['key']). Dies bewahrt die ursprüngliche Schreibweise und identifiziert gleichzeitig korrekt Duplikate.

Fazit

Das Entfernen doppelter Zeilen ist ein grundlegender Schritt in jedem Datenbereinigungsworkflow. Die pandas-Methode drop_duplicates() bewältigt die überwiegende Mehrheit der Deduplizierungsaufgaben mit nur wenigen Parametern:

• Verwenden Sie subset, um auf Basis bestimmter Spalten statt aller Spalten zu deduplizieren.
• Verwenden Sie keep='first' oder keep='last', um zu steuern, welches Vorkommen überlebt; verwenden Sie keep=False, um alle Kopien zu entfernen.
• Verwenden Sie duplicated(), um Duplikate vor dem Entfernen zu inspizieren und zu zählen.
• Sortieren Sie vor der Deduplizierung, wenn Sie eine bestimmte Zeile behalten müssen (z.B. den aktuellsten Datensatz).
• Für Deduplizierung ohne Berücksichtigung der Groß-/Kleinschreibung normalisieren Sie zuerst in einer temporären Spalte auf Kleinbuchstaben.
• Für große Datensätze begrenzen Sie die subset-Spalten und verwenden Sie geeignete Datentypen, um die Leistung hoch zu halten.

Sobald Ihre Daten bereinigt sind, ermöglicht Ihnen PyGWalker (opens in a new tab), das Ergebnis visuell zu erkunden, ohne Diagramm-Code zu schreiben. So können Sie überprüfen, ob die Deduplizierung korrekt funktioniert hat, und direkt mit der Analyse beginnen.