diff --git a/src/python_wahlmodul.typ b/src/python_wahlmodul.typ
index a4677ae..6fc6722 100644
--- a/src/python_wahlmodul.typ
+++ b/src/python_wahlmodul.typ
@@ -1,3 +1,6 @@
+#import "@preview/cetz:0.4.1"
+#import "@preview/cetz-venn:0.1.4"
+
 == Python Wahlmodul
 === Virtuall Envirements
 Python Umgebungen (Environments) sind isolierte Verzeichnisse, die eine spezifische Python-Version und Projektabhängigkeiten (Pakete) enthalten. Ihr Zweck ist die Trennung der Projekte voneinander, um Konflikte zu vermeiden und die Reproduzierbarkeit sicherzustellen. \
@@ -104,6 +107,118 @@ s2 = "Welt"
 [Zeichen ersetzen], [```py s.replace("a", "A") ```], ["dAs ist ein lAnger String"],
 )
 
+=== Set
+In einem Set kann im Vergleichen zur Liste jedes Element nur einmal existieren und ist sommit *einmalig!*
+#table(columns: (1fr, 1fr, 1fr),
+[Set erstellen], [```py s = {"a", "b", "c", "a"} ```], [Das letzte "a" wird nicht hinzugefügt da es bereits im Set ist.],
+[Liste in Set umwandeln], [```py s = set(["a", "b", "c", "a"]) ```], [],
+[String im Set], [```py s = set("Python") ```], [Jeder buchstabe wird einzeln gespeicher. \ `s = {'n’, ’y’, ’p’, ’h’, ’o’, ’t’}`],
+[Set erweitern], [```py s.add(5) ```], [],
+[Element aus Set löschen], [```py s.remove(12) ```], [Gibt einen Error aus wenn das zu entfernende Element nicht im Set ist.],
+[Element aus Set löschen ohne Error], [```py s.discard(12) ```], [Gibt keinen Error aus wenn das zu entfernende Element nicht im Set ist (Programm geht weiter).],
+)
+*Mathe* \
+Mit den Set's können Mengen operationen gemacht werden. Hier Beispiele mit "A" und "B".
+#table(columns: 1fr, [```py
+A = {"10", 120, "a"}
+B = {120, 5, 10}
+```])
+
+#let op_scale = 0.6
+#table(columns: (1fr, 1fr, 0.5fr), stroke: (x: none), align: horizon,
+[Vereinigung \ $A union B$ \ ```py print(A | B) ```], [`{5, 120, "10", 10, "a"}`], [
+#cetz.canvas({
+  cetz.draw.scale(op_scale)
+  cetz-venn.venn2(
+    name: "Vereinigung",
+    a-fill: yellow.transparentize(40%),
+    b-fill: yellow.transparentize(40%),
+    ab-fill: yellow.transparentize(40%),
+  )
+  cetz.draw.content("Vereinigung.a", [A])
+  cetz.draw.content("Vereinigung.b", [B])
+}) ],
+[Schnittmenge \ $A inter B$ \ ```py print(A & B) ```], [`{120}`], [
+#cetz.canvas({
+  cetz.draw.scale(op_scale)
+  cetz-venn.venn2(
+    name: "Durchschnitt",
+    a-fill: none,
+    b-fill: none,
+    ab-fill: yellow.transparentize(40%),
+  )
+  cetz.draw.content("Durchschnitt.a", [A])
+  cetz.draw.content("Durchschnitt.b", [B])
+}) ],
+[Mengendifferenz \ $A \\ B$ \ ```py print(A - B) ```], [`{"10", "a"}`], [
+#cetz.canvas({
+  cetz.draw.scale(op_scale)
+  cetz-venn.venn2(
+    name: "Mengendifferenz",
+    a-fill: yellow.transparentize(40%),
+    b-fill: none,
+    ab-fill: none,
+  )
+  cetz.draw.content("Mengendifferenz.a", [A])
+  cetz.draw.content("Mengendifferenz.b", [B])
+})
+],)
+
+=== Dictionary
+Ein Dictionary ist wie ein Wörterbuch mit einem "Key" und einer dazugehörigen "vule". Die "Keys müssen dabei *einzigartig* sein und *hashabel* (keine Listen oder modifizerbare Objekte).
+#table(columns: (1fr, 1fr, 1fr),
+[Dictionary erstellen], [```py d1 = {"1": "1. Element", 2: [1, 2, 3]} ``` \ ```py d2 = {[1, 2]: 2} ```], [d2 ist ungültig weil Listen keine "Key's" sind.],
+[Auf Element zugreifen], [```py d1[2] ```], [Gibt `[1, 2, 3]` zurück],
+[Auf Element zugreifen], [```py d1["x"] ```], [Gibt einen Fehler da "x" nicht im Dictionary ist],
+[Auf Element zugreifen mit get()], [```py d1.get(2)  # [1, 2, 3] ``` \ ```py d1.get("x") ```], [Gibt keinen Fehler auch wenn "x" nicht im Dictionary ist],
+[Element überschreiben], [```py d1[2] = 2 ```], [Die Liste wurde mit 2 überschrieben],
+[Element hinzufügen], [```py d1["neuer key"] = 12 ```], [Neuses Element mit dem der "value" 12.],
+)
+*Methoden* \
+```py d1 = { ’a ’: 10 , ’b ’: 27 , ’c ’: 12} ```
+#table(columns: (1fr, 1fr, 1fr),
+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]`],
+[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)]`],
+)
+
+=== Kommentare
+#table(columns: (1fr, 1fr),
+[Einzeiliger Kommentar],[```py price = 5.50 # this is an inline comment ``` \ ```py # this is a short ```],
+[Mehrzeiliger Kommentar],[```py
+def prepare_data(self):
+  """ Prepares all data
+  [...]
+  write to the database """
+  self.db_connect ()
+```],
+)
+
+=== input (Benutzer eingabe)
+Mit der input() funktion können eingaben vom User angenommen werden.
+#table(columns: 1fr, [```py
+number = input("Geben Sie eine Nummer ein : ")  # eingabe als string (Text)
+int_number = int(number)  # eingabe als intiger
+```])
+
+=== print (Benutzer ausgabe)
+#table(columns: 1fr, [```py
+print("Hallo ich bin ein String")
+a , b = 10 , 12
+print(a)
+print(f"Hier ist die Variable a mit dem wert {a}")  # Das ist ein "f" String
+
+balance = 9876.9376
+print(f"Balance: CHF {balance:.2f}")  # Balance: CHF 9876.94 -> Ausgabe auf 2 Stellen nach dem Komma gekuerzt
+```])
+
+=== Entscheidungen
+
+
 
 === Runden
 #table(columns: (1fr, 1fr),