Python
Demystifizierung von Pandas' NaN: Ein Leitfaden für Anfänger

Demystifizierung von Pandas' NaN: Ein Leitfaden für Anfänger

MoeNagy Dev

Grundlagen von pandas.isnull() und pandas.isna() verstehen

Erkunden des Konzepts von pandas is nan

Was ist pandas.isnull() und pandas.isna()?

Die Funktionen pandas.isnull() und pandas.isna() werden verwendet, um fehlende Werte in einem pandas DataFrame oder einer Series zu identifizieren. Diese Funktionen geben eine boolesche Maske mit der gleichen Form wie die Eingabe zurück, wobei True einen fehlenden Wert und False einen nicht fehlenden Wert angibt.

Hier ist ein Beispiel:

import pandas as pd
 
# Ein Beispiel DataFrame erstellen
df = pd.DataFrame({'A': [1, 2, None, 4], 'B': [5, None, 7, 8]})
 
# Nach fehlenden Werten suchen
print(df.isnull())
#       A     B
# 0  False False
# 1  False  True
# 2   True False
# 3  False False

In dem obigen Beispiel gibt die Methode df.isnull() ein boolesches DataFrame zurück, das das Vorhandensein von fehlenden Werten in jeder Zelle angibt.

Den Unterschied zwischen pandas.isnull() und pandas.isna() verstehen

Die Funktionen pandas.isnull() und pandas.isna() sind im Wesentlichen gleich und können ohne Unterschied verwendet werden. Beide Funktionen dienen demselben Zweck, fehlende Werte in einem DataFrame oder einer Series zu identifizieren.

Der Hauptunterschied besteht darin, dass pandas.isna() eine modernere und empfohlene Methode zur Überprüfung auf fehlende Werte ist, da sie eine bessere Unterstützung für die Behandlung verschiedener Datentypen bietet, einschließlich der NaN-Werte von NumPy, None von Python und der eigenen fehlenden Wertindikatoren von Pandas.

In den meisten Fällen können Sie pandas.isna() anstelle von pandas.isnull() ohne Probleme verwenden. Wenn Sie jedoch die Kompatibilität mit älteren Versionen von Pandas aufrechterhalten müssen, sollten Sie pandas.isnull() verwenden.

Umgang mit fehlenden Daten mit pandas is nan

Nachdem Sie die fehlenden Werte mit pandas.isnull() oder pandas.isna() identifiziert haben, können Sie verschiedene Methoden verwenden, um sie zu behandeln. Einige häufige Techniken sind:

  1. Ersetzen fehlender Werte: Sie können fehlende Werte durch einen bestimmten Wert oder einen auf Grundlage der Daten berechneten Wert ersetzen.
df['A'] = df['A'].fillna(0)  # Fehlende Werte in der Spalte 'A' durch 0 ersetzen
  1. Löschen von Zeilen oder Spalten mit fehlenden Werten:
df = df.dropna(subset=['A', 'B'])  # Zeilen mit beliebigen fehlenden Werten in den Spalten 'A' oder 'B' löschen
  1. Imputation von fehlenden Werten: Sie können verschiedene Imputationsverfahren wie Mittelwert, Median oder Modus-Imputation verwenden, um die fehlenden Werte zu füllen.
from sklearn.impute import SimpleImputer
imputer = SimpleImputer(strategy='mean')
df[['A', 'B']] = imputer.fit_transform(df[['A', 'B']])
  1. Interpolation von fehlenden Werten: Bei Zeitreihendaten können Sie Interpolation verwenden, um fehlende Werte basierend auf den umgebenden Datenpunkten zu schätzen.
df = df.interpolate()  # Fehlende Werte im DataFrame interpolieren

Anwendung von pandas.isnull() und pandas.isna() in der Datenmanipulation

Identifizierung fehlender Werte in einem DataFrame

Sie können die Funktionen pandas.isnull() oder pandas.isna() verwenden, um fehlende Werte in einem DataFrame zu identifizieren:

import pandas as pd
 
# Ein Beispiel DataFrame erstellen
df = pd.DataFrame({'A': [1, 2, None, 4], 'B': [5, None, 7, 8]})
 
# Nach fehlenden Werten suchen
print(df.isnull())
#       A     B
# 0  False False
# 1  False  True
# 2   True False
# 3  False False

Das resultierende boolesche DataFrame gibt das Vorhandensein von fehlenden Werten in jeder Zelle an.

Behandlung von fehlenden Werten mit pandas.isnull() und pandas.isna()

Sie können die boolesche Maske, die von pandas.isnull() oder pandas.isna() zurückgegeben wird, verwenden, um verschiedene Operationen auf dem DataFrame durchzuführen, z.B.:

  1. Ersetzen fehlender Werte:
df['A'] = df['A'].fillna(0)
df['B'] = df['B'].fillna(df['B'].mean())
  1. Löschen von Zeilen oder Spalten mit fehlenden Werten:
df = df.dropna(subset=['A', 'B'])  # Zeilen mit beliebigen fehlenden Werten in den Spalten 'A' oder 'B' löschen
df = df.dropna(how='all')  # Zeilen löschen, in denen alle Werte fehlen
df = df.dropna(axis=1)  # Spalten löschen, in denen beliebige fehlende Werte vorhanden sind
  1. Imputation von fehlenden Werten:
from sklearn.impute import SimpleImputer
imputer = SimpleImputer(strategy='mean')
df[['A', 'B']] = imputer.fit_transform(df[['A', 'B']])

Ersetzen fehlender Werte durch einen bestimmten Wert

Sie können fehlende Werte durch einen bestimmten Wert mit der Methode fillna() ersetzen:

# Fehlende Werte in der Spalte 'A' durch 0 ersetzen
df['A'] = df['A'].fillna(0)
 
# Fehlende Werte in der Spalte 'B' durch den Mittelwert der Spalte ersetzen
df['B'] = df['B'].fillna(df['B'].mean())

Löschen von Zeilen oder Spalten mit fehlenden Werten

Sie können Zeilen oder Spalten mit fehlenden Werten mit der Methode dropna() löschen:

# Zeilen mit beliebigen fehlenden Werten in den Spalten 'A' oder 'B' löschen
df = df.dropna(subset=['A', 'B'])
 
# Zeilen löschen, in denen alle Werte fehlen
df = df.dropna(how='all')
 
# Spalten löschen, in denen beliebige fehlende Werte vorhanden sind
df = df.dropna(axis=1)

Fortgeschrittene Techniken mit pandas is nan

Kombination von pandas.isnull() und pandas.isna() mit anderen DataFrame-Methoden

Sie können die Funktionen pandas.isnull() oder pandas.isna() mit anderen DataFrame-Methoden kombinieren, um komplexere Operationen durchzuführen. Sie können sie zum Beispiel bei bedingter Filterung, Datenkonvertierung und mehr verwenden.

# Zeilen mit fehlenden Werten in der Spalte 'A' filtern
filtered_df = df[df['A'].isnull()]
 
# Fehlende Werte in der Spalte 'B' mit dem Median der nicht fehlenden Werte in dieser Spalte füllen
df['B'] = df['B'].fillna(df['B'].median())
 
# Eine neue Spalte erstellen, die das Vorhandensein von fehlenden Werten in der Spalte 'A' anzeigt
df['has_missing_A'] = df['A'].isnull()

Bedingte Filterung basierend auf fehlenden Werten

Sie können die boolesche Maske, die von pandas.isnull() oder pandas.isna() zurückgegeben wird, verwenden, um bedingte Filterung auf Ihrem DataFrame durchzuführen:

# Filtern von Zeilen mit fehlenden Werten in Spalte 'A'
filtered_df = df[df['A'].isnull()]
 
# Filtern von Zeilen mit nicht fehlenden Werten in Spalte 'B'
non_missing_df = df[~df['B'].isnull()]

Auffüllen von fehlenden Werten mit verschiedenen Techniken

Neben der einfachen Wertersetzung können Sie fortgeschrittenere Techniken verwenden, um fehlende Werte zu ergänzen, wie z.B.:

  1. Mittelwert/Median/Modus-Ergänzung:
from sklearn.impute import SimpleImputer
imputer = SimpleImputer(strategy='mean')
df[['A', 'B']] = imputer.fit_transform(df[['A', 'B']])
  1. KNN-Ergänzung:
from fancyimpute import KNNImputer
imputer = KNNImputer(n_neighbors=5)
df[['A', 'B']] = imputer.fit_transform(df[['A', 'B']])
  1. Iterative Ergänzung:
from sklearn.experimental import enable_iterative_imputer
from sklearn.impute import IterativeImputer
imputer = IterativeImputer()
df[['A', 'B']] = imputer.fit_transform(df[['A', 'B']])

Diese fortgeschrittenen Ergänzungstechniken können besonders nützlich sein, wenn es um komplexere Muster von fehlenden Daten oder voneinander abhängige Merkmale geht.

Erkunden spezifischer Anwendungsfälle von pandas isnull

Datenreinigung und -vorverarbeitung mit pandas isnull

Einer der Hauptanwendungsfälle für pandas.isnull() und pandas.isna() liegt im Bereich der Datenreinigung und -vorverarbeitung in einer Datenanalyse oder einem maschinellen Lernmodell. Diese Funktionen helfen Ihnen dabei, fehlende Werte zu identifizieren und damit umzugehen, was ein wichtiger Schritt zur Sicherstellung der Qualität und Zuverlässigkeit Ihrer Daten ist.

Hier ist ein Beispiel, wie Sie pandas.isna() verwenden können, um einen Datensatz zu reinigen und vorzubereiten:

import pandas as pd
 
# Datensatz laden
df = pd.read_csv('datensatz.csv')
 
# Fehlende Werte identifizieren
fehlende_werte = df.isna().sum()
print(fehlende_werte)
 
# Zeilen mit fehlenden Werten in irgendeiner Spalte entfernen
df = df.dropna()
 
# Fehlende Werte in der Spalte 'Alter' mit dem Median auffüllen
df['alter'] = df['alter'].fillna(df['alter'].median())
 
# Eine neue Spalte erstellen, die das Vorhandensein von fehlenden Werten in der Spalte 'Einkommen' angibt
df['hat_fehlendes_einkommen'] = df['einkommen'].isna()

In diesem Beispiel werden zunächst mit df.isna().sum() die Anzahl der fehlenden Werte in jeder Spalte identifiziert. Anschließend werden Zeilen mit fehlenden Werten in irgendeiner Spalte entfernt und die fehlenden Werte in der Spalte 'alter' mit dem Median aufgefüllt. Schließlich wird eine neue Spalte erstellt, die das Vorhandensein von fehlenden Werten in der Spalte 'einkommen' angibt.

Umgang mit fehlenden Werten in Zeitreihendaten

Bei der Arbeit mit Zeitreihendaten ist der Umgang mit fehlenden Werten besonders herausfordernd. pandas.isnull() und pandas.isna() können zusammen mit anderen zeitreihe-spezifischen Funktionen verwendet werden, um fehlende Werte in solchen Datensätzen zu behandeln.

import pandas as pd
 
# Beispielhaften DataFrame für Zeitreihendaten erstellen
df = pd.DataFrame({'A': [1, 2, None, 4, 5], 'B': [5, None, 7, 8, 9]},
                  index=pd.date_range('2022-01-01', periods=5, freq='D'))
 
# Fehlende Werte identifizieren
print(df.isna())
#             A     B
# 2022-01-01 False False
# 2022-01-02 False  True
# 2022-01-03  True False
# 2022-01-04 False False
# 2022-01-05 False False
 
# Fehlende Werte interpolieren
df = df.interpolate()
print(df)
#             A    B
# 2022-01-01  1  5.0
# 2022-01-02  2  6.0
# 2022-01-03  3  7.0
# 2022-01-04  4  8.0
# 2022-01-05  5  9.0

In diesem Beispiel wird ein beispielhafter DataFrame für Zeitreihendaten mit fehlenden Werten erstellt. Mit der Methode interpolate() werden die fehlenden Werte basierend auf den umliegenden Datenpunkten geschätzt.

Umgang mit fehlenden Werten in maschinellen Lernmodellen

Fehlende Werte können sich erheblich auf die Leistung von maschinellen Lernmodellen auswirken. pandas.isnull() und pandas.isna() können verwendet werden, um fehlende Werte zu identifizieren und damit umzugehen, bevor die Daten in ein maschinelles Lernmodell eingespeist werden.

import pandas as pd
from sklearn.impute import SimpleImputer
from sklearn.linear_model import LinearRegression
 
# Datensatz laden
df = pd.read_csv('datensatz.csv')
 
# Fehlende Werte identifizieren
fehlende_werte = df.isna().sum()
print(fehlende_werte)
 
# Fehlende Werte mit Mean-Imputation ergänzen
imputer = SimpleImputer(strategy='mean')
X = imputer.fit_transform(df.drop('ziel', axis=1))
y = df['ziel']
 
# Ein lineares Regressionsmodell trainieren
modell = LinearRegression()
modell.fit(X, y)

In diesem Beispiel werden zunächst die fehlenden Werte im Datensatz mit df.isna().sum() identifiziert. Anschließend werden die fehlenden Werte mithilfe des SimpleImputer aus scikit-learn und dem Mittelwert jeder Variable ergänzt. Schließlich wird ein lineares Regressionsmodell auf den ergänzten Daten trainiert.

Der Umgang mit fehlenden Werten ist ein entscheidender Schritt bei der Vorbereitung von Daten für maschinelle Lernmodelle, da viele Modelle fehlende Werte nicht direkt verarbeiten können. Durch die Verwendung von pandas.isnull() und pandas.isna() können Sie sicherstellen, dass die fehlenden Werte richtig gehandhabt werden.

Funktionen

Die Standardbibliothek von Python bietet eine große Auswahl an integrierten Modulen, die Sammlungen von Funktionen, Klassen und Variablen sind. Sie können auch Ihre eigenen Module und Pakete erstellen, um Ihren Code zu organisieren und wiederverwendbarer zu machen.

Hier ist ein Beispiel, wie man ein einfaches Modul erstellt:

# my_module.py
def greet(name):
    """
    Begrüßt die Person mit dem angegebenen Namen.
 
    Args:
        name (str): Der Name der zu begrüßenden Person.
 
    Returns:
        str: Die Begrüßungsnachricht.
    """
    return f"Hallo, {name}!"

Um das Modul zu verwenden, können Sie es in einer anderen Python-Datei importieren:

# main.py
import my_module
 
gruß = my_module.greet("Alice")
print(gruß)  # Ausgabe: Hallo, Alice!

Pakete sind Sammlungen von Modulen, die in Verzeichnisse organisiert sind. Sie ermöglichen es Ihnen, verwandte Module zu gruppieren und eine hierarchische Struktur für Ihren Code bereitzustellen. Hier ist ein Beispiel, wie man ein einfaches Paket erstellt:

my_package/
    __init__.py
    utils/
        __init__.py
        math_functions.py
        string_functions.py

Die Dateien __init__.py werden verwendet, um die Paketstruktur festzulegen und anzugeben, welche Module importiert werden sollen, wenn das Paket importiert wird.

# my_package/utils/math_functions.py
def add(a, b):
    return a + b
 
def subtract(a, b):
    return a - b
# main.py
from my_package.utils import math_functions
 
ergebnis = math_functions.add(5, 3)
print(ergebnis)  # Ausgabe: 8

Ausnahmen

Ausnahmen sind Ereignisse, die während der Ausführung eines Programms auftreten und den normalen Ablauf der Anweisungen des Programms unterbrechen. Python verfügt über einen integrierten Mechanismus zur Ausnahmebehandlung, der es Ihnen ermöglicht, diese unerwarteten Situationen zu behandeln und zu verwalten.

Hier ist ein Beispiel, wie man eine ZeroDivisionError-Ausnahme behandelt:

def divide(a, b):
    try:
        ergebnis = a / b
        return ergebnis
    except ZeroDivisionError:
        print("Fehler: Division durch Null.")
        return None
 
print(divide(10, 2))  # Ausgabe: 5.0
print(divide(10, 0))  # Ausgabe: Fehler: Division durch Null.

In diesem Beispiel versucht die Funktion divide, das erste Argument durch das zweite Argument zu teilen. Wenn ein ZeroDivisionError auftritt, fängt die Funktion die Ausnahme ab, gibt eine Fehlermeldung aus und gibt dann None zurück.

Sie können auch benutzerdefinierte Ausnahmen erstellen, indem Sie Ihre eigenen Ausnahme-Klassen definieren, die von der integrierten Exception-Klasse oder einer ihrer Unterklassen erben.

class NegativeValueError(Exception):
    """Wird ausgelöst, wenn ein negativer Wert auftritt."""
    pass
 
def calculate_square_root(number):
    if number < 0:
        raise NegativeValueError("Kann die Quadratwurzel einer negativen Zahl nicht berechnen.")
    return number ** 0.5
 
try:
    print(calculate_square_root(16))  # Ausgabe: 4.0
    print(calculate_square_root(-4))
except NegativeValueError as e:
    print(e)  # Ausgabe: Kann die Quadratwurzel einer negativen Zahl nicht berechnen.

In diesem Beispiel wirft die Funktion calculate_square_root eine benutzerdefinierte NegativeValueError-Ausnahme, wenn die Eingabezahl negativ ist. Die Ausnahme wird dann im try-except-Block abgefangen und behandelt.

Datei Ein- und Ausgabe

Python bietet integrierte Funktionen und Methoden zum Lesen von und Schreiben in Dateien. Die gängigste Methode zum Arbeiten mit Dateien ist die Verwendung der Funktion open(), die ein Dateiobjekt zurückgibt, mit dem verschiedene Dateioperationen durchgeführt werden können.

Hier ist ein Beispiel, wie man aus einer Datei liest und in eine Datei schreibt:

# Schreiben in eine Datei
with open("beispiel.txt", "w") as datei:
    datei.write("Dies ist die erste Zeile.\n")
    datei.write("Dies ist die zweite Zeile.\n")
 
# Lesen aus einer Datei
with open("beispiel.txt", "r") as datei:
    inhalt = datei.read()
    print(inhalt)
    # Ausgabe:
    # Dies ist die erste Zeile.
    # Dies ist die zweite Zeile.

In diesem Beispiel wird die open()-Funktion verwendet, um eine Datei mit dem Namen "beispiel.txt" im Schreibmodus ("w") zu öffnen und zwei Zeilen Text in sie zu schreiben. Anschließend wird die Datei im Lese-Modus ("r") geöffnet und der Inhalt gelesen und ausgegeben.

Die with-Anweisung wird verwendet, um sicherzustellen, dass die Datei ordnungsgemäß geschlossen wird, nachdem die Operationen abgeschlossen sind, selbst wenn eine Ausnahme auftritt.

Sie können auch Dateien zeilenweise mit einer for-Schleife lesen:

with open("beispiel.txt", "r") as datei:
    for zeile in datei:
        print(zeile.strip())
    # Ausgabe:
    # Dies ist die erste Zeile.
    # Dies ist die zweite Zeile.

In diesem Beispiel wird die strip()-Methode verwendet, um das Zeilenendezeichen von jeder Zeile zu entfernen.

Reguläre Ausdrücke

Reguläre Ausdrücke (regex) sind ein leistungsstarkes Werkzeug zur Mustererkennung und Textmanipulation. Das integrierte re-Modul von Python bietet eine umfassende Reihe von Funktionen und Methoden zum Arbeiten mit regulären Ausdrücken.

Hier ist ein Beispiel, wie man reguläre Ausdrücke verwendet, um eine E-Mail-Adresse zu validieren:

import re
 
def is_valid_email(email):
    """
    Prüft, ob die angegebene E-Mail-Adresse gültig ist.
 
    Args:
        email (str): Die zu überprüfende E-Mail-Adresse.
 
    Returns:
        bool: True, wenn die E-Mail-Adresse gültig ist, sonst False.
    """
    pattern = r'^[\w\.-]+@[\w\.-]+\.\w+$'
    if re.match(pattern, email):
        return True
    else:
        return False
 
print(is_valid_email("beispiel@beispiel.com"))  # Ausgabe: True
print(is_valid_email("ungültige_email"))  # Ausgabe: False

In diesem Beispiel nimmt die Funktion is_valid_email eine E-Mail-Adresse als Eingabe entgegen und verwendet einen regulären Ausdrucks-Muster, um zu prüfen, ob die E-Mail-Adresse gültig ist. Die re.match()-Funktion wird verwendet, um das Muster auf die E-Mail-Adresse anzuwenden und ein boolesches Ergebnis zurückzugeben.

Reguläre Ausdrücke können für eine Vielzahl von Textverarbeitungsaufgaben verwendet werden, wie z.B.:

  • Suche nach bestimmten Mustern in Texten
  • Extrahieren von Informationen aus Texten
  • Ersetzen oder Ändern von Texten aufgrund von Mustern
  • Validierung von Eingabedaten Während reguläre Ausdrücke leistungsstark sein können, können sie auch komplex und schwer lesbar werden, insbesondere für fortgeschrittenere Anwendungsfälle. Es ist wichtig, die Verwendung von regulären Ausdrücken mit anderen Textverarbeitungstechniken wie Zeichenkettenmanipulation und integrierten Zeichenkettenmethoden auszugleichen.

Fazit

In diesem Tutorial haben Sie verschiedene Python-Konzepte auf mittlerem Niveau kennengelernt, einschließlich Funktionen, Modulen und Paketen, Ausnahmebehandlung, Datei-E/A und regulären Ausdrücken. Diese Themen sind essentiell für den Aufbau komplexerer und robusterer Python-Anwendungen.

Denken Sie daran, dass der beste Weg, Ihre Python-Fähigkeiten zu verbessern, darin besteht, zu üben, zu experimentieren und kontinuierlich zu lernen. Erforschen Sie die Python-Standardbibliothek, lesen Sie die Dokumentation und nehmen Sie an Online-Communitys teil, um Ihr Wissen zu erweitern und auf dem neuesten Stand der Entwicklungen im Python-Ökosystem zu bleiben.

Viel Spaß beim Programmieren!

MoeNagy Dev