Python
Pandas-Spalten mühelos neu ordnen: Ein Anfängerleitfaden

Pandas-Spalten mühelos neu ordnen: Ein Anfängerleitfaden

MoeNagy Dev

Bedeutung der Neuordnung von Spalten in Pandas

Das Neuordnen von Spalten in Pandas DataFrames ist eine wesentliche Fähigkeit für Datenanalysten und -forscher. Es kann die Datenanalyse und -visualisierung verbessern, die Lesbarkeit und Organisation von Datensätzen verbessern und Daten für spezifische Anwendungsfälle ausrichten.

Durch die Umstellung der Spaltenreihenfolge können Sie:

  • Die Datenanalyse und -visualisierung verbessern, indem Sie verwandte Spalten gruppieren, um die Daten einfacher zu verstehen und zu interpretieren.
  • Die Lesbarkeit und Organisation Ihrer Datensätze verbessern, um die Navigation und Struktur der Daten einfacher zu machen.
  • Daten für spezifische Anwendungsfälle ausrichten, wie zum Beispiel die Vorbereitung von Daten für maschinelles Lernen oder die Erstellung maßgeschneiderter Berichte.

Verständnis der Spaltenreihenfolge in Pandas DataFrames

In Pandas wird die Reihenfolge der Spalten in einem DataFrame durch die Reihenfolge bestimmt, in der die Spalten erstellt oder zum DataFrame hinzugefügt wurden. Wenn Sie ein neues DataFrame erstellen, werden die Spalten in der Regel in derselben Reihenfolge angeordnet, wie sie während des Erstellungsprozesses angegeben wurden.

Sie können auf die Reihenfolge der Spalten in einem DataFrame über das columns-Attribut zugreifen:

import pandas as pd
 
# Erstellen eines Beispiel-DataFrames
df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6], 'C': [7, 8, 9]})
 
# Anzeigen der Spaltenreihenfolge
print(df.columns)
# Ausgabe: Index(['A', 'B', 'C'], dtype='object')

Neuordnung von Spalten mit integrierten Methoden

Pandas bietet mehrere integrierte Methoden zur Neuordnung von Spalten in einem DataFrame.

df.reindex(columns=neue_reihenfolge)

Die Methode reindex() ermöglicht es Ihnen, die Spalten durch Angabe einer neuen Reihenfolge im columns-Parameter neu anzuordnen. Diese Methode erhält die ursprünglichen Datentypen der Spalten.

# Neuordnung der Spalten
neue_reihenfolge = ['C', 'A', 'B']
df_neu_geordnet = df.reindex(columns=neue_reihenfolge)
print(df_neu_geordnet)
#    C  A  B
# 0  7  1  4
# 1  8  2  5
# 2  9  3  6

Wenn Sie eine Spalte angeben, die im ursprünglichen DataFrame nicht vorhanden ist, fügt reindex() eine neue Spalte mit NaN-Werten hinzu.

df[neue_reihenfolge]

Sie können auch die Spalten auswählen und in der gewünschten Reihenfolge mithilfe der Spaltennamen in eckigen Klammern neu anordnen.

# Neuordnung der Spalten
neue_reihenfolge = ['C', 'A', 'B']
df_neu_geordnet = df[neue_reihenfolge]
print(df_neu_geordnet)
#    C  A  B
# 0  7  1  4
# 1  8  2  5
# 2  9  3  6

Diese Methode ist knapper als die Verwendung von reindex(), verarbeitet jedoch fehlende Spalten in der neuen Reihenfolge nicht.

Fortgeschrittene Techniken zur Neuordnung

Neuordnung basierend auf Spaltennamen

Sie können Spalten basierend auf ihren Namen neu ordnen, entweder in alphabetischer Reihenfolge oder in einer bestimmten Reihenfolge, die durch eine Liste definiert ist.

# Spalten alphabetisch neu ordnen
df_alphabetisch = df[sorted(df.columns)]
print(df_alphabetisch)
#    A  B  C
# 0  1  4  7
# 1  2  5  8
# 2  3  6  9
 
# Spalten in einer bestimmten Reihenfolge neu ordnen
bestimmte_reihenfolge = ['B', 'C', 'A']
df_bestimmte_reihenfolge = df[bestimmte_reihenfolge]
print(df_bestimmte_reihenfolge)
#    B  C  A
# 0  4  7  1
# 1  5  8  2
# 2  6  9  3

Neuordnung basierend auf Spaltendatentypen

Sie können Spalten nach ihren Datentypen gruppieren und die Reihenfolge der Datentypen neu anordnen.

# Spalten nach Datentyp neu ordnen
df_nach_datentyp = df.reindex(sorted(df.columns, key=lambda x: (df[x].dtype, x)), axis=1)
print(df_nach_datentyp)
#    A  B  C
# 0  1  4  7
# 1  2  5  8
# 2  3  6  9

In diesem Beispiel werden die Spalten zunächst nach ihren Datentypen und dann nach ihren Namen (als sekundäres Sortierkriterium) sortiert.

Neuordnung basierend auf Spaltenstatistiken

Sie können Spalten basierend auf bestimmten Statistiken neu ordnen, wie z. B. den Minimum-, Maximum- oder Durchschnittswerten der Spalten.

# Spalten nach dem Minimumwert neu ordnen
df_nach_minimum = df.reindex(df.min().sort_values().index, axis=1)
print(df_nach_minimum)
#    A  B  C
# 0  1  4  7
# 1  2  5  8
# 2  3  6  9

In diesem Beispiel werden die Spalten basierend auf dem Minimumwert jeder Spalte neu geordnet, wie es durch df.min().sort_values().index bestimmt wird.

Bedingte Neuordnung von Spalten

Sie können Spalten basierend auf bestimmten Bedingungen neu ordnen, wie z. B. das Auswählen von Spalten, die einem Muster entsprechen, oder das Ausschließen von Spalten, die bestimmte Kriterien erfüllen.

# Spalten neu anordnen, die den Buchstaben 'A' enthalten
df_mit_A = df[df.columns[df.columns.str.contains('A')]]
print(df_mit_A)
#    A
# 0  1
# 1  2
# 2  3
 
# Spalten neu anordnen, wobei solche ausgeschlossen werden, die den Buchstaben 'A' enthalten
df_ohne_A = df[df.columns[~df.columns.str.contains('A')]]
print(df_ohne_A)
#    B  C
# 0  4  7
# 1  5  8
# 2  6  9

Sie können die bedingte Neuordnung mit den integrierten Neuordnungsmethoden wie reindex() oder der Auswahl von Spalten mit eckigen Klammern kombinieren.

Beibehaltung der ursprünglichen Spaltenreihenfolge

Wenn Sie die Spaltenreihenfolge auf den ursprünglichen Zustand zurücksetzen müssen, können Sie die Methode reindex() mit der ursprünglichen Spaltenreihenfolge verwenden.

# Setzen Sie die Spaltenreihenfolge auf den ursprünglichen Zustand zurück
df_ursprüngliche_reihenfolge = df.reindex(df.columns, axis=1)
print(df_ursprüngliche_reihenfolge)
#    A  B  C
# 0  1  4  7
# 1  2  5  8
# 2  3  6  9

Dadurch wird sichergestellt, dass die Spaltenreihenfolge auf den ursprünglichen Zustand zurückgesetzt wird, auch wenn die Reihenfolge im Laufe des Datenverarbeitungs-Workflows geändert wurde.

Neuordnung von Spalten in mehrstufigen Spalten

Pandas unterstützt auch mehrstufige Spaltenstrukturen, bei denen jede Spalte einen hierarchischen Header hat. Sie können die zuvor diskutierten Neuordnungstechniken auf einzelne Ebenen der mehrstufigen Spaltenstruktur anwenden.

# Erstellen eines DataFrames mit mehrstufigen Spalten
df_mehrstufig = pd.DataFrame({
    ('level1', 'A'): [1, 2, 3],
    ('level1', 'B'): [4, 5, 6],
    ('level2', 'C'): [7, 8, 9]
})
 
# Neuordnung der Spalten nach der ersten Ebene
df_neu_geordnet_mehrstufig = df_mehrstufig[sorted(df_mehrstufig.columns.get_level_values(0))]
print(df_neu_geordnet_mehrstufig)
#    (level1, A)  (level1, B)  (level2, C)
# 0           1           4            7
# 1           2           5            8
# 2           3           6            9

In diesem Beispiel werden die Spalten entsprechend der ersten Ebene der mehrstufigen Spaltenstruktur umsortiert.

Bedingte Anweisungen

Bedingte Anweisungen in Python ermöglichen es Ihnen, verschiedene Codeblöcke basierend auf bestimmten Bedingungen auszuführen. Die am häufigsten verwendeten bedingten Anweisungen sind if, elif und else.

alter = 25
if alter >= 18:
    print("Du bist erwachsen.")
else:
    print("Du bist minderjährig.")

In diesem Beispiel wird der Codeblock unter der if-Anweisung ausgeführt, wenn die Variable alter größer oder gleich 18 ist. Andernfalls wird der Codeblock unter der else-Anweisung ausgeführt.

Sie können auch die elif-Anweisung verwenden, um nach mehreren Bedingungen zu prüfen:

punktzahl = 85
if punktzahl >= 90:
    print("Du hast eine A erhalten.")
elif punktzahl >= 80:
    print("Du hast eine B erhalten.")
elif punktzahl >= 70:
    print("Du hast eine C erhalten.")
else:
    print("Du hast versagt.")

Schleifen

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

For-Schleifen

for-Schleifen werden verwendet, um über eine Sequenz zu iterieren (wie z.B. eine Liste, ein Tuple oder einen String).

früchte = ["Apfel", "Banane", "Kirsche"]
for frucht in früchte:
    print(frucht)

Dies gibt aus:

Apfel
Banane
Kirsche

Sie können auch die range()-Funktion verwenden, um eine Sequenz von Zahlen zu erstellen, über die Sie iterieren können:

for i in range(5):
    print(i)

Dies gibt aus:

0
1
2
3
4

While-Schleifen

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

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

Dies gibt aus:

0
1
2
3
4

Funktionen

Funktionen in Python sind Blöcke von wiederverwendbarem Code, die eine bestimmte Aufgabe ausführen. Sie können Argumente entgegennehmen und Rückgabewerte liefern.

def begrüßen(name):
    print(f"Hallo, {name}!")
 
begrüßen("Alice")
begrüßen("Bob")

Das gibt aus:

Hallo, Alice!
Hallo, Bob!

Sie können auch Funktionen mit Standardargumenten und Variablengerüsten definieren:

def fläche_berechnen(länge, breite, höhe=None):
    if höhe:
        return länge * breite * höhe
    else:
        return länge * breite
 
print(fläche_berechnen(5, 3))       # Ausgabe: 15
print(fläche_berechnen(4, 2, 6))    # Ausgabe: 48

Module und Pakete

Die Python-Standardbibliothek bietet eine Vielzahl von integrierten Modulen, und Sie können auch Ihre eigenen Module und Pakete erstellen.

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

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

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

Pakete sind Sammlungen von Modulen und helfen dabei, Ihren Code in einer hierarchischen Struktur zu organisieren.

my_package/
    __init__.py
    module1.py
    module2.py
    subpackage/
        __init__.py
        module3.py

Fehlerbehandlung

Die Fehlerbehandlungsmechanismen in Python ermöglichen es Ihnen, Fehler und unerwartete Situationen in Ihrem Code zu handhaben.

try:
    ergebnis = 10 / 0
except ZeroDivisionError:
    print("Fehler: Division durch Null.")

Sie können auch except-Blöcke verwenden, um mehrere Ausnahmetypen zu behandeln, und einen optionalen else- und finally-Block einschließen.

try:
    zahl = int(input("Gib eine Zahl ein: "))
    print(10 / zahl)
except ValueError:
    print("Fehler: Ungültige Eingabe. Bitte gib eine Zahl ein.")
except ZeroDivisionError:
    print("Fehler: Division durch Null.")
else:
    print("Die Operation war erfolgreich.")
finally:
    print("Dieser Block wird immer ausgeführt.")

Datei-Zugriff

Python bietet integrierte Funktionen zum Lesen und Schreiben von Dateien.

# Schreiben in eine Datei
with open("beispiel.txt", "w") as datei:
    datei.write("Hallo, Welt!")
 
# Lesen aus einer Datei
with open("beispiel.txt", "r") as datei:
    inhalt = datei.read()
    print(inhalt)  # Ausgabe: Hallo, Welt!

Mit der with-Anweisung wird sichergestellt, dass die Datei nach Abschluss der Operationen ordnungsgemäß geschlossen wird.

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"Der {self.jahr} {self.marke} {self.modell} startet.")
 
mein_auto = Auto("Toyota", "Camry", 2020)
mein_auto.starten()  # Ausgabe: Der 2020 Toyota Camry startet.

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

Fazit

In diesem Tutorial haben wir eine Vielzahl von Python-Konzepten behandelt, einschließlich bedingter Anweisungen, Schleifen, Funktionen, Modulen und Paketen, Fehlerbehandlung, Datei-Zugriff und objektorientierter Programmierung. Diese Themen sind wesentlich für die Entwicklung robuster und effizienter Python-Anwendungen. Denken Sie daran, die bereitgestellten Codebeispiele zu üben und zu experimentieren, um Ihr Verständnis dieser Konzepte zu festigen. Viel Spaß beim Programmieren!

MoeNagy Dev