Python
Spalten in Python einfach umbenennen: Ein Anfängerleitfaden

Spalten in Python einfach umbenennen: Ein Anfängerleitfaden

MoeNagy Dev

Spaltenumbenennung in Pandas Dataframes

Verständnis von Pandas Dataframes

Pandas Dataframes sind die grundlegende Datenstruktur in der Pandas-Bibliothek, einem leistungsstarken Open-Source-Tool für Datenanalyse und -manipulation in Python. Dataframes sind zweidimensionale gelabelte Datenstrukturen, ähnlich wie Tabellenkalkulationen oder SQL-Tabellen, mit Zeilen und Spalten. Jede Spalte in einem Dataframe kann einen anderen Datentyp haben, was sie zu einer flexiblen und vielseitigen Datenstruktur für eine Vielzahl von Datenverarbeitungsaufgaben macht.

Zugriff und Modifikation von Spaltennamen

In Pandas können Sie auf die Spaltennamen eines Dataframes mit verschiedenen Methoden zugreifen und sie modifizieren. Die Spaltennamen werden als das columns-Attribut eines Dataframes gespeichert, das ein Index-Objekt ist. Sie können die aktuellen Spaltennamen anzeigen, indem Sie einfach das columns-Attribut ausgeben:

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

Umbenennung von Spalten mit der Methode rename()

Die primäre Methode zum Umbenennen von Spalten in einem Pandas Dataframe ist die Verwendung der Methode rename(). Diese Methode ermöglicht es Ihnen, eine oder mehrere Spalten auf einmal umzubenennen, und sie kann auf verschiedene Arten verwendet werden.

Umbenennung einer einzelnen Spalte

Um eine einzelne Spalte umzubenennen, können Sie der Methode rename() ein Wörterbuch übergeben, bei dem die Schlüssel die alten Spaltennamen und die Werte die neuen Spaltennamen sind:

# Umbenennung einer einzelnen Spalte
df = df.rename(columns={'A': 'neuer_spaltenname'})
print(df.columns)
# Ausgabe: Index(['neuer_spaltenname', 'B', 'C'], dtype='object')

Umbenennung mehrerer Spalten

Sie können auch mehrere Spalten auf einmal umbenennen, indem Sie ein Wörterbuch mit mehreren Schlüssel-Wert-Paaren übergeben:

# Umbenennung mehrerer Spalten
df = df.rename(columns={'B': 'spalte_b', 'C': 'spalte_c'})
print(df.columns)
# Ausgabe: Index(['neuer_spaltenname', 'spalte_b', 'spalte_c'], dtype='object')

Umbenennung von Spalten mit einem Wörterbuch

Anstatt die Spaltennamen direkt zu übergeben, können Sie auch ein Wörterbuch verwenden, um die alten Spaltennamen auf die neuen abzubilden:

# Umbenennung von Spalten mit einem Wörterbuch
umbenennungs_dict = {'neuer_spaltenname': 'spalte_a', 'spalte_b': 'spalte_b_neu', 'spalte_c': 'spalte_c_neu'}
df = df.rename(columns=umbenennungs_dict)
print(df.columns)
# Ausgabe: Index(['spalte_a', 'spalte_b_neu', 'spalte_c_neu'], dtype='object')

Umbenennung von Spalten mit einer Funktion

Sie können auch eine Funktion zum Umbenennen der Spalten verwenden. Die Funktion sollte den aktuellen Spaltennamen als Eingabe entgegennehmen und den neuen Spaltennamen zurückgeben:

# Umbenennung von Spalten mit einer Funktion
def umbenennungs_funktion(spaltenname):
    if spaltenname == 'spalte_a':
        return 'spalte_a_neu'
    elif spaltenname == 'spalte_b_neu':
        return 'spalte_b_umbenannt'
    else:
        return spaltenname
 
df = df.rename(columns=umbenennungs_funktion)
print(df.columns)
# Ausgabe: Index(['spalte_a_neu', 'spalte_b_umbenannt', 'spalte_c_neu'], dtype='object')

Umbenennung von Spalten direkt vs. Erstellung eines neuen Dataframes

Die rename()-Methode kann verwendet werden, um den ursprünglichen Dataframe direkt zu modifizieren oder einen neuen Dataframe mit den umbenannten Spalten zu erstellen. Standardmäßig gibt rename() einen neuen Dataframe zurück, aber Sie können den Parameter inplace=True verwenden, um den ursprünglichen Dataframe direkt zu modifizieren:

# Spalten in-place umbenennen
df.rename(columns={'spalte_a_neu': 'spalte_a_umbenannt'}, inplace=True)
print(df.columns)
# Ausgabe: Index(['spalte_a_umbenannt', 'spalte_b_umbenannt', 'spalte_c_neu'], dtype='object')
 
# Erstellung eines neuen Dataframes mit umbenannten Spalten
neuer_df = df.rename(columns={'spalte_b_umbenannt': 'spalte_b_neu'})
print(neuer_df.columns)
# Ausgabe: Index(['spalte_a_umbenannt', 'spalte_b_neu', 'spalte_c_neu'], dtype='object')

Umgang mit doppelten Spaltennamen

Wenn Sie versuchen, Spalten in Namen umzubenennen, die bereits im Dataframe vorhanden sind, wird Pandas eine ValueError-Ausnahme auswerfen. Um diesen Fall zu behandeln, können Sie die Parameter prefix oder suffix in der rename()-Methode verwenden:

# Umgang mit doppelten Spaltennamen
df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6], 'A': [7, 8, 9]})
print(df.columns)
# Ausgabe: Index(['A', 'B', 'A'], dtype='object')
 
# Spalten mit Präfix umbenennen
df = df.rename(columns={'A': 'A_neu', 'B': 'B_neu'})
print(df.columns)
# Ausgabe: Index(['A_neu', 'B_neu', 'A'], dtype='object')
 
# Spalten mit Suffix umbenennen
df = df.rename(columns={'A': 'A_suffix', 'B': 'B_suffix'})
print(df.columns)
# Ausgabe: Index(['A_suffix', 'B_suffix', 'A'], dtype='object')

Umbenennung von Spalten in gruppierten Dataframes

Bei der Arbeit mit gruppierten Dataframes können Sie auch die Spalten umbenennen. Dies kann nützlich sein, wenn Sie mehrere Aggregationen oder Transformationen auf den Dataframe angewendet haben und den resultierenden Spalten aussagekräftigere Namen geben möchten:

# Umbenennung von Spalten in gruppierten Dataframes
df = pd.DataFrame({'A': [1, 2, 3, 1, 2, 3], 'B': [4, 5, 6, 7, 8, 9]})
gruppiert_df = df.groupby('A').agg({'B': ['min', 'max']})
print(gruppiert_df.columns)
# Ausgabe: MultiIndex([('B', 'min'), ('B', 'max')], )
 
# Umbenennung von Spalten im gruppierten Dataframe
gruppiert_df = gruppiert_df.rename(columns={'B': {'min': 'B_min', 'max': 'B_max'}})
print(gruppiert_df.columns)
# Ausgabe: MultiIndex([('B_min',), ('B_max',)], )

Umbenennung von Spalten in anderen Datenstrukturen

Umbenennung von Spalten in Numpy-Arrays

Obwohl Pandas Dataframes die häufigste Möglichkeit sind, mit tabellarischen Daten in Python zu arbeiten, müssen Sie gelegentlich Spalten in Numpy-Arrays umbenennen. Da Numpy-Arrays keine benannten Spalten wie Dataframes haben, können Sie die zip()-Funktion und eine List Comprehension verwenden, um die Spalten umzubenennen:

import numpy as np
 

Erstellen eines Numpy-Arrays

arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) column_names = ['A', 'B', 'C']

Umbenennen von Spalten in einem Numpy-Array

renamed_arr = np.column_stack([arr[:, i].tolist() for i, name in enumerate(column_names)]) renamed_arr = np.column_stack([renamed_arr, column_names]) print(renamed_arr)

Ausgabe:

[['1' 'A']

['2' 'B']

['3' 'C']

['4' 'A']

['5' 'B']

['6' 'C']

['7' 'A']

['8' 'B']

['9' 'C']]


### Umbenennen von Spalten in CSV-Dateien

Wenn Sie Spalten in einer CSV-Datei umbenennen möchten, können Sie die Datei in ein Pandas-Datenframe laden, die Spalten umbenennen und dann das Datenframe in eine neue CSV-Datei schreiben:

```python
# Umbenennen von Spalten in einer CSV-Datei
df = pd.read_csv('input.csv')
df = df.rename(columns={'alte_spaltenbezeichnung': 'neue_spaltenbezeichnung'})
df.to_csv('output.csv', index=False)

Umbenennen von Spalten in SQL-Tabellen

Bei der Arbeit mit SQL-Datenbanken können Sie Spalten mit SQL-Befehlen umbenennen. Die Syntax kann je nach dem verwendeten Datenbankmanagementsystem (DBMS) geringfügig variieren, aber der allgemeine Ansatz ist der gleiche:

-- Umbenennen von Spalten in einer SQL-Tabelle
ALTER TABLE tabellenname
RENAME COLUMN alte_spaltenbezeichnung TO neue_spaltenbezeichnung;

Alternativ können Sie einen SQL-Client oder eine ORM (Object-Relational Mapping)-Bibliothek wie SQLAlchemy verwenden, um mit der Datenbank zu interagieren und Spalten in Python programmgesteuert umzubenennen.

Erweiterte Techniken für das Umbenennen von Spalten

Batch-Umbenennung von Spalten mit regulären Ausdrücken

Für komplexere Szenarien beim Umbenennen von Spalten können Sie reguläre Ausdrücke verwenden, um Stapelumbenennungsoperationen durchzuführen. Dies kann nützlich sein, wenn Sie eine einheitliche Benennungskonvention anwenden oder mehrere Änderungen an den Spaltennamen auf einmal vornehmen müssen:

# Batch-Umbenennung von Spalten mit regulären Ausdrücken
import re
 
df = pd.DataFrame({'feature_1': [1, 2, 3], 'feature_2': [4, 5, 6], 'zielvariable': [7, 8, 9]})
 
# Umbenennen von Spalten mit regulärem Ausdruck
df = df.rename(columns=lambda x: re.sub(r'feature_(\d+)', r'feature\1', x))
print(df.columns)
# Ausgabe: Index(['feature1', 'feature2', 'zielvariable'], dtype='object')

Umbenennen von Spalten basierend auf dem Spaltenindex

In einigen Fällen möchten Sie möglicherweise Spalten basierend auf ihrer Indexposition anstelle ihrer Namen umbenennen. Dies können Sie erreichen, indem Sie eine Liste oder ein Wörterbuch an die rename()-Methode übergeben, wobei die Schlüssel die Spaltenindizes und die Werte die neuen Spaltennamen sind:

# Umbenennen von Spalten basierend auf dem Spaltenindex
df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6], 'C': [7, 8, 9]})
 
# Umbenennen von Spalten mit einer Liste
df = df.rename(columns={0: 'neue_spalte_a', 1: 'neue_spalte_b', 2: 'neue_spalte_c'})
print(df.columns)
# Ausgabe: Index(['neue_spalte_a', 'neue_spalte_b', 'neue_spalte_c'], dtype='object')
 
# Umbenennen von Spalten mit einem Wörterbuch
df = df.rename(columns={0: 'spalte_a', 1: 'spalte_b', 2: 'spalte_c'})
print(df.columns)
# Ausgabe: Index(['spalte_a', 'spalte_b', 'spalte_c'], dtype='object')

Umbenennen von Spalten mit Multiindex Dataframes

Bei der Arbeit mit Multiindex-Dataframes können Sie die Spalten sowohl auf der äußeren als auch auf der inneren Ebene des Index umbenennen. Dies kann nützlich sein, wenn Sie hierarchische oder verschachtelte Datenstrukturen haben:

# Umbenennen von Spalten in Multiindex-Dataframes
df = pd.DataFrame({('gruppe1', 'A'): [1, 2, 3], ('gruppe1', 'B'): [4, 5, 6], ('gruppe2', 'C'): [7, 8, 9]})
 
# Umbenennen von Spalten auf der äußeren Ebene
df = df.rename(columns={('gruppe1', 'A'): ('gruppe1', 'neues_A'), ('gruppe1', 'B'): ('gruppe1', 'neues_B')})
print(df.columns)
# Ausgabe: MultiIndex([('gruppe1', 'neues_A'), ('gruppe1', 'neues_B'), ('gruppe2', 'C')], )
 
# Umbenennen von Spalten auf der inneren Ebene
df = df.rename(columns={('gruppe1', 'neues_A'): ('gruppe1', 'spalte_a'), ('gruppe1', 'neues_B'): ('gruppe1', 'spalte_b')})

Funktionen in Python sind wiederverwendbare Codeblöcke, die eine bestimmte Aufgabe ausführen. Sie können Argumente entgegennehmen, Operationen durchführen und optional einen Wert zurückgeben.

Funktionen definieren

Die allgemeine Syntax zum Definieren einer Funktion in Python lautet:

def funktionsname(argumente):
    # Funktionskörper
    return wert

Hier ist ein Beispiel für eine einfache Funktion, die zwei Zahlen addiert:

def addiere_zahlen(a, b):
    return a + b
 
ergebnis = addiere_zahlen(3, 4)
print(ergebnis)  # Ausgabe: 7

Argumente von Funktionen

Funktionen können verschiedene Arten von Argumenten akzeptieren, einschließlich Positional-Argumenten, Keyword-Argumenten und Default-Argumenten.

Positional-Argumente werden in der Reihenfolge übergeben, in der sie in der Funktion definiert sind:

def grüße(name, nachricht):
    print(f"{name}, {nachricht}!")
 
grüße("Alice", "Guten Morgen")  # Ausgabe: Alice, Guten Morgen!

Keyword-Argumente ermöglichen es Ihnen, das Argument per Namen anzugeben:

def grüße(name, nachricht):
    print(f"{name}, {nachricht}!")
 
grüße(nachricht="Einen schönen Tag noch", name="Bob")  # Ausgabe: Bob, Einen schönen Tag noch!

Default-Argumente haben einen Standardwert, der verwendet wird, wenn das Argument nicht angegeben wird:

def grüße(name, nachricht="Hallo"):
    print(f"{name}, {nachricht}!")
 
grüße("Charlie")  # Ausgabe: Charlie, Hallo!
grüße("Charlie", "Auf Wiedersehen")  # Ausgabe: Charlie, Auf Wiedersehen!

Rückgabewerte

Funktionen können Werte mit dem return-Statement zurückgeben. Sie können einen einzelnen Wert, mehrere Werte oder sogar komplexe Datenstrukturen wie Listen oder Dictionaries zurückgeben.

def berechne_fläche(breite, höhe):
    fläche = breite * höhe
    return fläche
 
ergebnis = berechne_fläche(5, 10)
print(ergebnis)  # Ausgabe: 50

Sie können auch mehrere Werte zurückgeben, indem Sie sie mit Kommas trennen:

def hole_name_und_alter():
    name = "Alice"
    alter = 30
    return name, alter
 
name, alter = hole_name_und_alter()
print(f"Name: {name}, Alter: {alter}")  # Ausgabe: Name: Alice, Alter: 30

Gültigkeitsbereich und Sichtbarkeit von Variablen

In Python haben Variablen einen definierten Gültigkeitsbereich, der bestimmt, wo sie zugegriffen und geändert werden können. Es gibt zwei Hauptgültigkeitsbereiche: global und lokal.

Globale Variablen sind im gesamten Programm zugänglich, während lokale Variablen nur innerhalb der Funktion oder des Blocks zugänglich sind, in dem sie definiert sind.

global_variable = 10
 
def meine_funktion():
    lokale_variable = 20
    print(f"Lokale Variable: {lokale_variable}")
    print(f"Globale Variable: {global_variable}")
 
meine_funktion()  # Ausgabe: Lokale Variable: 20, Globale Variable: 10
 
print(lokale_variable)  # Fehler: lokale_variable ist nicht definiert

Module und Pakete

Die modulare Struktur von Python ermöglicht es Ihnen, Ihren Code in wiederverwendbare und wartungsfähige Komponenten namens Module und Pakete zu organisieren.

Module

Ein Modul ist eine Datei, die Python-Definitionen und -Anweisungen enthält. Sie können Module in Ihren Code importieren, um die von ihnen definierten Funktionen, Klassen und Variablen zu verwenden.

# math_utils.py
def addiere(a, b):
    return a + b
 
def subtrahiere(a, b):
    return a - b
# main.py
import math_utils
 
ergebnis = math_utils.addiere(5, 3)
print(ergebnis)  # Ausgabe: 8

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

# main.py
from math_utils import addiere, subtrahiere
 
ergebnis = addiere(5, 3)
print(ergebnis)  # Ausgabe: 8

Pakete

Pakete sind Sammlungen von verwandten Modulen, die in einer hierarchischen Struktur organisiert sein können. Dadurch können Sie Ihren Code effektiver gruppieren und verwalten.

mein_paket/
    __init__.py
    math_utils/
        __init__.py
        basic.py
        advanced.py
# main.py
from mein_paket.math_utils.basic import addiere
from mein_paket.math_utils.advanced import berechne_fläche
 
ergebnis = addiere(5, 3)
fläche = berechne_fläche(4, 5)
print(ergebnis)  # Ausgabe: 8
print(fläche)    # Ausgabe: 20

Standardbibliothek und Pakete von Drittanbietern

Python wird mit einer umfangreichen Standardbibliothek geliefert, die eine Vielzahl von integrierten Modulen für verschiedene Aufgaben bietet. Darüber hinaus hat die Python-Community viele Pakete von Drittanbietern entwickelt, die mit Paketverwaltungswerkzeugen wie pip installiert werden können.

import os
import math
import datetime
import requests

Fazit

In diesem Tutorial haben Sie die grundlegenden Konzepte von Python kennengelernt, einschließlich Datenstrukturen, Kontrollstrukturen, Funktionen und Modulen. Sie haben gesehen, wie man Python-Code schreibt und ausführt, sowie wie man den Code mithilfe von Modulen und Paketen organisiert.

Python ist eine vielseitige und leistungsfähige Sprache mit einem umfangreichen Ökosystem von Bibliotheken und Werkzeugen. Wenn Sie diese grundlegenden Konzepte beherrschen, sind Sie auf dem besten Weg, ein versierter Python-Entwickler zu werden, der in der Lage ist, eine Vielzahl von Programmieraufgaben und -projekten zu bewältigen.

Denken Sie daran, dass der beste Weg, Ihre Python-Kenntnisse zu verbessern, darin besteht, zu üben, zu experimentieren und weiter zu lernen. Erforschen Sie die Standardbibliothek, versuchen Sie verschiedene Pakete von Drittanbietern aus und erstellen Sie eigene Projekte, um Ihr Verständnis zu festigen und praktische Erfahrung zu sammeln.

Viel Spaß beim Programmieren!

MoeNagy Dev