Skip to content
Themen
Pandas
Pandas Zeilen Filtern: Daten nach Bedingung in Python Auswählen

Pandas Zeilen Filtern: Daten nach Bedingung in Python Auswählen

Soren Atelier
Name
Soren Atelier

Updated on

Das Filtern von Zeilen in Pandas DataFrames ist eine der häufigsten Operationen in der Datenanalyse. Ob Sie Daten bereinigen, Muster erkunden oder Datensätze für maschinelles Lernen vorbereiten – Sie müssen bestimmte Zeilen basierend auf Bedingungen auswählen. Die Herausforderung besteht darin, die richtige Methode unter den mehreren Filteransätzen von Pandas zu wählen – jede mit unterschiedlicher Syntax, Leistungsmerkmalen und Anwendungsfällen.

Viele Data Scientists kämpfen mit der Filtereffizienz, insbesondere bei der Arbeit mit großen Datensätzen oder komplexen Bedingungen. Die falsche Methode kann Ihre Analyse um Größenordnungen verlangsamen. Zu verstehen, wann boolean Indexing gegenüber .query() oder .loc[] verwendet werden sollte, kann den Unterschied zwischen einem Skript ausmachen, das in Sekunden läuft, und einem, das Minuten benötigt.

Dieser Leitfaden behandelt alle Pandas-Filtermethoden mit praktischen Beispielen, Leistungsvergleichen und Best Practices. Sie lernen boolean Indexing, die .query()-Methode, .loc[]-Auswahl, die .where()-Funktion und die .filter()-Methode kennen. Am Ende wissen Sie genau, welchen Ansatz Sie für jedes Filterszenario verwenden sollten.

📚

    Pandas-Zeilenfilter-Methoden Verstehen

    Pandas bietet fünf primäre Methoden zum Filtern von DataFrame-Zeilen, jede für unterschiedliche Szenarien geeignet:

    MethodeAm Besten FürSyntax-BeispielLeistung
    Boolean IndexingEinfache Bedingungen, Lesbarkeitdf[df['age'] > 25]Schnell für kleine-mittlere Daten
    .query()Komplexe Bedingungen, String-basiertdf.query('age > 25 and city == "NYC"')Schneller für große Daten
    .loc[]Label-basiert mit Bedingungendf.loc[df['age'] > 25, ['name', 'age']]Flexible Spaltenauswahl
    .where()Struktur beibehalten, Werte ersetzendf.where(df['age'] > 25, np.nan)Behält DataFrame-Form bei
    .filter()Nach Spalten-/Indexnamen filterndf.filter(like='total', axis=1)Spalten-/Indexnamen-Muster

    Lassen Sie uns jede Methode mit detaillierten Beispielen erkunden.

    Boolean Indexing: Der Häufigste Ansatz

    Boolean Indexing filtert Zeilen durch Erstellen einer booleschen Maske (True/False-Werte) und deren Anwendung auf den DataFrame. Dies ist die intuitivste Methode für Anfänger.

    import pandas as pd
import numpy as np
 
# Beispiel-DataFrame erstellen
df = pd.DataFrame({
    'name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
    'age': [25, 30, 35, 28, 32],
    'city': ['NYC', 'LA', 'NYC', 'Chicago', 'LA'],
    'salary': [70000, 80000, 90000, 75000, 85000]
})
 
# Zeilen filtern, wo age größer als 30 ist
filtered = df[df['age'] > 30]
print(filtered)
#       name  age city  salary
# 2  Charlie   35  NYC   90000
# 4      Eve   32   LA   85000
 
# Boolesche Maske anzeigen
print(df['age'] > 30)
# 0    False
# 1    False
# 2     True
# 3    False
# 4     True

    Boolean Indexing funktioniert durch Auswertung der Bedingung df['age'] > 30, die eine Series von True/False-Werten zurückgibt. Wenn Sie diese Maske mit df[mask] an den DataFrame übergeben, gibt Pandas nur Zeilen zurück, bei denen die Maske True ist.

    Filtern mit Mehreren Bedingungen

    Kombinieren Sie mehrere Bedingungen mit logischen Operatoren. Wichtig: Verwenden Sie & (und), | (oder), ~ (nicht) anstelle von Pythons and, or, not Schlüsselwörtern. Umschließen Sie jede Bedingung immer mit Klammern.

    # Mehrere Bedingungen mit AND
filtered = df[(df['age'] > 25) & (df['city'] == 'NYC')]
print(filtered)
#       name  age city  salary
# 2  Charlie   35  NYC   90000
 
# Mehrere Bedingungen mit OR
filtered = df[(df['age'] > 30) | (df['salary'] > 80000)]
print(filtered)
#       name  age     city  salary
# 2  Charlie   35      NYC   90000
# 4      Eve   32       LA   85000
 
# NOT-Operator
filtered = df[~(df['city'] == 'NYC')]
print(filtered)
#     name  age     city  salary
# 1    Bob   30       LA   80000
# 3  David   28  Chicago   75000
# 4    Eve   32       LA   85000

    .isin() für Mehrere Werte Verwenden

    Filtern Sie Zeilen, bei denen eine Spalte mit einem beliebigen Wert in einer Liste übereinstimmt, mit .isin():

    # Zeilen filtern, wo city NYC oder LA ist
cities = ['NYC', 'LA']
filtered = df[df['city'].isin(cities)]
print(filtered)
#       name  age city  salary
# 0    Alice   25  NYC   70000
# 1      Bob   30   LA   80000
# 2  Charlie   35  NYC   90000
# 4      Eve   32   LA   85000
 
# Umkehrung: Städte NICHT in der Liste
filtered = df[~df['city'].isin(cities)]
print(filtered)
#     name  age     city  salary
# 3  David   28  Chicago   75000

    Filtern mit .between()

    Die .between()-Methode filtert Werte innerhalb eines Bereichs (standardmäßig inklusiv):

    # Alter zwischen 28 und 32 filtern
filtered = df[df['age'].between(28, 32)]
print(filtered)
#     name  age     city  salary
# 1    Bob   30       LA   80000
# 3  David   28  Chicago   75000
# 4    Eve   32       LA   85000
 
# Exklusive Grenzen
filtered = df[df['age'].between(28, 32, inclusive='neither')]
print(filtered)
#   name  age city  salary
# 1  Bob   30   LA   80000

    Die .query()-Methode: String-Basiertes Filtern

    Die .query()-Methode akzeptiert einen String-Ausdruck, was sie für komplexe Bedingungen lesbar macht. Sie ist besonders effizient für große DataFrames, da sie numexpr zur Optimierung verwendet.

    # Einfache Abfrage
filtered = df.query('age > 30')
print(filtered)
#       name  age city  salary
# 2  Charlie   35  NYC   90000
# 4      Eve   32   LA   85000
 
# Mehrere Bedingungen
filtered = df.query('age > 25 and city == "NYC"')
print(filtered)
#       name  age city  salary
# 2  Charlie   35  NYC   90000
 
# Variablen mit @-Symbol verwenden
min_age = 30
filtered = df.query('age > @min_age')
print(filtered)
#       name  age city  salary
# 2  Charlie   35  NYC   90000
# 4      Eve   32   LA   85000

    Erweiterte .query()-Ausdrücke

    # .isin() in Abfrage verwenden
cities = ['NYC', 'LA']
filtered = df.query('city in @cities')
print(filtered)
 
# Bereichsbedingungen
filtered = df.query('28 <= age <= 32')
print(filtered)
 
# String-Methoden
filtered = df.query('city.str.contains("LA")', engine='python')
print(filtered)

    .loc[] für Label-Basiertes Filtern

    Der .loc[]-Indexer kombiniert Zeilenfilterung mit Spaltenauswahl. Verwenden Sie ihn, wenn Sie bestimmte Spalten aus gefilterten Zeilen benötigen.

    # Zeilen filtern und Spalten auswählen
filtered = df.loc[df['age'] > 30, ['name', 'age']]
print(filtered)
#       name  age
# 2  Charlie   35
# 4      Eve   32
 
# Mehrere Bedingungen
filtered = df.loc[(df['age'] > 25) & (df['salary'] > 75000), ['name', 'salary']]
print(filtered)
#       name  salary
# 1      Bob   80000
# 2  Charlie   90000
# 4      Eve   85000
 
# Alle Spalten
filtered = df.loc[df['city'] == 'NYC', :]
print(filtered)

    .where()-Methode: Bedingte Wertersetzung

    Im Gegensatz zu anderen Methoden behält .where() die DataFrame-Form bei, indem Werte, die die Bedingung nicht erfüllen, durch NaN (oder einen angegebenen Wert) ersetzt werden.

    # Werte behalten, wo age > 30, andere durch NaN ersetzen
result = df.where(df['age'] > 30)
print(result)
#       name   age city   salary
# 0      NaN   NaN  NaN      NaN
# 1      NaN   NaN  NaN      NaN
# 2  Charlie  35.0  NYC  90000.0
# 3      NaN   NaN  NaN      NaN
# 4      Eve  32.0   LA  85000.0
 
# Mit benutzerdefiniertem Wert ersetzen
result = df.where(df['age'] > 30, 'FILTERED')
print(result)
 
# Zeilen mit NaN nach .where() entfernen
result = df.where(df['age'] > 30).dropna()
print(result)

    .filter()-Methode: Nach Spalten-/Indexnamen Filtern

    Die .filter()-Methode filtert Spalten oder Zeilen nach ihren Labels (Namen), nicht nach Werten. Verwenden Sie sie für musterbasierte Spaltenauswahl.

    # DataFrame mit mehreren Spalten erstellen
df_wide = pd.DataFrame({
    'total_sales': [100, 200, 300],
    'total_profit': [20, 40, 60],
    'monthly_sales': [10, 20, 30],
    'yearly_sales': [120, 240, 360],
    'region': ['East', 'West', 'North']
})
 
# Spalten filtern, die 'total' enthalten
filtered = df_wide.filter(like='total')
print(filtered)
#    total_sales  total_profit
# 0          100            20
# 1          200            40
# 2          300            60
 
# Spalten mit Regex filtern
filtered = df_wide.filter(regex=r'.*sales$')
print(filtered)
#    total_sales  monthly_sales  yearly_sales
# 0          100             10           120
# 1          200             20           240
# 2          300             30           360
 
# Spalten nach genauen Namen filtern
filtered = df_wide.filter(items=['total_sales', 'region'])
print(filtered)

    String-Daten Filtern

    Pandas bietet String-Methoden über den .str-Accessor zum Filtern von Textspalten.

    # DataFrame mit Textdaten erstellen
df_text = pd.DataFrame({
    'name': ['Alice Smith', 'Bob Johnson', 'Charlie Brown', 'David Lee'],
    'email': ['alice@gmail.com', 'bob@yahoo.com', 'charlie@gmail.com', 'david@outlook.com']
})
 
# Zeilen filtern, wo name 'Smith' enthält
filtered = df_text[df_text['name'].str.contains('Smith')]
print(filtered)
#          name           email
# 0  Alice Smith  alice@gmail.com
 
# Groß-/Kleinschreibung ignorieren
filtered = df_text[df_text['name'].str.contains('smith', case=False)]
print(filtered)
 
# Nach E-Mail-Domain filtern
filtered = df_text[df_text['email'].str.endswith('gmail.com')]
print(filtered)
#            name              email
# 0   Alice Smith    alice@gmail.com
# 2  Charlie Brown  charlie@gmail.com
 
# Mit Regex filtern
filtered = df_text[df_text['name'].str.match(r'^[A-C]')]
print(filtered)

    Null- und Nicht-Null-Werte Filtern

    Verwenden Sie .isna(), .notna(), .isnull() und .notnull(), um basierend auf fehlenden Daten zu filtern.

    # DataFrame mit fehlenden Werten erstellen
df_missing = pd.DataFrame({
    'A': [1, 2, np.nan, 4],
    'B': [5, np.nan, 7, 8],
    'C': [9, 10, 11, 12]
})
 
# Zeilen filtern, wo Spalte A nicht null ist
filtered = df_missing[df_missing['A'].notna()]
print(filtered)
#      A    B   C
# 0  1.0  5.0   9
# 1  2.0  NaN  10
# 3  4.0  8.0  12
 
# Zeilen filtern, wo IRGENDEINE Spalte null ist
filtered = df_missing[df_missing.isna().any(axis=1)]
print(filtered)
#      A    B   C
# 1  2.0  NaN  10
# 2  NaN  7.0  11
 
# Zeilen filtern, wo ALLE Spalten nicht null sind
filtered = df_missing[df_missing.notna().all(axis=1)]
print(filtered)
#      A    B   C
# 0  1.0  5.0   9
# 3  4.0  8.0  12

    Nach Datumsbereichen Filtern

    Bei der Arbeit mit Datetime-Spalten können Sie nach Datumsbereichen mit Standard-Vergleichsoperatoren filtern.

    # DataFrame mit Daten erstellen
df_dates = pd.DataFrame({
    'date': pd.date_range('2026-01-01', periods=10, freq='D'),
    'value': range(10)
})
 
# Daten nach einem bestimmten Datum filtern
filtered = df_dates[df_dates['date'] > '2026-01-05']
print(filtered)
 
# Datumsbereich filtern
start_date = '2026-01-03'
end_date = '2026-01-07'
filtered = df_dates[(df_dates['date'] >= start_date) & (df_dates['date'] <= end_date)]
print(filtered)
 
# .between() für Daten verwenden
filtered = df_dates[df_dates['date'].between('2026-01-03', '2026-01-07')]
print(filtered)

    Leistungsvergleich: Große DataFrames

    Verschiedene Filtermethoden haben unterschiedliche Leistungsmerkmale. Hier ist ein Vergleich für einen DataFrame mit 1 Million Zeilen:

    import time
 
# Großen DataFrame erstellen
np.random.seed(42)
df_large = pd.DataFrame({
    'A': np.random.randint(0, 100, 1000000),
    'B': np.random.randint(0, 100, 1000000),
    'C': np.random.choice(['X', 'Y', 'Z'], 1000000)
})
 
# Boolean Indexing
start = time.time()
result = df_large[(df_large['A'] > 50) & (df_large['B'] < 30)]
print(f"Boolean Indexing: {time.time() - start:.4f} Sekunden")
 
# .query()-Methode
start = time.time()
result = df_large.query('A > 50 and B < 30')
print(f".query()-Methode: {time.time() - start:.4f} Sekunden")
 
# .loc[]-Methode
start = time.time()
result = df_large.loc[(df_large['A'] > 50) & (df_large['B'] < 30)]
print(f".loc[]-Methode: {time.time() - start:.4f} Sekunden")

    Leistungserkenntnisse:

    • Boolean Indexing: Schnell für einfache Bedingungen, langsamer für komplexe Multi-Bedingung-Filter
    • .query(): Am schnellsten für große DataFrames mit mehreren Bedingungen (verwendet numexpr-Optimierung)
    • .loc[]: Ähnlich wie boolean Indexing, aber flexibler für Spaltenauswahl
    • .where(): Langsamer aufgrund vollständiger DataFrame-Durchquerung, nur verwenden, wenn Sie die Form beibehalten müssen

    Für Datensätze über 100.000 Zeilen mit mehreren Bedingungen übertrifft .query() typischerweise boolean Indexing um 20-40%.

    Häufige Fehler und Wie Man Sie Vermeidet

    Fehler 1: 'and' Statt '&' Verwenden

    # FALSCH - wirft ValueError
# filtered = df[df['age'] > 25 and df['city'] == 'NYC']
 
# RICHTIG
filtered = df[(df['age'] > 25) & (df['city'] == 'NYC')]

    Fehler 2: Klammern Vergessen

    # FALSCH - Probleme mit Operator-Vorrang
# filtered = df[df['age'] > 25 & df['city'] == 'NYC']
 
# RICHTIG - jede Bedingung umschließen
filtered = df[(df['age'] > 25) & (df['city'] == 'NYC')]

    Fehler 3: Original-DataFrame Ändern

    # Filtern erstellt eine Ansicht, keine Kopie
filtered = df[df['age'] > 30]
 
# FALSCH - SettingWithCopyWarning
# filtered['new_col'] = 100
 
# RICHTIG - explizite Kopie erstellen
filtered = df[df['age'] > 30].copy()
filtered['new_col'] = 100

    Fehler 4: String-Filterung Ohne NaN-Behandlung

    df_with_nan = pd.DataFrame({
    'name': ['Alice', np.nan, 'Charlie']
})
 
# FALSCH - wirft Fehler bei vorhandenem NaN
# filtered = df_with_nan[df_with_nan['name'].str.contains('li')]
 
# RICHTIG - NaN mit na-Parameter behandeln
filtered = df_with_nan[df_with_nan['name'].str.contains('li', na=False)]

    Gefilterte Daten mit PyGWalker Visualisieren

    Nach dem Filtern Ihres Pandas DataFrame hilft die Visualisierung der Ergebnisse, Muster und Erkenntnisse aufzudecken. PyGWalker (opens in a new tab) verwandelt gefilterte DataFrames direkt in Python-Notebooks in eine interaktive Tableau-ähnliche Oberfläche – keine Notwendigkeit, Daten zu exportieren oder komplexen Plotting-Code zu schreiben.

    PyGWalker ist besonders nützlich bei der Erkundung gefilterter Datensätze, da es Ihnen ermöglicht:

    • Spalten per Drag & Drop zu ziehen, um sofort Diagramme zu erstellen
    • Zusätzliche Filter visuell anzuwenden, ohne Code zu schreiben
    • Zwischen Diagrammtypen (Balken, Linie, Streuung, Heatmap) in Sekunden zu wechseln
    • Visualisierungen für Berichte oder Präsentationen zu exportieren
    import pygwalker as pyg
 
# DataFrame filtern
filtered_df = df[(df['age'] > 25) & (df['salary'] > 75000)]
 
# Interaktive Visualisierung starten
pyg.walk(filtered_df)

    Dies öffnet eine interaktive Oberfläche, in der Sie Visualisierungen erstellen können, indem Sie gefilterte Spalten in den Diagramm-Builder ziehen. Für Datenanalysten, die mit mehreren Filterbedingungen arbeiten, eliminiert PyGWalker den Iterationszyklus von filtern → plotten → anpassen → neu plotten.

    FAQ

    Wie filtere ich Pandas DataFrame-Zeilen nach Bedingung?

    Verwenden Sie boolean Indexing mit df[df['column'] > value] für einfache Bedingungen. Für mehrere Bedingungen verwenden Sie & (und), | (oder), ~ (nicht) mit Klammern: df[(df['A'] > 10) & (df['B'] < 20)]. Alternativ verwenden Sie .query() für lesbare Syntax: df.query('A > 10 and B < 20').

    Was ist der Unterschied zwischen .loc[] und boolean Indexing?

    Boolean Indexing (df[df['col'] > 5]) gibt alle Spalten für gefilterte Zeilen zurück. .loc[] ermöglicht gleichzeitige Spaltenauswahl: df.loc[df['col'] > 5, ['col1', 'col2']]. Beide Methoden haben ähnliche Leistung, aber .loc[] ist expliziter und unterstützt label-basierte Zeilenauswahl.

    Wie filtere ich Pandas DataFrame mit mehreren Bedingungen?

    Kombinieren Sie Bedingungen mit & (und), | (oder), ~ (nicht) Operatoren. Umschließen Sie jede Bedingung immer mit Klammern: df[(df['age'] > 25) & (df['city'] == 'NYC') | (df['salary'] > 80000)]. Für komplexe Bedingungen verwenden Sie .query(): df.query('age > 25 and (city == "NYC" or salary > 80000)').

    Wann sollte ich .query() statt boolean Indexing verwenden?

    Verwenden Sie .query() für große DataFrames (>100k Zeilen) mit mehreren Bedingungen – es ist 20-40% schneller aufgrund der numexpr-Optimierung. Es ist auch lesbarer für komplexe Bedingungen. Verwenden Sie boolean Indexing für einfache Filter oder wenn Sie maximale Kompatibilität benötigen (.query() erfordert String-Ausdrücke, die schwerer zu debuggen sind).

    Wie filtere ich Zeilen, bei denen der Spaltenwert in einer Liste ist?

    Verwenden Sie die .isin()-Methode: df[df['city'].isin(['NYC', 'LA', 'Chicago'])]. Für die Umkehrung (nicht in Liste) verwenden Sie den ~-Operator: df[~df['city'].isin(['NYC', 'LA'])]. Dies ist effizienter als das Verketten mehrerer |-Bedingungen für große Listen.

    Fazit

    Das Filtern von Pandas DataFrame-Zeilen ist eine grundlegende Fähigkeit für die Datenanalyse in Python. Sie verstehen jetzt fünf Filtermethoden: boolean Indexing für Einfachheit, .query() für Leistung, .loc[] für flexible Spaltenauswahl, .where() für Wertersetzung und .filter() für Spaltennamen-Muster.

    Wichtige Erkenntnisse:

    • Verwenden Sie boolean Indexing für schnelle, lesbare Filter auf kleinen bis mittleren Datensätzen
    • Wählen Sie .query() für große Datensätze mit komplexen Bedingungen (20-40% schneller)
    • Wenden Sie .loc[] an, wenn Sie sowohl Zeilenfilterung als auch Spaltenauswahl benötigen
    • Denken Sie daran, &, |, ~ Operatoren statt and, or, not zu verwenden
    • Umschließen Sie Bedingungen immer mit Klammern, um Probleme mit Operator-Vorrang zu vermeiden

    Meistern Sie diese Filtertechniken und Sie werden jedes Datenauswahl-Szenario effizient handhaben. Für die interaktive Erkundung gefilterter Daten erwägen Sie die Verwendung von PyGWalker, um Ihre Ergebnisse zu visualisieren, ohne zusätzlichen Plotting-Code zu schreiben.

    📚
      Pandas Where: Harnessing the Power of Pandas to Manage Null ValuesPandas read_csv() Tutorial: CSV-Dateien wie ein Profi importieren