Informatik M25d
🔸

Um den Ablauf eines Programmes zu steuern stehen uns verschieden Strukturen zur verfügung.

Sequenz

Die einfachste Struktur eines Programms: für einen Block auf der selben Ebenen (gleich weit eingerückt), führt Python die Befehle Zeile-um-Zeile von oben nach unten aus.

from turtle import *

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

done()
1
2
3
4
5
6
7

Aufgabe: aufgabe1.py

Zeichne eine Treppe bestehend aus 5 Stufen

Lösung: aufgabe1.py
from turtle import *

left(90)

forward(30)
right(90)
forward(40)
left(90)

forward(30)
right(90)
forward(40)
left(90)

forward(30)
right(90)
forward(40)
left(90)

forward(30)
right(90)
forward(40)
left(90)

forward(30)
right(90)
forward(40)
left(90)

done()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

Unterprogramm

Dinge die häufig oder immer wieder – auch an unterschiedlichen Stellen aufgerufen werden, können in ein Unterprogramm ausgelagert werden. So muss man nicht mehrmals denselben Code schreiben!

from turtle import *

def stufe():
    forward(100)
    left(90)
    forward(100)
    right(90)

stufe()
stufe()
stufe()
forward(100)
done()
1
2
3
4
5
6
7
8
9
10
11
12
13

Aufgabe: aufgabe2.py

Schreibe für jeden deiner Initialen ein Unterprogramm welches diesen zeichnet. Rufe dann die beiden Unterprogramme auf, so dass die Turtle deine Initialen auf den Bildschirm zeichnet.

Lösung: aufgabe2.py
from turtle import *

def s():
    x = xcor()
    y = ycor()
    circle(50, -30)
    circle(50, 200)
    circle(-50, 180)
    penup()
    goto(x,y)
    setheading(0)    
    forward(100)
    pendown()
    
def f():
    x = xcor()
    y = ycor()    
    left(90)
    forward(100)
    right(90)
    forward(40)
    backward(40)
    left(90)
    forward(100)
    right(90)
    forward(80)
    penup()
    goto(x,y)
    setheading(0)    
    forward(100)
    pendown()
    
s()
f()

done()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

Argumente

Unterprogramme können sogenannte Argumente entgegennehmen. Möchten wir z.B. ein Unterprogramm schreiben, das die Distanz der Turtle zu einem bestimmten Punkt berechnet, so müssen wir die Koordinaten dieses Punktes kennen. Wir übergeben diese
Werte dem Unterprogramm als Argumente:

from turtle import *
from math import sqrt

def distanz(x,y):
    delta_x = xcor() - x
    delta_y = ycor() - y
    resultat = sqrt(delta_x**2 + delta_y**2)
    print(resultat)

distanz(100, 200)
forward(100)
distanz(100, 200)

done()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
Zeile 4
Die Definition des Unterprogramms legt fest, dass zwei Argumente übergeben werden müssen. Diese stehen im Unterprogramm als x und y zur Verfügung.
Zeile 5 & 6
Wir könne die beiden Argumente wie Variablen verwenden um etwas zu berechnen
Zeile 10
Wir rufen unser Unterprogramm auf und übergeben als Argumente x den Wert 100 und als Argument y den Wert 200
Zeile 11
Wir bewegen die Turtle
Zeile 12
Wir rufen unser Unterprogramm nochmals mit den selben Argumenten auf

Aufgabe: aufgabe3.py

Programmiere ein Unterprogramm dreieck(s). Dieses soll ein gleichseitiges Dreieck mit der Seitenlänge s zeichnen. Rufe dein Unterprogramm mehrere Male mit unterschiedlichen Seitenlängen auf.

Lösung: aufgabe3.py
from turtle import *

def dreieck(s):
    forward(s)
    left(120)
    forward(s)
    left(120)
    forward(s)
    left(120)    

dreieck(400)
left(70)
dreieck(200)
left(70)
dreieck(100)
left(70)
dreieck(50)
left(70)
dreieck(25)

done()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

Rückgabewerte

Oft möchte man den berechneten Wert des Unterprogramms weiterverwenden und nicht einfach ausgeben. Unterprogramme können mit dem Schlüsselwort return einen Wert zurückgeben. return ist die letzte Anweisung – das Unterprogramm wird damit abgebrochen!

Das obige Beispiel mit Rückgabewert sieht wie folgt aus:

from turtle import *
from math import sqrt

def distanz(x,y):
    delta_x = xcor() - x
    delta_y = ycor() - y
    resultat = sqrt(delta_x**2 + delta_y**2)
    return resultat

d1 = distanz(100, 200)
forward(100)
d2 = distanz(100, 200)
print(d1 - d2, "näher am Ziel")

done()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Zeile 8
Statt das berechnete Resultat auszugeben wird es zurückgegeben!
Zeile 10
Das Unterprogramm wird aufgerufen und der Rückgabewert in der Variablen d1 abgespeichert
Zeile 11
Wir bewegen die Turtle
Zeile 10
Das Unterprogramm wird nochmals aufgerufen, der Rückgabewert in der Variablen d2 abgespeichert
Zeile 13
Wir können nun die beiden Werte verwenden und z.B. berechnen wie viel näher die Turtle dem Punkt (100,200) gekommen ist.

Aufgabe: aufgabe4.py

Teste das obenstehende Programm aus und versuche zu verstehen was es macht.

Wiederholung

Wenn wir etwas mehrmals machen wollen, so verwenden wir beim Programmieren eine sogenannte «Schleife». Python kennt zwei dieser Schleifen:

while

Die while-Schleife wiederholt solange wie eine Bedingung wahr ist. Die Bedingung wird vor jeder Wiederholung erneut geprüft.

from turtle import *

speed(0)
i = 0
while i < 12:
    forward(180)
    left(150)
    i = i + 1

done()
1
2
3
4
5
6
7
8
9
10

Aufgabe: aufgabe5.py

Zeichne eine Spirale (von innen nach aussen oder von aussen nach innen)

Lösung: aufgabe5.py
from turtle import *

speed(0)
i = 0
while i < 500:
    forward(5)
    left(i/30)
    i = i + 1

done()
1
2
3
4
5
6
7
8
9
10

for-in

Hinweis

Die zweite Art von Schleifen werden wir später im Zusammenhang mit Listen anschauen

👉 Listen

Entscheidung

Bedingte Ausführung von Code erreicht man, indem man eine Bedingung überprüft. Python kennt if, if-else und if-elif-else

if

Einen Code-Block nur ausführen, wenn eine Bedingung wahr ist

Wenn-dann

from turtle import *

speed(0)
while True:
    if distance(40,30) > 400:
        goto(0,0)
    forward(8)
    left(2)

done()
1
2
3
4
5
6
7
8
9
10

Aufgabe: aufgabe6.py

Versuche eine Blume zu zeichnen, gehe dabei wie folgt vor:

  • nimm das obenstehende Beispiel als Ausgangsprogramm
  • fülle die Blätter mit einer Farbe

Zusatz:

  • Zeichne die Blätter natürlicher, indem du nicht einfach immer gleich viel drehst, sondern mit Zufallszahlen arbeitest
from random import randint
...
left(randint(-2,4)) # Ganze Zahl zufällig zwischen -2 und 4
1
2
3
  • Variiere die Farben, indem du die Farbe mit einer Variablen berechnest und diese in der Schleife änderst
green = 1
...
green = green-0.01
fillcolor((0,green,0))
1
2
3
4
Lösung: aufgabe6.py
from turtle import *
from random import randint

bgcolor("black")
speed(0)
hideturtle()
begin_fill()
green = 1
fillcolor((0,1-green,0))
while True:
    if distance(40,30) > 400:
        end_fill()
        goto(0,0)
        fillcolor((0,1-green,0))
        green = green*0.99 
        begin_fill()        
    forward(12)
    left(randint(-2,4))

done()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

if-else

Einen Code-Block nur ausführen, wenn eine Bedingung wahr ist, sonst einen anderen Code-Block ausführen

Wenn-dann, Sonst

from turtle import *

groesse = 20

def quadrat():
    i = 0
    while i<4:
        forward(groesse)
        left(90)
        i = i+1

x = 0
while x < 8:
    y = 0
    while y < 8:
        schwarz = (x+y) % 2
        if schwarz == 0:
            begin_fill()
            quadrat()
            end_fill()
        else:
            quadrat()
        forward(groesse)
        y = y+1
    x = x+1
    penup()
    goto(0,0)
    left(90)    
    forward(groesse*x)
    right(90)
    pendown()
    
hideturtle()  
done()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

Aufgabe: aufgabe7.py

Verwende das Schachbrett-Beispiel als Vorlage:

  • baue zu Beginn eine Hintergrundfarbe ein, z.B.
bgcolor("orange")
1

Damit es nun immer noch ein Schachbrett (weiss/schwarz) zeichnet, müssen wir im if Anpassungen vornehmen:

  • Jedes Quadrat soll gefüllt werden (nicht nur jedes Zweite)
  • Dafür setzen wir die Füllfarbe abwechslungsweise bei jedem Quadrat
fillcolor("white")
...
fillcolor("black")
1
2
3
Lösung: aufgabe7.py
from turtle import *

groesse = 20
bgcolor("orange")

def quadrat():
    i = 0
    while i<4:
        forward(groesse)
        left(90)
        i = i+1

x = 0
while x < 8:
    y = 0
    while y < 8:
        schwarz = (x+y) % 2
        if schwarz == 0:
            fillcolor("black")
        else:
            fillcolor("white")
        begin_fill()
        quadrat()
        end_fill()
        forward(groesse)
        y = y+1
    x = x+1
    penup()
    goto(0,0)
    left(90)    
    forward(groesse*x)
    right(90)
    pendown()
    
hideturtle()  
done()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

if-elif-else

Mehrere Bedingungen nacheinander checken, also

Wenn-dann, Sonst-wenn-dann, Sonst


if x < 12:
	# if-Block
elif x > 10:
	# elif-Block
else:
	# else-Block
1
2
3
4
5
6
7
8

Es sind beliebig viele elif-Blöcke denkbar. Der else-Block am Schluss ist optional.

Aufgabe: aufgabe8.py

Nimm das Schachbrett-Programm und baue eine dritte Farbe ein, so dass zwischen drei Farben hin- und her gewechselt wird.

Lösung: aufgabe8.py
from turtle import *

groesse = 20

def quadrat():
    i = 0
    while i<4:
        forward(groesse)
        left(90)
        i = i+1

x = 0
while x < 8:
    y = 0
    while y < 8:
        if (x+y) % 3 == 0:
            fillcolor("black")
        elif (x+y) % 3 == 1:
            fillcolor("grey")
        else:
            fillcolor("white")
        begin_fill()
        quadrat()
        end_fill()
        forward(groesse)
        y = y+1
    x = x+1
    penup()
    goto(0,0)
    left(90)    
    forward(groesse*x)
    right(90)
    pendown()
    
hideturtle()  
done()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

rekursiv (Zusatz)

Beim rekursiven Programmieren ruft ein Unterprogramm sich selbst auf.

👉 Kochkurve (extern)