🧩

Funktionen – Parameter und Rückgabewerte

Informatik · Python · Klassen 10–13 · PRIMM-Methode

Python Interaktiv Kl. 10–13

🎯 Worum geht's? Klasse 10–13 · 3 Unterrichtsstunden

Nach dieser Seite kannst du …

den Kopf einer Funktion lesen: Name, Parameter, Rückgabe
vorhersagen, was eine Funktion bei einem Aufruf zurückgibt
erklären, was mit übergebenen Werten in der Funktion passiert
Rekursion Schritt für Schritt verfolgen und Funktionen selbst schreiben

Vorwissen: Variablen, Bedingungen und Schleifen in Python

📝 Aufgaben

Jede Aufgabe hat fünf Schritte: Predict › Run › Investigate › Modify › Make. Wähle eine Aufgabe aus – oder nutze oben die Leiste „Aufgaben: 1, 2, 3 …“.

0

⚡ Gesammelte XP

0

✅ Aufgaben abgeschlossen

0

🔥 Streak (Tage)

–

🎯 Genauigkeit

📐 Das Wichtigste in Kürze

def name(a, b): – Kopf einer Funktion mit zwei Parametern; der eingerückte Block ist der Rumpf.
return wert beendet die Funktion und gibt wert zurück. Ohne return kommt None zurück.
Standardwerte: def f(a, b=1): – b darf beim Aufruf fehlen.
Rekursion: Eine Funktion ruft sich selbst auf; der Basisfall beendet die Kette.

🏅 Zuletzt verdiente Badges

🔮 Predict

Aufgabe 1 – Funktionsköpfe lesen

Lies die Funktionen genau.

def berechne(n, x):
    return n * x

def gruss(name):
    print("Hallo", name)

ergebnis = gruss("Ali")
print(ergebnis)

Wie viele Parameter hat berechne?

Was gibt die letzte Zeile aus?

gruss gibt etwas aus, aber nichts zurück.

▶️ Run – Köpfe zuordnen

Trage die Zahl der Parameter ein und ob die Funktion einen Wert zurückgibt (ja/nein).

def maximum(a, b):
    return a if a > b else b

def zuruecksetzen():
    print("zurückgesetzt")

def verbinde(a, b, trenner):
    return a + trenner + b

def ist_prim(n):
    return n > 1 and all(n % t for t in range(2, n))

Funktion	Parameter	Rückgabe?
`maximum`
`zuruecksetzen`
`verbinde`
`ist_prim`

Zähle die Namen in den Klammern. Eine Rückgabe gibt es nur mit return wert.

🔍 Investigate

Was ist der Unterschied zwischen print und return?

Was gehört zum Kopf einer Funktion?

✏️ Modify

Der Funktionskopf ist fehlerhaft. Korrigiere ihn, sodass add zwei Zahlen addiert und das Ergebnis zurückgibt.

Ein Funktionskopf endet mit einem Doppelpunkt; der Rumpf steht eingerückt in der nächsten Zeile. Welche Parameter braucht die Funktion?

🛠️ Make

Schreibe potenz(basis, exp) mit einer Schleife (ohne **): potenz(2, 3) → 8.

Starte mit 1 und multipliziere exp-mal mit der Basis.

🔮 Predict

Aufgabe 2 – Rückgabewerte

Was liefert die Funktion zurück?

def geheim(n):
    anzahl = 0
    for i in range(1, n + 1):
        if n % i == 0:
            anzahl = anzahl + 1
    return anzahl

r = geheim(12)
print(r)

Welchen Wert hat r?

Für welche Zahlen i von 1 bis 12 bleibt bei 12 % i kein Rest?

▶️ Run – Verschiedene Aufrufe

Was liefert geheim?

Aufruf	Rückgabe
`geheim(1)`
`geheim(6)`
`geheim(10)`
`geheim(7)`

Zähle für jede Zahl ihre Teiler.

🔍 Investigate

def ohne_return(x):
    y = x * 2

def mit_code_danach():
    return 1
    print("nie")

Was liefert ohne_return(4)?

Was passiert mit print("nie") in mit_code_danach?

✏️ Modify

Ergänze eine frühe Rückgabe: Für n <= 0 soll sofort 0 zurückkommen.

Ganz am Anfang der Funktion: Wenn n kleiner oder gleich 0 ist, sofort mit return zurückgeben.

🛠️ Make

Schreibe quersumme(n) für eine nicht-negative ganze Zahl, ohne sie in Text umzuwandeln: quersumme(123) → 6.

n % 10 liefert die letzte Ziffer, n // 10 entfernt sie. Wiederhole das, solange n größer als 0 ist.

🔮 Predict

Aufgabe 3 – Parameter

Achte auf die Reihenfolge der Parameter.

def kombiniere(prefix, suffix, n):
    ergebnis = ""
    for i in range(n):
        ergebnis = ergebnis + prefix
    return ergebnis + suffix

print(kombiniere("Ha", "llo", 3))

Was wird ausgegeben?

prefix wird n-mal angehängt, danach einmal suffix.

▶️ Run – Aufrufe

Was liefern die Aufrufe?

Aufruf	Rückgabe
`kombiniere("A", "B", 1)`
`kombiniere("xy", "!", 2)`
`kombiniere("", "Z", 4)`
`kombiniere(n=2, suffix="?", prefix="o")`

Beim letzten Aufruf werden die Parameter mit Namen übergeben – die Reihenfolge ist dann egal.

🔍 Investigate

Wie heißen "Ha", "llo", 3 beim Aufruf?

Müssen die Namen beim Aufruf mit den Parameternamen übereinstimmen?

✏️ Modify

Ergänze einen vierten Parameter trenner, der zwischen je zwei Wiederholungen steht: kombiniere("Ha", "!", 3, "-") → "Ha-Ha-Ha!".

Der Trenner kommt nach jeder Wiederholung – außer nach der letzten.

🛠️ Make

Schreibe wiederhole(s, n, sep) mit einer Schleife: wiederhole("ho", 3, "!") → "ho!ho!ho".

Den Trenner nur zwischen zwei Wiederholungen einfügen.

🔮 Predict

Aufgabe 4 – Werte übergeben

Was passiert mit a, wenn die Funktion ihren Parameter ändert?

def verdopple(x):
    x = x * 2

a = 5
b = 10
verdopple(a)
print(a, b)

Was wird ausgegeben?

x = x * 2 gibt nur dem Namen x in der Funktion einen neuen Wert.

▶️ Run – Zu verschiedenen Zeitpunkten

Trage die Werte ein.

Zeitpunkt	`a`	`x` (in verdopple)
vor dem Aufruf		–
in verdopple am Anfang
in verdopple nach x = x * 2
nach dem Aufruf		–

x startet mit dem Wert von a, ist aber ein eigener Name.

🔍 Investigate

Was passiert, wenn eine Funktion eine übergebene Liste mit liste[0] = 99 ändert?

Wie gibt man einen berechneten Wert heraus?

✏️ Modify

Ändere verdopple und den Aufruf, sodass a danach 10 ist.

Die Funktion muss den neuen Wert zurückgeben – und das Hauptprogramm muss ihn in a speichern.

🛠️ Make

Schreibe skaliere(liste, faktor): eine neue Liste, in der jedes Element mit faktor multipliziert ist. Die Originalliste bleibt unverändert.

Lege eine neue Liste an und fülle sie in einer Schleife.

🔮 Predict

Aufgabe 5 – Standardwerte für Parameter

Ein Parameter mit Standardwert darf beim Aufruf fehlen.

def flaeche(a, b=None):
    if b is None:
        return a * a      # Quadrat
    return a * b          # Rechteck

print(flaeche(4))
print(flaeche(3, 7))

Was gibt Zeile 6 aus?

Was gibt Zeile 7 aus?

Fehlt b beim Aufruf, hat es den Wert None.

▶️ Run – Aufrufe

Was liefern die Aufrufe?

Aufruf	Rückgabe
`flaeche(5)`
`flaeche(4, 6)`
`flaeche(2.5)`
`flaeche(b=2, a=3)`

Ohne zweiten Wert wird das Quadrat berechnet.

🔍 Investigate

def f(x):
    return 1

def f(x, y):
    return 2

Was passiert, wenn man zwei Funktionen mit demselben Namen definiert?

Was liefert danach f(1, 1)?

✏️ Modify

Ergänze einen dritten Parameter form mit Standardwert "rechteck". Bei form == "dreieck" soll a * b / 2 herauskommen.

Schreibe form="rechteck" in den Kopf und prüfe im Rumpf, ob form gleich "dreieck" ist.

🛠️ Make

Schreibe minimum(a, b, c=None): das Minimum von zwei oder drei Zahlen – ohne min().

Vergleiche zuerst a und b. Prüfe c nur, wenn es übergeben wurde (c is not None).

🔮 Predict

Aufgabe 6 – Rekursion

Die Funktion ruft sich selbst auf.

def fak(n):
    if n == 0:
        return 1          # Basisfall
    return n * fak(n - 1)

print(fak(4))

Was wird ausgegeben?

fak(4) = 4 · fak(3) = 4 · 3 · fak(2) …

▶️ Run – Aufrufkette

Trage ein, was jeder Aufruf zurückgibt.

Aufruf	`n`	Rückgabe
`fak(4)`	4
`fak(3)`	3
`fak(2)`	2
`fak(1)`	1
`fak(0)`	0

Arbeite von unten nach oben: zuerst der Basisfall.

🔍 Investigate

Was passiert ohne Basisfall?

Wie viele Aufrufe von fak entstehen bei fak(5)?

✏️ Modify

Schreibe fak ohne Rekursion mit einer Schleife.

Starte mit 1 und multipliziere nacheinander alle Zahlen von 2 bis n.

🛠️ Make

Schreibe fib(n) rekursiv: fib(0) = 0, fib(1) = 1, sonst fib(n - 1) + fib(n - 2).

Basisfall: Für n = 0 und n = 1 ist das Ergebnis n selbst.

🔮 Predict

Aufgabe 7 – Lokal und global

Welche Variable x sieht welche Funktion?

x = 10

def zeige_x():
    print(x)

def aendere_x():
    x = 5
    print(x)

zeige_x()
aendere_x()
zeige_x()

Was wird ausgegeben?

x = 5 in aendere_x legt eine lokale Variable an.

▶️ Run – Welches x?

Trage den ausgegebenen Wert ein und ob er von der globalen oder einer lokalen Variable stammt.

Aufruf	Ausgabe	global/lokal
1. `zeige_x()`
2. `aendere_x()`
3. `zeige_x()`

zeige_x hat keine eigene Variable x – sie liest die globale.

🔍 Investigate

Wann wird eine lokale Variable wieder entfernt?

Was bewirkt global x in aendere_x?

✏️ Modify

Ändere aendere_x so, dass die globale Variable geändert wird. Die Ausgabe soll dann 10 5 5 sein.

Die Funktion muss ankündigen, dass sie die globale Variable meint.

🛠️ Make

Ergänze die drei Funktionen für einen Zähler mit der globalen Variable zaehler: erhoehe(), zuruecksetzen(), wert().

Funktionen, die zaehler verändern, brauchen global zaehler.

🔮 Predict

Aufgabe 8 – Klassen und Vererbung

Hund erbt von Tier und überschreibt laut.

class Tier:
    def laut(self):
        return "..."

class Hund(Tier):
    def laut(self, n=1):
        return "Wuff" * n

print(Hund().laut())

Was wird ausgegeben?

Ein Hund-Objekt nutzt seine eigene Methode laut.

▶️ Run – Aufrufe

Was liefern die Aufrufe?

Aufruf	Rückgabe
`Tier().laut()`
`Hund().laut()`
`Hund().laut(3)`

"Wuff" * 3 wiederholt den Text dreimal.

🔍 Investigate

Was bedeutet class Hund(Tier):?

Was ist self?

✏️ Modify

Ergänze eine Klasse Katze, die von Tier erbt und bei laut() "Miau" zurückgibt.

Die neue Klasse nennt Tier in Klammern und schreibt laut neu.

🛠️ Make

Schreibe alle_rufen(tiere): eine Liste mit den Ergebnissen von laut() für jedes Tier.

Eine Schleife über alle Tiere – für jedes laut() aufrufen und das Ergebnis anhängen. Python wählt automatisch die passende Methode.

🔮 Predict

Aufgabe 9 – Hilfsfunktionen

Kleine Hilfsfunktionen lassen sich kombinieren.

def betrag(x):
    return -x if x < 0 else x

def groesser(a, b):
    return a if a > b else b

print(betrag(-7))
print(groesser(betrag(-4), betrag(3)))

Was gibt Zeile 7 aus?

Was gibt Zeile 8 aus?

Verschachtelte Aufrufe werden von innen nach außen ausgewertet.

▶️ Run – Aufrufe

Berechne die Rückgaben.

Ausdruck	Ergebnis
`betrag(-4)`
`betrag(3)`
`groesser(2, 9)`
`groesser(betrag(-10), 5)`

Zuerst die inneren Aufrufe ausrechnen.

🔍 Investigate

Warum lohnen sich kleine Hilfsfunktionen?

Was liefert groesser(3, 3)?

✏️ Modify

Ergänze begrenze(wert, minimum, maximum): Liegt wert unter dem Minimum, kommt das Minimum zurück, liegt er darüber, das Maximum, sonst der Wert selbst.

Drei Fälle: unter dem Minimum, über dem Maximum, dazwischen.

🛠️ Make

Schreibe ist_palindrom(s) mit zwei Zeigern (ohne [::-1]): "Racecar" → True.

Klein schreiben, dann von außen nach innen vergleichen.

🔮 Predict

Aufgabe 10 – Rekursion und Aufrufkette

Verfolge die rekursiven Aufrufe.

def quersumme(n):
    if n < 10:
        return n
    return n % 10 + quersumme(n // 10)

print(quersumme(493))

Was wird ausgegeben?

Jeder Aufruf nimmt die letzte Ziffer und gibt den Rest weiter.

▶️ Run – Aufrufkette

Trage für jeden Aufruf n % 10 und die Rückgabe ein.

Aufruf	`n % 10`	Rückgabe
`quersumme(493)`
`quersumme(49)`
`quersumme(4)`	–

Von unten nach oben: Der Basisfall gibt die Zahl selbst zurück, jede Ebene addiert ihre letzte Ziffer.

🔍 Investigate

Wie viele Aufrufe entstehen bei quersumme(493)?

Was passiert ohne den Basisfall?

✏️ Modify

Schreibe quersumme ohne Rekursion mit einer while-Schleife.

Letzte Ziffer zur Summe addieren und abschneiden, solange n größer als 0 ist.

🛠️ Make

Schreibe potenz(basis, exp) rekursiv: potenz(2, 10) → 1024.

Basisfall exp == 0. Sonst gilt: basis^exp = basis · basis^exp−1.

🏅 Deine Badges

Verdiente Badges leuchten auf.

📊 Statistik

↺ Zurücksetzen

Alle gespeicherten Daten werden gelöscht.

📄 Arbeitsblatt erstellen

Wähle aus, welche Bereiche auf das Arbeitsblatt kommen. Es enthält dann alle … Aufgaben dieser Seite aus diesen Bereichen – mit Kästchen zum Ankreuzen, leeren Tabellen und Platz zum Schreiben, ohne Lösungen und Tipps.

Bereiche für das Arbeitsblatt 🔮 Predict – vorhersagen, was der Code macht ▶️ Run – Werte Zeile für Zeile in die Tabelle eintragen 🔍 Investigate – untersuchen, warum der Code so arbeitet ✏️ Modify – Code gezielt verändern 🛠️ Make – eigene Methode schreiben

Aufgabe gelöst!

Funktionen – Parameter und Rückgabewerte

📝 Aufgaben

📐 Das Wichtigste in Kürze

🏅 Zuletzt verdiente Badges

🏅 Deine Badges

📊 Statistik

↺ Zurücksetzen

📄 Arbeitsblatt erstellen