Python Funktionen – Übungsserie

📊 Übersicht der Lernbereiche

Teil 1: Einfache Funktionen

6 Aufg.

Teil 2: Mit Parametern

7 Aufg.

Teil 3: Mit Rückgabewert

8 Aufg.

Teil 4: Komplex

7 Aufg.

Einfache Funktionen

Ohne Parameter, ohne Rückgabewert — die Grundlage jeder Programmstruktur

EINSTIEG

📖 Theorie: Was ist eine Funktion?

Eine Funktion ist ein benannter Codeblock, der bei Bedarf aufgerufen werden kann. So muss derselbe Code nicht mehrfach geschrieben werden.

Funktionen werden mit def definiert
Der Name der Funktion folgt direkt auf def
Der Funktionsinhalt (Body) ist eingerückt (4 Leerzeichen)
Aufgerufen wird die Funktion mit funktionsname()

def meine_funktion():
    print("Ich bin eine Funktion!")

# Aufruf der Funktion:
meine_funktion()

A 1.1

Hallo Welt – Mein erstes Programm

⭐ Sehr einfach

▼

📋 Aufgabe

Schreibe eine Funktion namens begruesse_welt, die beim Aufruf folgende zwei Zeilen ausgibt. Rufe die Funktion anschliessend zweimal auf.

🖥 Erwartete Ausgabe

Hallo, Welt!
Willkommen bei Python!

💡 Hinweis

Beginne mit def begruesse_welt():
Vergiss den Doppelpunkt : am Ende der def-Zeile nicht!
Der Inhalt (Body) muss mit 4 Leerzeichen eingerückt sein
Aufruf: Schreibe begruesse_welt() zweimal untereinander

✅ Musterlösung

def begruesse_welt():
    print("Hallo, Welt!")
    print("Willkommen bei Python!")

begruesse_welt()
begruesse_welt()

Erklärung: Die Funktion enthält zwei print()-Aufrufe. Durch den zweifachen Aufruf der Funktion wird der gesamte Block zweimal ausgeführt — das ist der grosse Vorteil von Funktionen!

A 1.2

Trennlinie zeichnen

⭐ Sehr einfach

▼

📋 Aufgabe

Schreibe eine Funktion trennlinie, die eine Linie aus 40 Minuszeichen ausgibt. Rufe sie dreimal auf, um drei Trennlinien zu erzeugen.

🖥 Erwartete Ausgabe

----------------------------------------
----------------------------------------
----------------------------------------

💡 Hinweis

In Python kann man Strings multiplizieren: "-" * 40 ergibt 40 Minuszeichen
Schreibe die Multiplikation direkt in den print()-Aufruf

✅ Musterlösung

def trennlinie():
    print("-" * 40)

trennlinie()
trennlinie()
trennlinie()

Trick: "-" * 40 ist eine elegante Python-Technik, um Zeichen zu wiederholen. Diese Methode funktioniert mit jedem String-Zeichen.

A 1.3

Treppenhaus-Muster

⭐⭐ Einfach

▼

📋 Aufgabe

Schreibe eine Funktion treppe, die folgendes Muster ausgibt:

🖥 Erwartete Ausgabe

#
##
###
####
#####

💡 Hinweis

Du kannst 5 einzelne print()-Anweisungen schreiben
Oder eleganter: eine for-Schleife mit range(1, 6)
In der Schleife: print("#" * i) — der Zähler i wächst von 1 bis 5

✅ Musterlösung (zwei Varianten)

# Variante 1: Direkte Ausgabe
def treppe():
    print("#")
    print("##")
    print("###")
    print("####")
    print("#####")

# Variante 2: Mit Schleife (eleganter!)
def treppe():
    for i in range(1, 6):
        print("#" * i)

treppe()

Tipp: Variante 2 mit der Schleife ist viel flexibler — wenn man die Grösse der Treppe ändern möchte, muss man nur eine Zahl anpassen.

A 1.4

Visitenkarte ausgeben

⭐⭐ Einfach

▼

📋 Aufgabe

Schreibe drei Funktionen: kopf(), rumpf() und fuss(). Rufe sie in der richtigen Reihenfolge auf, um eine Visitenkarte zu erzeugen.

🖥 Erwartete Ausgabe

+================================+
|      PYTHON AKADEMIE           |
|--------------------------------|
| Name:  Max Mustermann          |
| Email: max@python.de           |
| Tel:   +41 79 123 45 67        |
+================================+

💡 Hinweis

Teile das Problem auf: kopf() gibt erste und zweite Zeile aus
rumpf() gibt die Daten-Zeilen aus
fuss() gibt die letzte Zeile aus
Wichtig: Zuerst alle Funktionen definieren, dann erst aufrufen!

✅ Musterlösung

def kopf():
    print("+================================+")
    print("|      PYTHON AKADEMIE           |")
    print("|--------------------------------|")

def rumpf():
    print("| Name:  Max Mustermann          |")
    print("| Email: max@python.de           |")
    print("| Tel:   +41 79 123 45 67        |")

def fuss():
    print("+================================+")

# Aufrufe in richtiger Reihenfolge:
kopf()
rumpf()
fuss()

Wichtiger Grundsatz: In Python muss eine Funktion definiert sein, bevor sie aufgerufen werden kann. Die Definition steht immer vor dem Aufruf!

A 1.5

Stundenplan der Woche

⭐⭐ Einfach

▼

📋 Aufgabe

Schreibe für jeden Wochentag (Montag–Freitag) eine eigene Funktion, die den Stundenplan dieses Tages ausgibt. Erstelle ausserdem eine Funktion gesamter_stundenplan(), die alle fünf Tage aufruft.

Jeder Tag soll mindestens 3 Fächer enthalten. Trenne die Tage mit einer Linie.

💡 Hinweis

Schreibe 5 Funktionen: montag(), dienstag(), etc.
In gesamter_stundenplan() rufst du alle 5 Funktionen auf
Du kannst auch eine Funktion trennlinie() aus Aufgabe 1.2 wiederverwenden!

✅ Musterlösung

def trennlinie():
    print("-" * 30)

def montag():
    print("MONTAG:")
    print("  1. Mathematik")
    print("  2. Deutsch")
    print("  3. Informatik")

def dienstag():
    print("DIENSTAG:")
    print("  1. Englisch")
    print("  2. Biologie")
    print("  3. Sport")

def mittwoch():
    print("MITTWOCH:")
    print("  1. Physik")
    print("  2. Geschichte")
    print("  3. Kunst")

def donnerstag():
    print("DONNERSTAG:")
    print("  1. Mathematik")
    print("  2. Chemie")
    print("  3. Musik")

def freitag():
    print("FREITAG:")
    print("  1. Deutsch")
    print("  2. Geografie")
    print("  3. Informatik")

def gesamter_stundenplan():
    montag()
    trennlinie()
    dienstag()
    trennlinie()
    mittwoch()
    trennlinie()
    donnerstag()
    trennlinie()
    freitag()

gesamter_stundenplan()

Konzept: Funktionen können andere Funktionen aufrufen! Das nennt man Komposition — ein wichtiges Prinzip der Softwareentwicklung.

A 1.6

Mini-Menü für ein Restaurant

⭐⭐⭐ Mittel

▼

📋 Aufgabe

Erstelle ein Restaurantmenü mit separaten Funktionen für vorspeise(), hauptgang(), dessert() und getraenke(). Eine Funktion menue_karte() soll das gesamte Menü hübsch formatiert ausgeben. Füge Trennlinien ein und gestalte es ansprechend!

💡 Hinweis

Denke an eine klare Struktur: zuerst alle Funktionen definieren, dann menue_karte()
Verwende Zeichen wie =, -, | für die Formatierung
Du kannst Sonderzeichen wie ★ oder € direkt in Strings verwenden
Preise können einfach als Text angegeben werden: "Tomatensuppe........CHF 8.50"

✅ Musterlösung

def rahmen():
    print("=" * 38)

def linie():
    print("-" * 38)

def vorspeise():
    print("  ★ VORSPEISEN ★")
    linie()
    print("  Tomatensuppe............. CHF 8.50")
    print("  Gemischter Salat......... CHF 9.00")
    print("  Bruschetta............... CHF 7.50")

def hauptgang():
    print("  ★ HAUPTGÄNGE ★")
    linie()
    print("  Pasta Bolognese.......... CHF 18.00")
    print("  Zürcher Geschnetzeltes... CHF 28.00")
    print("  Gemüse-Curry (vegan).... CHF 16.00")

def dessert():
    print("  ★ DESSERTS ★")
    linie()
    print("  Schokoladenfondue........ CHF 12.00")
    print("  Crème brûlée............. CHF 9.00")

def getraenke():
    print("  ★ GETRÄNKE ★")
    linie()
    print("  Mineralwasser............ CHF 4.00")
    print("  Orangensaft.............. CHF 5.50")

def menue_karte():
    rahmen()
    print("     🍽️  RESTAURANT PYTHON  🍽️")
    rahmen()
    vorspeise()
    rahmen()
    hauptgang()
    rahmen()
    dessert()
    rahmen()
    getraenke()
    rahmen()

menue_karte()

Funktionen mit Übergabeparameter

Flexibel durch Parameter — dieselbe Funktion, verschiedene Ergebnisse

AUFBAU

📖 Theorie: Parameter

Parameter erlauben es, einer Funktion beim Aufruf Werte zu übergeben. Die Funktion kann damit arbeiten, ohne dass diese Werte fest im Code stehen.

Parameter stehen in den Klammern der def-Zeile
Beim Aufruf übergibt man konkrete Werte (Argumente)
Mehrere Parameter werden durch Komma getrennt

def begruesse(name):           # "name" ist der Parameter
    print(f"Hallo, {name}!")

begruesse("Anna")  # → Hallo, Anna!
begruesse("Tom")   # → Hallo, Tom!

A 2.1

Personalisierte Begrüssung

⭐ Einfach

▼

📋 Aufgabe

Schreibe eine Funktion begruesse(name), die den übergebenen Namen in die Begrüssung einbaut. Rufe sie mit drei verschiedenen Namen auf.

🖥 Erwartete Ausgabe

Guten Tag, Anna!
Guten Tag, Benjamin!
Guten Tag, Clara!

💡 Hinweis

Verwende f-Strings: f"Text {variable} Text"
Der Parameter heisst name und kann direkt im f-String verwendet werden

✅ Musterlösung

def begruesse(name):
    print(f"Guten Tag, {name}!")

begruesse("Anna")
begruesse("Benjamin")
begruesse("Clara")

f-String: Der Buchstabe f vor dem Anführungszeichen macht den String zu einem f-String. Variablen in geschweiften Klammern {} werden direkt eingefügt.

A 2.2

Linie mit variabler Länge

⭐⭐ Einfach

▼

📋 Aufgabe

Schreibe eine Funktion zeichne_linie(laenge, zeichen), die eine Linie der angegebenen Länge mit dem angegebenen Zeichen zeichnet. Teste sie mit verschiedenen Kombinationen.

🖥 Erwartete Ausgabe (Beispielaufrufe)

----------
**********
======
!!!!!!!!!!!!!!!!

💡 Hinweis

Kombiniere die String-Multiplikation mit dem Parameter: zeichen * laenge
Aufruf z.B.: zeichne_linie(10, "-")

✅ Musterlösung

def zeichne_linie(laenge, zeichen):
    print(zeichen * laenge)

zeichne_linie(10, "-")
zeichne_linie(10, "*")
zeichne_linie(6, "=")
zeichne_linie(16, "!")

A 2.3

Rechteck zeichnen

⭐⭐ Einfach

▼

📋 Aufgabe

Schreibe eine Funktion zeichne_rechteck(breite, hoehe), die ein Rechteck aus #-Zeichen ausgibt.

🖥 Beispiel: zeichne_rechteck(6, 3)

######
######
######

💡 Hinweis

Eine Schleife for i in range(hoehe): wiederholt den Body hoehe-mal
In jedem Schleifendurchlauf druckst du eine Zeile mit breite Zeichen

✅ Musterlösung

def zeichne_rechteck(breite, hoehe):
    for i in range(hoehe):
        print("#" * breite)

zeichne_rechteck(6, 3)
print()
zeichne_rechteck(10, 5)

A 2.4

Temperaturanzeige

⭐⭐ Einfach

▼

📋 Aufgabe

Schreibe eine Funktion zeige_temperatur(stadt, temperatur), die eine formatierte Wetterausgabe erzeugt. Rufe sie für mindestens 4 verschiedene Städte auf.

🖥 Erwartete Ausgabe

Wetter aktuell:
  Genf:    22°C  ☀️
  Zürich:  18°C  ⛅
  Bern:    20°C  🌤️
  Basel:   21°C  ☀️

💡 Hinweis

f-Strings können Ausrichtung formatieren: f"{stadt:<10}" linksbündig in 10 Zeichen
Das °-Zeichen kannst du direkt im String schreiben
Emoji-Zeichen können direkt verwendet werden

✅ Musterlösung

def zeige_temperatur(stadt, temperatur):
    print(f"  {stadt:<8} {temperatur}°C")

print("Wetter aktuell:")
zeige_temperatur("Genf:", 22)
zeige_temperatur("Zürich:", 18)
zeige_temperatur("Bern:", 20)
zeige_temperatur("Basel:", 21)

Formatierung: f"{stadt:<8}" — das < bedeutet linksbündig, 8 ist die Mindestbreite. So werden alle Städte sauber untereinander ausgerichtet.

A 2.5

Text wiederholen

⭐⭐ Einfach

▼

📋 Aufgabe

Schreibe eine Funktion wiederhole(text, anzahl), die den Text genau anzahl-mal ausgibt, wobei jede Ausgabe mit einer fortlaufenden Nummer beginnt.

🖥 Beispiel: wiederhole("Python macht Spass!", 3)

1: Python macht Spass!
2: Python macht Spass!
3: Python macht Spass!

💡 Hinweis

Verwende for i in range(1, anzahl + 1): — damit startet i bei 1!
Warum anzahl + 1? range(1, 4) erzeugt 1, 2, 3 — das obere Ende ist exklusiv

✅ Musterlösung

def wiederhole(text, anzahl):
    for i in range(1, anzahl + 1):
        print(f"{i}: {text}")

wiederhole("Python macht Spass!", 3)

Wichtig: range(1, anzahl + 1) erzeugt Zahlen von 1 bis anzahl (inklusive). range(n) hingegen erzeugt 0 bis n-1.

A 2.6

Dreieck zeichnen

⭐⭐⭐ Mittel

▼

📋 Aufgabe

Schreibe eine Funktion zeichne_dreieck(hoehe), die ein nach rechts ausgerichtetes Dreieck ausgibt. Teste sie mit hoehe=5.

🖥 Beispiel: zeichne_dreieck(5)

    *
   **
  ***
 ****
*****

💡 Hinweis — Kniffeliger Teil!

In Zeile i (startet bei 1) braucht man: (hoehe - i) Leerzeichen und i Sterne
Beispiel bei hoehe=5, Zeile 1: 4 Leerzeichen + 1 Stern
Beispiel bei hoehe=5, Zeile 5: 0 Leerzeichen + 5 Sterne
Formel: print(" " * (hoehe - i) + "*" * i)

✅ Musterlösung

def zeichne_dreieck(hoehe):
    for i in range(1, hoehe + 1):
        leerzeichen = hoehe - i
        sterne = i
        print(" " * leerzeichen + "*" * sterne)

zeichne_dreieck(5)

Schlüssel: Die Summe aus Leerzeichen und Sternen ist immer gleich hoehe. In jeder Zeile nimmt die Zahl der Leerzeichen um 1 ab, und die der Sterne um 1 zu.

A 2.7

Tischkarte für eine Veranstaltung

⭐⭐⭐ Mittel

▼

📋 Aufgabe

Schreibe eine Funktion tischkarte(name, tisch_nr, menu_wahl), die eine schöne Tischkarte für eine Veranstaltung ausgibt. Erstelle Karten für 4 verschiedene Gäste.

🖥 Erwartete Ausgabe (ein Beispiel)

╔══════════════════════════╗
║  Willkommen, Anna Meier  ║
╠══════════════════════════╣
║  Tisch:    Nr. 3         ║
║  Menü:     Vegetarisch   ║
╚══════════════════════════╝

💡 Hinweis

Die Box-Zeichen (╔, ║, ═, ╚ usw.) können direkt als Strings verwendet werden
Tipp: f"║ Tisch: Nr. {tisch_nr}" usw.
Du kannst eine leere Zeile print() zwischen den Karten einfügen

✅ Musterlösung

def tischkarte(name, tisch_nr, menu_wahl):
    print("╔══════════════════════════╗")
    print(f"║  Willkommen, {name:<12}║")
    print("╠══════════════════════════╣")
    print(f"║  Tisch:    Nr. {tisch_nr:<9}║")
    print(f"║  Menü:     {menu_wahl:<14}║")
    print("╚══════════════════════════╝")
    print()

tischkarte("Anna Meier", 3, "Vegetarisch")
tischkarte("Ben Schmidt", 7, "Fleisch")
tischkarte("Clara Huber", 2, "Vegan")
tischkarte("David Keller", 5, "Fisch")

Funktionen mit Rückgabewert

Das Ergebnis zurückgeben — Funktionen als Bausteine für Berechnungen

FORTGESCHRITTEN

📖 Theorie: return

Mit return kann eine Funktion einen Wert an die aufrufende Stelle zurückgeben. Dieser Wert kann in einer Variable gespeichert oder direkt weiterverwendet werden.

Ohne return gibt eine Funktion None zurück
Nach return wird die Funktion sofort beendet
Der Rückgabewert kann in einer Variable gespeichert werden

def addiere(a, b):
    ergebnis = a + b
    return ergebnis

summe = addiere(3, 5)   # summe = 8
print(summe)              # → 8
print(addiere(10, 20))  # → 30

A 3.1

Quadrat einer Zahl berechnen

⭐ Einfach

▼

📋 Aufgabe

Schreibe eine Funktion quadrat(zahl), die das Quadrat der übergebenen Zahl zurückgibt. Berechne das Quadrat der Zahlen 1 bis 5 und gib sie aus.

🖥 Erwartete Ausgabe

1² = 1
2² = 4
3² = 9
4² = 16
5² = 25

💡 Hinweis

In Python ist ** der Potenz-Operator: zahl ** 2
Speichere den Rückgabewert in einer Variable: erg = quadrat(3)
Oder rufe die Funktion direkt im f-String auf: f"{i}² = {quadrat(i)}"

✅ Musterlösung

def quadrat(zahl):
    return zahl ** 2

for i in range(1, 6):
    print(f"{i}² = {quadrat(i)}")

A 3.2

Umfang und Fläche eines Rechtecks

⭐⭐ Einfach

▼

📋 Aufgabe

Schreibe zwei Funktionen: umfang_rechteck(breite, hoehe) und flaeche_rechteck(breite, hoehe). Beide geben das jeweilige Ergebnis zurück. Berechne und zeige Umfang und Fläche für ein Rechteck mit Breite=8 und Höhe=5.

🖥 Erwartete Ausgabe

Rechteck 8 x 5:
  Umfang:  26
  Fläche:  40

💡 Hinweis

Umfang eines Rechtecks: 2 * (breite + hoehe)
Fläche eines Rechtecks: breite * hoehe
Speichere die Rückgabewerte in Variablen und gib sie dann aus

✅ Musterlösung

def umfang_rechteck(breite, hoehe):
    return 2 * (breite + hoehe)

def flaeche_rechteck(breite, hoehe):
    return breite * hoehe

b, h = 8, 5
print(f"Rechteck {b} x {h}:")
print(f"  Umfang:  {umfang_rechteck(b, h)}")
print(f"  Fläche:  {flaeche_rechteck(b, h)}")

A 3.3

Temperatur umrechnen

⭐⭐ Einfach

▼

📋 Aufgabe

Schreibe Funktionen celsius_zu_fahrenheit(celsius) und fahrenheit_zu_celsius(fahrenheit). Gib eine Umrechnungstabelle für Celsius-Werte 0, 10, 20, 30, 40, 100 aus.

🖥 Erwartete Ausgabe

Celsius → Fahrenheit:
  0°C  =   32.0°F
  10°C =   50.0°F
  20°C =   68.0°F
  30°C =   86.0°F
  40°C =  104.0°F
  100°C = 212.0°F

💡 Hinweis

Formel: fahrenheit = celsius * 9/5 + 32
Rückrechnung: celsius = (fahrenheit - 32) * 5/9
Du kannst eine Liste der Werte mit einer Schleife durchgehen

✅ Musterlösung

def celsius_zu_fahrenheit(celsius):
    return celsius * 9/5 + 32

def fahrenheit_zu_celsius(fahrenheit):
    return (fahrenheit - 32) * 5/9

print("Celsius → Fahrenheit:")
celsius_werte = [0, 10, 20, 30, 40, 100]
for c in celsius_werte:
    f = celsius_zu_fahrenheit(c)
    print(f"  {c}°C = {f}°F")

A 3.4

Maximum zweier Zahlen

⭐⭐ Einfach

▼

📋 Aufgabe

Schreibe eine Funktion maximum(a, b), die die grössere der beiden Zahlen zurückgibt — ohne die eingebaute max()-Funktion zu verwenden. Teste sie mit verschiedenen Zahlenpaaren.

🖥 Erwartete Ausgabe

Maximum(5, 3) = 5
Maximum(7, 12) = 12
Maximum(4, 4) = 4

💡 Hinweis

Verwende if a >= b: — dann ist a das Maximum
Im else-Zweig ist b das Maximum
Beide Zweige brauchen ein return-Statement

✅ Musterlösung

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

print(f"Maximum(5, 3) = {maximum(5, 3)}")
print(f"Maximum(7, 12) = {maximum(7, 12)}")
print(f"Maximum(4, 4) = {maximum(4, 4)}")

Zwei return-Statements: Eine Funktion kann mehrere return-Anweisungen haben. Die erste, die erreicht wird, beendet die Funktion und gibt den Wert zurück.

A 3.5

Begrüssungstext zusammenstellen

⭐⭐ Einfach

▼

📋 Aufgabe

Schreibe eine Funktion erstelle_begruessungstext(vorname, nachname, alter), die einen vollständigen Begrüssungstext als String zurückgibt (nicht ausgibt!). Verwende den Rückgabewert dann auf verschiedene Arten.

🖥 Erwartete Ausgabe

Herzlich willkommen, Anna Müller! Sie sind 28 Jahre alt.
Länge des Textes: 53 Zeichen
HERZLICH WILLKOMMEN, ANNA MÜLLER! SIE SIND 28 JAHRE ALT.

💡 Hinweis — Wichtig!

Die Funktion soll nur den Text zurückgeben, ihn aber nicht ausgeben!
Speichere das Ergebnis: text = erstelle_begruessungstext(...)
Dann kannst du damit rechnen: len(text) oder text.upper()

✅ Musterlösung

def erstelle_begruessungstext(vorname, nachname, alter):
    return f"Herzlich willkommen, {vorname} {nachname}! Sie sind {alter} Jahre alt."

text = erstelle_begruessungstext("Anna", "Müller", 28)
print(text)
print(f"Länge des Textes: {len(text)} Zeichen")
print(text.upper())

Schlüsselunterschied: print() gibt etwas aus. return gibt einen Wert zurück, der weiterverwendet werden kann. Das ist ein grundlegender Unterschied!

A 3.6

Mittelwert einer Liste

⭐⭐⭐ Mittel

▼

📋 Aufgabe

Schreibe eine Funktion mittelwert(zahlen), die eine Liste von Zahlen entgegennimmt und den Mittelwert zurückgibt. Berechne den Mittelwert der Noten einer Klasse und gib ihn auf 2 Dezimalstellen gerundet aus.

🖥 Beispiel

Noten: [4, 5, 3, 6, 5, 4, 5, 3, 4, 6]
Mittelwert: 4.50

💡 Hinweis

Mittelwert = Summe aller Zahlen / Anzahl der Zahlen
sum(zahlen) berechnet die Summe einer Liste
len(zahlen) gibt die Anzahl der Elemente zurück
Runden: round(wert, 2) rundet auf 2 Dezimalstellen
Oder im f-String: f"{wert:.2f}"

✅ Musterlösung

def mittelwert(zahlen):
    return sum(zahlen) / len(zahlen)

noten = [4, 5, 3, 6, 5, 4, 5, 3, 4, 6]
mw = mittelwert(noten)
print(f"Noten: {noten}")
print(f"Mittelwert: {mw:.2f}")

A 3.7

Gerade oder Ungerade?

⭐⭐⭐ Mittel

▼

📋 Aufgabe

Schreibe eine Funktion ist_gerade(zahl), die True zurückgibt, wenn die Zahl gerade ist, und False, wenn sie ungerade ist. Filtere mit dieser Funktion alle geraden Zahlen von 1 bis 20 heraus.

🖥 Erwartete Ausgabe

Gerade Zahlen von 1-20:
2 4 6 8 10 12 14 16 18 20

💡 Hinweis — Kniffliger Teil!

Der Modulo-Operator % gibt den Rest bei Division zurück
Eine gerade Zahl hat keinen Rest bei Division durch 2: zahl % 2 == 0
Kurzform: return zahl % 2 == 0 gibt direkt True/False zurück!
Ausgabe ohne Zeilenumbruch: print(i, end=" ")

✅ Musterlösung

def ist_gerade(zahl):
    return zahl % 2 == 0

print("Gerade Zahlen von 1-20:")
for i in range(1, 21):
    if ist_gerade(i):
        print(i, end=" ")
print()  # Zeilenumbruch am Ende

Eleganter Trick: zahl % 2 == 0 ist bereits ein boolescher Ausdruck — das Ergebnis des Vergleichs ist schon True oder False. Kein if nötig!

A 3.8

Taschenrechner-Funktion

⭐⭐⭐ Mittel

▼

📋 Aufgabe

Schreibe eine Funktion rechner(a, b, operation), die je nach übergebenem Operator ("+", "-", "*", "/") das Ergebnis zurückgibt. Bei Division durch 0 soll eine sinnvolle Fehlermeldung zurückgegeben werden.

🖥 Erwartete Ausgabe

10 + 5 = 15
10 - 5 = 5
10 * 5 = 50
10 / 5 = 2.0
10 / 0 = Fehler: Division durch 0!

💡 Hinweis

Verwende if operation == "+": usw. für jeden Operator
Bei Division: zuerst prüfen ob b == 0, dann dividieren
Du kannst auch None bei Fehler zurückgeben, oder einen Fehlertext als String
Was passiert, wenn eine unbekannte Operation übergeben wird?

✅ Musterlösung

def rechner(a, b, operation):
    if operation == "+":
        return a + b
    elif operation == "-":
        return a - b
    elif operation == "*":
        return a * b
    elif operation == "/":
        if b == 0:
            return "Fehler: Division durch 0!"
        return a / b
    else:
        return "Unbekannte Operation"

operationen = ["+", "-", "*", "/"]
a, b = 10, 5
for op in operationen:
    erg = rechner(a, b, op)
    print(f"{a} {op} {b} = {erg}")

print(f"10 / 0 = {rechner(10, 0, '/')}")

Komplexe Aufgaben

Verzweigungen, Schleifen und Funktionen kombiniert — echte Problemlösung

KOMPLEX

📖 Theorie: Kombinieren von Konzepten

In echten Programmen werden Funktionen, Verzweigungen (if/elif/else) und Schleifen (for/while) kombiniert. Jede Funktion löst eine klar abgegrenzte Teilaufgabe.

if/elif/else: Verzweigung — je nach Bedingung verschiedene Pfade
for-Schleife: Für eine bekannte Anzahl von Wiederholungen
while-Schleife: Solange eine Bedingung wahr ist
Funktionen können andere Funktionen aufrufen (Komposition)

A 4.1

Notenbewertung mit Kommentar

⭐⭐⭐ Mittel

▼

📋 Aufgabe

Schreibe eine Funktion bewerte_note(note), die eine Note (1–6) entgegennimmt und eine Bewertung zurückgibt. Dann schreibe eine Funktion zeige_zeugnis(name, noten_dict), die ein vollständiges Zeugnis ausgibt.

6 → "Ausgezeichnet ⭐"
5 → "Sehr gut 👍"
4 → "Gut ✓"
3 → "Genügend"
2 → "Ungenügend ⚠️"
1 → "Sehr schlecht ❌"

🖥 Erwartete Ausgabe

╔══════════════════════════════════╗
║    ZEUGNIS: Anna Müller          ║
╠══════════════════════════════════╣
║ Mathematik:    5  Sehr gut 👍   ║
║ Deutsch:       4  Gut ✓         ║
║ Informatik:    6  Ausgezeichnet ⭐║
║ Englisch:      3  Genügend      ║
╠══════════════════════════════════╣
║ Notendurchschnitt:  4.50        ║
╚══════════════════════════════════╝

💡 Hinweis

Verwende if note == 6: ... elif note == 5: ... in bewerte_note()
Ein Dictionary hat die Form: {"Fach": note}
Über ein Dictionary iterieren: for fach, note in noten_dict.items():
Rufe mittelwert() aus Aufgabe 3.6 wieder auf!

✅ Musterlösung

def bewerte_note(note):
    if note == 6:
        return "Ausgezeichnet ⭐"
    elif note == 5:
        return "Sehr gut 👍"
    elif note == 4:
        return "Gut ✓"
    elif note == 3:
        return "Genügend"
    elif note == 2:
        return "Ungenügend ⚠️"
    else:
        return "Sehr schlecht ❌"

def mittelwert(zahlen):
    return sum(zahlen) / len(zahlen)

def zeige_zeugnis(name, noten_dict):
    print("╔══════════════════════════════════╗")
    print(f"║    ZEUGNIS: {name:<21}║")
    print("╠══════════════════════════════════╣")
    for fach, note in noten_dict.items():
        bewertung = bewerte_note(note)
        print(f"║ {fach:<14} {note}  {bewertung:<14}║")
    mw = mittelwert(list(noten_dict.values()))
    print("╠══════════════════════════════════╣")
    print(f"║ Notendurchschnitt:  {mw:.2f}<12}║")
    print("╚══════════════════════════════════╝")

noten = {
    "Mathematik:": 5,
    "Deutsch:": 4,
    "Informatik:": 6,
    "Englisch:": 3
}
zeige_zeugnis("Anna Müller", noten)

A 4.2

FizzBuzz – Der Klassikertest

⭐⭐⭐ Mittel

▼

📋 Aufgabe

Schreibe eine Funktion fizzbuzz(zahl), die folgendes zurückgibt:

"FizzBuzz", wenn die Zahl durch 3 und 5 teilbar ist
"Fizz", wenn sie nur durch 3 teilbar ist
"Buzz", wenn sie nur durch 5 teilbar ist
Die Zahl selbst (als String), sonst

Rufe sie für die Zahlen 1 bis 30 auf.

🖥 Erwartete Ausgabe (Auszug)

1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 FizzBuzz ...

💡 Hinweis — Häufiger Fehler!

Prüfe zuerst auf FizzBuzz (durch 3 UND 5)!
Wenn du zuerst auf "durch 3" prüfst, wird 15 fälschlicherweise nur als "Fizz" ausgegeben
In Python: and für logisches "und": zahl % 3 == 0 and zahl % 5 == 0
Oder eleganter: zahl % 15 == 0 ist dasselbe!

✅ Musterlösung

def fizzbuzz(zahl):
    if zahl % 15 == 0:   # zuerst: durch 3 UND 5!
        return "FizzBuzz"
    elif zahl % 3 == 0:
        return "Fizz"
    elif zahl % 5 == 0:
        return "Buzz"
    else:
        return str(zahl)

for i in range(1, 31):
    print(fizzbuzz(i), end=" ")
print()

Warum zuerst FizzBuzz? Wenn man zuerst auf 3 oder 5 prüft, wird die Prüfung auf beide nie erreicht. Die Reihenfolge von if/elif ist entscheidend!

A 4.3

Primzahlprüfung

⭐⭐⭐⭐ Schwer

▼

📋 Aufgabe

Schreibe eine Funktion ist_primzahl(zahl), die prüft, ob eine Zahl eine Primzahl ist (True/False). Erstelle dann eine Funktion primzahlen_bis(grenze), die alle Primzahlen von 2 bis zur Grenze ausgibt.

🖥 Beispiel: primzahlen_bis(50)

Primzahlen bis 50:
2 3 5 7 11 13 17 19 23 29 31 37 41 43 47
Anzahl: 15

💡 Hinweis — Algorithmus erklären

Eine Primzahl ist nur durch 1 und sich selbst teilbar
Zahlen kleiner als 2 sind keine Primzahlen → sofort return False
Prüfe alle Teiler von 2 bis zahl-1 mit einer Schleife
Wenn zahl % teiler == 0 → nicht prim → return False
Wenn kein Teiler gefunden → return True
Optimierung: Teiler nur bis int(zahl**0.5) + 1 prüfen (Wurzel reicht!)

✅ Musterlösung

def ist_primzahl(zahl):
    if zahl < 2:
        return False
    for teiler in range(2, int(zahl**0.5) + 1):
        if zahl % teiler == 0:
            return False
    return True

def primzahlen_bis(grenze):
    print(f"Primzahlen bis {grenze}:")
    anzahl = 0
    for zahl in range(2, grenze + 1):
        if ist_primzahl(zahl):
            print(zahl, end=" ")
            anzahl += 1
    print(f"\nAnzahl: {anzahl}")

primzahlen_bis(50)

Warum Wurzel? Wenn n = a × b, dann muss mindestens einer der Faktoren ≤ √n sein. Deshalb genügt es, bis zur Wurzel zu prüfen — das macht das Programm deutlich schneller.

A 4.4

Passwort-Validator

⭐⭐⭐⭐ Schwer

▼

📋 Aufgabe

Schreibe eine Funktion validiere_passwort(passwort), die ein Passwort prüft und eine Liste aller Probleme zurückgibt (leere Liste = alles OK).

Anforderungen:

Mindestens 8 Zeichen
Mindestens ein Grossbuchstabe
Mindestens ein Kleinbuchstabe
Mindestens eine Ziffer

🖥 Erwartete Ausgabe

"abc": ❌ Ungültig
  - Mindestens 8 Zeichen erforderlich
  - Kein Grossbuchstabe gefunden
  - Keine Ziffer gefunden

"Python3": ❌ Ungültig
  - Mindestens 8 Zeichen erforderlich

"Python3!": ✅ Passwort gültig!

💡 Hinweis — String-Methoden

any(c.isupper() for c in passwort) prüft ob irgendein Zeichen gross ist
any(c.islower() for c in passwort) — Kleinbuchstaben
any(c.isdigit() for c in passwort) — Ziffern
Erstelle eine leere Liste fehler = [] und füge Probleme mit fehler.append("...") hinzu
Gib am Ende fehler zurück

✅ Musterlösung

def validiere_passwort(passwort):
    fehler = []

    if len(passwort) < 8:
        fehler.append("Mindestens 8 Zeichen erforderlich")

    if not any(c.isupper() for c in passwort):
        fehler.append("Kein Grossbuchstabe gefunden")

    if not any(c.islower() for c in passwort):
        fehler.append("Kein Kleinbuchstabe gefunden")

    if not any(c.isdigit() for c in passwort):
        fehler.append("Keine Ziffer gefunden")

    return fehler

def zeige_ergebnis(passwort):
    probleme = validiere_passwort(passwort)
    if probleme:
        print(f'"{passwort}": ❌ Ungültig')
        for p in probleme:
            print(f"  - {p}")
    else:
        print(f'"{passwort}": ✅ Passwort gültig!')
    print()

zeige_ergebnis("abc")
zeige_ergebnis("Python3")
zeige_ergebnis("Python3!")

Generator-Ausdruck: any(c.isupper() for c in passwort) ist eine kompakte Art, jedes Zeichen zu prüfen. Es gibt True zurück, sobald ein einziges Zeichen die Bedingung erfüllt.

A 4.5

Fakultät berechnen

⭐⭐⭐ Mittel

▼

📋 Aufgabe

Schreibe eine Funktion fakultaet(n), die die Fakultät von n berechnet (n! = 1 × 2 × 3 × ... × n). Verwende eine Schleife (kein Rekursion). Gib die Fakultät für die Zahlen 0 bis 10 aus.

🖥 Erwartete Ausgabe

0! =  1
1! =  1
2! =  2
3! =  6
4! =  24
5! =  120
6! =  720
7! =  5040
8! =  40320
9! =  362880
10! = 3628800

💡 Hinweis — Akkumulator-Muster

Starte mit einem Akkumulator: ergebnis = 1
Multipliziere in einer Schleife: ergebnis *= i (dasselbe wie ergebnis = ergebnis * i)
Schleife: for i in range(2, n + 1): — bei 0! und 1! wird die Schleife nie ausgeführt → Ergebnis bleibt 1 ✓

✅ Musterlösung

def fakultaet(n):
    ergebnis = 1
    for i in range(2, n + 1):
        ergebnis *= i
    return ergebnis

for n in range(11):
    print(f"{n}! = {fakultaet(n)}")

Akkumulator-Muster: Man startet mit einem neutralen Startwert (bei Multiplikation: 1, bei Addition: 0) und "akkumuliert" in jeder Schleifeniteration den neuen Wert. Das ist ein grundlegendes Algorithmus-Muster!

A 4.6

Fibonacci-Folge

⭐⭐⭐⭐ Schwer

▼

📋 Aufgabe

Schreibe eine Funktion fibonacci(n), die die ersten n Fibonacci-Zahlen als Liste zurückgibt. Bei Fibonacci gilt: Jede Zahl ist die Summe der beiden vorherigen (0, 1, 1, 2, 3, 5, 8, ...).

Schreibe ausserdem zeige_fibonacci(n), die die Folge hübsch anzeigt und das Verhältnis benachbarter Zahlen (Goldener Schnitt ≈ 1.618) berechnet.

🖥 Erwartete Ausgabe (n=10)

Fibonacci-Folge (10 Zahlen):
0, 1, 1, 2, 3, 5, 8, 13, 21, 34

Verhältnisse (→ Goldener Schnitt):
  1/1 = 1.0000
  1/1 = 1.0000
  2/1 = 2.0000
  3/2 = 1.5000
  5/3 = 1.6667
  8/5 = 1.6000
  13/8 = 1.6250
  21/13 = 1.6154
  34/21 = 1.6190

💡 Hinweis — Listenaufbau

Starte mit folge = [0, 1] für die ersten zwei Zahlen
In der Schleife: folge.append(folge[-1] + folge[-2])
folge[-1] ist das letzte Element, folge[-2] das vorletzte
Sonderfall: was passiert wenn n kleiner als 2 ist?
Ausgabe mit Komma: ", ".join(str(x) for x in folge)

✅ Musterlösung

def fibonacci(n):
    if n <= 0:
        return []
    if n == 1:
        return [0]
    folge = [0, 1]
    for _ in range(n - 2):
        folge.append(folge[-1] + folge[-2])
    return folge

def zeige_fibonacci(n):
    folge = fibonacci(n)
    print(f"Fibonacci-Folge ({n} Zahlen):")
    print(", ".join(str(x) for x in folge))
    print()
    print("Verhältnisse (→ Goldener Schnitt):")
    for i in range(1, len(folge)):
        if folge[i - 1] != 0:
            verhaeltnis = folge[i] / folge[i - 1]
            print(f"  {folge[i]}/{folge[i-1]} = {verhaeltnis:.4f}")

zeige_fibonacci(10)

Mathematik: Das Verhältnis aufeinanderfolgender Fibonacci-Zahlen nähert sich dem Goldenen Schnitt (≈ 1.61803...) an — ein faszinierendes Muster der Mathematik, das in der Natur überall vorkommt!

A 4.7

Zahlen-Analyse — Abschlussprojekt

⭐⭐⭐⭐⭐ Sehr schwer

▼

📋 Aufgabe — Abschlussübung

Schreibe eine umfassende Zahlen-Analyse-Suite mit folgenden Funktionen:

minimum(zahlen) — gibt die kleinste Zahl zurück (ohne min())
maximum(zahlen) — gibt die grösste Zahl zurück (ohne max())
mittelwert(zahlen) — gibt den Durchschnitt zurück
summe(zahlen) — gibt die Summe zurück (ohne sum())
anzahl_gerade(zahlen) — zählt gerade Zahlen
analyse(zahlen) — ruft alle obigen Funktionen auf und zeigt eine vollständige Statistik

Teste mit der Liste: [15, 3, 28, 7, 42, 11, 6, 19, 34, 8]

🖥 Erwartete Ausgabe

╔══════════════════════════════════╗
║      ZAHLEN-ANALYSE              ║
╠══════════════════════════════════╣
║ Zahlen: [15,3,28,7,42,11,6,19,34,8]
║ Anzahl:          10              ║
╠══════════════════════════════════╣
║ Minimum:         3               ║
║ Maximum:         42              ║
║ Summe:           173             ║
║ Mittelwert:      17.30           ║
║ Gerade Zahlen:   5               ║
║ Ungerade Zahlen: 5               ║
╚══════════════════════════════════╝

💡 Hinweis — Algorithmen

minimum: Starte mit min_val = zahlen[0], vergleiche jedes Element
maximum: Analog, aber mit grösser-Vergleich
summe: Akkumulator: total = 0, dann total += zahl
anzahl_gerade: Zähle mit einem Zähler, den du bei jedem geraden Element um 1 erhöhst
analyse() ruft alle anderen Funktionen auf — perfekte Komposition!

✅ Musterlösung

def minimum(zahlen):
    min_val = zahlen[0]
    for z in zahlen:
        if z < min_val:
            min_val = z
    return min_val

def maximum(zahlen):
    max_val = zahlen[0]
    for z in zahlen:
        if z > max_val:
            max_val = z
    return max_val

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

def mittelwert(zahlen):
    return summe(zahlen) / len(zahlen)

def anzahl_gerade(zahlen):
    zaehler = 0
    for z in zahlen:
        if z % 2 == 0:
            zaehler += 1
    return zaehler

def analyse(zahlen):
    n = len(zahlen)
    gerade = anzahl_gerade(zahlen)
    print("╔══════════════════════════════════╗")
    print("║      ZAHLEN-ANALYSE              ║")
    print("╠══════════════════════════════════╣")
    print(f"║ Zahlen: {zahlen}")
    print(f"║ Anzahl:          {n:<16}║")
    print("╠══════════════════════════════════╣")
    print(f"║ Minimum:         {minimum(zahlen):<16}║")
    print(f"║ Maximum:         {maximum(zahlen):<16}║")
    print(f"║ Summe:           {summe(zahlen):<16}║")
    print(f"║ Mittelwert:      {mittelwert(zahlen):<16.2f}║")
    print(f"║ Gerade Zahlen:   {gerade:<16}║")
    print(f"║ Ungerade Zahlen: {n - gerade:<16}║")
    print("╚══════════════════════════════════╝")

zahlen = [15, 3, 28, 7, 42, 11, 6, 19, 34, 8]
analyse(zahlen)

Komposition at its best: mittelwert() ruft summe() auf! Statt dieselbe Logik zweimal zu schreiben, wiederverwendet man vorhandene Funktionen. Das ist DRY-Prinzip: Don't Repeat Yourself.