Kapitel 11: Funktionen

🎯 Lernziele

In diesem Kapitel lernst du:

• Was Funktionen sind und warum sie nützlich sind
• Funktionen definieren und aufrufen
• Parameter und Rückgabewerte verwenden
• Verschiedene Arten von Parametern
• Lambda-Funktionen (anonyme Funktionen)

11.1 Kernkonzept: Was sind Funktionen?

🤔 Warum Funktionen?

Problem ohne Funktionen:

# Code-Wiederholung (Copy-Paste)
print("Hallo Max!")
print("Willkommen beim Python-Kurs!")
print("-" * 30)

print("Hallo Anna!")
print("Willkommen beim Python-Kurs!")
print("-" * 30)

print("Hallo Tom!")
print("Willkommen beim Python-Kurs!")
print("-" * 30)

Lösung mit Funktionen:

# Funktion definieren (einmal schreiben!)
def begüß():
    print(f"Hallo {name}!")
    print("Willkommen beim Python-Kurs!")
    print("-" * 30)

# Funktion aufrufen (mehrfach verwenden!)
begüß("Max")
begüß("Anna")
begüß("Tom")

🎁 Vorteile von Funktionen

• ✅ Code-Wiederverwendung: Einmal schreiben, mehrmals verwenden
• ✅ Bessere Lesbarkeit: Code ist übersichtlicher
• ✅ Einfachere Wartung: Fehler an einer Stelle beheben
• ✅ Modularer Aufbau: Code in logische Blöcke teilen

11.2 Funktionen definieren und aufrufen

📏 Grundlegende Syntax

# Funktion definieren
def funktionsname(parameter):
    """Docstring: Beschreibung der Funktion"""
    # Funktionskörper (eingerückt!)
    anweisung1
    anweisung2
    return rückgabewert  # Optional

# Funktion aufrufen
funktionsname(argument)

💡 Einfaches Beispiel

# Funktion definieren
def sag_hallo():
    print("Hallo!")
    print("Willkommen bei Python!")

# Funktion aufrufen
sag_hallo()
sag_hallo()  # Mehrmals aufrufbar!

Ausgabe:

Hallo!
Willkommen bei Python!
Hallo!
Willkommen bei Python!

🎯 Praxisbeispiel: Begrüßungsfunktion

# Funktion mit Parameter
def begüß(name):
    print(f"Hallo {name}!")
    print("Schön, dass du da bist!")

# Aufruf mit Argument
begüß("Max")    # name wird "Max"
begüß("Anna")    # name wird "Anna"

Ausgabe:

Hallo Max!
Schön, dass du da bist!
Hallo Anna!
Schön, dass du da bist!

11.3 Funktionen mit Rückgabewert (return)

🔙 return-Anweisung

# Funktion mit Rückgabe
def addiere(a, b):
    ergebnis = a + b
    return ergebnis  # Gibt Wert zurück

# Rückgabe verwenden
summe = addiere(5, 3)
print(summe)  # 8

# Direkt verwenden
print(addiere(10, 20))  # 30

💡 Mehrere Rückgabewerte

# Funktion gibt mehrere Werte zurück (als Tupel!)
def min_max(zahlen):
    return min(zahlen), max(zahlen)

# Aufruf
zahlen = [5, 2, 8, 1, 9]
minimum, maximum = min_max(zahlen)  # Entpacken!
print(f"Min: {minimum}, Max: {maximum}")  # Min: 1, Max: 9

⚠️ Wichtig: return beendet Funktion!

def test():
    print("Vor return")
    return 42
    print("Nach return")  # Wird NICHT ausgeführt!

ergebnis = test()
print(ergebnis)  # 42

11.4 Parameter und Argumente

📋 Verschiedene Arten von Parametern

1. Positionsparameter (Reihenfolge wichtig!)

def begüß(vorname, nachname):
    print(f"Hallo {vorname} {nachname}!")

begüß("Max", "Muster")  # Richtig
# begüß("Muster", "Max")  # Falsch (Vertauscht!)

2. Schlüsselwortparameter (Reihenfolge egal!)

def begüß(vorname, nachname):
    print(f"Hallo {vorname} {nachname}!")

# Mit Schlüsselworten (Reihenfolge egal)
begüß(nachname="Muster", vorname="Max")

3. Standardparameter (Vorgabewerte)

def begüß(name, sprache="Deutsch"):
    if sprache == "Deutsch":
        print(f"Hallo {name}!")
    else:
        print(f"Hello {name}!")

begüß("Max")           # Hallo Max! (Standard)
begüß("Max", "Englisch")  # Hello Max!

🎯 Beliebig viele Parameter

*args (Positionsargumente)

def summe(*zahlen):
    ergebnis = 0
    for z in zahlen:
        ergebnis += z
    return ergebnis

print(summe(1, 2, 3))        # 6
print(summe(1, 2, 3, 4, 5))  # 15

**kwargs (Schlüsselwortargumente)

def zeige_info(**info):
    for schlüssel, wert in info.items():
        print(f"{schlüssel}: {wert}")

zeige_info(name="Max", alter=25, stadt="Berlin")
# name: Max
# alter: 25
# stadt: Berlin

11.5 Lambda-Funktionen (Anonyme Funktionen)

🏹 Einfache Lambda-Funktionen

# Normale Funktion
def quadrat(x):
    return x ** 2

# Lambda-Version (einzeilig!)
quadrat = lambda x: x ** 2

print(quadrat(5))  # 25

🎯 Lambda mit filter(), map(), sorted()

zahlen = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Nur gerade Zahlen (filter)
gerade = list(filter(lambda x: x % 2 == 0, zahlen))
print(gerade)  # [2, 4, 6, 8, 10]

# Alle Zahlen verdoppeln (map)
verdoppelt = list(map(lambda x: x * 2, zahlen))
print(verdoppelt)  # [2, 4, 6, ..., 20]

# Nach Länge sortieren (sorted)
wörter = ["Python", "C", "JavaScript", "Go"]
sortiert = sorted(wörter, key=lambda w: len(w))
print(sortiert)  # ['C', 'Go', 'Python', 'JavaScript']

11.6 Praxisbeispiel: Taschenrechner

# Funktionen definieren
def addiere(a, b):
    return a + b

def subtrahiere(a, b):
    return a - b

def multipliziere(a, b):
    return a * b

def dividiere(a, b):
    if b == 0:
        return "Fehler: Division durch 0!"
    return a / b

# Hauptprogramm
print("=== Einfacher Taschenrechner ===")
a = float(input("Gib die erste Zahl ein: "))
op = input("Gib den Operator ein (+, -, *, /): ")
b = float(input("Gib die zweite Zahl ein: "))

if op == "+":
    print(f"Ergebnis: {addiere(a, b)}")
elif op == "-":
    print(f"Ergebnis: {subtrahiere(a, b)}")
elif op == "*":
    print(f"Ergebnis: {multipliziere(a, b)}")
elif op == "/":
    print(f"Ergebnis: {dividiere(a, b)}")
else:
    print("Ungültiger Operator!")

⚠️ Häufige Fehler

❌ Fehler 1: Funktion aufrufen vor Definition

# Falsch (NameError!)
sage_hallo()  # Funktion noch nicht definiert!

def sage_hallo():
    print("Hallo!")

❌ Fehler 2: Funktion definieren mit gleichen Parameternamen

# Falsch
def test(x, x):  # SyntaxError!
    pass

❌ Fehler 3: return vergessen

# Falsch (gibt None zurück!)
def addiere(a, b):
    ergebnis = a + b
    # return ergebnis  # Vergessen!

print(addiere(5, 3))  # None

📝 Zusammenfassung

In diesem Kapitel hast du gelernt:

• ✅ Was Funktionen sind und warum sie nützlich sind
• ✅ Funktionen zu definieren (def)
• ✅ Parameter und Argumente zu verwenden
• ✅ Rückgabewerte mit return zu verwenden
• ✅ Verschiedene Parametertypen (*args, **kwargs)
• ✅ Lambda-Funktionen zu verwenden

🎯 Übung

1. Schreibe eine Funktion, die den Flächeninhalt eines Rechtecks berechnet
2. Schreibe eine Funktion, die prüft, ob eine Zahl prim ist
3. Schreibe eine Funktion, die eine Liste von Zahlen sortiert (Bubble Sort)
4. Verwende Lambda-Funktionen mit map() und filter()

⏭️ Nächstes Kapitel

In Kapitel 12 lernen wir Module und Pakete - wie man den Code in separate Dateien aufteilt!