Der Programmaufbau in Python ist immer gleich.

1. Includes
2. Definitionen
3. Hauptprogramm

Kommentare werden mit einem # versehen.

prog_1.py

#1.Includes
from gpanel import *
#2. Definitionen
def quadrat(x):
   return(x*x)
#3.Hauptprogramm
x=4
print(quadrat(x))

Aufgabe 1

1. Was macht dieses Programm? Bist du nicht sicher, so lade es herunter und teste es in der Lernumgebung Tigerjython aus.
2. Brauchen wir den Include?

Wir wechseln vom GPanel zur Turtle Graphik. Das nachfolgende Programm zeichnet ein gleichseitiges Dreieck. Dabei wird der Vorgang “marschiere 100 Pixel nach vorne und drehe dich dann um 120° nach rechts” dreimal wiederholt.

prog_2.py

from gturtle import *
makeTurtle()
forward(100)
right(120)
forward(100)
right(120)
forward(100)
right(120)
delay(500)
hideTurtle()

Anstelle dieses Spaghetti Codes verwenden wir eine Schleife. Da wir die Anzahl an Wiederholungen kennen, verwenden wir die for-Schleife.

for variable in range(Bereich):
    # hier steht der zu 
    # wiederholende Code

Damit wir der Code lesebarer und kompakter. Achtung, in Python gibt es kein “Begin - End” und / oder Klammern “{ }”, die den Anfang und das Ende einer Schleife anzeigen. Der zu wiederholende Code muss eingerückt werden. Wichtig: Nach range() steht ein Doppelpunkt!

Prog_3.py

from gturtle import *
makeTurtle()
for i in range(3):
    forward(100)
    right(120)
delay(500)
hideTurtle()

Die Anweisung in range(3) erzeugt eine Liste der Länge 3, beginnend bei Null, mit Abstand eins. $[0,1,2]$ Die Variable $i$ hat im ersten Durchlauf den Wert $0$, im zweiten Durchlauf den Wert $1$ usw. D.h. wir können innerhalb der Schleife auf die Zählvariable $i$ zugreifen und die aktuelle Durchlaufzahl benutzen.

Aufgabe 2

1. Was macht das nachfolgende Programm? Falls du dir nicht sicher bist, teste es aus!
2. Ändere das Programm so ab, dass eine Quadratschnecke mit mindestens drei Umdrehungen entsteht.

Prog_4.py

from gturtle import *
makeTurtle()
for i in range(9):
    forward(80*(i+1))
    right(120)
delay(500)
hideTurtle()

Kennt man die Anzahl der Wiederholungen nicht, dann verwendet wir die while-Schleife.

while wahre Aussage:
    # hier steht der zu 
    # wiederholende Code

Solange die Aussage wahr ist, wird die Schleife durchlaufen.

Prog_5.py

from gturtle import *
makeTurtle()
l=100
while l<600:
    forward(l)
    right(120)
    l=l+50
delay(500)
hideTurtle()

Aufgabe 3

1. Was macht das obige Programm? Falls du dir nicht sicher bist, teste es aus!

Willst du nur das fertige Bild sehen, so schreibe den Befehl hideTurtle() direkt nach makeTurtle(). delay(time in ms) kannst du auch weglassen.

Eine Verzweigung des Typs wenn-dann-sonst wird mit der Struktur

if wahre Aussage:
   # dann wird der Code
   # hier ausgeführt
else:
   # sonst wird der Code 
   # hier ausgeführt

realisiert. In Python gibt es dann auch noch die Version mit zwei wenn-dann hintereinander, im Sinne von wenn-dann-sonstwenn-dann-sonst.

if wahre Aussage 1:
   # dann wird der Code
   # hier ausgeführt
elif wahre Aussage 2:
   # dann wird der Code 
   # hier ausgeführt
else:
   # sonst wird der Code
   # hier ausgeführt

Prog_6.py

from gturtle import *
makeTurtle()
hideTurtle()
l=100
while l<600:
    if l<300:
        setPenColor("blue")
    else:
        setPenColor("red")        
    forward(l)
    right(120)
    l=l+50

Aufgabe 4

1. Erweitere das obige Programm so, dass die Linienfarbe für l kleiner 200 blau, ab 200 bis 400 grün und alles ab 400 rot gesetzt wird.

Hier das Programm von letzter Woche.

Prog_7.py

from gpanel import *
 
xmin=-2
xmax=1
ymin=-1.5
ymax=1.5
dstep=0.003
maxZ=2
maxIt=50
 
 
makeGPanel(xmin,xmax,ymin,ymax)
x=xmin
while x<xmax:
    y=ymin
    while y<ymax:
        z=0
        n=0
        c=complex(x,y)
        while n<maxIt and abs(z)<maxZ:
            z=z**2+c
            n=n+1
        if n==maxIt:
            setColor("yellow")
        else:
            setColor("blue")
        point(x,y)
        y=y+dstep
    x=x+dstep

• Achtung: a=b ist eine Zuweisung, a==b ist ein Vergleich auf Gleichheit, das Ergebnis ist dann ja für gleich und nein für nicht gleich.
• Aussagen können mit einem and oder or verknüpft werden. Bein einer UND Verknüpfung ist die ganze Aussage genau dann wahr, wenn alle Teilaussagen war sind. Bei einer ODER Verknüpfung ist die ganze Aussage genau dann wahr, wenn mindestens eine Aussage wahr ist.

Aufgabe 5

1. Verändere das obige Programm so, dass der Bildaufbau vertikal von unten nach oben und nicht mehr horizontal von links nach rechts verläuft.
2. Ergänze das Programm so, dass der Divergenz Bereich in Abhängigkeit der Anzahl Durchläufe $n$ eingefärbt wird. Schreibe dazu eine Unterprogramm mit dem Namen setItColor(n).

Unabhängig von der obigen Aufgabenstellung wollen wir drei von Unterprogrammen anschauen.

1. Unterprogramme ohne Parameterübergabe, wurde früher Prozedur genannt
2. Unterprogramme mit Parameterübergabe, wird i.d.R. Funktion genannt
3. Unterprogramm mit Parameterübergabe und Rückgabewert, wird i.d.R. auch Funktion genannt

from gturtle import *
def dreieck():
    for i in range(3):
        forward(100)
        left(120)
 
makeTurtle()
dreieck()
setPos(100,50)
dreieck()

Das Schlüsselwort ist def, gefolgt vom Namen() des Unterprogramms. Achtung den Doppelpunkt nicht vergessen. Das eigentliche Unterprogramm folgt dann eingerückt. Das Unterprogramm kann nun von einer beliebigen Stelle im Hauptprogramm aufgerufen werden.

Schöner wäre es aber, wenn die Seitenlänge nicht fix, sondern als Parameter übergeben werden kann. Dies geschieht wie folgt:

from gturtle import *
def dreieck(l):
    for i in range(3):
        forward(l)
        left(120)
 
makeTurtle()
dreieck(100)
setPos(100,50)
dreieck(50)

Bei der Definition Dreieck(l): seht eine Variable und beim Aufruf Dreieck(50) steht der konkrete Wert.

Beim Aufruf Dreieck(50) wird der Parameterwert 50 mit übergeben. Im Unterprogramm wird der Variablen l der Wert 50 zugewiesen und im Befehl forward steht keine Konstante, sondern l und l ist gleich 50.