Python
Spalten einfach umbenennen: Ein Anfängerleitfaden

Spalten einfach umbenennen: Ein Anfängerleitfaden

MoeNagy Dev

Bedeutung der Umbenennung von Spalten

Das Umbenennen von Spalten in Python ist eine grundlegende Aufgabe zur Datenmanipulation, die die Lesbarkeit, das Verständnis und die Verwendbarkeit Ihrer Daten erheblich verbessern kann. Hier sind einige wichtige Gründe, warum das Umbenennen von Spalten wichtig ist:

Verbesserung der Lesbarkeit und des Verständnisses der Daten

Spaltennamen sind die Hauptmethode, wie Benutzer und Analysten mit den Daten interagieren und sie verstehen. Indem Sie Spalten in aussagekräftigere und bedeutungsvolle Namen umbenennen, können Sie Ihre Daten intuitiver und einfacher handhaben, was die kognitive Belastung für alle Personen, die mit dem Datensatz interagieren, verringert.

Ausrichtung der Spaltennamen auf die Unternehmenssprache

In vielen realen Szenarien stimmen die ursprünglichen Spaltennamen möglicherweise nicht mit der Unternehmenssprache oder den in einer Organisation verwendeten Begriffen überein. Wenn Sie Spalten umbenennen, um den gängig verwendeten Begriffen zu entsprechen, können Sie die Lücke zwischen den technischen Daten und dem geschäftlichen Kontext überbrücken, was es den Interessenvertretern erleichtert, die Daten zu interpretieren und damit zu arbeiten.

Vorbereitung von Daten für nachgelagerte Analysen und Berichterstellung

Konsistente und gut benannte Spalten sind für nachgelagerte Datenanalysen, maschinelles Lernen und Berichterstellung von entscheidender Bedeutung. Wenn Spaltennamen klar und aussagekräftig sind, fällt es leichter, wartbaren und interpretierbaren Code zu schreiben, aussagekräftige Visualisierungen zu erstellen und Berichte zu generieren, die die Daten effektiv kommunizieren.

Methoden zum Umbenennen von Spalten

Python bietet mehrere Methoden und Ansätze zum Umbenennen von Spalten in Ihren Datenstrukturen. Schauen wir uns die gängigsten Techniken an:

Verwendung der Methode rename()

Die Methode rename() ist eine leistungsstarke und flexible Möglichkeit, Spalten in Python umzubenennen, insbesondere bei der Arbeit mit Pandas DataFrames.

Umbenennen einzelner Spalten

Um eine einzelne Spalte umzubenennen, können Sie die Methode rename() verwenden und die alten und neuen Spaltennamen angeben:

import pandas as pd
 
# Erstellen eines Beispieldatenrahmens
df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})
 
# Eine einzelne Spalte umbenennen
df = df.rename(columns={'A': 'Spalte_A'})

Umbenennen mehrerer Spalten

Sie können die Methode rename() auch verwenden, um mehrere Spalten auf einmal umzubenennen:

# Mehrere Spalten umbenennen
df = df.rename(columns={'B': 'Spalte_B', 'Spalte_A': 'Merkmal_A'})

Umbenennen von Spalten mit einem Wörterbuch

Anstatt die alten und neuen Spaltennamen einzeln zu übergeben, können Sie ein Wörterbuch verwenden, um die alten Namen den neuen zuzuordnen:

# Spalten mithilfe eines Wörterbuchs umbenennen
umbenennen_wörterbuch = {'A': 'Merkmal_A', 'B': 'Merkmal_B'}
df = df.rename(columns=umbenennen_wörterbuch)

Umbenennen von Spalten mit einer Funktion

Sie können der Methode rename() auch eine Funktion übergeben, die es Ihnen ermöglicht, eine komplexere Umbenennungslogik anzuwenden:

# Spalten mithilfe einer Funktion umbenennen
def umbenennen_funktion(sp):
    return sp.lower().replace(' ', '_')
 
df = df.rename(columns=umbenennen_funktion)

Direkte Bearbeitung der Spaltennamen

Neben der Verwendung der Methode rename() können Sie auch die Spaltennamen direkt bearbeiten, indem Sie auf die Spaltennamen Ihrer Datenstruktur zugreifen und diese aktualisieren.

Zugriff und Aktualisierung der Spaltennamen

Bei Pandas DataFrames können Sie auf die Spaltennamen zugreifen und sie mithilfe des Attributs columns aktualisieren:

# Direkter Zugriff und Aktualisierung der Spaltennamen
df.columns = ['Merkmal_A', 'Merkmal_B']

Umgang mit Konflikten bei den Spaltennamen

Beim Umbenennen von Spalten können Situationen auftreten, in denen die neuen Spaltennamen mit vorhandenen in Konflikt geraten. In solchen Fällen können Sie das inplace-Argument verwenden, um den DataFrame direkt zu aktualisieren, oder einen neuen DataFrame mit den umbenannten Spalten erstellen:

# Umgang mit Konflikten bei den Spaltennamen
df = df.rename(columns={'A': 'Merkmal_A', 'Merkmal_A': 'Neues_Merkmal_A'})

Umbenennen von Spalten in verschiedenen Datenstrukturen

Die Techniken zum Umbenennen von Spalten sind nicht auf Pandas DataFrames beschränkt. Sie können ähnliche Ansätze auch auf andere Datenstrukturen wie NumPy-Arrays und Wörterbücher anwenden.

Pandas DataFrames

Wie oben gezeigt, können Sie die Methode rename() oder das Attribut columns verwenden, um Spalten in Pandas DataFrames umzubenennen.

NumPy-Arrays

Bei der Arbeit mit NumPy-Arrays können Sie die Spaltennamen ändern, indem Sie das Attribut dtype.names bearbeiten:

import numpy as np
 
# Erstellen eines Beispiels für ein NumPy-Array
arr = np.array([(1, 2), (3, 4)], dtype=[('A', int), ('B', int)])
 
# Umbenennen von Spalten in einem NumPy-Array
arr.dtype.names = ('Merkmal_A', 'Merkmal_B')

Wörterbücher und Listen von Wörterbüchern

Bei Wörterbüchern und Listen von Wörterbüchern können Sie die Schlüssel umbenennen, um die Spaltennamen zu aktualisieren:

# Umbenennen von Spalten in einem Wörterbuch
daten = {'A': [1, 2, 3], 'B': [4, 5, 6]}
umbenannte_daten = {
    'Merkmal_A': daten['A'],
    'Merkmal_B': daten['B']
}
 
# Umbenennen von Spalten in einer Liste von Wörterbüchern
einzelheiten = [{'A': 1, 'B': 4}, {'A': 2, 'B': 5}, {'A': 3, 'B': 6}]
umbenannte_einzelheiten = [
    {'Merkmal_A': rec['A'], 'Merkmal_B': rec['B']}
    for rec in einzelheiten
]

Umgang mit komplexen Szenarien bei der Namensgebung von Spalten

Während die grundlegenden Techniken zum Umbenennen von Spalten einfach sind, können Sie auf komplexere Szenarien stoßen, die zusätzliche Überlegungen erfordern.

Umbenennen von Spalten mit Sonderzeichen

Spaltennamen können Sonderzeichen wie Leerzeichen, Satzzeichen oder nicht-ASCII-Zeichen enthalten. In solchen Fällen müssen Sie diese Zeichen entsprechend behandeln, wenn Sie die Spalten umbenennen.

# Umbenennen von Spalten mit Sonderzeichen
df = pd.DataFrame({'A B': [1, 2, 3], 'C,D': [4, 5, 6]})
df = df.rename(columns={'A B': 'Merkmal_A', 'C,D': 'Merkmal_C_D'})

Umbenennen von Spalten mit Leerzeichen oder gemischter Groß- und Kleinschreibung

Spaltennamen können Leerzeichen enthalten oder in gemischtem Fall sein, was die Arbeit mit ihnen schwierig machen kann. Sie können verschiedene Techniken zur Zeichenmanipulation verwenden, um diese Fälle zu handhaben.

# Umbenennen von Spalten mit Leerzeichen oder gemischtem Fall
df = pd.DataFrame({'Kundenname': [1, 2, 3], 'Bestellnummer': [4, 5, 6]})
df = df.rename(columns={
    'Kundenname': 'kundenname',
    'Bestellnummer': 'bestellnummer'
})

Umbenennen von Spalten basierend auf Mustern oder Präfixen/Suffixen

In einigen Szenarien möchten Sie möglicherweise Spalten basierend auf Mustern oder gemeinsamen Präfixen/Suffixen in den Spaltennamen umbenennen. Dies kann mit regulären Ausdrücken oder anderen Techniken zur Zeichenmanipulation erreicht werden.

# Umbenennen von Spalten basierend auf Mustern oder Präfixen/Suffixen
df = pd.DataFrame({
    'umsatz_2021': [100, 200, 300],
    'umsatz_2022': [150, 250, 350],
    'kosten_2021': [50, 70, 90],
    'kosten_2022': [60, 80, 100]
})
 
# Umbenennen von Spalten basierend auf Präfix
df = df.rename(columns=lambda x: x.replace('umsatz_', 'einnahmen_'))
 
# Umbenennen von Spalten basierend auf Suffix
df = df.rename(columns=lambda x: x.replace('_2021', '_letztes_jahr'))

Im nächsten Abschnitt werden wir erkunden, wie man den Umbenennungsprozess für Spalten automatisieren und in Datenpipelines integrieren kann.

Variablen und Datentypen

Numerische Datentypen

Python unterstützt verschiedene numerische Datentypen, einschließlich:

  • Ganze Zahlen (int): Ganze Zahlen wie 42 oder -17.
  • Fließkommazahlen (float): Zahlen mit Dezimalpunkten wie 3.14 oder -2.5.
  • Komplexe Zahlen (complex): Zahlen mit realen und imaginären Teilen wie 2+3j.

Sie können verschiedene arithmetische Operationen mit diesen Datentypen durchführen, wie Addition, Subtraktion, Multiplikation, Division und mehr.

# Ganze Zahlen
x = 42
y = -17
print(x + y)  # Ausgabe: 25
 
# Fließkommazahlen
a = 3.14
b = -2.5
print(a * b)  # Ausgabe: -7.85
 
# Komplexe Zahlen
c = 2 + 3j
d = 4 - 1j
print(c * d)  # Ausgabe: (8+11j)

Zeichenketten-Datentyp

Zeichenketten in Python sind Sequenzen von Zeichen, die in einfachen Anführungszeichen ('), doppelten Anführungszeichen ("), dreifachen Anführungszeichen (''' oder """) eingeschlossen sind. Zeichenketten unterstützen eine Vielzahl von Operationen wie Konkatenation, Indexierung und Slicing.

# Einzeilige Zeichenketten
message = 'Hallo, Welt!'
name = "Alice"
 
# Mehrzeilige Zeichenketten
gedicht = '''
Rosen sind rot,
Veilchen sind blau,
Zucker ist süß,
Und du auch.
'''
 
print(message)      # Ausgabe: Hallo, Welt!
print(name[0])     # Ausgabe: A
print(gedicht[:10])   # Ausgabe: Rosen sind

Boolean-Datentyp

Der boolsche Datentyp in Python repräsentiert logische Werte, entweder True oder False. Booleans werden häufig in bedingten Anweisungen und logischen Operationen verwendet.

ist_student = True
ist_erwachsen = False
 
print(ist_student)   # Ausgabe: True
print(ist_erwachsen)    # Ausgabe: False

Kein-Datentyp

Der None-Datentyp repräsentiert das Fehlen eines Wertes. Er wird häufig verwendet, um anzuzeigen, dass eine Variable oder Funktion keinen Rückgabewert hat.

ergebnis = None
print(ergebnis)  # Ausgabe: None

Typkonvertierung

Python ermöglicht Ihnen die Konvertierung zwischen verschiedenen Datentypen mithilfe von integrierten Funktionen wie int(), float(), str() und bool().

# In Ganzzahl konvertieren
x = int(3.14)
print(x)  # Ausgabe: 3
 
# In Gleitkommazahl konvertieren
y = float('4.2')
print(y)  # Ausgabe: 4.2
 
# In Zeichenkette konvertieren
z = str(42)
print(z)  # Ausgabe: '42'
 
# In Boolean konvertieren
ist_positiv = bool(10)
print(ist_positiv)  # Ausgabe: True

Operatoren und Ausdrücke

Arithmetische Operatoren

Python unterstützt die folgenden arithmetischen Operatoren:

  • Addition (+), Subtraktion (-), Multiplikation (*), Division (/)
  • Ganzzahlige Division (//), Modulo (%), Potenzierung (**)
a = 10
b = 4
 
print(a + b)     # Ausgabe: 14
print(a - b)     # Ausgabe: 6
print(a * b)     # Ausgabe: 40
print(a / b)     # Ausgabe: 2.5
print(a // b)    # Ausgabe: 2
print(a % b)     # Ausgabe: 2
print(a ** b)    # Ausgabe: 10000

Vergleichsoperatoren

Python stellt die folgenden Vergleichsoperatoren zur Verfügung:

  • Gleich (==), Ungleich (!=)
  • Größer als (>), Kleiner als (<)
  • Größer als oder gleich (>=), Kleiner als oder gleich (<=)
x = 7
y = 3
 
print(x == y)    # Ausgabe: False
print(x != y)    # Ausgabe: True
print(x > y)     # Ausgabe: True
print(x < y)     # Ausgabe: False
print(x >= y)    # Ausgabe: True
print(x <= y)    # Ausgabe: False

Logische Operatoren

Python unterstützt die folgenden logischen Operatoren:

  • UND (and), ODER (or), NICHT (not)
a = True
b = False
 
print(a and b)   # Ausgabe: False
print(a or b)    # Ausgabe: True
print(not a)     # Ausgabe: False

Bitweise Operatoren

Bitweise Operatoren in Python führen Operationen auf den einzelnen Bits von Ganzzahlwerten aus.

  • UND (&), ODER (|), XOR (^), NICHT (~)
  • Linksverschiebung (<<), Rechtsverschiebung (>>)
x = 0b1010  # Binär 10
y = 0b1100  # Binär 12
 
print(x & y)     # Ausgabe: 8 (Binär 1000)
print(x | y)     # Ausgabe: 14 (Binär 1110)
print(x ^ y)     # Ausgabe: 6 (Binär 110)
print(~x)        # Ausgabe: -11 (Binär -1011)
print(x << 1)    # Ausgabe: 20 (Binär 10100)
print(y >> 1)    # Ausgabe: 6 (Binär 110)

Operatorpriorität

Wenn mehrere Operatoren in einem Ausdruck verwendet werden, befolgt Python eine spezifische Reihenfolge der Priorität, um die Reihenfolge der Operationen zu bestimmen.

Die Prioritätsreihenfolge, von höchster zu niedrigster Priorität, lautet:

  1. Klammern ()
  2. Potenzierung **
  3. Unäre Operatoren (+, -, ~)
  4. Multiplikation, Division, Ganzzahlige Division, Modulo (*, /, //, %)
  5. Addition, Subtraktion (+, -)
  6. Bitweise Verschiebungsoperatoren (<<, >>)
  7. Bitweises UND &
  8. Bitweises XOR ^
  9. Bitweises ODER |
  10. Vergleichsoperatoren (<, >, <=, >=, ==, !=)
  11. Boolesches NICHT not
  12. Boolesches UND and
  13. Boolesches ODER or

Sie können Klammern verwenden, um die Standardpriorität außer Kraft zu setzen.

ausdruck = 2 * 3 + 4 ** 2 - 1
print(ausdruck)  # Ausgabe: 21
 
ausdruck_mit_klammern = 2 * (3 + 4) ** 2 - 1
print(ausdruck_mit_klammern)  # Ausgabe: 81

Kontrollstrukturen

Bedingte Anweisungen

Python bietet die if-elif-else-Anweisung für bedingte Ausführung.

age = 18
if age < 18:
    print("Du bist minderjährig.")
elif age < 21:
    print("Du bist erwachsen.")
else:
    print("Du bist volljährig.")

Schleifen

Python bietet zwei Haupt-Schleifenkonstrukte: for und while.

# For-Schleife
for i in range(5):
    print(i)  # Ausgabe: 0 1 2 3 4
 
# While-Schleife
count = 0
while count < 3:
    print(count)
    count += 1  # Ausgabe: 0 1 2

Abbrechen und Fortsetzen

Die break-Anweisung wird verwendet, um eine Schleife zu beenden, während die continue-Anweisung verwendet wird, um die aktuelle Iteration zu überspringen und zur nächsten überzugehen.

# Beispiel für Abbrechen
for i in range(5):
    if i == 3:
        break
    print(i)  # Ausgabe: 0 1 2
 
# Beispiel für Fortsetzen
for j in range(5):
    if j == 2:
        continue
    print(j)  # Ausgabe: 0 1 3 4

Ternärer Operator

Der ternäre Operator von Python, auch als bedingter Ausdruck bezeichnet, ermöglicht es Ihnen, einfache if-else-Anweisungen auf eine kürzere Weise zu schreiben.

age = 25
is_adult = "Ja" if age >= 18 else "Nein"
print(is_adult)  # Ausgabe: Ja

Funktionen

Funktionen in Python werden mit dem def-Schlüsselwort definiert, gefolgt vom Funktionsnamen, Parametern (falls vorhanden) und dem Funktionskörper.

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

Funktionsparameter

Funktionen können Parameter akzeptieren, die als Eingabe für die Funktion verwendet werden.

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

Standardparameter

Sie können Standardwerte für Funktionparameter angeben, die verwendet werden, wenn das Argument nicht angegeben wird.

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

Argumente mit variabler Länge

Python ermöglicht es Ihnen, Funktionen zu definieren, die eine variable Anzahl von Argumenten unter Verwendung der Syntax *args und **kwargs akzeptieren.

def print_numbers(*args):
    for arg in args:
        print(arg)
 
print_numbers(1, 2, 3)   # Ausgabe: 1 2 3
print_numbers(4, 5, 6, 7, 8)  # Ausgabe: 4 5 6 7 8

Gültigkeitsbereich und Namensraum

Python hat ein klar definiertes Gültigkeitsbereichs- und Namensraumsystem, das bestimmt, wo Variablen abgerufen werden können.

x = 10  # Globale Variable
 
def my_function():
    x = 5  # Lokale Variable
    print(f"Innerhalb der Funktion: {x}")
 
my_function()  # Ausgabe: Innerhalb der Funktion: 5
print(f"Außerhalb der Funktion: {x}")  # Ausgabe: Außerhalb der Funktion: 10

Module und Pakete

Importieren von Modulen

Python ermöglicht es Ihnen, Module zu importieren, die Dateien mit Funktionen, Klassen und Variablen enthalten, mithilfe der import-Anweisung.

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

Sie können auch bestimmte Elemente aus einem Modul mit dem from-Schlüsselwort importieren.

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

Erstellen von Modulen

Um Ihr eigenes Modul zu erstellen, speichern Sie Ihren Python-Code einfach in einer Datei mit der Erweiterung .py.

# my_module.py
def greet(name):
    print(f"Hallo, {name}!")

Sie können das Modul dann in Ihrem Python-Script importieren und verwenden.

import my_module
my_module.greet("Alice")  # Ausgabe: Hallo, Alice!

Pakete

Pakete in Python sind eine Möglichkeit, Module in eine hierarchische Struktur zu organisieren. Ein Paket ist ein Verzeichnis, das ein oder mehrere Python-Module enthält.

my_package/
    __init__.py
    math_utils.py
    string_utils.py

Sie können Elemente aus einem Paket mit der Punkt-Notation importieren.

import my_package.math_utils
result = my_package.math_utils.add_numbers(3, 4)
print(result)  # Ausgabe: 7

Fazit

In diesem Tutorial haben Sie die grundlegenden Konzepte von Python kennengelernt, einschließlich Variablen, Datentypen, Operatoren, Ausdrücken, Kontrollstrukturen, Funktionen und Modulen. Diese Bausteine werden Ihnen helfen, komplexere und leistungsfähigere Python-Programme zu schreiben. Üben Sie regelmäßig und erkunden Sie das umfangreiche Ökosystem von Python-Bibliotheken und -Frameworks, um Ihre Fähigkeiten zu erweitern und noch anspruchsvollere Projekte anzugehen.

MoeNagy Dev