Python in der Schule

Meine Tochter besucht die 8. Klasse eines Gymnasiums im Saarland und hat in diesem Jahr zum ersten Mal Informatikunterricht. Wenig überraschend finde ich die Unterrichtsinhalte wenig begeisternd, aber immerhin wird für die ersten Schritte beim Programmieren Python und Turtle verwendet. Kein Java oder Schlimmeres. Dieser Artikel ist mein Versuch, die behandelten Themen verständlicher und nicht so trocken zu erklären.

Python

Bevor wir loslegen will ich ein paar Punkte klären, die oft für Verwirrung sorgen, aber nicht so richtig zum Rest dieses Artikels passen. Am besten überfliegst du diesen Absatz einfach kurz, ohne dir groß Gedanken zu machen. Solltest du über eines der Themen stolpern, komm' einfach hierher zurück und ließ nochmal genau nach.

Laptop oder Browser

Die Beispiele sollten überall unverändert funktionieren. Evtl. erwartet deine Lehrperson von dir, nach dem import erst folgende Zeile zu schreiben bevor es richtig los geht:

makeTurtle()

Damit sagst du dem Computer, er soll die Turtle bereit machen, d.h. auch alles wieder auf die ursprünglichen Einstellungen (Position, Zeichenfarbe, Strichdicke, ...) setzen. Da die Beispiele eh immer frisch starten ist diese Zeile meiner Meinung nach unnötig. Ich schreibe diesen Text und die Beispiele auf einem normalen Laptop.

In einem Browser oder bei dir in der Schule kann das evtl. anders sein. Oder deine Lehrperson will ganz auf Nummer sicher gehen. In dem Fall mußt du dich danach richten und die Zeile einfügen. Am Rest der Beispiele ändert sich dadurch aber nichts.

Kommentare

Du kannst Kommentare in deine Code schreiben, in dem du das Rautezeichen # verwendest. Alles hinter dem Zeichen wird einfach ignoriert:

#   Die Raute kann direkt am Anfang stehen. Dann wird die ganze Zeile
#   ignoriert.

x = 5  # x ist jetzt 5, der Rest wird ignoriert

Ich verwende in einigen Beispielen Kommentaren und meine Tochter hat mich darauf hingewiesen, dass das in der Schule nicht erklärt wird.

Repeat

Falls du in der Schule https://webtigerjython.ethz.ch/ verwendest, hast du vermutlich eine repeat-Schleife gezeigt bekommen:

repeat 10:
    # ... irgendwas wird 10 mal gemacht ...

Den Befehl gibt's in Python eigentlich nicht. Er ist ein "Spezialfeature" von WebTiger und in meinen Augen Unsinn. Schleifen kommen aus gutem Grund ziemlich am Ende dieses Artikels. Dort erkläre ich, was es mit repeat auf sich hat und warum ich den Befehl für Unsinn halte.

Auf geht's!

Die folgenden Beispiele erklären dir, was Variablen, Schleifen und Funktionen sind. Wenn dir etwas nicht sofort klar ist, mach' dir nicht zuviele Gedanken sondern ließ erstmal weiter. So bekommst du einen Überblick worauf alles hinaus läuft. Beim zweiten oder dritten Lesen ergeben die Einzelteile vermutlich viel mehr Sinn. Solltest du irgendetwas wirklich gar nicht verstehen, habe ich wohl schlecht erklärt. In dem Fall würde ich mich über eine E-Mail freuen. Ich versuchen dann den Text mit deinem Feedback zu verbessern.

Jetzt aber wirklich!

Ich gehe davon aus, dass du aus der Schule weißt, wie man ein Pythonprogramm mit einer "Schildkröte" ausführt. Meine Tochter verwendet in der z.B. https://webtigerjython.ethz.ch/ Du solltest alle meine Beispiel unverändert selbst ausprobieren und der Schildkröte beim malen zuschauen können. Probiere am besten einfach mal dieses Beispiel aus:

from turtle import *

forward(200)
left(90)
forward(100)
left(90)
forward(200)
left(90)
forward(100)

Dein Bild sollte ungefähr so aussehen:

Falls dir das Bild etwas groß und leer vorkommt: Ich lasse alle Bilder in ihrer "Originalgröße". D.h. die Bilder sind alle gleich groß und der Start- bzw. Nullpunkt ist jeweils genau in der Mitte. So ist es für dich leichter die Bilder zu vergleichen und zu verstehen, was in den Beispielen passiert.

Die Schildkröte schaut am Anfang nach rechts. Daher bewegt der erste forward-Befehl die Schildröte nach rechts. left(90) dreht sie - aus der Sicht der Schildkröte - um 90 Grad nach links. Aus deiner Sicht schaut sie jetzt nach oben. Du bewegst sie nochmal (aus Sicht der Schildgröte) nach vorne, also (aus deiner Sicht) nach oben. Dann nochmal nach links drehen, nach vorne, nach links drehen, nach vorne und du bist wieder am Ausganspunkt. Du hast ein Rechteck gezeichnet, das doppelt so breit wie hoch ist. Mit diesem Rechteck werden wir jetzt "spielen".

Die Schildkröte schaut am Ende nach unten. Versuch' mal was passiert, wenn du den Code zweimal hintereinander ausführst. Also so:

from turtle import *

forward(200)
left(90)
forward(100)
left(90)
forward(200)
left(90)
forward(100)

forward(200)
left(90)
forward(100)
left(90)
forward(200)
left(90)
forward(100)

Dein Bild sollte so aussehen:

Die Leerzeilen haben übrigens keine Bedeutung und dienen nur der besseren Lesbarkeit. Deine Schildkröte zeigt jetzt nach links, d.h. du könntest den Code aus dem ersten Beispiel nochmal unten drunter kopieren um ein drittes Rechteck zu zeichnen. Und dann nochmal, aber das würde schon arg unübersichtlich. Womit wir zu einem der wichtigesten Punkte kommen, den man dir in der Schule vermutlich nicht so deutlich erklären wird:

Gute Programmierer*innen sind faul!

Beim Programmieren geht es ganz viel darum, sich das Leben leicht zu machen. Also im Prinzip so faul wie möglich zu sein. Du verstehst sicher, warum Lehrer*innen das ungern erwähnen?!

Schlau-sein ist der Job für Menschen. Computer sind für die langweiligen Fleißaufgaben da. Um die vier Rechtecke zu malen, solltest nicht du den Code mehrfach kopieren. Dafür sind Computer da! Ja, das ist ein einfaches Beispiel und du bekämst das sicher auch hin, aber du solltest von Anfang an für klare Verhältnisse sorgen: Fleißarbeit ist Sache des Computer! Du darfst "faul" sein.

Stell dir mal vor, du hast das erste Beispiel vier mal kopiert und entschließt dich dann die Größe der Rechtecke ändern. Eine so stupide Aufgabe ist nichts für Menschen. Also lassen wir das den Computer machen. Hier ist der Code und das Bild. Die Erklärung folgt darunter:

from turtle import *

def rechteck():
    forward(200)
    left(90)
    forward(100)
    left(90)
    forward(200)
    left(90)
    forward(100)

rechteck()
rechteck()
rechteck()
rechteck()

In dem Code stecken einige sehr wichtige Details, aber keine Sorge: Ich erkläre sie dir Schritt für Schritt!

Das def ist Teil der Programmiersprache Python, also eingebaut und vorgegeben, genau wie from und import. def steht für "definition" und definiert eine Funktion. Eine Funktion kannst du dir erstmal als eine Art Vorlage vortellen. Du beschreibst den Computer nur einmal was er machen soll und sagst ihm dann "mach das!". Bei Aufgaben, die er nur einmal machen soll bringt dir das wenig, aber in obigem Beispiel kannst du dadurch einfach sagen: "Tue es nochmal" "Und nochmal!" ohne die Details wiederholen zu müssen. Der Computer hat ja seine Vorlage. Du erinnerst dich: Du solltst als Menschen das Denken übernehmen und die stupide Wiederholung dem Computer überlassen.

Zurück zu def und der Funktion: Größere Programme haben natürlich viele Vorlagen bzw. Funktionen und du mußt dem Computer jeweils sagen, welche er ausführen soll. Daher brauchen Funktionen einen Namen, wie in dem Beispiel oben das rechteck. Zum Sinn und Zweck der Klammern kommen wir gleich. Für den Moment müssen sie einfach an den Namen angehängt werden, selbst wenn nichts darin steht. Der Doppelpunkt markiert das Ende.

Als nächstes kommt der sogenannte "body" - als Körper - der Funktion. Bisher haben wir nur den Namen, jetzt legen wir fest, was getan werden soll wenn wir rechteck verlangen. Die Einrückung sagt dabei, bis wohin die Vorlage geht. Alles was gleich weit eingrückt ist, gehört zusammen und ist Teil der Funktion. Wo die Einrückung endet - also vor den rechteck()-Zeilen - endet auch die Funktion.

Dass Blöcke durch Einrückung markiert werden, ist in Python ganz allgemein so. Eine if-Anweisung sieht z.B. so aus:

x = 7

if x < 10:
    print("x ist kleiner als 10")
    print("bla bla ...")
else:
    print("x ist größer oder gleich 10")

Auch wenn du noch keine if-Anweisung gesehen hast und du noch nichts von Varialben weißt, ist das Muster doch sichtbar. Im Prinzip steht da: Wenn irgendeine Bedingung erfüllt ist (hier x < 10) dann mache irgendwas. Wenn nicht (else), mache etwas anderes. Was "irgendwas" und "etwas anderes" ist, mußt du dem Computer natürlich sagen. Er weiß ja nicht, ob es nur um eine oder mehrere Zeilen geht, ergo mußt du wieder durch die Einrückung klar machen was wozu gehört.

Um wirklich zu verstehen, dass Funktionen Vorlagen sind, kannst du folgendes Programm ausprobieren. Das Ergebnis führt oft zu Verwirrung.

from turtle import *

def rechteck():
    forward(200)
    left(90)
    forward(100)
    left(90)
    forward(200)
    left(90)
    forward(100)

Es passiert einfach nichts. Du hast dem Computer zwar deine Vorlage gegeben, ihn aber nicht aufgefordert, diese auch auszuführen. Dazu schreibst du rechteck(). Die Klammern haben noch immer keinen Inhalt. Höchste Zeit das zu ändern, aber dazu müssen wir kurz einen Schritt zurück machen und erst klären, was Variablen sind.

Variablen

Variablen kann man aus zwei Blickwinkeln betrachten bzw. erklären. Am besten starten wir wieder mit einem Beispiel:

from turtle import *

height = 100
width = height * 2

forward(width)
left(90)
forward(height)
left(90)
forward(width)
left(90)
forward(height)

Das ist wieder unser Rechteck aus dem ersten Beispiel, nur mit ein paar kleinen Änderungen: Statt die Zahlen zu wiederholen, gebe ich der 100 den Namen height. Diesen Namen kann ich ab jetzt überall verwenden, wo die 100 hingehört. Willst du ein höheres Viereck haben, brauchst du nur eine Zeile zu ändern. Ja, in diesem Beispiel hättest du nur zwei Stellen ändern müssen, aber in der Realtiät werden Programme schnell größer. Dann willst du nicht viele viele Zeilen durchsuchen und 100 durch 150 ersetzen. Womöglich änderst du dabei aus Versehen eine 100, die gar nichts mit deinem Rechteck zu tun hat, was dann an anderer Stelle für Chaos sorgt.

Sicher hast du schon darauf gewartet: Du solltest einmal nachdenken, die stupide Fleißarbeit ist für den Computer!

Da Computer ziemlich gut im Rechnen sind, wird dich width vermutlich nicht überraschen. Statt den Wert von width mit einer konkreten Zahl (also z.B. 200) anzugeben, kannst du den Wert auch berechnen lassen. Der Stern steht für Multiplikation. Wenn du height statt 100 z.B. 150 zuweist, wird width ganz automatisch zu 300 statt vorher 200.

Gleich ist nicht gleich gleich!

Zuweisungen

Ich habe gerade das Wort "zuweisen" verwendet. Dabei war ein Gleichheitszeichen im Spiel. Diese sorgen bei Anfänger*innen gerne mal für Verwirrung und das würde ich bei dir gerne vermeiden. Also klären wir das jetzt ein und für alle mal, natürlich mit einem Beispiel:

height = 100

Sowas nennt man eine Zweisung. Wie oben beschrieben kann ich nach dieser Zeile den Namen height verwenden und der Computer weiß, dass der zugehörige Wert 100 ist. Du kannst dir entweder vorstellen, dass height ein reservierter Platz (eine Box, Schachtel, ...) ist und da hinterlegst du deine 100. Wenn du height verwendest schaut der Computer an diesem Platz nach dem passenden Wert. Oder du stellst es dir aus der Sicht der 100 vor, die ein Namensschild angesteckt bekommt. (In Wirklichkeit ist's etwas komplizierter und irgendwo zwischen diesen beiden Erklärungen, aber das hat Zeit bis später. Für jetzt kannst du dir den Blickwinkel aussuchen, der für dich einleuchtender ist.)

Links vom Gleichheitszeichen steht also der Name und rechts davon der Wert, der zugewiesen wird. Wie du bei width gesehen hast, kann rechts auch ein Rechenausdruck stehen. Der wird dann zuerst berechnet und das Ergebnis anschließend dem Namen auf der linken Seite zugewiesen.

Vergleiche

Ok, aber wo ist das Problem? Ein Gleichheitszeichen weist einer Variablen einen Wert zu. Aber was machst du, wenn du zwei Werte vergleichen willst? Ohne dich lange auf die Folter zu spannen:

if height == 100:
    print("Die Höhe ist genau 100!")

Wenn du Werte vergleichen willst, musst du == verwenden. Eine Zuweisung und ein Vergleich sind zwei verschiedene Sachen. Python ist nicht schlau genug beides auseinander zu halten, wenn wir jeweils das gleiche Symbol verwenden würden. Daher müssen wir zwei unterschiedliche verwenden: = für Zuweisungen und == für Vergleiche. So sind die Regeln. Musst du dir einfach merken.

Parameter

Du weisst jetzt, dass man Werte in Variablen speichern kann oder den Werten Namen geben kann, jenachdem welcher Blickwinkel dir lieber ist. Aber eigentlich wollten wir ja klären, was die mysteriösen Klammern hinter den Funktionen machen, die bisher immer leer waren.

Laß uns ein Beispiel betrachten, in dem wir zwei Rechtecke zeichnen wollen, die aber nicht gleich groß sind. Hier ein erster Versuch:

from turtle import *

height = 100
width = height * 2

forward(width)
left(90)
forward(height)
left(90)
forward(width)
left(90)
forward(height)

height = 150
width = height * 2

forward(width)
left(90)
forward(height)
left(90)
forward(width)
left(90)
forward(height)

Das funktioniert zwar, ist aber sehr unpraktisch. Du musst z.B. immer daran denken, auch width neu zu berechnen. An dieser Stelle noch eine kleine Anmerkung:

Im letzten Beispiel wurde das höhere Rechteck auch breiter. Das ist weder richtige noch falsch. Ich habe das einfach so beschlossen. Das ist das coole am Programmieren: Computer machen das, was man ihnen sagt. Wenn's dir nicht gefällt, sagst du ihm, dass er's anders machen soll und er macht es brav. So oft du willst. Probier' einfach aus! Dein Computer wird nicht explodieren, wenn dein Bild nicht so aussieht, wie du es erwartet hattest. Außer dir weiß ja eh niemand, was du machen wolltest und vielleicht entdeckst du aus Versehen spannende neue Muster.

Zurück zum Beispiel: Das größte Problem mit dem Beispiel ist, dass wir keine Vorlage benutzt haben. Die zwei Rechtecke sind nicht mehr identisch, also können wir auch nicht für beide die gleiche Vorlage benutzen. Oder doch? Dafür sind natürlich die Klammern da:

from turtle import *

def rechteck(height):
    width = height * 2

    forward(width)
    left(90)
    forward(height)
    left(90)
    forward(width)
    left(90)
    forward(height)

rechteck(100)
rechteck(150)

Funktionen bzw. Vorlagen, die immer exakt das Gleiche tun sind nicht sonderlich nützlich oder hilfreich. Mit Parametern (so nennt man das height in den Klammern in der def-Zeile) kannst du die Funktion flexibler machen. Du kannst dir height als eine Box vorstellen, die nur kurz angelegt wird, wenn du die Funktion (Vorlage) benutzt. D.h. die Zeile

rechteck(100)

sorgt dafür, dass eine frische height-Box angelegt wird, dort wird die 100 hinterlegt und dann wird der Code in der Funktion (also der eingrückte Block) ausgeführt. Wenn innerhalb der Funktion height verwendet wird, "sieht" der Code nur unsere neue frische Box mit der 100 drin. Sollte es im Programm andere Boxen mit dem gleichen Namen geben, sind sie für den Moment quasi "unsichtbar". Wenn die Funktion ausgeführt wurde (das Ende des eingrückten Blocks erreicht ist) wird unsere height-Box aufgeräumt, d.h. gelöscht. In der Zeile

rechteck(200)

passiert das gleich nochmal: Es wird eine frische height-Box angelegt, eine 200 hinterlegt und dann die gleiche Vorlage nochmal ausgeführt. An den Stellen wo height verwendet wird, wir jetzt die neue Box benutzt und es wird die 200 gefunden. D.h. es ist zwar die gleiche Vorlage, aber es kommt ein anderes Rechteck heraus, weil in der Box eine 200 statt einer 100 steckt.

Das alles gilt übrigens auch für width: Wenn die Vorlage abgearbeitet (ausgeführt) wird, wird in der Zeile

    width = height * 2

jeweils eine neue Box angelegt und der berechnete Wert (100 * 2 beim ersten Aufruf, 200 * 2 beim zweiten Aufruf) hinterlegt. Am Ende des Blocks wird die Box gelöscht. Solche Variablen (Boxen) nennt man "temporär", weil sie nur zeitweise (so lange die Funktion ausgeführt wird, d.h. innerhalb des eingrückten Blocks) existieren. Eine andere Bezeichnung ist "lokal". Damit meint man, dass sie nur innerhalb der Funktion (des eingrückten Blocks) existieren. Das Gegenstück zu "lokalen" Variablen sind "globale" Variablen, d.h. Variablen die immer und überall existieren.

In großen Programmen sind die Details, was wann wie und wo aufgeräumt wird, recht wichtig. Für den Moment reicht es, wenn du verstehst, dass bei jeder Benutzung einer Funktion kurzzeitig neue frische Boxen angelegt und dann wieder gelöscht werden.

Natürlich sind Funktionen nicht auf einen Parameter beschränkt. Du kannst mehrere haben, die dann durch Kommata getrennt werden. Wenn du z.B. Höhe und Breite angeben willst, könnte deine Funktion so aussehen:

def rechteck(height, width):
    forward(width)
    left(90)
    forward(height)
    left(90)
    forward(width)
    left(90)
    forward(height)

Oder falls du statt der Breite das Verhältnis angeben willst:

def rechteck(height, ratio):
    width = height * ratio
    #  ...

Keine der Optionen ist besser oder schlechter. Es kommt darauf an, was du machen willst. Im Prinzip geht es beim Programmieren sehr viel darum, Funktionen so zu strukturieren, dass man dem fleißigen aber nicht sehr schlauen Computer möglichst viel Arbeit auf's Auge drücken kann, ohne alles doppelt und dreifach erklären zu müssen. Du erinnerst dich: Gute Programmierer*innen sind faul und überlassen die langweilige Arbeit dem Computer.

Zwischenstand

Schön, dass du es bis hierhin geschafft hast! Das freut mich wirklich sehr, da ich den Text offensichtlich nicht umsonst geschrieben habe. ;-) Die größte Hürde beim Programmieren ist der Einstieg. Du hast jetzt schon eine Menge Handwerkszeug gelernt, das sich gleich wiederholen wird. D.h. ab hier sollten dir neue Sachen leichter fallen und gleichzeitig kannst du immer mehr Arbeit an den Computer abgeben. Dazu brauchen wir als nächstes Schleifen.

Schleifen

Wir starten nochmal mit diesem Beispiel von oben:

from turtle import *

def rechteck(height):
    width = height * 2

    forward(width)
    left(90)
    forward(height)
    left(90)
    forward(width)
    left(90)
    forward(height)

rechteck(100)
rechteck(150)

Das ist schon ganz ok, aber da stehen zwei Aufrufe von rechteck einmal mit 100 und einmal mit 150. Nicht weiter schlimm, aber was ist, wenn wir 10 oder 100 Rechtecke zeichnen wollen? Laß uns mit vier Rechtecken starten, die die Höhen 50, 100, 150 und 200 haben sollen. Z.B. so:

#    ...

rechteck(50)
rechteck(100)
rechteck(150)
rechteck(200)

Die Definition von rechteck lasse ich ab jetzt weg. Sie ist immer gleich und ändert sich nicht. Die Wiederholung von rechteck können wir vermeiden, in dem wir die vier Zahlen in eine Liste packen und dem Computer dann mitteilen, dass er für jedes Ding in der Liste etwas machen soll. Diese "Für jedes Ding tue etwas" nennt man eine "for-loop" (Loop = Schleife) und das sieht dann so aus:

#    ...
heights = [50, 100, 150, 200]

for h in heights:
    rechteck(h)

Das sieht auf den ersten Blick neuer aus, als es wirklich ist: Da steht eine Zuweisung. Neu ist nur die Liste auf der rechten Seite. Wenn du mehrere Werte hast, kannst du sie in eine Liste packen, was du Python mit den eckigen Klammern mitteilst. Die Liste wird dann in heights gespeichert (in die Box gepackt). Du kannst dir die Liste als eine Art Container oder Verpackung vorstellen. Aus Sicht von Python steckt in heights nur ein "Wert" (eher: Ding) in dem aber wiederum mehrere Zahlen verpackt sind.

Jetzt können wir für jedes Element in der Liste etwas tun:

for h in heights:

Diese Zeile sagt Python, dass es für jedes Element in heights etwas tun soll. Der Computer nimmt also zuerst die 50 aus der Liste, macht etwas damit, nimmt dann die 100, macht etwas damit, ... Aber was soll er tun? Wie auch bei der Funktion steht auch das im eingerückten Block. Kennst du also schon.

Auch das h funktioniert ziemlich ähnlich zu den Parametern einer Funktion. Es ist ja schön, dass Python die Werte nacheinander aus der Liste nimmt, aber wenn du sie in deinem Block verwenden willst, mußt du irgendwie an den jeweils aktuellen Wert dran kommen. Die Lösung ist - wenig überraschend - eine lokale Variable oder Box. Nochmal ganz ausführlich passiert also folgendes:

Die Schleife legt eine frische Variable (Box) h an, nimmt den ersten Wert aus der Liste in heights und packt den in h. In h ist jetzt also eine 50. Danach wird der eingrückte Block ausgeführt, der bei uns so aussieht:

    # ....
    rechteck(h)

Die Funktion (Vorlage) rechteck wird jetzt also benutzt, so als ob zwischen den Kammern die 50 stände. Die Funktion wir ausgeführt wie oben ausführlich beschrieben: Es gibt eine temporäre Box height in die die 50 gepackt wird, der Block der Funktion wird ausgeführt und am Ende wir aufgeräumt. Zurück in der Schleife schauen wir wie's weiter geht. Da unser Block in der Schleife nur eine Zeile lang ist, sind wir schon am Ende. Also auf zur nächsten Runde. Das nächste Element in der Liste ist die 100. Sie wird in die h-Box gepackt und das Spiel geht weiter. Nur dass jetzt 100 in h steht. Beim nächsten mal 150 und dann 200. Damit haben wir die Liste einmal abgeklappert, die Schleife ist fertig und der nächste - nicht mehr eingerückte Code - würde ausgeführt. In unserem Beispil steht da nichts mehr und somit ist das Programm fertig.

Ich hoffe, die ausführliche Beschreibung hat deutlich gemacht, dass der Computer ganz stupide seine Anweisungen befolgt. Mit diesem Wissen sollten dich auch verschachtelte Schleifen nicht mehr erschrecken können:

    aussen = [1, 2, 3]
    innen = ["a", "b"]

    for a in aussen:
        for i in innen:
            print(a,i)

Wir haben jetzt zwei Listen. Wir starten mit einer Schleife über aussen. Die Schleife benutzt die Variable (Box) a um den jeweiligen Wert zu hinterlegen. In der ersten Runde enthält a also die 1. Jetzt wird der eingrückte Block ausgeführt, d.h. dieser Teil:

        for i in innen:
            print(a,i)

Ich hoffe, meine ausführlichen Erklärungen werden langweilig und unnötig, aber zur Sicherheit: Der Computer macht stupide seine Arbeit. Er steckt zuerst "a" in die i-Box, führt die eingerückte Zeile aus, steckt dann "b" in die Box und führt die eingrückte Zeile nochmal aus. print ist eine Funktion, die einfach die Werte der Variablen ausgibt. Für die a-Box ändert sich ja nichts, daher wäre die Ausgabe:

1 a
1 b

Das war der erste Durchgang der äußeren Schleife. Sobald der innere Teil fertig ist, kommt der nächste Wert aus der aussen-Liste in die a-Box und alles wiederholt sich für die 2 und dann nochmal für die 3. Insgesamt sieht das Ergebnis also so aus:

1 a
1 b
2 a
2 b
3 a
3 b

Zum Abschluß noch ein Punkt, der am Anfang gerne für Verwirrung sorgt: In "echten" großen Programmen kommt es sehr, SEHR selten vor, dass man irgendetwas einfach fünf mal machen will. In der Regel will man immer etwas mit Elementen einer Liste machen, also eine for-Schleife wie oben benutzen. Daher gibt's in Python nur die for-Schleife und keinen Befehl für "mach es einfach 13 mal". Aber was tun, wenn man beim Spielen mit Turtle sowas doch mal braucht?

Der "Kunstgriff" ist ganz einfach und vermutlich wärst du auch selbst darauf gekommen: Du brauchst einfach nur eine Liste mit genug Elementen, benutzt diese in einer for-Schleife und ignorierst die Werte. Vermutlich hast du gerade keine passende Liste zur Hand und willst für 1001 Wiederholungen auch keine Liste mit 1001 Nullen (oder einem anderen beliebigen Wert) von Hand schreiben. Dafür gibt's die range- Funktion:

#   So würdest du es von Hand schreiben
meine_liste = [0,1,2,3,4]
#   So macht der Computer die Liste für dich, auch wenn
#   du 1001 oder 10001 oder .... Elemente brauchst.
meine_liste = range(5)

for _ in meine_liste:
    print("Programmieren ist toll! Schule nicht!")

Du mußt für die Vorschleife eine Variable angeben, auch wenn du sie eh ignorierst. Für solche Variablen verwendet man oft den Unterstrich, aber du hättest auch x oder trullala verwenden können.

Repeat-Schleifen

Ich hatte ganz oben erklärt, dass im Unterricht manchmal repeat-Schleifen gezeigt werden, repeat aber eigentlich gar kein Pythonbefehl ist. Ich hatte auch versprochen aufzuklären, was es damit auf sich hat und warum ich den Befehl für Unsinn halte.

Es ist dir bestimmt schon aufgefallen: Du hast die Erklärung schon gelesen. In Python gibt es aus gutem Grund keinen Befehl für "mache es 10 mal", da man in realen Problemen fast immer etwas für jedes Element einer Liste macht. Also eine for-Schleife verwendet. Hat man die for-Schleife aber erstmal verstanden, ist es ganz offensichtlich, dass man sie einfach so verwenden kann:

for _ in range(10):
    print("Programmieren ist toll! Schule nicht!")

In WebTiger kannst du statt dessen folgendes schreiben:

repeat 10:
    print("Programmieren ist toll! Schule nicht!")

Der einzige Grund warum man so etwas tun sollte, ist, dass man dir nicht zutraut die for-Schleife zu verstehen. Ziemlich anmaßend von deiner Lehrperson, oder? Noch schlimmer: Guido van Rossum ist eine Legende weil Python so klar und sauber strukturiert ist. Jemand der die Sprache, die zu Grunde liegenden Strukturen und ihre Eleganz auch nur ansatzweise verstanden hat, käme nie auf die Idee, daran herumfrickeln zu wollen. Schon gar nicht aus pseudo-pädagogischen Gründen.

Natürlich wirst du den Befehl verwenden müssen, wenn deine Lehrpeson das so will. Nach erfolgreicher Arbeit oder erfolgreichem Test solltest du ihn aber schnell wieder vergessen. Und dann richtig programmieren lernen.

Feedback

Soweit erstmal! Solltest du Fehler im Text finden, dir etwas unklar sein, du dir eine Fortsetung wünschen, ... schreib' mir einfach eine Mail. Natürlich freue ich mich auch einfach über eine positive Rückmeldung, falls dir die Erklärungen weitergeholfen haben.