
Kapitel 1
Programmieren mit Python
Skript Informatik · Klasse 10 · MINT
Notebooks in diesem Kapitel DS01–DS14
- DS01 Variablen, Eingabe und Ausgabe
- DS02 Operatoren: rechnen, vergleichen, verknüpfen
- DS03 Verzweigungen: Programme treffen Entscheidungen
- DS04 Übung: Verzweigungen lesen, testen und erweitern
- DS05 Die for-Schleife: Anweisungen wiederholen
- DS06 Die while-Schleife: Wiederholen, solange eine Bedingung gilt
- DS07 Übung: for- oder while-Schleife?
- DS08 Funktionen: Programme aus Bausteinen
- DS09 Übung: Funktionen lesen, testen und erweitern
- DS10 Zeichenketten: Texte Zeichen für Zeichen
- DS11 Listen: viele Werte unter einem Namen
- DS12 Algorithmen auf Listen: Summe, Minimum und Suche
- DS13 Projekt Verschlüsselung (Teil 1): die Caesar-Chiffre
- DS14 Projekt Verschlüsselung (Teil 2) und Berufe in der Softwareentwicklung
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:
- Lies einen Abschnitt in Ruhe. Die Abschnitte bauen aufeinander auf. Überspringe nichts, auch wenn es leicht aussieht.
- 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.
- 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.
- 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.
- 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.
Mit diesen Satzanfängen kannst du in jedem Abschnitt beschreiben und erklären, was ein Programm tut:
- „Für die Eingabe … liefert das Programm …, weil …“
- „Die Bedingung/Schleife/Funktion wird ausgeführt, wenn …“
- „Ich ändere …, damit …“
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.
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.
Nach diesem Abschnitt kannst du
- mit
print()Texte und Zahlen auf dem Bildschirm ausgeben, - Variablen anlegen, ihnen Werte zuweisen und mit ihnen rechnen,
- die Datentypen
int,float,strundboolunterscheiden, - mit
input()Eingaben einlesen und mitint()undfloat()in Zahlen umwandeln, - eine Fehlermeldung lesen und die Ursache des Fehlers finden.
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
- Zeile 1: Hier stehen keine Anführungszeichen.
Python liest
3 + 4als Rechnung, rechnet sie aus und gibt das Ergebnis7aus. - Zeile 2: Jetzt steht
3 + 4in Anführungszeichen. Für Python ist das ein Text wie jeder andere. Er wird genau so ausgegeben, wie er dasteht.
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.
Mit print(...) gibt man Werte auf dem Bildschirm aus.
Texte stehen in Anführungszeichen, Zahlen und Rechnungen ohne. Mehrere
Werte trennt man durch Kommas.
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.“
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.
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.
- Zeile 1: Die Variable
alterwird angelegt und bekommt den Wert15. Auf dem Bildschirm passiert dabei nichts. - Zeile 2:
altersteht ohne Anführungszeichen. Python schaut deshalb in die Schachtelalterund gibt ihren Inhalt aus:15. - Zeile 3: Text und Variable werden durch Kommas getrennt ausgegeben.
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
- Zeile 1:
alterbekommt den Wert15. - Zeile 3: Zuerst wird die rechte Seite ausgerechnet:
Der aktuelle Wert von
alterist15, plus1ergibt16. Dann bekommtalterdiesen neuen Wert. Der alte Wert15ist weg – er wurde überschrieben.
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 |
- Eine Variable ist ein benannter Speicherplatz im Arbeitsspeicher, in dem ein Wert abgelegt wird.
- Mit dem Zuweisungsoperator
=wird einer Variablen ein Wert zugewiesen, z. B.alter = 15. Zuerst wird die rechte Seite ausgewertet, dann wird das Ergebnis in der Variablen links gespeichert.
Gute Namen für Variablen
Den Namen einer Variablen darfst du selbst wählen. Dabei gelten ein paar Regeln:
- Erlaubt sind Buchstaben, Ziffern und der Unterstrich
_. Ein Name darf nicht mit einer Ziffer beginnen und keine Leerzeichen enthalten. - Groß- und Kleinschreibung zählt:
alterundAltersind zwei verschiedene Namen. - Verwende sprechende Namen, an denen man erkennt,
was gespeichert ist:
preisstattp,anzahl_artikelstattaa. Mehrere Wörter verbindest du mit_. - Verzichte auf Umlaute und ß in Namen:
groessestattgröße. Das funktioniert zwar meist, kann aber Probleme machen.
| Name | erlaubt? | Grund |
|---|---|---|
punkte |
✓ | |
punkte_runde_2 |
✓ | |
2_runde |
✗ | beginnt mit einer Ziffer |
meine punkte |
✗ | enthält ein Leerzeichen |
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’?“
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) |
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:
- Kommazahlen schreibt man in Python mit einem Punkt,
nicht mit einem Komma:
1.68, nicht1,68. - Alles in Anführungszeichen ist ein Text, auch wenn Ziffern darin
stehen:
"15"ist eine Zeichenkette,15eine Zahl. TrueundFalseschreibt man mit großem Anfangsbuchstaben und ohne Anführungszeichen. Wahrheitswerte brauchst du später für Bedingungen.
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.“
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.
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.
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
- Zeile 1:
inputzeigt zuerst den Text in den Klammern an, die sogenannte Eingabeaufforderung. Dann wartet das Programm, bis jemand etwas eintippt und die Eingabetaste drückt. Der eingetippte Text (hier blau gedruckt) wird in der Variablennamegespeichert. - Zeile 2: Der gespeicherte Name wird ausgegeben.
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".
- Mit
input(...)liest man eine Eingabe von der Nutzerin oder dem Nutzer ein. Die Eingabe ist immer vom Typstr!
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" |
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
- Zeile 1: Die Eingabe wird als Zeichenkette in
lieblingszahlgespeichert. - Zeile 2: Die Ausgabe bestätigt: Der Typ ist
str. - Zeile 3: Eine leere Zeile. Sie hat keine Wirkung, macht das Programm aber übersichtlicher.
- Zeile 4:
int(lieblingszahl)macht aus dem Text"7"die Zahl7. Das Ergebnis wird in einer neuen Variablen gespeichert. - Zeile 5: Jetzt wird wirklich gerechnet:
7 * 2 = 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
Soll eine Eingabe als Zahl weiterverarbeitet werden, muss sie
umgewandelt werden: int(...) bzw. float(...)
(Typumwandlung).
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.
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:
- 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 nurstr(nichtint) anstranhängen.“ - 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. - 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 beschreibst du ein Programm in Fachsprache – vom einfachen zum genauen Satz:
- „alter ist 15.“ → „Der Variablen
alterwird der Wert 15 zugewiesen.“ - „Das Programm fragt nach dem Namen.“ → „Die
Eingabeanweisung liest den Namen ein und speichert ihn als Zeichenkette
in der Variablen
name.“ - „Da kommt 14 raus.“ → „Zur Eingabe 7 gibt das Programm den Wert 14 aus.“
1.1.7Übungen
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
- In Zeile 1 fehlt das schließende Anführungszeichen nach
Erste Zahl:→SyntaxError. - In Zeile 3 steht
Zahl1mit großem Z. Die Variable heißt aberzahl1→NameError. - Die Eingaben werden nicht umgewandelt. Dann rechnet das Programm
nicht, sondern hängt die Texte aneinander: Aus
3und4wird34statt7. 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.
Schreibe ein Programm, das folgende Angaben mit input()
abfragt und anschließend als vollständigen Satz ausgibt:
- Name
- Alter (als Zahl!)
- Lieblingsfach
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.
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.
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.
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.
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.
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.
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.
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.
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.)- Finde die drei Fehler. Notiere jeweils die Zeile und was falsch ist.
- Schreibe das Programm richtig auf und teste es mit
20(richtig ist 68 Grad Fahrenheit).
Die Fehler:
Lösung vergleichen
- Zeile 1: Die Eingabe wird nicht umgewandelt.
celsiusist ein Text, und mit einem Text kann man nicht rechnen. Python meldet in Zeile 2 einenTypeError. Richtig:float(input(...)). - Zeile 3:
Fahrenheitmit großem F. Die Variable heißt aberfahrenheit. Python meldet einenNameError. - Zeile 3: Nach
Grad Fahrenheit.fehlt das schließende Anführungszeichen. Python meldet einenSyntaxError.
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.
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.
Für eine Person braucht man für Pfannkuchen 62,5 g Mehl, 0,5 Eier und 125 ml Milch.
- Schreibe ein Programm, das die Anzahl der Personen einliest und ausgibt, wie viel man von jeder Zutat braucht.
- Begründe, warum du die Anzahl der Personen mit
intund nicht mitfloatumwandelst.
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
- Personen kann man nur ganz zählen. Eine Eingabe wie
2.5wäre unsinnig, undintwürde sie mit einemValueErrorablehnen. Die Mengen für Mehl und Eier sind trotzdem Kommazahlen, weil mit62.5und0.5gerechnet wird. Bei der Milch wird nur mit ganzen Zahlen gerechnet, deshalb steht dort750ohne.0.
Eine Einzelfahrt mit dem Bus kostet 2,10 Euro. Eine Monatskarte kostet 58 Euro.
- 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.
- Teste dein Programm mit
2Fahrten an20Tagen und mit2Fahrten an10Tagen. 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
- Ein Programm ist eine Folge von Anweisungen, die von oben nach unten ausgeführt werden.
print(...)gibt Werte aus. Mehrere Werte werden durch Kommas getrennt und mit Leerzeichen ausgegeben.- Eine Variable ist ein benannter Speicherplatz. Mit
=bekommt sie einen Wert (Zuweisung); ein neuer Wert überschreibt den alten. - Wichtige Datentypen:
int(ganze Zahl),float(Kommazahl mit Punkt),str(Zeichenkette) undbool(True/False). input(...)liest eine Eingabe ein. Die Eingabe ist immer vom Typstr.- Mit
int(...),float(...)undstr(...)wandelt man Werte in einen anderen Datentyp um (Typumwandlung). - Fehlermeldungen liest man von unten nach oben: Fehlerart, Beschreibung, dann die Zeilennummer.
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.
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.
Nach diesem Abschnitt kannst du
- die Rechenoperatoren
//,%und**benutzen und erklären, was sie berechnen, - mit
//und%Minuten in Stunden und Minuten umrechnen und prüfen, ob eine Zahl gerade ist, - zwei Werte mit den Vergleichsoperatoren
==,!=,<,>,<=und>=vergleichen, - Wahrheitswerte mit
and,orundnotverknüpfen und das Ergebnis vorhersagen, - die Zuweisung
=und den Vergleich==sicher unterscheiden.
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.
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
- Zeile 1:
//ist die Ganzzahldivision. Sie gibt an, wie oft die 5 ganz in die 17 passt: 3-mal. Bei positiven Zahlen fallen die Nachkommastellen einfach weg. Wie viele Kekse bekommt jedes Kind? 3. - Zeile 2:
%heißt Modulo und liefert den Rest der Division: 17 − 3 · 5 = 2. Wie viele Kekse bleiben übrig? 2. - Zeile 3: Zum Vergleich die normale Division mit
/. Sie rechnet mit Nachkommastellen weiter und liefert einenfloat.
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.
- Zeile 1: Die Eingabe wird gleich in eine ganze Zahl
umgewandelt und in
minuten_gesamtgespeichert. - Zeile 2:
135 // 60ergibt2, denn die 60 passt zweimal ganz in die 135. - Zeile 3:
135 % 60ergibt15, denn 135 − 2 · 60 = 15 Minuten bleiben übrig. - Zeilen 4–5: Die Ausgabe ist lang und deshalb auf
zwei Zeilen verteilt. Innerhalb der Klammern von
printdarf man in der nächsten Zeile weiterschreiben.
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).
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
:
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.
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 **.
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
- Zeile 1: Erst die Potenz: , dann .
- Zeile 2: Erst die Klammer: , dann .
- Zeile 3: Erst
7 % 4, das ergibt3. Dann10 - 3 = 7.
Wenn du unsicher bist, setze Klammern. Sie schaden nie und machen das Programm leichter lesbar.
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
(),
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
- Zeilen 1–2: Die Variablen
aundbbekommen die Werte7und3. - Zeilen 3–5: Ist 7 größer als 3? Ja
(
True). Ist 7 gleich 3? Nein (False). Ist 7 ungleich 3? Ja (True). - Zeile 6: Ist 7 kleiner oder gleich 7? Ja, denn
„gleich“ reicht schon. Also
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'>
- Zeile 2: Wie bei jeder Zuweisung wird zuerst die
rechte Seite ausgewertet: Ist 15 größer oder gleich 18? Nein, das
Ergebnis ist
False. Erst dann wird dieser Wert inist_volljaehriggespeichert. - Zeile 4: Der Typ ist
bool, also ein Wahrheitswert.
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.
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:
x = 5ist eine Zuweisung: „xbekommt den Wert 5.“ Dabei wird nichts geprüft.x == 5ist ein Vergleich: „Istxgleich 5?“ Das Ergebnis istTrueoderFalse. Dabei wird nichts verändert.
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
==?“
- Vergleichsoperatoren liefern immer einen
Wahrheitswert (
bool:TrueoderFalse):==(gleich),!=(ungleich),<,>,<=,>=. - Verwechsle nicht
=(Zuweisung) und==(Vergleich)!
So beschreibst du einen Vergleich in Fachsprache – vom einfachen zum genauen Satz:
- „Da kommt True raus.“ → „Für
zahl = 7liefert der Vergleichzahl > 4den WahrheitswertTrue, weil 7 größer als 4 ist.“ - „Ich bekomme raus, ob die Zahl größer als 4 ist.“ → „Die Anweisung prüft, ob eine Zahl größer als 4 ist, und teilt das Ergebnis mit.“
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:
andheißt „und“. Das Ergebnis ist nur dannTrue, wenn beide SeitenTruesind. Sobald eine SeiteFalseist, ist das GanzeFalse.orheißt „oder“. Das Ergebnis istTrue, wenn mindestens eine SeiteTrueist – also auch, wenn beide wahr sind. Das ist anders als bei „entweder … oder“ im Alltag („Tee oder Kaffee?“). Nur wenn beide SeitenFalsesind, ist das ErgebnisFalse.notheißt „nicht“. Es steht vor einem einzelnen Wahrheitswert und kehrt ihn um: AusTruewirdFalseund ausFalsewirdTrue.
print(True and False)
print(True or False)
print(not True)
print(not 7 > 3)False
True
False
False
- Zeile 1: Die rechte Seite ist
False. Fürandmüssten beide Seiten wahr sein, alsoFalse. - Zeile 2: Für
orgenügt eine wahre Seite, alsoTrue. - Zeile 3:
notkehrtTrueum. - Zeile 4: Zuerst wird der Vergleich ausgewertet:
7 > 3istTrue. Dann kehrtnotdas Ergebnis um.
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 |
Logische Operatoren verknüpfen Wahrheitswerte:
and– beide Bedingungen müssen wahr sein,or– mindestens eine Bedingung muss wahr sein,not– kehrt einen Wahrheitswert um.
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:
alter >= 13, also15 >= 13, ergibtTrue.alter < 18, also15 < 18, ergibtTrue.True and TrueergibtTrue.
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.
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:
A= Die Hausaufgaben sind fertig.B= Das Zimmer ist aufgeräumt.C= Es ist Wochenende.
Zwei Eltern formulieren ihre Regel fürs Zocken unterschiedlich:
- Regel 1:
(A and B) or C– „Du darfst zocken, wenn die Hausaufgaben fertig und das Zimmer aufgeräumt ist – oder wenn Wochenende ist.“ Am Wochenende reicht alsoC = Trueallein. - Regel 2:
A and (B or C)– „Du darfst zocken, wenn die Hausaufgaben fertig sind und zusätzlich das Zimmer aufgeräumt oder Wochenende ist.“ Hier müssen die Hausaufgaben immer fertig sein.
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
- Zeilen 1–3: Die drei Bedingungen werden als
Wahrheitswerte gespeichert. Die Kommentare hinter
#erklären, wofür jede Variable steht. - Zeile 5: Zuerst wird die Klammer berechnet:
False and FalseergibtFalse. Dann folgtFalse or True, das istTrue. - Zeile 6: Zuerst die Klammer:
False or TrueergibtTrue. DannFalse and True, das istFalse.
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.
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
- Zeile 2: Die Klammer wird zuerst ausgewertet:
20 >= 13istTrue,20 < 18istFalse, zusammen mitandalsoFalse.notmacht darausTrue. Die Person ist nicht jugendlich. - Zeile 3: Dieselbe Frage ohne
not: Die Person ist nicht jugendlich, wenn sie jünger als 13 oder mindestens 18 ist. Auch das ergibtTrue.
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“.
Regeln von De Morgan:
not (A and B)ist dasselbe wienot A or not B,not (A or B)ist dasselbe wienot A and not B.
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
für and,
für or und
für not. Die beiden Regeln lauten dann
und
.
Das Zeichen
heißt: Beide Seiten haben für alle Werte von
und
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 |
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.
Schreibe zu jeder Bedingung eine Bedingung ohne
not, die genau das Gegenteil prüft. Teste deine Antworten
am Computer mit ein paar Werten.
zahl >= 1 and zahl <= 6(eine Würfelzahl)note == 1 or note == 2not (temperatur > 30 or regen)(Tipp:regenist eine Variable mit einem Wahrheitswert; „nichtregen“ darfst du hier alsnot regenstehen lassen.)
Meine Bedingungen:
Lösung vergleichen
zahl < 1 or zahl > 6– die Zahl ist keine Würfelzahl.note != 1 and note != 2– die Note ist weder 1 noch 2.- Hier ist schon eine Verneinung gegeben. Nach De Morgan gilt:
not (temperatur > 30 or regen)ist dasselbe wietemperatur <= 30 and not regen– es ist höchstens 30 Grad warm und es regnet nicht. (Nur anregenbleibt einnot, weilregenkein 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
- Zeilen 4–7: arithmetische Operatoren. Die 3 passt
2-mal ganz in die 7, Rest 1.
7 ** 2ist . - Zeilen 9–10: Vergleiche. Ihr Ergebnis ist ein Wahrheitswert.
- Zeilen 12–13: Die Variable
hat_ausweisspeichert direkt den WahrheitswertTrue. - Zeilen 14–15: Zuerst wird
alter >= 12ausgewertet, das ergibtTrue. Dann wirdTrue and Trueberechnet. Das Ergebnis istTrue. Probiere aus, was sich ändert, wenn duhat_ausweis = Falseoderalter = 11setzt.
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 GanzeFalse.x == 5 or y == 5: Eine wahre Seite genügt.not x > y:5 > 10istFalse, umgekehrtTrue.x % 2 == 0: Der Rest von 5 geteilt durch 2 ist 1, also nicht 0. 5 ist ungerade.- Im letzten Ausdruck ist
x + y >= 15wahr (15 ist größer oder gleich 15). Abery == 10ist wahr undnotmacht darausFalse. UndTrue and FalseergibtFalse.
1.2.5Übungen
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.
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.
Zerlege die Regel in Teile und übersetze jeden Teil einzeln:
- „durch 4 teilbar“ →
jahr % 4 == 0 - „nicht durch 100 teilbar“ →
jahr % 100 != 0 - „durch 400 teilbar“ →
jahr % 400 == 0
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.
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 % 8ist0: 40 ist durch 8 teilbar.3 % 8ist3: Die 8 passt keinmal in die 3, also ist die ganze 3 der Rest.17 % 2ist1: 17 ist ungerade.- In
10 - 4 // 2wird zuerst4 // 2 = 2gerechnet, denn//ist Punktrechnung. Mit Klammern wird zuerst10 - 4 = 6gerechnet, dann6 // 2 = 3.
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:bist gleich 9, die Frage „ist ungleich 9?“ wird also mitFalsebeantwortet.a >= 5: 4 ist weder größer als 5 noch gleich 5.a * 2 > b: Zuerst wird gerechnet (8), dann verglichen:8 > 9ist falsch.b % a == 1: 9 geteilt durch 4 ergibt 2 Rest 1. Der Rest ist also 1.
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
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.
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.
- Die Zahl
xist durch 3 teilbar. - Das Alter
alterliegt zwischen 10 und 15 (beide Grenzen gehören dazu). - Die Punktzahl
punkteist kleiner als 0 oder größer als 100. - Die Zahl
zahlist ungerade. - Die Anzahl
stundenist nicht 0.
Meine Ausdrücke:
Lösung vergleichen
x % 3 == 0alter >= 10 and alter <= 15punkte < 0 or punkte > 100zahl % 2 == 1(oderzahl % 2 != 0)stunden != 0(odernot 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.
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)- Finde die drei Fehler. Notiere jeweils die Zeile und was falsch ist.
- Schreibe das Programm richtig auf und teste es mit
35und42.
Die Fehler:
Lösung vergleichen
- Zeile 1: Die Eingabe wird nicht in eine Zahl
umgewandelt. Mit dem Text
"35"kann%nicht den Rest berechnen. Python meldet einenTypeError. Richtig:int(input(...)). - Zeile 2: Für den Vergleich braucht man
==, nicht=. Python meldet einenSyntaxError. - 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.
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)- Bestimme
darf_ausleihenfür die vier Fälle in der Tabelle. Prüfe am Computer, indem du die Werte in den Zeilen 1 bis 3 änderst. - 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.
- Ohne Klammern wird zuerst
andausgewertet, danachor. 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.
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
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 // 10ergibt47, und47 % 10ergibt7. Auchzahl % 100 // 10ist richtig:472 % 100ergibt72, und72 // 10ergibt7. - 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
- Ein Operator verarbeitet einen oder mehrere Werte (Operanden) zu einem neuen Wert.
- Arithmetische Operatoren:
+ - * /sowie//(Ganzzahldivision),%(Rest) und**(Potenz). Potenz vor Punkt vor Strich, Klammern zuerst. zahl // 60undzahl % 60zerlegen z. B. Minuten in Stunden und restliche Minuten.zahl % 2 == 0prüft, ob eine Zahl gerade ist.- Vergleichsoperatoren
== != < > <= >=liefern immerTrueoderFalse. - Logische Operatoren:
and(beide wahr),or(mindestens eine wahr),not(umkehren). - Klammern legen fest, was zuerst ausgewertet wird:
(A and B) or CundA and (B or C)sind nicht äquivalent. - Regeln von De Morgan:
not (A and B)ist dasselbe wienot A or not B,not (A or B)dasselbe wienot A and not B. So verneint man verknüpfte Bedingungen. =weist einen Wert zu,==vergleicht zwei Werte.
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.
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“.
Nach diesem Abschnitt kannst du
- erklären, woraus eine Verzweigung besteht, und die Fachbegriffe Bedingung, dann-Teil und sonst-Teil verwenden,
- ein-, zwei- und mehrseitige Verzweigungen mit
if,elseundelifschreiben, - mit der Einrückung festlegen, welche Anweisungen zu einem Block gehören, und Einrückungsfehler beheben,
- den Ablauf eines Programms mit Verzweigung in einem Programmablaufplan und einem Ablaufprotokoll darstellen,
- Bedingungen mit
andundorformulieren und Verzweigungen verschachteln.
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!
- Zeile 1: Die Variable
temperaturbekommt den Wert30. - Zeile 2:
ifist englisch und heißt „wenn“ oder „falls“. Dahinter steht die Bedingungtemperatur > 25. Python prüft sie: 30 ist größer als 25, die Bedingung ist alsoTrue. Am Ende der Zeile steht ein Doppelpunkt. - Zeile 3: Diese Zeile ist
eingerückt, sie beginnt mit vier Leerzeichen. Dadurch
gehört sie zur
if-Anweisung. Sie wird nur ausgeführt, weil die Bedingung wahr ist. - Zeile 4: Diese Zeile ist nicht eingerückt. Sie
gehört nicht mehr zur
if-Anweisung und wird in jedem Fall ausgeführt.
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.
Eine Bedingung ist ein Ausdruck, dessen Wert
entweder wahr (True) oder falsch (False) ist,
zum Beispiel temperatur > 25.
Eine Verzweigung ist eine Kontrollstruktur, die abhängig von einer Bedingung festlegt, welche Anweisungen ausgeführt werden. Man nennt sie auch bedingte Anweisung.
- Eine Verzweigung (bedingte Anweisung) besteht aus einer Bedingung und einem oder mehreren Anweisungsblöcken.
- Einseitige Verzweigung:
if Bedingung:– der eingerückte Block wird nur ausgeführt, wenn die BedingungTrueist.
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.
In Python bestimmt die Einrückung (4 Leerzeichen),
welche Anweisungen zu einem Block gehören. Die Zeile mit der Bedingung
endet mit einem Doppelpunkt :.
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 ':'
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.
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.
- Zeile 1: Die Eingabe wird in eine ganze Zahl
umgewandelt und in
zahlgespeichert. - Zeile 2: Die Bedingung
zahl > 4wird geprüft. Für 7 ist sie wahr. - Zeile 3: Dieser eingerückte Block ist der dann-Teil. Er wird ausgeführt, wenn die Bedingung wahr ist.
- Zeile 4:
else:steht genau unter demif(gleiche Einrückung) und hat keine eigene Bedingung, aber einen Doppelpunkt. Schreibst du trotzdem eine Bedingung dahinter, etwaelse zahl < 4:, meldet PythonSyntaxError: expected ':'. - Zeile 5: Der sonst-Teil. Er wird nur ausgeführt, wenn die Bedingung falsch ist. Bei der Eingabe 7 wird er übersprungen.
- Zeile 6: Nicht eingerückt, wird also in jedem Fall ausgeführt.
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).
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.
Zweiseitige Verzweigung: if … else: –
entweder der dann-Teil oder der
sonst-Teil wird ausgeführt.
So beschreibst du eine Verzweigung in Fachsprache – vom einfachen zum genauen Satz:
- „Ich bekomme raus, ob die Zahl größer als 4 ist.“
- „Die Anweisung gibt ‚Die Zahl ist größer als 4.‘ aus, wenn eine Zahl größer als 4 ist, und ‚Die Zahl ist nicht größer als 4.‘, wenn sie es nicht ist.“
- „Die Alternativanweisung prüft, ob eine Zahl größer als 4 ist. Ist dies der Fall, wird ‚Die Zahl ist größer als 4.‘ ausgegeben und sonst ‚Die Zahl ist nicht größer als 4.‘“
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.
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
- Zeile 1: Die Punktzahl wird eingelesen und in
notegespeichert. - Zeile 3: Die erste Bedingung wird geprüft: Ist 80 größer oder gleich 90? Nein.
- Zeile 5: Weil die erste Bedingung falsch war, wird die nächste geprüft: Ist 80 größer oder gleich 75? Ja.
- Zeile 6: Der zugehörige Block wird ausgeführt: „Note: gut“.
- Zeilen 7–10: Werden übersprungen. Sobald eine
Bedingung zutrifft, prüft Python die weiteren gar nicht
mehr, obwohl auch
80 >= 50wahr wäre.
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.
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.
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.
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.
Schreibe ein Programm, das ein Alter einliest und es so einordnet:
- unter 6: „Kleinkind“
- 6 bis unter 13: „Kind“
- 13 bis unter 18: „Jugendlicher“
- ab 18: „Erwachsener“
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.
- Zeile 1: Der Tag wird als Text eingelesen. Hier wird nicht umgewandelt, denn es soll ein Text verglichen werden.
- Zeile 2: Die Bedingung ist wahr, wenn
mindestens einer der beiden Vergleiche wahr ist.
tag == "Samstag"ist falsch,tag == "Sonntag"ist wahr. Also ist die ganze Bedingung wahr.
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.
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!
- Zeile 2: Die äußere Verzweigung prüft den Benutzernamen.
- Zeilen 3–7: Das ist der dann-Teil der äußeren Verzweigung. Alle diese Zeilen sind mindestens vier Leerzeichen eingerückt.
- Zeilen 4–7: Darin steht eine zweite, innere Verzweigung. Ihre Blöcke (Zeilen 5 und 7) sind noch einmal vier Leerzeichen weiter eingerückt, also acht Leerzeichen.
- Zeilen 8–9: Das
elsesteht genau unter dem äußerenif. Es gehört deshalb zur äußeren Verzweigung.
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.
Verzweigungen können verschachtelt werden: Eine
if-Anweisung steht im Block einer anderen. Die Einrückung
zeigt, welcher Block zu welcher Bedingung gehört.
Ein Freizeitpark hat folgende Regeln für eine Achterbahn:
- Mindestgröße: 140 cm.
- Ist man kleiner als 140 cm, aber mindestens 120 cm, darf man nur in Begleitung eines Erwachsenen mitfahren.
- Ist man kleiner als 120 cm, darf man nicht mitfahren.
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.
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“.
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.
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.
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.
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")- Finde die drei Fehler. Notiere jeweils die Zeile und was falsch ist.
- Schreibe das Programm richtig auf. Teste es mit den Grenzwerten 29, 30, 44, 45, 59 und 60.
Die Fehler:
Lösung vergleichen
- Zeile 6: Am Ende der
elif-Zeile fehlt der Doppelpunkt (SyntaxError: expected ':'). - Zeile 9: Die Anweisung im
else-Block ist nicht eingerückt (IndentationError). - 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 |
Schreibe ein Programm, das die Temperatur (ganze Zahl in Grad Celsius) einliest und eine Kleidungsempfehlung ausgibt:
- unter 10 Grad: „Zieh eine Jacke an.“
- 10 bis unter 20 Grad: „Ein Pulli reicht.“
- ab 20 Grad: „T-Shirt-Wetter!“
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.
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.
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
- gleichseitig ist (alle drei Seiten gleich lang),
- gleichschenklig ist (genau zwei Seiten gleich lang) oder
- allgemein ist (alle Seiten verschieden).
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
- Eine Verzweigung besteht aus einer
Bedingung (Wert
TrueoderFalse) und einem oder mehreren Anweisungsblöcken. if Bedingung:– der Block wird nur ausgeführt, wenn die Bedingung wahr ist (einseitig).if … else:– entweder der dann-Teil oder der sonst-Teil wird ausgeführt (zweiseitig).if … elif … else:– nur der Block der ersten zutreffenden Bedingung wird ausgeführt (mehrseitig). Die Reihenfolge ist wichtig.- Hinter jeder Bedingung und hinter
elsesteht ein Doppelpunkt. Die Einrückung (4 Leerzeichen) legt fest, was zum Block gehört. - Bedingungen können mit
and,orundnotverknüpft werden – auf beiden Seiten mit vollständigem Vergleich. - Verzweigungen können verschachtelt werden.
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.
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.
Nach diesem Abschnitt kannst du
- Fehler in Programmen mit Verzweigungen finden, mit Hilfe der Fehlermeldung erklären und beheben,
- ein Programm mit Verzweigungen lesen und seine Ausgabe vorhersagen, ohne es auszuführen,
- zu einem Programm sinnvolle Testfälle auswählen, auch für die Grenzfälle,
- eine Mehrfachauswahl als
CASE OFbeschreiben und in Python mitmatch/caseumsetzen, - ein Programm mit einer Mehrfachauswahl und einer verschachtelten Verzweigung schreiben.
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
if/elif/else– nur der Block der ersten zutreffenden Bedingung wird ausgeführt.- Achte auf Doppelpunkt
:und korrekte Einrückung. ==vergleicht,=weist zu.
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:
- Jeder Zweig mindestens einmal. Für jeden Block der Verzweigung brauchst du eine Eingabe, bei der genau dieser Block ausgeführt wird.
- Die Grenzfälle. Das sind die Werte direkt an einer
Grenze. Bei der Bedingung
alter < 18sind 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
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")- Finde die drei Fehler, bevor du das Programm ausführst. Notiere jeweils die Zeile und was falsch ist.
- Schreibe die korrigierte Version auf.
- Teste dein korrigiertes Programm mit den Testfällen aus dem Abschnitt „Programme testen“.
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:
- Zeile 2:
=statt==. Mit einem Gleichheitszeichen wäre es eine Zuweisung, gemeint ist aber ein Vergleich. - Zeile 2: Am Ende der Zeile fehlt der Doppelpunkt.
- 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
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)- Notiere, was das Programm für
zahl = 17ausgibt. Begründe mit den Bedingungen. - Sage ebenso die Ausgabe für
zahl = 9,zahl = 10undzahl = 30voraus. - Erkläre, warum die Bedingung
zahl % 15 == 0zuerst 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
- Für
zahl = 17gibt das Programm17aus. 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 derelse-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 |
- 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 |
- Eine Zahl, die durch 15 teilbar ist, ist auch durch 3 und durch 5
teilbar, zum Beispiel 30. Stünde
zahl % 3 == 0an erster Stelle, wäre diese Bedingung für 30 schon wahr. Dann würdeFizzausgegeben und die übrigen Bedingungen würden gar nicht mehr geprüft.FizzBuzzkä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.
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“.
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
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.
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
- Zeile 2:
match note:legt fest, welcher Wert verglichen wird. Wie beiifsteht am Ende ein Doppelpunkt, und alles Weitere ist eingerückt. - Zeilen 3–14: Jedes
casenennt einen festen Wert, dahinter einen Doppelpunkt. Python geht die Fälle von oben nach unten durch. Beim ersten passenden Fall wird der eingerückte Block darunter ausgeführt, die übrigen Fälle werden übersprungen. Hier passtcase 2. - Zeilen 15–16:
case _ist der Auffangfall. Der Unterstrich_passt zu jedem Wert. Dieser Fall entspricht demelsebzw. demOTHERWISE. Er muss als letzter Fall stehen.
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
CASE OFeignet sich, wenn ein Ausdruck mit mehreren festen Werten verglichen wird. In Python heißt diese Verzweigungmatch/case.case _ist der Auffangfall und entspricht hierelse. Für Bereiche und frei formulierte Bedingungen istifmeist geeigneter.
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.
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.
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
Gehe in drei Schritten vor:
- Lies die erste Zahl, den Operator und die zweite Zahl ein. Der Operator ist ein Text und wird nicht umgewandelt.
- Unterscheide die Operatoren mit
match op:und je einemcase "+":,case "-":und so weiter.case _übernimmt die Rolle des Auffangfalls für alle unbekannten Operatoren. - Im Fall
"/"brauchst du zusätzlich eine verschachtelte Verzweigung mitif: 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
floatumgewandelt, 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 innereif-Verzweigung, obbungleich 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.
Im Freibad gelten diese Preise:
- Kinder unter 6 Jahren: Eintritt frei
- 6 bis 17 Jahre: 2,50 Euro
- ab 18 Jahren: 4,00 Euro, mit Schüler- oder Studierendenausweis 3,00 Euro
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.
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 _.
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.
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".
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.
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.")- Finde die drei Fehler. Notiere jeweils die Zeile und was falsch ist.
- Schreibe das Programm richtig auf und teste es mit
Mund mitXL.
Die Fehler:
Lösung vergleichen
- Zeile 2: Hinter
match groessefehlt der Doppelpunkt (SyntaxError: expected ':'). - Zeile 6: Die
print-Anweisung ist nicht eingerückt. Sie muss im Block voncase "M":stehen (IndentationError). - Zeile 9: In einer Mehrfachauswahl gibt es kein
else. Der Auffangfall heißtcase _:.
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.
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.
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.
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
- Bei
if/elif/elsewird nur der Block der ersten zutreffenden Bedingung ausgeführt. Deshalb kommt es auf die Reihenfolge an: der speziellste Fall zuerst. - Python meldet immer nur den ersten Fehler. Behebe Fehler einzeln, von oben nach unten, und starte das Programm danach jeweils neu.
- Ein Testfall besteht aus einer Eingabe und der erwarteten Ausgabe. Teste jeden Zweig mindestens einmal und alle Grenzfälle.
- Beim Code-Lesen hilft ein Ablaufprotokoll: Welche Bedingung ist wahr, welche Zeile wird als Nächstes ausgeführt?
- Wird ein Wert mit mehreren festen
Werten verglichen, eignet sich die Mehrfachauswahl
(
CASE OF). In Python:match wert:mitcase …:für jeden Fall undcase _:als Auffangfall. - Mit einer verschachtelten Verzweigung fängt man Sonderfälle ab, zum Beispiel die Division durch 0.
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.
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.
Nach diesem Abschnitt kannst du
- erklären, was eine Schleife ist und wann man eine for-Schleife verwendet,
- eine for-Schleife mit Schleifenkopf und eingerücktem Schleifenrumpf schreiben,
- mit
rangeZahlenfolgen erzeugen, auch mit eigenem Start und eigener Schrittweite, - mit einer Schleife eine Summe berechnen und dabei
+=verwenden, - den Ablauf einer Schleife in einem Ablaufprotokoll Schritt für Schritt verfolgen.
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!
- Zeile 1: Diese Zeile ist der
Schleifenkopf. Er sagt: „Mache das Folgende dreimal.“
Was
iundrange(3)genau bedeuten, lernst du gleich. Der Kopf endet mit einem Doppelpunkt. - Zeile 2: Diese Zeile ist eingerückt (4 Leerzeichen). Alles, was eingerückt unter dem Kopf steht, wird wiederholt. Diesen Teil nennt man den Schleifenrumpf.
Der Vorteil wird deutlich, wenn du statt 3 die Zahl
100 schreibst: Das Programm bleibt zwei Zeilen lang, gibt
aber 100-mal „Hallo!“ aus.
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.
Eine for-Schleife (auch Zählschleife) ist eine Schleife, bei der die Anzahl der Durchläufe schon vor dem Start der Schleife feststeht.
- Eine Schleife wiederholt einen Anweisungsblock mehrfach.
- Die for-Schleife wird verwendet, wenn die Anzahl der Wiederholungen vorher bekannt ist (z. B. „10-mal“, „für jede Zahl von 1 bis 100“).
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
- Zeile 1:
range(1, 4)liefert der Reihe nach die Zahlen1,2und3. Die Zählvariableibekommt im ersten Durchlauf den Wert1, im zweiten den Wert2, im dritten den Wert3. - Zeile 2: Der Schleifenrumpf. Er gibt in jedem
Durchlauf „Runde“ und den aktuellen Wert von
iaus. - Zeile 3: Diese Zeile ist nicht eingerückt. Sie gehört also nicht mehr zur Schleife. Sie wird erst ausgeführt, wenn die Schleife ganz fertig ist – und zwar nur einmal.
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:
- Python springt nach dem Rumpf (Zeile 2) immer wieder zurück
zum Kopf (Zeile 1). Dort bekommt
iden nächsten Wert. - Im Schritt 7 ist Python noch einmal im Kopf. Jetzt liefert
range(1, 4)aber keine Zahl mehr. Die Schleife ist zu Ende,ibehält den letzten Wert3, und es geht mit Zeile 3 weiter. - Die Zeile 1 wird viermal ausgeführt, der Rumpf dreimal.
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.
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 ':'
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:
range(stop)beginnt bei0und endet vorstop.range(5)liefert0, 1, 2, 3, 4– genau 5 Zahlen. Diese Form nimmst du, wenn es nur auf die Anzahl der Durchläufe ankommt.range(start, stop)beginnt beistartund endet wieder vorstop. Die Zahlstopselbst ist nie dabei.range(start, stop, schritt)zählt mit der Schrittweiteschrittweiter. Mit einer negativen Schrittweite zählt man rückwärts.
| 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 |
range(n)erzeugt die Zahlen0, 1, ..., n-1.range(start, stop)erzeugt die Zahlen vonstartbisstop-1.range(start, stop, schritt)erlaubt eine eigene Schrittweite.
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
- Zeilen 1–2: Die erste Schleife gibt die Zahlen von
1 bis 5 aus. Für „1 bis 5“ braucht man
range(1, 6), weil der Stoppwert nicht dazugehört. - Zeile 4: Ein Trennstrich. Er steht nicht eingerückt, gehört also zu keiner Schleife und wird einmal ausgegeben.
- Zeilen 6–7: Die zweite Schleife läuft mit
ivon 1 bis 10. In jedem Durchlauf wird eine Zeile des Siebener-Einmaleins ausgegeben."7 *"und"="sind Texte,iund7 * isind Zahlen. Der Wert7 * iwird in jedem Durchlauf neu ausgerechnet. - Beide Schleifen benutzen den Namen
i. Das ist erlaubt: Die zweite Schleife gibtieinfach wieder neue Werte.
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.
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).
- Gib an, welche Zahlen die folgenden
range-Aufrufe erzeugen. - 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.
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
- Zeile 1: Die Summenvariable bekommt den Startwert
0– die Kasse ist leer. - Zeile 2:
iläuft von 1 bis 5. - Zeile 3: Der aktuelle Wert von
iwird zur bisherigen Summe addiert. Das Ergebnis wird wieder insummegespeichert. Diese Zeile kennst du schon ausalter = alter + 1: Erst wird rechts gerechnet, dann links gespeichert. - Zeile 4: Nicht eingerückt – die Summe wird einmal ausgegeben, wenn die Schleife fertig ist.
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.
Eine Summe berechnet man mit einer Summenvariablen in drei Schritten:
- vor der Schleife:
summe = 0 - in der Schleife:
summe = summe + zahl - 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.
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.
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
- Zeile 1: Die Obergrenze wird eingelesen und in eine ganze Zahl umgewandelt.
- Zeile 3: Damit
nselbst noch mitgezählt wird, muss der Stoppwertn + 1sein. - Zeilen 4–5: wie im Beispiel oben, mit der
Kurzschreibweise
+=.
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.
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.
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.
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 beschreibst du eine for-Schleife in Fachsprache – vom einfachen zum genauen Satz:
- „Das wird fünfmal gemacht.“ → „Die Anweisungen im Schleifenrumpf werden fünfmal wiederholt.“
- „i wird immer eins mehr.“ → „Der Wert der Zählvariablen
iwird bei jedem Durchlauf um 1 erhöht.“ - „Da kommt 15 raus.“ → „Die Schleife addiert die Zahlen von 1 bis 5 zur Summenvariablen. Nach der Schleife gibt das Programm den Wert 15 aus.“
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.
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.
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.
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.
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.
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)- Führe das Programm aus und beschreibe, was falsch ist.
- 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.
- Zeile 1: Der Stoppwert
19gehört nicht dazu. Die Schleife endet bei 17. Richtig istrange(1, 20, 2)(oder21). - Zeile 2:
summe = 0steht in der Schleife. Dann wird die Summe in jedem Durchlauf wieder auf 0 gesetzt. Der Startwert gehört vor die Schleife. - Zeile 4:
printist 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.
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.
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.
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.
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 genauanzahlDurchläufe. Die Zählvariableiwird im Rumpf nicht gebraucht. - Zeilen 4–5: In jedem Durchlauf wird eine Note eingelesen und zur Summe addiert.
- Zeilen 7–10: Bei
anzahl = 0läuft die Schleife gar nicht, undsumme / anzahlwürde durch 0 teilen. Ohne die Verzweigung bricht das Programm mit einemZeroDivisionErrorab.
Eine for-Schleife passt hier, weil die Anzahl der Noten schon vor der Schleife feststeht.
1.5.7Das Wichtigste in Kürze
- Eine Schleife wiederholt einen Anweisungsblock (den Schleifenrumpf) mehrfach.
- Die for-Schleife nimmt man, wenn die Anzahl der Wiederholungen vorher feststeht.
- Aufbau:
for i in range(...):– Kopf mit Doppelpunkt, darunter der eingerückte Rumpf. Was nicht eingerückt ist, kommt nach der Schleife. - Die Zählvariable bekommt bei jedem Durchlauf
automatisch den nächsten Wert aus
range. range(n)liefert0bisn-1,range(start, stop)liefertstartbisstop-1,range(start, stop, schritt)zählt mit eigener Schrittweite. Der Stoppwert gehört nie dazu.- Summen: Summenvariable vor der Schleife auf 0
setzen, in der Schleife erhöhen, nach
der Schleife ausgeben.
summe += iist die Kurzform vonsumme = summe + i.
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.
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.
Nach diesem Abschnitt kannst du
- eine while-Schleife mit Bedingung und eingerücktem Schleifenrumpf schreiben,
- den Ablauf einer while-Schleife in einem Ablaufprotokoll und einem Programmablaufplan darstellen,
- eine Endlosschleife erkennen, abbrechen und ihre Ursache beheben,
- Eingaben so lange wiederholen lassen, bis sie gültig sind,
- Zufallszahlen mit
random.randinterzeugen, - begründet entscheiden, ob eine for- oder eine while-Schleife besser passt.
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
- Zeile 1: Die Variable
ibekommt den Startwert1. Das musst du bei while selbst erledigen. - Zeile 2: Der Schleifenkopf:
while, dann die Bedingung, dann ein Doppelpunkt. Vor jedem Durchlauf prüft Python, obi <= 3wahr ist. Nur dann wird der Rumpf ausgeführt. - Zeilen 3–4: Der eingerückte Schleifenrumpf. Er gibt
iaus und erhöhtidanach um 1. Diese Erhöhung ist wichtig: Ohne sie bliebeiimmer1, und die Bedingung wäre immer wahr. - Zeile 5: Nicht eingerückt – wird ausgeführt, sobald die Bedingung falsch ist.
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.
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.
- Die while-Schleife wird verwendet, wenn die Anzahl der Wiederholungen vorher nicht bekannt ist – sie läuft, solange eine Bedingung wahr ist.
- Syntax:
while Bedingung:gefolgt vom eingerückten Anweisungsblock.
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“.
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
- Zeile 1: Die Summenvariable startet bei 0 – genau wie bei der for-Schleife.
- Zeile 2: Die erste Zahl wird schon
vor der Schleife eingelesen. Sonst könnte Python die
Bedingung in Zeile 4 gar nicht prüfen, denn
zahlhätte noch keinen Wert. - Zeile 4: Solange die eingegebene Zahl nicht 0 ist, wird der Rumpf ausgeführt.
- Zeile 5: Die Zahl wird zur Summe addiert.
- Zeile 6: Die nächste Zahl wird eingelesen. Danach springt Python zurück zu Zeile 4 und prüft die neue Zahl. Diese Zeile sorgt dafür, dass sich die Bedingung ändern kann.
- Zeile 8: Nach der Schleife wird die Summe ausgegeben.
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).
Das Muster aus diesem Beispiel brauchst du immer wieder, wenn eine Schleife von Eingaben abhängt:
- vor der Schleife die erste Eingabe einlesen,
- im Kopf die Eingabe prüfen,
- am Ende des Rumpfs die nächste Eingabe einlesen.
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.
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.
Die Bedingung muss sich innerhalb der Schleife verändern können, sonst entsteht eine Endlosschleife.
So findest du die Ursache einer Endlosschleife:
- Welche Variablen stehen in der Bedingung?
- Wird mindestens eine davon im Rumpf verändert?
Typische vergessene Zeilen sind
i = i + 1oder ein neuesinput(...)am Ende des Rumpfs. - Wird sie in die richtige Richtung verändert, sodass die Bedingung irgendwann falsch wird?
- 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
- Zeile 1: Die erste Eingabe wird vor der Schleife eingelesen.
- Zeile 2: Die Bedingung beschreibt eine ungültige Eingabe: kleiner als 1 oder größer als 6. Solange das zutrifft, wird wiederholt.
- Zeilen 3–4: Hinweis ausgeben und neu fragen. Die neue Eingabe überschreibt die alte.
- Zeile 5: Hier kommt das Programm nur an, wenn die Note gültig ist.
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.
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
- Zeile 1: Das Modul
randomwird geladen. - Zeilen 3–5: Der erste Wurf wird vor der Schleife ausgeführt, gezählt und ausgegeben.
- Zeile 6: Solange keine Sechs gewürfelt wurde, geht es weiter.
- Zeilen 7–9: Neu würfeln, den Zähler um 1 erhöhen, den Wurf ausgeben. Durch das neue Würfeln kann sich die Bedingung ändern.
- Zeile 10: Nach der Schleife steht fest: Der letzte Wurf war eine Sechs.
So beschreibst du eine while-Schleife in Fachsprache – vom einfachen zum genauen Satz:
- „Das läuft, bis man 0 eingibt.“ → „Die Anweisungen im Schleifenrumpf werden wiederholt, solange die eingegebene Zahl ungleich 0 ist.“
- „Dann hört es auf.“ → „Sobald die Bedingung
zahl != 0falsch ist, terminiert die Schleife, und das Programm gibt die Summe aus.“ - „Das hängt sich auf.“ → „Die Schleife terminiert nicht,
weil der Wert der Variablen
iim Schleifenrumpf nicht erhöht wird.“
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 + 11
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 |
Faustregel: Ist die Anzahl der Durchläufe vorher bekannt →
for. Hängt das Ende von einer Bedingung oder Eingabe ab →
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
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.
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!“.
Erweitere dein Programm aus dem Auftrag Zahl erraten:
- Die geheime Zahl soll mit
random.randintzufällig zwischen 1 und 100 gewählt werden. - 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.
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.
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.
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 + 10
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.
Lies das Programm, ohne es auszuführen.
- Schreibe auf, was es ausgibt.
- Gib an, wie oft der Schleifenrumpf ausgeführt wird und welchen Wert
zahlam 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.
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!.
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).
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 + 1i = 10
while i > 0:
i = i + 1i = 1
while i != 10:
i = i + 2i = 0
while i < 3:
print(i)
i = i + 1Meine Entscheidungen und Begründungen:
Lösung vergleichen
- Endet.
iwird größer und erreicht nach vier Durchläufen den Wert 5. Dann ist5 < 5falsch.
- Endet.
- Endlosschleife.
iwird größer statt kleiner. Damit bleibti > 0immer wahr.
- Endlosschleife.
- Endlosschleife.
inimmt die Werte 1, 3, 5, 7, 9, 11, … an. Die 10 wird übersprungen, deshalb isti != 10immer wahr. Mit der Bedingungi < 10würde die Schleife enden.
- Endlosschleife.
- Endlosschleife.
i = i + 1ist nicht eingerückt und gehört nicht zum Rumpf. Im Rumpf steht nurprint(i), und es wird endlos0ausgegeben.
- Endlosschleife.
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“.
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.")- Finde die drei Fehler. Notiere jeweils die Zeile und was falsch ist.
- Schreibe das Programm richtig auf. Teste es mit den Eingaben
Hund,Katze,Maus,stoppund auch mit sofortstopp.
Die Fehler:
Lösung vergleichen
- Zeile 3: Die Bedingung ist umgekehrt. Die Schleife
soll laufen, solange das Wort nicht
stoppist:wort != "stopp". - Zeile 5: Die nächste Eingabe ist nicht eingerückt
und gehört nicht zum Rumpf. Dann ändert sich
wortin der Schleife nie, und es entsteht eine Endlosschleife. - Zeile 6: Zwischen
anzahlund 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.
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.
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.
- 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.
- 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.
- 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.
Mit einer Startzahl wird immer wieder so gerechnet:
- Ist die Zahl gerade, wird sie halbiert.
- Ist sie ungerade, wird sie mit 3 multipliziert und dann 1 addiert.
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.
- Schreibe ein Programm, das eine Startzahl einliest, jede neue Zahl ausgibt und am Ende die Anzahl der Schritte. Teste mit 6 und mit 7.
- 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 == 0prü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.
- Bei
0entsteht eine Endlosschleife. 0 ist gerade, und0 // 2ergibt wieder0. Die Zahl wird also nie 1, und das Programm gibt endlos0aus. Abhilfe: Vorher mit einer while-Schleife prüfen, dass die Startzahl mindestens 1 ist.
1.6.9Das Wichtigste in Kürze
- Die while-Schleife wiederholt ihren Rumpf, solange die Bedingung wahr ist. Die Bedingung wird vor jedem Durchlauf geprüft.
- Aufbau:
while Bedingung:– darunter der eingerückte Rumpf. - Startwert und Veränderung der Variablen in der Bedingung musst du
selbst programmieren. Ändert sich die Bedingung nie, entsteht eine
Endlosschleife. Abbrechen mit der Stopp-Schaltfläche
oder
Strg+C. - Bei Eingaben gilt das Muster: erste Eingabe vor der Schleife, nächste Eingabe am Ende des Rumpfs.
import randomundrandom.randint(a, b)liefern eine zufällige ganze Zahl vonabis einschließlichb.- Steht die Anzahl der Durchläufe vorher fest →
for. Hängt das Ende von einer Bedingung oder Eingabe ab →while.
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.
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.
Nach diesem Abschnitt kannst du
- für eine Aufgabe begründet zwischen for- und while-Schleife wählen,
- ein Programm mit Schleife lesen und seine Ausgabe vorhersagen,
- Summen und Produkte mit einer Schleife berechnen,
- Eingaben mit einer while-Schleife wiederholen lassen,
- deine Programme mit sinnvoll gewählten Testfällen überprüfen.
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 * 2Durchlauf 1
Durchlauf 2
Durchlauf 3
zahl ist 1
zahl ist 2
zahl ist 4
zahl ist 8
- for-Schleife: Die Anzahl der Durchläufe steht vorher fest.
- while-Schleife: Das Ende hängt von einer Bedingung ab, die Anzahl ist vorher unbekannt.
Bei jeder Aufgabe unten gilt: Überlege zuerst, welche Schleifenart passt, bevor du programmierst!
Zwei Muster brauchst du immer wieder:
- Zusammenzählen: Summenvariable vor
der Schleife auf
0setzen, in der Schleife erhöhen (summe = summe + zahlodersumme += zahl), nach der Schleife ausgeben. - Eingaben wiederholen: erste Eingabe vor der while-Schleife, Bedingung prüft die Eingabe, nächste Eingabe am Ende des Rumpfs.
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
Lies das Programm, ohne es auszuführen.
- Gib an, was das Programm ausgibt.
- Gib an, wie oft der Schleifenrumpf ausgeführt wird.
- 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 (gesprochen „n Fakultät“) für das Produkt aller ganzen Zahlen von 1 bis . Zum Beispiel ist und . Für legt man den Wert 1 fest. Die Fakultät gibt zum Beispiel an, auf wie viele Arten man Personen in einer Reihe aufstellen kann.
Berechne die Fakultät einer eingegebenen Zahl (). Welche Schleifenart passt hier besser? Begründe deine Wahl, bevor du programmierst.
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
eingegeben ist, steht fest, dass genau
Zahlen multipliziert werden müssen. Die Zählvariable i
liefert dabei gleich die Faktoren 1, 2, …,
.
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:
iläuft von 1 bis einschließlich , deshalbn + 1als 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.
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.
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.
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.
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 > 1ist ein Vergleich und ergibtTrueoderFalse. Für Zahlen größer als 1 startetist_primzahlalso mitTrue(Annahme: Primzahl), für 1 und 0 gleich mitFalse. - Zeile 3: Eine for-Schleife passt, denn die Teiler
von 2 bis
zahl - 1stehen fest.range(2, zahl)endet genau vorzahl. - Zeilen 4–5: Geht die Division ohne Rest auf, ist
ein Teiler gefunden, und die Annahme wird widerlegt. Einmal
FalsebleibtFalse. - Zeile 6: Das Ergebnis wird ausgegeben. 91 ist keine Primzahl, denn .
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.
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.
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.
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 + 55
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.
Lies das Programm, ohne es auszuführen.
- Gib an, was das Programm ausgibt.
- Gib an, wie oft die Zeile
summe = summe + zahlausgefü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 |
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:
.
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
.
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)- Finde die drei Fehler. Notiere jeweils die Zeile und was falsch ist.
- Schreibe das Programm richtig auf.
Die Fehler:
Lösung vergleichen
- Zeile 2:
=statt==im Vergleich (SyntaxError). - Vor Zeile 1: Die Zählvariable
anzahlbekommt nie einen Startwert. In Zeile 3 meldet Python deshalb einenNameError. Vor die Schleife gehörtanzahl = 0. - 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.
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.
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.
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
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
besteunverändert. Nach der Schleife steht inbestedie 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
- Vor dem Programmieren entscheiden: Steht die Anzahl der Durchläufe
beim Start fest →
for. Hängt das Ende von einer Bedingung oder Eingabe ab →while. - Summen starten bei 0, Produkte bei 1. Der Startwert gehört vor die Schleife.
- Bei while-Schleifen muss sich die Bedingung im Rumpf ändern können, sonst terminiert die Schleife nicht.
- Teste Programme mit Grenzfällen, besonders mit Eingaben, bei denen die Schleife gar nicht oder nur einmal läuft.
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.
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
macht aus 4 die 16 und aus 7 die 49.
Nach diesem Abschnitt kannst du
- eine Funktion mit
defdefinieren und sie aufrufen, - Funktionen mit Parametern schreiben und ihnen beim Aufruf Argumente übergeben,
- mit
returneinen Rückgabewert zurückgeben und damit weiterrechnen, - erklären, warum
printin einer Funktion etwas anderes ist alsreturn, - beschreiben, was bei einem Funktionsaufruf Schritt für Schritt passiert,
- eine Funktion mit mehreren Aufrufen testen.
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
--------------------
- Zeile 1: Das Wort
def(von englisch define, „festlegen“) beginnt eine Funktionsdefinition. Danach folgt der Name der Funktion, hiertrennlinie, dann runde Klammern und ein Doppelpunkt. Die Klammern sind leer, weil diese Funktion keine Werte braucht. - Zeile 2: Diese Zeile ist um 4 Leerzeichen
eingerückt. Alle eingerückten Zeilen unter
defbilden den Funktionsrumpf. Das kennst du vonifundfor: Was eingerückt ist, gehört dazu. - Zeile 3: Die leere Zeile ist nicht nötig, macht das Programm aber übersichtlicher. Die Funktion endet, wo die Einrückung endet.
- Zeile 4: Hier beginnt das eigentliche Programm, das
Hauptprogramm. Wichtig: Beim Lesen der Zeilen 1 und 2
hat Python noch nichts ausgegeben. Es hat sich nur
gemerkt, was
trennliniebedeuten soll. - Zeile 5:
trennlinie()ist ein Funktionsaufruf. Jetzt führt Python den Funktionsrumpf aus und gibt die Linie aus. - Zeilen 6–7: Noch eine Ausgabe und noch ein Aufruf. Die Linie erscheint ein zweites Mal, obwohl sie nur einmal im Programm steht.
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.
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.
- Eine Funktion fasst eine Folge von Anweisungen unter einem Namen zusammen und macht sie wiederverwendbar.
- Definition:
def funktionsname(parameter1, parameter2):gefolgt vom eingerückten Funktionsrumpf.
Was parameter1 und parameter2 in den
Klammern bedeuten, lernst du gleich im Abschnitt über Parameter. Bei
trennlinie() bleiben die Klammern leer.
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 ':'.
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!
- Zeile 1: In den Klammern steht jetzt
name. Das ist ein Parameter: eine Variable der Funktion, die ihren Wert erst beim Aufruf bekommt. Er ist wie ein Platzhalter, eine noch leere Schachtel. - Zeile 2: Im Funktionsrumpf benutzt du
namewie jede andere Variable. - Zeile 4: Beim Aufruf steht in den Klammern der Wert
"Alex". Diesen Wert nennt man Argument. Python legt ihn in den Parameter, als stünde dortname = "Alex", und führt dann den Rumpf aus. - Zeile 5: Beim zweiten Aufruf bekommt
nameden Wert"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.
Ein Parameter ist eine Variable in der Funktionsdefinition, die beim Aufruf einen Wert bekommt. Der Wert, der beim Aufruf übergeben wird, heißt Argument.
Parameter sind die „Eingabewerte“ einer Funktion – beim Aufruf werden ihnen konkrete Argumente übergeben, und zwar in derselben Reihenfolge.
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“.
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
- Zeile 1: Die Funktion
quadrathat einen Parameterzahl. - Zeile 2: Im Rumpf wird
zahl * zahlausgerechnet und inergebnisgespeichert. - Zeile 3:
return ergebnisgibt den Wert vonergebnisan die Stelle zurück, an der die Funktion aufgerufen wurde. Diesen Wert nennt man Rückgabewert. - Zeile 5: Lies die Zeile von innen nach außen.
Zuerst wird
quadrat(4)ausgeführt und liefert16. Der Aufruf wird dann durch diesen Wert ersetzt – es steht also gewissermaßenprint(16)da. - Zeile 6: Genauso:
quadrat(7)liefert49, das ausgegeben wird. - Zeile 8: Diesmal wird der Rückgabewert
100in der Variablenxgespeichert. - Zeile 9:
xwird ausgegeben.
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.
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!
- Mit
return wertgibt eine Funktion einen Rückgabewert an die aufrufende Stelle zurück und beendet die Funktion. - Der Funktionsaufruf (z. B.
ergebnis = quadrat(4)) ist zu unterscheiden von der Funktionsdefinition (def quadrat(zahl):mit Rumpf).
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.
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
- Zeile 1: Python liest die Definition und merkt sich die Funktion. Die Zeilen 2 und 3 werden jetzt nicht ausgeführt.
- Zeile 5: Aufruf
quadrat(10). Python springt in die Funktion, der Parameterzahlbekommt den Wert10. Zeile 2 rechnetergebnis = 100, Zeile 3 gibt100zurück. Zurück in Zeile 5 bekommtxden Wert100. - Zeile 6: Aufruf
quadrat(3). Wieder geht es in die Funktion, diesmal mitzahl = 3. Der Rückgabewert ist9. Zurück in Zeile 6 wird9 + 1 = 10gerechnet und inygespeichert. - Zeile 7: Ausgabe von
xundy.
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.
1.8.5print oder
return?
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
- Zeile 7:
quadrat_mit_print(4)gibt sofort16auf dem Bildschirm aus – das ist die erste Ausgabezeile. Die Funktion hat aber keinreturn. Deshalb gibt sie dem Hauptprogramm nichts zurück, undabekommt den besonderen WertNone(englisch für „nichts“). - Zeile 8:
quadrat_mit_return(4)gibt nichts aus. Sie liefert aber16zurück, und dieser Wert landet inb. - Zeilen 9–10: Jetzt sieht man den Unterschied: In
astehtNone, inbsteht16.
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 |
- Eine Funktion ohne
returnliefertNonezurück. printin einer Funktion zeigt einen Wert nur an. Soll das Programm mit dem Ergebnis weiterarbeiten, muss die Funktion es mitreturnzurückgeben.
Faustregel: Eine Funktion, die etwas berechnet, gibt
ihr Ergebnis mit return zurück. Das
Ausgeben mit print erledigt das
Hauptprogramm.
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.")- Gib an, was das Programm ausgibt.
- Erkläre, warum die Ausgabe nicht stimmt.
- Verbessere die Funktion.
Ausgabe und Erklärung:
Lösung vergleichen
- Die Ausgabe ist:
300
Das sind None Sekunden.
- Die Funktion gibt
300nur mitprintaus, gibt aber nichts zurück. Deshalb bekommtdauerden WertNone. - Statt
printmussreturnstehen:
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:
- Vorher von Hand ausrechnen, was herauskommen muss (erwartetes Ergebnis).
- Die Funktion mit diesen Werten aufrufen und das tatsächliche Ergebnis ausgeben.
- 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 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.
- „Zur Eingabe 4 bekomme ich die 17.“ → „Wenn ich der
Funktion die Zahl 4 gebe, liefert sie mir die 17 als Ergebnis.“ →
„Wenn die Funktion
fmit dem Wert 4 für den Parameterxaufgerufen wird, berechnet sie das Ergebnis 17 und gibt es zurück.“ - „Eine Funktion liefert je nach Parameter ein spezifisches Ergebnis, zum Beispiel 17 für die Eingabe 4.“
- „Der Funktion wird der Wert 4 übergeben. Die Funktion berechnet und gibt 17 zurück.“
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.
In den USA misst man Temperaturen in Grad Fahrenheit (°F). Die Umrechnung lautet: °F = °C · 9/5 + 32.
- Implementiere eine Funktion
celsius_zu_fahrenheit(grad_celsius), die eine Temperatur in Grad Celsius entgegennimmt und den Wert in Fahrenheit zurückgibt. - 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.
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ß.
- Implementiere eine Funktion
ist_gerade(zahl), dieTruezurückgibt, wenn die Zahl gerade ist, und sonstFalse. Der Rückgabewert ist also vom Typbool. - 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.
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:
- den Namen der Funktion,
- die Parameter,
- die Argumente beim Aufruf,
- die Zeile, in der die Funktion aufgerufen wird,
- den Rückgabewert für diesen Aufruf.
Meine Antworten:
Lösung vergleichen
- Die Funktion heißt
preis_mit_pfand. - Die Parameter sind
preisundflaschen(sie stehen in der Definition in Zeile 1). - Die Argumente sind
3.5und6(sie stehen beim Aufruf in Zeile 4). - Der Aufruf steht in Zeile 4. Zeile 1 ist die Definition, kein Aufruf.
- Der Rückgabewert ist :
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.
Gegeben ist die Funktion rechne:
def rechne(x):
return 3 * x - 1Bestimme 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.
Im Freibad kostet der Eintritt 4 Euro. Für jede Stunde, die man bleibt, kommen 2 Euro dazu.
- Implementiere eine Funktion
eintritt(stunden), die den Preis in Euro zurückgibt. - 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.
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
- Nach
def flaeche_dreieck(g, h)fehlt der Doppelpunkt (SyntaxError: expected ':'). - Die Zeile mit
returnist nicht eingerückt. Sie gehört aber zum Funktionsrumpf (IndentationError). - 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.
Die Funktion soll den Mittelwert von zwei Zahlen zurückgeben. Sie läuft ohne Fehlermeldung.
def mittelwert(a, b):
return a + b / 2- Rechne von Hand aus, was für
mittelwert(4, 6)herauskommen muss. - Teste die Funktion mit
mittelwert(4, 6)und mitmittelwert(0, 0). Notiere die Ergebnisse. - Erkläre den Fehler und verbessere die Funktion.
- Erkläre, warum der Test mit
0und0allein den Fehler nicht gefunden hätte.
Meine Antworten:
Lösung vergleichen
- Der Mittelwert von 4 und 6 ist .
- 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
- Wegen „Punkt vor Strich“ rechnet Python zuerst
b / 2und addiert danna: . 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
- Bei
0und0liefern beide Rechnungen zufällig dasselbe Ergebnis. Ein einzelner Test kann also „Glück haben“. Deshalb testet man immer mit mehreren, verschiedenen Werten.
Ein Kino verlangt je nach Alter einen anderen Preis:
- unter 6 Jahren: 0 Euro (frei),
- von 6 bis unter 18 Jahren: 6 Euro,
- ab 18 Jahren: 9 Euro.
- Implementiere eine Funktion
kinopreis(alter), die den Preis zurückgibt. Verwende eine mehrseitige Verzweigung. - 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.
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
.
Die Zeilen 1 und 2 werden beim ersten Lesen nicht ausgeführt, Python
merkt sich dort nur die Funktion.
Im Auftrag Quersumme (Abschnitt über die while-Schleife)
hast du die Quersumme einer Zahl berechnet (Quersumme von 384 ist
).
Zur Erinnerung: zahl % 10 liefert die letzte Ziffer,
zahl // 10 entfernt sie.
- Implementiere eine Funktion
quersumme(zahl), die die Quersumme zurückgibt. Teste sie mit 384 (erwartet: 15), 7 (erwartet: 7) und 1000 (erwartet: 1). - Benutze die Funktion in einer
for-Schleife: Gib alle Zahlen von 1 bis 100 aus, deren Quersumme genau 10 ist.
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
zahlwie das Programm aus dem Abschnitt über die while-Schleife. Statt die Quersumme auszugeben, gibt sie sie mitreturnzurück. Wichtig:returnsteht nach der Schleife, also nicht eingerückt unterwhile. - 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
- Eine Funktion fasst Anweisungen unter einem Namen
zusammen. Ihre Definition beginnt mit
def, der Rumpf ist eingerückt. Die Definition legt nur fest, was die Funktion tut. Ausgeführt wird sie erst beim Aufruf. - Parameter sind die Eingabewerte der Funktion. Beim Aufruf bekommen sie der Reihe nach die Argumente.
return wertgibt einen Rückgabewert zurück und beendet die Funktion. Der Aufruf steht danach für diesen Wert.- Ohne
returnliefert eine FunktionNone.printin der Funktion zeigt nur an – weiterrechnen kann man damit nicht. - Beim Aufruf springt Python in die Funktion und mit dem Rückgabewert zurück. Variablen in der Funktion sind lokal.
- Funktionen testet man mit mehreren Aufrufen, deren Ergebnis man vorher kennt – auch mit Sonderfällen.
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.
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.
Nach diesem Abschnitt kannst du
- gegebene Funktionen lesen und ihr Verhalten vorhersagen und erklären,
- einen Fehler in einer Funktion durch geschicktes Testen finden und beheben,
- Funktionen schreiben, die andere Funktionen aufrufen,
- eine vorhandene Funktion zu einer neuen Funktion erweitern,
- mit
math.pidie Kreiszahl verwenden.
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
def quadrat(zahl):definiert die Funktionquadratmit dem Parameterzahl. Der eingerückte Rumpf wird erst beim Aufruf ausgeführt.return zahl * zahlgibt das Ergebnis als Rückgabewert zurück und beendet die Funktion.quadrat(3)undquadrat(10)sind zwei Aufrufe derselben Funktion mit verschiedenen Argumenten.
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
- Zeilen 1–2: die bekannte Funktion
quadrat. - Zeilen 4–5: Die Funktion
summe_der_quadraterechnet selbst nichts mit*. Sie ruft zweimalquadratauf und addiert die beiden Rückgabewerte. - Zeile 7: Der Aufruf
summe_der_quadrate(3, 4)springt in die Funktion mita = 3undb = 4. Dort springtquadrat(a)in die Funktionquadratund kommt mit9zurück. Dann liefertquadrat(b)die16. Zum Schluss gibtsumme_der_quadrateden Wert9 + 16 = 25zurück.
Der Vorteil: Jede Funktion erledigt eine kleine, klar umrissene
Aufgabe. Ist quadrat einmal getestet, kann man sich darauf
verlassen, wo immer man sie benutzt.
def name(parameter):definiert eine Funktion,return wertgibt einen Wert zurück.- Eine Funktion kann mehrfach mit unterschiedlichen Argumenten aufgerufen werden.
- Funktionen können andere Funktionen aufrufen (z. B. eine Hauptfunktion nutzt Hilfsfunktionen).
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.
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.
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))- Beschreibe in eigenen Worten, was die Funktion
verarbeitemacht. - Gib an, was
print(verarbeite(5, 3))ausgibt – und wasprint(verarbeite(6, 3))ausgibt.
Führe den Code danach aus und überprüfe deine Vermutung.
Meine Erklärung und Vorhersage:
Lösung vergleichen
ist_teilbar(a, b)prüft, obadurchbteilbar ist, und gibtTrueoderFalsezurück.verarbeite(x, y)benutzt diese Hilfsfunktion: Istxdurchyteilbar, gibt sie den Quotientenx // yzurück, sonst das Produktx * y.- 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 .
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
Die folgende Funktion soll den Umfang eines Kreises berechnen (Formel: ). 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 . Die Funktion rechnet nur . 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.
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- Rechne von Hand aus, was für die Einkaufswerte 20, 50 und 100 Euro herauskommen muss.
- Teste die Funktion mit diesen drei Werten. Welcher Test schlägt fehl?
- Erkläre den Fehler und verbessere die Funktion.
Erwartete Werte, Testergebnis und Verbesserung:
Lösung vergleichen
- 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.
- 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
- Die Bedingung
preis > 50ist für genau 50 falsch. „Ab 50“ bedeutet aber „50 oder mehr“. Richtig istpreis >= 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
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.
Schreibe drei Funktionen:
flaeche_rechteck(a, b)– gibt die Fläche eines Rechtecks mit den Seitenlängenaundbzurück,umfang_rechteck(a, b)– gibt den Umfang dieses Rechtecks zurück,beschreibe_rechteck(a, b)– nutzt die beiden Funktionen oben und liefert einen zusammenfassenden Satz, den das Hauptprogramm ausgibt, z. B. für die Seiten 4 und 5:„Ein Rechteck mit den Seiten 4 und 5 hat die Fläche 20 und den Umfang 18.“
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_rechteckrechnet nichts selbst, sondern ruft die beiden Hilfsfunktionen auf und speichert ihre Rückgabewerte in den lokalen Variablenflaecheundumfang.- Der Satz wird mit
+verkettet; alle Zahlen werden vorher mitstr(...)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: und .
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.
Im Abschnitt über Funktionen hast du maximum(a, b)
geschrieben:
def maximum(a, b):
if a > b:
return a
else:
return bErweitere 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.
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)liefert4, unddoppelt(4)liefert8.doppelt(3)liefert6, undplus_eins(6)liefert7. Die Reihenfolge der Funktionen macht also einen Unterschied.plus_eins(0)liefert1,doppelt(1)liefert2, unddoppelt(2)liefert4.
Die Fläche eines Kreises berechnet man mit der Formel .
- Implementiere eine Funktion
kreisflaeche(radius), die die Fläche zurückgibt. Verwendemath.pi. - Teste die Funktion mit den Radien 1, 0 und 2. Zur Kontrolle: Für den Radius 1 muss genau 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
.
Statt radius * radius darfst du auch
radius ** 2 schreiben.
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 <= 19Nenne 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.
Im Abschnitt über Funktionen hast du ist_gerade(zahl)
geschrieben:
def ist_gerade(zahl):
return zahl % 2 == 0Implementiere 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.
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))- Beschreibe, wie du durch einen einzelnen Test der Hilfsfunktion herausfindest, in welcher der beiden Funktionen der Fehler steckt.
- Behebe den Fehler und teste erneut.
Mein Vorgehen und der Fehler:
Lösung vergleichen
- Man testet
stunden_zu_minutenallein, zum Beispiel mitprint(stunden_zu_minuten(1)). Erwartet sind 60 Minuten, die Funktion liefert aber 100. Der Fehler steckt also in der Hilfsfunktion.fahrzeit_minutenselbst rechnet richtig: Sie addiert die Minuten zum Rückgabewert der Hilfsfunktion. - 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.
Ein Online-Shop berechnet 5 Euro Versandkosten. Ab einem Warenwert von 30 Euro ist der Versand kostenlos.
- Implementiere eine Funktion
versandkosten(warenwert), die die Versandkosten zurückgibt (0 oder 5). - Implementiere eine Funktion
endpreis(warenwert), die den Warenwert plus Versandkosten zurückgibt. Sie sollversandkostenaufrufen. - Teste
endpreismit 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.
Was ist mehr Pizza: eine große Pizza mit 32 cm Durchmesser oder zwei kleine mit je 22 cm Durchmesser?
- Implementiere eine Funktion
pizza_flaeche(durchmesser), die die Fläche einer runden Pizza zurückgibt. Sie soll die Funktionkreisflaeche(radius)aus dem Auftrag Kreisfläche aufrufen. Denk daran: Der Radius ist der halbe Durchmesser. - 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
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ß.
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.
- Implementiere eine Funktion
ist_teiler(t, zahl), dieTruezurückgibt, wenntein Teiler vonzahlist (die Division geht ohne Rest auf). - Implementiere eine Funktion
ist_primzahl(zahl), dieTrueoderFalsezurückgibt. Sie sollist_teilerbenutzen. - Gib mit einer Schleife alle Primzahlen von 1 bis 30 aus.
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 == 0istTrue, wenn beim Teilen kein Rest bleibt. - Zeilen 4–9:
ergebnisist zuerstTruefür alle Zahlen größer als 1 undFalsefür 1 (und kleinere Zahlen). Wird ein Teiler zwischen 2 undzahl - 1gefunden, wirdergebnisaufFalsegesetzt. Dasreturnsteht nach der Schleife. - Zeilen 11–12: Erst die Hilfsfunktionen einzeln testen, dann zusammensetzen.
- Zeilen 14–16: Das Hauptprogramm ruft
ist_primzahlfü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
- Programme lesen: Von innen nach außen auswerten und für jeden Aufruf die Werte der Parameter notieren.
- Funktionen können andere Funktionen aufrufen. Große Aufgaben zerlegt man so in kleine Hilfsfunktionen, die man einzeln testet.
- Falsche Ergebnisse ohne Fehlermeldung findet man durch Testen mit Werten, deren Ergebnis man vorher kennt.
- Besonders wichtig sind Tests mit Sonder- und
Grenzfällen wie
0oder dem Grenzwert einer Bedingung. - Mit
import mathsteht die Kreiszahl alsmath.pizur Verfügung.
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.
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.
Nach diesem Abschnitt kannst du
- eine Zeichenkette als Folge (Sequenz) von Zeichen beschreiben und den Index eines Zeichens angeben,
- mit
text[index]auf einzelne Zeichen zugreifen und mitlen(text)die Länge bestimmen, - Zeichenketten verketten und Ausgaben mit f-Strings bequem zusammensetzen,
- mit einer Schleife alle Zeichen einer Zeichenkette durchlaufen,
in,.upper(),.lower(),.isalpha()und.isdigit()anwenden,- einen
IndexErrorerklären und vermeiden.
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:
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.
Eine Zeichenkette (englisch string,
Datentyp str) ist eine Folge (Sequenz) von
Zeichen, z. B. "Informatik". Die Zeichen stehen in einer
festen Reihenfolge.
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.
- Eine Zeichenkette (
str) ist eine Sequenz von Zeichen, z. B."Informatik". - Jedes Zeichen hat eine Position (Index), beginnend
bei
0.
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
- Zeile 1: Die Variable
textbekommt die Zeichenkette"Informatik". - Zeile 2:
text[0]ist das Zeichen mit dem Index 0, also das erste Zeichen:I. - Zeile 3:
text[2]ist das dritte Zeichen,f. Schau in der Abbildung oben nach. - Zeile 4:
text[9]ist das letzte Zeichen,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.
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
- Zeile 2:
"Informatik"hat 10 Zeichen. - Zeile 3:
"Ada Lovelace"hat 12 Zeichen – das Leerzeichen zählt mit (siehe Abbildung). Ada Lovelace gilt übrigens als erste Programmiererin der Welt. - Zeile 4:
""ist die leere Zeichenkette. Sie enthält kein einziges Zeichen und hat die Länge 0.
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
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
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.
Ein Zugriff auf einen ungültigen Index (z. B. text[100]
bei kurzem Text) führt zu einer Fehlermeldung
(IndexError).
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
- Zeile 3: Drei Zeichenketten werden verkettet: der
Vorname, ein Leerzeichen und der Nachname. Ohne das
" "in der Mitte stündeAdaLovelaceda. - Zeile 5: Verkettung und Index-Zugriff lassen sich kombinieren: Das erste Zeichen des Vornamens und das erste Zeichen des Nachnamens ergeben die Initialen.
Die Verkettung (Konkatenation) zweier Zeichenketten
erfolgt mit +.
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
- Zeile 2: Die Zählvariable
anzahlstartet bei 0. - Zeile 3: Die Schleife läuft über alle vier Zeichen
von
"Anna". - Zeilen 4–5: Nur wenn das aktuelle Zeichen ein
nist, wirdanzahlum 1 erhöht. - Zeile 6: Erst nach der Schleife (nicht eingerückt) wird das Ergebnis ausgegeben.
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
- Zeile 2:
len(text)ist 3, also durchläuftidie Werte 0, 1 und 2. - Zeile 3: Mit
text[i]holst du das Zeichen an der Positioni.
for zeichen in text:durchläuft nacheinander alle Zeichen der Zeichenkette.for i in range(len(text)):durchläuft alle Indizes. Das Zeichen dazu isttext[i].
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
- Zeile 2:
text.upper()liefert den Text in Großbuchstaben (englisch upper case). - Zeile 3:
text.lower()liefert ihn in Kleinbuchstaben (lower case). - Zeile 4:
textselbst ist unverändert..upper()und.lower()erzeugen eine neue Zeichenkette und lassen die alte, wie sie ist.
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.
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.
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:
text.isalpha()istTrue, wenn alle Zeichen Buchstaben sind (auch Umlaute und ß),text.isdigit()istTrue, wenn alle Zeichen Ziffern sind.
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)
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.
Ein Ausschnitt (Slice) wird mit
text[start:ende] erzeugt (das Zeichen am Index
ende ist nicht mehr enthalten).
1.10.10Übungen
Schreibe ein Programm, das ein Wort einliest und Folgendes ausgibt:
- die Länge des Wortes,
- das erste und das letzte Zeichen,
- das Wort rückwärts.
So könnte es aussehen:
Wort eingeben: «Python»
Länge: 6
Erstes Zeichen: P
Letztes Zeichen: n
Rückwärts: nohtyP
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)}").
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.
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äöü".
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.
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.
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
,
also das vorletzte Zeichen.
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 steht0. Das sind Zeichen, keine Zahlen.+hängt sie aneinander, das ergibt den Text10(und nicht die Zahl 1). - Ein kleines
skommt vor, ein großesSnicht. .lower()macht ausKeink. Ziffern und Leerzeichen bleiben, wie sie sind.
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.
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.
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)- Gib an, welche Fehlermeldung erscheint, und erkläre sie.
- 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.
- Schreibe das Programm richtig auf.
Die beiden Fehler:
Lösung vergleichen
- 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)).
satz.lower()erzeugt zwar den Text in Kleinbuchstaben, aber das Ergebnis wird nicht gespeichert.satzbleibt unverändert, und die beiden großen E würden nicht gezählt. Richtig istsatz = satz.lower().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.
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).
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.
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.
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).
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:
idurchläuft alle Indizes von 0 bislen(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
- Eine Zeichenkette ist eine Sequenz von Zeichen. Jedes Zeichen hat einen Index, gezählt ab 0.
text[i]liefert das Zeichen am Indexi;text[-1]ist das letzte Zeichen.len(text)liefert die Länge. Gültige Indizes reichen von 0 bislen(text) - 1, sonst gibt es einen IndexError.- Mit
+verkettet man Zeichenketten. Ein f-Stringf"... {wert} ..."setzt Werte bequem in einen Text ein. for zeichen in text:durchläuft alle Zeichen,for i in range(len(text)):alle Indizes.x in textprüft, obxenthalten ist..upper()und.lower()liefern eine neue Zeichenkette;.isalpha()und.isdigit()prüfen auf Buchstaben bzw. Ziffern.
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.
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.
Nach diesem Abschnitt kannst du
- eine Liste (ein Feld) als Datenstruktur beschreiben, die mehrere Elemente der Reihe nach zu einer Einheit zusammenfasst,
- zwischen dem Index und dem Element an dieser Stelle unterscheiden,
- über den Index lesend und schreibend auf einzelne Listenelemente zugreifen,
- Elemente mit
append,insert,popundremovehinzufügen und entfernen, - mit einer Schleife alle Elemente einer Liste durchlaufen,
- die Fehlermeldung
IndexErrorerklären und den Fehler beheben.
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'>
- Zeile 1: Eine Liste schreibt man in eckigen
Klammern
[ ]. Die einzelnen Werte werden durch Kommas getrennt. Die ganze Liste wird in der Variablennotengespeichert. - Zeile 2:
printgibt die Liste mit ihren Klammern und Kommas aus. - Zeile 3: Der Datentyp einer Liste heißt
list(englisch für „Liste“).
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.
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.
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.
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
- Zeile 2:
noten[0]liefert das Element mit dem Index 0. Das ist das erste Element, die2. - Zeile 3:
noten[2]liefert das Element mit dem Index 2. Das ist die1– also das dritte Element. Die Zahl in den eckigen Klammern ist der Index, nicht der Wert! - Zeilen 4–5: Ein gelesenes Element kann man wie jeden anderen Wert in einer Variablen speichern.
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).
- Jedes Element besitzt einen Index, beginnend bei
0. Der Index ist nicht dasselbe wie der gespeicherte Wert! - Lesender Zugriff:
liste[index]liefert das Element an dieser Position. - Die Anzahl der Elemente erhält man mit
len(liste). Das letzte Element hat den Indexlen(liste) - 1(oder kurz-1).
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]
- Zeile 2: Das Element am Index 1 bekommt den Wert
5. Der alte Wert3ist weg. Das funktioniert wie eine Zuweisung an eine Variable – nur eben an eine Stelle der Liste. - Zeile 4: Wie bei
x = x + 1wird zuerst die rechte Seite ausgerechnet:noten[2]ist1, plus 1 ergibt2. Dieser Wert wird dann am Index 2 gespeichert.
Die Länge der Liste ändert sich dabei nicht. Es werden nur Inhalte ausgetauscht.
Schreibender Zugriff:
liste[index] = neuer_wert überschreibt das Element an
dieser Position.
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] = 1IndexError: 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.
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:
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]
- Zeilen 3–6: Lesender Zugriff: die ganze Liste, ihre Länge, das Element am Index 0 und das Element am Index 2. Beachte: Die dritte Note hat den Index 2.
- Zeile 8: Schreibender Zugriff: Das Element am Index 1 (die 3) wird durch 5 ersetzt.
- Zeile 11: Die Note 6 wird ans Ende angehängt. Die Liste hat danach sechs Elemente.
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.
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']
- Zeile 2:
pop()ohne Index entfernt das letzte Element ("Eier") und gibt es zurück. Es wird inletztesgespeichert. - Zeile 5:
pop(0)entfernt das Element am Index 0 ("Brot"). Die übrigen Elemente rücken nach links."Käse"hat jetzt den Index 0.
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.
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 beschreibst du Listenoperationen in Fachsprache – vom einfachen zum genauen Satz:
- „Die 5 ist an Stelle 1.“ → „Das Listenelement am Index 1 hat den Wert 5.“
- „Ich mach die 3 zur 5.“ → „Das Listenelement an der Stelle 1 wird von 3 auf 5 verändert.“
- „Die 6 kommt hinten dran.“ → „Mit
appendwird das Element 6 am Ende der Liste hinzugefügt.“ - „Da kommt ein Fehler.“ → „Beim Zugriff auf die
ungültige Listenposition 5 erhalte ich die Fehlermeldung
IndexError.“
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
- Zeile 2: Die Schleifenvariable
stadtbekommt nacheinander jedes Element der Liste, von vorne nach hinten. - Zeile 3: Der eingerückte Schleifenrumpf wird für jedes Element einmal ausgeführt – hier also viermal.
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
- Zeile 2:
len(staedte)ist 4.range(4)erzeugt die Zahlen 0, 1, 2, 3 – genau die gültigen Indizes der Liste. Die Schleifenvariableiist also ein Index. - Zeile 3: Mit
staedte[i]wird das Element am Indexigelesen.
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.
Ä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]
- Zeile 1: Die Liste ist zuerst leer.
- Zeilen 2–3: Für jede Zahl von 1 bis 5 wird ihr Quadrat ans Ende der Liste angehängt.
- Zeile 4: Erst nach der Schleife wird die fertige
Liste ausgegeben. Stünde
printeingerückt in der Schleife, würde die Liste fünfmal ausgegeben – jedes Mal ein Stück länger.
1.11.7Übungen
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.
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).
Gegeben ist die Liste
staedte = ["Saarbrücken", "Trier", "Mainz", "Koblenz"].
- Gib den Wert am Index 2 aus.
- Ändere den Wert am Index 0 zu
"Saarlouis"und gib die Liste aus. - 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).
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.
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.
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
,
und am Index 2 steht "Mi". Das Element "Do"
steht am Index 3. Wer mit tage.index("Do")
nachprüft, bekommt ebenfalls 3.
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:
appendhä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.
Am Montag hast du die Fächer Mathe, Deutsch, Informatik und Sport.
- Lege eine Liste
montagmit diesen vier Fächern an. - Gib das erste und das letzte Fach aus.
- Sport fällt aus, stattdessen ist Kunst. Ändere das Element mit einem schreibenden Zugriff.
- Nach der Schule ist noch die Theater-AG. Hänge
"Theater-AG"an die Liste an. - 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.
Das Programm soll die letzte Farbe der Liste ausgeben. Es bricht aber ab.
farben = ["rot", "gelb", "grün"]
print(farben[3])- Gib an, welche Indizes in dieser Liste gültig sind.
- Erkläre, warum die Fehlermeldung
IndexError: list index out of rangeerscheint. - 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
- Die Liste hat 3 Elemente. Gültig sind die Indizes 0, 1 und 2 (und von hinten −1, −2, −3).
- 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.
- Mit
farben[2]oderfarben[-1]. Beide Fassungen gebengrünaus. Für Listen jeder Länge passt auchfarben[len(farben) - 1].
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.
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.
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.
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.
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.
Im Sitzplan
sitzplan = ["Ben", "Ada", "Tom", "Mia", "Lea"] wollen Tom
und Lea die Plätze tauschen.
- Bestimme mit
.index()die Indizes von Tom und Lea. - Tausche die beiden Elemente mit schreibenden Zugriffen. Gib den Sitzplan vor und nach dem Tausch aus.
- Erkläre, warum du dafür eine Hilfsvariable brauchst.
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
merkezwischengespeichert. - Zeile 6: Am Index 2 steht jetzt Lea. Tom wäre ohne
merkeverloren. - Zeile 7: Tom kommt aus
merkean 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
- Eine Liste (ein Feld) fasst
mehrere Elemente in einer festen Reihenfolge zu einer
Einheit zusammen:
noten = [2, 3, 1, 4, 2]. - Jedes Element hat einen Index, beginnend bei 0.
Index und Element sind verschiedene Dinge:
noten[2]ist das Element am Index 2. - Lesen:
liste[i]. Schreiben:liste[i] = wert. Negative Indizes zählen von hinten:liste[-1]ist das letzte Element. len(liste)liefert die Anzahl der Elemente. Gültige Indizes sind0bislen(liste) - 1. Ein ungültiger Index führt zu einemIndexError.appendhängt an,insertfügt ein,popentfernt am Index,removeentfernt ein Element mit einem bestimmten Wert.for element in liste:durchläuft die Elemente,for i in range(len(liste)):durchläuft die Indizes.
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.
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.
Nach diesem Abschnitt kannst du
- mit einer Schleife über die Elemente oder über die Indizes einer Liste laufen und die passende Art auswählen,
- die Summe und den Mittelwert aller Elemente einer Liste berechnen,
- das kleinste und das größte Element einer Liste bestimmen,
- mit der linearen Suche herausfinden, ob und an welchem Index ein Wert in einer Liste vorkommt,
- zählen, wie oft ein Wert in einer Liste vorkommt,
- deine Ergebnisse mit
sum(),min(),max()undsorted()kontrollieren.
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.
Über eine Liste kann man auf zwei Arten iterieren (sie durchlaufen):
- über die Elemente direkt:
for element in liste: - über die Indizes:
for i in range(len(liste)):– nützlich, wenn man den Index selbst braucht (z. B. für schreibenden Zugriff).
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
- Zeile 3: Die Hilfsvariable
summewird vor der Schleife auf 0 gesetzt. Man sagt: Sie wird mit 0 initialisiert. - Zeilen 4–5: In jedem Durchlauf wird das aktuelle
Element zu
summeaddiert. - Zeile 6: Erst nach der Schleife
steht in
summedas Endergebnis. Deshalb istprintnicht eingerückt.
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).
Summenbildung: Eine Hilfsvariable wird vor der
Schleife auf 0 gesetzt und in jedem Durchlauf um das
aktuelle Element erhöht.
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.
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
- Zeile 2: Die Hilfsvariable
maximumwird mit dem ersten Element der Liste initialisiert. Das ist die erste Karte in der Hand. - Zeile 4: In jedem Durchlauf wird geprüft, ob das aktuelle Element größer ist als das bisherige Maximum.
- Zeile 5: Nur wenn das der Fall ist, wird
maximumaktualisiert: Es bekommt den neuen, größeren Wert.
Für das Minimum geht man genauso vor. Man dreht nur
den Vergleich um: < statt >.
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 |
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.
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
- Zeile 2: Weil die Funktion den Index zurückgeben soll, läuft die Schleife über die Indizes.
- Zeile 3: Das Element am Index
iwird mit dem gesuchten Wert verglichen. - Zeile 4: Bei einem Treffer gibt
return iden Index zurück.returnbeendet die Funktion sofort – auch mitten in der Schleife. Die restlichen Elemente werden nicht mehr angesehen. - Zeile 5: Diese Zeile wird nur erreicht, wenn die
Schleife bis zum Ende gelaufen ist, ohne etwas zu finden. Dann gibt die
Funktion
-1zurück. - Zeilen 8–9:
"Tom"steht am Index 2."Lea"kommt nicht vor, deshalb lautet das Ergebnis-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
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.
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 beschreibst du einen Listen-Algorithmus in Fachsprache:
- „Die Funktion findet Tom an Stelle 2.“ → „Der Funktion
lineare_suchewerden die Listenamenund der Wert"Tom"übergeben. Sie durchläuft die Liste Element für Element und gibt den Index 2 zurück.“ - „Bei Lea kommt −1.“ → „Ist der gesuchte Wert nicht in der Liste enthalten, gibt die Funktion −1 zurück.“
- „maximum merkt sich die größte Zahl.“ → „Die
Hilfsvariable
maximumwird mit dem ersten Listenelement initialisiert und aktualisiert, sobald ein größeres Element gefunden wird.“
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.
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.
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
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]))- Gib an, was das Programm ausgibt.
- Beschreibe in einem Satz, was die Funktion
geheimallgemein berechnet. - Erkläre, warum das Ergebnis nicht
3ist, obwohl am Index 3 auch eine 8 steht.
Deine Antworten:
Lösung vergleichen
- Das Programm gibt
1aus. - 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.
- Das Maximum 8 kommt zweimal vor. Die Hilfsvariable
positionwird nur bei einem echt größeren Element aktualisiert (>). Beim Index 3 ist8 > 8falsch. Deshalb bleibt der Index 1 des ersten Vorkommens. Mit>=wäre das Ergebnis 3.
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().
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.
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“.
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
.
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.
In einer Liste steht die Länge jedes Songs einer Playlist in Minuten:
songs = [3, 4, 2, 5, 3].
- Implementiere eine Funktion
gesamtdauer(liste), die die Summe aller Elemente zurückgibt. - Implementiere eine Funktion
mittlere_dauer(liste), die die durchschnittliche Länge zurückgibt. Sie sollgesamtdaueraufrufen. - 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.
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.
In der Liste faecher steht, wem welches Schließfach
gehört. Ein leeres Fach ist mit der leeren Zeichenkette ""
gekennzeichnet:
faecher = ["Ada", "Ben", "", "Mia", ""]- 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-1zurückgeben. - 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.
- 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.
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- Teste die Funktion mit
[3, -1, 5](erwartet: 5) und mit[-2, -1, -5](erwartet: −1). Notiere die Ergebnisse. - Erkläre die beiden Fehler und verbessere die Funktion.
Testergebnisse und Fehler:
Lösung vergleichen
- 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
- Fehler 1:
return besteist 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:bestebeginnt 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.
Ein Tag mit einer Temperatur unter 0 °C heißt Frosttag.
- Implementiere eine Funktion
frosttage(temperaturen), die zählt, wie viele Werte der Liste unter 0 liegen. - 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.
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 |
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
- Über eine Liste iteriert man über die Elemente
(
for element in liste:) oder über die Indizes (for i in range(len(liste)):). Zum Verändern braucht man die Indizes. - Summe: Hilfsvariable vor der Schleife auf 0 setzen,
in jedem Durchlauf das Element addieren. Mittelwert =
Summe /
len(liste). - Maximum/Minimum: Hilfsvariable mit dem ersten Element initialisieren und bei jedem größeren bzw. kleineren Element aktualisieren.
- Lineare Suche: Element für Element vergleichen, bis
der Wert gefunden oder die Liste zu Ende ist. Ergebnis: der Index (oder
-1) bzw.True/False. - Zählen: Hilfsvariable mit 0 beginnen und um 1 erhöhen, wenn ein Element die Bedingung erfüllt.
sum,min,max,sortedundinerledigen das fertig – gut zur Kontrolle eigener Funktionen.
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.
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.
Nach diesem Abschnitt kannst du
- das Verfahren der Caesar-Chiffre beschreiben und von Hand anwenden,
- die Position eines Buchstabens im Alphabet bestimmen und mit
% 26am Ende des Alphabets vorne weiterzählen, - Funktionen zum Verschlüsseln eines Buchstabens und eines ganzen Textes implementieren und systematisch testen,
- ein Programmierprojekt im Team planen, Teilaufgaben verteilen und die Ergebnisse zusammenführen.
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.
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.
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.
Benutze die Abbildung oben (Schlüssel 3).
- Verschlüssele das Wort
INFORMATIK:
| I | N | F | O | R | M | A | T | I | K |
|---|---|---|---|---|---|---|---|---|---|
- Entschlüssele den Geheimtext
ZDVVHU. - Beschreibe in einem Satz, wie du beim Entschlüsseln vorgegangen bist.
Deine Antworten zu 2 und 3:
Lösung vergleichen
INFORMATIKwird zuLQIRUPDWLN.ZDVVHUwird zuWASSER.- 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:
- Verstehen und planen: Was genau soll das Programm können? Wie löst man das Problem – erst einmal ohne Computer?
- Zerlegen und verteilen: Das Problem wird in Teilaufgaben zerlegt. Für jede Teilaufgabe wird eine Funktion geplant. Jede Person im Team übernimmt eine Teilaufgabe.
- Umsetzen und testen: Jede Person programmiert ihre Funktion und testet sie mit vorher festgelegten Beispielen.
- Zusammenführen: Die Funktionen werden zu einem Programm zusammengesetzt und gemeinsam getestet.
- 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.
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.
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.
Plant gemeinsam auf Papier, bevor ihr programmiert. Beantwortet dazu die drei Fragen:
- Wie ermittelt man zu einem Buchstaben seine Position im Alphabet?
- Wie kommt man von der Position zurück zum (verschobenen) Buchstaben?
- Was passiert am Ende des Alphabets, z. B. bei
Zmit 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
- 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 mitalphabet.index(buchstabe). - Man addiert den Schlüssel zur Position und liest mit
alphabet[neue_position]den Buchstaben an der neuen Position ab. - 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 % 26ergibt2, 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
- Zeile 1: Das Alphabet besteht aus 26 Großbuchstaben. A hat den Index 0, Z den Index 25.
- Zeile 3:
alphabet.index("C")geht vom Zeichen zur Position: Ergebnis 2. - Zeile 4:
alphabet[5]geht von der Position zum Zeichen: Ergebnis F.
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.
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.
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
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.
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: ADas 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
- Zeile 2:
ergebnisbeginnt als leere Zeichenkette – so wiesummebei 0 beginnt. - Zeile 4: In jedem Durchlauf wird das Zeichen
zweimal angehängt. Der neue, längere Text wird wieder in
ergebnisgespeichert.
- Schreibt eine Funktion
verschluessle_text(text, schluessel). Sie soll in einer Schleife jeden Buchstaben eines Textes mitverschluessle_buchstabeverschlüsseln und den Geheimtext als neue Zeichenkette zurückgeben. Testet mitverschluessle_text("HALLO", 3)(erwartet:KDOOR). - 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
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.
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.
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 |
- Verschlüssele das Wort
PIZZAmit dem Schlüssel 5. - Entschlüssele den Geheimtext
KJWNJS. Er wurde mit dem Schlüssel 5 verschlüsselt.
Meine Lösungen:
Lösung vergleichen
- 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. - 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.
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
, und 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.
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))- Gib an, was die beiden Zeilen ausgeben.
- Erkläre, warum in der zweiten Zeile wieder der Klartext herauskommt.
- 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
- Die erste Zeile gibt
UNYYBaus, die zweite wiederHALLO. - Die zweite Zeile verschiebt jeden Buchstaben zweimal um 13, also insgesamt um Stellen. Das ist einmal ganz um das Alphabet herum, und jeder Buchstabe landet wieder an seiner alten Stelle.
- 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.
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.
- 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". - 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.
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 > 0verhindert 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
- Die Caesar-Chiffre verschiebt jeden Buchstaben um eine feste Anzahl von Stellen (den Schlüssel) im Alphabet. Aus dem Klartext wird der Geheimtext.
- Die Position eines Buchstabens ist sein Index in
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"(oderord(buchstabe) - ord("A")). (position + schluessel) % 26sorgt dafür, dass es nach Z wieder bei A weitergeht.- Einen neuen Text baut man auf, indem man mit
""beginnt und in einer Schleife Zeichen anhängt. - Im Team zerlegt man das Problem in Teilaufgaben, legt vorher die Schnittstellen der Funktionen fest, testet jede Funktion mit Normal- und Randfällen und führt die Teile am Ende zusammen.
Im nächsten Abschnitt entwickelt ihr die passende Entschlüsselung und schließt das Projekt ab.
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.
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?
Nach diesem Abschnitt kannst du
- erklären, wie Entschlüsselung und Verschlüsselung bei der Caesar-Chiffre zusammenhängen, und eine Entschlüsselungsfunktion implementieren,
- mit dem Ausprobieren aller Schlüssel (Brute-Force) einen Geheimtext knacken und die Sicherheit der Caesar-Chiffre beurteilen,
- ein Programmierprojekt testen, dokumentieren und kurz vorstellen,
- Berufe, Berufsfelder und Berufsbiografien mit Bezug zur Softwareentwicklung mit seriösen Quellen recherchieren und die Ergebnisse geordnet festhalten.
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
- Zeilen 3–6:
verschluessle_buchstabebestimmt die Position des Buchstabens, verschiebt sie um den Schlüssel und lässt sie mit% 26am Ende des Alphabets umlaufen. - Zeilen 8–16:
verschluessle_textgeht den Text Zeichen für Zeichen durch. Buchstaben werden verschlüsselt, alle anderen Zeichen (wie das Leerzeichen) unverändert angehängt.
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.
Ü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
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.
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.
Beurteile die Sicherheit der Caesar-Chiffre. Gehe dabei auf diese Fragen ein:
- Wie viele verschiedene Schlüssel gibt es, die den Text tatsächlich verändern?
- 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?
- 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.
- Ergänzt euer Programm um einen Kommentarkopf wie oben.
- Führt mit dem fertigen Programm noch einmal alle Tests aus den Teilaufgaben A bis D durch.
- 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?
- 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:
- Fachinformatikerin oder Fachinformatiker für Anwendungsentwicklung
- Softwareentwicklerin oder Softwareentwickler
- IT-Sicherheitsexpertin oder IT-Sicherheitsexperte (hier spielt Verschlüsselung eine große Rolle)
- Data Scientist oder Data Engineer (Datenwissenschaft)
- UX/UI-Designerin oder UX/UI-Designer (Gestaltung von Bedienoberflächen)
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:
- BERUFENET der Bundesagentur für Arbeit
(
berufenet.arbeitsagentur.de): Steckbriefe zu sehr vielen Berufen mit Aufgaben, Zugangswegen und Ausbildung. - planet-beruf.de und abi.de, ebenfalls von der Bundesagentur für Arbeit: Informationen zur Berufs- und Studienwahl für Schülerinnen und Schüler, auch mit Erfahrungsberichten.
- Hochschulkompass
(
hochschulkompass.de): Übersicht über Studiengänge an deutschen Hochschulen. - Die Berufsberatung der Agentur für Arbeit und das Berufsinformationszentrum (BiZ). Fragt auch an eurer Schule nach Beratungsterminen.
- Für Berufsbiografien: Interviews und Porträts, z. B. auf den Karriereseiten von Unternehmen. Bedenke: Unternehmen wollen dort auch für sich werben.
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
- Welche Aufgaben und Tätigkeiten gehören zu diesem Berufsbild?
- Welche Ausbildung bzw. welches Studium wird benötigt?
- Welche Programmiersprachen oder Werkzeuge werden häufig eingesetzt?
- Wie hat sich das Berufsbild in den letzten Jahren verändert, z. B. durch KI-Werkzeuge?
- Was interessiert euch persönlich an diesem Berufsfeld – oder was eher nicht?
- Welche Person aus diesem Berufsfeld könnt ihr finden? Recherchiert ihren Werdegang (Berufsbiografie): Ausbildung oder Studium → Berufseinstieg → heutige Tätigkeit.
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.
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.
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.
Der Geheimtext WGLYPI wurde mit der Caesar-Chiffre und
dem Schlüssel 4 verschlüsselt.
- Entschlüssele ihn von Hand. Benutze die Positionstabelle aus dem Auftrag Caesar mit Schlüssel 5 im ersten Projektteil.
- 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
- 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. - Der Gegenschlüssel ist . 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.
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.
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.
- 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. - Nimm an, dass dieser Buchstabe für E steht. Berechne daraus den Schlüssel.
- Entschlüssele den Text mit
entschluessle_textund prüfe, ob ein sinnvoller Satz herauskommt.
Häufigster Buchstabe, Schlüssel, Klartext:
Lösung vergleichen
- Der Buchstabe O kommt sechsmal vor, jeder andere Buchstabe höchstens zweimal.
- O hat die Position 14, E die Position 4. Der Schlüssel ist also .
- 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.
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".
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_forcewerden alle Schlüssel von 0 bis 25 durchprobiert. - Zeile 23: Das Ergebnis wird in
versuchgespeichert, 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
- Entschlüsseln heißt: jeden Buchstaben um den Schlüssel
zurück verschieben. Das entspricht dem Verschlüsseln
mit
-soder26 - s. % 26liefert in Python auch bei negativen Zahlen ein Ergebnis von 0 bis 25.- Mit Brute-Force probiert man alle Schlüssel aus. Weil es nur 25 sinnvolle Schlüssel gibt, ist die Caesar-Chiffre nicht sicher.
- Zum Projektabschluss gehören: alle Tests wiederholen, das Programm dokumentieren (Kommentarkopf), es vorstellen und im Team zurückblicken.
- Berufe und Berufsbiografien recherchiert man mit seriösen Quellen wie BERUFENET, gibt jede Angabe mit Quelle an und erfindet nichts dazu.
1.15Kapitel 1 kompakt: der Lernzettel
Diesen Abschnitt als PDF (S. 195–198)
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)
- Eine Variable ist ein benannter Speicherplatz. Mit
=bekommt sie einen Wert:alter = 15(Zuweisung, gelesen „alter wird 15“). - Datentypen:
int(ganze Zahl,15),float(Kommazahl mit Punkt,1.68),str(Text in Anführungszeichen,"Hallo"),bool(True/False). print(...)gibt aus, mehrere Werte mit Komma getrennt:print("Alter:", alter).input(...)liest ein. Das Ergebnis ist immer ein Text (str), auch wenn eine Zahl eingegeben wird.- Typumwandlung: Zum Rechnen umwandeln.
alter = int(input("Alter? ")) # ganze Zahl
groesse = float(input("Größe? ")) # KommazahlTypische 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 |
and: beide Bedingungen müssen wahr sein.or: mindestens eine.not: kehrt um.=weist zu,==vergleicht.- Umrechnen mit
//und%:200 // 60ergibt 3 (volle Minuten),200 % 60ergibt 20 (Rest-Sekunden). Ob eine Zahl gerade ist:zahl % 2 == 0. - De Morgan (eine verknüpfte Bedingung verneinen):
Aus
andwirdorund umgekehrt, jeder Teil wird verneint.
| 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- Es wird nur der Block der ersten wahren Bedingung ausgeführt, der Rest wird übersprungen.
- Einseitig: nur
if. Zweiseitig:if … else. Mehrseitig:if … elif … else. - Was eingerückt ist, gehört zum Block. Verzweigungen kann man verschachteln.
- Bei Bereichen (unter 1000, 1000 bis unter 2000, ab 2000) von unten
nach oben prüfen:
if x < 1000:, dannelif x < 2000:, dannelse:. - Mehrfachauswahl (
CASE OF) vergleicht einen Wert mit festen Werten:
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: |
range(5)ergibt 0, 1, 2, 3, 4.range(1, 5)ergibt 1, 2, 3, 4.range(0, 10, 3)ergibt 0, 3, 6, 9. Der Stoppwert gehört nie dazu.- Die Zählvariable (
i) ändert sich bei jedem Durchlauf von selbst. - In einer
while-Schleife muss sich die Bedingung im Rumpf ändern können, sonst entsteht eine Endlosschleife.
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: ausgebensumme = 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- Eine Funktion fasst Anweisungen unter einem Namen zusammen und ist wiederverwendbar.
- Parameter sind die Platzhalter in der Definition, Argumente die Werte beim Aufruf.
returngibt einen Rückgabewert zurück und beendet die Funktion. Ohnereturnliefert sieNone.- Die Definition allein tut nichts. Erst der Aufruf führt die Funktion aus.
- Funktionen dürfen andere Funktionen aufrufen.
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" |
- Eine Zeichenkette ist eine Folge von Zeichen. Der
Index beginnt bei 0, das letzte Zeichen hat den Index
len(text) - 1. - Durchlaufen:
for zeichen in text:geht jedes Zeichen der Reihe nach durch. - Ein Index, den es nicht gibt (
text[6]), führt zumIndexError.
1.15.7Listen und Listenalgorithmen (Abschnitte 1.11 und 1.12)
- Eine Liste fasst mehrere Elemente zusammen:
noten = [2, 3, 1, 4]. Der Index ist die Position (ab 0), das Element der gespeicherte Wert. - Lesen:
noten[0]ergibt2. Ändern:noten[1] = 2. Anhängen:noten.append(5). Länge:len(noten). - Durchlaufen über die Elemente
(
for note in noten:) oder über die Indizes (for i in range(len(noten)):, wenn man den Index braucht, zum Beispiel zum Ändern).
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 = TrueFü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)
- Jeder Buchstabe wird um den Schlüssel im Alphabet verschoben. Mit Schlüssel 3: A → D, X → A.
- Die Position eines Buchstabens liefert
alphabet.index(buchstabe), den Buchstaben an einer Positionalphabet[position]:
alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"- Neue Position:
(position + schluessel) % 26. Das% 26sorgt dafür, dass es nach Z wieder bei A weitergeht. - Entschlüsseln heißt um den Schlüssel
zurückschieben:
(position - schluessel) % 26. - Ein Text wird Zeichen für Zeichen verschlüsselt, vorher mit
text.upper()in Großbuchstaben umgewandelt. Eine Hilfsfunktion für einen Buchstaben, eine zweite für den ganzen Text, die die erste in einer Schleife aufruft.
1.16Rückblick auf Kapitel 1
Diesen Abschnitt als PDF (S. 199–200)
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. |