Dritte Übung und Lösung für Aufgabe 1 und 2

Uebung01/Uebung01_LSG.ipynb

+{
+ "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": 1,
+   "id": "592319ed-cc88-4291-8834-3b3db239f620",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "62.96227415999999"
+      ]
+     },
+     "execution_count": 1,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "3.2394**2*6 #Kommazahlen werden mit einem . geschrieben. Ein Würfel hat 6 Flächen. Jede Fläche hat den Inhalt Kantenlänge zum quadrat. Punkt- vor Strichrechnung funktioniert hierbei wie man es erwaten würde"
+   ]
+  },
+  {
+   "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": 3,
+   "id": "e6120a8a-9674-4057-abf7-ec0b362728e4",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "52.78\n",
+      "23.667\n"
+     ]
+    }
+   ],
+   "source": [
+    "h=2.3\n",
+    "b=4.9\n",
+    "t=2.1\n",
+    "flaeche=h*t*2 #Die linke und rechte fläche\n",
+    "flaeche+=h*b*2 #Die Fläche vorn und hinten\n",
+    "flaeche+=b*t*2 #Die Fläache oben und unten\n",
+    "print(flaeche)#die Gesamtfläche ausgeben\n",
+    "volumen=h*b*t #Das Volumen ist höhe mal breite mal tiefe\n",
+    "print(volumen)# Volumen ausgeben"
+   ]
+  },
+  {
+   "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": 4,
+   "id": "c30d3f3e-ab88-4141-88e7-06794115ae2f",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Der Quader hat die Abmessungen HxBxT\n",
+      "2.3\n",
+      "4.9\n",
+      "2.1\n",
+      "Die Oberfläche des Quaders ist\n",
+      "52.78\n",
+      "Das Volumen des Quaders ist\n",
+      "23.667\n"
+     ]
+    }
+   ],
+   "source": [
+    "h=2.3\n",
+    "b=4.9\n",
+    "t=2.1\n",
+    "print (\"Der Quader hat die Abmessungen HxBxT\")\n",
+    "print(h)\n",
+    "print(b)\n",
+    "print(t)\n",
+    "flaeche=h*t*2 #Die linke und rechte fläche\n",
+    "flaeche+=h*b*2 #Die Fläche vorn und hinten\n",
+    "flaeche+=b*t*2 #Die Fläache oben und unten\n",
+    "print(\"Die Oberfläche des Quaders ist\")\n",
+    "print(flaeche)#die Gesamtfläche ausgeben\n",
+    "print (\"Das Volumen des Quaders ist\")\n",
+    "volumen=h*b*t #Das Volumen ist höhe mal breite mal tiefe\n",
+    "print(volumen)# Volumen ausgeben"
+   ]
+  },
+  {
+   "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.8.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

Uebung02/Uebung02.ipynb → Uebung02/Uebung02_LSG.ipynb

@@ -64,11 +64,54 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 1,
    "id": "6b0c8c9d-f3b6-47fc-9de7-04f557ed5511",
    "metadata": {},
-   "outputs": [],
-   "source": []
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Die  25  Fibonacci-Zahl ist 46368\n"
+     ]
+    }
+   ],
+   "source": [
+    "fn_2=0\n",
+    "fn_1=1#definiert Variablen für die letzte und vorletzte Fibonacci Zahl\n",
+    "for i in range(3,26):#Eine Schleife, bei der i als Zählvariable bei 3 Anfängt und die Schleife bei i==25 endet\n",
+    "    fn=fn_2+fn_1 #Die aktuelle Fibonaci Zahl ist die Summer der beiden vorhergehenden. Beim ersten Schleifendurchlauf wird also die 3. Berechnet, weswegen i bei 3 startet\n",
+    "    fn_2=fn_1#Für die Berechnung der nächsten Fibonacci-Zahl ist die jetzt letzte Zahl die vorletzte\n",
+    "    fn_1=fn#und die gerade berechnete die letzte bekannte Fibonacci Zahl\n",
+    "print (\"Die \",i,\" Fibonacci-Zahl ist\",fn)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "da506129-3e45-4420-befb-478572d73bc6",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Die  25  Fibonacci-Zahl ist 46368\n"
+     ]
+    }
+   ],
+   "source": [
+    "#Alernativ kann man das ganze auch mit einer while-Schleife implementieren\n",
+    "fn_2=0\n",
+    "fn_1=1#definiert Variablen für die letzte und vorletzte Fibonacci Zahl\n",
+    "i=3#Die erste berechnete Fibonacci-Zahl wird die 3. sein\n",
+    "while i<=25: #so lange i kleiner oder gleich 25 ist\n",
+    "    fn=fn_2+fn_1 #Die aktuelle Fibonaci Zahl ist die Summer der beiden vorhergehenden. Beim ersten Schleifendurchlauf wird also die 3. Berechnet, weswegen i bei 3 startet\n",
+    "    fn_2=fn_1#Für die Berechnung der nächsten Fibonacci-Zahl ist die jetzt letzte Zahl die vorletzte\n",
+    "    fn_1=fn#und die gerade berechnete die letzte bekannte Fibonacci Zahl\n",
+    "    i+=1# hierbei nicht vergessen, dass die Zählvariable selbst weitergezählt werden muss\n",
+    "print (\"Die \",i-1,\" Fibonacci-Zahl ist\",fn)#Die Schleife zählt in ihrem letzten durchgang i noch eins weiter hoch, sodass in der Ausgabe i-1 stehen muss, das ließe sich auch anders Programmieren"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -83,19 +126,37 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 1,
    "id": "7309e508-227e-4431-901b-4125b0f8ed65",
    "metadata": {},
    "outputs": [],
-   "source": []
+   "source": [
+    "fn_2=0\n",
+    "fn_1=1\n",
+    "n=2"
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 6,
    "id": "8e27cc1a-62c2-4003-a6ab-4c8baff3cfaf",
    "metadata": {},
-   "outputs": [],
-   "source": []
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Die  7  Fibonacci-Zahl ist 8\n"
+     ]
+    }
+   ],
+   "source": [
+    "fn=fn_2+fn_1\n",
+    "n+=1\n",
+    "print (\"Die \",n,\" Fibonacci-Zahl ist\", fn)\n",
+    "fn_2=fn_1\n",
+    "fn_1=fn\n"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -126,11 +187,44 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 5,
    "id": "dc85e62c-a188-46ab-b7c5-55fc44d8bbbf",
    "metadata": {},
    "outputs": [],
-   "source": []
+   "source": [
+    "def Fib(nr):##Definition eine Funktion mit dem Namen Fib. Ein Parameter. Außerdem ein Hilfe-Text für help(Fib) (der Optional ist)\n",
+    "    \"\"\"\n",
+    "    Diese Funktion berechnet eine Fibonacci-Zahl\n",
+    "    \"\"\"\n",
+    "    fn_2=0#der Inhalt entspricht der Aufgabe 1\n",
+    "    fn_1=1\n",
+    "    for i in range(3,nr+1):#hier Aufpassen. Das Range Intervall enthält die zweite Zahl gerade nicht mehr. Um z.B. die 20 Zahl auszurechnen muss range(3,21) verwendet werden!\n",
+    "        fn=fn_2+fn_1\n",
+    "        fn_2=fn_1\n",
+    "        fn_1=fn\n",
+    "    return fn"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "0e9c8780-e30c-4b89-9e46-df58801dc17f",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "4181"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "Fib(20)"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -191,10 +285,30 @@
     "def ausgabe(name,wert):\n",
     "    print(\"Der Wert mit dem Namen \"+name+\" hat den Wert \"+str(wert))\n",
     "y=10\n",
-    "ausgabe(\"X\",5)\n",
+    "ausgabe(\"X\",5)#Diese Zeile\n",
     "ausgabe(\"Y\",y)"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "707035e8-7c5a-4391-9cee-8e62e3a6353f",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Der Wert mit dem Namen X hat den Wert 5\n"
+     ]
+    }
+   ],
+   "source": [
+    "name=\"X\"\n",
+    "wert=5\n",
+    "print(\"Der Wert mit dem Namen \"+name+\" hat den Wert \"+str(wert))"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "8a2f2e31-b96a-4fcd-9ce5-88d9d2c5cee4",
@@ -285,7 +399,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 22,
    "id": "38b648f0-321b-43ec-aeaf-82fd5efdefb7",
    "metadata": {},
    "outputs": [
@@ -480,19 +594,71 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 7,
    "id": "a13a6dc5-a537-4104-ae5c-6e6fb3700a69",
    "metadata": {},
    "outputs": [],
-   "source": []
+   "source": [
+    "def istPrimzahl(nr):#Eine Funktion definieren\n",
+    "    if nr==1:#Überprüfen ob der Parameter gleich 1 war. 1 ist per Definition keine Primzahl\n",
+    "        return False#Falls nr gleich 1 dann False zurückgeben, da 1 keine Primzahl. Das return beendet die Funktion. Daher wird in diesem Fall das folgende gar nicht mehr ausgeführt\n",
+    "    elif nr==0:#Das gleiche für die 0, die auch keine Primzahl ist\n",
+    "        return False\n",
+    "    for t in range(2,nr//2+1):#Für alle Zahlen t von 2 an bis nr//2 (da kann man aufhören da die Zahl durch größere Zahlen als ihre hälfte nicht ganzzahlig teilbar sein kann). Die +1 wieder aus dem selben Grund wie bei den Fibonacci-Zahlen\n",
+    "        if nr%t==0:#Falls die Zahl nr ganzzahlig durch t teilbar ist, ist sie keine Primzahl\n",
+    "            return False#Deswegen in diesem Fall False zurückgeben. Das beendet die Funktion und damit auch die Schleife. WI\n",
+    "    return True#Ist die Funktion bis hierhin ohne return durchgelaufen, was die Zahl nr durch keinen Testteiler teilbar. Sie ist eine Primzahl! Hier liegt der Grund, wieso die Fälle\n",
+    "                #nr==0 und nr==1 gesondert abgefangen werden mussten. in diesen Fällen wäre das range in der Schleife range(2,1), da 0//2==0 und 1//2==0. In diesem Fall wäre die Range\n",
+    "                #leer und die for schleife würde übersprungen bzw. 0 mal ausgeführt . Das würde dann immer ein True als Rückgabewert bedeuten, was in diesen beiden Fällen aber falsch ist."
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 9,
    "id": "b4c83fc4-ac7f-4384-a442-a7a268696085",
    "metadata": {},
-   "outputs": [],
-   "source": []
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2  ist eine Primzahl\n",
+      "3  ist eine Primzahl\n",
+      "5  ist eine Primzahl\n",
+      "7  ist eine Primzahl\n",
+      "11  ist eine Primzahl\n",
+      "13  ist eine Primzahl\n",
+      "17  ist eine Primzahl\n",
+      "19  ist eine Primzahl\n",
+      "23  ist eine Primzahl\n",
+      "29  ist eine Primzahl\n",
+      "31  ist eine Primzahl\n",
+      "37  ist eine Primzahl\n",
+      "41  ist eine Primzahl\n",
+      "43  ist eine Primzahl\n",
+      "47  ist eine Primzahl\n",
+      "53  ist eine Primzahl\n",
+      "59  ist eine Primzahl\n",
+      "61  ist eine Primzahl\n",
+      "67  ist eine Primzahl\n",
+      "71  ist eine Primzahl\n",
+      "73  ist eine Primzahl\n",
+      "79  ist eine Primzahl\n",
+      "83  ist eine Primzahl\n",
+      "89  ist eine Primzahl\n",
+      "97  ist eine Primzahl\n",
+      "es gibt 25  Primzahlen\n"
+     ]
+    }
+   ],
+   "source": [
+    "n=0#Ein Zähler für gefundene Primzahlen. Bis jetzt haben wir 0 Primzahlen gefunden\n",
+    "for x in range(0,101):#x läuft von 0 bis inklusive 100\n",
+    "    if istPrimzahl(x):#Testen ob x eine Primzahl ist\n",
+    "        print(x,\" ist eine Primzahl\")#Falls ja die Zahl ausgeben\n",
+    "        n+=1#Weil eine Primzahl gefunden wurde die Zahl der gefundenen Primzahlen um 1 erhöhen\n",
+    "print (\"es gibt\",n,\" Primzahlen\")# Ausgeben wie viele Primzahlen wir gefunden haben"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -531,21 +697,44 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 10,
    "id": "62f4cfe0-7e29-42eb-939f-87de2b568c13",
    "metadata": {},
    "outputs": [],
-   "source": []
+   "source": [
+    "def statistik(werte):#Eine Funktion statistik definieren. Der Parameter ist eine Liste von Werten\n",
+    "    mean=0#Eine Variable für den Mittelwert\n",
+    "    for x in werte:# x nimmt nacheinander den Wert aller Elemente der Liste an\n",
+    "        mean+=x #Den aktuellen Wert zum Mittelwert hinzuzählen\n",
+    "    mean/=len(werte)#An diesem Punkt ist mean die Summe aller Werte. Für den Mittelwert müssen wir durch die Anzahl der Werte in der Liste teilen\n",
+    "    sigma=0#Eine Variable für die Standardabwichung\n",
+    "    for x in werte:#Wir brauchen noch einmal eine Schleife über alle Werte der Liste\n",
+    "        sigma+=(x-mean)**2#Das quadrat der Differenz von Wert und Mittelwert zur Variable addieren\n",
+    "    sigma/=len(werte)#Und durch die Anzahl der Elemente teilen\n",
+    "    sigma=sigma**0.5#Anschließend die Wurzel berechnen. Das ist hoch 0.5\n",
+    "    return mean,sigma#Den Mittelwert und die Standardabweichung als Ergebnis zrückgeben"
+   ]
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": 11,
    "id": "12c1ee6c-2e1f-453f-b530-d89638bf1ecd",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Der Mittelwert ist 0.516335426194055\n",
+      "Die Standardabweichung ist:0.2891832330043811\n"
+     ]
+    }
+   ],
    "source": [
     "vals=[0.6964376821627082, 0.26266291048512347, 0.6745158617205556, 0.5288863107123398, 0.9274827629604636, 0.5243575061460061, 0.13385032676535535, 0.5411765303585021, 0.8198672857283978, 0.520437008812458, 0.562041573670414, 0.8561634972894122, 0.9623313631899726, 0.31907914320612074, 0.26119438987542387, 0.13520243670788368, 0.09469575247376472, 0.4246904822161435, 0.9133966307845354, 0.6420660225100518, 0.5785388233096391, 0.5238427408012839, 0.6647315475249502, 0.23571241136003973, 0.05961979239799975, 0.2165498289343185, 0.27159399814957363, 0.7655112819065766, 0.3431093024220383, 0.032247101142615864, 0.3015891143198096, 0.8097960606785481, 0.6796579318567529, 0.04436335567039129, 0.3407031394453095, 0.9458530157190131, 0.4218758395390574, 0.800645477912877, 0.7122317776120418, 0.16153560000189693, 0.8135112166616905, 0.6482516503330767, 0.19497040057189519, 0.7385295095967741, 0.5853177365981909, 0.7420310625532276, 0.9973422543876882, 0.6452433133176014, 0.08077974197489635, 0.46872138143040165, 0.4054095407349284, 0.9820027392529405, 0.1336574018638953, 0.7951695379763538, 0.526730196167776, 0.5838599467003179, 0.0101539445719665, 0.48955298718235196, 0.03312143865023964, 0.8037955706420147, 0.3720197208314814, 0.48910812354462607, 0.24786536056996467, 0.1308221105399613, 0.041839203867548025, 0.9577432390272803, 0.5173227078055732, 0.6214831882992236, 0.2735357256248029, 0.6800368701292161, 0.7925116477725586, 0.9995034932317471, 0.5874671327858604, 0.862421214533514, 0.528701106919735, 0.812381203902576, 0.5914815145860267, 0.6983657416025035, 0.9147650053289076, 0.1193325169156918, 0.2749890766516555, 0.7890513406461243, 0.10338960814994036, 0.497040228474409, 0.7482023492365272, 0.5720468814904877, 0.4042269451026068, 0.9831530451459302, 0.15738865410556224, 0.05169634869621442, 0.6801435501291248, 0.3197438911718855, 0.01245122578094271, 0.6284172563073083, 0.9055888582598005, 0.7634333890207554, 0.8039480668851395, 0.03594773926272621, 0.5331691153755076, 0.7424130320454684]\n",
-    "statistik(vals)"
+    "mean,sigma=statistik(vals)\n",
+    "print(\"Der Mittelwert ist\", mean)\n",
+    "print(\"Die Standardabweichung ist\", sigma,sep=\":\")"
    ]
   },
   {
@@ -559,7 +748,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 43,
    "id": "565d45c1-30f9-47bc-aed6-c95d29a744fd",
    "metadata": {},
    "outputs": [
@@ -695,7 +884,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 85,
+   "execution_count": 50,
    "id": "b138b8bb-6766-4e77-ba01-8606459aa438",
    "metadata": {},
    "outputs": [
@@ -704,7 +893,7 @@
      "output_type": "stream",
      "text": [
       "9\n",
-      "[9, 2, 3, 4, 5]\n"
+      "[9, 2, 3, 4, 5, 9]\n"
      ]
     }
    ],
@@ -715,6 +904,7 @@
     "var2=var1\n",
     "var2=12\n",
     "Liste2[0]=9\n",
+    "Liste1.append(9)\n",
     "print (var1)\n",
     "print (Liste1)"
    ]
@@ -729,7 +919,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 88,
+   "execution_count": 47,
    "id": "ecc55c5d-e9d2-40aa-b2bd-189f176c19be",
    "metadata": {},
    "outputs": [
@@ -737,15 +927,25 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Liste2 ist jetzt eine Zahl mit dem Wert  5\n",
-      "Liste1 ist weiterhin die Liste [9, 2, 3, 4, 5]\n"
+      "Liste2 ist jetzt eine Zahl mit dem Wert  5\n"
+     ]
+    },
+    {
+     "ename": "NameError",
+     "evalue": "name 'Liste1' 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 [47], line 3\u001b[0m\n\u001b[0;32m      1\u001b[0m Liste2\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m5\u001b[39m\n\u001b[0;32m      2\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mListe2 ist jetzt eine Zahl mit dem Wert \u001b[39m\u001b[38;5;124m\"\u001b[39m,Liste2)\n\u001b[1;32m----> 3\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mListe1 ist weiterhin die Liste\u001b[39m\u001b[38;5;124m\"\u001b[39m,Liste1,sep\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m:\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n",
+      "\u001b[1;31mNameError\u001b[0m: name 'Liste1' is not defined"
      ]
     }
    ],
    "source": [
     "Liste2=5\n",
     "print(\"Liste2 ist jetzt eine Zahl mit dem Wert \",Liste2)\n",
-    "print(\"Liste1 ist weiterhin die Liste\",Liste1)"
+    "print(\"Liste1 ist weiterhin die Liste\",Liste1,sep=\":\")"
    ]
   },
   {
@@ -828,6 +1028,21 @@
     "print(meineListe)"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "433c1215-837d-4f41-9816-c1d9475285f6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "meineListe=[1,2,3,4,5]\n",
+    "#meineFunktion()\n",
+    "parameter=meineListe\n",
+    "parameter[0]=10\n",
+    "#Ende meine Funktion\n",
+    "print(meineListe)"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "73036041-e0cd-48c8-8d8b-2a751e48413d",
@@ -951,7 +1166,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.5"
+   "version": "3.8.3"
   }
  },
  "nbformat": 4,

Uebung03/Uebung03.ipynb

+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "757b9a6c-6599-4cd6-93c5-c4fb30ed5b53",
+   "metadata": {},
+   "source": [
+    "# <font color='blue'>**Übung 3 - Objektorientierte Programmierung**</font>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d3a49027-9186-48a6-ba9f-332428e93bd9",
+   "metadata": {},
+   "source": [
+    "## <font color='blue'>**Die Grundlagen von Objektorientierter Programmierung**</font>\n",
+    "\n",
+    "In den vorherigen Übungen wurden die grundlegenden Elemente zur Ablaufsteuerung von Programmen behandelt. In dieser Übung führen wir ein wichtiges Konzept der Programmierung ein, die Objektorientierte Programmierung. Diese hilft sowohl bei der Strukturierung komplexer Projekte, der Verständlichkeit von Quellcode und dem gemeinsamen Arbeiten. Die Grundidee dahinter ist es, zusammengehörende Daten zusammen mit dazu passenden Operationen in (selbst) definierten Datentypen zusammenzufassen.    \n",
+    "\n",
+    "### **Weitere Notebooks, die dir helfen könnten**\n",
+    "* Python Grundlagen Teil 1\n",
+    "* Python Grundlagen Teil 2\n",
+    "* OOP Grundlagen\n",
+    "\n",
+    "### **Vorkenntnisse**\n",
+    "* Übung 1\n",
+    "* Übung 2\n",
+    "\n",
+    "### **Lernziele**\n",
+    "* Klassen und Objekte\n",
+    "* Attribute und Methoden\n",
+    "* Spezielle Methoden"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b0e426c9-9a66-4bc6-a0be-fc8e08c18858",
+   "metadata": {},
+   "source": [
+    "# <font color='blue'>**Abschnitt 1 - Einfache Klasse**</font>\n",
+    "## <font color='blue'>*Aufgabe*</font>\n",
+    "\n",
+    "Für den ersten Kontakt mit Klassen und Objekten wollen wir mit einem einfachen Alltagsbeispiel beginnen.\n",
+    "\n",
+    "Erstelle eine Klasse namens Artikel, mit dem ein Supermarkt seine Artikel verwalten kann. Die Artikel sollen einen Namen, eine Menge und einen Preis pro Mengeneinheit haben. Dazu soll die Datenstruktur Methoden besitzen, mit denen der Supermarkt den Lagerbestand auffüllen kann, sowie eine bestimmte Menge eines Artikels (soweit vorhanden) verkaufen kann. Beim Verkaufen soll eine Ausgabe über die verkaufte Menge, den Preis und die verbleibende Menge gegeben werden. Außerdem soll ermittelbar sein, wieviele verschiedene Artikel es gibt.\n",
+    "\n",
+    "Teste das Programm anhand eines Supermarktes der zu Beginn 500 kg Zucker zu 1 Euro pro kg, und 1000 kg Mehl zu 1,50 Euro pro kg auf Lager hat. Er füllt das Lager um 600 kg Zucker auf, und ein Kunde kauft 4 kg Mehl. Nutze die erstellte Klasse, um die neuen Lagerbestände zu ermitteln, sowie den vom Kunden gezahlten Preis.  "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b29c819a-aedd-4232-bcd7-eedcd810695c",
+   "metadata": {},
+   "source": [
+    "## <font color='blue'>*Lösung*</font>\n",
+    "\n",
+    "Klassendefinition und Instanziierung:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6b0c8c9d-f3b6-47fc-9de7-04f557ed5511",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d046ee6a",
+   "metadata": {},
+   "source": [
+    "Auffüll- und Verkaufsoperationen, sowie Testausgaben (beliebig oft wiederholbar):"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7b68c5f0",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c665968c",
+   "metadata": {},
+   "source": [
+    "## <font color='blue'>*Hinweise*</font>\n",
+    "\n",
+    "Es soll eine Klasse und ein Hauptprogramm erstellt werden. In dem Hauptprogramm sollen Objekte der Klasse verwendet werden, um die beispielhafte Testaufgabe zu erfüllen. Natürlich kannst du dich hier auch frei austoben und mehrere Verkäufe machen, oder testen, ob die Klasse beim Verkaufen korrekt erkennt, wenn nicht genug auf Lager ist. Es darf keine negativen Mengen geben.\n",
+    "\n",
+    "Wir machen folgende Vorschläge für die Namen der Klasse, Attribute und Methoden:\n",
+    "Klasse ```Artikel```,\n",
+    "Attribute ```anz_artikel```, ```menge```, ```preis```, ```name```\n",
+    "Methoden ```__init__()```, ```auffuellen()```, ```verkaufen()```\n",
+    "\n",
+    "Für die Syntax benötigst du Informationen aus dem Grunlagen OOP Notebook. Für diesen Abschnitt benötigst du Klassen und Objekte, Klassen- und Objektattribute, sowie Objektmethoden.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "46d21f3a-b37e-49d3-864f-587b09ba0b89",
+   "metadata": {},
+   "source": [
+    "# <font color='blue'>**Abschnitt 2 - Vektorrechnungen**</font>\n",
+    "\n",
+    "Nachdem du nun erste Erfahrungen mit der Objektorientierten Programmierung gemacht hast, wollen wir uns einem mathematischeren Thema widmen. Dabei wollen wir auch das Thema spezielle Methoden (auch magic method genannt) einführen. Diese erlauben es uns in dieser Aufgabe, Vektorrechnung mit den bekannten Operatoren wie mit \"normalen\" Variablen auch, durchzuführen."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6e25b06f",
+   "metadata": {},
+   "source": [
+    "## <font color='blue'>*Aufgabe*</font>\n",
+    "\n",
+    "Berechne den Betrag des Vektors  c = a-b, mit den Vektoren a = (1,2,3) und b = (5,-4,3). Außerdem soll das Skalarprodukt mit a * b berechnet werden. Erstelle dazu eine Klasse ```Vektor3``` für die dreidimensionalen Vektoren so, dass die bereits gegebenen Codezeilen erfolgreich ausgeführt werden können."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e7333454-be6d-487d-a39e-ba509472aa30",
+   "metadata": {
+    "tags": []
+   },
+   "source": [
+    "## <font color='blue'>*Lösung*</font>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4d5ce741-9f03-4e88-b10a-be8d223ef9e5",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "dc85e62c-a188-46ab-b7c5-55fc44d8bbbf",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "a = Vektor3([1,2,3])\n",
+    "b = Vektor3([5,-4,3])\n",
+    "\n",
+    "c = a-b\n",
+    "\n",
+    "print(\"Betrag des Vektors c: \" + str(c.get_betrag()))\n",
+    "print(\"Skalarprodukt a * b: \" + str(a*b))\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ac9ba52d",
+   "metadata": {},
+   "source": [
+    "## <font color='blue'>*Hinweise*</font>\n",
+    "\n",
+    "Nun benötigst du noch den Abschnitt über spezielle Methoden aus dem OOP-Grundlagen Notebook. Diese erlauben es, die Methoden so zu definieren, dass die Operationen wie a-b mit den selbst definierten Vektoren funktionieren.\n",
+    "\n",
+    "Es ist dir selbst überlassen, ob du die Einträge der Vektoren als eine Liste, oder als drei einzelne Werte speicherst.\n",
+    "\n",
+    "Das Ergebnis einer Summe oder Differenz ist ein neuer Vektor.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "595a83db-5a61-4048-84d3-e5f1ca14c263",
+   "metadata": {},
+   "source": [
+    "# <font color='blue'>**Aufgabe zum selbst probieren**</font>\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ca559a03-b79b-4f1a-a128-4e3e3e177017",
+   "metadata": {},
+   "source": [
+    "Erweitere die Vektorklasse um weitere Operationen, die dir sinnvoll erscheinen. Ebenso könnte es interessant sein, die Beschränkung auf 3 Dimensionen aufzuheben. Beachte dabei, dass die Operationen bestimmte Anforderungen haben. So funktioniert das Kreuzprodukt nur mit Vektoren mit drei Dimensionen, Addition und Substraktion nur für Vektoren gleicher Dimension etc. Die Funktionen müssen das dann überprüfen, ob sie selbst und auch der andere Operand die geforderte länge haben.\n",
+    "\n",
+    "\n",
+    "## <font color='blue'>**Lösung**</font>\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6a4e935d-1468-41be-a175-71505b044a38",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "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
+}