diff --git a/Tutorium/tut15/README.md b/Tutorium/tut15/README.md new file mode 100644 index 0000000..526f1db --- /dev/null +++ b/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! + + + diff --git a/Tutorium/tut15/img/dfa.png b/Tutorium/tut15/img/dfa.png new file mode 100644 index 0000000..cc2c473 Binary files /dev/null and b/Tutorium/tut15/img/dfa.png differ diff --git a/Tutorium/tut15/slides.pdf b/Tutorium/tut15/slides.pdf new file mode 100644 index 0000000..0892abb Binary files /dev/null and b/Tutorium/tut15/slides.pdf differ diff --git a/Tutorium/tut15/src/ex5_dataclasses.py b/Tutorium/tut15/src/ex5_dataclasses.py new file mode 100644 index 0000000..3a2a302 --- /dev/null +++ b/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) \ No newline at end of file diff --git a/Tutorium/tut15/src/ex5_dataclasses_private.py b/Tutorium/tut15/src/ex5_dataclasses_private.py new file mode 100644 index 0000000..b26a32a --- /dev/null +++ b/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 \ No newline at end of file