Python
Pandas: Spaltennamen einfach ändern - Ein Anfängerleitfaden

Pandas: Spaltennamen einfach ändern - Ein Anfängerleitfaden

MoeNagy Dev

Spaltennamen in Pandas ändern

Überblick über Pandas DataFrame

Ein Pandas DataFrame ist eine zweidimensionale, tabellarische Datenstruktur mit Zeilen und Spalten. Jede Spalte in einem DataFrame kann einen anderen Datentyp haben, und die Spalten können individuell abgerufen und manipuliert werden.

Verständnis der Struktur eines Pandas DataFrames

import pandas as pd
 
# Beispiel DataFrame erstellen
data = {'Name': ['Alice', 'Bob', 'Charlie'],
        'Age': [25, 30, 35],
        'City': ['New York', 'London', 'Paris']}
 
df = pd.DataFrame(data)
print(df)

Ausgabe:

       Name  Age       City
0    Alice   25  New York
1      Bob   30    London
2  Charlie   35     Paris

Zugriff auf und Manipulation von Spaltendaten

Sie können einzelne Spalten eines DataFrames mithilfe des Spaltennamens als Attribut oder als Schlüssel in eckigen Klammern abrufen:

print(df['Name'])
print(df.Age)

Ausgabe:

0    Alice
1      Bob
2  Charlie
Name: Name, dtype: object
0    25
1    30
2    35
Name: Age, dtype: int64

Sie können auch neuen Werten eine Spalte zuweisen:

df['Country'] = ['USA', 'UK', 'France']
print(df)

Ausgabe:

       Name  Age       City Country
0    Alice   25  New York     USA
1      Bob   30    London      UK
2  Charlie   35     Paris   France

Umbenennen von Spalten

Das Umbenennen von Spalten in einem Pandas DataFrame ist eine häufige Aufgabe bei der Arbeit mit Daten. Es gibt mehrere Möglichkeiten, dies zu erreichen.

Verwendung der Methode rename()

Die Methode rename() ermöglicht es Ihnen, eine oder mehrere Spalten umzubenennen. Sie können ein Wörterbuch oder eine Funktion an den Parameter columns übergeben.

# Umbenennen einer einzelnen Spalte mithilfe eines Wörterbuchs
df = df.rename(columns={'Name': 'Voller Name'})
print(df)

Ausgabe:

       Voller Name  Age       City Country
0           Alice   25  New York     USA
1             Bob   30    London      UK
2         Charlie   35     Paris   France

Übergeben eines Wörterbuchs an rename()

Sie können ein Wörterbuch an den Parameter columns übergeben, wobei die Schlüssel die alten Spaltennamen und die Werte die neuen Spaltennamen sind.

# Umbenennen mehrerer Spalten mithilfe eines Wörterbuchs
df = df.rename(columns={'Voller Name': 'Teilnehmer', 'Age': 'Alter'})
print(df)

Ausgabe:

       Teilnehmer  Alter       City Country
0           Alice     25  New York     USA
1             Bob     30    London      UK
2         Charlie     35     Paris   France

Übergeben einer Funktion an rename()

Sie können auch eine Funktion an den Parameter columns übergeben, die auf jeden Spaltennamen angewendet wird.

# Umbenennen von Spalten mithilfe einer Funktion
df = df.rename(columns=lambda x: x.lower().replace(' ', '_'))
print(df)

Ausgabe:

       teilnehmer  alter       city country
0           alice     25  New York     USA
1             bob     30    London      UK
2         charlie     35     Paris   France

Mehrere Spalten auf einmal umbenennen

Sie können mehrere Spalten umbenennen, indem Sie ein Wörterbuch oder eine Liste von Tupeln an den Parameter columns übergeben.

# Mehrere Spalten auf einmal umbenennen
df = df.rename(columns={'teilnehmer': 'name', 'alter': 'alter'})
print(df)

Ausgabe:

       name  alter       city country
0     alice     25  New York     USA
1       bob     30    London      UK
2   charlie     35     Paris   France

Direkte Modifikation der Spaltennamen

Sie können Spaltennamen auch direkt ändern, indem Sie auf das Attribut columns des DataFrames zugreifen.

Zugriff auf und Aktualisierung von Spaltennamen

# Zugriff auf und Aktualisierung von Spaltennamen
df.columns = ['Name', 'Alter', 'Ort', 'Nationalität']
print(df)

Ausgabe:

       Name  Alter    Ort Nationalität
0     alice     25  New York         USA
1       bob     30    London           UK
2   charlie     35     Paris        France

Verwendung von List Comprehension zum Umbenennen von Spalten

Sie können List Comprehension verwenden, um eine Transformation auf die Spaltennamen anzuwenden.

# Umbenennen von Spalten mithilfe von List Comprehension
df.columns = [col.upper() for col in df.columns]
print(df)

Ausgabe:

       NAME  ALTER    ORT NATIONALITÄT
0     alice     25  New York         USA
1       bob     30    London           UK
2   charlie     35     Paris        France

Behandlung fehlender oder doppelter Spaltennamen

Es ist wichtig, Fälle zu behandeln, in denen Spaltennamen fehlen oder dupliziert sind.

Ermittlung und Behebung von fehlenden Spaltennamen

# Erstellen eines DataFrame mit fehlendem Spaltennamen
data = {'Name': ['Alice', 'Bob', 'Charlie'], 'Age': [25, 30, 35]}
df = pd.DataFrame(data)
print(df)

Ausgabe:

       Name   Age
0    Alice   25
1      Bob   30
2  Charlie   35

Um den fehlenden Spaltennamen zu beheben, können Sie die Methode rename() verwenden oder direkt einen neuen Namen dem Attribut columns zuweisen.

# Umbenennen des fehlenden Spaltennamens
df = df.rename(columns={None: 'Neue Spalte'})
print(df)

Ausgabe:

       Name   Age     Neue Spalte
0    Alice   25            NaN
1      Bob   30            NaN
2  Charlie   35            NaN

Behandlung von doppelten Spaltennamen

# Erstellen eines DataFrame mit doppelten Spaltennamen
data = {'Name': ['Alice', 'Bob', 'Charlie'], 'Age': [25, 30, 35], 'Name': [1, 2, 3]}
df = pd.DataFrame(data)
print(df)

Ausgabe:

       Name  Age  Name
0    Alice   25     1
1      Bob   30     2
2  Charlie   35     3

Um die doppelten Spaltennamen aufzulösen, können Sie die Methode rename() oder die Methode set_axis() verwenden.

# Auflösen von doppelten Spaltennamen
df = df.rename(columns={'Name_x': 'Name', 'Name_y': 'Name_2'})
print(df)

Ausgabe:

       Name  Age  Name_2
0    Alice   25       1

Advancede Techniken zur Umbenennung von Spalten

Pandas bietet zusätzliche Techniken für fortgeschrittenere Szenarien zur Umbenennung von Spalten.

Umbenennung von Spalten basierend auf einem spezifischen Muster

# Umbenennung von Spalten basierend auf einem Muster
data = {'feature_1': [1, 2, 3], 'feature_2': [4, 5, 6], 'target': [10, 20, 30]}
df = pd.DataFrame(data)
df = df.rename(columns=lambda x: x.replace('feature_', 'col_'))
print(df)

Ausgabe:

   col_1  col_2  target
0      1      4      10
1      2      5      20
2      3      6      30

Umbenennung von Spalten mit regulären Ausdrücken

# Umbenennung von Spalten mit regulären Ausdrücken
data = {'feature1_a': [1, 2, 3], 'feature1_b': [4, 5, 6], 'feature2_a': [7, 8, 9]}
df = pd.DataFrame(data)
df = df.rename(columns=lambda x: re.sub(r'feature(\d+)_(\w+)', r'col_\1_\2', x))
print(df)

Ausgabe:

   col_1_a  col_1_b  col_2_a
0        1        4        7
1        2        5        8
2        3        6        9

Umbenennung von Spalten in einem mehrstufigen Spaltenindex

# Umbenennung von Spalten in einem mehrstufigen Spaltenindex
data = {('group1', 'A'): [1, 2, 3], ('group1', 'B'): [4, 5, 6], ('group2', 'C'): [7, 8, 9]}
df = pd.DataFrame(data)
df.columns = pd.MultiIndex.from_tuples([('Group 1', 'Feature A'), ('Group 1', 'Feature B'), ('Group 2', 'Feature C')])
df = df.rename(columns=lambda x: (x[0].replace('Group', 'G'), x[1]))
print(df)

Ausgabe:

   (G 1, Feature A)  (G 1, Feature B)  (G 2, Feature C)
0                 1                 4                 7
1                 2                 5                 8
2                 3                 6                 9

Umbenennung von Spalten während der Erstellung eines DataFrame

Es ist auch möglich, Spalten beim Erstellen eines Pandas DataFrame umzubenennen.

Übergeben von Spaltennamen während der Initialisierung des DataFrames

# Umbenennung von Spalten während der Initialisierung des DataFrames
data = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
df = pd.DataFrame(data, columns=['A', 'B', 'C'])
print(df)

Ausgabe:

   A  B  C
0  1  2  3
1  4  5  6
2  7  8  9

Umbenennung von Spalten beim Lesen von Daten aus Dateien

# Umbenennung von Spalten beim Lesen von Daten aus einer Datei
df = pd.read_csv('data.csv', names=['Name', 'Age', 'City'])
print(df)

Beibehalten der Spaltenreihenfolge nach Umbenennung

Bei der Umbenennung von Spalten ist es wichtig, die Reihenfolge der Spalten zu beachten.

Beibehaltung der ursprünglichen Spaltenreihenfolge

# Beibehaltung der ursprünglichen Spaltenreihenfolge
df = df[['Name', 'Age', 'City']]
print(df)

Ausgabe:

       Name  Age       City
0    Alice   25  New York
1      Bob   30    London
2  Charlie   35     Paris

Neuanordnung von Spalten nach der Umbenennung

# Neuanordnung von Spalten nach der Umbenennung
df = df[['City', 'Name', 'Age']]
print(df)

Ausgabe:

       City       Name  Age
0  New York    Alice   25
1    London      Bob   30
2     Paris  Charlie   35

Umbenennung von Spalten in mehreren DataFrames anwenden

Bei der Arbeit mit mehreren zusammenhängenden DataFrames ist es oft notwendig, eine einheitliche Benennung von Spalten sicherzustellen.

Umbenennung von Spalten in zusammenhängenden DataFrames

# Umbenennung von Spalten in zusammenhängenden DataFrames
df1 = pd.DataFrame({'Name': ['Alice', 'Bob'], 'Age': [25, 30]})
df2 = pd.DataFrame({'Name': ['Charlie', 'David'], 'City': ['New York', 'London']})
 
df1 = df1.rename(columns={'Name': 'Teilnehmer', 'Age': 'Alter'})
df2 = df2.rename(columns={'Name': 'Teilnehmer', 'City': 'Ort'})
 
print(df1)
print(df2)

Ausgabe:

   Teilnehmer  Alter
0       Alice         25
1         Bob         30

   Teilnehmer   Ort
0     Charlie  New York
1       David    London

Sicherstellung einheitlicher Benennung von Spalten

# Sicherstellung einheitlicher Benennung von Spalten
df1 = df1.rename(columns={'Teilnehmer': 'Name', 'Alter': 'Alter'})
df2 = df2.rename(columns={'Teilnehmer': 'Name', 'Ort': 'Stadt'})
 
print(df1)
print(df2)

Ausgabe:

      Name  Alter
0   Alice   25
1     Bob   30

      Name     Stadt
0  Charlie  New York
1    David   London

Automatisierung von Workflows zur Umbenennung von Spalten

Um die Umbenennung von Spalten effizienter zu gestalten, können Sie wiederverwendbare Funktionen entwickeln und in Ihre Datenverarbeitungspipelines integrieren.

Schleifen und bedingte Anweisungen

Schleifen und bedingte Anweisungen sind in Python essentiell, um den Ablauf Ihres Programms zu steuern und wiederholte Aufgaben zu automatisieren. Werfen wir einen Blick auf einige gängige Schleifenstrukturen und bedingte Anweisungen.

For-Schleifen

For-Schleifen werden verwendet, um über eine Sequenz (wie eine Liste, ein Tupel oder einen String) oder andere iterierbare Objekte zu iterieren. Hier ist ein Beispiel für eine For-Schleife, die über eine Liste von Zahlen iteriert und jede einzelne ausgibt:

numbers = [1, 2, 3, 4, 5]
for num in numbers:
    print(num)

Ausgabe:

1
2
3
4
5

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

for i in range(1, 6):
    print(i)

Ausgabe:

1
2
3
4
5

While-Schleifen

While-Schleifen werden verwendet, um einen Codeblock auszuführen, solange eine bestimmte Bedingung wahr ist. Hier ist ein Beispiel für eine While-Schleife, die von 5 bis 1 herunterzählt:

count = 5
while count > 0:
    print(count)
    count -= 1
print("Blast off!")

Ausgabe:

5
4
3
2
1
Blast off!

Bedingte Anweisungen

Bedingte Anweisungen wie if-elif-else ermöglichen es Ihnen, Entscheidungen basierend auf bestimmten Bedingungen zu treffen. Hier ist ein Beispiel für eine einfache if-else-Anweisung:

age = 18
if age >= 18:
    print("Sie sind volljährig.")
else:
    print("Sie sind minderjährig.")

Ausgabe:

Sie sind volljährig.

Sie können auch elif verwenden, um mehrere Bedingungen zu überprüfen:

score = 85
if score >= 90:
    print("Sie haben eine A-Note erzielt!")
elif score >= 80:
    print("Sie haben eine B-Note erzielt.")
elif score >= 70:
    print("Sie haben eine C-Note erzielt.")
else:
    print("Sie müssen sich verbessern.")

Ausgabe:

Sie haben eine B-Note erzielt.

Verschachtelte Schleifen und bedingte Anweisungen

Sie können Schleifen und bedingte Anweisungen ineinander verschachteln, um komplexere Logik zu erstellen. Hier ist ein Beispiel für eine verschachtelte for-Schleife, die überprüft, ob eine Zahl prim ist:

for num in range(2, 21):
    is_prime = True
    for i in range(2, int(num ** 0.5) + 1):
        if num % i == 0:
            is_prime = False
            break
    if is_prime:
        print(f"{num} ist eine Primzahl.")
    else:
        print(f"{num} ist keine Primzahl.")

Ausgabe:

2 ist eine Primzahl.
3 ist eine Primzahl.
4 ist keine Primzahl.
5 ist eine Primzahl.
6 ist keine Primzahl.
7 ist eine Primzahl.
8 ist keine Primzahl.
9 ist keine Primzahl.
10 ist keine Primzahl.
11 ist eine Primzahl.
12 ist keine Primzahl.
13 ist eine Primzahl.
14 ist keine Primzahl.
15 ist keine Primzahl.
16 ist keine Primzahl.
17 ist eine Primzahl.
18 ist keine Primzahl.
19 ist eine Primzahl.
20 ist keine Primzahl.

Funktionen

Funktionen sind ein grundlegendes Bausteine in Python. Sie ermöglichen es Ihnen, zusammengehörigen Code zu gruppieren und Ihre Programme organisierter, modularer und wiederverwendbarer 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. Der Code, der den Körper der Funktion bildet, wird eingerückt.

Hier ist ein Beispiel für eine einfache Funktion, die den Benutzer grüßt:

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

Ausgabe:

Hallo, Alice!

Sie können auch Funktionen definieren, die mehrere Argumente akzeptieren:

def zahlen_addieren(a, b):
    return a + b
 
ergebnis = zahlen_addieren(5, 3)
print(ergebnis)

Ausgabe:

8

Standard- und Schlüsselwortargumente

Funktionen können Standardargumente haben, die verwendet werden, wenn ein Parameter beim Funktionsaufruf nicht angegeben wird. Hier ist ein Beispiel:

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

Ausgabe:

Hallo, Alice!
Hi, Bob!

Sie können auch Schlüsselwortargumente verwenden, um Funktionen aufzurufen, was den Code lesbarer machen kann:

def fläche_berechnen(länge, breite):
    return länge * breite
 
# Verwendung von Schlüsselwortargumenten
fläche = fläche_berechnen(länge=5, breite=3)
print(fläche)

Ausgabe:

15

Gültigkeitsbereich und Gültigkeit von Variablen

Der Gültigkeitsbereich einer Variable bestimmt, wo sie in Ihrem Code verwendet werden kann. Python hat einen lokalen und globalen Gültigkeitsbereich. Variablen, die innerhalb einer Funktion definiert werden, haben einen lokalen Gültigkeitsbereich, während Variablen, die außerhalb von Funktionen definiert werden, einen globalen Gültigkeitsbereich haben.

Hier ist ein Beispiel, das den Unterschied verdeutlicht:

globale_variable = "Ich bin global!"
 
def meine_funktion():
    lokale_variable = "Ich bin lokal."
    print(globale_variable)
    print(lokale_variable)
 
meine_funktion()
print(globale_variable)
# print(lokale_variable)  # Dies führt zu einem Fehler

Ausgabe:

Ich bin global!
Ich bin lokal.
Ich bin global!

Beachten Sie, dass lokale_variable außerhalb der Funktion meine_funktion() nicht verwendet werden kann, da sie einen lokalen Gültigkeitsbereich hat.

Rekursive Funktionen

Rekursive Funktionen sind Funktionen, die sich selbst aufrufen, um ein Problem zu lösen. Hier ist ein Beispiel für eine rekursive Funktion, die die Fakultät einer Zahl berechnet:

def fakultät(n):
    if n == 0 or n == 1:
        return 1
    else:
        return n * fakultät(n - 1)
 
print(fakultät(5))

Ausgabe:

120

In diesem Beispiel ruft die fakultät()-Funktion sich selbst mit einem kleineren Wert von n auf, bis sie den Basisfall erreicht (wenn n 0 oder 1 ist), und gibt dann 1 zurück.

Module und Pakete

In Python werden Module und Pakete verwendet, um Code zu organisieren und wiederzuverwenden. Module sind einzelne Python-Dateien, während Pakete Sammlungen von zusammengehörigen Modulen sind.

Importieren von Modulen

Um Code aus einem Modul zu verwenden, müssen Sie es importieren. Hier ist ein Beispiel für das Importieren des integrierten math-Moduls:

import math
 
print(math.pi)
print(math.sqrt(16))

Ausgabe:

3.141592653589793
4.0

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

from math import pi, sqrt
 
print(pi)
print(sqrt(16))

Ausgabe:

3.141592653589793
4.0

Erstellen von Modulen

Um Ihr eigenes Modul zu erstellen, speichern Sie Ihren Python-Code einfach in einer Datei mit der Erweiterung .py. Zum Beispiel erstellen wir ein Modul namens my_module.py mit einer Funktion namens grüßen():

# my_module.py
def grüßen(name):
    print(f"Hallo, {name}!")

Sie können die grüßen()-Funktion dann in einer anderen Python-Datei importieren und verwenden:

# main.py
import my_module
 
my_module.grüßen("Alice")

Ausgabe:

Hallo, Alice!

Pakete

Pakete werden verwendet, um zusammengehörige Module in einer hierarchischen Struktur zu organisieren. Um ein Paket zu erstellen, müssen Sie ein Verzeichnis mit einer __init__.py-Datei erstellen. Hier ist ein Beispiel:

mein_paket/
    __init__.py
    math_utils.py
    string_utils.py

Die __init__.py-Datei kann leer sein, ist aber erforderlich, damit Python das Verzeichnis als Paket erkennt.

Sie können dann Funktionen aus den Modulen innerhalb des Pakets importieren:

# main.py
from mein_paket.math_utils import addieren
from mein_paket.string_utils import umdrehen
 
print(addieren(5, 3))
print(umdrehen("hallo"))

Ausgabe:

8
olleh

Fazit

In diesem Tutorial haben Sie die grundlegenden Konzepte von Schleifen, bedingten Anweisungen, Funktionen, Modulen und Paketen in Python kennengelernt. Diese Werkzeuge sind grundlegend für das Erstellen von robusten und dynamischen Programmen in Python.

Denken Sie daran, dass der beste Weg, Ihre Python-Kenntnisse zu verbessern, darin besteht, zu üben, zu experimentieren und weiter zu lernen. Erkunden Sie das umfangreiche Ökosystem von Python-Bibliotheken und -Modulen und zögern Sie nicht, in die offizielle Python-Dokumentation einzutauchen, um weitere detaillierte Informationen zu erhalten.

Viel Spaß beim Programmieren!

MoeNagy Dev