Programmieren II: Variablen, Verzweigungen, Schleifen [KSR Wiki]

Diese Seite ist nicht editierbar. Du kannst den Quelltext sehen, jedoch nicht verändern. Kontaktiere den Administrator, wenn du glaubst, dass hier ein Fehler vorliegt.
====== Programmieren II: Variablen, Verzweigungen, Schleifen ======

Du kannst bereits programmieren? Dann [[gf_informatik:programmieren_ii:advanced|schau hier nach]].
===== - Variablen & Mathematik =====

Neben Turtlegrafik kann man in TigerJython und Python auch noch andere Dinge machen, die Spass machen, wie z.B. Mathe.

*Tipp:* Möchtest du nur z.B. etwas berechnen, ohne dabei eine Turtle zu gebrauchen? Dann kannst du die zuvor immer benötigte Zeile Code `from turtle import *` weglassen.


==== - Variablen ====

In **Variablen** werden Werte gespeichert, die man im Laufe des Programms lesen oder verändern will. Variablen haben einen Namen und einen Wert. Den Namen der Variable darf man frei wählen. Nicht erlaubt sind allerdings die Schüsselwörter (z.B. *from*, *repeat*, ...) und Namen mit Sonderzeichen.

Variablen kannst du ganz einfach deklarieren: `<Name der Variablen> = <Wert der Variablen>`

Variablen haben jeweils einen **Typ**:

   * **Zahlen**: Mit Zahlen kann man rechnen.
   * Ein Text wird in der Informatik als **String** bezeichnet. In Python müssen Strings immer in Anführungs- und Schlusszeichen geschrieben werden. Zahlen sind keine Strings und benötigen deshalb keine Anführungs- und Schlusszeichen. Natürlich kann man mit Strings nicht rechnen.

**Beispiele:**

<code python>
x = 7 # Zahl

a = "Hallo, ich bin ein String!" # String
</code>

**Versuche, von nun an möglichst möglichst viel mit Variablen zu arbeiten!**

==== - Einfache Rechnungen ====

Betrachte als Beispiel den folgenden Code:

<code python>
x = 7

y = x*x

print(y)
</code>

Im ersten Schritte legen wir eine Variable mit Namen `x` fest und weisen ihr den Wert 7 zu. Danach quadrieren wir die Zahl und speichern diesen Wert in einer zweiten Variable mit Namen `y`. Nun geben wir in der Konsole den Wert der Variable `y` (also 49) aus. Die **Konsole** (auch **Terminal**) ist das Fenster unterhalb des Code-Fensters.
Um etwas in der Konsole auszugeben, schreiben wir dies in die `print(...)` Funktion.

Führe diesen Code (selber schreiben, nicht copy-paste!) nun selbst aus. Weise der Variablen `x` nun einen anderen Wert zu. Damit wird dann auch der Wert der Variablen `y` verändert und dementsprechend sieht die Ausgabe im Terminal anders aus.

Einige wichtige **mathematischen Operatoren** sind:

^ Funktion ^ Python-Code ^ Resultat ^
| Addition | `5+2` | `7` |
| Subtraktion | `5-2` | `3` |
| Multiplikation | `5*2` | `10` |
| Division (Nachkommastellen) | `5/2` | `2.5` |
| Ganzzahldivision | `5//2` | `2` |
| Hoch (z.B. 2 hoch 5) | `5**2` | `25` |
| Wurzel (z.B. Wurzel von 2, sqrt für square-root) | `sqrt(2)` | `1.4142135...` |
| Modulo (Rest der Ganzzahl-Division) | `5%2`| `1` |
==== - Input ====

Man kann auch den Benutzer auffordern, einen Input zu geben. Der eingegebene Wert kann dann in einer Variablen gespeichert werden:

<code python>
x = input("Gib deinen Namen ein:")
</code>

Mit diesem Code wird der Benutzer aufgefordert, seinen Namen einzugeben. Sobald er dies gemacht hat, wird der eingetippte Wert in der Variablen `x` gespeichert.

Beachte, dass man in die `input()`-Funktion eine Anweisung schreiben kann.

Beachte, dass `input()` immer einen String zurückgibt. Möchten wir eine Zahl einlesen, so muss das Resultat noch in eine Zahl (`int` für eine ganze Zahl, en. _integer_, `float` für eine Kommazahl, en. _floating point number_) umgewandelt werden:

<code python>
n = int(input("Wie alt bist du?"))
</code>

==== - Formatierte Ausgaben ====

Betrachte nochmals [[#einfache_rechnungen|diesen Codeblock]]. Dort wird eine Zahl in der Variablen `x` gespeichert. Danach weisen wir das Quadrat von `x` der Variablen `y` zu und geben diese aus. In der Konsole steht dann einfach 49.
Wir hätten nun aber gerne, dass dort der Satz "Das Quadrat der Zahl 7 is 49" ausgegeben wird. Dies erreichen wir mit der folgenden Zeile Code:

<code python>
print(f"Das Quadrat der Zahl {x} is {y}")
</code>

In der print-Funktion schreiben wir in Anführungs- und Schlusszeichen den Satz, den wir gerne als Ausgabe hätten. Beachte, dass die beiden Variablen `x` und `y` mit geschweiften Klammern umgeben eingefügt werden können. Damit dies funktioniert, muss vor dem ersten Anführungszeichen der Buchstabe `f` (für Format-String) stehen.

==== - Aufgaben D ====

Von nun an arbeiten wir nur noch selten mit TurtleGraphics. Die Zeile `from turtle import *` wird also nicht gebraucht und kann weggelassen werden.

=== Aufgabe D1 ===

1) Frage den Benutzer nach einer Zahl. Diese soll in der Variablen `x` gespeichert werden.
Gib dann der Reihe nach aus:

   * Das Quadrat der Zahl
   * Die Wurzel der Zahl
   * Das 10-fache der Zahl

2) Formatiere nun die Ausgabe, so dass jeweils steht:

   * "Das Quadrat der Zahl 4 is 16"
   * "Die Wurzel der Zahl 4 ist 2"
   * "Das 10-fache der Zahl 4 ist 40"

**Achtung:** Natürlich soll dies nur gelten, falls der Input 4 ist. Falls eine andere Zahl eingegeben wird, soll die //Ausgabe entsprechend anders// sein.

=== Aufgabe D2 ===

Nun wollen wir wieder mit unserer Turtle arbeiten. Der Benutzer soll aufgefordert werden, eine Zahl einzugeben. Danach soll die Turtle ein Quadrat ablaufen. Die Seitenlänge des Quadrates soll genau dieser eingegebenen Zahl entsprechen.

=== Aufgabe D3 ===
Mache eine Kopie einer deiner bereits gelösten Aufgaben aus den Aufgaben A und B und speichere diese unter dem Namen `aufgabe_D3.py`. Suche einen möglichst langen und komplizierten Code aus. Füge nun überall wo es möglich ist, Variablen ein. Anstelle, dass du also immer `fritz.left(90)` schreibst, definiere eine Variable `winkel = 90` und schreibe nachher immer `fritz.left(winkel)`.

=== Aufgabe D4 ===

Kopiere deinen Code aus Aufgabe D2 und erweitere den Code. Anstelle eines Quadrates soll das Turtle nun ein Rechteck ablaufen. Dazu soll der Benutzer zuerst folgende Werte eingeben (alle mit einem seperaten `input`-Statement):

   * x-Koordinate des Startpunkts
   * y-Koordinate des Startpunkts
   * Breite des Rechtecks
   * Höhe des Rechtecks


=== Aufgabe D5 ===

Die Schildkröte soll eine Spirale aus mehreren (unterschiedlich grossen) Halbkreisen zeichnen. Die Benutzer:in soll dazu folgende Werte eingeben (alle mit einem seperatern `input`-Statement):
  * Anzahl Halbkreise
  * Start-Radius: Der kleinste Halbkreis wird mit diesem Radius gezeichnet.
  * Zunahme: Um diesen Wert wird der Radius jedes Halbkreises grösser als der vorherige.

===== - Logik: if-else =====

Beim Programmieren kommt man oft in die Situation, wo man **Entscheidungen** treffen muss. Zum Beispiel soll, je nach dem was der Benutzer eintippt, ein anderer Code ausgeführt werden.

Am einfachsten ist der sogenannte **if**-Befehl: Damit kann man überprüfen, ob (also //if//) eine gewisse Bedingung erfüllt ist oder nicht. Dieser Befehl hat die Form

<code python>
if BEDINGUNG:
    # Codeblock, falls BEDINGUNG erfüllt ist
</code>

Es wird eine Bedingung überprüft. Falls diese erfüllt ist (und nur dann!), wird der darauffolgende Codeblock ausgeführt. Beachte:

   * Nach der Bedingung muss ein **Doppelpunkt** stehen.
   * Der nachfolgende Codeblock muss **eingerückt** (mit Tab) sein, wie bei der repeat- oder for-Schleife.

**Bedingungen** können zum Beispiel sein:

^ Bedingung       ^ **Erklärung**                                  ^
| `x == 4`        | x ist Zahl und hat Wert von genau 4            |
| `s == "Hallo"`  | s ist String und hat genau den Inhalt "Hallo"  |
| `x != 4`        | x ist NICHT eine Zahl vom Wert 4               |
| `x > 5`         | x ist Zahl grösser als 5                       |
| `x >= 5`        | x ist Zahl grösser gleich 5                    |
| `x < 5`         | x ist Zahl kleiner als 5                       |
| `x <= 5`        | x ist Zahl kleiner gleich 5                    |

**Wichtig:** Beachte das **Doppelgleichzeichen** `==`. Eine Bedingung mit nur einem Gleichzeichen wie z.B. `x = 4` funktioniert nicht!

Oft hat man die Situation, in der man zwischen zwei Situationen unterscheiden möchte:

   * Eine Bedingung wird erfüllt.
   * Eine Bedingung wird //nicht// erfüllt.

Dies erreicht man mit einem **if-else**-Befehl (else: ansonsten):

<code python>
if BEDINGUNG:
    # Code, falls BEDINGUNG erfüllt ist
else:
    # Code, falls BEDINGUNG nicht erfüllt ist
</code>

Es gibt auch die Situation, in der man verschiedene Bedingungen überprüfen möchte. Je nachdem, welche Bedingung erfüllt wird, wird ein anderer Codeblock ausgeführt. Ein solcher **if-elif-else**-Befehl hat die Form:

<code python>
if BEDINGUNG1:
    # Code, falls BEDINGUNG1 erfüllt ist.
elif BEDINGUNG2:
    # Code, falls BEDINGUNG2 erfüllt ist, aber nicht BEDINGUNG1.
else:
    # Code, falls keine der Bedingungen erfüllt ist.
</code>

Bemerkungen:

   * Man kann beliebig viele //elif//-Befehle hintereinanter haben.
   * Falls die Bedingung bei //if// erfüllt ist, werden alle //elif//s gar nicht mehr überprüft!
   * Gleiches gilt für //elif//s: Sobald die Bedingung von einem //elif// erfüllt wird, werden alle //elif//s weiter unten ignoriert.

==== - Beispiel ====

Wir wollen ein Programm schreiben, in dem der Benutzer eine Zahl eintippen soll. Der Code soll dann entscheiden, ob die Zahl positiv oder negativ ist und eine entsprechende Message ausgeben:

<code python>
x = input("Tippe eine Zahl ein:")

if x >= 0:
    print("Die Zahl {0} ist positiv.".format(x))
else:
    print("Die Zahl {0} ist negativ.".format(x))
</code>

Tippe dieses Beispiel ab (nicht einfach copy paste!) und führe es aus. Versuche dann, jede Zeile genau zu verstehen:

Schauen wir uns dies etwas genauer an: `if x >= 0` überprüft, ob die Zahl grösser gleich 0 ist. Falls ja wird der darauffolgende print-Befehl ausgeführt, in dem mitgeteilt wird, dass die Zahl positiv ist. Falls die Bedingung `if x >= 0` //nicht// erfüllt ist, muss die Zahl also negativ sein. Deshalb wird in diesem Fall der print-Befehl nach dem //else// ausgeführt.


==== - Aufgaben E ====

=== Aufgabe E1 ===

Nimm den Code aus dem Beispiel als Startpunkt. In diesem wird eine Zahl eingeben wird und dann entschieden, ob die Zahl positiv oder negativ ist. Erweitere den Code nun so, dass zwischen den folgenden drei Fällen unterschieden wird:

   * x ist positiv
   * x ist genau gleich 0
   * x ist negativ

//Tipp:// Hier benötigst du einen //if-elif-else//-Befehl.

=== Aufgabe E2 ===

Schreibe ein Programm, in dem der Benutzer eine Figur wünschen kann, die der Turtle dann abläuft. Diese sollen sein:

   * Quadrat
   * Kreis

Der Benutzer soll dazu aufgefordert werden, eine Figur einzutippen (also z.B. "Quadrat"). Dann soll der Turtle diese Figur ablaufen. Achte darauf, dass der Benutzer den Input //genau// so schreiben muss, wie es in der Bedingung steht! Gib dem Benutzer als Hilfe die zur Auswahl stehenden Figuren vor. Falls etwas falsches eingetippt wird, soll der Benutzer freundlich darauf hingewiesen werden, dass seine Eingabe nicht zulässig ist.

*Optional: Füge weitere Figuren hinzu.

=== Aufgabe E3 ===

== Schritt 1 ==

Schreibe ein kleines **Mathe-Quiz-Spiel**. Der Benutzer soll eine Additionsrechnung erhalten, die er lösen soll. Nachdem er das Resultat eingegeben hat, soll er die Rückmeldung erhalten, ob das Resultat korrekt war oder nicht.

== Schritt 2 ==

Erweitere nun dein Mathe-Quiz. In diesem soll die Aufgabe per Zufall generiert werden. Nutze den Zufallsgenerator von Python, um die beiden Zahlen, die addiert werden sollen, zufällig zu wählen.

Dazu musst du das //random//-Modul einbinden.

<code python>
import random # schreibe dies ganz oben in deinem Code
...
zahl1 = random.randint(0,10) # wählt zufällig eine Zahl aus den Zahlen 0,1,2,3,...,9,10 aus
...
</code>


===== - While-Schleife =====

Oft wollen wir einen Schritt mehrmals wiederholen. Dies können wir mit einer **while-Schleife** (dt. //während//) umsetzen. Diese hat folgende Form:

<code python>
...
while BEDINGUNG:
    ... # Dieser Codeblock wird solange ausgefuehrt,
    ... # wie die BEDINGUNG True (also erfuellt) ist

... # Dieser Code wird ausgefuehrt
... # sobald die BEDINGUNG nicht mehr erfuellt ist
</code>

Die Bedingungen schreibt man gleich wie für if-Verzweigungen, also `==, >, >=, ...`

**Beispiel:** Im folgenden Programm wird man aufgefordert, eine positive Zahl einzugeben. Man kann solange weiterspielen, bis man etwas eingibt, was //keine// positive Zahl ist, also z.B. eine negative Zahl oder Text.

<code python>
x = input("Gib eine positive Zahl ein:")

while x > 0:
    x = input("Gib eine positive Zahl ein:")

print("Game Over! Du hast etwas eingegeben, was keine positive Zahl ist.")
</code>

Tippe diesen Code ab, führe ihn aus und stelle sicher, dass du jede Zeile verstehst.

Falls wir einen Codeblock so oft ausführen wollen, bis der Benutzer abbricht, können wir eine **Endlosschleife** erzeugen. Wir schreiben dazu eine while-Schleife mit einer Bedingung, die //immer// erfüllt ist. Eine Möglichkeit wäre `7==7`, einfacher ist es aber, einfach `True` zu schreiben:

<code python>
...
while True:
    ... # Dieser Code wird solange ausgeführt, bis der Benutzer abbricht

... # Dieser Code wird NIE erreicht
</code>

Eine Möglichkeit gibt es aber, aus eine Schleife wie der oberen (`while True: ...`) auszubrechen: Wird der Befehl `break` aufgerufen, wird die **Schleife umgehend abgebrochen** und der Code unterhalb wird ausgeführt. 

==== - Aufgaben F ====

=== Aufgabe F1 ===

Schreibe ein Programm, in dem man eine zweistellige Zahl eingeben soll. Dies soll man solange machen können, bis man diese Bedingung einmal nicht mehr erfüllt.

Beachte, dass du dazu zwei Bedingungen (Bedingung 1: grösser gleich 10, Bedingung 2: kleiner als 100) verknüpfen muss. Dies kann man einfach mit dem Keyword `and` erreichen. Dies funktioniert für Verzweigungen und while-Schleifen:

<code python>
if BEDINGUNG1 and BEDINGUNG2:
    ...
    
while BEDINGUNG1 and BEDINGUNG2:
    ...    
</code>

=== Aufgabe F2 ===
Oft wollen wir einen Schritt eine bestimmte Anzahl mal wiederholen. In TigerJython können wir dazu `repeat` verwenden, was aber in Python nicht unterstützt wird. Wie kannst du die gleiche Funktionalität erhalten mit `while`?

Schreibe Turtle Code, der ein Quadrat zeichnet, aber verwende dazu nur `while`.

=== Aufgabe F3 ===
Erweitere nun dein Spiel aus E3 wie folgt:

== Schritt 1 ==

Erweitere nun dein Spiel wie folgt: Es sollen mehrere Runden gespielt werden, wobei in jeder Runde eine Zufallsaufgabe generiert wird (wie in Schritt 2). Es soll mitgezählt werden, wie viele Aufgaben richtig gelöst wurden. Nach jeder Frage wird der Spielstand ausgegeben, der Spieler soll eine entsprechende Rückmeldung erhalten, z.B.:
''Du hast 7 von 10 Aufgaben richtig gelöst.''

=== Aufgabe F4 (optional) ===

Gleich wie Aufgabe F3. Es sollen aber neben der Addition auch Subtraktionen und Multiplikationen vorkommen. Die Division sollte weggelassen werden, da es dort schnell Aufgaben gibt, die man kaum lösen kann. Welche der drei Operationen an der Reihe ist, soll ebenfalls der Zufall entscheiden.

=== Aufgabe F5 ===

Mache eine Kopie von deinem Mathe-Quiz aus der letzten Aufgabe. 
Wähle eine der beiden Varianten:

== Variante 1 (einfacher) ==

Man soll solange spielen können, bis man einen Fehler macht. Bei einem Fehler ist Game Over.

== Variante 2 (etwas anspruchsvoller, aber empfohlen!) ==

Man soll solange spielen können, bis man drei Fehler gemacht hat. Dann ist Game Over.

=== Aufgabe F6 ===
Schreibe eine Programm, das wie folgt funktioniert:
  * Die Benutzer:in muss eine positive, zweistellige Zahl eingeben. Hierzu wird sie solange aufgefordert, bis sie wirklich eine positive, zweistellige Zahl eingegeben hat. 
  * Dann macht das Programm Folgendes:
    * Wenn die eingegebene Zahl gerade (also restlos durch 2 teilbar) ist, dann gibt das Programm alle geraden Zahlen von 0 bis zur eingegeben Zahl aus. 
    * Wenn die eingegebene Zahl ungerade ist, dann gibt das Programm alle Zahlen der Fünfer-Reihe von 0 bis (in etwa) zur eingegeben Zahl aus.