From 91c26f247c1ebe4a753b08720dcd018e8419f6ef Mon Sep 17 00:00:00 2001
From: Malte Woidt <m.woidt@tu-braunschweig.de>
Date: Wed, 2 Nov 2022 02:24:11 +0100
Subject: [PATCH] Uebung 1
---
JupyterNotebook_Grundlagen.ipynb | 319 ------
Uebung01/JupyterNotebook_Grundlagen.ipynb | 417 ++++++++
Uebung01/Python_Grundlagen.ipynb | 1104 +++++++++++++++++++++
Uebung01/Uebung01.ipynb | 525 ++++++++++
4 files changed, 2046 insertions(+), 319 deletions(-)
delete mode 100644 JupyterNotebook_Grundlagen.ipynb
create mode 100644 Uebung01/JupyterNotebook_Grundlagen.ipynb
create mode 100644 Uebung01/Python_Grundlagen.ipynb
create mode 100644 Uebung01/Uebung01.ipynb
diff --git a/JupyterNotebook_Grundlagen.ipynb b/JupyterNotebook_Grundlagen.ipynb
deleted file mode 100644
index 62105eb..0000000
--- a/JupyterNotebook_Grundlagen.ipynb
+++ /dev/null
@@ -1,319 +0,0 @@
-{
- "cells": [
- {
- "cell_type": "markdown",
- "id": "2686acb8-0a4f-4035-bf03-ba58c86eeb6b",
- "metadata": {},
- "source": [
- "### **Einführung Jupyter-Notebooks**\n",
- "Für die Übung ??? verwenden wir die Programmierumgebung Jupyter-Notebook. Dieses Notebook bietet eine kurze Einführung in Jupyter und erklärt das Bedienungskonzept"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "3fba5bde-edf2-445d-962f-d9ac1ae87505",
- "metadata": {},
- "source": [
- "# **\"Lernthema\"**\n",
- "Im Verlauf der Übung wird Jupyter-Notebooks sowohl als Lehrmaterial als auch als Umgebung zur Bearbeitung der Übungsaufgaben genutzt. In diesem Dokument erklären wir euch, wie und wieso man Jupyter-Notebooks zum Programmieren in Python einsetzt. An Ende dieser Eunheut sollt ihr:\n",
- "* \"\"\n",
- "* \"\"\n",
- "* \"\"\n",
- "\n",
- "### **Einordnung in Notebook Kontext**\n",
- "Einordnung bezüglich der \n",
- "* \"übergeordneten Themen\"\n",
- "* \"anderen Notebooks\"\n",
- "* \"Lernziele des Notebooks\" (spezifisch mit Bibliotheken und Code Verweisen)\n",
- "\n",
- "### **Vorkenntnisse**\n",
- "* \"keine\""
- ]
- },
- {
- "cell_type": "markdown",
- "id": "59fffdd0-6428-471c-8dd6-ac7faf9cfef7",
- "metadata": {
- "tags": []
- },
- "source": [
- "# **Was sind Jupyter-Notebooks**\n",
- "Das Jupyter-Projekt bietet eine Reihe von Tools zur interaktiven Verwendung von Programmiersprachen als Webanwendung im Browser an. Die Idee ist dabei, dass das Programm nicht auf dem eigenen PC, sondern auf einem Server läuft. Auch die Beispiele in diesem Notebook werden nicht auf eurem PC ausgeführt, sondern auf einem Server des Rechenzentrums. Alles was zur Benutzung benötigt wird ist also ein Webbrowser\n",
- "\n",
- "Jupyter-Notebooks ist eine einfache Programmierumgebung als Browseranwendung, die es erlaubt strukturierten Text (Text, Bilder, Tabellen, Formeln, Inhaltsverzeichnis, etc.) mit ausführbarem Programmcode zu vermischen und die Ausgabe des Programmcodes gleich im Browser anzuzeigen. Das ist beispielsweise in diesem Notebook illustriert. Das Notebook selbst ist dabei in Zellen strukturiert, dazu mehr im nächsten Abschnitt (oder der nächsten Zelle).\n",
- "\n",
- "Jupyter-Notebooks wird vor allem für interaktive Nutzung von Python eingesetzt. Z.B. für die Analyse von Daten und das Erstellen von Diagrammen und weniger für die Programmierung ganzer Programme. Prinzipiell ist allerdings beides möglich\n",
- "\n",
- "Ein weiterer großer Vorteil von Jupyter-Notebooks ist, dass ihr damit auch auf eurem eigenen PC arbeiten könnt, falls ihr nicht auf den Servern des GITZ arbeiten wollt. Das kann sinnvoll sein, wenn ihr zum Beispiel keine Internetverbindung habt, oder euch der Server zu langsam ist, oder ihr unabhängig der Übung selbst etwas programmieren wollt. Die Installation ist relativ einfach, wir haben euch ***hier*** eine Anleitung erstellt. Damit habt ihr so zusagen genau die gleiche Umgebung wie auf dem GITZ-Server auf eurem eigenen PC, nur eben viel kleiner und nur für die lokale Benutzung durch einen Benutzer gedacht.\n"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "0bbed02a-276b-4240-9948-f4c19c6bc854",
- "metadata": {
- "tags": []
- },
- "source": [
- "# **Wie benutzt man Jupyter-Notebooks**\n",
- "Das Notebook-Bedienkonzept gibt es auch in anderen Programmierumgebungen (z.B. Wolfram Mathematica). Das Notebook ist eine Datei bzw. ein Dokument. Dieses Dokument ist in untereinanderliegende Zellen aufgeteilt, wie z.B. dieses Dokument. Wenn ihr zum Beispiel mit der linken Maustaste einmal auf diesen Text klickt, seht ihr einen Rahmen. Das ist die Zelle, in der diese Text steht. Es gibt verschiedene Zelltypen. Zum einen Textzellen, das ist eine Zelle wie diese hier. Zum Anderen gibt es Code-Zellen, dass ist Python Programmcode, der ausgeführt werden kann. \n",
- "**Der modale Editor**\n",
- "Jupyter-Notebooks ist ein sogenannter modaler Editor. Er kenn zwei Modi\n",
- "\n",
- "* den Edit Mode zum Bearbeiten einer Zelle\n",
- "* den Command Mode um Die Struktur der Dokumentes zu verändern\n",
- "\n",
- "Momentan befindet ihr euch im Command Mode. Direkt unter dieser Textzelle befindet sich eine Codezelle mit dem Inhalt \"3+5\". Wenn ihr mit der linken Maustauste auf die Zelle klickt, befindet ihr euch im Edit mode. Ihr könnt den Inhalt der Zelle beliebig verändern. Die Codezellen Erkennt man an den Eckigen Klammern am linken Rand. Ihr verlasst den Editmode, indem ihr links neben die Zelle klickt oder Escape drückt. Die Zelle ist jetzt wieder grau hinterlegt, aber noch ausgewählt. Ihr könnt den Programmcode in dieser Zelle ausführen, indem ihr Shift+Enter drückt. In der Eckigen klammer steht dann eine Zahl. Das ist einfach ein Zähler, der mitzählt, wie viel Codezellen ihr schon ausgeführt habt und gibt die Reihenfolge der Ausführung an. Das kann wichtig sein, wie weiter unten beschrieben. Damit habt ihr euer erstes Programm ausgeführt, auch wen dessen Ausgabe etwas vorhersehbar war.\n",
- "\n",
- "Eine letzte besonderheit bieten die Textzellen. Wenn ihr einmal auf eine Textzelle klickt, dann wird sie nur ausgewählt, ihr bleibt aber im Command Mode. Mit einem Doppelklick kommt ihr in den Editmode. Das Probiert ihr am besten nicht mit dieser Zelle aus. Ihr seht dann den Quelltext der Zelle (Die Auszeichnungssprache heißt Markdown, die ihr vielleicht aus Internetforen o.ä. schon kennt). Wenn ihr den Editmode wieder verlasst ist die Zelle weiterhin grau unterlegt und zeigt den Quelltext an. Mit Shift-Enter könnt ihr die Textzelle quasi ausführen. Das Ergebnis ist dann der formatierte Text\n",
- "\n",
- "Die Wichtigsten Kommandos als Kurzrefferenz:\n",
- "Um in den Edit Mode zu gelangen auf eine Zelle klicken (Bei formatiert angezeigten Textzellen doppelklick)\n",
- "Um in den Command Mode zu kommen Esc drücken oder links neben die Zelle klicken\n",
- "\n",
- "Im Command Mode:\n",
- "* y: Macht die aktuelle Zelle zur Code-Zelle\n",
- "* m: Nacht die aktuelle Zelle zur Text-Zelle\n",
- "* a: Fügt eine Zelle über der aktuellen Zelle ein\n",
- "* b: Fügt eine Zelle unter der aktuellen Zelle ein\n",
- "* d-d: Zweimal d drücken löscht die Zelle. Kann durch ctrl-z rückgängig gemacht werden, bzw über das Menü Edit->Undo Delete Cells)\n",
- "Im Edit Mode:\n",
- "* Esc: Wechselt in den Command Mode\n",
- "* tab : Autoverfollständigung (Funktioniert beim Programmieren in etwa so wie die Autoverfollständigung von Worten auf eurem Handy)\n",
- "Ansonsten funktionieren die gängigen Tastenkombinationen wie ctrl-c, ctrl-x, ctrl-v und ctrl-z für Kopieren, Ausschneiden, Einfügen und Rückgängig machen\n",
- "\n",
- "* shift-enter: unabhängig vom Modus\n",
- " * Code Zelle: Der gesamte Programmcode in der Zelle wird ausgeführt\n",
- " * Text Zelle: Der Text wird formatiert angezeigt (und ist dann nicht mehr grau hinterlegt)\n",
- "\n",
- "\n",
- "Alle Aktionen sind auch über das Menü am oberen Ende des Notebooks zugänglich"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "id": "abcaec09-8492-4d8b-85f5-58d51bc64a56",
- "metadata": {
- "tags": []
- },
- "outputs": [],
- "source": [
- "3+5"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "feb4741a-faa6-4438-974f-77f1b66d43f6",
- "metadata": {},
- "source": [
- "# **Ein paar Besonderheiten der Notebooks**\n",
- "Die Notebooks haben zwei Besonderheiten, die man im Hinterkopf behalten sollte. Der Code in den Zellen wird nie automatisch ausgeführt, sondern erst, wenn shift-enter bzw. der entsprechende Knopf im Menü gedrückt wird. Das gilt sowohl wenn ein Notebook geöffnet wird, als auch wenn der Programmcode modifiziert wird. Die Nächste Zelle enthält Programmcode, der eine zufällige Zahl ausgibt. unter der Zelle siehst du bereits ein Ergebnis (0.1290...). Das wurde nicht beim öffnen des Notebooks erstellt sondern ist das Ergebnis, das ich beim erstellen dieses Notebooks erhalten habe. Die ausgabe der Zellen werden sozusagen als Vorschau mit dem Notebook zusammen gespeichert. Wenn du die Zelle ausführst erhälst du jedesmal ein neues, zufälliges Ergebnis"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": 19,
- "id": "dd3c833d-d0b9-40d8-9b49-b6b25d9b3675",
- "metadata": {},
- "outputs": [
- {
- "data": {
- "text/plain": [
- "0.8129827011701761"
- ]
- },
- "execution_count": 19,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
- "source": [
- "from random import*\n",
- "random()"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "558d9f97-6c85-455a-b95e-c75e397eec80",
- "metadata": {},
- "source": [
- "Die Zahlen in den Eckigen Klammern links neben den Code Zellen geben an, in welcher Reihenfolge sie Ausgeführt wurden. Das ist wichtig, da nicht jede Zelle ein abgeschlossenes Programm für sich ist. Viel mehr wird der Programmcode ausgeführt und der Python-Interpreter wartet auf weitere Eingaben. Die nächsten zwei Zellen sollen das verdeutlichen. Auch ohne Programmierkenntnisse ist hoffentlich verständlich was passiert. Wenn du die erste Zelle und dann die zweite Zelle ausführst, dann funktioniert die zweite Zelle. Versuchst du die zweite Zelle ein zweites mal auszuführen, ohne die erste erneut ausgeführt zu haben, erhälst du eine Fehlermeldung. Du kannst das in diesem Notebook einfach ausprobieren"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "id": "f0fd320a-ff4f-441f-bdec-00ff957735fc",
- "metadata": {},
- "outputs": [],
- "source": [
- "x=7 #Erzeugt eine Variable mit dem Namen x, in der der Wert 7 gespeichert wird\n",
- "print(x) #gibt den Wert der Variable x aus"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "id": "9660af8f-2afc-43c1-9cd8-726b8236217d",
- "metadata": {},
- "outputs": [],
- "source": [
- "print(x) #gibt den Wert der Variable x aus\n",
- "del(x) #löscht die Variable x"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "07620b12-7782-47d6-ab54-22047d341b2f",
- "metadata": {},
- "source": [
- "Die erste Zelle erzeugt eine Variable mit dem Namen x, die in der zweiten Zelle ausgegeben wird. Das ist möglich, da eine Zelle kein abgeschlossenes Programm ist. Eine Zelle findet den Zustand also so vor, wie ihn die letzte ausgeführte Zelle hinterlassen hat. In der zweiten Zelle wird die Variable x anschließend gelöscht. Versucht man jetzt die zweite Zelle auszuführen oder führt man die zweite Zelle vor der ersten Zelle aus, dann gibt es einen Fehler, da die Variable in keinem der beiden Fälle bekannt ist. D.h. die Reihenfolge, in der die Zellen ausgeführt werden ist nicht egal und entspricht nicht zwingend der Reihenfolge im Notebook, da die Zellen immer manuell ausgeführt werden!"
- ]
- },
- {
- "cell_type": "markdown",
- "id": "d4a8a8af-2871-4148-9ee4-a9dcae61512a",
- "metadata": {},
- "source": [
- "# **Aufgaben**\n",
- "* Probiere in diesem Dokument einfach aus Zellen einzufügen, Zellen zu löschen oder zu editieren. Du befindest dich gerade in deiner eigenen, privaten Kopie unseres Dokuments und kannst damit machen, was du willst\n",
- "* Da es in diesem Notebook noch nicht um das Programmieren an sich geht, ist es ein bisschen langweilig. Um dir zu beweisen, dass man mit Jupyter-Notebooks auch mehr kann als Zahlen auszugeben, kannst du die nächsten zwei Codezellen ausführen\n",
- "\n",
- "Was du siehst ist ein Lorenz-Attraktor. Das ist anschaulich beschrieben der Weg eines Partikels, das sich mit der Konvektionsströmung einer Flüssigkeit zwischen einer Warmen und einer Kalten platte bewegt in einer vereinfachten physikalischen Modellierung.\n",
- "Das erste Beispiel ist eine statische Darstellung, beim zweiten Beispiel können die Parameter der zugrundeliegenden Differentialgleichung interaktiv mit den Reglern angepasst werden"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "id": "9a7785ba-ace4-4675-a211-be73f22f0553",
- "metadata": {},
- "outputs": [],
- "source": [
- "import numpy as np\n",
- "from scipy.integrate import solve_ivp\n",
- "import matplotlib.pyplot as plt\n",
- "\n",
- "WIDTH, HEIGHT, DPI = 1000, 750, 100\n",
- "\n",
- "# Lorenz paramters and initial conditions.\n",
- "sigma, beta, rho = 10, 2.667, 28\n",
- "u0, v0, w0 = 0, 1, 1.05\n",
- "\n",
- "# Maximum time point and total number of time points.\n",
- "tmax, n = 100, 10000\n",
- "\n",
- "def lorenz(t, X, sigma, beta, rho):\n",
- " \"\"\"The Lorenz equations.\"\"\"\n",
- " u, v, w = X\n",
- " up = -sigma*(u - v)\n",
- " vp = rho*u - v - u*w\n",
- " wp = -beta*w + u*v\n",
- " return up, vp, wp\n",
- "\n",
- "# Integrate the Lorenz equations.\n",
- "soln = solve_ivp(lorenz, (0, tmax), (u0, v0, w0), args=(sigma, beta, rho),\n",
- " dense_output=True)\n",
- "# Interpolate solution onto the time grid, t.\n",
- "t = np.linspace(0, tmax, n)\n",
- "x, y, z = soln.sol(t)\n",
- "\n",
- "# Plot the Lorenz attractor using a Matplotlib 3D projection.\n",
- "fig = plt.figure(facecolor='k', figsize=(WIDTH/DPI, HEIGHT/DPI))\n",
- "ax = fig.gca(projection='3d')\n",
- "ax.set_facecolor('k')\n",
- "fig.subplots_adjust(left=0, right=1, bottom=0, top=1)\n",
- "\n",
- "# Make the line multi-coloured by plotting it in segments of length s which\n",
- "# change in colour across the whole time series.\n",
- "s = 10\n",
- "cmap = plt.cm.winter\n",
- "for i in range(0,n-s,s):\n",
- " ax.plot(x[i:i+s+1], y[i:i+s+1], z[i:i+s+1], color=cmap(i/n), alpha=0.4)\n",
- "\n",
- "# Remove all the axis clutter, leaving just the curve.\n",
- "ax.set_axis_off()"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "id": "5d5375e8-66e2-4acb-ba3c-963e846fe7d8",
- "metadata": {
- "tags": []
- },
- "outputs": [],
- "source": [
- "import numpy as np\n",
- "from matplotlib import pyplot as plt\n",
- "from scipy import integrate\n",
- "\n",
- "from ipywidgets import interactive, fixed\n",
- "def solve_lorenz(sigma=10.0, beta=8./3, rho=28.0):\n",
- " \"\"\"Plot a solution to the Lorenz differential equations.\"\"\"\n",
- "\n",
- " max_time = 4.0\n",
- " N = 30\n",
- "\n",
- " fig = plt.figure(1)\n",
- " ax = fig.add_axes([0, 0, 1, 1], projection='3d')\n",
- " ax.axis('off')\n",
- "\n",
- " # prepare the axes limits\n",
- " ax.set_xlim((-25, 25))\n",
- " ax.set_ylim((-35, 35))\n",
- " ax.set_zlim((5, 55))\n",
- " \n",
- " def lorenz_deriv(x_y_z, t0, sigma=sigma, beta=beta, rho=rho):\n",
- " \"\"\"Compute the time-derivative of a Lorenz system.\"\"\"\n",
- " x, y, z = x_y_z\n",
- " return [sigma * (y - x), x * (rho - z) - y, x * y - beta * z]\n",
- "\n",
- " # Choose random starting points, uniformly distributed from -15 to 15\n",
- " np.random.seed(1)\n",
- " x0 = -15 + 30 * np.random.random((N, 3))\n",
- "\n",
- " # Solve for the trajectories\n",
- " t = np.linspace(0, max_time, int(250*max_time))\n",
- " x_t = np.asarray([integrate.odeint(lorenz_deriv, x0i, t)\n",
- " for x0i in x0])\n",
- " \n",
- " # choose a different color for each trajectory\n",
- " colors = plt.cm.viridis(np.linspace(0, 1, N))\n",
- "\n",
- " for i in range(N):\n",
- " x, y, z = x_t[i,:,:].T\n",
- " lines = ax.plot(x, y, z, '-', c=colors[i])\n",
- " plt.setp(lines, linewidth=2)\n",
- " angle = 104\n",
- " ax.view_init(30, angle)\n",
- " plt.show()\n",
- "\n",
- " return t, x_t\n",
- "w=interactive(solve_lorenz,sigma=(0.0,50.0),rho=(0.0,50.0))\n",
- "w"
- ]
- }
- ],
- "metadata": {
- "kernelspec": {
- "display_name": "Python 3 (ipykernel)",
- "language": "python",
- "name": "python3"
- },
- "language_info": {
- "codemirror_mode": {
- "name": "ipython",
- "version": 3
- },
- "file_extension": ".py",
- "mimetype": "text/x-python",
- "name": "python",
- "nbconvert_exporter": "python",
- "pygments_lexer": "ipython3",
- "version": "3.8.3"
- }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}
diff --git a/Uebung01/JupyterNotebook_Grundlagen.ipynb b/Uebung01/JupyterNotebook_Grundlagen.ipynb
new file mode 100644
index 0000000..407e042
--- /dev/null
+++ b/Uebung01/JupyterNotebook_Grundlagen.ipynb
@@ -0,0 +1,417 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "2686acb8-0a4f-4035-bf03-ba58c86eeb6b",
+ "metadata": {},
+ "source": [
+ "# **Einführung Jupyter-Notebooks**\n",
+ "Für die Übung *\"Digitale Werkzeuge\"* verwenden wir die Programmierumgebung *Jupyter-Notebooks*. Dieses Notebook bietet eine kurze Einführung in *Jupyter* und erklärt das Bedienungskonzept. Viele Inhalte werden auch in der Übung gezeigt. Falls du nur noch einmal schnell nachlesen willst, welche Taste was machst, kannst du auch direkt zur [Kurzrefrenz](#referenz) springen.\n",
+ "\n",
+ "Was du hier siehst ist deine private Kopie von unserem Notebook. Du kannst sie nach belieben verändern.\n",
+ "\n",
+ "Nach der Einführung in *Jupyter-Notebooks* gibt es noch zwei [Beispiele](#Aufgaben), die dir einen Eindruck der Möglichkeiten von Jupyter-Notebooks zeigen sollen. Wie sie genau funktionieren, ist an dieser Stelle noch nicht relevant. Am Ende des Dokumentes findest du noch einen Absatz über [technische Hintergründe](#weiterfuehrendes). Dieser Absatz ist für die kommenden Übungen nicht relevant, er soll dir nur einen Einstiegspunkt bieten, falls du genauer wissen möchtest, wie *Jupyter* und *Jupyter-Notebooks* funktioniert, oder wie du zu einer Kopie von unserem Notebook gekommen bist."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "3fba5bde-edf2-445d-962f-d9ac1ae87505",
+ "metadata": {},
+ "source": [
+ "## **Lernziele**\n",
+ "Im Verlauf der Übung wird *Jupyter-Notebooks* sowohl als Lehrmaterial als auch als Umgebung zur Bearbeitung der Übungsaufgaben genutzt. In diesem Dokument erklären wir euch, wie und wieso man *Jupyter-Notebooks* zum Programmieren in Python einsetzt. An Ende dieser Einheit sollst du:\n",
+ "\n",
+ "* Wissen wie ein Notebook aufgebaut ist\n",
+ "* Jupyter-Notebooks grundlegend bedienen können\n",
+ "\n",
+ "## **Vorkenntnisse**\n",
+ "* keine"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "59fffdd0-6428-471c-8dd6-ac7faf9cfef7",
+ "metadata": {
+ "tags": []
+ },
+ "source": [
+ "## **Was ist Jupyter und was ist Jupyter-Notebooks**\n",
+ "*Jupyter* ist ein Projekt, das eine Reihe von Tools rund um die Verwendung von Programmiersprachen als Webanwendung im Browser bereitstellt. Dabei wird Programmcode an einen Server geschickt, der ihn anschließend ausführt und die Ergebnisse in eine Form aufbereitet, die in einem Browser dargestellt werden kann. Auch die Beispiele in diesem Notebook werden nicht auf eurem PC ausgeführt, sondern auf einem Server des GITZ. Dadurch wird prinzipiell nur ein Browser benötigt. *Jupyter* bietet neben *Python* prinzipiell auch die Anbindung an weitere Programmiersprachen an, worauf wir im Verlauf der Übung allerdings nicht eingehen werden.\n",
+ "\n",
+ "*Jupyter-Notebooks* ist als Teil des *Jupyter* Projektes eine einfache Programmierumgebung als Browseranwendung, die auf sogenannten Notebooks basiert. Das Notebook erlaubt es strukturierten Text (Text, Bilder, Tabellen, Formeln, Inhaltsverzeichnis, etc.) mit Programmcode zu vermischen, diesen bei bedaruf auszuführen und die Ausgabe des Programmcodes gleich im Browser anzuzeigen. Das ist beispielsweise in diesem Notebook illustriert. \n",
+ "\n",
+ "Der Fokus von *Jupyter-Notebooks* liegt primär auf der interaktive Nutzung von *Python* (z.B. Datenanalyse und Visualisierung, oder auch interaktive Tutorials) und weniger auf der Programmierung klassischer Anwenderprogramme (obwohl prinzipiell beides möglich ist). Das ist so zu verstehen, dass *Jupyter-Notebooks* die Möglichkeit bietet, den Programmcode anzuschauen, zu verändern und direkt zu testen. Dadurch sind Notebooks oft so aufgebaut, das es vorgesehen ist, den Programmcode bei jeder verwendung anzupassen oder zu erweitern, wohingegen Anwenderprogramme normalerweise vom Anwender nicht modifiziert werden müssen, um zu funktionieren.\n",
+ "\n",
+ "Ein weiterer großer Vorteil von *Jupyter-Notebooks* ist, dass ihr es auch auf eurem PC installieren könnt, falls ihr nicht auf den Servern des GITZ arbeiten wollt. Das kann sinnvoll sein, wenn ihr zum Beispiel keine Internetverbindung habt, oder euch der Server zu langsam ist, oder ihr unabhängig der Übung selbst etwas programmieren wollt. Die Installation ist relativ einfach, im StudIP werden wir eine Anleitung bereitstellen. Damit erstellt ihr sozusagen die gleiche Umgebung wie auf dem Server des GITZ, nur eben viel kleiner und nur für die lokale Benutzung durch einen Benutzer gedacht."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0bbed02a-276b-4240-9948-f4c19c6bc854",
+ "metadata": {
+ "tags": []
+ },
+ "source": [
+ "\n",
+ "## **Wie benutzt man Jupyter-Notebooks**\n",
+ "### *Das Notebook*\n",
+ "Das Dokument, das ihr gerade lest, ist ein Notebook. Ein Vergleibares Bedienkonzept gibt es auch in anderen Programmierumgebungen (z.B. *Wolfram Mathematica*). Das Notebook ist eine Datei bzw. ein Dokument. Dieses Dokument ist in untereinanderliegende Zellen aufgeteilt. Jede Zelle hat einen Inhalt, der zusammengehört. Wenn du zum Beispiel mit der linken Maustaste einmal links neben diesen Text klickst, erscheint ein Rahmen. Das ist die Zelle, in der diese Text steht. Diese Zelle ist jetzt ausgewählt. Darüber und darunter befinden sich weitere Zellen.\n",
+ "\n",
+ "Es gibt drei wichtige Arten von Zellen in Jupyter-Notebooks, die sich in ihrer Funktionalität unterscheiden:\n",
+ "\n",
+ "* Textzellen: Eine Zelle wie diese, die formatierten Text enthält\n",
+ "* Codezelle: Eine Zelle, die Programmcode enthält, der ausgeführt werden kann\n",
+ "* Ergebniszelle: Enthält die Ausgaben, die beim Ausführen einer Codezelle entstehen\n",
+ "\n",
+ "Die Ergebniszellen werden automatisch beim Ausführen von Codezellen erstellt.\n",
+ "\n",
+ "Ein Notebook ist wie ein eigenes Programm, das du beim öffnen startest. Wenn du ein Notebook öffnest, wird im Hintergrund ein eigener *Python-Interpreter* für das Notebook gestartet. Der Interpreter wartet so lange, bis du eine Codezelle ausführst. Nach der Ausführung einer Zelle bleibt er an diesem Punkt stehen und wartet darauf, dass du die nächste Zelle ausführst. Wenn du das Notebook beendest, beendest du damit auch das laufende Programm bzw. den Python-Interpreter. Beim erneuten öffnen ist zwar der eingegebene Quellcode noch vorhanden, er wird aber nicht automatisch erneut ausgeführt. Da der Python-Interpreter neu gestartet wird ist der Zustand (wie z.B. bereits definierte Python-Varaiblen) nicht mehr vorhanden. Die Codezellen müssen erneut ausgeführt werden\n",
+ "\n",
+ "### *Der modale Editor*\n",
+ "Der Editor ist die Webanwendung, in der ihr dieses Notebook gerade betrachtet. Er dient zum Erstellen, Bearbeiten und Anschauen von Notebooks.\n",
+ "*Jupyter-Notebooks* ist ein sogenannter modaler Editor. Er kennt zwei Modi\n",
+ "\n",
+ "* Edit-Mode: zum Bearbeiten des Inhalts einer Zelle \n",
+ "* Command-Mode: zum verändern der Struktur des Dokumentes (z.B. einfügen neuer Zellen, umsortieren, etc.)\n",
+ "\n",
+ "Momentan befindest du dich im Command-Mode. Das erkennt ihr daran, dass der Balken links der markierten Zelle (sofern eine Zelle ausgewählt wurde) blau ist.\n",
+ "Direkt unter dieser Textzelle befindet sich eine Codezelle mit dem Inhalt \"3+5\". Wenn du mit der linken Maustauste auf die Zelle klickt, befindest du dich im Edit-Mode. Der Balken links neben der Zelle ist jetzt grün. Du kannst den Inhalt der Zelle beliebig verändern.\n",
+ "Um den *Edit-Mode* zu verlassen kannst du links neben die Zelle klicken, oder Esc drücken. Der Balken wird dann wieder Blau und du befindest dich wieder im Command-Mode\n",
+ "\n",
+ "Die Codezellen Erkennt man an den eckigen Klammern am linken Rand. Du kannst den Programmcode in einer Codezelle ausführen, indem du sie ausfwählst und Shift+Enter drückst oder alternativ das Play-Symbol am oberen Rand des Editors. In der eckigen Klammer erscheint dann eine Zahl. Diese Zahlen gibt an, Wie viele Zellen bereits ausgeführt wurden und damit einen Anhaltspunkt, in welcher Reihenfolge die Zellen ausgeführt wurden. Das kann wichtig sein, wie weiter unten beschrieben. Probier es einfach in der nächsten Codezelle aus. Damit hast du dein erstes Programm ausgeführt, auch wen dessen Ausgabe etwas vorhersehbar war. So lange der Programmcode in der Zelle ausgeführt wird, erscheint ein * zwischen den Klammern. Dieses Beispiel funktioniert so schnell, dass das *-Symbol nicht sichtbar ist. Die Codezelle unter dem \"3+5\" wartet 3 Sekunden. Dabei kannst du dieses Verhalten beobachten. Das * ist wie die Sanduhr bei anderen Programmen\n",
+ "\n",
+ "Eine letzte besonderheit bieten die Textzellen. Wenn du einmal auf eine Textzelle klickt, dann wird sie nur ausgewählt, du bleibst aber im Command-Mode. Mit einem Doppelklick kommst du in den Edit-Mode. Du siehst dann den Quelltext der Zelle (Die Auszeichnungssprache heißt [Markdown](https://de.wikipedia.org/wiki/Markdown \"Beschreibung von Markdown\"), die du vielleicht aus Internetforen o.ä. kennst). Wenn du den Editmode wieder verlässt, ist die Zelle weiterhin grau unterlegt und zeigt den Quelltext an. Mit Shift-Enter kannst du die Textzelle sozusagen ausführen. Das Ergebnis ist dann der formatierte Text, der nicht mehr grau hinterlegt ist."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "abcaec09-8492-4d8b-85f5-58d51bc64a56",
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [],
+ "source": [
+ "3+5"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "5757fb60-6aa1-45a5-92b9-33d5d5b00e80",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import time\n",
+ "print (\"Warte 3 Sekunden\")\n",
+ "time.sleep(3)\n",
+ "print (\"3 Sekunden sind um\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9220f43f-61e5-4cfb-b104-8526f1a8d86c",
+ "metadata": {},
+ "source": [
+ "### *Die Wichtigsten Kommandos des Editors als Kurzreferenz* <a name=\"referenz\"></a>\n",
+ "\n",
+ "#### *Bearbeitung des Notebooks*\n",
+ "Um in den Edit-Mode zu gelangen auf eine Zelle klicken (Bei formatiert angezeigten Textzellen doppelklick)\n",
+ "Um in den Command-Mode zu kommen Esc drücken oder links neben die Zelle klicken\n",
+ "\n",
+ "Im Command Mode (blauer Balken):\n",
+ "* y: Macht die aktuelle Zelle zur Code-Zelle\n",
+ "* m: Nacht die aktuelle Zelle zur Text-Zelle\n",
+ "* a: Fügt eine Zelle über der aktuellen Zelle ein\n",
+ "* b: Fügt eine Zelle unter der aktuellen Zelle ein\n",
+ "* d-d: Zweimal d drücken löscht die Zelle. Kann durch ctrl-z rückgängig gemacht werden, bzw über das Menü \"Edit->Undo Delete Cells\")\n",
+ "\n",
+ "Im Edit Mode (grüner Balken):\n",
+ "* Esc: Wechselt in den Command Mode\n",
+ "* tab : Autoverfollständigung (Funktioniert beim Programmieren in etwa so, wie die Autoverfollständigung von Worten auf eurem Handy)\n",
+ "\n",
+ "Ansonsten funktionieren die gängigen Tastenkombinationen wie ctrl-c, ctrl-x, ctrl-v und ctrl-z für Kopieren, Ausschneiden, Einfügen und Rückgängig machen\n",
+ "\n",
+ "* shift-enter: unabhängig vom Modus\n",
+ " * Codezelle: Der gesamte Programmcode in der Zelle wird ausgeführt\n",
+ " * Textzelle: Der Text wird formatiert angezeigt (und ist dann nicht mehr grau hinterlegt)\n",
+ "\n",
+ "\n",
+ "Alle Aktionen sind auch über das Menü am oberen Ende des Editors zugänglich\n",
+ "\n",
+ "Du kannst Änderungen am Notebook mit dem \"Speichern\" Symbol am oberen Rand des Editors speichern. Die Änderungen werden auch von Zeit zu Zeit automatisch gespeichert und sie werden gespeichert, wenn du das Notebook schließt.\n",
+ "\n",
+ "Mit dem Menüpunkt \"File\"->\"Rename\" kannst du Notebooks umbenennen\n",
+ "\n",
+ "#### *Interaktion mit dem Python Kernel*\n",
+ "Am oberen Rand des Editors sind 4 Symbole zur Interaktion mit dem im Hintergrund laufenden Python-Interpreter\n",
+ "* Play-Symbol (Dreieck) : Führt die aktuell markierte Zelle aus. Das gleiche wie das Tastenkürzel shift+enter\n",
+ "* Stop-Symbol (Viereck) : Bricht die Ausführung einer Zelle ab. Das kann praktisch sein, falls die Ausführung einer Zelle sehr lange dauert und du etwas ändern möchtest\n",
+ "* Replay-Symbol (Runder Pfeil) : Startet das Notebook (bzw. den Python-Interpreter) komplett neu. Selber effekt als wenn du es beendest und es neu startest\n",
+ "* Vorspul-Symbol (zwei Pfeile) : Startet das Notebook komplett neu und führt alle Zellen in der Dokumentenreihenfolge aus"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6ee072b1-ef73-40d8-9944-4882853d3357",
+ "metadata": {},
+ "source": [
+ "### **Jupyter Hub**\n",
+ "\n",
+ "Der *Jupyter Hub* ist eine Art simpler Dateiexplorer, in dem du deine Notebooks auf dem Server durchsuchen und öffnen kannst. Du erreichst ihn, indem du auf das Jupyter-Hub Symbol am oberen Ende des Editors klickst (du kannst ihn auch problemlos in einem neuen Browsertab öffnen), oder den Link <https://jupyter.rz.tu-bs.de/> öffnest. Du solltest im Hub einen Ordner für die Dokumente dieser Übung sehen und ggf. Notebooks, die du selbst angelegt hast.\n",
+ "\n",
+ "Wenn du auf ein Notebook in der Liste klickst, öffnet sich der Editor. Du kannst Problemlos mehrere Notebooks in mehreren Browsertabs öffnen. Die einzelnen Notebooks laufen komplett unabhängig voneinander und beeinflussen sich nicht gegenseitig. Jedes Notebook kann allerdings nur einmal gestartet werden.\n",
+ "\n",
+ "Mit der Schaltfläche \"New\" kannst du ein neues Notebook erstellen. Das neu erstellte Notebook heißt immer \"Untitled\". Du kannst ihm im Editor einen neuen Namen geben.\n",
+ "\n",
+ "Die Notebooks und ihr Python-Interpreter werden übrigends nicht beendet, wenn du ausversehen den Browsertab des Notebooks schließt. Sie laufen weiter, bis du sie im Editor mit dem Menüpunkt \"File\"->\"Close and Halt\" beendest. Geöffnete Notebooks werden auf dem GITZ-Server allerdings nach einiger Zeit der Inaktivität automatisch beendet. Noch geöffnete Notebooks werden im Jupyter Hub mit einem grünen Symbol dargestellt (evtl. Aktualisieren drücken). Wenn du das Notebook öffnest ist es noch in dem Zustand, wie du es verlassen hast"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "feb4741a-faa6-4438-974f-77f1b66d43f6",
+ "metadata": {},
+ "source": [
+ "## **Ein paar Besonderheiten der Notebooks**\n",
+ "Das Notebook-Konzept von Jupyter hat einige Besonderheiten, die man im Hinterkopf behalten sollte!\n",
+ "Jedes Notebook stellt ein Programm für sich dar. Mehrere Notebooks die gleichzeitig laufen beeinflussen sich nicht. Allerdings kann jedes Notebook nur einmal geöffnet sein. Du solltest es vermeiden ein Notebook in mehreren Browsertabs anzuzeigen, da das zu Problemen führen kann.\n",
+ "\n",
+ "Der Code in den Zellen wird nie automatisch ausgeführt, sondern erst, wenn shift-enter bzw. der entsprechende Knopf im Menü gedrückt wird. Das gilt sowohl wenn ein Notebook geöffnet wird, als auch wenn der Programmcode modifiziert wird. Veränderst du den Inhalt einer Codezelle musst du sie erst erneut ausführen, damit die Änderungen auch im *Python-Interpreter* ankommen.\n",
+ "\n",
+ "Das Notebook behält seinen aktuellen Zustand, solange es geöffnet bleibt, da der *Python-Interpreter* im Hintergrund auch geöffnet bleibt. Das Ausführung des Notebooks kann unter dem Menüpunkt \"File\"->\"Close and Halt\" beendet werden. Das Programm, das du mit deinem Codezellen ausführst, läuft also auch immer weiter und sind nicht in sich abgeschlossen. Daher ist auch die Reihenfolge, in der du die Codezellen ausführst nicht immer unerheblich. Die nächsten zwei Zellen sollen das verdeutlichen. Das Prinzip ist hoffentlich auch ohne Programmierkentnisse halbwegs verständlich, bzw. wird im weiteren Verlauf der Übungen verständlich."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "f0fd320a-ff4f-441f-bdec-00ff957735fc",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x=7 #Erzeugt eine Variable mit dem Namen x, in der der Wert 7 gespeichert wird\n",
+ "print(x) #gibt den Wert der Variable x aus"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "9660af8f-2afc-43c1-9cd8-726b8236217d",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "print(x) #gibt den Wert der Variable x aus\n",
+ "del(x) #löscht die Variable x"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a51bafa2-46c5-403d-ad1f-cc092acd07f1",
+ "metadata": {},
+ "source": [
+ "Die erste Zelle erzeugt eine Variable mit dem Namen x, in der der Wert 7 gespeichert wird. Anschließend wird der Wert von x ausgegebe. Die zweite Zelle gibt den Wert von x noch einmal aus und löscht die Variable anschließend. Das ist möglich, da das Notebook, bzw. der *Python-Interpreter* zum Notebook, nach Ausführen einer Zelle nicht beendet wird. Eine Zelle findet den Zustand also so vor, wie ihn die letzte ausgeführte Zelle hinterlassen hat. Versucht man jetzt die zweite Zelle erneut auszuführen, oder führt man die zweite Zelle vor der ersten Zelle aus, dann gibt es einen Fehler, da die Variable in keinem der beiden Fälle bekannt ist (sie wurde ja gelöscht). D.h. die Reihenfolge, in der die Zellen ausgeführt werden ist nicht egal und entspricht nicht zwingend der Reihenfolge im Notebook! Sollte das Notebook nach dem Ausführen der Ersten Zelle beendet oder neu gestartet werden (siehe oben), kann die zweite Zelle auch nicht funktionieren, da der Zustand des Notebooks mit dem Beenden verloren geht. Die erste Zelle muss erneut ausgeführt werden.\n",
+ "\n",
+ "Du kannst über das Menü im Editor die Zellen nach oben und unten schieben. Es ist oft eine gute Idee, die Code-Zellen in eine Reihenfolge zu bringen, in der sie auch ausführbar sind!"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "558d9f97-6c85-455a-b95e-c75e397eec80",
+ "metadata": {},
+ "source": [
+ "# *Ergebniszellen*\n",
+ "Die Nächste Zelle enthält Programmcode, der eine zufällige Zahl ausgibt. Unter der Zelle siehst du bereits ein Ergebnis (0.827...) und in der Eckigen Klammer eine Zahl (die 36). Das Ergebnis wurde nicht beim öffnen des Notebooks erstellt, sondern ist das Ergebnis, das ich beim erstellen dieses Notebooks erhalten habe. Der Inhalt der Ausgabezellen wird standardmäßig mit dem Notebook gespeichert, sozusagen als Vorschau. Außerdem die Reihenfolge, in der die Zellen zuletzt ausgeführt wurden. Das kann praktisch sein, um die Verwendung eines komplexeren Notebooks zu verstehen, kann aber auch verwirrend sein, da unter Umständen nicht zu erkennen ist, ob eine Zelle bereits ausgeführt wurde, oder ob nur das Ergebnis mit dem Notebook gespeichert wurde. Du kannst alle Ausgabezellen über das Menü \"Cell\"->\"All Output\"->\"Clear\" löschen.\n",
+ "\n",
+ "Wenn du die foglende Zelle ausführst, erhälst du jedesmal ein neues, zufälliges Ergebnis.\n",
+ "\n",
+ "Wenn du die Codezellen in diesem Dokument ausführst und dir die Ergebniszellen genau anschaust wirst du entdecken, dass manche Ausgabezellen links eine eckige Klammer mit der gleichen Zahl wie die zugehörige Codezelle haben. Andere nicht. Das ist kein Zufall und wir werden später in den Übungen noch darauf eingehen. Es hat allerdings nichts damit zu tun, ob die Ergebniszellen noch im Notebook gespeichert waren, oder ob sie bei dieser Ausführung berechnet wurden."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 36,
+ "id": "dd3c833d-d0b9-40d8-9b49-b6b25d9b3675",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "0.8279804860782948"
+ ]
+ },
+ "execution_count": 36,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from random import*\n",
+ "random()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d4a8a8af-2871-4148-9ee4-a9dcae61512a",
+ "metadata": {},
+ "source": [
+ "## **Aufgaben** <a name=\"Aufgaben\"> </a>\n",
+ "* Probiere aus Zellen einzufügen, Zellen zu löschen und zu editieren. Du befindest dich gerade in deiner eigenen, privaten Kopie unseres Dokuments und kannst damit machen, was du willst\n",
+ "* Da es in diesem Notebook noch nicht um das Programmieren an sich geht, ist es ein bisschen langweilig. Deswegen kannst du dir einige Möglichkeiten von *Jupyter-Notebooks* in den nächsten zwei Codezellen anschauen. Führe sie einfach aus und schaue dir das Ergebnis an. An diesem Punkt der Übung kannst du vermutlich nicht nachvollziehen, wie das Programm funktioniert, aber wir kommen auf das Beispiel vielleicht in späteren Übungen noch einmal zurück\n",
+ "\n",
+ "Was du als Ergbebnis siehst, ist ein [Lorenz-Attraktor](https://de.wikipedia.org/wiki/Lorenz-Attraktor). Das ist anschaulich beschrieben der Weg (also die Trajektorien) von Partikeln, die sich mit der Konvektionsströmung einer Flüssigkeit zwischen einer warmen und einer kalten Platte bewegt (natürlich in einer stark vereinfachten physikalischen Modellierung).\n",
+ "Das erste Beispiel ist eine statische Darstellung, beim zweiten Beispiel kannst du die Parameter der zugrundeliegenden Differentialgleichung interaktiv mit den Reglern anpassen."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "9a7785ba-ace4-4675-a211-be73f22f0553",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import numpy as np\n",
+ "from scipy.integrate import solve_ivp\n",
+ "import matplotlib.pyplot as plt\n",
+ "\n",
+ "WIDTH, HEIGHT, DPI = 1000, 750, 100\n",
+ "\n",
+ "# Lorenz paramters and initial conditions.\n",
+ "sigma, beta, rho = 10, 2.667, 28\n",
+ "u0, v0, w0 = 0, 1, 1.05\n",
+ "\n",
+ "# Maximum time point and total number of time points.\n",
+ "tmax, n = 100, 10000\n",
+ "\n",
+ "def lorenz(t, X, sigma, beta, rho):\n",
+ " \"\"\"The Lorenz equations.\"\"\"\n",
+ " u, v, w = X\n",
+ " up = -sigma*(u - v)\n",
+ " vp = rho*u - v - u*w\n",
+ " wp = -beta*w + u*v\n",
+ " return up, vp, wp\n",
+ "\n",
+ "# Integrate the Lorenz equations.\n",
+ "soln = solve_ivp(lorenz, (0, tmax), (u0, v0, w0), args=(sigma, beta, rho),\n",
+ " dense_output=True)\n",
+ "# Interpolate solution onto the time grid, t.\n",
+ "t = np.linspace(0, tmax, n)\n",
+ "x, y, z = soln.sol(t)\n",
+ "\n",
+ "# Plot the Lorenz attractor using a Matplotlib 3D projection.\n",
+ "fig = plt.figure(facecolor='k', figsize=(WIDTH/DPI, HEIGHT/DPI))\n",
+ "ax = fig.gca(projection='3d')\n",
+ "ax.set_facecolor('k')\n",
+ "fig.subplots_adjust(left=0, right=1, bottom=0, top=1)\n",
+ "\n",
+ "# Make the line multi-coloured by plotting it in segments of length s which\n",
+ "# change in colour across the whole time series.\n",
+ "s = 10\n",
+ "cmap = plt.cm.winter\n",
+ "for i in range(0,n-s,s):\n",
+ " ax.plot(x[i:i+s+1], y[i:i+s+1], z[i:i+s+1], color=cmap(i/n), alpha=0.4)\n",
+ "\n",
+ "# Remove all the axis clutter, leaving just the curve.\n",
+ "ax.set_axis_off()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "5d5375e8-66e2-4acb-ba3c-963e846fe7d8",
+ "metadata": {
+ "tags": []
+ },
+ "outputs": [],
+ "source": [
+ "import numpy as np\n",
+ "from matplotlib import pyplot as plt\n",
+ "from scipy import integrate\n",
+ "\n",
+ "from ipywidgets import interactive, fixed\n",
+ "def solve_lorenz(sigma=10.0, beta=8./3, rho=28.0):\n",
+ " \"\"\"Plot a solution to the Lorenz differential equations.\"\"\"\n",
+ "\n",
+ " max_time = 4.0\n",
+ " N = 30\n",
+ "\n",
+ " fig = plt.figure(1)\n",
+ " ax = fig.add_axes([0, 0, 1, 1], projection='3d')\n",
+ " ax.axis('off')\n",
+ "\n",
+ " # prepare the axes limits\n",
+ " ax.set_xlim((-25, 25))\n",
+ " ax.set_ylim((-35, 35))\n",
+ " ax.set_zlim((5, 55))\n",
+ " \n",
+ " def lorenz_deriv(x_y_z, t0, sigma=sigma, beta=beta, rho=rho):\n",
+ " \"\"\"Compute the time-derivative of a Lorenz system.\"\"\"\n",
+ " x, y, z = x_y_z\n",
+ " return [sigma * (y - x), x * (rho - z) - y, x * y - beta * z]\n",
+ "\n",
+ " # Choose random starting points, uniformly distributed from -15 to 15\n",
+ " np.random.seed(1)\n",
+ " x0 = -15 + 30 * np.random.random((N, 3))\n",
+ "\n",
+ " # Solve for the trajectories\n",
+ " t = np.linspace(0, max_time, int(250*max_time))\n",
+ " x_t = np.asarray([integrate.odeint(lorenz_deriv, x0i, t)\n",
+ " for x0i in x0])\n",
+ " \n",
+ " # choose a different color for each trajectory\n",
+ " colors = plt.cm.viridis(np.linspace(0, 1, N))\n",
+ "\n",
+ " for i in range(N):\n",
+ " x, y, z = x_t[i,:,:].T\n",
+ " lines = ax.plot(x, y, z, '-', c=colors[i])\n",
+ " plt.setp(lines, linewidth=2)\n",
+ " angle = 104\n",
+ " ax.view_init(30, angle)\n",
+ " plt.show()\n",
+ "\n",
+ " return t, x_t\n",
+ "w=interactive(solve_lorenz,sigma=(0.0,50.0),beta=(-2.7,8),rho=(0.0,50.0))\n",
+ "w"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fdd41b5a-036f-4023-b37f-8453b797a11d",
+ "metadata": {},
+ "source": [
+ "## **Technische Hintergründe und weiterführendes** <a name=\"weiterfuehrendes\"></a>\n",
+ "Hier ein paar weitere technische Hintergründe zu [Jupyter](https://jupyter.org/), Jupyter-Notebooks und der bereitstellung dieser Übung, falls sie dich interessieren\n",
+ "### *Jupyter und Jupyter-Notebooks*\n",
+ "#### *Jupyter-Notebooks*\n",
+ "Jupyter-Notebooks ist eine Webanwendung, die auf Jupyter basiert. Es ist der Notebook-Editor den du im Browser verwenden kannst. Dabei liegt der Fokus auf dem interaktiven Arbeiten mit Programmiersprachen. Es gibt neben Jupyter-Notebooks noch weiterer solcher Schnitstellen. Z.B. Jupyter-Lab (Eine modernisierte Version von Notebooks), Jupyter-Books (Ein Werkzeug um statische Webinhalte zu erstellen, bei denen z.B. Diagramme bei der Erstellung durch Programmcode erzeugt werden) oder Jupyter-flex (ein Werkzeug um interaktive Dashboards zu erstellen. Ähnlich den Notebooks, nur dass der Benutzer den Quellcode nicht sehen oder verändern kann um die ausführung beliebigen Programmcodes auf dem Server zu verhindern). Alle diese Webanwendungen interagieren im Hintergrund mit einem Jupyter-Server um den in ihnen enthaltenen Programmcode auszuführen. \n",
+ "\n",
+ "\n",
+ "#### *Jupyter*\n",
+ "Jupyter oder Jupyter-Server ist das Backend für alle Jupyter Webanwendungen. Der Serber bietet dabei eine Schnittstelle um verschiedene Programmiersprachen (z.B. Python) anzubinden. Die Anbindung an eine Programmiersprache wird bei Jupyter als Kernel bezeichnet, somit übernimmt der Python-Kernel die Anbindung an Python. Jupyter kann solche Kernel starten und bietet Protokolle, mit denen die Webapplikationen Quellcode an den Kernel schicken können. Der Python-Interpreter ist der selbe, den du auch auf deinem PC starten kannst. Da Python an sich einen interaktiven Modus besitzt ist die Anbindung relativ einfach. Bei anderen Programmiersprachen kann dieser Aspekt deutlich komplizierter werden.\n",
+ "Auf der anderen Seite nimmt der Python-Kernel Programmausgaben entgegen und stellt sie über den Jupyter-Server den Webanwendungen bereit. Dies gescheiht in einer Form, die für die Ausgabe in einem Webbrowser vorgesehen ist. Dieser Teil ist im Fall von simplem Text noch einfach, aber in den Beispielen oben siehst du Bilder und sogar ein interaktives Diagramm, das bei Veränderung der Regler neu berechnet wird. Diese Art von Integration ist deutlich komplizierter, für den Fall von Python aber sehr weit entwickelt. Das Python-Packet, dass zur grafischen Darstellung verwendet wurde heißt matplotlib und du wirst es im Laufe der Übungen noch kennen lernen. Das die gezeichneten Bilder im Browser ankommen, funktioniert nicht automatisch. Matplotlib kann Diagramme auf verschiedene Arten anzeigen. Z.B. kann es die Bilder in Dateien speichern, oder in einem Fenster anzeigen, oder auch an Jupyter senden. Es wurde also speziell mit einer Integration für Jupyter entwickelt. Das ist nicht selbstverständlich. Um komplexere Ergebnisse über Jupyter anschauen zu können, müssen auch die Pakete, die diese Ergebnisse liefern, dafür vorgesehen sein. Das Jupyter-Notebooks viel im Zusammenhang mit Python und Datenanalyse verwendet wird, bieten die meißten einschlägigen Pakete eine gute Integration.\n",
+ "\n",
+ "### *Bereitstellung der Ãœbungsaufgaben*\n",
+ "Die Übungsaufgaben werden von uns über eine Quellcodeverwaltungssoftware bereitgestellt, die sich [Git](https://git-scm.com/) nennt. Die ist eigentlich dafür vorgesehen, dass mehrere Personen an Programmen arbeiten können und sich ihre Änderungen gegenseitig bereitstellen können. Git wird in sehr vielen großen Software-Projekten verwendet (z.B. dem Linux-Kernel). Wenn du dich später einmal eingehender mit Programmierung beschäftigen solltest, wirst du auch dieses Tool fast zwangsweise kennenlernen. Wenn du auf den von uns generierten Link zur Übung klickst, wird die entsprechende Datei automatisch aus unserem Repository heruntergeladen und in deinem privaten Verzeichnis auf dem GITZ-Server gespeichert. Anschließend wird das Notebook auf dem Server geöffnet. So kannst du mit einem Link automatisch das Notebook auf den Server herunterladen und ausführen. Anschließend kannst du die Datei daher auch in deinem Jupyter-Hub sehen. Da genau dieses Verhalten oft gewünscht ist bietet Jupyter diese Option von sich aus an. Das Tool was das übernimmt heißt nbgitpuller.\n"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.10.5"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/Uebung01/Python_Grundlagen.ipynb b/Uebung01/Python_Grundlagen.ipynb
new file mode 100644
index 0000000..c77f803
--- /dev/null
+++ b/Uebung01/Python_Grundlagen.ipynb
@@ -0,0 +1,1104 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "7c04a295-5911-4631-bc24-6dc2975f2a35",
+ "metadata": {},
+ "source": [
+ "# <font color='blue'>**Einleitendes Thema**</font>\n",
+ "Python ist eine Programmiersprache, die unter anderem in den Ingenieurswissenschaften weite Verbreitung gefunden hat. Python besitzt einen eingebauten Packetmanager, mit dem Zusatzfunktionalität schnell und einfach installiert werden kann. Z.B. Funktionen zum Auslesen oder Erstellen von Excel-Datein, Anbindun an verschiedene Datenbanksysteme oder Programmbibliotheken zur grafischen Ausgabe. Zum einen können in Python klassische Anwendungen programmiert werden, Python bietet allerdings auch einen interaktiven Modus. Dieser eignet sich sehr gut für Datenanalyse oder das Erstellen von Diagrammen aus verschiedenen Datenquellen.\n",
+ "Python besitzt eine Syntax, die vergleichsweise gut von Menschen lesbar ist und eine strukturierte Darstellung des Quelltextes erzwingen soll. So ist in Python z.B. eine Zeile ein zusammenhängender Ausdruck der mit der Zeile endet, sodass nicht mehrere Programmzeilen in eine Textzeile geschreiben werden können. Zusammenhängende Zeilen bzw. Code-Blöcke werden durch Einrückung der Zeilen mit Leerzeichen definiert.\n",
+ "Python selbst ist ursprünglich eine Scriptsprache, d.h. das Programm wird als Quelltext verteilt und der Benutzer des Programms benötigt einen sogenannten Python-Interpreter, um es auf seinem Computer laufen zu lassen. Das führt dazu, dass Python-Programme relativ unabhängig vom verwendeten Betriebssystem oder der verwendeten Computerarchitektur funktionieren, so lange ein Python-Interpreter für das Zielsystem existiert. Python selbst bietet viel Funktionalität um Programme zu schreiben, die unanhängig des verwendeten Betriebssystems funktioniern. Ob diese benutzt werden liegt allerdings auch beim Programmierer.\n",
+ "Mit Python lassen sich auch Programmteile steuern, die in anderen Programmiersprachen geschrieben wurden. Da Python-Programme selbst relativ langsam sind, ist diese Möglichkeit für eine Verwendung im wissenschaftlichen Rahmen sehr wichtig, da oft große Datenmengen bearbeitet werden."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "4356c612-2040-4567-8d97-b11bcc16d234",
+ "metadata": {},
+ "source": [
+ "# <font color='blue'>**Ãœbersicht - Python Grundlagen**</font>\n",
+ "Das folgende Notebook beschreibt einige Grundlagen der Programmiersprache Python, die für die erste Übung benötigt werden. Es ist eine Art mini-Referenz von den bereits verwendeten Teilen der Programmiersprache. Im laufe der ersten paar Übungen werden wir die einzelnen Abschnitte des Dokuments noch etwas erweitern, sodass es zum Schluss eine Referenz der strukturierten Programmierung in Python darstellt, die alle in den Übungen enthaltenen Aspekte der Programmiersprache enthält. Unter den einzelnen Abschnitten findest du einige Dinge etwas detaillierter beschrieben, als in den Übungen besprochen. Insgesammt sind allerdings alle Themen kurz gehalten. Das Dokument soll nicht als Eratz zur Übung dienen, sondern als Nachschlagewerk für die Bearbeitung der Aufgaben."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9c407ee4-f407-4c18-ab8b-dfbbea4a8680",
+ "metadata": {
+ "tags": []
+ },
+ "source": [
+ "### <font color='blue'>*Lernziele des Notebooks*</font>\n",
+ "Das Notebook ist in mehrere thematische Abschnitte gegliedert.\n",
+ "\n",
+ "* [Syntax](#Syntax)\n",
+ "* [Literale](#Literale)\n",
+ "* [Variablen](#Variablen)\n",
+ "* [Wichtige Funktionen](#Funktionen)\n",
+ "* [Operatoren](#Operatoren)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1a43032b-9076-4f88-92cc-98ddb86cfa76",
+ "metadata": {},
+ "source": [
+ "# <font color='blue'> **Syntax** </font> <a name=\"Syntax\"> </a>\n",
+ "## <font color='blue'>*Kommentare*</font>\n",
+ "Es ist möglich, den Quelltext direkt zu kommentieren. Kommentare dienen nur der Nachvollziebarkeit des Quelltextes und werden vom Python-Interpreter ignoriert.\n",
+ "Es gibt es zwei Möglichkeiten Kommentare zu schreiben, die beide in der nächsten Code-Zelle dargestellt sind. Mit einem #-Zeichen, wird der Rest der Zeile zum Kommentar. Der Kommentar endet also mit dem nächsten Zeilenumbruch. Um mehrzeilige Kommentare zu schreiben, kann ein dreifaches Anführungszeichen am Anfang einer Zeile verwendet werden. Der Kommentar endet durch drei weitere Anführungszeichen. Ein mehrzeiliger Kommentar muss innerhalb der selben Code-Zelle beendet werden, in der er beginnt, ansonsten wird ein Fehler ausgelöst\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 144,
+ "id": "25992d88-dc99-461e-a987-cd611ff70c04",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "5\n"
+ ]
+ }
+ ],
+ "source": [
+ "x=3+2 #das hier ist ein Kommentar.\n",
+ "#eine ganze Zeile als Kommentar\n",
+ "\"\"\"\n",
+ "das ist ein \n",
+ "mehrzeiliger Kommentar. Er kann sich über beliebig\n",
+ "viele Zeilen der Zelle erstrecken\n",
+ "\"\"\"\n",
+ "print(x)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1448301e-51b6-4e3d-934f-248d2a0934c7",
+ "metadata": {},
+ "source": [
+ "## <font color='blue'>*Reihenfolge der Auswertungen in einer Zeile*\n",
+ "Wenn mehrere Operatoren in einer Zeile stehen, bzw. mehrere Funktionen ausgewertet werden müssen, kann die Reihenfolge in der das passiert wichtig werden. Operatoren folgen den Punkt vor Strich Rechenregeln. Trotzdem kann die Reihenfolge manchmal sehr schwer nachvollziebar sein. Es ist daher möglich, wie in mathematischer Schreibweise, runde Klammern einzusetzen, um die Auswertereihenfolge festzulegen"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 145,
+ "id": "ec2c445f-2763-4608-bda0-33e044f900e7",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "39\n",
+ "63\n"
+ ]
+ }
+ ],
+ "source": [
+ "x=4+5*7\n",
+ "y=(4+5)*7\n",
+ "print (x)\n",
+ "print (y)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "4c49646f-9210-4860-9605-8dfc4f7c59a0",
+ "metadata": {},
+ "source": [
+ "## <font color='blue'>*Zeilenumbrüche*\n",
+ "\n",
+ "Ein \"Ausdruck\" in Python ist normalerweise eine Zeile im Quelltext"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 44,
+ "id": "640fc218-ed8a-4f24-8e1d-c9a2898559d0",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "14\n"
+ ]
+ }
+ ],
+ "source": [
+ "x=3+4+7\n",
+ "print (x)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "22ed06fe-2e87-448f-bb6c-7f592c1fee65",
+ "metadata": {},
+ "source": [
+ "Sollte es passieren, dass eine Zeile zu lang wird und aus optischen Gründen auf mehrere Zeilen aufeteilt werden soll, kann mit einem \\ am Ende der Zeile der folgende Zeilenumbruch ignoriert werden, er existiert für den Python-Interpreter nicht. Das \\\\-Zeichen muss am Ende der Zeile stehen."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 137,
+ "id": "12a585f2-7dcf-49e9-af78-6684cf5e6049",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "14\n"
+ ]
+ }
+ ],
+ "source": [
+ "x=3+4+\\\n",
+ " 7 #Die nächste Zeile darf eingerückt werden, muss aber nicht. Es sieht allerdings besser aus\n",
+ "print (x)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2f0b7f16-d7b0-46b2-951a-227763a91d8b",
+ "metadata": {},
+ "source": [
+ "# <font color='blue'>**Literale**</font> <a name=\"Literale\"> </a>\n",
+ "\n",
+ "Literale sind feststehende Werte, die in den Programmcode eingebaut werden können. Z.B. Zahlen oder Texte. Sie können verwendet werden, um Variablen einen initialen Wert zu geben oder Textabschnitte zu definieren, die im Rahmen der Benutzerinteraktion vom Programm ausgegeben werden. Mit Literalen können diese Werte in einer für den Programmierer praktischen Formatierung eingegeben werden. Gerade bei numerischen Literalen gibt es daher verschiedene Möglichkeiten eine Zahl zu schreiben, die in unterschiedlichen Szenarien sinnvoll werden können. Literale, bzw. die Werte die sie beschreiben, haben, wie auch Variablen, einen Typ. Literale sind unveränderbare (bzw. konstante) Werte. Das heißt, sie können niemals auf der linken Seite einer Zuweisung stehen.\n",
+ "Einige Beispiele:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 138,
+ "id": "af634aba-0393-4480-9905-9b05d23ab8a9",
+ "metadata": {},
+ "outputs": [
+ {
+ "ename": "SyntaxError",
+ "evalue": "cannot assign to literal (1432500936.py, line 9)",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[1;36m Cell \u001b[1;32mIn [138], line 9\u001b[1;36m\u001b[0m\n\u001b[1;33m 3=x ##Funktioniert nicht. Ein Literal darf nicht auf der linken Seite einer Zuweisung stehen\u001b[0m\n\u001b[1;37m ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m cannot assign to literal\n"
+ ]
+ }
+ ],
+ "source": [
+ "3 #Eine ganze Zahl\n",
+ "7e9 #Eine Fließkommazahö\n",
+ "5.234 #Eine Fließkommazahl\n",
+ "0b1001010 #Eine ganze Zahl in binärer Schreibweise\n",
+ "0o2347 #Eine ganze Zahl in oktaler Schreibweise\n",
+ "0xAF #Eine ganze Zahl in hexadezimaler Schreibweise\n",
+ "\"Ich bin eine Zeichenkette\"\n",
+ "(2+4j) #Eine komplexe Zahl\n",
+ "3=x ##Funktioniert nicht. Ein Literal darf nicht auf der linken Seite einer Zuweisung stehen"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1afdb19b-0b12-4aed-b642-5d8cd7317260",
+ "metadata": {},
+ "source": [
+ "## <font color='blue'>*Numerische Literale*</font>\n",
+ "\n",
+ "Es gibt drei Arten von numerischen Literalen in Python:\n",
+ "\n",
+ "* Fließkommawerte\n",
+ "* ganzzahlige Werte\n",
+ "* imaginäre Werte\n",
+ "\n",
+ "\n",
+ "Bei allen numerischen Literalen ist ein führendes \"-\"-Zeichen für eine negative Zahl zulässig. Bei genauer Betrachtung ist das Minus jedoch nicht Teil des Literals, siehe Abschnitt Operatoren.\n",
+ "\n",
+ "### *Fließkommawerte*\n",
+ "\n",
+ "Fliekommawerte beschreiben eine Zahl mit Nachkommastellen. Fließkommazahlen besitzen in Python den Typ 'float'. Die Nachkommastellen dürfen auch alle 0 sein, womit der Wert technisch gesehen eine Ganzzahl ist. Die Unterscheidung bei Computern liegt allerdings nicht nur im Vorhandensein von Nachkommastellen, sondern auch in der Arithmetik und dem möglichen Wertebereich, der sich von Ganzzahlen unterscheidet. Wie groß oder klein eine Fließkommazahl ist, hängt auch vom Verwendeten Prozessor ab. Normalerweise liegt der gültige Bereich zwischen plus und minus 10 hoch 308.\n",
+ "\n",
+ "Fließkommazahlen werden in Python als Kommazalen in englischer Notation (mit \".\" als Komma) eingegeben."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "9a30ddf4-cc88-403f-8cf7-ba18dbf69d3f",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x=3.5434 #ein Beispiel für eine Kommazahl\n",
+ "y=-2.4 #eine negative Zahl kann mit einem führenden Minus angegeben werden"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cad863d6-84f2-4b62-83f0-6805d83a23ef",
+ "metadata": {},
+ "source": [
+ "#### Einige praktische Hinweise\n",
+ "Falls die Zahl mit einer 0 vor dem Komma beginnt, kann die 0 optional weggelassen werden. Gleiches gilt, für die 0 nach dem Komma, falls alle Nachkommastellen 0 sind. Außerdem kann am Ende der Zahl optional ein \"e\" gefolgt von einer ganzen Zahl angegeben werden. Die Zahl wird als Exponent zur Basis 10 interpretiert (ein e3 nimmt die eingegebene Zahl mal 10 hoch 3. Das \"e\" kann dabei groß oder klein geschrieben werden).\n",
+ "\n",
+ "Es ist zulässig Unterstriche \"_\" an beliebigen Stellen der Zahl zu verwenden, um Ziffern zu gruppieren. Die Unterstriche werden bei der Interpretation ignoriert. Sie dienen nur dem Programmierer, um z.B. Zahlen mit vielen aufeinanderfolgenden identischen Ziffern besser lesbar zu machen"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 139,
+ "id": "4b84c21c-3065-4aba-a69a-f77fdfb6e038",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "0.43\n",
+ "32000.0\n",
+ "0.00032\n",
+ "1.000000001\n",
+ "3.0\n"
+ ]
+ }
+ ],
+ "source": [
+ "x=.43 #führende Nullen können optional weggelassen werden ist identisch mit x=0.43\n",
+ "y=3.2e4 #Hat als Ergebnis 3.2*10**4\n",
+ "z=3.2E-4 #Das funktioniert auch mit negativen Zahlen. Das e darf wahlweise groß oder klein geschrieben werden\n",
+ "a=1.000_000_001 #Unterstriche können zur besseren Darstellung für den Programmierer verwendet werden, um Ziffern zu gruppieren. Sie werden ignoriert\n",
+ "b=3. #eine 0 nach dem Komma kann weggelassen werden\n",
+ "print(x)\n",
+ "print(y)\n",
+ "print(z)\n",
+ "print(a)\n",
+ "print(b)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "edca5fcc-10a6-475c-afa4-6fa165b5bf9c",
+ "metadata": {},
+ "source": [
+ "Eine Besonderheit der Notation mit dem \"E\" als Zehnerpotenz ist, dass der resultierende Wert immer als Fließkommazahl interpretiert wird, auch wenn er keine Nachkommastellen besitzt"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "id": "cf98f7e0-b393-4104-a0f7-f5faca365f86",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "<class 'float'>\n"
+ ]
+ }
+ ],
+ "source": [
+ "x=3e5#Wird als Fließkommazahl interpretiert\n",
+ "print(type(x))# gibt den Typ von x aus"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b44b3fe4-7146-4d79-8a53-3ea903000cb5",
+ "metadata": {},
+ "source": [
+ "### *Ganze Zahlen*"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c3a6fa24-f6a2-44f2-b209-7a9827f7f13d",
+ "metadata": {},
+ "source": [
+ "Für die Eingabe von ganzen Zahlen gibt es mehrere Möglichkeiten. Der Wertebereich der ganzen Zahlen in Python ist unbegrenzt, ihr Typ heißt 'int' (Kurzform von Integer). Die einfachste Möglichkeit ist, die Zahl einfach im Dezimalsystem einzugeben. Auch hier dürfen \"_\" Zeichen zur Zahlengruppierung eingesetzt werden, die vom Python-Interpreter ignoriert werden. Führende Nullen, also die Zahl 15 als 015 zu schreiben, ist nicht zulässig!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "id": "30f6e8d0-907c-4ba1-bdcd-c4969634ecd9",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x=1032454 #Einge ganze Zahl\n",
+ "y=-223_322_023_000 #Eine negative Zahl. Zur besseren Lesbarkeit des Quelltextes in 3er Gruppen gruppiert\n",
+ "z=0 #Die Null ist in Ordnung"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "id": "8d9e9c64-acd5-499c-b4a9-d64a910ff137",
+ "metadata": {},
+ "outputs": [
+ {
+ "ename": "SyntaxError",
+ "evalue": "leading zeros in decimal integer literals are not permitted; use an 0o prefix for octal integers (1519621152.py, line 1)",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[1;36m Cell \u001b[1;32mIn [15], line 1\u001b[1;36m\u001b[0m\n\u001b[1;33m a=010\u001b[0m\n\u001b[1;37m ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m leading zeros in decimal integer literals are not permitted; use an 0o prefix for octal integers\n"
+ ]
+ }
+ ],
+ "source": [
+ "a=010 #Diese Zelle löst einen Fehler aus"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a7cd09f0-0438-4d43-8acf-af5386ed22e2",
+ "metadata": {},
+ "source": [
+ "#### Eingaben in anderen Zahlensystemen\n",
+ "Neben Eingaben im Dezimalsystem sind auch Zahleneingaben im binärsystem (mit den Ziffern 0 und 1), im Octalsystem (mit den Ziffern 0...7) und im Hexadezimalsystem (mit den \"Ziffern\" 0..9 A..F) möglich. Dazu werden vor die Zahl 0b für binär, 0o für Octal pder 0x für Hexadezimal geschrieben. Alle Buchstaben dürfen hierbei wahlweise groß oder klein geschrieben werden. Der resultierende Wert ist unabhängig der Eingabeform immer ein normaler Zahlenwert. Die Ausgabe von Ganzzahlen erfolgt normalerweise im Zehnersystem (was einstellbar ist). Die folgende Zelle definiert den gleichen Wert über unterschiedliche Literale.\n",
+ "\n",
+ "Diese Möglichkeit existiert, da Computer im allgemeinen im Binärsystem rechnen und dadurch manche Werte in diesen Zahlensystemen aussagekräftiger oder praktischer dargestellt werden können."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "id": "c630976e-2a71-4332-9b2f-d8ab469bab65",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "4863\n",
+ "4863\n",
+ "4863\n"
+ ]
+ }
+ ],
+ "source": [
+ "x=0x12FF #Eine Hexadezimale Zahl\n",
+ "y=0o11377 #Eine Oktalzahl\n",
+ "z=0b0001_0010_1111_1111 #eine binäre Zahl\n",
+ "print (x)\n",
+ "print (y)\n",
+ "print (z)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "4a08a900-fff9-4e47-be61-3d5d3c9be955",
+ "metadata": {},
+ "source": [
+ "### *Imaginäre Zahlen*\n",
+ "Python kann auch mit imaginären Zahlen umgehen. Statt einem \"i\" wird allerdings ein \"j\" an die imaginäre Zahl angehängt. Der Type der komplexen Zahlen in Python heißt 'complex'. Es gibt kein spezielles Literal, um komplexe Zahlen mit realteil zu erzeugen. Diese müssen durch Addieren von Real- und Imaginärteil selbst \"zusammengebaut\" werden. Damit z.B. bei komplitzierteren Ausdrücken mit Multiplikationen etc. keine Fehler passieren, ist es empfehlenswer,t eine Imaginäre Zahl mit Realteil in einer Klammer zu schreiben, wie bei der Variable z. Das ist aber kein Muss. Komplexe Zahlen sind in Python immer aus zwei Fließkommazahlen zusammengesetzt."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 24,
+ "id": "d56aec6e-c337-4d28-bc9c-f33bfc81dfca",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x=12j#Eine komplexe Zahl\n",
+ "y=3+4j#Eine komplexe Zahl mit dem Realteil \n",
+ "z=(3+4j)#Am besten die ganze komplexe Zahl in Klammern schreiben, um Fehler zu vermeinden"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6d16809c-aa29-4e74-a5c4-70ba94c33e9f",
+ "metadata": {},
+ "source": [
+ "## <font color='blue'>*Zeichenketten*</font>\n",
+ "Zeichenketten haben in Python den Typen \"str\". Es sind Aneinanderreihungen von lesbaren Buchstaben beliebiger Länge. Python unterstützt die meisten Sonderzeichen (verwendet sogenannte Unicode-Zeichen). Es ist zu beachten, dass Eine Zeichenkette auch Ziffern enthalten kann. Auch wenn die Zeichenkette nur Ziffern enthält, bleibt sie eine Zeichenkette. Python unterscheidet, wie die allermeisten Programmiersprachen, Zeichenketten strikt von Zahlen. Man kann mit diesen Zeichenketten nicht rechnen (man kann sie allerdings in Zahlen umwandeln). Eine Zeichenkette wird in einfache oder doppelte Anführungzeichen gesetzt. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 28,
+ "id": "4af6d5fd-c62a-4a34-814e-4c6c29762e2e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "a=\"Ich bin ein Text\"\n",
+ "b='Ich bin ein Text'#beide Möglichkeiten sind gleichwertig"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "104718ca-9145-46b1-8a05-d839aa0da608",
+ "metadata": {},
+ "source": [
+ "Ein Problem dabei ist, dass je nach verwendeter Schreibweise das einfache oder doppelte Anführungszeichen nicht innerhalb der Zeichenkette verwendet werden kann, da die Zeichenkette damit beendet werden würde. Aus diesem Grund wird innerhalb von Zeichenketten das \\\\-Zeichen als sogenannter Escape-Character verwendet. Das Zeichen nach dem \\ hat eine besondere Bedeutung. Z.b. kann über \\\\\" Ein Anführungszeichen innerhalb der Zeichenkette als Buchstabe verwendet werden. um ein \\ als Buchstaben zu erhalten muss \\\\\\\\ verwendet werden. Über diesen Mechanismus werden auch weitere Zeichen dargestellt, die ansonsten nicht verwendbar wären. ein \\n ist zum Beispiel ein Zeilenumbruch. Es gibt neben dem \\n noch weitere sogenannte Steuerzeiche. Die nächste Zelle soll das Verhalten verdeutlichen"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 39,
+ "id": "0a8ec550-dab3-45e6-9c22-426441d68709",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Ein doppeltes Anführungszeichen: \". \n",
+ "ein einfaches Anführungszeichen kann in dieser Zeichenkette einfach geschrieben werden ' es ist allerdings auch als ' möglich\n",
+ "Hier ist ein \" einfach. Ein einfaches Anführungszeichen muss hier ein ' sein\n",
+ "Ein Rückstrich ist nur durch \\ schreibbar\n"
+ ]
+ }
+ ],
+ "source": [
+ "a=\"Ein doppeltes Anführungszeichen: \\\". \\nein einfaches Anführungszeichen kann in dieser Zeichenkette einfach geschrieben werden ' es ist allerdings auch als \\' möglich\"\n",
+ "b='Hier ist ein \" einfach. Ein einfaches Anführungszeichen muss hier ein \\' sein'\n",
+ "c=\"Ein Rückstrich ist nur durch \\\\ schreibbar\"\n",
+ "print(a)\n",
+ "print(b)\n",
+ "print(c)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "08406a63-b7bf-4b99-8d7d-acc8f95b5a37",
+ "metadata": {},
+ "source": [
+ "### Weitere Möglichkeiten\n",
+ "Es gibt in Python noch weitere Möglichkeiten rund um das Thema Zeichenkettenliterale. Wie bei den ganzen Zahlen ist allerdings nur die Schreibweise eine andere.\n",
+ "\n",
+ "Zwei Optionen die in Sonderfällen praktisch sein können sind hier noch aufgeführt:\n",
+ "\n",
+ "Es ist möglich Zeichenketten mit drei Anführungszeichen zu beginnen und zu beenden, wie bei mehrzeiligen Kommentaren. Auch hier sind einfache und doppelte Anführungszeichen möglich. Der Effekt ist, dass die Zeichenkette Zeilenumbrüche enthalten kann. Sie ist also für lange Texte besser geeignet. Die Zeilenumbrüche befinden sich als Steuerzeichen in der Zeichenkette, werden also mit print auch ausgegeben\n",
+ "\n",
+ "Außerdem kann vor das erste Anführungszeichen ein R oder r gesetzt werden. Dann wird das \\\\-Zeichen als normales Zeichen interpretiert. Es ist nicht mehr möglich Steuerzeichen oder Anführungszeichen über das \\\\ zu schreiben. Diese Version wird gerne verwendet, wenn eine Zeichenkette keine Anführungszeichen aber viele Rückstriche enthält (z.B. Dateinamen bei Windows-Betriebssystemen)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 141,
+ "id": "29be2463-0542-402e-916d-ce79e3d54a2b",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Es sind auch drei Anführungszeichen möglich, damit sind bis zu 2 Anführungszeichen in Reiche innerhalb der Zeichenkette normal schreibbar \"\". Sie wird durch drei Anführungszeichen beendet\n",
+ "Dieser String kann über mehrere Zelen gehen, was bei langen Texten sehr praktisch ist\n",
+ "bei einem R oder r vor der Zeichenkette ist das \\ ein normales Zeichen. Damit sind allerdings Steuerzeichen und Anführungszeichen nicht mehr schreibbar\n"
+ ]
+ }
+ ],
+ "source": [
+ "a=\"\"\"Es sind auch drei Anführungszeichen möglich, damit sind bis zu 2 Anführungszeichen in Reiche innerhalb der Zeichenkette normal schreibbar \"\". Sie wird durch drei Anführungszeichen beendet\n",
+ "Dieser String kann über mehrere Zelen gehen, was bei langen Texten sehr praktisch ist\"\"\" #geht auch mit einfachen Anführungszeichen. Kann sich über mehrere Zeilen erstrecken\n",
+ "b=R\"bei einem R oder r vor der Zeichenkette ist das \\ ein normales Zeichen. Damit sind allerdings Steuerzeichen und Anführungszeichen nicht mehr schreibbar\"\n",
+ "print (a)\n",
+ "print (b)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a7a36225-e2eb-4dae-8eee-bacc2e6b8ced",
+ "metadata": {},
+ "source": [
+ "## <font color='blue'>Boolsche Werte</font>\n",
+ "Boolsche Werte können Wahr oder Falsch sein. Die Zugehörigen Literale sind \"True\" und \"False\". Boolsche Werte werden immer dort verwendet, wo zwischen zwei Optionen unterschieden werden muss. Z.B sind sie das Ergebnis von Vergleichsoperatoren"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 104,
+ "id": "7b7d000c-3d5c-450e-b808-1f59b3e5538b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "a=True\n",
+ "b=False#Literale für boolsche Werte"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "763734b2-222a-45a2-a4c3-dc160db9622c",
+ "metadata": {},
+ "source": [
+ "# <font color='blue'>**Variablen**</font> <a name=\"Variablen\"> </a>\n",
+ "Variablen speichern Werte unter einem Namen, den der Programmierer frei wählen kann (unter Einhaltung einiger Regeln). Eine Varaible wird bei der ersten Zuweisung eines Wertes erstellt. Der Wert kann dabei ein Literal, der Wert einer anderen Variable oder auch das Ergebnis eines Funktionsaufrufs sein. Jede Variable hat einen Typ (z.B. Ganzzahl, Fließkommazahl, Zeichenkette). Sie übernimmt den Typ vom zugewiesenen Wert. Damit besitzt eine Variable also einen Wert und einen Namen (auch als Identität bezeichnet). Der Name einer Variable darf beliebig lang sein und Buchstaben, Zahlen und das Sonderzeichen \"\\_\" enthalten. Er darf nicht mit einer Zahl anfangen. Außerdem sollte er nicht mit einem \"\\_\" angangen, da der Unterstrich am Anfang einer Variablen im Kontext der objektorientierten Programmierung eine spezielle Bedeutung hat. Das ist allerdings eine Übereinkunft bzw. Empfehlung und kein Muss. Nach Möglichkeit sollten Variablen gerade in komplizierteren Programmen sinnvolle Namen gegeben werden! Ohne sinnvolle Variablennamen sind selbst kurze Quelltextabschnitte teilweise extrem schwer nachzuvollziehen."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 59,
+ "id": "11133077-4508-4129-9e9a-7d187c9d11ae",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "7\n",
+ "7\n"
+ ]
+ }
+ ],
+ "source": [
+ "x=7 #Erstellt eine Variable mit dem Namen x und weist ihr den Wert 7 als Ganzzahl zu\n",
+ "Variable_2=x #Erstellt eine Variable mit dem Namen Variable_2 und weist ihr den Wert von x zu (das ist in diesem Fall die 7). Auch Variable_2 ist damit eine Ganzzahl \n",
+ "print (x)#Gibt den Wert von x aus\n",
+ "print (Variable_2)#Gibt den Wert von Variable2 aus"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "379be8b7-faae-4697-b890-553fd65d9690",
+ "metadata": {},
+ "source": [
+ "Einer Variable kann jederzeit ein neuer Wert zugewiesen werden. Da Python eine sogenannte schwach-typisierende Programmiersprache ist, kann der neue Wert auch einen anderen Typ besitzen als die Variable. Sie verändert dann ihren Typ. Variablen sind außerdem nicht statisch. Das heißt, sie existieren erst, wenn ihnen ein Wert zugewiesen wird. Vorher ist der Variablenname nicht bekannt. Außerdem können Variablen auch wieder gelöscht werden. Sie hören dann auf zu existieren"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 60,
+ "id": "4a5c12c6-8c5f-4919-86e6-8279f6ce6ddb",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Ich bin jetzt ein Text\n"
+ ]
+ }
+ ],
+ "source": [
+ "x=\"Ich bin jetzt ein Text\" #x kann ein neuer Wert zugwiesen werden. Der Wert kann einen anderen Typ besitzen. x war vor der Zuweisung eine Ganzzahl, jetzt ist x eine Zeichenkette\n",
+ "print (x)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 61,
+ "id": "6c9f0d01-5909-41f7-a1a0-e54ef3ab4c8f",
+ "metadata": {},
+ "outputs": [
+ {
+ "ename": "NameError",
+ "evalue": "name 'x' is not defined",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)",
+ "Cell \u001b[1;32mIn [61], line 2\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[38;5;28;01mdel\u001b[39;00m(x) \u001b[38;5;66;03m#Löscht die Variable x\u001b[39;00m\n\u001b[1;32m----> 2\u001b[0m \u001b[38;5;28mprint\u001b[39m (\u001b[43mx\u001b[49m)\n",
+ "\u001b[1;31mNameError\u001b[0m: name 'x' is not defined"
+ ]
+ }
+ ],
+ "source": [
+ "del(x) #Löscht die Variable x\n",
+ "print (x) #Löst jetzt einen Fehler aus, da keine Variable mit dem Namen x bekannt ist"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ce8fbb20-8f01-459e-b952-38e304dc5346",
+ "metadata": {},
+ "source": [
+ "# <font color='blue'>**Wichtige Funktionen**</font> <a name=\"Funktionen\"> </a>\n",
+ "Funktionen werden auch als Methoden, Routinen oder Unterprogramme bezeichnet. Über sie wird ein großer Teil der Funktionalitäten von Python bereitgestellt.\n",
+ "Funktionen besitzen einen Namen, der den gleichen Regeln wie Variablennamen unterliegt.\n",
+ "\n",
+ "Das Prinzip der Funktionen soll an einem Beispiel erklärt werden:\n",
+ "Die Funktion print gibt einen Wert in Textform aus. Damit sie einen Wert ausgeben kann, muss sie aufgerufen werden und benötigt den auszugebenden Wert (z.B. ein Literal, der Wert einer Variablen, etc). Optional können Funktionen auch einen Wert als Ergebnis zurückliefern, was print nicht tut. Aufgerufen werden Funktionen über ihren Namen, gefolgt von runden Klammern. Innerhalb der runden Klammern können Parameter an die Funktion übergeben werden. Bei mehreren Parametern sind die einzelnen Parameter durch Kommas getrennt. Falls kein Parameter übergeben wird, bleiben die Klammer leer. Das Beispiel print wurde bereits in vielen Beispielen verwendet. Ob eine Funktion Parameter benötigt, bzw. wie viele Parameter sie erwartet, ist allein von der Funktion abhängig. Es gibt auch Funktionen, die mit einer variablen Zahl an Parametern umgehen können. Die Reihenfolge der Parameter ist durch die Funktion festgelegt. Teilweise gibt es auch benannte Parameter (siehe print). Funktionen können durch den Programmierer selbst in Python geschrieben werden, aus sogenannten Paketen importiert werden oder fest zum Sprachkern von Python gehönren (sogenannte built-in Funktionen)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 142,
+ "id": "c9b6ee6f-1c3c-4816-ac95-759f67b6233e",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "3.4\n",
+ "Hallo Welt\n",
+ "3 Hallo 4.3\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(3.4)#Ruft die Funktion \"print\" auf. Als Parameter wird der Wert 3.4 übergeben\n",
+ "eineVariable=\"Hallo Welt\"\n",
+ "print(eineVariable)#Statt eines Literals kann auch eine Variable verwendet werden. Die Funktion bekommt dann den Wert der Variable übergeben\n",
+ "print(3,\"Hallo\",4.3)#print kann mit beliebig vielen Parametern aufgerufen werden, das ist nicht bei allen Funktionen so\n",
+ "print()#beliebige Anzahl heißt in diesem Fall auch kein Parameter"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8d8feb3f-ff99-411f-b004-f6aafed61f20",
+ "metadata": {},
+ "source": [
+ "## <font color='blue'>*print*</font>\n",
+ "\"print\" ist eine Funktion, die Werte als Text ausgeben kann. Die Funktion kann beliebig viele Parameter übergeben bekommen. Im Fall von keinem Parameter, wird eine leere Zeile ausgegeben. Bei mehreren Parametern werden die Parameter mit einem Trennzeichen getrennt in einer Zeile ausgegeben. \"print\" kann Werte mit beliebigen Typ übergeben bekommen. Sie werden vor der Ausgabe in eine geeignete Textform überführt. Je nach Datentyp kann das besser oder schlechter funktionieren. Zahlen und Text lassen sich jedoch sehr gut ausgeben.\n",
+ "Das Trennzeichen zwischen den Einzelwerten kann über einen sogenannten \"benannten Parameter\" frei gewählt werden und hat ein Leerzeichen als Standardwert, falls kein eigenes Trennzeichen angegeben wird. Das Trennzeichen muss auch kein einzelnes Zeichen sein, sondern kann eine beliebige Zeichenkette sein. Im Beispiel in der nächsten Codezeile ist das Trennzeichen auf :-: gesetzt. Das ist ein Beispiel für die Verwendung eines benannten Parameters. In den allermeisten Fällen wird print allerdings mit nur einem Parameter verwendet. \"print\" gibt keinen Wert zurück"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 73,
+ "id": "763c5bfe-48f8-4cc4-9f7b-03c49cd3aea7",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "3\n",
+ "A:-:3:-:4:-:5.4\n"
+ ]
+ }
+ ],
+ "source": [
+ "x=3\n",
+ "print(x)\n",
+ "print(\"A\",x,4,5.4,sep=\":-:\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7115d783-39af-4953-98f6-590b4ff5d108",
+ "metadata": {},
+ "source": [
+ "## <font color='blue'>*help*</font>\n",
+ "\"help\" ist eine Funktion, die zu einer Funktion einen Hilfetext liefert. Es ist sozusagen ein Hilfe-System, das in die Programmiersprache eingebaut ist. Programmierer können ihre Funktionen so dokumentieren, dass help automatisch den verfassten Hilfetext findet. Es ist also möglich, dass nicht zu jeder Funktion ein Hilfetext gefunden wird. Die Funktion \"help\" gibt den Hilfetext direkt aus und wird meistens bei der interaktiven Verwendun von Python genutzt. \"help\" kann auch ohne Parameter aufgerufen werden, was ein interaktives Hilfeprogramm startet das läuft, bis quit zum Beenden eingegeben wird. Du kannst es in diesem Notebook ausprobieren, auch wenn die Verwendung der interaktiven Hilfe in einem Jupyter-Notebook eher weniger zu empfehlen ist. Die Code-Zelle blockiert den Python-Kernel des Notebooks, bis die interaktive Hilfe beendet wurde\n",
+ "\n",
+ "Wie hilfreich die ausgegebenen Texte sind variiert sehr stark, da die Texte durch die jeweiligen Programmierer verfasst wurden"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 143,
+ "id": "9551e0bc-0884-41bb-987e-25c66bec55c8",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Help on built-in function print in module builtins:\n",
+ "\n",
+ "print(...)\n",
+ " print(value, ..., sep=' ', end='\\n', file=sys.stdout, flush=False)\n",
+ " \n",
+ " Prints the values to a stream, or to sys.stdout by default.\n",
+ " Optional keyword arguments:\n",
+ " file: a file-like object (stream); defaults to the current sys.stdout.\n",
+ " sep: string inserted between values, default a space.\n",
+ " end: string appended after the last value, default a newline.\n",
+ " flush: whether to forcibly flush the stream.\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "help(print)#gibt den Hilfetext der Funktion print aus."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "580a0764-0558-496e-b34b-d5052053534c",
+ "metadata": {},
+ "source": [
+ "## <font color='blue'>*type*</font>\n",
+ "\"type\" ist eine Funktion, mit der man den Typ von Variablen oder Werten ermittel kann. Die Verwendung von \"type\" in Programmen ist bei Python eher unüblich und wird selten benötigt. Es kann aber eine sehr praktische Hilfe sein, um die Funktion von Python näher zu betrachten.\n",
+ "\"type\" erwartet einen Parameter, von dem der Typ bestimmt werden soll. Die Funktion gibt den Typ nicht aus, sondern gibt ihn als Ergenis des Funktionsaufrufs zurück. Das Ergebnis kann dann mit \"print\" ausgegeben werden. Das Ergebnis kann auch in einer Variable gespeichert werden. Das ist ein Beispiel, wie ein Funktionsaufruf rechts des Zuweisungsoperators genutzt werden kann"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 95,
+ "id": "1f199866-0c60-447f-9184-d69c3c8b9324",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "<class 'str'>\n",
+ "<class 'int'>\n",
+ "<class 'float'>\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(type(\"Hallo\"))\n",
+ "x=4\n",
+ "print(type(x))\n",
+ "erg=type(2.3)\n",
+ "print(erg)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "38023d3c-888b-470d-b738-c36564043da4",
+ "metadata": {},
+ "source": [
+ "\"type\" funktioniert auch bei Funktionen und anderen Objekten. Die Ausgabe kann aber unter Umständen etwas schwierig zu interpretieren sein"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 99,
+ "id": "38241019-1cc6-44e2-9115-4f0e15b970cf",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "<class 'builtin_function_or_method'>\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(type(print))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "adc5e372-f5ea-41b4-a179-61520da3f655",
+ "metadata": {},
+ "source": [
+ "## <font color='blue'>Typenumwandlung</font>\n",
+ "Gelegentlich muss der Inhalt einer Variablen in einen anderen Typ konvertiert werden. Zwischen ganzen Zahlen und Fließkommazahlen passiert das automatisch. Zwischen Zeichenketten und Zahlen generell nicht. Es gibt für jeden dieser Datentypen ein Funktion, die so heißt wie der zugehörige Typ, der die Umwandlung, sofern sinvoll möglich, durchführt. Der umgewandelte Wert wird als Ergebnis zurückgegebe\n",
+ "\n",
+ "### str\n",
+ "Mit der Funktion können Zahlen in Zeichenketten umgewandelt werden. Z.B. um sie für die Ausgabe in einem Text vorzubereiten"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 152,
+ "id": "f9cdd943-cdb9-4a81-8f70-13f052ef5f24",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Die Zahl ist:3.45\n"
+ ]
+ }
+ ],
+ "source": [
+ "x=3.45\n",
+ "als_Zeichenkette=str(x)\n",
+ "print(\"Die Zahl ist:\"+als_Zeichenkette)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e62d5e48-c1b1-44af-922f-ad5883d4c43e",
+ "metadata": {},
+ "source": [
+ "### float\n",
+ "Wandelt eine Zeichenkette oder eine ganze Zahl in eine Fließkommazahl um. Die Zeichenkette muss dafür eine Zahl darstellen, also keine Buchstaben enthalten (genau genommen gelten die Regeln der Fließkomma-Literale hier auch)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 157,
+ "id": "c2990bb3-9f5f-4f72-9930-c9e5d297b882",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "4.22345\n"
+ ]
+ }
+ ],
+ "source": [
+ "eine_Zeichenkette=\"3.22345\"\n",
+ "x=float(eine_Zeichenkette)\n",
+ "x+=1\n",
+ "print(x)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f33e38d9-40d7-4ee4-b87d-eb9c78229cd0",
+ "metadata": {},
+ "source": [
+ "### int\n",
+ "Wandelt eine Fließkommazahl oder eine Zeichenkette in eine ganze Zahl um. Bei einer Zeichenkette muss der Inhalt eine ganze Zahl sein im Dezimalsystem sein (Binär-,Oktal- oder Hexadezimalzahlen funktionieren nicht). Wenn eine Fließkommazahl umgewandelt wird, wird sie grundsätzlich abgerundet"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 159,
+ "id": "bf1e790b-36a9-4ffa-b962-51d53d579ef6",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "1244\n",
+ "3\n"
+ ]
+ }
+ ],
+ "source": [
+ "zeichenkette=\"1234\"\n",
+ "x=int(zeichenkette)\n",
+ "print(x+10)\n",
+ "y=3.9\n",
+ "print(int(y))#Fließkommazahlen werden immer abgerundet"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "eb7a2164-a37b-47cf-a53e-247b50647746",
+ "metadata": {},
+ "source": [
+ "# <font color='blue'>**Operatoren**</font> <a name=\"Operatoren\"> </a>"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1190808f-7277-4002-b4c3-611ad3b6c741",
+ "metadata": {},
+ "source": [
+ "Operatoren bzw. die Operatorenschreibweise ist in Programmiersprechen üblich, um den Quelltext an die Gewohnheiten des natürlichen Sprachgebrauchs anzupassen. Sie benötigt im Vergleich zur Funktionsschreibweise weniger Platz Ein Beispiel ist das +-Zeichen, das einen Operator darstellt"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 100,
+ "id": "e67d9706-a563-4685-9765-dd204852cf35",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "7"
+ ]
+ },
+ "execution_count": 100,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "4+3"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "49b40984-af01-456e-a4a4-c138c2f922c4",
+ "metadata": {},
+ "source": [
+ "Operatoren funktionieren ähnlich wie Funktionen. Das Plus hat zwei Parameter und ein Ergebnis. Der Operator steht allerdings zwischen den Parametern. Operatoren wie das Plus heißen binärer Operator, da sie zwei Parameter benötigen (im Beispiel die 4 und die 3). Der Operator selbst steht zwischen den Parametern. Neben den binären Operatoren gibt es auch unäre Operatoren, die nur ein Parameter erwarten. Sie stehen vor ihrem Parameter. Ein Beispiel ist das - als Vorzeichen"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 101,
+ "id": "334fc718-6847-42c5-865c-a7a0c4955ab3",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "-7"
+ ]
+ },
+ "execution_count": 101,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "-7"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f7c1f1d3-8996-4808-973b-b1daa9b5b668",
+ "metadata": {},
+ "source": [
+ "Im Gegensatz zu vielen anderen Programmiersprachen ist das Minus bei Python nicht Teil des Literals, sondern ein unärer Operator vor dem Literal (auch wenn praktische Auswirkungen dieses Unterschieds eher nicht vorhanden sind und es eine technische Spitzfindigkeit ist).\n",
+ "\n",
+ "Es gibt verschiedene Operatoren in Python. Welche Zeichen ein Operator sind ist vordefiniert und nicht erweiterbar. Es ist allerdings in manchen Fällen möglich zu verändern, was der Operator tut (im Kapitel über objektorientierte Programmierung beschreiben). Die für arithmetische Operationen genutzten Operatoren (+,-,*,etc.) werden in der Potenz vor Punkt vor Strich Reihenfolge ausgeführt, wenn sie in einer Zeile stehen! Das ist bei Rechnungen praktisch, in anderen Fällen evtl. nicht erwünscht. Im Zweifelsfall Klammer setzen.\n",
+ "## <font color='blue'>*Zuweisungsoperator*</font>\n",
+ "Der Zuweisungsoperatpor ist in Python das =-Zeichen. Der Zuweisungsoperator weist den Wert, der auf seiner rechten Seite steht der Variablen auf seiner linken Seite zu. Er wird immer als letztes Ausgewertet. Das heißt, sollten auf der rechten Seite der Zuweisung mehrere Operationen stehen werden alle zu erst Ausgewertet. Der resultierende Wert wird dann der Variable auf der linken Seite zugewiesen. Sollte die Variable auf der linken Seite nicht existieren, wird sie angelegt. Literale können nicht auf der linken Seite der Zuweisung stehen. Python folgt einer \"Alles ist eine Variable\" logik. Daher sind technisch betrachtet auch alle Funktionen Variablen. Es sollte vermieden werden wichtige Funktionen wie print o.ä. mit Werten zu überschreiben. Es ist möglich, aber bis zum neustart des Python-Interpreters ist dann die Funktion nicht mehr verfügbar!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "9b5a15fb-a387-446d-9d19-f8c9ed15dc69",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x=4 #Falls x unbekannt ist wird eine Variable x erstellt\n",
+ "x=4+3*9*11#Auf der rechten Seite des Zuweisungsoperators können auch komplexe Ausdrücke stehen. Der Wert von x wird überschrieben\n",
+ "y=x*4#Die rechte Seite wird vor Zuweisung ausgewertet. Das Ergebnis wird in y geschrieben. Wenn x verändert wird, bleibt y unverändert, da bei der Auswertung der rechten Seite nur der Wert relevant ist, der momentan in x gespeichert ist!"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2eab76af-6673-4816-9179-3ba7dc4c1fb1",
+ "metadata": {},
+ "source": [
+ "## <font color='blue'>*Arithmetische Operatoren*</font>\n",
+ "Die Grundrechenarten. Die Arithmetischen Operatoren sind binäre Operatoren und erwarten Zahlen als Parameter. Die meisten arithmetischen Operatoren funktionieren sowohl mit Fließkommazahlen, als auch mit ganzen Zahlen. Die Operatoren // und % sind eigentlich nur für ganze Zahlen definiert. Werden sie auf Fließkommazahlen angewendet, werden diese zunächst in ganze Zahlen umgewandelt (siehe Abschnitt über Typumwandlung)\n",
+ "\n",
+ "|Operator | Bedeutung| Anmerkung|\n",
+ "|---------|----------|----------|\n",
+ "|+ |Addition | |\n",
+ "|- |Subtraktion| |\n",
+ "|/ |Geteilt durch| Ergebnis ist immer Fließkommazahl|\n",
+ "|//| Ganzzahliges teilen. Der Rest entfällt 7//3 = 2 (Rest 1)|Ergebnis ist immer ganze Zahl|\n",
+ "|% |Modulo. Der Rest beim ganzzahligen Teilen 7%3= 1|Ergebnis ist immer ganze Zahl|\n",
+ "|** |Potenz. Ersatz für Hoch-Zeichen|Ergebnis ist immer Fließkommazahl|\n",
+ "\n",
+ "### Kombinationsoperatoren\n",
+ "Alle Arithmetischen Operatoren können mit einem Zuweisungsoperator komibiniert werden. Z.B. +=. Das ist lediglich eine abkürzende Schreibweise und bietet keine neue Funktionalität"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "b841fd14-ff64-4464-a16a-a122bc319a34",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "7\n"
+ ]
+ }
+ ],
+ "source": [
+ "x=3\n",
+ "x+=4 #Eine Abkürzung für x=x+3\n",
+ "print (x)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "3f488cda-28ea-42b5-8bc6-bf0deaae564a",
+ "metadata": {},
+ "source": [
+ "## <font color='blue'>*Vergleichsoperatoren*</font>\n",
+ "Die Vergleichsoperatoren vergleichen Zahlen miteinander. Das Ergebnis ist ein boolscher Wert (Wahr oder Falsch). Die Vergleichsoperatoren in Python sind\n",
+ "|Operator | Bedeutung |\n",
+ "|---------|-----------|\n",
+ "|==|ist gleich|\n",
+ "| <|kleiner|\n",
+ "|> |größer|\n",
+ "|<= |kleiner oder gleich|\n",
+ "|>= |größer oder gleich|\n",
+ "|!= |ungleich|\n",
+ "\n",
+ "Der \"ist gleich\" und \"ungleich\" Operator sollte nach möglichkeit nicht auf Fließkommazahlen angewendet werden! Das gilt im Übrigen nicht nur für Python-Programmierung sondern ist ein generelles Problem bei Computern"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 147,
+ "id": "e500889b-7395-4774-a6c3-57411f9b9dff",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "True"
+ ]
+ },
+ "execution_count": 147,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "3>2"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a90e0157-cef9-4fce-bbf3-bc2a131fed9f",
+ "metadata": {},
+ "source": [
+ "## <font color='blue'>Operatoren und Zeichenketten</font>\n",
+ "Einige Operatoren sind auch auf Zeichenketten anwendbar.\n",
+ "\n",
+ "Der Vergleich auf Gleichheit und Ungleichheit \"==\", \"!=\" funktionieren wie erwartet. Sie sind Case-Senstitive (also beachten groß und Kleinschreibung).\n",
+ "\n",
+ "Auch <,>,<=,>= funktionieren. Sie sortieren die Zeichenketten so, wie man es in einem Aktenschrank erwarten würden. Sie vergleichen von links nach rechts Zeichen für Zeichen, bis ein Unterschied auftritt. Dabei gilt die Regel Ziffern vor Buchstaben, alle großen Buchstaben vor allen kleinen Buchstaben. Bei den Buchstaben ist die Sortierung alphabetisch.\n",
+ "\n",
+ "Die Arithmetischen Operatoren sind teilweise auf Zeichenketten Anwendbar, haben dann aber andere Bedeutung\n",
+ "|Operator| Bedeutung | Typen der Parameter|\n",
+ "|--------|-----------|--------------------|\n",
+ "|+ |fügt Zeichenketten zusammen| str und str|\n",
+ "|* | Hängt die Zeichenkette n mal hintereinander| str und ganze Zahl|\n",
+ "\n",
+ "Beim *-Operator muss die Zeichenkette auf der linken Seite des Operators sein. Die Reihenfolge der Parameter ist also nicht austauschbar!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 130,
+ "id": "4f429086-0aab-4639-9770-78ca651fef05",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "hallo welt\n",
+ "hallo welthallo welthallo welt\n"
+ ]
+ }
+ ],
+ "source": [
+ "x=\"hallo\"+\" \"+\"welt\"\n",
+ "y=\"hallo welt\"*3\n",
+ "print(x)\n",
+ "print(y)"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.10.5"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/Uebung01/Uebung01.ipynb b/Uebung01/Uebung01.ipynb
new file mode 100644
index 0000000..995752c
--- /dev/null
+++ b/Uebung01/Uebung01.ipynb
@@ -0,0 +1,525 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "18aad444-cf2f-4db2-843b-9481d9529894",
+ "metadata": {},
+ "source": [
+ "# <font color='blue'>**Ãœbung 1 - Grundlagen Python**</font>"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bb2e9a17-024f-4329-82e7-c185f2163b63",
+ "metadata": {},
+ "source": [
+ "## <font color='blue'>**Die Grundlagen von Python Teil 1**</font>\n",
+ "Dieses Notebook wird in der ersten Übung verwendet. Es stellt den ersten Teil der Python Grundlagen dar. In diesem Notebook geht es um die ersten Gehversuche mit der Programmiersprache Python. Das Notebook besteht, wie alle folgenden, aus einigen Beispielen, die in der Übung erklärt werden. Im Anschluss gibt es Aufgaben zum selber ausprobieren. Da wir im Moment ganz am Anfang der Übung stehen, hat dieses Notebook noch keine zusammenhängende Aufgabe, sondern soll vor allem Grundlagen erläutern. Das wird sich mit den kommenden Übungen ändern. Zu den Übungen gibt es Grundlagen Notebooks, die zum Nachschlagen der wichtigsten Informationen der Übung dienen sollen und teilweise einige Informationen enthalten, die in der Übung aus Zeitgründen nicht ausführlich besprochen werden.\n",
+ "\n",
+ "### **Weitere Notebooks, die dir helfen könnten**\n",
+ "* Jupyter Grundlagen\n",
+ "* Python Grundlagen\n",
+ "\n",
+ "### **Vorkenntnisse**\n",
+ "* Keine"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "70133fc6-40c9-4e4b-b106-f64d2e145e63",
+ "metadata": {},
+ "source": [
+ "# <font color='blue'>**Abschnitt 1 - Verwendung von Python als Taschenrechner**</font>\n",
+ "## <font color='blue'>*Aufgabe*</font>\n",
+ "Berechne die Oberfläche eines Würfels mit der Kantenlänge 3,2394"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9f8951be-3086-4427-9dc5-be3263af2a58",
+ "metadata": {},
+ "source": [
+ "## <font color='blue'>*Lösung*</font>"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "592319ed-cc88-4291-8834-3b3db239f620",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a55562c9-557d-4864-9fa9-c0090413a8c7",
+ "metadata": {},
+ "source": [
+ "## <font color='blue'>*Grundlagen*</font>\n",
+ "Python ist in diesem Notebook im interaktiven Modus gestartet. In diesem Modus kann das auszuführende Programm Zeile für Zeile eingegeben werden, wobei jede Zeile nach der Eingabe ausgeführt wird. Im einfachsten Fall kann man Python wie einen Taschenrechner verwenden."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "57d2a9b3-6be4-4d8e-9ad7-7263b48aae1b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "3+5"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "48a1c463-27b0-43bc-8b97-395887ed9e5a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "3**4\n",
+ "6-2.9301"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "b7a9e863-b61e-48a4-a34c-4e04e826c660",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "3+4*3"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "da7f9a36-3736-408a-9bb1-93eaddb1d805",
+ "metadata": {},
+ "source": [
+ "Die Notebook-Codezellen können auch mehr als eine Zeile enthalten. Bei der Ausführung werden alle Zeilen an den Python-Interpreter geschickt, der sie nacheinander ausführt. In den Beispielen ist zu sehen, dass das Ergebnis der letzten Zeile ausgegeben wird\n",
+ "Die Ausgaben sind sogenannte Debug-Ausgaben, weil in der letzten Zeile ein Wert \"übrigbleibt\". Alle anderen Werte werden zwar berechnet, gehen aber verloren.\n",
+ "Um mit den Ergebnissen etwas anzufangen, kann man sie z.B. ausgeben. Die Funktionalität heißt print"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ff16400c-027b-460f-a13f-608359e2bf17",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "print(3+4)\n",
+ "print(8+9)\n",
+ "print(2**4)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "36b551f4-6f32-4e94-9b69-ae2a9a663053",
+ "metadata": {},
+ "source": [
+ "Die Werte, die print ausgeben soll, stehen in runden Klammern hinter dem print. Python ist Textzeilen basiert. In jeder Zeile kann nur ein Befehl, also ein print, stehen. Der Befehl kann dabei aber beliebig kompliziert werden.\n",
+ "Es können nicht nur Berechnungen angestellt werden, sondern auch Werte verglichen werden"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "da039e49-2726-4716-a346-75c03beeb7f7",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "print (3+7<9*4)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "97149c54-b9e5-4658-9aa9-4065c169f2d3",
+ "metadata": {},
+ "source": [
+ "Etwas vorsicht ist geboten, das die Abfrage, ob zwei Werte gleich sind mit einem == durchgeführt wird"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "e1e7851e-4adc-467e-a14f-55d2591e497e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "print (7*9==53)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1daeb6f0-29dd-467f-a0ce-ed09177fba97",
+ "metadata": {},
+ "source": [
+ "# <font color='blue'>**Abschnitt 2 - Definition von Variablen**</font>"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "50800ef0-0245-4fd1-80b2-93c623d4121b",
+ "metadata": {},
+ "source": [
+ "## <font color='blue'>*Aufgabe*</font>\n",
+ "Berechne die Oberfläche, das Volumen und die Länge aller Kanten eines Quaders mit den Abmessungen (HxBxT) 2,3x4,9x2,1\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ba41fef8-6c52-4b19-b3ff-bb0a0c507d2c",
+ "metadata": {},
+ "source": [
+ "## <font color='blue'>*Lösung*</font>"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "e6120a8a-9674-4057-abf7-ec0b362728e4",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ccd72eba-be65-4441-96c5-2e3c638f8956",
+ "metadata": {},
+ "source": [
+ "## <font color='blue'>*Grundlagen*</font>\n",
+ "Prinzipiell ließe sich die Aufgabe wie die letzte Aufgabe bearbeiten. Das Prolem ist nur, dass der Ansatz keinen Vorteil gegenüber der Verwendung eines Taschenrechners hat. Bis jetzt wurden Werte nur berechnet und ausgegeben. Wir können Werte jedoch auch in Variablen speichern,die wir später wiederverwenden können. Nehmen wir als Beispiel wieder den Würfel"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "dad88763-7981-476b-8ffd-7feb5ee4eca2",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "h=3.2394\n",
+ "print(h)\n",
+ "volumen=h**3\n",
+ "flaeche=h*h*6\n",
+ "print(volumen)\n",
+ "print(flaeche)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0067ed23-13cf-4a45-8de7-964ab7453777",
+ "metadata": {},
+ "source": [
+ "Variablen sollten sinvoll benannt werden. Sonderzeichen sind in Variablennamen nicht zulässig und der Name darf nicht mit einer Zahl beginnen\n",
+ "Wir könnten diese Zellefür andere Kantenlängen schnell verändern und erneut ausführen"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "85d667b1-34c3-4ddf-bfcd-2ff7f04c722d",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "print (volumen/flaeche)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "345f62ac-aaaf-439b-b9de-b695e17f4f42",
+ "metadata": {},
+ "source": [
+ "Variablen aus bereits ausgeführten Zellen sind nach beendigung der Ausführung weiter verfügbar. Ihr Wert kann jederzeit geändert werden. Das = kopiert den Wert einer Variable. Die Variablen sind also nicht dauerhaft gleich"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "5a9d0b0c-0ac7-49ea-9c01-dd52f5fc2be2",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "variable=volumen\n",
+ "print (volumen)\n",
+ "print (variable)\n",
+ "volumen=9\n",
+ "print (volumen)\n",
+ "print (variable)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "636203fb-d387-40e3-b566-bfbc3b3488d3",
+ "metadata": {},
+ "source": [
+ "Berechnungen werden immer mit dem Wert durchgeführt den die Variable hat, wenn die Zelle ausgeführt hat. Die Zelle die das Oberflächenverhältnis bestimmt gibt jetzt einen anderen Wert aus.\n",
+ "Variablen können immer statt eines Wertes verwendet werden. Auch die Beispiele mit Vergleichen funktioniert"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "c139e606-a307-460a-a85e-4b79d4966839",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "print(flaeche==h**2*6)\n",
+ "print(flaeche==3.2394**2*6)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f82757ab-69a7-474c-81b4-58fbdf7f450c",
+ "metadata": {},
+ "source": [
+ "Beim Vergleich von Fließkommazahlen am PC auf Gleichheit ist etwas Vorsicht geboten. Der Vergleich ist exakt, die Berechnungen unterliegen aber Rundungsfehlern! Diese können relevant werden, wenn mit Zahlen unterschiedlicher Größenordnung gerechnet wird"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "cdb8e497-c51b-4de1-bd35-6707a1079611",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "a=(11**10)/(3**-5)\n",
+ "b=((3**-5)/(11**10))\n",
+ "\n",
+ "print(a==1/b)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "c9c53e76-5d73-444b-b424-69b493231406",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "print(a-1/b)\n",
+ "print(a)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "508ca08a-ae3a-462e-884d-733950eddbe7",
+ "metadata": {},
+ "source": [
+ "### *Ein kleiner Tip um später Schreibarbeit zu sparen*\n",
+ "Beim Programmieren gibt es oft Situationen, in denen man den Wert einer Variablen verändern möchte, indem man z.B. den Wert der Variable mal 6 nehmen möchte. Wenn wir z.B. den Flächeninhalt einer Fläche des obigen Würfels berechnen wollen und dann die Gesamtoberfläche ginge das so"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "2972a23a-541f-41a6-9267-f40d3cfaf044",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "flaeche=h*h\n",
+ "print(flaeche)\n",
+ "flaeche=flaeche*6\n",
+ "print(flaeche)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "04e27b56-89cc-4b9e-b551-23f4db2beb59",
+ "metadata": {},
+ "source": [
+ "Eine Variable kann also auf beiden Seiten des = auftauchen. Auf der rechten Seite mit dem alten Wert bevor ihr der neue Wert zugewiesen wird. Da solche Zeilen in Programmen extrem häufig vorkommen gibt es eine Kurzschreibweise"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "ee23a3c0-60f0-4c43-bae6-91eb8920a4be",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "flaeche=h*h\n",
+ "flaeche*=6\n",
+ "print(flaeche)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "16cc99c7-a7f7-42cd-ba6a-8410ef9dfec7",
+ "metadata": {},
+ "source": [
+ "Das funktioniert auch mit allen anderen Rechenarten"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "43fc8099-4463-4142-8667-53dfdce8daac",
+ "metadata": {},
+ "source": [
+ "# <font color='blue'>**Abschnitt 3 - Verwendung von Zeichenketten**</font>"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "523caae5-6106-43d9-8568-2147ada140ff",
+ "metadata": {},
+ "source": [
+ "## <font color='blue'>*Aufgabe*</font>\n",
+ "Die bisherigen Beispiele haben wir nur Werte ausgegeben. Ohne das Programm komplett zu verstehen sind diese Werte relativ nutzlos, weil nirgendwo angegeben wird, was sie bedeuten. Erweitere das Programm aus Abschnitt 2 so, dass vor jedem Ausgegebene eine Ausgabe erfolgt die beschreibt, was der Wert bedeutet\n",
+ "## <font color='blue'>*Lösung*</font>"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "c30d3f3e-ab88-4141-88e7-06794115ae2f",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "36e32f85-7977-462f-9ef8-618b186075dd",
+ "metadata": {},
+ "source": [
+ "\n",
+ "## <font color='blue'>*Grundlagen*</font>\n",
+ "In vielen Programmier-Situationen ist es hilfreich, auch Text ausgeben zu können. Text wird in Python grundlegend anders behandelt als Zahlen. Auch wenn der Text nur Ziffern enthält bleibt er ein Text. Text kann z.B. in Anführungszeichen eingegeben werden"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "af7d575d-a213-4dd6-8f49-1ec32cf9d683",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "print(\"Hallo Welt\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7dc61c90-01c7-4aa0-a61d-704cb4e559bd",
+ "metadata": {},
+ "source": [
+ "So kann man die vorherigen Ãœbungsprogramme schon etwas verbessern"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "96820aa0-5539-496b-a626-374962669204",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "h=3.2394\n",
+ "print(\"Ein Würfel mit einer Kantenlänge von:\")\n",
+ "print(h)\n",
+ "volumen=h**3\n",
+ "flaeche=h*h*6\n",
+ "print(\"hat ein Volumen von:\")\n",
+ "print(volumen)\n",
+ "print(\"und eine Fläche von:\")\n",
+ "print(flaeche)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "dcdc957d-4355-4281-8e7d-797867dc1da3",
+ "metadata": {},
+ "source": [
+ "Text lässt sich nicht nur ausgeben, sondern auch in Variablen speichern. Die Variablen lassen sich auch mit den Rechenoperatoren verändern (zumindest mit dem + und dem \\*). Die Bedeutung ist aber eine andere "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "97115c66-bb2c-4b4a-80e6-712cd0de260b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "text1=\"hallo\"\n",
+ "text2=\"welt\"\n",
+ "print (text1+text2)\n",
+ "print (text1+\" \"+text2)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "c65f62bf-0a89-4075-b260-7559edaf2a96",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "text3=text1+\" \"+text2\n",
+ "print(text3*3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b6aa71e5-81c7-4b9b-9b95-9d9b457d716d",
+ "metadata": {
+ "tags": []
+ },
+ "source": [
+ "# <font color='blue'>**Aufgabe zum selbst probieren**</font>\n",
+ "Verbessere das Programm zur Quaderberechnung. Wie bisher werden Länge, Breite und Tiefe über drei Variablen vorgegeben. Neben den bisherigen Ausgaben soll das Verhältnis zwischen Oberfläche und Volumen berechnet werden. Außerdem soll die Ausgabe verbessert werden. Im bisherigen Beispiel erfolgt die Ausgabe eines Wertes immer eine Zeile unter der Beschreibung. Die Ausgabe deines Programmes soll zum schluss etwa so aussehen:\n",
+ "\n",
+ "```\n",
+ "Ein Quader mit den Abmessungen (LxBxT): 2.3x3.9x2.1\n",
+ "hat ein Volumen von 23.667m3\n",
+ "bei einer Oberfläche von 52.78m2\n",
+ "Das Verhältnis von Oberfläche zu Volumen ist 2.230109435978379\n",
+ "Die Gesamtlänge seiner Kanten beträgt 37.2m\n",
+ "```\n",
+ "\n",
+ "Wie viele Dezimalstellen genau ausgegeben werden ist hierbei egal. Eine Lösung um das zu kontrollieren finden wir in späteren Übungen. Wenn die Codezelle mit anderen Werten für Länge, Breite und Tiefe ausgeführt wird, sollen sich die Ausgabewerte entsprechend anpassen"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a69e45f4-0957-40c6-bc3f-3b7808297f76",
+ "metadata": {},
+ "source": [
+ "## <font color='blue'>*Lösung*</font>"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "aa0cced0-059f-4290-8f47-62f7215a929e",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fe45f476-750e-4ded-81f7-96e6cb63be52",
+ "metadata": {},
+ "source": [
+ "### Hinweis zur Aufgabe\n",
+ "Prinzipiell besteht die Schwierigkeit in der Ausgabe von Text und Zahlen in einer Zeile. Es sind zwei Lösungsmöglichkeiten. Wenn du die Python-Grundlagen zur Hilfe nimmst, kannst du zwei Lösungswege finden. Eine möglichkeit wäre, die Zahlenwerte in Text umzuwandeln und mit den in der Übung gezeigten Hilfsmitteln die Ausgabezeilen \"zusammenzubauen\""
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.10.5"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
--
GitLab