#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. \
*Environment erstellen* \ Normalerweise werden die Environments ".venv" genannt.
#table(columns: 1fr, [```sh
python -m venv /path/to/venv
```])
*Environment betretten* \ Dafür gibt es zwei methoden.
#table(columns: 1fr, [```sh
. ./path/to/venv/bin/activate
# oder
source ./path/to/venv/bin/activate
```])
=== Datentyp
#table(columns: (0.7fr, 0.5fr, 1fr),
[Ganzzahl],[```py int ```], [```py x: int = 4 ```],
[Gleitkomma Zahl],[```py float ```], [```py x: float = 1.234 ```],
[Text (String)],[```py str ```], [```py x: str = "Hallo" ```],
[Wahr oder Falsch],[```py bool ```], [```py x: bool = True ``` \ ```py x: bool = False ```],
[Liste (Array)],[```py list ```], [```py x: list = [1, 2, "abc", 1.23] ```],
[Dicenary],[```py dict ```], [```py x: dict = {"a": 3, "b": 4} ```],
// [Ganzzahl],[```py set ```], [```py x: int = 4 ```],
)
=== Operatoren
#table(columns: (0.7fr, 1fr, 0.6fr),
fill: (x, y) => if y == 0 {gray.lighten(40%)},
[Python-Operatoren], [Erklärung], [Operatoren],
[Arithmetische Operatoren], [Verknüpfen zweier Zahlen zu einr neuen Zahl], [`+, -, *, /, //, %, **`],
[Vergleichsoperatoren], [Vergleichen zweier Ausdrücke miteinander], [`<, >, ==, !=, <=, >=`],
[Logische Operatoren], [Verknüpfen Ausdrücke im boolischen Kontext], [`and, or, not`],
[Identitäts Operatoren], [Feststellen ob zwei Namen auf dasselbe Objekt verweisen], [`is, is not`],
)
*Anmerkungen zu den Operatoren:* \
#table(columns: (0.4fr, 0.5fr,  0.5fr, 0.4fr, 1fr),
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 // 3 ```], [2], [Ergebnis wird immer zur nächsten kleineren Ganzzahl abgerundet],
[`**`], [Hochrechnen], [```py 2**3 ```], [8], [Nichts anderes als: $2^3$],
)
=== Listen
#table(columns: (0.5fr, 0.7fr, 1fr),
fill: (x, y) => if y == 0 {gray.lighten(40%)},
[Operation], [Beispiel], [Beschreibung],
[Liste Zuweisen], [```py li = [10, 15, 20, 25, 30] ```], [Die Liste wurde der Variable "li" zugewiessen],
[Ein Element ausgeben], [```py print(li[1]) ``` \ -> 15], [Es Wird "15" ausgeben da das erste Element den Index 0 hat.],
[Das Letzte Element ausgeben], [```py print(li[-1]) ``` \ -> 30], [Mit dem "-" werden die Elemente von Hinten ausgeben. z.b. bei "-2" würde 25 ausgegeben werden],
[Alles ab x ausgeben], [```py print(li[2:]) ``` \ -> `[20, 25, 30]`], [Da kein ende hinter dem Doppelpunk definiert ist wird alles ausgeben],
[Alles bis x ausgeben], [```py print(li[:2]) ``` \ -> `[10, 15]`], [Es wird alles bis zum dritten Item ausgegeben],
[Von x bis y ausgeben], [```py print(li[2:4]) ``` \ -> `[20, 25]`], [Es wird der Start und stop definiert],
[Jedes x ausfeben], [```py print(li[::2]) ``` \ -> `[10, 20, 30]`], [Es wir jedes Zeite Item ausgegeben],
[Jedes x ausfeben mit erstem beginnen], [```py print(li[1::2]) ``` \ -> `[15, 25]`], [Es wir jedes Zeite Item ausgegeben, dedoch mit dem ersten Item beginnend],
[Elemente anhängen], [```py li.append(44) ``` \ -> `[10, ... 30, 44]`], [Das neue Element wird ans ende der Liste gesetzt],
[Elemente anhängen], [```py li.append([1, 2]) ``` \ -> `[10, ... 30, [1, 2]]`], [Wir eine Liste mit append an eine Lsiste angehäng so wird diese einfach eingefügt],
[Listen zusammenfügen], [```py li.extend([1, 2]) ``` \ -> `[10, ... 30, 1, 2]`], [Die Listen wir hinten an die andere Liste angehängt],
[Element ausgeben und gleichzeitig aus der liste entfernen], [```py li.pop(1) ``` \ -> `15` \ `[10, 20, 25, ...]`], [Das Zweite Element wid entfernt und ausgelesen z.b. ```py x = li.pop() ``` \ (ohne Index wird das letzte Element ausgeben)],
[Element an einer bestimmten Stelle einfügen], [```py li.insert(0, 23) ``` \ -> `[23, 10, 20, 25, ...]`], [Das Element wird an der Stelle des Index eingefügt und alle folgenden Element um eins nach hinten geschoben],
[Elemente sortieren], [```py li.sort() ``` \ -> `[10, 20, 25, ...]`], [Normalerweise wird es der grösse nach sortiert. ES ist aber möglich "key's" mitzugeben um z.b. nach der Länge zu sortiert, etc.],
)
==== Tuples
Tuples sind Listen welche nach dem erstellen nicht mehr verändert werden können weder in der länge(anzahl Elemente) oder dem wert der Elemente.
#table(columns: (1fr, 1fr),
[Tuple erstellen], [```py tu = (10, 23, 15, 1) ```],
[Element lesen], [```py tu[1] # -> 23 ```],
[Letztes Element lesen], [```py tu[-1] # -> 1 ```],
)
Bemerkung: Ist z.B. eine Liste in einer Tuple so kann die Liste verändert werden.
```py
li = [1 , 2 , 3]
tu = (10 , 23 , li , True ) # (10 , 23 , [1 , 2 , 3] , True )
li . extend ([4 , 5])
print ( tu ) # (10 , 23 , [1 , 2 , 3 , 4 , 5] , True )
```

=== Strings
#table(columns: (1fr, 1fr, 1fr),
[String Zuweisen], [```py s = "Hello World!" ```], [],
[Element ausgeben], [```py s[0] ```], ["H"],
[Letztes Element ausgeben], [```py s[-1] ```], ["!"],
[Bereich ausgeben], [```py s[1:5] ```], ["ello"],
[Bereich ausgeben], [```py s[7:] ```], ["orld!"],
[Sequenz ausgeben], [```py s[2:9:2] ```], ["loWr"],
[String verkehrt ausgeben], [```py s[::-1] ```], ["!dlroW olleH"],
[länge ausgeben], [```py len(s) ```], [12],
[Strings Zusammensetzen], [```py
s1 = "Hallo"
s2 = "Welt"
s1 + s2 ```], ["HalloWelt"],
[Strings Zusammensetzen mit join], [```py
s1 = "Hallo"
s2 = "Welt"
" ".join([s1, s2]) ```], ["Hallo Welt"],
)

*Methoden*
#table(columns: (1fr, 1fr, 1fr),
[String Zuweisen], [```py s = "das ist ein langer String" ```], [],
[Alles in grossbuchstaben], [```py s.upper() ```], ["DAS IST EIN LANGER STRING"],
[Alles in kleinbuchstaben], [```py s.lower() ```], ["das ist ein langer string"],
[Anfangsbuschstabe gross], [```py s.capitalize() ```], ["Das ist ein langer string"],
[Beginnt der String mit], [```py s.startswith("d") ```], [True],
[Endet der String mit], [```py s.endswith("?") ```], [False],
[String in Wörter aufteilen], [```py s.split(" ") ```], [`['das', 'ist', 'ein', 'langer', 'String']`],
[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 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)]`],
)

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



=== Runden
#table(columns: (1fr, 1fr),
[```py
pi = 3.141592653589793
print(round(pi, 2)
```], [ -> 3.14]
)
Die "2" durch anzahl stellen ersetzen.

flour runden

upper runden