37. Integrierte Funktionen und nützliche Tools

Python bietet eine umfangreiche Sammlung integrierter Funktionen, die immer verfügbar sind, ohne dass Sie Module importieren müssen. Diese Funktionen bilden die Grundlage der alltäglichen Python-Programmierung und helfen Ihnen, effizient mit Daten, Sequenzen und Sammlungen zu arbeiten. In diesem Kapitel werden wir Pythons nützlichste integrierte Tools erkunden und lernen, wie Sie sie nutzen, um saubereren, ausdrucksstärkeren Code zu schreiben.

Pythons Typsystem verstehen

Bevor wir in konkrete integrierte Funktionen eintauchen, ist es hilfreich zu verstehen, wie Python seine Datentypen organisiert. Dieses Wissen hilft Ihnen vorherzusagen, welche Operationen mit welchen Typen funktionieren, und Fehlermeldungen zu verstehen, wenn sie auftreten.

Pythons Datentypen lassen sich aus zwei komplementären Perspektiven betrachten:

Typhierarchie: Wie Typen zusammenhängen

Das zeigt, wie Python Typen in Familien organisiert, basierend darauf, was sie SIND.

Fähigkeitsbasierte Sicht: Was Typen können

Für integrierte Funktionen ist wichtiger, was Typen TUN können:

Wichtige Fähigkeiten:

Iterable(iterable): Kann in for-Schleifen(loop) verwendet werden → Funktioniert mit sum(), any(), all(), sorted()
Collection(collection): Iterable mit len() → Funktioniert mit len() und dem in-Operator
Sequence(sequence): Collection mit Indizierung → Unterstützt [index] und Slicing [start:end]

Warum das wichtig ist

Integrierte Funktionen erfordern bestimmte Fähigkeiten:

Funktion	Erfordert	Funktioniert mit
`len()`	Collection	str, list, dict, set, tuple
`sum()`	Iterable aus Zahlen	list, tuple, set, range, generator
`sorted()`	Iterable	str, list, dict, set, tuple
`[index]`	Sequence	str, list, tuple, range

Wenn Sie diese Kategorien verstehen, hilft Ihnen das:

vorherzusagen, welche Funktionen mit welchen Typen funktionieren
Fehlermeldungen wie „object is not iterable“ zu verstehen
zu wissen, wann Sie indizieren können ([0]) und wann Sie nur schleifen können (for)

37.1) Häufige integrierte Funktionen (len, sum, min, max, abs, round)

Pythons am häufigsten verwendete integrierte Funktionen helfen Ihnen, gängige Operationen auf Daten auszuführen, ohne Schleifen oder komplexe Logik zu schreiben. Diese Funktionen sind optimiert, gut lesbar und bilden die Grundlage von pythonischem Code.

37.1.1) Längen messen mit len()

Die Funktion len() gibt die Anzahl der Elemente in einer Sammlung zurück. Sie funktioniert mit Strings, Listen, Tupeln, Dictionaries, Sets und jedem anderen Collection-Typ.

python

# Zeichen in einem String zählen
message = "Hello, World!"
print(len(message))  # Output: 13
 
# Elemente in einer Liste zählen
scores = [85, 92, 78, 90, 88]
print(len(scores))   # Output: 5
 
# Schlüssel-Wert-Paare in einem Dictionary zählen
student = {"name": "Bob", "age": 21, "major": "CS"}
print(len(student))  # Output: 3
 
# Eindeutige Elemente in einem Set zählen
unique_ids = {101, 102, 103, 101, 102}  # Duplikate entfernt
print(len(unique_ids))  # Output: 3

Die Funktion len() ist besonders nützlich, wenn Sie die Größe von Daten kennen müssen, bevor Sie sie verarbeiten:

python

# Daten abhängig von der Größe verarbeiten
data = [12, 45, 23, 67, 89, 34]
 
if len(data) < 5:
    print("Not enough data for analysis")
else:
    print(f"Analyzing {len(data)} data points")  # Output: Analyzing 6 data points
    average = sum(data) / len(data)
    print(f"Average: {average}")  # Output: Average: 45.0

37.1.2) Summen berechnen mit sum()

Die Funktion sum() addiert alle Zahlen in einem Iterable. Das ist deutlich sauberer, als eine Schleife zu schreiben, um Werte zu akkumulieren.

python

# Summe einer Zahlenliste bilden
prices = [19.99, 24.50, 15.75, 32.00]
total = sum(prices)
print(f"Total: ${total}")  # Output: Total: $92.24
 
# Summe eines Tupels bilden
daily_steps = (8500, 10200, 7800, 9500, 11000)
weekly_total = sum(daily_steps)
print(f"Total steps this week: {weekly_total}")  # Output: Total steps this week: 47000
 
# Summe eines range bilden
total_1_to_100 = sum(range(1, 101))
print(total_1_to_100)  # Output: 5050

Ein praktisches Beispiel, das sum() und len() kombiniert, um Durchschnitte zu berechnen:

python

# Durchschnittliche Testergebnisse berechnen
test_scores = [88, 92, 79, 85, 90, 87]
 
total_score = sum(test_scores)
num_tests = len(test_scores)
average_score = total_score / num_tests
 
print(f"Average score: {average_score:.1f}")  # Output: Average score: 86.8

Wichtige Einschränkung: sum() funktioniert nur mit Zahlen. Sie können es nicht verwenden, um Strings zu verketten oder Listen zu kombinieren:

python

# Das löst TypeError aus
words = ["Hello", " ", "World"]
# sentence = sum(words)  # TypeError: unsupported operand type(s)

37.1.3) Extremwerte finden mit min() und max()

Die Funktionen min() und max() finden die kleinsten und größten Werte in einem Iterable. Sie funktionieren mit Zahlen, Strings und allen Objekten, die verglichen werden können.

python

# Kleinste und größte Zahl finden
temperatures = [72, 68, 75, 70, 73, 69]
coldest = min(temperatures)
warmest = max(temperatures)
print(f"Temperature range: {coldest}°F to {warmest}°F")
# Output: Temperature range: 68°F to 75°F
 
# Kleinster und größter String (alphabetisch) finden
names = ["Zoe", "Alice", "Bob", "Charlie"]
first_alphabetically = min(names)
last_alphabetically = max(names)
print(f"First: {first_alphabetically}, Last: {last_alphabetically}")
# Output: First: Alice, Last: Zoe

Sie können auch mehrere Argumente direkt übergeben, statt eine Sammlung:

python

# Einzelwerte vergleichen
lowest = min(45, 23, 67, 12, 89)
highest = max(45, 23, 67, 12, 89)
print(f"Lowest: {lowest}, Highest: {highest}")
# Output: Lowest: 12, Highest: 89
 
# Nützlich, um einige konkrete Werte zu vergleichen
price1 = 19.99
price2 = 24.50
price3 = 15.75
cheapest = min(price1, price2, price3)
print(f"Cheapest option: ${cheapest}")  # Output: Cheapest option: $15.75

37.1.4) Absolute Werte mit abs() ermitteln

Die Funktion abs() gibt den absoluten Wert einer Zahl zurück – ihren Abstand zu Null, immer positiv. Das ist nützlich, wenn Sie sich für die Größe interessieren, aber nicht für die Richtung.

python

# Absolutwert negativer Zahlen
print(abs(-42))      # Output: 42
print(abs(-3.14))    # Output: 3.14
 
# Absolutwert positiver Zahlen (unverändert)
print(abs(42))       # Output: 42
print(abs(3.14))     # Output: 3.14
 
# Absolutwert von Null
print(abs(0))        # Output: 0

Ein häufiger Anwendungsfall ist das Berechnen von Differenzen, bei denen die Richtung keine Rolle spielt:

python

# Temperaturänderung berechnen (nur Betrag)
morning_temp = 65
evening_temp = 72
temperature_change = abs(evening_temp - morning_temp)
print(f"Temperature changed by {temperature_change}°F")
# Output: Temperature changed by 7°F

37.1.5) Zahlen runden mit round()

Die Funktion round() rundet eine Zahl auf eine angegebene Anzahl von Dezimalstellen. Ohne zweites Argument rundet sie auf die nächste ganze Zahl.

python

# Auf die nächste ganze Zahl runden
print(round(3.7))     # Output: 4
print(round(3.2))     # Output: 3
print(round(3.5))     # Output: 4
print(round(4.5))     # Output: 4  (rundet auf die nächste gerade Zahl)
 
# Auf bestimmte Dezimalstellen runden
price = 19.876
print(round(price, 2))  # Output: 19.88  (2 Dezimalstellen)
print(round(price, 1))  # Output: 19.9   (1 Dezimalstelle)
 
# Auf negative Dezimalstellen runden (auf Zehner, Hunderter usw.)
population = 1234567
print(round(population, -3))  # Output: 1235000  (nächster Tausender)
print(round(population, -4))  # Output: 1230000  (nächster Zehntausender)

Hinweis zu Halbwerten: Wenn Sie eine Zahl runden, die exakt auf halbem Weg zwischen zwei ganzen Zahlen liegt, hat Python eine spezielle Regel. Zum Beispiel liegt 2.5 genau zwischen 2 und 3. Sie würden vielleicht erwarten, dass auf 3 aufgerundet wird, aber Python rundet auf den Nachbarn, der eine gerade Zahl ist – in diesem Fall 2.

Das nennt man „banker's rounding“ oder „round half to even“. Es ist Teil des IEEE-754-Standards und hilft, Verzerrungen über viele Rundungsoperationen hinweg zu reduzieren.

python

# Halbwerte runden auf die nächste gerade Zahl
print(round(0.5))   # Output: 0 (0 is even)
print(round(1.5))   # Output: 2 (2 is even)
print(round(2.5))   # Output: 2 (2 is even)
print(round(3.5))   # Output: 4 (4 is even)
print(round(4.5))   # Output: 4 (4 is even)

37.2) Sequenzen mit enumerate() aufzählen

Beim Durchlaufen einer Sequenz brauchen Sie oft sowohl das Element als auch seine Position. Die Funktion enumerate() liefert beides und macht manuelle Zählervariablen überflüssig.

37.2.1) Das Problem mit manuellen Zählern

Bevor Sie enumerate() kennenlernen, verwenden Programmierer oft eine Zählervariable, um die Position zu verfolgen:

python

# Ansatz mit manuellem Zähler (funktioniert, ist aber nicht ideal)
fruits = ["apple", "banana", "cherry", "date"]
index = 0
 
for fruit in fruits:
    print(f"{index}: {fruit}")
    index += 1
# Output:
# 0: apple
# 1: banana
# 2: cherry
# 3: date

Dieser Ansatz hat mehrere Nachteile:

Zusätzliche Variable, die verwaltet werden muss (index)
Leicht zu vergessen, den Zähler zu erhöhen

37.2.2) enumerate() für Position und Wert verwenden

Die Funktion enumerate() löst dieses Problem elegant. Sie nimmt ein Iterable und gibt Paare aus (index, element):

python

# enumerate() verwenden – sauberer und pythonischer
fruits = ["apple", "banana", "cherry", "date"]
 
for index, fruit in enumerate(fruits):
    print(f"{index}: {fruit}")
# Output:
# 0: apple
# 1: banana
# 2: cherry
# 3: date

Die Syntax for index, fruit in enumerate(fruits) verwendet Tuple-Unpacking (wie wir in Kapitel 15 gelernt haben). In jeder Iteration liefert enumerate() ein Tuple wie (0, "apple"), das in die Variablen index und fruit entpackt wird.

Das ist es, was enumerate() tatsächlich erzeugt:

python

# Die Ausgabe von enumerate() direkt ansehen
fruits = ["apple", "banana", "cherry"]
enumerated = list(enumerate(fruits))
print(enumerated)
# Output: [(0, 'apple'), (1, 'banana'), (2, 'cherry')]

37.2.3) Aufzählung bei einer anderen Zahl starten

Standardmäßig beginnt enumerate() bei 0 zu zählen. Sie können mit dem Parameter start eine andere Startzahl angeben:

python

# Zählen bei 1 starten (nützlich für die Anzeige)
tasks = ["Write code", "Test code", "Deploy code"]
 
for number, task in enumerate(tasks, start=1):
    print(f"Step {number}: {task}")
# Output:
# Step 1: Write code
# Step 2: Test code
# Step 3: Deploy code

Das ist besonders nützlich, wenn Sie nummerierte Listen für Benutzer anzeigen, die typischerweise erwarten, dass bei 1 begonnen wird:

python

# Menü mit nummerierten Optionen
menu_items = ["New Game", "Load Game", "Settings", "Quit"]
 
print("Main Menu:")
for number, item in enumerate(menu_items, start=1):
    print(f"{number}. {item}")
# Output:
# Main Menu:
# 1. New Game
# 2. Load Game
# 3. Settings
# 4. Quit

37.2.4) enumerate() mit Strings und anderen Iterables

Die Funktion enumerate() funktioniert mit jedem Iterable, nicht nur mit Listen:

python

# Zeichen in einem String aufzählen
word = "Python"
 
for position, letter in enumerate(word):
    print(f"Letter {position}: {letter}")
# Output:
# Letter 0: P
# Letter 1: y
# Letter 2: t
# Letter 3: h
# Letter 4: o
# Letter 5: n
 
# Ein Tuple aufzählen
coordinates = (10, 20, 30, 40)
 
for index, value in enumerate(coordinates):
    print(f"Coordinate {index}: {value}")
# Output:
# Coordinate 0: 10
# Coordinate 1: 20
# Coordinate 2: 30
# Coordinate 3: 40

Die Funktion enumerate() macht Code besser lesbar und weniger fehleranfällig. Immer wenn Sie sowohl Position als auch Wert in einer Schleife brauchen, greifen Sie zu enumerate() statt einen Zähler manuell zu verwalten.

37.3) Sequenzen mit zip() kombinieren

Die Funktion zip() kombiniert mehrere Iterables Element für Element und erzeugt Paare (oder Tupel) aus entsprechenden Elementen. Das ist unverzichtbar, wenn Sie zusammengehörige Daten aus getrennten Sequenzen gleichzeitig verarbeiten müssen.

37.3.1) Verstehen, wie zip() funktioniert

Die Funktion zip() nimmt zwei oder mehr Iterables und gibt einen Iterator von Tupeln zurück, wobei jedes Tuple ein Element aus jedem Eingabe-Iterable enthält:

python

# Zwei Listen kombinieren
names = ["Alice", "Bob", "Charlie"]
ages = [25, 30, 35]
 
combined = list(zip(names, ages))
print(combined)
# Output: [('Alice', 25), ('Bob', 30), ('Charlie', 35)]

Der Name „zip“ kommt vom Reißverschluss an Kleidung – er verbindet zwei getrennte Seiten zu einer gemeinsamen Struktur, Element für Element.

Hier ist eine visuelle Darstellung, wie zip() Elemente paart:

37.3.2) zip() in Schleifen verwenden

Die häufigste Verwendung von zip() ist in for-Schleifen, wenn Sie über mehrere Sequenzen gleichzeitig iterieren müssen:

python

# Parallele Daten verarbeiten
students = ["Alice", "Bob", "Charlie", "Diana"]
scores = [92, 85, 88, 95]
 
for student, score in zip(students, scores):
    print(f"{student} scored {score}")
# Output:
# Alice scored 92
# Bob scored 85
# Charlie scored 88
# Diana scored 95

Das ist deutlich sauberer als Indizes zu verwenden:

python

# Ohne zip() – komplexer und fehleranfälliger
students = ["Alice", "Bob", "Charlie", "Diana"]
scores = [92, 85, 88, 95]
 
for i in range(len(students)):
    print(f"{students[i]} scored {scores[i]}")
# Same output, but more code and potential for index errors

37.3.3) Sequenzen unterschiedlicher Länge behandeln

Wenn die Eingabesequenzen unterschiedliche Längen haben, stoppt zip(), sobald die kürzeste Sequenz aufgebraucht ist:

python

# Sequenzen ungleicher Länge
names = ["Alice", "Bob", "Charlie", "Diana"]
ages = [25, 30]  # Only 2 ages
 
for name, age in zip(names, ages):
    print(f"{name} is {age} years old")
# Output:
# Alice is 25 years old
# Bob is 30 years old
# (Charlie and Diana are not processed)

Dieses Verhalten verhindert Fehler, kann aber zu stillem Datenverlust führen, wenn Sie nicht aufpassen. Verifizieren Sie immer, dass Ihre Sequenzen die erwarteten Längen haben:

python

# Auf Längen-Mismatch prüfen
names = ["Alice", "Bob", "Charlie"]
ages = [25, 30]
 
if len(names) != len(ages):
    print(f"Warning: {len(names)} names but {len(ages)} ages")
    print("Only processing the first", min(len(names), len(ages)), "entries")
    # Output: Warning: 3 names but 2 ages
    # Output: Only processing the first 2 entries
 
# Mit zip() fortfahren – es stoppt bei der kürzesten Sequenz
for name, age in zip(names, ages):
    print(f"{name} is {age} years old")

37.3.4) Mehr als zwei Sequenzen zippen

Die Funktion zip() kann beliebig viele Iterables kombinieren:

python

# Drei Sequenzen kombinieren
products = ["Laptop", "Mouse", "Keyboard"]
prices = [999.99, 24.99, 79.99]
quantities = [5, 20, 15]
 
print("Inventory Report:")
for product, price, quantity in zip(products, prices, quantities):
    total_value = price * quantity
    print(f"{product}: ${price} × {quantity} = ${total_value:.2f}")
# Output:
# Inventory Report:
# Laptop: $999.99 × 5 = $4999.95
# Mouse: $24.99 × 20 = $499.80
# Keyboard: $79.99 × 15 = $1199.85

37.3.5) Dictionaries mit zip() erstellen

Ein mächtiges Muster ist die Verwendung von zip(), um Dictionaries aus getrennten Schlüssel- und Wertsequenzen zu erstellen:

python

# Ein Dictionary aus zwei Listen erstellen
keys = ["name", "age", "city"]
values = ["Alice", 25, "Boston"]
 
person = dict(zip(keys, values))
print(person)
# Output: {'name': 'Alice', 'age': 25, 'city': 'Boston'}

37.4) Boolesche Aggregation mit any() und all()

Die Funktionen any() und all() testen Bedingungen über ganze Iterables hinweg und liefern ein einzelnes boolesches Ergebnis. Sie sind mächtige Werkzeuge für Validierung und Entscheidungen, die auf mehreren Bedingungen basieren.

37.4.1) any() verstehen: True, wenn mindestens ein Element True ist

Die Funktion any() gibt True zurück, wenn mindestens ein Element in einem Iterable truthy ist (zu True ausgewertet wird). Wenn alle Elemente falsy sind, gibt sie False zurück:

python

# Grundlegende any()-Beispiele
print(any([True, False, False]))   # Output: True  (at least one True)
print(any([False, False, False]))  # Output: False (all False)
print(any([False, True, True]))    # Output: True  (multiple True values)
 
# Leere Iterables
print(any([]))  # Output: False (no elements to be True)

Die Funktion any() verwendet Pythons Truthiness-Regeln (wie wir in Kapitel 7 gelernt haben). Nicht-Null-Zahlen, nicht-leere Strings und nicht-leere Sammlungen sind truthy:

python

# any() mit unterschiedlichen truthy/falsy-Werten
print(any([0, 0, 1]))           # Output: True  (1 is truthy)
print(any([0, 0, 0]))           # Output: False (all zeros are falsy)
print(any(["", "", "text"]))    # Output: True  ("text" is truthy)
print(any(["", "", ""]))        # Output: False (empty strings are falsy)

37.4.2) Praktische Anwendungen von any()

Beispiel: Prüfen, ob irgendeine Bedingung erfüllt ist

python

# Prüfen, ob irgendeine Note durchfällt (unter 60)
scores = [75, 82, 55, 90, 88]
has_failing_grade = any(score < 60 for score in scores)
 
if has_failing_grade:
    print("Warning: At least one failing grade")
    # Output: Warning: At least one failing grade
else:
    print("All grades are passing")

37.4.3) all() verstehen: True nur, wenn alle Elemente True sind

Die Funktion all() gibt nur dann True zurück, wenn alle Elemente in einem Iterable truthy sind. Wenn irgendein Element falsy ist, gibt sie False zurück:

python

# Grundlegende all()-Beispiele
print(all([True, True, True]))    # Output: True  (all True)
print(all([True, False, True]))   # Output: False (one False)
print(all([True, True, False]))   # Output: False (one False)
 
# Leere Iterables
print(all([]))  # Output: True (vacuous truth - no False elements)

Das Verhalten bei leeren Iterables wirkt vielleicht überraschend: all([]) gibt True zurück. Das nennt man vacuous truth – die Aussage „alle Elemente sind True“ ist technisch wahr, wenn es keine Elemente gibt, die ihr widersprechen könnten.

python

# all() mit unterschiedlichen truthy/falsy-Werten
print(all([1, 2, 3]))           # Output: True  (all non-zero)
print(all([1, 0, 3]))           # Output: False (0 is falsy)
print(all(["a", "b", "c"]))     # Output: True  (all non-empty)
print(all(["a", "", "c"]))      # Output: False (empty string is falsy)

37.4.4) Praktische Anwendungen von all()

Beispiel: Validieren, dass alle Bedingungen erfüllt sind

python

# Prüfen, ob alle Noten bestanden sind (60 oder höher)
scores = [75, 82, 68, 90, 88]
all_passing = all(score >= 60 for score in scores)
 
if all_passing:
    print("Congratulations! All grades are passing")
    # Output: Congratulations! All grades are passing
else:
    print("Some grades need improvement")

37.4.5) Short-Circuit-Auswertung in any() und all()

Sowohl any() als auch all() verwenden Short-Circuit-Auswertung (wie wir in Kapitel 9 gelernt haben). Sie hören mit dem Prüfen auf, sobald das Ergebnis feststeht:

python

# Funktion, die beim Aufruf etwas ausgibt (um die Ausführung zu zeigen)
def is_positive(n):
    print(f"Checking {n}")
    return n > 0
 
# any() stoppt beim ersten True
print("Testing any():")
numbers = [0, 0, 1, 2, 3]
result = any(is_positive(n) for n in numbers)
# Output:
# Testing any():
# Checking 0
# Checking 0
# Checking 1
# (Stops here - doesn't check 2 or 3)
print(f"Result: {result}")  # Output: Result: True
 
print("\nTesting all():")
numbers = [1, 2, 0, 3, 4]
result = all(is_positive(n) for n in numbers)
# Output:
# Testing all():
# Checking 1
# Checking 2
# Checking 0
# (Stops here - doesn't check 3 or 4)
print(f"Result: {result}")  # Output: Result: False

Das macht any() und all() effizient – sie verschwenden keine Zeit damit, Elemente zu prüfen, nachdem das Ergebnis feststeht.

37.5) Sortieren mit sorted() und benutzerdefinierten Keys

Die Funktion sorted() erstellt aus jedem Iterable eine neue sortierte Liste. Im Gegensatz zur Methode .sort() (die nur auf Listen funktioniert und diese in-place verändert) funktioniert sorted() mit jedem Iterable und gibt immer eine neue Liste zurück.

37.5.1) Grundlegendes Sortieren mit sorted()

Die Funktion sorted() ordnet Elemente standardmäßig in aufsteigender Reihenfolge:

python

# Zahlen sortieren
numbers = [42, 17, 93, 8, 55]
sorted_numbers = sorted(numbers)
print(sorted_numbers)  # Output: [8, 17, 42, 55, 93]
 
# Die ursprüngliche Liste bleibt unverändert
print(numbers)  # Output: [42, 17, 93, 8, 55]
 
# Strings sortieren (alphabetisch)
names = ["Charlie", "Alice", "Bob", "Diana"]
sorted_names = sorted(names)
print(sorted_names)  # Output: ['Alice', 'Bob', 'Charlie', 'Diana']

Die Funktion sorted() funktioniert mit jedem Iterable, nicht nur mit Listen:

python

# Ein Tuple sortieren (gibt eine Liste zurück)
coordinates = (5, 2, 8, 1, 9)
sorted_coords = sorted(coordinates)
print(sorted_coords)  # Output: [1, 2, 5, 8, 9]
 
# Einen String sortieren (gibt eine Liste von Zeichen zurück)
word = "python"
sorted_letters = sorted(word)
print(sorted_letters)  # Output: ['h', 'n', 'o', 'p', 't', 'y']
 
# Ein Set sortieren (gibt eine sortierte Liste zurück)
unique_numbers = {5, 8, 2, 1}
sorted_unique = sorted(unique_numbers)
print(sorted_unique)  # Output: [1, 2, 5, 8]

37.5.2) Rückwärts sortieren

Verwenden Sie den Parameter reverse=True, um in absteigender Reihenfolge zu sortieren:

python

# Absteigende Reihenfolge für Zahlen
scores = [85, 92, 78, 95, 88]
highest_first = sorted(scores, reverse=True)
print(highest_first)  # Output: [95, 92, 88, 85, 78]
 
# Absteigende Reihenfolge für Strings (umgekehrte Alphabetreihenfolge)
names = ["Charlie", "Alice", "Bob", "Diana"]
reverse_alpha = sorted(names, reverse=True)
print(reverse_alpha)  # Output: ['Diana', 'Charlie', 'Bob', 'Alice']

37.5.3) Den Parameter key verstehen

Der Parameter key ist der Punkt, an dem sorted() wirklich mächtig wird. Er verändert, wie Python Elemente während des Sortierens vergleicht.

Was ist der key-Parameter?

Der Parameter key akzeptiert eine Funktion(function). Python ruft diese Funktion für jedes Element auf, um einen „Vergleichsschlüssel“ zu extrahieren, und sortiert dann anhand dieser Schlüssel statt anhand der ursprünglichen Elemente.

So funktioniert es Schritt für Schritt:

Python ruft die Key-Funktion für jedes Element auf
Python sammelt alle Keys
Python sortiert, indem es diese Keys vergleicht
Python gibt die ursprünglichen Elemente in der neuen Reihenfolge zurück

python

# Beispiel: Nach Länge sortieren
words = ["python", "is", "awesome"]
 
# Schritt 1: Python ruft len() für jedes Wort auf
# len("python")  → 6
# len("is")      → 2
# len("awesome") → 7
 
# Schritt 2: Python hat diese Keys: [6, 2, 7]
 
# Schritt 3: Python sortiert die Keys: [2, 6, 7]
 
# Schritt 4: Python gibt words in dieser Reihenfolge zurück: ["is", "python", "awesome"]
 
result = sorted(words, key=len)
print(result)  # Output: ['is', 'python', 'awesome']

Die Key-Funktion visualisieren:

Was kann eine Key-Funktion sein?

Die Key-Funktion muss:

ein Argument akzeptieren (das zu sortierende Element)
einen Wert zurückgeben, den Python vergleichen kann (Zahlen, Strings, Tupel usw.)

python

# Integrierte Funktionen funktionieren hervorragend
sorted(numbers, key=abs)        # Nach Absolutwert sortieren
sorted(words, key=len)          # Nach Länge sortieren
sorted(names, key=str.lower)    # Ohne Beachtung der Groß-/Kleinschreibung sortieren
 
# Eigene Funktionen
def first_letter(word):
    return word[0]
 
sorted(words, key=first_letter)  # Nach dem ersten Buchstaben sortieren
 
# Lambda-Funktionen (Kapitel 23)
sorted(words, key=lambda w: w[-1])  # Nach dem letzten Buchstaben sortieren

Wichtig: Die Key-Funktion wird einmal pro Element aufgerufen

python

# Demonstrieren, wann die Key-Funktion aufgerufen wird
def show_key(word):
    print(f"Getting key for: {word}")
    return len(word)
 
words = ["cat", "elephant", "dog"]
result = sorted(words, key=show_key)
# Output:
# Getting key for: cat
# Getting key for: elephant
# Getting key for: dog
 
print(result)  # Output: ['cat', 'dog', 'elephant']

Wichtig: Die Key-Funktion wird einmal pro Element aufgerufen

Beachten Sie, dass show_key für jedes Wort genau einmal aufgerufen wird, nicht wiederholt während der Vergleiche. Python ist effizient – es extrahiert zuerst alle Keys, cached sie und sortiert dann mithilfe der gecachten Keys.

Denken Sie bei key an die Frage: „Welchen Aspekt soll ich vergleichen?“

key=len → „Nach Länge vergleichen“
key=abs → „Nach Absolutwert vergleichen“
key=str.lower → „Vergleichen, als wäre alles kleingeschrieben“
key=lambda x: x[1] → „Nach dem zweiten Element vergleichen“

Der Parameter key ermöglicht es Ihnen, nach jeder Eigenschaft Ihrer Elemente zu sortieren, was sorted() unglaublich vielseitig macht.

37.5.4) Sortieren mit integrierten Funktionen als Keys

Pythons integrierte Funktionen eignen sich hervorragend als Key-Funktionen:

python

# Nach Absolutwert sortieren
numbers = [-5, 2, -8, 1, -3, 7]
sorted_by_magnitude = sorted(numbers, key=abs)
print(sorted_by_magnitude)  # Output: [1, 2, -3, -5, 7, -8]
 
# Strings ohne Beachtung der Groß-/Kleinschreibung sortieren
names = ["alice", "Bob", "CHARLIE", "diana"]
sorted_case_insensitive = sorted(names, key=str.lower)
print(sorted_case_insensitive)  # Output: ['alice', 'Bob', 'CHARLIE', 'diana']

37.5.5) Komplexe Datenstrukturen sortieren

Wenn Sie Listen von Tupeln oder Listen sortieren, können Sie per Index angeben, nach welchem Element sortiert werden soll:

python

# Tupel nach dem zweiten Element sortieren
students = [
    ("Alice", 92),
    ("Bob", 85),
    ("Charlie", 88),
    ("Diana", 95)
]
 
# Nach Score sortieren (zweites Element)
by_score = sorted(students, key=lambda student: student[1])
print(by_score)
# Output: [('Bob', 85), ('Charlie', 88), ('Alice', 92), ('Diana', 95)]
 
# Nach Score absteigend sortieren
by_score_desc = sorted(students, key=lambda student: student[1], reverse=True)
print(by_score_desc)
# Output: [('Diana', 95), ('Alice', 92), ('Charlie', 88), ('Bob', 85)]

Hinweis: Wir verwenden hier lambda (wie wir in Kapitel 23 gelernt haben). Ein Lambda ist eine kleine anonyme Funktion. Der Ausdruck lambda student: student[1] erstellt eine Funktion, die ein Student-Tuple entgegennimmt und dessen zweites Element (den Score) zurückgibt.

37.5.6) Mehrstufiges Sortieren

Sie können nach mehreren Kriterien sortieren, indem Sie aus der Key-Funktion ein Tuple zurückgeben. Python vergleicht Tupel Element für Element, von links nach rechts:

So funktioniert der Tuple-Vergleich:

Wenn Python zwei Tupel vergleicht, folgt es diesen Regeln:

Vergleichen Sie die ersten Elemente. Wenn sie unterschiedlich sind, ist der Vergleich abgeschlossen.
Wenn die ersten Elemente gleich sind, vergleichen Sie die zweiten Elemente.
Wenn die zweiten Elemente gleich sind, vergleichen Sie die dritten Elemente.
Fahren Sie fort, bis ein Unterschied gefunden wird oder die Elemente ausgehen.

python

# Beispiele für Tuple-Vergleiche
print((1, 'a') < (2, 'z'))   # Output: True  (1 < 2, so True immediately)
print((1, 'z') < (1, 'a'))   # Output: False (1 == 1, so compare 'z' < 'a')
print((1, 'a') < (1, 'a'))   # Output: False (both tuples are equal)
print((1, 2, 9) < (1, 3, 1)) # Output: True  (1 == 1, then 2 < 3)

Das macht Tupel perfekt für mehrstufiges Sortieren – Python übernimmt automatisch die Logik „erstes Kriterium vergleichen, dann zweites, dann drittes“ für Sie:

python

# Nach mehreren Kriterien sortieren
students = [
    ("Alice", "Smith", 92),
    ("Bob", "Jones", 85),
    ("Alice", "Brown", 88),
    ("Charlie", "Smith", 85)
]
 
# Nach Vorname, dann Nachname sortieren
by_name = sorted(students, key=lambda s: (s[0], s[1]))
print("By name:")
for student in by_name:
    print(f"  {student}")
# Output:
# By name:
#   ('Alice', 'Brown', 88)
#   ('Alice', 'Smith', 92)
#   ('Bob', 'Jones', 85)
#   ('Charlie', 'Smith', 85)
 
# Nach Score absteigend, dann Name aufsteigend sortieren
by_score_then_name = sorted(students, key=lambda s: (-s[2], s[0]))
print("\nBy score (high to low), then name:")
for student in by_score_then_name:
    print(f"  {student}")
# Output:
# By score (high to low), then name:
#   ('Alice', 'Smith', 92)
#   ('Alice', 'Brown', 88)
#   ('Bob', 'Jones', 85)
#   ('Charlie', 'Smith', 85)

Hinweis: Um ein Kriterium absteigend und ein anderes aufsteigend zu sortieren, negieren wir den numerischen Wert (-s[2]). Das funktioniert, weil Negieren die Sortierreihenfolge für Zahlen umkehrt. Im Beispiel oben sortiert -s[2] Scores von hoch nach niedrig, während s[0] Namen von A bis Z sortiert.

37.5.7) Hilfsfunktionen für komplexe Keys verwenden

Wenn die Sortierlogik komplex wird, macht eine Hilfsfunktion den Code lesbarer und besser wartbar. Sie können diese Hilfsfunktion dann innerhalb Ihrer Key-Funktion verwenden.

Beispiel: Dateien nach Erweiterung sortieren

Angenommen, Sie möchten Dateien nach ihrer Erweiterung gruppieren (.csv, .jpg, .pdf usw.) und innerhalb jeder Gruppe alphabetisch nach Dateiname sortieren. Die Key-Funktion muss die Dateierweiterung extrahieren, was etwas String-Manipulation erfordert.

python

# Dateien nach Erweiterung sortieren, dann nach Name
files = [
    "report.pdf",
    "data.csv",
    "image.jpg",
    "notes.txt",
    "backup.csv",
    "photo.jpg"
]
 
# Erweiterung zum Sortieren extrahieren
def get_extension(filename):
    """Extract the file extension from a filename."""
    return filename.split(".")[-1]  # Nach "." splitten und den letzten Teil nehmen
 
# Die Hilfsfunktion im Key verwenden
sorted_files = sorted(files, key=lambda f: (get_extension(f), f))
print("Files sorted by extension, then name:")
for file in sorted_files:
    print(f"  {file}")
# Output:
# Files sorted by extension, then name:
#   backup.csv      # csv files first (alphabetically)
#   data.csv        # csv files first (alphabetically)
#   image.jpg       # jpg files next
#   photo.jpg       # jpg files next
#   report.pdf      # pdf files next
#   notes.txt       # txt files last

So funktioniert es:

Die Key-Funktion lambda f: (get_extension(f), f) gibt für jeden Dateinamen ein Tuple zurück
Für "report.pdf" gibt sie ("pdf", "report.pdf") zurück
Für "data.csv" gibt sie ("csv", "data.csv") zurück
Python sortiert nach dem ersten Element des Tupels (Erweiterung) und dann nach dem zweiten Element (vollständiger Dateiname)
Dadurch werden Dateien nach Erweiterung gruppiert und innerhalb jeder Gruppe alphabetisch sortiert

Warum eine Hilfsfunktion verwenden?

Vergleichen Sie die Lesbarkeit:

python

# Ohne Hilfsfunktion – schwerer zu verstehen
sorted_files = sorted(files, key=lambda f: (f.split(".")[-1], f))
 
# Mit Hilfsfunktion – klarere Absicht
sorted_files = sorted(files, key=lambda f: (get_extension(f), f))

Die Hilfsfunktion macht Ihren Code selbstdokumentierend. Jeder, der get_extension(f) liest, versteht sofort, was passiert, während f.split(".")[-1] gedanklich erst zerlegt werden muss.

37.5.8) sorted() vs .sort(): Wann Sie was verwenden sollten

Python bietet zwei Möglichkeiten zum Sortieren:

sorted() – Funktion, die eine neue sortierte Liste zurückgibt
.sort() – Listenmethode, die in-place sortiert

python

# sorted() – erstellt eine neue Liste, Original bleibt unverändert
numbers = [3, 1, 4, 1, 5]
sorted_numbers = sorted(numbers)
print(f"Original: {numbers}")        # Output: Original: [3, 1, 4, 1, 5]
print(f"Sorted: {sorted_numbers}")   # Output: Sorted: [1, 1, 3, 4, 5]
 
# .sort() – verändert die Liste in-place, gibt None zurück
numbers = [3, 1, 4, 1, 5]
result = numbers.sort()
print(f"Modified: {numbers}")        # Output: Modified: [1, 1, 3, 4, 5]
print(f"Return value: {result}")     # Output: Return value: None

Wann Sie sorted() verwenden sollten:

Sie müssen die ursprüngliche Reihenfolge beibehalten
Sie sortieren etwas anderes als eine Liste (Tuple, String, Set usw.)
Sie möchten sortieren und in einem Ausdruck zuweisen

Wann Sie .sort() verwenden sollten:

Sie haben eine Liste und benötigen die ursprüngliche Reihenfolge nicht
Sie möchten Speicher sparen (keine neue Liste wird erstellt)
Sie sortieren eine große Liste in-place für mehr Effizienz

Die Funktion sorted() ist eines von Pythons vielseitigsten Tools. In Kombination mit dem Parameter key kann sie praktisch jede Sortieranforderung erfüllen – von einfacher Zahlenordnung bis hin zu komplexem Multi-Kriterien-Sortieren verschachtelter Datenstrukturen.

Dieses Kapitel hat Sie mit Pythons wichtigsten integrierten Funktionen und Tools ausgestattet. Sie haben gelernt, wie Sie:

Pythons Typhierarchie verstehen und vorhersagen, welche Operationen mit welchen Typen funktionieren
grundlegende Funktionen wie len(), sum(), min(), max(), abs() und round() für gängige Operationen verwenden
mit Positionsinformationen mithilfe von enumerate() iterieren
parallele Sequenzen gleichzeitig mit zip() verarbeiten
Entscheidungen über Sammlungen hinweg mit any() und all() treffen
Daten flexibel mit sorted() und benutzerdefinierten Key-Funktionen sortieren

Diese Tools bilden das Fundament idiomatischen Python-Codes. Sie sind effizient, gut lesbar und behandeln Randfälle korrekt. Während Sie weiter programmieren, werden Sie ständig zu diesen Funktionen greifen – sie sind die Bausteine, die Python-Code elegant und ausdrucksstark machen.

Im nächsten Kapitel werden wir Decorators untersuchen, mit denen Sie das Verhalten von Funktionen auf mächtige Weise verändern und erweitern können, aufbauend auf den Konzepten der First-Class-Funktionen, die wir in Kapitel 23 gelernt haben.