Programmieren I: Grundlagen der Programmierung

Lernziele

Ein Computer ist zunächst einfach mal eine Maschine, die wahnsinnig schnell arbeiten (rechnen) kann. Damit man zum Beispiel ein Spiel spielen können, muss irgend jemand dem Computer also sagen, was er denn genau zu tun hat. Jemand muss also ein Computerprogramm, oder Code, schreiben. Dieses besteht aus Befehlen, die der Computer auszuführen hat. Damit der Computer auch versteht, was er machen soll, müssen Programmierer und Computer 'die gleiche Sprache' sprechen. Es gibt sehr viele unterschiedliche solche Programmiersprachen mit unterschiedlichen Anwendungsbereiechen und 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 Schreibfelern und Grammatikfehler lesen, so sind wir meist trotzdem in der Lage, den Satz zu verstehen. Im Gegensatz zu uns hat ein Computer aber keine Intelligenz und ist deshalb nicht in der Lage, einen Text selbst zu interpretieren. Ein Computer kann ein Programm nur ausführen, wenn es gar keine Fehler, sogenannte Bugs, hat. Es ist deshalb ganz wichtig, dass man sich an die formalen Vorgaben der Programmiersprache hält.

Wie gesagt werden wir in der Programmiersprache Python programmieren. Wir brauchen aber noch ein Programm, um unseren Code zu schreiben und auszuführen, 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/

1. Öffne die Web-IDE: https://webtigerpython.ethz.ch/
2. Schreibe Code, führe aus (grüner Pfeil)
3. Speichere regelmässig, in dem Code per Copy-Paste (CTRL C & V) in OneNote übertragen wird
4. Alle Codes müssen auf OneNote sauber geordnet abgelegt werden. Vergisst man einen Code zu speichern, muss er nochmals geschrieben werden..

• 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!

Tippe folgenden Code in den Editor:

from gturtle import *
 
fritz = Turtle()
 
fritz.forward(100)

Verwende anstelle von fritz deinen Namen (keine Bindestriche im Namen!)

Erklärung der Zeilen:

1. Zuerst musst du das Modul gturtle importieren, damit wir mit Turtlegrafik arbeiten können.
2. Erzeuge einen neuen Turtle mit einem Namen. Man nennt dieses auch ein Turtle-Objekt.
3. 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:

Link zur Dokumentation mit allen Befehlen

Programmiere deine Turtle so, dass es 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.

Tipps:

Programmiere nun ein gleichseitiges Dreieck.

Und nun ein regelmässiges Sechseck.

Zeichne nun zwei identische Quadrate nebeneinander:

Tipps:

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

Slides Variablen & Schleifen

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

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)

Nun möchten wir das Quadrat aber grösser machen zu Seitenlänge $200$ Pixel. 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. l = 200. Nun können wir einfach fritz.forward(l) schreiben und es wird für l der Wert $200$ eingefügt:

from gturtle import *
fritz = Turtle()
 
l = 200
fritz.forward(l)
fritz.left(90)
fritz.forward(l)
fritz.left(90)
fritz.forward(l)
fritz.left(90)
fritz.forward(l)
fritz.left(90)

Wenn wir die Seitenlänge nun wieder ändern wollen, so müssen wir nur den Wert der Variablen ändern, z.B. l = 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:

fritz.forward(l)
fritz.left(90)

Deshalb können wir auch einfach sagen, dass dieser Codeblock 4x hintereinander wiederholt (→ repeated) werden soll:

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

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. Weiter ist es wichtig, den Doppelpunkt im repeat-Befehl nicht zu vergessen.

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
2. Dreieck
3. Sechseck

Zeichne eine Treppe mithilfe einer Variable und einer Schleife:

Zeichne folgende Figur (Variable optional):

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.

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

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

fritz.dot(20)

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

fritz.rightArc(r, w)
fritz.leftArc(r, w)

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.

Freiwillig: Mit setPenColor("red") die Farbe ändern.

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

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

Zeichne nun folgende Figur, welche aus lauter Halbkreisen besteht:

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

Zeichne nun folgende Figur, welche aus drei Halbkreisen besteht:

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

radius_1 = 70 # lege kleinen Radius fest
radius_2 = 2 * radius_1 # grosse Radius wird als 2x der kleine Radius definiert

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

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

In der Dokumentation findet man genauere Erklärungen zu diesen (und allen anderen) Turtle-Befehlen.

Zeichne ein farbiges Quadrat mit dicken Linien und einer Hintergrundfarbe:

Zeichne einen Smiley:

Zeichne eine Ampel:

Slides Verzweigungen

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

Beispiel 1:

answer = input("Was gibt 37 + 5?")
 
if answer == 42:
    print("Korrekt!")
else:
    print("Falsch!")
 
print("Auf Wiedersehen")

Beispiel 2:

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")

Beispiel 3:

money = input("Wie viel Geld hast du?")
 
if money >= 1000000:
    print("Du bist Millionär!")
else:
    print("Du bist kein Millionär!")

Vergleichsoperatoren:

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.

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.

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.
   
   
2. Modifiziere nun den Code oben so, dass man (neben „q“ für Quadrat) auch „d“ eingeben kann, damit ein Dreieck gezeichnet wird.

Witz-Sammlung: Notiere 3 bis 5 (durchaus flache) 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 nicht passieren.

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 ==: < , > , <= , >=.

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

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.

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.
2. 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:

Mit Python kann man besser rechnen als mit jedem Taschenrechner. Unter anderem gibt es alle gängigen Rechenoperationen wie $+,-,\cdot,/$ und viele weitere mathematische Operatoren in Python:

Erinnerung: Wenn wir einer Variable einen Wert zuweisen, verwenden wir die Zuweisungsanweisung =. Dieser weist der Variablen auf der linken Seite den Wert auf der rechten Seite zu, also z.B. x = 42. Damit kann man auch den Wert einer Variable erhöhen oder verringern:

x = 42 # Variable x mit Wert 42
print(x) # Ausgabe: 42
x = x + 1 # Rechte Seite ergibt 43. Dieser Wert wird nun x zugewiesen
print(x) # Ausgabe: 43

Ein String ist nichts anderes als Text, der zum Beispiel in einer Variable gespeichert wird:

name = "Hans Müller" # Variable name hat Wert "Hans Müller" und ist ein String

(Überigens ist dieser Name laut ChatGPT der 'schweizeriste' Name).

Wir werden nun vermehrt Werte berechnen, die wir dann in einem schönen Format ausgeben wollen. Am einfachsten geht dies mit sogenannten f-Strings: Diese erlauben es einem, einen String mit dem Wert einer Variable zu kombinieren:

age = input("Wie alt bist du?") # Benutzerin wird nach Alter gefragt, wird in Variable age gespeichert.
print(f"Du bist {age} Jahre alt") # Der Wert der Variable age (also das Alter) wird im String eingefügt.

Falls die Benutzerin $15$ eingibt, gibt der Code dann also „Du bist 15 Jahre alt“ aus. Beachte:

• Vor dem String muss zwingend f stehen, was für formatiert steht.
• Die Variable, von der der Wert eingefügt werden soll, muss in geschwungenen Klammern {...} stehen.

Berechne mithilfe von Python. Verwende dazu die Rechenoperatoren in der Tabelle oben.

1. $62342+43169 = $
2. $287 \cdot 63 = $
3. $7731 : 532 = $
4. $\cfrac{(24\cdot 9)^3+10077697}{13} = $

Frage die Benutzerin der Reihe (separate input-Befehle) nach ihrem Namen, Alter und Wohnort. Gib dann eine schöne Zusammenfassung aller Eingaben mittels eines schön formatierten Strings (f-String) aus.

Beispiel:

• Eingaben:
  • „Hans Müller“
  • 42
  • „Romanshorn“
• Ausgabe: „Du heisst Hans Müller, bist 42 Jahre alt und wohnst in Romanshorn.“

Frage die Benutzerin nach ihrem Alter (in Jahren). Berechne nun ihr Alter …

• in Jahren
• in Monaten
• in Tagen
• in Sekunden

Gib die Resultate schönt formatiert aus. Keep it simple, ignoriere Schaltjahre.

Beispiel: Falls Eingabe $7$ ist, sollen Ausgaben sein:

Alter in Jahren:   7
Alter in Monaten:  84
Alter in Tagen:    2555
Alter in Sekunden: 220752000

Programmiere einen Countdown. In der Konsole soll also ausgegeben werden:

10
9
8
7
6
5
4
3
2
1
Los!

Tipps:

Optional: Summiere alle Zahlen auf. Berechne also $10 + 9 + 8 + \ldots + 1$. Was erhält man, wenn man den Countdown bei $100$ startet?

Zeichne mit einer Turtle die folgende eckige Spirale:

Tipp 1:

Tipp 2:

M&M-Verteiler: Zusammen mit ein paar Freunden kaufst du dir eine Tüte M&M. Diese werden dann gleichmässig verteilt. Schreibe nun folgenden Code:

• Frage Benutzer nach Anzahl M&M in der Tüte.
• Frage Benutzer nach Anzahl Freunden.
• Der Code gibt dann schön formatiert aus, wie viele M&M jede Person erhält …
• … und wie viele übrig bleiben.

Beispiel: Für $39$ M&M und $4$ Freunde soll ausgegeben werden: „Es gibt 9 M&M pro Person und es bleiben 3 Stück übrig.“

Tipps:

Zeichne mit einer Turtle die folgende Spirale:

Tipps:

Zeichne mit einer Turtle die folgende Figur:

Tipps:

Zeichne mit einer Turtle die folgende Figur:

Tipps:

Slides: Bedingungen & while-Schleife

Mit einer Schleife kann man einen Codeblock wiederholt ausführen lassen und zwar solange, wie eine vorgegebene Bedingung erfüllt ist.

while <Bedingung>:
    # Hier Codeblock, der wiederholt werden soll,
    # solange die Bedingung erfüllt ist.
    # Allen Zeilen, die zum Codeblock gehören
    # müssen eingerückt sein.
 
# hier Code, der NACH der while-Schleife ausgeführt werden soll

Alle Zeilen Code, die zum Codeblock der Schleife gehören werden eingerückt. Verwende dazu die Tab-Taste oben links. Nachdem der ganze Codeblock ausgeführt wurde, wird die Bedingung erneut überprüft. Ist sie immer noch erfüllt, wird der gleiche Codeblock wieder ausgeführt usw.

Ab sofort gilt ein komplettes Verbot der repeat-Schleife. Verwende stattdessen die while-Schleife.

Zählen: Gib alle Zahlen von $0$ bis und mit $42$ in der Konsole aus. Verwende eine while-Schleife.

Ausgabe:

0
1
2
...
41
42

It's (not) the final countdown: Programmiere wieder einen Countdown, diesmal aber natürlich mit einer while-Schleife.

Ausgabe:

10
9
8
...
2
1
Los!

Tipps:

Quadrat III: Lasse wieder eine Turtle ein Quadrat zeichnen - aber mit while!

Summieren: Berechne die Summe aller natürlicher Zahlen bis und mit $100$, also: $$1 + 2 + 3 + \ldots + 98 + 99 + 100 = ???$$ Guess what? Genau, man soll wieder eine while-Schleife programmieren.

Tipps:

Gib die ersten $100$ Zahlen der 7er-Reihe aus, also $7,14,21,\ldots$.

Eine While-Schleife wiederholt einen Codeblock solange, wie deren Bedingung erfüllt ist. Falls die Bedingung immer erfüllt ist, liegt eine Endlosschleife vor. Oft programmiert man aus Versehen eine Endlosschleife, es gibt aber auch viele Situationen, in denen dies erwünscht ist. Zum Beispiel will man typischerweise ein Game so lange spielen können, bis man keine Lust mehr hat (oder einem die Eltern zwingen, aufzuhören). Man verfolgt dann beim Programmieren den folgenden Ansatz:

1. Schreibe den Code in eine Endlosschleife:

while True:
    # hier kommt der Codeblock,
    # der wiederholt werden soll

1. Sobald der Codeblock aber doch abgebrochen werden soll (z.B. wegen GameOver oder beim erfolgreichen Abschliessen des Spiels oder weil die Benutzerin keine Lust mehr hat), schreibt man das Keyword break. Dies bricht die Schleife per sofort ab.

Beispiel: Die Benutzerin soll aufgefordert werden, die nerdigste Zahl der Welt (also $42$) einzugeben: „Gib die nerdigste Zahl der Welt ein“. Sobald sie $42$ eingegeben hat, soll die Schleife abgebrochen und der Benutzerin gratuliert werden:

while True:
    number = input("Gib die nerdigste Zahl der Welt ein")
    if number == 42:
        break
    else:
        print("Leider nicht, versuche es noch einmal")
 
print("Gratuliere, du hast die richtige Zahl, 42, eingegeben!")

Löse alle Aufgaben mit while-Schleifen und break.

Negative Zahl: Die Benutzerin soll solange aufgefordert, eine negative Zahl einzugeben, bis sie es geschafft hat. Gibt sie eine falsche Zahl ein, soll sie erneut aufgefordert werden.

Code für Geheimtür: Der Benutzer soll aufgefordert werden, das geheime Passwort („spaghetti“) einzugeben. Gibt er es falsch ein, wird ausgegeben „Zugang verweigert“. Macht er es richtig, wird „Zugang gewährt“ ausgegeben und der Code abgebrochen.

Unendliche Summe: Die Benutzerin soll unendlich oft hintereinander aufgefordert werden, eine Zahl einzugeben. Die neu eingegebene Zahl wird zu den bisherigen hinzuaddiert und das aktuelle Resultat ausgegeben.

Um das Programm abzubrechen, kann die Benutzerin „q“ (für Quit) eingeben.

Löse die Aufgaben so elegant wie möglich. Verwende z.B. wann immer möglich Schleifen.

Bart hat mal seine Carbonara wieder mit Rahm gekocht! Zur Strafe muss er 100x „Kein Rahm in die Carbonara!“ schreiben. Da du ein Herz für Bart hast, möchtest du ihm helfen und ihm einen Code schreiben, der ihm die Arbeit abnimmt (auch wenn er seine Strafe eigentlich verdient hat).

Gib alle Zahlen der 5er Reihe aus im Bereich $5,10,...,500$.

Berechne die Summe aller gerader Zahlen von $2$ bis und mit $100$.

Im Sekundentakt soll herauf gezählt werden: $1,2,3,4,5,...$. Um einen Delay von 1s einzubauen, gehe wie folgt vor:

import time # importiere ganz oben im Code
...
time.sleep(1) # Befehl, dass für 1s soll pausieren

Erzeuge das folgende Bild auf clevere Art und Weise.

Tipp: Verwende zwei ineinander verschachtelte Schleifen.

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 dem Lehrer.

Lösungen A

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)

from gturtle import *
fritz = Turtle()
fritz.right(90)
fritz.forward(200)
fritz.left(120)
fritz.forward(200)
fritz.left(120)
fritz.forward(200)

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)

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)

Lösungen B

from gturtle import *
 
length = 150
 
turi = Turtle()
 
repeat 4:
    turi.forward(length)
    turi.left(90)

from gturtle import *
 
length = 150
 
turi = Turtle()
turi.right(90)
 
repeat 3:
    turi.forward(length)
    turi.left(120)

from gturtle import *
 
length = 150
 
turi = Turtle()
 
repeat 6:
    turi.forward(length)
    turi.left(60)

from gturtle import *
 
length = 30
 
turi = Turtle()
 
repeat 10:
    turi.forward(length)
    turi.right(90)
    turi.forward(length)
    turi.left(90)

from gturtle import *
 
turi = Turtle()
 
repeat 9:
    turi.forward(150)
    turi.left(160)

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)

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)

Lösungen C

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)

from gturtle import *
 
peter = Turtle()
 
radius = 30
 
peter.setPos(0,-200)
 
repeat 4:
    peter.rightArc(radius,180)
    peter.leftArc(radius,180)

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)

from gturtle import *
 
peter = Turtle()
 
radius = 70
 
peter.rightArc(radius,180)
peter.leftArc(radius,180)
peter.leftArc(2*radius,180)

Lösungen D

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)

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)

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()

Lösungen E

guess = input("Versuche, meine Lieblingszahl zu erraten!")
 
if guess == 7:
    print("Korrekt!")
else:
    print("Falsch! Warum weisst du das nicht?")

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!")

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!")

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.")

age = input("Wie alt bist du?")
 
if age >= 18:
    print("Volljährig.")
else:
    print("Minderjährig.")

number = input("Gib eine Zahl ein")
 
if number > 0:
    print("positiv")
elif number == 0:
    print("Null")
else:
    print("negativ")

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)

Lösungen G

print(62342 + 43169)
print(287 * 63)
print(7731 / 532)
print(((24*9)**3+10077697)/13)

name = input("Wie heisst du?")
age = input("Wie alt bist du?")
residence = input("Wo wohnst du?")
print(f"Du heisst {name}, bist {age} Jahre alt und wohnst in {residence}.")

age = input("Gib dein Alter ein.")
 
print(f"Alter in Jahren:     {age}")
print(f"Alter in Monaten:    {age * 12}")
print(f"Alter in Tagen:      {age * 365}")
print(f"Alter in Sekunden:   {age * 365 * 24 * 3600}")

number = 10
 
repeat 10:
    print(number)
    number = number - 1
 
print("Los!")

number = 10
 
repeat number:
    print(number)
    number = number - 1
 
print("Los!")

from gturtle import *
 
turi = Turtle()
turi.hideTurtle()
 
length = 50
 
repeat 32:
    turi.forward(length)
    turi.left(90)
    length = length + 10

nr_mm_total = input("Wie viele M&M sind in der Packung?")
friends = input("Wie viele Freunde seid ihr?")
 
nr_mm_per_person = nr_mm_total // friends
mm_remaining = nr_mm_total % friends
 
print(f"Es gibt {nr_mm_per_person} M&M pro Person und es bleiben {mm_remaining} Stück übrig.")

from gturtle import *
 
turi = Turtle()
turi.hideTurtle()
 
length = 10
 
repeat 30:
    turi.leftArc(length,90)
    length = length + 5

from gturtle import *
 
turi = Turtle()
turi.hideTurtle()
 
position = -200
radius = 30
 
repeat 10:
    turi.setPos(position,0)
    turi.leftArc(30,360)
    position = position + 2 * radius

from gturtle import *
 
turi = Turtle()
turi.hideTurtle()
 
radius = 40
position = -300
 
repeat 6:
    turi.setPos(position,0)
    repeat 4:
        turi.forward(100)
        turi.left(90)
    position = position + 120

Aufgaben H

count = 0
while count <= 42:
    print(count)
    count = count + 1

countdown = 10
while countdown > 0:
    print(countdown)
    countdown = countdown - 1
 
print("Los!")

from gturtle import *
 
turi = Turtle()
 
count = 0
while count < 4:
    turi.forward(150)
    turi.left(90)
    count = count + 1

summe = 0
 
count = 0
while count <= 100:
    summe = summe + count
    count = count + 1
 
print(summe)

# OPTION 1: mit zwei separaten Variablen
count = 0
number = 7
 
while count < 100:
    print(number)
    count = count + 1
    number = number + 7
 
# OPTION 2: mit nur einer Variablen
count = 0
while count < 100:
    count = count + 1
    print(7*count)

Aufgaben I

while True:
    number = input("Gib eine negative Zahl ein.")
    if number < 0:
        break
    else:
        print("Falsch. Try again!")
 
print("Korrekt!")

while True:
    eingabe = input("Gib das geheime Passwort ein")
    if eingabe == "Spaghetti":
        print("Korrekt. Zutritt gewährt")
        break
    else:
        print("Falsch. Zugang verweigert. Try again!")

summe = 0
 
while True:
    eingabe = input("Gib Zahl ein, die dazu addiert werden soll. Abbrechen mit 'q'.")
    if eingabe == 'q':
        break
    summe = summe + eingabe
    print(f"Die Summe bisher ist: {summe}")
 
print(f"Die finale Summe ist: {summe}")