diff --git a/src/informatik_1.typ b/src/informatik_1.typ
index 70e5755..69a24f4 100644
--- a/src/informatik_1.typ
+++ b/src/informatik_1.typ
@@ -207,6 +207,9 @@ int main(){
 ```
 ]
 
+=== String
+Endung auf `\0`
+
 === enum
 
 === struct
diff --git a/src/informatik_3.typ b/src/informatik_3.typ
index 64fbd8b..532365c 100644
--- a/src/informatik_3.typ
+++ b/src/informatik_3.typ
@@ -389,6 +389,49 @@ func_with_ref_param(x);
 )
 Zudem gibt es bei Referenzen keine null pointer und es können keine Referenzen auf Referenzen gemacht werden.
 
+=== Try
+Falls es userinputs gibt oder man nicht weiss ob es geht kann man mit der Try funktion sachen probieren und bei einem fehlschlag crasht das programm nicht.
+Beispiel mit vector: Der user will die 8 pos eines vektors welcher nur 3 Elemente hat.
+#table(columns: 1fr, [```cpp
+#include <stdexcept>
+int main(){
+    std::vector<int> v{0, 1, 2};
+    // so wurde das programm auf der folgenden Zeile craschen
+    // std::cout << v.at(8) << std::endl;
+
+    try {
+        std::cout << v.at(8) << std::endl;
+    } catch (std::exception &ex){
+        // gibt eine fehlermeldung zurück und geht weiter
+        std::cout << "Error: " << ex.what() << std::endl;
+    }
+    return 0;
+}
+```]
+)
+Beispiel mit einer Division durch Null:
+#table(columns: 1fr, [```cpp
+#include <stdexcept>
+int divide(int dividend, int divisor){
+    if (divisor == 0){
+        throw std::runtime_error("Divide by zero");
+    }
+    return dividend / divisor;
+}
+
+int main(){
+    try {
+        std::cout << "Trying to divide by zero ..." << std::endl;
+        std::cout << divide(4, 0) << std::endl;
+
+    } catch (std::exception &ex){
+        std::cout << "Error: " << ex.what() << std::endl;
+    }
+    return 0;
+}
+```]
+)
+
 
 === testing
 ```cpp
diff --git a/src/python_wahlmodul.typ b/src/python_wahlmodul.typ
index 6fc6722..db614b9 100644
--- a/src/python_wahlmodul.typ
+++ b/src/python_wahlmodul.typ
@@ -38,7 +38,7 @@ fill: (x, y) => if y == 0 {gray.lighten(40%)},
 fill: (x, y) => if y == 0 {gray.lighten(40%)},
 [Ausdruck], [Name], [Beispiel], [Ergebnis], [Beschreibung],
 [`%`], [Modulo], [```py 7 % 3 ```], [1], [Gibt den Rest einer Division aus],
-[`//`], [Floor division], [```py 7 // 2 ```], [2], [Ergebnis wird immer zur nächsten kleineren Ganzzahl abgerundet],
+[`//`], [Floor division], [```py 7 // 3 ```], [2], [Ergebnis wird immer zur nächsten kleineren Ganzzahl abgerundet],
 [`**`], [Hochrechnen], [```py 2**3 ```], [8], [Nichts anderes als: $2^3$],
 )
 === Listen
@@ -92,7 +92,7 @@ s1 + s2 ```], ["HalloWelt"],
 [Strings Zusammensetzen mit join], [```py
 s1 = "Hallo"
 s2 = "Welt"
-" ".join ([s1, s2]) ```], ["Hallo Welt"],
+" ".join([s1, s2]) ```], ["Hallo Welt"],
 )
 
 *Methoden*
@@ -180,7 +180,7 @@ Ein Dictionary ist wie ein Wörterbuch mit einem "Key" und einer dazugehörigen
 fill: (x, y) => if y == 0 {gray.lighten(40%)},
 [Was], [Code], [ausgabe],
 [Liefert den value zum zugehörigen key], [```py d1.get("a") ```], [`10`],
-[Löscht den value zum zugehörigen key], [```py d1.pop() ```], [`[10, 27, 12]`],
+[Löscht den key & value zum zugehörigen key], [```py d1.pop("a") ```], [`[10, 27, 12]`],
 [Liefert alle values eines Dictionaries als Liste], [```py d1.values() ```], [`[10, 27, 12]`],
 [Liefert alle keys eines dictionaries als Liste], [```py d1.keys() ```], [`["a", "b", "c"]`],
 [Liefert alle key/value-Paare eines Dictionary als Tuple], [```py d1.items() ```], [`[("a", 10), ("b", 27), ("c", 12)]`],
@@ -217,6 +217,110 @@ print(f"Balance: CHF {balance:.2f}")  # Balance: CHF 9876.94 -> Ausgabe auf 2 St
 ```])
 
 === Entscheidungen
+==== if
+Das `if` in Python kann einzel verwendet werden oder in kombination mit `elif` oder `else`.
+#table(columns: 1fr, [```py
+number = 15
+if number > 0:
+  print("The number is positive")
+```])
+#table(columns: 1fr, [```py
+a = 200
+b = 33
+if b > a:
+  print("b is greater than a")
+elif a == b:
+  print("a and b are equal")
+else:
+  print("a is greater than b")
+```])
+
+==== march (switch case)
+Mit dem march hat man in Python eine switch case option.
+- `_`: der Underline ist der default parameter wenn keine bedingung erfühlt ist.
+#table(columns: 1fr, [```py
+day = 4
+match day:
+    case 6:
+        print("Today is Saturday")
+    case 7:
+        print("Today is Sunday")
+    case _:
+        print("Looking forward to the Weekend")
+```])
+- `|`: mittels pipe können or verknüpfungen gemacht werden.
+#table(columns: 1fr, [```py
+day = 4
+match day:
+  case 1 | 2 | 3 | 4 | 5:
+    print("Today is a weekday")
+  case 6 | 7:
+    print("I love weekends!")```])
+
+
+
+=== Schleifen
+==== for-loop
+Alle Items werden ausgeprintet.
+#table(columns: 1fr, [```py
+for item in ["itemA" , "itemB" , "itemC"]:
+   print(item)
+```])
+
+==== while
+Schleifen werden verwendet wen nicht bekannt ist wie lange es dauert bis die bedinung erfühlt ist. \
+- ```py continue ```: mit dem continue statement springt die schleife wieder an den anfang und in dem fall wird 3 nicht geprintet.
+- ```py break ```: mit dem break statement wird die schleife vorzeitig verlassen.
+#table(columns: 1fr, [```py
+i = 1
+while i < 6:
+    if i == 3:
+        continue
+    if i == 5:
+        break
+    i += 1
+    print(i)
+```])
+
+
+=== range() (Exkurs)
+Mit der ```py range() ``` funktion können Reihen geformt werden. Die Funktion hat drei parameter `range(start, stop, step)`
+- start: (Optional). Ein Intiger Wert, welcher die Startposition festlegt. (default: 0)
+- stop: (Required). Ein Intiger Wert, welcher die Endposition festlegt.
+- step: (Optional). Ein Intiger Wert, welcher die Schrittweite festlegt. Kann auch negativ sein. (default: 1)
+#table(columns: (1fr, 1fr),
+[```py
+for i in range(5):
+    print(i)
+```], [`0, 1, 2, 3, 4`],
+[```py
+for i in range(0, 5, 1):
+    print(i)
+```], [`0, 1, 2, 3, 4`],
+[```py
+for i in range(0, 5, 2):
+    print(i)
+```], [`0, 2, 4`],
+[```py
+for i in range(10, 5, -1):
+    print(i)
+```], [`10, 9, 8, 7, 6`],
+)
+
+=== Funktionen
+Mit einer Funktion können wir code wiederholen ohne ihn mehrmals zu schreiben.
+#table(columns: 1fr, [```py
+def funktionsname(a, b, c=3):
+    # code
+    return something
+```])
+Erklärung:
+- ```py def ```: Schlüsselwort zum `definieren` einer Funktion.
+- ```py funktionsname ```: Name mit der die Funktion später aufgerufen werden soll.
+- ```py (a, b, c=3) ```: Argumente / Parameter welche der funktion mitgegeben werden. Wenn eine Variable keinen wert hat muss der Wert beim funktionsaufruf mitgegeben werden. Ist wie z.b. bei c=3 mittels gleich einen Wert, liste, etc. als default Wert definiert so ist der Parameter optional und muss nicht mitgegeben werden, dann wir einfach der default wert verwendet.
+- ```py # code ```: Hier kommt der code der Funktion hin.
+- ```py return something ```: Falls etwas zurückgegeben werden möchte kann dies mitels return gemcht werden. Es ist auch möglich mehere variabeln zurückzugeben z.b. ```py f, p = return x, y ```. Falls nicht zurückgegeben werden möchte kann auf dass return verzichtet werden.
+Optionale Parameter kommen immer am schluss!