Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen der Seite angezeigt.

Link zu der Vergleichsansicht

Nächste Überarbeitung		 Vorherige Überarbeitung
gf_informatik:programmieren_ii:variablen_verzweigungen_schleifen [2022-10-24 12:53] – angelegt hofgf_informatik:programmieren_ii:variablen_verzweigungen_schleifen [2023-10-22 10:21] (aktuell) – [Tabelle] hof
Zeile 1: Zeile 1:
-====== Programmieren II: Variablen, Schleifen, Funktionen ======+====== Programmieren II: Variablen, Verzweigungen, Schleifen ======
  
 Du kannst bereits programmieren? Dann [[gf_informatik:programmieren_ii:advanced|schau hier nach]]. Du kannst bereits programmieren? Dann [[gf_informatik:programmieren_ii:advanced|schau hier nach]].
Zeile 6: Zeile 6:
 Neben Turtlegrafik kann man in TigerJython und Python auch noch andere Dinge machen, die Spass machen, wie z.B. Mathe. Neben Turtlegrafik kann man in TigerJython und Python auch noch andere Dinge machen, die Spass machen, wie z.B. Mathe.
  
-*Tipp:* Möchtest du nur z.B. etwas berechnen, ohne dabei eine Turtle zu gebrauchen? Dann kannst du die zuvor immer benötigte Zeile Code `from gturtle import *` weg lassen.+*Tipp:* Möchtest du nur z.B. etwas berechnen, ohne dabei eine Turtle zu gebrauchen? Dann kannst du die zuvor immer benötigte Zeile Code `from turtle import *` weglassen.
  
  
 ==== - Variablen ==== ==== - Variablen ====
  
-In **Variablen** werden Werte gespeichert, die man im Laufe des Programms lesen oder verändern will. Variablen haben einen Namen und einen Wert. Der Name der Variable darf man frei wählen. Nicht erlaubt sind allerdings die Schüsselwörter (z.B. *from*, *repeat*, ...) und Namen mit Sonderzeichen.+In **Variablen** werden Werte gespeichert, die man im Laufe des Programms lesen oder verändern will. Variablen haben einen Namen und einen Wert. Den Namen der Variable darf man frei wählen. Nicht erlaubt sind allerdings die Schüsselwörter (z.B. *from*, *repeat*, ...) und Namen mit Sonderzeichen.
  
 Variablen kannst du ganz einfach deklarieren: `<Name der Variablen> = <Wert der Variablen>` Variablen kannst du ganz einfach deklarieren: `<Name der Variablen> = <Wert der Variablen>`
Zeile 49: Zeile 49:
 Einige wichtige **mathematischen Operatoren** sind: Einige wichtige **mathematischen Operatoren** sind:
  
-^ Funktion ^ Python-Code ^ +^ Funktion ^ Python-Code ^ Resultat ^ 
-| Addition | `7+3` | +| Addition | `5+2` | `7` | 
-| Subtraktion | `7-3` | +| Subtraktion | `5-2` | `3` | 
-| Multiplikation | `7*3` | +| Multiplikation | `5*2` | `10` | 
-| Division (Nachkommastellen) | `7/3` | +| Division (Nachkommastellen) | `5/2` | `2.5` | 
-| Ganzzahldivision | `7//3` | +| Ganzzahldivision | `5//2` | `2` | 
-| Hoch (z.B. 2 hoch 5) | `2**5` | +| Hoch (z.B. 2 hoch 5) | `5**2` | `25` | 
-| Wurzel (z.B. Wurzel von 2, sqrt für square-root) | `sqrt(2)` | +| Wurzel (z.B. Wurzel von 2, sqrt für square-root) | `sqrt(2)` | `1.4142135...` | 
-| Modulo (Rest der Ganzzahl-Division, Bsp. `17%5 = 2`) | `17%2`| +| Modulo (Rest der Ganzzahl-Division) | `5%2`| `1` |
 ==== - Input ==== ==== - Input ====
  
Zeile 84: Zeile 83:
 ==== - Aufgaben D ==== ==== - Aufgaben D ====
  
-Von nun an arbeiten wir nur noch selten mit TurtleGraphics. Die Zeile `from gturtle import *` wird also nicht gebraucht und kann weggelassen werden.+Von nun an arbeiten wir nur noch selten mit TurtleGraphics. Die Zeile `from turtle import *` wird also nicht gebraucht und kann weggelassen werden.
  
 === Aufgabe D1 === === Aufgabe D1 ===
Zeile 108: Zeile 107:
  
 === Aufgabe D3 === === Aufgabe D3 ===
- 
 Mache eine Kopie einer deiner bereits gelösten Aufgaben aus den Aufgaben A und B und speichere diese unter dem Namen `aufgabe_D3.py`. Suche einen möglichst langen und komplizierten Code aus. Füge nun überall wo es möglich ist, Variablen ein. Anstelle, dass du also immer `fritz.left(90)` schreibst, definiere eine Variable `winkel = 90` und schreibe nachher immer `fritz.left(winkel)`. Mache eine Kopie einer deiner bereits gelösten Aufgaben aus den Aufgaben A und B und speichere diese unter dem Namen `aufgabe_D3.py`. Suche einen möglichst langen und komplizierten Code aus. Füge nun überall wo es möglich ist, Variablen ein. Anstelle, dass du also immer `fritz.left(90)` schreibst, definiere eine Variable `winkel = 90` und schreibe nachher immer `fritz.left(winkel)`.
  
Zeile 119: Zeile 117:
    * Breite des Rechtecks    * Breite des Rechtecks
    * Höhe des Rechtecks    * Höhe des Rechtecks
 +
 +
 +=== Aufgabe D5 ===
 +
 +Die Schildkröte soll eine Spirale aus mehreren (unterschiedlich grossen) Halbkreisen zeichnen. Die Benutzer:in soll dazu folgende Werte eingeben (alle mit einem seperatern `input`-Statement):
 +  * Anzahl Halbkreise
 +  * Start-Radius: Der kleinste Halbkreis wird mit diesem Radius gezeichnet.
 +  * Zunahme: Um diesen Wert wird der Radius jedes Halbkreises grösser als der vorherige.
  
 ===== - Logik: if-else ===== ===== - Logik: if-else =====
Zeile 124: Zeile 130:
 Beim Programmieren kommt man oft in die Situation, wo man **Entscheidungen** treffen muss. Zum Beispiel soll, je nach dem was der Benutzer eintippt, ein anderer Code ausgeführt werden. Beim Programmieren kommt man oft in die Situation, wo man **Entscheidungen** treffen muss. Zum Beispiel soll, je nach dem was der Benutzer eintippt, ein anderer Code ausgeführt werden.
  
-Am einfachsten ist der sogenannte **if**-Befehl: Damit kann man überprüfen ob (also //if//) eine gewisse Bedingung erfüllt ist oder nicht. Dieser Befehl hat die Form+Am einfachsten ist der sogenannte **if**-Befehl: Damit kann man überprüfen, ob (also //if//) eine gewisse Bedingung erfüllt ist oder nicht. Dieser Befehl hat die Form
  
 <code python> <code python>
Zeile 138: Zeile 144:
 **Bedingungen** können zum Beispiel sein: **Bedingungen** können zum Beispiel sein:
  
-^ Bedingung ^ Erklährung ^ +^ Bedingung       ^ **Erklärung**                                  ^ 
-| `x == 4` | x ist Zahl und hat Wert von genau 4 | +| `x == 4`        | x ist Zahl und hat Wert von genau 4            | 
-| `s == "Hallo"` | s ist String und hat genau den Inhalt "Hallo" | +| `s == "Hallo"`  | s ist String und hat genau den Inhalt "Hallo"  | 
-| `x != 4` | x ist NICHT eine Zahl vom Wert | +| `x != 4`        | x ist NICHT eine Zahl vom Wert 4               | 
-| `x > 5` | x ist Zahl grösser als 5 | +| `x > 5`         | x ist Zahl grösser als 5                       | 
-| `x >= 5` | x ist Zahl grösser gleich 5 | +| `x >= 5`        | x ist Zahl grösser gleich 5                    | 
-| `x < 5` | x ist Zahl kleiner als 5 | +| `x < 5`         | x ist Zahl kleiner als 5                       | 
-| `x <= 5` | x ist Zahl kleiner gleich 5 |+| `x <= 5`        | x ist Zahl kleiner gleich 5                    |
  
 **Wichtig:** Beachte das **Doppelgleichzeichen** `==`. Eine Bedingung mit nur einem Gleichzeichen wie z.B. `x = 4` funktioniert nicht! **Wichtig:** Beachte das **Doppelgleichzeichen** `==`. Eine Bedingung mit nur einem Gleichzeichen wie z.B. `x = 4` funktioniert nicht!
Zeile 198: Zeile 204:
  
  
-==== - Aufgaben F ====+==== - Aufgaben E ====
  
-=== Aufgabe F1 ===+=== Aufgabe E1 ===
  
 Nimm den Code aus dem Beispiel als Startpunkt. In diesem wird eine Zahl eingeben wird und dann entschieden, ob die Zahl positiv oder negativ ist. Erweitere den Code nun so, dass zwischen den folgenden drei Fällen unterschieden wird: Nimm den Code aus dem Beispiel als Startpunkt. In diesem wird eine Zahl eingeben wird und dann entschieden, ob die Zahl positiv oder negativ ist. Erweitere den Code nun so, dass zwischen den folgenden drei Fällen unterschieden wird:
Zeile 210: Zeile 216:
 //Tipp:// Hier benötigst du einen //if-elif-else//-Befehl. //Tipp:// Hier benötigst du einen //if-elif-else//-Befehl.
  
-=== Aufgabe F2 ===+=== Aufgabe E2 ===
  
 Schreibe ein Programm, in dem der Benutzer eine Figur wünschen kann, die der Turtle dann abläuft. Diese sollen sein: Schreibe ein Programm, in dem der Benutzer eine Figur wünschen kann, die der Turtle dann abläuft. Diese sollen sein:
Zeile 221: Zeile 227:
 *Optional: Füge weitere Figuren hinzu. *Optional: Füge weitere Figuren hinzu.
  
-=== Aufgabe F3 ===+=== Aufgabe E3 ===
  
 == Schritt 1 == == Schritt 1 ==
Zeile 236: Zeile 242:
 import random # schreibe dies ganz oben in deinem Code 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+zahl1 = random.randint(0,10) # wählt zufällig eine Zahl aus den Zahlen 0,1,2,3,...,9,10 aus
 ... ...
 </code> </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!| 
- 
- 
-=== Aufgabe F4 (optional) === 
- 
-Gleich wie Aufgabe F3. Es sollen aber neben der Addition auch Subtraktionen und Multiplikationen vorkommen. Die Division sollte weggelassen werden, da es dort schnell Aufgaben gibt, die man kaum lösen kann. Welche der drei Operationen an der Reihe ist, soll ebenfalls der Zufall entscheiden. 
  
 ===== - While-Schleife ===== ===== - While-Schleife =====
  
-Die for-Schleife ist praktisch, wenn man genau weiss, wie oft etwas durchgeführt werden soll. In der Aufgabe E3 hast du ein Mathe-Quiz mit 10 Runden programmiert. Dort hat es Sinn gemacht, eine for-Schleife (`for i in range(10)`) zu verwenden. Dies ist aber nicht immer der Fall. Zum Beispiel könnte man ein Spiel programmieren, in dem man nur solange weiterspielen darf, bis man einen Fehler macht. Es entscheidet sich also erst im Spiel, wie viele Runden man spielt - vielleicht sind es 30, vielleicht aber auch nur eine. +Oft wollen wir einen Schritt mehrmals wiederholen. Dies können wir mit einer **while-Schleife** (dt. //während//) umsetzen. Diese hat folgende Form:
- +
-Dies können wir mit einer **while-Schleife** (dt. //während//) umsetzen. Diese hat folgende Form:+
  
 <code python> <code python>
Zeile 278: Zeile 261:
 </code> </code>
  
-Die Bedingungen schreibt man gleich wie für for-Schleifen, also `==, >, >=, ...`+Die Bedingungen schreibt man gleich wie für if-Verzweigungen, also `==, >, >=, ...`
  
 **Beispiel:** Im folgenden Programm wird man aufgefordert, eine positive Zahl einzugeben. Man kann solange weiterspielen, bis man etwas eingibt, was //keine// positive Zahl ist, also z.B. eine negative Zahl oder Text. **Beispiel:** Im folgenden Programm wird man aufgefordert, eine positive Zahl einzugeben. Man kann solange weiterspielen, bis man etwas eingibt, was //keine// positive Zahl ist, also z.B. eine negative Zahl oder Text.
Zeile 305: Zeile 288:
 Eine Möglichkeit gibt es aber, aus eine Schleife wie der oberen (`while True: ...`) auszubrechen: Wird der Befehl `break` aufgerufen, wird die **Schleife umgehend abgebrochen** und der Code unterhalb wird ausgeführt.  Eine Möglichkeit gibt es aber, aus eine Schleife wie der oberen (`while True: ...`) auszubrechen: Wird der Befehl `break` aufgerufen, wird die **Schleife umgehend abgebrochen** und der Code unterhalb wird ausgeführt. 
  
-==== - Aufgaben G ====+==== - Aufgaben F ====
  
-=== Aufgabe G1 ===+=== Aufgabe F1 ===
  
 Schreibe ein Programm, in dem man eine zweistellige Zahl eingeben soll. Dies soll man solange machen können, bis man diese Bedingung einmal nicht mehr erfüllt. Schreibe ein Programm, in dem man eine zweistellige Zahl eingeben soll. Dies soll man solange machen können, bis man diese Bedingung einmal nicht mehr erfüllt.
Zeile 321: Zeile 304:
 </code> </code>
  
-=== Aufgabe G2 ===+=== Aufgabe F2 === 
 +Oft wollen wir einen Schritt eine bestimmte Anzahl mal wiederholen. In TigerJython können wir dazu `repeat` verwenden, was aber in Python nicht unterstützt wird. Wie kannst du die gleiche Funktionalität erhalten mit `while`?
  
-Mache eine Kopie von deinem Mathe-Quiz aus Aufgabe F3 oder F4. Man soll nun beliebig lange spielen können. Nach jeder Frage wird der Spielstand ausgegeben. +Schreibe Turtle Code, der ein Quadrat zeichnet, aber verwende dazu nur `while`.
  
-//Tipp:// Verwende eine Endlosschleife.+=== Aufgabe F3 === 
 +Erweitere nun dein Spiel aus E3 wie folgt:
  
-=== Aufgabe G3 ===+== Schritt 1 == 
 + 
 +Erweitere nun dein Spiel wie folgt: Es sollen mehrere Runden gespielt werden, wobei in jeder Runde eine Zufallsaufgabe generiert wird (wie in Schritt 2). Es soll mitgezählt werden, wie viele Aufgaben richtig gelöst wurden. Nach jeder Frage wird der Spielstand ausgegeben, der Spieler soll eine entsprechende Rückmeldung erhalten, z.B.: 
 +''Du hast 7 von 10 Aufgaben richtig gelöst.'' 
 + 
 +=== Aufgabe F4 (optional) === 
 + 
 +Gleich wie Aufgabe F3. Es sollen aber neben der Addition auch Subtraktionen und Multiplikationen vorkommen. Die Division sollte weggelassen werden, da es dort schnell Aufgaben gibt, die man kaum lösen kann. Welche der drei Operationen an der Reihe ist, soll ebenfalls der Zufall entscheiden. 
 + 
 +=== Aufgabe F5 ===
  
 Mache eine Kopie von deinem Mathe-Quiz aus der letzten Aufgabe.  Mache eine Kopie von deinem Mathe-Quiz aus der letzten Aufgabe. 
Zeile 340: Zeile 334:
 Man soll solange spielen können, bis man drei Fehler gemacht hat. Dann ist Game Over. Man soll solange spielen können, bis man drei Fehler gemacht hat. Dann ist Game Over.
  
- +=== Aufgabe F6 === 
-===== - Funktionen ===== +Schreibe eine Programm, das wie folgt funktioniert: 
- +  * Die Benutzer:in muss eine positive, zweistellige Zahl eingeben. Hierzu wird sie solange aufgefordert, bis sie wirklich eine positive, zweistellige Zahl eingegeben hat.  
-Komplexe Programme können mit Hilfe von Funktionen in kleinere, leichter zu programmierende Teilprogramme zerlegt werden. Solche Teilprogramme können zudem mehrmals verwendet werden. +  * Dann macht das Programm Folgendes: 
- +    * Wenn die eingegebene Zahl gerade (also restlos durch 2 teilbar) ist, dann gibt das Programm alle geraden Zahlen von 0 bis zur eingegeben Zahl aus.  
-==== - Definition ==== +    * Wenn die eingegebene Zahl ungerade ist, dann gibt das Programm alle Zahlen der Fünfer-Reihe von 0 bis (in etwa) zur eingegeben Zahl aus.
- +
-Eine **Funktion** ist immer wie folgt aufgebaut: +
- +
-<code python> +
-def name_der_funktion(PARAMETER): # Parameter sind optional +
-    # CODE DER FUNKTION +
-    return RETURN_WERT # ist optional +
-</code> +
- +
-   * Das Schlüsselwort **def** leitet immer die Definition einer Funktion ein. +
-   * Darauf folgt der **Funktionsname**. Typischerweise schreibt man diesen mit ausschliesslich Kleinbuchstaben und Underlines _ +
-   * Direkt anschliessend werden **runde Klammern** geschrieben. Diese enthalten die **Parameter**. Das sind Werte, die an die Funktion übergeben werden. Funktionen können auch ohne Parameter definiert werden, die Klammern sind dann halt einfach leer. +
-   * Nach einem **Doppelpunkt** ... +
-   * kommt der **Funktionskörper**, welcher den eigentlichen Code der Funktion beinhaltet. Dieser Code muss **eingerückt** sein. +
- +
-Nachdem du eine Funktion definiert hast, kannst du sie ganz einfach aufrufen. Dazu mehr in den Beispielen unten. +
- +
-Übrigens hast du schon viele Funktionen kennengelernt - ohne dass du es wahrscheinlich gemerkt hast. Zum Beispiel ist die Funktion `forward()` für Turtles eine Funktion, die ein Turtle vorwärts laufen lässt. Diese Funktion wurde vorprogrammiert. Nun wollen wir schauen, wie wir unsere eigenen Funktionen definieren können. +
- +
-==== - Funktionen ohne Rückgabewert ==== +
- +
-In diesem Unterkapitel schauen wir Funktionen ohne Rückgabewert an, also Funktionen ohne das `return`-Statement am Ende. +
- +
-**Beispiel:** Du möchtest das gleiche Quadrat mehrfach zeichnen. Dies kannst du wie folgt machen: +
- +
-<code python> +
-from gturtle import * +
- +
-fritz = Turtle() +
-fritz.hideTurtle() +
- +
-# Quadrat 1 +
-fritz.setPos(-130,0) +
-repeat 4: +
-    fritz.forward(100) +
-    fritz.left(90) +
- +
-# Quadrat 2 +
-fritz.setPos(0,0) +
-repeat 4: +
-    fritz.forward(100) +
-    fritz.left(90) +
-</code> +
- +
-Es fällt auf, das hier zweimal der //identische// Code vorkommt: +
-<code python> +
-repeat 4: +
-    fritz.forward(100) +
-    fritz.left(90) +
-</code> +
- +
-Dies ist nicht sehr elegant. Wenn man nun das gleiche Quadrat 10-mal zeichnen möchte, wird es noch viel schlimmer! Es lohnt sich deshalb hier, eine Funktion //quadrat// zu definieren und diese dann mehrfach aufzurufen: +
- +
-<code python> +
-from gturtle import * +
- +
-fritz = Turtle() +
-fritz.hideTurtle() +
- +
-def quadrat(): +
-    repeat 4: +
-        fritz.forward(100) +
-        fritz.left(90) +
- +
-# Quadrat 1 +
-fritz.setPos(-130,0) +
-quadrat() +
- +
-# Quadrat 2 +
-fritz.setPos(0,0) +
-quadrat() +
-</code> +
- +
-Beachte, dass man jeweils zuerst die Position der Turtle festlegen muss, bevor man die Funktion aufrufen kann. Noch eleganter ist es, wenn man das Setzen der Position in die Funktion hinein nimmt. Die Koordinaten muss man dann der Funktion als **Argument** übergeben. Mit zwei weiteren Argumenten geben wir die Grösse des Quadrates und die Farbe an: +
- +
-<code python> +
-from gturtle import * +
-  +
-fritz = Turtle() +
-fritz.hideTurtle() +
-  +
-def quadrat(x,y): +
-    fritz.setPos(x,y) +
-    repeat 4: +
-        fritz.forward(100) +
-        fritz.left(90) +
-  +
-# Quadrat 1 +
-quadrat(-130,0) +
-  +
-# Quadrat 2 +
-quadrat(0,0) +
-</code> +
- +
-Man kann der Funktion auch noch weitere Argumente übergeben, zum Beispiel um die Grösse des Quadrats und dessen Farbe anzugeben: +
- +
-<code python> +
-from gturtle import * +
-  +
-fritz = Turtle() +
-fritz.hideTurtle() +
-  +
-def quadrat(x,y,seite,farbe): +
-    fritz.setPos(x,y) +
-    fritz.setPenColor(farbe) +
-    repeat 4: +
-        fritz.forward(seite) +
-        fritz.left(90) +
-  +
-# Quadrat 1 +
-quadrat(-130,0,70,"red") +
-  +
-# Quadrat 2 +
-quadrat(0,0,100,"magenta") +
-</code> +
- +
-==== - Funktionen mit Rückgabewert ==== +
- +
-Funktionen bieten sich auch an, wenn man mehrfach die gleiche Rechnung, einfach mit verschiedenen Werten, ausführen möchte. Allerdings möchte man dann, dass die Funktion einem das Resultat als **Rückgabewert** zurück gibt. +
- +
-**Beispiel:** Wir wollen eine Funktion definieren, die uns das Volumen eines Quaders zurück gibt. Falls der Quader die Seitenlängen $a,b$ und $c$ hat, so ist sein Volumen +
-$$V = a \cdot b \cdot c$$ +
-Die zugehörige Funktion ist dann: +
-<code python quader.py> +
-def quader(a,b,c): +
-    resultat = a*b*c +
-    return resultat +
-     +
-print(quader(4,3,2)) +
-</code> +
-Auf der letzten Zeile wird das Volumen für einen Quader mit Seitenlängen $4, 3$ und $2$ berechnet und dann in der Konsole ausgegeben. +
- +
-==== - Aufgaben H ==== +
- +
-=== Aufgabe H1 === +
- +
-Definiere folgende Funktionen: +
- +
-   * quadrat(breite,farbe,x,y) +
-   * dreieck(breite,farbe,x,y) +
-   * kreis(radius,farbe,x,y) +
- +
-Ruft man z.B. die Funktion `dreieck(300,red,-200,50)` auf, soll ein rotes Dreieck mit Startpunkt (-200,50) gezeichnet werden. +
- +
-Zeichne mit diesen Funktionen ein Bild. Jede der drei Formen soll mindestens 3x vorkommen. Variiere die Farbe und Grösse der Formen. +
- +
-=== Aufgabe H2 === +
- +
-Kennt man in einem rechtwinkligen Dreieck die beiden Katheten, so kann man mit dem Satz von Pythagoras die Hypothenuse bestimmen. Definiere eine Funktion mit Namen //pythagoras//. Als Argumente soll man die beiden Katheten eines rechtwinkligen Dreiecks eingeben. Die Funktion berechnet dann die Hypothenuse und gibt diese mit //return// zurück. +
- +
-//Tipp:// Die Wurzel einer Zahl ziehst du mit `sqrt(x)`, dazu musst du aber zuerst das math-Modul importieren: `import math`. +
- +
-//Kontrolle:// Für die Katheten 3 und 4 ist die Hypothenuse 5. Die Codezeile `print(pythagoras(3,4))` soll dann also `5.0` ausgeben. +
- +
-=== Aufgabe H3 === +
- +
-Das Volumen einer Kugel mit Radius $R$ ist: $$V = \frac{4\pi}{3}\cdot R^3$$ +
-Definiere eine Funktion //kugel//, der man als Argument den Radius übergibt und die dann das Volumen zurückgibt. Die Kreiszahl Pi ($\pi$) kannst du mit `math.pi` aufrufen, dazu muss aber auch wieder zuerst das math-Modul importiert werden (`import math`). +
- +
-=== Aufgabe H4 === +
- +
-Definiere eine Funktion //wuerfel//, welche einen Würfel simuliert, d.h. eine Zufallszahl zwischen 1 und 6 mit //return// zurückgibt. +
- +
-=== Aufgabe H5 === +
- +
-Die Fakultät ist eine Funktion, welche jeder ganzen natürlichen Zahl das Produkt aller natürlichen Zahlen (ohne Null) kleiner und gleich dieser Zahl zuordnet. Sie wird mit einem Ausrufezeichen geschrieben. Als Beispiel: $5!=1 \cdot 2 \cdot 3 \cdot 4 \cdot 5 =120$. +
- +
-Schreibe eine Funktion //fakultaet//, welcher als Argument eine ganze Zahl übergeben wird und welche dir dann die Fakultät dieser Zahl zurückgibt. +
- +
-**Challenge**: Kannst du die Fakultät ganz ohne Schleife berechnen? Dann hast du das Prinzip der *Rekursion* (Selbst-Aufruf) entdeckt! +
- +
-=== Aufgabe H6 (optional) === +
-In einer Zusatzaufgabe von früher (https://sca.ksr.ch/doku.php?id=gf_informatik_1m_20_21:python_zusatzaufgaben#euklidischer_algorithmus) hast du den euklidischen Algorithmus benutzt, um den ggT von zwei Zahlen zu berechnen. +
- +
-Schreibe eine Funktion //ggt// und //kgv// welche als Argument zwei Zahlen nimmt, und daraus den grössten gemeinsamen Teiler, bzw. das kleinste gemeinsame Vielfache berechnet. +
- +
-Wenn du das gemacht hast, machst du daraus eine einzelne Funktion, welche als Argument zusätzlich einen String mit ggt, bzw. kgv entgegennimmt und dann entweder den ggT bzw. das kgV ausgibt. +
- +
- +
-=== Aufgabe H7 (optional) === +
- +
-In **Aufgabe F2** wird der Benutzer gefragt, was für eine Grafik angezeigt werden soll. Erweitere deinen Code, so dass der Benutzer folgendes machen kann: +
- +
-   * Auswahl der Farbe +
-   * Festlegen der Grösse +
-   * Festlegen der Stiftbreite +
-   * Weitere Formen +
- +
-//Tipp:// Möchte man die Formen farbig ausfüllen, so lohnt es sich, die 2. Methode mit `fillToPoint` zu verwenden. +
- +
-=== Aufgabe H8 (optional) === +
- +
-In einer Aufgabe oben hast du eine Funktion `wuerfel` definiert. Simuliere nun mit TurtleGraphics einen Würfel.  +
- +
-===== - Listen ===== +
- +
-Bisher haben wir Resultate entweder mit print() direkt in der Konsole ausgegeben oder als einzelne Zahlen in Variablen gespeichert. Oft macht es Sinn, Werte in Listen zu speichern. Dies geht ganz einfach: +
- +
-Eine Liste erstellt man wie folgt: +
-<code python> +
-L = [2,4,6,8] +
-</code> +
-Eine Liste besteht aus **Elementen**, die Position eines Elements wird **Index** genannt. Die Elemente einer Liste kann man über ihren Index **auslesen**. Das erste Element hat den Index 0, das zweite den Index 1 usw. `print(L[2])` gibt also `6` in der Konsole aus. Ganz ähnlich kannst du auch einen **Wert ändern**: `L[2] = 7`. +
- +
-Elemente hinten **hinzufügen** kann man mit append: +
-<code python> +
-L = [2,4,6,8] +
-L.append(10) +
-</code> +
- +
-Nach dem append-Befehl sieht die Liste wie folgt aus: `[2, 4, 6, 8, 10]`. Mit `print(L)` kannst du dich selbst davon überzeugen. Weitere wichtige Befehle sind +
-<code python> +
-L.insert(2,5) # fügt an Index-Position 2 den Wert 5 ein +
-L.pop(4) # Entfernt das Element mit Index 4 +
-len(L) # Gibt an, wieviele Elemente sich in der Liste befinden. Diesen Wert kann man z.B. printen oder in einer Variablen speichern +
-</code> +
- +
-Es ist ganz einfach, alle Elemente einer Liste durchzugehen: +
-<code python> +
-for e in L: +
-    print(e) +
-</code> +
- +
-==== - Aufgaben I ==== +
- +
-=== - Aufgabe I1 === +
- +
-Diese Aufgabe besteht aus vielen kleinen Teilaufgaben, in denen die Grundlagen der Listen geübt werden. +
-   - Erstelle die Liste `A = [0,1,2,3,4,5,6]`. Füge der Liste hinten den Wert `7` hinzu. Entferne dann weiter das erste Element `0`. Printe die bearbeitete Liste in die Konsole und vergewissere dich, dass sie wie folgt ausschaut: `[1, 2, 3, 4, 5, 6, 7]`. +
-   - Erstelle eine leere Liste `B = []`. Nun sollen alle Werte von 0 bis 99 darin gespeichert werden. Erstelle dazu eine for-Schleife, die durch alle Werte von 0 bis 99 zählt. In jedem Durchlauf der for-Schleife soll das nächste Element hinzugefügt werden. +
-   - Kopiere die folgende Liste ins TigerJython: `C = [68, 71, 53, 34, 66, 55, 80, 93, 24, 49, 68, 73, 9, 8, 93, 22, 44, 11, 82]`. Bestimme dann mithilfe von deinem Wissen über Listen, aus wievielen Elementen diese Liste besteht. Selbst zählen zählt nicht! +
-   - Kopiere die Liste `[0,2,4,6,8,10,12,16,18,20]` ins TigerJython. In ihr fehlt die Zahl 14! Füge diese am richtigen Ort ein. +
-   - Kopiere die Liste `[0,2,3,6,8,10,13,14,16,19,20]` ins TigerJython. In ihr sind drei Zahlen falsch! Ändere diese, in dem du direkt die Werte anpasst. Du darfst also weder //pop// noch //insert// verwenden. Wähle also zum Beispiel das Element mit Index 2 aus und ändere seinen Wert. +
-   - Die folgende Liste sollte eigentlich ausschlisslich aus Zahlen der 5er-Reihe bis und mit 50 bestehen: `E = [5,10,12,15,20,27,30,31,35,36,40,50]`. Kopiere diese Liste ins TigerJython und bearbeite sie so, dass sie stimmt: Entferne falsche Elemente und füge fehlende Elemente ein. Arbeite also ausschliesslich mit //pop// und //insert//. +
- +
-=== - Aufgabe I2 === +
- +
-Definiere eine Funktion `zero_list(n)`. Dieser wird als Argument eine Zahl übergeben. In der Funktion wird dann eine Liste erstellt, die n-mal die Zahl 0 enthält. Diese Liste wird dann zurückgegeben. Mit dem Befehl `print(zero_list(7))` soll man dann also den Output `[0, 0, 0, 0, 0, 0, 0]` erhalten. +
- +
-=== - Aufgabe I3 === +
- +
-Betrachte die Liste `[68, 71, 53, 34, 66, 55, 80, 93, 24, 49, 68, 73, 9, 8, 93, 22, 44, 11, 82]` +
-   - Berechne die Summe aller Elemente in der Liste in einer for-Schleife. +
-   - Berechne die Summe aller ungerader Elemente (also das erste, dritte,...) in der Liste. +
-Natürlich sollen sämtliche Schritte voll automatisiert ablaufen. Tauscht man die Liste mit einer anderen Liste, so soll der Code auch funktionieren. +
- +
-=== - Aufgabe I4 (optional) === +
- +
-Implementiere einige Funktionen, welche einem helfen sollen, Listen zu analysieren: +
-   * Funktion `liste_anzahl(L,x)`: Nimmt eine Liste L und eine Zahl oder ein String x entgegen. Die Funktion bestimmt dann, wie oft das Element x in L vorkommt und gibt diese Anzahl zurück. +
-   * Funktion `liste_max(L)`: Bestimmt das grösste Element einer List (welche aus Zahlen besteht) und gibt dieses zurück. +
-   * Funktion `liste_min(L)`: Ähnlich wie `liste_max(L)`, gibt aber das kleinste Element zurück. +
- +
-Für die Liste `A = [3,1,5,4,9,4,8,3,1,2,4,9]` und die Aufrufe  +
-<code python> +
-print(liste_anzahl(A,3)) +
-print(liste_max(A)) +
-print(liste_min(A)) +
-</code> +
-ist der Output +
-<code bash> +
-2 +
-9 +
-1 +
-</code> +
- +
- +
-=== - Aufgabe I5 (optional) === +
- +
-Programmiere eine Funktion `liste_haeufigste(L)`: Gibt eine Liste zurück, die alle Elemente enthält, die am häufigsten vorkommen. Neben dieser Liste wird auch eine Zahl ausgegeben, die angibt, wie oft diese Elemente in der Liste vorkommen.+
  
  • gf_informatik/programmieren_ii/variablen_verzweigungen_schleifen.1666615994.txt.gz
  • Zuletzt geändert: 2022-10-24 12:53
  • von hof