====== 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.
=== Struktogramm ===
=== Python ===
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.
{{ :gf_informatik:x_42.png?300 |}}
{{ :gf_informatik:meinnameistalbert.png?300 |}}
x = 42
name = "Albert Einstein"
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.
\\ \\
Mit einer **Schleife** kann man einen Codeblock wiederholt ausführen lassen und zwar solange, wie eine vorgegebene Bedingung erfüllt ist.
{{ :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.
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.
Alle Zeilen Code, die zum Codeblock der Schleife gehören werden //gleichmässig eingerückt//. Verwende dazu die //Tab//-Taste oben links.
\\ \\
Mit einer **Verzweigung** kann man das Programm eine Entscheidung treffen: Je nach dem, ob eine vorgegebene Bedingung erfüllt ist oder nicht, nimmt der Code einen anderen Verlauf.
{{ :gf_informatik:struktogramme_verzweigungen.png?300 |}}
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
Auch hier muss auf eine korrekte Einrückung geachtet werden.
\\ \\
**Eingabe** und **Ausgabe**:
{{ :gf_informatik: struktogramme_input.png?300 |}}
{{ :gf_informatik: struktogramme_input_str.png?300 |}}
{{ :gf_informatik: struktogramme_output.png?300 |}}
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
==== Variablen, Verzweigungen, Schleifen in Python ====
Die oben aufgeführten Programmier-Konstrukte werden im [[gf_informatik:programmieren_ii:variablen_verzweigungen_schleifen|Skript]] im Detail erklär.
==== 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.
++++Lösungen Aufgaben A|
==== Lösungen A ====
=== Aufgabe A1 ===
== Teil I==
x = int(input('Gib eine Zahl ein'))
y = int(input('Gib eine Zahl ein'))
print(x + y)
== Teil II==
Einfach:
x = int(input('Gib eine Zahl ein'))
y = int(input('Gib eine Zahl ein'))
if x > y:
print(x)
else:
print(y)
=== Aufgabe A2 ===
n = int(input("Gib Startzahl von Countdown ein!"))
while n > 0:
print(n)
n = n - 1
print("Los!")
=== Aufgabe A3 ===
== Teil I ==
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)
== Teil II ==
n = int(input("Gib Zahl ein"))
summe = 0
zahl = 0
while zahl < n:
zahl = zahl + 1
summe = summe + zahl
print(summe)
=== Aufgabe A4 ===
TBD
++++
===== Python Grundlagen =====
++++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!
++++
==== 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:
# single line comment
"""
multi
line
comment
"""
++++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:
from math import *
++++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:
name = "Albert Einstein" # Ob doppeltes Anfuehrungs-/Schlusszeichen oder....
job = 'Physicist' # ... einfaches spielt keine Regel. In einem String darf man einfach nicht mischen.
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:
firstname = "Albert"
lastname = "Einstein"
print("Full name is " + firstname + " " + lastname + "!")
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.
++++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:
import random
z = random.randint(1,6) # bestimmt eine Zufallszahl aus Bereich 1,2,3,4,5,6
print(z)
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$.
++++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**.
++++
==== Verzweigungen im Detail ====
Im Kapitel haben wir bereits **if-else-Verzweigungen** kennengelernt:
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)
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:
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.
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$
=== Aufgabe B2: Personendetails ===
Studiere das [[#strings_zeichenketten|Kapitel zu Strings.]]
Schreibe ein Programm, in welchem eine Person der Reihe nach aufgefordert wird, ihren Namen, Wohnort und Alter (als *Zahl*, 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!"
=== Aufgabe B3: Verbotenes Wort ===
Studiere das [[#vergleichsoperatoren|Kapitel zu Vergleichsoperatoren.]]
Schreibe ein Programm, in welchem man aufgefordert wird, ein Wort einzugeben. Alle Eingaben sind ok bis auf eine: Die des verbotenen Wortes **"Voldemort"**. 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.
=== Aufgabe B4: Kettenrechnung ===
Weise der Variablen `x` den Wert $7$ zu. Verändere nun die Variable nacheinander wie folgt:
- verdopple sie
- multipliziere mit 100
- dividiere ganzzahlig (keine Nachkommazahlen) durch 80
- rechne hoch drei
- subtrahiere 13
- ziehe die Quadratwurzel
- dividiere durch 10
Nun solltest du wieder 7 erhalten.
=== Aufgabe B5: Zähler ===
1. Gib alle Zahlen $0,1,2, \ldots, 9$ mithilfe einer *Schleife* aus.
1. 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.
=== Aufgabe B6: Alter ===
Berechne dein Alter in Tagen, Stunden und Sekunden. Speichere zuerst dein Alter in Jahren in einer passenden Variablen, z.B.
my_age_in_years = 14
Berechne nun das Alter in:
- Tagen
- Stunden
- Sekunden
Effekte wie Schaltjahre oder Schaltsekunden darfst du bei der Berechnung nicht berücksichtigen.
Jeder Wert soll in einer Variablen mit passendem Namen, z.B. `my_age_in_seconds` gespeichert werden. Gib nun die berechneten Werte in formatierten Strings als Sätze aus, z.B.:
- "I am 14 years old."
- "I am ... days old."
- "..."
Wichtig! Ändert man nun den Wert von `my_age_in_years`, so müssen sich alle daraus berechneten Werte entsprechend anpassen!
=== Aufgabe B7: Ganzzahldivision ===
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.
Beispiel: Werden $23$ und $5$ eingegeben, so ist die Ausgabe: "23 : 5 = 4 Rest 3"
++++Lösungen Aufgaben B|
==== Lösungen B ====
=== Aufgabe B1 ===
# 1.
print(7777+8888)
# 2.
print(101432-27312)
# 3.
print(1447//29)
# 4.
print(sqrt(1764)) # ja, ist Quadratzahl
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 ===
name = input("Wie heisst du?")
city = input("Wo wohnst du?")
age = input("Wie alt bist du?")
print(name + " wohnt in " + city + " und ist " + str(age) + " Jahre alt!")
=== Aufgabe B3 ===
=== Aufgabe B4 ===
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)
=== Aufgabe B5 ===
Zählen von $0$ bis $9$:
i = 0
while i < 10:
print(i)
i = i + 1
Zählen von $0$ bis $99$, es muss nur $10$ durch $9$ ersetzt werden.
i = 0
while i < 100:
print(i)
i = i + 1
Beachte, Code kann auch z.B. mit `while i <= 9` geschrieben werden. Die Notation `while i < 10` hat aber den Vorteil, dass man sofort sieht, wieviele Zahlen ($10$) angezeigt werden. Natürlich muss dafür $i$ bei $0$ starten.
=== Aufgabe B6 ===
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("I am " + str(my_age_in_years) + " years old.")
print("I am " + str(my_age_in_days) + " day old.")
print("I am " + str(my_age_in_hours) + " hours old.")
print("I am " + str(my_age_in_seconds) + " seconds old.")
++++
==== 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 ===
Lasse eine Turtle ein Quadrat ablaufen, diesmal aber mithilfe der **while**-Schleife.
=== 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 `setX` und `setY` (oder `setPos`) und zeichne die Zweite Spirale mit einer neuen while-Schleife.
{{ : gf_informatik:spiralen_duo.png?250 |}}
++++Tipps|
Definiere für die Seitenlänge eine Variable. Nach jedem Durchgang der Schleife wird die Variable um einen bestimmten Wert vergrössert.
++++
=== Aufgabe C3 ===
Zeichne folgende Figur:
{{ : gf_informatik:spirale.png?200 |}}
=== Aufgabe C4 (optional) ===
Zeichne folgende Figur:
{{ : gf_informatik:spirale_rechteckig.png?250 |}}
=== 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.
++++Lösungen Aufgaben C|
==== Aufgaben C ====
=== Aufgabe C1 ===
from gturtle import *
turi = Turtle()
turi.hideTurtle()
i = 0
while i < 4:
turi.forward(200)
turi.left(90)
=== Aufgabe C2 ===
from gturtle import *
monika = Turtle()
monika.hideTurtle()
monika.setPos(-200,0)
i = 0
while i < 39:
monika.forward(10*i)
monika.left(90)
i = i + 1
monika.setPos(200,0)
i = 0
while i < 96:
monika.forward(4*i)
monika.left(90)
i = i + 1
=== Aufgabe C3 ===
from gturtle import *
t = Turtle()
t.hideTurtle()
i = 0
l = 5
while i < 150:
t.rightArc(l,20)
l = l + 2 # increase radius
i = i + 1
=== Aufgabe C4 ===
++++
==== Aufgaben D ====
**Vorwissen:** [[gf_informatik:programmieren_ii#verzweigungen_im_detail|Verzweigungen im Detail]]
Bei diesen Aufgaben geht es um folgendes:
* Schleifen mit elif zu programmieren
* etwas längere Programme schreiben
=== Aufgabe D1 ===
Das Programm soll:
* den Benutzer nach dem Alter fragen
* Ausgeben, ob der Benutzer Schnaps, Bier oder Sirup trinken darf.
Programmiere die Schnaps, Bier & Sirup Aufgabe mit einer if-elif-else-Verzweigung.
=== Aufgabe D2 ===
Die Benutzerin wird aufgefordert, eine Zahl einzugeben. Der Code analysiert, ob die Zahl positiv, Null oder negativ ist und gibt eine entsprechende Nachricht.
=== Aufgabe D3 ===
== Teil I ==
Der Benutzer wird aufgeforder, eine der folgenden Eingaben zu machen:
* "q" für Quadrat
* "k" für Kreis
* "r" für Rechteck
* "..." für eigene Figur
Die Turtle zeichnet dann die entsprechende Figur. Vermeide Code-Repetitionen, verwende stattdessen Schleifen!
Wird etwas anderes eingegeben, so soll eine der folgenden Varianten zum Zug kommen (entscheide selbst):
* Variante 1: einfach eine Rückmeldung, dass unzulässige Eingabe
* Variante 2: Turtle läuft ein Fragezeichen ab
== 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 Zufallsgenerator von Python, um die beiden Zahlen, die addiert werden sollen, zufällig zu wählen.
Dazu musst du das //random//-Modul einbinden.
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
...
== 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!|
=== 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.
++++Lösungen Aufgaben D|
==== Aufgaben D ====
=== Aufgabe D1 ===
age = int(input("Gib dein Alter ein"))
if age >= 18:
print("Schnaps!")
elif age >= 16:
print("Bier!")
else:
print("Sirup!")
=== Aufgabe D2 ===
x = int(input("Gib eine Zahl ein"))
if x > 0:
print("Positiv!")
elif x == 0:
print("Null!")
else:
print("Negativ!")
=== Aufgabe D3 ===
from turtle import *
turi = Turtle()
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()
=== Aufgabe D4 ===
++++