Fehlende Werte auffüllen
Ersetzen Sie NaN mit fillna() und dessen Parameter method durch eine Konstante, den Spaltenmittelwert, Vorwärts- oder Rückwärtsauffüllen.
Fehlende Werte auffüllen ist eine kostenlose Pandas & NumPy Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Pandas & NumPy Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Pandas & NumPy Academy-Kurs umfasst insgesamt 4 Lektionen.
Einführung in fillna()
Imputation bezeichnet das Ersetzen fehlender Werte durch einen sinnvollen Ersatzwert, anstatt die Zeile zu entfernen. Pandas fillna() ist das wichtigste Werkzeug dafür: Es ersetzt jedes NaN in einer Series oder einem DataFrame durch einen von Ihnen festgelegten Wert. Im Gegensatz zum Entfernen bleiben bei der Imputation alle Zeilen erhalten. Das ist besonders wichtig, wenn nur wenige Daten vorhanden sind oder das Muster der fehlenden Werte aussagekräftig ist.
Die einfachste Form übergibt einen Skalar: df['col'].fillna(0).
import pandas as pd
import numpy as np
df = pd.DataFrame({
'product': ['A', 'B', 'C', 'D'],
'price': [10.0, np.nan, 30.0, np.nan]
})
# Fill all NaN in 'price' with 0
filled = df['price'].fillna(0)
print(filled)
# 0 10.0
# 1 0.0
# 2 30.0
# 3 0.0Auffüllen mit Mittelwert oder Median einer Spalte
Das Auffüllen mit dem Mittelwert einer Spalte (bei symmetrischen Verteilungen) oder mit dem Median (bei schiefen Verteilungen) ist eine der häufigsten Imputationsstrategien. Diese statistischen Kennzahlen beschreiben die zentrale Tendenz der Daten und minimieren daher die Verzerrung der Spaltenverteilung. Berechnen Sie die Kennzahl immer auf der Trainingspartition, um Data Leakage zu vermeiden.
import pandas as pd
import numpy as np
df = pd.DataFrame({
'salary': [50000, np.nan, 70000, 80000, np.nan, 60000]
})
mean_salary = df['salary'].mean()
median_salary = df['salary'].median()
df['salary_mean_filled'] = df['salary'].fillna(mean_salary)
df['salary_median_filled'] = df['salary'].fillna(median_salary)
print(df)
# salary salary_mean_filled salary_median_filled
# 0 50000.0 50000.0 50000.0
# 1 NaN 65000.0 65000.0
# 2 70000.0 70000.0 70000.0Auffüllen kategorialer Spalten mit dem Modus
Bei kategorialen Spalten sind Mittelwert oder Median nicht sinnvoll. Verwenden Sie stattdessen den Modus – den am häufigsten vorkommenden Wert. Series.mode()[0] gibt den häufigsten Wert zurück; [0] behandelt den Fall, dass mehrere Modi vorhanden sind.
import pandas as pd
import numpy as np
df = pd.DataFrame({
'status': ['active', 'inactive', None, 'active', None, 'active']
})
most_common = df['status'].mode()[0]
print('Mode:', most_common) # active
df['status'] = df['status'].fillna(most_common)
print(df['status'].tolist())
# ['active', 'inactive', 'active', 'active', 'active', 'active']Vorwärts auffüllen mit ffill()
Beim Vorwärtsauffüllen (auch Last-Observation-Carried-Forward, LOCF genannt) wird der letzte gültige Wert (also ein Wert, der nicht NaN ist) vorwärts übertragen, um nachfolgende NaN-Positionen aufzufüllen. Diese Methode eignet sich ideal für Zeitreihendaten, bei denen ein Messwert bis zu seiner Aktualisierung konstant bleibt – etwa Gerätestatus, Preisniveaus oder Sensormesswerte, die sich nur bei bestimmten Ereignissen ändern.
import pandas as pd
import numpy as np
price = pd.Series(
[100, np.nan, np.nan, 105, np.nan, 110],
index=pd.date_range('2024-01', periods=6, freq='ME')
)
filled = price.ffill()
print(filled)
# 2024-01-31 100.0
# 2024-02-29 100.0
# 2024-03-31 100.0
# 2024-04-30 105.0
# 2024-05-31 105.0
# 2024-06-30 110.0Rückwärts auffüllen mit bfill()
Beim Rückwärtsauffüllen (Next-Observation-Carried-Backward, NOCB) wird der nächste gültige Wert rückwärts übertragen, um vorhergehende NaN-Positionen aufzufüllen. Das ist nützlich, wenn zukünftige Daten fehlende Werte aus der Vergangenheit ergänzen – etwa wenn Sie Monatsenddaten erhalten und die Tage dieses Monats vor Eintreffen des Berichts rückwirkend auffüllen müssen.
import pandas as pd
import numpy as np
df = pd.DataFrame({'value': [np.nan, np.nan, 3, np.nan, 5]})
print(df['value'].bfill())
# 0 3.0
# 1 3.0
# 2 3.0
# 3 5.0
# 4 5.0
# dtype: float64Der Parameter limit für Vorwärts- und Rückwärtsauffüllen
Sowohl ffill() als auch bfill() akzeptieren den Parameter limit, der festlegt, wie viele aufeinanderfolgende NaN-Werte aufgefüllt werden. Das ist wichtig, wenn Sie einen Wert nur über eine kurze Lücke hinweg übertragen möchten – lange Lücken sollten NaN bleiben, um anzuzeigen, dass die Daten tatsächlich fehlen und nicht nur verspätet vorliegen.
import pandas as pd
import numpy as np
s = pd.Series([1.0, np.nan, np.nan, np.nan, 5.0])
# Fill only the first NaN gap, leave the rest
print(s.ffill(limit=1))
# 0 1.0
# 1 1.0 <- filled
# 2 NaN <- still NaN (limit reached)
# 3 NaN
# 4 5.0Unterschiedliches Auffüllen verschiedener Spalten
In einem realen DataFrame benötigen verschiedene Spalten möglicherweise unterschiedliche Auffüllstrategien. Übergeben Sie fillna() ein Dictionary, dessen Schlüssel Spaltennamen und dessen Werte die einzusetzenden Werte sind. So wenden Sie spaltenspezifische Imputation in einem einzigen Aufruf an, was übersichtlicher ist als mehrere aufeinanderfolgende einzelne fillna-Aufrufe.
import pandas as pd
import numpy as np
df = pd.DataFrame({
'age': [25, np.nan, 30],
'income': [50000, np.nan, 70000],
'country': ['USA', np.nan, 'UK']
})
fill_values = {
'age': df['age'].median(),
'income': df['income'].mean(),
'country': 'Unknown'
}
filled = df.fillna(fill_values)
print(filled)
# age income country
# 0 25.0 50000.0 USA
# 1 27.5 60000.0 Unknown
# 2 30.0 70000.0 UKGruppenbasierte Imputation
Eine anspruchsvollere Strategie besteht darin, NaN-Werte mit dem Gruppenmittelwert oder -median statt mit dem Gesamtmittelwert der Spalte aufzufüllen. Beispielsweise können Sie ein fehlendes Gehalt mit dem Median für die jeweilige Berufskategorie ersetzen. Dadurch bleibt die Struktur der Untergruppen erhalten und die Imputation ist realistischer als bei einer globalen Kennzahl.
import pandas as pd
import numpy as np
df = pd.DataFrame({
'dept': ['Eng', 'Eng', 'HR', 'HR', 'Eng'],
'salary': [90000, np.nan, 50000, np.nan, 110000]
})
# Fill salary NaN with the median salary for each department
df['salary'] = df.groupby('dept')['salary'].transform(
lambda x: x.fillna(x.median())
)
print(df)
# dept salary
# 0 Eng 90000.0
# 1 Eng 100000.0 <- group median (90k+110k)/2
# 2 HR 50000.0
# 3 HR 50000.0
# 4 Eng 110000.0Auffüllen mit einem konstanten Platzhalterwert
Manchmal ist ein Platzhalterwert die richtige Imputation, der „unbekannt“ statt einer tatsächlichen Messung signalisiert. Beispiele sind -1 für ein unbekanntes Alter, 'N/A' für eine unbekannte Kategorie oder False für ein unbekanntes boolesches Flag. Platzhalterwerte sind sinnvoll, wenn nachgelagerter Code ausdrücklich auf sie prüft und sie anders als echte Daten behandelt.
import pandas as pd
import numpy as np
df = pd.DataFrame({
'user_id': [1, 2, 3],
'referral_source': ['email', np.nan, 'ad'],
'trial_days': [14, np.nan, 7]
})
df['referral_source'] = df['referral_source'].fillna('unknown')
df['trial_days'] = df['trial_days'].fillna(-1).astype(int)
print(df)
# user_id referral_source trial_days
# 0 1 email 14
# 1 2 unknown -1
# 2 3 ad 7fillna() in einer Pipeline verketten
Wie alle Pandas-Methoden gibt fillna() einen neuen DataFrame zurück und lässt sich problemlos in eine Methodenkette integrieren. Ein Aufruf von .fillna() nach .dropna() wendet eine zweistufige Strategie an: Zuerst werden Zeilen entfernt, in denen wichtige Spalten fehlen, anschließend werden die übrigen optionalen NaN-Werte mit sinnvollen Standardwerten aufgefüllt – alles in einer übersichtlichen Pipeline.
import pandas as pd
import numpy as np
df = pd.DataFrame({
'user_id': [1, None, 3, 4],
'score': [88, 95, np.nan, 76],
'label': ['A', 'B', None, 'D']
})
cleaned = (
df
.dropna(subset=['user_id'])
.fillna({'score': df['score'].mean(), 'label': 'Unknown'})
)
print(cleaned)
# user_id score label
# 0 1.0 88.0 A
# 2 3.0 86.3 Unknown
# 3 4.0 76.0 DÜberprüfen, dass keine NaN-Werte verbleiben
Überprüfen Sie nach der Imputation immer, dass in den Zielspalten keine NaN-Werte mehr vorhanden sind. Rufen Sie df.isna().sum() auf oder stellen Sie sicher, dass die Anzahl null ist. Eine unerwartete Anzahl ungleich null bedeutet, dass Ihre fillna-Logik einen Fall nicht abgedeckt hat – möglicherweise hatte eine Spalte einen Datentyp, der das Auffüllen verhindert hat, oder Sie haben eine Spalte in Ihrem Dictionary vergessen.
import pandas as pd
import numpy as np
df = pd.DataFrame({'a': [1.0, np.nan, 3.0], 'b': [np.nan, 2.0, 3.0]})
filled = df.fillna(0)
# Verify
assert filled.isna().sum().sum() == 0, 'Some NaN remain!'
print('All NaN filled successfully')
print(filled.isna().sum())
# a 0
# b 0
# dtype: int64Schnelltest
Testen Sie Ihr Verständnis zum Auffüllen fehlender Werte in Pandas.
Zusammenfassung der Lektion
In dieser Lektion haben Sie gelernt: fillna(scalar) ersetzt alle NaN durch eine Konstante, fillna(mean/median) führt eine Imputation mit Spaltenstatistiken durch und ffill()/bfill() übertragen benachbarte Werte in Zeitreihen. Übergeben Sie fillna() ein Dictionary, um spaltenspezifische Strategien festzulegen, und verwenden Sie groupby().transform() für gruppenbasierte Imputation. Als Nächstes behandeln wir Interpolation und die Frage, wann fortgeschrittene Imputationstechniken sinnvoll sind.
Häufig gestellte Fragen
Ist die Lektion „Fehlende Werte auffüllen“ kostenlos?
Ja — der vollständige Text von „Fehlende Werte auffüllen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Pandas & NumPy Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Pandas & NumPy Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Fehlende Werte auffüllen“?
Ersetzen Sie NaN mit fillna() und dessen Parameter method durch eine Konstante, den Spaltenmittelwert, Vorwärts- oder Rückwärtsauffüllen. Du übst Pandas & NumPy Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um Pandas & NumPy Academy zu starten?
Keine Vorkenntnisse erforderlich. Pandas & NumPy Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.
Wie lange dauert die Lektion „Fehlende Werte auffüllen“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser Pandas & NumPy Academy-Lektion Code schreiben und ausführen?
Ja. Jede Pandas & NumPy Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Fehlende Werte erkennen
- Fehlende Werte entfernen
- Fehlende Werte auffüllen
- Interpolation und fortgeschrittene Imputation