Pandas & NumPy Academy · Lektion

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.

Lektion 1 von 413 Schritte

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      NaN

isna() 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())  # True

Mit 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.com

Fehlende 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: int64

Prozentsatz 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: float64

Zusammenfassungstabelle 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  float64

Anzahl 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              3

Zeilen 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  NaN

Eine 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())         # False

Fehlende 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      float64

Schnelltest

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().

Kostenlos starten

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

  1. Fehlende Werte erkennen
  2. Fehlende Werte entfernen
  3. Fehlende Werte auffüllen
  4. Interpolation und fortgeschrittene Imputation
← Zurück zu Pandas & NumPy Academy