Fehlende Werte erkennen
Verwenden Sie isna(), notna() und isnull(), um NaN-Positionen in einer Series oder einem DataFrame zu finden und fehlende Werte pro Spalte zu zählen.
Fehlende Werte erkennen ist eine kostenlose Pandas & NumPy Academy-Lektion auf CoddyKit. Dies ist Lektion 1 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.
Was sind fehlende Werte in Pandas?
In Pandas wird ein fehlender Wert in numerischen Spalten als NaN (Not a Number) und in Datetime-Spalten als None oder pd.NaT dargestellt. Fehlende Daten sind in realen Datensätzen häufig, weil Datensätze unvollständig sein können, Sensoren ausfallen oder Joins nicht zugeordneten Zeilen erzeugen können. Das Erkennen fehlender Werte ist immer der erste Schritt in einem Data-Cleaning-Workflow.
Pandas normalisiert None, float('nan') und numpy.nan in numerischen Spalten auf dieselbe interne NaN-Darstellung.
import pandas as pd
import numpy as np
df = pd.DataFrame({
'name': ['Alice', None, 'Carol'],
'age': [25, np.nan, 30],
'salary': [50000.0, 60000.0, np.nan]
})
print(df)
# name age salary
# 0 Alice 25.0 50000.0
# 1 None NaN 60000.0
# 2 Carol 30.0 NaNisna() und isnull()
isna() und isnull() sind vollständig identisch – beide geben einen DataFrame oder eine Series mit derselben Form zurück, die überall dort True und an den übrigen Stellen False enthält, wo ein Wert fehlt. Pandas stellt beide Namen ausschließlich aus Gründen der persönlichen Präferenz bereit. Das Ergebnis kann direkt als boolesche Maske zum Filtern oder für weitere Berechnungen verwendet werden.
import pandas as pd
import numpy as np
df = pd.DataFrame({
'A': [1, np.nan, 3],
'B': [np.nan, 2, np.nan]
})
print(df.isna())
# A B
# 0 False True
# 1 True False
# 2 False True
# Both are identical
print((df.isna() == df.isnull()).all().all()) # TrueMit notna() vorhandene Werte finden
notna() (auch als notnull() bezeichnet) ist das Gegenteil von isna() – die Methode gibt dort True zurück, wo Werte vorhanden sind, und dort False, wo sie fehlen. Das ist nützlich, wenn Sie auf Zeilen filtern möchten, die in einer wichtigen Spalte einen Wert enthalten, etwa wenn ein Primärschlüssel oder eine Zielvariable nicht NaN sein darf.
import pandas as pd
import numpy as np
df = pd.DataFrame({
'id': [1, 2, 3],
'email': ['a@x.com', None, 'c@x.com']
})
# Keep only rows where email is present
with_email = df[df['email'].notna()]
print(with_email)
# id email
# 0 1 a@x.com
# 2 3 c@x.comFehlende Werte pro Spalte zählen
Wenn Sie .isna().sum() auf einem DataFrame aufrufen, werden die True-Werte (die dem Wert 1 entsprechen) spaltenweise addiert. Dadurch erhalten Sie die Anzahl fehlender Werte pro Spalte. Das ist der wichtigste erste Schritt, um die Qualität eines neuen Datensatzes zu beurteilen – Sie sehen, welche Spalten Aufmerksamkeit benötigen.
import pandas as pd
import numpy as np
df = pd.DataFrame({
'name': ['Alice', None, 'Carol', None],
'age': [25, np.nan, 30, 22],
'salary': [50000, 60000, np.nan, np.nan]
})
missing_counts = df.isna().sum()
print(missing_counts)
# name 2
# age 1
# salary 2
# dtype: int64Prozentsatz fehlender Werte pro Spalte
Eine absolute Anzahl von NaN-Werten ist weniger aussagekräftig als der Prozentsatz fehlender Werte, da sie mit der Größe des Datensatzes skaliert. Wenn Sie isna().sum() durch die Gesamtzahl der Zeilen teilen (oder isna().mean() aufrufen), erhalten Sie den Anteil fehlender Werte, den Sie für einen Prozentsatz mit 100 multiplizieren können. Spalten mit mehr als 30–50 % fehlenden Werten erfordern häufig eine Entscheidung darüber, ob sie überhaupt beibehalten werden sollen.
import pandas as pd
import numpy as np
df = pd.DataFrame({
'A': [1, np.nan, 3, np.nan, 5],
'B': [np.nan, 2, np.nan, 4, 5],
'C': [1, 2, 3, 4, 5]
})
missing_pct = (df.isna().mean() * 100).round(1)
print(missing_pct)
# A 40.0
# B 40.0
# C 0.0
# dtype: float64Zusammenfassungstabelle fehlender Werte
Ein häufig verwendetes EDA-Muster ist eine Zusammenfassungstabelle fehlender Werte, die Anzahl, Prozentsatz und dtype für jede Spalte in einer Ansicht zeigt. Dadurch erhalten Sie ein vollständiges Bild der Datenqualität, bevor Sie Bereinigungsentscheidungen treffen. Sie können die Tabelle sortieren, um zuerst die problematischsten Spalten anzuzeigen.
import pandas as pd
import numpy as np
df = pd.DataFrame({
'col_a': [1, np.nan, 3],
'col_b': [np.nan, np.nan, 3],
'col_c': [1, 2, 3]
})
summary = pd.DataFrame({
'missing_count': df.isna().sum(),
'missing_pct': (df.isna().mean() * 100).round(1),
'dtype': df.dtypes
}).sort_values('missing_pct', ascending=False)
print(summary)
# missing_count missing_pct dtype
# col_b 2 66.7 float64
# col_a 1 33.3 float64
# col_c 0 0.0 float64Anzahl fehlender Werte pro Zeile
Sie können fehlende Werte auch pro Zeile zählen, indem Sie isna().sum(axis=1) aufrufen. So lassen sich Datensätze identifizieren, die größtenteils leer sind (z. B. unvollständige Umfrageantworten) und die Sie möglicherweise als Ganzes markieren oder entfernen möchten. Eine Zeile mit vielen fehlenden Werten unterscheidet sich grundlegend von verstreut fehlenden Werten auf Spaltenebene.
import pandas as pd
import numpy as np
df = pd.DataFrame({
'a': [1, np.nan, np.nan],
'b': [np.nan, 2, np.nan],
'c': [3, 4, np.nan]
})
# Count NaN per row
df['missing_count'] = df.isna().sum(axis=1)
print(df)
# a b c missing_count
# 0 1.0 NaN 3.0 1
# 1 NaN 2.0 4.0 1
# 2 NaN NaN NaN 3Zeilen mit beliebigen oder ausschließlich fehlenden Werten filtern
Verwenden Sie df[df.isna().any(axis=1)], um Zeilen mit mindestens einem NaN-Wert zu finden, oder df[df.isna().all(axis=1)], um Zeilen zu finden, in denen jeder Wert NaN ist. Mit diesen Filtern können Sie problematische Datensätze zur Prüfung isolieren, bevor Sie entscheiden, wie damit verfahren werden soll.
import pandas as pd
import numpy as np
df = pd.DataFrame({
'x': [1, np.nan, np.nan],
'y': [2, 3, np.nan],
'z': [4, 5, np.nan]
})
# Rows with at least one NaN
has_any_nan = df[df.isna().any(axis=1)]
print('Any NaN:\n', has_any_nan)
# Rows where all values are NaN
all_nan = df[df.isna().all(axis=1)]
print('All NaN:\n', all_nan)
# x y z
# 2 NaN NaN NaNEine bestimmte Spalte auf NaN prüfen
Für eine schnelle Plausibilitätsprüfung einer einzelnen Spalte rufen Sie df['col'].isna().sum() auf oder verwenden Sie df['col'].isna().any(), um einen einzelnen booleschen Wert zu erhalten (True, wenn irgendein NaN vorhanden ist). Diese Einzeiler eignen sich für Datenvalidierungsprüfungen oder Protokollanweisungen in einer Pipeline.
import pandas as pd
import numpy as np
df = pd.DataFrame({'price': [10.0, np.nan, 30.0, np.nan, 50.0]})
print('NaN count in price:', df['price'].isna().sum()) # 2
print('Any NaN in price?', df['price'].isna().any()) # True
print('All present?', df['price'].notna().all()) # FalseFehlende Werte mit einer Heatmap visualisieren
Bei Datensätzen mit vielen Spalten ist eine Heatmap fehlender Werte aussagekräftiger als eine Zahlentabelle. Mit Seaborn können Sie eine solche Heatmap einfach erstellen: Je dunkler eine Zelle ist, desto mehr fehlende Daten enthält die betreffende Kombination aus Spalte und Zeile. Die beliebte Drittanbieterbibliothek missingno bietet spezielle Visualisierungen für fehlende Werte.
import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
np.random.seed(0)
df = pd.DataFrame(
np.where(np.random.rand(20, 5) > 0.7, np.nan, np.random.randn(20, 5)),
columns=['A', 'B', 'C', 'D', 'E']
)
# Heatmap of missing values
sns.heatmap(df.isna(), cbar=False, yticklabels=False)
plt.title('Missing Value Pattern')
plt.tight_layout()
plt.savefig('missing_heatmap.png')
print('Saved missing_heatmap.png')info() für eine schnelle Prüfung fehlender Werte
df.info() gibt eine kompakte Zusammenfassung aus, die für jede Spalte die Anzahl nicht nuller Werte enthält. Das ist der schnellste Weg, um fehlende Werte in einem neuen Datensatz zu erkennen: Jede Spalte, deren Anzahl nicht nuller Werte kleiner als die Gesamtzahl der Zeilen ist, enthält NaN-Werte. Außerdem werden dtype und Speicherverbrauch angezeigt.
import pandas as pd
import numpy as np
df = pd.DataFrame({
'id': [1, 2, 3, 4, 5],
'age': [25, np.nan, 30, np.nan, 22],
'salary': [50000, 60000, np.nan, 70000, 80000]
})
df.info()
# <class 'pandas.core.frame.DataFrame'>
# RangeIndex: 5 entries, 0 to 4
# Data columns (total 3 columns):
# # Column Non-Null Count Dtype
# --- ------ -------------- -----
# 0 id 5 non-null int64
# 1 age 3 non-null float64
# 2 salary 4 non-null float64Schnelltest
Testen Sie Ihr Verständnis des Erkennens fehlender Werte in Pandas.
Zusammenfassung der Lektion
In dieser Lektion haben Sie gelernt: isna() und isnull() sind identisch und geben boolesche Masken der Positionen fehlender Werte zurück, isna().sum() zählt NaN pro Spalte, und isna().mean()*100 liefert den Prozentsatz fehlender Werte. Verwenden Sie df.info() für einen schnellen Überblick und isna().any(axis=1), um Zeilen mit mindestens einem NaN zu finden. Als Nächstes beschäftigen Sie sich mit dem Entfernen fehlender Werte mithilfe von dropna().
Lerne Python mit einem KI-Tutor — kostenlos
Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.
- Kurse
- 30
- Lektionen
- 120
Häufig gestellte Fragen
Ist die Lektion „Fehlende Werte erkennen“ kostenlos?
Ja — der vollständige Text von „Fehlende Werte erkennen“ 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 erkennen“?
Verwenden Sie isna(), notna() und isnull(), um NaN-Positionen in einer Series oder einem DataFrame zu finden und fehlende Werte pro Spalte zu zählen. 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 1 von 4.
Wie lange dauert die Lektion „Fehlende Werte erkennen“?
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