Gymnasium OttweilerSkript zum MINT-Zweig
Programmieren mit PythonKapitel 1

Kapitel 1

Programmieren mit Python

Skript Informatik · Klasse 10 · MINT

Notebooks in diesem Kapitel DS01–DS14

Alle Notebooks der Klasse · Das grüne Schild an einer Überschrift zeigt, zu welchem Notebook der Abschnitt gehört.

PDF zum Ausdrucken zusammenstellen

Kreuze an, welche Abschnitte du brauchst. Die PDF hat dasselbe Aussehen wie das gedruckte Skript, mit Platz zum Schreiben. Jeden Abschnitt gibt es auch einzeln unter seiner Überschrift, das ganze Kapitel unten auf der Seite.

In diesem Kapitel lernst du, Programme in der Programmiersprache Python zu schreiben. Aus der Blockprogrammierung kennst du schon Bausteine wie Wiederholungen und Bedingungen. Jetzt schreibst du dieselben Ideen als Text. Das ist am Anfang ungewohnt: Ein fehlendes Komma oder eine falsche Einrückung genügt, und das Programm läuft nicht. Dieses Skript zeigt dir deshalb jeden Schritt einzeln, erklärt jedes Beispiel Zeile für Zeile und zeigt dir die typischen Fehler, bevor sie dir passieren.

So arbeitest du mit diesem Skript

Diesen Abschnitt als PDF (S. 1–2)

Das Skript ist zum selbstständigen Lernen gedacht. Du kannst damit jede Unterrichtsstunde vorbereiten, nacharbeiten oder nachholen. Am besten arbeitest du so:

  1. Lies einen Abschnitt in Ruhe. Die Abschnitte bauen aufeinander auf. Überspringe nichts, auch wenn es leicht aussieht.
  2. Tippe die Beispiele selbst ab und starte sie. Kopieren ist bequemer, aber beim Abtippen lernst du die Schreibweise. Vergleiche dein Ergebnis mit der abgedruckten Ausgabe.
  3. Bearbeite die Arbeitsaufträge. Programme schreibst und testest du direkt am Computer. Wo du etwas überlegen, vorhersagen oder begründen sollst, ist unter dem Auftrag Platz zum Schreiben.
  4. Kontrolliere mit dem Lösungsheft – aber erst, wenn du es selbst versucht hast. Oft gibt es mehrere richtige Lösungen. Wichtig ist, dass dein Programm das Richtige tut.
  5. Hake am Ende den Selbstcheck ab. Wenn du einen Punkt nicht abhaken kannst, lies den passenden Teil noch einmal.

Die Kästen im Skript haben feste Farben. So weißt du sofort, was dich erwartet:

Kasten Farbe Was darin steht
Merke rot das Wichtigste, das du dir merken musst
Definition grün was ein Fachbegriff genau bedeutet
Leitidee, Lernziele, Beispiel gelb Einstieg, Ziele und ausführliche Beispiele
Stolperstein, Werkzeug, Tipp gelb typische Fehler, kleine Hilfsmittel, Hinweise
So kannst du es sagen gelb Mustersätze, um Programme in Fachsprache zu beschreiben
Versuch, Arbeitsauftrag blau hier bist du dran: ausprobieren oder eine Aufgabe lösen
Auswertung, Beurteilung lila Ergebnisse zusammentragen und bewerten

Programme stehen in grauen Kästen. Die Farben im Code helfen beim Lesen, genau wie in vielen Programmierumgebungen. Was ein Programm ausgibt, steht in einem weißen Kasten mit der Aufschrift AUSGABE. Was du selbst eintippst, ist darin blau und fett gedruckt. Fehlermeldungen stehen in einem ebensolchen Kasten mit der Aufschrift FEHLERMELDUNG.

So kannst du es sagen

Mit diesen Satzanfängen kannst du in jedem Abschnitt beschreiben und erklären, was ein Programm tut:

Tipp

Es ist egal, ob du im Jupyter-Notebook aus dem Unterricht programmierst oder in einem Editor wie Thonny. Die Programme in diesem Skript laufen überall, wo Python 3 installiert ist. Wie du Python zu Hause einrichtest, steht im Anhang.

1.1Variablen, Eingabe und Ausgabe DS01

Diesen Abschnitt als PDF (S. 3–19)

Das Jupyter-Notebook aus dem Unterricht: DS01_Variablen_Ein_Ausgabe.ipynb. Herunterladen und in VS Code oder Jupyter öffnen.

Zum Weiterüben: DS01_Weitere_Uebungen.ipynb mit den Aufgaben aus „Weitere Übungen“ zum Bearbeiten in Python.

Leitidee

Ein Programm ist eine Liste von Anweisungen, die der Computer der Reihe nach ausführt – von oben nach unten. In der Blockprogrammierung hast du die Anweisungen als Bausteine zusammengeschoben. In Python schreibst du sie als Text. In diesem Abschnitt lernst du die drei wichtigsten Dinge, die fast jedes Programm braucht: Es gibt etwas aus, es merkt sich Werte und es liest Eingaben der Nutzerin oder des Nutzers ein. Am Ende schreibst du ein Programm, das dich nach deinem Namen fragt und dir einen Steckbrief ausgibt.

Lernziele

Nach diesem Abschnitt kannst du

1.1.1Das erste Programm: Ausgaben mit print

Das kürzeste sinnvolle Programm besteht aus einer einzigen Zeile:

print("Hallo Welt!")
Hallo Welt!

Das Wort print ist englisch und heißt „drucken“. Gemeint ist: Zeige etwas auf dem Bildschirm an. Was angezeigt werden soll, steht in den runden Klammern dahinter. Der Text steht in Anführungszeichen. Die Anführungszeichen selbst erscheinen nicht in der Ausgabe. Sie zeigen Python nur, wo der Text anfängt und wo er aufhört.

Ein Programm hat meistens mehrere Zeilen. Python führt sie nacheinander von oben nach unten aus. Jede print-Anweisung beginnt eine neue Zeile in der Ausgabe:

print("Guten Morgen!")
print("Heute lernen wir Python.")
print("Los geht's.")
Guten Morgen!
Heute lernen wir Python.
Los geht's.

Text oder Zahl?

Mit print kannst du auch Zahlen ausgeben und sogar rechnen. Vergleiche die beiden Zeilen genau:

print(3 + 4)
print("3 + 4")
7
3 + 4

Du kannst in eine print-Anweisung auch mehrere Dinge schreiben. Trenne sie durch Kommas. Python setzt in der Ausgabe automatisch je ein Leerzeichen dazwischen:

print("Ich bin", 15, "Jahre alt.")
print("In fünf Jahren bin ich", 15 + 5, "Jahre alt.")
Ich bin 15 Jahre alt.
In fünf Jahren bin ich 20 Jahre alt.
Merke

Mit print(...) gibt man Werte auf dem Bildschirm aus. Texte stehen in Anführungszeichen, Zahlen und Rechnungen ohne. Mehrere Werte trennt man durch Kommas.

Versuch: Probiere es aus

Tippe das Programm mit „Guten Morgen!“ ab und starte es. Ändere dann die Texte. Was passiert, wenn du eine der drei Zeilen an den Anfang verschiebst?

Wenn etwas schiefgeht

Beim Abtippen passieren Fehler – auch Profis jeden Tag. Python bricht dann ab und zeigt eine Fehlermeldung. Das ist kein Grund zur Sorge: Die Meldung ist ein Hinweis, wo das Problem liegt. Hier fehlt das schließende Anführungszeichen:

print("Hallo)
SyntaxError: unterminated string literal (detected at line 1)

Die Fehlermeldung ist englisch. SyntaxError bedeutet: Die Schreibweise stimmt nicht – Python versteht den Satz nicht. Unterminated string literal heißt „nicht abgeschlossener Text“. Python sagt dir sogar die Zeile: detected at line 1. Die Lösung: das fehlende " ergänzen.

Und was passiert, wenn du die Anführungszeichen ganz vergisst?

print(Hallo)
NameError: name 'Hallo' is not defined

Ohne Anführungszeichen hält Python Hallo nicht für einen Text, sondern für einen Namen – so wie die Variablen, die du gleich kennenlernst. Einen Namen Hallo gibt es aber nicht. Deshalb meldet Python einen NameError: „Der Name ‘Hallo’ ist nicht definiert.“

Stolperstein

Die häufigsten Tippfehler am Anfang: ein vergessenes Anführungszeichen, eine vergessene Klammer, Print statt print (Python unterscheidet Groß- und Kleinschreibung!) und deutsche Anführungszeichen „…“ statt "…". Wenn eine Fehlermeldung kommt, schau dir zuerst die genannte Zeile an – und die Zeile davor.

1.1.2Variablen: Werte speichern

Programme müssen sich Dinge merken: einen Namen, einen Punktestand, einen Preis. Dafür gibt es Variablen.

Stell dir eine Variable wie eine beschriftete Schachtel vor. Außen auf der Schachtel steht ein Name, zum Beispiel alter. In der Schachtel liegt ein Wert, zum Beispiel 15. Immer wenn das Programm den Namen alter liest, schaut es in die Schachtel und nimmt den Wert, der gerade darin liegt.

Drei Variablen: Außen steht der Name, innen liegt der Wert. Darunter steht, welche Art von Wert es ist (der Datentyp)
Definition: Variable

Eine Variable ist ein benannter Speicherplatz im Arbeitsspeicher des Computers, in dem ein Wert abgelegt wird. Über ihren Namen kann das Programm den Wert lesen und verändern.

In Python legst du eine Variable an, indem du ihr einen Wert gibst:

alter = 15
print(alter)
print("Ich bin", alter, "Jahre alt.")
15
Ich bin 15 Jahre alt.

Das Gleichheitszeichen ist ein Zuweisungszeichen

Das Zeichen = bedeutet in Python nicht „ist gleich“ wie in Mathe. Es bedeutet: „bekommt den Wert“. Lies alter = 15 also so: „Die Variable alter bekommt den Wert 15.“ Man nennt das eine Zuweisung. Dabei wird immer zuerst die rechte Seite ausgerechnet, dann wird das Ergebnis in die Variable links gelegt.

Deshalb ist die folgende Zeile in Python sinnvoll, obwohl sie in Mathe falsch wäre:

alter = 15
print(alter)
alter = alter + 1
print(alter)
15
16

Wie sich die Werte Schritt für Schritt ändern, zeigt ein Ablaufprotokoll. Darin steht nach jeder ausgeführten Zeile, welchen Wert die Variable gerade hat:

Schritt Zeile ausgeführte Anweisung alter danach
1 1 alter = 15 15
2 2 print(alter) 15
3 3 alter = alter + 1 16
4 4 print(alter) 16
Merke

Gute Namen für Variablen

Den Namen einer Variablen darfst du selbst wählen. Dabei gelten ein paar Regeln:

Name erlaubt? Grund
punkte ✓
punkte_runde_2 ✓
2_runde ✗ beginnt mit einer Ziffer
meine punkte ✗ enthält ein Leerzeichen
Stolperstein

Wenn du eine Variable benutzt, bevor sie einen Wert bekommen hat, oder dich beim Namen vertippst, meldet Python einen NameError:

alter = 15
print(Alter)
NameError: name 'Alter' is not defined. Did you mean: 'alter'?

Neuere Python-Versionen geben dir sogar einen Tipp: Did you mean: ‘alter’? – „Meintest du ‘alter’?“

Arbeitsauftrag 1: Vorhersage

Lies das Programm, ohne es auszuführen. Schreibe auf, was es ausgibt. Überprüfe deine Vorhersage danach am Computer.

punkte = 10
print(punkte)
punkte = punkte + 5
punkte = punkte * 2
print("Endstand:", punkte)

Meine Vorhersage:

Lösung vergleichen
10
Endstand: 30

punkte bekommt zuerst den Wert 10, der ausgegeben wird. Dann wird 10 + 5 = 15 gespeichert und danach 15 * 2 = 30. Erst dann wird wieder ausgegeben. Wer 20 erwartet hat, hat übersehen, dass in Zeile 4 mit dem neuen Wert 15 gerechnet wird.

1.1.3Datentypen: Zahlen, Texte und Wahrheitswerte

In einer Variablen können ganz unterschiedliche Arten von Werten liegen: ganze Zahlen, Kommazahlen, Texte. Die Art eines Wertes heißt Datentyp. Python merkt sich zu jedem Wert seinen Datentyp, denn davon hängt ab, was man mit dem Wert machen kann. Mit Zahlen kann man rechnen, mit Texten nicht.

Datentyp Bedeutung Beispiele
int ganze Zahl (englisch integer) 15, -3, 0, 2026
float Kommazahl (englisch floating point number) 1.68, -0.5, 3.0
str Zeichenkette, also Text (englisch string) "Alex", "Hallo Welt!", "15"
bool Wahrheitswert (nach George Boole) True (wahr), False (falsch)
Definition: Datentyp

Der Datentyp eines Wertes legt fest, welche Art von Daten er darstellt (z. B. ganze Zahl, Kommazahl, Text oder Wahrheitswert) und welche Operationen damit möglich sind.

Drei Dinge sind besonders wichtig:

Mit type(...) kannst du Python fragen, welchen Datentyp ein Wert hat:

name = "Alex"
alter = 15
groesse = 1.68
volljaehrig = False
print(type(name))
print(type(alter))
print(type(groesse))
print(type(volljaehrig))
<class 'str'>
<class 'int'>
<class 'float'>
<class 'bool'>

Die Ausgabe <class 'str'> bedeutet einfach: „Dieser Wert ist vom Typ str.“

Merke

Python unterscheidet u. a. die Datentypen int (Ganzzahl), float (Kommazahl), str (Zeichenkette) und bool (Wahrheitswert).

Rechnen mit Zahlen

Mit int- und float-Werten kannst du rechnen. Die Grundrechenarten schreibt man mit +, -, * (mal) und / (geteilt). Es gilt wie in Mathe Punkt vor Strich, und Klammern werden zuerst ausgerechnet:

a = 7
b = 2
print(a + b)
print(a - b)
print(a * b)
print(a / b)
print(2 + 3 * 4)
print((2 + 3) * 4)
9
5
14
3.5
14
20

Beachte Zeile 6: Das Ergebnis einer Division mit / ist immer ein float, auch wenn es aufgeht. 6 / 2 ergibt 3.0, nicht 3. Weitere Rechenzeichen lernst du im nächsten Abschnitt kennen.

Stolperstein

Schreibst du eine Kommazahl versehentlich mit Komma, gibt es keine Fehlermeldung – Python versteht aber etwas völlig anderes:

preis = 2,50
print(preis)
(2, 50)

Python hat zwei Zahlen gespeichert, 2 und 50. Mit preis kann man jetzt nicht mehr rechnen. Richtig ist preis = 2.50.

Arbeitsauftrag 2: Datentypen bestimmen

Gib zu jedem Wert den Datentyp an (int, float, str oder bool). Überprüfe deine Antworten anschließend mit type(...).

Wert 42 "42" 4.2 True "True" -7 7 / 7 "Hallo"
Datentyp
Lösung vergleichen
Wert 42 "42" 4.2 True "True" -7 7 / 7 "Hallo"
Datentyp int str float bool str int float str

Alles in Anführungszeichen ist eine Zeichenkette (str), auch "42" und "True". Das Ergebnis von / ist immer ein float: 7 / 7 ergibt 1.0.

1.1.4Eingaben mit input

Bisher stehen alle Werte fest im Programm. Spannender wird es, wenn die Nutzerin oder der Nutzer etwas eingeben kann. Dafür gibt es input(...):

name = input("Wie heißt du? ")
print("Hallo", name)
Wie heißt du? «Lena»
Hallo Lena
Tipp

Setze ans Ende der Eingabeaufforderung ein Leerzeichen: "Wie heißt du? ". Sonst klebt die Eingabe direkt am Fragezeichen.

Die Eingabe ist immer ein Text

Probiere einmal dieses Programm mit der Eingabe 7. Was erwartest du?

zahl = input("Gib eine Zahl ein: ")
print(zahl + zahl)
print(type(zahl))
Gib eine Zahl ein: «7»
77
<class 'str'>

Überraschung: Python rechnet nicht 7 + 7 = 14, sondern gibt 77 aus. Der Grund steht in der letzten Zeile: zahl hat den Typ str. Das, was jemand eintippt, ist für Python immer eine Zeichenkette, auch wenn nur Ziffern darin stehen. Und das Pluszeichen hängt zwei Zeichenketten einfach aneinander: "7" + "7" ergibt "77".

Merke

1.1.5Typumwandlung: aus Text wird eine Zahl

Damit du mit einer Eingabe rechnen kannst, musst du sie in eine Zahl umwandeln. Dafür gibt es drei Befehle, die genauso heißen wie die Datentypen:

Befehl wandelt um in Beispiel Ergebnis
int(...) ganze Zahl int("7") 7
float(...) Kommazahl float("2.5") 2.5
str(...) Zeichenkette str(15) "15"
Definition: Typumwandlung

Bei einer Typumwandlung wird ein Wert in einen anderen Datentyp umgewandelt, zum Beispiel die Zeichenkette "7" in die ganze Zahl 7.

Das folgende Programm zeigt alles zusammen. Es fragt nach einer Lieblingszahl, zeigt, dass die Eingabe ein Text ist, und rechnet nach der Umwandlung mit ihr:

lieblingszahl = input("Gib deine Lieblingszahl ein: ")
print("Deine Eingabe war:", lieblingszahl, "- Typ:", type(lieblingszahl))

lieblingszahl_int = int(lieblingszahl)
print("Deine Zahl mal 2 ist:", lieblingszahl_int * 2)
Gib deine Lieblingszahl ein: «7»
Deine Eingabe war: 7 - Typ: <class 'str'>
Deine Zahl mal 2 ist: 14

Eingabe und Umwandlung in einer Zeile

Meistens schreibt man Eingabe und Umwandlung in eine Zeile. Das ist kürzer, und man braucht keine zweite Variable:

alter = int(input("Wie alt bist du? "))
print("Nächstes Jahr bist du", alter + 1)
Wie alt bist du? «15»
Nächstes Jahr bist du 16

Lies Zeile 1 von innen nach außen: Zuerst wird input(...) ausgeführt und liefert den Text "15". Dieser Text wird an int(...) übergeben und in die Zahl 15 umgewandelt. Erst diese Zahl wird in alter gespeichert. Achte darauf, dass am Ende zwei schließende Klammern stehen – eine für input, eine für int.

Für Kommazahlen nimmst du float statt int:

groesse = float(input("Wie groß bist du in Metern? "))
print("In Zentimetern sind das", groesse * 100)
Wie groß bist du in Metern? «1.68»
In Zentimetern sind das 168.0
Merke

Soll eine Eingabe als Zahl weiterverarbeitet werden, muss sie umgewandelt werden: int(...) bzw. float(...) (Typumwandlung).

Stolperstein

Die Umwandlung klappt nur, wenn der Text wirklich wie eine Zahl aussieht. Sonst meldet Python einen ValueError („falscher Wert“):

alter = int(input("Wie alt bist du? "))
ValueError: invalid literal for int() with base 10: 'sieben'

Dasselbe passiert bei int("2.5") (eine Kommazahl ist keine ganze Zahl) und bei float("2,5") (Komma statt Punkt). Bei einem ValueError lohnt sich also ein Blick darauf, was eingegeben wurde.

1.1.6Texte zusammensetzen

Mit Kommas in print setzt Python immer ein Leerzeichen zwischen die Teile. Manchmal willst du das nicht, zum Beispiel wenn direkt nach einem Namen ein Komma oder ein Punkt folgen soll. Dann kannst du Texte mit + aneinanderhängen (verketten). Dabei kommt kein Leerzeichen dazu – die brauchst du selbst in den Anführungszeichen:

name = "Alex"
print("Hallo, " + name + "!")
print("Hallo,", name, "!")
Hallo, Alex!
Hallo, Alex !

In Zeile 3 stört das Leerzeichen vor dem Ausrufezeichen. Mit + (Zeile 2) sitzt alles genau richtig.

Stolperstein

Mit + lassen sich nur Texte mit Texten verbinden. Eine Zahl muss vorher mit str(...) in einen Text umgewandelt werden. Sonst bricht das Programm ab:

alter = 15
print("Du bist " + alter + " Jahre alt.")
Traceback (most recent call last):
  File "steckbrief.py", line 2, in <module>
    print("Du bist " + alter + " Jahre alt.")
          ~~~~~~~~~~~^~~~~~~
TypeError: can only concatenate str (not "int") to str

Richtig ist: print("Du bist " + str(alter) + " Jahre alt.")

Eine Fehlermeldung lesen

Die Meldung oben ist eine vollständige Fehlermeldung, wie du sie auf dem Bildschirm siehst. Lies sie von unten nach oben:

  1. Letzte Zeile: die Art des Fehlers und eine kurze Beschreibung. Hier: TypeError – ein Fehler mit den Datentypen. can only concatenate str (not “int”) to str heißt: „Kann nur str (nicht int) an str anhängen.“
  2. Die Zeilen darüber zeigen, wo der Fehler passiert ist: in Zeile 2 (line 2). Darunter steht diese Zeile noch einmal, und die Zeichen ~~~^~~~ zeigen auf die Stelle, an der der Fehler auftritt.
  3. Die erste Zeile Traceback (most recent call last) kannst du überlesen.

Die vier Fehlerarten, die dir am Anfang am häufigsten begegnen:

Fehler Bedeutung typische Ursache
SyntaxError Schreibweise falsch Anführungszeichen oder Klammer fehlt
NameError Name unbekannt Tippfehler im Namen, Variable noch nicht angelegt, Anführungszeichen vergessen
TypeError Datentyp passt nicht Zahl und Text mit + verbunden
ValueError Wert passt nicht int("sieben"), float("2,5")
So kannst du es sagen

So beschreibst du ein Programm in Fachsprache – vom einfachen zum genauen Satz:

1.1.7Übungen

Arbeitsauftrag 3: Fehler finden

Das folgende Programm soll nach zwei Zahlen fragen und ihre Summe ausgeben. Es enthält aber drei Fehler. Finde sie, erkläre jeweils, welche Fehlermeldung oder welches falsche Verhalten sie auslösen, und schreibe das Programm richtig auf.

zahl1 = input("Erste Zahl: )
zahl2 = input("Zweite Zahl: ")
print("Die Summe ist", Zahl1 + zahl2)

Die Fehler:

Lösung vergleichen
  1. In Zeile 1 fehlt das schließende Anführungszeichen nach Erste Zahl: → SyntaxError.
  2. In Zeile 3 steht Zahl1 mit großem Z. Die Variable heißt aber zahl1 → NameError.
  3. Die Eingaben werden nicht umgewandelt. Dann rechnet das Programm nicht, sondern hängt die Texte aneinander: Aus 3 und 4 wird 34 statt 7. Dieser Fehler erzeugt keine Fehlermeldung – das Ergebnis ist einfach falsch.
zahl1 = int(input("Erste Zahl: "))
zahl2 = int(input("Zweite Zahl: "))
print("Die Summe ist", zahl1 + zahl2)
Erste Zahl: «3»
Zweite Zahl: «4»
Die Summe ist 7

Auch float statt int ist richtig. Dann funktioniert das Programm sogar mit Kommazahlen.

Arbeitsauftrag 4: Steckbrief

Schreibe ein Programm, das folgende Angaben mit input() abfragt und anschließend als vollständigen Satz ausgibt:

Gib zum Schluss in einer zweiten Zeile das doppelte Alter aus. Daran siehst du, ob das Alter wirklich als Zahl gespeichert ist.

So könnte die Ausgabe aussehen:

Wie heißt du? «Alex»
Wie alt bist du? «15»
Was ist dein Lieblingsfach? «Informatik»
Hallo, ich bin Alex, 15 Jahre alt und mein Lieblingsfach ist Informatik.
Doppeltes Alter: 30
Lösung vergleichen
name = input("Wie heißt du? ")
alter = int(input("Wie alt bist du? "))
fach = input("Was ist dein Lieblingsfach? ")
print("Hallo, ich bin " + name + ", " + str(alter)
      + " Jahre alt und mein Lieblingsfach ist " + fach + ".")
print("Doppeltes Alter:", alter * 2)
Wie heißt du? «Alex»
Wie alt bist du? «15»
Was ist dein Lieblingsfach? «Informatik»
Hallo, ich bin Alex, 15 Jahre alt und mein Lieblingsfach ist Informatik.
Doppeltes Alter: 30

Das Alter wird mit int(...) in eine Zahl umgewandelt, wie es die Aufgabe verlangt. Für die Ausgabe mit + muss es dann mit str(...) wieder in einen Text verwandelt werden. Die print-Anweisung ist lang. Python erlaubt, sie innerhalb der Klammern in der nächsten Zeile fortzusetzen. Die letzte Zeile zeigt, warum die Umwandlung wichtig ist: Mit der Zahl 15 ergibt alter * 2 den Wert 30. Hätte man die Eingabe als Text gelassen, käme 1515 heraus – der Text würde einfach verdoppelt.

Auch diese Lösung mit Kommas ist richtig. name + "," hängt das Komma direkt an den Namen:

name = input("Wie heißt du? ")
alter = int(input("Wie alt bist du? "))
fach = input("Was ist dein Lieblingsfach? ")
print("Hallo, ich bin", name + ",", alter,
      "Jahre alt und mein Lieblingsfach ist", fach + ".")
print("Doppeltes Alter:", alter * 2)
Wie heißt du? «Alex»
Wie alt bist du? «15»
Was ist dein Lieblingsfach? «Informatik»
Hallo, ich bin Alex, 15 Jahre alt und mein Lieblingsfach ist Informatik.
Doppeltes Alter: 30

Vorsicht bei Kommas: print("Hallo, ich bin", name, ",", alter, ...) würde Leerzeichen vor die Kommas setzen („Alex , 15“). Deshalb wird hier name + "," geschrieben.

Arbeitsauftrag 5: Einfacher Rechner

Schreibe ein Programm, das zwei Zahlen einliest (denk an die Typumwandlung!) und Summe, Differenz und Produkt der beiden Zahlen ausgibt.

Lösung vergleichen
a = float(input("Erste Zahl: "))
b = float(input("Zweite Zahl: "))
print("Summe:", a + b)
print("Differenz:", a - b)
print("Produkt:", a * b)
Erste Zahl: «7.5»
Zweite Zahl: «2»
Summe: 9.5
Differenz: 5.5
Produkt: 15.0

Mit float kann man auch Kommazahlen eingeben. Wer nur ganze Zahlen zulassen will, nimmt int.

Werkzeug

Mit round(wert, stellen) rundest du eine Zahl auf eine bestimmte Anzahl von Nachkommastellen. round(3.14159, 2) ergibt 3.14. Lässt du die Stellen weg, wird auf eine ganze Zahl gerundet: round(2.7) ergibt 3.

Arbeitsauftrag 6 (Zusatz): Gesamtpreis

Frage einen Preis in Euro (als Kommazahl, float) sowie eine Anzahl an Artikeln (als int) ab und berechne den Gesamtpreis. Runde die Ausgabe sinnvoll (Tipp: round(wert, 2)).

Lösung vergleichen
preis = float(input("Preis pro Artikel in Euro: "))
anzahl = int(input("Anzahl der Artikel: "))
gesamtpreis = preis * anzahl
print("Gesamtpreis:", round(gesamtpreis, 2), "Euro")
Preis pro Artikel in Euro: «1.99»
Anzahl der Artikel: «3»
Gesamtpreis: 5.97 Euro

Bei diesen Eingaben stimmt das Ergebnis zufällig auch ohne round. Das ist aber nicht immer so. Computer speichern Kommazahlen nicht immer ganz exakt, und beim Rechnen entstehen manchmal winzige Abweichungen:

print(0.10 * 3)
print(round(0.10 * 3, 2))
0.30000000000000004
0.3

Deshalb rundet man Geldbeträge auf zwei Stellen.

1.1.8Weitere Übungen

Hier kannst du das Gelernte weiter üben. Die Punkte im Titel zeigen, wie schwer eine Aufgabe ist: ●○○ leicht, ●●○ mittel, ●●● knifflig. Fang mit den leichten an.

Arbeitsauftrag 7: Mit oder ohne Anführungszeichen? ●○○

Lies das Programm, ohne es auszuführen. Schreibe auf, was es ausgibt. Überprüfe deine Vorhersage danach am Computer.

name = "Mia"
alter = 14
print("Name:", name)
print("alter")
print(alter)
print("In drei Jahren bist du", alter + 3)

Meine Vorhersage:

Lösung vergleichen
Name: Mia
alter
14
In drei Jahren bist du 17

In Zeile 4 steht alter in Anführungszeichen. Dann ist es ein Text, und genau dieser Text wird ausgegeben. In Zeile 5 fehlen die Anführungszeichen. Dann ist alter der Name einer Variablen, und Python gibt ihren Wert 14 aus. In Zeile 6 wird zuerst 14 + 3 ausgerechnet.

Arbeitsauftrag 8: Welcher Datentyp? ●○○

Das Programm wird mit den Eingaben 12, 12 und 1.5 ausgeführt. Gib zu jeder Variablen an, welchen Datentyp ihr Wert hat (int, float, str oder bool). Überprüfe deine Antworten anschließend am Computer mit print(type(...)).

a = input("Gib eine Zahl ein: ")
b = int(input("Gib eine Zahl ein: "))
c = float(input("Gib eine Zahl ein: "))
d = "3.5"
e = 3.5
f = False
Variable a b c d e f
Datentyp
Lösung vergleichen
Variable a b c d e f
Datentyp str int float str float bool

So kannst du es prüfen:

a = input("Gib eine Zahl ein: ")
b = int(input("Gib eine Zahl ein: "))
c = float(input("Gib eine Zahl ein: "))
d = "3.5"
e = 3.5
f = False
print(type(a), type(b), type(c))
print(type(d), type(e), type(f))
Gib eine Zahl ein: «12»
Gib eine Zahl ein: «12»
Gib eine Zahl ein: «1.5»
<class 'str'> <class 'int'> <class 'float'>
<class 'str'> <class 'float'> <class 'bool'>

a ist eine Zeichenkette, obwohl 12 eingegeben wurde: Eine Eingabe ist immer vom Typ str, solange man sie nicht umwandelt. d steht in Anführungszeichen und ist deshalb ebenfalls ein Text. False ohne Anführungszeichen ist ein Wahrheitswert.

Arbeitsauftrag 9: Kontostand verfolgen ●○○

Fülle das Ablaufprotokoll aus. Trage nach jedem Schritt die Werte der beiden Variablen ein (– bedeutet: noch kein Wert). Gib dann an, was das Programm ausgibt.

kontostand = 20
kontostand = kontostand - 5
taschengeld = 15
kontostand = kontostand + taschengeld
print("Kontostand:", kontostand)
Schritt Zeile kontostand taschengeld
1 1
2 2
3 3
4 4
5 5

Ausgabe:

Lösung vergleichen
Schritt Zeile kontostand taschengeld
1 1 20 –
2 2 15 –
3 3 15 15
4 4 30 15
5 5 30 15
Kontostand: 30

In Zeile 2 wird zuerst rechts gerechnet (20 - 5 = 15), dann wird der alte Wert 20 überschrieben. In den Schritten 1 und 2 gibt es taschengeld noch nicht, denn die Variable bekommt erst in Zeile 3 einen Wert.

Arbeitsauftrag 10: Handyvertrag ●○○

Das Programm soll den monatlichen Preis eines Handyvertrags (Kommazahl) und die Laufzeit in Monaten (ganze Zahl) einlesen und die Gesamtkosten ausgeben, auf Cent gerundet. Ergänze die drei Lücken ___ und teste dein Programm mit den Eingaben 9.99 und 24.

preis = ___(input("Preis pro Monat in Euro: "))
monate = ___(input("Laufzeit in Monaten: "))
gesamt = preis * monate
print("Gesamtkosten:", ___, "Euro")
Lösung vergleichen
preis = float(input("Preis pro Monat in Euro: "))
monate = int(input("Laufzeit in Monaten: "))
gesamt = preis * monate
print("Gesamtkosten:", round(gesamt, 2), "Euro")
Preis pro Monat in Euro: «9.99»
Laufzeit in Monaten: «24»
Gesamtkosten: 239.76 Euro

Der Preis hat Nachkommastellen, deshalb float. Die Anzahl der Monate ist eine ganze Zahl, deshalb int. round(gesamt, 2) rundet auf zwei Nachkommastellen, also auf Cent. Ohne round kann bei manchen Eingaben eine lange Kommazahl erscheinen.

Arbeitsauftrag 11: Fehler finden: Temperatur umrechnen ●●○

In den USA misst man Temperaturen in Grad Fahrenheit. Man rechnet so um: Grad Fahrenheit = Grad Celsius · 1,8 + 32. Das Programm soll eine Temperatur in Grad Celsius einlesen und in Grad Fahrenheit umrechnen. Es enthält drei Fehler.

celsius = input("Temperatur in Grad Celsius: ")
fahrenheit = celsius * 1.8 + 32
print("Das sind", Fahrenheit, "Grad Fahrenheit.)
  1. Finde die drei Fehler. Notiere jeweils die Zeile und was falsch ist.
  2. Schreibe das Programm richtig auf und teste es mit 20 (richtig ist 68 Grad Fahrenheit).

Die Fehler:

Lösung vergleichen
  1. Zeile 1: Die Eingabe wird nicht umgewandelt. celsius ist ein Text, und mit einem Text kann man nicht rechnen. Python meldet in Zeile 2 einen TypeError. Richtig: float(input(...)).
  2. Zeile 3: Fahrenheit mit großem F. Die Variable heißt aber fahrenheit. Python meldet einen NameError.
  3. Zeile 3: Nach Grad Fahrenheit. fehlt das schließende Anführungszeichen. Python meldet einen SyntaxError.
celsius = float(input("Temperatur in Grad Celsius: "))
fahrenheit = celsius * 1.8 + 32
print("Das sind", fahrenheit, "Grad Fahrenheit.")
Temperatur in Grad Celsius: «20»
Das sind 68.0 Grad Fahrenheit.

Python meldet zuerst den SyntaxError, denn die Schreibweise prüft es, bevor das Programm überhaupt startet. Die anderen beiden Fehler zeigen sich erst, wenn das Programm läuft. Auch int statt float ist richtig, dann kann man aber keine Kommazahlen eingeben.

Arbeitsauftrag 12: Taschengeld ●●○

Schreibe ein Programm, das das wöchentliche Taschengeld (Kommazahl) und eine Anzahl von Wochen (ganze Zahl) einliest. Es soll ausgeben, wie viel Geld in dieser Zeit zusammenkommt. Danach soll es den Preis eines Wunschartikels einlesen und ausgeben, wie viel Geld nach dem Kauf noch übrig ist. Runde die Beträge auf Cent.

So könnte es aussehen:

Taschengeld pro Woche in Euro: «7.5»
Anzahl der Wochen: «6»
In 6 Wochen bekommst du 45.0 Euro.
Preis des Wunschartikels in Euro: «29.99»
Nach dem Kauf bleiben 15.01 Euro übrig.
Lösung vergleichen
taschengeld = float(input("Taschengeld pro Woche in Euro: "))
wochen = int(input("Anzahl der Wochen: "))
gespart = taschengeld * wochen
print("In", wochen, "Wochen bekommst du", round(gespart, 2), "Euro.")
preis = float(input("Preis des Wunschartikels in Euro: "))
rest = gespart - preis
print("Nach dem Kauf bleiben", round(rest, 2), "Euro übrig.")
Taschengeld pro Woche in Euro: «7.5»
Anzahl der Wochen: «6»
In 6 Wochen bekommst du 45.0 Euro.
Preis des Wunschartikels in Euro: «29.99»
Nach dem Kauf bleiben 15.01 Euro übrig.

Das Zwischenergebnis wird in gespart gespeichert, damit man es in Zeile 6 weiterverwenden kann. Gerade bei 45.0 - 29.99 ist round wichtig: Ohne Runden zeigt Python hier 15.010000000000002 an. Das liegt daran, dass der Computer Kommazahlen nicht immer ganz exakt speichert.

Arbeitsauftrag 13: Pfannkuchen für alle ●●○

Für eine Person braucht man für Pfannkuchen 62,5 g Mehl, 0,5 Eier und 125 ml Milch.

  1. Schreibe ein Programm, das die Anzahl der Personen einliest und ausgibt, wie viel man von jeder Zutat braucht.
  2. Begründe, warum du die Anzahl der Personen mit int und nicht mit float umwandelst.

Begründung:

Lösung vergleichen
personen = int(input("Für wie viele Personen? "))
mehl = 62.5 * personen
eier = 0.5 * personen
milch = 125 * personen
print("Mehl:", mehl, "g")
print("Eier:", eier)
print("Milch:", milch, "ml")
Für wie viele Personen? «6»
Mehl: 375.0 g
Eier: 3.0
Milch: 750 ml
  1. Personen kann man nur ganz zählen. Eine Eingabe wie 2.5 wäre unsinnig, und int würde sie mit einem ValueError ablehnen. Die Mengen für Mehl und Eier sind trotzdem Kommazahlen, weil mit 62.5 und 0.5 gerechnet wird. Bei der Milch wird nur mit ganzen Zahlen gerechnet, deshalb steht dort 750 ohne .0.
Arbeitsauftrag 14: Busfahrt oder Monatskarte? ●●●

Eine Einzelfahrt mit dem Bus kostet 2,10 Euro. Eine Monatskarte kostet 58 Euro.

  1. Schreibe ein Programm, das einliest, wie viele Busfahrten man an einem Schultag macht und an wie vielen Schultagen man im Monat fährt. Es soll ausgeben, was die Einzelfahrten im Monat zusammen kosten. Danach soll es ausgeben, wie viel man mit der Monatskarte spart, also die Kosten der Einzelfahrten minus 58 Euro.
  2. Teste dein Programm mit 2 Fahrten an 20 Tagen und mit 2 Fahrten an 10 Tagen. Erkläre, was ein negatives Ergebnis für die Ersparnis bedeutet.

Testergebnisse und Erklärung:

Lösung vergleichen
fahrten_pro_tag = int(input("Busfahrten pro Schultag: "))
tage = int(input("Schultage im Monat: "))
kosten_einzeln = fahrten_pro_tag * tage * 2.10
ersparnis = kosten_einzeln - 58
print("Einzelfahrten kosten:", round(kosten_einzeln, 2), "Euro")
print("Ersparnis mit Monatskarte:", round(ersparnis, 2), "Euro")
Busfahrten pro Schultag: «2»
Schultage im Monat: «20»
Einzelfahrten kosten: 84.0 Euro
Ersparnis mit Monatskarte: 26.0 Euro

Mit 2 und 10 kosten die Einzelfahrten 42 Euro, die Ersparnis ist -16.0 Euro. Ein negatives Ergebnis bedeutet: Die Monatskarte ist teurer als die Einzelfahrten, man würde 16 Euro mehr bezahlen. Dann lohnt sie sich nicht.

Wichtig ist die Reihenfolge der Rechnung: Erst werden die Kosten der Einzelfahrten berechnet und gespeichert, dann wird mit diesem Wert weitergerechnet. Ob sich die Monatskarte lohnt, kann das Programm selbst noch nicht entscheiden. Das lernst du im Abschnitt über Verzweigungen.

1.1.9Das Wichtigste in Kürze

Selbstcheck

1.2Operatoren: rechnen, vergleichen, verknüpfen DS02

Diesen Abschnitt als PDF (S. 20–37)

Das Jupyter-Notebook aus dem Unterricht: DS02_Operatoren.ipynb. Herunterladen und in VS Code oder Jupyter öffnen.

Zum Weiterüben: DS02_Weitere_Uebungen.ipynb mit den Aufgaben aus „Weitere Übungen“ zum Bearbeiten in Python.

Leitidee

Ein Film dauert 135 Minuten. Wie viele Stunden und Minuten sind das? Ist eine Zahl gerade oder ungerade? Darf eine 15-Jährige ohne Ausweis ins Kino? Für solche Fragen muss ein Programm rechnen, vergleichen und mehrere Aussagen verknüpfen. Die Zeichen, mit denen man das in Python aufschreibt, heißen Operatoren. Einige kennst du schon: +, -, * und /. In diesem Abschnitt kommen neue Rechenzeichen dazu und vor allem Operatoren, deren Ergebnis True oder False ist. Mit diesen Wahrheitswerten kann ein Programm im nächsten Abschnitt Entscheidungen treffen.

Lernziele

Nach diesem Abschnitt kannst du

1.2.1Was ist ein Operator?

In der Rechnung 7 + 3 steht das Pluszeichen zwischen zwei Zahlen. Es sagt Python, was mit den beiden Zahlen geschehen soll: Sie werden addiert. Ein solches Zeichen heißt Operator. Die Werte, mit denen gerechnet wird, heißen Operanden. Das Ergebnis ist wieder ein Wert, hier 10. Eine solche Verbindung aus Werten, Variablen und Operatoren, die Python zu einem Wert ausrechnet, nennt man einen Ausdruck.

Definition: Operator

Ein Operator ist ein Zeichen oder ein Wort, das eine Operation mit einem oder mehreren Werten (den Operanden) ausführt und daraus einen neuen Wert berechnet. Beispiel: In 7 + 3 ist + der Operator, 7 und 3 sind die Operanden.

In diesem Abschnitt lernst du drei Gruppen von Operatoren kennen: arithmetische Operatoren zum Rechnen (Ergebnis ist eine Zahl), Vergleichsoperatoren und logische Operatoren (Ergebnis ist jeweils ein Wahrheitswert, also True oder False).

1.2.2Arithmetische Operatoren: mehr als die Grundrechenarten

Die vier Grundrechenarten +, -, * und / kennst du schon aus dem Abschnitt über Variablen. Python hat drei weitere Rechenoperatoren. Hier sind alle sieben auf einen Blick, jeweils mit den Zahlen 7 und 3:

Operator Name Beispiel Ergebnis
+ Addition 7 + 3 10
- Subtraktion 7 - 3 4
* Multiplikation 7 * 3 21
/ Division 7 / 3 2.3333333333333335
// Ganzzahldivision 7 // 3 2
% Modulo (Rest) 7 % 3 1
** Potenz 7 ** 3 343

Die drei neuen Operatoren schauen wir uns jetzt genauer an.

Ganzzahldivision // und Rest %

Erinnere dich an die Grundschule: Dort hast du „mit Rest“ geteilt. 17 Kekse werden gerecht an 5 Kinder verteilt. Jedes Kind bekommt 3 Kekse, und 2 Kekse bleiben übrig. Man schreibt: 17 : 5 = 3 Rest 2.

Genau diese beiden Zahlen liefern dir die Operatoren // und %:

print(17 // 5)
print(17 % 5)
print(17 / 5)
3
2
3.4

Du kannst das Ergebnis immer überprüfen: 3 · 5 + 2 = 17. Ganzzahl-Ergebnis mal Teiler plus Rest ergibt wieder die Ausgangszahl. Übrigens: Das Zeichen % hat in Python nichts mit Prozent zu tun. 17 % 5 bedeutet „Rest von 17 geteilt durch 5“.

Anwendung: Minuten in Stunden und Minuten umrechnen

Wozu braucht man die Division mit Rest? Ein typisches Beispiel ist das Umrechnen von Zeiten. Eine Stunde hat 60 Minuten. Wie viele volle Stunden in einer Anzahl von Minuten stecken, liefert // 60. Die Minuten, die danach übrig bleiben, liefert % 60:

minuten_gesamt = int(input("Wie viele Minuten dauert der Film? "))
stunden = minuten_gesamt // 60
minuten = minuten_gesamt % 60
print(minuten_gesamt, "Minuten sind", stunden, "Stunden und",
      minuten, "Minuten.")
Wie viele Minuten dauert der Film? «135»
135 Minuten sind 2 Stunden und 15 Minuten.
Versuch: Probiere es aus

Starte das Programm mit den Eingaben 60, 59 und 600. Stimmen die Ergebnisse? Was passiert bei 0? Ändere das Programm dann so, dass es eine Anzahl von Sekunden in volle Minuten und restliche Sekunden umrechnet. Zum Beispiel sind 200 Sekunden 3 Minuten und 20 Sekunden.

Anwendung: Ist eine Zahl gerade?

Eine Zahl ist gerade, wenn sie sich ohne Rest durch 2 teilen lässt. Der Rest beim Teilen durch 2 ist also 0. Bei ungeraden Zahlen bleibt immer der Rest 1:

print(14 % 2, 15 % 2, 2024 % 4, 2026 % 4)
0 1 0 2

14 ist gerade (Rest 0), 15 ist ungerade (Rest 1). Dasselbe funktioniert mit jedem Teiler: 2024 ist durch 4 teilbar (Rest 0), 2026 nicht (Rest 2).

Merke

Eine Zahl a ist genau dann durch b teilbar, wenn a % b den Wert 0 ergibt. Insbesondere ist eine Zahl gerade, wenn zahl % 2 gleich 0 ist.

Potenzieren mit **

Mit zwei Sternchen berechnest du eine Potenz. 2 ** 3 bedeutet 23=2⋅2⋅2=82^3 = 2 \cdot 2 \cdot 2 = 8:

print(2 ** 3, 10 ** 6, 5 ** 2)
8 1000000 25

Die erste Zahl ist die Basis, die zweite der Exponent. 5 ** 2 ist also „5 hoch 2“, das Quadrat von 5.

Stolperstein

In manchen Programmen (z. B. in Tabellenkalkulationen) schreibt man „hoch“ mit dem Zeichen ^. In Python bedeutet ^ etwas ganz anderes. Es gibt keine Fehlermeldung, aber ein falsches Ergebnis:

print(2 ^ 3)
1

Für Potenzen brauchst du in Python immer **.

Merke

Arithmetische Operatoren: +, -, *, / (Division, Ergebnis ist immer ein float), // (Ganzzahldivision), % (Modulo, also der Rest der Division) und ** (Potenz).

Was wird zuerst gerechnet?

Wie in Mathe gilt eine feste Reihenfolge: zuerst Klammern, dann Potenzen **, dann Punktrechnung, zuletzt Strichrechnung + und -. // und % zählen zur Punktrechnung, genau wie * und /.

print(2 + 3 ** 2)
print((2 + 3) ** 2)
print(10 - 7 % 4)
11
25
7

Wenn du unsicher bist, setze Klammern. Sie schaden nie und machen das Programm leichter lesbar.

Arbeitsauftrag 15: Rechenausdrücke

Bestimme das Ergebnis jedes Ausdrucks zuerst im Kopf und trage es in die Tabelle ein. Überprüfe dann mit print(...) am Computer.

Ausdruck Ergebnis
23 // 4
23 % 4
23 / 4
2 ** 5
10 % 2
7 % 10
3 + 2 ** 3
(3 + 2) ** 2
Lösung vergleichen
print(23 // 4)
print(23 % 4)
print(23 / 4)
print(2 ** 5)
print(10 % 2)
print(7 % 10)
print(3 + 2 ** 3)
print((3 + 2) ** 2)
5
3
5.75
32
0
7
11
25

Die 4 passt 5-mal in die 23, Rest 3 (denn 5 · 4 + 3 = 23). Bei 7 % 10 passt die 10 keinmal in die 7, deshalb ist der ganze Wert 7 der Rest. In 3 + 2 ** 3 wird zuerst die Potenz berechnet (23=82^3 = 8), dann addiert.

1.2.3Vergleichsoperatoren: wahr oder falsch?

Viele Fragen kann man nur mit Ja oder Nein beantworten: Ist 7 größer als 3? Ist die Eingabe gleich „ja“? Python beantwortet solche Fragen mit einem Wahrheitswert: True (wahr, ja) oder False (falsch, nein). Den passenden Datentyp bool kennst du schon aus dem Abschnitt über Datentypen.

Eine solche Frage stellst du mit einem Vergleichsoperator:

Operator Bedeutung Beispiel Ergebnis
== ist gleich 7 == 3 False
!= ist ungleich 7 != 3 True
< ist kleiner als 7 < 3 False
> ist größer als 7 > 3 True
<= ist kleiner oder gleich 7 <= 7 True
>= ist größer oder gleich 3 >= 7 False

Das Zeichen != liest man als „ungleich“. Das Ausrufezeichen steht für „nicht“. Bei <= und >= steht das Gleichheitszeichen immer rechts.

a = 7
b = 3
print(a > b)
print(a == b)
print(a != b)
print(a <= 7)
True
False
True
True

Ergebnisse von Vergleichen speichern

Ein Wahrheitswert ist ein ganz normaler Wert. Du kannst ihn deshalb in einer Variablen speichern:

alter = int(input("Wie alt bist du? "))
ist_volljaehrig = alter >= 18
print("Volljährig:", ist_volljaehrig)
print(type(ist_volljaehrig))
Wie alt bist du? «15»
Volljährig: False
<class 'bool'>

Für Variablen mit Wahrheitswerten wählt man gern Namen, die wie eine Ja-Nein-Frage klingen: ist_volljaehrig, hat_ausweis, ist_gerade.

Texte vergleichen

Auch Texte kann man mit == und != vergleichen. Das brauchst du, wenn eine Nutzerin zum Beispiel „ja“ oder „nein“ eingibt. Dabei kommt es auf jedes Zeichen an, auch auf Groß- und Kleinschreibung:

print("ja" == "ja", "Ja" == "ja", "ja " == "ja")
True False False

Im zweiten Vergleich unterscheiden sich die Texte im ersten Buchstaben, im dritten durch ein Leerzeichen am Ende. Für Python sind das verschiedene Texte.

Stolperstein

Vergleichst du eine Eingabe mit einer Zahl und hast die Typumwandlung vergessen, gibt es keine Fehlermeldung. Das Ergebnis ist aber immer False:

zahl = input("Gib eine Zahl ein: ")
print(zahl == 7)
Gib eine Zahl ein: «7»
False

Der Text "7" ist nicht dasselbe wie die Zahl 7. Abhilfe: zahl = int(input(...)).

Zuweisung = oder Vergleich ==?

Diese beiden Zeichen sehen sich ähnlich, bedeuten aber etwas völlig anderes:

Verwechselst du die beiden, meldet Python oft einen Fehler. Python ahnt sogar, was du gemeint hast:

print(7 = 7)
  File "programm.py", line 1
    print(7 = 7)
          ^^^
SyntaxError: expression cannot contain assignment, perhaps you meant "=="?

Expression cannot contain assignment heißt: „Ein Ausdruck darf keine Zuweisung enthalten.“ Und perhaps you meant "=="? bedeutet „Meintest du vielleicht ==?“

Merke
So kannst du es sagen

So beschreibst du einen Vergleich in Fachsprache – vom einfachen zum genauen Satz:

1.2.4Logische Operatoren: and, or und not

Oft reicht eine einzige Frage nicht aus. Ein Film ist ab 12 Jahren freigegeben, und an der Kasse wird ein Ausweis verlangt. Du darfst also nur hinein, wenn beide Bedingungen erfüllt sind: Du bist mindestens 12 und du hast deinen Ausweis dabei. Solche Verknüpfungen schreibt man mit logischen Operatoren. Sie verknüpfen Wahrheitswerte und liefern wieder einen Wahrheitswert.

Es gibt drei logische Operatoren:

print(True and False)
print(True or False)
print(not True)
print(not 7 > 3)
False
True
False
False

Die drei Operatoren auf einen Blick. Dabei stehen A und B für zwei beliebige Wahrheitswerte:

A B A and B A or B not A
False False False False True
False True False True True
True False False True False
True True True True False
Merke

Logische Operatoren verknüpfen Wahrheitswerte:

Auch Wahrheitswerte kann man mit == und != vergleichen. A == B ist True, wenn beide denselben Wahrheitswert haben. A != B ist True, wenn sie verschieden sind – also genau dann, wenn genau einer von beiden wahr ist:

A B A == B A != B
False False True False
False True False True
True False False True
True True True False

Die Spalte A != B merkst du dir am besten als „entweder … oder“: wahr, wenn genau eine Seite wahr ist. Diese Verknüpfung begegnet dir in Kapitel 2 als XOR wieder.

Vergleiche verknüpfen

Meistens verknüpft man mit and und or keine festen Werte, sondern Vergleiche. Hier wird geprüft, ob eine Person jugendlich ist, also mindestens 13 und jünger als 18 Jahre alt:

alter = int(input("Wie alt bist du? "))
ist_jugendlich = alter >= 13 and alter < 18
print("Jugendlich:", ist_jugendlich)
Wie alt bist du? «15»
Jugendlich: True

Python wertet Zeile 2 in dieser Reihenfolge aus:

  1. alter >= 13, also 15 >= 13, ergibt True.
  2. alter < 18, also 15 < 18, ergibt True.
  3. True and True ergibt True.

Rechnungen und Vergleiche werden also vor den logischen Operatoren ausgewertet. Unter den logischen Operatoren gilt: zuerst not, dann and, zuletzt or. Wenn du and und or in einem Ausdruck mischst, setze Klammern. Dann sieht jeder sofort, was zusammengehört.

Stolperstein

Im Deutschen sagt man „älter als 12 und jünger als 18“. Python braucht aber auf beiden Seiten von and einen vollständigen Vergleich:

alter = 15
print(alter > 12 and < 18)
SyntaxError: invalid syntax

Richtig ist: alter > 12 and alter < 18.

Klammern entscheiden: Darf ich zocken?

Bei drei Bedingungen kommt es darauf an, was zusammengehört. Ein Beispiel aus dem Alltag:

Zwei Eltern formulieren ihre Regel fürs Zocken unterschiedlich:

Probiere es aus: Die Hausaufgaben sind nicht fertig, das Zimmer ist nicht aufgeräumt, aber es ist Wochenende.

A = False   # Hausaufgaben sind fertig
B = False   # Zimmer ist aufgeräumt
C = True    # Es ist Wochenende

ausdruck_1 = (A and B) or C
ausdruck_2 = A and (B or C)

print("(A and B) or C =", ausdruck_1)
print("A and (B or C) =", ausdruck_2)
(A and B) or C = True
A and (B or C) = False

Nach Regel 1 darfst du also zocken, nach Regel 2 nicht. Die Klammerung entscheidet darüber, welche Bedingung zwingend erfüllt sein muss. Die Tabelle zeigt alle acht Möglichkeiten:

A B C A and B B or C (A and B) or C A and (B or C)
False False False False False False False
False False True False True True False
False True False False True False False
False True True False True True False
True False False False False False False
True False True False True True True
True True False True True True True
True True True True True True True

In vier Zeilen unterscheiden sich die beiden letzten Spalten. Die Ausdrücke (A and B) or C und A and (B or C) bedeuten also nicht dasselbe – man sagt: Sie sind nicht äquivalent.

Merke

Klammern bestimmen, welcher Teilausdruck zuerst ausgewertet wird. (A and B) or C und A and (B or C) sind nicht äquivalent. Setze deshalb immer Klammern, wenn du and und or in einem Ausdruck mischst.

Bedingungen verneinen: die Regeln von De Morgan

Manchmal will man das Gegenteil einer verknüpften Bedingung prüfen, zum Beispiel: Ist eine Person nicht jugendlich? Am einfachsten setzt man not vor die ganze Bedingung in Klammern:

alter = 20
print(not (alter >= 13 and alter < 18))
print(alter < 13 or alter >= 18)
True
True

Beide Zeilen liefern für jedes Alter dasselbe Ergebnis. Probiere es mit anderen Werten aus, zum Beispiel alter = 15 oder alter = 9. Beim Umformen ist zweierlei passiert: Jeder einzelne Vergleich wurde verneint (aus >= wurde <, aus < wurde >=), und aus and wurde or. Das ist kein Zufall, sondern eine allgemeine Regel. Sie heißt nach dem englischen Mathematiker Augustus De Morgan:

A B not (A and B) not A or not B not (A or B) not A and not B
False False True True True True
False True True True False False
True False True True False False
True True False False False False

Die dritte und vierte Spalte stimmen in jeder Zeile überein, ebenso die fünfte und sechste. Im Alltag kennst du das auch: „Es ist nicht so, dass es regnet oder windet“ bedeutet „Es regnet nicht und es windet nicht“.

Merke

Regeln von De Morgan:

Verneint man eine verknüpfte Bedingung, wird jede Teilbedingung verneint, und aus and wird or (und umgekehrt).

In der Mathematik und in Kapitel 2 schreibt man ∧\land für and, ∨\lor für or und ¬\lnot für not. Die beiden Regeln lauten dann ¬(A∧B)≡¬A∨¬B\lnot(A \land B) \equiv \lnot A \lor \lnot B und ¬(A∨B)≡¬A∧¬B\lnot(A \lor B) \equiv \lnot A \land \lnot B. Das Zeichen ≡\equiv heißt: Beide Seiten haben für alle Werte von AA und BB dasselbe Ergebnis.

Um einen einzelnen Vergleich zu verneinen, brauchst du kein not. Es genügt, den Vergleichsoperator umzudrehen:

Vergleich verneint
a == b a != b
a < b a >= b
a > b a <= b
Stolperstein

Der häufigste Fehler: Man verneint die Teilbedingungen, vergisst aber, and in or umzuwandeln.

alter = 20
print(alter < 13 and alter >= 18)
False

Kein Mensch ist gleichzeitig jünger als 13 und mindestens 18 Jahre alt. Diese Bedingung ist also immer False, egal welches Alter eingegeben wird. Richtig ist alter < 13 or alter >= 18.

Arbeitsauftrag 16: Bedingungen verneinen

Schreibe zu jeder Bedingung eine Bedingung ohne not, die genau das Gegenteil prüft. Teste deine Antworten am Computer mit ein paar Werten.

  1. zahl >= 1 and zahl <= 6 (eine Würfelzahl)
  2. note == 1 or note == 2
  3. not (temperatur > 30 or regen) (Tipp: regen ist eine Variable mit einem Wahrheitswert; „nicht regen“ darfst du hier als not regen stehen lassen.)

Meine Bedingungen:

Lösung vergleichen
  1. zahl < 1 or zahl > 6 – die Zahl ist keine Würfelzahl.
  2. note != 1 and note != 2 – die Note ist weder 1 noch 2.
  3. Hier ist schon eine Verneinung gegeben. Nach De Morgan gilt: not (temperatur > 30 or regen) ist dasselbe wie temperatur <= 30 and not regen – es ist höchstens 30 Grad warm und es regnet nicht. (Nur an regen bleibt ein not, weil regen kein Vergleich ist.)

Kontrolle mit Beispielwerten:

zahl = 7
print(not (zahl >= 1 and zahl <= 6), zahl < 1 or zahl > 6)
note = 2
print(not (note == 1 or note == 2), note != 1 and note != 2)
temperatur = 25
regen = False
print(not (temperatur > 30 or regen), temperatur <= 30 and not regen)
True True
False False
True True

In jeder Zeile stimmen beide Werte überein.

Alles zusammen

Das folgende Programm zeigt noch einmal alle drei Gruppen von Operatoren:

a = 7
b = 3

print("Summe:", a + b)
print("Ganzzahldivision:", a // b)
print("Rest (Modulo):", a % b)
print("Potenz:", a ** 2)

print("a größer b?", a > b)
print("a gleich b?", a == b)

alter = 15
hat_ausweis = True
print("Darf ins Kino (ab 12) und hat Ausweis dabei:",
      alter >= 12 and hat_ausweis)
Summe: 10
Ganzzahldivision: 2
Rest (Modulo): 1
Potenz: 49
a größer b? True
a gleich b? False
Darf ins Kino (ab 12) und hat Ausweis dabei: True
Arbeitsauftrag 17: Wahr oder falsch?

Es gilt x = 5 und y = 10. Bestimme für jeden Ausdruck, ob er True oder False ergibt. Überprüfe deine Antworten danach am Computer.

Ausdruck Ergebnis
x < y
x == 5 and y == 5
x == 5 or y == 5
not x > y
x % 2 == 0
x + y >= 15 and not y == 10
Lösung vergleichen
x = 5
y = 10
print(x < y)
print(x == 5 and y == 5)
print(x == 5 or y == 5)
print(not x > y)
print(x % 2 == 0)
print(x + y >= 15 and not y == 10)
True
False
True
True
False
False
  • x == 5 and y == 5: Die rechte Seite ist falsch, deshalb ist das Ganze False.
  • x == 5 or y == 5: Eine wahre Seite genügt.
  • not x > y: 5 > 10 ist False, umgekehrt True.
  • x % 2 == 0: Der Rest von 5 geteilt durch 2 ist 1, also nicht 0. 5 ist ungerade.
  • Im letzten Ausdruck ist x + y >= 15 wahr (15 ist größer oder gleich 15). Aber y == 10 ist wahr und not macht daraus False. Und True and False ergibt False.

1.2.5Übungen

Arbeitsauftrag 18: Gerade oder ungerade?

Schreibe ein Programm, das eine Ganzzahl einliest und mit Hilfe des Modulo-Operators % einen Wahrheitswert ausgibt, der angibt, ob die Zahl gerade ist.

So könnte es aussehen:

Ganzzahl eingeben: «14»
Ist gerade: True
Lösung vergleichen
zahl = int(input("Ganzzahl eingeben: "))
ist_gerade = zahl % 2 == 0
print("Ist gerade:", ist_gerade)
Ganzzahl eingeben: «14»
Ist gerade: True

In Zeile 2 wird zuerst zahl % 2 berechnet (Rest beim Teilen durch 2). Dann wird geprüft, ob dieser Rest gleich 0 ist. Das Ergebnis True oder False wird in ist_gerade gespeichert. Teste mehrere Eingaben:

Eingabe zahl % 2 Ausgabe
14 0 Ist gerade: True
7 1 Ist gerade: False
0 0 Ist gerade: True

Typischer Fehler: zahl % 2 = 0 mit nur einem Gleichheitszeichen. Das ist eine Zuweisung und führt zu einem SyntaxError.

Arbeitsauftrag 19: Schaltjahr-Check

Ein Jahr ist ein Schaltjahr, wenn es durch 4 teilbar ist, aber nicht durch 100 – außer es ist auch durch 400 teilbar.

Schreibe ein Programm, das eine Jahreszahl einliest und einen Wahrheitswert ausgibt, der angibt, ob es ein Schaltjahr ist. Verwende dafür and, or und not bzw. Vergleichsoperatoren. Du brauchst dafür nur Operatoren, sonst nichts.

Tipp

Zerlege die Regel in Teile und übersetze jeden Teil einzeln:

Ein Jahr ist also Schaltjahr, wenn die ersten beiden Teile zusammen wahr sind oder wenn der dritte Teil wahr ist. Setze Klammern um das, was zusammengehört. Teste dein Programm mit 2024 (Schaltjahr), 2023 (kein Schaltjahr), 1900 (kein Schaltjahr) und 2000 (Schaltjahr).

Lösung vergleichen
jahr = int(input("Jahreszahl eingeben: "))
schaltjahr = (jahr % 4 == 0 and jahr % 100 != 0) or (jahr % 400 == 0)
print("Schaltjahr:", schaltjahr)
Jahreszahl eingeben: «1900»
Schaltjahr: False

Für 1900 wertet Python Zeile 2 so aus: 1900 % 4 == 0 ist True, 1900 % 100 != 0 ist False (1900 ist durch 100 teilbar). Die linke Klammer ergibt also True and False, das ist False. 1900 % 400 == 0 ist ebenfalls False, denn der Rest ist 300. Insgesamt: False or False, also False.

Eingabe durch 4? durch 100? durch 400? Ausgabe
2024 ja nein nein Schaltjahr: True
2023 nein nein nein Schaltjahr: False
1900 ja ja nein Schaltjahr: False
2000 ja ja ja Schaltjahr: True

Statt jahr % 100 != 0 kannst du auch not jahr % 100 == 0 schreiben. Beides bedeutet „nicht durch 100 teilbar“.

Übersichtlicher wird es, wenn du die Teilbedingungen erst einzeln speicherst und dann zusammensetzt:

jahr = int(input("Jahreszahl eingeben: "))

A = jahr % 4 == 0
B = jahr % 100 == 0
C = jahr % 400 == 0

schaltjahr = (A and not B) or C

print("Durch 4 teilbar:  ", A)
print("Durch 100 teilbar:", B)
print("Durch 400 teilbar:", C)
print("Schaltjahr:       ", schaltjahr)
Jahreszahl eingeben: «1900»
Durch 4 teilbar:   True
Durch 100 teilbar: True
Durch 400 teilbar: False
Schaltjahr:        False

So kann man an den Zwischenergebnissen genau sehen, welche Teilbedingung wahr ist. Die Regel selbst steht dann kurz und lesbar in einer Zeile: „durch 4 und nicht durch 100 – oder durch 400“.

1.2.6Weitere Übungen

Hier kannst du das Gelernte weiter üben. Die Punkte im Titel zeigen, wie schwer eine Aufgabe ist: ●○○ leicht, ●●○ mittel, ●●● knifflig. Fang mit den leichten an.

Arbeitsauftrag 20: Teilen mit Rest ●○○

Bestimme das Ergebnis jedes Ausdrucks zuerst im Kopf und trage es in die Tabelle ein. Überprüfe dann mit print(...) am Computer.

Ausdruck Ergebnis Ausdruck Ergebnis
29 // 5 2 ** 4
29 % 5 17 % 2
40 % 8 10 - 4 // 2
3 % 8 (10 - 4) // 2
Lösung vergleichen
print(29 // 5, 29 % 5, 40 % 8, 3 % 8)
print(2 ** 4, 17 % 2, 10 - 4 // 2, (10 - 4) // 2)
5 4 0 3
16 1 8 3
  • Die 5 passt 5-mal ganz in die 29, es bleibt der Rest 4 (denn 5 · 5 + 4 = 29).
  • 40 % 8 ist 0: 40 ist durch 8 teilbar.
  • 3 % 8 ist 3: Die 8 passt keinmal in die 3, also ist die ganze 3 der Rest.
  • 17 % 2 ist 1: 17 ist ungerade.
  • In 10 - 4 // 2 wird zuerst 4 // 2 = 2 gerechnet, denn // ist Punktrechnung. Mit Klammern wird zuerst 10 - 4 = 6 gerechnet, dann 6 // 2 = 3.
Arbeitsauftrag 21: True oder False? ●○○

Es gilt a = 4 und b = 9. Bestimme für jeden Vergleich, ob er True oder False ergibt. Überprüfe deine Antworten danach am Computer.

Ausdruck Ergebnis Ausdruck Ergebnis
a < b a * 2 > b
b != 9 b % a == 1
a >= 5 a + 5 == b
Lösung vergleichen
a = 4
b = 9
print(a < b, b != 9, a >= 5)
print(a * 2 > b, b % a == 1, a + 5 == b)
True False False
False True True
  • b != 9: b ist gleich 9, die Frage „ist ungleich 9?“ wird also mit False beantwortet.
  • a >= 5: 4 ist weder größer als 5 noch gleich 5.
  • a * 2 > b: Zuerst wird gerechnet (8), dann verglichen: 8 > 9 ist falsch.
  • b % a == 1: 9 geteilt durch 4 ergibt 2 Rest 1. Der Rest ist also 1.
Arbeitsauftrag 22: Wahrheitstabelle ausfüllen ●○○

Fülle die Tabelle aus. Bestimme zuerst die Spalte not B. Mit ihrer Hilfe kannst du die beiden letzten Spalten ausfüllen.

A B not B A and not B A or not B
False False
False True
True False
True True
Lösung vergleichen
A B not B A and not B A or not B
False False True False True
False True False False False
True False True True True
True True False False True

not wird vor and und or ausgewertet. A and not B ist nur in der dritten Zeile wahr: Dort ist A wahr und not B wahr. A or not B ist nur in der zweiten Zeile falsch: Dort sind A und not B beide falsch.

Zum Nachprüfen kannst du für A und B Werte festlegen, zum Beispiel:

A = True
B = False
print(not B, A and not B, A or not B)
True True True
Arbeitsauftrag 23: Eier verpacken ●○○

Eier werden in Kartons zu je 6 Stück verpackt. Das Programm soll eine Anzahl von Eiern einlesen und ausgeben, wie viele Kartons voll werden und wie viele Eier übrig bleiben. Ergänze die beiden Lücken ___ mit // und %. Teste mit 20, 18 und 5.

eier = int(input("Wie viele Eier? "))
kartons = ___    # volle Kartons
rest = ___       # übrige Eier
print(eier, "Eier ergeben", kartons, "volle Kartons und",
      rest, "übrige Eier.")
Lösung vergleichen
eier = int(input("Wie viele Eier? "))
kartons = eier // 6
rest = eier % 6
print(eier, "Eier ergeben", kartons, "volle Kartons und",
      rest, "übrige Eier.")
Wie viele Eier? «20»
20 Eier ergeben 3 volle Kartons und 2 übrige Eier.
Eingabe kartons rest
20 3 2
18 3 0
5 0 5

eier // 6 gibt an, wie oft die 6 ganz in die Anzahl passt. eier % 6 ist der Rest. Wer die beiden Operatoren vertauscht, bekommt bei 20 Eiern „2 Kartons und 3 Eier“ – das ist falsch.

Arbeitsauftrag 24: Bedingungen aufschreiben ●●○

Schreibe zu jeder Aussage einen Python-Ausdruck, der True ergibt, wenn die Aussage stimmt, und sonst False. Teste jeden Ausdruck am Computer mit zwei passenden Werten.

  1. Die Zahl x ist durch 3 teilbar.
  2. Das Alter alter liegt zwischen 10 und 15 (beide Grenzen gehören dazu).
  3. Die Punktzahl punkte ist kleiner als 0 oder größer als 100.
  4. Die Zahl zahl ist ungerade.
  5. Die Anzahl stunden ist nicht 0.

Meine Ausdrücke:

Lösung vergleichen
  1. x % 3 == 0
  2. alter >= 10 and alter <= 15
  3. punkte < 0 or punkte > 100
  4. zahl % 2 == 1 (oder zahl % 2 != 0)
  5. stunden != 0 (oder not stunden == 0)

Kontrolle mit Beispielwerten:

x = 12
alter = 15
punkte = 105
zahl = 8
stunden = 0
print(x % 3 == 0, alter >= 10 and alter <= 15)
print(punkte < 0 or punkte > 100, zahl % 2 == 1, stunden != 0)
True True
True False False

Bei 2. braucht man auf beiden Seiten von and einen vollständigen Vergleich. alter >= 10 and <= 15 ist ein Syntaxfehler. Weil die Grenzen dazugehören, steht >= und <=, nicht > und <. Bei 3. muss es or heißen: Eine Zahl kann nicht gleichzeitig kleiner als 0 und größer als 100 sein.

Arbeitsauftrag 25: Fehler finden: Teilbar durch 5? ●●○

Das Programm soll eine ganze Zahl einlesen und einen Wahrheitswert ausgeben, der angibt, ob die Zahl durch 5 teilbar ist. Es enthält drei Fehler.

zahl = input("Zahl: ")
durch_fuenf = zahl % 5 = 0
print("Durch 5 teilbar:" durch_fuenf)
  1. Finde die drei Fehler. Notiere jeweils die Zeile und was falsch ist.
  2. Schreibe das Programm richtig auf und teste es mit 35 und 42.

Die Fehler:

Lösung vergleichen
  1. Zeile 1: Die Eingabe wird nicht in eine Zahl umgewandelt. Mit dem Text "35" kann % nicht den Rest berechnen. Python meldet einen TypeError. Richtig: int(input(...)).
  2. Zeile 2: Für den Vergleich braucht man ==, nicht =. Python meldet einen SyntaxError.
  3. Zeile 3: Zwischen dem Text und der Variablen fehlt das Komma. Python meldet SyntaxError: invalid syntax. Perhaps you forgot a comma?
zahl = int(input("Zahl: "))
durch_fuenf = zahl % 5 == 0
print("Durch 5 teilbar:", durch_fuenf)
Zahl: «35»
Durch 5 teilbar: True

Mit der Eingabe 42 gibt das Programm Durch 5 teilbar: False aus, denn 42 geteilt durch 5 ergibt 8 Rest 2.

Arbeitsauftrag 26: Ausleihe in der Bücherei ●●○

In der Stadtbücherei gilt: Man darf ein Buch ausleihen, wenn man einen Ausweis hat und entweder keine offenen Gebühren hat oder jünger als 18 ist. Im Programm sieht das so aus:

hat_ausweis = True
gebuehren = 0
alter = 30
darf_ausleihen = hat_ausweis and (gebuehren == 0 or alter < 18)
print("Darf ausleihen:", darf_ausleihen)
  1. Bestimme darf_ausleihen für die vier Fälle in der Tabelle. Prüfe am Computer, indem du die Werte in den Zeilen 1 bis 3 änderst.
  2. Jemand lässt die Klammern weg: hat_ausweis and gebuehren == 0 or alter < 18. Bestimme das Ergebnis für den vierten Fall und erkläre den Unterschied.
hat_ausweis gebuehren alter darf_ausleihen
True 0 30
True 2 15
True 2 40
False 0 12

Zu 2.:

Lösung vergleichen
hat_ausweis gebuehren alter darf_ausleihen
True 0 30 True
True 2 15 True
True 2 40 False
False 0 12 False

Im zweiten Fall hat die Person zwar Gebühren, ist aber jünger als 18. Die Klammer ergibt False or True, also True. Im vierten Fall fehlt der Ausweis. Dann ist das Ganze wegen and sofort False, egal was in der Klammer steht.

  1. Ohne Klammern wird zuerst and ausgewertet, danach or. Für den vierten Fall:
hat_ausweis = False
gebuehren = 0
alter = 12
print(hat_ausweis and gebuehren == 0 or alter < 18)
True

False and True ergibt False, danach False or True ergibt True. Ohne Klammern dürfte also jedes Kind unter 18 ausleihen, auch ohne Ausweis. Die Klammern sorgen dafür, dass der Ausweis immer nötig ist.

Arbeitsauftrag 27: Ziffern zerlegen ●●●

Schreibe ein Programm, das eine dreistellige Zahl einliest und ihre Ziffern einzeln ausgibt: die Hunderterziffer, die Zehnerziffer und die Einerziffer. Zum Schluss soll es die Quersumme ausgeben, also die Summe der drei Ziffern. Verwende dafür // und %.

So könnte es aussehen:

Dreistellige Zahl: «472»
Hunderter: 4
Zehner: 7
Einer: 2
Quersumme: 13
Tipp

Die Einerziffer ist der Rest beim Teilen durch 10. Die Hunderterziffer sagt, wie oft die 100 ganz in die Zahl passt. Für die Zehnerziffer brauchst du zwei Schritte: 472 // 10 ergibt 47. Welche Rechnung liefert daraus die 7?

Lösung vergleichen
zahl = int(input("Dreistellige Zahl: "))
hunderter = zahl // 100
zehner = zahl // 10 % 10
einer = zahl % 10
print("Hunderter:", hunderter)
print("Zehner:", zehner)
print("Einer:", einer)
print("Quersumme:", hunderter + zehner + einer)
Dreistellige Zahl: «472»
Hunderter: 4
Zehner: 7
Einer: 2
Quersumme: 13
  • Zeile 2: Die 100 passt 4-mal ganz in die 472.
  • Zeile 3: // und % werden von links nach rechts ausgewertet: 472 // 10 ergibt 47, und 47 % 10 ergibt 7. Auch zahl % 100 // 10 ist richtig: 472 % 100 ergibt 72, und 72 // 10 ergibt 7.
  • Zeile 4: Der Rest beim Teilen durch 10 ist immer die letzte Ziffer.

Teste auch eine Zahl mit einer 0 in der Mitte, zum Beispiel 305: Dann ist die Zehnerziffer 0 und die Quersumme 8.

1.2.7Das Wichtigste in Kürze

Selbstcheck

1.3Verzweigungen: Programme treffen Entscheidungen DS03

Diesen Abschnitt als PDF (S. 38–54)

Das Jupyter-Notebook aus dem Unterricht: DS03_Verzweigungen.ipynb. Herunterladen und in VS Code oder Jupyter öffnen.

Zum Weiterüben: DS03_Weitere_Uebungen.ipynb mit den Aufgaben aus „Weitere Übungen“ zum Bearbeiten in Python.

Leitidee

Jeden Tag triffst du Entscheidungen nach einfachen Regeln: Wenn es regnet, dann nehme ich einen Schirm mit. Wenn der Bus kommt, steige ich ein, sonst warte ich. Auch Programme müssen entscheiden: Ist das Passwort richtig? Hat die Spielerin genug Punkte? Ist die Zahl positiv? Bisher hat Python jede Zeile deines Programms ausgeführt, immer von oben nach unten. Jetzt lernst du, wie ein Programm abhängig von einer Bedingung nur bestimmte Anweisungen ausführt. Aus der Blockprogrammierung kennst du dafür die Bausteine „falls … dann“ und „falls … dann … sonst“.

Lernziele

Nach diesem Abschnitt kannst du

1.3.1Die einseitige Verzweigung: if

Stell dir eine Weiche bei der Eisenbahn vor. Je nachdem, wie sie gestellt ist, fährt der Zug geradeaus oder biegt ab. In einem Programm übernimmt eine Bedingung die Rolle der Weiche. Eine Bedingung ist eine Frage, deren Antwort True oder False ist – genau wie die Vergleiche aus dem Abschnitt über Operatoren.

temperatur = 30
if temperatur > 25:
    print("Es ist heiß. Trink genug Wasser!")
print("Schönen Tag!")
Es ist heiß. Trink genug Wasser!
Schönen Tag!

Was passiert, wenn die Bedingung falsch ist? Überlege zuerst, dann lies weiter.

temperatur = 18
if temperatur > 25:
    print("Es ist heiß. Trink genug Wasser!")
print("Schönen Tag!")
Schönen Tag!

Jetzt ist temperatur > 25 falsch (False). Python überspringt die eingerückte Zeile 3 und macht direkt mit Zeile 4 weiter.

Die if-Anweisung steuert also, welche Zeilen ausgeführt werden. Anweisungen, die so den Ablauf eines Programms steuern, nennt man Kontrollstrukturen.

Aufbau einer einseitigen Verzweigung in Python. Nur der eingerückte Anweisungsblock hängt von der Bedingung ab
Definition: Bedingung

Eine Bedingung ist ein Ausdruck, dessen Wert entweder wahr (True) oder falsch (False) ist, zum Beispiel temperatur > 25.

Definition: Verzweigung

Eine Verzweigung ist eine Kontrollstruktur, die abhängig von einer Bedingung festlegt, welche Anweisungen ausgeführt werden. Man nennt sie auch bedingte Anweisung.

Merke

1.3.2Einrückung: Was gehört zum Block?

Ein Block kann aus mehreren Zeilen bestehen. Woher weiß Python, wo der Block aufhört? An der Einrückung. Alle Zeilen direkt unter dem if, die gleich weit eingerückt sind, gehören zum Block. Die erste Zeile, die wieder ganz links beginnt, gehört nicht mehr dazu.

Vergleiche die beiden Programme. Sie unterscheiden sich nur in der Einrückung von Zeile 4:

punkte = 3
if punkte >= 10:
    print("Gewonnen!")
    print("Du bekommst einen Preis.")
print("Spiel beendet.")
Spiel beendet.
punkte = 3
if punkte >= 10:
    print("Gewonnen!")
print("Du bekommst einen Preis.")
print("Spiel beendet.")
Du bekommst einen Preis.
Spiel beendet.

In beiden Programmen ist die Bedingung 3 >= 10 falsch. Im ersten Programm gehören die Zeilen 3 und 4 zum Block und werden beide übersprungen. Im zweiten Programm gehört nur Zeile 3 zum Block. Zeile 4 wird immer ausgeführt – und das Programm verteilt einen Preis, obwohl niemand gewonnen hat.

Merke

In Python bestimmt die Einrückung (4 Leerzeichen), welche Anweisungen zu einem Block gehören. Die Zeile mit der Bedingung endet mit einem Doppelpunkt :.

Stolperstein

Vergisst du den Doppelpunkt, meldet Python expected ':' („Doppelpunkt erwartet“). Das Zeichen ^ zeigt genau auf die Stelle, an der er fehlt:

zahl = 5
if zahl > 0
    print("positiv")
  File "programm.py", line 2
    if zahl > 0
               ^
SyntaxError: expected ':'
Tipp

Die meisten Programmierumgebungen rücken nach einem Doppelpunkt automatisch ein, wenn du die Eingabetaste drückst. Mit der Tabulatortaste (Tab) rückst du selbst ein. Achte darauf, dass alle Zeilen eines Blocks genau gleich weit eingerückt sind.

Stolperstein

Fehlt die Einrückung nach dem Doppelpunkt ganz, bricht Python mit einem IndentationError ab (indentation heißt „Einrückung“):

zahl = 5
if zahl > 0:
print("Die Zahl ist positiv.")
  File "programm.py", line 3
    print("Die Zahl ist positiv.")
    ^^^^^
IndentationError: expected an indented block after 'if' statement on line 2

Übersetzt: „Nach der if-Anweisung in Zeile 2 wurde ein eingerückter Block erwartet.“ Python zeigt auf Zeile 3, denn dort hätte der Block beginnen müssen. Abhilfe: Zeile 3 um vier Leerzeichen einrücken.

Auch zu viel Einrückung ist ein Fehler. Eine Zeile darf nur eingerückt sein, wenn sie zu einem Block gehört, der mit einer Zeile mit Doppelpunkt beginnt:

zahl = 5
    print(zahl)
IndentationError: unexpected indent

Unexpected indent heißt „unerwartete Einrückung“. Prüfe die genannte Zeile und rücke sie richtig ein.

1.3.3Die zweiseitige Verzweigung: if … else

Oft soll ein Programm in beiden Fällen etwas tun: wenn die Bedingung wahr ist, das eine, und sonst das andere. Dafür gibt es else (englisch „sonst“):

zahl = int(input("Gib eine Zahl ein: "))
if zahl > 4:
    print("Die Zahl ist größer als 4.")
else:
    print("Die Zahl ist nicht größer als 4.")
print("Fertig.")
Gib eine Zahl ein: «7»
Die Zahl ist größer als 4.
Fertig.

Es wird also immer genau einer der beiden Teile ausgeführt, nie beide und nie keiner. Weil das Programm zwischen zwei Möglichkeiten (Alternativen) wählt, nennt man die zweiseitige Verzweigung auch Alternativanweisung.

Den Ablauf darstellen

Wie ein Programm mit Verzweigung abläuft, kann man in einem Programmablaufplan zeichnen. Rauten stehen für Bedingungen, Rechtecke für Anweisungen. Die Pfeile zeigen, in welcher Reihenfolge Python die Anweisungen ausführt. An einer Raute teilt sich der Weg in „ja“ (Bedingung wahr) und „nein“ (Bedingung falsch).

Programmablaufpläne: links die einseitige Verzweigung aus dem Temperatur-Beispiel, rechts die zweiseitige Verzweigung aus dem Programm oben

Ein Ablaufprotokoll zeigt, welche Zeilen bei einer bestimmten Eingabe wirklich ausgeführt werden. Hier für das Programm oben, links mit der Eingabe 7, rechts mit der Eingabe 2:

Schritt Zeile zahl
1 1 7
2 2 7
3 3 7
4 6 7
Schritt Zeile zahl
1 1 2
2 2 2
3 5 2
4 6 2

Bei der Eingabe 7 ist die Bedingung in Zeile 2 wahr, also geht es mit Zeile 3 weiter. Bei der Eingabe 2 ist sie falsch, also springt Python zu Zeile 5. Die Zeile else: selbst tut nichts. Sie zeigt Python nur, wo der sonst-Teil beginnt. Deshalb taucht Zeile 4 im Protokoll nicht auf.

Merke

Zweiseitige Verzweigung: if … else: – entweder der dann-Teil oder der sonst-Teil wird ausgeführt.

So kannst du es sagen

So beschreibst du eine Verzweigung in Fachsprache – vom einfachen zum genauen Satz:

Nützliche Wendungen: Die Verzweigung besteht aus … · Es wird geprüft, ob … · Ist die Bedingung erfüllt, wird der dann-Teil ausgeführt, sonst der sonst-Teil.

Arbeitsauftrag 28: Glatteis-Warnung

Lies das Programm. Beschreibe in zwei bis drei Sätzen mit Fachbegriffen, was es tut. Gib dann an, was es bei den Eingaben -3, 0 und 5 ausgibt.

temperatur = int(input("Temperatur in Grad Celsius: "))
if temperatur <= 0:
    print("Achtung, Glatteisgefahr!")
else:
    print("Keine Glatteisgefahr.")

Beschreibung und Ausgaben:

Lösung vergleichen

Das Programm liest eine Temperatur als ganze Zahl ein. Die Alternativanweisung prüft, ob die Temperatur kleiner oder gleich 0 ist. Ist dies der Fall, wird „Achtung, Glatteisgefahr!“ ausgegeben, sonst „Keine Glatteisgefahr.“

Eingabe Bedingung temperatur <= 0 Ausgabe
-3 True Achtung, Glatteisgefahr!
0 True Achtung, Glatteisgefahr!
5 False Keine Glatteisgefahr.

Die Eingabe 0 ist ein Grenzfall: Wegen <= gehört sie zum dann-Teil. Stünde dort <, würde bei 0 Grad keine Warnung ausgegeben.

1.3.4Die mehrseitige Verzweigung: if … elif … else

Manchmal gibt es mehr als zwei Möglichkeiten. Ein Programm soll aus einer Punktzahl von 0 bis 100 eine Note machen. Dafür gibt es elif. Das ist eine Abkürzung für else if, also „sonst, wenn“:

note = int(input("Punktzahl (0-100) eingeben: "))

if note >= 90:
    print("Note: sehr gut")
elif note >= 75:
    print("Note: gut")
elif note >= 50:
    print("Note: befriedigend")
else:
    print("Note: nicht bestanden")
Punktzahl (0-100) eingeben: «80»
Note: gut

Der else-Teil am Ende fängt alle Fälle auf, in denen keine der Bedingungen wahr war. Er darf auch fehlen. Dann passiert in diesem Fall einfach nichts.

Das Ablaufprotokoll zeigt, welche Zeilen ausgeführt werden. Links für die Eingabe 80, rechts für die Eingabe 30:

Schritt Zeile note
1 1 80
2 3 80
3 5 80
4 6 80
Schritt Zeile note
1 1 30
2 3 30
3 5 30
4 7 30
5 10 30

Bei der Eingabe 30 sind alle drei Bedingungen falsch (Zeilen 3, 5 und 7). Deshalb wird der else-Teil in Zeile 10 ausgeführt.

Programmablaufplan des Notenrechners: Die Bedingungen werden von oben nach unten geprüft. Die erste, die zutrifft, entscheidet
Merke

Mehrseitige Verzweigung: if … elif … else: – es wird nur der Block der ersten zutreffenden Bedingung ausgeführt. Trifft keine zu, wird der else-Block ausgeführt.

Stolperstein

Bei elif kommt es auf die Reihenfolge an. Hier stehen die Bedingungen in der falschen Reihenfolge:

note = int(input("Punktzahl (0-100) eingeben: "))
if note >= 50:
    print("Note: befriedigend")
elif note >= 75:
    print("Note: gut")
elif note >= 90:
    print("Note: sehr gut")
Punktzahl (0-100) eingeben: «95»
Note: befriedigend

95 Punkte, aber nur „befriedigend“! Die erste Bedingung 95 >= 50 ist wahr, also wird ihr Block ausgeführt und der Rest übersprungen. Die Fälle „sehr gut“ und „gut“ werden nie erreicht. Regel: Bei >= die größte Grenze zuerst prüfen, bei < die kleinste.

Arbeitsauftrag 29: Größte von zwei Zahlen

Schreibe ein Programm, das zwei Zahlen einliest und ausgibt, welche die größere ist – oder ob beide gleich sind. Teste dein Programm mit mindestens drei Eingabepaaren: einmal ist die erste Zahl größer, einmal die zweite, einmal sind beide gleich.

Lösung vergleichen
a = float(input("Erste Zahl: "))
b = float(input("Zweite Zahl: "))
if a > b:
    print("Die erste Zahl ist größer.")
elif b > a:
    print("Die zweite Zahl ist größer.")
else:
    print("Beide Zahlen sind gleich.")
Erste Zahl: «3»
Zweite Zahl: «7»
Die zweite Zahl ist größer.
Eingaben Ausgabe
7 und 3 Die erste Zahl ist größer.
3 und 7 Die zweite Zahl ist größer.
5 und 5 Beide Zahlen sind gleich.
2.5 und -1 Die erste Zahl ist größer.

Es gibt drei Fälle, also braucht man eine mehrseitige Verzweigung. Für den else-Teil bleibt nur noch der Fall übrig, dass weder a > b noch b > a gilt – dann sind die Zahlen gleich. Mit float funktioniert das Programm auch mit Kommazahlen.

Arbeitsauftrag 30: Altersklassifikation

Schreibe ein Programm, das ein Alter einliest und es so einordnet:

Teste dein Programm besonders mit den Grenzwerten 5, 6, 12, 13, 17 und 18.

Lösung vergleichen
alter = int(input("Alter eingeben: "))
if alter < 6:
    print("Kleinkind")
elif alter < 13:
    print("Kind")
elif alter < 18:
    print("Jugendlicher")
else:
    print("Erwachsener")
Alter eingeben: «13»
Jugendlicher
Eingabe Ausgabe Eingabe Ausgabe
5 Kleinkind 13 Jugendlicher
6 Kind 17 Jugendlicher
12 Kind 18 Erwachsener

In Zeile 4 muss man nicht alter >= 6 and alter < 13 schreiben. Python kommt nur bei Zeile 4 an, wenn alter < 6 falsch war. Das Alter ist dort also schon mindestens 6. Die Lösung mit and ist aber auch richtig.

1.3.5Bedingungen mit and und or

Eine Bedingung darf alles sein, was True oder False ergibt – also auch Verknüpfungen mit and, or und not aus dem Abschnitt über Operatoren:

tag = input("Welcher Tag ist heute? ")
if tag == "Samstag" or tag == "Sonntag":
    print("Wochenende! Ausschlafen.")
else:
    print("Wecker stellen.")
Welcher Tag ist heute? «Sonntag»
Wochenende! Ausschlafen.
Stolperstein

Ein häufiger Fehler ist, den zweiten Vergleich abzukürzen: if tag == "Samstag" or "Sonntag":. Das sieht aus wie Deutsch, bedeutet in Python aber etwas anderes. Python liest "Sonntag" als eigene Bedingung, und ein Text, der nicht leer ist, zählt als wahr. Die Bedingung ist deshalb immer erfüllt:

tag = input("Welcher Tag ist heute? ")
if tag == "Samstag" or "Sonntag":
    print("Wochenende! Ausschlafen.")
Welcher Tag ist heute? «Montag»
Wochenende! Ausschlafen.

Schreibe auf beiden Seiten von or und and einen vollständigen Vergleich.

Stolperstein

Schreibst du in einer Bedingung = statt ==, meldet Python einen Syntaxfehler und macht gleich einen Vorschlag:

zahl = 0
if zahl = 0:
    print("Die Zahl ist null.")
  File "programm.py", line 2
    if zahl = 0:
       ^^^^^^^^
SyntaxError: invalid syntax. Maybe you meant '==' or ':=' instead of '='?

„Meintest du vielleicht == …?“ – genau. Den zweiten Vorschlag := brauchst du nicht.

1.3.6Verschachtelte Verzweigungen

Im Block einer Verzweigung dürfen beliebige Anweisungen stehen – auch eine weitere Verzweigung. Man spricht dann von einer verschachtelten Verzweigung. Ein Beispiel ist eine Anmeldung: Nur wenn der Benutzername bekannt ist, wird überhaupt nach dem Passwort gefragt.

benutzer = input("Benutzername: ")
if benutzer == "alex":
    passwort = input("Passwort: ")
    if passwort == "geheim123":
        print("Willkommen, Alex!")
    else:
        print("Falsches Passwort.")
else:
    print("Unbekannter Benutzer.")
Benutzername: «alex»
Passwort: «geheim123»
Willkommen, Alex!

An der Einrückung erkennst du, welches else zu welchem if gehört: Es steht immer genau darunter. Das Ablaufprotokoll für die Eingaben alex und 1234 zeigt, dass Python die innere Verzweigung erreicht, dort aber den sonst-Teil ausführt:

Schritt Zeile benutzer passwort
1 1 "alex" –
2 2 "alex" –
3 3 "alex" "1234"
4 4 "alex" "1234"
5 7 "alex" "1234"

Der Strich – bedeutet: Die Variable passwort gibt es zu diesem Zeitpunkt noch nicht.

Merke

Verzweigungen können verschachtelt werden: Eine if-Anweisung steht im Block einer anderen. Die Einrückung zeigt, welcher Block zu welcher Bedingung gehört.

Arbeitsauftrag 31 (Zusatz): Achterbahn-Check

Ein Freizeitpark hat folgende Regeln für eine Achterbahn:

Schreibe ein Programm, das die Körpergröße (in cm) abfragt und ob eine erwachsene Begleitung dabei ist (ja/nein). Es soll die passende Meldung ausgeben. Nutze eine verschachtelte Verzweigung.

Lösung vergleichen
groesse = int(input("Körpergröße in cm: "))
begleitung = input("Erwachsene Begleitung dabei? (ja/nein): ")

if groesse >= 140:
    print("Du darfst mitfahren!")
else:
    if groesse >= 120 and begleitung == "ja":
        print("Du darfst in Begleitung mitfahren.")
    else:
        print("Du darfst leider nicht mitfahren.")
Körpergröße in cm: «130»
Erwachsene Begleitung dabei? (ja/nein): «ja»
Du darfst in Begleitung mitfahren.

Die äußere Verzweigung prüft, ob man groß genug ist, um allein zu fahren. Nur wenn das nicht der Fall ist, prüft die innere Verzweigung, ob man mindestens 120 cm groß ist und eine Begleitung dabei hat.

Größe Begleitung Ausgabe
150 nein Du darfst mitfahren!
140 nein Du darfst mitfahren!
130 ja Du darfst in Begleitung mitfahren.
130 nein Du darfst leider nicht mitfahren.
120 ja Du darfst in Begleitung mitfahren.
110 ja Du darfst leider nicht mitfahren.

Achtung: Wer Ja mit großem J eingibt, darf nach diesem Programm nicht mitfahren, denn "Ja" == "ja" ist False.

1.3.7Weitere Übungen

Hier kannst du das Gelernte weiter üben. Die Punkte im Titel zeigen, wie schwer eine Aufgabe ist: ●○○ leicht, ●●○ mittel, ●●● knifflig. Fang mit den leichten an.

Arbeitsauftrag 32: Bestanden? ●○○

Lies das Programm, ohne es auszuführen. Gib an, was es bei den Eingaben 70, 50 und 49 ausgibt. Überprüfe danach am Computer.

punkte = int(input("Punkte: "))
if punkte >= 50:
    print("bestanden")
else:
    print("nicht bestanden")
print("Ende")

Meine Vorhersagen:

Lösung vergleichen
Eingabe Bedingung punkte >= 50 Ausgabe
70 True bestanden, danach Ende
50 True bestanden, danach Ende
49 False nicht bestanden, danach Ende

Für die Eingabe 70 sieht das so aus:

punkte = int(input("Punkte: "))
if punkte >= 50:
    print("bestanden")
else:
    print("nicht bestanden")
print("Ende")
Punkte: «70»
bestanden
Ende

Ende wird immer ausgegeben, denn Zeile 6 ist nicht eingerückt und gehört zu keinem Block. Bei 50 ist die Bedingung wegen >= erfüllt: 50 ist ein Grenzfall und gehört noch zu „bestanden“.

Arbeitsauftrag 33: Einrückung entscheidet ●○○

Die beiden Programme unterscheiden sich nur in der Einrückung der letzten Zeile. Gib für beide an, was sie ausgeben. Erkläre den Unterschied in einem Satz.

Programm A:

x = 3
if x > 5:
    print("groß")
    print("fertig")

Programm B:

x = 3
if x > 5:
    print("groß")
print("fertig")

Ausgaben und Erklärung:

Lösung vergleichen

Programm A gibt nichts aus. Programm B gibt aus:

fertig

Die Bedingung 3 > 5 ist falsch. In Programm A sind beide print-Zeilen eingerückt und gehören zum dann-Teil, also werden beide übersprungen. In Programm B gehört print("fertig") nicht mehr zur Verzweigung und wird deshalb in jedem Fall ausgeführt.

Arbeitsauftrag 34: Gerade oder ungerade? ●○○

Das Programm soll ausgeben, ob eine eingegebene ganze Zahl gerade oder ungerade ist. Ergänze die beiden Lücken ___ und teste dein Programm mit 8, 7 und 0.

zahl = int(input("Zahl: "))
if ___:
    print(zahl, "ist gerade.")
___
    print(zahl, "ist ungerade.")
Lösung vergleichen
zahl = int(input("Zahl: "))
if zahl % 2 == 0:
    print(zahl, "ist gerade.")
else:
    print(zahl, "ist ungerade.")
Zahl: «7»
7 ist ungerade.

Eine Zahl ist gerade, wenn beim Teilen durch 2 kein Rest bleibt. In die zweite Lücke gehört else: mit Doppelpunkt. Hinter else steht keine Bedingung. Die 0 ist gerade, denn 0 % 2 ergibt 0.

Arbeitsauftrag 35: Fieber messen ●○○

Das Programm ordnet eine gemessene Körpertemperatur ein. Teste es mit den Eingaben aus der Tabelle. Überlege die Ausgabe zuerst und trage sie ein. Prüfe danach am Computer.

temp = float(input("Temperatur in Grad Celsius: "))
if temp < 37.5:
    print("normal")
elif temp < 38.5:
    print("erhöht")
else:
    print("Fieber")
Eingabe 36.8 37.4 37.5 38.4 38.5 39.2
Ausgabe
Lösung vergleichen
Eingabe 36.8 37.4 37.5 38.4 38.5 39.2
Ausgabe normal normal erhöht erhöht Fieber Fieber

Die Grenzwerte sind 37.5 und 38.5. Weil dort < steht, gehört der Grenzwert selbst schon zur nächsten Stufe: Bei 37.5 ist temp < 37.5 falsch, aber temp < 38.5 wahr. Bei 38.4 ist die zweite Bedingung noch wahr, bei 38.5 nicht mehr.

Arbeitsauftrag 36: Fehler finden: Medaillen beim Sportfest ●●○

Beim Sportfest gibt es ab 60 Punkten Gold, ab 45 Punkten Silber und ab 30 Punkten Bronze. Wer weniger hat, bekommt keine Medaille. Das Programm soll die Medaille ausgeben. Es enthält drei Fehler. Einer davon erzeugt keine Fehlermeldung, sondern eine falsche Ausgabe.

punkte = int(input("Punkte: "))
if punkte >= 30:
    print("Bronze")
elif punkte >= 45:
    print("Silber")
elif punkte >= 60
    print("Gold")
else:
print("keine Medaille")
  1. Finde die drei Fehler. Notiere jeweils die Zeile und was falsch ist.
  2. Schreibe das Programm richtig auf. Teste es mit den Grenzwerten 29, 30, 44, 45, 59 und 60.

Die Fehler:

Lösung vergleichen
  1. Zeile 6: Am Ende der elif-Zeile fehlt der Doppelpunkt (SyntaxError: expected ':').
  2. Zeile 9: Die Anweisung im else-Block ist nicht eingerückt (IndentationError).
  3. Zeilen 2–7: Die Reihenfolge ist falsch. Schon bei 30 Punkten ist die erste Bedingung wahr. Dann wird „Bronze“ ausgegeben, auch bei 70 Punkten, und die anderen Fälle werden nie erreicht. Bei >= muss die größte Grenze zuerst geprüft werden.
punkte = int(input("Punkte: "))
if punkte >= 60:
    print("Gold")
elif punkte >= 45:
    print("Silber")
elif punkte >= 30:
    print("Bronze")
else:
    print("keine Medaille")
Punkte: «60»
Gold
Eingabe 29 30 44 45 59 60
Ausgabe keine Medaille Bronze Bronze Silber Silber Gold
Arbeitsauftrag 37: Was ziehe ich an? ●●○

Schreibe ein Programm, das die Temperatur (ganze Zahl in Grad Celsius) einliest und eine Kleidungsempfehlung ausgibt:

Danach soll das Programm fragen, ob es regnet (ja/nein). Nur wenn die Antwort ja ist, gibt es zusätzlich „Nimm einen Regenschirm mit.“ aus. Teste mit allen Zweigen und den Grenzwerten.

Lösung vergleichen
temperatur = int(input("Temperatur in Grad Celsius: "))
if temperatur < 10:
    print("Zieh eine Jacke an.")
elif temperatur < 20:
    print("Ein Pulli reicht.")
else:
    print("T-Shirt-Wetter!")

regen = input("Regnet es? (ja/nein): ")
if regen == "ja":
    print("Nimm einen Regenschirm mit.")
Temperatur in Grad Celsius: «15»
Ein Pulli reicht.
Regnet es? (ja/nein): «ja»
Nimm einen Regenschirm mit.

Für die Temperatur braucht man eine mehrseitige Verzweigung, für den Regen eine einseitige: Bei nein passiert einfach nichts. Die zweite Verzweigung beginnt mit einem neuen if, weil die Regenfrage unabhängig von der Temperatur ist. Mit elif würde sie nie gestellt, wenn schon eine Temperatur-Bedingung zugetroffen hat. Sinnvolle Testfälle: 9, 10, 19, 20, jeweils einmal mit ja und einmal mit nein.

Arbeitsauftrag 38: Schaltjahr mit Verzweigung ●●○

Im Abschnitt über Operatoren hast du im Auftrag Schaltjahr-Check einen Wahrheitswert berechnet. Schreibe das Programm jetzt so, dass es einen vollständigen Satz ausgibt, zum Beispiel 2024 ist ein Schaltjahr. oder 2023 ist kein Schaltjahr. Teste mit 2024, 2023, 1900 und 2000.

Zur Erinnerung: Ein Jahr ist ein Schaltjahr, wenn es durch 4 teilbar ist, aber nicht durch 100 – außer es ist auch durch 400 teilbar.

Lösung vergleichen
jahr = int(input("Jahreszahl: "))
if (jahr % 4 == 0 and jahr % 100 != 0) or jahr % 400 == 0:
    print(jahr, "ist ein Schaltjahr.")
else:
    print(jahr, "ist kein Schaltjahr.")
Jahreszahl: «1900»
1900 ist kein Schaltjahr.
Eingabe 2024 2023 1900 2000
Ausgabe Schaltjahr kein Schaltjahr kein Schaltjahr Schaltjahr

Die Bedingung aus dem Schaltjahr-Check steht jetzt direkt hinter if. Du kannst sie auch zuerst in einer Variablen speichern (schaltjahr = ...) und dann if schaltjahr: schreiben. Das ist ebenfalls richtig, denn hinter if darf alles stehen, was True oder False ergibt.

Arbeitsauftrag 39: Welches Dreieck? ●●●

Aus drei Seitenlängen a, b und c kann man nur dann ein Dreieck bauen, wenn je zwei Seiten zusammen länger sind als die dritte: a + b > c, a + c > b und b + c > a.

Schreibe ein Programm, das drei Seitenlängen einliest. Wenn sich kein Dreieck bauen lässt, soll es das ausgeben. Sonst soll es mit einer verschachtelten Verzweigung ausgeben, ob das Dreieck

Teste mit 3, 4, 5 und mit 5, 5, 8 und mit 5, 5, 5 und mit 1, 2, 5.

Lösung vergleichen
a = float(input("Seite a: "))
b = float(input("Seite b: "))
c = float(input("Seite c: "))
if a + b > c and a + c > b and b + c > a:
    if a == b and b == c:
        print("Das Dreieck ist gleichseitig.")
    elif a == b or b == c or a == c:
        print("Das Dreieck ist gleichschenklig.")
    else:
        print("Das Dreieck ist allgemein.")
else:
    print("Aus diesen Seiten kann man kein Dreieck bauen.")
Seite a: «5»
Seite b: «5»
Seite c: «8»
Das Dreieck ist gleichschenklig.
Eingaben Ausgabe
3, 4, 5 Das Dreieck ist allgemein.
5, 5, 8 Das Dreieck ist gleichschenklig.
5, 5, 5 Das Dreieck ist gleichseitig.
1, 2, 5 Aus diesen Seiten kann man kein Dreieck bauen.
2, 3, 5 Aus diesen Seiten kann man kein Dreieck bauen.
  • Zeile 4: Die äußere Verzweigung prüft, ob es überhaupt ein Dreieck ist. Alle drei Teilbedingungen müssen erfüllt sein, deshalb and.
  • Zeilen 5–10: Die innere Verzweigung wird nur für echte Dreiecke ausgeführt. Die Reihenfolge ist wichtig: Ein gleichseitiges Dreieck erfüllt auch a == b. Deshalb muss „gleichseitig“ zuerst geprüft werden.

Der letzte Testfall ist ein Grenzfall: 2 + 3 ist genau 5, aber nicht größer als 5. Die drei Seiten würden flach aufeinanderliegen. Deshalb steht in der Bedingung > und nicht >=.

1.3.8Das Wichtigste in Kürze

Selbstcheck

1.4Übung: Verzweigungen lesen, testen und erweitern DS04

Diesen Abschnitt als PDF (S. 55–67)

Das Jupyter-Notebook aus dem Unterricht: DS04_Uebung_Verzweigungen.ipynb. Herunterladen und in VS Code oder Jupyter öffnen.

Zum Weiterüben: DS04_Weitere_Uebungen.ipynb mit den Aufgaben aus „Weitere Übungen“ zum Bearbeiten in Python.

Leitidee

Programmiererinnen und Programmierer schreiben nicht nur neue Programme. Mindestens genauso oft lesen sie fremden Code, suchen Fehler darin und erweitern ein Programm, das schon da ist. Die Fehlersuche heißt auf Englisch Debugging – wörtlich „Entwanzen“, denn einen Programmfehler nennt man einen Bug („Käfer“). In diesem Abschnitt übst du genau diese drei Tätigkeiten mit Verzweigungen. Dazu lernst du, wie man ein Programm mit gut ausgewählten Eingaben testet, und du lernst eine neue Form der Verzweigung kennen: die Mehrfachauswahl.

Lernziele

Nach diesem Abschnitt kannst du

1.4.1Das brauchst du

Alles, was du für diesen Abschnitt brauchst, kennst du aus den Abschnitten über Operatoren und Verzweigungen. Hier ist es noch einmal kurz zusammengefasst. Der Aufbau einer mehrseitigen Verzweigung sieht so aus (elif und else sind dabei freiwillig):

if Bedingung_1:
    Anweisungen, wenn Bedingung_1 wahr ist
elif Bedingung_2:
    Anweisungen, wenn Bedingung_1 falsch und Bedingung_2 wahr ist
else:
    Anweisungen, wenn keine Bedingung wahr ist
Merke

Die häufigsten Fehler bei Verzweigungen und was Python dazu meldet:

Fehler im Code Meldung von Python Abhilfe
Doppelpunkt vergessen: if zahl > 0 SyntaxError: expected ':' : ans Zeilenende
Block nicht eingerückt IndentationError: expected an indented block … Block 4 Leerzeichen einrücken
Zeile ohne Grund eingerückt IndentationError: unexpected indent Einrückung entfernen
= statt == in der Bedingung SyntaxError: invalid syntax. Maybe you meant '==' … == schreiben
Bedingung hinter else: else zahl < 0: SyntaxError: expected ':' elif statt else
elif-Bedingungen in falscher Reihenfolge keine – aber falsches Ergebnis Reihenfolge prüfen

1.4.2Programme testen

Ein Programm, das ohne Fehlermeldung läuft, ist noch lange nicht richtig. Es kann trotzdem eine falsche Ausgabe liefern. Deshalb testet man es: Man führt es mit verschiedenen Eingaben aus und vergleicht die Ausgabe mit dem, was herauskommen soll.

Eine Eingabe zusammen mit der erwarteten Ausgabe nennt man einen Testfall. Wichtig ist, dass du die erwartete Ausgabe vorher überlegst – nicht erst, wenn du das Ergebnis siehst. Bei Programmen mit Verzweigungen wählst du die Testfälle so:

  1. Jeder Zweig mindestens einmal. Für jeden Block der Verzweigung brauchst du eine Eingabe, bei der genau dieser Block ausgeführt wird.
  2. Die Grenzfälle. Das sind die Werte direkt an einer Grenze. Bei der Bedingung alter < 18 sind das 17 und 18. Hier passieren die meisten Fehler, zum Beispiel wenn < statt <= geschrieben wurde.

Ein Beispiel: Ein Programm soll ausgeben, ob eine Zahl positiv, negativ oder null ist. Sinnvolle Testfälle sind:

Eingabe erwartete Ausgabe Warum dieser Test?
5 Die Zahl ist positiv Zweig „positiv“
-3 Die Zahl ist negativ Zweig „negativ“
0 Die Zahl ist null Zweig „null“, zugleich die Grenze zwischen positiv und negativ
1 und -1 positiv bzw. negativ direkt neben der Grenze

Genau dieses Programm reparierst du in der nächsten Aufgabe.

1.4.3Fehler finden

Arbeitsauftrag 40: Fehler finden (Debugging)

Das folgende Programm soll ausgeben, ob eine eingegebene Zahl positiv, negativ oder null ist. Es enthält drei Fehler.

zahl = int(input("Zahl eingeben: "))
if zahl = 0
    print("Die Zahl ist null")
elif zahl > 0:
print("Die Zahl ist positiv")
else:
    print("Die Zahl ist negativ")
  1. Finde die drei Fehler, bevor du das Programm ausführst. Notiere jeweils die Zeile und was falsch ist.
  2. Schreibe die korrigierte Version auf.
  3. Teste dein korrigiertes Programm mit den Testfällen aus dem Abschnitt „Programme testen“.
Tipp

Wenn du das fehlerhafte Programm ausführst, meldet Python immer nur den ersten Fehler, den es findet. Behebe ihn und starte das Programm erneut. Dann erscheint die Meldung zum nächsten Fehler. Die Tabelle im Abschnitt „Das brauchst du“ hilft dir, die Meldungen zu verstehen.

Die Fehler:

Lösung vergleichen

Die drei Fehler:

  1. Zeile 2: = statt ==. Mit einem Gleichheitszeichen wäre es eine Zuweisung, gemeint ist aber ein Vergleich.
  2. Zeile 2: Am Ende der Zeile fehlt der Doppelpunkt.
  3. Zeile 5: Die Anweisung ist nicht eingerückt. Sie muss aber zum elif-Block gehören.

Python meldet die Fehler nacheinander. Zuerst kommt:

  File "programm.py", line 2
    if zahl = 0
       ^^^^^^^^
SyntaxError: invalid syntax. Maybe you meant '==' or ':=' instead of '='?

Nach dem Ersetzen von = durch == meldet Python SyntaxError: expected ':' für Zeile 2. Ist auch der Doppelpunkt ergänzt, folgt IndentationError: expected an indented block after 'elif' statement on line 4 für Zeile 5.

Das korrigierte Programm:

zahl = int(input("Zahl eingeben: "))
if zahl == 0:
    print("Die Zahl ist null")
elif zahl > 0:
    print("Die Zahl ist positiv")
else:
    print("Die Zahl ist negativ")
Zahl eingeben: «-3»
Die Zahl ist negativ
Eingabe 5 -3 0 1 -1
Ausgabe positiv negativ null positiv negativ

Alle Testfälle liefern die erwartete Ausgabe.

1.4.4Code lesen

Arbeitsauftrag 41: Code lesen und erklären

Lies das folgende Programm, ohne es auszuführen.

zahl = 17
if zahl % 15 == 0:
    print("FizzBuzz")
elif zahl % 3 == 0:
    print("Fizz")
elif zahl % 5 == 0:
    print("Buzz")
else:
    print(zahl)
  1. Notiere, was das Programm für zahl = 17 ausgibt. Begründe mit den Bedingungen.
  2. Sage ebenso die Ausgabe für zahl = 9, zahl = 10 und zahl = 30 voraus.
  3. Erkläre, warum die Bedingung zahl % 15 == 0 zuerst geprüft wird.

Führe das Programm danach aus (ändere dazu den Wert in Zeile 1) und prüfe deine Vorhersagen.

Meine Vorhersagen und Begründungen:

Lösung vergleichen
  1. Für zahl = 17 gibt das Programm 17 aus. 17 ist weder durch 15 noch durch 3 noch durch 5 teilbar (die Reste sind 2, 2 und 2). Alle drei Bedingungen sind falsch, also wird der else-Block ausgeführt und die Zahl selbst ausgegeben. Das Ablaufprotokoll zeigt, dass Python alle drei Bedingungen prüft (Zeilen 2, 4, 6) und dann zu Zeile 9 springt:
Schritt Zeile zahl
1 1 17
2 2 17
3 4 17
4 6 17
5 9 17
  1. Die anderen Werte:
zahl durch 15? durch 3? durch 5? Ausgabe
9 nein ja nein Fizz
10 nein nein ja Buzz
30 ja ja ja FizzBuzz
  1. Eine Zahl, die durch 15 teilbar ist, ist auch durch 3 und durch 5 teilbar, zum Beispiel 30. Stünde zahl % 3 == 0 an erster Stelle, wäre diese Bedingung für 30 schon wahr. Dann würde Fizz ausgegeben und die übrigen Bedingungen würden gar nicht mehr geprüft. FizzBuzz käme nie vor. Deshalb muss der speziellste Fall zuerst stehen.

Das Programm stammt übrigens von einem Zählspiel: Man zählt reihum, sagt aber „Fizz“ statt einer Zahl, die durch 3 teilbar ist, „Buzz“ bei Teilbarkeit durch 5 und „FizzBuzz“ bei Teilbarkeit durch beides.

Arbeitsauftrag 42: Programmablaufplan zeichnen

Zeichne einen Programmablaufplan zum Programm aus dem Auftrag Code lesen und erklären. Verwende Rauten für die Bedingungen und Rechtecke für die Anweisungen. Beschrifte die Pfeile an den Rauten mit „ja“ und „nein“.

Tipp

Orientiere dich am Programmablaufplan des Notenrechners im Abschnitt über Verzweigungen. Jedes if und jedes elif wird zu einer Raute. Der „nein“-Pfeil führt jeweils zur nächsten Raute.

Mein Programmablaufplan:

Lösung vergleichen
Programmablaufplan zum FizzBuzz-Programm

Wichtig ist: Die drei Bedingungen werden nacheinander geprüft. Nur über „nein“ geht es zur nächsten Raute weiter. Jeder Weg endet bei derselben Ende-Markierung.

1.4.5Mehrfachauswahl: CASE OF

Oft wird ein und derselbe Wert mit mehreren festen Möglichkeiten verglichen. Ein Programm soll zum Beispiel eine Schulnote in Worten ausgeben. Mit if und elif sieht das so aus:

note = int(input("Note (1-6): "))
if note == 1:
    print("sehr gut")
elif note == 2:
    print("gut")
elif note == 3:
    print("befriedigend")
elif note == 4:
    print("ausreichend")
elif note == 5:
    print("mangelhaft")
elif note == 6:
    print("ungenügend")
else:
    print("Das ist keine gültige Note.")
Note (1-6): «2»
gut

Das funktioniert, ist aber umständlich: In jeder Zeile steht wieder note == …. Für solche Fälle gibt es eine eigene Form der Verzweigung, die Mehrfachauswahl. Man beschreibt sie unabhängig von einer Programmiersprache oft so:

CASE note OF
    1: Ausgabe "sehr gut"
    2: Ausgabe "gut"
    ...
    6: Ausgabe "ungenügend"
    OTHERWISE: Ausgabe "Das ist keine gültige Note."
END CASE

Lies das so: „Im Fall, dass note den Wert 1 hat, gib ‚sehr gut‘ aus. Im Fall 2 …“ OTHERWISE („andernfalls“) ist der Auffangfall. Er greift, wenn keiner der genannten Werte passt.

Definition: Mehrfachauswahl

Bei einer Mehrfachauswahl (CASE OF) wird ein Ausdruck mit mehreren festen Werten verglichen. Ausgeführt wird der Fall, dessen Wert passt. Passt keiner, wird der Auffangfall ausgeführt.

Die Mehrfachauswahl in Python: match und case

In Python schreibt man die Mehrfachauswahl mit den Schlüsselwörtern match („vergleiche“) und case („Fall“):

note = int(input("Note (1-6): "))
match note:
    case 1:
        print("sehr gut")
    case 2:
        print("gut")
    case 3:
        print("befriedigend")
    case 4:
        print("ausreichend")
    case 5:
        print("mangelhaft")
    case 6:
        print("ungenügend")
    case _:
        print("Das ist keine gültige Note.")
Note (1-6): «2»
gut

Die Mehrfachauswahl funktioniert genauso mit Texten. Das nutzt du gleich für einen Taschenrechner:

operator = "-"
match operator:
    case "+":
        print("Addition")
    case "-":
        print("Subtraktion")
    case _:
        print("Unbekannter Operator")
Subtraktion
Merke

Wann nimmst du was? Die Mehrfachauswahl passt nur, wenn ein Wert mit festen Werten verglichen wird: Noten 1 bis 6, Operatoren + - * /, Menüpunkte "a", "b", "c". Für Bereiche wie „unter 6 Jahren“ oder „zwischen 6 und 17“ und für Bedingungen mit and und or bleibt if/elif/else die richtige Wahl.

Stolperstein

match und case gibt es erst seit Python 3.10 (erschienen 2021). Mit einer älteren Version meldet Python bei match note: einen SyntaxError. Thonny und die meisten aktuellen Umgebungen bringen eine neuere Version mit. Welche Version du hast, zeigt dir das Programm import sys und print(sys.version) – oder du startest einfach das Beispiel oben.

Ein zweiter häufiger Fehler: case _ steht nicht am Ende. Dann passt er zu allem, und die Fälle darunter werden nie erreicht. Python meldet in diesem Fall einen SyntaxError.

1.4.6Ein Programm erweitern

Im Abschnitt über Variablen hast du im Auftrag Einfacher Rechner ein Programm geschrieben, das zwei Zahlen einliest und mit ihnen rechnet. Eine kurze Version davon sieht so aus:

a = float(input("Erste Zahl: "))
b = float(input("Zweite Zahl: "))
print("Summe:", a + b)
Erste Zahl: «7»
Zweite Zahl: «2»
Summe: 9.0

Dieses Programm rechnet immer plus. Mit einer Mehrfachauswahl kann die Nutzerin selbst wählen, welche Rechnung ausgeführt wird.

Arbeitsauftrag 43: Taschenrechner mit CASE OF

Schreibe einen Taschenrechner, der zwei Zahlen sowie einen Operator (+, -, *, /) abfragt. Setze die Mehrfachauswahl in Python mit match/case um. Fange den Fall ab, dass durch 0 geteilt werden soll, und gib bei einem unbekannten Operator eine verständliche Meldung aus. Teste dein Programm mit allen vier Operatoren, mit einer Division durch 0 und mit einem unbekannten Operator.

So könnte es aussehen:

Erste Zahl: «7»
Operator (+ - * /): «/»
Zweite Zahl: «2»
Ergebnis: 3.5
Tipp

Gehe in drei Schritten vor:

  1. Lies die erste Zahl, den Operator und die zweite Zahl ein. Der Operator ist ein Text und wird nicht umgewandelt.
  2. Unterscheide die Operatoren mit match op: und je einem case "+":, case "-": und so weiter. case _ übernimmt die Rolle des Auffangfalls für alle unbekannten Operatoren.
  3. Im Fall "/" brauchst du zusätzlich eine verschachtelte Verzweigung mit if: Nur wenn die zweite Zahl ungleich 0 ist, darf geteilt werden.

Ohne diese Prüfung bricht das Programm bei einer Division durch 0 mit einem ZeroDivisionError (Division durch null) ab.

Lösung vergleichen
a = float(input("Erste Zahl: "))
op = input("Operator (+ - * /): ")
b = float(input("Zweite Zahl: "))

match op:
    case "+":
        print("Ergebnis:", a + b)
    case "-":
        print("Ergebnis:", a - b)
    case "*":
        print("Ergebnis:", a * b)
    case "/":
        if b != 0:
            print("Ergebnis:", a / b)
        else:
            print("Division durch 0 ist nicht erlaubt!")
    case _:
        print("Unbekannter Operator")
Erste Zahl: «7»
Operator (+ - * /): «/»
Zweite Zahl: «0»
Division durch 0 ist nicht erlaubt!
  • Zeilen 1–3: Die Zahlen werden mit float umgewandelt, der Operator bleibt ein Text.
  • Zeilen 5–11: match op: vergleicht den Operator mit den festen Werten. Für jeden Operator gibt es einen eigenen Fall.
  • Zeilen 12–16: Im Fall "/" prüft eine innere if-Verzweigung, ob b ungleich 0 ist.
  • Zeilen 17–18: Alle anderen Eingaben landen im Auffangfall case _.
Eingaben Ausgabe
7, +, 2 Ergebnis: 9.0
7, -, 2 Ergebnis: 5.0
7, *, 2 Ergebnis: 14.0
7, /, 2 Ergebnis: 3.5
7, /, 0 Division durch 0 ist nicht erlaubt!
7, ^, 2 Unbekannter Operator
0, /, 5 Ergebnis: 0.0

Die Ergebnisse haben alle eine Nachkommastelle, weil die Zahlen mit float eingelesen werden. Der letzte Testfall zeigt: Die erste Zahl darf 0 sein, nur durch 0 teilen geht nicht. Auch eine Lösung mit if op == "+":, elif op == "-": … und else ist richtig. Mit match sieht man aber auf einen Blick, dass immer derselbe Wert op verglichen wird.

Arbeitsauftrag 44 (Zusatz): Eintrittspreis

Im Freibad gelten diese Preise:

Schreibe ein Programm, das zuerst das Alter abfragt. Nur bei Personen ab 18 Jahren soll es zusätzlich fragen, ob ein Ausweis vorliegt (ja/nein). Dann gibt es den Eintrittspreis aus. Lege vorher eine Tabelle mit Testfällen an, die alle Zweige und alle Grenzfälle abdeckt, und teste dein Programm damit.

Meine Testfälle (Eingabe, erwartete Ausgabe):

Lösung vergleichen
alter = int(input("Alter: "))
if alter < 6:
    print("Eintritt frei")
elif alter < 18:
    print("Eintritt: 2,50 Euro")
else:
    ausweis = input("Schüler- oder Studierendenausweis? (ja/nein): ")
    if ausweis == "ja":
        print("Eintritt: 3,00 Euro")
    else:
        print("Eintritt: 4,00 Euro")
Alter: «18»
Schüler- oder Studierendenausweis? (ja/nein): «ja»
Eintritt: 3,00 Euro

Die Frage nach dem Ausweis steht im else-Block, also wird sie nur Personen ab 18 gestellt. Die Preise stehen als Text in der Ausgabe. So erscheinen sie genau so, wie man Preise in Deutschland schreibt: mit Komma und zwei Nachkommastellen.

Eingaben erwartete Ausgabe Warum dieser Test?
5 Eintritt frei Zweig „unter 6“, Grenzfall
6 Eintritt: 2,50 Euro Grenzfall, erster Wert mit Preis
17 Eintritt: 2,50 Euro Grenzfall, letzter Wert vor 18
18, ja Eintritt: 3,00 Euro Grenzfall, Zweig „mit Ausweis“
18, nein Eintritt: 4,00 Euro Grenzfall, Zweig „ohne Ausweis“
40, nein Eintritt: 4,00 Euro ein ganz normaler Fall

1.4.7Weitere Übungen

Hier kannst du das Gelernte weiter üben. Die Punkte im Titel zeigen, wie schwer eine Aufgabe ist: ●○○ leicht, ●●○ mittel, ●●● knifflig. Fang mit den leichten an.

Arbeitsauftrag 45: Welcher Tag? ●○○

Lies das Programm, ohne es auszuführen. Gib an, was es für tag = 3 ausgibt. Gib ebenso die Ausgabe für tag = 7 und für tag = 1 an. Prüfe danach am Computer, indem du den Wert in Zeile 1 änderst.

tag = 3
match tag:
    case 1:
        print("Montag")
    case 2:
        print("Dienstag")
    case 3:
        print("Mittwoch")
    case _:
        print("anderer Tag")

Meine Vorhersagen:

Lösung vergleichen
tag 3 7 1
Ausgabe Mittwoch anderer Tag Montag

Python vergleicht tag der Reihe nach mit den festen Werten 1, 2 und 3. Beim ersten passenden Fall wird der Block darunter ausgeführt. Für 7 passt keiner der Werte, deshalb greift der Auffangfall case _.

Arbeitsauftrag 46: Ampel mit match ●○○

Schreibe das folgende Programm so um, dass es statt if/elif/else eine Mehrfachauswahl mit match und case verwendet. Das Programm soll danach genau dasselbe ausgeben. Teste mit rot, grün und blau.

farbe = input("Ampelfarbe: ")
if farbe == "rot":
    print("Stehen bleiben!")
elif farbe == "gelb":
    print("Warten!")
elif farbe == "grün":
    print("Gehen!")
else:
    print("Diese Farbe kennt die Ampel nicht.")
Lösung vergleichen
farbe = input("Ampelfarbe: ")
match farbe:
    case "rot":
        print("Stehen bleiben!")
    case "gelb":
        print("Warten!")
    case "grün":
        print("Gehen!")
    case _:
        print("Diese Farbe kennt die Ampel nicht.")
Ampelfarbe: «blau»
Diese Farbe kennt die Ampel nicht.

Aus farbe == "rot" wird case "rot":. Der Name farbe steht nur noch einmal oben hinter match. Aus else wird der Auffangfall case _. Die print-Zeilen sind jetzt zwei Stufen eingerückt (acht Leerzeichen), weil sie im Block von case stehen und dieser im Block von match.

Arbeitsauftrag 47: Wochentage ●○○

Das Programm soll zu einem Kürzel von Mo bis Fr den ganzen Wochentag ausgeben. Bei allen anderen Eingaben soll es „Das ist kein Schultag.“ ausgeben. Ergänze die Lücken ___ und die fehlenden Fälle für Mi, Do und Fr.

kuerzel = input("Kürzel (Mo bis Fr): ")
match ___:
    case "Mo":
        print("Montag")
    case ___:
        print("Dienstag")
    # Hier fehlen die Fälle für Mi, Do und Fr.
    ___:
        print("Das ist kein Schultag.")
Lösung vergleichen
kuerzel = input("Kürzel (Mo bis Fr): ")
match kuerzel:
    case "Mo":
        print("Montag")
    case "Di":
        print("Dienstag")
    case "Mi":
        print("Mittwoch")
    case "Do":
        print("Donnerstag")
    case "Fr":
        print("Freitag")
    case _:
        print("Das ist kein Schultag.")
Kürzel (Mo bis Fr): «Do»
Donnerstag

Die Kürzel sind Texte, deshalb stehen sie in Anführungszeichen. Die Eingabe wird nicht umgewandelt. Der Auffangfall case _ muss als letzter Fall stehen. Teste auch So und mo: Beide landen im Auffangfall, denn "mo" ist wegen der Kleinschreibung ein anderer Text als "Mo".

Arbeitsauftrag 48: Testfälle für ein Spiel ●○○

Ein Spiel teilt Spielerinnen und Spieler nach ihrem Level ein:

level = int(input("Level: "))
if level < 1:
    print("ungültiges Level")
elif level <= 10:
    print("Anfänger")
elif level <= 30:
    print("Fortgeschritten")
else:
    print("Profi")

Lege eine Tabelle mit Testfällen an: Jeder Zweig soll mindestens einmal vorkommen, außerdem alle Grenzfälle. Trage zu jedem Testfall die erwartete Ausgabe ein, bevor du das Programm ausführst. Prüfe dann am Computer.

Eingabe erwartete Ausgabe Warum dieser Test?
Lösung vergleichen
Eingabe erwartete Ausgabe Warum dieser Test?
0 ungültiges Level Zweig „ungültig“, Grenzfall
1 Anfänger Grenzfall, kleinstes gültiges Level
10 Anfänger Grenzfall, wegen <= noch Anfänger
11 Fortgeschritten Grenzfall, erstes Level danach
30 Fortgeschritten Grenzfall
31 Profi Grenzfall, Zweig „Profi“

Die Grenzen liegen bei 1, 10 und 30. An jeder Grenze testet man den Wert auf der Grenze und den Wert direkt daneben. Weitere sinnvolle Tests sind ein „normaler“ Wert in jedem Bereich, zum Beispiel 5, 20 und 50, und eine negative Zahl wie -3.

Arbeitsauftrag 49: Fehler finden: Pizzagröße ●●○

Das Programm soll zu einer Pizzagröße (S, M oder L) den Preis ausgeben. Es enthält drei Fehler.

groesse = input("Größe (S, M, L): ")
match groesse
    case "S":
        print("Preis: 6,50 Euro")
    case "M":
    print("Preis: 8,00 Euro")
    case "L":
        print("Preis: 9,50 Euro")
    else:
        print("Diese Größe gibt es nicht.")
  1. Finde die drei Fehler. Notiere jeweils die Zeile und was falsch ist.
  2. Schreibe das Programm richtig auf und teste es mit M und mit XL.

Die Fehler:

Lösung vergleichen
  1. Zeile 2: Hinter match groesse fehlt der Doppelpunkt (SyntaxError: expected ':').
  2. Zeile 6: Die print-Anweisung ist nicht eingerückt. Sie muss im Block von case "M": stehen (IndentationError).
  3. Zeile 9: In einer Mehrfachauswahl gibt es kein else. Der Auffangfall heißt case _:.
groesse = input("Größe (S, M, L): ")
match groesse:
    case "S":
        print("Preis: 6,50 Euro")
    case "M":
        print("Preis: 8,00 Euro")
    case "L":
        print("Preis: 9,50 Euro")
    case _:
        print("Diese Größe gibt es nicht.")
Größe (S, M, L): «XL»
Diese Größe gibt es nicht.

Mit der Eingabe M gibt das Programm Preis: 8,00 Euro aus. Die Preise stehen als Text in der Ausgabe, deshalb darf dort ein Komma stehen.

Arbeitsauftrag 50: match oder if? ●●○

Entscheide für jede Situation, ob eine Mehrfachauswahl mit match/case oder eine Verzweigung mit if/elif/else besser passt. Begründe kurz.

Situation match oder if?
a) Eine Schulnote von 1 bis 6 in Worten ausgeben
b) Aus einer Temperatur eine Warnstufe bestimmen (unter 0, 0 bis 30, über 30)
c) Ein Menü mit den Punkten a, b und c
d) Prüfen, ob jemand mindestens 16 ist und eine Einverständniserklärung hat
e) Zu einer Monatsnummer von 1 bis 12 den Namen des Monats ausgeben

Begründungen zu a) bis e):

Lösung vergleichen
Situation Auswahl Begründung
a) Schulnote in Worten match Ein Wert wird mit festen Werten 1 bis 6 verglichen.
b) Temperatur-Warnstufe if Es geht um Bereiche, nicht um feste Werte.
c) Menü mit a, b, c match Ein Wert wird mit festen Texten verglichen.
d) Alter und Erklärung if Zwei Bedingungen werden mit and verknüpft.
e) Monatsname match Ein Wert wird mit festen Werten 1 bis 12 verglichen.

Die Faustregel: Wird ein Wert mit mehreren festen Werten verglichen, passt match. Bei Bereichen wie „unter 0“ oder bei verknüpften Bedingungen ist if die richtige Wahl. Mit if könnte man zwar auch a), c) und e) lösen, match ist dort aber übersichtlicher.

Arbeitsauftrag 51: Längen umrechnen ●●○

Schreibe ein Programm, das eine Länge (Kommazahl) und eine Einheit (km, m oder cm) einliest und die Länge in Metern ausgibt. Verwende eine Mehrfachauswahl. Bei einer unbekannten Einheit soll eine verständliche Meldung erscheinen. Teste mit 2.5 und km, mit 150 und cm und mit 3 und mm.

So könnte es aussehen:

Länge: «2.5»
Einheit (km, m, cm): «km»
Das sind 2500.0 Meter.
Lösung vergleichen
laenge = float(input("Länge: "))
einheit = input("Einheit (km, m, cm): ")
match einheit:
    case "km":
        print("Das sind", laenge * 1000, "Meter.")
    case "m":
        print("Das sind", laenge, "Meter.")
    case "cm":
        print("Das sind", laenge / 100, "Meter.")
    case _:
        print("Die Einheit", einheit, "kenne ich nicht.")
Länge: «150»
Einheit (km, m, cm): «cm»
Das sind 1.5 Meter.

Ein Kilometer hat 1000 Meter, ein Meter hat 100 Zentimeter. Deshalb wird bei km mit 1000 multipliziert und bei cm durch 100 geteilt. Bei m muss nichts gerechnet werden. Die Länge wird mit float eingelesen, die Einheit bleibt ein Text. Mit 3 und mm gibt das Programm Die Einheit mm kenne ich nicht. aus.

Arbeitsauftrag 52: Taschenrechner erweitern ●●●

Erweitere deinen Taschenrechner aus dem Auftrag Taschenrechner mit CASE OF um drei weitere Operatoren: // (Ganzzahldivision), % (Rest) und ** (Potenz). Auch bei // und % darf die zweite Zahl nicht 0 sein. Lege eine Tabelle mit Testfällen an, in der jeder neue Operator und jeder Sonderfall mindestens einmal vorkommt, und teste dein Programm damit.

Meine Testfälle (Eingaben, erwartete Ausgabe):

Lösung vergleichen
a = float(input("Erste Zahl: "))
op = input("Operator (+ - * / // % **): ")
b = float(input("Zweite Zahl: "))

match op:
    case "+":
        print("Ergebnis:", a + b)
    case "-":
        print("Ergebnis:", a - b)
    case "*":
        print("Ergebnis:", a * b)
    case "/":
        if b != 0:
            print("Ergebnis:", a / b)
        else:
            print("Division durch 0 ist nicht erlaubt!")
    case "//":
        if b != 0:
            print("Ergebnis:", a // b)
        else:
            print("Division durch 0 ist nicht erlaubt!")
    case "%":
        if b != 0:
            print("Ergebnis:", a % b)
        else:
            print("Division durch 0 ist nicht erlaubt!")
    case "**":
        print("Ergebnis:", a ** b)
    case _:
        print("Unbekannter Operator")
Erste Zahl: «7»
Operator (+ - * / // % **): «%»
Zweite Zahl: «0»
Division durch 0 ist nicht erlaubt!
Eingaben erwartete Ausgabe
7, //, 2 Ergebnis: 3.0
7, %, 2 Ergebnis: 1.0
2, **, 10 Ergebnis: 1024.0
7, //, 0 Division durch 0 ist nicht erlaubt!
7, %, 0 Division durch 0 ist nicht erlaubt!
7, ^, 2 Unbekannter Operator

Für jeden neuen Operator gibt es einen eigenen Fall. // und % teilen ebenfalls, deshalb brauchen sie wie / eine verschachtelte Verzweigung. Ohne sie bricht das Programm mit einem ZeroDivisionError ab. Die Ergebnisse haben alle .0, weil die Zahlen mit float eingelesen werden. Die alten Testfälle aus dem Auftrag Taschenrechner mit CASE OF solltest du auch noch einmal ausprobieren.

1.4.8Das Wichtigste in Kürze

Selbstcheck

1.5Die for-Schleife: Anweisungen wiederholen DS05

Diesen Abschnitt als PDF (S. 68–81)

Das Jupyter-Notebook aus dem Unterricht: DS05_for_Schleife.ipynb. Herunterladen und in VS Code oder Jupyter öffnen.

Zum Weiterüben: DS05_Weitere_Uebungen.ipynb mit den Aufgaben aus „Weitere Übungen“ zum Bearbeiten in Python.

Leitidee

Stell dir vor, dein Programm soll die Zahlen von 1 bis 100 ausgeben. Mit dem, was du bisher kannst, bräuchtest du dafür 100 print-Zeilen. Das ist mühsam, und bei einem Tippfehler in Zeile 73 suchst du lange. Viel besser wäre eine Anweisung wie: „Wiederhole das 100-mal.“ Aus der Blockprogrammierung kennst du dafür den Baustein „wiederhole 10-mal“. In Python heißt diese Wiederholung for-Schleife. Mit ihr gibst du Zahlenreihen aus, berechnest Summen und zeichnest einfache Muster – mit nur zwei oder drei Zeilen Code.

Lernziele

Nach diesem Abschnitt kannst du

1.5.1Die Idee: Wiederholen statt abschreiben

Statt dreimal print("Hallo!") untereinanderzuschreiben, kannst du Python sagen: „Mache das dreimal.“ Das sieht so aus:

for i in range(3):
    print("Hallo!")
Hallo!
Hallo!
Hallo!

Der Vorteil wird deutlich, wenn du statt 3 die Zahl 100 schreibst: Das Programm bleibt zwei Zeilen lang, gibt aber 100-mal „Hallo!“ aus.

Definition: Schleife

Eine Schleife ist eine Kontrollstruktur, die einen Block von Anweisungen (den Schleifenrumpf) mehrfach hintereinander ausführt. Jede einzelne Ausführung des Schleifenrumpfs heißt Durchlauf.

Definition: for-Schleife

Eine for-Schleife (auch Zählschleife) ist eine Schleife, bei der die Anzahl der Durchläufe schon vor dem Start der Schleife feststeht.

Merke

1.5.2Aufbau einer for-Schleife

Die Zählvariable

Im Schleifenkopf steht eine Variable, hier i. Sie heißt Zählvariable (oder Schleifenvariable). Bei jedem Durchlauf bekommt sie automatisch den nächsten Wert. Du kannst sie im Schleifenrumpf benutzen, zum Beispiel ausgeben:

for i in range(1, 4):
    print("Runde", i)
print("Fertig")
Runde 1
Runde 2
Runde 3
Fertig

Du kannst dir die for-Schleife wie eine Läuferin auf der Sportbahn vorstellen: Sie läuft ihre Runden und zählt dabei mit. Die Zahl, die sie gerade zählt, ist der Wert der Zählvariablen. Nach der letzten Runde hört sie auf und geht zur Bank (Zeile 3).

Der Ablauf Schritt für Schritt

Was genau passiert, zeigt ein Ablaufprotokoll. Es listet jede ausgeführte Zeile auf und den Wert von i nach dieser Zeile:

Schritt Zeile Anweisung i
1 1 for i in range(1, 4): 1
2 2 print("Runde", i) 1
3 1 for i in range(1, 4): 2
4 2 print("Runde", i) 2
5 1 for i in range(1, 4): 3
6 2 print("Runde", i) 3
7 1 for i in range(1, 4): 3
8 3 print("Fertig") 3

Beachte drei Dinge:

Merke

Die Zählvariable bekommt bei jedem Durchlauf automatisch den nächsten Wert. Du musst sie nicht selbst erhöhen.

Einrückung: Was gehört zur Schleife?

Wie bei if entscheidet in Python die Einrückung, welche Anweisungen zusammengehören. Der Schleifenrumpf darf mehrere Zeilen haben. Alle müssen gleich weit eingerückt sein. Vergleiche die beiden Programme. Sie unterscheiden sich nur in der Einrückung der letzten Zeile:

for i in range(3):
    print("Ich übe Python.")
    print("Das macht Spaß!")
Ich übe Python.
Das macht Spaß!
Ich übe Python.
Das macht Spaß!
Ich übe Python.
Das macht Spaß!
for i in range(3):
    print("Ich übe Python.")
print("Das macht Spaß!")
Ich übe Python.
Ich übe Python.
Ich übe Python.
Das macht Spaß!

Im ersten Programm gehören beide print-Anweisungen zum Rumpf und werden dreimal ausgeführt. Im zweiten Programm gehört nur die erste dazu. Die letzte Zeile wird erst nach der Schleife ausgeführt, also nur einmal.

Stolperstein

Vergisst du die Einrückung, meldet Python einen Fehler, bevor das Programm überhaupt startet:

for i in range(3):
print(i)
  File "programm.py", line 2
    print(i)
    ^^^^^
IndentationError: expected an indented block after 'for' statement on line 1

IndentationError heißt „Einrückungsfehler“. Die Meldung sagt: „Nach der for-Anweisung in Zeile 1 wurde ein eingerückter Block erwartet.“ Die Zeichen ^^^^^ zeigen auf die Zeile 2, die eingerückt sein müsste. Rücke den Rumpf mit 4 Leerzeichen (oder der Tab-Taste) ein.

Fehlt der Doppelpunkt am Ende des Kopfes, kommt diese Meldung:

for i in range(3)
    print(i)
SyntaxError: expected ':'
Versuch: Probiere es aus

Tippe das Programm mit „Runde“ ab. Ändere die Zahlen in range(1, 4) und beobachte, wie sich die Ausgabe ändert. Rücke dann print("Fertig") ein. Was passiert jetzt?

1.5.3Zahlenfolgen mit range

range heißt auf Deutsch „Bereich“. Es erzeugt eine Folge von ganzen Zahlen, die die Zählvariable nacheinander annimmt. Es gibt drei Formen:

Aufruf erzeugt die Zahlen Anzahl
range(5) 0, 1, 2, 3, 4 5
range(1, 6) 1, 2, 3, 4, 5 5
range(3, 8) 3, 4, 5, 6, 7 5
range(0, 10, 2) 0, 2, 4, 6, 8 5
range(1, 10, 3) 1, 4, 7 3
range(10, 0, -1) 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 10
range(5, 1) keine Zahl (die Schleife läuft gar nicht) 0
Merke
Tipp

Eine Eselsbrücke: Die Zahl stop ist wie die Ziellinie beim Laufen. Man zählt bis kurz davor, die Linie selbst gehört nicht mehr dazu. Bei range(start, stop) gibt es genau stop - start Zahlen.

Beispiel: Zahlen ausgeben und das Einmaleins

Das folgende Programm zeigt zwei Schleifen hintereinander. Überlege zuerst, was es ausgibt. Lies dann weiter.

for i in range(1, 6):
    print(i)

print("---")

for i in range(1, 11):
    print("7 *", i, "=", 7 * i)
1
2
3
4
5
---
7 * 1 = 7
7 * 2 = 14
7 * 3 = 21
7 * 4 = 28
7 * 5 = 35
7 * 6 = 42
7 * 7 = 49
7 * 8 = 56
7 * 9 = 63
7 * 10 = 70

Rückwärts zählen

Mit der Schrittweite -1 zählt die Schleife rückwärts. for i in range(5, 0, -1): lässt i die Werte 5, 4, 3, 2, 1 annehmen – ein Countdown. Auch hier gehört der Stoppwert 0 nicht mehr dazu.

Stolperstein

Der häufigste Fehler bei range: Man vergisst, dass der Stoppwert nicht dazugehört. range(1, 10) erzeugt die Zahlen von 1 bis 9, nicht bis 10. Python meldet dabei keinen Fehler – das Programm tut einfach nicht ganz das, was du wolltest. Prüfe deshalb immer die erste und die letzte Zahl der Ausgabe. Für „von 1 bis 10“ schreibst du range(1, 11).

Arbeitsauftrag 53: range-Detektiv
  1. Gib an, welche Zahlen die folgenden range-Aufrufe erzeugen.
  2. Gib zu den Zahlenfolgen in der unteren Tabelle einen passenden range-Aufruf an.

Überprüfe deine Antworten am Computer mit einer Schleife, die i ausgibt.

Aufruf erzeugt die Zahlen
range(4)
range(2, 7)
range(5, 30, 5)
range(9, 3, -2)
Zahlenfolge Aufruf
1, 2, 3, 4, 5, 6, 7, 8
10, 20, 30, 40, 50
3, 2, 1, 0
Lösung vergleichen
Aufruf erzeugt die Zahlen
range(4) 0, 1, 2, 3
range(2, 7) 2, 3, 4, 5, 6
range(5, 30, 5) 5, 10, 15, 20, 25
range(9, 3, -2) 9, 7, 5
Zahlenfolge Aufruf
1, 2, 3, 4, 5, 6, 7, 8 range(1, 9)
10, 20, 30, 40, 50 range(10, 51, 10)
3, 2, 1, 0 range(3, -1, -1)

Bei der zweiten Tabelle gibt es mehrere richtige Antworten. range(10, 60, 10) liefert zum Beispiel ebenfalls 10 bis 50, denn 60 gehört nicht mehr dazu. Bei der letzten Folge muss der Stoppwert -1 sein, damit die 0 noch dabei ist.

Arbeitsauftrag 54: Zahlenreihe

Gib mit einer for-Schleife alle geraden Zahlen von 2 bis 20 aus (Tipp: Schrittweite nutzen!).

Lösung vergleichen
for i in range(2, 21, 2):
    print(i)
2
4
6
8
10
12
14
16
18
20

Die Folge beginnt bei 2 und springt mit der Schrittweite 2 weiter. Der Stoppwert muss größer als 20 sein, damit die 20 noch ausgegeben wird: 21 (oder 22). Wer range(2, 20, 2) schreibt, bekommt nur die Zahlen bis 18.

Auch diese Lösung ist richtig: i läuft von 1 bis 10, ausgegeben wird das Doppelte.

for i in range(1, 11):
    print(2 * i)
2
4
6
8
10
12
14
16
18
20

1.5.4Summen bilden

Schleifen sind besonders nützlich, wenn viele Zahlen zusammengezählt werden sollen. Denk an eine Kasse im Supermarkt: Am Anfang steht die Anzeige auf 0. Bei jedem Artikel, der über das Band läuft, kommt sein Preis dazu. Am Ende steht der Gesamtbetrag auf der Anzeige.

Genauso geht man im Programm vor. Man braucht eine Variable, die die Zwischensumme speichert. Sie wird vor der Schleife auf 0 gesetzt. In der Schleife kommt bei jedem Durchlauf eine Zahl dazu. Nach der Schleife steht in ihr das Ergebnis. Eine solche Variable heißt Summenvariable (Fachwort: Akkumulator, von lateinisch accumulare = anhäufen).

Das Programm berechnet die Summe der Zahlen von 1 bis 5:

summe = 0
for i in range(1, 6):
    summe = summe + i
print("Summe:", summe)
Summe: 15

Wie die Summe wächst, zeigt das Ablaufprotokoll. Lies vor allem die Spalte summe von oben nach unten: 0, 1, 3, 6, 10, 15.

Schritt Zeile Anweisung i summe
1 1 summe = 0 – 0
2 2 for i in range(1, 6): 1 0
3 3 summe = summe + i 1 1
4 2 for i in range(1, 6): 2 1
5 3 summe = summe + i 2 3
6 2 for i in range(1, 6): 3 3
7 3 summe = summe + i 3 6
8 2 for i in range(1, 6): 4 6
9 3 summe = summe + i 4 10
10 2 for i in range(1, 6): 5 10
11 3 summe = summe + i 5 15
12 2 for i in range(1, 6): 5 15
13 4 print("Summe:", summe) 5 15

Im Schritt 1 hat i noch keinen Wert (–), denn die Schleife hat noch nicht begonnen. Im Schritt 12 liefert range keine Zahl mehr, die Schleife endet.

Merke

Eine Summe berechnet man mit einer Summenvariablen in drei Schritten:

  1. vor der Schleife: summe = 0
  2. in der Schleife: summe = summe + zahl
  3. nach der Schleife: Ergebnis ausgeben

Die Kurzschreibweise +=

Zeilen wie summe = summe + i kommen so oft vor, dass es dafür eine Abkürzung gibt: summe += i. Lies das als „summe wird um i erhöht“. Beide Schreibweisen bewirken genau dasselbe.

Kurzschreibweise bedeutet Beispiel (vorher x = 10)
x += 3 x = x + 3 x ist danach 13
x -= 3 x = x - 3 x ist danach 7
x *= 3 x = x * 3 x ist danach 30

Im Summenprogramm kannst du also statt Zeile 3 auch summe += i schreiben. Du darfst beide Schreibweisen benutzen. Am Anfang ist die lange Form oft leichter zu lesen.

Stolperstein

Die Summenvariable steht in der Schleife. Dann wird sie in jedem Durchlauf wieder auf 0 gesetzt, und alles bisher Gezählte geht verloren:

for i in range(1, 6):
    summe = 0
    summe = summe + i
print("Summe:", summe)
Summe: 5

Am Ende steht in summe nur noch die letzte Zahl 5. Python meldet keinen Fehler, das Ergebnis ist einfach falsch. Der Startwert gehört vor die Schleife.

Die Ausgabe ist eingerückt. Dann wird nach jedem Durchlauf eine Zwischensumme ausgegeben:

summe = 0
for i in range(1, 6):
    summe = summe + i
    print("Summe:", summe)
Summe: 1
Summe: 3
Summe: 6
Summe: 10
Summe: 15

Das kann zum Nachprüfen nützlich sein. Wenn nur das Ergebnis gefragt ist, darf print aber nicht eingerückt sein.

Arbeitsauftrag 55: Summe berechnen

Berechne mit einer for-Schleife die Summe aller Zahlen von 1 bis 100 (ohne eine fertige Summenfunktion zu verwenden) und gib das Ergebnis aus.

Lösung vergleichen
summe = 0
for i in range(1, 101):
    summe = summe + i
print("Summe:", summe)
Summe: 5050

Die Summenvariable startet vor der Schleife bei 0. i läuft von 1 bis 100, deshalb steht im Kopf range(1, 101). Mit range(1, 100) fehlt die 100, und es kommt 4950 heraus. Statt Zeile 3 kann man auch summe += i schreiben.

Zur Kontrolle: Der Mathematiker Carl Friedrich Gauß soll diese Aufgabe als Schüler im Kopf gelöst haben. Er bildete Paare: 1 + 100, 2 + 99, 3 + 98 … Das sind 50 Paare mit der Summe 101, also 50 · 101 = 5050.

Die Obergrenze eingeben lassen

Die Schleife wird noch nützlicher, wenn die Nutzerin oder der Nutzer die Obergrenze selbst eingibt. Weil range nur mit ganzen Zahlen arbeitet, muss die Eingabe mit int umgewandelt werden:

n = int(input("Bis zu welcher Zahl soll ich addieren? "))
summe = 0
for i in range(1, n + 1):
    summe += i
print("Die Summe von 1 bis", n, "ist", summe)
Bis zu welcher Zahl soll ich addieren? «10»
Die Summe von 1 bis 10 ist 55
Stolperstein

Vergisst du die Umwandlung mit int, ist n eine Zeichenkette. Damit kann range nichts anfangen:

n = input("Bis zu welcher Zahl soll ich addieren? ")
for i in range(1, n):
    print(i)
TypeError: 'str' object cannot be interpreted as an integer

Die Meldung heißt: „Ein Wert vom Typ str kann nicht als ganze Zahl verstanden werden.“ Dieselbe Meldung mit 'float' bekommst du, wenn du float statt int benutzt. range braucht immer ganze Zahlen.

Arbeitsauftrag 56: Ablaufprotokoll

Fülle das Ablaufprotokoll zu dem Programm aus. Trage nach jedem Schritt die Werte von i und x ein (– bedeutet: noch kein Wert). Gib dann an, was das Programm ausgibt.

x = 0
for i in range(3):
    x = x + 2 * i
print("x =", x)
Schritt Zeile Anweisung Wert von i Wert von x
1 1 x = 0 –
2 2 for i in range(3):
3 3 x = x + 2 * i
4 2 for i in range(3):
5 3 x = x + 2 * i
6 2 for i in range(3):
7 3 x = x + 2 * i
8 2 for i in range(3):
9 4 print("x =", x)

Ausgabe:

Lösung vergleichen
Schritt Zeile Anweisung Wert von i Wert von x
1 1 x = 0 – 0
2 2 for i in range(3): 0 0
3 3 x = x + 2 * i 0 0
4 2 for i in range(3): 1 0
5 3 x = x + 2 * i 1 2
6 2 for i in range(3): 2 2
7 3 x = x + 2 * i 2 6
8 2 for i in range(3): 2 6
9 4 print("x =", x) 2 6
x = 6

range(3) beginnt bei 0, nicht bei 1. Im ersten Durchlauf wird also 2 * 0 = 0 addiert. Danach kommen 2 * 1 = 2 und 2 * 2 = 4 dazu: 0 + 2 + 4 = 6.

1.5.5Muster ausgeben

Mit Schleifen kann man auch Bilder aus Zeichen zeichnen. Dafür brauchst du ein kleines Hilfsmittel.

Werkzeug: Texte vervielfachen mit *

Multiplizierst du eine Zeichenkette mit einer ganzen Zahl, wird der Text so oft hintereinandergehängt:

print("ab" * 3)
print("-" * 20)
ababab
--------------------

Die Zahl muss eine ganze Zahl (int) sein. Sie darf auch eine Variable sein, zum Beispiel die Zählvariable einer Schleife.

Arbeitsauftrag 57 (Zusatz): Sternendreieck

Gib mit einer for-Schleife folgendes Muster aus:

*
**
***
****
*****
Lösung vergleichen
for i in range(1, 6):
    print("*" * i)
*
**
***
****
*****

Das Dreieck hat 5 Zeilen, in Zeile Nummer i stehen i Sterne. Deshalb läuft i von 1 bis 5 (range(1, 6)), und in jedem Durchlauf wird "*" * i ausgegeben. Mit range(5) würde die erste Zeile leer bleiben ("*" * 0 ist ein leerer Text) und die letzte hätte nur 4 Sterne.

Wer das Dreieck auf dem Kopf haben möchte, zählt rückwärts: for i in range(5, 0, -1):.

So kannst du es sagen

So beschreibst du eine for-Schleife in Fachsprache – vom einfachen zum genauen Satz:

1.5.6Weitere Übungen

Hier kannst du das Gelernte weiter üben. Die Punkte im Titel zeigen, wie schwer eine Aufgabe ist: ●○○ leicht, ●●○ mittel, ●●● knifflig. Fang mit den leichten an.

Arbeitsauftrag 58: Wie oft läuft die Schleife? ●○○

Bestimme für jeden Schleifenkopf, wie oft die Schleife durchlaufen wird und welchen Wert i im ersten und im letzten Durchlauf hat. Überprüfe am Computer, indem du in den Rumpf print(i) schreibst.

Schleifenkopf Anzahl Durchläufe erster Wert letzter Wert
for i in range(6):
for i in range(1, 6):
for i in range(3, 10):
for i in range(0, 20, 5):
for i in range(1, 2):
for i in range(4, 4):
Lösung vergleichen
Schleifenkopf Anzahl Durchläufe erster Wert letzter Wert
for i in range(6): 6 0 5
for i in range(1, 6): 5 1 5
for i in range(3, 10): 7 3 9
for i in range(0, 20, 5): 4 0 15
for i in range(1, 2): 1 1 1
for i in range(4, 4): 0 – –

Der Stoppwert gehört nie dazu. Bei range(start, stop) gibt es deshalb stop - start Durchläufe, zum Beispiel 10 - 3 = 7. Bei range(0, 20, 5) sind es die Werte 0, 5, 10 und 15 – die 20 ist schon der Stoppwert. range(4, 4) erzeugt keine Zahl, der Rumpf wird nie ausgeführt.

Arbeitsauftrag 59: Runde für Runde ●○○

Lies das Programm, ohne es auszuführen. Schreibe auf, was es ausgibt. Überprüfe deine Vorhersage danach am Computer.

for i in range(1, 4):
    print("Runde", i)
    print("---")
print("Spiel vorbei")

Meine Vorhersage:

Lösung vergleichen
Runde 1
---
Runde 2
---
Runde 3
---
Spiel vorbei

Die Zeilen 2 und 3 sind eingerückt und gehören zum Schleifenrumpf. Sie werden in jedem der drei Durchläufe ausgeführt, also auch der Trennstrich dreimal. Zeile 4 ist nicht eingerückt und wird erst nach der Schleife einmal ausgeführt.

Arbeitsauftrag 60: Einmaleins nach Wahl ●○○

Das Programm soll eine Zahl einlesen und ihr Einmaleins von 1 bis 10 ausgeben, zum Beispiel für 9 die Zeilen 9 * 1 = 9 bis 9 * 10 = 90. Ergänze die drei Lücken ___.

zahl = int(input("Welche Reihe? "))
for i in range(___, ___):
    print(zahl, "*", i, "=", ___)
Lösung vergleichen
zahl = int(input("Welche Reihe? "))
for i in range(1, 11):
    print(zahl, "*", i, "=", zahl * i)
Welche Reihe? «9»
9 * 1 = 9
9 * 2 = 18
9 * 3 = 27
9 * 4 = 36
9 * 5 = 45
9 * 6 = 54
9 * 7 = 63
9 * 8 = 72
9 * 9 = 81
9 * 10 = 90

Damit die 10 noch dabei ist, muss der Stoppwert 11 sein. In der dritten Lücke wird gerechnet: zahl * i ohne Anführungszeichen. Das "*" davor steht in Anführungszeichen, es wird nur als Zeichen ausgegeben.

Arbeitsauftrag 61: Quadratzahlen ●○○

Schreibe ein Programm, das mit einer for-Schleife die Quadratzahlen von 1 bis 10 ausgibt. Jede Zeile soll so aussehen wie im Beispiel. Verwende den Operator **.

1 hoch 2 ist 1
2 hoch 2 ist 4
3 hoch 2 ist 9
Lösung vergleichen
for i in range(1, 11):
    print(i, "hoch 2 ist", i ** 2)
1 hoch 2 ist 1
2 hoch 2 ist 4
3 hoch 2 ist 9
4 hoch 2 ist 16
5 hoch 2 ist 25
6 hoch 2 ist 36
7 hoch 2 ist 49
8 hoch 2 ist 64
9 hoch 2 ist 81
10 hoch 2 ist 100

Die Zählvariable i läuft von 1 bis 10, deshalb range(1, 11). In jedem Durchlauf wird i ** 2 neu berechnet. Statt i ** 2 ist auch i * i richtig.

Arbeitsauftrag 62: Fehler finden: Ungerade Zahlen addieren ●●○

Das Programm soll die Summe der ungeraden Zahlen von 1 bis 19 berechnen (1 + 3 + 5 + … + 19) und einmal ausgeben. Richtig wäre Summe: 100. Das Programm läuft ohne Fehlermeldung, enthält aber drei Fehler.

for i in range(1, 19, 2):
    summe = 0
    summe = summe + i
    print("Summe:", summe)
  1. Führe das Programm aus und beschreibe, was falsch ist.
  2. Finde die drei Fehler und schreibe das Programm richtig auf.

Die Fehler:

Lösung vergleichen

Das fehlerhafte Programm gibt neun Zeilen aus: Summe: 1, Summe: 3, Summe: 5 bis Summe: 17.

  1. Zeile 1: Der Stoppwert 19 gehört nicht dazu. Die Schleife endet bei 17. Richtig ist range(1, 20, 2) (oder 21).
  2. Zeile 2: summe = 0 steht in der Schleife. Dann wird die Summe in jedem Durchlauf wieder auf 0 gesetzt. Der Startwert gehört vor die Schleife.
  3. Zeile 4: print ist eingerückt. Dann wird nach jedem Durchlauf ausgegeben statt einmal am Ende.
summe = 0
for i in range(1, 20, 2):
    summe = summe + i
print("Summe:", summe)
Summe: 100

Solche Fehler nennt man logische Fehler: Python meldet nichts, aber das Ergebnis stimmt nicht. Man findet sie nur, wenn man das erwartete Ergebnis kennt und vergleicht.

Arbeitsauftrag 63: Ablaufprotokoll: Abziehen ●●○

Fülle das Ablaufprotokoll zu dem Programm aus. Trage nach jedem Schritt die Werte von i und wert ein (– bedeutet: noch kein Wert). Gib dann an, was das Programm ausgibt.

wert = 10
for i in range(2, 8, 2):
    wert = wert - i
print("wert =", wert)
Schritt Zeile Anweisung i wert
1 1 wert = 10
2 2 for i in range(2, 8, 2):
3 3 wert = wert - i
4 2 for i in range(2, 8, 2):
5 3 wert = wert - i
6 2 for i in range(2, 8, 2):
7 3 wert = wert - i
8 2 for i in range(2, 8, 2):
9 4 print("wert =", wert)

Ausgabe:

Lösung vergleichen
Schritt Zeile Anweisung i wert
1 1 wert = 10 – 10
2 2 for i in range(2, 8, 2): 2 10
3 3 wert = wert - i 2 8
4 2 for i in range(2, 8, 2): 4 8
5 3 wert = wert - i 4 4
6 2 for i in range(2, 8, 2): 6 4
7 3 wert = wert - i 6 -2
8 2 for i in range(2, 8, 2): 6 -2
9 4 print("wert =", wert) 6 -2
wert = -2

range(2, 8, 2) liefert 2, 4 und 6. Die 8 ist der Stoppwert und gehört nicht dazu. Abgezogen werden also 2 + 4 + 6 = 12, und 10 − 12 = −2. Im Schritt 8 liefert range keine Zahl mehr, die Schleife endet.

Arbeitsauftrag 64: Sparschwein ●●○

Im Sparschwein liegt schon ein Startbetrag. Jede Woche kommt derselbe Betrag dazu. Schreibe ein Programm, das den Startbetrag, den Betrag pro Woche und die Anzahl der Wochen (alles ganze Zahlen) einliest. Es soll für jede Woche den Stand ausgeben.

So könnte es aussehen:

Startbetrag in Euro: «10»
Betrag pro Woche in Euro: «3»
Wie viele Wochen? «4»
Nach Woche 1 sind 13 Euro im Sparschwein.
Nach Woche 2 sind 16 Euro im Sparschwein.
Nach Woche 3 sind 19 Euro im Sparschwein.
Nach Woche 4 sind 22 Euro im Sparschwein.
Lösung vergleichen
stand = int(input("Startbetrag in Euro: "))
pro_woche = int(input("Betrag pro Woche in Euro: "))
wochen = int(input("Wie viele Wochen? "))
for woche in range(1, wochen + 1):
    stand = stand + pro_woche
    print("Nach Woche", woche, "sind", stand, "Euro im Sparschwein.")
Startbetrag in Euro: «10»
Betrag pro Woche in Euro: «3»
Wie viele Wochen? «4»
Nach Woche 1 sind 13 Euro im Sparschwein.
Nach Woche 2 sind 16 Euro im Sparschwein.
Nach Woche 3 sind 19 Euro im Sparschwein.
Nach Woche 4 sind 22 Euro im Sparschwein.

stand funktioniert wie eine Summenvariable. Sie startet aber nicht bei 0, sondern beim Startbetrag. Die Zählvariable heißt hier woche, damit man sieht, wofür sie steht. Damit die letzte Woche dabei ist, ist der Stoppwert wochen + 1. Weil print eingerückt ist, wird der Stand nach jeder Woche ausgegeben.

Arbeitsauftrag 65: Notendurchschnitt ●●●

Schreibe ein Programm, das zuerst einliest, wie viele Noten es gibt. Danach soll es mit einer for-Schleife jede Note einzeln einlesen. Am Ende soll es die Summe der Noten und den Durchschnitt ausgeben, auf zwei Nachkommastellen gerundet.

Teste mit den Noten 2, 3, 1 und 2 (Durchschnitt 2.0) und mit 2, 2 und 1 (Durchschnitt 1.67). Was passiert, wenn du am Anfang 0 eingibst? Verbessere dein Programm so, dass es dann eine Meldung ausgibt, statt abzubrechen.

Tipp

Die Eingabe der einzelnen Noten gehört in den Schleifenrumpf. Dann wird sie in jedem Durchlauf neu ausgeführt. Den Durchschnitt berechnest du nach der Schleife: Summe geteilt durch Anzahl.

Lösung vergleichen
anzahl = int(input("Wie viele Noten? "))
summe = 0
for i in range(anzahl):
    note = float(input("Nächste Note: "))
    summe = summe + note
print("Summe:", summe)
if anzahl > 0:
    print("Durchschnitt:", round(summe / anzahl, 2))
else:
    print("Ohne Noten gibt es keinen Durchschnitt.")
Wie viele Noten? «3»
Nächste Note: «2»
Nächste Note: «2»
Nächste Note: «1»
Summe: 5.0
Durchschnitt: 1.67
  • Zeile 3: range(anzahl) sorgt für genau anzahl Durchläufe. Die Zählvariable i wird im Rumpf nicht gebraucht.
  • Zeilen 4–5: In jedem Durchlauf wird eine Note eingelesen und zur Summe addiert.
  • Zeilen 7–10: Bei anzahl = 0 läuft die Schleife gar nicht, und summe / anzahl würde durch 0 teilen. Ohne die Verzweigung bricht das Programm mit einem ZeroDivisionError ab.

Eine for-Schleife passt hier, weil die Anzahl der Noten schon vor der Schleife feststeht.

1.5.7Das Wichtigste in Kürze

Selbstcheck

1.6Die while-Schleife: Wiederholen, solange eine Bedingung gilt DS06

Diesen Abschnitt als PDF (S. 82–97)

Das Jupyter-Notebook aus dem Unterricht: DS06_while_Schleife.ipynb. Herunterladen und in VS Code oder Jupyter öffnen.

Zum Weiterüben: DS06_Weitere_Uebungen.ipynb mit den Aufgaben aus „Weitere Übungen“ zum Bearbeiten in Python.

Leitidee

Mit der for-Schleife wiederholst du Anweisungen eine feste Anzahl von Malen. Oft weiß man aber vorher nicht, wie viele Wiederholungen nötig sind. Beim „Mensch ärgere dich nicht“ würfelst du, bis eine Sechs kommt – das kann einmal dauern oder zehnmal. Ein Geldautomat fragt die PIN ab, solange sie falsch ist. Für solche Fälle gibt es die while-Schleife. Sie prüft vor jedem Durchlauf eine Bedingung und hört auf, sobald die Bedingung nicht mehr erfüllt ist. In diesem Abschnitt lernst du, wie man sie schreibt, wie man gefährliche Endlosschleifen vermeidet und wann man besser for und wann besser while verwendet.

Lernziele

Nach diesem Abschnitt kannst du

1.6.1Wiederholen, solange eine Bedingung wahr ist

Das Wort while ist englisch und heißt „solange“. Eine while-Schleife sagt: „Solange die Bedingung wahr ist, führe den Rumpf aus.“ Die Bedingung kennst du schon von if: Es ist ein Ausdruck, der True oder False ergibt, zum Beispiel i <= 3 oder eingabe != "stopp".

Das erste Beispiel zählt von 1 bis 3 – das könnte die for-Schleife auch, aber so siehst du gut, wie die while-Schleife arbeitet:

i = 1
while i <= 3:
    print(i)
    i = i + 1
print("Ende")
1
2
3
Ende

Das Ablaufprotokoll zeigt, wie Python nach dem Rumpf immer wieder zur Bedingung in Zeile 2 zurückspringt:

Schritt Zeile Anweisung i
1 1 i = 1 1
2 2 while i <= 3: 1
3 3 print(i) 1
4 4 i = i + 1 2
5 2 while i <= 3: 2
6 3 print(i) 2
7 4 i = i + 1 3
8 2 while i <= 3: 3
9 3 print(i) 3
10 4 i = i + 1 4
11 2 while i <= 3: 4
12 5 print("Ende") 4

Im Schritt 11 hat i den Wert 4. Die Bedingung 4 <= 3 ist falsch. Die Schleife endet, und Python macht mit Zeile 5 weiter. Am Ende hat i also den Wert 4, obwohl zuletzt 3 ausgegeben wurde.

Definition: while-Schleife

Eine while-Schleife (bedingte Schleife) wiederholt ihren Schleifenrumpf, solange eine Bedingung wahr ist. Die Bedingung wird vor jedem Durchlauf geprüft. Ist sie schon beim ersten Mal falsch, wird der Rumpf kein einziges Mal ausgeführt.

Merke

Der Ablauf als Bild

Den Ablauf einer Schleife kann man auch zeichnen. In einem Programmablaufplan stehen Bedingungen in Rauten und Anweisungen in Rechtecken. Pfeile zeigen, in welcher Reihenfolge es weitergeht. Bei einer Schleife führt ein Pfeil vom Rumpf zurück zur Bedingung – daher der Name „Schleife“.

Programmablaufplan der while-Schleife aus dem Beispiel: Solange die Bedingung in der Raute wahr ist (ja), wird der Rumpf ausgeführt und danach die Bedingung erneut geprüft

1.6.2Beispiel: Zahlen addieren, bis 0 eingegeben wird

Jetzt ein Beispiel, bei dem die for-Schleife nicht weiterhilft. Das Programm soll beliebig viele Zahlen addieren. Wie viele es sind, entscheidet die Nutzerin oder der Nutzer beim Eintippen: Die Eingabe 0 beendet die Schleife.

summe = 0
zahl = int(input("Zahl eingeben (0 zum Beenden): "))

while zahl != 0:
    summe = summe + zahl
    zahl = int(input("Zahl eingeben (0 zum Beenden): "))

print("Summe aller Eingaben:", summe)
Zahl eingeben (0 zum Beenden): «4»
Zahl eingeben (0 zum Beenden): «7»
Zahl eingeben (0 zum Beenden): «2»
Zahl eingeben (0 zum Beenden): «0»
Summe aller Eingaben: 13

Das Ablaufprotokoll für die Eingaben 4, 7, 2, 0:

Schritt Zeile zahl summe
1 1 – 0
2 2 4 0
3 4 4 0
4 5 4 4
5 6 7 4
6 4 7 4
7 5 7 11
8 6 2 11
9 4 2 11
10 5 2 13
11 6 0 13
12 4 0 13
13 8 0 13

Im Schritt 12 ist zahl gleich 0. Die Bedingung 0 != 0 ist falsch, die Schleife endet. Die 0 selbst wird nicht mehr addiert (das würde aber auch nichts ändern).

Tipp

Das Muster aus diesem Beispiel brauchst du immer wieder, wenn eine Schleife von Eingaben abhängt:

  1. vor der Schleife die erste Eingabe einlesen,
  2. im Kopf die Eingabe prüfen,
  3. am Ende des Rumpfs die nächste Eingabe einlesen.
Versuch: Probiere es aus

Starte das Programm und gib gleich als Erstes 0 ein. Was passiert? Erkläre mit der Definition der while-Schleife, warum der Rumpf kein einziges Mal ausgeführt wird.

1.6.3Endlosschleifen

In der while-Schleife bist du dafür verantwortlich, dass die Bedingung irgendwann falsch wird. Vergisst du das, hört die Schleife nie auf. Hier soll ein Countdown von 3 herunterzählen. Findest du den Fehler?

zahl = 3
while zahl > 0:
    print(zahl)
    zahl = zahl + 1
print("Start!")
3
4
5
6
7
...

In Zeile 4 wird zahl erhöht statt verringert. Die Zahl wird also immer größer, und zahl > 0 bleibt für immer wahr. Das Programm gibt endlos Zahlen aus und erreicht print("Start!") nie. Richtig wäre zahl = zahl - 1.

Definition: Endlosschleife

Eine Endlosschleife ist eine Schleife, deren Bedingung nie falsch wird. Sie terminiert nicht, das heißt: Sie endet nie von selbst.

Woran erkennst du eine Endlosschleife? Das Programm wird nicht fertig. Entweder läuft die Ausgabe immer weiter, oder es passiert scheinbar gar nichts mehr (die Schleife läuft dann ohne Ausgabe). In Jupyter steht links neben deinem Programm lange ein Sternchen [*].

Wie brichst du sie ab? In Jupyter klickst du oben auf die Stopp-Schaltfläche (ein kleines Quadrat). In Thonny klickst du auf den roten Stopp-Knopf. In einem Terminal drückst du Strg + C. Python bricht dann mit dieser Meldung ab:

KeyboardInterrupt

KeyboardInterrupt heißt „Unterbrechung über die Tastatur“. Das ist kein Fehler in deinem Code, sondern nur die Bestätigung, dass du das Programm angehalten hast. Den eigentlichen Fehler musst du danach selbst suchen.

Merke

Die Bedingung muss sich innerhalb der Schleife verändern können, sonst entsteht eine Endlosschleife.

Stolperstein

So findest du die Ursache einer Endlosschleife:

  1. Welche Variablen stehen in der Bedingung?
  2. Wird mindestens eine davon im Rumpf verändert? Typische vergessene Zeilen sind i = i + 1 oder ein neues input(...) am Ende des Rumpfs.
  3. Wird sie in die richtige Richtung verändert, sodass die Bedingung irgendwann falsch wird?
  4. Steht die Änderung wirklich eingerückt im Rumpf und nicht erst nach der Schleife?

1.6.4Eingaben prüfen: Wiederholen, bis die Eingabe stimmt

Eine typische Aufgabe für die while-Schleife: Ein Programm soll so lange nachfragen, bis eine gültige Eingabe kommt. Wie oft sich jemand vertippt, weiß man vorher nicht. Das folgende Programm akzeptiert nur Schulnoten von 1 bis 6:

note = int(input("Gib deine Note ein (1 bis 6): "))
while note < 1 or note > 6:
    print("Ungültig! Erlaubt sind nur 1 bis 6.")
    note = int(input("Gib deine Note ein (1 bis 6): "))
print("Gespeichert: Note", note)
Gib deine Note ein (1 bis 6): «8»
Ungültig! Erlaubt sind nur 1 bis 6.
Gib deine Note ein (1 bis 6): «0»
Ungültig! Erlaubt sind nur 1 bis 6.
Gib deine Note ein (1 bis 6): «2»
Gespeichert: Note 2
Tipp

Beim Formulieren der Bedingung hilft die Frage: „Wann muss ich noch einmal fragen?“ Die Antwort ist die Bedingung der while-Schleife. Hier: „wenn die Note kleiner als 1 oder größer als 6 ist“.

1.6.5Zufallszahlen

Bei Spielen braucht man oft den Zufall: einen Würfelwurf oder eine geheime Zahl, die sich das Programm selbst ausdenkt. Dafür gibt es in Python ein Zusatzmodul.

Werkzeug: Zufallszahlen mit random.randint

Das Modul random ist eine Sammlung von Befehlen rund um den Zufall. Damit du es benutzen kannst, schreibst du einmal am Anfang des Programms import random. Danach liefert random.randint(a, b) eine zufällige ganze Zahl von a bis b. Anders als bei range gehören hier beide Grenzen dazu: random.randint(1, 6) liefert 1, 2, 3, 4, 5 oder 6 – wie ein Würfel.

Das folgende Programm würfelt so lange, bis eine Sechs fällt, und zählt die Würfe. Wie oft gewürfelt wird, entscheidet der Zufall – ein klarer Fall für while:

import random

wurf = random.randint(1, 6)
anzahl = 1
print("Gewürfelt:", wurf)
while wurf != 6:
    wurf = random.randint(1, 6)
    anzahl += 1
    print("Gewürfelt:", wurf)
print("Endlich eine Sechs! Anzahl der Würfe:", anzahl)

So könnte es aussehen (bei jedem Start kommt etwas anderes heraus):

Gewürfelt: 4
Gewürfelt: 1
Gewürfelt: 6
Endlich eine Sechs! Anzahl der Würfe: 3
So kannst du es sagen

So beschreibst du eine while-Schleife in Fachsprache – vom einfachen zum genauen Satz:

1.6.6for oder while?

Viele Aufgaben kann man mit beiden Schleifenarten lösen. Das Zählen von 1 bis 3 sieht mit for und while so aus:

for i in range(1, 4):
    print(i)
1
2
3
i = 1
while i <= 3:
    print(i)
    i = i + 1
1
2
3

Beide Programme geben dasselbe aus. Die for-Schleife ist aber kürzer und sicherer: Startwert, Bedingung und Erhöhung stecken alle in range(1, 4). Bei der while-Schleife musst du an alle drei selbst denken – vergisst du die Erhöhung, entsteht eine Endlosschleife. Umgekehrt eignet sich die for-Schleife nicht für Aufgaben wie „würfle bis zur Sechs“, weil range eine feste Anzahl braucht.

Bei der Wahl hilft eine einzige Frage: Steht beim Start der Schleife fest, wie oft wiederholt wird? Das ist auch dann der Fall, wenn die Anzahl vorher eingegeben wurde, zum Beispiel bei „Summe von 1 bis n“.

Situation Schleife Begründung
Zahlen von 1 bis 100 ausgeben for genau 100 Durchläufe
Summe von 1 bis n, n wird eingegeben for beim Start der Schleife steht n fest
Zahlen addieren, bis 0 eingegeben wird while Ende hängt von der Eingabe ab
Eingabe wiederholen, bis sie gültig ist while Anzahl der Fehlversuche unbekannt
würfeln, bis eine Sechs fällt while Ende hängt vom Zufall ab
Ziffern einer Zahl einzeln abarbeiten while so lange, bis keine Ziffer mehr übrig ist
Merke

Faustregel: Ist die Anzahl der Durchläufe vorher bekannt → for. Hängt das Ende von einer Bedingung oder Eingabe ab → while.

Arbeitsauftrag 66: for oder while?

Entscheide jeweils, ob eine for- oder eine while-Schleife besser passt, und begründe kurz. (Du musst die Programme nicht schreiben.)

Situation for oder while?
a) 20-mal „Hallo“ ausgeben
b) Wörter einlesen, bis „stopp“ eingegeben wird
c) das Einmaleins einer eingegebenen Zahl ausgeben
d) ein Guthaben von 100 € wächst jedes Jahr um 5 %: Nach wie vielen Jahren sind es mindestens 200 €?

Begründungen zu a) bis d):

Lösung vergleichen
Situation Schleife Begründung
a) 20-mal „Hallo“ for Die Anzahl 20 steht fest.
b) Wörter bis „stopp“ while Wie viele Wörter kommen, entscheidet die Eingabe.
c) Einmaleins for Es sind immer 10 Zeilen, die Zahl steht vor der Schleife fest.
d) Guthaben verdoppeln while Wie viele Jahre nötig sind, soll ja erst herausgefunden werden. Die Schleife läuft, solange das Guthaben unter 200 € liegt.

Entscheidend ist immer die Frage, ob die Anzahl der Durchläufe beim Start der Schleife schon feststeht.

1.6.7Übungen

Arbeitsauftrag 67: Zahl erraten

Lege eine geheime Zahl im Code fest (z. B. geheim = 42). Die Nutzerin oder der Nutzer soll so lange raten dürfen, bis die richtige Zahl eingegeben wurde. Gib nach jedem Versuch „zu hoch“ oder „zu niedrig“ aus.

Tipp

Nutze das Muster aus dem Abschnitt über das Addieren von Eingaben: erste Eingabe vor der Schleife, Bedingung „Zahl ist noch nicht richtig“, neue Eingabe am Ende des Rumpfs. Für „zu hoch“ oder „zu niedrig“ brauchst du im Rumpf eine Verzweigung mit if und else.

Lösung vergleichen
geheim = 42
versuch = int(input("Rate die Zahl: "))
while versuch != geheim:
    if versuch < geheim:
        print("zu niedrig")
    else:
        print("zu hoch")
    versuch = int(input("Rate die Zahl: "))
print("Richtig geraten!")
Rate die Zahl: «50»
zu hoch
Rate die Zahl: «30»
zu niedrig
Rate die Zahl: «42»
Richtig geraten!

Die Schleife läuft, solange der Versuch nicht die geheime Zahl ist. Im Rumpf entscheidet die Verzweigung, welcher Hinweis ausgegeben wird. Zeile 8 liest den nächsten Versuch ein – fehlt sie, wird der erste Versuch immer wieder geprüft, und es entsteht eine Endlosschleife. Die if-Anweisung ist eine Stufe tiefer eingerückt als while, ihre Rümpfe noch eine Stufe tiefer.

Teste dein Programm mit einer zu großen Zahl, einer zu kleinen Zahl und der richtigen Zahl. Teste auch, was passiert, wenn du sofort richtig rätst: Dann wird der Rumpf nie ausgeführt, und es kommt gleich „Richtig geraten!“.

Arbeitsauftrag 68: Ratespiel mit Zufallszahl

Erweitere dein Programm aus dem Auftrag Zahl erraten:

  1. Die geheime Zahl soll mit random.randint zufällig zwischen 1 und 100 gewählt werden.
  2. Das Programm soll die Versuche zählen und am Ende ausgeben, wie viele Versuche gebraucht wurden.

Schreibe nur die Zeilen auf, die du ergänzt oder änderst, und gib jeweils an, wo sie stehen.

Lösung vergleichen
import random

geheim = random.randint(1, 100)
versuch = int(input("Rate die Zahl zwischen 1 und 100: "))
anzahl = 1
while versuch != geheim:
    if versuch < geheim:
        print("zu niedrig")
    else:
        print("zu hoch")
    versuch = int(input("Rate die Zahl zwischen 1 und 100: "))
    anzahl += 1
print("Richtig geraten nach", anzahl, "Versuchen!")

So könnte es aussehen (die geheime Zahl war hier 18):

Rate die Zahl zwischen 1 und 100: «50»
zu hoch
Rate die Zahl zwischen 1 und 100: «25»
zu hoch
Rate die Zahl zwischen 1 und 100: «12»
zu niedrig
Rate die Zahl zwischen 1 und 100: «18»
Richtig geraten nach 4 Versuchen!

Neu oder geändert sind die Zeilen 1, 3, 5, 12 und 13. In den Zeilen 4 und 11 wurde nur der Fragetext ergänzt; das ist freiwillig. import random steht ganz oben. Der Zähler anzahl beginnt bei 1, weil der erste Versuch schon vor der Schleife eingelesen wird. Bei jedem weiteren Versuch im Rumpf wird er um 1 erhöht. Zum Testen kannst du die geheime Zahl vorübergehend mit print(geheim) ausgeben lassen und diese Zeile danach wieder löschen.

Arbeitsauftrag 69: Quersumme

Berechne mit einer while-Schleife die Quersumme einer eingegebenen Zahl (z. B. ist die Quersumme von 384 gleich 3 + 8 + 4 = 15).

Tipp: zahl % 10 liefert die letzte Ziffer, zahl // 10 entfernt sie.

Tipp

Probiere die beiden Rechenzeichen zuerst einzeln aus: 384 % 10 ergibt 4 (der Rest beim Teilen durch 10), 384 // 10 ergibt 38. Wiederholst du das mit 38, bekommst du 8 und 3. Und mit 3 bekommst du 3 und 0. Bei 0 ist keine Ziffer mehr übrig – das ist deine Abbruchbedingung.

Lösung vergleichen
zahl = int(input("Zahl eingeben: "))
quersumme = 0
while zahl > 0:
    quersumme = quersumme + zahl % 10
    zahl = zahl // 10
print("Quersumme:", quersumme)
Zahl eingeben: «384»
Quersumme: 15

In jedem Durchlauf wird die letzte Ziffer zur Quersumme addiert (Zeile 4) und dann abgeschnitten (Zeile 5). Die Schleife läuft, solange noch Ziffern übrig sind, also solange zahl > 0 ist. Weil zahl in jedem Durchlauf kleiner wird, terminiert die Schleife sicher. Das Ablaufprotokoll für die Eingabe 384:

Schritt Zeile zahl quersumme
1 1 384 –
2 2 384 0
3 3 384 0
4 4 384 4
5 5 38 4
6 3 38 4
7 4 38 12
8 5 3 12
9 3 3 12
10 4 3 15
11 5 0 15
12 3 0 15
13 6 0 15

Eine while-Schleife passt hier, weil die Anzahl der Ziffern nicht direkt bekannt ist. Weitere Testfälle: Quersumme von 7 ist 7, von 1000 ist 1, von 99999 ist 45. Bei der Eingabe 0 wird der Rumpf nicht ausgeführt, die Quersumme ist 0.

Arbeitsauftrag 70 (Zusatz): Endlosschleife erkennen

Der folgende Code enthält eine Endlosschleife. Finde den Fehler und korrigiere ihn. Ändere nicht die Bedingung i < 10, sondern behebe den eigentlichen Fehler im Schleifenrumpf.

i = 0
while i < 10:
    print(i)

Die Fehler:

Lösung vergleichen

Im Rumpf wird i nie verändert. i bleibt 0, die Bedingung 0 < 10 ist immer wahr, und das Programm gibt endlos 0 aus. Es fehlt die Erhöhung von i im Rumpf:

i = 0
while i < 10:
    print(i)
    i = i + 1
0
1
2
3
4
5
6
7
8
9

Die neue Zeile muss eingerückt sein. Stünde i = i + 1 ohne Einrückung unter der Schleife, wäre es immer noch eine Endlosschleife. Statt i = i + 1 kann man auch i += 1 schreiben.

1.6.8Weitere Übungen

Hier kannst du das Gelernte weiter üben. Die Punkte im Titel zeigen, wie schwer eine Aufgabe ist: ●○○ leicht, ●●○ mittel, ●●● knifflig. Fang mit den leichten an.

Arbeitsauftrag 71: In Viererschritten ●○○

Lies das Programm, ohne es auszuführen.

  1. Schreibe auf, was es ausgibt.
  2. Gib an, wie oft der Schleifenrumpf ausgeführt wird und welchen Wert zahl am Ende hat.
zahl = 20
while zahl > 5:
    print(zahl)
    zahl = zahl - 4
print("fertig")

Meine Antworten:

Lösung vergleichen
20
16
12
8
fertig

Der Rumpf wird viermal ausgeführt. Danach hat zahl den Wert 4. Die Bedingung 4 > 5 ist falsch, die Schleife endet. Die 4 wird nicht mehr ausgegeben, denn die Bedingung wird vor dem Rumpf geprüft. Wer fertig vergessen hat: Zeile 5 ist nicht eingerückt und wird nach der Schleife einmal ausgeführt.

Arbeitsauftrag 72: Countdown ●○○

Das Programm soll eine Startzahl einlesen und von dort bis 1 herunterzählen. Danach soll es „Start!“ ausgeben. Ergänze die beiden Lücken ___ und teste mit 5 und mit 0.

zahl = int(input("Starte bei: "))
while ___:
    print(zahl)
    ___
print("Start!")
Lösung vergleichen
zahl = int(input("Starte bei: "))
while zahl > 0:
    print(zahl)
    zahl = zahl - 1
print("Start!")
Starte bei: «5»
5
4
3
2
1
Start!

Die Zahl muss im Rumpf kleiner werden, sonst bleibt die Bedingung immer wahr. Auch zahl >= 1 ist als Bedingung richtig. Bei der Eingabe 0 ist die Bedingung schon beim ersten Prüfen falsch: Der Rumpf wird nie ausgeführt, und es erscheint nur Start!.

Arbeitsauftrag 73: Anzahl der Spieler ●○○

Ein Brettspiel ist für 2 bis 4 Personen. Schreibe ein Programm, das die Anzahl der Spielerinnen und Spieler so lange abfragt, bis eine gültige Zahl eingegeben wird. Bei einer ungültigen Eingabe soll es einen Hinweis ausgeben. Am Ende soll es Das Spiel startet mit 3 Personen. ausgeben (mit der eingegebenen Zahl).

Lösung vergleichen
anzahl = int(input("Wie viele spielen mit? "))
while anzahl < 2 or anzahl > 4:
    print("Das Spiel ist für 2 bis 4 Personen.")
    anzahl = int(input("Wie viele spielen mit? "))
print("Das Spiel startet mit", anzahl, "Personen.")
Wie viele spielen mit? «6»
Das Spiel ist für 2 bis 4 Personen.
Wie viele spielen mit? «1»
Das Spiel ist für 2 bis 4 Personen.
Wie viele spielen mit? «3»
Das Spiel startet mit 3 Personen.

Die Bedingung beschreibt, wann noch einmal gefragt werden muss: bei weniger als 2 oder mehr als 4 Personen. Mit and wäre die Bedingung nie wahr. Teste auch die Grenzwerte 2 und 4 (gültig) sowie 1 und 5 (ungültig).

Arbeitsauftrag 74: Endlosschleife oder nicht? ●●○

Entscheide für jedes Programm, ob die Schleife irgendwann endet oder ob eine Endlosschleife entsteht. Begründe kurz. Führe die Programme nicht aus.

i = 1
while i < 5:
    i = i + 1
i = 10
while i > 0:
    i = i + 1
i = 1
while i != 10:
    i = i + 2
i = 0
while i < 3:
    print(i)
i = i + 1

Meine Entscheidungen und Begründungen:

Lösung vergleichen
    1. Endet. i wird größer und erreicht nach vier Durchläufen den Wert 5. Dann ist 5 < 5 falsch.
    1. Endlosschleife. i wird größer statt kleiner. Damit bleibt i > 0 immer wahr.
    1. Endlosschleife. i nimmt die Werte 1, 3, 5, 7, 9, 11, … an. Die 10 wird übersprungen, deshalb ist i != 10 immer wahr. Mit der Bedingung i < 10 würde die Schleife enden.
    1. Endlosschleife. i = i + 1 ist nicht eingerückt und gehört nicht zum Rumpf. Im Rumpf steht nur print(i), und es wird endlos 0 ausgegeben.

Fall c) zeigt: Eine Bedingung mit != ist gefährlich, wenn die Variable in größeren Schritten springt. Sie kann den Wert, bei dem die Schleife enden soll, „überspringen“.

Arbeitsauftrag 75: Fehler finden: Wörter zählen ●●○

Das Programm soll so lange Wörter einlesen, bis stopp eingegeben wird. Danach soll es ausgeben, wie viele Wörter eingegeben wurden (ohne stopp). Es enthält drei Fehler.

anzahl = 0
wort = input("Wort (stopp zum Beenden): ")
while wort == "stopp":
    anzahl = anzahl + 1
wort = input("Wort (stopp zum Beenden): ")
print("Du hast", anzahl "Wörter eingegeben.")
  1. Finde die drei Fehler. Notiere jeweils die Zeile und was falsch ist.
  2. Schreibe das Programm richtig auf. Teste es mit den Eingaben Hund, Katze, Maus, stopp und auch mit sofort stopp.

Die Fehler:

Lösung vergleichen
  1. Zeile 3: Die Bedingung ist umgekehrt. Die Schleife soll laufen, solange das Wort nicht stopp ist: wort != "stopp".
  2. Zeile 5: Die nächste Eingabe ist nicht eingerückt und gehört nicht zum Rumpf. Dann ändert sich wort in der Schleife nie, und es entsteht eine Endlosschleife.
  3. Zeile 6: Zwischen anzahl und dem Text fehlt ein Komma (SyntaxError).
anzahl = 0
wort = input("Wort (stopp zum Beenden): ")
while wort != "stopp":
    anzahl = anzahl + 1
    wort = input("Wort (stopp zum Beenden): ")
print("Du hast", anzahl, "Wörter eingegeben.")
Wort (stopp zum Beenden): «Hund»
Wort (stopp zum Beenden): «Katze»
Wort (stopp zum Beenden): «Maus»
Wort (stopp zum Beenden): «stopp»
Du hast 3 Wörter eingegeben.

Wird sofort stopp eingegeben, läuft der Rumpf nie, und das Programm gibt Du hast 0 Wörter eingegeben. aus. Das ist richtig so.

Arbeitsauftrag 76: Ablaufprotokoll: Stellen zählen ●●○

Das Programm zählt, wie viele Stellen eine Zahl hat. Fülle das Ablaufprotokoll aus (– bedeutet: noch kein Wert) und gib an, was das Programm ausgibt.

zahl = 4096
stellen = 0
while zahl > 0:
    zahl = zahl // 10
    stellen = stellen + 1
print("Stellen:", stellen)
Schritt Zeile zahl stellen Schritt Zeile zahl stellen
1 1 9 3
2 2 10 4
3 3 11 5
4 4 12 3
5 5 13 4
6 3 14 5
7 4 15 3
8 5 16 6

Ausgabe:

Lösung vergleichen
Schritt Zeile zahl stellen Schritt Zeile zahl stellen
1 1 4096 – 9 3 40 2
2 2 4096 0 10 4 4 2
3 3 4096 0 11 5 4 3
4 4 409 0 12 3 4 3
5 5 409 1 13 4 0 3
6 3 409 1 14 5 0 4
7 4 40 1 15 3 0 4
8 5 40 2 16 6 0 4
Stellen: 4

zahl // 10 schneidet in jedem Durchlauf die letzte Ziffer ab: aus 4096 wird 409, dann 40, dann 4, dann 0. Für jede abgeschnittene Ziffer wird stellen um 1 erhöht. Bei 0 ist keine Ziffer mehr übrig, und die Schleife endet. Das ist dasselbe Vorgehen wie beim Auftrag Quersumme.

Arbeitsauftrag 77: Papier falten ●●○

Ein Blatt Papier ist etwa 0,1 mm dick. Faltet man es einmal, ist der Stapel doppelt so dick. Stell dir vor, man könnte das Blatt beliebig oft falten.

  1. Schreibe ein Programm, das berechnet, wie oft man falten müsste, bis der Stapel mindestens 1 Meter (1000 mm) dick ist. Gib die Anzahl der Faltungen und die Dicke aus.
  2. Begründe, warum hier eine while-Schleife passt.

Begründung:

Lösung vergleichen
dicke = 0.1
faltungen = 0
while dicke < 1000:
    dicke = dicke * 2
    faltungen = faltungen + 1
print("Nach", faltungen, "Faltungen ist der Stapel",
      round(dicke, 1), "mm dick.")
Nach 14 Faltungen ist der Stapel 1638.4 mm dick.

faltungen zählt die Durchläufe und startet bei 0. Im Rumpf wird die Dicke verdoppelt und die Faltung gezählt. Nach 13 Faltungen sind es erst 819,2 mm, deshalb ist noch eine 14. Faltung nötig.

  1. Eine while-Schleife passt, weil die Anzahl der Faltungen gerade das ist, was gesucht wird. Sie steht vor der Schleife nicht fest. Die Schleife läuft, solange der Stapel dünner als 1000 mm ist. Sie terminiert, weil die Dicke in jedem Durchlauf wächst.
Arbeitsauftrag 78: Die 3n+1-Folge ●●●

Mit einer Startzahl wird immer wieder so gerechnet:

Das wird wiederholt, bis die Zahl 1 erreicht ist. Aus 6 wird zum Beispiel 3, dann 10, 5, 16, 8, 4, 2 und 1. Das sind 8 Schritte.

  1. Schreibe ein Programm, das eine Startzahl einliest, jede neue Zahl ausgibt und am Ende die Anzahl der Schritte. Teste mit 6 und mit 7.
  2. Was passiert bei der Startzahl 0? Erkläre.

Zu 2.:

Lösung vergleichen
zahl = int(input("Startzahl: "))
schritte = 0
while zahl != 1:
    if zahl % 2 == 0:
        zahl = zahl // 2
    else:
        zahl = 3 * zahl + 1
    print(zahl)
    schritte = schritte + 1
print("Schritte:", schritte)
Startzahl: «6»
3
10
5
16
8
4
2
1
Schritte: 8
  • Zeile 3: Die Schleife läuft, solange die 1 noch nicht erreicht ist. Wie viele Schritte das sind, weiß man vorher nicht, deshalb while.
  • Zeilen 4–7: Im Rumpf steht eine Verzweigung. zahl % 2 == 0 prüft, ob die Zahl gerade ist. Zum Halbieren nimmt man //, damit die Zahl ganz bleibt.
  • Zeilen 8–9: Die neue Zahl wird ausgegeben und der Schritt gezählt. Beide Zeilen gehören zur Schleife, aber nicht mehr zur Verzweigung.

Mit der Startzahl 7 braucht das Programm 16 Schritte, die größte Zahl unterwegs ist 52.

  1. Bei 0 entsteht eine Endlosschleife. 0 ist gerade, und 0 // 2 ergibt wieder 0. Die Zahl wird also nie 1, und das Programm gibt endlos 0 aus. Abhilfe: Vorher mit einer while-Schleife prüfen, dass die Startzahl mindestens 1 ist.

1.6.9Das Wichtigste in Kürze

Selbstcheck

1.7Übung: for- oder while-Schleife? DS07

Diesen Abschnitt als PDF (S. 98–106)

Das Jupyter-Notebook aus dem Unterricht: DS07_Uebung_Schleifen.ipynb. Herunterladen und in VS Code oder Jupyter öffnen.

Zum Weiterüben: DS07_Weitere_Uebungen.ipynb mit den Aufgaben aus „Weitere Übungen“ zum Bearbeiten in Python.

Leitidee

Du kennst jetzt zwei Arten von Schleifen: die for-Schleife und die while-Schleife. In diesem Abschnitt übst du, beide sicher einzusetzen. Dabei geht es nicht nur um das Programmieren selbst. Bei jeder Aufgabe überlegst du zuerst, welche Schleifenart besser passt, und begründest deine Wahl. Erst dann schreibst du das Programm. Diese Entscheidung zu treffen, ist eine wichtige Fähigkeit beim Programmieren – sie macht Programme kürzer und schützt vor Endlosschleifen.

Lernziele

Nach diesem Abschnitt kannst du

1.7.1Das brauchst du

Die beiden Schleifenarten im Vergleich:

for-Schleife while-Schleife
Wann? Anzahl der Durchläufe steht beim Start fest Ende hängt von einer Bedingung ab
Kopf for i in range(1, 6): while zahl != 0:
Startwert steckt in range vor der Schleife selbst setzen
Veränderung automatisch im Rumpf selbst programmieren
Gefahr Stoppwert gehört nicht dazu Endlosschleife

So sehen die beiden Grundformen aus:

for i in range(1, 4):
    print("Durchlauf", i)

zahl = 1
while zahl < 10:
    print("zahl ist", zahl)
    zahl = zahl * 2
Durchlauf 1
Durchlauf 2
Durchlauf 3
zahl ist 1
zahl ist 2
zahl ist 4
zahl ist 8
Merke

Bei jeder Aufgabe unten gilt: Überlege zuerst, welche Schleifenart passt, bevor du programmierst!

Zwei Muster brauchst du immer wieder:

Tipp

So testest du ein Programm mit Schleife. Probiere nicht nur eine „normale“ Eingabe aus, sondern auch Grenzfälle: die kleinste erlaubte Zahl (oft 0 oder 1), eine Eingabe, bei der die Schleife gar nicht durchlaufen wird, und eine, bei der sie sehr oft läuft. Rechne das erwartete Ergebnis vorher von Hand aus und vergleiche.

1.7.2Aufträge

Arbeitsauftrag 79: Programm lesen

Lies das Programm, ohne es auszuführen.

  1. Gib an, was das Programm ausgibt.
  2. Gib an, wie oft der Schleifenrumpf ausgeführt wird.
  3. Begründe, warum hier eine while-Schleife verwendet wird.
zahl = 1
while zahl < 50:
    zahl = zahl * 3
print(zahl)

Deine Antworten:

Lösung vergleichen
81

Der Rumpf wird viermal ausgeführt. Das Ablaufprotokoll zeigt es:

Schritt Zeile Anweisung zahl
1 1 zahl = 1 1
2 2 while zahl < 50: 1
3 3 zahl = zahl * 3 3
4 2 while zahl < 50: 3
5 3 zahl = zahl * 3 9
6 2 while zahl < 50: 9
7 3 zahl = zahl * 3 27
8 2 while zahl < 50: 27
9 3 zahl = zahl * 3 81
10 2 while zahl < 50: 81
11 4 print(zahl) 81

Die Ausgabe ist 81, nicht etwa eine Zahl unter 50: Die Bedingung wird erst nach dem Verdreifachen wieder geprüft. Bei 27 ist sie noch wahr, also wird ein weiteres Mal verdreifacht. Eine while-Schleife passt, weil man nicht von vornherein weiß, wie oft man verdreifachen muss, bis die Zahl 50 erreicht. Die Schleife terminiert, weil zahl in jedem Durchlauf größer wird.

Fakultät

In der Mathematik schreibt man n!n! (gesprochen „n Fakultät“) für das Produkt aller ganzen Zahlen von 1 bis nn. Zum Beispiel ist 4!=1⋅2⋅3⋅4=244! = 1 \cdot 2 \cdot 3 \cdot 4 = 24 und 5!=1⋅2⋅3⋅4⋅5=1205! = 1 \cdot 2 \cdot 3 \cdot 4 \cdot 5 = 120. Für 0!0! legt man den Wert 1 fest. Die Fakultät gibt zum Beispiel an, auf wie viele Arten man nn Personen in einer Reihe aufstellen kann.

Arbeitsauftrag 80: Fakultät

Berechne die Fakultät einer eingegebenen Zahl nn (n!=1⋅2⋅3⋅…⋅nn! = 1 \cdot 2 \cdot 3 \cdot \ldots \cdot n). Welche Schleifenart passt hier besser? Begründe deine Wahl, bevor du programmierst.

Tipp

Die Fakultät berechnest du fast wie eine Summe – nur wird multipliziert statt addiert. Überlege genau, mit welchem Wert die Produktvariable vor der Schleife starten muss. Was passiert, wenn du sie wie eine Summe mit 0 beginnen lässt?

Begründung:

Lösung vergleichen

Begründung: Eine for-Schleife passt besser. Sobald nn eingegeben ist, steht fest, dass genau nn Zahlen multipliziert werden müssen. Die Zählvariable i liefert dabei gleich die Faktoren 1, 2, …, nn.

n = int(input("n eingeben: "))
fakultaet = 1
for i in range(1, n + 1):
    fakultaet = fakultaet * i
print(str(n) + "! =", fakultaet)
n eingeben: «5»
5! = 120
  • Zeile 2: Die Produktvariable startet bei 1. Mit 0 wäre jedes Produkt 0, denn 0 mal eine beliebige Zahl ergibt 0.
  • Zeile 3: i läuft von 1 bis einschließlich nn, deshalb n + 1 als Stoppwert.
  • Zeile 4: In jedem Durchlauf wird mit dem nächsten Faktor multipliziert. Kürzer: fakultaet *= i.
  • Zeile 5: str(n) + "!" hängt das Ausrufezeichen ohne Leerzeichen an die Zahl.

Ablaufprotokoll für die Eingabe 4:

Schritt Zeile Anweisung i fakultaet
1 1 n = int(input("n eingeben: ")) – –
2 2 fakultaet = 1 – 1
3 3 for i in range(1, n + 1): 1 1
4 4 fakultaet = fakultaet * i 1 1
5 3 for i in range(1, n + 1): 2 1
6 4 fakultaet = fakultaet * i 2 2
7 3 for i in range(1, n + 1): 3 2
8 4 fakultaet = fakultaet * i 3 6
9 3 for i in range(1, n + 1): 4 6
10 4 fakultaet = fakultaet * i 4 24
11 3 for i in range(1, n + 1): 4 24
12 5 print(str(n) + "! =", fakultaet) 4 24

Testfälle:

Eingabe erwartete Ausgabe Warum testen?
5 5! = 120 normaler Fall
1 1! = 1 Schleife läuft genau einmal
0 0! = 1 Schleife läuft gar nicht, der Startwert 1 bleibt stehen
10 10! = 3628800 großer Wert

Auch eine while-Schleife würde funktionieren. Dann müsstest du aber Startwert und Erhöhung von i selbst programmieren – mehr Code und die Gefahr einer Endlosschleife.

Arbeitsauftrag 81: Passwortabfrage

Frage so lange nach einem Passwort, bis das korrekte Passwort informatik10 eingegeben wurde. Gib danach „Zugang gewährt“ aus. Welche Schleifenart passt hier? Begründe.

Tipp

Das Passwort ist ein Text. Die Eingabe musst du deshalb nicht umwandeln. Texte vergleichst du wie Zahlen mit == und !=. Das richtige Passwort steht im Programm in Anführungszeichen.

Begründung:

Lösung vergleichen

Begründung: Eine while-Schleife passt, denn niemand weiß vorher, wie viele Fehlversuche es gibt. Die Schleife läuft, solange das Passwort falsch ist.

passwort = input("Passwort eingeben: ")
while passwort != "informatik10":
    passwort = input("Falsch! Erneut versuchen: ")
print("Zugang gewährt")
Passwort eingeben: «geheim»
Falsch! Erneut versuchen: «Informatik10»
Falsch! Erneut versuchen: «informatik10»
Zugang gewährt

Die erste Eingabe steht vor der Schleife. Im Rumpf wird erneut gefragt – mit einem anderen Text, damit man merkt, dass der Versuch falsch war. Ohne diese Zeile im Rumpf entstünde bei einem falschen Passwort eine Endlosschleife.

Testfälle: sofort richtig (dann wird der Rumpf nie ausgeführt), ein- oder mehrmals falsch und dann richtig. Der zweite Versuch oben zeigt: Python unterscheidet Groß- und Kleinschreibung, Informatik10 ist ein anderes Passwort.

Primzahl-Test

Eine Primzahl ist eine natürliche Zahl größer als 1, die nur durch 1 und durch sich selbst teilbar ist, zum Beispiel 2, 3, 5, 7, 11 und 13. Die Zahl 9 ist keine Primzahl, weil sie durch 3 teilbar ist. Die 1 ist nach Festlegung keine Primzahl.

Ob eine Zahl durch eine andere teilbar ist, prüfst du mit dem Rest-Operator %: Ist zahl % teiler == 0, geht die Division ohne Rest auf.

Arbeitsauftrag 82: Primzahl-Test

Prüfe, ob eine eingegebene Zahl eine Primzahl ist. Tipp: Teste, ob sie durch eine Zahl zwischen 2 und sich selbst minus 1 teilbar ist.

Tipp

Arbeite mit einer Variablen, die sich ein Ergebnis merkt: Nimm zuerst an, die Zahl ist eine Primzahl (ist_primzahl = True). Probiere dann mit einer Schleife alle möglichen Teiler aus. Findest du einen, der ohne Rest aufgeht, war die Annahme falsch: ist_primzahl = False. Denke an den Sonderfall 1.

Lösung vergleichen
zahl = int(input("Zahl eingeben: "))
ist_primzahl = zahl > 1
for teiler in range(2, zahl):
    if zahl % teiler == 0:
        ist_primzahl = False
print("Primzahl:", ist_primzahl)
Zahl eingeben: «91»
Primzahl: False
  • Zeile 2: zahl > 1 ist ein Vergleich und ergibt True oder False. Für Zahlen größer als 1 startet ist_primzahl also mit True (Annahme: Primzahl), für 1 und 0 gleich mit False.
  • Zeile 3: Eine for-Schleife passt, denn die Teiler von 2 bis zahl - 1 stehen fest. range(2, zahl) endet genau vor zahl.
  • Zeilen 4–5: Geht die Division ohne Rest auf, ist ein Teiler gefunden, und die Annahme wird widerlegt. Einmal False bleibt False.
  • Zeile 6: Das Ergebnis wird ausgegeben. 91 ist keine Primzahl, denn 91=7⋅1391 = 7 \cdot 13.

Testfälle:

Eingabe erwartete Ausgabe Warum testen?
7 Primzahl: True normale Primzahl
9 Primzahl: False Quadratzahl, nur ein echter Teiler (3)
2 Primzahl: True kleinste Primzahl; range(2, 2) ist leer, die Schleife läuft nicht
1 Primzahl: False Sonderfall: 1 ist keine Primzahl
97 Primzahl: True größere Primzahl

Für Schnelle: Die for-Schleife prüft auch dann noch weiter, wenn längst ein Teiler gefunden ist. Mit einer while-Schleife kann man beim ersten Teiler aufhören:

zahl = int(input("Zahl eingeben: "))
teiler = 2
while teiler < zahl and zahl % teiler != 0:
    teiler += 1
if zahl > 1 and teiler == zahl:
    print(zahl, "ist eine Primzahl.")
else:
    print(zahl, "ist keine Primzahl.")
Zahl eingeben: «91»
91 ist keine Primzahl.

Die Schleife läuft, solange teiler kleiner als die Zahl ist und noch nicht aufgeht. Sie endet bei 91 schon bei teiler = 7. Ist nach der Schleife teiler == zahl, wurde kein Teiler gefunden, die Zahl ist also eine Primzahl.

Arbeitsauftrag 83 (Zusatz): Sparziel

Auf einem Sparkonto liegen 100 €. Jedes Jahr kommen 5 % Zinsen dazu, das Guthaben wird also mit 1,05 multipliziert. Schreibe ein Programm, das berechnet, nach wie vielen Jahren das Guthaben zum ersten Mal mindestens 200 € beträgt. Gib die Anzahl der Jahre und das Guthaben (auf Cent gerundet) aus. Begründe deine Wahl der Schleifenart.

Begründung:

Lösung vergleichen

Begründung: Eine while-Schleife passt, denn die Anzahl der Jahre ist ja gerade das, was gesucht wird. Die Schleife läuft, solange das Guthaben unter 200 € liegt.

guthaben = 100
jahre = 0
while guthaben < 200:
    guthaben = guthaben * 1.05
    jahre += 1
print("Nach", jahre, "Jahren:", round(guthaben, 2), "Euro")
Nach 15 Jahren: 207.89 Euro

jahre zählt die Durchläufe und startet bei 0. Im Rumpf wird das Guthaben verzinst und das Jahr gezählt. Die Schleife terminiert, weil das Guthaben in jedem Durchlauf wächst. Im Programm schreibt man 1.05 mit Punkt. Zum Testen kannst du print(jahre, guthaben) in den Rumpf schreiben: Nach 14 Jahren sind es erst etwa 197,99 €.

1.7.3Weitere Übungen

Hier kannst du das Gelernte weiter üben. Die Punkte im Titel zeigen, wie schwer eine Aufgabe ist: ●○○ leicht, ●●○ mittel, ●●● knifflig. Fang mit den leichten an.

Arbeitsauftrag 84: Welche Schleife passt? ●○○

Entscheide jeweils, ob eine for- oder eine while-Schleife besser passt, und begründe kurz. Du musst die Programme nicht schreiben.

Situation for oder while?
a) das Taschengeld von 12 Monaten zusammenzählen
b) Zahlen einlesen, bis eine negative Zahl eingegeben wird
c) alle geraden Zahlen von 2 bis 50 ausgeben
d) so lange nachfragen, bis ja oder nein eingegeben wird
e) eine eingegebene Zahl so oft halbieren, bis sie kleiner als 1 ist
f) für jede der 25 Personen einer Klasse eine Note einlesen

Begründungen zu a) bis f):

Lösung vergleichen
Situation Schleife Begründung
a) 12 Monate for Die Anzahl 12 steht fest.
b) bis zur negativen Zahl while Wie viele Zahlen kommen, entscheidet die Eingabe.
c) gerade Zahlen bis 50 for Die Zahlen stehen fest: range(2, 51, 2).
d) bis ja oder nein while Die Anzahl der Fehlversuche ist unbekannt.
e) halbieren bis unter 1 while Wie oft halbiert werden muss, soll erst herauskommen.
f) 25 Noten for Es sind genau 25 Durchläufe.

Entscheidend ist immer die Frage: Steht beim Start der Schleife fest, wie oft wiederholt wird? Bei e) hängt das Ende von einer Bedingung ab („solange die Zahl mindestens 1 ist“), auch wenn keine Eingabe mehr kommt.

Arbeitsauftrag 85: Aus for wird while ●○○

Schreibe ein Programm mit einer while-Schleife, das genau dasselbe ausgibt wie das folgende Programm. Denke an Startwert, Bedingung und Veränderung der Zählvariablen.

for i in range(5, 26, 5):
    print(i)
Lösung vergleichen
i = 5
while i < 26:
    print(i)
    i = i + 5
5
10
15
20
25

Die drei Angaben aus range(5, 26, 5) verteilen sich auf drei Stellen: Der Startwert 5 steht vor der Schleife, der Stoppwert 26 in der Bedingung und die Schrittweite 5 in der letzten Zeile des Rumpfs. Auch while i <= 25: ist richtig. Fehlt i = i + 5, entsteht eine Endlosschleife.

Arbeitsauftrag 86: Nur die ungeraden ●○○

Lies das Programm, ohne es auszuführen.

  1. Gib an, was das Programm ausgibt.
  2. Gib an, wie oft die Zeile summe = summe + zahl ausgeführt wird.
summe = 0
for zahl in range(1, 6):
    if zahl % 2 == 1:
        summe = summe + zahl
print(summe)

Meine Antworten:

Lösung vergleichen
9

zahl läuft von 1 bis 5. Nur bei den ungeraden Zahlen 1, 3 und 5 ist die Bedingung zahl % 2 == 1 wahr. Die Zeile summe = summe + zahl wird also dreimal ausgeführt: 1 + 3 + 5 = 9.

zahl 1 2 3 4 5
zahl % 2 == 1 True False True False True
summe danach 1 1 4 4 9
Arbeitsauftrag 87: Potenzieren ohne ** ●○○

Das Programm soll eine Potenz berechnen, ohne den Operator ** zu benutzen. Dafür wird die Basis so oft mit sich selbst multipliziert, wie der Exponent angibt: 25=2⋅2⋅2⋅2⋅22^5 = 2 \cdot 2 \cdot 2 \cdot 2 \cdot 2. Ergänze die drei Lücken ___. Teste mit Basis 2 und Exponent 10 (Ergebnis 1024) und mit Basis 5 und Exponent 0 (Ergebnis 1).

basis = int(input("Basis: "))
exponent = int(input("Exponent: "))
ergebnis = ___
for i in range(___):
    ergebnis = ___
print(basis, "hoch", exponent, "ist", ergebnis)
Lösung vergleichen
basis = int(input("Basis: "))
exponent = int(input("Exponent: "))
ergebnis = 1
for i in range(exponent):
    ergebnis = ergebnis * basis
print(basis, "hoch", exponent, "ist", ergebnis)
Basis: «2»
Exponent: «10»
2 hoch 10 ist 1024

Wie bei der Fakultät startet die Produktvariable bei 1. range(exponent) sorgt für genau exponent Durchläufe. Bei Exponent 0 läuft die Schleife gar nicht, und das Ergebnis bleibt 1. Das stimmt, denn 50=15^0 = 1.

Arbeitsauftrag 88: Fehler finden: Vielfache von 7 zählen ●●○

Das Programm soll zählen, wie viele Zahlen von 1 bis 70 durch 7 teilbar sind. Richtig wäre Anzahl: 10. Es enthält drei Fehler.

for zahl in range(1, 70):
    if zahl % 7 = 0:
        anzahl = anzahl + 1
print("Anzahl:", anzahl)
  1. Finde die drei Fehler. Notiere jeweils die Zeile und was falsch ist.
  2. Schreibe das Programm richtig auf.

Die Fehler:

Lösung vergleichen
  1. Zeile 2: = statt == im Vergleich (SyntaxError).
  2. Vor Zeile 1: Die Zählvariable anzahl bekommt nie einen Startwert. In Zeile 3 meldet Python deshalb einen NameError. Vor die Schleife gehört anzahl = 0.
  3. Zeile 1: Der Stoppwert 70 gehört nicht dazu. Dann fehlt die 70, und es kommt 9 statt 10 heraus. Richtig ist range(1, 71). Dieser Fehler erzeugt keine Fehlermeldung.
anzahl = 0
for zahl in range(1, 71):
    if zahl % 7 == 0:
        anzahl = anzahl + 1
print("Anzahl:", anzahl)
Anzahl: 10

Die Zählvariable funktioniert wie eine Summenvariable: Startwert 0 vor der Schleife, in der Schleife um 1 erhöhen. Hier wird aber nur erhöht, wenn die Bedingung wahr ist.

Arbeitsauftrag 89: Alle Teiler einer Zahl ●●○

Schreibe ein Programm, das eine ganze Zahl einliest und alle ihre Teiler ausgibt. Am Ende soll es ausgeben, wie viele Teiler es sind. Begründe, welche Schleifenart du verwendest.

So könnte es aussehen:

Zahl: «12»
1
2
3
4
6
12
Anzahl der Teiler: 6

Begründung:

Lösung vergleichen
zahl = int(input("Zahl: "))
anzahl = 0
for teiler in range(1, zahl + 1):
    if zahl % teiler == 0:
        print(teiler)
        anzahl = anzahl + 1
print("Anzahl der Teiler:", anzahl)
Zahl: «12»
1
2
3
4
6
12
Anzahl der Teiler: 6

Eine for-Schleife passt: Die möglichen Teiler 1 bis zahl stehen fest, sobald die Zahl eingegeben ist. Damit die Zahl selbst mitgeprüft wird, ist der Stoppwert zahl + 1. Ausgabe und Zählen stehen im if-Block, denn sie sollen nur bei einem echten Teiler passieren. Weitere Testfälle: Die 7 hat genau 2 Teiler (sie ist eine Primzahl), die 1 hat nur einen Teiler.

Arbeitsauftrag 90: Gerade und ungerade zählen ●●○

Schreibe ein Programm, das so lange ganze Zahlen einliest, bis 0 eingegeben wird. Danach soll es ausgeben, wie viele der eingegebenen Zahlen gerade und wie viele ungerade waren. Die 0 zählt nicht mit. Teste mit 4, 7, 10, 3, 8, 0 und mit sofort 0.

Lösung vergleichen
gerade = 0
ungerade = 0
zahl = int(input("Zahl (0 zum Beenden): "))
while zahl != 0:
    if zahl % 2 == 0:
        gerade = gerade + 1
    else:
        ungerade = ungerade + 1
    zahl = int(input("Zahl (0 zum Beenden): "))
print("Gerade Zahlen:", gerade)
print("Ungerade Zahlen:", ungerade)
Zahl (0 zum Beenden): «4»
Zahl (0 zum Beenden): «7»
Zahl (0 zum Beenden): «10»
Zahl (0 zum Beenden): «3»
Zahl (0 zum Beenden): «8»
Zahl (0 zum Beenden): «0»
Gerade Zahlen: 3
Ungerade Zahlen: 2

Eine while-Schleife passt, weil vorher nicht feststeht, wie viele Zahlen kommen. Es gibt zwei Zählvariablen, beide starten vor der Schleife bei 0. Die Verzweigung im Rumpf entscheidet, welche erhöht wird. Die nächste Eingabe steht am Ende des Rumpfs, nach der Verzweigung und nicht in einem ihrer Blöcke. Die 0 wird nicht mitgezählt, weil die Schleife bei ihr sofort endet. Bei sofort 0 gibt das Programm zweimal 0 aus.

Arbeitsauftrag 91: Bestweite beim Weitsprung ●●●

Beim Weitsprung werden die Weiten eines Versuchs nach dem anderen eingegeben (in Metern, als Kommazahl). Die Eingabe 0 beendet die Eingabe. Schreibe ein Programm, das danach die Anzahl der Versuche und die beste Weite ausgibt. Wurde gar keine Weite eingegeben, soll es „Keine Weite eingegeben.“ ausgeben.

So könnte es aussehen:

Weite in m (0 = Ende): «3.85»
Weite in m (0 = Ende): «4.10»
Weite in m (0 = Ende): «3.92»
Weite in m (0 = Ende): «0»
Versuche: 3
Bestweite: 4.1 m
Tipp

Merke dir die bisher beste Weite in einer Variablen beste. Weil alle Weiten größer als 0 sind, kann sie bei 0 starten. Bei jeder neuen Weite fragst du: Ist sie größer als die bisher beste? Dann wird sie die neue beste Weite.

Lösung vergleichen
versuche = 0
beste = 0
weite = float(input("Weite in m (0 = Ende): "))
while weite != 0:
    versuche = versuche + 1
    if weite > beste:
        beste = weite
    weite = float(input("Weite in m (0 = Ende): "))
if versuche > 0:
    print("Versuche:", versuche)
    print("Bestweite:", beste, "m")
else:
    print("Keine Weite eingegeben.")
Weite in m (0 = Ende): «3.85»
Weite in m (0 = Ende): «4.10»
Weite in m (0 = Ende): «3.92»
Weite in m (0 = Ende): «0»
Versuche: 3
Bestweite: 4.1 m
  • Zeilen 3–8: das bekannte Muster für Eingaben: erste Eingabe vor der Schleife, nächste Eingabe am Ende des Rumpfs.
  • Zeilen 6–7: Ist die neue Weite größer als die bisher beste, wird sie gespeichert. Sonst bleibt beste unverändert. Nach der Schleife steht in beste die größte Weite.
  • Zeilen 9–13: Nach der Schleife entscheidet eine Verzweigung, ob überhaupt Versuche eingegeben wurden.

Python zeigt 4.10 als 4.1 an, denn bei einer Kommazahl lässt es Nullen am Ende weg. Teste auch, ob die Bestweite stimmt, wenn der beste Sprung der erste oder der letzte ist.

1.7.4Das Wichtigste in Kürze

Selbstcheck

1.8Funktionen: Programme aus Bausteinen DS08

Diesen Abschnitt als PDF (S. 107–122)

Das Jupyter-Notebook aus dem Unterricht: DS08_Funktionen.ipynb. Herunterladen und in VS Code oder Jupyter öffnen.

Zum Weiterüben: DS08_Weitere_Uebungen.ipynb mit den Aufgaben aus „Weitere Übungen“ zum Bearbeiten in Python.

Leitidee

Du hast schon viele Funktionen benutzt, ohne viel darüber nachzudenken: print(...), input(...), int(...), round(...) oder random.randint(...). Du schreibst ihren Namen, gibst ihnen in Klammern Werte mit und bekommst ein Ergebnis. Wie sie innen arbeiten, musst du dafür nicht wissen. In diesem Abschnitt schreibst du eigene Funktionen. So schreibst du eine Rechnung, die du oft brauchst, nur einmal auf und benutzt sie dann so oft du willst. Die Idee kennst du aus Mathe: Die Funktion f(x)=x2f(x) = x^2 macht aus 4 die 16 und aus 7 die 49.

Lernziele

Nach diesem Abschnitt kannst du

1.8.1Eine eigene Funktion definieren

Stell dir vor, dein Programm soll an mehreren Stellen eine Trennlinie ausgeben. Statt die Linie jedes Mal neu abzutippen, gibst du der Anweisung einen Namen:

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

print("Einkaufsliste")
trennlinie()
print("Milch, Brot, Käse")
trennlinie()
Einkaufsliste
--------------------
Milch, Brot, Käse
--------------------

Du kannst dir eine Funktion wie ein Rezept vorstellen. Die Definition schreibt das Rezept auf. Davon wird noch niemand satt. Erst beim Aufruf wird nach dem Rezept gekocht – und das so oft, wie man möchte.

Definition: Funktion

Eine Funktion ist eine Folge von Anweisungen, die unter einem Namen zusammengefasst ist. Über diesen Namen kann man sie beliebig oft aufrufen, also ausführen lassen.

Merke

Was parameter1 und parameter2 in den Klammern bedeuten, lernst du gleich im Abschnitt über Parameter. Bei trennlinie() bleiben die Klammern leer.

Stolperstein

Vergisst du die Einrückung, meldet Python einen IndentationError („Einrückungsfehler“):

def trennlinie():
print("--------------------")
  File "programm.py", line 2
    print("--------------------")
    ^^^^^
IndentationError: expected an indented block after function definition on line 1

Die letzte Zeile heißt: „Nach der Funktionsdefinition in Zeile 1 wurde ein eingerückter Block erwartet.“ Gefunden hat Python das Problem in Zeile 2 (line 2). Rücke diese Zeile mit 4 Leerzeichen (oder der Tabulatortaste) ein. Fehlt der Doppelpunkt am Ende von Zeile 1, kommt ein SyntaxError: expected ':'.

Stolperstein

Eine Funktion muss definiert sein, bevor sie aufgerufen wird, denn Python liest das Programm von oben nach unten. Steht trennlinie() vor dem def, meldet Python NameError: name 'trennlinie' is not defined. Schreibe deshalb alle Funktionsdefinitionen an den Anfang des Programms. Und vergiss beim Aufruf die Klammern nicht: trennlinie ohne () ruft die Funktion nicht auf.

1.8.2Parameter: der Funktion Werte mitgeben

Die Trennlinie sieht immer gleich aus. Oft soll eine Funktion aber mit verschiedenen Werten arbeiten. Eine Begrüßung zum Beispiel soll jedes Mal einen anderen Namen enthalten. Dafür schreibst du in die Klammern hinter dem Funktionsnamen einen Parameter:

def gruesse(name):
    print("Hallo, " + name + "!")

gruesse("Alex")
gruesse("Sam")
Hallo, Alex!
Hallo, Sam!

Eine Funktion darf auch mehrere Parameter haben. Sie werden durch Kommas getrennt. Beim Aufruf werden die Argumente der Reihe nach auf die Parameter verteilt: das erste Argument in den ersten Parameter, das zweite in den zweiten.

def gruesse(gruss, name):
    print(gruss + ", " + name + "!")

gruesse("Hallo", "Alex")
gruesse("Servus", "Sam")
gruesse("Sam", "Moin")
Hallo, Alex!
Servus, Sam!
Sam, Moin!

In Zeile 6 sind die Argumente vertauscht. Python bemerkt das nicht: gruss bekommt "Sam", name bekommt "Moin". Achte deshalb beim Aufruf auf die Reihenfolge.

Definition: Parameter und Argument

Ein Parameter ist eine Variable in der Funktionsdefinition, die beim Aufruf einen Wert bekommt. Der Wert, der beim Aufruf übergeben wird, heißt Argument.

Merke

Parameter sind die „Eingabewerte“ einer Funktion – beim Aufruf werden ihnen konkrete Argumente übergeben, und zwar in derselben Reihenfolge.

Stolperstein

Die Anzahl der Argumente muss zur Anzahl der Parameter passen:

def gruesse(name):
    print("Hallo, " + name + "!")

gruesse()
TypeError: gruesse() missing 1 required positional argument: 'name'

Übersetzt: „Der Funktion gruesse() fehlt 1 benötigtes Argument: name.“ Gibst du zu viele Argumente an, z. B. gruesse("Alex", "Sam"), heißt es: takes 1 positional argument but 2 were given – „nimmt 1 Argument, aber 2 wurden übergeben“.

Versuch: Probiere es aus

Rufe gruesse mit deinem eigenen Namen auf. Was passiert bei gruesse(15)? Lies die Fehlermeldung und erkläre sie mit dem, was du über das Verketten mit + weißt.

1.8.3Rückgabewert: die Funktion liefert ein Ergebnis

gruesse gibt etwas auf dem Bildschirm aus. Das Ergebnis ist danach aber für das Programm verloren. Bei round ist das anders: zahl = round(3.14159, 2) rechnet und gibt das Ergebnis 3.14 zurück, und es wird in zahl gespeichert. Das geht auch mit eigenen Funktionen – mit dem Wort return:

def quadrat(zahl):
    ergebnis = zahl * zahl
    return ergebnis

print(quadrat(4))
print(quadrat(7))

x = quadrat(10)
print("x ist jetzt:", x)
16
49
x ist jetzt: 100

Eine Funktion mit Parametern und Rückgabewert funktioniert wie eine Maschine: Oben wirft man etwas hinein, die Maschine arbeitet, und unten kommt ein Ergebnis heraus.

Die Funktion quadrat als Maschine: Das Argument 4 geht als Parameter hinein, der Rückgabewert 16 kommt heraus
Definition: Rückgabewert

Der Rückgabewert ist das Ergebnis, das eine Funktion mit return an die Stelle zurückgibt, an der sie aufgerufen wurde.

Weil ein Aufruf wie quadrat(3) am Ende einfach für einen Wert steht, kannst du ihn überall einsetzen, wo ein Wert stehen darf – in Rechnungen, Bedingungen oder als Argument einer anderen Funktion:

def quadrat(zahl):
    ergebnis = zahl * zahl
    return ergebnis

summe = quadrat(3) + quadrat(4)
print("3*3 + 4*4 =", summe)
if quadrat(5) > 20:
    print("5*5 ist größer als 20.")
3*3 + 4*4 = 25
5*5 ist größer als 20.

Wichtig: Mit return endet die Funktion sofort. Steht danach im Rumpf noch etwas, wird es nicht mehr ausgeführt.

Ein Rückgabewert muss keine Zahl sein. Diese Funktion setzt einen Gruß zusammen und gibt ihn als Zeichenkette zurück:

def begruessung(name, gruss):
    return gruss + ", " + name + "!"

print(begruessung("Alex", "Hallo"))
print(begruessung("Sam", "Servus"))
Hallo, Alex!
Servus, Sam!
Merke
Arbeitsauftrag 92: Vorhersage

Lies das Programm, ohne es auszuführen. Schreibe auf, was es ausgibt. Überprüfe deine Vorhersage danach am Computer.

def verdopple(zahl):
    return 2 * zahl

a = verdopple(3)
b = verdopple(a) + 1
print(a, b)
print(verdopple(verdopple(5)))

Meine Vorhersage:

Lösung vergleichen
6 13
20

verdopple(3) liefert 6, also ist a = 6. In Zeile 5 wird verdopple(6) ausgerechnet, das ergibt 12, plus 1 ist 13. In der letzten Zeile wird von innen nach außen gerechnet: verdopple(5) liefert 10, und verdopple(10) liefert 20.

1.8.4Was beim Aufruf passiert

Ohne Funktionen läuft ein Programm einfach von oben nach unten. Ein Funktionsaufruf unterbricht diese Reihenfolge: Python springt in die Funktion, führt ihren Rumpf aus und springt mit dem Rückgabewert zurück an die Stelle des Aufrufs. Dort geht es weiter.

Beim Aufruf quadrat(10) springt Python in die Funktion, der Parameter zahl bekommt den Wert 10. Mit return springt Python zurück, und der Aufruf wird durch den Rückgabewert 100 ersetzt

Verfolge den Ablauf an diesem Programm:

def quadrat(zahl):
    ergebnis = zahl * zahl
    return ergebnis

x = quadrat(10)
y = quadrat(3) + 1
print(x, y)
100 10
  1. Zeile 1: Python liest die Definition und merkt sich die Funktion. Die Zeilen 2 und 3 werden jetzt nicht ausgeführt.
  2. Zeile 5: Aufruf quadrat(10). Python springt in die Funktion, der Parameter zahl bekommt den Wert 10. Zeile 2 rechnet ergebnis = 100, Zeile 3 gibt 100 zurück. Zurück in Zeile 5 bekommt x den Wert 100.
  3. Zeile 6: Aufruf quadrat(3). Wieder geht es in die Funktion, diesmal mit zahl = 3. Der Rückgabewert ist 9. Zurück in Zeile 6 wird 9 + 1 = 10 gerechnet und in y gespeichert.
  4. Zeile 7: Ausgabe von x und y.

Im Ablaufprotokoll des Hauptprogramms sieht es so aus, als würde Zeile 5 in einem einzigen Schritt erledigt:

Schritt Zeile Anweisung x y
1 1 def quadrat(zahl): – –
2 5 x = quadrat(10) 100 –
3 6 y = quadrat(3) + 1 100 10
4 7 print(x, y) 100 10

In Wirklichkeit läuft bei jedem Aufruf die Funktion einmal ab. Das Ablaufprotokoll innerhalb der Funktion zeigt die beiden Durchläufe:

Schritt Zeile Anweisung zahl ergebnis
1 2 ergebnis = zahl * zahl 10 100
2 3 return ergebnis 10 100
3 2 ergebnis = zahl * zahl 3 9
4 3 return ergebnis 3 9

Variablen in der Funktion bleiben in der Funktion

Die Variablen zahl und ergebnis gibt es nur, solange die Funktion läuft. Man nennt sie lokale Variablen. Von außen kann man nicht auf sie zugreifen: Schreibt man im Programm oben am Ende noch print(ergebnis), meldet Python NameError: name 'ergebnis' is not defined.

Aus der Maschine kommt nur heraus, was mit return zurückgegeben wird. Genau deshalb braucht man return: Mit dem, was du bisher kennst, ist es der einzige Weg, auf dem das Ergebnis aus der Funktion zum Hauptprogramm gelangt.

Der häufigste Fehler mit Funktionen: print statt return zu schreiben. Auf den ersten Blick sieht beides gleich aus, denn in beiden Fällen erscheint am Ende eine Zahl. Vergleiche die beiden Funktionen:

def quadrat_mit_print(zahl):
    print(zahl * zahl)

def quadrat_mit_return(zahl):
    return zahl * zahl

a = quadrat_mit_print(4)
b = quadrat_mit_return(4)
print("a ist", a)
print("b ist", b)
16
a ist None
b ist 16

Will man mit dem Ergebnis weiterrechnen, bricht das Programm mit der print-Variante sogar ab:

def quadrat_mit_print(zahl):
    print(zahl * zahl)

summe = quadrat_mit_print(3) + quadrat_mit_print(4)
9
16
TypeError: unsupported operand type(s) for +: 'NoneType' and 'NoneType'

Die Funktion hat zwar 9 und 16 angezeigt, aber beide Aufrufe liefern None. Und None + None kann Python nicht rechnen. Die Meldung heißt: „Der Operator + ist für die Typen NoneType und NoneType nicht möglich.“ Wenn in einer Fehlermeldung NoneType auftaucht, fehlt sehr oft ein return.

print(...) in der Funktion return ...
Was passiert? Der Wert wird auf dem Bildschirm angezeigt. Der Wert wird an die Stelle des Aufrufs zurückgegeben.
Wer bekommt den Wert? die Person vor dem Bildschirm das Programm
Was liefert der Aufruf? None den Wert hinter return
Weiterrechnen möglich? nein ja
Merke
Tipp

Faustregel: Eine Funktion, die etwas berechnet, gibt ihr Ergebnis mit return zurück. Das Ausgeben mit print erledigt das Hauptprogramm.

Arbeitsauftrag 93: print oder return?

Das Programm soll Minuten in Sekunden umrechnen. Es läuft ohne Fehlermeldung, aber die Ausgabe ist seltsam.

def minuten_zu_sekunden(minuten):
    print(minuten * 60)

dauer = minuten_zu_sekunden(5)
print("Das sind", dauer, "Sekunden.")
  1. Gib an, was das Programm ausgibt.
  2. Erkläre, warum die Ausgabe nicht stimmt.
  3. Verbessere die Funktion.

Ausgabe und Erklärung:

Lösung vergleichen
  1. Die Ausgabe ist:
300
Das sind None Sekunden.
  1. Die Funktion gibt 300 nur mit print aus, gibt aber nichts zurück. Deshalb bekommt dauer den Wert None.
  2. Statt print muss return stehen:
def minuten_zu_sekunden(minuten):
    return minuten * 60

dauer = minuten_zu_sekunden(5)
print("Das sind", dauer, "Sekunden.")
Das sind 300 Sekunden.

1.8.6Funktionen testen

Eine Funktion kann man beliebig oft mit verschiedenen Argumenten aufrufen. Das ist praktisch, um sie zu testen: Du rufst sie mit Werten auf, bei denen du das richtige Ergebnis schon kennst, und vergleichst. So gehst du vor:

  1. Vorher von Hand ausrechnen, was herauskommen muss (erwartetes Ergebnis).
  2. Die Funktion mit diesen Werten aufrufen und das tatsächliche Ergebnis ausgeben.
  3. Vergleichen. Weicht ein Ergebnis ab, steckt ein Fehler in der Funktion – oder in deiner Rechnung.

Wähle die Testwerte mit Bedacht: einen ganz normalen Wert, aber auch Sonderfälle wie 0, negative Zahlen oder Kommazahlen. Genau dort verstecken sich Fehler am häufigsten.

def quadrat(zahl):
    return zahl * zahl

print(quadrat(4), "erwartet: 16")
print(quadrat(0), "erwartet: 0")
print(quadrat(-3), "erwartet: 9")
print(quadrat(1.5), "erwartet: 2.25")
16 erwartet: 16
0 erwartet: 0
9 erwartet: 9
2.25 erwartet: 2.25

Alle vier Tests stimmen. Den Vergleich kann Python auch selbst übernehmen: print(quadrat(-3) == 9) gibt True aus, wenn der Test stimmt, und sonst False.

So kannst du es sagen

So beschreibst du, was eine Funktion tut. Als Beispiel dient die Funktion f mit dem Parameter x und dem Rumpf return x * x + 1. Der Aufruf f(4) liefert 17.

1.8.7Übungen

So gehst du beim Schreiben einer Funktion vor: Überlege zuerst, welche Werte die Funktion braucht (Parameter) und was sie zurückgeben soll (Rückgabewert). Schreibe dann den Rumpf. Teste die Funktion zum Schluss mit mehreren Aufrufen, deren Ergebnis du vorher ausgerechnet hast.

Arbeitsauftrag 94: Celsius in Fahrenheit

In den USA misst man Temperaturen in Grad Fahrenheit (°F). Die Umrechnung lautet: °F = °C · 9/5 + 32.

  1. Implementiere eine Funktion celsius_zu_fahrenheit(grad_celsius), die eine Temperatur in Grad Celsius entgegennimmt und den Wert in Fahrenheit zurückgibt.
  2. Teste sie mit mehreren Werten. Zur Kontrolle: Wasser gefriert bei 0 °C = 32 °F und siedet bei 100 °C = 212 °F.
Lösung vergleichen
def celsius_zu_fahrenheit(grad_celsius):
    return grad_celsius * 9 / 5 + 32

print(celsius_zu_fahrenheit(0))
print(celsius_zu_fahrenheit(100))
print(celsius_zu_fahrenheit(20))
print(celsius_zu_fahrenheit(-40))
32.0
212.0
68.0
-40.0

Die Formel wird fast wörtlich übernommen, das Malzeichen ist *. Wegen „Punkt vor Strich“ braucht man keine Klammern. Weil / immer eine Kommazahl liefert, erscheint 32.0 statt 32. Die Testwerte 0 und 100 bestätigen die Kontrollwerte aus der Aufgabe. -40 ist ein lustiger Sonderfall: −40 °C sind genau −40 °F.

Häufiger Fehler: print(...) statt return in der Funktion. Dann zeigt der Test zwar Zahlen an, aber zusätzlich jeweils None.

Arbeitsauftrag 95: Maximum von zwei Zahlen

Implementiere eine Funktion maximum(a, b), die die größere von zwei Zahlen zurückgibt. Verwende dafür nicht die eingebaute Funktion max(), sondern eine Verzweigung. Teste deine Funktion – auch mit zwei gleichen Zahlen.

Lösung vergleichen
def maximum(a, b):
    if a > b:
        return a
    else:
        return b

print(maximum(3, 9))
print(maximum(17, 5))
print(maximum(4, 4))
9
17
4

Die Funktion hat zwei return-Anweisungen. Es wird aber immer nur eine davon ausgeführt: Ist a > b, gibt die Funktion a zurück und ist sofort beendet. Sonst gibt sie b zurück. Bei gleichen Zahlen ist a > b falsch, also wird b zurückgegeben – das ist richtig, denn beide Zahlen sind gleich groß.

Arbeitsauftrag 96 (Zusatz): Gerade Zahlen
  1. Implementiere eine Funktion ist_gerade(zahl), die True zurückgibt, wenn die Zahl gerade ist, und sonst False. Der Rückgabewert ist also vom Typ bool.
  2. Nutze die Funktion anschließend in einer for-Schleife, um alle geraden Zahlen von 1 bis 20 auszugeben.
Lösung vergleichen
def ist_gerade(zahl):
    return zahl % 2 == 0

for i in range(1, 21):
    if ist_gerade(i):
        print(i)
2
4
6
8
10
12
14
16
18
20

Eine Zahl ist gerade, wenn beim Teilen durch 2 der Rest 0 bleibt. Der Vergleich zahl % 2 == 0 ergibt selbst schon True oder False. Dieses Ergebnis kann man direkt zurückgeben. Weil der Rückgabewert ein Wahrheitswert ist, kann der Aufruf ist_gerade(i) direkt als Bedingung hinter if stehen. range(1, 21) läuft von 1 bis einschließlich 20.

Auch diese längere Fassung ist richtig:

def ist_gerade(zahl):
    if zahl % 2 == 0:
        return True
    else:
        return False

print(ist_gerade(7), ist_gerade(8))
False True

1.8.8Weitere Übungen

Hier kannst du das Gelernte weiter üben. Die Punkte im Titel zeigen, wie schwer eine Aufgabe ist: ●○○ leicht, ●●○ mittel, ●●● knifflig. Fang mit den leichten an.

Arbeitsauftrag 97: Fachbegriffe am Beispiel ●○○

Am Kiosk kostet jede Pfandflasche 25 Cent Pfand zusätzlich zum Preis. Lies das Programm:

def preis_mit_pfand(preis, flaschen):
    return preis + flaschen * 0.25

gesamt = preis_mit_pfand(3.5, 6)
print(gesamt)

Nenne zu diesem Programm:

  1. den Namen der Funktion,
  2. die Parameter,
  3. die Argumente beim Aufruf,
  4. die Zeile, in der die Funktion aufgerufen wird,
  5. den Rückgabewert für diesen Aufruf.

Meine Antworten:

Lösung vergleichen
  1. Die Funktion heißt preis_mit_pfand.
  2. Die Parameter sind preis und flaschen (sie stehen in der Definition in Zeile 1).
  3. Die Argumente sind 3.5 und 6 (sie stehen beim Aufruf in Zeile 4).
  4. Der Aufruf steht in Zeile 4. Zeile 1 ist die Definition, kein Aufruf.
  5. Der Rückgabewert ist 3,5+6⋅0,25=5,03{,}5 + 6 \cdot 0{,}25 = 5{,}0:
def preis_mit_pfand(preis, flaschen):
    return preis + flaschen * 0.25

gesamt = preis_mit_pfand(3.5, 6)
print(gesamt)
5.0

Typischer Fehler: Parameter und Argumente verwechseln. Merkhilfe: Parameter stehen bei der Planung (Definition), Argumente beim Aufruf.

Arbeitsauftrag 98: Rückgabewerte vorhersagen ●○○

Gegeben ist die Funktion rechne:

def rechne(x):
    return 3 * x - 1

Bestimme ohne Computer, welchen Wert die Aufrufe zurückgeben. Prüfe danach am Computer, z. B. mit print(rechne(2)).

Aufruf Rückgabewert
rechne(2)
rechne(0)
rechne(-1)
rechne(10)
rechne(rechne(1))
Lösung vergleichen
Aufruf Rückgabewert
rechne(2) 5
rechne(0) -1
rechne(-1) -4
rechne(10) 29
rechne(rechne(1)) 5
def rechne(x):
    return 3 * x - 1

print(rechne(2), rechne(0), rechne(-1), rechne(10))
print(rechne(rechne(1)))
5 -1 -4 29
5

Punkt vor Strich: Zuerst wird 3 * x gerechnet, dann 1 abgezogen. Den letzten Aufruf liest du von innen nach außen: rechne(1) liefert 2, und rechne(2) liefert 5.

Arbeitsauftrag 99: Eintritt im Freibad ●○○

Im Freibad kostet der Eintritt 4 Euro. Für jede Stunde, die man bleibt, kommen 2 Euro dazu.

  1. Implementiere eine Funktion eintritt(stunden), die den Preis in Euro zurückgibt.
  2. Teste sie mit den Werten aus der Tabelle. Rechne die erwarteten Werte vorher von Hand aus.
Aufruf erwartet tatsächlich
eintritt(1)
eintritt(3)
eintritt(0)
Lösung vergleichen
def eintritt(stunden):
    return 4 + 2 * stunden

print(eintritt(1), "erwartet: 6")
print(eintritt(3), "erwartet: 10")
print(eintritt(0), "erwartet: 4")
6 erwartet: 6
10 erwartet: 10
4 erwartet: 4

Der Parameter stunden ist der einzige Wert, den die Funktion braucht. Der Test mit 0 ist ein Sonderfall: Dann bleibt nur der Grundpreis übrig. Häufiger Fehler: print statt return in der Funktion. Dann erscheint im Test zusätzlich None.

Arbeitsauftrag 100: Drei Fehler ●○○

Die Funktion soll die Fläche eines Dreiecks berechnen (Grundseite mal Höhe durch 2). Das Programm enthält drei Fehler. Finde sie und schreibe das Programm richtig auf. Teste es: Für die Grundseite 4 und die Höhe 3 muss 6.0 herauskommen.

def flaeche_dreieck(g, h)
return g * h / 2

print(flaeche_dreieck(4))

Die drei Fehler:

Lösung vergleichen
  1. Nach def flaeche_dreieck(g, h) fehlt der Doppelpunkt (SyntaxError: expected ':').
  2. Die Zeile mit return ist nicht eingerückt. Sie gehört aber zum Funktionsrumpf (IndentationError).
  3. Beim Aufruf fehlt das zweite Argument. Die Funktion hat zwei Parameter, also braucht der Aufruf zwei Argumente (TypeError: ... missing 1 required positional argument: 'h').
def flaeche_dreieck(g, h):
    return g * h / 2

print(flaeche_dreieck(4, 3))
6.0

Python meldet immer nur den ersten Fehler. Wenn du einen behoben hast, starte das Programm erneut und lies die nächste Meldung.

Arbeitsauftrag 101: Ein Test deckt den Fehler auf ●●○

Die Funktion soll den Mittelwert von zwei Zahlen zurückgeben. Sie läuft ohne Fehlermeldung.

def mittelwert(a, b):
    return a + b / 2
  1. Rechne von Hand aus, was für mittelwert(4, 6) herauskommen muss.
  2. Teste die Funktion mit mittelwert(4, 6) und mit mittelwert(0, 0). Notiere die Ergebnisse.
  3. Erkläre den Fehler und verbessere die Funktion.
  4. Erkläre, warum der Test mit 0 und 0 allein den Fehler nicht gefunden hätte.

Meine Antworten:

Lösung vergleichen
  1. Der Mittelwert von 4 und 6 ist (4+6):2=5(4 + 6) : 2 = 5.
  2. Die fehlerhafte Funktion liefert:
def mittelwert(a, b):
    return a + b / 2

print(mittelwert(4, 6), "erwartet: 5")
print(mittelwert(0, 0), "erwartet: 0")
7.0 erwartet: 5
0.0 erwartet: 0
  1. Wegen „Punkt vor Strich“ rechnet Python zuerst b / 2 und addiert dann a: 4+3=74 + 3 = 7. Die Summe muss in Klammern stehen:
def mittelwert(a, b):
    return (a + b) / 2

print(mittelwert(4, 6), "erwartet: 5")
print(mittelwert(0, 0), "erwartet: 0")
5.0 erwartet: 5
0.0 erwartet: 0
  1. Bei 0 und 0 liefern beide Rechnungen zufällig dasselbe Ergebnis. Ein einzelner Test kann also „Glück haben“. Deshalb testet man immer mit mehreren, verschiedenen Werten.
Arbeitsauftrag 102: Kinokarten ●●○

Ein Kino verlangt je nach Alter einen anderen Preis:

  1. Implementiere eine Funktion kinopreis(alter), die den Preis zurückgibt. Verwende eine mehrseitige Verzweigung.
  2. Teste die Funktion an den Grenzen: mit den Altern 5, 6, 17 und 18.
Lösung vergleichen
def kinopreis(alter):
    if alter < 6:
        return 0
    elif alter < 18:
        return 6
    else:
        return 9

print(kinopreis(5), "erwartet: 0")
print(kinopreis(6), "erwartet: 6")
print(kinopreis(17), "erwartet: 6")
print(kinopreis(18), "erwartet: 9")
0 erwartet: 0
6 erwartet: 6
6 erwartet: 6
9 erwartet: 9

Die Funktion hat drei return-Anweisungen, aber bei jedem Aufruf wird nur eine davon ausgeführt. Die Bedingung alter < 18 im elif wird nur geprüft, wenn alter < 6 falsch war. Deshalb muss man dort nicht noch einmal alter >= 6 schreiben. Die vier Testwerte liegen genau an den Grenzen, wo Fehler wie <= statt < auffallen würden.

Arbeitsauftrag 103: Funktion in der Schleife ●●○

Fülle das Ablaufprotokoll des Hauptprogramms aus. Trage nach jedem Schritt die Werte von i und summe ein (– bedeutet: noch kein Wert). Gib dann an, was das Programm ausgibt.

def dreifach(zahl):
    return 3 * zahl

summe = 0
for i in range(1, 4):
    summe = summe + dreifach(i)
print("Summe:", summe)
Schritt Zeile Anweisung i summe
1 1 def dreifach(zahl): – –
2 4 summe = 0 –
3 5 for i in range(1, 4):
4 6 summe = summe + dreifach(i)
5 5 for i in range(1, 4):
6 6 summe = summe + dreifach(i)
7 5 for i in range(1, 4):
8 6 summe = summe + dreifach(i)
9 5 for i in range(1, 4):
10 7 print("Summe:", summe)

Ausgabe:

Lösung vergleichen
Schritt Zeile Anweisung i summe
1 1 def dreifach(zahl): – –
2 4 summe = 0 – 0
3 5 for i in range(1, 4): 1 0
4 6 summe = summe + dreifach(i) 1 3
5 5 for i in range(1, 4): 2 3
6 6 summe = summe + dreifach(i) 2 9
7 5 for i in range(1, 4): 3 9
8 6 summe = summe + dreifach(i) 3 18
9 5 for i in range(1, 4): 3 18
10 7 print("Summe:", summe) 3 18
def dreifach(zahl):
    return 3 * zahl

summe = 0
for i in range(1, 4):
    summe = summe + dreifach(i)
print("Summe:", summe)
Summe: 18

In jedem Durchlauf springt Python in die Funktion und kommt mit dem Dreifachen von i zurück: 3, 6 und 9. Zusammen ergibt das 3+6+9=183 + 6 + 9 = 18. Die Zeilen 1 und 2 werden beim ersten Lesen nicht ausgeführt, Python merkt sich dort nur die Funktion.

Arbeitsauftrag 104: Quersumme als Funktion ●●●

Im Auftrag Quersumme (Abschnitt über die while-Schleife) hast du die Quersumme einer Zahl berechnet (Quersumme von 384 ist 3+8+4=153 + 8 + 4 = 15). Zur Erinnerung: zahl % 10 liefert die letzte Ziffer, zahl // 10 entfernt sie.

  1. Implementiere eine Funktion quersumme(zahl), die die Quersumme zurückgibt. Teste sie mit 384 (erwartet: 15), 7 (erwartet: 7) und 1000 (erwartet: 1).
  2. Benutze die Funktion in einer for-Schleife: Gib alle Zahlen von 1 bis 100 aus, deren Quersumme genau 10 ist.
Tipp

Schreibe die Schleife aus dem Abschnitt über die while-Schleife in den Funktionsrumpf und ersetze das print am Ende durch return. Im zweiten Teil steht der Aufruf quersumme(i) in der Bedingung einer if-Anweisung, so wie ist_gerade(i) im Auftrag Gerade Zahlen.

Lösung vergleichen
def quersumme(zahl):
    summe = 0
    while zahl > 0:
        summe = summe + zahl % 10
        zahl = zahl // 10
    return summe

print(quersumme(384), "erwartet: 15")
print(quersumme(7), "erwartet: 7")
print(quersumme(1000), "erwartet: 1")

for i in range(1, 101):
    if quersumme(i) == 10:
        print(i)
15 erwartet: 15
7 erwartet: 7
1 erwartet: 1
19
28
37
46
55
64
73
82
91
  • Zeilen 1–6: Die Funktion arbeitet mit ihrem Parameter zahl wie das Programm aus dem Abschnitt über die while-Schleife. Statt die Quersumme auszugeben, gibt sie sie mit return zurück. Wichtig: return steht nach der Schleife, also nicht eingerückt unter while.
  • Zeilen 12–14: Für jede Zahl von 1 bis 100 wird die Funktion aufgerufen. Nur wenn der Rückgabewert 10 ist, wird die Zahl ausgegeben.

Die Variable zahl wird in der Funktion bis auf 0 verkleinert. Das stört das Hauptprogramm nicht: Der Parameter ist eine lokale Variable, und i behält seinen Wert.

1.8.9Das Wichtigste in Kürze

Selbstcheck

1.9Übung: Funktionen lesen, testen und erweitern DS09

Diesen Abschnitt als PDF (S. 123–131)

Das Jupyter-Notebook aus dem Unterricht: DS09_Uebung_Funktionen.ipynb. Herunterladen und in VS Code oder Jupyter öffnen.

Zum Weiterüben: DS09_Weitere_Uebungen.ipynb mit den Aufgaben aus „Weitere Übungen“ zum Bearbeiten in Python.

Leitidee

Im Abschnitt über Funktionen hast du gelernt, eigene Funktionen zu schreiben. Jetzt übst du, was Programmiererinnen und Programmierer jeden Tag tun: fremden Code lesen und verstehen, Fehler finden, Funktionen testen und aus kleinen Funktionen ein größeres Programm zusammensetzen. Dabei lernst du eine wichtige neue Idee kennen: Eine Funktion darf andere Funktionen aufrufen. So entstehen Programme aus Bausteinen, die man einzeln prüfen kann.

Lernziele

Nach diesem Abschnitt kannst du

1.9.1Das brauchst du

Wiederhole kurz das Wichtigste über Funktionen:

def quadrat(zahl):
    return zahl * zahl

print(quadrat(3))
print(quadrat(10))
9
100

Funktionen rufen Funktionen auf

Neu ist nur eine Kleinigkeit: Im Rumpf einer Funktion darf man auch andere Funktionen aufrufen. So kann eine größere Funktion kleinere Hilfsfunktionen benutzen:

def quadrat(zahl):
    return zahl * zahl

def summe_der_quadrate(a, b):
    return quadrat(a) + quadrat(b)

print(summe_der_quadrate(3, 4))
25

Der Vorteil: Jede Funktion erledigt eine kleine, klar umrissene Aufgabe. Ist quadrat einmal getestet, kann man sich darauf verlassen, wo immer man sie benutzt.

Merke

1.9.2Code lesen und erklären

Bevor du ein fremdes Programm ausführst, lohnt es sich, es zu lesen und vorherzusagen, was passiert. So trainierst du, Programme wirklich zu verstehen – und nicht nur auszuprobieren.

Tipp

Erinnere dich an die Rechenzeichen aus dem Abschnitt über Operatoren: a % b ist der Rest der Division (7 % 3 ergibt 1), a // b ist die ganzzahlige Division (7 // 3 ergibt 2). Ist der Rest 0, geht die Division auf. Lies verschachtelte Aufrufe von innen nach außen und schreibe dir für jeden Aufruf die Werte der Parameter auf.

Arbeitsauftrag 105: Code lesen

Lies den folgenden Code, ohne ihn auszuführen.

def ist_teilbar(a, b):
    return a % b == 0

def verarbeite(x, y):
    if ist_teilbar(x, y):
        return x // y
    else:
        return x * y

print(verarbeite(6, 3))
print(verarbeite(5, 3))
  1. Beschreibe in eigenen Worten, was die Funktion verarbeite macht.
  2. Gib an, was print(verarbeite(5, 3)) ausgibt – und was print(verarbeite(6, 3)) ausgibt.

Führe den Code danach aus und überprüfe deine Vermutung.

Meine Erklärung und Vorhersage:

Lösung vergleichen
  1. ist_teilbar(a, b) prüft, ob a durch b teilbar ist, und gibt True oder False zurück. verarbeite(x, y) benutzt diese Hilfsfunktion: Ist x durch y teilbar, gibt sie den Quotienten x // y zurück, sonst das Produkt x * y.
  2. Die Ausgabe ist:
2
15

6 ist durch 3 teilbar (6 % 3 ergibt 0), also wird 6 // 3 = 2 zurückgegeben. 5 ist nicht durch 3 teilbar (5 % 3 ergibt 2), also wird 5 * 3 = 15 zurückgegeben. Das Ablaufprotokoll innerhalb von verarbeite zeigt, welcher Zweig jeweils ausgeführt wird:

Schritt Zeile Anweisung x y
1 5 if ist_teilbar(x, y): 6 3
2 6 return x // y 6 3
3 5 if ist_teilbar(x, y): 5 3
4 8 return x * y 5 3

1.9.3Fehler finden durch Testen

Manche Fehler erzeugen keine Fehlermeldung: Das Programm läuft, aber das Ergebnis ist falsch. Solche Fehler findest du nur durch Testen mit Werten, deren richtiges Ergebnis du kennst. Für die nächste Aufgabe brauchst du die Kreiszahl π\pi.

Werkzeug

Python bringt viele mathematische Werte und Funktionen in einem Modul namens math mit. Ein Modul ist eine Sammlung fertiger Bausteine. Damit du es benutzen kannst, schreibst du einmal am Programmanfang import math – so wie import random beim Würfeln. Danach steht die Kreiszahl als math.pi zur Verfügung:

import math
print(math.pi)
3.141592653589793
Arbeitsauftrag 106: Kreisumfang

Die folgende Funktion soll den Umfang eines Kreises berechnen (Formel: U=2⋅π⋅rU = 2 \cdot \pi \cdot r). Sie gibt aber ein falsches Ergebnis zurück. Finde den Fehler und behebe ihn. Teste die verbesserte Funktion.

import math

def kreisumfang(radius):
    umfang = 2 * radius
    return umfang

# Test: sollte bei radius = 5 etwa 31.4 ergeben
print(kreisumfang(5))
10

Der Fehler:

Lösung vergleichen

In Zeile 4 fehlt der Faktor π\pi. Die Funktion rechnet nur 2⋅r2 \cdot r. Richtig ist:

import math

def kreisumfang(radius):
    umfang = 2 * math.pi * radius
    return umfang

print(kreisumfang(5))
print(round(kreisumfang(5), 2))
print(kreisumfang(0))
31.41592653589793
31.42
0.0

Der Test mit radius = 5 zeigt jetzt etwa 31,4 wie erwartet. Mit round erhält man eine übersichtlichere Ausgabe. Auch der Sonderfall 0 stimmt: Ein Kreis mit Radius 0 hat den Umfang 0. Einen Hinweis auf den Fehler gab übrigens schon die Zeile import math: Das Modul wurde importiert, aber nie benutzt.

Arbeitsauftrag 107: Grenzfälle testen

Ein Online-Shop gibt ab einem Einkaufswert von 50 Euro 10 % Rabatt. Die folgende Funktion soll den Preis nach Abzug des Rabatts zurückgeben:

def rabatt_preis(preis):
    if preis > 50:
        return preis * 0.9
    else:
        return preis
  1. Rechne von Hand aus, was für die Einkaufswerte 20, 50 und 100 Euro herauskommen muss.
  2. Teste die Funktion mit diesen drei Werten. Welcher Test schlägt fehl?
  3. Erkläre den Fehler und verbessere die Funktion.

Erwartete Werte, Testergebnis und Verbesserung:

Lösung vergleichen
  1. Erwartet: 20 Euro bleiben 20 Euro (kein Rabatt). 50 Euro werden zu 45 Euro, denn „ab 50 Euro“ schließt 50 mit ein. 100 Euro werden zu 90 Euro.
  2. Der Test zeigt den Fehler beim Wert 50:
def rabatt_preis(preis):
    if preis > 50:
        return preis * 0.9
    else:
        return preis

print(rabatt_preis(20), "erwartet: 20")
print(rabatt_preis(50), "erwartet: 45")
print(rabatt_preis(100), "erwartet: 90")
20 erwartet: 20
50 erwartet: 45
90.0 erwartet: 90
  1. Die Bedingung preis > 50 ist für genau 50 falsch. „Ab 50“ bedeutet aber „50 oder mehr“. Richtig ist preis >= 50:
def rabatt_preis(preis):
    if preis >= 50:
        return preis * 0.9
    else:
        return preis

print(rabatt_preis(50))
45.0

Solche Fehler an der Grenze sind sehr häufig. Teste deshalb immer auch genau den Grenzwert – hier 50 – und nicht nur Werte deutlich darunter oder darüber.

1.9.4Ein Programm aus mehreren Funktionen

Tipp

Bei der nächsten Aufgabe schreibst du zuerst die beiden kleinen Funktionen und testest jede einzeln. Erst wenn sie stimmen, schreibst du beschreibe_rechteck. Diese Funktion ruft die beiden anderen auf, so wie summe_der_quadrate oben quadrat aufruft. Den Satz setzt du mit + zusammen. Denk daran: Zahlen müssen dafür mit str(...) in Text umgewandelt werden.

Arbeitsauftrag 108: Rechteck

Schreibe drei Funktionen:

Lösung vergleichen
def flaeche_rechteck(a, b):
    return a * b

def umfang_rechteck(a, b):
    return 2 * (a + b)

def beschreibe_rechteck(a, b):
    flaeche = flaeche_rechteck(a, b)
    umfang = umfang_rechteck(a, b)
    return ("Ein Rechteck mit den Seiten " + str(a) + " und "
            + str(b) + " hat die Fläche " + str(flaeche)
            + " und den Umfang " + str(umfang) + ".")

print(flaeche_rechteck(4, 5), umfang_rechteck(4, 5))
print(beschreibe_rechteck(4, 5))
print(beschreibe_rechteck(2.5, 3))
20 18
Ein Rechteck mit den Seiten 4 und 5 hat die Fläche 20 und den Umfang 18.
Ein Rechteck mit den Seiten 2.5 und 3 hat die Fläche 7.5 und den Umfang 11.0.
  • beschreibe_rechteck rechnet nichts selbst, sondern ruft die beiden Hilfsfunktionen auf und speichert ihre Rückgabewerte in den lokalen Variablen flaeche und umfang.
  • Der Satz wird mit + verkettet; alle Zahlen werden vorher mit str(...) umgewandelt. Weil der Ausdruck lang ist, steht er in runden Klammern. Innerhalb von Klammern darf man in der nächsten Zeile weiterschreiben.
  • Die erste print-Zeile testet die beiden Hilfsfunktionen einzeln: 4⋅5=204 \cdot 5 = 20 und 2⋅(4+5)=182 \cdot (4 + 5) = 18.

Auch richtig ist eine Fassung, in der beschreibe_rechteck den Satz selbst mit print ausgibt, z. B. print("Ein Rechteck mit den Seiten", a, "und", b, "hat die Fläche", flaeche, "und den Umfang", str(umfang) + "."). Dann ruft man im Hauptprogramm nur beschreibe_rechteck(4, 5) auf – ohne print drumherum, sonst erscheint zusätzlich None.

Arbeitsauftrag 109 (Zusatz): Maximum von drei Zahlen

Im Abschnitt über Funktionen hast du maximum(a, b) geschrieben:

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

Erweitere das Programm um eine Funktion maximum3(a, b, c), die die größte von drei Zahlen zurückgibt. Benutze dafür die Funktion maximum – maximum3 selbst soll ohne if auskommen. Teste mit mindestens drei Aufrufen, bei denen die größte Zahl jeweils an einer anderen Stelle steht.

Lösung vergleichen
def maximum(a, b):
    if a > b:
        return a
    else:
        return b

def maximum3(a, b, c):
    return maximum(maximum(a, b), c)

print(maximum3(9, 2, 4))
print(maximum3(2, 9, 4))
print(maximum3(2, 4, 9))
9
9
9

Von innen nach außen: maximum(a, b) liefert die größere der ersten beiden Zahlen. Diese wird dann mit c verglichen. Die drei Tests decken alle Positionen der größten Zahl ab – genau dort könnte ein Fehler stecken. Auch richtig: m = maximum(a, b) und dann return maximum(m, c).

1.9.5Weitere Übungen

Hier kannst du das Gelernte weiter üben. Die Punkte im Titel zeigen, wie schwer eine Aufgabe ist: ●○○ leicht, ●●○ mittel, ●●● knifflig. Fang mit den leichten an.

Arbeitsauftrag 110: Verschachtelte Aufrufe ●○○

Lies das Programm, ohne es auszuführen. Gib an, was jede print-Zeile ausgibt. Überprüfe danach am Computer.

def plus_eins(x):
    return x + 1

def doppelt(x):
    return 2 * x

print(doppelt(plus_eins(3)))
print(plus_eins(doppelt(3)))
print(doppelt(doppelt(plus_eins(0))))

Meine Vorhersage:

Lösung vergleichen
def plus_eins(x):
    return x + 1

def doppelt(x):
    return 2 * x

print(doppelt(plus_eins(3)))
print(plus_eins(doppelt(3)))
print(doppelt(doppelt(plus_eins(0))))
8
7
4

Verschachtelte Aufrufe liest du von innen nach außen:

  • plus_eins(3) liefert 4, und doppelt(4) liefert 8.
  • doppelt(3) liefert 6, und plus_eins(6) liefert 7. Die Reihenfolge der Funktionen macht also einen Unterschied.
  • plus_eins(0) liefert 1, doppelt(1) liefert 2, und doppelt(2) liefert 4.
Arbeitsauftrag 111: Kreisfläche ●○○

Die Fläche eines Kreises berechnet man mit der Formel A=π⋅r⋅rA = \pi \cdot r \cdot r.

  1. Implementiere eine Funktion kreisflaeche(radius), die die Fläche zurückgibt. Verwende math.pi.
  2. Teste die Funktion mit den Radien 1, 0 und 2. Zur Kontrolle: Für den Radius 1 muss genau π\pi herauskommen, also etwa 3,14.
Lösung vergleichen
import math

def kreisflaeche(radius):
    return math.pi * radius * radius

print(kreisflaeche(1))
print(kreisflaeche(0))
print(round(kreisflaeche(2), 2))
3.141592653589793
0.0
12.57

Wie beim Kreisumfang muss import math am Anfang stehen, sonst kennt Python math.pi nicht (NameError: name 'math' is not defined). Für den Radius 2 ist die Fläche π⋅4≈12,57\pi \cdot 4 \approx 12{,}57. Statt radius * radius darfst du auch radius ** 2 schreiben.

Arbeitsauftrag 112: Gute Testwerte wählen ●○○

Die Funktion ist_teenager(alter) soll True zurückgeben, wenn jemand 13 bis einschließlich 19 Jahre alt ist, sonst False.

def ist_teenager(alter):
    return alter >= 13 and alter <= 19

Nenne vier Testwerte, mit denen du die Funktion besonders gut prüfen kannst, und gib jeweils das erwartete Ergebnis an. Begründe deine Auswahl in einem Satz.

Testwerte und Begründung:

Lösung vergleichen

Gute Testwerte liegen direkt an den beiden Grenzen, jeweils einer innerhalb und einer außerhalb:

def ist_teenager(alter):
    return alter >= 13 and alter <= 19

print(ist_teenager(12), "erwartet: False")
print(ist_teenager(13), "erwartet: True")
print(ist_teenager(19), "erwartet: True")
print(ist_teenager(20), "erwartet: False")
False erwartet: False
True erwartet: True
True erwartet: True
False erwartet: False

Begründung: An den Grenzen passieren die häufigsten Fehler, zum Beispiel > statt >=. Ein Wert wie 15 oder 40 würde einen solchen Fehler nicht zeigen. Auch andere Werte sind als Ergänzung richtig, solange 13 und 19 dabei sind.

Arbeitsauftrag 113: Ungerade mit Hilfsfunktion ●○○

Im Abschnitt über Funktionen hast du ist_gerade(zahl) geschrieben:

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

Implementiere eine Funktion ist_ungerade(zahl), die True zurückgibt, wenn die Zahl ungerade ist. Benutze dafür die Funktion ist_gerade und den Operator not. Teste mit 7 und mit 10.

Lösung vergleichen
def ist_gerade(zahl):
    return zahl % 2 == 0

def ist_ungerade(zahl):
    return not ist_gerade(zahl)

print(ist_ungerade(7), "erwartet: True")
print(ist_ungerade(10), "erwartet: False")
True erwartet: True
False erwartet: False

ist_ungerade ruft die Hilfsfunktion ist_gerade auf und kehrt ihr Ergebnis mit not um. Eine Zahl ist genau dann ungerade, wenn sie nicht gerade ist. Auch richtig, aber ohne Hilfsfunktion: return zahl % 2 == 1.

Arbeitsauftrag 114: Wo steckt der Fehler? ●●○

Eine Fahrt dauert 2 Stunden und 15 Minuten. Das Programm soll die Fahrzeit in Minuten berechnen, also 135. Es gibt aber 215 aus.

def stunden_zu_minuten(stunden):
    return stunden * 100

def fahrzeit_minuten(stunden, minuten):
    return stunden_zu_minuten(stunden) + minuten

print(fahrzeit_minuten(2, 15))
  1. Beschreibe, wie du durch einen einzelnen Test der Hilfsfunktion herausfindest, in welcher der beiden Funktionen der Fehler steckt.
  2. Behebe den Fehler und teste erneut.

Mein Vorgehen und der Fehler:

Lösung vergleichen
  1. Man testet stunden_zu_minuten allein, zum Beispiel mit print(stunden_zu_minuten(1)). Erwartet sind 60 Minuten, die Funktion liefert aber 100. Der Fehler steckt also in der Hilfsfunktion. fahrzeit_minuten selbst rechnet richtig: Sie addiert die Minuten zum Rückgabewert der Hilfsfunktion.
  2. Eine Stunde hat 60 Minuten, nicht 100:
def stunden_zu_minuten(stunden):
    return stunden * 60

def fahrzeit_minuten(stunden, minuten):
    return stunden_zu_minuten(stunden) + minuten

print(stunden_zu_minuten(1), "erwartet: 60")
print(fahrzeit_minuten(2, 15), "erwartet: 135")
60 erwartet: 60
135 erwartet: 135

Das ist der Vorteil von Hilfsfunktionen: Man kann jede einzeln testen und so den Fehler eingrenzen.

Arbeitsauftrag 115: Versandkosten ●●○

Ein Online-Shop berechnet 5 Euro Versandkosten. Ab einem Warenwert von 30 Euro ist der Versand kostenlos.

  1. Implementiere eine Funktion versandkosten(warenwert), die die Versandkosten zurückgibt (0 oder 5).
  2. Implementiere eine Funktion endpreis(warenwert), die den Warenwert plus Versandkosten zurückgibt. Sie soll versandkosten aufrufen.
  3. Teste endpreis mit den Warenwerten 20, 30 und 45. Überlege vorher, was herauskommen muss.
Lösung vergleichen
def versandkosten(warenwert):
    if warenwert >= 30:
        return 0
    else:
        return 5

def endpreis(warenwert):
    return warenwert + versandkosten(warenwert)

print(endpreis(20), "erwartet: 25")
print(endpreis(30), "erwartet: 30")
print(endpreis(45), "erwartet: 45")
25 erwartet: 25
30 erwartet: 30
45 erwartet: 45

endpreis rechnet selbst nur eine Addition. Ob Versandkosten anfallen, entscheidet die Hilfsfunktion. „Ab 30 Euro“ schließt 30 mit ein, deshalb steht dort >=. Der Test mit genau 30 prüft diese Grenze.

Arbeitsauftrag 116: Pizza-Vergleich ●●○

Was ist mehr Pizza: eine große Pizza mit 32 cm Durchmesser oder zwei kleine mit je 22 cm Durchmesser?

  1. Implementiere eine Funktion pizza_flaeche(durchmesser), die die Fläche einer runden Pizza zurückgibt. Sie soll die Funktion kreisflaeche(radius) aus dem Auftrag Kreisfläche aufrufen. Denk daran: Der Radius ist der halbe Durchmesser.
  2. Berechne damit die Fläche der großen Pizza und die Fläche der beiden kleinen Pizzen zusammen. Gib beide Werte gerundet aus und beantworte die Frage.
Lösung vergleichen
import math

def kreisflaeche(radius):
    return math.pi * radius * radius

def pizza_flaeche(durchmesser):
    return kreisflaeche(durchmesser / 2)

gross = pizza_flaeche(32)
zwei_kleine = 2 * pizza_flaeche(22)
print("Eine große Pizza:", round(gross), "Quadratzentimeter")
print("Zwei kleine Pizzen:", round(zwei_kleine), "Quadratzentimeter")
Eine große Pizza: 804 Quadratzentimeter
Zwei kleine Pizzen: 760 Quadratzentimeter

Die eine große Pizza ist etwas mehr Pizza, obwohl 2⋅22=442 \cdot 22 = 44 cm nach mehr aussieht. Die Fläche wächst nämlich mit dem Quadrat des Radius. pizza_flaeche rechnet nur den Radius aus und überlässt den Rest der Hilfsfunktion kreisflaeche. Typischer Fehler: kreisflaeche(durchmesser) ohne / 2. Dann wird jede Fläche viermal zu groß.

Arbeitsauftrag 117: Primzahlen mit Hilfsfunktionen ●●●

Im Auftrag Primzahl-Test (Übung zu for- und while-Schleife) hast du geprüft, ob eine Zahl eine Primzahl ist. Jetzt zerlegst du die Aufgabe in Funktionen.

  1. Implementiere eine Funktion ist_teiler(t, zahl), die True zurückgibt, wenn t ein Teiler von zahl ist (die Division geht ohne Rest auf).
  2. Implementiere eine Funktion ist_primzahl(zahl), die True oder False zurückgibt. Sie soll ist_teiler benutzen.
  3. Gib mit einer Schleife alle Primzahlen von 1 bis 30 aus.
Tipp

Eine Primzahl ist eine Zahl größer als 1, die nur durch 1 und sich selbst teilbar ist. Gehe in ist_primzahl wie im Auftrag Primzahl-Test vor: Starte mit ergebnis = zahl > 1 und prüfe in einer Schleife alle möglichen Teiler von 2 bis zahl - 1. Findest du einen Teiler, setzt du ergebnis = False.

Lösung vergleichen
def ist_teiler(t, zahl):
    return zahl % t == 0

def ist_primzahl(zahl):
    ergebnis = zahl > 1
    for t in range(2, zahl):
        if ist_teiler(t, zahl):
            ergebnis = False
    return ergebnis

print(ist_teiler(3, 12), ist_teiler(5, 12))
print(ist_primzahl(7), ist_primzahl(9), ist_primzahl(1))

for zahl in range(1, 31):
    if ist_primzahl(zahl):
        print(zahl)
True False
True False False
2
3
5
7
11
13
17
19
23
29
  • Zeilen 1–2: zahl % t == 0 ist True, wenn beim Teilen kein Rest bleibt.
  • Zeilen 4–9: ergebnis ist zuerst True für alle Zahlen größer als 1 und False für 1 (und kleinere Zahlen). Wird ein Teiler zwischen 2 und zahl - 1 gefunden, wird ergebnis auf False gesetzt. Das return steht nach der Schleife.
  • Zeilen 11–12: Erst die Hilfsfunktionen einzeln testen, dann zusammensetzen.
  • Zeilen 14–16: Das Hauptprogramm ruft ist_primzahl für jede Zahl von 1 bis 30 auf.

Ein häufiger Fehler ist return True im else-Teil innerhalb der Schleife. Dann endet die Funktion schon beim ersten Nicht-Teiler, und zum Beispiel 9 gilt als Primzahl (9 ist nicht durch 2 teilbar).

1.9.6Das Wichtigste in Kürze

Selbstcheck

1.10Zeichenketten: Texte Zeichen für Zeichen DS10

Diesen Abschnitt als PDF (S. 132–146)

Das Jupyter-Notebook aus dem Unterricht: DS10_Zeichenketten.ipynb. Herunterladen und in VS Code oder Jupyter öffnen.

Zum Weiterüben: DS10_Weitere_Uebungen.ipynb mit den Aufgaben aus „Weitere Übungen“ zum Bearbeiten in Python.

Leitidee

Namen, Passwörter, Nachrichten – sehr viele Daten in Programmen sind Texte. Bisher hast du Texte nur als Ganzes benutzt: eingelesen, ausgegeben, mit + zusammengesetzt. Oft muss ein Programm aber in einen Text hineinschauen: Wie lang ist das Passwort? Enthält es eine Ziffer? Mit welchem Buchstaben beginnt der Name? Wie viele Vokale stecken in einem Satz? Dafür lernst du in diesem Abschnitt, wie Python einen Text sieht: als eine Reihe einzelner Zeichen, jedes an einer festen Position. Mit diesem Wissen kannst du später sogar Texte verschlüsseln.

Lernziele

Nach diesem Abschnitt kannst du

1.10.1Eine Zeichenkette ist eine Folge von Zeichen

Für Python besteht ein Text aus einzelnen Zeichen, die der Reihe nach hintereinander stehen – wie Perlen auf einer Schnur. Ein Zeichen ist ein Buchstabe, eine Ziffer, ein Satzzeichen oder auch ein Leerzeichen. Jedes Zeichen hat eine feste Position. Diese Positionsnummer heißt Index. Gezählt wird ab 0, nicht ab 1:

Die Zeichenkette "Informatik" in der Variablen text: Jedes Zeichen hat eine Position (Index), gezählt ab 0

Das erste Zeichen I hat also den Index 0, das zweite Zeichen n den Index 1 und das letzte Zeichen k den Index 9. Die Zeichenkette hat 10 Zeichen, aber der größte Index ist 9. Warum ab 0? Man kann sich den Index als Abstand vom Anfang vorstellen: Das erste Zeichen ist 0 Schritte vom Anfang entfernt.

Definition: Zeichenkette

Eine Zeichenkette (englisch string, Datentyp str) ist eine Folge (Sequenz) von Zeichen, z. B. "Informatik". Die Zeichen stehen in einer festen Reihenfolge.

Definition: Index

Der Index gibt die Position eines Zeichens in der Zeichenkette an. Das erste Zeichen hat den Index 0, das zweite den Index 1 und so weiter.

Merke

1.10.2Auf einzelne Zeichen zugreifen

Um ein einzelnes Zeichen zu bekommen, schreibst du hinter die Zeichenkette den Index in eckigen Klammern:

text = "Informatik"
print(text[0])
print(text[2])
print(text[9])
I
f
k

In den eckigen Klammern darf auch eine Variable oder eine Rechnung stehen, zum Beispiel text[i] oder text[i + 1]. Das Ergebnis ist selbst wieder eine Zeichenkette, die aus genau einem Zeichen besteht.

Merke

Zugriff auf ein einzelnes Zeichen: text[index].

1.10.3Die Länge einer Zeichenkette

Wie viele Zeichen eine Zeichenkette hat, verrät dir die Funktion len (von englisch length, „Länge“):

text = "Informatik"
print(len(text))
print(len("Ada Lovelace"))
print(len(""))
10
12
0
Auch das Leerzeichen ist ein Zeichen: In "Ada Lovelace" steht es am Index 3. Die Zeichenkette hat 12 Zeichen

Weil der Index bei 0 beginnt, hat das letzte Zeichen immer den Index len(text) - 1. So findest du es, auch wenn du nicht weißt, wie lang der Text ist – zum Beispiel bei einer Eingabe:

text = "Informatik"
letzter_index = len(text) - 1
print(letzter_index)
print(text[letzter_index])
9
k
Merke

Die Länge einer Zeichenkette erhält man mit len(text). Deshalb hat das letzte Zeichen immer den Index len(text) - 1.

Von hinten zählen

Python erlaubt auch negative Indizes. Sie zählen von hinten: text[-1] ist das letzte Zeichen, text[-2] das vorletzte. Bei "Informatik" ist text[-1] also k und text[-2] ist i. text[-1] ist eine kurze Schreibweise für text[len(text) - 1].

Wenn der Index zu groß ist

Was passiert, wenn du auf ein Zeichen zugreifst, das es gar nicht gibt?

text = "Informatik"
print(text[10])
IndexError: string index out of range
Stolperstein

Ein IndexError bedeutet: „Der Index liegt außerhalb des gültigen Bereichs.“ "Informatik" hat 10 Zeichen, gültig sind also nur die Indizes 0 bis 9 (und −1 bis −10). Der Index 10 gehört schon nicht mehr dazu. Das ist ein sehr häufiger Fehler: Man denkt an die Länge 10 und vergisst, dass ab 0 gezählt wird. Prüfe bei einem IndexError deshalb: Wie lang ist der Text, und welcher Index wurde benutzt? Auch bei der leeren Zeichenkette "" führt schon text[0] zu diesem Fehler.

Merke

Ein Zugriff auf einen ungültigen Index (z. B. text[100] bei kurzem Text) führt zu einer Fehlermeldung (IndexError).

Arbeitsauftrag 118: Zeichen bestimmen

Gegeben ist das folgende Programm. Gib ohne Computer an, was jede Zeile ausgibt. Eine Zeile führt zu einem Fehler – welche, und warum? Überprüfe danach am Computer.

wort = "Python"
print(wort[1])
print(len(wort))
print(wort[len(wort) - 1])
print(wort[-2])
print(wort[6])

Meine Vorhersage:

Lösung vergleichen
wort = "Python"
print(wort[1])
print(len(wort))
print(wort[len(wort) - 1])
print(wort[-2])
print(wort[6])
y
6
n
o
IndexError: string index out of range

wort[1] ist das zweite Zeichen, y. Das Wort hat 6 Zeichen, also hat das letzte Zeichen den Index 5: wort[5] ist n. wort[-2] ist das vorletzte Zeichen, o. Der Index 6 existiert nicht mehr, deshalb bricht die letzte Zeile mit einem IndexError ab.

1.10.4Zeichenketten verketten

Aus dem Abschnitt über Variablen kennst du schon das Verketten mit +: Zwei Zeichenketten werden zu einer neuen, längeren Zeichenkette aneinandergehängt.

vorname = "Ada"
nachname = "Lovelace"
name = vorname + " " + nachname
print(name)
initialen = vorname[0] + nachname[0]
print(initialen)
Ada Lovelace
AL
Merke

Die Verkettung (Konkatenation) zweier Zeichenketten erfolgt mit +.

Werkzeug: f-Strings

Texte mit Zahlen mit + zusammenzusetzen ist mühsam: Jede Zahl muss mit str(...) umgewandelt werden, und die Leerzeichen vergisst man leicht. Bequemer geht es mit einem f-String. Du schreibst ein f direkt vor das erste Anführungszeichen. Im Text darfst du dann Variablen oder Rechnungen in geschweifte Klammern {...} setzen. Python ersetzt sie durch ihren Wert:

name = "Alex"
alter = 15
print(f"{name} ist {alter} Jahre alt.")
print(name + " ist " + str(alter) + " Jahre alt.")
print(f"{name} hat {len(name)} Buchstaben.")
Alex ist 15 Jahre alt.
Alex ist 15 Jahre alt.
Alex hat 4 Buchstaben.

Zeile 3 und Zeile 4 erzeugen dieselbe Ausgabe, aber der f-String kommt ohne str(...) aus. Vergisst du das f, erscheinen die geschweiften Klammern unverändert in der Ausgabe: {name} ist {alter} Jahre alt.

1.10.5Alle Zeichen durchlaufen

Mit einer for-Schleife kannst du nacheinander jedes Zeichen einer Zeichenkette bearbeiten. Statt range(...) schreibst du hinter in einfach die Zeichenkette:

for zeichen in "Bit":
    print(zeichen)
B
i
t

Die Schleifenvariable zeichen bekommt im ersten Durchlauf den Wert "B", im zweiten "i" und im dritten "t". Danach gibt es keine Zeichen mehr, und die Schleife endet. Der Name zeichen ist frei gewählt – du könntest auch buchstabe schreiben.

Zeichen zählen

Eine typische Aufgabe: Zähle, wie oft ein bestimmtes Zeichen vorkommt. Dazu verbindest du die Schleife mit einer Verzweigung und einer Zählvariablen:

wort = "Anna"
anzahl = 0
for zeichen in wort:
    if zeichen == "n":
        anzahl = anzahl + 1
print("Anzahl n:", anzahl)
Anzahl n: 2

Das Ablaufprotokoll zeigt, wie zeichen nacheinander jeden Wert annimmt und anzahl nur bei einem n wächst:

Schritt Zeile Anweisung zeichen anzahl
1 1 wort = "Anna" – –
2 2 anzahl = 0 – 0
3 3 for zeichen in wort: "A" 0
4 4 if zeichen == "n": "A" 0
5 3 for zeichen in wort: "n" 0
6 4 if zeichen == "n": "n" 0
7 5 anzahl = anzahl + 1 "n" 1
8 3 for zeichen in wort: "n" 1
9 4 if zeichen == "n": "n" 1
10 5 anzahl = anzahl + 1 "n" 2
11 3 for zeichen in wort: "a" 2
12 4 if zeichen == "n": "a" 2
13 3 for zeichen in wort: "a" 2
14 6 print("Anzahl n:", anzahl) "a" 2

Beachte: Das große A am Anfang wird nicht gezählt, denn "A" und "a" sind für Python verschiedene Zeichen.

Einen neuen Text aufbauen

In einer Schleife kann man auch Zeichen für Zeichen eine neue Zeichenkette zusammensetzen. Man beginnt mit der leeren Zeichenkette "" und hängt in jedem Durchlauf etwas an:

neu = ""
for zeichen in "Bit":
    neu = neu + zeichen + zeichen
print(neu)
BBiitt

Jedes Zeichen wird doppelt angehängt: Aus "" wird "BB", dann "BBii" und schließlich "BBiitt".

Schleife über die Indizes

Manchmal brauchst du nicht nur das Zeichen, sondern auch seine Position. Dann lässt du die Schleife über alle Indizes laufen. range(len(text)) liefert genau die gültigen Indizes 0, 1, …, len(text) - 1:

text = "Bit"
for i in range(len(text)):
    print(i, text[i])
0 B
1 i
2 t
Merke

1.10.6Ist ein Zeichen enthalten?

Mit dem Wort in prüfst du, ob ein Zeichen – oder ein ganzes Textstück – in einer Zeichenkette vorkommt. Das Ergebnis ist True oder False:

print("a" in "Banane")
print("x" in "Banane")
print("nan" in "Banane")
print("B" in "banane")
True
False
True
False

Die letzte Zeile zeigt wieder: Groß- und Kleinbuchstaben sind verschieden. Besonders praktisch ist in mit einer Zeichenkette, die alle „erlaubten“ Zeichen enthält. So prüfst du zum Beispiel, ob ein Buchstabe ein Vokal ist:

buchstabe = "e"
if buchstabe in "aeiou":
    print(buchstabe, "ist ein Vokal.")
e ist ein Vokal.

1.10.7Groß- und Kleinschreibung

Für Python sind "Ja", "ja" und "JA" drei verschiedene Zeichenketten. Oft ist die Schreibweise aber egal. Dann hilft es, alles in Klein- oder Großbuchstaben umzuwandeln:

text = "Hallo Welt"
print(text.upper())
print(text.lower())
print(text)
HALLO WELT
hallo welt
Hallo Welt

Die Schreibweise mit dem Punkt ist neu: upper wird nicht wie len(text) mit dem Text in Klammern aufgerufen, sondern hinter dem Text, verbunden durch einen Punkt. Solche Funktionen nennt man Methoden.

Definition: Methode

Eine Methode ist eine Funktion, die zu einem Wert gehört. Man ruft sie mit einem Punkt hinter dem Wert auf: text.upper(). Die Klammern dürfen auch leer sein, aber sie dürfen nicht fehlen.

Praktisch ist das bei Eingaben: Mit if antwort.lower() == "ja": erkennt ein Programm die Antwort, egal ob jemand ja, Ja oder JA eintippt.

Stolperstein

Eine Zeichenkette lässt sich nicht verändern. text.lower() allein ändert text deshalb nicht:

text = "Hallo"
text.lower()
print(text)
Hallo

Das Ergebnis von text.lower() wurde nirgends gespeichert und ist verloren. Richtig ist text = text.lower(): Die Variable text bekommt dann die neue, kleingeschriebene Zeichenkette.

1.10.8Zeichen prüfen: Buchstabe oder Ziffer?

Zwei weitere Methoden prüfen, woraus eine Zeichenkette besteht. Sie liefern True oder False:

print("Hallo".isalpha())
print("Hallo Welt".isalpha())
print("2026".isdigit())
print("-5".isdigit())
print("3.5".isdigit())
True
False
True
False
False

"Hallo Welt" enthält ein Leerzeichen, und das ist kein Buchstabe. "-5" und "3.5" sind zwar Zahlen, aber das Minuszeichen und der Punkt sind keine Ziffern.

Damit kannst du den ValueError vermeiden, der bei int(...) mit einer falschen Eingabe entsteht: Das Programm wandelt die Eingabe nur um, wenn sie aus Ziffern besteht.

eingabe = input("Wie alt bist du? ")
if eingabe.isdigit():
    print("In fünf Jahren bist du", int(eingabe) + 5)
else:
    print("Bitte gib eine ganze Zahl mit Ziffern ein.")
Wie alt bist du? «fünfzehn»
Bitte gib eine ganze Zahl mit Ziffern ein.

1.10.9Zusatzwissen: Ausschnitte (Slicing)

Werkzeug: Slicing

Diesen Teil brauchst du für die Aufgaben nicht – er zeigt dir eine praktische Abkürzung. Mit zwei Indizes und einem Doppelpunkt in den eckigen Klammern schneidest du einen Ausschnitt (englisch slice) aus einer Zeichenkette heraus: text[start:ende]. Das Zeichen am Index start gehört dazu, das Zeichen am Index ende nicht mehr.

text = "Informatik"
print(text[0:4])
print(text[2:6])
print(text[::-1])
Info
form
kitamrofnI

text[0:4] enthält die Zeichen mit den Indizes 0, 1, 2 und 3. Die Schreibweise text[::-1] ist ein Trick: Sie durchläuft den ganzen Text mit der Schrittweite −1, also rückwärts.

Merke: Zusatzwissen

Ein Ausschnitt (Slice) wird mit text[start:ende] erzeugt (das Zeichen am Index ende ist nicht mehr enthalten).

1.10.10Übungen

Arbeitsauftrag 119: Zeichen-Steckbrief

Schreibe ein Programm, das ein Wort einliest und Folgendes ausgibt:

So könnte es aussehen:

Wort eingeben: «Python»
Länge: 6
Erstes Zeichen: P
Letztes Zeichen: n
Rückwärts: nohtyP
Tipp

Für das Rückwärts-Wort baust du in einer Schleife einen neuen Text auf, wie im Abschnitt Einen neuen Text aufbauen. Der Trick: Hänge jedes Zeichen vorne an, nicht hinten. Also nicht rueckwaerts + zeichen, sondern zeichen + rueckwaerts.

Lösung vergleichen
wort = input("Wort eingeben: ")
print("Länge:", len(wort))
print("Erstes Zeichen:", wort[0])
print("Letztes Zeichen:", wort[len(wort) - 1])
rueckwaerts = ""
for zeichen in wort:
    rueckwaerts = zeichen + rueckwaerts
print("Rückwärts:", rueckwaerts)
Wort eingeben: «Python»
Länge: 6
Erstes Zeichen: P
Letztes Zeichen: n
Rückwärts: nohtyP

Das letzte Zeichen steht am Index len(wort) - 1; ebenso richtig ist wort[-1]. Für das Umdrehen startet rueckwaerts leer. Weil jedes neue Zeichen vor den bisherigen Text gesetzt wird, steht das erste Zeichen am Ende ganz hinten. Das zeigt das Ablaufprotokoll dieses kurzen Programms für das Wort "Bit":

wort = "Bit"
rueckwaerts = ""
for zeichen in wort:
    rueckwaerts = zeichen + rueckwaerts
print(rueckwaerts)
tiB
Schritt Zeile Anweisung zeichen rueckwaerts
1 1 wort = "Bit" – –
2 2 rueckwaerts = "" – ""
3 3 for zeichen in wort: "B" ""
4 4 rueckwaerts = zeichen + rueckwaerts "B" "B"
5 3 for zeichen in wort: "i" "B"
6 4 rueckwaerts = zeichen + rueckwaerts "i" "iB"
7 3 for zeichen in wort: "t" "iB"
8 4 rueckwaerts = zeichen + rueckwaerts "t" "tiB"
9 3 for zeichen in wort: "t" "tiB"
10 5 print(rueckwaerts) "t" "tiB"

Mit dem Zusatzwissen geht das Umdrehen auch kürzer: print("Rückwärts:", wort[::-1]).

Mit einem f-String lässt sich die Ausgabe ebenfalls schreiben, z. B. print(f"Länge: {len(wort)}").

Arbeitsauftrag 120: Vokale zählen

Schreibe ein Programm, das einen Satz einliest und mit einer Schleife zählt, wie viele Vokale (a, e, i, o, u) darin vorkommen. Gib die Anzahl aus. Auch großgeschriebene Vokale sollen mitgezählt werden.

Tipp

Kombiniere drei Dinge aus diesem Abschnitt: die Schleife über alle Zeichen, die Zählvariable aus dem Beispiel "Anna" und die Prüfung zeichen in "aeiou". Gegen das Problem mit den Großbuchstaben hilft .lower().

Lösung vergleichen
satz = input("Satz eingeben: ")
anzahl_vokale = 0
for zeichen in satz.lower():
    if zeichen in "aeiou":
        anzahl_vokale = anzahl_vokale + 1
print("Anzahl Vokale:", anzahl_vokale)
Satz eingeben: «Informatik macht Spaß»
Anzahl Vokale: 6

Die Schleife läuft über satz.lower(), also über den Satz in Kleinbuchstaben. Dadurch wird auch das große I am Anfang gezählt: i, o, a, i, a, a ergibt 6. Ohne .lower() käme 5 heraus. Umlaute zählt das Programm nicht mit; wer möchte, schreibt "aeiouäöü".

Arbeitsauftrag 121: Passwort prüfen

Ein Passwort gilt hier als sicher, wenn es mindestens 8 Zeichen lang ist und mindestens eine Ziffer enthält. Implementiere eine Funktion ist_sicher(passwort), die True oder False zurückgibt. Teste sie mit einem zu kurzen Passwort, einem langen Passwort ohne Ziffer und einem sicheren Passwort.

Lösung vergleichen
def ist_sicher(passwort):
    anzahl_ziffern = 0
    for zeichen in passwort:
        if zeichen.isdigit():
            anzahl_ziffern = anzahl_ziffern + 1
    return len(passwort) >= 8 and anzahl_ziffern >= 1

print(ist_sicher("abc1"))
print(ist_sicher("sommerferien"))
print(ist_sicher("sommer2026"))
False
False
True

Die Schleife zählt wie im Beispiel "Anna", prüft aber mit zeichen.isdigit(), ob das einzelne Zeichen eine Ziffer ist. Die return-Zeile verknüpft beide Bedingungen mit and. Das Ergebnis ist schon True oder False und kann direkt zurückgegeben werden. Die drei Tests decken alle Fälle ab: "abc1" ist zu kurz, "sommerferien" hat keine Ziffer, nur "sommer2026" erfüllt beide Bedingungen.

Arbeitsauftrag 122 (Zusatz): Palindrom

Ein Palindrom ist ein Wort, das vorwärts und rückwärts gelesen gleich ist, z. B. „Anna“ oder „Rentner“. Schreibe eine Funktion ist_palindrom(wort), die True oder False zurückgibt. Groß- und Kleinschreibung soll dabei keine Rolle spielen (Tipp: text.lower()). Teste mit „Anna“, „Rentner“ und „Informatik“.

Lösung vergleichen
def ist_palindrom(wort):
    wort = wort.lower()
    rueckwaerts = ""
    for zeichen in wort:
        rueckwaerts = zeichen + rueckwaerts
    return wort == rueckwaerts

print(ist_palindrom("Anna"))
print(ist_palindrom("Rentner"))
print(ist_palindrom("Informatik"))
True
True
False

Zuerst wird das Wort in Kleinbuchstaben umgewandelt, sonst wäre "Anna" rückwärts "annA" und damit verschieden. Dann wird es wie im Zeichen-Steckbrief umgedreht. Der Vergleich wort == rueckwaerts ist True oder False und wird direkt zurückgegeben.

Eine andere Idee vergleicht Zeichen paarweise: das erste mit dem letzten, das zweite mit dem vorletzten und so weiter. Findet man ein ungleiches Paar, ist es kein Palindrom:

def ist_palindrom(wort):
    wort = wort.lower()
    for i in range(len(wort)):
        if wort[i] != wort[len(wort) - 1 - i]:
            return False
    return True

print(ist_palindrom("Anna"), ist_palindrom("Informatik"))
True False

Mit dem Zusatzwissen geht es in einer Zeile: return wort == wort[::-1].

1.10.11Weitere Übungen

Hier kannst du das Gelernte weiter üben. Die Punkte im Titel zeigen, wie schwer eine Aufgabe ist: ●○○ leicht, ●●○ mittel, ●●● knifflig. Fang mit den leichten an.

Arbeitsauftrag 123: Index und Zeichen ●○○

Gegeben ist wort = "Freibad". Bestimme ohne Computer die Werte der Ausdrücke. Prüfe danach mit print(...) am Computer.

wort[0] wort[3] wort[-1] len(wort) wort[len(wort) - 2]

Gib außerdem an, an welchem Index das Zeichen b steht.

Das Zeichen b steht am Index:

Lösung vergleichen
wort[0] wort[3] wort[-1] len(wort) wort[len(wort) - 2]
F i d 7 a
wort = "Freibad"
print(wort[0], wort[3], wort[-1])
print(len(wort))
print(wort[len(wort) - 2])
F i d
7
a

Schreibe dir die Indizes über die Buchstaben: F hat den Index 0, r den Index 1, e den Index 2, i den Index 3, b den Index 4, a den Index 5 und d den Index 6. len(wort) - 2 ist 7−2=57 - 2 = 5, also das vorletzte Zeichen.

Arbeitsauftrag 124: Ausgabe vorhersagen ●○○

Gib ohne Computer an, was das Programm ausgibt. Überprüfe danach am Computer.

text = "Klasse 10a"
print(len(text))
print(text[7] + text[8])
print("s" in text)
print("S" in text)
print(text.lower())

Meine Vorhersage:

Lösung vergleichen
text = "Klasse 10a"
print(len(text))
print(text[7] + text[8])
print("s" in text)
print("S" in text)
print(text.lower())
10
10
True
False
klasse 10a
  • "Klasse 10a" hat 10 Zeichen, das Leerzeichen zählt mit.
  • Am Index 7 steht 1, am Index 8 steht 0. Das sind Zeichen, keine Zahlen. + hängt sie aneinander, das ergibt den Text 10 (und nicht die Zahl 1).
  • Ein kleines s kommt vor, ein großes S nicht.
  • .lower() macht aus K ein k. Ziffern und Leerzeichen bleiben, wie sie sind.
Arbeitsauftrag 125: Initialen ●○○

Implementiere eine Funktion initialen(vorname, nachname), die die Initialen mit Punkten zurückgibt, zum Beispiel für „Mia“ und „Becker“ die Zeichenkette M. B.. Teste die Funktion mit zwei verschiedenen Namen.

Lösung vergleichen
def initialen(vorname, nachname):
    return vorname[0] + ". " + nachname[0] + "."

print(initialen("Mia", "Becker"))
print(initialen("Jonas", "Schmitt"))
M. B.
J. S.

vorname[0] ist der erste Buchstabe des Vornamens. Mit + werden vier Zeichenketten verkettet: der erste Buchstabe, ". " (Punkt und Leerzeichen), der erste Buchstabe des Nachnamens und ".". Typischer Fehler: vorname[1]. Das ist schon der zweite Buchstabe.

Arbeitsauftrag 126: Buchstaben zählen ●○○

Implementiere eine Funktion zaehle(text, zeichen), die zurückgibt, wie oft zeichen in text vorkommt. Teste sie mit diesen Aufrufen:

Aufruf erwartet tatsächlich
zaehle("Banane", "a") 2
zaehle("Mississippi", "s") 4
zaehle("Hallo", "x") 0
Lösung vergleichen
def zaehle(text, zeichen):
    anzahl = 0
    for z in text:
        if z == zeichen:
            anzahl = anzahl + 1
    return anzahl

print(zaehle("Banane", "a"))
print(zaehle("Mississippi", "s"))
print(zaehle("Hallo", "x"))
2
4
0

Das ist das Muster aus dem Beispiel "Anna", verpackt in eine Funktion. Die Schleifenvariable heißt hier z, weil der Name zeichen schon für den Parameter vergeben ist. Das return steht nach der Schleife. Der Test mit "x" prüft den Sonderfall, dass das Zeichen gar nicht vorkommt.

Arbeitsauftrag 127: Zwei Fehler finden ●●○

Das Programm soll zählen, wie oft der Buchstabe e im Satz vorkommt, egal ob groß oder klein. Erwartet ist 7. Stattdessen bricht es mit einem Fehler ab.

satz = "Eine Elefantenherde"
satz.lower()
anzahl = 0
for i in range(1, len(satz) + 1):
    if satz[i] == "e":
        anzahl = anzahl + 1
print(anzahl)
  1. Gib an, welche Fehlermeldung erscheint, und erkläre sie.
  2. Das Programm enthält noch einen zweiten Fehler. Er würde dafür sorgen, dass die großen E nicht mitgezählt werden. Erkläre ihn.
  3. Schreibe das Programm richtig auf.

Die beiden Fehler:

Lösung vergleichen
  1. Es erscheint ein IndexError:
satz = "Eine Elefantenherde"
satz.lower()
anzahl = 0
for i in range(1, len(satz) + 1):
    if satz[i] == "e":
        anzahl = anzahl + 1
print(anzahl)
IndexError: string index out of range

Der Satz hat 19 Zeichen, gültig sind also die Indizes 0 bis 18. range(1, len(satz) + 1) erzeugt aber die Zahlen 1 bis 19. Der Index 19 existiert nicht. Außerdem wird das erste Zeichen (Index 0) übersprungen. Richtig ist range(len(satz)).

  1. satz.lower() erzeugt zwar den Text in Kleinbuchstaben, aber das Ergebnis wird nicht gespeichert. satz bleibt unverändert, und die beiden großen E würden nicht gezählt. Richtig ist satz = satz.lower().

  2. Die verbesserte Fassung:

satz = "Eine Elefantenherde"
satz = satz.lower()
anzahl = 0
for i in range(len(satz)):
    if satz[i] == "e":
        anzahl = anzahl + 1
print(anzahl)
7

Noch einfacher ist die Schleife über die Zeichen: for zeichen in satz: mit if zeichen == "e":. Dann kann es gar keinen IndexError geben.

Arbeitsauftrag 128: Ohne Leerzeichen ●●○

Implementiere eine Funktion ohne_leerzeichen(text), die eine neue Zeichenkette zurückgibt, in der alle Leerzeichen fehlen. Teste mit "Hallo Welt" (erwartet: HalloWelt) und mit "0151 234 567" (erwartet: 0151234567).

Tipp

Baue wie im Abschnitt Einen neuen Text aufbauen einen neuen Text auf. Beginne mit "" und hänge nur die Zeichen an, die kein Leerzeichen sind. Ein Leerzeichen schreibst du als " ".

Lösung vergleichen
def ohne_leerzeichen(text):
    neu = ""
    for zeichen in text:
        if zeichen != " ":
            neu = neu + zeichen
    return neu

print(ohne_leerzeichen("Hallo Welt"))
print(ohne_leerzeichen("0151 234 567"))
HalloWelt
0151234567

Die Schleife geht jedes Zeichen durch. Nur wenn es ungleich " " ist, wird es an neu angehängt. Leerzeichen werden einfach übersprungen. Typischer Fehler: neu = "" in die Schleife schreiben. Dann wird der neue Text in jedem Durchlauf wieder gelöscht, und am Ende steht nur das letzte Zeichen darin.

Arbeitsauftrag 129: Vokale tauschen ●●○

Ein bekanntes Sprachspiel: Man ersetzt in einem Satz alle Vokale durch denselben Vokal. Aus „Wir sehen uns morgen“ wird dann „Wir sihin ins mirgin“. Implementiere eine Funktion nur_i(text), die eine neue Zeichenkette zurückgibt, in der jeder Vokal (a, e, i, o, u, auch großgeschrieben) durch ein kleines i ersetzt ist. Alle anderen Zeichen bleiben unverändert. Teste mit "Wir sehen uns morgen" und mit "Otto".

Lösung vergleichen
def nur_i(text):
    neu = ""
    for zeichen in text:
        if zeichen in "aeiouAEIOU":
            neu = neu + "i"
        else:
            neu = neu + zeichen
    return neu

print(nur_i("Wir sehen uns morgen"))
print(nur_i("Otto"))
Wir sihin ins mirgin
itti

Für jedes Zeichen gibt es zwei Fälle: Ist es ein Vokal, wird "i" angehängt, sonst das Zeichen selbst. Die Prüfung zeichen in "aeiouAEIOU" erledigt die Groß- und Kleinbuchstaben auf einmal. Der zweite Test zeigt, dass auch ein großer Vokal am Anfang ersetzt wird. Wer möchte, macht aus dem "i" einen zweiten Parameter vokal und probiert alle Vokale durch.

Arbeitsauftrag 130: Handynummer verbergen ●●●

Auf Rechnungen wird eine Handynummer oft nur teilweise gezeigt, zum Beispiel *********678. Implementiere eine Funktion verberge(nummer), die eine neue Zeichenkette zurückgibt. Darin ist jedes Zeichen durch * ersetzt – außer den letzten drei Zeichen. Teste mit "015112345678" (erwartet: *********678) und "12345" (erwartet: **345).

Tipp

Hier brauchst du die Position jedes Zeichens. Lass die Schleife deshalb über die Indizes laufen: for i in range(len(nummer)):. Überlege: Ab welchem Index beginnen die letzten drei Zeichen? Bei 12 Zeichen sind das die Indizes 9, 10 und 11.

Lösung vergleichen
def verberge(nummer):
    neu = ""
    for i in range(len(nummer)):
        if i < len(nummer) - 3:
            neu = neu + "*"
        else:
            neu = neu + nummer[i]
    return neu

print(verberge("015112345678"))
print(verberge("12345"))
*********678
**345
  • Zeile 3: i durchläuft alle Indizes von 0 bis len(nummer) - 1.
  • Zeile 4: Die letzten drei Zeichen beginnen beim Index len(nummer) - 3. Bei 12 Zeichen ist das der Index 9. Alle kleineren Indizes werden durch * ersetzt.
  • Zeile 7: Die letzten drei Zeichen werden mit nummer[i] übernommen.

Weil die Grenze mit len(nummer) berechnet wird, funktioniert die Funktion für Nummern jeder Länge. Ein häufiger Fehler ist i < 9: Das stimmt nur für Nummern mit genau 12 Zeichen.

1.10.12Das Wichtigste in Kürze

Selbstcheck

1.11Listen: viele Werte unter einem Namen DS11

Diesen Abschnitt als PDF (S. 147–162)

Das Jupyter-Notebook aus dem Unterricht: DS11_Listen_Felder.ipynb. Herunterladen und in VS Code oder Jupyter öffnen.

Zum Weiterüben: DS11_Weitere_Uebungen.ipynb mit den Aufgaben aus „Weitere Übungen“ zum Bearbeiten in Python.

Leitidee

Stell dir vor, du willst die Noten deiner letzten fünf Klassenarbeiten in einem Programm speichern. Mit dem, was du bisher kennst, brauchst du dafür fünf Variablen: note1, note2 und so weiter. Bei den Noten einer ganzen Klasse oder bei den Temperaturen eines ganzen Jahres wird das schnell unübersichtlich. Programme brauchen deshalb eine Möglichkeit, viele Werte unter einem Namen zu speichern: die Liste. Vieles daran kennst du schon von den Zeichenketten – auch in einer Liste hat jeder Wert eine Position, und gezählt wird ab 0. Am Ende dieses Abschnitts programmierst du eine Einkaufsliste.

Lernziele

Nach diesem Abschnitt kannst du

1.11.1Warum Listen?

Speicherst du fünf Noten in fünf Variablen note1 bis note5, hat das zwei Schwächen. Kommt eine sechste Note dazu, brauchst du eine neue Variable und musst jede Rechnung ändern, die alle Noten benutzt. Außerdem kannst du keine Schleife über note1 bis note5 laufen lassen: Für Python sind das fünf völlig unabhängige Namen.

Mit einer Liste speicherst du alle Noten in einer Variablen:

noten = [2, 3, 1, 4, 2]
print(noten)
print(type(noten))
[2, 3, 1, 4, 2]
<class 'list'>

Die Werte in einer Liste heißen Elemente. Sie stehen in einer festen Reihenfolge hintereinander, wie die Waggons eines Zuges: Es gibt ein erstes und ein letztes Element, und jedes andere Element hat genau einen Vorgänger und einen Nachfolger. Man sagt deshalb: Eine Liste ist eine lineare Datenstruktur.

Die Liste noten mit fünf Elementen. Über jedem Element steht seine Position, der Index
Definition: Liste bzw. Feld

Eine Liste (auch Feld genannt) ist eine Datenstruktur, die mehrere Werte – die Elemente – in einer festen Reihenfolge zu einer Einheit zusammenfasst. In Python schreibt man sie in eckigen Klammern, z. B. [2, 3, 1, 4, 2].

Liste oder Feld?

In Python heißt diese Datenstruktur Liste (list). In anderen Programmiersprachen wie Java oder C begegnet dir dafür das Wort Feld (englisch array). Ein Feld hat dort meist eine feste Länge. Eine Python-Liste kann dagegen wachsen und schrumpfen. Die Grundidee ist dieselbe: viele Elemente in einer Reihe, durchnummeriert ab 0.

Weitere Listen

In einer Liste können auch Zeichenketten oder Kommazahlen stehen, z. B. [1.99, 0.49, 2.5]. Eine Liste kann sogar leer sein:

staedte = ["Saarbrücken", "Trier", "Mainz"]
leer = []
print(staedte)
print(leer)
['Saarbrücken', 'Trier', 'Mainz']
[]

Beachte die Ausgabe in der ersten Zeile: Python zeigt Zeichenketten in einer Liste mit einfachen Anführungszeichen '…' an. Das ist nur die Art der Anzeige. Im Programm darfst du "…" oder '…' schreiben. In diesem Skript verwenden wir immer "…".

Die leere Liste [] in Zeile 2 sieht nutzlos aus. Sie ist aber praktisch: Man legt sie an und füllt sie später nach und nach.

Merke

Eine Liste (in Python: list) fasst mehrere Elemente zu einer Einheit zusammen, z. B. noten = [2, 3, 1, 4, 2].

1.11.2Index und Element

Denk an die Schließfächer in deiner Schule. Jedes Fach hat eine Nummer an der Tür, und in jedem Fach liegt ein Inhalt. Wer „Fach 2“ sagt, meint die Nummer – nicht das, was darin liegt.

Bei einer Liste ist es genauso. Jedes Element hat eine Positionsnummer, den Index. Wie bei Zeichenketten beginnt die Zählung bei 0: Das erste Element hat den Index 0, das zweite den Index 1 und so weiter.

Definition: Index und Element

Der Index ist die Positionsnummer eines Elements in einer Liste. Er beginnt bei 0. Das Element (Listenelement) ist der Wert, der an dieser Position gespeichert ist.

Lesender Zugriff

Um ein einzelnes Element zu lesen, schreibst du den Index in eckigen Klammern hinter den Namen der Liste – genau wie bei Zeichenketten:

noten = [2, 3, 1, 4, 2]
print(noten[0])
print(noten[2])
erste = noten[0]
print("Die erste Note ist", erste)
2
1
Die erste Note ist 2
Der Ausdruck noten\[2\] liefert das Element am Index 2. Das ist die 1, nicht die 2

Gerade bei Listen mit kleinen Zahlen verwechselt man Index und Element leicht. In der Liste noten kommt das Element 2 zweimal vor: am Index 0 und am Index 4. Am Index 2 steht dagegen das Element 1.

Die Länge einer Liste

Wie viele Elemente eine Liste hat, verrät dir len(...) – wie bei Zeichenketten:

noten = [2, 3, 1, 4, 2]
print(len(noten))
print(noten[len(noten) - 1])
5
2

Die Liste hat fünf Elemente. Weil die Zählung bei 0 beginnt, hat das letzte Element aber den Index 4, also len(noten) - 1. Zeile 3 liest deshalb das letzte Element. Das funktioniert für jede Liste, egal wie lang sie ist.

Negative Indizes

Von den Zeichenketten kennst du schon eine Abkürzung: Ein negativer Index zählt von hinten. noten[-1] ist das letzte Element (die 2), noten[-2] das vorletzte (die 4).

Unter jedem Element steht der negative Index. Er zählt von hinten, beginnend bei -1
Merke
Arbeitsauftrag 131: Index oder Element?

Gegeben ist die Liste zahlen = [3, 0, 4, 1, 2]. Bestimme ohne Computer, welchen Wert die Ausdrücke haben. Prüfe danach mit print(...) am Computer.

zahlen[1] len(zahlen) zahlen[-1] zahlen[zahlen[0]]

Gib außerdem an: An welchem Index steht das Element 4?

Das Element 4 steht am Index:

Lösung vergleichen
zahlen[1] len(zahlen) zahlen[-1] zahlen[zahlen[0]]
0 5 2 1
zahlen = [3, 0, 4, 1, 2]
print(zahlen[1])
print(len(zahlen))
print(zahlen[-1])
print(zahlen[zahlen[0]])
0
5
2
1

Der letzte Ausdruck wird von innen nach außen ausgewertet: zahlen[0] ist 3, und zahlen[3] ist 1. Das Element 4 steht am Index 2.

1.11.3Schreibender Zugriff: ein Element ändern

Ein Schließfach kann man ausräumen und neu füllen – die Nummer bleibt gleich. Genauso kannst du ein Listenelement überschreiben. Der Zugriff mit Index steht dann links vom =:

noten = [2, 3, 1, 4, 2]
noten[1] = 5
print(noten)
noten[2] = noten[2] + 1
print(noten)
[2, 5, 1, 4, 2]
[2, 5, 2, 4, 2]

Die Länge der Liste ändert sich dabei nicht. Es werden nur Inhalte ausgetauscht.

Vorher: Am Index 1 steht die 3
Nachher (nach noten\[1\] = 5): Am Index 1 steht die 5. Alle anderen Elemente sind unverändert
Merke

Schreibender Zugriff: liste[index] = neuer_wert überschreibt das Element an dieser Position.

Stolperstein

Bei Zeichenketten geht das nicht. Eine Zeichenkette kann man nur lesen, aber nicht stellenweise ändern:

wort = "Hallo"
wort[0] = "B"
TypeError: 'str' object does not support item assignment

Die Meldung heißt: „Ein str-Objekt unterstützt keine Zuweisung an einzelne Stellen.“ Listen sind dagegen veränderbar. Das ist ein wichtiger Unterschied zwischen den beiden Datenstrukturen.

1.11.4Ungültige Position: der IndexError

Was passiert, wenn du auf einen Index zugreifst, den es gar nicht gibt?

noten = [2, 3, 1, 4, 2]
print(noten[5])
Traceback (most recent call last):
  File "noten.py", line 2, in <module>
    print(noten[5])
          ~~~~~^^^
IndexError: list index out of range

Lies die Meldung wieder von unten nach oben: IndexError heißt „Fehler beim Index“. list index out of range bedeutet: „Der Listenindex liegt außerhalb des gültigen Bereichs.“ Die Zeilen darüber zeigen, dass der Fehler in Zeile 2 passiert ist, und die Zeichen ^^^ zeigen auf [5].

Die Liste hat fünf Elemente. Gültig sind also nur die Indizes 0 bis 4 (und von hinten −1 bis −5). Einen Index 5 gibt es nicht.

Auch beim Schreiben an eine Stelle, die es nicht gibt, meldet Python einen Fehler. Eine Liste wird durch eine Zuweisung nicht automatisch länger:

noten = [2, 3, 1, 4, 2]
noten[5] = 1
IndexError: list assignment index out of range

list assignment index out of range heißt: „Der Index für die Zuweisung liegt außerhalb des gültigen Bereichs.“ Um ein Element hinzuzufügen, brauchst du append aus dem nächsten Abschnitt.

Merke

Ein Zugriff auf einen ungültigen Index führt zu einer Fehlermeldung (IndexError). Gültig sind bei einer Liste mit n Elementen nur die Indizes 0 bis n - 1.

Die häufigste Ursache für einen IndexError: Man zählt aus Gewohnheit ab 1 und greift mit liste[len(liste)] auf das „letzte“ Element zu. Der größte gültige Index ist aber len(liste) - 1. Prüfe bei einem IndexError immer: Wie lang ist die Liste gerade, und welchen Index habe ich benutzt?

1.11.5Listen verändern: Elemente hinzufügen und entfernen

Eine Liste kann wachsen und schrumpfen. Dafür gibt es eigene Methoden, die man mit einem Punkt an den Namen der Liste hängt: liste.methode(...). Methoden kennst du schon von den Zeichenketten, zum Beispiel text.upper().

Ein Element anhängen: append

append heißt „anhängen“. Die Methode fügt ein neues Element am Ende der Liste an. Nach noten.append(6) ist die Liste noten um ein Element länger. Das neue Element hat den Index 5:

Nach noten.append(6): Das neue Element steht am Ende, am Index 5
Merke

Mit liste.append(wert) wird ein neues Element ans Ende der Liste angehängt.

Das Beispiel im Ganzen

Das folgende Programm fasst alles zusammen, was du bis jetzt über Listen gelernt hast – auch append. Überlege zuerst, was es ausgibt. Lies dann weiter.

noten = [2, 3, 1, 4, 2]

print(noten)
print("Anzahl Noten:", len(noten))
print("Erste Note (Index 0):", noten[0])
print("Dritte Note (Index 2):", noten[2])

noten[1] = 5
print("Nach Änderung:", noten)

noten.append(6)
print("Nach append:", noten)
[2, 3, 1, 4, 2]
Anzahl Noten: 5
Erste Note (Index 0): 2
Dritte Note (Index 2): 1
Nach Änderung: [2, 5, 1, 4, 2]
Nach append: [2, 5, 1, 4, 2, 6]

Ein Element einfügen: insert

Mit liste.insert(index, wert) fügst du ein Element an einer beliebigen Stelle ein. Der erste Wert in den Klammern ist der Index, an dem das neue Element stehen soll, der zweite ist das Element selbst:

einkauf = ["Brot", "Milch", "Eier"]
einkauf.insert(1, "Käse")
print(einkauf)
['Brot', 'Käse', 'Milch', 'Eier']

Der Käse steht jetzt am Index 1. Alle Elemente, die vorher ab Index 1 standen, rücken eine Stelle nach rechts. Ihr Index wird dadurch um 1 größer: Die Milch hatte vorher den Index 1, jetzt hat sie den Index 2.

Vorher: drei Elemente mit den Indizes 0 bis 2
Nachher (nach einkauf.insert(1, "Käse")): Milch und Eier sind eine Stelle nach rechts gerückt

Elemente entfernen: pop und remove

Zum Entfernen gibt es zwei Methoden. Sie unterscheiden sich darin, was du in die Klammern schreibst: einen Index oder ein Element.

liste.pop(index) entfernt das Element am angegebenen Index. Ohne Index entfernt pop() das letzte Element. In beiden Fällen gibt pop das entfernte Element zurück – so wie eine Funktion mit return einen Wert zurückgibt. Du kannst es also in einer Variablen auffangen:

einkauf = ["Brot", "Käse", "Milch", "Eier"]
letztes = einkauf.pop()
print(letztes)
print(einkauf)
erstes = einkauf.pop(0)
print(erstes)
print(einkauf)
Eier
['Brot', 'Käse', 'Milch']
Brot
['Käse', 'Milch']

liste.remove(wert) sucht dagegen nach einem Element mit diesem Wert und entfernt es. Kommt der Wert mehrmals vor, wird nur das erste Vorkommen entfernt:

einkauf = ["Brot", "Käse", "Milch", "Käse"]
einkauf.remove("Käse")
print(einkauf)
['Brot', 'Milch', 'Käse']

Die Tabelle fasst die Methoden zusammen:

Methode Wirkung in den Klammern steht
liste.append(wert) hängt wert ans Ende an ein Element
liste.insert(i, wert) fügt wert am Index i ein ein Index und ein Element
liste.pop() entfernt das letzte Element und gibt es zurück nichts
liste.pop(i) entfernt das Element am Index i und gibt es zurück ein Index
liste.remove(wert) entfernt das erste Element mit dem Wert wert ein Element

Merke dir den Unterschied: pop erwartet einen Index, remove ein Element.

Stolperstein

Ist der Wert nicht in der Liste, kann remove nichts entfernen und meldet einen ValueError („falscher Wert“):

einkauf = ["Brot", "Milch"]
einkauf.remove("Käse")
ValueError: list.remove(x): x not in list

Die Meldung heißt: „x ist nicht in der Liste.“ Ähnlich bei pop: Aus einer leeren Liste kann nichts entfernt werden. Dann meldet Python IndexError: pop from empty list.

So kannst du es sagen

So beschreibst du Listenoperationen in Fachsprache – vom einfachen zum genauen Satz:

Arbeitsauftrag 132: Listen-Vorhersage

Lies das Programm, ohne es auszuführen. Zeichne die Liste tiere nach jeder Zeile als Reihe von Kästchen und schreibe den Index darüber. Gib dann an, was das Programm ausgibt. Überprüfe deine Vorhersage am Computer.

tiere = ["Hund", "Katze", "Maus"]
tiere.append("Igel")
tiere[0] = "Pferd"
tiere.insert(2, "Esel")
tiere.remove("Katze")
x = tiere.pop()
print(tiere)
print(x)
print(len(tiere))

Die Liste nach jeder Zeile und die Ausgabe:

Lösung vergleichen

Das Ablaufprotokoll zeigt den Inhalt von tiere und x nach jeder Zeile:

Schritt Zeile tiere x
1 1 ['Hund', 'Katze', 'Maus'] –
2 2 ['Hund', 'Katze', 'Maus', 'Igel'] –
3 3 ['Pferd', 'Katze', 'Maus', 'Igel'] –
4 4 ['Pferd', 'Katze', 'Esel', 'Maus', 'Igel'] –
5 5 ['Pferd', 'Esel', 'Maus', 'Igel'] –
6 6 ['Pferd', 'Esel', 'Maus'] "Igel"
7 7 ['Pferd', 'Esel', 'Maus'] "Igel"
8 8 ['Pferd', 'Esel', 'Maus'] "Igel"
9 9 ['Pferd', 'Esel', 'Maus'] "Igel"
['Pferd', 'Esel', 'Maus']
Igel
3

Wichtig ist Zeile 4: Der Esel wird am Index 2 eingefügt, vor der Maus. In Zeile 6 entfernt pop() das letzte Element, den Igel, und speichert ihn in x.

1.11.6Listen mit Schleifen durchlaufen

Oft soll ein Programm mit jedem Element einer Liste etwas tun. Dafür gibt es zwei Arten von for-Schleifen.

Schleife über die Elemente

Über die Zeichen einer Zeichenkette läufst du mit for zeichen in text:. Über die Elemente einer Liste geht es genauso:

staedte = ["Saarbrücken", "Trier", "Mainz", "Koblenz"]
for stadt in staedte:
    print("Ich fahre nach", stadt)
Ich fahre nach Saarbrücken
Ich fahre nach Trier
Ich fahre nach Mainz
Ich fahre nach Koblenz

Schleife über die Indizes

Manchmal brauchst du nicht nur das Element, sondern auch seinen Index. Dann läufst du mit range(len(liste)) über alle gültigen Indizes:

staedte = ["Saarbrücken", "Trier", "Mainz", "Koblenz"]
for i in range(len(staedte)):
    print(i, staedte[i])
0 Saarbrücken
1 Trier
2 Mainz
3 Koblenz

Die Schleife über die Indizes brauchst du immer dann, wenn du die Position kennen musst – zum Beispiel, um Elemente zu verändern. Mehr dazu im nächsten Abschnitt.

Versuch: Fehler finden

Ändere die Schleife zu for i in range(1, len(staedte) + 1):. Was gibt das Programm jetzt aus, bevor es abbricht? Welche Fehlermeldung erhältst du? Erkläre: Welche Indizes erzeugt range jetzt, und welcher davon ist ungültig?

Eine Liste mit einer Schleife füllen

Ein sehr häufiges Muster: Man beginnt mit einer leeren Liste und hängt in einer Schleife ein Element nach dem anderen an.

quadratzahlen = []
for zahl in range(1, 6):
    quadratzahlen.append(zahl * zahl)
print(quadratzahlen)
[1, 4, 9, 16, 25]

1.11.7Übungen

Arbeitsauftrag 133: Einkaufsliste

Lege eine leere Liste an. Frage nacheinander 5 Artikelnamen ab (mit input() in einer Schleife) und füge sie mit append() zur Liste hinzu. Gib die vollständige Liste am Ende aus.

Lösung vergleichen
einkaufsliste = []
for i in range(5):
    artikel = input("Artikel eingeben: ")
    einkaufsliste.append(artikel)
print(einkaufsliste)
Artikel eingeben: «Brot»
Artikel eingeben: «Milch»
Artikel eingeben: «Eier»
Artikel eingeben: «Käse»
Artikel eingeben: «Äpfel»
['Brot', 'Milch', 'Eier', 'Käse', 'Äpfel']

Weil die Anzahl (5) vorher feststeht, passt eine for-Schleife. Die Schleifenvariable i wird im Rumpf gar nicht gebraucht – sie zählt nur die Durchläufe. Achte darauf, dass print nicht eingerückt ist. Sonst wird die Liste nach jeder Eingabe ausgegeben.

Werkzeug

Mit liste.index(wert) erfährst du, an welchem Index ein Element steht. Kommt der Wert mehrmals vor, erhältst du den Index des ersten Vorkommens. Ist der Wert gar nicht in der Liste, meldet Python einen Fehler, z. B. ValueError: 'Lea' is not in list. Im nächsten Abschnitt programmierst du so eine Suche selbst (lineare Suche).

Arbeitsauftrag 134: Index vs. Wert

Gegeben ist die Liste staedte = ["Saarbrücken", "Trier", "Mainz", "Koblenz"].

  1. Gib den Wert am Index 2 aus.
  2. Ändere den Wert am Index 0 zu "Saarlouis" und gib die Liste aus.
  3. Gib den Index der Stadt "Mainz" aus (Tipp: liste.index(wert)).
Lösung vergleichen
staedte = ["Saarbrücken", "Trier", "Mainz", "Koblenz"]
print(staedte[2])
staedte[0] = "Saarlouis"
print(staedte)
print(staedte.index("Mainz"))
Mainz
['Saarlouis', 'Trier', 'Mainz', 'Koblenz']
2

Zeile 2 und Zeile 5 sind „Gegenstücke“: staedte[2] geht vom Index zum Element (Ergebnis "Mainz"), staedte.index("Mainz") geht vom Element zum Index (Ergebnis 2).

Tipp

Zur Erinnerung: Mit einer negativen Schrittweite zählt range rückwärts: range(4, -1, -1) erzeugt 4, 3, 2, 1, 0. Die Zahl in der Mitte (-1) ist wie immer die Grenze, die nicht mehr erreicht wird.

Arbeitsauftrag 135 (Zusatz): Liste umkehren

Gegeben ist die Liste zahlen = [1, 2, 3, 4, 5]. Erzeuge mit einer Schleife eine neue Liste, die die Elemente in umgekehrter Reihenfolge enthält, und gib sie aus. Verwende dafür keine eingebaute Funktion zum Umkehren.

Lösung vergleichen
zahlen = [1, 2, 3, 4, 5]
umgekehrt = []
for i in range(len(zahlen) - 1, -1, -1):
    umgekehrt.append(zahlen[i])
print(umgekehrt)
[5, 4, 3, 2, 1]

Die Schleife läuft über die Indizes rückwärts: von len(zahlen) - 1 (dem letzten Index, hier 4) bis 0. Das Element an jedem dieser Indizes wird an die neue Liste angehängt.

Eine andere richtige Lösung läuft vorwärts über die Elemente und fügt jedes Element vorne ein. So landet das zuletzt eingefügte Element ganz vorne:

zahlen = [1, 2, 3, 4, 5]
umgekehrt = []
for zahl in zahlen:
    umgekehrt.insert(0, zahl)
print(umgekehrt)
[5, 4, 3, 2, 1]

1.11.8Weitere Übungen

Hier kannst du das Gelernte weiter üben. Die Punkte im Titel zeigen, wie schwer eine Aufgabe ist: ●○○ leicht, ●●○ mittel, ●●● knifflig. Fang mit den leichten an.

Arbeitsauftrag 136: Wochentage ●○○

Gegeben ist die Liste tage = ["Mo", "Di", "Mi", "Do", "Fr"]. Bestimme ohne Computer die Werte der Ausdrücke. Prüfe danach mit print(...) am Computer.

tage[1] tage[-1] len(tage) tage[len(tage) - 3]

Gib außerdem an, an welchem Index das Element "Do" steht.

“Do” steht am Index:

Lösung vergleichen
tage[1] tage[-1] len(tage) tage[len(tage) - 3]
"Di" "Fr" 5 "Mi"
tage = ["Mo", "Di", "Mi", "Do", "Fr"]
print(tage[1], tage[-1])
print(len(tage))
print(tage[len(tage) - 3])
Di Fr
5
Mi

tage[1] ist das zweite Element, denn gezählt wird ab 0. len(tage) - 3 ist 5−3=25 - 3 = 2, und am Index 2 steht "Mi". Das Element "Do" steht am Index 3. Wer mit tage.index("Do") nachprüft, bekommt ebenfalls 3.

Arbeitsauftrag 137: Liste verändern ●○○

Gib ohne Computer an, was das Programm ausgibt. Überprüfe danach am Computer.

punkte = [12, 7, 9]
punkte[0] = 10
punkte.append(15)
punkte[1] = punkte[1] + 3
print(punkte)
print(len(punkte))

Meine Vorhersage:

Lösung vergleichen
punkte = [12, 7, 9]
punkte[0] = 10
punkte.append(15)
punkte[1] = punkte[1] + 3
print(punkte)
print(len(punkte))
[10, 10, 9, 15]
4
  • Zeile 2: Das Element am Index 0 wird überschrieben: aus 12 wird 10.
  • Zeile 3: append hängt 15 ans Ende. Die Liste hat jetzt 4 Elemente.
  • Zeile 4: Rechts vom = wird zuerst das alte Element gelesen (7), dann 3 addiert. Das Ergebnis 10 wird an den Index 1 geschrieben.
Arbeitsauftrag 138: Stundenplan ●○○

Am Montag hast du die Fächer Mathe, Deutsch, Informatik und Sport.

  1. Lege eine Liste montag mit diesen vier Fächern an.
  2. Gib das erste und das letzte Fach aus.
  3. Sport fällt aus, stattdessen ist Kunst. Ändere das Element mit einem schreibenden Zugriff.
  4. Nach der Schule ist noch die Theater-AG. Hänge "Theater-AG" an die Liste an.
  5. Gib die Liste und die Anzahl der Einträge aus.
Lösung vergleichen
montag = ["Mathe", "Deutsch", "Informatik", "Sport"]
print("Erstes Fach:", montag[0])
print("Letztes Fach:", montag[-1])
montag[3] = "Kunst"
montag.append("Theater-AG")
print(montag)
print("Anzahl:", len(montag))
Erstes Fach: Mathe
Letztes Fach: Sport
['Mathe', 'Deutsch', 'Informatik', 'Kunst', 'Theater-AG']
Anzahl: 5

Sport steht am Index 3, also schreibt man montag[3] = "Kunst". Für das letzte Fach geht auch montag[len(montag) - 1]. Wichtig: Das letzte Fach muss vor der Änderung ausgegeben werden, sonst steht dort schon Kunst.

Arbeitsauftrag 139: IndexError erklären ●○○

Das Programm soll die letzte Farbe der Liste ausgeben. Es bricht aber ab.

farben = ["rot", "gelb", "grün"]
print(farben[3])
  1. Gib an, welche Indizes in dieser Liste gültig sind.
  2. Erkläre, warum die Fehlermeldung IndexError: list index out of range erscheint.
  3. Nenne zwei Möglichkeiten, die letzte Farbe richtig auszugeben.

Meine Antworten:

Lösung vergleichen
farben = ["rot", "gelb", "grün"]
print(farben[3])
IndexError: list index out of range
  1. Die Liste hat 3 Elemente. Gültig sind die Indizes 0, 1 und 2 (und von hinten −1, −2, −3).
  2. Der Index 3 liegt außerhalb des gültigen Bereichs („out of range“). Der Fehler entsteht, weil man an die Länge 3 denkt und vergisst, dass ab 0 gezählt wird.
  3. Mit farben[2] oder farben[-1]. Beide Fassungen geben grün aus. Für Listen jeder Länge passt auch farben[len(farben) - 1].
Arbeitsauftrag 140: Preiserhöhung am Kiosk ●●○

Am Schulkiosk werden alle Preise um 50 Cent teurer. Die Preise stehen in der Liste preise = [1.5, 2.0, 0.8, 3.0] (in Euro).

Schreibe ein Programm, das mit einer Schleife jedes Element der Liste um 0.5 erhöht. Gib die Liste danach aus.

Tipp

Du musst die Elemente in der Liste verändern. Dafür brauchst du die Schleife über die Indizes: for i in range(len(preise)):. Im Rumpf steht dann ein schreibender Zugriff wie im Auftrag Liste verändern.

Lösung vergleichen
preise = [1.5, 2.0, 0.8, 3.0]
for i in range(len(preise)):
    preise[i] = preise[i] + 0.5
print(preise)
[2.0, 2.5, 1.3, 3.5]

i durchläuft die Indizes 0, 1, 2 und 3. In jedem Durchlauf wird das Element am Index i gelesen, um 0.5 erhöht und an dieselbe Stelle zurückgeschrieben. Das Programm funktioniert auch, wenn die Liste länger wird, weil len(preise) die Anzahl selbst bestimmt.

Arbeitsauftrag 141: Siegerliste ●●○

Die Liste sieger = ["Lea", "Tom", "Ada", "Ben"] enthält die Namen nach der Platzierung beim Sportfest. Schreibe ein Programm, das mit einer Schleife diese Ausgabe erzeugt:

Platz 1 - Lea
Platz 2 - Tom
Platz 3 - Ada
Platz 4 - Ben
Lösung vergleichen
sieger = ["Lea", "Tom", "Ada", "Ben"]
for i in range(len(sieger)):
    print("Platz", i + 1, "-", sieger[i])
Platz 1 - Lea
Platz 2 - Tom
Platz 3 - Ada
Platz 4 - Ben

Der Index beginnt bei 0, der Platz aber bei 1. Deshalb wird i + 1 ausgegeben. Das Element liest man trotzdem mit sieger[i]. Hier sieht man gut: Index und Platznummer sind zwei verschiedene Dinge. Typischer Fehler: sieger[i + 1]. Dann fehlt Lea, und beim letzten Durchlauf gibt es einen IndexError.

Arbeitsauftrag 142: Zwei Mannschaften ●●○

Beim Fußball im Sportunterricht stehen alle in einer Reihe: reihe = ["Ada", "Ben", "Cem", "Dana", "Eli", "Finn"]. Wer an einem geraden Index steht (0, 2, 4), kommt in Mannschaft A, die anderen in Mannschaft B.

Schreibe ein Programm, das zwei neue Listen team_a und team_b mit append füllt und beide ausgibt.

Tipp

Denk an die Schrittweite von range aus dem Abschnitt über die for-Schleife: range(0, 6, 2) erzeugt 0, 2, 4. Statt 6 schreibst du besser len(reihe).

Lösung vergleichen
reihe = ["Ada", "Ben", "Cem", "Dana", "Eli", "Finn"]
team_a = []
team_b = []
for i in range(0, len(reihe), 2):
    team_a.append(reihe[i])
for i in range(1, len(reihe), 2):
    team_b.append(reihe[i])
print("Team A:", team_a)
print("Team B:", team_b)
Team A: ['Ada', 'Cem', 'Eli']
Team B: ['Ben', 'Dana', 'Finn']

Die erste Schleife durchläuft die Indizes 0, 2, 4, die zweite die Indizes 1, 3, 5. Auch richtig ist eine Schleife über alle Indizes mit der Bedingung if i % 2 == 0: (gerader Index) und einem else-Teil für Mannschaft B.

Arbeitsauftrag 143: Plätze tauschen ●●●

Im Sitzplan sitzplan = ["Ben", "Ada", "Tom", "Mia", "Lea"] wollen Tom und Lea die Plätze tauschen.

  1. Bestimme mit .index() die Indizes von Tom und Lea.
  2. Tausche die beiden Elemente mit schreibenden Zugriffen. Gib den Sitzplan vor und nach dem Tausch aus.
  3. Erkläre, warum du dafür eine Hilfsvariable brauchst.
Tipp

Stell dir zwei Gläser vor: eins mit Saft, eins mit Wasser. Um die Inhalte zu tauschen, brauchst du ein drittes, leeres Glas. Im Programm ist das dritte Glas eine Hilfsvariable, z. B. merke = sitzplan[i].

Warum braucht man die Hilfsvariable?

Lösung vergleichen
sitzplan = ["Ben", "Ada", "Tom", "Mia", "Lea"]
print(sitzplan)
i = sitzplan.index("Tom")
j = sitzplan.index("Lea")
merke = sitzplan[i]
sitzplan[i] = sitzplan[j]
sitzplan[j] = merke
print(sitzplan)
['Ben', 'Ada', 'Tom', 'Mia', 'Lea']
['Ben', 'Ada', 'Lea', 'Mia', 'Tom']
  • Zeilen 3–4: Tom steht am Index 2, Lea am Index 4.
  • Zeile 5: Tom wird in merke zwischengespeichert.
  • Zeile 6: Am Index 2 steht jetzt Lea. Tom wäre ohne merke verloren.
  • Zeile 7: Tom kommt aus merke an den Index 4.

Ohne Hilfsvariable schreibt man sitzplan[2] = sitzplan[4] und danach sitzplan[4] = sitzplan[2]. Nach der ersten Zeile steht aber schon an beiden Stellen Lea. Die zweite Zeile schreibt also Lea auf Leas Platz, und Tom ist verschwunden.

1.11.9Das Wichtigste in Kürze

Selbstcheck

1.12Algorithmen auf Listen: Summe, Minimum und Suche DS12

Diesen Abschnitt als PDF (S. 163–175)

Das Jupyter-Notebook aus dem Unterricht: DS12_Listenalgorithmen.ipynb. Herunterladen und in VS Code oder Jupyter öffnen.

Zum Weiterüben: DS12_Weitere_Uebungen.ipynb mit den Aufgaben aus „Weitere Übungen“ zum Bearbeiten in Python.

Leitidee

In einer Liste stehen die Noten einer Klassenarbeit. Wie gut war die Klasse im Durchschnitt? Was war die beste Note? Hat jemand eine 6 geschrieben, und wenn ja, wie viele? Bei einer kurzen Liste siehst du das auf einen Blick. Ein Computer kann aber nicht „auf einen Blick“ sehen. Er muss die Liste Element für Element durchgehen. Ein Algorithmus ist eine genaue Schritt-für-Schritt-Anleitung, mit der man eine Aufgabe löst – so eindeutig, dass auch ein Computer sie ausführen kann. In diesem Abschnitt programmierst du einige grundlegende Algorithmen für Listen selbst: Summe und Mittelwert, Minimum und Maximum, die lineare Suche und das Zählen. Erst danach lernst du die fertigen Funktionen kennen, die Python dafür schon mitbringt.

Lernziele

Nach diesem Abschnitt kannst du

1.12.1Zwei Arten, eine Liste zu durchlaufen

Im Abschnitt über Listen hast du zwei Arten von for-Schleifen kennengelernt. Hier noch einmal beide nebeneinander:

Schleife Schleifenvariable geeignet, wenn …
for element in liste: jedes Element nur Werte nötig sind
for i in range(len(liste)): jeder Index Position nötig ist

Willst du Elemente einer Liste verändern, brauchst du die Schleife über die Indizes. Hier werden alle Preise verdoppelt:

preise = [2.0, 3.5, 1.0]
for i in range(len(preise)):
    preise[i] = preise[i] * 2
print(preise)
[4.0, 7.0, 2.0]

In Zeile 3 steht ein schreibender Zugriff: Das Element am Index i wird durch sein Doppeltes ersetzt.

Merke

Über eine Liste kann man auf zwei Arten iterieren (sie durchlaufen):

Stolperstein

Mit der Schleife über die Elemente kann man die Liste nicht verändern:

preise = [2.0, 3.5, 1.0]
for preis in preise:
    preis = preis * 2
print(preise)
[2.0, 3.5, 1.0]

Es gibt keine Fehlermeldung, aber die Liste ist unverändert. Die Variable preis bekommt in jedem Durchlauf den Wert eines Elements. Zeile 3 gibt nur der Variablen preis einen neuen Wert. Die Liste selbst bekommt davon nichts mit.

1.12.2Summenbildung

An der Supermarktkasse werden die Preise nacheinander zu einer Zwischensumme addiert. Am Anfang steht die Zwischensumme auf 0. Bei jedem Artikel kommt sein Preis dazu. Nach dem letzten Artikel ist die Zwischensumme die Gesamtsumme.

Genauso arbeitet der Algorithmus zur Summenbildung. Die Zwischensumme ist eine Hilfsvariable, hier summe:

zahlen = [7, 2, 9, 4, 1, 8]

summe = 0
for zahl in zahlen:
    summe = summe + zahl
print("Summe:", summe)
Summe: 31

Wie sich summe Schritt für Schritt ändert, zeigt das Ablaufprotokoll. Damit es übersichtlich bleibt, steht hier eine kürzere Liste mit nur drei Zahlen:

Schritt Zeile Anweisung zahl summe
1 1 zahlen = [7, 2, 9] – –
2 2 summe = 0 – 0
3 3 for zahl in zahlen: 7 0
4 4 summe = summe + zahl 7 7
5 3 for zahl in zahlen: 2 7
6 4 summe = summe + zahl 2 9
7 3 for zahl in zahlen: 9 9
8 4 summe = summe + zahl 9 18
9 3 for zahl in zahlen: 9 18
10 5 print("Summe:", summe) 9 18

Die for-Zeile wird viermal ausgeführt: dreimal mit einem neuen Element und ein viertes Mal, um festzustellen, dass die Liste zu Ende ist (Schritt 9).

Merke

Summenbildung: Eine Hilfsvariable wird vor der Schleife auf 0 gesetzt und in jedem Durchlauf um das aktuelle Element erhöht.

Stolperstein

Steht summe = 0 in der Schleife, wird die Zwischensumme bei jedem Durchlauf wieder auf 0 gesetzt. Am Ende steht dann nur das letzte Element in summe. Die Hilfsvariable muss deshalb immer vor der Schleife initialisiert werden.

Der Mittelwert

Den Mittelwert (Durchschnitt) erhältst du, wenn du die Summe durch die Anzahl der Elemente teilst. Die Anzahl liefert len:

noten = [2, 3, 1, 4, 2]
summe = 0
for note in noten:
    summe = summe + note
mittelwert = summe / len(noten)
print("Durchschnitt:", mittelwert)
Durchschnitt: 2.4

Das Programm funktioniert für jede Liste, egal wie viele Noten darin stehen. Kommt eine Note dazu, muss man nichts am Programm ändern.

Arbeitsauftrag 144: Durchschnitt berechnen

Schreibe eine Funktion durchschnitt(liste), die den Durchschnitt aller Zahlen in einer Liste berechnet und zurückgibt. Teste sie mit der Liste [7, 2, 9, 4, 1, 8].

Lösung vergleichen
def durchschnitt(liste):
    summe = 0
    for wert in liste:
        summe = summe + wert
    return summe / len(liste)

print(durchschnitt([7, 2, 9, 4, 1, 8]))
5.166666666666667

Die Summe ist 31, die Liste hat 6 Elemente, und 31 / 6 ergibt ungefähr 5,17. Wer weniger Nachkommastellen möchte, schreibt round(durchschnitt(...), 2).

Achtung bei einer leeren Liste: Dann ist len(liste) gleich 0, und Python kann nicht durch 0 teilen:

print(durchschnitt([]))
ZeroDivisionError: division by zero

Wer das vermeiden will, prüft vorher mit if len(liste) == 0: und gibt dann zum Beispiel 0 zurück.

1.12.3Maximum und Minimum

Stell dir vor, du deckst Spielkarten mit Zahlen nacheinander auf. Die erste Karte behältst du in der Hand. Bei jeder weiteren Karte vergleichst du: Ist die neue Zahl größer als die in deiner Hand? Dann tauschst du. Sonst legst du die neue Karte weg. Wenn alle Karten aufgedeckt sind, hältst du die größte Zahl in der Hand.

Im Programm ist die „Karte in der Hand“ wieder eine Hilfsvariable. Das folgende Programm bestimmt das Maximum derselben Liste wie oben:

zahlen = [7, 2, 9, 4, 1, 8]
maximum = zahlen[0]
for zahl in zahlen:
    if zahl > maximum:
        maximum = zahl
print("Maximum:", maximum)
Maximum: 9

Für das Minimum geht man genauso vor. Man dreht nur den Vergleich um: < statt >.

Merke

Minimum/Maximum: Eine Hilfsvariable wird mit dem ersten Element initialisiert und bei jedem kleineren bzw. größeren Fund aktualisiert.

Das Ablaufprotokoll für die Liste [7, 2, 9, 4] zeigt, dass maximum sich nur einmal ändert – beim Element 9:

Schritt Zeile Anweisung zahl maximum
1 1 zahlen = [7, 2, 9, 4] – –
2 2 maximum = zahlen[0] – 7
3 3 for zahl in zahlen: 7 7
4 4 if zahl > maximum: 7 7
5 3 for zahl in zahlen: 2 7
6 4 if zahl > maximum: 2 7
7 3 for zahl in zahlen: 9 7
8 4 if zahl > maximum: 9 7
9 5 maximum = zahl 9 9
10 3 for zahl in zahlen: 4 9
11 4 if zahl > maximum: 4 9
12 3 for zahl in zahlen: 4 9
13 6 print("Maximum:", maximum) 4 9
Stolperstein

Warum beginnt man mit dem ersten Element und nicht einfach mit 0? Weil 0 kein Element der Liste ist. Bei einer Liste aus lauter negativen Zahlen geht das schief:

temperaturen = [-5, -2, -8]
maximum = 0
for t in temperaturen:
    if t > maximum:
        maximum = t
print("Höchste Temperatur:", maximum)
Höchste Temperatur: 0

Keine der Temperaturen ist größer als 0. Deshalb wird maximum nie aktualisiert, und das Programm gibt 0 aus – einen Wert, der gar nicht in der Liste steht. Richtig wäre −2. Mit maximum = temperaturen[0] stimmt das Ergebnis.

Arbeitsauftrag 145: Minimum finden

Schreibe eine Funktion minimum(liste), die das kleinste Element einer Liste zurückgibt, ohne die eingebaute Funktion min() zu verwenden. Teste sie mit der Liste [7, 2, 9, 4, 1, 8].

Lösung vergleichen
def minimum(liste):
    kleinstes = liste[0]
    for wert in liste:
        if wert < kleinstes:
            kleinstes = wert
    return kleinstes

print(minimum([7, 2, 9, 4, 1, 8]))
1

kleinstes wird mit dem ersten Element initialisiert und immer dann aktualisiert, wenn ein kleineres Element gefunden wird. Das return steht nach der Schleife (nicht eingerückt unter for), denn erst wenn alle Elemente verglichen sind, steht das Ergebnis fest.

1.12.4Lineare Suche

Du suchst in einem Stapel Klassenarbeiten die von Tom. Die Arbeiten sind nicht sortiert. Also nimmst du die oberste, schaust auf den Namen, dann die nächste – so lange, bis du Toms Arbeit gefunden hast oder der Stapel zu Ende ist. Dieses Vorgehen heißt lineare Suche: Man geht die Liste der Reihe nach durch, wie an einer Linie entlang.

Die folgende Funktion sucht einen Wert in einer Liste. Sie gibt den Index zurück, an dem der Wert steht. Kommt er nicht vor, gibt sie -1 zurück:

def lineare_suche(liste, gesuchter_wert):
    for i in range(len(liste)):
        if liste[i] == gesuchter_wert:
            return i
    return -1

namen = ["Ben", "Ada", "Tom", "Mia"]
print(lineare_suche(namen, "Tom"))
print(lineare_suche(namen, "Lea"))
2
-1

Das Ablaufprotokoll zeigt die Zeilen innerhalb der Funktion beim Aufruf lineare_suche(namen, "Tom"):

Schritt Zeile Anweisung i
1 2 for i in range(len(liste)): 0
2 3 if liste[i] == gesuchter_wert: 0
3 2 for i in range(len(liste)): 1
4 3 if liste[i] == gesuchter_wert: 1
5 2 for i in range(len(liste)): 2
6 3 if liste[i] == gesuchter_wert: 2
7 4 return i 2

Nach drei Vergleichen ist Tom gefunden (Schritt 6). In Schritt 7 wird return i ausgeführt, und die Funktion ist beendet. Mia wird gar nicht mehr angeschaut.

Warum gerade -1? Ein Index ist nie negativ, wenn man von vorne zählt. Deshalb ist -1 ein eindeutiges Zeichen für „nicht gefunden“. Aber Vorsicht: Als negativer Index ist -1 in Python gültig. namen[-1] wäre "Mia"! Prüfe das Ergebnis der Suche also immer, bevor du es als Index benutzt:

position = lineare_suche(namen, "Lea")
if position == -1:
    print("Lea ist nicht in der Liste.")
else:
    print("Lea steht am Index", position)
Lea ist nicht in der Liste.

Manchmal will man nur wissen, ob ein Wert vorkommt. Dann kann die Suche einen Wahrheitswert zurückgeben. Den Index braucht man dafür nicht, also genügt die Schleife über die Elemente:

def enthaelt(liste, gesuchter_wert):
    for element in liste:
        if element == gesuchter_wert:
            return True
    return False

namen = ["Ben", "Ada", "Tom", "Mia"]
print(enthaelt(namen, "Mia"))
print(enthaelt(namen, "Lea"))
True
False
Merke

Lineare Suche: Man durchläuft die Liste Element für Element und vergleicht mit dem Suchwert, bis er gefunden wurde oder die Liste zu Ende ist.

Stolperstein

Ein sehr häufiger Fehler: return -1 steht in einem else innerhalb der Schleife.

def lineare_suche(liste, gesuchter_wert):
    for i in range(len(liste)):
        if liste[i] == gesuchter_wert:
            return i
        else:
            return -1

namen = ["Ben", "Ada", "Tom", "Mia"]
print(lineare_suche(namen, "Tom"))
-1

Tom steht in der Liste, trotzdem kommt -1 heraus. Beim ersten Element ("Ben") ist der Vergleich falsch, also wird der else-Teil ausgeführt – und return beendet die Funktion sofort. Die anderen Namen werden nie verglichen. „Nicht gefunden“ steht erst fest, wenn alle Elemente verglichen wurden, also nach der Schleife.

So kannst du es sagen

So beschreibst du einen Listen-Algorithmus in Fachsprache:

1.12.5Zählen

Beim Zählen führt man eine Strichliste: Jedes Mal, wenn ein Element eine Bedingung erfüllt, kommt ein Strich dazu. Im Programm ist die Strichliste wieder eine Hilfsvariable, die mit 0 beginnt. Sie wird aber – anders als bei der Summe – nur um 1 erhöht, und nur dann, wenn die Bedingung erfüllt ist:

noten = [2, 3, 1, 4, 2, 5, 1]
anzahl = 0
for note in noten:
    if note <= 2:
        anzahl = anzahl + 1
print("Anzahl der Noten 1 oder 2:", anzahl)
Anzahl der Noten 1 oder 2: 4

Die Noten 2, 1, 2 und 1 erfüllen die Bedingung note <= 2. Bei jeder von ihnen wird anzahl um 1 erhöht.

Arbeitsauftrag 146: Häufigkeit zählen

Schreibe eine Funktion zaehle_vorkommen(liste, wert), die zählt, wie oft wert in liste vorkommt. Anders als die lineare Suche, die beim ersten Treffer aufhört, soll die Funktion alle Vorkommen zählen. Teste sie mit der Liste [1, 2, 2, 3, 2, 4] und dem Wert 2.

Lösung vergleichen
def zaehle_vorkommen(liste, wert):
    anzahl = 0
    for element in liste:
        if element == wert:
            anzahl = anzahl + 1
    return anzahl

print(zaehle_vorkommen([1, 2, 2, 3, 2, 4], 2))
3

Die Schleife darf hier nicht beim ersten Treffer mit return abbrechen. Sie muss alle Elemente ansehen. Erst nach der Schleife wird das Ergebnis zurückgegeben.

1.12.6Fertige Funktionen zur Kontrolle

Python bringt für viele dieser Aufgaben fertige Funktionen mit. Du kannst sie ab jetzt benutzen – zum Beispiel, um deine eigenen Funktionen zu überprüfen:

Funktion Ergebnis
sum(liste) die Summe aller Elemente
min(liste) das kleinste Element
max(liste) das größte Element
sorted(liste) eine neue, aufsteigend sortierte Liste
wert in liste True, wenn wert in der Liste vorkommt, sonst False
zahlen = [7, 2, 9, 4, 1, 8]
print(sum(zahlen))
print(min(zahlen), max(zahlen))
print(sorted(zahlen))
print(zahlen)
print(9 in zahlen)
31
1 9
[1, 2, 4, 7, 8, 9]
[7, 2, 9, 4, 1, 8]
True

Beachte Zeile 5: sorted verändert die ursprüngliche Liste nicht. Es erzeugt eine neue, sortierte Liste. Den Operator in kennst du schon von den Zeichenketten. Bei Listen fragt er, ob ein Element mit diesem Wert vorkommt – im Hintergrund ist das eine lineare Suche.

Warum hast du die Algorithmen dann überhaupt selbst programmiert? Erstens verstehst du nun, was in den fertigen Funktionen passiert. Zweitens gibt es viele ähnliche Aufgaben, für die es keine fertige Funktion gibt: zum Beispiel den Index des größten Elements oder die zwei größten Werte. Die kannst du jetzt lösen, indem du die Algorithmen abwandelst.

Tipp

So testest du eine eigene Funktion mit einer fertigen: print(minimum(zahlen) == min(zahlen)) muss True ausgeben. Probiere dabei verschiedene Listen aus, auch eine mit negativen Zahlen und eine mit nur einem Element.

1.12.7Übungen

Arbeitsauftrag 147: Code lesen

Lies die Funktion, ohne sie auszuführen.

def geheim(liste):
    position = 0
    for i in range(len(liste)):
        if liste[i] > liste[position]:
            position = i
    return position

print(geheim([3, 8, 5, 8, 1]))
  1. Gib an, was das Programm ausgibt.
  2. Beschreibe in einem Satz, was die Funktion geheim allgemein berechnet.
  3. Erkläre, warum das Ergebnis nicht 3 ist, obwohl am Index 3 auch eine 8 steht.

Deine Antworten:

Lösung vergleichen
  1. Das Programm gibt 1 aus.
  2. Die Funktion gibt den Index des größten Elements der Liste zurück. Sie arbeitet wie die Suche nach dem Maximum, merkt sich aber nicht den Wert, sondern die Position.
  3. Das Maximum 8 kommt zweimal vor. Die Hilfsvariable position wird nur bei einem echt größeren Element aktualisiert (>). Beim Index 3 ist 8 > 8 falsch. Deshalb bleibt der Index 1 des ersten Vorkommens. Mit >= wäre das Ergebnis 3.
Arbeitsauftrag 148 (Zusatz): Zwei größte Werte

Finde mit einer Schleife die zwei größten Werte der Liste zahlen = [4, 17, 9, 22, 3, 15] und gib sie aus. Verwende dabei nicht sorted().

Tipp

Merke dir in zwei Hilfsvariablen den größten und den zweitgrößten Wert. Initialisiere sie mit den ersten beiden Elementen (in der richtigen Reihenfolge!). Überlege dann für jedes weitere Element: Ist es größer als der bisher größte Wert? Oder nur größer als der zweitgrößte?

Lösung vergleichen
zahlen = [4, 17, 9, 22, 3, 15]

if zahlen[0] > zahlen[1]:
    groesstes = zahlen[0]
    zweitgroesstes = zahlen[1]
else:
    groesstes = zahlen[1]
    zweitgroesstes = zahlen[0]

for i in range(2, len(zahlen)):
    zahl = zahlen[i]
    if zahl > groesstes:
        zweitgroesstes = groesstes
        groesstes = zahl
    elif zahl > zweitgroesstes:
        zweitgroesstes = zahl

print("Größter Wert:", groesstes)
print("Zweitgrößter Wert:", zweitgroesstes)
Größter Wert: 22
Zweitgrößter Wert: 17
  • Zeilen 3–8: Die beiden Hilfsvariablen werden mit den ersten beiden Elementen initialisiert – das größere wird groesstes.
  • Zeile 10: Die Schleife beginnt beim Index 2, weil die ersten beiden Elemente schon verarbeitet sind.
  • Zeilen 12–14: Ist das Element größer als der bisher größte Wert, rutscht der bisher größte Wert auf Platz 2, und das Element wird der neue größte Wert. Die Reihenfolge dieser beiden Zeilen ist wichtig: Vertauscht man sie, geht der alte Höchstwert verloren.
  • Zeilen 15–16: Sonst wird geprüft, ob das Element wenigstens den zweiten Platz verdrängt.

Mit sorted(zahlen) kannst du das Ergebnis kontrollieren: Die letzten beiden Elemente der sortierten Liste sind 17 und 22.

1.12.8Weitere Übungen

Hier kannst du das Gelernte weiter üben. Die Punkte im Titel zeigen, wie schwer eine Aufgabe ist: ●○○ leicht, ●●○ mittel, ●●● knifflig. Fang mit den leichten an.

Arbeitsauftrag 149: Maximum von Hand ●○○

Das Programm sucht das Maximum der Liste [4, 9, 2, 9, 6]:

zahlen = [4, 9, 2, 9, 6]
maximum = zahlen[0]
for zahl in zahlen:
    if zahl > maximum:
        maximum = zahl
print("Maximum:", maximum)

Fülle die Tabelle aus: Ist das Element größer als das bisherige Maximum? Welchen Wert hat maximum nach diesem Durchlauf? Gib dann an, wie oft maximum insgesamt geändert wird.

Durchlauf zahl zahl > maximum? maximum danach
vor der Schleife – – 4
1 4
2 9
3 2
4 9
5 6

Anzahl der Änderungen:

Lösung vergleichen
Durchlauf zahl zahl > maximum? maximum danach
vor der Schleife – – 4
1 4 nein 4
2 9 ja 9
3 2 nein 9
4 9 nein 9
5 6 nein 9
zahlen = [4, 9, 2, 9, 6]
maximum = zahlen[0]
for zahl in zahlen:
    if zahl > maximum:
        maximum = zahl
print("Maximum:", maximum)
Maximum: 9

maximum wird nur einmal geändert, im zweiten Durchlauf. Beim zweiten 9er ist 9 > 9 falsch, denn „größer“ heißt „echt größer“.

Arbeitsauftrag 150: Summe und Zählen ●○○

In der Liste stehen die Punkte, die ein Team in sechs Spielen geholt hat. Gib ohne Computer an, was das Programm ausgibt, und beschreibe in einem Satz, was anzahl zählt.

punkte = [3, 0, 1, 3, 0, 3]
summe = 0
anzahl = 0
for p in punkte:
    summe = summe + p
    if p == 0:
        anzahl = anzahl + 1
print(summe, anzahl)

Ausgabe und Erklärung:

Lösung vergleichen
punkte = [3, 0, 1, 3, 0, 3]
summe = 0
anzahl = 0
for p in punkte:
    summe = summe + p
    if p == 0:
        anzahl = anzahl + 1
print(summe, anzahl)
10 2

Die Summe ist 3+0+1+3+0+3=103 + 0 + 1 + 3 + 0 + 3 = 10. anzahl zählt, wie viele Spiele ohne Punkte (also verloren) waren: zwei. In derselben Schleife laufen zwei Algorithmen gleichzeitig. Die Summe wird bei jedem Element erhöht, die Zählvariable nur, wenn die Bedingung erfüllt ist.

Arbeitsauftrag 151: Playlist ●○○

In einer Liste steht die Länge jedes Songs einer Playlist in Minuten: songs = [3, 4, 2, 5, 3].

  1. Implementiere eine Funktion gesamtdauer(liste), die die Summe aller Elemente zurückgibt.
  2. Implementiere eine Funktion mittlere_dauer(liste), die die durchschnittliche Länge zurückgibt. Sie soll gesamtdauer aufrufen.
  3. Teste beide Funktionen mit der Playlist. Erwartet sind 17 Minuten und 3,4 Minuten.
Lösung vergleichen
def gesamtdauer(liste):
    summe = 0
    for dauer in liste:
        summe = summe + dauer
    return summe

def mittlere_dauer(liste):
    return gesamtdauer(liste) / len(liste)

songs = [3, 4, 2, 5, 3]
print(gesamtdauer(songs), "Minuten")
print(mittlere_dauer(songs), "Minuten")
17 Minuten
3.4 Minuten

gesamtdauer ist die Summenbildung: Hilfsvariable mit 0 initialisieren, jedes Element addieren, nach der Schleife zurückgeben. mittlere_dauer teilt die Summe durch die Anzahl der Songs. So wird die Summe nur an einer Stelle programmiert.

Arbeitsauftrag 152: Kälteste Nacht ●○○

In einer Woche wurden nachts diese Temperaturen gemessen (in °C): nachts = [-3, 2, -7, 0, 4, -1, 1].

Implementiere eine Funktion kaelteste(temperaturen), die die niedrigste Temperatur zurückgibt. Verwende nicht min(). Teste mit der Liste. Erwartet ist −7.

Lösung vergleichen
def kaelteste(temperaturen):
    kleinste = temperaturen[0]
    for t in temperaturen:
        if t < kleinste:
            kleinste = t
    return kleinste

nachts = [-3, 2, -7, 0, 4, -1, 1]
print(kaelteste(nachts))
-7

Das ist der Algorithmus für das Minimum: mit dem ersten Element beginnen und bei jedem kleineren Element aktualisieren. Wer mit kleinste = 0 beginnt, bekommt hier zufällig das richtige Ergebnis. Bei einer Woche ohne Frost, z. B. [3, 5, 2], käme aber 0 heraus – ein Wert, der gar nicht gemessen wurde.

Arbeitsauftrag 153: Freies Schließfach ●●○

In der Liste faecher steht, wem welches Schließfach gehört. Ein leeres Fach ist mit der leeren Zeichenkette "" gekennzeichnet:

faecher = ["Ada", "Ben", "", "Mia", ""]
  1. Implementiere eine Funktion erstes_freies(faecher), die mit einer linearen Suche den Index des ersten freien Fachs zurückgibt. Gibt es kein freies Fach, soll sie -1 zurückgeben.
  2. Gib im Hauptprogramm aus, welches Fach frei ist. Die Fächer sind für Menschen ab 1 nummeriert, also ist der Index 2 das Fach Nummer 3. Ist kein Fach frei, soll „Alle Fächer sind belegt.“ erscheinen.
  3. Teste auch mit einer Liste ganz ohne freies Fach.
Lösung vergleichen
def erstes_freies(faecher):
    for i in range(len(faecher)):
        if faecher[i] == "":
            return i
    return -1

faecher = ["Ada", "Ben", "", "Mia", ""]
position = erstes_freies(faecher)
if position == -1:
    print("Alle Fächer sind belegt.")
else:
    print("Fach Nummer", position + 1, "ist frei.")

print(erstes_freies(["Ada", "Ben", "Mia"]))
Fach Nummer 3 ist frei.
-1

Die Funktion ist die lineare Suche aus diesem Abschnitt, gesucht wird hier die leere Zeichenkette. Weil return i die Funktion sofort beendet, wird das zweite freie Fach (Index 4) nicht mehr angesehen. Das return -1 steht nach der Schleife. Im Hauptprogramm wird das Ergebnis erst geprüft und dann als Fachnummer ausgegeben.

Arbeitsauftrag 154: Zwei Fehler im Maximum ●●○

Die Funktion soll die beste Tordifferenz einer Saison zurückgeben. Sie liefert falsche Ergebnisse.

def beste_differenz(differenzen):
    beste = 0
    for d in differenzen:
        if d > beste:
            beste = d
        return beste
  1. Teste die Funktion mit [3, -1, 5] (erwartet: 5) und mit [-2, -1, -5] (erwartet: −1). Notiere die Ergebnisse.
  2. Erkläre die beiden Fehler und verbessere die Funktion.

Testergebnisse und Fehler:

Lösung vergleichen
  1. Die fehlerhafte Funktion liefert:
def beste_differenz(differenzen):
    beste = 0
    for d in differenzen:
        if d > beste:
            beste = d
        return beste

print(beste_differenz([3, -1, 5]), "erwartet: 5")
print(beste_differenz([-2, -1, -5]), "erwartet: -1")
3 erwartet: 5
0 erwartet: -1
  1. Fehler 1: return beste ist zu weit eingerückt. Es steht in der Schleife und beendet die Funktion schon nach dem ersten Element. Deshalb kommt beim ersten Test 3 heraus. Fehler 2: beste beginnt mit 0. Sind alle Differenzen negativ, ist keine größer als 0, und die Funktion liefert 0 – einen Wert, der gar nicht in der Liste steht. Richtig ist der Start mit dem ersten Element:
def beste_differenz(differenzen):
    beste = differenzen[0]
    for d in differenzen:
        if d > beste:
            beste = d
    return beste

print(beste_differenz([3, -1, 5]), "erwartet: 5")
print(beste_differenz([-2, -1, -5]), "erwartet: -1")
5 erwartet: 5
-1 erwartet: -1

Der zweite Test war wichtig: Mit lauter positiven Zahlen wäre Fehler 2 nicht aufgefallen.

Arbeitsauftrag 155: Frosttage ●●○

Ein Tag mit einer Temperatur unter 0 °C heißt Frosttag.

  1. Implementiere eine Funktion frosttage(temperaturen), die zählt, wie viele Werte der Liste unter 0 liegen.
  2. Teste mit der Liste aus dem Auftrag Kälteste Nacht (erwartet: 3) und mit [0, 1, 2] (erwartet: 0).
Lösung vergleichen
def frosttage(temperaturen):
    anzahl = 0
    for t in temperaturen:
        if t < 0:
            anzahl = anzahl + 1
    return anzahl

nachts = [-3, 2, -7, 0, 4, -1, 1]
print(frosttage(nachts), "erwartet: 3")
print(frosttage([0, 1, 2]), "erwartet: 0")
3 erwartet: 3
0 erwartet: 0

Das ist der Zählalgorithmus mit der Bedingung t < 0. Der zweite Test prüft die Grenze: 0 °C ist kein Frosttag. Mit t <= 0 käme dort 1 heraus.

Arbeitsauftrag 156: Besser als der Durchschnitt ●●●

Implementiere eine Funktion ueber_durchschnitt(liste), die zählt, wie viele Elemente größer als der Durchschnitt der Liste sind. Teste mit:

Aufruf erwartet tatsächlich
ueber_durchschnitt([2, 4, 6, 8]) 2
ueber_durchschnitt([10, 10, 10]) 0
ueber_durchschnitt([1, 1, 1, 9]) 1
Tipp

Du brauchst zwei Schritte nacheinander. Erst berechnest du mit einer Schleife den Durchschnitt. Erst danach kannst du mit einer zweiten Schleife zählen, denn vorher kennst du den Vergleichswert noch nicht.

Lösung vergleichen
def ueber_durchschnitt(liste):
    summe = 0
    for wert in liste:
        summe = summe + wert
    mittelwert = summe / len(liste)

    anzahl = 0
    for wert in liste:
        if wert > mittelwert:
            anzahl = anzahl + 1
    return anzahl

print(ueber_durchschnitt([2, 4, 6, 8]))
print(ueber_durchschnitt([10, 10, 10]))
print(ueber_durchschnitt([1, 1, 1, 9]))
2
0
1
  • Zeilen 2–5: Summenbildung und Mittelwert. Bei [2, 4, 6, 8] ist der Mittelwert 5.
  • Zeilen 7–11: Zählen mit der Bedingung wert > mittelwert. 6 und 8 sind größer als 5, also kommt 2 heraus.

Bei [10, 10, 10] ist kein Element größer als der Mittelwert 10. Der dritte Test zeigt, dass ein einziger großer Wert den Durchschnitt nach oben zieht (Mittelwert 3). Man kann die Funktion auch mit der Funktion durchschnitt aus dem Auftrag Durchschnitt berechnen schreiben: mittelwert = durchschnitt(liste).

1.12.9Das Wichtigste in Kürze

Selbstcheck

1.13Projekt Verschlüsselung (Teil 1): die Caesar-Chiffre DS13

Diesen Abschnitt als PDF (S. 176–185)

Das Jupyter-Notebook aus dem Unterricht: DS13_Projekt_Verschluesselung_Teil1.ipynb. Herunterladen und in VS Code oder Jupyter öffnen.

Zum Weiterüben: DS13_Weitere_Uebungen.ipynb mit den Aufgaben aus „Weitere Übungen“ zum Bearbeiten in Python.

Leitidee

Wie verschickt man eine Nachricht so, dass nur Eingeweihte sie lesen können? Schon der römische Feldherr Julius Caesar soll dafür ein einfaches Verfahren benutzt haben: Jeder Buchstabe wird im Alphabet um ein paar Stellen verschoben. In diesem und im nächsten Abschnitt programmiert ihr dieses Verfahren im Team. Dabei braucht ihr fast alles, was ihr bisher gelernt habt: Zeichenketten, Schleifen, Verzweigungen, Funktionen und den Rest-Operator %. Ihr lernt außerdem, wie man ein Programmierprojekt plant, die Arbeit aufteilt, testet und die Teile am Ende zusammenfügt.

Lernziele

Nach diesem Abschnitt kannst du

1.13.1Wie die Caesar-Chiffre funktioniert

Bei der Caesar-Chiffre wird jeder Buchstabe eines Textes im Alphabet um eine feste Anzahl von Stellen nach hinten verschoben. Diese Anzahl ist der Schlüssel. Mit dem Schlüssel 3 wird aus A ein D, aus B ein E, aus C ein F und so weiter. Am Ende des Alphabets geht es vorne weiter: Aus X wird A, aus Y wird B, aus Z wird C.

Caesar-Chiffre mit dem Schlüssel 3: Jeder Buchstabe der oberen Reihe wird durch den Buchstaben darunter ersetzt. Am Ende des Alphabets geht es vorne weiter (rot)

So wird aus dem Klartext HALLO mit dem Schlüssel 3 der Geheimtext KDOOR: H → K, A → D, L → O, L → O, O → R. Wer den Schlüssel kennt, kann den Geheimtext wieder entschlüsseln, indem er jeden Buchstaben um 3 Stellen zurück verschiebt.

Definition: Klartext, Geheimtext, Schlüssel

Beim Verschlüsseln wird ein lesbarer Klartext mithilfe eines Schlüssels in einen Geheimtext umgewandelt. Beim Entschlüsseln wird aus dem Geheimtext mit dem Schlüssel wieder der Klartext.

Arbeitsauftrag 157: Von Hand verschlüsseln

Benutze die Abbildung oben (Schlüssel 3).

  1. Verschlüssele das Wort INFORMATIK:
I N F O R M A T I K
  1. Entschlüssele den Geheimtext ZDVVHU.
  2. Beschreibe in einem Satz, wie du beim Entschlüsseln vorgegangen bist.

Deine Antworten zu 2 und 3:

Lösung vergleichen
  1. INFORMATIK wird zu LQIRUPDWLN.
  2. ZDVVHU wird zu WASSER.
  3. Man sucht jeden Buchstaben des Geheimtextes in der unteren Reihe und liest den Buchstaben darüber ab. Das heißt: Man verschiebt jeden Buchstaben um 3 Stellen zurück. Vor A geht es dabei hinten im Alphabet weiter (aus C wird Z).

1.13.2Das Projekt im Team planen

Ein Programm, an dem mehrere Personen arbeiten, entsteht nicht dadurch, dass alle gleichzeitig drauflos tippen. Professionelle Softwareteams gehen in Schritten vor. Für euer Projekt sieht das so aus:

  1. Verstehen und planen: Was genau soll das Programm können? Wie löst man das Problem – erst einmal ohne Computer?
  2. Zerlegen und verteilen: Das Problem wird in Teilaufgaben zerlegt. Für jede Teilaufgabe wird eine Funktion geplant. Jede Person im Team übernimmt eine Teilaufgabe.
  3. Umsetzen und testen: Jede Person programmiert ihre Funktion und testet sie mit vorher festgelegten Beispielen.
  4. Zusammenführen: Die Funktionen werden zu einem Programm zusammengesetzt und gemeinsam getestet.
  5. Dokumentieren und vorstellen: Das Team hält fest, was das Programm kann, wie es aufgebaut ist und was offen geblieben ist.

Damit ihr gleichzeitig an verschiedenen Funktionen arbeiten könnt, müsst ihr vorher festlegen, wie jede Funktion heißt, welche Parameter sie bekommt und was sie zurückgibt. Das nennt man die Schnittstelle einer Funktion. Wer die Funktion benutzt, muss nur die Schnittstelle kennen – nicht, wie die Funktion innen arbeitet.

Definition: Schnittstelle einer Funktion

Die Schnittstelle einer Funktion legt fest, wie sie heißt, welche Parameter sie erwartet und welchen Rückgabewert sie liefert.

Für euer Projekt sind die Schnittstellen schon vorgegeben:

Teil Funktion mit Parametern Rückgabewert
A verschluessle_buchstabe(buchstabe, schluessel) der verschobene Buchstabe
B verschluessle_text(text, schluessel) der Geheimtext
C Hauptprogramm (keine Funktion) – (fragt ab und gibt aus)

Teilaufgabe B benutzt die Funktion aus Teilaufgabe A. Trotzdem kann man B schon programmieren, bevor A fertig ist: Man weiß ja, wie A heißt und was A zurückgibt.

Tipp

Du arbeitest den Abschnitt allein zu Hause durch? Dann übernimm alle Teilaufgaben nacheinander. Der Ablauf bleibt derselbe: erst planen, dann jede Funktion einzeln programmieren und testen, dann zusammenfügen.

Arbeitsauftrag 158: Projektplan

Plant gemeinsam auf Papier, bevor ihr programmiert. Beantwortet dazu die drei Fragen:

  1. Wie ermittelt man zu einem Buchstaben seine Position im Alphabet?
  2. Wie kommt man von der Position zurück zum (verschobenen) Buchstaben?
  3. Was passiert am Ende des Alphabets, z. B. bei Z mit dem Schlüssel 3?

Verteilt dann die Teilaufgaben. Tragt ein, wer welche Teilaufgabe übernimmt und wer sie testet. Zum Testen tauscht ihr: Niemand testet die eigene Funktion allein.

Teilaufgabe programmiert von getestet von fertig?
A: einen Buchstaben verschlüsseln
B: einen Text verschlüsseln
C: interaktives Programm

Unsere Antworten zu den Fragen 1 bis 3:

Lösung vergleichen
  1. Man legt das Alphabet als Zeichenkette "ABCDEFGHIJKLMNOPQRSTUVWXYZ" an. Die Position eines Buchstabens ist sein Index in dieser Zeichenkette (A hat die Position 0, Z die Position 25). Man findet sie mit einer linearen Suche oder mit alphabet.index(buchstabe).
  2. Man addiert den Schlüssel zur Position und liest mit alphabet[neue_position] den Buchstaben an der neuen Position ab.
  3. Z hat die Position 25. Mit dem Schlüssel 3 ergibt sich 28 – eine Position, die es im Alphabet nicht gibt. Man muss nach Z wieder bei A anfangen. Das erledigt der Rest-Operator: 28 % 26 ergibt 2, also C.

Bei der Aufgabenverteilung gibt es keine feste Lösung. Wichtig ist, dass jede Teilaufgabe eine verantwortliche Person hat und von jemand anderem getestet wird.

1.13.3Werkzeuge für das Projekt

Das Alphabet als Zeichenkette

Das Alphabet speichert ihr am einfachsten als Zeichenkette. Den Index eines Zeichens findet ihr mit .index(). Diese Methode kennst du von den Listen. Sie funktioniert bei Zeichenketten genauso:

alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
print(alphabet)
print("Position von C:", alphabet.index("C"))
print("Buchstabe an Position 5:", alphabet[5])
ABCDEFGHIJKLMNOPQRSTUVWXYZ
Position von C: 2
Buchstabe an Position 5: F
Stolperstein

Kommt das gesuchte Zeichen nicht im Alphabet vor – zum Beispiel ein Leerzeichen oder ein Kleinbuchstabe –, meldet .index() einen Fehler:

alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
print(alphabet.index("a"))
ValueError: substring not found

substring not found heißt „Teilzeichenkette nicht gefunden“. Prüft deshalb vorher mit zeichen in alphabet, ob das Zeichen überhaupt ein Großbuchstabe ist.

Am Ende des Alphabets: der Rest-Operator

Verschiebt man X (Position 23) um 3, ergibt sich die Position 26. Die gibt es nicht: alphabet[26] führt zu einem IndexError. Nach Z soll es wieder bei A weitergehen – wie bei einer Uhr, auf der nach 12 wieder die 1 kommt.

Genau das leistet der Rest-Operator %, den du von den Operatoren kennst. zahl % 26 ist der Rest bei der Division durch 26. Für Zahlen von 0 bis 25 ändert sich nichts. Aus 26 wird 0, aus 27 wird 1, aus 28 wird 2:

for position in range(22, 26):
    neue_position = (position + 3) % 26
    print(position, "->", neue_position)
22 -> 25
23 -> 0
24 -> 1
25 -> 2

W (22) wird zu Z (25). X (23) wird zu A (0), Y zu B, Z zu C – genau wie in der Abbildung oben. Die Klammern in Zeile 2 sind wichtig: Zuerst wird addiert, dann der Rest gebildet.

Merke

Mit (position + schluessel) % 26 erhält man immer eine gültige Position von 0 bis 25. Am Ende des Alphabets geht es dadurch vorne weiter.

Werkzeug

Es geht auch ohne Alphabet-Zeichenkette. Der Computer speichert jedes Zeichen als Zahl. ord(zeichen) liefert die Zahl zu einem Zeichen, chr(zahl) das Zeichen zu einer Zahl. Die Großbuchstaben A bis Z haben die Zahlen 65 bis 90, der Reihe nach:

print(ord("A"), ord("B"), ord("Z"))
print(chr(68))
print(ord("C") - ord("A"))
65 66 90
D
2

Die Position im Alphabet ist also ord(buchstabe) - ord("A"), und zurück geht es mit chr(position + ord("A")). Entscheidet euch im Team für einen der beiden Wege.

1.13.4Teilaufgabe A: einen Buchstaben verschlüsseln

Tipp

Gute Tests prüfen nicht nur den Normalfall (A → D), sondern auch die Randfälle: das Ende des Alphabets (X, Y, Z) und besondere Schlüssel wie 0 oder 25. Gerade dort stecken die meisten Fehler.

Arbeitsauftrag 159: Teilaufgabe A

Schreibt eine Funktion verschluessle_buchstabe(buchstabe, schluessel), die einen Großbuchstaben um schluessel Stellen im Alphabet verschiebt und den neuen Buchstaben zurückgibt. Denkt an den Übertrag am Ende des Alphabets (% 26). Ihr könnt mit diesem Gerüst beginnen:

alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"

def verschluessle_buchstabe(buchstabe, schluessel):
    # Position finden, verschieben, mit % 26 umlaufen lassen

print(verschluessle_buchstabe("A", 3))   # erwartet: D
print(verschluessle_buchstabe("X", 3))   # erwartet: A
print(verschluessle_buchstabe("Z", 1))   # erwartet: A

Das Gerüst läuft so noch nicht: Steht im Funktionsrumpf nur ein Kommentar, meldet Python einen IndentationError, denn Kommentare zählen nicht als Anweisungen. Ersetzt den Kommentar durch eure eingerückten Programmzeilen.

Testet die Funktion mit den Aufrufen in der Tabelle. Tragt ein, was eure Funktion zurückgibt, und ob es stimmt.

Aufruf erwartet tatsächlich ✓ oder ✗
verschluessle_buchstabe("A", 3) D
verschluessle_buchstabe("X", 3) A
verschluessle_buchstabe("Z", 1) A
verschluessle_buchstabe("M", 0) M
verschluessle_buchstabe("B", 25) A
Lösung vergleichen
alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"

def verschluessle_buchstabe(buchstabe, schluessel):
    position = alphabet.index(buchstabe)
    neue_position = (position + schluessel) % 26
    return alphabet[neue_position]

print(verschluessle_buchstabe("A", 3))
print(verschluessle_buchstabe("X", 3))
print(verschluessle_buchstabe("Z", 1))
print(verschluessle_buchstabe("M", 0))
print(verschluessle_buchstabe("B", 25))
D
A
A
M
A

Zeile 4 bestimmt die Position, Zeile 5 verschiebt sie und lässt sie mit % 26 umlaufen, Zeile 6 gibt den Buchstaben an der neuen Position zurück. Alle fünf Tests stimmen.

Mit ord und chr sieht die Funktion so aus:

def verschluessle_buchstabe(buchstabe, schluessel):
    position = ord(buchstabe) - ord("A")
    neue_position = (position + schluessel) % 26
    return chr(neue_position + ord("A"))

print(verschluessle_buchstabe("X", 3))
A

1.13.5Teilaufgabe B: einen ganzen Text verschlüsseln

Für Teilaufgabe B braucht ihr ein Muster, das ihr aus dem Abschnitt über Zeichenketten (Einen neuen Text aufbauen) kennt. Es funktioniert wie die Summenbildung – nur mit Text statt Zahlen. Man beginnt mit einer leeren Zeichenkette "" und hängt in einer Schleife mit + Zeichen an:

text = "ABC"
ergebnis = ""
for zeichen in text:
    ergebnis = ergebnis + zeichen + zeichen
print(ergebnis)
AABBCC
Arbeitsauftrag 160: Teilaufgabe B
  1. Schreibt eine Funktion verschluessle_text(text, schluessel). Sie soll in einer Schleife jeden Buchstaben eines Textes mit verschluessle_buchstabe verschlüsseln und den Geheimtext als neue Zeichenkette zurückgeben. Testet mit verschluessle_text("HALLO", 3) (erwartet: KDOOR).
  2. Zusatz-Herausforderung: Was passiert bei Leerzeichen oder Kleinbuchstaben, z. B. bei "Hallo Welt!"? Überlegt euch im Team eine Lösung. Zum Beispiel: Leerzeichen und Satzzeichen bleiben unverändert, und der Text wird vorher mit .upper() in Großbuchstaben umgewandelt.
Lösung vergleichen

Eine erste Fassung (die Funktion verschluessle_buchstabe aus Teilaufgabe A steht davor):

alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"

def verschluessle_buchstabe(buchstabe, schluessel):
    position = alphabet.index(buchstabe)
    neue_position = (position + schluessel) % 26
    return alphabet[neue_position]

def verschluessle_text(text, schluessel):
    ergebnis = ""
    for zeichen in text:
        neu = verschluessle_buchstabe(zeichen, schluessel)
        ergebnis = ergebnis + neu
    return ergebnis

print(verschluessle_text("HALLO", 3))
KDOOR

Die Hilfsvariable neu hält das verschlüsselte Zeichen nur kurz fest. So bleibt die Zeile kurz und gut lesbar.

Bei einem Leerzeichen bricht diese Fassung ab, weil alphabet.index(" ") nichts findet:

print(verschluessle_text("HALLO WELT", 3))
ValueError: substring not found

Die verbesserte Fassung wandelt den Text zuerst in Großbuchstaben um und verschlüsselt nur Zeichen, die im Alphabet vorkommen. Alle anderen Zeichen werden unverändert übernommen:

def verschluessle_text(text, schluessel):
    ergebnis = ""
    for zeichen in text.upper():
        if zeichen in alphabet:
            neu = verschluessle_buchstabe(zeichen, schluessel)
            ergebnis = ergebnis + neu
        else:
            ergebnis = ergebnis + zeichen
    return ergebnis

print(verschluessle_text("HALLO WELT", 3))
print(verschluessle_text("Hallo Welt!", 3))
KDOOR ZHOW
KDOOR ZHOW!

Umlaute wie Ä und das ß stehen nicht im Alphabet. Sie bleiben deshalb ebenfalls unverschlüsselt. Wer das ändern will, kann sie vorher ersetzen, z. B. Ä durch AE.

1.13.6Teilaufgabe C: das interaktive Programm

Arbeitsauftrag 161: Teilaufgabe C

Setzt beide Funktionen zu einem vollständigen Programm zusammen. Es soll den Klartext und den Schlüssel mit input() abfragen und den Geheimtext ausgeben. Testet das fertige Programm mit mindestens drei verschiedenen Eingaben.

Lösung vergleichen
alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"

def verschluessle_buchstabe(buchstabe, schluessel):
    position = alphabet.index(buchstabe)
    neue_position = (position + schluessel) % 26
    return alphabet[neue_position]

def verschluessle_text(text, schluessel):
    ergebnis = ""
    for zeichen in text.upper():
        if zeichen in alphabet:
            neu = verschluessle_buchstabe(zeichen, schluessel)
            ergebnis = ergebnis + neu
        else:
            ergebnis = ergebnis + zeichen
    return ergebnis

klartext = input("Klartext: ")
schluessel = int(input("Schlüssel (1 bis 25): "))
geheimtext = verschluessle_text(klartext, schluessel)
print("Geheimtext:", geheimtext)
Klartext: «Treffen um acht»
Schlüssel (1 bis 25): «5»
Geheimtext: YWJKKJS ZR FHMY

Das Programm ist in drei Teile gegliedert: das Alphabet, die beiden Funktionen und das Hauptprogramm (Zeilen 18–21). Der Schlüssel wird mit int() umgewandelt, weil input() immer eine Zeichenkette liefert.

1.13.7Zusammenführen und dokumentieren

Wenn alle Teilaufgaben fertig sind, fügt ihr sie in einer Datei zusammen, und zwar in dieser Reihenfolge: das Alphabet, Funktion A, Funktion B, das Hauptprogramm. Eine Funktion muss definiert sein, bevor sie aufgerufen wird. Testet danach das ganze Programm noch einmal mit allen Tests aus den Teilaufgaben.

Ein Programm, das in ein paar Wochen niemand mehr versteht, ist wenig wert. Schreibt deshalb an den Anfang einen kurzen Kommentar mit dem Namen des Programms, den Namen des Teams und einem Satz dazu, was das Programm tut. Kommentare beginnen in Python mit # und werden beim Ausführen übersprungen.

Arbeitsauftrag 162: Projekttagebuch

Führt ein Projekttagebuch. Tragt am Ende jeder Arbeitsphase ein, was ihr geschafft habt, welche Probleme aufgetreten sind und was als Nächstes zu tun ist. Ihr braucht es im nächsten Abschnitt, um das Projekt fortzusetzen und vorzustellen.

Datum erledigt Probleme und wie wir sie gelöst haben nächster Schritt
Lösung vergleichen

Ein möglicher Eintrag:

Datum erledigt Probleme und wie wir sie gelöst haben nächster Schritt
1. Projekttag Teilaufgaben A und B fertig und getestet Absturz bei Leerzeichen; gelöst mit if zeichen in alphabet Hauptprogramm, Entschlüsselung

Es kommt darauf an, dass die Einträge konkret sind: Wer später liest, soll wissen, wo das Team steht und was als Nächstes kommt.

1.13.8Weitere Übungen

Hier kannst du das Gelernte weiter üben. Die Punkte im Titel zeigen, wie schwer eine Aufgabe ist: ●○○ leicht, ●●○ mittel, ●●● knifflig. Fang mit den leichten an.

Arbeitsauftrag 163: Caesar mit Schlüssel 5 ●○○

Benutze das Alphabet mit Positionen. Ein Tipp: Schreibe dir zuerst die Positionen auf, addiere 5 und rechne bei Ergebnissen ab 26 noch 26 ab.

A B C D E F G H I J K L M
0 1 2 3 4 5 6 7 8 9 10 11 12
N O P Q R S T U V W X Y Z
13 14 15 16 17 18 19 20 21 22 23 24 25
  1. Verschlüssele das Wort PIZZA mit dem Schlüssel 5.
  2. Entschlüssele den Geheimtext KJWNJS. Er wurde mit dem Schlüssel 5 verschlüsselt.

Meine Lösungen:

Lösung vergleichen
  1. P (15) → 20 = U, I (8) → 13 = N, Z (25) → 30, minus 26 ergibt 4 = E, noch einmal Z → E, A (0) → 5 = F. Ergebnis: UNEEF.
  2. Beim Entschlüsseln zieht man 5 ab: K (10) → 5 = F, J (9) → 4 = E, W (22) → 17 = R, N (13) → 8 = I, J → E, S (18) → 13 = N. Ergebnis: FERIEN.

Kontrolle mit der Funktion aus Teilaufgabe B (die Entschlüsselung prüft man, indem man das Ergebnis wieder verschlüsselt):

alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"

def verschluessle_buchstabe(buchstabe, schluessel):
    position = alphabet.index(buchstabe)
    neue_position = (position + schluessel) % 26
    return alphabet[neue_position]

def verschluessle_text(text, schluessel):
    ergebnis = ""
    for zeichen in text.upper():
        if zeichen in alphabet:
            neu = verschluessle_buchstabe(zeichen, schluessel)
            ergebnis = ergebnis + neu
        else:
            ergebnis = ergebnis + zeichen
    return ergebnis

print(verschluessle_text("PIZZA", 5))
print(verschluessle_text("FERIEN", 5))
UNEEF
KJWNJS

Typischer Fehler beim Z: Position 30 gibt es nicht. Nach Z geht es vorne weiter, deshalb wird 26 abgezogen. Genau das macht im Programm % 26.

Arbeitsauftrag 164: Rechnen mit % 26 ●○○

Berechne zu jeder Zeile die neue Position (position + schluessel) % 26 und den Buchstaben, der dort steht. Benutze die Positionstabelle aus dem vorigen Auftrag.

position schluessel (position + schluessel) % 26 Buchstabe
24 4
10 13
3 30
25 26

Was fällt dir in der letzten Zeile auf? Erkläre.

Meine Erklärung zur letzten Zeile:

Lösung vergleichen
position schluessel (position + schluessel) % 26 Buchstabe
24 4 2 C
10 13 23 X
3 30 7 H
25 26 25 Z
alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
print((24 + 4) % 26, alphabet[(24 + 4) % 26])
print((10 + 13) % 26, alphabet[(10 + 13) % 26])
print((3 + 30) % 26, alphabet[(3 + 30) % 26])
print((25 + 26) % 26, alphabet[(25 + 26) % 26])
2 C
23 X
7 H
25 Z

24+4=2824 + 4 = 28, und 28:2628 : 26 ergibt 1 Rest 2. In der letzten Zeile bleibt der Buchstabe gleich: Mit dem Schlüssel 26 läuft man einmal ganz um das Alphabet herum und landet wieder am Start. Der Schlüssel 26 verschlüsselt also gar nicht – er wirkt wie der Schlüssel 0. Ebenso wirkt der Schlüssel 30 wie der Schlüssel 4.

Arbeitsauftrag 165: Zweimal verschlüsseln ●●○

Die Funktionen verschluessle_buchstabe und verschluessle_text (verbesserte Fassung aus Teilaufgabe B) stehen vor diesen beiden Zeilen:

print(verschluessle_text("HALLO", 13))
print(verschluessle_text(verschluessle_text("HALLO", 13), 13))
  1. Gib an, was die beiden Zeilen ausgeben.
  2. Erkläre, warum in der zweiten Zeile wieder der Klartext herauskommt.
  3. Gibt es einen weiteren Schlüssel zwischen 1 und 25 mit dieser Eigenschaft? Begründe.

Meine Antworten:

Lösung vergleichen
alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"

def verschluessle_buchstabe(buchstabe, schluessel):
    position = alphabet.index(buchstabe)
    neue_position = (position + schluessel) % 26
    return alphabet[neue_position]

def verschluessle_text(text, schluessel):
    ergebnis = ""
    for zeichen in text.upper():
        if zeichen in alphabet:
            neu = verschluessle_buchstabe(zeichen, schluessel)
            ergebnis = ergebnis + neu
        else:
            ergebnis = ergebnis + zeichen
    return ergebnis

print(verschluessle_text("HALLO", 13))
print(verschluessle_text(verschluessle_text("HALLO", 13), 13))
UNYYB
HALLO
  1. Die erste Zeile gibt UNYYB aus, die zweite wieder HALLO.
  2. Die zweite Zeile verschiebt jeden Buchstaben zweimal um 13, also insgesamt um 13+13=2613 + 13 = 26 Stellen. Das ist einmal ganz um das Alphabet herum, und jeder Buchstabe landet wieder an seiner alten Stelle.
  3. Nein. Zweimal verschieben ergibt nur dann 26 Stellen, wenn der Schlüssel genau die Hälfte von 26 ist, also 13. Deshalb hat das Verfahren mit dem Schlüssel 13 einen eigenen Namen: ROT13. Damit verschlüsselt und entschlüsselt man mit derselben Funktion.
Arbeitsauftrag 166: Geheimtext in Fünfergruppen ●●●

Früher hat man Geheimtexte ohne Leerzeichen und in Gruppen zu je fünf Buchstaben aufgeschrieben. So verrät die Länge der Wörter nichts mehr über den Klartext.

  1. Implementiere eine Funktion fuenfergruppen(text). Sie entfernt zuerst alle Leerzeichen und fügt dann nach je fünf Zeichen ein Leerzeichen ein. Aus "YWJKKJS ZR FHMY" wird so "YWJKK JSZRF HMY".
  2. Teste die Funktion zusammen mit verschluessle_text: Verschlüssele „Treffen um acht“ mit dem Schlüssel 5 und gib das Ergebnis in Fünfergruppen aus.
Tipp

Zerlege die Aufgabe in zwei Schritte. Schritt 1: Baue einen neuen Text ohne Leerzeichen auf (Zeichen nur anhängen, wenn es kein " " ist). Schritt 2: Laufe über die Indizes dieses Textes. Vor jedem Zeichen, dessen Index durch 5 teilbar ist (außer beim Index 0), hängst du zuerst ein Leerzeichen an. „Durch 5 teilbar“ prüfst du mit i % 5 == 0.

Lösung vergleichen
alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"

def verschluessle_buchstabe(buchstabe, schluessel):
    position = alphabet.index(buchstabe)
    neue_position = (position + schluessel) % 26
    return alphabet[neue_position]

def verschluessle_text(text, schluessel):
    ergebnis = ""
    for zeichen in text.upper():
        if zeichen in alphabet:
            neu = verschluessle_buchstabe(zeichen, schluessel)
            ergebnis = ergebnis + neu
        else:
            ergebnis = ergebnis + zeichen
    return ergebnis

def fuenfergruppen(text):
    ohne = ""
    for zeichen in text:
        if zeichen != " ":
            ohne = ohne + zeichen
    gruppiert = ""
    for i in range(len(ohne)):
        if i > 0 and i % 5 == 0:
            gruppiert = gruppiert + " "
        gruppiert = gruppiert + ohne[i]
    return gruppiert

print(fuenfergruppen("YWJKKJS ZR FHMY"))
geheim = verschluessle_text("Treffen um acht", 5)
print(fuenfergruppen(geheim))
YWJKK JSZRF HMY
YWJKK JSZRF HMY
  • Zeilen 19–22: Der erste Teil baut den Text ohne Leerzeichen auf, wie im Auftrag Ohne Leerzeichen im Abschnitt über Zeichenketten.
  • Zeilen 23–27: Bei den Indizes 5, 10, 15 … wird vor dem Zeichen ein Leerzeichen angehängt. Die Bedingung i > 0 verhindert ein Leerzeichen ganz am Anfang, denn auch 0 ist durch 5 teilbar.
  • Zeilen 31–32: Die beiden Funktionen arbeiten zusammen: Erst wird verschlüsselt, dann gruppiert.

Wer die Nachricht entschlüsselt, bekommt TREFF ENUMA CHT und muss die Wortgrenzen selbst erraten. Das ist der Preis für die zusätzliche Tarnung.

1.13.9Das Wichtigste in Kürze

Im nächsten Abschnitt entwickelt ihr die passende Entschlüsselung und schließt das Projekt ab.

Selbstcheck

1.14Projekt Verschlüsselung (Teil 2) und Berufe in der Softwareentwicklung DS14

Diesen Abschnitt als PDF (S. 186–194)

Das Jupyter-Notebook aus dem Unterricht: DS14_Projekt_Verschluesselung_Teil2_Berufsorientierung.ipynb. Herunterladen und in VS Code oder Jupyter öffnen.

Zum Weiterüben: DS14_Weitere_Uebungen.ipynb mit den Aufgaben aus „Weitere Übungen“ zum Bearbeiten in Python.

Leitidee

Euer Programm kann Texte verschlüsseln. Eine geheime Nachricht nützt aber nur etwas, wenn die Empfängerin oder der Empfänger sie auch wieder entschlüsseln kann. In diesem Abschnitt ergänzt ihr diese Funktion, prüft, wie sicher die Caesar-Chiffre wirklich ist, und schließt das Projekt ab: testen, dokumentieren, vorstellen. Im zweiten Teil schaut ihr über den Klassenraum hinaus: Wer entwickelt beruflich Software, welche Berufe gibt es, und wie kommt man dorthin?

Lernziele

Nach diesem Abschnitt kannst du

1.14.1Rückblick: der Stand aus Teil 1

Nehmt eure Ergebnisse aus dem ersten Projektteil und euer Projekttagebuch wieder zur Hand. Kopiert eure fertigen Funktionen an den Anfang eurer Programmdatei. Sie sollten ungefähr so aussehen:

alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"

def verschluessle_buchstabe(buchstabe, schluessel):
    position = alphabet.index(buchstabe)
    neue_position = (position + schluessel) % 26
    return alphabet[neue_position]

def verschluessle_text(text, schluessel):
    ergebnis = ""
    for zeichen in text.upper():
        if zeichen in alphabet:
            neu = verschluessle_buchstabe(zeichen, schluessel)
            ergebnis = ergebnis + neu
        else:
            ergebnis = ergebnis + zeichen
    return ergebnis

print(verschluessle_text("HALLO WELT", 3))
KDOOR ZHOW
Merke

Verschlüsseln mit der Caesar-Chiffre: Position des Buchstabens bestimmen, um den Schlüssel verschieben, mit % 26 umlaufen lassen und den Buchstaben an der neuen Position ablesen. Zeichen, die keine Buchstaben sind, bleiben unverändert.

1.14.2Teilaufgabe D: Entschlüsseln

Beim Entschlüsseln wird jeder Buchstabe um den Schlüssel zurück verschoben. Statt + schluessel rechnet man also - schluessel. Was passiert dabei am Anfang des Alphabets? A hat die Position 0, und 0 − 3 = −3. Auch hier hilft der Rest-Operator:

print((0 - 3) % 26)
print((1 - 3) % 26)
23
24

In Python liefert % 26 immer ein Ergebnis von 0 bis 25 – auch bei negativen Zahlen. Aus A (0) wird mit dem Schlüssel 3 also X (23), aus B (1) wird Y (24). Genau so muss es sein.

Es gibt noch einen zweiten Weg. Stell dir das Alphabet als Kreis vor, wie das Zifferblatt einer Uhr mit 26 Stunden. 3 Schritte zurück landen an derselben Stelle wie 23 Schritte vorwärts. Zurückschieben um s ist also dasselbe wie Vorwärtsschieben um 26 - s.

Arbeitsauftrag 167: Teilaufgabe D

Überlegt im Team: Wie hängt die Entschlüsselung mit der Verschlüsselung zusammen?

Schreibt dann eine Funktion entschluessle_text(geheimtext, schluessel). Tipp: Entschlüsseln mit dem Schlüssel s entspricht dem Verschlüsseln mit dem Schlüssel -s (bzw. 26 - s). Ihr könnt also die Funktion verschluessle_text wiederverwenden.

Testet mit einem Hin-und-zurück-Test: Verschlüsselt einen Text und entschlüsselt das Ergebnis wieder. Es muss der ursprüngliche Text herauskommen (in Großbuchstaben).

Klartext Schlüssel verschlüsselt wieder entschlüsselt ✓ oder ✗
HALLO WELT 3
Treffen um acht 5
Lösung vergleichen

Die Funktionen aus Teil 1 (siehe Rückblick) stehen davor:

def entschluessle_text(geheimtext, schluessel):
    return verschluessle_text(geheimtext, 26 - schluessel)

geheim = verschluessle_text("HALLO WELT", 3)
print(geheim)
print(entschluessle_text(geheim, 3))
print(entschluessle_text("YWJKKJS ZR FHMY", 5))
KDOOR ZHOW
HALLO WELT
TREFFEN UM ACHT

Die Entschlüsselung braucht nur eine Zeile: Sie ruft die Verschlüsselung mit dem „Gegenschlüssel“ 26 - schluessel auf. Mit -schluessel funktioniert es genauso, weil % 26 auch negative Zahlen richtig behandelt. Der Hin-und-zurück-Test liefert jeweils den Klartext in Großbuchstaben, denn die Verschlüsselung wandelt den Text mit .upper() um.

1.14.3Erweiterungen für schnelle Teams

Arbeitsauftrag 168 (Zusatz): Brute-Force-Entschlüsselung

Baut eine Brute-Force-Entschlüsselung: Eine Funktion brute_force(geheimtext) probiert für einen gegebenen Geheimtext automatisch alle 26 möglichen Schlüssel durch und gibt alle Ergebnisse aus. So kann man den richtigen Klartext von Hand heraussuchen. Testet mit dem Geheimtext KDOOR ZHOW.

Lösung vergleichen
def brute_force(geheimtext):
    for schluessel in range(26):
        print(schluessel, ":", entschluessle_text(geheimtext, schluessel))

brute_force("KDOOR ZHOW")
0 : KDOOR ZHOW
1 : JCNNQ YGNV
2 : IBMMP XFMU
3 : HALLO WELT
4 : GZKKN VDKS
5 : FYJJM UCJR
6 : EXIIL TBIQ
7 : DWHHK SAHP
8 : CVGGJ RZGO
9 : BUFFI QYFN
10 : ATEEH PXEM
11 : ZSDDG OWDL
12 : YRCCF NVCK
13 : XQBBE MUBJ
14 : WPAAD LTAI
15 : VOZZC KSZH
16 : UNYYB JRYG
17 : TMXXA IQXF
18 : SLWWZ HPWE
19 : RKVVY GOVD
20 : QJUUX FNUC
21 : PITTW EMTB
22 : OHSSV DLSA
23 : NGRRU CKRZ
24 : MFQQT BJQY
25 : LEPPS AIPX

Nur bei Schlüssel 3 entsteht ein sinnvoller deutscher Text. Der Schlüssel 0 lässt den Text unverändert. Er wird hier nur der Vollständigkeit halber mit ausprobiert.

Arbeitsauftrag 169 (Zusatz): Menü

Erweitert euer Programm um ein kleines Text-Menü: Die Nutzerin oder der Nutzer wählt, ob ein Text verschlüsselt oder entschlüsselt werden soll oder ob das Programm beendet wird. Das Menü erscheint so lange immer wieder, bis „beenden“ gewählt wurde.

Lösung vergleichen
auswahl = ""
while auswahl != "3":
    print("1 = verschlüsseln, 2 = entschlüsseln, 3 = beenden")
    auswahl = input("Deine Wahl: ")
    if auswahl == "1" or auswahl == "2":
        text = input("Text: ")
        schluessel = int(input("Schlüssel: "))
        if auswahl == "1":
            print("Ergebnis:", verschluessle_text(text, schluessel))
        else:
            print("Ergebnis:", entschluessle_text(text, schluessel))
    elif auswahl != "3":
        print("Ungültige Wahl.")
print("Programm beendet.")
1 = verschlüsseln, 2 = entschlüsseln, 3 = beenden
Deine Wahl: «1»
Text: «Hallo»
Schlüssel: «3»
Ergebnis: KDOOR
1 = verschlüsseln, 2 = entschlüsseln, 3 = beenden
Deine Wahl: «2»
Text: «KDOOR»
Schlüssel: «3»
Ergebnis: HALLO
1 = verschlüsseln, 2 = entschlüsseln, 3 = beenden
Deine Wahl: «4»
Ungültige Wahl.
1 = verschlüsseln, 2 = entschlüsseln, 3 = beenden
Deine Wahl: «3»
Programm beendet.

Weil vorher nicht feststeht, wie oft das Menü erscheint, passt eine while-Schleife. auswahl wird vor der Schleife mit "" belegt, damit die Bedingung beim ersten Mal wahr ist. Die Wahl bleibt eine Zeichenkette, deshalb wird mit "1" verglichen und nicht mit 1.

Arbeitsauftrag 170: Wie sicher ist die Caesar-Chiffre?

Beurteile die Sicherheit der Caesar-Chiffre. Gehe dabei auf diese Fragen ein:

  1. Wie viele verschiedene Schlüssel gibt es, die den Text tatsächlich verändern?
  2. Wie lange braucht ein Programm, das einfach alle Schlüssel nacheinander ausprobiert (man nennt das Brute-Force, „rohe Gewalt“, siehe die Zusatzaufgabe oben), um einen Geheimtext zu knacken?
  3. Was müsste ein sicheres Verfahren anders machen?

Deine Beurteilung:

Lösung vergleichen

Die Caesar-Chiffre ist nicht sicher. Es gibt nur 25 Schlüssel, die den Text verändern (der Schlüssel 26 wirkt wie 0). Ein Programm probiert sie in einem Bruchteil einer Sekunde alle durch, und den richtigen Klartext erkennt man sofort, weil nur er sinnvoll ist. Außerdem bleibt die Häufigkeit der Buchstaben erhalten: Der häufigste Buchstabe im Geheimtext steht bei einem längeren deutschen Text wahrscheinlich für E. Ein sicheres Verfahren braucht so viele mögliche Schlüssel, dass Ausprobieren praktisch unmöglich ist, und es darf die Buchstabenhäufigkeiten nicht einfach durchreichen.

1.14.4Das Projekt abschließen

Zum Abschluss eines Projekts gehört mehr als ein laufendes Programm. Andere sollen verstehen, was es kann und wie es aufgebaut ist. Schreibt deshalb an den Anfang der Datei einen Kommentarkopf:

# Caesar-Chiffre: Texte ver- und entschlüsseln
# Team: Alex, Sam, Lea
# Funktionen: verschluessle_buchstabe, verschluessle_text,
#             entschluessle_text
# Bekannte Grenzen: Umlaute und ß werden nicht verschlüsselt.

Alle Zeilen beginnen mit #. Python überspringt sie beim Ausführen – sie sind nur für Menschen da.

Arbeitsauftrag 171: Projektabschluss
  1. Ergänzt euer Programm um einen Kommentarkopf wie oben.
  2. Führt mit dem fertigen Programm noch einmal alle Tests aus den Teilaufgaben A bis D durch.
  3. Bereitet eine Vorstellung von etwa einer Minute vor. Beantwortet darin: Was kann euer Programm? Aus welchen Funktionen besteht es? Welches Problem war am schwierigsten, und wie habt ihr es gelöst? Was würdet ihr noch verbessern?
  4. Schaut im Team zurück und füllt die Tabelle aus.
Rückblick im Team Stichpunkte
Das lief bei der Zusammenarbeit gut:
Das würden wir beim nächsten Projekt anders machen:
Das habe ich in diesem Projekt gelernt:

Stichpunkte für eure Vorstellung:

Lösung vergleichen

Hier gibt es keine einzig richtige Lösung. Eine gute Vorstellung nennt in wenigen Sätzen, was das Programm kann (ver- und entschlüsseln, ggf. Brute-Force und Menü), wie es aufgebaut ist (Alphabet, drei Funktionen, Hauptprogramm) und ein konkretes Problem mit seiner Lösung, z. B.: „Bei Leerzeichen ist unser Programm abgestürzt. Wir prüfen jetzt mit in, ob ein Zeichen im Alphabet steht.“ Im Rückblick kommt es auf ehrliche, konkrete Punkte an, nicht auf „alles war gut“.

1.14.5Berufliche Orientierung: Berufe rund um die Softwareentwicklung

Euer Verschlüsselungsprogramm ist klein. Aber nach demselben Prinzip – planen, zerlegen, programmieren, testen, zusammenführen – entsteht auch große Software: in Autos und Smartphones, in Krankenhäusern, Banken und Behörden, in Spielen und Lern-Apps. Daran arbeiten Menschen mit ganz unterschiedlichen Aufgaben und Ausbildungswegen. Manche haben eine Ausbildung gemacht, andere ein Studium, wieder andere sind aus einem ganz anderen Beruf eingestiegen.

Recherchiert in Partner- oder Kleingruppenarbeit zu einem Beruf bzw. Berufsfeld mit Bezug zur Softwareentwicklung, zum Beispiel:

Definition: Berufsbiografie

Eine Berufsbiografie beschreibt den beruflichen Werdegang einer realen Person: Schulabschluss, Ausbildung oder Studium, Berufseinstieg und die weiteren Stationen bis zur heutigen Tätigkeit.

Seriöse Quellen finden

Im Internet findest du zu jedem Beruf sehr viel – nicht alles davon stimmt, und manches ist Werbung. Beginne deshalb bei Quellen, die neutral informieren:

Tipp

Prüfe jede Information mit drei Fragen: Wer hat sie veröffentlicht? Wann wurde sie veröffentlicht oder zuletzt aktualisiert? Wird etwas verkauft oder beworben? Wichtige Angaben bestätigst du mit einer zweiten Quelle. Vorsicht bei Antworten von KI-Chatbots: Sie können überzeugend klingende, aber falsche Angaben erfinden (mehr dazu im Kapitel über Sprachmodelle). Schreibe nur auf, was du in einer Quelle gefunden hast, und notiere diese Quelle.

Leitfragen für die Recherche

  1. Welche Aufgaben und Tätigkeiten gehören zu diesem Berufsbild?
  2. Welche Ausbildung bzw. welches Studium wird benötigt?
  3. Welche Programmiersprachen oder Werkzeuge werden häufig eingesetzt?
  4. Wie hat sich das Berufsbild in den letzten Jahren verändert, z. B. durch KI-Werkzeuge?
  5. Was interessiert euch persönlich an diesem Berufsfeld – oder was eher nicht?
  6. Welche Person aus diesem Berufsfeld könnt ihr finden? Recherchiert ihren Werdegang (Berufsbiografie): Ausbildung oder Studium → Berufseinstieg → heutige Tätigkeit.
Arbeitsauftrag 172: Berufsfeld-Steckbrief

Recherchiert zu einem Beruf bzw. Berufsfeld mit Bezug zur Softwareentwicklung. Haltet die Antworten auf die Leitfragen 1 bis 5 in Stichpunkten fest und notiert zu jeder Angabe die Quelle. Für ausführlichere Notizen nutzt ein Extrablatt oder euer Berufsorientierungs-Portfolio.

Stichpunkte Quelle
Beruf/Berufsfeld
Aufgaben und Tätigkeiten
Ausbildung oder Studium
Werkzeuge und Programmiersprachen
Veränderung des Berufsbilds
Meine Einschätzung –
Lösung vergleichen

Ein Beispiel für einen guten Steckbrief (gekürzt). Prüfe die Angaben selbst nach – Berufsbilder werden immer wieder überarbeitet.

Stichpunkte Quelle
Beruf/Berufsfeld Fachinformatiker/-in für Anwendungsentwicklung BERUFENET
Aufgaben und Tätigkeiten Software nach Kundenwunsch planen, programmieren, testen und anpassen; Fehler beheben; Programme dokumentieren; Anwender beraten BERUFENET
Ausbildung oder Studium duale Ausbildung (Betrieb und Berufsschule), in der Regel 3 Jahre BERUFENET
Werkzeuge und Programmiersprachen verschiedene Programmiersprachen (z. B. Java, C#, Python), Entwicklungsumgebungen, Datenbanken Stellenanzeigen, BERUFENET
Veränderung des Berufsbilds KI-Assistenten schlagen Programmcode vor; dieser Code muss geprüft und getestet werden Fachartikel (mit Datum notieren)
Meine Einschätzung spannend: eigene Programme für echte Nutzer; weniger reizvoll: viel Sitzen am Bildschirm –

Worauf es ankommt: Die Stichpunkte beantworten die Leitfragen konkret, jede Sachangabe hat eine Quelle, und die eigene Einschätzung ist begründet. Zahlen (z. B. Gehälter) solltest du nur aufschreiben, wenn du sie mit Quelle und Datum belegen kannst.

Arbeitsauftrag 173: Berufsbiografie

Sucht den Werdegang einer realen Person aus eurem Berufsfeld, z. B. in einem Interview oder einem Porträt. Tragt die Stationen ein. Erfindet nichts: Was ihr nicht herausfinden könnt, kennzeichnet ihr mit „unbekannt“.

Station Zeitraum Was genau?
Schulabschluss
Ausbildung oder Studium
Berufseinstieg
heutige Tätigkeit
Quelle (mit Datum)
Lösung vergleichen

Hier kann keine Musterlösung stehen, weil ihr eine reale Person recherchiert. Ein gutes Ergebnis nennt die Stationen in zeitlicher Reihenfolge, gibt die Quelle mit Datum an und unterscheidet klar zwischen dem, was in der Quelle steht, und eurer eigenen Vermutung. Häufig zeigen solche Biografien, dass Wege in die Softwareentwicklung nicht geradlinig sind – das ist eine wichtige Erkenntnis.

Arbeitsauftrag 174: Kurzbeitrag

Bereitet zu eurem Berufsfeld einen mündlichen Beitrag von etwa einer Minute vor. Er soll drei Teile haben: Was macht man in diesem Beruf? Wie kommt man dorthin? Was hat euch bei der Recherche überrascht?

Stichpunkte für euren Beitrag:

Lösung vergleichen

Ein möglicher Aufbau: „Wir haben uns den Beruf … angesehen. Man … (zwei bis drei typische Tätigkeiten). Dorthin kommt man über … (Ausbildung/Studium). Überrascht hat uns, dass … Unsere Quelle war vor allem …“ Wichtig sind kurze Sätze, wenige, aber konkrete Fakten und die Nennung der Quelle.

1.14.6Weitere Übungen

Hier kannst du das Gelernte weiter üben. Die Punkte im Titel zeigen, wie schwer eine Aufgabe ist: ●○○ leicht, ●●○ mittel, ●●● knifflig. Fang mit den leichten an.

Arbeitsauftrag 175: Entschlüsseln und Gegenschlüssel ●○○

Der Geheimtext WGLYPI wurde mit der Caesar-Chiffre und dem Schlüssel 4 verschlüsselt.

  1. Entschlüssele ihn von Hand. Benutze die Positionstabelle aus dem Auftrag Caesar mit Schlüssel 5 im ersten Projektteil.
  2. Gib den Gegenschlüssel an: Mit welchem Schlüssel muss man verschlüsseln, um dasselbe Ergebnis zu bekommen wie beim Entschlüsseln mit dem Schlüssel 4?

Meine Lösungen:

Lösung vergleichen
  1. Beim Entschlüsseln zieht man 4 ab: W (22) → 18 = S, G (6) → 2 = C, L (11) → 7 = H, Y (24) → 20 = U, P (15) → 11 = L, I (8) → 4 = E. Der Klartext ist SCHULE.
  2. Der Gegenschlüssel ist 26−4=2226 - 4 = 22. Vier Schritte zurück landen an derselben Stelle wie 22 Schritte vorwärts.
alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"

def verschluessle_buchstabe(buchstabe, schluessel):
    position = alphabet.index(buchstabe)
    neue_position = (position + schluessel) % 26
    return alphabet[neue_position]

def verschluessle_text(text, schluessel):
    ergebnis = ""
    for zeichen in text.upper():
        if zeichen in alphabet:
            neu = verschluessle_buchstabe(zeichen, schluessel)
            ergebnis = ergebnis + neu
        else:
            ergebnis = ergebnis + zeichen
    return ergebnis

print(verschluessle_text("WGLYPI", 22))
print(verschluessle_text("WGLYPI", -4))
SCHULE
SCHULE

Beide Aufrufe entschlüsseln: einmal mit dem Gegenschlüssel 22, einmal mit −4. % 26 sorgt in beiden Fällen dafür, dass das Ergebnis eine gültige Position ist.

Arbeitsauftrag 176: Wer macht was? ●○○

In eurem Projekt habt ihr geplant, Schnittstellen festgelegt, programmiert, getestet, dokumentiert und die Sicherheit beurteilt. In einer Softwarefirma übernehmen oft verschiedene Personen diese Aufgaben.

Ordne drei dieser Projektschritte jeweils einem Beruf oder Berufsfeld aus dem Abschnitt Berufliche Orientierung zu. Begründe jede Zuordnung in einem Satz.

Projektschritt – Beruf – Begründung:

Lösung vergleichen

Eine mögliche Zuordnung:

  • Programmieren und Testen – Fachinformatikerin oder Fachinformatiker für Anwendungsentwicklung bzw. Softwareentwicklerin oder Softwareentwickler: Sie schreiben Programme nach den Wünschen der Kundschaft und prüfen sie mit Tests.
  • Sicherheit beurteilen – IT-Sicherheitsexpertin oder IT-Sicherheitsexperte: Sie untersuchen, ob ein Verfahren angreifbar ist – so wie ihr gezeigt habt, dass man die Caesar-Chiffre durch Ausprobieren knacken kann.
  • Bedienung planen (zum Beispiel das Menü) – UX/UI-Designerin oder UX/UI-Designer: Sie gestalten, wie Menschen ein Programm bedienen, damit es verständlich ist.

Andere Zuordnungen sind ebenso richtig, wenn die Begründung passt. In kleinen Firmen erledigt oft eine Person mehrere dieser Aufgaben.

Arbeitsauftrag 177: Der häufigste Buchstabe verrät den Schlüssel ●●○

Du hast den Geheimtext NOB OVOPKXD QORD JEW COO abgefangen. Den Schlüssel kennst du nicht. In deutschen Texten ist E meistens der häufigste Buchstabe.

  1. Bestimme den häufigsten Buchstaben im Geheimtext. Du kannst von Hand zählen oder die Funktion zaehle(text, zeichen) aus dem Auftrag Buchstaben zählen im Abschnitt über Zeichenketten benutzen.
  2. Nimm an, dass dieser Buchstabe für E steht. Berechne daraus den Schlüssel.
  3. Entschlüssele den Text mit entschluessle_text und prüfe, ob ein sinnvoller Satz herauskommt.

Häufigster Buchstabe, Schlüssel, Klartext:

Lösung vergleichen
  1. Der Buchstabe O kommt sechsmal vor, jeder andere Buchstabe höchstens zweimal.
  2. O hat die Position 14, E die Position 4. Der Schlüssel ist also 14−4=1014 - 4 = 10.
  3. Mit dem Schlüssel 10 ergibt sich ein sinnvoller Satz:
alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"

def verschluessle_buchstabe(buchstabe, schluessel):
    position = alphabet.index(buchstabe)
    neue_position = (position + schluessel) % 26
    return alphabet[neue_position]

def verschluessle_text(text, schluessel):
    ergebnis = ""
    for zeichen in text.upper():
        if zeichen in alphabet:
            neu = verschluessle_buchstabe(zeichen, schluessel)
            ergebnis = ergebnis + neu
        else:
            ergebnis = ergebnis + zeichen
    return ergebnis

def entschluessle_text(geheimtext, schluessel):
    return verschluessle_text(geheimtext, 26 - schluessel)

def zaehle(text, zeichen):
    anzahl = 0
    for z in text:
        if z == zeichen:
            anzahl = anzahl + 1
    return anzahl

geheim = "NOB OVOPKXD QORD JEW COO"
print("O:", zaehle(geheim, "O"))
print("D:", zaehle(geheim, "D"))
print(entschluessle_text(geheim, 10))
O: 6
D: 2
DER ELEFANT GEHT ZUM SEE

Statt alle 26 Schlüssel auszuprobieren, reicht hier ein Versuch. Diese Idee heißt Häufigkeitsanalyse. Sie zeigt einen zweiten Grund, warum die Caesar-Chiffre unsicher ist: Die Häufigkeit der Buchstaben bleibt beim Verschlüsseln erhalten. Bei sehr kurzen Texten klappt der Trick allerdings nicht immer, weil dort zufällig ein anderer Buchstabe am häufigsten sein kann.

Arbeitsauftrag 178: Knacken mit Suchwort ●●●

Die Funktion brute_force aus der Erweiterung gibt alle 26 Entschlüsselungen aus. Bei langen Texten ist es mühsam, darin den Klartext zu suchen.

Implementiere eine Funktion knacke(geheimtext, wort), die alle Schlüssel von 0 bis 25 ausprobiert, aber nur die Ergebnisse ausgibt, in denen das Wort wort vorkommt (zusammen mit dem Schlüssel). Teste mit dem Geheimtext KDOOR ZHOW und dem Suchwort "WELT" sowie mit dem Geheimtext aus dem vorigen Auftrag und dem Suchwort "DER".

Tipp

Mit wort in text prüfst du, ob ein Textstück in einer Zeichenkette vorkommt (Abschnitt über Zeichenketten). Diese Bedingung setzt du in die Schleife von brute_force vor das print.

Lösung vergleichen
alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"

def verschluessle_buchstabe(buchstabe, schluessel):
    position = alphabet.index(buchstabe)
    neue_position = (position + schluessel) % 26
    return alphabet[neue_position]

def verschluessle_text(text, schluessel):
    ergebnis = ""
    for zeichen in text.upper():
        if zeichen in alphabet:
            neu = verschluessle_buchstabe(zeichen, schluessel)
            ergebnis = ergebnis + neu
        else:
            ergebnis = ergebnis + zeichen
    return ergebnis

def entschluessle_text(geheimtext, schluessel):
    return verschluessle_text(geheimtext, 26 - schluessel)

def knacke(geheimtext, wort):
    for schluessel in range(26):
        versuch = entschluessle_text(geheimtext, schluessel)
        if wort in versuch:
            print(schluessel, ":", versuch)

knacke("KDOOR ZHOW", "WELT")
knacke("NOB OVOPKXD QORD JEW COO", "DER")
3 : HALLO WELT
10 : DER ELEFANT GEHT ZUM SEE
  • Zeile 22: Wie bei brute_force werden alle Schlüssel von 0 bis 25 durchprobiert.
  • Zeile 23: Das Ergebnis wird in versuch gespeichert, weil es zweimal gebraucht wird: für die Prüfung und für die Ausgabe.
  • Zeilen 24–25: Nur wenn das Suchwort im Versuch vorkommt, wird er ausgegeben.

Das Suchwort muss in Großbuchstaben stehen, weil verschluessle_text immer Großbuchstaben liefert. Mit "Welt" würde nichts gefunden. Ein Angreifer, der nur vermutet, dass ein häufiges Wort wie „DER“ oder „UND“ im Text steht, findet den Schlüssel so in einem Augenblick.

1.14.7Das Wichtigste in Kürze

Selbstcheck

1.15Kapitel 1 kompakt: der Lernzettel

Diesen Abschnitt als PDF (S. 195–198)

Leitidee

Hier steht das Wichtigste aus Kapitel 1 auf wenigen Seiten, zum Wiederholen vor einem GLN. Wenn dir etwas unklar ist, lies im passenden Abschnitt nach: Dort ist alles ausführlich erklärt, mit Beispielen und Aufgaben.

1.15.1Variablen, Ein- und Ausgabe (Abschnitt 1.1)

alter = int(input("Alter? "))        # ganze Zahl
groesse = float(input("Größe? "))    # Kommazahl

Typische Fehler: int(...) vergessen, dann gibt es beim Rechnen einen TypeError. Kommazahl mit Komma statt Punkt (1,68). Ein Variablenname mit anderer Groß-/Kleinschreibung (Alter statt alter) führt zum NameError.

1.15.2Operatoren und Bedingungen (Abschnitt 1.2)

Art Operatoren Beispiel
Rechnen + - * / 7 / 2 ergibt 3.5 (immer float)
ganzzahlig teilen, Rest //, % 7 // 2 ergibt 3, 7 % 2 ergibt 1
Potenz ** 2 ** 3 ergibt 8
Vergleich == != < > <= >= 3 != 4 ergibt True
logisch and, or, not True and False ergibt False
statt … schreibt man …
not (A and B) not A or not B
not (A or B) not A and not B
not (alter >= 12 and groesse >= 140) alter < 12 or groesse < 140

Das Gegenteil von >= ist <, das Gegenteil von <= ist >, das von == ist !=.

1.15.3Verzweigungen (Abschnitte 1.3 und 1.4)

if bedingung:            # Doppelpunkt!
    anweisungen          # eingerückt: 4 Leerzeichen
elif andere_bedingung:   # beliebig viele, freiwillig
    anweisungen
else:                    # freiwillig, ohne Bedingung
    anweisungen
match wahl:
    case 1:
        print("Kurzstrecke")
    case 2:
        print("Einzelfahrt")
    case _:              # alle anderen Werte, steht immer zuletzt
        print("Gibt es nicht")

Typische Fehler: Doppelpunkt vergessen (SyntaxError). = statt == in der Bedingung. Mehrere if statt elif, dann können zwei Ausgaben kommen. Grenzwert falsch (<= statt <). Bei match ohne int(...) passt case 1: nie, weil die Eingabe ein Text ist.

1.15.4Schleifen (Abschnitte 1.5 bis 1.7)

Schleife wann? Beispiel
for Anzahl der Durchläufe steht vorher fest for i in range(5):
while Ende hängt von einer Bedingung ab, Anzahl vorher unbekannt while zahl != 0:

Zwei Muster, die du sicher können solltest:

summe = 0                       # VOR der Schleife: einmal auf 0
for zahl in range(1, 11):
    summe = summe + zahl        # IN der Schleife: aufaddieren
print("Summe:", summe)          # NACH der Schleife: ausgeben
summe = 0
anzahl = 0
wert = float(input("Wert (0 = Ende): "))      # erste Eingabe vor der Schleife
while wert != 0:
    summe = summe + wert
    anzahl = anzahl + 1
    wert = float(input("Wert (0 = Ende): "))  # neue Eingabe am Ende des Rumpfs
print(anzahl, "Werte, Summe:", summe)

Typische Fehler: summe = 0 in die Schleife geschrieben, dann wird die Summe in jedem Durchlauf gelöscht. range(1, 10) statt range(1, 11). In der while-Schleife die neue Eingabe vergessen (Endlosschleife). summe + zahl ohne summe = davor ändert nichts.

1.15.5Funktionen (Abschnitte 1.8 und 1.9)

def flaeche(laenge, breite):     # Definition mit zwei Parametern
    return laenge * breite       # Rückgabewert

ergebnis = flaeche(3, 4)         # Aufruf mit den Argumenten 3 und 4
print(ergebnis)                  # 12

Typische Fehler: print statt return in der Funktion, dann kann man mit dem Ergebnis nicht weiterrechnen. Funktion aufgerufen, bevor sie definiert ist. Falsche Anzahl von Argumenten.

1.15.6Zeichenketten (Abschnitt 1.10)

Was Beispiel mit text = "Python" Ergebnis
Zeichen am Index text[0], text[5] "P", "n"
Länge len(text) 6
Ausschnitt (Slice) text[0:3] "Pyt" (Index 3 nicht mehr dabei)
Verkettung text + "!" "Python!"
Kleinbuchstaben text.lower() "python"

1.15.7Listen und Listenalgorithmen (Abschnitte 1.11 und 1.12)

Die Standardalgorithmen:

groesste = zahlen[0]             # Maximum: mit dem ersten Element beginnen
for zahl in zahlen:
    if zahl > groesste:
        groesste = zahl

gefunden = False                 # lineare Suche
for zahl in zahlen:
    if zahl == gesucht:
        gefunden = True

Für die Summe gilt dasselbe Muster wie bei den Schleifen (vor der Schleife 0, in der Schleife aufaddieren). Für das Minimum dreht man den Vergleich um (<).

Typische Fehler: Index und Element verwechseln. Der letzte Index ist len(liste) - 1, nicht len(liste). Das Maximum mit 0 statt mit dem ersten Element beginnen (falsch, wenn alle Zahlen negativ sind).

1.15.8Projekt: Caesar-Verschlüsselung (Abschnitte 1.13 und 1.14)

alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"

1.16Rückblick auf Kapitel 1

Diesen Abschnitt als PDF (S. 199–200)

Leitidee

Am Ende des Kapitels lohnt sich ein Blick zurück: Welche Fachbegriffe kennst du jetzt? Was kannst du schon sicher, was solltest du noch einmal üben? Die Tabellen auf den nächsten Seiten helfen dir dabei, zum Beispiel bei der Vorbereitung auf eine Klassenarbeit.

1.16.1Die Basisbegriffe

Diese Begriffe nennt der Lehrplan als Basisbegriffe. Du solltest jeden davon mit eigenen Worten erklären und an einem kleinen Beispiel zeigen können.

Begriff Bedeutung Beispiel
Variable benannter Speicherplatz für einen Wert alter = 15
Operator Zeichen für eine Rechen-, Vergleichs- oder Logikoperation +, %, ==, and
Eingabe Daten, die das Programm von der Nutzerin oder dem Nutzer bekommt name = input("Name? ")
Ausgabe Daten, die das Programm anzeigt print("Hallo", name)
Bedingung Ausdruck, der wahr (True) oder falsch (False) ist alter >= 18
Verzweigung Je nach Bedingung werden unterschiedliche Anweisungen ausgeführt. if … elif … else
for-Schleife wiederholt Anweisungen für jeden Wert einer Folge (Zählschleife) for i in range(5):
while-Schleife wiederholt Anweisungen, solange eine Bedingung wahr ist while zahl > 0:
Funktion benannter Programmteil, der bei Aufruf ausgeführt wird def quadrat(x):
Parameter Platzhalter für den Wert, den man der Funktion beim Aufruf übergibt x in def quadrat(x):
Rückgabewert Ergebnis, das eine Funktion mit return zurückgibt return x * x
Zeichenkette Folge (Sequenz) von Zeichen "Hallo"
Liste bzw. Feld geordnete Zusammenfassung mehrerer Elemente zu einer Einheit [4, 7, 1]
Index Position eines Elements; die Zählung beginnt bei 0 zahlen[0]

1.16.2Kompetenz-Check

Kreuze ehrlich an, wie sicher du dich fühlst. Wo du „noch nicht“ ankreuzt, lies den passenden Abschnitt noch einmal und bearbeite seine Arbeitsaufträge.

Ich kann … sicher teilweise noch nicht
Variablen verwenden, um Daten unterschiedlicher Typen zu speichern.
Ein- und Ausgabeanweisungen verwenden und Eingaben in Zahlen umwandeln.
arithmetische, vergleichende und logische Operatoren verwenden.
verknüpfte Bedingungen mit den Regeln von De Morgan verneinen.
ein-, zwei- und mehrseitige Verzweigungen analysieren und programmieren.
eine Mehrfachauswahl (CASE OF) mit match/case programmieren.
for- und while-Schleifen analysieren, programmieren und passend auswählen.
Funktionen mit Parametern und Rückgabewert verwenden und selbst schreiben.
fremde Programme lesen, erklären, testen und erweitern.
eigene Algorithmen entwerfen und als Programm umsetzen.
Zeichenketten als Folge von Zeichen beschreiben und bearbeiten (Verkettung, Länge, Zugriff auf Zeichen).
Listen anlegen, zwischen Index und Element unterscheiden und Elemente lesen und ändern.
mit Schleifen über Zeichenketten und Listen laufen.
Minimum, Maximum, Summe und lineare Suche auf Listen programmieren.
im Team ein Programmierprojekt umsetzen.
Berufe mit Bezug zur Softwareentwicklung recherchieren und vorstellen.
Informatik 10 | Programmieren mit PythonDruckfassung (PDF)