340 lines
14 KiB
Typst
340 lines
14 KiB
Typst
#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
|
||
|