Skip to content

Pandas Spalte entfernen: So löschen Sie Spalten aus einem DataFrame

Soren Atelier
Name
Soren Atelier

Updated on

DataFrames aus realen Quellen enthalten selten nur die Spalten, die Sie benötigen. CSV-Exporte enthalten Metadaten-Spalten, Datenbankabfragen ziehen zusätzliche Felder und API-Antworten enthalten verschachtelte Daten, die Sie bereits abgeflacht haben. Vor jeder sinnvollen Analyse müssen Sie die irrelevanten Spalten entfernen. Wenn Sie dabei einen Fehler machen -- versehentlich die falsche Spalte löschen oder den Original-DataFrame ändern, wenn Sie eine Kopie erstellen wollten -- entstehen Datenverlust-Bugs, die schwer nachzuverfolgen sind.

Pandas bietet mehrere Methoden zum Entfernen von Spalten, die jeweils für unterschiedliche Situationen geeignet sind. Die Methode drop() ist die vielseitigste, aber del, pop() und Spaltenauswahl bieten nützliche Alternativen. Diese Anleitung behandelt jeden Ansatz mit klaren Beispielen, die zeigen, wann Sie welchen verwenden sollten.

📚

    df.drop() verwenden -- Der Standardansatz

    Die Methode drop() ist die primäre Art, Spalten zu entfernen. Übergeben Sie Spaltennamen und setzen Sie axis=1 (oder verwenden Sie den Parameter columns).

    Eine einzelne Spalte entfernen

    import pandas as pd
 
df = pd.DataFrame({
    'name': ['Alice', 'Bob', 'Charlie'],
    'age': [25, 30, 35],
    'salary': [50000, 60000, 70000],
    'department': ['Engineering', 'Marketing', 'Sales'],
})
 
# Methode 1: columns-Parameter verwenden (empfohlen)
df_clean = df.drop(columns=['salary'])
print(df_clean)
 
# Methode 2: axis=1 verwenden
df_clean = df.drop('salary', axis=1)

    Mehrere Spalten entfernen

    import pandas as pd
 
df = pd.DataFrame({
    'id': [1, 2, 3],
    'name': ['Alice', 'Bob', 'Charlie'],
    'email': ['a@test.com', 'b@test.com', 'c@test.com'],
    'temp_col': [None, None, None],
    'internal_id': ['X1', 'X2', 'X3'],
})
 
# Mehrere Spalten auf einmal entfernen
df_clean = df.drop(columns=['temp_col', 'internal_id', 'email'])
print(df_clean)
#    id     name
# 0   1    Alice
# 1   2      Bob
# 2   3  Charlie

    Der Parameter inplace

    Standardmäßig gibt drop() einen neuen DataFrame zurück. Verwenden Sie inplace=True, um das Original zu ändern:

    import pandas as pd
 
df = pd.DataFrame({'a': [1], 'b': [2], 'c': [3]})
 
# Gibt neuen DataFrame zurück (Original unverändert)
new_df = df.drop(columns=['b'])
print(df.columns.tolist())      # ['a', 'b', 'c'] (unverändert)
print(new_df.columns.tolist())  # ['a', 'c']
 
# Ändert den Original-DataFrame
df.drop(columns=['b'], inplace=True)
print(df.columns.tolist())  # ['a', 'c']

    Fehlende Spalten mit dem Parameter errors behandeln

    import pandas as pd
 
df = pd.DataFrame({'a': [1], 'b': [2], 'c': [3]})
 
# Standard: löst KeyError aus, wenn Spalte nicht existiert
# df.drop(columns=['d'])  # KeyError: "['d'] not found in axis"
 
# Fehlende Spalten ignorieren
df_clean = df.drop(columns=['b', 'd'], errors='ignore')
print(df_clean.columns.tolist())  # ['a', 'c']

    Die del-Anweisung verwenden

    Die del-Anweisung entfernt eine Spalte direkt (in-place). Sie ist kompakt, aber auf eine Spalte pro Aufruf beschränkt.

    import pandas as pd
 
df = pd.DataFrame({'a': [1, 2], 'b': [3, 4], 'c': [5, 6]})
 
del df['b']
print(df.columns.tolist())  # ['a', 'c']

    Einschränkungen: Kann nicht mehrere Spalten gleichzeitig löschen. Kann fehlende Spalten nicht ignorieren (löst KeyError aus). Ändert immer direkt (in-place).

    df.pop() verwenden

    pop() entfernt eine Spalte und gibt sie als Series zurück. Nützlich, wenn Sie die entfernte Spalte weiterverwenden möchten.

    import pandas as pd
 
df = pd.DataFrame({
    'name': ['Alice', 'Bob'],
    'target': [1, 0],
    'feature1': [10, 20],
    'feature2': [30, 40],
})
 
# Zielspalte extrahieren und gleichzeitig aus DataFrame entfernen
y = df.pop('target')
X = df
 
print(y)
# 0    1
# 1    0
# Name: target, dtype: int64
 
print(X)
#     name  feature1  feature2
# 0  Alice        10        30
# 1    Bob        20        40

    Spalten auswählen (Umkehrung des Entfernens)

    Manchmal ist es einfacher, die gewünschten Spalten auszuwählen, anstatt die zu entfernenden aufzulisten.

    import pandas as pd
 
df = pd.DataFrame({
    'name': ['Alice', 'Bob'],
    'age': [25, 30],
    'salary': [50000, 60000],
    'dept': ['Eng', 'Mkt'],
    'internal_id': ['X1', 'X2'],
})
 
# Nur bestimmte Spalten behalten
df_clean = df[['name', 'age', 'salary']]
 
# Spalten durch Auswahl von allem außer ihnen entfernen
df_clean = df.loc[:, df.columns != 'internal_id']
 
# Spalten nach Bedingung behalten
df_numeric = df.select_dtypes(include='number')
print(df_numeric)
#    age  salary
# 0   25   50000
# 1   30   60000

    Spalten nach Muster oder Bedingung entfernen

    Spalten nach Namensmuster entfernen

    import pandas as pd
 
df = pd.DataFrame({
    'name': ['Alice'], 'age': [25],
    'temp_1': [None], 'temp_2': [None],
    'internal_flag': [True],
})
 
# Spalten entfernen, die mit 'temp_' beginnen
cols_to_drop = [c for c in df.columns if c.startswith('temp_')]
df_clean = df.drop(columns=cols_to_drop)
print(df_clean.columns.tolist())  # ['name', 'age', 'internal_flag']
 
# Spalten entfernen, die 'internal' enthalten
cols_to_drop = [c for c in df.columns if 'internal' in c]
df_clean = df.drop(columns=cols_to_drop)
 
# filter() verwenden, um passende Spalten zu behalten
df_temps = df.filter(like='temp')  # Behält nur Spalten mit 'temp'
df_no_temps = df.drop(columns=df.filter(like='temp').columns)

    Spalten nach Datentyp entfernen

    import pandas as pd
 
df = pd.DataFrame({
    'name': ['Alice', 'Bob'],
    'age': [25, 30],
    'score': [95.5, 87.3],
    'active': [True, False],
})
 
# Alle nicht-numerischen Spalten entfernen
df_numeric = df.select_dtypes(include='number')
 
# Alle Object-Spalten (String) entfernen
df_no_strings = df.select_dtypes(exclude='object')
print(df_no_strings.columns.tolist())  # ['age', 'score', 'active']

    Spalten mit zu vielen fehlenden Werten entfernen

    import pandas as pd
import numpy as np
 
df = pd.DataFrame({
    'a': [1, 2, 3, 4, 5],
    'b': [1, np.nan, np.nan, np.nan, np.nan],
    'c': [1, 2, np.nan, 4, 5],
    'd': [np.nan, np.nan, np.nan, np.nan, np.nan],
})
 
# Spalten entfernen, bei denen mehr als 50% der Werte fehlen
threshold = len(df) * 0.5
df_clean = df.dropna(axis=1, thresh=int(threshold))
print(df_clean.columns.tolist())  # ['a', 'c']

    Methodenvergleich

    MethodeRückgabeIn-PlaceMehrere SpaltenUmgang mit fehlenden Spalten
    df.drop(columns=...)Neuer DataFrameOptional (inplace)Jaerrors='ignore'
    del df[col]NichtsImmerNein (einzeln)Löst KeyError aus
    df.pop(col)Entfernte SeriesImmerNein (einzeln)Löst KeyError aus
    df[cols_to_keep]Neuer DataFrameNeinJa (invers)Löst KeyError aus
    df.select_dtypes()Neuer DataFrameNeinNach DatentypN/A

    Ihren bereinigten DataFrame visualisieren

    Nach dem Entfernen von Spalten und der Bereinigung Ihrer Daten bietet PyGWalker (opens in a new tab) eine interaktive Tableau-ähnliche Oberfläche, um den bereinigten DataFrame direkt in Jupyter zu erkunden:

    import pygwalker as pyg
 
# Nach der Bereinigung Ihres DataFrames
walker = pyg.walk(df_clean)

    So können Sie verbleibende Spalten per Drag-and-Drop in Diagramme ziehen, ohne Plotting-Code schreiben zu müssen.

    FAQ

    Wie entferne ich eine Spalte in Pandas?

    Verwenden Sie df.drop(columns=['spaltenname']), um eine Spalte zu entfernen und einen neuen DataFrame zurückzugeben. Für In-Place-Entfernung fügen Sie inplace=True hinzu. Sie können auch del df['spaltenname'] für eine schnelle In-Place-Löschung verwenden, oder df.pop('spaltenname'), um die Spalte zu entfernen und als Series zurückzugeben.

    Wie entferne ich mehrere Spalten auf einmal?

    Übergeben Sie eine Liste von Spaltennamen an df.drop(columns=['col1', 'col2', 'col3']). Dies entfernt alle angegebenen Spalten in einem einzigen Vorgang und gibt einen neuen DataFrame zurück.

    Wie entferne ich Spalten bedingt (nach Muster oder Datentyp)?

    Für Namensmuster verwenden Sie List Comprehension: df.drop(columns=[c for c in df.columns if c.startswith('temp_')]). Für Datentypen verwenden Sie df.select_dtypes(exclude='object'), um String-Spalten zu entfernen, oder df.select_dtypes(include='number'), um nur numerische Spalten zu behalten.

    Was ist der Unterschied zwischen drop() und del zum Entfernen von Spalten?

    df.drop() gibt standardmäßig einen neuen DataFrame zurück, kann mehrere Spalten gleichzeitig verarbeiten und hat eine Option errors='ignore' für fehlende Spalten. del df[col] ändert immer in-place, funktioniert nur mit einer Spalte gleichzeitig und löst KeyError aus, wenn die Spalte nicht existiert.

    Wie entferne ich Spalten mit fehlenden Werten?

    Verwenden Sie df.dropna(axis=1), um jede Spalte mit mindestens einem NaN zu entfernen. Verwenden Sie df.dropna(axis=1, thresh=n), um nur Spalten mit mindestens n Nicht-Null-Werten zu behalten. Für benutzerdefinierte Schwellenwerte filtern Sie nach dem Prozentsatz der Nullwerte: df.loc[:, df.isnull().mean() < 0.5] behält Spalten mit weniger als 50% fehlenden Daten.

    Fazit

    Für die meisten Situationen ist df.drop(columns=[...]) die richtige Wahl -- es ist explizit, verarbeitet mehrere Spalten und gibt standardmäßig einen neuen DataFrame zurück. Verwenden Sie del für schnelle In-Place-Einzelspaltenlöschung, pop(), wenn Sie die entfernte Spalte benötigen, und Spaltenauswahl oder select_dtypes(), wenn es einfacher ist anzugeben, was Sie behalten möchten, als was Sie entfernen möchten.

    📚