====KW34: Erste Schritte mit Python====
===Programmaufbau in Python===
Der Programmaufbau in Python ist immer gleich.

  - Includes
  - Definitionen
  - Hauptprogramm

Kommentare werden mit einem # versehen.

<code  python prog_1.py>
#1.Includes
from gpanel import *
#2. Definitionen
def quadrat(x):
   return(x*x)
#3.Hauptprogramm
x=4
print(quadrat(x))
</code>
**Aufgabe 1**
  - Was macht dieses Programm? Bist du nicht sicher, so lade es herunter und teste es in der Lernumgebung Tigerjython aus.
  - Brauchen wir den Include?

===Wiederholungen===
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.
<code python prog_2.py>
from gturtle import *
makeTurtle()
forward(100)
right(120)
forward(100)
right(120)
forward(100)
right(120)
delay(500)
hideTurtle()
</code>
Anstelle dieses Spaghetti Codes verwenden wir eine Schleife. Da wir die Anzahl an Wiederholungen kennen, verwenden wir die **for**-Schleife.
<code python>
for variable in range(Bereich):
    # hier steht der zu 
    # wiederholende Code
</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!
<code python Prog_3.py>
from gturtle import *
makeTurtle()
for i in range(3):
    forward(100)
    right(120)
delay(500)
hideTurtle()
</code>
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**
  - Was macht das nachfolgende Programm? Falls du dir nicht sicher bist, teste es aus!
  - Ändere das Programm so ab, dass eine Quadratschnecke mit mindestens drei Umdrehungen entsteht.
<code python Prog_4.py>
from gturtle import *
makeTurtle()
for i in range(9):
    forward(80*(i+1))
    right(120)
delay(500)
hideTurtle()
</code>

Kennt man die Anzahl der Wiederholungen nicht, dann verwendet wir die **while**-Schleife. 
<code python>
while wahre Aussage:
    # hier steht der zu 
    # wiederholende Code
</code>
Solange die Aussage wahr ist, wird die Schleife durchlaufen. 
<code python Prog_5.py>
from gturtle import *
makeTurtle()
l=100
while l<600:
    forward(l)
    right(120)
    l=l+50
delay(500)
hideTurtle()
</code>

**Aufgabe 3**
  - 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.

===Verzweigungen===
Eine Verzweigung des Typs **wenn-dann-sonst** wird mit der Struktur
<code python>
if wahre Aussage:
   # dann wird der Code
   # hier ausgeführt
else:
   # sonst wird der Code 
   # hier ausgeführt
</code>
realisiert.
In Python gibt es dann auch noch die Version mit zwei wenn-dann hintereinander, im Sinne von **wenn-dann-sonstwenn-dann-sonst**.
<code python>
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
</code>
<code python 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
</code>

**Aufgabe 4**
  - 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.
====Apfelmännchen====
Hier das Programm von letzter Woche.
<code python 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
</code>
  * 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**
  - Verändere das obige Programm so, dass der Bildaufbau vertikal von unten nach oben und nicht mehr horizontal von links nach rechts verläuft.
  - 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)**.

===Unterprogramme / Funktion mit und ohne Rückgabewert===
Unabhängig von der obigen Aufgabenstellung wollen wir drei von Unterprogrammen anschauen.
  - Unterprogramme ohne Parameterübergabe, wurde früher Prozedur genannt
  - Unterprogramme mit Parameterübergabe, wird i.d.R. Funktion genannt
  - Unterprogramm mit Parameterübergabe und Rückgabewert, wird i.d.R. auch Funktion genannt
===Zu 1. Unterprogramme ohne Parameterübergabe===
<code python>
from gturtle import *
def dreieck():
    for i in range(3):
        forward(100)
        left(120)

makeTurtle()
dreieck()
setPos(100,50)
dreieck()
</code>
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.

===Zu 2. Unterprogramme mit Parameterübergabe===
Schöner wäre es aber, wenn die Seitenlänge nicht fix, sondern als Parameter übergeben werden kann. Dies geschieht wie folgt:
<code python>
from gturtle import *
def dreieck(l):
    for i in range(3):
        forward(l)
        left(120)

makeTurtle()
dreieck(100)
setPos(100,50)
dreieck(50)
</code>
Bei der Definition def 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.

Noch schöner wäre es, wenn nicht nur die Länge, sonder die Anzahl der Ecken übergeben werden kann. Es muss ja nicht immer ein Dreieck sein. Siehe dazu folgendes Programm.
<code python>
from gturtle import *
def nEck(n,l):
    if n>2:
        for i in range(n):
            forward(l)
            left(360/n)
        
makeTurtle()
nEck(3,100)
setPos(100,50)
nEck(4,50)
setPos(25,125)
nEck(5,80)
</code>
Was geschieht, wenn wir ein 0-Eck, ein 1-Eck oder ein 2-Eck zeichnen wollen. Nun n muss grösser als 2 sein, sonst wird nichts gezeichnet. Falls aber gekommen wir auch eine Rückmeldung vom Unterprogramm? Nein noch nicht.
===Zu 3. Unterprogramme mit Parameterübergabe und Rückgabewert===
<code python Prog_8.py>
from gturtle import *
def nEck(n,l):
    if n>2:
        for i in range(n):
            forward(l)
            left(360/n)
        return(1)
    return(0) 
makeTurtle()
ans=nEck(3,100)
if ans!=1:
    print("Es ist ein Fehler aufgetreten!")
setPos(100,50)
if nEck(1,50)!=1:print("Es ist ein Fehler aufgetreten!")
setPos(25,125)
ans=nEck(5,80)
</code>

**Aufgabe 6**
  - Arbeite die drei Fälle sorgfältig durch. Dann du die drei Fälle ohne nachzuschauen erklären? Falls nicht, schau sie nochmals an.
  - Ändere das obige Programm nach belieben ab und schaue was dabe herauskommt.
  - Füge eine Meldung hinzu, falls das n-Eck gezeichnet werden konnte.
  - Füge eine Meldung hinzu, falls alle n-Ecke gezeichnet werden konnten. 

====Was ist ein Fraktal und was ist eine gebrochene Dimension?====
Siehe dazu folgendes Video vom Kanal [[https://www.youtube.com/watch?v=gB9n2gHsHN4|3Blue1Brown]].

Als weitere Quelle hier noch ein altes Skript von der ETHZ{{ :kurse:efcomputergrafik:fraktale_ethz.pdf |}}

Wer Interesse hat, kann das Buch **SuperFractals**, Pattern of Nature von Michael F. Baransley, ISBN-13 987-0-521-84493-2 von mir ausleihen.

**Aufgabe 7**

* Was ist ein Fraktal?
<hidden>
Ein Objekt mit einer gebrochenen Dimension, d.h. $D\not\in \mathbb{N}$.
</hidden>
* Kennst du die Dimension des Serpinski Dreiecks bestimmen?
<hidden>
Verkleinerung der Strecke um den Faktor 2, erzeugt eine Verkleinerung der Fläche um den Faktor 3.  $2^D=3 \quad\rightarrow\quad D=log_2(3)=1.585$  
</hidden>
* Kennst du eine allgemeine Formel zur Dimensionsbestimmung?
<hidden>
Du findest eine am Schluss des Skript Fraktale von der ETHZ.
</hidden>