====== Programmieren II: Python Grundlagen ======
 
===== Von Struktogrammen zu Python =====

Du kannst nun mit Struktogrammen einfache Programme schreiben. Damit wir diese auch einem Computer zum Ausführen geben können, müssen wir diese in einer Sprache formulieren, die ein Computer versteht. Wir wählen dazu die Programmiersprache **Python**. Die Elemente, die wir bei den Struktogrammen kennengelernt haben, gibt es auch in Python.

<WRAP group>
<WRAP 45% column>
=== Struktogramm ===
</WRAP>
<WRAP 45% column>
=== Python ===
</WRAP>
</WRAP>

In einer **Variablen** kann ein Wert //gespeichert// werden. Zum Beispiel kann man der Variablen `x` den Wert $42$ oder der Variablen `name` den Wert `"Albert Einstein"` zuweisen.

<WRAP group>
<WRAP 45% column>
{{ :gf_informatik:x_42.png?300 |}}
{{ :gf_informatik:meinnameistalbert.png?300 |}}
</WRAP>
<WRAP 45% column>
<code python>
x = 42
name = "Albert Einstein"
</code>
Variablen haben unterschiedliche **Datentypen:**
   * `x` ist ein **Integer** (kurz **int**), also eine *ganze Zahl*
   * `name` ist ein **String**, also //Text//. Dafür werden Anführungs- & Schlusszeichen (`'` oder `"`) verwendet.
</WRAP>
Mehrere Anweisungen bilden zusammen eine **Sequenz**, die von oben nach unten ausgeführt wird.
</WRAP>
\\ \\
Mit einer **Schleife** kann man einen Codeblock wiederholt ausführen lassen und zwar solange, wie eine vorgegebene Bedingung erfüllt ist.

<WRAP group>
<WRAP 45% column>
{{ :gf_informatik: struktogramme_solange.png?300 |}}
Der Balken auf der linken Seite (hier blau) gibt an, welche Zeilen Code genau zum Codeblock der Schleife gehören.
</WRAP>
<WRAP 45% column>
<code python>
while BEDINGUNG:
    # Codeblock der ausgeführt wird, solange (while)
    # Bedingung erfüllt ist.
    # Nachdem Codeblock komplett ausgeführt wurde,
    # wird Bedingung wieder neu überprüft.
</code>
Alle Zeilen Code, die zum Codeblock der Schleife gehören werden //gleichmässig eingerückt//. Verwende dazu die //Tab//-Taste oben links (s. [[user:hof:copypaste#text-editing|Tastaturbefehle]]. 
</WRAP>
</WRAP>
\\ \\
Mit einer **Verzweigung** trifft das Programm eine Entscheidung: Je nach dem, ob eine vorgegebene Bedingung erfüllt ist oder nicht, nimmt der Code einen anderen Verlauf.

<WRAP group>
<WRAP 45% column>
{{ :gf_informatik:struktogramme_verzweigungen.png?300 |}}
</WRAP>
<WRAP 45% column>
<code python>
if BEDINGUNG:
    # Codeblock der ausgeführt wird,
    # falls (if) Bedingung erfüllt ist
else:
    # Codeblock der ausgeführt wird,
    # der ansonsten ausgeführt wird,
    # falls also Bedingung NICHT erfüllt ist
</code>
Auch hier muss auf eine korrekte Einrückung geachtet werden.
</WRAP>
</WRAP> 
\\ \\
**Eingabe** und **Ausgabe**:

<WRAP group>
<WRAP 45% column>
{{ :gf_informatik: struktogramme_input.png?300 |}}
{{ :gf_informatik: struktogramme_input_str.png?300 |}}
{{ :gf_informatik: struktogramme_output.png?300 |}}
</WRAP>
<WRAP 45% column>
<code python>
x = int(input("Gib eine Zahl ein")) # Aufforderung, etwas einzugeben, wird sichergestellt, dass Zahl ist, dann in Variable x gespeichert
s = str(input("Gib einen String ein")) # wie oben, wird aber als Text (String) gespeichert
print(x) # der Wert der Variablen x wird in Konsole ausgegeben
</code>
</WRAP>
</WRAP> 

==== Variablen, Verzweigungen, Schleifen in Python ====

Die oben aufgeführten Programmier-Konstrukte werden im [[gf_informatik:programmieren_ii:variablen_verzweigungen_schleifen|Skript]] im Detail erklärt.

==== Aufgaben A ====

Alle Befehle, die wir in Struktogrammen kennengelernt haben, gibt es in ganz ähnlicher Form auch für die Programmiersprache Python. In diesem ersten Aufgabenblock geht es darum, Struktogramme in Python und umgekehrt zu 'übersetzen'.

Löse diese Aufgaben zuerst auf **Papier** und erst dann am Computer, wenn dies im Auftrag vorgegeben wird.

=== Aufgabe A1 ===

== Teil I==

Schlage deine Lösung zu Teil i) der [[gf_informatik:algorithmen_i#aufgabe_c2_struktogramme_aufschreiben|Aufgabe C2]] nach. Sie sollte in etwa so aussehen:

{{ :gf_informatik:taschenrechner_1op.png?250 |}}

Schreibe das entsprechende Programm in Python (auf Papier).

== Teil II==

Wie Teil 1, aber für Teil ii) der Aufgabe C2.
{{ :gf_informatik:struktogramme_aufgabe_d_lsg.png?250 |}}

==Teil III==

Probiere deine Lösungen (eine nach der anderen) am Computer in **TigerPython** aus: Tippe deinen Code ab, verwende für **Einrückungen** die *Tabulator* Taste (oben links). Führe dann den Code aus (grüner Pfeil oder F5)

=== Aufgabe A2 ===

Übersetze das Struktogramm zur folgenden Struktogramm, das einen Countdown ausgibt:
{{ :gf_informatik:struktogramm_countdown.png?250 |}}

   1. zuerst auf Papier.
   1. Probiere deine Lösung dann am Computer aus.

=== Aufgabe A3 ===

Übersetze alle Teilaufgaben aus der [[gf_informatik:algorithmen_i#aufgabe_c1_struktogramme_evaluieren_verstehen|Aufgabe C1]] auch nach Python, und zwar direkt am Computer.

=== Zusatzaufgaben A ===

Übersetze die Struktogramme der [[gf_informatik:algorithmen_i#aufgabe_c4_zusatzaufgabeteilertest|Zusatzaufgaben C4 / C5]] auf Python.

<nodisp 1>

++++Lösungen Aufgaben A|

==== Lösungen A ====

=== Aufgabe A1 ===

== Teil I==

<bottom-editor>
x = int(input('Gib eine Zahl ein'))
y = int(input('Gib eine Zahl ein'))
print(x + y)
</bottom-editor>

== Teil II==

Einfach:
<bottom-editor>
x = int(input('Gib eine Zahl ein'))
y = int(input('Gib eine Zahl ein'))

if x > y:
    print(x)
else:
    print(y)
</bottom-editor>


=== Aufgabe A2 ===
<bottom-editor>
n = int(input("Gib Startzahl von Countdown ein!"))

while n > 0:
    print(n)
    n = n - 1

print("Los!")
</bottom-editor>

=== Aufgabe A3 ===
== Teil I ==
<bottom-editor>
a = int(input("Gib Zahl ein"))
b = int(input("Gib Zahl ein"))
c = 0
while a >= b:
    a = a - b
    c = c + 1
print(c)
print(a)
</bottom-editor>

== Teil II ==
<bottom-editor>
n = int(input("Gib Zahl ein"))
summe = 0
zahl = 0
while zahl < n:
    zahl = zahl + 1
    summe = summe + zahl
print(summe)
</bottom-editor>

=== Aufgabe A4 ===
<bottom-editor>
zahl = int(input("Eine Zahl eingeben: "))
kandidat = 2
while kandidat < zahl:
    a = zahl
    b = kandidat
    while b <= a:
        a = a - b
    if a == 0:
        print("Zahl ist keine Primzahl")
        quit()
    kandidat = kandidat + 1
print("Zahl ist eine Primzahl")
</bottom-editor>


++++
</nodisp>

===== Python Grundlagen =====

<nodisp 2>
++++Gruppenpuzzle|

=== Gruppenpuzzle ===

== Phase I: Expert:in werden! ==

   * Zeit: 10'
   * Alle mit gleichem Thema (A,B,C) treffen sich.
   * Einzeln Theorie durchlesen ...
   * ... dann zusammen besprechen ...
   * ... und Fragen beantworten.
   * Bei Bedarf darf auch mit TigerJython ausprobiert werden.

== Phase II: Austausch mit anderen Expert:innen ==

   * Zeit: 15’
   * Dreiergruppen: je A,B,C mit gleicher Nummer (z.B. A4,B4,C4)
   * Jede Expert:in stellt anderen ihr Thema vor.
   * Ziel: Alle verstehen alles!

++++
</nodisp>

==== Kommentare ====

Auf den unteren Zeilen des obigen Beispiels findest du **Kommentare.** Diese beginnen mit einem Hashtag `#`. Sämtlicher Code der folgt, wird von Python //ignoriert//. Damit kann man seinem Code zum Beispiel Überschriften oder Erklärungen anfügen. Möchte man Kommentare über mehrere Zeilen schreiben, verwendet man drei Anführungszeichen:
<code python>
# single line comment

"""
multi
line
comment
"""
</code>


++++Leitfragen|

   * Warum sollte man seinem Code Kommentare anfügen?
   * Wann braucht man `#` und wann `"""` für Kommentare?

++++


==== Vergleichsoperatoren ====

Für Bedingungen in Verzweigungen und Schleifen benötigen wir **Vergleichsoperatoren:**

^ Operator        ^ 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 (Ungleich-Operator).  |
| `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                          |
| `5 <= x <= 10`  | `x` ist Zahl zwischen 5 und 10 (inklusive)             |


++++Leitfragen|

   * Bisher nicht gebraucht haben wir den `!=` Operator. Wozu ist dieser nützlich?
   * Mache ein konkretes Beispiel für den `!=` Operator.
   * Was ist der Unterschied zwischen dem `>` und dem `>=` Operator?

++++


==== Mathematische Operationen ====

Neben dem `+` gibt es eine Vielzahl an **mathematischen Operatoren**:

^ 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. 5 hoch 2) | `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` |

**Achtung:** Für `sqrt` muss noch das Mathe-Modul importiert werden:
<code python>
from math import *
</code>

++++Leitfragen|

   * Wie rechnet man hoch (Potenzen)?
   * Was ist der Unterschied zwischen `/` und `//`?
   * Was macht der Modulo Operator `%`? Wozu ist dieser nützlich?

++++


==== Strings (Zeichenketten) ====

Strings werden bekanntlich mit Anführungs- und Schlusszeichen geschriebene, zum Beispiel:
<code python>
name = "Albert Einstein" # Ob doppeltes Anfuehrungs-/Schlusszeichen oder....
job = 'Physicist'        # ... einfaches spielt keine Regel. In einem String darf man einfach nicht mischen.
</code>

Oft möchte man mehrere Strings und Zahlen zu einem einzelnen String kombinieren. Einzelne Strings können mit `+` zusammengefügt werden. Möchte man eine Zahl-Variable `x` an einen String anfügen, so muss man diese zuerst in einen String umwandeln: `str(x)`. Ein String, der aus mehreren einzelnen Strings und Zahlen zusammengesetzt wurde, nennt man einen **formatierten String**. Wird der String mit print ausgegeben, so spricht man von einer **formatierten Ausgabe**. Beispiel:

<bottom-editor>
firstname = "Albert"
lastname = "Einstein"
print("Full name is " + firstname + " " + lastname + "!")
</bottom-editor>

Beachte, dass der **Plus-Operator** `+` komplett **unterschiedliche Bedeutungen** haben kann, je nach Situation, in der er angewendet wird:
   * `3 + 7`: Wird er auf *zwei Zahlen* angewendet, so handelt es sich um die normale **mathematische Addition**. Das Resultat ist also `10`.
   * `"Hallo " + "Klasse"` oder `"3" + "7"`: Wird er auf *zwei Strings* angewendet, werden diese **aneinander gehängt**. Resultat: `"Hallo Klasse"`, resp. `"37"`
   * **Mischt** man die beiden, z.B. `"Meine Lieblingszahl ist " + x` (wobei `x = 42`), so erhält man einen **Fehler**. Um diesen zu beheben, muss man den Wert von `x` vorher noch in einen String umwandeln: `"Meine Lieblingszahl ist " + str(x)`

Praktisch sind auch die Befehle `s.lower()` und `s.upper()`, mit denen ein String `s` in kleinbuchstaben, resp. GROSSBUCHSTABEN umgewandelt werden.

=== Stringformatierung ===
Um eine schöne Ausgabe mit verschiedenen Variablen egal welchen Typs zu erhalten, verwendet man Format-Strings. Sobald vor dem ersten Anführungszeichen der Buchstabe `f` steht, können Variablen mittels geschweifter Klammern in den String eingebettet werden.

<bottom-editor>
age = 42
first_name = 'Albert'
last_name = 'Einstein'

print(f'My name is {first_name} {last_name} and I am {age} years old')
</bottom-editor>


++++Leitfragen|

   * Wie fügt man Strings mit Zahlen zu einem neuen String zusammen?
   * Dies ist nützlich, um z.B. ein mathematisches Resultat in einem Satz schön zu präsenteren. Mache ein Beispiel.
   * In welchen Situationen darf man den `+`-Operator (nicht) anwenden? Was sind die Unterschiede?
   * Wozu braucht man `s.lower()` und `s.upper()`. In welcher Situation könnten diese Funktionen nützlich sein?

++++


==== Zufallszahlen ====

Mithilfe des **random**-Moduls können ganz einfach Zufallszahlen erzeugt werden. Folgender Code simuliert den Wurf eines Würfels:
<bottom-editor>
import random

z = random.randint(1,6) # bestimmt eine Zufallszahl aus Bereich 1,2,3,4,5,6
print(z)
</bottom-editor>

Beachte, dass die Zufallsfunktion **randint** heisst. Dies steht für '**rand**om **int**eger', also 'zufällige ganze Zahl'. Ganze Zahlen sind Zahlen ohne Nachkommastellen, also $\ldots, -3,-2,-1,0,1,2,3,\ldots$.

<nodisp 2>
++++Debugger:|
==== Debugger ====

Verwende den Debugger (Breakpoints in VSCode), um deinen Code anzuhalten resp. verlangsamt durchlaufen zu lassen. Dies ist sehr nützlich um **Bugs**, also Fehler im Code, zu identifizieren. Daher auch der Name **Debugger**.
++++
</nodisp>

==== Verzweigungen im Detail ====

Im Kapitel haben wir bereits **if-else-Verzweigungen** kennengelernt:
<code python>
if BEDINGUNG:
    # Codeblock der ausgeführt wird,
    # falls (if) Bedingung erfüllt (True) ist
else:
    # Codeblock der ausgeführt wird,
    # der ansonsten ausgeführt wird,
    # falls also Bedingung NICHT erfüllt ist (False)
</code>
Diese sind sehr praktisch, wenn man im Code zwischen **zwei verschiedenen Fällen** unterscheiden will.

Gibt es aber **drei oder mehr Fälle**, muss man if-else-Verzweigungen ineinander verschachteln, wie zum Beispiel in der Schnaps, Bier & Sirup Aufgabe. Dadurch wird der Code sehr schnell unübersichtlich und fehleranfällig. Es ist dann besser, eine **if-elif-else-Verzweigung** zu programmieren, da man mit dieser **beliebig viele Fälle** unterscheiden kann:
<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 hintereinander schalten.
   * Falls die Bedingung bei //if// oder einem //elif// erfüllt ist, werden alle darauffolgenden //elif//s gar **nicht mehr überprüft**.



==== Aufgaben B ====

**Vorwissen:** [[#python_grundlagen|Weitere Grundlagen]]

=== Aufgabe B1 ===

Python ist super im rechnen und macht jeden Taschenrechner vergessen. Studiere das folgende kurze Kapitel zu den [[#mathematische_operationen|mathematischen Operationen]], welches eine Übersicht über die wichtigsten mathematischen Rechenoperationen beinhaltet.

Berechne mit Python und gib das Resultat aus:
   - Addiere $7777$ und $8888$
   - Subtrahiere $27312$ von $101432$
   - Wie oft kommt $29$ in $1447$ vor?
   - Ist $1764$ eine Quadratzahl oder nicht? Beispiel für Quadratzahlen: $49$, weil $7^2 = 49$

<bottom-exercise id="b1">
<template data-type="starter"></template>
<template data-type="test">
assert output_lines() == ["16665", "74120", "49", "42.0"]
</template>
<template data-type="solution">
from math import sqrt
# 1.
print(7777+8888)
# 2.
print(101432-27312)
# 3.
print(1447//29)
# 4.
print(sqrt(1764)) # ja, ist Quadratzahl
</template>
</bottom-exercise>

Bemerkung: Einzelne Werte können auch in Variablen gespeichert werden. Dann kann mit den Variablen gerechnet werden. Es macht den Code aber nur länger.


=== Aufgabe B2: Personendetails ===

Studiere das [[#strings_zeichenketten|Kapitel zu Strings.]]

<bottom-exercise id="b2">
<div slot="prompt">Schreibe ein Programm, in welchem eine Person der Reihe nach aufgefordert wird, ihren Namen, Wohnort und Alter (als <em>Zahl</em>, nicht String) einzugeben. Die Werte werden in passenden Variablen gespeichert. Die Details zur Person werden dann in einem schön formatierten String ausgegeben, z.B. "Fritz wohnt in Romanshorn und ist 42 Jahre alt!"
</div>

<template data-type="starter"></template>
<template data-type="solution">
name = input("Wie heisst du?")
city = input("Wo wohnst du?")
age  = int(input("Wie alt bist du?"))
print(name + " wohnt in " + city + " und ist " + str(age) + " Jahre alt!")
</template>
</bottom-exercise>

=== Aufgabe B3: Verbotenes Wort ===

Studiere das [[#vergleichsoperatoren|Kapitel zu Vergleichsoperatoren.]]

<bottom-exercise id="b3">
<div slot="prompt">Schreibe ein Programm, in welchem man aufgefordert wird, ein Wort einzugeben. Alle Eingaben sind ok bis auf eine: Die des verbotenen Wortes <b>"Voldemort"</b>. Gibt man dieses Wort ein, soll eine deutliche Warnung angezeigt werden mit der Aufforderung, dieses Wort nie wieder einzugeben! Ansonsten erhält man die Rückmeldung, dass das Wort in Ordnung sei. Verwende dazu den Ungleich-Operator!
</div>

<template data-type="starter"></template>
<template data-type="solution">
wort = str(input("Gib ein Wort ein!"))
if wort != "Voldemort":
    print("OK")
else:
    print("Das Wort ist bööööööse!")
</template>
</bottom-exercise>

=== Aufgabe B4: Kettenrechnung ===

<bottom-exercise id="b4">
<div slot="prompt">
Weise der Variablen <code>x</code> den Wert <code>7</code> zu. Verändere nun die Variable nacheinander wie folgt:
<ul>
   <li>verdopple sie
   <li>multipliziere mit 100
   <li>dividiere ganzzahlig (keine Nachkommazahlen) durch 80
   <li>rechne hoch drei
   <li>subtrahiere 13
   <li>ziehe die Quadratwurzel
   <li>dividiere durch 10
</ul>
Nun solltest du wieder 7 erhalten.
</div>
<template data-type="starter"></template>
<template data-type="solution">
from math import sqrt
x = 7
x = x*2
x = x*100
x = x // 80
x = x**3
x = x - 13
x = sqrt(x)
x = x // 10

print(x)
</template>
</bottom-exercise>


=== Aufgabe B5: Zähler ===


<bottom-exercise id="b5">
<div slot="prompt">
<ol>
   <li>Gib alle Zahlen 0,1,2,&hellip;, 9 mithilfe einer <em>Schleife</em> aus.
   <li>Gib nun alle Werte von 0 bis und mit 99 aus. Hast du den Code im ersten Schritt richtig programmiert, musst du nur einen *einzigen Wert* ändern.
</ol>
</div>
<template data-type="starter"></template>
<template data-type="solution">
i = 0
while i < 10: # oder 100
    print(i)
    i = i + 1
</template>
</bottom-exercise>



=== Aufgabe B6: Alter ===

<bottom-exercise id="b6">
<div slot="prompt">
Berechne dein Alter in Tagen, Stunden und Sekunden. Speichere zuerst dein Alter in Jahren in einer passenden Variablen, z.B.
<code>my_age_in_years = 14</code>

<p>Berechne nun das Alter in Tagen, Stunden und Sekunden.

<p>Effekte wie Schaltjahre oder Schaltsekunden musst du bei der Berechnung nicht berücksichtigen.

<p>Jeder Wert soll in einer Variablen mit passendem Namen, z.B. <code>my_age_in_seconds</code> gespeichert werden. Gib nun die berechneten Werte in formatierten Strings als Sätze aus, z.B.:
<ul>
   <li>"I am 14 years old."
   <li>"I am ... days old."
   <li>"..."
</ul>

<p>Wichtig! Ändert man nun den Wert von <code>my_age_in_years</code>, so müssen sich alle daraus berechneten Werte entsprechend anpassen!
</div>
<template data-type="starter">my_age_in_years = 14
</template>
<template data-type="solution">
my_age_in_years = 14
 
my_age_in_days = my_age_in_years * 365
my_age_in_hours = my_age_in_days * 24
my_age_in_seconds = my_age_in_hours * 3600

print(f"I am {my_age_in_years} years old.")
print(f"I am {my_age_in_days} days old.")
print(f"I am {my_age_in_hours} hours old.")
print(f"I am {my_age_in_seconds} seconds old.")
</template>
</bottom-exercise>


=== Aufgabe B7: Ganzzahldivision ===

<bottom-exercise id="b7">
<div slot="prompt">
Es sollen zwei Zahlen eingegeben werden. Der Code berechnet dann die Ganzzahldivision inklusive Rest der beiden Zahlen und gibt diese in einem formatierten String aus. 

<p>Beispiel: Werden 23 und 5 eingegeben, so ist die Ausgabe: "23 : 5 = 4 Rest 3"
</div>
<template data-type="starter">
</template>
<template data-type="solution">
zahl1 = int(input("Erste Zahl?"))
zahl2 = int(input("Zweite Zahl?"))
quotient = zahl1 // zahl2
rest = zahl1 % zahl2
print(f'{zahl1} : {zahl2} = {quotient} Rest {rest}')
</template>
</bottom-exercise>

==== Aufgaben C ====

**Vorwissen:** [[gf_informatik:programmieren_ii#python_grundlagen|Python Grundlagen]]

In einer alten Aufgabe hast du mithilfe von `repeat` ein Turtle ein Quadrat zeichnen lassen. Der `repeat` befehlt ist eine Eigenheit von TigerJython und *kein richtiges Python*. Verwendest du repeat, outest du dich als **uncool**, weshalb wir von nun an **an die Finger von repeat lassen** und stattdessen **while-Schleifen** verwenden! Bei allen weiteren **Prüfungen** ist das Verwenden von repeat verboten!

=== Aufgabe C1 ===

<bottom-exercise id="c1" layout="canvas" showswitcher>
<div slot="prompt">
Lasse eine Turtle ein Quadrat ablaufen, diesmal aber mithilfe der <code>while</code>-Schleife.
</div>
<template data-type="solution">
from turtle import *
turi = Turtle()
turi.hideturtle()

sides = 4
while sides > 0:
    turi.forward(100)
    turi.left(90)
    sides = sides - 1
</template>
</bottom-exercise>


=== Aufgabe C2 ===

Kannst du auch eine Spirale zeichnen? Beim Quadrat bleiben Seitenlänge und Winkel immer gleich - welcher der beiden Werte ändert sich bei der Spirale?

Zeichne erst eine Spirale. Zeichne dann ein zweite Spirale ähnlich wie im Bild. Zeichne dazu mit einer while-Schleife die eine. Versetze dann die Position deiner Turtle mit `teleport` und zeichne die Zweite Spirale mit einer neuen while-Schleife.

{{ : gf_informatik:spiralen_duo.png?250 |}}

<nodisp 0>
++++Tipps|

Definiere für die Seitenlänge eine Variable. Nach jedem Durchgang der Schleife wird die Variable um einen bestimmten Wert vergrössert.

++++
</nodisp>

<bottom-exercise id="c2" layout="canvas" showswitcher>
<template data-type="solution">
from turtle import *

monika = Turtle()
monika.hideturtle()

monika.teleport(-100,0)
length = 100
while length > 0:
    monika.forward(length)
    monika.left(90)
    length = length - 5
    
monika.teleport(100,0)
length = 100
while length > 0:
    monika.forward(length)
    monika.left(90)
    length = length - 2
</template>
</bottom-exercise>

=== Aufgabe C3 ===

Zeichne folgende Figur:

{{ : gf_informatik:spirale.png?200 |}}

<bottom-exercise id="c3" layout="canvas" showswitcher>
<template data-type="solution">
from turtle import *
t = Turtle()
t.hideturtle()

radius = 50
while radius > 0:
    t.circle(radius, 180)
    radius = radius - 4
</template>
</bottom-exercise>

=== Aufgabe C4 (optional) ===

Zeichne folgende Figur:

{{ : gf_informatik:spirale_rechteckig.png?250 |}}

<bottom-exercise id="c4" layout="canvas" showswitcher>
<template data-type="solution">
from turtle import *

kurt = Turtle()
kurt.speed(8)

side = 100      # Länge der kürzeren Seite
side_ratio = 2  # Soviel länger ist die längere Seite
step_size = 5   # Soviel wird die Länge kürzer pro Durchgang

while side > 0:
    kurt.forward(side * side_ratio)
    kurt.left(90)
    kurt.forward(side)
    kurt.left(90)
    side = side - step_size
</template>
</bottom-exercise>

=== Zusatzaufgabe C (Uhr) ===

Nutze TurtleGraphics, um eine Uhr zu simulieren. Wähle selbst aus, ob es eine traditionelle SBB-Uhr oder eine Digitaluhr sein soll:
   * SBB-Uhr: https://sca.ksr.ch/doku.php?id=gf_informatik:programmieren_zusatzaufgaben#sbb-uhr
   * Digitaluhr: https://sca.ksr.ch/doku.php?id=gf_informatik:programmieren_zusatzaufgaben#digitale_uhr

Schicke das Endresultat per Teams der Lehrperson.


==== Aufgaben D ====

**Vorwissen:** [[gf_informatik:programmieren_ii#verzweigungen_im_detail|Verzweigungen im Detail]]

Bei diesen Aufgaben geht es um folgendes:

   * Verzweigungen mit elif zu programmieren
   * etwas längere Programme schreiben


=== Aufgabe D1 ===

<bottom-exercise id="d1">
<div slot="prompt">
Das Programm soll:
<ul>
  <li>den Benutzer nach dem Alter fragen
  <li>Ausgeben, ob der Benutzer Schnaps, Bier oder Sirup trinken darf.
</ul>
<p>Programmiere die Schnaps, Bier & Sirup Aufgabe mit einer if-elif-else-Verzweigung.
</div>
<template data-type="solution">
age = int(input("Gib dein Alter ein"))

if age >= 18:
    print("Schnaps!")
elif age >= 16:
    print("Bier!")
else:
    print("Sirup!")
</template>
</bottom-exercise>

=== Aufgabe D2 ===

<bottom-exercise id="d2">
<div slot="prompt">
Die Benutzerin wird aufgefordert, eine Zahl einzugeben. Der Code analysiert, ob die Zahl positiv, Null oder negativ ist und gibt eine entsprechende Nachricht.
</div>
<template data-type="solution">
x = int(input("Gib eine Zahl ein"))

if x > 0:
    print("Positiv!")
elif x == 0:
    print("Null!")
else:
    print("Negativ!")
</template>
</bottom-exercise>

=== Aufgabe D3 ===

== Teil I ==

<bottom-exercise id="d3" layout="canvas" showswitcher>
<div slot="prompt">
Der Benutzer wird aufgefordert, eine der folgenden Eingaben zu machen:

<ul>
   <li>"q" für Quadrat
   <li>"k" für Kreis
   <li>"r" für Rechteck
   <li>"..." für eigene Figur
</ul>

<p>Die Turtle zeichnet dann die entsprechende Figur. Vermeide Code-Repetitionen, verwende stattdessen Schleifen!

<p>Wird etwas anderes eingegeben, so soll eine der folgenden Varianten zum Zug kommen (entscheide selbst):

<ul>
   <li>Variante 1: einfach eine Rückmeldung, dass unzulässige Eingabe
   <li>Variante 2: Turtle läuft ein Fragezeichen ab 
</ul>
</div>
<template data-type="solution">
from turtle import *

turi = Turtle()
turi.speed(8)
turi.hideturtle()

shape = str(input("Gib ein q (Quadrat), k (Kreis) oder r (Rechteck)"))
pen_color = str(input("Waehle die Stiftfarbe"))
fill_color = str(input("Waehle die Füllfarbe"))

turi.color(pen_color)
turi.fillcolor(fill_color)
turi.width(10)
turi.begin_fill()

if shape == "q":
    i = 0
    while i < 4:
        turi.forward(200)
        turi.right(90)
        i = i + 1
elif shape == "k":
    turi.circle(100, 360)
elif shape == "r":
    i = 0
    while i < 2:
        turi.forward(200)
        turi.right(90)
        turi.forward(400)
        turi.right(90)
        i = i + 1    
else:
    print("ungueltige Eingabe!") 

turi.end_fill() 
</template>
</bottom-exercise>

== Teil II ==

Erweitere nun deinen Code wie folgt:

   1. Nach der Eingabe für die Form soll der Benutzer die Farbe für den Stift und die Füllfarbe auswählen können (//Tipp:// `farbe = str(input("Farbe eingeben (z.B. 'red'): ")`). Mehr zu Farben findest du [[gf_informatik:programmieren_i#farben_optional|hier]].
   1. Der Stift wird auf die entsprechende Farbe gesetzt: `t.color(farbe)`.
   1. Flächen füllen mit `t.begin_fill()` und `t.end_fill()`.

=== Aufgabe D4 ===

== 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 [[#zufallszahlen|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
...
x = random.randint(0,10) # wählt zufällig eine Zahl aus den Zahlen 0,1,2,3,...,9,10 aus
...
</code>

== Schritt 3 ==

Erweitere nun dein Spiel wie folgt: Insgesamt sollen 10 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. Am Schluss soll der Spieler eine entsprechende Rückmeldung erhalten, z.B.:
''Du hast 7 von 10 Aufgaben richtig gelöst.''

== Schritt 4 ==

Gleich wie Schritt 3, die Rückmeldung soll aber erweitert werden. Je nach erreichter Anzahl Punkte soll eine andere Meldung erscheinen:

|**Erreichte Punkte**|**Meldung**|
|10|Perfekt, du hast alle Aufgaben richtig gelöst!|
|8-9|Sehr gut, du hast fast alle Aufgaben richtig gelöst!|
|6-7|Nicht schlecht, du hast mehr als die Hälfte der Aufgaben richtig gelöst!|
|5|Genügend, du hast die Häfte der Aufgaben richtig gelöst|
|1-4|Ungenügend, du hast leider weniger als die Hälfte der Aufgaben richtig gelöst|
|0|Leider hast du alle Aufgaben falsch gelöst. Zurück in die Primarschule!|

<bottom-exercise id="d4">
<template data-type="solution">
import random

questions = 0
correct = 0

while questions < 10:
    questions = questions + 1

    x = random.randint(1, 20)
    y = random.randint(1, 20)
    result = x + y
    answer = int(input(f'Was ergibt {x} + {y} ?'))
    if answer == result:
        correct = correct + 1

print(f'Du hast {correct} von 10 Aufgaben richtig gelöst!')
</template>
</bottom-exercise>

=== Aufgabe D5 (optional) ===

Mache eine Kopie von deinem Mathe-Quiz. Erweitere deinen Code nun so, dass neben der Addition auch Subtraktionen und Multiplikationen vorkommen können. 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.