Python
Pandas Rename: Ein Anfängerleitfaden zum mühelosen Umbenennen

Pandas Rename: Ein Anfängerleitfaden zum mühelosen Umbenennen

MoeNagy Dev

Pandas Rename: Grundlagen verstehen

Vorstellung der Methode pandas.DataFrame.rename()

Die Methode pandas.DataFrame.rename() ist ein leistungsstolles Werkzeug zum Umbenennen von Spalten und Indizes (Zeilen und Spalten) eines pandas DataFrame. Diese Methode ermöglicht es Ihnen, die Namen Ihrer Daten flexibel und effizient zu ändern, um mit Ihren Daten einfacher zu arbeiten und sie besser zu verstehen.

Umbenennen von Spalten

Um Spalten in einem DataFrame umzubenennen, können Sie den Parameter columns der Methode rename() verwenden. Sie können ein Wörterbuch oder eine Funktion übergeben, um die neuen Spaltennamen festzulegen.

import pandas as pd
 
# Beispiel DataFrame erstellen
df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6], 'C': [7, 8, 9]})
 
# Spalten nach Namen umbenennen
df = df.rename(columns={'A': 'alpha', 'B': 'beta', 'C': 'gamma'})
print(df)

Ausgabe:

   alpha  beta  gamma
0      1     4      7
1      2     5      8
2      3     6      9

Umbenennen von Indizes (Zeilen und Spalten)

Die Methode rename() kann auch verwendet werden, um die Zeilenindizes (Index) und Spaltenindizes eines DataFrames umzubenennen. Sie können den Parameter index verwenden, um die Zeilen umzubenennen, und den Parameter columns, um die Spalten umzubenennen.

# Zeilen und Spalten umbenennen
df = df.rename(index={0: 'eins', 1: 'zwei', 2: 'drei'}, columns={'alpha': 'A', 'beta': 'B', 'gamma': 'C'})
print(df)

Ausgabe:

        A  B  C
eins    1  4  7
zwei    2  5  8
drei    3  6  9

Mehrere Umbenennungen gleichzeitig handhaben

Sie können auch mehrere Umbenennungen gleichzeitig durchführen, indem Sie ein Wörterbuch oder eine Funktion an die Methode rename() übergeben.

# Mehrere Spalten und Indizes gleichzeitig umbenennen
df = df.rename(index={'eins': 'erstes', 'zwei': 'zweites', 'drei': 'drittes'},
               columns={'A': 'X', 'B': 'Y', 'C': 'Z'})
print(df)

Ausgabe:

        X  Y  Z
erstes  1  4  7
zweites 2  5  8
drittes 3  6  9

Pandas Rename: Umbenennen von Spalten

Umbenennen von Spalten nach Namen

Sie können Spalten umbenennen, indem Sie die alten und neuen Spaltennamen direkt im columns Parameter der Methode rename() angeben.

# Spalten nach Namen umbenennen
df = pd.DataFrame({'original_a': [1, 2, 3], 'original_b': [4, 5, 6], 'original_c': [7, 8, 9]})
df = df.rename(columns={'original_a': 'new_a', 'original_b': 'new_b', 'original_c': 'new_c'})
print(df)

Ausgabe:

   new_a  new_b  new_c
0      1      4      7
1      2      5      8
2      3      6      9

Umbenennen von Spalten mit einem Wörterbuch

Sie können auch ein Wörterbuch verwenden, um die alten Spaltennamen den neuen Spaltennamen zuzuordnen.

# Spalten mit einem Wörterbuch umbenennen
umbenennungs_wörterbuch = {'original_a': 'new_a', 'original_b': 'new_b', 'original_c': 'new_c'}
df = df.rename(columns=umbenennungs_wörterbuch)
print(df)

Ausgabe:

   new_a  new_b  new_c
0      1      4      7
1      2      5      8
2      3      6      9

Umbenennen von Spalten mit einer Funktion

Sie können auch eine Funktion verwenden, um die Spaltennamen zu ändern. Die Funktion sollte den ursprünglichen Spaltennamen als Eingabe entgegennehmen und den neuen Spaltennamen zurückgeben.

# Spalten mit einer Funktion umbenennen
def umbenennungs_funktion(spaltenname):
    if spaltenname.startswith('original_'):
        return spaltenname.replace('original_', 'new_')
    else:
        return spaltenname
 
df = df.rename(columns=umbenennungs_funktion)
print(df)

Ausgabe:

   new_a  new_b  new_c
0      1      4      7
1      2      5      8
2      3      6      9

Umgang mit Groß- und Kleinschreibung in Spaltennamen

Standardmäßig ist die Methode rename() bei der Groß- und Kleinschreibung von Spaltennamen unterscheidungsfähig. Wenn Sie eine Groß- und Kleinschreibungs-unempfindliche Umbenennung durchführen möchten, können Sie die Spaltennamen vor der Verwendung der Methode rename() in eine bestimmte Schreibweise umwandeln.

# Umgang mit Groß- und Kleinschreibung in Spaltennamen
df = pd.DataFrame({'OriginalA': [1, 2, 3], 'OriginalB': [4, 5, 6], 'OriginalC': [7, 8, 9]})
df = df.rename(columns={s.lower(): f'new_{s.lower()}' for s in df.columns})
print(df)

Ausgabe:

   new_originala  new_originalb  new_originalc
0             1              4              7
1             2              5              8
2             3              6              9

Umgang mit Spaltennamen, die mehrfach vorkommen

Wenn Ihr DataFrame Spalten mit gleichen Namen enthält, können Sie die Methode rename() verwenden, um die Duplikate aufzulösen.

# Umgang mit Spaltennamen, die mehrfach vorkommen
df = pd.DataFrame({'A': [1, 2, 3], 'A': [4, 5, 6], 'B': [7, 8, 9]})
df = df.rename(columns={'A': 'A_1', 'A.1': 'A_2'})
print(df)

Ausgabe:

   A_1  A_2  B
0    1    4  7
1    2    5  8
2    3    6  9

Pandas Rename: Umbenennen von Indizes

Umbenennen von Zeilen (Index)

Sie können den index Parameter der Methode rename() verwenden, um die Zeilenindizes (Index) eines DataFrames umzubenennen.

# Umbenennen von Zeilen (Index)
df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]}, index=['alter_index_1', 'alter_index_2', 'alter_index_3'])
df = df.rename(index={'alter_index_1': 'neuer_index_1', 'alter_index_2': 'neuer_index_2', 'alter_index_3': 'neuer_index_3'})
print(df)

Ausgabe:

               A  B
neuer_index_1  1  4
neuer_index_2  2  5
neuer_index_3  3  6

Umbenennen von Spalten (Columns)

Ähnlich können Sie den columns Parameter der Methode rename() verwenden, um die Spaltenindizes eines DataFrames umzubenennen.

# Umbenennen von Spalten (Columns)
df = pd.DataFrame({'alter_col_a': [1, 2, 3], 'alter_col_b': [4, 5, 6]}, index=['reihe_1', 'reihe_2', 'reihe_3'])
df = df.rename(columns={'alter_col_a': 'neuer_col_a', 'alter_col_b': 'neuer_col_b'})
print(df)

Ausgabe:

        neuer_col_a  neuer_col_b
reihe_1           1           4
reihe_2           2           5
reihe_3           3           6

Gleichzeitiges Umbenennen von Zeilen und Spalten

Sie können auch die rename() Methode verwenden, um sowohl die Zeilen- als auch die Spaltenindizes gleichzeitig umzubenennen.

# Gleichzeitiges Umbenennen von Zeilen und Spalten
df = pd.DataFrame({'alte_spalte_a': [1, 2, 3], 'alte_spalte_b': [4, 5, 6]}, index=['alte_zeile_1', 'alte_zeile_2', 'alte_zeile_3'])
df = df.rename(index={'alte_zeile_1': 'neue_zeile_1', 'alte_zeile_2': 'neue_zeile_2', 'alte_zeile_3': 'neue_zeile_3'},
               columns={'alte_spalte_a': 'neue_spalte_a', 'alte_spalte_b': 'neue_spalte_b'})
print(df)

Output:

              neue_spalte_a  neue_spalte_b
neue_zeile_1              1              4
neue_zeile_2              2              5
neue_zeile_3              3              6

Umgang mit hierarchischen Indizes (mehrstufige Indizes)

Die rename() Methode kann auch verwendet werden, um hierarchische Indizes (mehrstufige Indizes) in einem DataFrame umzubenennen.

# Umgang mit hierarchischen Indizes (mehrstufige Indizes)
df = pd.DataFrame([[1, 2, 3], [4, 5, 6], [7, 8, 9]],
                  index=pd.MultiIndex.from_tuples([('alte_level1', 'alte_level2'), ('neuer_level1', 'neuer_level2'), ('dritter_level1', 'dritter_level2')],
                                                 names=['level1', 'level2']),
                  columns=['alte_spalte_a', 'alte_spalte_b', 'alte_spalte_c'])
df = df.rename(index={'alte_level1': 'umbenannter_level1', 'neuer_level1': 'umbenannter_level1_2', 'dritter_level1': 'umbenannter_level1_3'},
               columns={'alte_spalte_a': 'neue_spalte_a', 'alte_spalte_b': 'neue_spalte_b', 'alte_spalte_c': 'neue_spalte_c'})
print(df)

Output:

                                neue_spalte_a  neue_spalte_b  neue_spalte_c
level1              level2
umbenannter_level1  alte_level2                1              2              3
umbenannter_level1_2 neuer_level2               4              5              6
umbenannter_level1_3 dritter_level2             7              8              9

Pandas Umbenennen: Fortgeschrittene Techniken

Bedingte Umbenennung basierend auf spezifischen Kriterien

Sie können eine Funktion verwenden, um bedingte Umbenennungen basierend auf spezifischen Kriterien durchzuführen.

# Bedingte Umbenennung basierend auf spezifischen Kriterien
df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6], 'C': [7, 8, 9]})
df = df.rename(columns=lambda x: 'neu_' + x if x in ['A', 'B'] else x)
print(df)

Output:

   neu_A  neu_B  C
0      1      4  7
1      2      5  8
2      3      6  9

Umbenennung mit regulären Ausdrücken

Sie können reguläre Ausdrücke verwenden, um komplexere Umbenennungsoperationen durchzuführen.

# Umbenennung mit regulären Ausdrücken
import re
 
df = pd.DataFrame({'feature_1': [1, 2, 3], 'feature_2': [4, 5, 6], 'ziel': [7, 8, 9]})
df = df.rename(columns=lambda x: re.sub(r'feature_(\d+)', r'neues_feature_\1', x))
print(df)

Output:

   neues_feature_1  neues_feature_2  ziel
0                1                4     7
1                2                5     8
2                3                6     9

Umbenennung mit inplace-Änderung

Standardmäßig liefert die rename() Methode ein neues DataFrame mit den umbenannten Spalten oder Indizes zurück. Wenn Sie das ursprüngliche DataFrame direkt ändern möchten, können Sie den Parameter inplace auf True setzen.

# Umbenennung mit inplace-Änderung
df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})
df.rename(columns={'A': 'neu_A', 'B': 'neu_B'}, inplace=True)
print(df)

Output:

   neu_A  neu_B
0      1      4
1      2      5
2      3      6

Listen und Tupel

Listen und Tupel sind zwei der am häufigsten verwendeten Datenstrukturen in Python. Sie ermöglichen das Speichern und Manipulieren von Datensammlungen.

Listen

Listen sind veränderbar, was bedeutet, dass Sie Elemente in der Liste nach der Erstellung hinzufügen, entfernen oder ändern können. Sie können eine Liste mit eckigen Klammern [] erstellen und die Elemente mit Kommas trennen.

fruits = ['Apfel', 'Banane', 'Kirsche']
print(fruits)  # Output: ['Apfel', 'Banane', 'Kirsche']

Sie können auf einzelne Elemente in einer Liste über ihren Index zugreifen, der bei 0 beginnt.

print(fruits[0])  # Output: 'Apfel'
print(fruits[1])  # Output: 'Banane'
print(fruits[-1])  # Output: 'Kirsche' (negativer Index beginnt am Ende)

Sie können auch Elemente in einer Liste ändern:

fruits[1] = 'Orange'
print(fruits)  # Output: ['Apfel', 'Orange', 'Kirsche']

Listen unterstützen verschiedene integrierte Methoden wie append(), insert(), remove() und sort().

fruits.append('Traube')
print(fruits)  # Output: ['Apfel', 'Orange', 'Kirsche', 'Traube']
 
fruits.insert(1, 'Birne')
print(fruits)  # Output: ['Apfel', 'Birne', 'Orange', 'Kirsche', 'Traube']
 
fruits.remove('Orange')
print(fruits)  # Output: ['Apfel', 'Birne', 'Kirsche', 'Traube']
 
fruits.sort()
print(fruits)  # Output: ['Apfel', 'Kirsche', 'Traube', 'Birne']

Tupel

Tupel sind ähnlich wie Listen, aber sie sind unveränderbar, was bedeutet, dass Sie ihre Elemente nach der Erstellung nicht mehr ändern können. Sie können ein Tupel mit Klammern () erstellen und die Elemente mit Kommas trennen.

point = (3, 4)
print(point)  # Output: (3, 4)

Sie können auf einzelne Elemente in einem Tupel über ihren Index zugreifen, genau wie bei Listen.

print(point[0])  # Output: 3
print(point[1])  # Output: 4

Sie können jedoch die Elemente in einem Tupel nicht ändern:

point[0] = 5  # TypeError: 'tuple' object does not support item assignment

Tupel sind nützlich, wenn Sie sicherstellen möchten, dass die Datenstruktur unverändert bleibt, z. B. beim Arbeiten mit Koordinaten oder anderen Arten von Daten, die nicht geändert werden sollten.

Bedingte Anweisungen

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

alter = 25
if alter < 18:
    print("Du bist minderjährig.")
elif alter < 65:
    print("Du bist erwachsen.")
else:
    print("Du bist Senior.")

In diesem Beispiel überprüft das Programm den Wert der Variablen alter und führt den entsprechenden Codeblock basierend auf der Bedingung aus.

Sie können auch logische Operatoren wie and, or und not verwenden, um mehrere Bedingungen zu kombinieren.

temperatur = 35
luftfeuchtigkeit = 80
if temperatur > 30 and luftfeuchtigkeit > 70:
    print("Es ist heiß und feucht draußen.")
else:
    print("Das Wetter ist angenehm.")

Python unterstützt auch den ternären Operator, mit dem Sie eine einfache if-else-Anweisung in einer einzigen Zeile schreiben können.

is_student = True
discount = 50 if is_student else 0
print(f"Ihr Rabatt beträgt {discount}%.")  # Ausgabe: Ihr Rabatt beträgt 50%.

In diesem Beispiel wird der Wert von discount auf 50 gesetzt, wenn is_student True ist, andernfalls auf 0.

Schleifen

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

For-Schleifen

Eine for-Schleife wird verwendet, um über eine Sequenz zu iterieren, wie z.B. eine Liste, ein Tupel oder einen String.

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

Dies gibt aus:

Apfel
Banane
Kirsche

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

for i in range(5):
    print(i)  # Ausgabe: 0 1 2 3 4

While-Schleifen

Eine while-Schleife wird verwendet, um einen Codeblock auszuführen, solange eine bestimmte Bedingung wahr ist.

count = 0
while count < 3:
    print(f"Iteration {count + 1}")
    count += 1

Dies gibt aus:

Iteration 1
Iteration 2
Iteration 3

Sie können auch die break- und continue-Anweisungen verwenden, um den Ablauf einer Schleife zu steuern.

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

In diesem Beispiel stoppt die Schleife, wenn sie die Zahl 3 erreicht, durch die break-Anweisung.

numbers = [1, 2, 3, 4, 5]
for num in numbers:
    if num % 2 == 0:
        continue
    print(num)  # Ausgabe: 1 3 5

In diesem Beispiel werden durch die continue-Anweisung gerade Zahlen übersprungen.

Funktionen

Funktionen in Python sind Blöcke von wiederverwendbarem Code, die eine bestimmte Aufgabe erfüllen. Sie können eine Funktion mit dem Schlüsselwort def definieren.

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

Funktionen können auch Parameter entgegennehmen und Werte zurückgeben.

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

Sie können auch Standardwerte für Funktionen festlegen.

def greet(name, message="Hallo"):
    print(f"{message}, {name}!")
 
greet("Alice")  # Ausgabe: Hallo, Alice!
greet("Bob", "Hi")  # Ausgabe: Hi, Bob!

Funktionen können auch verschachtelt sein, und Sie können Funktionen definieren, die andere Funktionen als Argumente entgegennehmen (Höherwertige Funktionen).

def zweimal_anwenden(func, arg):
    return func(func(arg))
 
def quadrat(x):
    return x * x
 
ergebnis = zweimal_anwenden(quadrat, 3)
print(ergebnis)  # Ausgabe: 81

In diesem Beispiel nimmt die Funktion zweimal_anwenden() eine Funktion func und ein Argument arg entgegen und wendet die Funktion zweimal auf das Argument an.

Module und Pakete

In Python können Sie Ihren Code in Module und Pakete organisieren, um ihn modularer und wiederverwendbarer zu machen.

Module

Ein Modul ist eine Datei mit Python-Definitionen und -Anweisungen. Sie können ein Modul mit der import-Anweisung importieren.

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

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

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

Pakete

Ein Paket ist eine Sammlung von Modulen, die in einer Verzeichnisstruktur organisiert sind. Sie können Ihre eigenen Pakete erstellen, um verwandte Module zusammenzufassen.

Angenommen, Sie haben folgende Verzeichnisstruktur:

my_package/
    __init__.py
    math_utils.py
    string_utils.py

In der Datei math_utils.py können Sie eine Funktion definieren:

def quadrat(x):
    return x * x

Um diese Funktion zu verwenden, können Sie sie aus dem Paket importieren:

from my_package.math_utils import quadrat
print(quadrat(5))  # Ausgabe: 25

Die Datei __init__.py wird verwendet, um den Inhalt des Pakets anzugeben und kann auch Initialisierungscode enthalten.

Fazit

In diesem Tutorial haben Sie verschiedene Python-Konzepte kennengelernt, einschließlich Listen, Tupel, bedingte Anweisungen, Schleifen, Funktionen und Module/Pakete. Diese sind fundamentale Bausteine der Python-Sprache und helfen Ihnen dabei, effizienteren und besser strukturierten Code zu schreiben.

Denken Sie daran, dass der beste Weg, Ihre Python-Kenntnisse zu verbessern, darin besteht, zu üben, zu experimentieren und die umfangreiche Python-Bibliothekslandschaft und -Werkzeuge zu erkunden. Bleiben Sie am Ball und viel Spaß beim Programmieren!

MoeNagy Dev