Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen der Seite angezeigt.

--- talit:python_advanced_problems [2025-01-13 10:09] – [7. Flask-Tutorial] sca
+++ talit:python_advanced_problems [2025-08-11 14:45] (aktuell) – sca
@@ Zeile 6: / Zeile 6: @@
    * Mit **Jupyter-Notebooks** arbeiten
-===== - Jupyter-Widgets & Markdown =====
+===== Nützliche Links =====
-Zeit: 1 Woche
+   * [[pham_physik_sca:python|NumPy, MatPlotLib, Jupyter, Widgets usw. für PHAM]]
-. Studiere das kurze Tutorial zu [[talit:python_advanced#jupyter_notebook|Jupyter Notebooks]] und **installiere beide Varianten**, also Jupyter im Browser und Jupyter in VSCode.
-. Lade das PDF mit dem [[talit:python_advanced#magic_cheat_sheet|Jupyter-Cheat Sheet]] herunter und verschaffe dir eine grobe Übersicht.
-. Lade das folgende Jupyter-Notebook herunter (zuerst entzippen) und arbeite es durch: {{ :talit:01_intro_widgets.ipynb.zip |}}
 ===== - Einfache Differentialgleichungen (DGL) =====
 Zeit: 1 Woche
-Erstelle ein Jupyter-NB mit Namen `02_einfache_dgl.ipynb` im entsprechenden Repo.
 ==== Einführung ====
@@ Zeile 69: / Zeile 62: @@
 import matplotlib.pyplot as plt
-def dgl(y,x):
+def dgl(y,x): # contains right side of DGL y'(x) = ...
     k = 0.4
     y_prime = - k * y
     return y_prime
-X = np.linspace(0,20,100)
+x = np.linspace(0,20,100)
 y0 = 15
-Y = odeint(dgl,y0,X)
+y = odeint(dgl,y0,x)
-plt.plot(X,Y)
+plt.plot(x,y)
 </code>
@@ Zeile 92: / Zeile 85: @@
-==== Aufgaben B ====
+==== Aufgaben A ====
+=== Aufgabe A0 ===
+. Erstelle auf GitHub ein Repo für diesen Kurs, z.B. `advanced_python_problems`, klone es auf deinen Computer und gib es der LP frei.
+. Erstelle ein File mit Namen `01_einfache_dgl.ipynb` im entsprechenden Repo.
+. Richte Jupyter Notebooks in VSCode ein (falls noch nicht gemacht)
-=== Aufgabe B1: Beispiel oben ===
+=== Aufgabe A1: Beispiel oben ===
 == Part I ==
@@ Zeile 114: / Zeile 113: @@
 == Part III ==
-Mache eine Kopie des Codes und füge einen Slider ein, mit dem man den Wert von $k$ einstellen kann.
+Mache eine Kopie des Codes und füge einen [[pham_physik_sca:python|Slider]] ein, mit dem man den Wert von $k$ einstellen kann.
-=== Aufgabe B2 ===
+=== Aufgabe A2 ===
 . Löse die Differentialgleichung $$f'(x) = a$$ mit odeint, wobei $a$ ein beliebiger Parameter ist.
@@ Zeile 123: / Zeile 122: @@
 . Um was für eine Funktion handelt es sich bei $f(x)$?
-=== Aufgabe B3 ===
+=== Aufgabe A3 ===
 . Löse die DGL vom Theorieteil am Anfang des Kapitels: $$f'(x) = \frac{2 \cdot f(x)}{x}$$
 . Stelle die Lösung graphisch dar und vergleiche sie mit der exakten Lösung $f(x) = k x^2$.
-=== Aufgabe B4: Matplotlib ===
+=== Aufgabe A4: Matplotlib ===
-Finde heraus, wie du die Darstellung deiner Figur verändern kannst, z.B.:
+Gehe zurück zum Plot der letzten Aufgabe und verschönere diese, z.B.:
 . Grösse der Figur
@@ Zeile 138: / Zeile 137: @@
 . Beschriftungen: Titel, Achsen, Graph, Legende
 . ...
 ===== - Bewegungsgleichungen =====
@@ Zeile 227: / Zeile 228: @@
 Dabei ist $c$ eine Konstante, die uns angibt, wie stark der Luftwiderstand ist.
-==== Aufgaben C ====
+==== Aufgaben B ====
-Erstelle ein Jupyter-NB mit Namen `03_bewegungsgleichungen.ipynb` im entsprechenden Repo.
+Erstelle ein Jupyter-NB mit Namen `02_bewegungsgleichungen.ipynb` im entsprechenden Repo.
-=== Aufgabe C1: Harmonischer Oszillator ===
+=== Aufgabe B1: Harmonischer Oszillator ===
 . Beweise, dass $x(t) = x\_0 \cos\left(\sqrt{\frac{k}{m}} \cdot t\right)$ eine Lösung des harmonischen Oszillators ist: Setze einfach in die DGL ein und zeige, dass links und rechts das Gleiche herauskommt.
@@ Zeile 238: / Zeile 239: @@
 . Vergleiche nun deine numerische Lösung mit der analytischen Lösung $x(t) = x_0 \cos\left(\sqrt{\frac{k}{m}} \cdot t\right)$ und stelle sicher, dass diese übereinstimmen.
-=== Aufgabe C2: Gedämpfter harmonischer Oszillator ===
+=== Aufgabe B2: Gedämpfter harmonischer Oszillator ===
 . Simuliere nun den gedämpften harmonischen Oszillator mit einem Reibungsterm, der linear von der Geschwindigkeit abhängt.
@@ Zeile 248: / Zeile 249: @@
    * `param1` usw. sind die Parameter, die mit Widgets (z.B. Slider) eingestellt werden
-===== - Das Zweikörperproblem =====
-Zeit: 2 Wochen
-Gegeben sind zwei Massen $m_1$ und $m_2$ mit ...
-   * Anfangsposition $\vec{r}_1(t=0)$ und $\vec{r}_2(t=0)$
-   * Anfangsgeschwindigkeit $\vec{v}_1(t=0)$ und $\vec{v}_2(t=0)$
-{{:talit:two_body_problem.png?400|}}
-<nodisp 2>
-++++Code Graph|
-<code>
-\begin{tikzpicture}[scale=1,cap=round,>=latex]
-	\pgfmathsetmacro{\Rone}{0.5}
-	\pgfmathsetmacro{\Rtwo}{0.75}
-	\pgfmathsetmacro{\F}{3}
-	\pgfmathsetmacro{\d}{10}
-	\draw[very thick,fill=blue!50] (7,-2) circle(0) node[below] {$0$};
-	\draw[very thick,fill=blue!50] (0,0) circle(\Rone);
-	\draw[very thick,fill=yellow!50] (8,2) circle(\Rtwo);
-	\draw[black,fill=black] (0,\Rone) node[above] {$m_1$};
-	\draw[black,fill=black] (8,2+\Rtwo) node[above] {$m_2$};
-	\draw[->,ultra thick,cyan] (0,0) -- (8,2) node[above,midway] {$\vec{r}_{12}$};
-	\draw[->,ultra thick,magenta,dashed] (0,0) -- ++(2,0.5) node[above,pos=0.8] {$\vec{F}_{12}$};
-	\draw[->,ultra thick,magenta,dashed] (8,2) -- ++(-2,-0.5) node[above,pos=0.8] {$\vec{F}_{21}$};
-	\draw[->,ultra thick] (7,-2) -- (0,0) node[below,midway] {$\vec{r}_1$};
-	\draw[->,ultra thick] (7,-2) -- (8,2) node[right,midway] {$\vec{r}_2$};
-	\draw[->,ultra thick] (7,-2) -- (5,1.25) node[right,pos=0.6] {$\vec{R}$};
-	\draw[very thick,fill=black] (5,1.25) circle(0.07);
-\end{tikzpicture}
-</code>
-++++
-</nodisp>
-**Ziel:** Bestimme Position der beiden Massen zu jedem Zeitpunkt, also $\vec{r}_1(t) = ?$ und $\vec{r}_2(t) = ?$
-==== Die Differenzialgleichungen ====
-Die beiden Massen ziehen sich natürlich gegenseitig mit der Gravitationskraft an:
-$$F_G = G \frac{m_1 \cdot m_2}{d^2}$$
-wobei $d$ der Abstand zwischen den beiden Massen ist.
-Da eine Kraft sowohl eine Stärke als auch eine Richtung hat, wird sie als *Vektor* dargestellt. Die Formel oben, die du bereits aus dem GF Physik kennst, gibt allerdings nur die Stärke an. Wir brauchen aber die *Vektor-Version*:
-Die Gravitationskraft, die wegen $m_2$ auf $m_1$ wirkt, ist:
-$$\vec{F}_{12} = G \frac{m_1 \cdot m_2}{|\vec{r}_{12}|^3} \vec{r}_{12}$$
-wobei $\vec{r}_{12} = \vec{r}_2 - \vec{r}_1$ der *Verschiebungsvektor* ist, der von $m_1$ zu $m_2$ zeigt. Damit ergibt sich:
-$$\vec{F}_{12} = G \frac{m_1 \cdot m_2}{|\vec{r}_2 - \vec{r}_1|^3} (\vec{r}_2 - \vec{r}_1)$$
-Wahrscheinlich fragst du dich, woher das "hoch 3" kommt! Dies macht Sinn, wenn man die Stärke dieses Vektors bestimmt:
-$$|\vec{F}_{12}| = G \frac{m_1 \cdot m_2}{|\vec{r}_{12}|^3} |\vec{r}_{12}| = G \frac{m_1 \cdot m_2}{|\vec{r}_{12}|^2}$$
-Die Differenzialgleichungen (DGL), welche die Position der Masse $m_1$ bestimmt ist dann wie immer durch das **2. Newtonsche Gesetz** gegeben:
-$$m_1 \, \ddot{\vec{r}}_1 = \vec{F}_{12} = G \frac{m_1 \cdot m_2}{|\vec{r}_2 - \vec{r}_1|^3} (\vec{r}_2 - \vec{r}_1)$$
-und gleichermassen für die zweite Masse:
-$$m_2 \, \ddot{\vec{r}}_2 = \vec{F}_{21} = G \frac{m_1 \cdot m_2}{|\vec{r}_1 - \vec{r}_2|^3} (\vec{r}_1 - \vec{r}_2)$$
-In einem Zweikörpersystem bewegen sich die beiden Massen *immer in einer Ebene*. Wir können daher das Problem in 2D anstelle 3D betrachten. Die beiden Positionsvektoren haben dann also je eine $x-$ und $y-$ Komponente:
-$$\vec{r}_1 = \begin{pmatrix} x_1 \\ y_1 \end{pmatrix} \,, \quad
-\vec{r}_2 = \begin{pmatrix} x_2 \\ y_2 \end{pmatrix}$$
-Die DGL sind dann also:
-$$m_1 \begin{pmatrix} \ddot{x}_1 \\ \ddot{y}_1 \end{pmatrix} = G \frac{m_1 \cdot m_2}{d^3} \begin{pmatrix} x_2 - x_1 \\ y_2 - y_1 \end{pmatrix}$$
-$$m_2 \begin{pmatrix} \ddot{x}_2 \\ \ddot{y}_2 \end{pmatrix} = G \frac{m_1 \cdot m_2}{d^3} \begin{pmatrix} x_1 - x_2 \\ y_1 - y_2 \end{pmatrix}$$
-$$d = \sqrt{(x_1 - x_2)^2 + (y_1 - y_2)^2}$$
-Beachte, dass es sich um zwei Vektor-DGL handelt, es sind insgesamt also $4$ DGL:
-$$\ddot{x}_1 = \frac{G \cdot m_2}{d^3} (x_2 - x_1)$$
-$$\ddot{y}_1 = \frac{G \cdot m_2}{d^3} (y_2 - y_1)$$
-$$\ddot{x}_2 = \frac{G \cdot m_1}{d^3} (x_1 - x_2)$$
-$$\ddot{y}_2 = \frac{G \cdot m_1}{d^3} (y_1 - y_2)$$
-**Löst man nun diese DGL** (z.B. mit odeint), so erhält man die Position der beiden Massen.
-==== Der Schwerpunkt ====
-Der Schwerpunkt (barycenter) der beiden Massen ist gegeben durch:
-$$\vec{R} = \frac{m_1\,\vec{r}_1 + m_2\,\vec{r}_2}{m_1 + m_2}$$
-Wie oben besprochen geht es im Zweikörperproblem darum, die zu DGL lösen, welche durch das **2. Newtonsche Gesetz** gegeben sind:
-$$m_1\,\ddot{\vec{r}}_1 = \vec{F_{12}} = \text{Kraft, die Masse 2 auf Masse 1 ausübt}$$
-$$m_2\,\ddot{\vec{r}}_2 = \vec{F_{21}} = \text{Kraft, die Masse 1 auf Masse 2 ausübt}$$
-Dase **3. Newtonsche Gesetz** besagt, dass $$\vec{F_1} = - \vec{F_2}$$
-und damit
-$$\vec{F_1} + \vec{F_2} = 0$$
-Es gilt also:
-$$m_1\,\ddot{\vec{r}}_1 + m_2\,\ddot{\vec{r}}_2 = 0 \quad | \quad :(m_1+m_2)$$
-$$\frac{m_1\,\ddot{\vec{r}}_1 + m_2\,\ddot{\vec{r}}_2}{m_1 + m_2} = 0$$
-$$\ddot{\vec{R}} = 0$$
-Das bedeutet also, dass der *Schwerpunkt* des 2-Körpersystems *nicht beschleunigt* ist. Seine Geschwindigkeit $\vec{v} = \dot{\vec{R}}$ ist also *konstant*.
-Wenn man die Lösung des Zweikörperproblems graphisch darstellt, so macht es Sinn, dafür ein **Bezugssystem** zu wählen, in welchem der sich der *Schwerpunkt in Ruhe*. Dafür geht man wie folgt vor:
-. **Löse die DGL**, welche für die beiden Massen durch die Newtonsche Gravitationskraft gegeben sind, ganz normal mit odeint.
-. Berechne dann mithilfe der erhaltenen Lösung für jeden Zeitpunkt den **Schwerpunkt** des Zweikörpersystems.
-. **Subtrahiere** den Schwerpunkt von den Positionen der beiden Massen.
-. **Plotte** die Bahnen der beiden Massen. Du solltest jetzt sehen, dass sie sich auf **Ellipsen** bewegen.
-==== Aufgaben D ====
-. **Simuliere die Umlaufbahnen** zweier Planeten im Zweikörpersystem. Rechne den Schwerpunkt aus den $x$- und $y$-Koordinaten heraus. Verwende folgende Werte:
-. $G=1$
-. Massen: z.B. in Grössenordnung $1-10$.
-. Startposition: ebenfalls $1-10$.
-. Anfangsgeschwindigkeit eher $0.05-0.5$
-. Finde dann durch ausprobieren möglichst **unterschiedliche Orbits**. U.a. sollen die folgenden reproduziert werden:
-   {{:talit:two_body_problem_orbits.png?400|}}
-. **Zweikörpersimulator mit Widgets:** Füge einige Widgets ein, mit denen man den Orbit festlegen kann. Sinn würde z.B. folgendes machen:
-. Massen m1 und m2
-. Distanz $d$: m1 hat dann Anfangsposition (-d/2,0) und m2 hat dann Anfangsposition (d/2,0).
-. Anfangsgeschwindigkeiten der beiden, aber immer in $y$-Richtung.
-. **(Optional) Animation:** Umlaufbahnen sollen animiert dargestellt werden
-===== - Game Of Life =====
-==== Version 1 ====
-Zeit: 1 Woche
-   * Studiere nur [[https://de.wikipedia.org/wiki/Conways_Spiel_des_Lebens#Die_Spielregeln|Spielregeln]]
-   * Implementiere das Game of Life mit Python (normal oder Jupyter)
-   * Wie du es visualisierst, ist dir überlassen: Konsole, PyGame, PyQt, Jupyter, ...
-   * Programmiere **ganz alleine** (keine Inspiration von Google, weiter unten auf Wiki, ...)
-==== Version 2 ====
-Zeit: 1 Woche
-++++Vorgaben Version v02|
-   * Mache eine Kopie von v01 oder starte neu und gebe einen passenden Namen, z.B. `game_of_life_v02.py` (manchmal einfacher: neues File, dann Code Stück für Stück hinein kopieren)
-   * Modell überarbeiten / neu schreiben
-   * Die Anzeige soll in **Konsole** gemacht werden (PyGame o.ä. später, Idee ist, dass man dann das *genau gleiche* Modell auch für PyGame oder andere GUI-Libraryverwenden kann)
-   * muss **komplett objektorientiert** sein (siehe unten empfohlene Klassen)
-   * **unendlich grosse Welt:** Zellen können ausserhalb des auf Bildschirm angezeigten Bereichs leben
-   * speichere nur die lebendigen Zellen, die toten werden aus Liste entfernt
-   * **Model und View komplett getrennt**.
-   * Bitte ausreichend **Kommentieren**
-++++
-++++Theorie Model vs. View|
-   * Ist ein **Programmierparadigma** ("Programmier-Philosophie")
-   * **Model:** Abbildung des Game-States im Code (Objekte, Listen, ...)
-   * **View:** kümmert sich um alles was mit Input und Output zu tun hat
-     * Output: Anzeige des Game-States (z.B. Console-View, PyGame, ...)
-     * Input: User-Eingaben verarbeiten, hier wahrscheinlich irrelevant
-   * Die beiden sollten *strikt getrennt sein*
-   * Vorteil: Kann Modell 1x programmieren und dann in verschiedenen Views verwenden, z.B. Console-App, PyGame, Webgame, ...
-++++
-++++Empfohlene Klassen|
-<code python>
-# MODELL
-"""
-Die ersten beiden Klassen bilden das Modell und haben nichts mit der Darstellung zu tun.
-Deshalb dürfen diese KEINE print, PyGame usw. Befehle beinhalten.
-"""
-class World:
-    """
-    Create only one object of this class.
-    Contains list with all cells that are alive, updated them, ...
-    """
-    def __init__(self,...):
-        self.cells = [] # saves all cells that are ALIVE
-        ...
-    def update(self):
-        pass
-    ....
-class Cell:
-    """
-    describes a single cell
-    """
-    def __init__(self,...):
-        self.x = ... # x coordinate
-        self.y = ... # y coordinate
-        self.is_alive = ... # is currently alive
-        self.stays_alive = ... # will still be alive in next round
-        self.neighbours = []
-    ....
-# VIEW
-"""
-Die Klasse(n) hier ist für die Darstellung zuständig.
-"""
-class ConsoleApp: # or PyGameApp
-    pass
-# EXECUTE PROGRAM
-"""
-Könnte etwa wie folgt aussehen:
-"""
-if __name__ == "__main__":
-    world = World("static 1") # erstelle Welt mit vordefiniertem Preset, weitere Möglichkeiten: "glider 1", "random", ...
-    console_app = ConsoleApp(world) # erstelle eine Console App (oder PyGame, ...)
-    console_app.animate() # führe aus
-</code>
-++++
-==== Version 3 ====
-Zeit: 1 Woche
-**Ziel:** Identischen Model-Code von V2 verwenden für mind. zwei verschiedene Views: Console (aus V2) und GUI (z.B. PyGame/PyQT/Matplotlib)
-. Verbessere falls nötig Code von V2: **Model- und View-Code müssen strikt getrennt sein** und alles **muss strikt objektorientiert programmiert** sein.
-. Strukturiere nun Code um. Je ein **eigenes File für**:
-. Ganzen Model-Code, z.B. `game_of_life_model.py`
-. Code für Console-View, z.B. `game_of_life_console.py`
-. Code für GUI-View, z.B. `game_of_life_pygame.py`
-. Importiere in den beiden Files für die View den Model-Code, z.B. `from game_of_life_model import *`
-. Programmiere nun die beiden Views aus.
-. Optional: Coole Features einbauen
-===== - Winter Wonderland Christmas Game =====
-Erstelle im Eiltempo (2L und ein bisschen zuhause) ein einfaches PyGame-Game, welches an Moorhuhnjagd erinnern soll:
-   * Statisches Hintergrundbild mit Winterlandschaft
-   * Es werden zufällig Schneeflocken am oberen Rand erzeugt, die in unterschiedlichen Tempi herunter fallen.
-   * Es werden zufällig Geschenke am oberen Rand erzeugt, die in unterschiedlichen Tempi herunter fallen.
-   * Durch Mausklick soll man diese einfangen können: Verschwinden bei Klick, Score erhöht sich um 1.
-Weitere optionale Idee:
-   * Verschiedene Geschenke, gewisse Typen beinhalten Bomben -> Abzug oder Leben verlieren bis Game Over
-   * Santa der mit Schlitten quer durch den Bildschirm reitet
-   * Power-Ups
-   * Animationen, z.B. wenn Bombe explodiert, ...
-   * Musik & SFX
-   * Eigene Ideen, sei kreativ!
-Anforderungen Programmieren:
-   * Muss strikt **objektorientiert** sein. Mache z.B. Klasse `Item` sowohl für Geschenke als auch Schneeflocken. Allerdings sollen nur die Geschenke einsammelbar sein. Mache dazu z.B. eine Flag `is_collectable`, welche `True` für Geschenke und `False` für Schneeflocken ist.
-   * Tipp: Starte mit **Template** von [[python_pygame#template|hier]].
-   * Verwende z.B. diese Bilder oder finde/erzeuge eigene:
-{{:talit:winterwonderland.png?200|}} {{:talit:snowflake.png?100|}} {{:talit:present.png?100|}}
-===== - Flask-Tutorial =====
-Erstelle mit Flask eine einfache Website mit folgenden Features:
-. **Clicker:** Programmiere (nicht serverseitig) einen Counter. Jedes Mal wenn ein Button gedrückt wird, erhöht sich dieser um 1.
-. **Zufallszahl:** Auf Knopfdruck wird eine Zufallszahl angezeigt. Diese wird serverseitig erzeugt.
-. **Encryption:** In Textfeld kann Text eingegeben werden. Dieser wird in real time (also direkt mit Eingabe) serverseitig verschlüsselt. Verwende dazu einen Algorithmus, denn du im Grundlagenfach bereits programmiert hast (Cäsar, Vigenere, ...). Der verschlüsselte Text wird dann immer gleich angezeigt.
-. **Automatisierter Counter** oder automatisierte Zufallszahl: Jede Sekunde soll der Wert neu gesetzt werden. Syntax:<WRAP>
-<code javascript>
-async function loop() {
-    while (true) {
-        // <code that gets executed before the wait>
-        await new Promise(resolve => setTimeout(resolve, 1000)); // Sleep for 1 second (1000 milliseconds)
-        // <code that gets executed after the wait>
-    }
-}
-loop()
-</code>
-</WRAP>
-Nützliche Links:
-   * [[talit:flask_webserver]]
-   * [[gf_informatik:web_sca:websites]]
-   * [[informatik:website_with_js]]
-   * [[informatik:javascript_cheat_sheet]]