gf2:pythonaufgabenkonzepte [DokuWiki CSC]

Diese Seite ist nicht editierbar. Sie können den Quelltext sehen, jedoch nicht verändern. Kontaktieren Sie den Administrator, wenn Sie glauben, dass hier ein Fehler vorliegt.
===== Programmierkonzepte in Python =====

<callout type="primary" title="1. Variablen verwenden">
{{fa>angle-double-down}}
<button collapse="collvar" type="link">Bereich ausklappen/einklappen </button> <collapse id="collvar">
Eine **Variable** ist ein Behälter, in dem Daten gespeichert werden können. Stelle dir z.B. einen Koffer vor, in dem du etwas aufbewahren kannst. Die Variable ist der Koffer und der Wert der Variablen ist der Inhalt dieses Koffers. Eine Variable erstellt man mit dem Gleichheitszeichen: 

<code Python>
 meinKoffer = 3 
</code>

Es wurde eine Variable mit dem Namen //meinKoffer// erstellt und darin der Wert 3 abgelegt. Jedes Mal, wenn nun die Variable im Programm aufgerufen wird, wird sie durch ihren aktuellen Wert ersetzt. 
<well>Das Gleichheitszeichen ( = ) hat in der Programmierung also nicht dieselbe Bedeutung wie in der Mathematik: es testet nicht, ob die linke Seite gleich ist wie die rechte Seite, sondern es definiert eine Variable und weist dieser den Wert zu, der auf der rechten Seite steht.</well>

In manchen Programmiersprachen muss man bei jeder Variable angeben, welcher Typ von Daten gespeichert werden soll (damit im Speicher des Computers die richtige Menge Platz reserviert werden kann), dies ist in Python nicht der Fall. In derselben Variable kann man eine Ganze Zahl, eine Kommazahl, einen Text, eine Liste etc. speichern. Man muss einfach den "alten" Wert durch einen neuen Wert überschreiben:

<code Python>
# Verschidene Datentypen können in derselben Variablen gespeichert werden
a = 1
print(a+1)
a = "Ein Text" 
a = True
</code>

Im obigen Beispiel werden der Variablen a verschiedene Werte zugewiesen:

  * Zuerst erhält sie den Wert 1, eine natürliche Zahl, ein sogenannter //Integer// (kurz int). 
  * Dann wird in der Variablen zwei Zeilen später ein sog. //string// ein Stück Text gepeichert. Mit dieser Variable könnte man jetzt nicht mehr rechnen, da darin keine Zahl mehr gepeichert wird. 
  * Und schliesslich in der letzten Zeile wird der Variablen "True" (//boolean//) zugewiesen, einer der beiden Wahrheitswerte ''True'' oder ''False''.

<WRAP nicebox green>

**Aufgabe B** 
  - Analysiere das untenstehende Programm. Was macht der Agent?
  - Welche Variablen beinhaltet das Programm? Identifiziere diese Variablen. (Bemerkung: wir werden weiter später sehen, wie man dieses Beispiel viel eleganter programmieren kann.)
  - Erweitere das Programm wie folgt: 
    - Während des Programmablaufs nehmen bereits vorhandene Variablen einen anderen Wert an.
    - Eine weitere Variable wird eingeführt und vom Programm auch genutzt.

<code python>
agent.set_assist(PLACE_ON_MOVE, True) # Agent baut, wenn er sich bewegt
agent.set_assist(DESTROY_OBSTACLES,True) # Agent zerstört Hindernisse beim Bauen
agent.set_item(SANDSTONE,64,1) # 64 Blöcke Sandstein ins erste Fach des Inventars legen

schrittgroesse = 4
ausrichtung = WEST
xKoord = 1
yKoord = 1
zKoord = 1
agent.teleport(pos(xKoord,yKoord,zKoord),ausrichtung)
agent.move(FORWARD,schrittgroesse)
agent.teleport(pos(xKoord+1,yKoord+1,zKoord+1),ausrichtung)
agent.move(FORWARD,schrittgroesse)
</code>

</WRAP>
<accordion>
<panel title='mögliche Lösungen'>
**Aufgabe 3a**
<code python>
agent.set_assist(PLACE_ON_MOVE, True) # Agent baut, wenn er sich bewegt
agent.set_assist(DESTROY_OBSTACLES,True) # Agent zerstört Hindernisse beim Bauen
agent.set_item(SANDSTONE,64,1) # 64 Blöcke Sandstein ins erste Fach des Inventars legen
 
schrittgroesse = 4
ausrichtung = WEST
xKoord = 1
yKoord = 1
zKoord = 1
agent.teleport(pos(xKoord,yKoord,zKoord),ausrichtung)
agent.move(FORWARD,schrittgroesse)
schrittgroesse = 6 # Beispielsweise hier die Schrittgrösse auf 6 setzen.
agent.teleport(pos(xKoord+1,yKoord+1,zKoord+1),ausrichtung)
agent.move(FORWARD,schrittgroesse)
</code>

**Aufgabe 3b**
<code python>
agent.set_assist(PLACE_ON_MOVE, True) # Agent baut, wenn er sich bewegt
agent.set_assist(DESTROY_OBSTACLES,True) # Agent zerstört Hindernisse beim Bauen
agent.set_item(SANDSTONE,64,1) # 64 Blöcke Sandstein ins erste Fach des Inventars legen
 
schrittgroesse = 4
ausrichtung = WEST
bewegungserichtung = FORWARD
xKoord = 1
yKoord = 1
zKoord = 1
bewegungsrichtung = FORWARD # Beispielsweise hier eine Bewegungsrichtung definieren. 
agent.teleport(pos(xKoord,yKoord,zKoord),ausrichtung)
agent.move(bewegungsrichtung,schrittgroesse)
schrittgroesse = 6 # Beispielsweise hier die Schrittgrösse auf 6 setzen.
agent.teleport(pos(xKoord+1,yKoord+1,zKoord+1),ausrichtung)
agent.move(bewegungsrichtung,schrittgroesse)
</code>
</panel>
</accordion>
**Namen für Variablen und Funktionen** {{ :gf2:camelcase2.png?220&direct}} Wichtige Variablen oder Funktionen sollten (wenn möglich) Namen haben, die ihre Bedeutung erkennen lassen. Es gibt zwei Konventionen, die sich bei Namen mit mehreren Wörter etabliert haben:

| **Camelcase (Kamelfall)**  | Bei Namen, die aus mehreren Wörtern bestehen, wird jeweils bei einem neuen Wort der erste Buchstabe grossgeschrieben. Der allererste Buchstabe jedoch klein (Bsp: anzahlGoldbloecke, rechtesFenster). |
| **Snakecase (Schlangenfall)**  | Bei Namen, die aus mehreren Wörtern bestehen, werden diese durch einen Unterstrich getrennt (Bsp. anzahl_goldbloecke, rechtes_fenster) |

** Was bringen diese Variablen? **

Stelle dir vor, du hast ein kleines Programm geschrieben, welches den Agenten dazu bringt, eine Spirale zu bauen (wir werden weiter später sehen, wie man das Beispiel eleganter programmieren kann):

<code python>
agent.set_assist(PLACE_ON_MOVE, True) # Agent baut, wenn er sich bewegt
agent.set_assist(DESTROY_OBSTACLES,True) # Agent zerstört Hindernisse beim Bauen
agent.set_item(SANDSTONE,64,1) # 64 Blöcke Sandstein ins erste Fach des Inventars legen

agent.move(FORWARD,1)
agent.turn(LEFT)
agent.move(FORWARD,2)
agent.turn(LEFT)
agent.move(FORWARD,3)
agent.turn(LEFT)
agent.move(FORWARD,4)
agent.turn(LEFT)
agent.move(FORWARD,5)
agent.turn(LEFT)
agent.move(FORWARD,6)
</code>

Wie du siehst, wird sehr häufig der Befehl ''agent.turn(LEFT)'' verwendet. Wenn du nun dein Programm leicht verändern möchtest, so dass der Agent die Spirale nach rechts machen soll, statt nach links, musst du all diese ''agent.turn(LEFT)''-Befehle zu ''agent.turn(RIGHT)'' ändern, was bei grösseren Programmen sehr mühsam sein kann. Es ist besser, die Drehrichtung in einer Variablen zu speichern und im Code dann diese Variable zu verwenden. Dadurch muss nur der Wert der Variablen geändert werden, um die Spirale in die andere Richtung drehen zu lassen.

<code Python>
agent.set_assist(PLACE_ON_MOVE, True) # Agent baut, wenn er sich bewegt
agent.set_assist(DESTROY_OBSTACLES,True) # Agent zerstört Hindernisse beim Bauen
agent.set_item(SANDSTONE,64,1) # 64 Blöcke Sandstein ins erste Fach des Inventars legen

drehRichtung = LEFT # Alternativ: drehRichtung = RIGHT

agent.move(FORWARD,1)
agent.turn(drehRichtung)
agent.move(FORWARD,2)
agent.turn(drehRichtung)
agent.move(FORWARD,3)
agent.turn(drehRichtung)
agent.move(FORWARD,4)
agent.turn(drehRichtung)
agent.move(FORWARD,5)
agent.turn(drehRichtung)
agent.move(FORWARD,6) 
</code>

Zusammenfassend lässt sich sagen, dass durch Variablen die Programme (oder Arbeitsabläufe des Agenten in diesem Beispiel) flexiebler einsetzbar und besser anpassbar werden. 

</collapse>
</callout>

<callout type="info" title="2. Eigene Funktionen definieren mit ''def''">
{{fa>angle-double-down}}  <button collapse="collfunc" type="link">Bereich ausklappen/einklappen </button> 
<collapse id="collfunc"> **Funktion** oder  oder **Prozedur** (die beiden Begriffe werden hier als Synonym betrachtet) bezeichnet ein Unterprogramm, das durch seinen Namen aufgerufen werden kann.  
In Minecraft gibt es viele vordefinierte Funktionen, die wir bereits verwendet haben, z.B. die Funktion, welche den Agenten dazu bringt, einen Block zu setzen: In Minecraft gibt es viele vordefinierte Funktionen, die wir bereits verwendet haben, z.B. die Funktion, welche den Agenten dazu bringt, einen Block zu setzen: '' agent.place(FORWARD) ''..

Oft hilft es auch, eigene Funktionen zu programmieren. Der Vorteil liegt auf der Hand: wenn mehrmals dieselben Anweisungen nacheinander ausgeführt werden sollen, kann man diese als Funktion speichern und diese Funktion dann mehrmals über ihren Namen aufrufen. 

Dies wird in Python durch den Befehl ''def'' realisiert. Dadurch wird das Programm oft kürzer und übersichtlicher.

Wir können beispielsweise unser Spiralbeispiel als Funktion definieren, und dann viele Spiralen bauen, weil wir die definierte Funktion beliebig oft aufrufen können:

<code python baueSpirale.py>
agent.set_assist(PLACE_ON_MOVE, True) # Agent baut, wenn er sich bewegt
agent.set_assist(DESTROY_OBSTACLES,True) # Agent zerstört Hindernisse beim Bauen
agent.set_item(SANDSTONE,64,1) # 64 Blöcke Sandstein ins erste Fach des Inventars legen

def baueSpirale():
    drehRichtung = LEFT # Alternativ: drehRichtung = RIGHT
    agent.move(FORWARD,1)
    agent.turn(drehRichtung)
    agent.move(FORWARD,2)
    agent.turn(drehRichtung)
    agent.move(FORWARD,3)
    agent.turn(drehRichtung)
    agent.move(FORWARD,4)
    agent.turn(drehRichtung)
    agent.move(FORWARD,5)
    agent.turn(drehRichtung)
    agent.move(FORWARD,6)

baueSpirale()
agent.move(FORWARD, 10)

</code>

<WRAP nicebox green>

**Aufgaben C**
  - Überlege dir, was der Agent genau baut, wenn man das oben angegebene Programm ausführt. Bei welcher Zeile des Codes beginnt der Agent mit dem Bauen?
  - Mache eine kleine Skizze: wie wird das gebaute Objekt wohl aussehen? Häuschenpapier kann viel helfen...
  - Überprüfe deine Überlegung und deine Skizze, indem du das Programm in Minecraft einfügst und ausführst (evt. musst du zunächst den Agenten zu dir teleportieren. Im Chat kannst du das machen mit ''/teleport @c @s'')
  - Gibt es eine Möglichkeit, das in vorige Aufgabe (Aufgabe 3) geschriebene Programm zu verkürzen? Wenn ja, welche? Wenn nein, warum bist du sicher, den kürzesten Programmcode gefunden zu haben?
  - Schreibe eine Funktion ''linie1()'', welche den Agenten dazu bringt, eine Linie aus 5 Blöcken mit dem Material deiner Wahl zu bauen. 
  - Schreibe ein Programm, welches ein gefülltes Quadrat der Grösse 5 mal 5 Blöcke aus Gold baut (nutze eventuell die Lösung der Aufgabe 5). Versuche, einen möglichst kurzen Code zu produzieren!
  - Füge in deinem Programm zur Aufgabe 6 eine Variable hinzu, sodass man das Baumaterial durch diese Variable festlegen kann.

</WRAP>
<accordion>
<panel title='mögliche Lösungen'>
**Aufgabe 4**
<code python>
agent.set_assist(PLACE_ON_MOVE, True) # Agent baut, wenn er sich bewegt
agent.set_assist(DESTROY_OBSTACLES,True) # Agent zerstört Hindernisse beim Bauen
agent.set_item(SANDSTONE,64,1) # 64 Blöcke Sandstein ins erste Fach des Inventars legen
#Spirale kurzes Programm mit while
def baueSpiralewhile():
    drehRichtung = LEFT
    zaehler=0 # hier ist ein zähler nötig, da es eine while-Schleife ist.
    while ( zaehler<7):
        agent.move(FORWARD,zaehler)
        agent.turn(drehRichtung)
        zaehler=zaehler+1
baueSpiralewhile()

</code>
**Aufgabe 5 - 7**
<code python>
agent.set_assist(PLACE_ON_MOVE, True) # Agent baut, wenn er sich bewegt
agent.set_assist(DESTROY_OBSTACLES,True) # Agent zerstört Hindernisse beim Bauen
#Linie, Funktion ohne Parameter für Linie aus 5 Blöcken
def linie1():
    agent.set_item(SANDSTONE,64,1)
    agent.set_slot(1)
    agent.move(FORWARD,5)
linie1()

# Funtion linie2 mit Parameter 'material', so kann das Baumaterial flexibel gewählt werden.
def linie2(material):
    agent.set_item(material,64,1)
    agent.set_slot(1)
    agent.move(FORWARD,5)
linie2(GOLD_BLOCK)

#leeres Quadrat, nicht gefüllt.
def quadrat(material):
    zaehler=0
    while (zaehler < 5):
        linie2(material)
        agent.turn(LEFT_TURN)
        agent.move(FORWARD,1)
        zaehler=zaehler+1
    agent.move(LEFT,1)
quadrat(DIAMOND_BLOCK)

#voll ausgefülltes Quadrat mit frei wählbarem Material.
def quadrat2(material):
    zaehler=0
    while (zaehler < 5):
        agent.set_assist(PLACE_ON_MOVE, True)
        linie2(material)
        agent.turn(LEFT_TURN)
        agent.move(FORWARD,1)
        agent.turn(LEFT)
        agent.set_assist(PLACE_ON_MOVE, False)
        linie2(material)
        agent.turn(LEFT)
        agent.turn(LEFT)
        agent.set_assist(PLACE_ON_MOVE, True)
        zaehler=zaehler+1
        agent.set_assist(PLACE_ON_MOVE, False)
    agent.move(LEFT,1)
quadrat2(GREEN_WOOL)
</code>
</panel>
</accordion>
<well> ** Globale und lokale Variablen **

Oben wird die Variable ''drehRichtung'' innerhalb der Funktion ''baueSpirale'' definiert. Man kann sie dann nur innerhalb dieser Funktion verwenden: man spricht von einer **lokalen Variablen**. Würde man die Variable ausserhalb der Funktion (ganz zu Beginn des Codes) definieren, dann wäre sie überall im Programm sichtbar, auch für andere Funktionen lesbar. Globale Variablen sind wie Taucher, die unter Wasser für alle sichtbar sind. Lokale Variablen sind dagegen wie die Besatzung des U-Boots: Sie sind nur für die anderen Menschen im U-Boot sichtbar. Wenn man in Python eine globale Variable innerhalb einer Funktion verändern will, dann muss dies mit ''global'' deklariert sein, ansonsten erstellt Python eine gleichbenannte lokale Variable. </well>

==== Funktion mit Parametern ====
Wenn man mit ''def'' eine eigene Funktion definiert, kann man diese flexibler machen, indem man Parameter verwendet. Dies sind Variablen, die beim Aufruf der Funktion übergeben werden und dann innerhalb der Funktion wie lokale Variablen funktionieren. So könnte man z.B. eine Funktion ''Hochhaus(n)'' definieren, welches ein Hochhaus mit n Etagen baut. Wenn man die Funktion dann aufruft, muss man für n einen konkreten Wert angeben: z.B. ''Hochhaus(7)''.

Das Beispiel unserer Spirale können wir mit Parametern etwas eleganter gestalten: wir übergeben der Funktion die Drehrichtung als Parameter. 

<code python spiraleneu.py>
agent.set_assist(PLACE_ON_MOVE, True) # Agent baut, wenn er sich bewegt
agent.set_assist(DESTROY_OBSTACLES,True) # Agent zerstört Hindernisse beim Bauen
agent.set_item(SANDSTONE,64,1) # 64 Blöcke Sandstein ins erste Fach des Inventars legen

def baueSpiraleNeu(richtung):
    agent.move(FORWARD,1)
    agent.turn(richtung)
    agent.move(FORWARD,2)
    agent.turn(richtung)
    agent.move(FORWARD,3)
    agent.turn(richtung)
    agent.move(FORWARD,4)
    agent.turn(richtung)
    agent.move(FORWARD,5)
    agent.turn(richtung)
    agent.move(FORWARD,6)

baueSpiraleNeu(LEFT)
agent.move(FORWARD, 10)
baueSpiraleNeu(RIGHT)
agent.move(FORWARD, 10)
baueSpiraleNeu(LEFT)
agent.move(FORWARD, 10)
baueSpiraleNeu(RIGHT)
agent.move(FORWARD, 10)
</code>

Nun können wir dieselbe Funktion verwenden, um rechtsdrehende und linksdrehende Spiralen zu bauen. Wir übergeben beim Aufruf der Funktion die Drehrichtung (Nun können wir dieselbe Funktion verwenden, um rechtsdrehende und linksdrehende Spiralen zu bauen. Wir übergeben beim Aufruf der Funktion die Drehrichtung (''baueSpiraleNeu(Right)'') und diese Drehrichtung ist dann innerhalb der Funktion an die Variable) und diese Drehrichtung ist dann innerhalb der Funktion an die Variable ''richtung'' gekoppelt (da wir bei der Definition der Funktion diesen Namen gewählt haben).   gekoppelt (da wir bei der Definition der Funktion diesen Namen gewählt haben).

<WRAP nicebox green>

**Aufgaben D**
  - Spiralen:
    - Studiere das neue Programm für die Spirale. Wird der Agent dieses Mal dasselbe bauen wie vorher? Erkläre.
    - Verändere das Programm so, dass der Agent zwei Spiralen aneinander baut, eine nach links drehend und eine nach rechts drehend.
  - Linien:
    - Schreibe eine Funktion ''linie1()'', welche den Agenten dazu bringt, eine Linie der Länge 5 zu bauen. Wähle den Baustein selber aus der Liste der Materialen aus.
    - Schreibe eine Funktion ''linie2(n)'', welche den Agenten dazu bringt, eine Linie der Länge n zu bauen, indem er n Schritte vorwärts geht und die Linie als Blöcke hinter sich platzert. Wähle den Baustein selber aus der Liste [[gf2:bloecke|Zusammenfassung der wichtigsten Blöcke/Materialien]]
    - Schreibe eine Funktion ''linie3(n)'', welche den Agenten dazu bringt, eine Linie der Länge n zu bauen, indem er n Schritte vorwärts geht und die Linie aus //unterschiedlichen// Blöcken hinter sich platzert. (Die gesetzen Blöcke können die Baustein-ID n haben - Siehe dazu [[gf2:bloecke|Zusammenfassung der wichtigsten Blöcke/Materialien]]). Teste mit verschiedenen Linien.

Notiere die wichtisten drei Erkenntnisse der Aufgaben in eigenen Worten und mit einem Beispiel. Dies ist für eine Prüfungsvorbereitung sehr nützlich!

</WRAP>

<accordion>
<panel title='mögliche Lösungen'>
**Aufgabe 4**
<code python>
agent.set_assist(PLACE_ON_MOVE, True) # Agent baut, wenn er sich bewegt
agent.set_assist(DESTROY_OBSTACLES,True) # Agent zerstört Hindernisse beim Bauen
agent.set_item(SANDSTONE,64,1) # 64 Blöcke Sandstein ins erste Fach des Inventars legen
#Spirale kurzes Programm mit while
def baueSpiralewhile():
    drehRichtung = LEFT
    zaehler=0 # hier ist ein zähler nötig, da es eine while-Schleife ist.
    while ( zaehler<7):
        agent.move(FORWARD,zaehler)
        agent.turn(drehRichtung)
        zaehler=zaehler+1
baueSpiralewhile()

</code>
**Aufgaben 1b und 2**
<code python>
#Aufgabe 1b

agent.set_assist(PLACE_ON_MOVE, True) # Agent baut, wenn er sich bewegt
agent.set_assist(DESTROY_OBSTACLES,True) # Agent zerstört Hindernisse beim Bauen
agent.set_item(BLUE_WOOL,64,1) # 64 Blöcke Sandstein ins erste Fach des Inventars legen
 
def baueSpiraleNeu(richtung):
    i=0
    while (i<6):
        agent.move(FORWARD,i)
        agent.turn(richtung)
        i=i+1
    

def baueSpiraleumgekehrt(richtung):
    i=0
    while (i<7):
        agent.move(FORWARD,7-i)
        agent.turn(richtung)
        i=i+1
    

def baueZusammengesetzeSpirale(richtung):
    baueSpiraleNeu(LEFT)
    baueSpiraleumgekehrt(RIGHT)
baueZusammengesetzeSpirale(LEFT)
</code>
**Aufgabe 2a**
<code python>
# Linie bauen
agent.set_assist(PLACE_ON_MOVE, True) # Agent baut, wenn er sich bewegt
agent.set_assist(DESTROY_OBSTACLES,True) # Agent zerstört Hindernisse beim Bauen
agent.set_item(BLUE_WOOL,64,1) # 64 Blöcke Sandstein ins erste Fach des Inventars legen

#Linie der Länge 5
def linie():
    agent.set_assist(PLACE_ON_MOVE, True)
    agent.move(FORWARD,5)
linie()

#Linie der Länge n
def linie2(n):
    agent.set_assist(PLACE_ON_MOVE, True)
    agent.move(FORWARD,n)
linie2(7)

#Linie mit unterschiedlichen Blöcken der Länge n.
#Erinnerung % bedeutet Modulo
def linie3(n):
    agent.set_assist(PLACE_ON_MOVE, True)
    while (n>0):
        if (n%3==0):
            agent.set_item(RED_WOOL, 64, 1)
            agent.set_slot(1)
            agent.move(FORWARD,1)
        elif (n%3==1):
            agent.set_item(BLUE_WOOL, 64, 2)
            agent.set_slot(2)
            agent.move(FORWARD,1)
        else:
            agent.set_item(YELLOW_WOOL, 64, 3)
            agent.set_slot(3)
            agent.move(FORWARD,1)
        n=n-1
linie3(7)
</code>
</panel>
</accordion>
</collapse>
</callout>

<callout type="warning" title="3. Listen (Arrays) erstellen, durchgehen und der range-Befehl">
{{fa>angle-double-down}}<button collapse="colllists" type="link">Bereich ausklappen/einklappen</button> 
<collapse id="colllists">
==== Listen erstellen ==== 
Mit eckigen Klammern kann man in Python eine Liste erstellen. Dabei können die einzelnen Elemente der Liste ganz unterschiedliche Typen haben. Es können sogar selbst wieder Listen sein. Auf die einzelnen Elemente der Liste kann man zugreifen, indem man den Namen der Liste mit eckigen Klammern und dem Index angibt (der Index bezeichnet die Position des Elementes in der Liste - er beginnt bei 0. Gibt man als Index negative Zahlen an, so zählt Python vom letzten Element an rückwärts. D.h. das letzte Element der Liste ''Liste1'' erhält man mit  erhält man mit ''Liste1[-1]'').).

<code Python>
>>> Liste1 = [1, 2, 3, 4, 5]
>>> Liste2 = [51, "Hallo", True, 3.141592]
>>> Liste1[1]
2
>>> Liste1[2]
Hallo
>>> Liste2[-1]
3.141592
>>> 
</code>

Listen verwendet man oft, wenn man viele Daten speichern muss. Statt dass man z.B. zehn Variablen Listen verwendet man oft, wenn man viele Daten speichern muss. Statt dass man z.B. zehn Variablen ''v1=5, v2=3, v3=8, v4=9,..., v10=0.34'' definiert, erstellt man besser eine Liste  definiert, erstellt man besser eine Liste ''v = [5,3,8,9,...,0.34]'' und greift dann auf die Werte zu, indem man  und greift dann auf die Werte zu, indem man ''v[0]'', , ''v[1]'' etc. aufruft. Dadurch wird nur eine Variable vom Typ Liste genutzt und nicht viele Variabeln beispielsweise vom Typ float. etc. aufruft. Dadurch wird nur eine Variable vom Typ Liste genutzt und nicht viele Variabeln beispielsweise vom Typ float.

<WRAP nicebox green>

**Aufgabe E **

Gegeben ist eine Liste von Baumaterialien: \\  ''Materialien=[RED_SANDSTONE, GRASS, WOOL, DIAMOND_BLOCK, GOLD_BLOCK]'' \\

Schreibe ein Programm, welches den Agenten dazu bringt, eine Linie mit fünf verschieden Blöcken aus den Materialien der Liste zu bauen. Die Reihenfolge der Liste soll dabei eingehalten werden.

Tipps:
  * Dein Code beginnt mit ''Materialien=[RED_SANDSTONE, GRASS, WOOL, DIAMOND_BLOCK, GOLD_BLOCK]''
  * Die Liste muss in deinem Code verwendet werden
  * Damit der Agent bauen kann, muss das Inventar zuerst mit den richtigen Materialien gefüllt werden.{{ :gf2:inventar_agent.png?250 }}
  * Verwende unter anderem die Befehle ''agent.set_item'' und ''agent.set_slot''

</WRAP>
<accordion>
<panel title='mögliche Lösungen'>
**Aufgabe E**
<code Python>
def linie4():
    materialien=[RED_SANDSTONE, GRASS, WOOL, DIAMOND_BLOCK, GOLD_BLOCK]
    agent.set_assist(PLACE_ON_MOVE, True)
    i=0
    while (i<5):
        agent.set_item(materialien[i], 64, i+1)
        agent.set_slot(i+1)
        agent.move(FORWARD,1)
        i=i+1
linie4()
</code>
</panel>
</accordion>
==== Der range-Befehl ====
Sehr häufig möchte man eine regelmässige Liste von Zahlen erstellen: z.B. alle Zahlen von 1 bis 10 oder die Zahlen von 1 bis 100 in 2er-Schritten etc.Sehr häufig möchte man eine regelmässige Liste von Zahlen erstellen: z.B. alle Zahlen von 1 bis 10 oder die Zahlen von 1 bis 100 in 2er-Schritten etc. Dazu ist der range-Befehl sehr praktisch. Dieser kann in drei Varianten genutzt werden:Dazu ist der range-Befehl sehr praktisch. Dieser kann in drei Varianten genutzt werden:

^ range-Befehl  ^ Bedeutung  ^
| ''range(Endzahl)'' | Erstellt eine Liste der Zahlen von 0 bis und ohne die Endzahl in Einerschritten. |
| ''range(10)'' | Liste der Zahlen von 0 bis 10 (exklusive 10), also [0,1,2,3,4,5,6,7,8,9] |
|  |  |
|  |  |
| ''range(Startzahl, Endzahl)'' | Erstellt eine Liste von und mit der Startzahl bis und ohne der Endzahl in Einerschritten. |
| ''range(4,9)'' | Liste der Zahlen von 4 (inkl.) bis 9 (exkl.), also [4,5,6,7,8] |
|  |  |
|  |  |
| ''range(Startzahl, Endzahl, Schrittweite)'' | Erstellt eine Liste von und mit der Startzahl bis und ohne der Endzahl in der angegebenen Schrittweite. |
| ''range(13,25,3)'' | Liste der Zahlen von 13 (inkl.) bis 25 (exkl.) in 3er-Schritten, also [13,16,19,22] |

<WRAP nicebox green>

**Aufgabe F** \\
Erstelle mit dem ''range''-Befehl die folgenden Listen:

  - ''L1'' die Liste der ganzen Zahlen zwischen 0 und 8. 
  - ''L2'' die Liste der ganzen Zahlen, die kleiner als 20 und durch 3 teilbar sind.
  - ''L3'' die Liste der ganzen Zahlen zwischen 20 und 40, die durch 4 teilbar sind.

Tipp: Mit dem Befehl ''player.say'' kannst du im Codebuilder deine Listen anzeigen lassen. Beispiel: ''player.say(L1)''

</WRAP>
<accordion>
<panel title='mögliche Lösungen'>
**Aufgabe F 1. bis F 3.**
<code python>
def liste1():
    for i in range (8):
        player.say(i)
liste1()

#durch 3 teilbare Zahlen
def liste2():
    for i in range (20):
        if i%3==0:
            player.say(i)
        else:
            pass
liste2()

#durch 4 teilbare Zahlen

def liste3():
    for i in range (20, 40,4):
        player.say(i)
liste3()
</code>
</panel>
</accordion>
==== Listen abklappern (durchgehen) ====

Ganz oft will man für alle Elemente in einer Liste dasselbe tun, d.h. man will die Liste "abklappern" (durchlaufen) und dann für jedes Element dieselbe Aktion durchfühen. Z.B. hat man eine Liste von Positionen und möchte bei jeder Position ein Haus bauen, oder man hat eine Liste von Baumaterialien und man möchte für jedes dieser Materialien einen Block platzieren etc.

Dafür gibt es in Python den Befehl ''for <Variable> in <Liste>''. Am besten versteht man dies an einem Beispiel. Wir verbessern unser Programm, welches die Spirale baut, weiter: 

<code Python>
def baueSpirale(richtung):    
    agent.move(FORWARD,1)
    agent.turn(richtung)
    agent.move(FORWARD,2)
    agent.turn(richtung)
    agent.move(FORWARD,3)
    agent.turn(richtung)
    agent.move(FORWARD,4)
    agent.turn(richtung)
    agent.move(FORWARD,5)
    agent.turn(richtung)
    agent.move(FORWARD,6)
</code>

Wir sagen Python einfach: Gehe alle Zahlen von 1 bis 6 durch (sage der Variablen z.B. ''zahl'') und mache dann die beiden Befehle:
{{ :gf2:for_schleife_v4.png?nolink&400|}}

<code Python>
    agent.move(FORWARD,zahl)
    agent.turn(richtung)
</code>

Damit sieht unser Programm viel kürzer aus:

<code Python>
def baueSpirale(richtung):
    for zahl in [1,2,3,4,5,6]:
        agent.move(FORWARD,zahl)
        agent.turn(richtung) 
</code>

\\ 
Die Liste [1,2,3,4,5,6] können wir uns natürlich auch mit dem Range-Befehl erstellen lassen: \\ \\ 
{{ :gf2:forschleife.png?400&direct}}
<code Python>
def baueSpirale(richtung):
    for zahl in range(1,7):
        agent.move(FORWARD,zahl)
        agent.turn(richtung) 
</code>


<well> Will man z.B. etwas in Minecraft 10-Mal wiederholen, so kann man einfach den Befehl: ''for i in range(10)'' verwenden. </well>

<code Python>
for i in range(10): # i geht die Zahlen von 0 bis 9 durch
   agent.move(FORWARD,2)
   agent.place(BACK) 
</code>

Allgemein werden for-Schleifen verwendet, wenn man weiss, wie oft ein Skriptteil wiederholt werden soll. Wenn die For-Schleife eine Liste abarbeiten soll, dann ist der  ''range()''-Befehl nötig.  <well> Allgemein könnte eine for-Schleife wie folgt beschrieben werden:</well>

<code Python>
for i in range(k): # i geht die Zahlen von 0 bis k durch
   Programm wird ausgeführt  
</code>


<WRAP nicebox green>

**Aufgabe G** \\

Schreibe das Programm aus Aufgabe E kürzer. Gehe wie folgt vor:

  * Fülle das Inventar des Agenten mit Hilfe des ''for''-Befehls und der Materialienliste
  * Baue die Linie mit den fünf Materialien des Inventars mit Hilfe eines ''Range''-Befehls.

</WRAP>
<accordion>
<panel title = "mögliche Lösungen">
<code>
def linie4plus():
    materialien=[RED_SANDSTONE, GRASS, WOOL, DIAMOND_BLOCK, GOLD_BLOCK]
    agent.set_assist(PLACE_ON_MOVE, True)
    for i in range (4):
        agent.set_item(materialien[i], 64, i+1)
        agent.set_slot(i+1)
        agent.move(FORWARD,1)

linie4plus()

</code>
</panel>
</accordion>
<WRAP nicebox green>

**Aufgaben H** \\

  - Schreibe eine Funktion ''LinieZwei(n)'', welche eine Linie mit zwei selbst gewählten Materialien baut, wobei es jeweils abwechselt.
  - Schreibe eine Funktion ''LinieDrei(n)'', welche eine Linie mit drei selbst gewählten Materialien baut, wobei es jeweils abwechselt mit allen drei Materialien.
  - Schreibe eine Funktion ''LinieDoppelt(n)'', welche eine Linie mit Höhe zwei Blöcke und Länge n baut. Das Baumaterial ist frei wählbar. 
  - Schreibe eine Funktion ''LinieMitHöhe(n,h)'', welche eine Linie mit Höhe zwei Blöcke und Länge n und Höhe h baut. 
  - Schreibe eine Funktion ''Quadrat(n)'', welche den Agenten dazu bringt, ein nicht ausgefülltes Quadrat der Länge n zu bauen. 
  - Schreibe eine Funktion ''Quadratf(n)'' welche ein gefülltes Quadrat baut.
  - Schreibe eine Funktion ''Tower(n,h)'' welche einen Turm mit quadratischer Grundfläche der Breite n und der Höhe h baut.

</WRAP>
<accordion>
<panel title = "mögliche Lösungen">
** Aufgabe 1**
<code python>
def linieZwei(n): 
    materialZwei=[GOLD_BLOCK,DIAMOND_BLOCK]
    for i in range (n):
        if i%2==0:
            agent.set_item(materialZwei[i%2],64,i%2+1)
            agent.set_slot(i%2+1)
            agent.set_assist(PLACE_ON_MOVE, True)
            agent.move(FORWARD,1)
        else:
            agent.set_item(materialZwei[i%2],64,i%2+1)
            agent.set_slot(i%2+1)
            agent.set_assist(PLACE_ON_MOVE, True)
            agent.move(FORWARD,1)

linieZwei(8) 
</code>
**Aufgabe 2**
<code python>
def linieDrei(n):
    materialZwei=[GOLD_BLOCK,GLASS, GREEN_WOOL]
    for i in range (1,n,1):
        if i%3==0:
            agent.set_item(materialZwei[i%3],64,i%3+1)
            agent.set_slot(i%3+1)
            agent.set_assist(PLACE_ON_MOVE, True)
            agent.move(FORWARD,1)
        elif i%3==1:
            agent.set_item(materialZwei[i%3],64,i%3+1)
            agent.set_slot(i%3+1)
            agent.set_assist(PLACE_ON_MOVE, True)
            agent.move(FORWARD,1)
        else:
            agent.set_item(materialZwei[i%3],64,i%3+1)
            agent.set_slot(i%3+1)
            agent.set_assist(PLACE_ON_MOVE, True)
            agent.move(FORWARD,1)

linieDrei(8)

</code>
**Aufgabe 3**
<code python>
def linieDoppelt(n):
    agent.set_item(GOLD_BLOCK,64,1)
    agent.set_slot(1)
    agent.set_assist(PLACE_ON_MOVE, True)
    for i in range(1,n,1):
        agent.place(UP)
        agent.move(FORWARD,1)
        
linieDoppelt(5)
</code>
**Aufgabe 4**
<code>
def linieMitHoehe(n,h):
    agent.set_item(GOLD_BLOCK,64,1)
    agent.set_slot(1)
    for i in range (n):
        agent.set_assist(PLACE_ON_MOVE, True)
        agent.move(UP,h)
        agent.set_assist(PLACE_ON_MOVE, False)
        agent.move(FORWARD,1)
        agent.move(DOWN,h)
linieMitHoehe(3,5)
</code>
**Aufgabe 5**
<code python>

def quadrat(n):
    agent.set_item(BLUE_WOOL,64,1)
    agent.set_slot(1)
    agent.set_assist(PLACE_ON_MOVE, True)
    for i in range (4):
        agent.move(FORWARD,n)
        agent.turn_right()
    agent.move(LEFT,1)
        
Quadrat(7)
</code>
**Aufgabe 6**
<code>
def Quadratf(n):
    agent.set_item(BLUE_WOOL,64,1)
    agent.set_slot(1)
    agent.set_assist(PLACE_ON_MOVE, True)
    for i in range (1,n,2):
        agent.move(FORWARD,n-1)
        agent.turn_right()
        agent.move(FORWARD,1)
        agent.turn_right()
        agent.move(FORWARD,n-1)
        agent.turn_left()
        agent.move(FORWARD,1)
        agent.turn(LEFT)
    if n%2==1:
        agent.move(FORWARD,n-1)
        agent.turn_right()
        agent.move(FORWARD,1)
        agent.turn_right()
    else:
        pass

Quadratf(8)
</code>
**Aufgabe 7**
<code python>
#Tower(n,h) welche einen Turm mit quadratischer 
#Grundfläche der Breite n und der Höhe h baut.
def Tower(n,h):
    for i in range (h):
        Quadratf(n)
        agent.set_assist(PLACE_ON_MOVE, False)
        agent.move(UP,1)
        agent.move(LEFT,n)

Tower(2,3)
</code>
</panel>
</accordion>



/*
^ Listenbefehl          ^ Bedeutung       ^
| ''L1 = [3, "bla", 5, 6]'' | Liste erstellen                                                   |
| ''L1[1]''           | Auf das erste Element zugreifen (Achtung: Zählung beginnt bei 0!) |
| ''len(L1)''         | Länge der Liste L1 (Anzahl der Elemente)  |
| '' [3,6]+[1,9]'' oder \\ ''[3,6].extend([1,9])''   | Listen zusammenfügen |
| '' del L1[0]'' | Ein Element bei einem best. Index löschen | 
| '' L1.remove("bla")'' | Ein Element mit einem bestimmten Wert löschen  | 
| '' L1[1:3]'' | Unterliste von Index 1 (inkl.) bis Index 3 (exkl.)  | 
| '' L1[1:]'' | Unterliste von Index 1 (inkl.) bis zum Schluss der Liste  | 
| '' 3 in L1'' | Testet, ob der Wert 3 in der Liste L1 enthalten ist. Gibt ''True'' oder ''False'' zurück. | 
*/

</collapse>
</callout>

<callout type="primary" title="4. Verzweigungen mit ''if'' und Schleifen mit ''while'' ">

{{fa>angle-double-down}}<button collapse="collif" type="link">Bereich ausklappen/einklappen</button> 
<collapse id="collif">
==== Verzweigungen mit if ==== 
{{ :gf2:ifverzweigung2.jpg?400&direct}} Mit der Mit der ''if'' Anweisung kann man Befehle nur dann ausführen lassen, wenn eine bestimmte Bedingung  Anweisung kann man Befehle nur dann ausführen lassen, wenn eine bestimmte Bedingung **wahr** (True) ist. Durch diese Anweisung kann eine Entscheidung programmiert werden.  (True) ist. Durch diese Anweisung kann eine Entscheidung programmiert werden.

<code Python>
# Wenn ein Block vor dem und links vom Agenten liegt, 
# dreht sich der Agent nach links. Sonst, was bedeutet, 
# der Weg ist frei, macht der Agent einen Schritt vorwärts.

if (agent.detect(AgentDetection.BLOCK, FORWARD)==True):  
    agent.turn(LEFT)                                     
else:                                                    
    agent.move(FORWARD,1)
</code>

==== Schleifen mit "while" ====
Wir haben bereits die ''for''-Schleife gesehen, um Befehle zu wiederholen. Mit der ''while''-Schleife kann man das auch tun, wobei die Wiederholung nicht durch eine Liste gesteuert ist (wie bei der ''for''-Schleife) sondern durch eine Bedingung. Solange die Bedingung wahr (True) ist, werden die Befehle wiederholt:

<code Python>
# Solange  ein Block vor dem und links vom Agenten liegt, 
# und somit der Weg ist frei, macht der Agent einen Schritt vorwärts. 

while (agent.detect(AgentDetection.BLOCK, FORWARD)==False):  
    agent.place(BACK)  
    agent.move(FORWARD,1)  
</code>

</collapse>

</callout>

While-Schleifen werden verwendet, wenn man nicht weiss, wie oft der Schleifeninhalt wiederholt werden soll und man aus diesem Grund keine for-Schleife verwenden kann. Die Anzahl Wiederholungen kann beispielsweise von einer Eingabe abhängen. While-Schleifen sind können auch als Endlos-Schleife formuliert werden. Schleifenkörper können weitere Schleifen beinhalten, dies sind dann sogenannte Verschachtelte Schleifen. Eine For-Schleife kann eine While-Schleife beinhalten oder auch umgekehrt.

<WRAP nicebox green>
**Aufgabe I**
  - Schreibe mit ''while'' ein Programm, das den Agenten vorwärts gehen lässt, bis er auf einen Block stösst
  - Schreibe mit ''while'' ein Programm, so dass der Agent vorwärts geht und alle Blöcke vor ihm zerstört, bis er auf einen Diamant-Block stösst.
  - Schreibe mit ''while'' ein Programm, so dass der Agent vorwärts geht, solange ein Block rechts von ihm ist.
  - Lade das Labyrinth auf deinen Computer und versuche den Algorithmus "Gehe immer so, dass die Mauer rechts von dir ist" zu programmieren. {{ :gf2:labyrinth.zip |}}
</WRAP>
<accordion>
<panel title = "mögliche Lösungen">
** Aufgabe 1**
<code python>
def Vorwaerts():
    agent.set_assist(DESTROY_OBSTACLES,False) # Agent zerstört Hindernisse beim Bauen nicht
    agent.set_assist(PLACE_ON_MOVE, False) # Agent baut nicht, wenn er sich bewegt
    while True:
        agent.move(FORWARD,1)

Vorwaerts()
</code>
**Aufgabe 2**
<code python>
#Schreibe mit while ein Programm, so dass der Agent vorwärts 
#geht und alle Blöcke vor ihm zerstört, bis er auf einen Diamant-Block stösst.

def VorwaertsBisDiamant():
    agent.set_assist(DESTROY_OBSTACLES,True) # Agent zerstört Hindernisse beim Bauen nicht
    agent.set_assist(PLACE_ON_MOVE,False) # Agent baut nicht, wenn er sich bewegt
    while (agent.inspect(AgentInspection.BLOCK, FORWARD) != 57): # Die Zeichenfolge != heisst nicht gleich.
        agent.move(FORWARD,1)
VorwaertsBisDiamant()
</code>
**Aufgaben 3**
<code python>
def VorwaertsBeiREchts():
    agent.set_assist(DESTROY_OBSTACLES,True) # Agent zerstört Hindernisse beim Bauen nicht
    agent.set_assist(PLACE_ON_MOVE,False) # Agent baut nicht, wenn er sich bewegt
    while (agent.detect(AgentDetection.BLOCK, RIGHT) == True): # schaut, ob rechts etwas ist
        agent.move(FORWARD,1)
VorwaertsBeiREchts()
</code>
</panel>
</accordion>

<accordion>
<panel title="schwierigere Aufgabe">
<WRAP nicebox green>
**Zusatzaufgabe**
  - Um die Aufgaben oben schwieriger zu machen, kann zwischen zwei Materialien abgewechselt werden und als Challange in der zweiten oberen Linie die umgekehrte Materialfolge, so dass ein schönes Muster entsteht. Stelle dir eine solche oder eine ähnliche Aufgabe.
  - Schreibe eine Funktion ''kugel(n)'', welche eine Kugel baut mit "Radius" n, ohne dabei die Funktion shapes.sphere vom Code-Builder zu nutzen.
  - Schreibe eine Funktion ''house()'', welche ein Haus baut.Siehe dabei auch den Tipp unten! 
</WRAP>

<WRAP nicebox green>
Wie kann man ein Haus bauen? Ist das überhaupt über den Code-Builder so möglich? Eine Idee wäre z.B., dass man einen gefüllten Block macht und ihn dann mit einem kleineren gefüllten Block aus 'Luft' wieder aushöhlt... danach kann man Fenster, Türe etc einfügen und das Dach machen. Man kann aber auch die Wände einzeln bauen, wenn man möchte.
</WRAP>

</panel>
</accordion>