Pandas fillna(): Fehlende Werte in DataFrames behandeln

Name

Soren Atelier

Updated on 10.2.2026

Fehlende Werte sind der stille Saboteur der Datenanalyse. Ein einziges NaN, das sich in einer kritischen Spalte versteckt, kann dazu führen, dass eine Aggregation NaN zurückgibt, ein Machine-Learning-Modell beim Training einen Fehler wirft oder ein Dashboard-Diagramm eine leere Lücke anzeigt, wo eigentlich eine Trendlinie sein sollte. Reale Datensätze enthalten fast immer Lücken -- Sensordaten fallen aus, Umfrageteilnehmer überspringen Fragen, API-Antworten liefern Null-Felder und CSV-Exporte kommen mit leeren Zellen an. Die Frage ist nie, ob Sie auf fehlende Daten stoßen werden, sondern wie Sie damit umgehen.

Die Pandas-Methode fillna() ist das primäre Werkzeug zum Ersetzen fehlender Werte durch etwas Sinnvolles. Dieser Leitfaden behandelt jeden Parameter, demonstriert gängige Füllstrategien (Skalar, Dictionary, Forward Fill, Backward Fill, Mittelwert/Median/Modus), vergleicht fillna() mit dropna() und interpolate() und zeigt, wie man diese Operationen in eine saubere Datenpipeline verkettet. Jedes Codebeispiel ist kopierfähig mit erwarteter Ausgabe.

Fehlende Werte erkennen, bevor sie gefüllt werden

Bevor Sie irgendetwas füllen, müssen Sie wissen, wo die Lücken sind. Pandas bietet drei Erkennungsfunktionen:

import pandas as pd
import numpy as np
 
df = pd.DataFrame({
    'name': ['Alice', 'Bob', None, 'Diana', 'Eve'],
    'age': [28, np.nan, 35, np.nan, 42],
    'salary': [55000, 62000, np.nan, 48000, np.nan]
})
 
# isna() gibt True für fehlende Werte zurück (Alias: isnull())
print(df.isna())

Ausgabe:

    name    age  salary
0  False  False   False
1  False   True   False
2   True  False    True
3  False   True   False
4  False  False    True

Schnelle Zusammenfassung der fehlenden Werte

# Fehlende Werte pro Spalte zählen
print(df.isna().sum())

Ausgabe:

name      1
age       2
salary    2
dtype: int64

notna() für die inverse Prüfung

# notna() gibt True für nicht-fehlende Werte zurück
print(df.notna().sum())

Ausgabe:

name      4
age       3
salary    3
dtype: int64

Diese Funktionen arbeiten sowohl mit DataFrames als auch mit einzelnen Series. Verwenden Sie sie, um Ihre Daten zu prüfen, bevor Sie sich für eine Füllstrategie entscheiden.

Einfaches fillna() mit einem Skalarwert

Die einfachste Verwendung von fillna() ersetzt jedes NaN im DataFrame durch einen einzelnen Wert:

import pandas as pd
import numpy as np
 
df = pd.DataFrame({
    'product': ['Widget', 'Gadget', 'Gizmo'],
    'price': [19.99, np.nan, 29.99],
    'stock': [100, 50, np.nan]
})
 
print("Vorher:")
print(df)
 
df_filled = df.fillna(0)
 
print("\nNach fillna(0):")
print(df_filled)

Ausgabe:

Vorher:
  product  price  stock
0  Widget  19.99  100.0
1  Gadget    NaN   50.0
2   Gizmo  29.99    NaN

Nach fillna(0):
  product  price  stock
0  Widget  19.99  100.0
1  Gadget   0.00   50.0
2   Gizmo  29.99    0.0

Das funktioniert, aber eine Preisspalte mit 0 zu füllen ist irreführend -- es suggeriert, das Produkt sei kostenlos. Für String-Spalten könnten Sie mit "Unbekannt" füllen. Der Schlüssel ist die Wahl eines Füllwerts, der für jede Spalte semantisch sinnvoll ist.

Vollständige Methodensignatur

DataFrame.fillna(value=None, method=None, axis=None, inplace=False, limit=None)

fillna() mit einem Dictionary: Verschiedene Werte pro Spalte

In den meisten realen Datensätzen repräsentiert jede Spalte eine andere Art von Messung, und ein einzelner Füllwert ergibt nicht überall Sinn. Übergeben Sie ein Dictionary an fillna(), um spaltenweise Füllwerte festzulegen:

import pandas as pd
import numpy as np
 
df = pd.DataFrame({
    'name': ['Alice', None, 'Charlie', 'Diana'],
    'age': [28, 34, np.nan, 45],
    'department': ['Engineering', 'Sales', None, 'Marketing'],
    'salary': [75000, np.nan, 68000, np.nan]
})
 
fill_values = {
    'name': 'Unknown',
    'age': df['age'].median(),
    'department': 'Unassigned',
    'salary': df['salary'].mean()
}
 
df_filled = df.fillna(fill_values)
print(df_filled)

Ausgabe:

      name   age   department   salary
0    Alice  28.0  Engineering  75000.0
1  Unknown  34.0        Sales  71500.0
2  Charlie  34.0   Unassigned  68000.0
3    Diana  45.0    Marketing  71500.0

Dies ist der empfohlene Ansatz für Produktionsdatenpipelines, da er Ihnen explizite Kontrolle darüber gibt, was jede Spalte erhält.

Forward Fill (ffill) und Backward Fill (bfill)

Zeitreihendaten und geordnete Datensätze profitieren oft von propagierungsbasiertem Füllen. Forward Fill überträgt den letzten bekannten Wert nach vorne; Backward Fill nimmt den nächsten bekannten Wert nach hinten.

import pandas as pd
import numpy as np
 
df = pd.DataFrame({
    'date': pd.date_range('2026-01-01', periods=7, freq='D'),
    'temperature': [22.1, np.nan, np.nan, 24.5, np.nan, 26.0, np.nan]
})
 
print("Original:")
print(df)
 
print("\nForward Fill (ffill):")
print(df.fillna(method='ffill'))
 
print("\nBackward Fill (bfill):")
print(df.fillna(method='bfill'))

Ausgabe:

Original:
        date  temperature
0 2026-01-01         22.1
1 2026-01-02          NaN
2 2026-01-03          NaN
3 2026-01-04         24.5
4 2026-01-05          NaN
5 2026-01-06         26.0
6 2026-01-07          NaN

Forward Fill (ffill):
        date  temperature
0 2026-01-01         22.1
1 2026-01-02         22.1
2 2026-01-03         22.1
3 2026-01-04         24.5
4 2026-01-05         24.5
5 2026-01-06         26.0
6 2026-01-07         26.0

Backward Fill (bfill):
        date  temperature
0 2026-01-01         22.1
1 2026-01-02         24.5
2 2026-01-03         24.5
3 2026-01-04         24.5
4 2026-01-05         26.0
5 2026-01-06         26.0
6 2026-01-07          NaN

Beachten Sie, dass Backward Fill die letzte Zeile als NaN belässt, da kein nachfolgender Wert vorhanden ist. Sie können beide Methoden kombinieren, um alle Lücken zu schließen:

df_filled = df.fillna(method='ffill').fillna(method='bfill')
print(df_filled)

Ab Pandas 2.1 können Sie auch die eigenständigen Methoden df.ffill() und df.bfill() direkt verwenden, die Kurzformen für fillna(method='ffill') und fillna(method='bfill') sind.

Propagierung mit limit begrenzen

Wenn ein Sensor tagelang ausfällt, kann unbegrenztes Forward-Filling echte Datenlücken verbergen. Der Parameter limit begrenzt, wie viele aufeinanderfolgende NaNs gefüllt werden:

import pandas as pd
import numpy as np
 
s = pd.Series([1.0, np.nan, np.nan, np.nan, 5.0])
 
print("limit=1:")
print(s.fillna(method='ffill', limit=1))
 
print("\nlimit=2:")
print(s.fillna(method='ffill', limit=2))

Ausgabe:

limit=1:
0    1.0
1    1.0
2    NaN
3    NaN
4    5.0
dtype: float64

limit=2:
0    1.0
1    1.0
2    1.0
3    NaN
4    5.0
dtype: float64

Dies ist entscheidend für Zeitreihendaten, bei denen Sie kleine Lücken füllen, aber längere Ausfälle zur manuellen Überprüfung markieren möchten.

fillna() mit Mittelwert, Median und Modus

Statistische Imputation ersetzt fehlende Werte durch eine zusammenfassende Statistik, die aus den nicht-fehlenden Werten der jeweiligen Spalte berechnet wird. Dies ist die häufigste Strategie für numerische Features, bevor Daten in ein Modell eingespeist werden:

import pandas as pd
import numpy as np
 
df = pd.DataFrame({
    'math_score': [85, np.nan, 92, 78, np.nan, 88],
    'reading_score': [np.nan, 76, 81, np.nan, 90, 85],
    'grade': ['A', 'B', 'A', np.nan, 'B', np.nan]
})
 
# Numerische Spalten mit ihrem Spaltenmittelwert füllen
df['math_score'] = df['math_score'].fillna(df['math_score'].mean())
df['reading_score'] = df['reading_score'].fillna(df['reading_score'].median())
 
# Kategoriale Spalte mit Modus (häufigster Wert) füllen
df['grade'] = df['grade'].fillna(df['grade'].mode()[0])
 
print(df)

Ausgabe:

   math_score  reading_score grade
0       85.00          83.00     A
1       85.75          76.00     B
2       92.00          81.00     A
3       78.00          83.00     A
4       85.75          90.00     B
5       88.00          85.00     A

Für Machine-Learning-Pipelines sollten Sie sklearn.impute.SimpleImputer in Betracht ziehen, der sich in scikit-learn-Pipelines integriert und die Imputation bei Train/Test-Splits korrekt handhabt.

interpolate() für numerische Daten

Wenn Daten einem Trend folgen (Aktienkurse, Sensordaten, Wachstumsmetriken), schätzt interpolate() fehlende Werte basierend auf den umgebenden Datenpunkten, anstatt eine flache Füllung zu verwenden:

import pandas as pd
import numpy as np
 
df = pd.DataFrame({
    'day': range(1, 8),
    'revenue': [1000, np.nan, np.nan, 1600, np.nan, 2000, np.nan]
})
 
df['fillna_ffill'] = df['revenue'].fillna(method='ffill')
df['interpolated'] = df['revenue'].interpolate(method='linear')
 
print(df)

Ausgabe:

   day  revenue  fillna_ffill  interpolated
0    1   1000.0        1000.0        1000.0
1    2      NaN        1000.0        1200.0
2    3      NaN        1000.0        1400.0
3    4   1600.0        1600.0        1600.0
4    5      NaN        1600.0        1800.0
5    6   2000.0        2000.0        2000.0
6    7      NaN        2000.0        2000.0

Beachten Sie, wie interpolate() eine glatte lineare Progression (1000, 1200, 1400, 1600, 1800, 2000) erzeugt, während ffill flache Plateaus bildet. Pandas unterstützt mehrere Interpolationsmethoden:

Verwenden Sie interpolate(), wenn die Daten eine natürliche Ordnung und einen Trend haben. Verwenden Sie fillna(), wenn Sie einen bekannten Ersatzwert haben oder propagierungsbasiertes Füllen benötigen.

Der Parameter inplace

Wie die meisten Pandas-Methoden gibt fillna() standardmäßig einen neuen DataFrame zurück. Das Setzen von inplace=True ändert das Original:

import pandas as pd
import numpy as np
 
df = pd.DataFrame({'a': [1, np.nan, 3], 'b': [np.nan, 5, 6]})
 
# Methode 1: Zuweisung (empfohlen)
df_new = df.fillna(0)
print(f"Original unverändert: {df.isna().sum().sum()} NaNs")
print(f"Neue Kopie: {df_new.isna().sum().sum()} NaNs")
 
# Methode 2: inplace (ändert das Original)
df.fillna(0, inplace=True)
print(f"Nach inplace: {df.isna().sum().sum()} NaNs")

Ausgabe:

Original unverändert: 2 NaNs
Neue Kopie: 0 NaNs
Nach inplace: 0 NaNs

Die moderne Best Practice in Pandas bevorzugt Zuweisung gegenüber inplace=True, da Zuweisung natürlich in Methodenketten funktioniert und den Datenfluss explizit macht.

Vergleich: fillna() vs dropna() vs interpolate()

Die Wahl der richtigen Strategie für fehlende Daten hängt von Ihrem Datensatz, dem Muster der Fehlwerte und Ihrem nachgelagerten Anwendungsfall ab. Hier ist ein Seite-an-Seite-Vergleich:

Faustregel für die Entscheidung:

1. Wenn weniger als 5% der Zeilen fehlen und die Daten vollständig zufällig fehlen, ist dropna() sicher.
2. Wenn Sie einen sinnvollen Standard haben oder eine vernünftige Statistik berechnen können, verwenden Sie fillna().
3. Wenn die Daten geordnet und numerisch mit einem Trend sind, verwenden Sie interpolate().

fillna() für bestimmte Spalten

Sie möchten nicht immer den gesamten DataFrame füllen. Wenden Sie fillna() auf einzelne Spalten oder eine Teilmenge an:

import pandas as pd
import numpy as np
 
df = pd.DataFrame({
    'city': ['NYC', None, 'LA', None, 'Chicago'],
    'temperature': [32.1, np.nan, 75.3, np.nan, 28.5],
    'humidity': [45, 60, np.nan, np.nan, 55]
})
 
# Nur die Stadtspalte füllen
df['city'] = df['city'].fillna('Unknown')
 
# Nur die Temperaturspalte mit ihrem Mittelwert füllen
df['temperature'] = df['temperature'].fillna(df['temperature'].mean())
 
# Luftfeuchtigkeit-NaNs vorerst unberührt lassen
print(df)

Ausgabe:

      city  temperature  humidity
0      NYC    32.100000      45.0
1  Unknown    45.300000      60.0
2       LA    75.300000       NaN
3  Unknown    45.300000       NaN
4  Chicago    28.500000      55.0

Dieser selektive Ansatz ist wichtig, wenn verschiedene Spalten unterschiedliche Behandlung erfordern -- oder wenn einige fehlende Werte beabsichtigt sind (z.B. könnte Luftfeuchtigkeit für Innenmessungen nicht relevant sein).

fillna() mit anderen Operationen verketten

Pandas-Methodenverkettung ermöglicht lesbare Datenpipelines. fillna() passt natürlich in diese Ketten:

import pandas as pd
import numpy as np
 
raw = pd.DataFrame({
    'customer_id': [101, 102, 101, 103, 102, 104],
    'purchase': [25.0, np.nan, 30.0, np.nan, 15.0, np.nan],
    'channel': ['web', 'store', None, 'web', None, 'store']
})
 
result = (
    raw
    .fillna({'purchase': 0, 'channel': 'unknown'})
    .drop_duplicates(subset=['customer_id'], keep='first')
    .sort_values('customer_id')
    .reset_index(drop=True)
)
 
print(result)

Ausgabe:

   customer_id  purchase  channel
0          101      25.0      web
1          102       0.0    store
2          103       0.0      web
3          104       0.0    store

Diese Pipeline füllt fehlende Werte, dedupliziert nach Kunden-ID, sortiert und setzt den Index in einem einzigen lesbaren Ausdruck zurück.

Praxisnahe Pipeline: Verkaufsdaten bereinigen

Hier ist eine realistischere Kette, die mehrere Bereinigungsschritte kombiniert:

import pandas as pd
import numpy as np
 
sales = pd.DataFrame({
    'date': ['2026-01-01', '2026-01-02', '2026-01-03', '2026-01-04', '2026-01-05'],
    'product': ['Widget', None, 'Widget', 'Gadget', None],
    'units': [10, np.nan, 15, np.nan, 8],
    'unit_price': [9.99, 9.99, np.nan, 14.99, np.nan],
    'region': ['East', 'East', None, 'West', 'West']
})
 
clean = (
    sales
    .assign(date=lambda d: pd.to_datetime(d['date']))
    .fillna({
        'product': 'Unknown',
        'region': 'Unassigned',
        'units': sales['units'].median(),
        'unit_price': sales['unit_price'].median()
    })
    .assign(total=lambda d: d['units'] * d['unit_price'])
    .sort_values('date')
    .reset_index(drop=True)
)
 
print(clean)

Ausgabe:

        date  product  units  unit_price      region   total
0 2026-01-01   Widget   10.0        9.99        East   99.90
1 2026-01-02  Unknown   10.0        9.99        East   99.90
2 2026-01-03   Widget   15.0        9.99  Unassigned  149.85
3 2026-01-04   Gadget   10.0       14.99        West  149.90
4 2026-01-05  Unknown    8.0        9.99        West   79.92

Die assign()-Aufrufe erstellen oder transformieren Spalten, fillna() behandelt die Lücken, und die Kette fließt von oben nach unten in logischer Reihenfolge.

Fehlende Datenmuster mit PyGWalker visualisieren

Bevor Sie eine Füllstrategie wählen, hilft es zu sehen, wo die fehlenden Werte konzentriert sind. Sind sie zufällig verstreut, in bestimmten Spalten gehäuft oder mit bestimmten Zeiträumen korreliert? Visuelle Inspektion offenbart oft Muster, die zusammenfassende Statistiken übersehen.

PyGWalker (opens in a new tab) ist eine Open-Source-Python-Bibliothek, die jeden Pandas DataFrame in eine interaktive, Tableau-ähnliche Visualisierungsoberfläche direkt in Jupyter Notebook verwandelt. Sie können Spalten auf Achsen ziehen, Diagrammtypen wechseln und Daten mit Klicks filtern, anstatt Matplotlib-Boilerplate zu schreiben.

import pandas as pd
import pygwalker as pyg
 
# Laden Sie Ihre Daten und markieren Sie fehlende Muster
df = pd.read_csv('your_data.csv')
 
# Spalte hinzufügen, die fehlende Werte pro Zeile zählt
df['missing_count'] = df.isna().sum(axis=1)
 
# Interaktiven Explorer starten
walker = pyg.walk(df)

In der PyGWalker-Oberfläche können Sie Balkendiagramme erstellen, die die Anzahl fehlender Werte pro Spalte zeigen, Heatmaps, die offenbaren, welche Zeilen die meisten Lücken haben, und Streudiagramme, um zu prüfen, ob Fehlwerte mit anderen Variablen korrelieren. Diese Art der visuellen Prüfung ändert oft, welche Füllstrategie Sie wählen.

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

FAQ

Was ist der Unterschied zwischen fillna() und dropna()?

fillna() ersetzt fehlende Werte durch einen von Ihnen angegebenen Wert und behält alle Zeilen bei. dropna() entfernt ganze Zeilen (oder Spalten), die fehlende Werte enthalten. Verwenden Sie fillna(), wenn Sie einen vernünftigen Ersatzwert haben und Ihre Zeilenanzahl beibehalten möchten. Verwenden Sie dropna(), wenn die fehlenden Zeilen wenige sind und Imputation eine inakzeptable Verzerrung einführen würde.

Kann ich NaN-Werte mit dem Mittelwert einer Spalte füllen?

Ja. Verwenden Sie df['column'] = df['column'].fillna(df['column'].mean()). Dies berechnet den Mittelwert aus den nicht-fehlenden Werten und füllt jedes NaN in dieser Spalte mit dem Ergebnis. Für schiefe Daten ist median() oft die bessere Wahl, da er weniger von extremen Ausreißern beeinflusst wird.

Was macht der Parameter limit in fillna()?

Der Parameter limit begrenzt die maximale Anzahl aufeinanderfolgender NaN-Werte, die gefüllt werden. Zum Beispiel füllt df.fillna(method='ffill', limit=2) höchstens 2 aufeinanderfolgende Lücken per Forward Fill. Jede längere Folge fehlender Werte wird nur teilweise gefüllt, wobei die verbleibenden Lücken als NaN erhalten bleiben. Dies ist nützlich für Zeitreihendaten, bei denen Sie kurze Lücken füllen, aber längere Ausfälle markieren möchten.

Wie fülle ich NaN mit verschiedenen Werten für verschiedene Spalten?

Übergeben Sie ein Dictionary an fillna(), wobei die Schlüssel Spaltennamen und die Werte die Füllwerte sind: df.fillna({'age': 0, 'name': 'Unknown', 'salary': df['salary'].median()}). Jede Spalte erhält ihren eigenen Füllwert, und Spalten, die nicht im Dictionary aufgeführt sind, bleiben unverändert.

Ändert fillna() den ursprünglichen DataFrame?

Nein, standardmäßig gibt fillna() einen neuen DataFrame zurück und das Original bleibt unverändert. Um das Original zu ändern, verwenden Sie entweder Zuweisung (df = df.fillna(0)) oder übergeben Sie inplace=True. Der Zuweisungsansatz wird empfohlen, da er mit Methodenverkettung funktioniert und den Datenfluss explizit macht.

Fazit

Fehlende Werte sind in realen Daten unvermeidlich. Die Pandas-Methode fillna() gibt Ihnen präzise Kontrolle darüber, wie Sie damit umgehen:

• Verwenden Sie skalares fillna für einfache, einheitliche Ersetzungen im gesamten DataFrame.
• Verwenden Sie Dictionary fillna, um verschiedene Füllstrategien pro Spalte anzuwenden -- das häufigste Muster in Produktionscode.
• Verwenden Sie Forward Fill (ffill) und Backward Fill (bfill) für geordnete und Zeitreihendaten, bei denen die Propagierung bekannter Werte sinnvoll ist.
• Verwenden Sie Mittelwert, Median oder Modus für statistische Imputation numerischer und kategorialer Spalten.
• Verwenden Sie interpolate(), wenn die Daten einem natürlichen Trend folgen und Sie glatte geschätzte Werte anstelle von flachen Füllungen wünschen.
• Verwenden Sie den limit-Parameter, um zu verhindern, dass propagierungsbasierte Methoden übermäßig lange Lücken füllen.
• Bevorzugen Sie Zuweisung gegenüber inplace=True für saubereren, besser lesbaren Code.
• Erkennen und prüfen Sie immer fehlende Werte mit isna() und notna(), bevor Sie eine Füllstrategie wählen.

Sobald Ihre fehlenden Werte behandelt sind, können Sie mit Tools wie PyGWalker (opens in a new tab) die bereinigten Daten interaktiv erkunden, ohne Diagrammcode zu schreiben -- so können Sie überprüfen, ob Ihre Fülllogik sinnvolle Ergebnisse liefert, und direkt mit der Analyse fortfahren.