Programmieren Teil 1 – TurtleGraphics, python-Grundlagen [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 Teil 1 – TurtleGraphics, python-Grundlagen ======


Weiter zu [[gf_informatik:programmieren_ii_gra|]]
\\

++++Lernziele|

   * Ich kann erklären, was eine **Variable** ist und passende Analogien machen.
   * Ich kann erklären, wann und warum man Variablen verwenden sollte.
   * Ich kann eine Turtle erzeugen ...
   * ... und mit ihr **Figuren** mit geraden und gebogenen Linien zeichnen.
   * Ich kann die Turtle an eine beliebige Position **beamen**.
   * Ich kann erklären, was eine **Schleife** ist und warum diese praktisch sind.
   * Ich schreibe meinen Code so **elegant und kompakt** wie möglich. Dazu verwende ich:
     * Schleifen anstelle von Copy-Paste.
     * Variablen für Werte, die mehr als 1x benötigt werden im Code.
     * (Beachte: Bei Prüfungen wird nicht nur bewertet *ob* der Code korrekt funktioniert, sondern auch, wie elegant er programmiert wurde.)
   * <color blue>Ich kann die Stiftfarbe der Turtle verändern.</color>
   * Ich kann von der Benutzer:in eine **Eingabe** verlangen und diese in einer Variable speichern.
   * Ich kann **Verzweigungen** (if, if-else, if-elif-else) programmieren.
   * Ich kann einfache **Konsolenprogramme** (Programme mit Eingabe und/oder Ausgabe aber *ohne Turtle*) programmieren.
   * Ich kann ein Flussdiagramm zu einem Code mit Befhelen und Verzweigungen zeichnen und die Blöcke verständlich beschriften. 
   * (Optional): Ich kann in **farbige Bilder** erstellen mit TurtleGraphics.


++++

===== - Einführung =====

{{ :gf_informatik:pythoncodeintro.png?440|So sieht python-Code aus.}}


Ein Computer ist eine Maschine, die wahnsinnig schnell arbeiten (rechnen) kann. Damit du auf dem Computer zum Beispiel ein Spiel spielen kannst, muss jemand das Spiel programmieren. Jemand muss ein **Computerprogramm** oder **Code**, schreiben. Computerporgramme bestehen aus //Befehlen, die der Computer auszuführen// hat. Damit der Computer auch versteht, was er machen soll, müssen Programmierer:innen und Computer 'die gleiche Sprache' sprechen. Es gibt viele unterschiedliche Programmiersprachen mit unterschiedlichen Anwendungsbereiechen, Vor- und Nachteilen.

Wir wählen hier die Programmiersprache **Python**. Im Jahre 2020 ist diese Sprache sicher in der Top 3 der wichtigsten Programmiersprachen - wenn nicht sogar auf dem ersten Platz. Dazu kommt, dass Python im Vergleich zu anderen Sprachen, z.B. C\+\+ (C Plus Plus), Java oder C# (C Sharp) relativ einfach zu erlernen ist. 

Wenn wir einen Satz mit vielen Schreibfehlern lesen, so sind wir trotzdem in der Lage, den Satz zu verstehen. Der Computer aber kann ein Programm nur ausführen, wenn es //gar keine Fehler//, sogenannte **Bugs**, hat. Es ist deshalb ganz wichtig, dass du dich an die formalen Vorgaben der Programmiersprache hältst.

Um unseren Code zu schreiben und auszuführen, brauchen wir eine sogenannte **IDE (Integrated Development Environment, auf Deutsch Entwicklungsumgebung)**. Typischerweise sind Entwicklungsumgebungen Programme, die man auf seinem Computer installiert. Mittlerweile gibt es aber auch zahlreiche Online-Entwicklungsumgebungen, mit denen man arbeiten kann. Wir werden zuerst mit einer solchen arbeiten: [[https://webtigerpython.ethz.ch/]]

==== Arbeiten mit TigerPython ====

   1. Öffne die Web-IDE: https://webtigerpython.ethz.ch/
   1. Schreibe Code, führe aus (grüner Pfeil)
   1. **Speichere** regelmässig:
     1. **Variante a – alles in einem Dokument/Notizbuch:**  Übertrage den Code per Copy-Paste (CTRL C & V) in ein Word-Dokument oder OneNote-Notizbuch. Du kannst auch bloss den **Permalink** kopieren und einfügen: Hierzu oben rechts auf den Share-Button klicken, dann den Link am gewünschten Ort einfügen.
     1. **Variante b – jedes Programm in einer Python-Datei:** Speichere deinen Code als Python-Datei. Hierzu oben rechts auf die drei Pünktchen klicken, dann auf Save program (Programm speichern) klicken. Die Python-Datei ist nun im Downloads-Ordner. Verschiebe sie von hier in den richtigen Ordner, zum Beispiel: ''Informatik/Programmieren1/...''
     1. <color blue>So oder so gilt: Speichere jeden Code so, dass du ihn jederzeit wieder findest. Vergisst du einen Code zu speichern, muss du ihn **nochmals schreiben**.</color>



==== Tipps ====

   * Im Dossier gibt es viele kleine **Code-Beispiele**. Tippe diese jeweils //von Hand ab// und versuche, alles zu //verstehen//. Wenn du den Code per Copy-Paste kopierst, lernst du gar nichts!


===== - TurtleGraphics-Befehle =====

{{:gf_informatik:programmieren_i_gra:pasted:20240924-084100.png?150 |}}
== Was ist TurtleGraphics? ==
TurtleGraphics ist ein Python-Modul, mit dem du eine **Schildkröte** (engl. turtle) steuern und so **Grafiken** zeichnen kannst. Du sagst der Schildkröte, welchen Weg sie laufen soll und sie zieht eine Spur hinter sich her. Du kannst die Farbe und Dicke dieser Spur bestimmen und vieles mehr. Das Bild links ist mit TurtleGraphics gezeichnet. Die Schildkröte ist versteckt (siehe Tabelle mit Befehlen unten).

\\
\\

== Erste Schritte ==
Tippe folgenden Code in den Editor:

<code python>
from gturtle import *

karl = Turtle()

karl.forward(100)
</code>

Verwende anstelle von *karl* deinen Namen (keine Bindestriche im Namen!)

Erklärung der Zeilen:
  - Zuerst musst du das *Modul gturtle importieren*, damit wir mit Turtlegrafik arbeiten können.
  - Erzeuge einen neuen Turtle mit einem Namen. Man nennt dieses auch ein *Turtle-Objekt*.
  - Gib deinem Turtle den Befehl, 100 Pixel vorwärts zu laufen.

Du kannst deinem Turtle nun auch sagen, er soll sich um einen gewissen Winkel drehen oder rückwärts laufen. Die wichtigsten Befehle sind:

^ Befehl ^ Beschreibung ^
| forward(s) | s Schritte (in Pixel) vorwärts bewegen         |
| back(s)    | s Schritte rückwärts bewegen                   |
| right(w)   | um den Winkel w (in Grad) nach rechts drehen   |
| left(w)    | um den Winkel w nach links drehen              |
| setPos(-100,50) | Setzt Turtle an Position (-100,50) |
| setX(30)     | setzt x-Koordinate des Turtles |
| setY(30)     | setzt y-Koordinate des Turtles |
| setHeading(w) | setzt die Richtung der Turtle (0 gegen oben, im Uhrzeigersinn) |
| hideTurtle()     | Turtle versteckt sich, darauf folgende Befehle werden instantan ausgeführt |

[[https://www.python-online.ch/index.php?inhalt_links=turtle/navigation.inc.php&inhalt_mitte=turtle/turtledoc.html|Link zur Dokumentation mit allen Befehlen]]

==== Aufgaben A ====

=== Aufgabe A1 ===

Programmiere deine Turtle so, dass sie ein **Quadrat** abläuft. Die Position, in der sich die Turtle am Schluss befindet, ist irrelevant. Auch ob die Figur etwas kleiner oder grösser gerät, ist egal.

{{:gf_informatik:quadrat.png?direct&150|}}

++++Tipps:|forward und left / right++++

=== Aufgabe A2 ===

Programmiere nun ein **gleichseitiges Dreieck**.

{{:gf_informatik:dreieck.png?direct&150|}}

=== Aufgabe A3 ===

Und nun ein **regelmässiges Sechseck**.

{{:gf_informatik:sechseck_2.png?direct&150|}}

=== Aufgabe A4 ===

Zeichne nun zwei identische Quadrate nebeneinander:

{{:gf_informatik:zwei_quadrate.png?direct&350|}}

++++Tipps:|setPos++++

=== Aufgabe A5 ===

Programmiere deine Turtle so, dass sie **deinen Namen**, Spitznamen oder zumindest deine Initialen abläuft.

===== - Variablen und Schleifen (repeat) =====

Folgender Code erzeugt ein Quadrat mit Seitenlänge 120 Pixel:

<code python>
from gturtle import *
fritz = Turtle()

fritz.forward(120)
fritz.left(90)
fritz.forward(120)
fritz.left(90)
fritz.forward(120)
fritz.left(90)
fritz.forward(120)
fritz.left(90)
</code>

Nun möchten wir das Quadrat grösser machen: mit $200$ Pixel Seitenlänge. Dazu müssen wir jetzt die vier Werte mit $120$ zu $200$ ändern, was etwas *umständlich* ist. Es gibt einen einfacheren Weg: Wir **speichern** die gewünschte Seitenlänge in einer **Variable**, z.B. `length = 200`. Nun können wir einfach `fritz.forward(length)` schreiben und es wird für `length` der Wert $200$ eingefügt:


<code python>
from gturtle import *
fritz = Turtle()

length = 200
fritz.forward(length)
fritz.left(90)
fritz.forward(length)
fritz.left(90)
fritz.forward(length)
fritz.left(90)
fritz.forward(length)
fritz.left(90)
</code>
Wenn wir die Seitenlänge nun wieder ändern wollen, so müssen wir nur den Wert der Variablen ändern, z.B. `length = 50`. Wichtig ist immer, dass man die Variable festlegt *bevor* man sie verwendet, also **oberhalb** im Code.

Weiter fällt auf, dass dieser Codeblock viel Copy-Paste beinhaltet: Der folgende Codeblock kommt 4x direkt hintereinander vor:
<code python>
fritz.forward(length)
fritz.left(90)
</code>

Deshalb können wir auch einfach sagen, dass dieser Codeblock 4x hintereinander wiederholt (-> repeated) werden soll:
<code python>
repeat 4:
    fritz.forward(length)
    fritz.left(90)
</code>
Da ein Codeblock mehrfach hintereinander ausgeführt wird, spricht man von einer **Schleife**.
Beachte, dass der Codeblock, der wiederholt werden soll, **eingerückt** sein muss. Verwende dazu die **Tabulatortaste**((befindet sich oberhalb der Shift-Taste, ganz links, vierte Reihe von unten)). Weiter ist es wichtig, den Doppelpunkt im repeat-Befehl nicht zu vergessen.

<box 100% round green|**Variablen**>
   * Eine Variable ist **wie ein Behälter, in dem du einen Wert** – zum Beispiel eine Zahl oder einen Text – **speichern** kannst.
   * Eine Variable hat einen **Namen**, den du frei wählen kannst (Umlaute und Sonderzeichen sind nicht erlaubt).
   * Über den Namen kannst du auf den Wert, der in der Variable gespeichert ist, zugreifen: Du kannst den Wert **abfragen, neu setzen oder verändern** (erhöhen, verringern, multiplizieren etc.)
   * Eine Variable bringt dir unter anderem **folgende Vorteile** (siehe auch Beispiele oben): 
     * Du kannst eine Variable einmal definieren und dann an vielen Stellen verwenden. Falls du den Wert ändern möchtest, brauchst du das nur an einer Stelle zu tun.
     * Du kannst den Wert in einer Variable verändern, ohne diesen zu kennen. So kannst du zum Beispiel den Radius eines Hablkreises in jedem Schleifen-Durchlauf um 10 erhöhen: ''radius = radius + 10''
     * Du kannst eine Eingabe (zum Beispiel von der Benutzer:in) in einer Variable speichern und diese dann abfragen (siehe Kapitel Verzweigungen). 
</box>

<box 100% round green|**repeat-Schleife**>
   * Mit der repeat-Schleife kannst du einen oder mehrere Befehele **wiederholt** ausführen lassen. 
   * Damit kannst du einen Code, der viele Wiederholungen enthält, viel **kürzer** schreiben. Je kürzer dein Code ist, desto **weniger Fehler** kann er enthalten.
   * Nach dem Wort ''repeat'' schreibst du die Anzahl Wiederholungen hin (hier könnte auch eine Variable stehen), dann einen Doppelpunkt.
   * Alle Befehle, die wiederholt werden sollen, müssen **direkt unterhalb und um eine Ebene eingerückt** stehen. Verwende die **Tabulatortaste**.
</box>
==== Aufgaben B ====


=== Aufgabe B1 ===

Nun wollen wir einige der Figuren aus A nochmals zeichnen, diesmal aber mithilfe von **Variablen** und **Schleifen**. Löse jede Aufgabe mit einem *eigenen Code* (also nicht alle Figuren zusammen):

   1. Quadrat
   1. Dreieck
   1. Sechseck

=== Aufgabe B2 ===

Zeichne eine Treppe mithilfe einer Variable und einer Schleife:

{{:gf_informatik:treppe.png?direct&200|}}

=== Aufgabe B3 ===

Zeichne folgende Figur (Variable optional):

{{:gf_informatik:stern.png?direct&150|}}

=== Aufgabe B4 ===

In einer A-Aufgabe hast du **zwei Quadrate** nebeneinander gezeichnet. Wahrscheinlich war dieser Code ziemlich lange. Schreibe jetzt einen Code, der das gleiche Bild erzeugt, der aber viel kürzer ist, indem du zwei Schleifen verwendest: Eine Schleife für jedes der Quadrate.

{{:gf_informatik:zwei_quadrate.png?direct&350|}}

=== Aufgabe B5 ===

Zeichne nun ein grosses und ein kleines Quadrat nebeneinander. Verwende wieder Variablen und Schleifen.

{{:gf_informatik:quadrate_gross_klein.png?direct&300|}}


===== - Kreisbogen =====

Um eine Turtle namens *fritz* einen **Punkt** mit Radius 20 Pixel zeichnen zu lassen, tippe einfach:

<code python>
fritz.dot(20)
</code>

Bisher haben wir unsere Turtles ausschliesslich gerade Linien laufen lassen. Um auf einem **Bogen** (engl. "arc") zu gehen, verwende die Befehle

<code python>
fritz.rightArc(r, w)
fritz.leftArc(r, w)
</code>

Diese beiden Funktionen zeichnen einen Bogen nach rechts (`rightArc`) und nach links (`leftArc`). Diesen Funktionen muss man zwei Zahlen als Argumente übergeben:

   * Zahl r: Radius des Kreises in Pixel
   * Zahl w: Winkel in Grad

Zum Beispiel zeichnet man mit dem Befehl `rightArc(100, 180)` einen Halbkreis (180 Grad Winkel) mit Radius 100 Pixel.



==== Aufgaben C ====

Freiwillig: Mit `setPenColor("red")` die Farbe ändern.
=== Aufgabe C1 ===

Verwende die Befehle `dot(), forward(), right(), left()`, um folgende Figur zu zeichnen:

{{:gf_informatik:turtle_zick_zack.png?direct&300|}}

Versuche nun deinen Code zu kurz wie möglich zu schreiben. Vermeide Code-Wiederholungen, in dem du eine **Schleife** programmierst. Definiere wo sinnvoll **Variablen**.

=== Aufgabe C2 ===

Zeichne folgende Figur, welche aus lauter Halbkreisen besteht:

{{:gf_informatik:halbkreise.png?direct&400|}}

Tipp: Verwende hier `leftArc(...)` und `rightArc()`.

=== Aufgabe C3 ===

Zeichne folgende Figur, welche aus drei Halbkreisen besteht:

{{:gf_informatik:halbkreise_2.png?direct&200|}}

Beachte, dass der grosse Halbkreis einen doppelt so grossen Radius hat wie die kleinen beiden Halbkreise. Du kannst deshalb den grossen Radius über den kleinen Radius definieren:

<code python>
radius_1 = 70 # lege kleinen Radius fest
radius_2 = 2 * radius_1 # grosse Radius wird als 2x der kleine Radius definiert
</code>

=== Aufgabe C4 ===

Zeichne folgende Figur, welche aus sieben Halbkreisen besteht:

{{:gf_informatik:programmieren_i_gra:pasted:20241002-123015.png?direct&200}}

Schreibe den Code möglichst kurz, verwende Variable(n) und Schleife(n).


=== Aufgabe C5 ===

Zeichne folgende Figur. Jede der beiden Spiralen besteht aus 14 Viertelkreisen.

{{:gf_informatik:programmieren_i_gra:pasted:20241002-125146.png?direct&400}}

Schreibe den Code möglichst kurz, verwende Variable(n) und Schleife(n).

=== Aufgabe C6 (optional) ===

Zeichne folgende Figur aus acht Sechsecken ineinander.

{{:gf_informatik:programmieren_i_gra:pasted:20241004-074308.png?direct&200}}

Schreibe den Code möglichst kurz, verwende Variable(n) und Schleife(n).

++++ Tipp:|
Eine zweite Schleife in der ersten Schleife.
++++
===== - Farben (optional) =====

Wir können nun auch etwas Farbe ins Spiel bringen:

   * Mit `setPenColor("red")` kannst du die Farbe des Stifts festlegen.
   * Mit `setPenWidth(10)` kannst du die Dicke des Stifts festlegen.
   * Mit `clear("black")` ganz am Anfang des Codes (bevor man Turtle erzeugt) kannst du die Hintergrundfarbe festlegen.
   * Mit `setFillColor("blue")`, `startPath()` und `fillPath()` kannst du eine Fläche farbig ausfüllen.

[[https://www.python-online.ch/index.php?inhalt_links=turtle/navigation.inc.php&inhalt_mitte=turtle/turtledoc.html|In der Dokumentation findest du genauere Erklärungen zu diesen (und allen anderen) Turtle-Befehlen.]]

==== Aufgaben D ====

=== Aufgabe D1 ===

Zeichne ein farbiges Quadrat mit dicken Linien und einer Hintergrundfarbe:

{{:gf_informatik:quadrat_farbig.png?direct&150|}}

=== Aufgabe D2 ===

Zeichne einen Smiley:

{{:gf_informatik:smiley.png?direct&150|}}
=== Aufgabe D3 ===

Zeichne eine Ampel:

{{:gf_informatik:ampel.png?direct&100|}}

=== Aufgabe D4 ===

Zeichne einen Lolli:

{{:gf_informatik:programmieren_i_gra:pasted:20241002-134647.png?direct&150|}}
===== - Verzweigungen =====
{{ :gf_informatik:programmieren_i_verzweigungen_gra.pdf | Präsentation zu Verzweigungen}}

In **Verzweigungen** werden Bedingungen überprüft. Je nachdem, wird *unterschiedlicher* Code ausgeführt.

**Beispiel 1:**

<code python>
answer = input("Was gibt 37 + 5?")

if answer == 42:
    print("Korrekt!")
else:
    print("Falsch!")

print("Auf Wiedersehen")
</code>

**Beispiel 2:**

<code python>
answer = input("Was gibt 37 + 5?")

if answer == 42:
    print("Korrekt!")
elif answer == 40:
    print("Fast, um 1 zu tief!")
elif answer == 41:
    print("Fast, um 1 zu hoch!")
else:
    print("Falsch!")

print("Auf Wiedersehen")
</code>

**Beispiel 3:**

<code python>
money = input("Wie viel Geld hast du?")

if money >= 1000000:
    print("Du bist Millionär!")
else:
    print("Du bist kein Millionär!")
</code>

**Vergleichsoperatoren:**

^ **Vergleichsoperator** ^ **Überprüft ob ...** ^
| `x == y` | x gleich y ist. |
| `x != y` | x *un*gleich y ist. |
| `x > y` | x grösser als y ist. |
| `x < y` | x kleiner als y ist. |
| `x >= y` | x grösser oder gleich y ist. |
| `x <= y` | x kleiner oder gleich y ist. |

==== Aufgaben E ====

Beachte: Einige Aufgaben sollen mit TurtleGraphics gelöst werden, andere ohne. Den TurtleCode `from gturtle import *` usw. soll nur dann geschrieben werden, wenn man auch eine Turtle hat.

=== Aufgabe E1 ===

Schreibe einen Code, in dem die Benutzerin dazu aufgefordert wird, deine Lieblingszahl zu erraten. Gelingt es ihr, so wird ihr gratuliert. Falls nicht, wird sie dafür kritisiert, dass sie dies nicht weiss.

=== Aufgabe E2 ===

   1. Die Benutzerin soll dazu aufgefordert werden, den Buchstaben "q" einzugeben. Fall sie dies macht, soll ein *Quadrat* gezeichnet werden. Falls irgendetwas anderes eingegeben wird, soll nichts gezeichnet werden. Stattdessen soll ausgegeben werden (mit `print("...")`), dass eine unzulässige Eingabe gemacht wurde.\\ \\
   1. Modifiziere nun den Code oben so, dass man (neben "q" für Quadrat) auch "d" eingeben kann, damit ein Dreieck gezeichnet wird.

=== Aufgabe E3 ===

**Witz-Sammlung:** Notiere 3 bis 5 Witze. Die Benutzerin soll aufgefordert werden, eine Zahl 1-... einzugeben. Gibt sie eine 1/2/3 ein, so soll der erste/zweite/dritte Witz angezeigt werden. Macht sie eine falsche Eingabe, so soll einfach *nichts* passieren.

=== Aufgabe E4 ===

**Volljährig Checker:** Die Benutzerin wird aufgefordert, ihr Alter einzugeben. Überprüfe ob sie volljährig ist oder nicht und gib entsprechend "volljährig" oder "minderjährig" aus. Beachte, dass es hier einen anderen Vergleichsoperator braucht als `==`: `< , > , <= , >=`.

=== Aufgabe E5 ===

**Positiv, Null oder negativ?** Die Benutzerin wird aufgefordert, eine Zahl einzugeben. Der Code gibt aus "positiv", "Null" oder "negativ".

=== Aufgabe E6 ===

**Grössere Zahl:** Die Benutzerin wird aufgefordert, *hintereinander* zwei Zahlen einzugeben. Speichere diese zwei Zahlen in unterschiedlichen Variablen. Die grössere der beiden Zahlen soll dann ausgegeben werden.

Beispiel: Falls zuerst $5$ und dann $7$ eingegeben wird, soll $7$ ausgegeben werden.

=== Aufgabe E7 ===
Schreibe möglichst kurzen Code, der eine zweifarbige, quadratische Spirale aus 16 Seiten wie im Bild unten zeichnet: Start mit Seitenlänge 20, Zunahme jeweils um 10. Ab Seitenlänge 100 soll die Farbe von rot auf blau wechseln.

{{:gf_informatik:programmieren_i_gra:pasted:20241023-152242.png?direct&150|}}

++++ Hinweise:|
  * Farbe setzen mit ''setPenColor("red")''. 
  * [[https://www.trinket.io/docs/colors|Hier]] eine Übersicht über alle Farbtexte. 
++++

=== Aufgabe E8 ===
Schreibe möglichst kurzen Code, der ein dreifarbiges Muster aus 9 Kreisen wie im Bild unten zeichnet: Start mit Radius 100, Abnahme jeweils um 10. Ab Radius 70 soll die Farbe auf blau wechseln und ab Radius 40 auf rot.

{{:gf_informatik:programmieren_i_gra:pasted:20241023-153628.png?direct&150|}} 

=== Aufgabe E9 ===
**1 bis 12 Punkte:** Schreibe möglichst kurzen Code, der folgende Anforderungen erfüllt:
  * Die Benutzer:in kann eingeben, wie viele Punkte gezeichnet werden sollen, es wird eine Eingabe zwischen 1 und 12 erwartet. 
  * Wenn die Eingabe zu gering ist, wird eine entsprechende Meldung ausgegeben und es wird genau 1 Punkt gezeichnet. 
  * Wenn die Eingabe zu gross ist, wird eine entsprechende Meldung ausgegeben und es werden genau 12 Punkte gezeichnet.
  * (Ansonsten werden so viele Punkte gezeichnet, wie eingegeben).
  * Es werden von links nach rechts 20-px-Punkte im Abstand von 20 px gezeichnet, siehe Bild.

{{:gf_informatik:programmieren_i_gra:pasted:20241023-154834.png?direct&300|}}

=== Aufgabe E10 ===
**Farbiger Punkt:** Schreibe möglichst kurzen Code, der folgende Anforderungen erfüllt:
  * Die Benutzer:in kann zwischen drei angebotenen Farben wählen, indem sie den Namen der Farbe (auf Deutsch) eingibt. 
  * Wenn die Benutzerin eine ungültige Farbe eingibt, wird eine entsprechende Meldung ausgegeben und die Punktfarbe bleibt schwarz.
  * Es wird ein grosser 100-px-Punkt in der gewählten Farbe gezeichnet, siehe Bild.

{{:gf_informatik:programmieren_i_gra:pasted:20241023-155842.png?direct&150|}}




===== Verzweigungen darstellen mit Flussdiagrammen =====
Ein Code mit Verzweigungen können wir mit einem Flussidagramm darstellen und beschreiben. Hier ein Beispiel:
<code python>
from gturtle import *

morla = Turtle()

note = input("Informatik-Note eingeben.")

if note >= 5:
    morla.setPenColor("green")
elif note >= 4:
    morla.setPenColor("yellow")
else:
    morla.setPenColor("red")

morla.dot(100)
</code>

Obiger Code ist im folgenden Flussiagramm dargestellt. Die einzelnen Blöcke beschreiben, was der jeweilige Befehl tut:

{{:gf_informatik:programmieren_i_gra:pasted:20241030-133841.png?600|}}

Dieses Flussdiagramm sollte jede Person lesen können – egal ob sie python-Befehle kennt oder nicht. Anhand des Flussdiagramms können wir verstehen, wie der Code funktioniert.

**Zeichne deine Lösung für folgende Aufgaben von Hand und ohne Lineal:**  
  * auf Papier oder
  * auf dem Display deines Laptops, zum Beispiel in Powerpoint oder OneNote
**Lege deine Lösung (Foto oder Screenshot davon) bei den anderen Dateien ab.**
=== Aufgabe E11 ===
Zeichne ein Flussdiagramm zu folgendem Code. Beschrifte die Blöcke sinnvoll (siehe Beispiel oben).

<code python>
jahr = input("Gib dein Geburtsjahr ein:")

if jahr >= 2010:
    print("Du bist Teil der Generation Alpha.")
elif jahr >= 1995:
    print("Du bist Teil der Generation Z.")
elif jahr >= 1980:
    print("Du bist Teil der Generation Y.")
elif jahr >= 1965:
    print("Du bist Teil der Generation X.")
else:
    print("Du bist alt.")
</code>

=== Aufgabe E12 ===
  - Zeichne ein Flussdiagramm zu folgendem Code. Beschrifte die Blöcke sinnvoll (siehe Beispiel oben). Den ''repeat''-Block kannst du als **einen** Befehl zeichnen.
  - Überlege, was der Code genau macht und wie die Figur aussieht, die bei einer bestimmten Eingabe gezeichnet wird. Prüfe, ob deine Überlegung stimmt, indem du den Code in webtigerpython ausführst. 

<code python>
from gturtle import *

morla = Turtle()

anzahl = input("Wie viele Kreise? (2-8)")

if anzahl > 8:
    print("Eingabe ungültig. Es werden 8 Figuren gezeichnet.")
    anzahl = 8
elif anzahl < 2:
    print("Eingabe ungültig. Es werden 2 Figuren gezeichnet.")
    anzahl = 2

morla.right(90)

repeat anzahl:
    morla.rightArc(20,360)
    morla.forward(40)
</code>
===== Zusatzaufgaben I =====
=== Race ===

   1. Zeichne mit Turtle eine eigene Map mit einer Rennbahn und weiteren Elementen (Gewässer, Bäume, Häuser, Menschen, ...). Verwende für diesen Teil den `.hideTurtle()` Befehl, damit die Map sofort gezeichnet ist.
   1. Zeige nachher die Turtle wieder an mit `.showTurtle()` und lasse die Turtle auf der Rennbahn Runden drehen. Mit `repeat:` kann ein Code unendlich oft wiederholt werden.

Beispiel:

{{:gf_informatik:rennbahn.png?direct&200|}}




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

**Achtung:** Meist gibt es mehrere Lösungen. Nur weil deine Lösung anders ist als diejenige in den Musterlösungen unten, bedeutet dies nicht, dass deine nicht richtig/gut ist. Sende oder zeige im Zweifelsfall deine Lösung der Lehrperson.

<nodisp 1>

++++Lösungen A|

=== Aufgabe A1 ===

<code python>
from gturtle import *
fritz = Turtle()
fritz.forward(200)
fritz.left(90)
fritz.forward(200)
fritz.left(90)
fritz.forward(200)
fritz.left(90)
fritz.forward(200)
</code>

=== Aufgabe A2 ===

<code python>
from gturtle import *
fritz = Turtle()
fritz.right(90)
fritz.forward(200)
fritz.left(120)
fritz.forward(200)
fritz.left(120)
fritz.forward(200)
</code>

=== Aufgabe A3 ===

<code python>
from gturtle import *
fritz = Turtle()
fritz.right(60)
fritz.forward(100)
fritz.right(60)
fritz.forward(100)
fritz.right(60)
fritz.forward(100)
fritz.right(60)
fritz.forward(100)
fritz.right(60)
fritz.forward(100)
fritz.right(60)
fritz.forward(100)
</code>

=== Aufgabe A4 ===

<code python>

from gturtle import *
fritz = Turtle()

# Quadrat 1
fritz.forward(100)
fritz.left(90)
fritz.forward(100)
fritz.left(90)
fritz.forward(100)
fritz.left(90)
fritz.forward(100)
fritz.left(90)

# Quadrat 2
fritz.setPos(-200,0)
fritz.forward(100)
fritz.left(90)
fritz.forward(100)
fritz.left(90)
fritz.forward(100)
fritz.left(90)
fritz.forward(100)
fritz.left(90)
</code>

++++


++++Lösungen B|

=== Aufgabe B1 ===

Quadrat:
<code python>
from gturtle import *

length = 150

turi = Turtle()

repeat 4:
    turi.forward(length)
    turi.left(90)
</code>

Dreieck:
<code python>
from gturtle import *

length = 150

turi = Turtle()
turi.right(90)

repeat 3:
    turi.forward(length)
    turi.left(120)
</code>

Sechseck:
<code python>
from gturtle import *

length = 150

turi = Turtle()

repeat 6:
    turi.forward(length)
    turi.left(60)
</code>

=== Aufgabe B2 ===

<code python>
from gturtle import *

length = 30

turi = Turtle()

repeat 10:
    turi.forward(length)
    turi.right(90)
    turi.forward(length)
    turi.left(90)
</code>


=== Aufgabe B3 ===

<code python>
from gturtle import *

turi = Turtle()

repeat 9:
    turi.forward(150)
    turi.left(160)
</code>

=== Aufgabe B2 ===

<code python>
from gturtle import *
fritz = Turtle()

l = 100
repeat 4:
    fritz.forward(l)
    fritz.left(90)

fritz.setPos(200,0)
repeat 4:
    fritz.forward(l)
    fritz.left(90)
</code>

=== Aufgabe B3 ===

<code python>
from gturtle import *
fritz = Turtle()
 
# Quadrat 1
l = 100
repeat 4:
    fritz.forward(l)
    fritz.left(90)
 
# Quadrat 2
fritz.setPos(300,0)
l = 200
repeat 4:
    fritz.forward(l)
    fritz.left(90)
</code>

++++


++++Lösungen C|


=== Aufgabe C1 ===

<code python>
from gturtle import *

peter = Turtle()

length = 50
angle = 90
dot_size = 20

peter.right(45)

repeat 6:
    peter.dot(dot_size)
    peter.forward(length)
    peter.dot(dot_size)
    peter.right(angle)
    peter.forward(length)
    peter.left(angle)
</code>

=== Aufgabe C2 ===

<code python>
from gturtle import *

peter = Turtle()

radius = 30

peter.setPos(0,-200)

repeat 4:
    peter.rightArc(radius,180)
    peter.leftArc(radius,180)
</code>

=== Aufgabe C3 ===

<code python>
from gturtle import *

peter = Turtle()

radius_1 = 70
radius_2 = 2 * radius_1

peter.rightArc(radius_1,180)
peter.leftArc(radius_1,180)
peter.leftArc(radius_2,180)
</code>
Oder einfach:
<code python>
from gturtle import *

peter = Turtle()

radius = 70

peter.rightArc(radius,180)
peter.leftArc(radius,180)
peter.leftArc(2*radius,180)
</code>

=== Aufgabe C4 ===

<code python>
from gturtle import *

michelangelo = Turtle()

radius = 50
winkel = 180

repeat 7:
    michelangelo.rightArc(radius, winkel)
    radius = radius + 10
</code>

=== Aufgabe C5 ===

<code python>
from gturtle import *
michelangelo = Turtle()

radius = 50
winkel = 90

repeat 14:
    michelangelo.rightArc(radius, winkel)
    radius = radius + 5

repeat 14:
    michelangelo.leftArc(radius, winkel)
    radius = radius - 5
</code>

=== Aufgabe C6 ===

<code python>
from gturtle import *

michelangelo = Turtle()

anzahl = 8
seite = 20

michelangelo.left(60)
repeat anzahl:
    repeat 6:
        michelangelo.forward(seite)
        michelangelo.right(60)
    seite += 10
</code>
++++


++++Lösungen D|

=== Aufgabe D1 ===

<code python>
from gturtle import *

clear("green")

peter = Turtle()
peter.setPenWidth(10)
length = 200

peter.setPenColor("red")
peter.forward(length)
peter.left(90)
peter.setPenColor("blue")
peter.forward(length)
peter.left(90)
peter.setPenColor("yellow")
peter.forward(length)
peter.left(90)
peter.setPenColor("magenta")
peter.forward(length)
peter.left(90)
</code>

=== Aufgabe D2 ===

<code python>
from gturtle import *

smiley = Turtle()
smiley.hideTurtle()

radius = 100
eyes = 30

# face
smiley.setPenWidth(5)
smiley.setPos(radius,0)
smiley.startPath()
smiley.leftArc(radius,360)
smiley.setFillColor("yellow")
smiley.fillPath()

# eyes
smiley.setPos(radius//3,radius//3)
smiley.dot(eyes)
smiley.setPos(-radius//3,radius//3)
smiley.dot(eyes)

# smile
smiley.setPos(radius//2,-radius//4)
smiley.left(180)
smiley.rightArc(radius//2,180)
</code>


=== Aufgabe D3 ===

<code python>
from gturtle import *

clear("black")

peter = Turtle()
peter.hideTurtle()

radius = 60
offset = 20

peter.setPenColor("white")
peter.setPenWidth(5)

# red
peter.setPos(0,2*radius + offset)
peter.setFillColor("red")
peter.startPath()
peter.leftArc(radius,360)
peter.fillPath()
# yellow
peter.setPos(0,0)
peter.setFillColor("yellow")
peter.startPath()
peter.leftArc(radius,360)
peter.fillPath()
# green
peter.setPos(0,-2*radius - offset)
peter.setFillColor("green")
peter.startPath()
peter.leftArc(radius,360)
peter.fillPath()
</code>

=== Aufgabe D4 ===

<code python>
from gturtle import *
michelangelo = Turtle()
michelangelo.hideTurtle()

# Hintergrund
michelangelo.startPath()
michelangelo.rightArc(200,360)
michelangelo.setFillColor("yellow")
michelangelo.fillPath()

# Spirale
michelangelo.setPenWidth(20)
michelangelo.setPenColor("magenta")
michelangelo.setPos(200,-50)
michelangelo.left(90)
radius = 50
winkel = 90
repeat 16:
    michelangelo.rightArc(radius, winkel)
    radius = radius + 10

# Stil
michelangelo.setPenColor("orange")
michelangelo.left(90)
michelangelo.forward(300)
</code>

++++


++++Lösungen E|

=== Aufgabe E1 ===

In dieser Aufgabe braucht es keine Turtle.

<code python>
guess = input("Versuche, meine Lieblingszahl zu erraten!")

if guess == 7:
    print("Korrekt!")
else:
    print("Falsch! Warum weisst du das nicht?")
</code>


=== Aufgabe E2 ===

Version 1:

<code python>
from gturtle import *

chris = Turtle()

form = input("Gib q ein, um ein Quadrat zu zeichnen.")

if form == "q":
    repeat 4:
        chris.forward(100)
        chris.left(90)
else:
    print("Unzulässige Eingabe!")
</code>

Version 2:
<code python>
from gturtle import *

chris = Turtle()

form = input("Gib q (Quadrat) oder d (Dreieck) ein, um die Figur zu zeichnen.")
length = 100

if form == "q":
    repeat 4:
        chris.forward(length)
        chris.left(90)
if form == "d":
    chris.left(30)
    repeat 3:
        chris.forward(length)
        chris.left(120)
else:
    print("Unzulässige Eingabe!")
</code>



=== Aufgabe E3 ===

Keine Turtles hier!

<code python>
joke_number = input("Gib eine Witznummer 1-5 ein.")

if joke_number == 1:
    print("Was macht ein Pirat am Computer? Er drückt die Enter-Taste.")
elif joke_number == 2:
    print("Was macht ein Clown im Büro? Faxen.")
elif joke_number == 3:
    print("Was ist orange und läuft durch den Wald? Eine Wanderine.")
elif joke_number == 4:
    print("Was ist weiss und rollt den Berg hoch? Eine Lawine mit Heimweh.")
elif joke_number == 5:
    print("Warum können Bienen so gut rechnen? Weil sie den ganzen Tag mit Summen beschäftigt sind.")
</code>

=== Aufgabe E4 ===

<code python>
age = input("Wie alt bist du?")

if age >= 18:
    print("Volljährig.")
else:
    print("Minderjährig.")
</code>

=== Aufgabe E5 ===

<code python>
number = input("Gib eine Zahl ein")

if number > 0:
    print("positiv")
elif number == 0:
    print("Null")
else:
    print("negativ")
</code>

=== Aufgabe E6 ===

<code python>
nr_1 = input("Gib eine Zahl ein")
nr_2 = input("Gib eine zweite Zahl ein")

if nr_1 > nr_2:
    print(nr_1)
else:
    print(nr_2)
</code>

=== Aufgabe E7 ===

<code python>
from gturtle import *

donatello = Turtle()
seite = 20
donatello.setPenColor("red")

repeat 16:
    donatello.forward(seite)
    donatello.left(90)
    seite = seite + 10
    if seite >= 100:
        donatello.setPenColor("blue")
</code>

=== Aufgabe E8 ===

<code python>
from gturtle import *

donatello = Turtle()
donatello.setPenColor("green")
radius = 100

repeat 9:
    donatello.rightArc(radius, 360)
    radius = radius - 10
    if radius < 80:
        donatello.setPenColor("blue")
    if radius < 50:
        donatello.setPenColor("red")
</code>

=== Aufgabe E9 ===

<code python>
from gturtle import *

donatello = Turtle()

n = input("Wie viele Punkte (1-12)?")

if n < 1:
    print("Eingabe zu klein, habe 1 gesetzt")
    n = 1
elif n > 12:
    print("Eingabe zu gross, habe 12 gesetzt")
    n = 12

donatello.right(90)
repeat n:
    donatello.dot(20)
    donatello.forward(20)
</code>

=== Aufgabe E10 ===

<code python>
from gturtle import *

donatello = Turtle()

color = input("Welche Farbe (pink, violett, gelb)?")

if color == "pink":
    donatello.setPenColor("deep pink")
elif color == "violett":
    donatello.setPenColor("orchid")
elif color == "gelb":
    donatello.setPenColor("yellow")
else:
    print("Eingabe ungültig, bleibe schwarz.")

donatello.dot(100)
</code>

=== Aufgabe E11 ===
{{:gf_informatik:programmieren_i_gra:pasted:20241030-144921.png?800|}}

=== Aufgabe E12 ===
{{:gf_informatik:programmieren_i_gra:pasted:20241030-151043.png?600|}}
++++
</nodisp>