tut 15

Tutorium/tut15/README.md

@@ -0,0 +1,185 @@
+---
+marp: true
+paginate: true
+# class: invert
+theme: rose-pine
+footer: Tutorium 15 - 09.02.2024 - Nils Pukropp - https://s.narl.io/s/tutorium-15
+header:
+math: mathjax
+---
+
+# Tutorium 15 - 19.02.2024
+
+Orga, Test-Exam, Regex (Exkurs)
+
+---
+
+# Orga
+
+---
+
+## Orga - Punkte, Vorstellen und einscannen
+
+- Ich habe bei **allen** auf Blatt 12 (oder dem letzten korrigierten) `+6p` für das **verpasste Tutorium** vergeben
+- Ich habe für **heute** bereits allen die **Anwesenheitspunkte + Vorstellen** eingetragen
+
+Alle auf die das Zutrifft sind:
+
+`as2037, at359, au56, aw616, bo35, cl393, dk446, eh224, eh295, fk439, fv100, ib180, jb1484, jx20, lf409, ln200, lp269, lp321, ls818, mk1518, mr824, mt367, mw793, mz144, mz242, nm320, no43, pk375, rh295, rl173, rw208, sn205, tr211, ua28, vb202, vb205, vr110, yp39, zj11`
+
+Bei Problemen oder Rückfragen einfach per mail [nils@narl.io](mailto:nils@narl.io) oder nach dem Tutorium
+
+---
+
+## Orga - Klausur
+
+- Klausur am 19.02.
+- Es gibt vorraussichtlich zwei Termine
+- 2 Stunden
+- keine unterschiedlichen Klausuren
+- Wo, Wann?
+  - individuell
+  - https://courses.laurel.informatik.uni-freiburg.de/courses/2023WS-EiP/exam
+  - https://s.narl.io/s/termin
+- Klausurumgebung ausprobieren unter
+  - https://bwlehrpool.ruf.uni-freiburg.de/guacamole
+  - https://s.narl.io/s/examvm
+
+---
+
+## Orga - Vorbereitung auf Klausur
+
+- Macht Altklausuren
+- Übungsaufgaben im Git
+  - https://git.narl.io/nvrl/eidp-klausuraufgaben-2023
+  - https://s.narl.io/s/eidp-ub
+- Wenn ihr die Probeklausur gut hinbekommen habt (**auch Zeitlich!!!**) seid ihr eig safe
+- Zusatztutorium mit Dani und mir
+
+---
+
+## Orga - Zusatztutorium von Dani und mir
+
+- Wir machen Altklausuren/Übungsaufgaben
+- Zu zweit kann man sich etwas persönlicher kümmern
+- Gibt obv. keine Punkte, wir machen das auch nur freiwillig
+- Wann, Wo?
+  - Mittwoch
+  - x.xx Uhr open end
+  - Hier in 101
+  - Es folgt auch noch eine E-Mail an alle über dessen Uni-Mail mit allen Infos
+
+---
+
+# Test-Exam
+
+---
+
+## Test-Exam - Datenklassen
+
+- Ihr könnt **private** Attribute nicht in einer Unterklasser verwenden!
+- Mit `super().post_init(...)` könnt ihr diese trotzdem setzen
+- `self.__privet_attribute` in einer Unterklasse führt zu einem Fehler
+- Es gibt `protected` welches von Außen nicht sichtbar ist, aber in Unterklassen
+  - `_protected_attribute` welche mit einem `_` annotiert werden
+  - Beißt sich leider etwas mit `InitVar[...]` von `dataclasses`
+- Vergesst am besten `private`, `public` für die Klausur :) versprechen kann ich aber nichts
+
+---
+
+## Test-Exam - Automata
+
+- Bitte kein `T` oder Trash State in der Klausur, außer es ist explizit gefordert
+  - Ein State bei dem invalide Eingaben hingeschoben werden
+- Auch wenn das die Musterlösung von Exercise-13 gemacht hat
+- Und auch wenn es eigentlich sinnvoller ist, weil wir wollen nicht bei einer falschen Eingabe dass unser Programm abstürzt
+```python
+class State(Enum):
+    q0 = auto()
+    q1 = auto()
+    q2 = auto()
+```
+
+---
+
+## Test-Exam - Automata
+
+```python
+def delta(state: State, input: str) -> State:
+    match state, input:
+        case State.q0, "a":
+            return State.q1
+        case State.q0, "b":
+            return State.q2
+        case State.q1, "a":
+            return State.q0
+        case State.q1, "b":
+            return State.q1
+        case State.q2, "a":
+            return State.q2
+        case State.q2, "b":
+            return State.q1
+        case _:
+            raise ValueError("invalid state or input")
+```
+---
+
+# ReGex
+
+---
+
+## Was ist ein ReGex?
+
+- Ein regulärer Ausdruck ist ein **match pattern** in einem **text**
+- Genau gesagt bildet es eine Menge von Zeichenketten (eine **Sprache**)
+- Ihr habt bereits ReGex benutzt
+  - Wenn ihr z.B. im Browser Ctrl+F drückt und nach einem Wort sucht
+  - das Wort ist dann ein ReGex
+- Es gibt aber auch deutlich komplexere ReGex
+
+---
+
+## Automaten schon wieder
+
+- Was ist wenn wir einen Eingabe-String überprüfen wollen ob er 
+  - mit `a` beginnt
+  - dann mindest ein, aber beliebig viele `b` folgen
+  - und mit einem `a` endet
+- Wir können einen Akzeptor zeichnen! (nicht-deterministischen endlichen Automaten mit akzeptierenden Zustand)
+
+
+---
+
+  ![img not found width:1080](./img/dfa.png)
+
+---
+
+## ReGex - Python
+
+- In Python haben wir `re` also Modul
+- Ein ReGex ist eine Zeichenkette
+  - `"ab"` akzeptiert `"ab"`
+  - `re.fullmatch(r"ab", "ab")`
+- Es gibt Sonderzeichen wie `*, +, (, ), ...` mit denen man komplexere Eingaben überprüfen kann
+- Wir wollen `"ab...a"` von der vorherigen Slide matchen
+  - `b*` möchte 0 bis unendlich `b`
+  - `b+` möchte 1 bis unendlich `b`
+- also `re.fullmatch(r"ab+a", "abbbbbbba")` ist ein Match
+
+---
+
+## Weiter Sonderzeichen/Variabeln
+
+- Mit `\d` kann man in Python eine beliebige Zahl meinen
+- Mit `\s` kann man ein beliebigen Whitespace meinen
+- So kann man z.B. eine beliebige Ip so darstellen
+  - `r'(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})'`
+- Nützlich zum Parsen oder auch Testen
+  - Ich nutze z.b. ReGex um eure Aufgaben zu testen
+
+---
+
+# Viel Erfolg bei der Klausur!
+
+
+

Tutorium/tut15/src/ex5_dataclasses.py

@@ -0,0 +1,51 @@
+from dataclasses import dataclass
+
+# (a) Vehicle
+
+
+@dataclass
+class Vehicle:
+    seats: int
+    hp: int
+    ccm: int
+    weight: int
+
+    def __post_init__(self):
+        assert 0 < self.seats < 10
+        assert 0 < self.hp
+        assert 0 < self.ccm
+        assert 0 < self.weight
+
+    def fun_factor(self) -> float:
+        return (10 * self.hp + self.ccm) / self.weight
+
+    def __gt__(self, other: 'Vehicle') -> bool:
+        return self.fun_factor() > other.fun_factor()
+
+# (b) Car
+
+
+@dataclass
+class Car(Vehicle):
+    spoiler: bool
+
+    def fun_factor(self) -> float:
+        return super().fun_factor() + (0.2 if self.spoiler else 0)
+
+
+# (c) Motorcycle
+
+
+@dataclass
+class Motorcycle(Vehicle):
+    sidecar: bool
+
+    def __post_init__(self):
+        super().__post_init__()
+        if self.sidecar:
+            assert 2 <= self.seats <= 3
+        else:
+            assert 1 <= self.seats <= 2
+
+    def fun_factor(self) -> float:
+        return super().fun_factor() * (2.4 if self.sidecar else 3)

Tutorium/tut15/src/ex5_dataclasses_private.py

@@ -0,0 +1,84 @@
+from dataclasses import InitVar, dataclass
+
+# (a) Vehicle
+
+
+@dataclass
+class Vehicle:
+    _seats: InitVar[int]
+    _hp: InitVar[int]
+    _ccm: InitVar[int]
+    _weight: InitVar[int]
+
+    def __post_init__(self, seats: int, hp: int, ccm: int, weight: int):
+        assert 0 < seats < 10
+        assert 0 < hp
+        assert 0 < ccm
+        assert 0 < weight
+        self.__seats = seats
+        self.__hp = hp
+        self.__ccm = ccm
+        self.__weight = weight
+
+    def fun_factor(self) -> float:
+        return (10 * self.__hp + self.__ccm) / self.__weight
+
+    def __gt__(self, other: 'Vehicle') -> bool:
+        return self.fun_factor() > other.fun_factor()
+    
+    @property
+    def seats(self) -> int:
+        return self.__seats
+    
+    @property
+    def hp(self) -> int:
+        return self.__hp
+    
+    @property
+    def ccm(self) -> int:
+        return self.__ccm
+    
+    @property
+    def weight(self) -> int:
+        return self.__weight
+
+# (b) Car
+
+
+@dataclass
+class Car(Vehicle):
+    _spoiler: InitVar[bool]
+    
+    def __post_init__(self, seats: int, hp: int, ccm: int, weight: int, spoiler: bool):
+        super().__post_init__(seats, hp, ccm, weight)
+        self.__spoiler = spoiler
+
+    def fun_factor(self) -> float:
+        return super().fun_factor() + (0.2 if self.__spoiler else 0)
+    
+    @property
+    def has_spoiler(self) -> bool:
+        return self.__spoiler
+
+
+# (c) Motorcycle
+
+
+@dataclass
+class Motorcycle(Vehicle):
+    _sidecar: InitVar[bool]
+
+    def __post_init__(self, seats: int, hp: int, ccm: int, weight: int, sidecar: bool):
+        if sidecar:
+            assert 2 <= seats <= 3
+        else:
+            assert 1 <= seats <= 2
+        super().__post_init__(seats, hp, ccm, weight)
+        self.__sidecar = sidecar
+
+    def fun_factor(self) -> float:
+        return super().fun_factor() * (2.4 if self.__sidecar else 3)
+    
+    @property
+    def is_sidecar(self) -> bool:
+        return self.__sidecar