Python
DataFrame Dropna beherrschen: Ein Leitfaden für Anfänger

DataFrame Dropna beherrschen: Ein Leitfaden für Anfänger

MoeNagy Dev

Umgang mit fehlenden Daten in Pandas mit df.dropna()

Grundlagen fehlender Daten in Pandas

Verständnis von Nullwerten und NaN in Pandas

In Pandas werden fehlende Daten durch den speziellen Wert NaN (Not a Number) repräsentiert. NaN ist ein Gleitkommawert, der verwendet wird, um das Fehlen eines gültigen Wertes anzugeben. Dies ist wichtig zu verstehen, da Pandas NaN-Werte anders behandelt als gewöhnliche numerische Werte oder None-Werte.

import pandas as pd
 
# Erstellen eines DataFrames mit fehlenden Werten
data = {'A': [1, 2, None, 4], 'B': [5, None, 7, 8]}
df = pd.DataFrame(data)
print(df)
#    A    B
# 0  1  5.0
# 1  2  NaN
# 2  None  7.0
# 3  4  8.0

Im obigen Beispiel enthält das DataFrame df fehlende Werte, die durch None und NaN repräsentiert werden.

Anerkennen der Bedeutung des Umgangs mit fehlenden Daten

Fehlende Daten sind eine häufige Herausforderung bei der Datenanalyse und können sich erheblich auf die Genauigkeit und Zuverlässigkeit Ihrer Ergebnisse auswirken. Das Ignorieren oder falsche Handhaben fehlender Daten kann zu voreingenommenen Schlussfolgerungen, falschen Vorhersagen und unzuverlässigen Erkenntnissen führen. Daher ist es wichtig, ein solides Verständnis dafür zu haben, wie fehlende Daten in Ihren Pandas-Workflows effektiv gehandhabt werden können.

Einführung in df.dropna()

Was ist df.dropna()?

Die Methode df.dropna() in Pandas ist ein leistungsstolles Tool zum Entfernen von Zeilen oder Spalten mit fehlenden Daten aus einem DataFrame. Diese Methode ermöglicht es Ihnen, das Verhalten beim Umgang mit fehlenden Daten anzupassen, was sie zu einer vielseitigen und flexiblen Lösung für den Umgang mit unvollständigen Datensätzen macht.

Wann sollte df.dropna() verwendet werden?

Die Methode df.dropna() wird in der Regel verwendet, wenn Sie Zeilen oder Spalten mit fehlenden Daten aus Ihrem DataFrame entfernen möchten. Dies kann in Szenarien nützlich sein, in denen:

  1. Sie einen sauberen Datensatz für weitere Analysen oder Modellierung vorbereiten möchten.
  2. Die Anwesenheit von fehlenden Daten sich negativ auf die Leistung Ihrer Machine Learning-Modelle auswirken kann.
  3. Sie Ihre Daten ohne die Verzerrungen durch fehlende Werte visualisieren möchten.
  4. Sie bestimmten Anforderungen oder Einschränkungen genügen müssen, die einen vollständigen Datensatz erfordern.

Entfernen von Zeilen mit fehlenden Daten

Entfernen von Zeilen mit beliebigen NaN-Werten

Der einfachste Weg, Zeilen mit fehlenden Daten zu entfernen, besteht darin, die Methode df.dropna() ohne Argumente zu verwenden:

import pandas as pd
 
# Erstellen eines DataFrames mit fehlenden Werten
data = {'A': [1, 2, None, 4], 'B': [5, None, 7, 8]}
df = pd.DataFrame(data)
 
# Entfernen von Zeilen mit beliebigen NaN-Werten
df_dropped = df.dropna()
print(df_dropped)
#    A    B
# 0  1  5.0
# 3  4  8.0

In diesem Beispiel entfernt die Methode df.dropna() alle Zeilen, die mindestens einen NaN-Wert enthalten, und erzeugt ein neues DataFrame df_dropped nur mit den vollständigen Zeilen.

Entfernen von Zeilen mit bestimmten Spalten, die NaN enthalten

Sie können auch angeben, welche Spalten berücksichtigt werden sollen, wenn Zeilen mit fehlenden Daten entfernt werden. Dies geschieht durch Übergeben des Parameters subset an df.dropna():

# Entfernen von Zeilen mit NaN-Werten in der Spalte 'A'
df_dropped_A = df.dropna(subset=['A'])
print(df_dropped_A)
#    A    B
# 0  1  5.0
# 1  2  NaN
# 3  4  8.0
 
# Entfernen von Zeilen mit NaN-Werten in den Spalten 'A' und 'B'
df_dropped_AB = df.dropna(subset=['A', 'B'])
print(df_dropped_AB)
#    A    B
# 0  1  5.0
# 3  4  8.0

Im ersten Beispiel entfernt df.dropna(subset=['A']) Zeilen, in denen die Spalte 'A' NaN-Werte enthält. Im zweiten Beispiel entfernt df.dropna(subset=['A', 'B']) Zeilen, in denen sowohl die Spalte 'A' als auch die Spalte 'B' NaN-Werte enthalten.

Anpassung des Verhaltens von df.dropna()

Die Methode df.dropna() bietet mehrere zusätzliche Parameter, um ihr Verhalten anzupassen:

  • how: Gibt die Bedingung zum Entfernen von Zeilen an. Kann 'any' (Standardwert) sein, um Zeilen mit beliebigen NaN-Werten zu entfernen, oder 'all', um Zeilen nur dann zu entfernen, wenn alle Werte NaN sind.
  • thresh: Gibt die Mindestanzahl von Nicht-NaN-Werten an, die für eine Zeile erforderlich sind, um beibehalten zu werden.
  • subset: Gibt die Spalten an, die berücksichtigt werden sollen, wenn Zeilen entfernt werden.
# Entfernen von Zeilen mit ausschließlich NaN-Werten
df_dropped_all = df.dropna(how='all')
print(df_dropped_all)
#    A    B
# 0  1  5.0
# 1  2  NaN
# 3  4  8.0
 
# Entfernen von Zeilen mit weniger als 2 Nicht-NaN-Werten
df_dropped_thresh = df.dropna(thresh=2)
print(df_dropped_thresh)
#    A    B
# 0  1  5.0
# 3  4  8.0

Im ersten Beispiel entfernt df.dropna(how='all') Zeilen, in denen alle Werte NaN sind. Im zweiten Beispiel entfernt df.dropna(thresh=2) Zeilen mit weniger als 2 Nicht-NaN-Werten.

Entfernen von Spalten mit fehlenden Daten

Entfernen von Spalten mit beliebigen NaN-Werten

Um Spalten mit beliebigen NaN-Werten zu entfernen, können Sie den Parameter axis=1 in der Methode df.dropna() verwenden:

# Entfernen von Spalten mit beliebigen NaN-Werten
df_dropped_cols = df.dropna(axis=1)
print(df_dropped_cols)
#    A
# 0  1
# 1  2
# 2  None
# 3  4

In diesem Beispiel entfernt die Methode df.dropna(axis=1) die Spalte 'B', da sie NaN-Werte enthält, und hinterlässt nur die Spalte 'A' im resultierenden DataFrame df_dropped_cols.

Entfernen von Spalten mit einer bestimmten Anzahl von NaN-Werten

Sie können auch eine Grenze für die maximale Anzahl von NaN-Werten festlegen, die in einer Spalte erlaubt sind, bevor sie entfernt wird. Dies geschieht mit dem Parameter thresh:

# Entfernen von Spalten mit mehr als einem NaN-Wert
df_dropped_threshold = df.dropna(axis=1, thresh=3)
print(df_dropped_threshold)
#    A    B
# 0  1  5.0
# 1  2  NaN
# 2  None  7.0
# 3  4  8.0

In diesem Beispiel entfernt df.dropna(axis=1, thresh=3) Spalten, die mehr als einen NaN-Wert haben (da das DataFrame 4 Zeilen hat), und behält die Spalten 'A' und 'B' im resultierenden DataFrame df_dropped_threshold.

Umgang mit Spalten mit gemischten Datentypen

Bei der Arbeit mit Spalten, die eine Mischung aus Datentypen enthalten, einschließlich NaN-Werten, kann die Methode df.dropna() je nach Datentyp unterschiedlich funktionieren. Dies liegt daran, dass Pandas fehlende Werte in unterschiedlichen Datentypen unterschiedlich behandelt.

# Erstellung eines DataFrame mit gemischten Datentypen
data = {'A': [1, 2, None, 4], 'B': [5, None, '7', 8]}
df = pd.DataFrame(data)
print(df)
#    A     B
# 0  1   5.0
# 1  2   NaN
# 2  None  7
# 3  4   8.0
 
# Löschen von Spalten mit beliebigen NaN-Werten
df_dropped_mixed = df.dropna(axis=1)
print(df_dropped_mixed)
#    A
# 0  1
# 1  2
# 2  None
# 3  4

In diesem Beispiel enthält die Spalte 'B' eine Mischung aus numerischen und Zeichenfolgenwerten, einschließlich NaN. Wenn df.dropna(axis=1) verwendet wird, wird die Spalte 'B' gelöscht, da sie NaN-Werte enthält, obwohl der Zeichenfolgenwert '7' von Pandas nicht als fehlender Wert betrachtet wird.

Um Spalten mit gemischten Datentypen zu verarbeiten, müssen Sie möglicherweise die Datentypen konvertieren oder alternative Methoden zur Behandlung fehlender Daten verwenden, wie z.B. Imputation oder Data Cleaning-Techniken.

Erweiterte Techniken mit df.dropna()

Kombination von df.dropna() mit anderen Pandas-Operationen

Die Methode df.dropna() kann mit anderen Pandas-Operationen kombiniert werden, um komplexere Datenbereinigungs- und Vorverarbeitungsvorgänge zu erstellen. Sie können z.B. df.dropna() zusammen mit df.fillna() verwenden, um fehlende Daten auf umfassendere Weise zu behandeln.

# Kombination von df.dropna() und df.fillna()
data = {'A': [1, 2, None, 4], 'B': [5, None, 7, 8]}
df = pd.DataFrame(data)
 
# Fehlende Werte mit 0 auffüllen und dann Zeilen mit beliebigen NaN löschen
df_cleaned = df.fillna(0).dropna()
print(df_cleaned)
#    A  B
# 0  1  5
# 3  4  8

In diesem Beispiel füllt die Methode df.fillna(0) die fehlenden Werte mit 0 auf, und dann entfernt die Methode df.dropna() alle verbleibenden Zeilen mit NaN-Werten.

Erhalt des ursprünglichen DataFrame mit .copy()

Beim Verwenden von df.dropna() ist es wichtig zu beachten, dass die Methode den ursprünglichen DataFrame modifiziert. Wenn Sie den ursprünglichen DataFrame beibehalten möchten, können Sie die Methode .copy() verwenden, um einen neuen DataFrame zu erstellen, bevor Sie df.dropna() anwenden.

# Beibehalten des ursprünglichen DataFrame
data = {'A': [1, 2, None, 4], 'B': [5, None, 7, 8]}
df = pd.DataFrame(data)
 
# Erstellen einer Kopie des DataFrames vor dem Löschen von Zeilen
df_copy = df.copy()
df_dropped = df_copy.dropna()
 
print("Ursprünglicher DataFrame:")
print(df)
print("\nKopierter und gelöschter DataFrame:")
print(df_dropped)

In diesem Beispiel erstellt df_copy = df.copy() einen neuen DataFrame df_copy, der eine Kopie des ursprünglichen df ist. Die Operation df.dropna() wird dann auf df_copy durchgeführt, wodurch der ursprüngliche DataFrame df erhalten bleibt.

Behandlung fehlender Daten in Zeitreihendaten

Bei der Arbeit mit Zeitreihendaten ist es besonders wichtig, fehlende Werte zu behandeln, da Lücken in den Daten Ihre Analysen und Prognosen erheblich beeinträchtigen können. Die Methode df.dropna() kann verwendet werden, um Zeilen mit fehlenden Daten in Zeitreihendaten zu entfernen, aber je nach spezifischem Anwendungsfall müssen Sie möglicherweise auch alternative Ansätze wie Interpolation oder Vorwärts-/Rückwärtsbefüllung in Betracht ziehen.

# Beispiel für die Behandlung von fehlenden Daten in Zeitreihendaten
import pandas as pd
 
# Erstellen eines Beispiels für ein Zeitreihen-DataFrame mit fehlenden Werten
dates = pd.date_range(start='2022-01-01', end='2022-01-10', freq='D')
data = {'A': [1, 2, None, 4, 5, None, 7, 8, 9, 10]}
df_ts = pd.DataFrame(data, index=dates)
 
# Zeilen mit beliebigen NaN-Werten löschen
df_ts_dropped = df_ts.dropna()
print(df_ts_dropped)
#            A
# 2022-01-01  1
# 2022-01-02  2
# 2022-01-04  4
# 2022-01-05  5
# 2022-01-07  7
# 2022-01-08  8
# 2022-01-09  9
# 2022-01-10 10

In diesem Beispiel stellt das DataFrame df_ts eine Zeitreihe mit fehlenden Werten dar. Die Methode df.dropna() wird verwendet, um die Zeilen mit NaN-Werten zu entfernen, was zum DataFrame df_ts_dropped führt.

Beste Praktiken und Überlegungen

Bewertung der Auswirkung des Löschen von Daten

Beim Verwenden von df.dropna() ist es wichtig, die möglichen Auswirkungen des Löschens von Zeilen oder Spalten mit fehlenden Daten zu berücksichtigen. Das Entfernen zu vieler Daten kann zu einem erheblichen Informationsverlust und möglicherweise zu verfälschten Ergebnissen führen. Es ist eine gute Praxis, den Anteil fehlender Daten und die

Bedingte Anweisungen

Bedingte Anweisungen in Python ermöglichen es Ihnen, verschiedene Codeblöcke basierend auf bestimmten Bedingungen auszuführen. Die häufigste bedingte Anweisung ist die if-elif-else-Anweisung.

age = 25
if age < 18:
    print("Du bist minderjährig.")
elif age >= 18 and age < 65:
    print("Du bist volljährig.")
else:
    print("Du bist Senior.")

In diesem Beispiel überprüft das Programm den Wert der Variablen age und gibt die entsprechende Nachricht basierend auf dem Altersbereich aus.

Schleifen

Schleifen in Python ermöglichen es Ihnen, einen Codeblock wiederholt auszuführen. Die beiden häufigsten Schleifentypen sind for- und while-Schleifen.

for-Schleifen

for-Schleifen werden verwendet, um über eine Sequenz zu iterieren, wie z.B. eine Liste, ein Tupel oder eine Zeichenkette.

fruits = ["Apfel", "Banane", "Kirsche"]
for fruit in fruits:
    print(fruit)

Dieser Code gibt aus:

Apfel
Banane
Kirsche

while-Schleifen

while-Schleifen werden verwendet, um einen Codeblock so lange auszuführen, wie eine bestimmte Bedingung wahr ist.

count = 0
while count < 5:
    print(count)
    count += 1

Dieser Code gibt aus:

0
1
2
3
4

Funktionen

Funktionen in Python sind Blöcke von wiederverwendbarem Code, die eine bestimmte Aufgabe erfüllen. Sie können Argumente entgegennehmen und Werte zurückgeben.

def greet(name):
    print(f"Hallo, {name}!")
 
greet("Alice")
greet("Bob")

Dieser Code gibt aus:

Hallo, Alice!
Hallo, Bob!

Sie können auch Funktionen mit Standardargumenten und Variablenlängenargumenten definieren.

def calculate_area(length, width, height=None):
    if height is None:
        return length * width
    else:
        return length * width * height
 
print(calculate_area(5, 10))       # Ausgabe: 50
```python
print(calculate_area(2, 3, 4))     # Ausgabe: 24

Module und Pakete

Die Python-Standardbibliothek bietet eine Vielzahl von integrierten Modulen, die Sie in Ihren Programmen verwenden können. Sie können auch Ihre eigenen Module und Pakete erstellen, um Ihren Code zu organisieren.

import math
print(math.pi)  # Ausgabe: 3.141592653589793

In diesem Beispiel importieren wir das math-Modul und verwenden die Konstante pi daraus.

Sie können auch bestimmte Funktionen oder Attribute aus einem Modul importieren:

from math import sqrt, pi
print(sqrt(16))  # Ausgabe: 4.0
print(pi)       # Ausgabe: 3.141592653589793

Datei I/O

Python bietet integrierte Funktionen zum Lesen und Schreiben von Dateien.

# Schreiben in eine Datei
with open("beispiel.txt", "w") as file:
    file.write("Dies ist eine Beispieldatei.")
 
# Lesen aus einer Datei
with open("beispiel.txt", "r") as file:
    content = file.read()
    print(content)  # Ausgabe: Dies ist eine Beispieldatei.

Die with-Anweisung stellt sicher, dass die Datei nach Abschluss der Operationen ordnungsgemäß geschlossen wird.

Ausnahmebehandlung

Python's Ausnahmebehandlungsmechanismus ermöglicht es Ihnen, Fehler und unerwartete Situationen in Ihrem Code zu behandeln.

try:
    result = 10 / 0
except ZeroDivisionError:
    print("Fehler: Division durch Null")
else:
    print(f"Ergebnis: {result}")
finally:
    print("Dieser Block wird immer ausgeführt.")

Dieser Code gibt aus:

Fehler: Division durch Null
Dieser Block wird immer ausgeführt.

Objektorientierte Programmierung (OOP)

Python unterstützt objektorientierte Programmierung, mit der Sie benutzerdefinierte Klassen und Objekte erstellen können.

class Auto:
    def __init__(self, marke, modell, jahr):
        self.marke = marke
        self.modell = modell
        self.jahr = jahr
 
    def starten(self):
        print(f"Das {self.jahr} {self.marke} {self.modell} wurde gestartet.")
 
mein_auto = Auto("Toyota", "Corolla", 2020)
mein_auto.starten()  # Ausgabe: Das 2020 Toyota Corolla wurde gestartet.

In diesem Beispiel definieren wir eine Auto-Klasse mit einer __init__-Methode, um die Attribute des Objekts zu initialisieren, und einer starten-Methode, um das Auto zu simulieren.

Fazit

In diesem Tutorial haben Sie verschiedene Python-Konzepte kennengelernt, einschließlich bedingter Anweisungen, Schleifen, Funktionen, Modulen und Paketen, Datei I/O, Ausnahmebehandlung und objektorientierter Programmierung. Diese grundlegenden Fähigkeiten helfen Ihnen dabei, komplexere und robustere Python-Anwendungen zu entwickeln. Vergessen Sie nicht, mit den bereitgestellten Codebeispielen zu üben und zu experimentieren, um Ihr Verständnis dieser Themen zu festigen.

MoeNagy Dev