Python
Säulen in Pandas DataFrames mühelos umbenennen: Ein kurzer Leitfaden

Säulen in Pandas DataFrames mühelos umbenennen: Ein kurzer Leitfaden

MoeNagy Dev

Umbenennen von Säulen in Pandas: Ein umfassender Leitfaden

Bedeutung der Umbenennung von Säulen in Pandas

Das Umbenennen von Säulen in Pandas ist eine wesentliche Aufgabe bei der Arbeit mit Daten. Es kann die Lesbarkeit und das Verständnis Ihrer Daten erheblich verbessern, indem es erleichtert, die Spaltennamen an die Anforderungen Ihres Projekts anzupassen und die Daten für die Analyse und Visualisierung vorzubereiten.

Grundlegende Techniken zur Umbenennung

Umbenennen einer einzelnen Säule

Um eine einzelne Säule in Pandas umzubenennen, können Sie die Methode df.rename() verwenden:

import pandas as pd
 
# Beispiel DataFrame erstellen
df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})
 
# Eine einzelne Säule umbenennen
df = df.rename(columns={'A': 'neuer_spaltenname'})

Umbenennen mehrerer Säulen

Um mehrere Säulen auf einmal umzubenennen, können Sie einem Wörterbuch das columns-Argument der Methode df.rename() übergeben:

# Mehrere Säulen umbenennen
df = df.rename(columns={'A': 'neuer_spaltenname_1', 'B': 'neuer_spaltenname_2'})

Umbenennen von Säulen mit einem Wörterbuch

Sie können auch ein Wörterbuch verwenden, um die Säulen auf eine kürzere Art und Weise umzubenennen:

# Säulen mit einem Wörterbuch umbenennen
umbenennen_dict = {'A': 'neuer_spaltenname_1', 'B': 'neuer_spaltenname_2'}
df = df.rename(columns=umbenennen_dict)

Umbenennen von Säulen mit einer Funktion

Wenn Sie eine komplexere Umbenennungslogik anwenden müssen, können Sie eine Funktion mit der Methode df.rename() verwenden:

# Säulen mit einer Funktion umbenennen
def säulen_umbenennen(spaltenname):
    if spaltenname == 'A':
        return 'neuer_spaltenname_1'
    elif spaltenname == 'B':
        return 'neuer_spaltenname_2'
    else:
        return spaltenname
 
df = df.rename(columns=säulen_umbenennen)

Fortgeschrittene Techniken zur Umbenennung

Umbenennen von Säulen mit regulären Ausdrücken (Regex)

Mit regulären Ausdrücken (Regex) können Sie auf einmal mehrere Säulen basierend auf einem Muster umbenennen:

import re
 
# Säulen mit Regex umbenennen
df = df.rename(columns=lambda x: re.sub(r'^col_', 'neu_', x))

Mit diesem Beispiel werden alle Säulen, die mit 'col_' beginnen, mit 'neu_' beginnen.

Umbenennen von Säulen basierend auf vorhandenen Namen

Sie können auch die vorhandenen Spaltennamen verwenden, um neue Namen zu generieren:

# Säulen basierend auf vorhandenen Namen umbenennen
df = df.rename(columns=lambda x: 'neu_' + x)

Dies fügt allen Spaltennamen das Präfix 'neu_' hinzu.

Umbenennen von Säulen mit Änderungen der Groß-/Kleinschreibung

Um die Groß-/Kleinschreibung von Spaltennamen zu ändern, können Sie String-Methoden wie lower(), upper() oder title() verwenden:

# Säulen mit Änderungen der Groß-/Kleinschreibung umbenennen
df = df.rename(columns=str.lower)
df = df.rename(columns=str.upper)
df = df.rename(columns=str.title)

Umbenennen von Säulen mit der .rename()-Methode

Die .rename()-Methode kann auch verwendet werden, um Säulen direkt zu umbenennen:

# Säulen mit der .rename()-Methode umbenennen
df.rename(columns={'A': 'neuer_spaltenname_1', 'B': 'neuer_spaltenname_2'}, inplace=True)

Umgang mit doppelten Spaltennamen

Erkennen von doppelten Spaltennamen

Bevor Sie Säulen umbenennen, ist es wichtig zu überprüfen, ob in Ihrem DataFrame doppelte Spaltennamen vorhanden sind:

# Doppelte Spaltennamen erkennen
doppelte_spalten = df.columns[df.columns.duplicated()]
print(doppelte_spalten)

Auflösen von doppelten Spaltennamen

Wenn Sie doppelte Spaltennamen finden, können Sie diese durch Umbenennen der Spalten auflösen:

# Auflösen von doppelten Spaltennamen
df = df.rename(columns={'doppelter_spaltenname': 'eindeutiger_spaltenname'})

Umbenennen von Säulen, um Duplikate zu vermeiden

Sie können auch proaktiv Säulen umbenennen, um doppelte Säulen erst gar nicht zu erzeugen:

# Umbenennen von Säulen, um Duplikate zu vermeiden
df = df.rename(columns={'spaltenname': 'spaltenname_1'})

Umbenennen von Säulen in spezifischen Szenarien

Umbenennen von Säulen mit Leerzeichen oder Sonderzeichen

Säulen mit Leerzeichen oder Sonderzeichen können schwierig zu verwenden sein. Sie können die df.rename()-Methode verwenden, um solche Fälle zu handhaben:

# Umbenennen von Säulen mit Leerzeichen oder Sonderzeichen
df = df.rename(columns={'spalten name': 'spaltenname', 'spalte#1': 'spalte_1'})

Umbenennen von Säulen mit gemischter Groß-/Kleinschreibung oder alles in Großbuchstaben

Säulen mit gemischter Groß-/Kleinschreibung oder alles in Großbuchstaben können ebenfalls mit der df.rename()-Methode umbenannt werden:

# Umbenennen von Säulen mit gemischter Groß-/Kleinschreibung oder alles in Großbuchstaben
df = df.rename(columns={'SpalteMitGroßUndKleinschreibung': 'spalte_mit_gemischter_groß_und_kleinschreibung', 'GROSSBUCHSTABENSPALTE': 'spalte_in_großbuchstaben'})

Umbenennen von Säulen mit numerischen Präfixen oder Suffixen

Säulen mit numerischen Präfixen oder Suffixen können mit einer Funktion oder einem Wörterbuch umbenannt werden:

# Umbenennen von Säulen mit numerischen Präfixen oder Suffixen
df = df.rename(columns={'spalte1': 'neuer_spalte_1', 'spalte2': 'neuer_spalte_2'})

Kombinieren von Umbenennungen mit anderen Pandas-Operationen

Umbenennen von Säulen während des Imports von Daten

Sie können Säulen während des Datenimports umbenennen, indem Sie den DataFrame-Konstruktor oder die read_csv()-Funktion verwenden:

# Umbenennen von Säulen während des Datenimports
df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]}, columns=['neuer_spaltenname_1', 'neuer_spaltenname_2'])
df = pd.read_csv('data.csv', names=['neuer_spaltenname_1', 'neuer_spaltenname_2'])

Umbenennen von Säulen nach Daten-Transformation

Sie können auch Säulen nach Daten-Transformationen umbenennen, wie z. B. dem Zusammenführen oder Gruppieren von Daten:

# Umbenennen von Säulen nach Daten-Transformation
zusammengeführter_df = pd.merge(df1, df2, on='gemeinsame_spalte')
zusammengeführter_df = zusammengeführter_df.rename(columns={'gemeinsame_spalte': 'umbenannte_gemeinsame_spalte'})

Umbenennen von Säulen vor der Datenvisualisierung

Das Umbenennen von Säulen kann auch vor der Erstellung von Datenvisualisierungen sinnvoll sein, um sicherzustellen, dass die Spaltennamen klar und aussagekräftig sind:

# Umbenennen der Spalten vor der Datenvisualisierung
df = df.rename(columns={'column_a': 'Umsatz', 'column_b': 'Gewinn'})

Funktionen

Funktionen sind wiederverwendbare Codeblöcke, die eine bestimmte Aufgabe ausführen. Sie ermöglichen es Ihnen, Logik zu kapseln und Ihren Code modularer und einfacher wartbar zu machen.

Definition von Funktionen

Um eine Funktion in Python zu definieren, verwenden Sie das Schlüsselwort def, gefolgt vom Funktionsnamen, einer Klammer und einem Doppelpunkt. Innerhalb der Funktion können Sie beliebigen gültigen Python-Code verwenden.

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

In diesem Beispiel definieren wir eine Funktion namens begrüßen, die einen einzelnen Parameter name erwartet. Wenn wir diese Funktion aufrufen, wird eine Begrüßungsnachricht ausgegeben.

Funktionsparameter

Funktionen können null oder mehrere Parameter akzeptieren. Parameter sind Variablen, die der Funktion übergeben werden, wenn sie aufgerufen wird. Sie ermöglichen es der Funktion, Eingaben anzunehmen und basierend auf diesen Eingaben verschiedene Operationen durchzuführen.

def zahlen_addieren(a, b):
   ergebnis = a + b
   print(f"Die Summe von {a} und {b} ist {ergebnis}.")
 
zahlen_addieren(5, 3)  # Ausgabe: Die Summe von 5 und 3 ist 8.
zahlen_addieren(10, 20)  # Ausgabe: Die Summe von 10 und 20 ist 30.

In diesem Beispiel nimmt die Funktion zahlen_addieren zwei Parameter a und b entgegen und führt damit die Addition aus.

Return-Anweisungen

Funktionen können auch Werte mit der return-Anweisung zurückgeben. Dies ermöglicht es Ihnen, das Ergebnis einer Funktion in anderen Teilen Ihres Codes zu verwenden.

def quadrat(x):
   return x ** 2
 
ergebnis = quadrat(4)
print(ergebnis)  # Ausgabe: 16

In diesem Beispiel nimmt die Funktion quadrat einen einzelnen Parameter x entgegen und gibt das Quadrat dieser Zahl zurück. Wir speichern das Ergebnis anschließend in der Variablen ergebnis und geben es aus.

Standardparameter

Sie können auch Standardwerte für Funktionparameter festlegen, die verwendet werden, wenn beim Aufruf der Funktion kein Wert angegeben wird.

def begrüßen(name, nachricht="Hallo"):
   print(f"{nachricht}, {name}!")
 
begrüßen("Alice")  # Ausgabe: Hallo, Alice!
begrüßen("Bob", "Hi")  # Ausgabe: Hi, Bob!

In diesem Beispiel hat die Funktion begrüßen zwei Parameter: name und nachricht. Der Parameter nachricht hat den Standardwert "Hallo", daher wird der Standardwert verwendet, wenn kein Wert angegeben wird.

Variable-Länge-Argumente

Manchmal wissen Sie im Voraus nicht, wie viele Argumente eine Funktion akzeptieren muss. Python erlaubt es Ihnen, Funktionen zu definieren, die eine beliebige Anzahl von Argumenten mit der Syntax *args akzeptieren können.

def zahlen_summieren(*args):
   summe = 0
   for num in args:
       summe += num
   return summe
 
print(zahlen_summieren(1, 2, 3))  # Ausgabe: 6
print(zahlen_summieren(4, 5, 6, 7, 8))  # Ausgabe: 30

In diesem Beispiel kann die Funktion zahlen_summieren eine beliebige Anzahl von Argumenten akzeptieren, die in einem Tupel namens args gesammelt werden. Die Funktion iteriert dann über das Tupel args und summiert alle Zahlen auf.

Schlüsselwortargumente

Neben den positionsabhängigen Argumenten unterstützt Python auch Schlüsselwortargumente, die mit der Syntax Schlüssel=Wert übergeben werden. Dies ermöglicht es Ihnen, die Namen der Argumente beim Aufruf der Funktion anzugeben.

def personen_info(name, alter, stadt):
   print(f"Name: {name}")
   print(f"Alter: {alter}")
   print(f"Stadt: {stadt}")
 
personen_info(name="Alice", alter=30, stadt="New York")
personen_info(stadt="London", alter=25, name="Bob")

In diesem Beispiel nimmt die Funktion personen_info drei Parameter name, alter und stadt entgegen. Bei Aufruf der Funktion können wir die Argumente mit ihren Namen angeben, und die Reihenfolge der Argumente spielt keine Rolle.

Geltungsbereich

Der Geltungsbereich einer Variablen bestimmt, wo sie in Ihrem Code zugegriffen und geändert werden kann. Python hat die folgenden Geltungsbereiche:

  • Lokaler Geltungsbereich: Variablen, die innerhalb einer Funktion oder eines Codeblocks definiert sind.
  • Globaler Geltungsbereich: Variablen, die außerhalb einer Funktion oder eines Codeblocks definiert sind.
  • Eingebauter Geltungsbereich: Variablen und Funktionen, die Teil der Python-Sprache sind.
x = 10  # Globaler Geltungsbereich
 
def meine_funktion():
   y = 5  # Lokaler Geltungsbereich
   print(f"Innerhalb der Funktion, x = {x}")
   print(f"Innerhalb der Funktion, y = {y}")
 
meine_funktion()
print(f"Außerhalb der Funktion, x = {x}")
# print(f"Außerhalb der Funktion, y = {y}")  # Das würde einen NameError verursachen

In diesem Beispiel ist x eine globale Variable und y eine lokale Variable innerhalb der Funktion meine_funktion. Wir können sowohl innerhalb als auch außerhalb der Funktion auf x zugreifen, aber y ist nur innerhalb der Funktion zugänglich.

Module

Module sind Python-Dateien, die Definitionen und Anweisungen enthalten. Sie ermöglichen es Ihnen, Ihren Code in wiederverwendbare Komponenten zu organisieren und Funktionalitäten über verschiedene Teile Ihrer Anwendung hinweg zu teilen.

Um ein Modul zu verwenden, können Sie es am Anfang Ihres Python-Skripts importieren.

import math
 
ergebnis = math.sqrt(25)
print(ergebnis)  # Ausgabe: 5.0

In diesem Beispiel importieren wir das eingebaute Modul math, das verschiedene mathematische Funktionen und Konstanten zur Verfügung stellt. Wir verwenden dann die Funktion sqrt aus dem math-Modul, um die Quadratwurzel von 25 zu berechnen.

Sie können auch bestimmte Funktionen oder Variablen aus einem Modul mit dem Schlüsselwort from importieren.

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

Diese Vorgehensweise ermöglicht es Ihnen, auf die importierten Funktionen oder Variablen direkt zuzugreifen, ohne sie mit dem Modulnamen voranstellen zu müssen.

Pakete

Pakete sind Sammlungen von Modulen, die in hierarchischen Verzeichnissen organisiert sind. Sie bieten eine Möglichkeit, Ihren Code zu strukturieren und Namenskonflikte zu vermeiden.

Um ein Paket zu erstellen, müssen Sie ein Verzeichnis mit einer __init__.py-Datei erstellen. Diese Datei kann leer sein, ist aber erforderlich, damit Python das Verzeichnis als Paket behandelt.

mein_paket/
   __init__.py
   modul1.py
   modul2.py

Sie können dann Module aus dem Paket mit der Punktnotation importieren.

import mein_paket.modul1
ergebnis = mein_paket.modul1.meine_funktion()
 
from mein_paket import modul2
ergebnis = modul2.eine_andere_funktion()

Pakete ermöglichen es Ihnen, Ihren Code in logische Einheiten zu organisieren und erleichtern die Verwaltung und Verteilung Ihrer Anwendung.

Fazit

In diesem Tutorial haben wir eine Vielzahl von Python-Konzepten behandelt, darunter Funktionen, Parameter, Rückgabeanweisungen, Standardparameter, variable Argumente, Schlüsselwortargumente, Geltungsbereich, Module und Pakete. Diese Funktionen sind entscheidend für den Aufbau komplexerer und wartbarerer Python-Anwendungen.

Durch das Verständnis und die Anwendung dieser Konzepte werden Sie in der Lage sein, effizienteren, modulareren und wiederverwendbaren Code zu schreiben. Denken Sie daran, mit diesen Konzepten zu üben und zu experimentieren, um Ihr Verständnis zu festigen und ein versierterer Python-Programmierer zu werden.

MoeNagy Dev