diff --git a/src/analysis_3.typ b/src/analysis_3.typ index 6696b8d..2143493 100644 --- a/src/analysis_3.typ +++ b/src/analysis_3.typ @@ -1,3 +1,4 @@ +#import "@preview/cetz:0.4.1" #set math.mat(align: left) == Differentialgleichungen @@ -113,8 +114,24 @@ h^' (t) eq frac(Q_i, A) minus frac(A_a, A) dot root(, 2 dot g dot h) $ $ cases( -"OED: " h^' (t) &eq frac(Q_i, A) minus frac(A_a, A) dot root(, 2 dot g dot h) \ +"OED: " h^' (t) &eq frac(Q_i, A) minus frac(A_a, A) dot root(, 2 dot g dot h), "IC: " h(t_0) &eq h_0 ) $ +=== Mechanik +#cetz.canvas({ + import cetz.draw: * + rect((0, 0), (2, 1), ) + line((0, 0.5), (-1.5, 0.5), mark: (end: ">"), fill: black, stroke: black) + line((2, 0.7), (3, 0.7), mark: (end: ">"), fill: black, stroke: black) + line((2, 0.3), (4, 0.3), mark: (end: ">"), fill: black, stroke: black) + content((1, 0.5), [Data]) + content((-1, 0.9), [$F_1$], anchor: "west") + content((2.3, 1.1), [$F_2$], anchor: "west") + content((2.3, -0.1), [$F_n$], anchor: "west") +}) +Newton-Aktionsprinzip $m dot a eq F eq F_1 plus F_2 plus ... plus F_n$ \ +Fall 1: Geschwindigkeit $m dot v^' eq F_1(v) plus F_2(v) plus ... plus F_n (v)$ \ +Fall 2: Weg $m dot s^'' eq F_1(s) plus F_2(s) plus ... plus F_n (s)$ \ +Fall 3: Wrg und Geschwindigkeit $m dot s^'' eq F_1(s, s^') plus F_2(s, s^') plus ... plus F_n (s, s^')$ \ diff --git a/src/bachelorarbeit.typ b/src/bachelorarbeit.typ index 9693633..3ecb092 100644 --- a/src/bachelorarbeit.typ +++ b/src/bachelorarbeit.typ @@ -316,11 +316,17 @@ import cetz.draw: * })], [```typ content((0, 0), [1]) content((0, -1), [Median = 4]) +content((0, -2), [$integral x dot "dt"$], anchor: "north-west") +- north +- south +- west +- east ```], [ #cetz.canvas({ import cetz.draw: * content((0, 0), [1]) content((0, -1), [Median = 4]) + content((0, -2), [$integral x dot "dt"$], anchor: "north-west") })], [```typ ```],[] diff --git a/src/informatik_1.typ b/src/informatik_1.typ index 69a24f4..1ef055d 100644 --- a/src/informatik_1.typ +++ b/src/informatik_1.typ @@ -116,6 +116,13 @@ if (x > 3){ } else { printf("x ist gleich 3 oder kleiner."); } +```], +[Short Hand If...Else:], +[```c +int time = 20; +(time < 18) ? printf("Good day.") : printf("Good evening."); + +variable = (condition) ? expressionTrue : expressionFalse; ```] ) diff --git a/src/python_wahlmodul.typ b/src/python_wahlmodul.typ index 42302ed..35de99b 100644 --- a/src/python_wahlmodul.typ +++ b/src/python_wahlmodul.typ @@ -471,6 +471,172 @@ print(my_read_in_dict) [`"r"`], [Lesen modus], ) +=== Klassen (Objektorientierte Programmierung (OOP)) +==== Klassen +```py my_obj = MyClass() ``` my_obj ist eine Instanz von der klasse MyClass. \ +Einfache Klasse: +#table(columns: 1fr, [```py +class MyClass: + pass +```]) +#table(columns: 1fr, [```py +print(MyClass.__name__) # -> MyClass +mc = MyClass() # liefert auch bereits Funktionalität + # -> die Klasse ist ‘callable’ + # -> sie liefert eine Instanz der Klasse zurück! +print(isinstance(mc, MyClass)) # True +```]) + +===== Atriebute +#table(columns: 1fr, [```py +class Person: + name = "Marco" + eye_color = "blue" +```]) +Zugriff auf die Variablen +#table(columns: 1fr, [```py +Person.name # 'Marco' +Person.exe_color # 'blue' +```]) +Modifikation der Variablen +#table(columns: 1fr, [```py +setattr(Person, 'name', 'Sandra') # alternativ aber Dot-Notation üblich +getattr(Person, 'name') # 'Sandra' + +Person.name = 'Sandra' +Person.name # 'Sandra' +```]) + +===== Methoden +#table(columns: 1fr, [```py +class Person: + def say_hello(self): + print(f"Hello {self.name}!") + +p1 = Person() +p1.name = "Marco" +p1.say_hello() # Hello Marco! +p2 = Person() +p2.name = "Sarah" +p2.say_hello() # Hello Sarah! +```]) + mit zusätzlichem parameter: +#table(columns: 1fr, [```py +class Person: + def say_hello(self, mark): + print(f"Hello {self.name}{mark}") + +p1 = Person() +p1.name = "Marco" +p1.say_hello('!!!!!') # Hello Marco!!!!! +p2 = Person() +p2.name = "Sarah" +p2.say_hello('?') # Hello Sarah? +```]) + +===== Initialisierung +#table(columns: 1fr, [```py +class Person: + def __init__(self, name="Unbekannter"): + self.name = name + def say_hello(self): + print(f"Hallo {self.name}") + +p1 = Person() +p1.say_hello() # Hallo Unbekannter +p2 = Person(name="Marco") +p2.say_hello() # Hallo Marco +```]) + +==== Objekte +===== Dunder-Methode +#table(columns: (0.2fr, 1fr), +table.cell(colspan: 2, fill: gray)[Initialisierung], +[```py __init__```], [Wird beim initialisieren aufgerufen.], +[```py __del__```], [Wird beim löschen aufgerufen. (destructor)], +table.cell(colspan: 2, fill: gray)[Arithmetische Operatoren], +[```py __add__```], [`+`], +[```py __sub__```], [`-`], +[```py __mul__```], [`*`], +[```py __floordiv__```], [`//`], +[```py __truediv__```], [`/`], +[```py __mod__```], [`%`], +[```py __pow__```], [`**`], +[```py __lshift__```], [`<<`], +[```py __rshift__```], [`>>`], +[```py __and__```], [`&`], +[```py __or__```], [`|`], +[```py __xor__```], [`^`], +[```py __invert__```], [`~`], +table.cell(colspan: 2, fill: gray)[Strings], +[```py __str__```], [Was passiert wenn geprintet wird.], +table.cell(colspan: 2, fill: gray)[Vergleichsoperatoren], +[```py __eq__```], [`==`], +[```py __ne__```], [`!=`], +[```py __lt__```], [`<`], +[```py __gt__```], [`>`], +[```py __le__```], [`<=`], +[```py __ge__```], [`>=`], +) + +#table(columns: 1fr, [```py +class Point: + def __init__(self, x=0, y=0): + self.x = x + self.y = y + + def __add__(self, other): + if not isinstance(other, Point): + raise Exception(f"Nur Objekte vom Typ Point werden berücksichtigt") + return Point(self.x + other.x, self.y + other.y) + + def __str__(self): + return f"Point({self.x}, {self.y})" + +p1 = Point(1, 2) +p2 = Point(3, 4) +p3 = p1 + p2 +print(p3) # Point(4, 6) +```]) + +===== Statische Methode +Statische methoden haben weder zugrif auf ```py self``` oder ```py cls```. +#table(columns: 1fr, [```py +class Mathe: + @staticmethod + def addiere(x, y): + return x + y + +resultat = Mathe.addiere(3, 5) +print(resultat) # 8 +```]) + +===== Klassen Methode +Wie Statische Methoden hat aber zugiff auf klassen Objekte(```py cls```)(Klassenattribut). cls sind wie globale Variablen inerhalb einer klasse. Das ```py self``` hat zugriff auf das ```py cls``` sowie auf die eigene Instanz. +#table(columns: 1fr, [```py +class Auto: + anzahl_autos = 0 + + @classmethod + def number_of_cars_instantiated(cls): + return cls.anzahl_autos + + def __init__(self, marke, farbe): + self.marke = marke + self.farbe = farbe + Auto.anzahl_autos += 1 + +print(Auto.number_of_cars_instantiated()) +bmw = Auto('BMW', 'white') +audi = Auto('Audi', 'blue') +print(Auto.number_of_cars_instantiated()) +```]) + +==== Vererbung +==== Polymorphismus + + + === Runden #table(columns: (1fr, 1fr), [```py