Merge remote-tracking branch 'origin/main'

content/material/Programmieren/Python-Cheatsheets/01-Schleifen.mdx

@@ -0,0 +1,115 @@
+# Schleifen
+## Die `for`-Schleife
+:::key[Fixe Anzahl Wiederholungen]
+Wir verwenden die `for`-Schleife immer dann, wenn wir einen bestimmten Code-Block eine **fixe Anzahl Mal** wiederholen wollen.
+:::
+
+Hier sehen Sie ein Beispiel einer `for`-Schleife:
+```python showLineNumbers {3-5}
+from turtle import *
+
+for i in range(4):
+    forward(100)
+    right(90)
+
+done()
+```
+
+Die Zeile `for i in range(4)` bedeutet, dass die Instruktionen auf den Zeilen `4` und `5` 4x wiederholt werden sollen.
+
+Der Ausdruck `range(4)` erzeugt eine [Liste](Listen) mit den vier ganzzahligen Elementen von `0` bis `3`, also `[0, 1, 2, 3]`. Folgendes Programm wäre also gleichwertig:
+
+```python showLineNumbers {3-5}
+from turtle import *
+
+for i in [0, 1, 2, 3]:
+    forward(100)
+    right(90)
+
+done()
+```
+
+Die `range(4)`-Schreibweise ist aber einerseits kürzer zum Schreiben. Andererseits könnte man den Wert `4` in den Klammern auch mit einer [Variable](Variablen-und-Datentypen) ersetzen. So könnten wir das Turtle-Quadrat beispielsweise zu einem generischen n-Eck verwandeln:
+
+```python showLineNumbers {3,5,7}
+from turtle import *
+
+seiten = 5
+
+for i in range(seiten):
+    forward(100)
+    right(360 / seiten)
+
+done()
+```
+
+Das `i` in `for i in range(4)` ist übrigens auch eine Variable. Wir können einerseits einen beliebigen anderen Variablennamen verwenden und andererseits diesen Wert innerhalb der Schleife verwenden:
+
+```python showLineNumbers {3-4}
+from turtle import *
+
+for schrittlaenge in range(100):
+    forward(schrittlaenge)
+    right(20)
+
+done()
+```
+
+Wenn wir auf Zeile `4` die Variable `schrittlaenge` verwenden, dann verhält sie sich beim ersten Schleifendurchlauf wie die Zahl `0` (also `forward(0)`), beim zweiten Durchlauf wie eine `1` (also `forward(1)`), und beim 100-sten und letzten Durchlauf wie eine `99` (also `forward(99)`).
+
+:::key[Zahlen-Range]
+Bei einer Schleife definiert durch `for i in range(10)` nimmt `i` der Reihe nach die Werte `0` bis `9` an.
+:::
+
+## Die `while`-Schleife
+:::key[Bedingung]
+Wir verwenden die `while`-Schleife immer dann, wenn wir einen bestimmten Code-Block so lange wiederholen wollen, wie eine gewisse Bedingung erfüllt ist.
+:::
+
+Hier sehen Sie ein Beispiel einer `while`-Schleife:
+```python showLineNumbers {4}
+from random import randint
+
+zufallszahl = randint(1, 6)
+while zufallszahl < 6:
+    print("Noch keine 6 gewürfelt!")
+    zufallszahl = randint(1, 6)
+
+print("6 gewürfelt - fertig!")
+```
+
+Hier wird _so lange_ eine [Zufallszahl](Random) erzeugt, _wie noch keine 6_ "gewürfelt" wurde. Diese Bedingung wird auf Zeile `4` überprüft. So lange werden die Instruktionen auf den Zeilen `5` und `6` wiederholt. Zum Zeitpunkt der Entwicklung dieses Programms wissen wir also nicht, wie oft die Instruktionen wiederholt werden müssen. Deshalb verwenden wir hier eine `while`- statt eine `for`-Schleife.
+
+Mit der `while`-Schleife kann man auch eine `for`-Schleife "nachbauen":
+```python showLineNumbers {3-4,7}
+from turtle import *
+
+zaehler = 0
+while zaehler < 4:
+    forward(100)
+    right(90)
+    zaehler = zaehler + 1
+
+done()
+```
+
+:::key[Endlosschleife]
+Im Gegensatz zur `for`-Schleife können wir bei der `while`-Schleife eine **Endlosschleife** erzeugen. Das Programm wird in solchen Fällen nie enden (oder in gewissen Fällen den Computer zum Abstürzen bringen).
+:::
+
+Wichtig ist dabei, dass wir auf der Zeile `7` den `zaehler` erhöhen. Ansonsten erhalten wir eine Endlosschleife:
+```python showLineNumbers
+from turtle import *
+
+zaehler = 0
+while zaehler < 4:
+    forward(100)
+    right(90)
+    zaehler = zaehler + 1
+
+done()
+```
+
+Dieses Programm wird nie enden.
+
+---

content/material/Programmieren/Python-Cheatsheets/02-Variablen-und-Datentypen.mdx

@@ -0,0 +1,139 @@
+# Variablen und Datentypen
+## Variablen
+Eine Variable ist wie ein Gefäss, in das wir beliebige Werte einfüllen können. Statt eines konkreten Werts (zum Beispiel einer Zahl) können wir dann die Variable verwenden. Diese "verhält" sich genau gleich, wie der Wert, den sie zu diesem Zeitpunkt beinhaltet.
+
+Die folgenden beiden Turtle-Programme sind genau gleichwertig:
+
+**Beispiel 1: Ohne Variable**
+```python showLineNumbers {3}
+from turtle import *
+
+forward(100)
+
+done()
+```
+
+**Beispiel 2: Mit Variable**
+```python showLineNumbers {3,4}
+from turtle import *
+
+distanz = 100
+forward(distanz)
+
+done()
+```
+
+Im zweiten Beispiel geschieht auf Zeile `3` die **Zuweisung**: Wir _weisen_ der Variable `distanz` den Wert `100` _zu_. Auf Zeile `4` wird die Variable in den Klammern **verwendet** und ist in dem Moment eine Art _Stellvertreter_ für den Wert `100`.
+
+:::key[Zuweisung]
+Beim folgenden Ausdruck...
+
+```python showLineNumbers
+distanz = 100
+```
+
+...handelt es sich **nicht um einen Vergleich**, sondern um einen **Befehl**: Wir prüfen _nicht_, ob `distanz` gleich  `100` ist, sondern wir _befehlen_ dem Computer, dass er in der Variable `distanz` den Wert `100` abspeichern soll.
+
+Bevor dieser Ausdruck ausgeführt wird, ist die Variable `distanz` noch gar nicht bekannt. Sie hat also noch keinen Wert und wir dürfen sie noch nicht beispielsweise in einem Ausdruck wie `forward(distanz)` verwenden.
+
+Die "Flussrichtung" des Werts verläuft bei der Zuweisung immer von rechts nach links: Auf der _rechten Seite_ steht der Wert (hier `100`), welcher _nach links_ in die Variable (hier `distanz`) fliessen soll.
+
+Folgender Ausdruck wäre folglich unsinnig und würde in Python zu einem Fehler führen:
+
+```python showLineNumbers
+100 = distanz
+```
+:::
+
+<details>
+  <summary>Wieso verwenden wir Variablen?</summary>
+  <div>
+    Es gibt zwei Gründe, weshalb wir Variablen verwenden:
+    1. Wir wollen uns nicht wiederholen.
+    2. Zum Zeitpunkt des Programmierens könnte ein bestimmter Wert noch unbekannt sein.
+
+    Zu Punkt 2 finden Sie einige Beispiele in den Cheatsheets [Zufall](Random) und [Ein- und Ausgabe](Input-Output).
+
+    Folgendes Turtle-Beispiel illustriert Punkt 1:
+    ```python showLineNumbers
+    from turtle import *
+
+    forward(100)
+    right(90)
+    forward(100)
+    left(90)
+    forward(100)
+
+    done()
+    ```
+
+    Es zeichnet eine Treppenstufe mit einer Seitenlänge von `100`. Doch was, wenn wir die Seitenlänge verändern möchten? Ohne Variablen müssen wir den Wert dreimal anpassen. Bei grösseren und komplexeren Programmen geht da schnell eine Anpassung vergessen.
+
+    Das folgende überarbeitete Beispiel ist genau gleichwertig:
+    ```python showLineNumbers {3,4,6,8}
+    from turtle import *
+
+    seitenlaenge = 100
+    forward(seitenlaenge)
+    right(90)
+    forward(seitenlaenge)
+    left(90)
+    forward(seitenlaenge)
+
+    done()
+    ```
+
+    Hier müssen wir die Seitenlänge aber nur noch an einem Ort anpassen. Theoretisch könnten wir auch noch eine zweite Variable `winkel` einführen, damit wir nicht zweimal `90` schreiben müssen. Wenn wir allerdings eine Treppenstufe zeichnen wollen, dann wird der Drehwinkel vermutlich immer 90° sein, und somit werden wir diesen Wert wohl auch nie anpassen müssen.
+  </div>
+</details>
+
+## Datentypen
+In Python gibt es unterschiedliche Arten von Daten, welche sich auch unterschiedlich verhalten und verwenden lassen.
+
+Dies sind die wichtigsten Datentypen in Python:
+
+| Datentyp | Beschreibung                                                                                                                                                             |
+|----------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `int`    | Ganzzahlen, z.B. `1`, `10`, `-5`                                                                                                                                         |
+| `float`  | Dezimalzahlen, z.B. `1.0`, `3.14`, `-2.7`                                                                                                                                |
+| `str`    | genannt _String_, Text, z.B. `"Hallo, Welt!"`, `"a"`, `"1"`; immer mit Anführungs- und Schlusszeichen (`"`) umschlossen                                                  |
+| `bool`   | kann genau zwei Werte haben, nämlich `True` (_wahr_) oder `False` (falsch); vgl. [Logische Operatoren](Vergleichsoperatoren-und-Logische-Operatoren#logische-operatoren) |
+
+Weitere wichtige Datentypen sind `list` (vgl. [Listen](Listen)) und `dict` (für _Dictionary_). Auf diese Datentypen gehen wir hier jedoch nicht genauer ein.
+
+### Zahl oder Text?
+Wie genau unterscheiden sich die Werte `1` und `"1"`?
+
+Beim Wert `1` handelt es sich um eine Zahl (konkret, um einen `int`), während es sich bei `"1"` um einen Text (also einen `str`) handelt. Dies erkennt man an den Anführungszeichen (`"`) beim `str`.
+
+Zahlen und Text zeigen in Python unterschiedliche Verhaltensweisen, beispielsweise in Bezug auf [arithmetische Operationen](Arithmetische-Operatoren).
+
+So gibt folgendes Programm den Wert `11` aus:
+```python showLineNumbers
+resultat = 5 + 6
+print(resultat)
+```
+
+Folgendes Programm gibt jedoch den Wert `56` aus:
+```python showLineNumbers
+resultat = "5" + "6"
+print(resultat)
+```
+
+### Datentypen umwandeln
+Unter gewissen Umständen ist es möglich und notwendig, einen Wert in einen anderen Datentyp umzuwandeln. Mehr dazu finden Sie unter [Ein- und Ausgabe](Input-Output#datentypen-im-kontext-der-ein--und-ausgabe).
+
+## Variablen und Datentypen
+Eine Variable hat immer einen Datentyp. Dieser richtet sich nach dem Datentyp des Werts, den wir der Variable zuweisen. Der Datentyp einer Variable kann sich auch ändern.
+
+Das folgende (unsinnige) Programm illustriert dieses Verhalten:
+
+```python showLineNumbers
+x = 100
+x = "Hallo, Welt"
+x = 3.1
+```
+
+Nach der Zuweisung auf Zeile `1` hat `x` den Datentyp `int`. Nach Zeile `2` ist es dann ein `str` und nach Zeile `3` ist `x` ein `float`. Unsinnig ist das Programm deshalb, weil wir der Variable `x` zwar Werte zuweisen, die Variable jedoch nirgend verwenden.
+
+---

content/material/Programmieren/Python-Cheatsheets/03-Arithmetische-Operatoren.mdx

@@ -0,0 +1,56 @@
+# Arithmetische Operatoren
+In Python gibt es unterschiedliche arithmetische Operatoren je nach [Datentyp](Variablen-und-Datentypen#datentypen).
+
+Die wichtigsten arithmetischen Operatoren für Zahlen (also `int` und `float`) sind:
+
+| Operator | Bedeutung                                    |
+|----------|----------------------------------------------|
+| `+`      | Addition, z.B. `3 + 2` (Ergebnis: `5`)       |
+| `-`      | Subtraktion, z.B. `5 - 4` (Ergebnis: `1`)    |
+| `*`      | Multiplikation, z.B. `4 * 2` (Ergebnis: `8`) |
+| `/`      | Division, z.B. `10 / 4` (Ergebnis: `2.5`)    |
+
+Dabei spielt es keine Rolle, ob Sie mit `int`, `float`, oder einer Mischung aus beiden Zahlentypen arbeiten. Für die Addition, Subtraktion und Multiplikation gelten folgende Regeln:
+- Wenn der linke und rechte Operand beide vom Typ `int` sind, dann ist auch das Resultat vom Typ `int`.
+- Wenn mindestens einer der Operanden vom Typ `float` ist, dann ist auch das Resultat vom Typ `float`.
+
+Bei der Division verhält es sich anders: Das Resultat der Division ist immer von Typ `float`. Als Alternative zur Division (`/`) kennt Python auch noch die **Ganzzahldivision** (`//`, siehe Tabelle unten). Dabei st das Resultat immer vom Typ `int`. Nicht-ganzzahlige Ergebnisse werden dabei immer abgerundet.
+
+Weitere erwähnenswerte arithmetische Operatoren sind:
+
+| Operator | Bedeutung                                       |
+|----------|-------------------------------------------------|
+| `//`     | Ganzzahldivision, z.B. `5 // 2` (Ergebnis: `2`) |
+| `**`     | Potenz ("hoch"), z.B. `2**3` (Ergebnis: `8`)    |
+
+## Weitere mathematische Operationen
+Die meisten weiteren mathematischen Operationen existieren in Python nicht als Operator, sondern müssen als Funktionen aus dem Modul `math` importiert werden.
+
+Folgendes Beispiel zeigt, wie wir die Quadratwurzel (`sqrt`, engl.: _**sq**uare **r**oo**t**_) berechnen und ausgeben können:
+
+```python showLineNumbers
+from math import sqrt
+
+print(sqrt(25))
+```
+
+Die vollständige Dokumentation aller verfügbaren mathematischen Funktionen im Modul `math` finden Sie [hier](https://docs.python.org/3/library/math.html).
+
+## Arithmetische Operatoren mit Strings
+Die wichtigste arithmetische Operation auf dem Datentyp `str` ist die Addition — wir sprechen in diesem Kontext allerdings von **Konkatenation**. Sie funktioniert nur, wenn **sowohl der linke als auch der rechte Operand** vom Datentyp `str` sind. Die beiden Operanden werden dann einfach aneinandergehängt (wir sagen, _konkateniert_).
+
+Folgendes Beispiel illustriert diese Operation:
+
+```python showLineNumbers
+name = "Bob"
+gruss = "Hallo, " + name + "!"
+print(gruss)
+```
+
+Dieses Programm gibt in der Kommandozeile folgenden Text aus:
+
+```
+Hallo, Bob!
+```
+
+---