2. Einführung in Python und erste Schleifen

Um mit einem Computer zu “sprechen”, brauchen wir eine Sprache, die er versteht: Eine Programmiersprache. Indem wir Programme schreiben, geben wir dem Computer klare Anweisungen, welche Aufgaben er erledigen soll. In diesem Skript nutzen wir die neueste Version der Programmiersprache Python.

Genau wie unsere menschlichen Sprachen haben Programmiersprachen Wörter mit einer festen Bedeutung. Wörter, die dem Computer sagen, was er tun soll, nennen wir Befehlswörter oder einfach Befehle.

Ein Programm ist im Grunde eine Reihe von Befehlen in einer Programmiersprache, die zusammen eine bestimmte Aufgabe lösen. Stellen Sie sich ein Programm als eine genaue Anleitung vor, die ein Computer Schritt für Schritt abarbeiten kann.

Das Hauptziel des Programmierens ist die Automatisierung von Abläufen. Wir übertragen die Ausführung einer Aufgabe komplett an den Computer. Deshalb muss ein Programm absolut eindeutig sein und genau beschreiben, was zu tun ist. Es darf keine Missverständnisse geben.

In diesem Kapitel schreiben Sie Ihre ersten eigenen Programme. Dabei lernen Sie das Konzept der Schleifen kennen. Schleifen sind unglaublich praktisch, denn sie ermöglichen es, wiederkehrende Aufgaben automatisch mehrfach auszuführen. Sie werden sehen, wie nützlich das in vielen Alltagssituationen ist!

Einige grundlegende Befehle und Operationen

`print`-Funktion und built-in Funktionen

In unserem Hello, World!-Programm (Abschnitt) haben wir bereits die Python-Funktion print(...) gesehen. Diese Funktion ermöglicht es uns, Dinge (genauer: Python-Objekte) auszugeben (“zu printen”) und dadurch für den User im Terminal sichtbar zu machen. Die print-Funktion ist eine built-in Funktion, das heisst, sie ist direkter Bestandteil der Python-Sprache und ist in Python standardmässig verfügbar.

Beispiel

Weitere Beispiele von Prints in Python:

Bemerkung

Unter dem Link

https://docs.python.org/3/library/functions.html#print

finden Sie eine Übersicht aller built-in Funktionen in Python. Wir empfehlen Ihnen für diesen Link ein Lesezeichen (Bookmark) in Ihrem Webbrowser zu erstellen. Einige dieser Funktionen werden wir im Folgenden gemeinsam kennenlernen.

Python-Kommentare

Kommentare in Python dienen dazu, Programmcode genauer zu beschreiben. Kommentare werden von Python vollständig ignoriert und dienen lediglich dem besseren Verständnis des (menschlichen) Lesers.

Beispiel

Dieses Beispiel zeigt die Funktionsweise von Zeilenkommentaren und Blockkommentaren.

Einfache Arithmetik

In Python lassen sich einfache Rechenoperationen ähnlich wie bei einem Taschenrechner angeben. Dabei hält sich Python an die gewohnten Konventionen wie zum Beispiel “Punkt vor Strich”. Symbole gängiger arithmetischer Operationen sind in Abschnitt zusammengefasst.

arithmetische Operationen in Python

mathematische Operation	In Python
Addition	`+`
Subtraktion	`-`
Multiplikation	`*`
Division	`/`
Potenzieren	`**`

Beispiel

Wir haben einige typische Rechenoperationen für Sie aufgeführt:

Erste Zeichnungen mit der Python-Turtle

Für den Einstieg in das Programmieren ist es didaktisch sinnvoll, mit der Python-Turtle zu starten. Genau dies werden wir hier tun! Wir werden der Turtle Instruktionen erteilen, damit sie für uns bestimmte Bilder und geometrische Formen zeichnet. Der didaktische Vorteil des Arbeitens mit der Turtle liegt in dem grafischen Output. Dieser lässt Sie (meist) sofort selber erkennen, was Ihr Programm macht und auch potenzielle Fehler lassen sich in der Regel recht einfach auffinden.

Um mit der Turtle arbeiten zu können, müssen Sie das turtle-Modul durch den Befehl import turtle zu Beginn des Programms (ganz oben) importieren. Ein Modul ist eine “Erweiterung” von Python, so dass wir zusätzlich zu den built-in functions auch die Befehle des Moduls verwenden können.

Mit dem Ausdruck import turtle as t sagen wir, dass wir das Modul turtle in unser Programm importieren und dieses Modul innerhalb des Programms mit dem Ausdruck t benennen werden (wir könnten auch import turtle as bliblablup schreiben, dies wäre jedoch wohl weniger praktisch).

Abschnitt lässt die Turtle einen Strich mit einer Länge von \(140\) zeichnen. Abschnitt zeichnet ein gleichseitiges Dreieck mit Seitenlänge \(100\).

# File: strich.py
import turtle as t

# Tempo der Turtle festlegen
t.speed(1)

# gerade Linie / Strich zeichnen
t.forward(140)

# Turtle-Zeichnung stehen lassen
t.done()

Note

💡 Hinweis: Dieses Skript verwendet grafische Desktop-Bibliotheken (turtle / pygame). Führen Sie diesen Code in Ihrer lokalen Entwicklungsumgebung (z.B. VS Code) aus.

# File: dreieck.py
import turtle as t

# Tempo der Turtle festlegen
t.speed(1)

# gleichseitiges Dreieck zeichnen
t.forward(100)
t.left(120)
t.forward(100)
t.left(120)
t.forward(100)
t.left(120)

# Turtle-Zeichnung stehen lassen
t.done()

Note

💡 Hinweis: Dieses Skript verwendet grafische Desktop-Bibliotheken (turtle / pygame). Führen Sie diesen Code in Ihrer lokalen Entwicklungsumgebung (z.B. VS Code) aus.

Bemerkung

Unter dem Link

https://docs.python.org/3/library/turtle.html#module-turtle

finden Sie eine Übersicht aller Turtle-Funktionen. Wir empfehlen Ihnen für diesen Link ein Lesezeichen (Bookmark) in Ihrem Webbrowser zu erstellen. Einige dieser Funktionen werden wir im Folgenden gemeinsam kennenlernen.

Aufgabe

Vervollständigen Sie die gegebene Vorlage, um ein Haus ähnlich dem in Abschnitt mithilfe der Turtle zu zeichnen.

Die Längen dürfen Sie selber bestimmen.
Das Schrägdach soll in roter Farbe gezeichnet werden und muss ein gleichschenkliges und rechtwinkliges Dreieck sein.
Das Programm soll die Länge der Kathete dieses rechtwinkligen Dreieckes mit einem Print ausgeben.

# File: haus_vorlage.py
import math
import turtle as t

# Tempo der Turtle festlegen
t.speed(1)

# Mauern
...
...
...

# Dach (rechtwinkliges Dreieck)
t.pencolor("red")  # setzte die Stiftfarbe auf rot
...
...
...

# Turtle verstecken (damit sie nicht das Haus verdeckt)
t.hideturtle()

# Turtle-Zeichnung stehen lassen
t.done()

Note

💡 Hinweis: Dieses Skript verwendet grafische Desktop-Bibliotheken (turtle / pygame). Führen Sie diesen Code in Ihrer lokalen Entwicklungsumgebung (z.B. VS Code) aus.

💡 Musterlösung anzeigen

# File: haus.py
import math
import turtle as t

# Tempo der Turtle festlegen
t.speed(1)

# Mauern
t.fd(100)
t.lt(90)
t.fd(100)
t.lt(90)
t.fd(100)
t.lt(90)
t.fd(100)
t.lt(180)
t.fd(100)

# Dach (rechtwinkliges Dreieck)
t.pencolor("red")  # setze die Stiftfarbe auf rot
t.rt(45)
t.fd(100 / math.sqrt(2))
t.rt(90)
t.fd(100 / math.sqrt(2))
print("Länge der Kathete:", 100 / math.sqrt(2))

# Turtle verstecken (damit sie nicht das Haus verdeckt)
t.hideturtle()

# Turtle-Zeichnung stehen lassen
t.done()

Note

💡 Hinweis: Dieses Skript verwendet grafische Desktop-Bibliotheken (turtle / pygame). Führen Sie diesen Code in Ihrer lokalen Entwicklungsumgebung (z.B. VS Code) aus.

Aufgabe

Schreiben Sie ein Programm um einen Dreizack möglichst ähnlich dem in Abschnitt mithilfe der Turtle zu zeichnen.

Tipp: Durchsuchen Sie die Turtle-Dokumentation (siehe Abschnitt) um zu lernen, wie die Stiftbreite und Stiftfarbe (hier: ) angepasst werden können.

💡 Musterlösung anzeigen

Diese Musterlösung finden Sie in Abschnitt.

Schleifen

Schleifen (Englisch: loops) ermöglichen uns, Prozesse zu wiederholen.

Beispiel

In Abschnitt ist eine Treppe gezeigt. Wie können wir diese Treppe mithilfe der Turtle zeichnen? Mit unserem bisherigen Wissen wäre dies sehr mühsam:

import turtle as t

t.lt(90)

# diese 4 Zeilen müssen wir 14 weitere Male Kopieren,
# um insgesamt 15 Stufen zu erhalten
t.fd(15)
t.lt(90)
t.fd(25)
t.rt(90)

t.hideturtle()
t.done()

Note

💡 Hinweis: Dieses Skript verwendet grafische Desktop-Bibliotheken (turtle / pygame). Führen Sie diesen Code in Ihrer lokalen Entwicklungsumgebung (z.B. VS Code) aus.

Stellen Sie sich vor, Sie müssten eine Treppe mit \(10000\) Stufen zeichnen 🧐.

Abschnitt zeigt auf, dass wir eine praktikable Methode zum häufigen Wiederholen von Mustern oder Prozessen benötigen. In Python lassen sich Wiederholungen mit Schleifen realisieren. Die Treppe aus Abschnitt lässt sich mit einer sogenannten for-Schleife ganz einfach wie in Abschnitt realisieren.

# File: treppe.py
import turtle as t

t.lt(90)
for _ in range(6):
    t.fd(15)
    t.lt(90)
    t.fd(25)
    t.rt(90)

t.hideturtle()
t.done()

Note

💡 Hinweis: Dieses Skript verwendet grafische Desktop-Bibliotheken (turtle / pygame). Führen Sie diesen Code in Ihrer lokalen Entwicklungsumgebung (z.B. VS Code) aus.

Dabei wird folgender Ausdruck:

for _ in range(15):

der Schleifenkopf der Schleife genannt. Die vier Zeilen (6 – 9) werden Schleifenkörper der Schleife genannt, wie im unten stehenden Code zu sehen ist.

Der Schleifenkörper ist (in Python) daran erkennbar, dass er (relativ zu dem Schleifenkopf) nach rechts eingerückt (Englisch: indented) ist. Diese Einrückung erreichen wir in VS Code durch das einfache Drücken der Tabulator-Taste (). Wir können Code auch wieder um einen Tab nach links rücken, indem wir den entsprechenden Code zuerst selektieren (einfärben) und danach die Shift-Taste sowie die Tabulator-Taste gleichzeitig drücken (). In anderen Programmen als VS Code kann es sein, dass die Tastaturkombination dafür eine andere ist.

Aufgabe

In Abschnitt wird gezeigt, wie ein Kreis schrittweise durch regelmässige Polygone¹(https://de.wikipedia.org/wiki/Regelm%C3%A4%C3%9Figes_Polygon]) approximiert (angenähert) wird.

Lassen Sie die Turtle in demselben Bild ein regelmässiges 5-Eck, ein regelmässiges 6-Eck sowie ein regelmässiges 8-Eck zeichnen.
Die Orientierungen und Grössen der Figuren spielen dabei keine Rolle.
Die Figuren sollen sich nicht überschneiden.
Sie wollen die Turtle bewegen, ohne dabei zu zeichen? Schauen Sie sich die Funktionen t.penup() und t.pendown() in der turtle-Dokumentation an (suchen Sie nach diesen Befehlen mit dem Shortcut (Windows) oder (MacOS)).

💡 Musterlösung anzeigen

# File: regelmaessige_polygone.py
import turtle as t

# 5-Eck
for _ in range(5):
    t.fd(50)
    t.right(360 / 5)

# verschieben ohne zu zeichnen
t.up()
t.fd(120)
t.down()

# 6-Eck
for _ in range(6):
    t.fd(50)
    t.right(360 / 6)

# verschieben ohne zu zeichnen
t.up()
t.fd(120)
t.down()

# 8-Eck
for _ in range(8):
    t.fd(50)
    t.right(360 / 8)

t.done()

Note

💡 Hinweis: Dieses Skript verwendet grafische Desktop-Bibliotheken (turtle / pygame). Führen Sie diesen Code in Ihrer lokalen Entwicklungsumgebung (z.B. VS Code) aus.

geschachtelte Schleifen

In der Praxis verwenden wir oft Schleifen innerhalb von Schleifen. Solche Schleifen nennt man geschachtelte Schleifen.

Beispiel

In diesem Beispiel zeichnen wir, mithilfe geschachtelter Schleifen, drei nebeneinander liegende Quadrate:

# File: quadrate.py
import turtle

# Die aeussere Schleife bestimmt, wie viele Quadrate (3) gezeichnet werden
for _ in range(3):

    # Die innere Schleife zeichnet die 4 Seiten eines Quadrats
    for _ in range(4):
        turtle.forward(50)
        turtle.left(90)

    # Nach jedem Quadrat: Stift hoch und zum Startpunkt des naechsten Quadrats
    turtle.penup()
    turtle.forward(70)
    turtle.pendown()

turtle.done()

Note

💡 Hinweis: Dieses Skript verwendet grafische Desktop-Bibliotheken (turtle / pygame). Führen Sie diesen Code in Ihrer lokalen Entwicklungsumgebung (z.B. VS Code) aus.

Aufgabe

Zeichnen Sie die folgende Blume mit der Turtle. Tipp: Es handelt sich dabei um \(10\) Quadrate, die jeweils um \(36\) Grad gedreht sind.

💡 Musterlösung anzeigen

# File: blume.py
import turtle as t

for _ in range(10):
    # zeichne ein Quadrat
    for _ in range(4):
        t.fd(100)
        t.rt(360 / 4)
    # Rechtsdrehung um 36 Grad
    t.rt(360 / 10)

# Turtle-Zeichnung nicht schliessen
t.done()

Note

💡 Hinweis: Dieses Skript verwendet grafische Desktop-Bibliotheken (turtle / pygame). Führen Sie diesen Code in Ihrer lokalen Entwicklungsumgebung (z.B. VS Code) aus.

Weitere Aufgaben

Aufgabe

Zeichnen Sie die quadratische Schweizer Flagge (Tipp: zuerst ohne Farben, danach farbig). Um eine Form auszufüllen, schauen Sie sich die Funktionen t.fillcolor(), t.begin_fill() und t.end_fill() in der turtle-Dokumentation an. Suchen Sie nach dem Begriff "fill” mit dem Shortcut (Windows) oder (MacOS).
Zeichnen Sie die Flagge des Kantons Zürich (quadratisch):

\ Farbe “Züri-Blau”: (0 / 255, 112 / 255, 180 / 255)

Zeichnen Sie eine horizontal dreigeteilte, rechteckige Flagge (wie etwa die Flagge Frankreichs oder Italiens ).

💡 Musterlösung anzeigen

Diese Musterlösung finden Sie in Abschnitt.

turtle-Befehle

Kurzform	Langform	Beschreibung
`t.fd(x)`	`t.forward(x)`	bewegt die Turtle um `x` Schritte vorwärts
`t.bk(x)`	`t.backward(x)`	bewegt die Turtle um `x` Schritte rückwärts
`t.rt(x)`	`t.right(x)`	dreht die Turtle um `x` Grad nach rechts
`t.lt(x)`	`t.left(x)`	dreht die Turtle um `x` Grad nach links
`t.color(c)`	`t.color(c)`	setzt die Zeichenfarbe auf `c` (z.,B. `"red"`)
`t.begin_fill()`	`t.begin_fill()`	Start des Füllbereichs
`t.end_fill()`	`t.end_fill()`	Ende des Füllbereichs (füllt Fläche)
`t.fillcolor(c)`	`t.fillcolor(c)`	setzt die Füllfarbe auf `c` (z.,B. `"red"`)
`t.pu()`	`t.penup()`	hebt den Stift (es wird nicht mehr gezeichnet)
`t.pd()`	`t.pendown()`	senkt den Stift (es wird wieder gezeichnet)
`t.ht()`	`t.hideturtle()`	versteckt die Turtle
`t.st()`	`t.showturtle()`	zeigt die Turtle
`t.speed(x)`	`t.speed(x)`	Geschwindigkeit setzen (`0` = schnellste)
`t.goto(x, y)`	`t.goto(x, y)`	bewegt die Turtle zu den Koordinaten `(x, y)`
`t.circle(r)`	`t.circle(r)`	zeichnet einen Kreis mit Radius `r`
`t.tracer(False)`	`t.tracer(False)`	zeigt direkt das Resultat (ohne Animation)²
`t.teleport(x, y)`	`t.teleport(x, y)`	teleportiert die Turtle zu `(x, y)`

Längere Lösungen

💡 Musterlösung anzeigen

[myexercise:dreizack]

# File: dreizack.py
import turtle as t

t.speed(4)
t.width(5)
t.pencolor("gold")

t.left(90)
t.forward(200)
t.left(90)
t.forward(40)
t.right(90)

t.forward(80)
t.right(145)
t.forward(10)
t.back(10)
t.right(70)
t.forward(10)
t.back(10)
t.right(145)
t.back(80)

t.right(90)
t.forward(40)
t.left(90)

t.forward(80)
t.right(145)
t.forward(10)
t.back(10)
t.right(70)
t.forward(10)
t.back(10)
t.right(145)
t.back(80)

t.right(90)
t.forward(40)
t.left(90)

t.forward(80)
t.right(145)
t.forward(10)
t.back(10)
t.right(70)
t.forward(10)
t.back(10)
t.right(145)

# Turtle verstecken (damit sie nicht das Haus verdeckt)
t.hideturtle()

# Turtle-Zeichnung stehen lassen
t.done()

Note

💡 Hinweis: Dieses Skript verwendet grafische Desktop-Bibliotheken (turtle / pygame). Führen Sie diesen Code in Ihrer lokalen Entwicklungsumgebung (z.B. VS Code) aus.

💡 Musterlösung anzeigen

[myexercise:Flaggen]

# File: schweizer_kreuz.py
"""
Aus Wikipedia:

Für das Schweizerkreuz gilt
Das Verhältnis von Breite und Länge beträgt
bei den Kreuzarmen 6 zu 7 und
bei den ganzen Kreuzbalken 6 zu 20.

Der Abstand zwischen Kreuz und Fahnenrand
beträgt auf jeder Seite eine Balkenbreite.

Das Verhältnis der Länge der Kreuzbalken
zur gesamten Seitenlänge der Fahne
beträgt somit 5 zu 8.
"""

import turtle as t

t.speed(10)
t.teleport(-160, -160)
t.penup()

# Rotes Quadrat
t.fillcolor("red")
t.begin_fill()
for _ in range(4):
    t.forward(320)
    t.left(90)
t.end_fill()

# turtle verschieben
t.forward(130)
t.left(90)
t.forward(60)

# weisses Kreuz
t.fillcolor("white")
t.begin_fill()
for _ in range(4):
    t.forward(70)
    t.left(90)
    t.forward(70)
    t.right(90)
    t.forward(60)
    t.right(90)
t.end_fill()

t.done()

Note

💡 Hinweis: Dieses Skript verwendet grafische Desktop-Bibliotheken (turtle / pygame). Führen Sie diesen Code in Ihrer lokalen Entwicklungsumgebung (z.B. VS Code) aus.

# File: zueri_flagge.py
import math
import turtle as t

# blauer Teil
t.fillcolor((0, 112 / 255, 180 / 255))
t.begin_fill()
# Stift einstellen

t.fd(100)
t.rt(135)
t.fd(math.sqrt(2 * 100**2))
t.rt(135)
t.fd(100)
t.end_fill()

# weisser Teil
for _ in range(3):
    t.bk(100)
    t.lt(90)

# Fertig
t.done()

Note

💡 Hinweis: Dieses Skript verwendet grafische Desktop-Bibliotheken (turtle / pygame). Führen Sie diesen Code in Ihrer lokalen Entwicklungsumgebung (z.B. VS Code) aus.

# File: flagge_dreiteil.py
import turtle as t

t.speed(10)
t.penup()

# Farben von Italien gemäss Wikipedia
t.fillcolor(0, 140 / 255, 69 / 255)

t.begin_fill()
for _ in range(2):
    t.forward(100)
    t.left(90)
    t.forward(200)
    t.left(90)
t.end_fill()

t.forward(100)

t.fillcolor(244 / 255, 245 / 255, 240 / 255)

t.begin_fill()
for _ in range(2):
    t.forward(100)
    t.left(90)
    t.forward(200)
    t.left(90)
t.end_fill()

t.forward(100)

t.fillcolor(205 / 255, 33 / 255, 42 / 255)

t.begin_fill()
for _ in range(2):
    t.forward(100)
    t.left(90)
    t.forward(200)
    t.left(90)
t.end_fill()

t.done()

Note

💡 Hinweis: Dieses Skript verwendet grafische Desktop-Bibliotheken (turtle / pygame). Führen Sie diesen Code in Ihrer lokalen Entwicklungsumgebung (z.B. VS Code) aus.

}

Footnotes

[https://de.wikipedia.org/wiki/Regelm%C3%A4%C3%9Figes_Polygon]↩︎
Funktioniert nicht in allen Programmier-Umgebungen↩︎

Einige grundlegende Befehle und Operationen

print-Funktion und built-in Funktionen

Python-Kommentare

Einfache Arithmetik

Erste Zeichnungen mit der Python-Turtle

Schleifen

geschachtelte Schleifen

Weitere Aufgaben

Längere Lösungen

Footnotes

`print`-Funktion und built-in Funktionen