## Iteration mit Schleifen

Statt einen Befehl mehrere Male hintereinander hinzuschreiben, können wir eine Anweisung oder eine ganze Sequenz auch mit einer _Schleife_ wiederholen. Die untenstehende Schleife lässt Kara _solange_ (Englisch: _while_) vorwärts laufen, als sie **nicht** vor einem Pilz steht.

Dafür können wir Kara fragen, ob auf dem Platz vor ihr ein Pilz ist, mit `kara.mushroomFront()`. Da Kara solange weiterlaufen wollen, als **kein** Pilz vor ihr ist, müssen wir Karas Antwort gerade **umdrehen**, das geschieht mit dem Schlüsselwort `not` vor `kara`.

<kara-editor step="300" id="while">
while not kara.mushroomFront():
    kara.move()

<kara-world>
   TTTTTTTTT
   T       T
   T       T
   T >     M
   T       T
   T       T
   TTTTTTTTT
</kara-world>
</kara-editor>

**Beachte:**
  * Nach der Bedingung von `while` muss ein Doppelpunkt `:` stehen.
  * Die zu wiederholenden Anweisungen werden **gleichmässig eingerückt**
    * Drücke <kbd>Tab</kbd>, um eine Zeile (oder mehrere) einzurücken, <key>⇧+Tab</key>, um sie auszurücken.
    * Die [[wpde>Tabulatortaste]] heisst je nach Tastatur <key>⇥</key> oder <key>↹</key>, sie ist links der Taste <key>Q</key>.
    * <key>⇧</key> bezeichnet die [[wpde>Umschalttaste]], teilweise auch mit <key>S</key> bezeichnet.
  * Sobald die Bedingung falsch wird, wird das Programm nach dem eingerückten Block fortgesetzt.

Der Fachbegriff für eine Schleife ist **[[wpde>Iteration]]** (von lateinisch _iterare_ 'wiederholen').

#### Aufgabe B1: Zwei Schleifen
Schau dir die untenstehende Kara-Welt gut an. Kannst du ein Kara-Programm schreiben, das **mit zwei Schleifen** zum Pilz kommt? Dafür kannst du mit `kara.treeFront()` herausfinden, ob vor Kara ein Baum steht.

<kara-exercise step="300" id="a2">
while not kara.treeFront():
    kara.move()

<kara-world>
   TTTTTTTTT
   T       T
   T       T
   T       T
   T >  T  T
   T       T
   T       T
   T       T
   TTTTMTTTT
</kara-world>
<kara-solution>
while not kara.treeFront():
    kara.move()

kara.turnRight()

while not kara.mushroomFront():
    kara.move()
</kara-solution>
<kara-tests>
assert kara.x == 4 and kara.y == 7, f"Kara sollte an 4/7 sein, war aber an {kara.x}/{kara.y}"
</kara-tests>
</kara-exercise>

#### Aufgabe B2: Anpassungsfähige Kara
Schreibe ein Kara-Programm, das mit zwei Schleifen zum Pilz gelangt! Funktioniert das Programm auch, wenn Kara zu Beginn in eine andere Richtung schaut?

<kara-editor step="300" id="a3">
<kara-world>
   TTTTTTTTT
   T       T
   TTTT    T
   Tv      M
   TTTT    T
   T       T
   T       T
   T       T
   TTTTTTTTT
</kara-world>
</kara-editor>

Probier deine Lösung ohne Änderung in dieser Welt aus:

<kara-editor step="300" id="a3_2">
<kara-world>
   TTTTTTTTT
   T       T
   TTTT    T
   T<      M
   TTTT    T
   T       T
   T       T
   T       T
   TTTTTTTTT
</kara-world>
</kara-editor>

<nodisp 1>
++++Lösung 3|
<code python>
while kara.treeFront():
    kara.turnRight()  # oder kara.turnLeft()

while not kara.mushroomFront():
    kara.move()
</code>
++++
</nodisp>

### Verschachtelte Schleifen
Eine `while`-Schleife lässt sich auch innerhalb einer anderen Schleife verschachteln.

#### Aufgabe B3: Code interpretieren

<WRAP todo>
Löse diese Aufgabe zu zweit oder in der Gruppe, falls du gerade in der Klasse bist!
</WRAP>

Betrachte den folgenden Code zuerst **ohne ihn auszuführen**! Wie wird sich Kara bewegen?

<kara-editor step="300" id="a4">
while not kara.mushroomFront():
    while kara.treeFront():
        kara.turnLeft()
    kara.move()
<kara-world>
   TTTTTTTTT
   T       T
   TTTTTT  T
   T>   T  T
   T TT T  T
   T      TT
   M       T
   T       T
   TTTTTTTTT
</kara-world>
</kara-editor>


Kara geht geradeaus, solange kein Pilz vor ihr steht. Wenn sie dabei auf einen Baum trifft, wendet sie nach links, bis der Weg frei ist. Funktioniert das immer? Kannst du ein Labyrinth entwerfen, aus dem Kara nicht hinausfindet?

++++Antwort|
Kara kann sich in _Taschen_ fangen, die sich nicht mit Links-Drehungen verlassen lassen. Wäre zum Beispiel der Baum unten rechts nicht vorhanden, würde sie nicht zum Pilz finden:

<kara-editor step="300" id="a4_b">
while not kara.mushroomFront():
    while kara.treeFront():
        kara.turnLeft()
    kara.move()
<kara-world>
   TTTTTTTTT
   T       T
   TTTTTT  T
   T>   T  T
   T TT T  T
   T       T
   M       T
   T       T
   TTTTTTTTT
</kara-world>
</kara-editor>

++++

### Weiter
Gratuliere, du hast deine ersten Kara-Schleifen geschrieben!

Um wirklich ein Programm schreiben zu können, das aus vielen oder sogar allen Labyrinthen findet, möchten wir etwas von der folgenden Form haben. Beachte: der Hashtag (`#`) im folgenden Codebeispiel markiert eine Kommentarzeile: Sie wird von Kara ignoriert. Mit Kommentaren kann Code erklärt werden.

<code python>
while not kara.mushroomFront():
    # Wahl zwischen turnLeft, turnRight oder move, je nach Situation.
</code>

Wir könnten das vielleicht mit mehreren verschachtelten Schleifen erreichen, aber Kara hat noch mehr auf Lager!

Weiter gehts mit [[.:verzweigungen]].