From f16751a67ba9518b750df1d6c9bd17d13222699d Mon Sep 17 00:00:00 2001
From: Malte Woidt <m.woidt@tu-braunschweig.de>
Date: Wed, 9 Nov 2022 02:20:12 +0100
Subject: [PATCH] =?UTF-8?q?Unterlagen=20der=20zweiten=20=C3=9Cbung?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
Uebung01/Python_Grundlagen.ipynb | 2 +-
Uebung01/Uebung01.ipynb | 2 +-
Uebung02/Python_Grundlagen2.ipynb | 1525 +++++++++++++++++++++++++++++
Uebung02/Uebung02.ipynb | 959 ++++++++++++++++++
4 files changed, 2486 insertions(+), 2 deletions(-)
create mode 100644 Uebung02/Python_Grundlagen2.ipynb
create mode 100644 Uebung02/Uebung02.ipynb
diff --git a/Uebung01/Python_Grundlagen.ipynb b/Uebung01/Python_Grundlagen.ipynb
index a8e74e6..c87af8e 100644
--- a/Uebung01/Python_Grundlagen.ipynb
+++ b/Uebung01/Python_Grundlagen.ipynb
@@ -1099,7 +1099,7 @@
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
- "version": "3.10.5"
+ "version": "3.8.3"
}
},
"nbformat": 4,
diff --git a/Uebung01/Uebung01.ipynb b/Uebung01/Uebung01.ipynb
index 995752c..56db5a4 100644
--- a/Uebung01/Uebung01.ipynb
+++ b/Uebung01/Uebung01.ipynb
@@ -517,7 +517,7 @@
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
- "version": "3.10.5"
+ "version": "3.8.3"
}
},
"nbformat": 4,
diff --git a/Uebung02/Python_Grundlagen2.ipynb b/Uebung02/Python_Grundlagen2.ipynb
new file mode 100644
index 0000000..b9a5afa
--- /dev/null
+++ b/Uebung02/Python_Grundlagen2.ipynb
@@ -0,0 +1,1525 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "6d96dde1-9930-415b-a59b-399676ec1733",
+ "metadata": {},
+ "source": [
+ "# <font color='blue'>**Einleitendes Thema**</font>\n",
+ "Dieses Notebook umfasst den Grundlagen-Teil zu Python, der in der zweiten Übung benötigt wird. Nach der nächsten Übung werde ich die Grundlagen-Notebooks zu einem Dokument zusammenfassen, in dem du alles über die Python-Grundlagen nachlesen kannst, falls du in späteren Teilen der Übung noch einmal etwas wissen möchtest. Wie im letzten Notebook enthält dieses Notebook neben zwingend benötigten Informationen auch immer ein paar weiterführende Informationen, die bei vielen Problemen praktisch sein können"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bab513b6-7981-4bc9-b756-4a9a5ae042e7",
+ "metadata": {},
+ "source": [
+ "# <font color='blue'>**Ãœbersicht - Python Grundlagen2**</font>\n",
+ "### <font color='blue'>*Lernziele des Notebooks*</font>\n",
+ "Das Notebook ist in mehrere thematische Abschnitte gegliedert.\n",
+ "\n",
+ "* [Syntax und Begriffe](#Syntax)\n",
+ "* [Datentypen](#Datentypen)\n",
+ "* [Verzweigungen](#Verzweigungen)\n",
+ "* [Schleifen](#Schleifen)\n",
+ "* [Funktionen](#Funkt)\n",
+ "* [wichtige Funtkionen](#STDFunc)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c56b4a88-583e-4b3a-b0ad-78d2c129df2b",
+ "metadata": {},
+ "source": [
+ "# <font color='blue'> **Syntax** </font> <a name=\"Syntax\"> </a>\n",
+ "## <font color='blue'>*Codeblöcke*</font>\n",
+ "In Python-Programmen gibt es Situationen, in denen mehrere Programmzeilen zusammengehören. Z.b. bei Funktionen, Schleifen oder Verzweigungen. Eine Funktion kann beliebig viele Zeilen enthalten. Um kenntlich zu machen, wo sie endet, werden Codeblöcke verwendet. Ein Codeblock sind in Python mehrere aufeinanderfolgende Zeilen, die eingerückt sind. Zeilen, auf die ein Codeblock folgen muss, enden mit einem ':'. Codeblöcke können verschachtelt sein. Ein Beispiel:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "e8974314-d043-4e16-8fdf-127e160705bc",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def eineFunktion(x):#auf ein : folgt ein Codeblock\n",
+ " print(x)#Ein Codeblock ist eingerückt\n",
+ " if x==0:# auf ein : folgt ein neuer Codeblock\n",
+ " print (\"X ist gleich Null\")#dieser muss weiter eingerückt sein\n",
+ " return#Diese Zeile gehört wieder zum Codeblock der Funktion\n",
+ " "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "12f9838d-2a96-430e-9dc3-c44d6bb949fb",
+ "metadata": {},
+ "source": [
+ "Es ist dabei prinzipiell egal, wie weit ein Code-Block eingerückt wird. Einzige Regel ist, dass ein Code-Block in einem Codeblock weiter als der umschließende Code-Block eingerückt sein muss und alle Zeilen eines Codeblocks gleich weit eingerückt sein müssen. Es ist auch nötig einen Code-Block einzurücken, wenn er nur aus einer Zeile besteht. Zum Einrücken dürfen Leerzeichen und 'Tab' verwendet werden. Man sollte allerdings beachten, dass ein 'Tab' und ein Leerzeichen in Python nich das selbe ist und keine Zuordnung besteht, wie viele Leerzeichen ein 'Tab' entspricht.\\\n",
+ "Aus Erfahrung ist eine gute Regel, einen Codeblock 4 Leerzeichen tiefer einzurücken, als seine Umgebung. Das ist auch in der Code-Zelle so gemacht. Editoren die für Python-Programmierung gedacht sind, wie auch Jupyter-Notebooks, erzeugen beim Eingeben eines 'Tab' automatisch 4 Leerzeichen. Bei Editoren, die das nicht tun, ist optisch sehr schwer zu unterscheiden, welches Zeichen am Anfang der Zeile steht, da sowohl 'Tab' und Leerzeichen zwei getrennte Symbole im ASCII-Code (der einfachsten Möglichkeit Text in binären Dateien zu speichern) sind. Das löst später Fehler aus, die schwer zu finden sind und deswegen ist die Verwendung des 'Tab'-Symbols eine schlechte Idee. Bei Jupyter-Notebook als Editor (und fast jedem anderen für Python gedachten Editor), ist die Eingabe von 4 Leerzeichen über die Tab-Taste der Tastatur aber kein Problem.\\\n",
+ "Soll ein Code-Block leer bleiben (z.B. weil man den Inhalt später programmieren möchte), muss er mindestens aus einer Zeile mit dem inhalt *pass* bestehen.\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "00f62d26-632b-40c6-8d6f-7ab857b9b3aa",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def eineFunktionDieNichtsTut():\n",
+ " pass\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5fb15d0c-b05f-45dd-a8e7-033f59ec9268",
+ "metadata": {},
+ "source": [
+ "## <font color='blue'>*Documentation-Strings und das help-System*</font>\n",
+ "Eine Funktion kann in einer bestimmten Art dokumentiert werden, um mit der *help* Funktion von Python zu funktionieren. Dazu wird einfach ein ggf. Mehrzeiliger Kommentar direkt nach der Definitions-Zeile der Funktion gesetzt. Der Inhalt wird dann von *help* angezeigt. Der Kommentar muss wie der folgende Code-Block eingerückt sein"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "b9822308-58a8-4d33-8866-69eb277b89ac",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Help on function meineFunktion in module __main__:\n",
+ "\n",
+ "meineFunktion()\n",
+ " Diese Funktion tut eigentlich gar nichts\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "def meineFunktion():\n",
+ " \"\"\"\n",
+ " Diese Funktion tut eigentlich gar nichts\n",
+ " \"\"\"\n",
+ " pass\n",
+ "\n",
+ "help(meineFunktion)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1b932071-e452-4bd1-ad7d-aeb31a612df6",
+ "metadata": {},
+ "source": [
+ "## <font color='blue'>*Boolscher Ausdruck*</font>\n",
+ "Der Begriff *boolscher Ausdruck* kommt häufiger vor. Er bezieht sich auf einen Ausdruck, der entweder *True* oder *False* ergibt. Also z.B. einen Vergleich zweier Zahlen etc.. Eine if-Abfrage benötigt z.B. einen boolschen Ausdruck um zu bestimmen, an welcher Stelle das Programm weiter geht. Aus \"Gewohnheit\" anderer Programmiersprachen können auch ganze Zahlen verwendet werden. Eine 0 bedeutet dabei *False*, jede andere Zahl *True*. In Hinsicht auf lesbaren Quellcode sollte man von dieser Möglichkeit allerdings keinen Gebrauch machen"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5a911685-6d0a-4d98-a9a5-19ebd884fc40",
+ "metadata": {},
+ "source": [
+ "# <font color='blue'> **Datentypen** </font> <a name=\"Datentypen\"> </a>\n",
+ "## <font color='blue'>*Listen*</font>\n",
+ "Listen sind ein Datentyp in Python mit dem namen *list*. Sie stellen eine Liste dar, die beliebig viele Werte enthalten kann. Die Werte müssen nicht den selben Datentyp besitzen. Listen können sogar Listen als Elemente besitzen. Die Elemente der Liste werden von 0 ausgehend indiziert. Sie können über eckige Klammern als Literal erzeugt werden. Die einzelnen Elemente werden dabei mit *,* getrennt. Auf die einzelnen Elemente kann mit einem Operator zugegriffen werden. Es sind eckige Klammern hinter der Liste, in denen denen ein index steht"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "7190b8c1-9962-43a5-afd7-979f50bb2c68",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "3\n",
+ "Apfel\n"
+ ]
+ }
+ ],
+ "source": [
+ "eineListe=[3,2,\"Apfel\",0.3]\n",
+ "print(eineListe[0])\n",
+ "print(eineListe[2])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a702824a-214e-4ee0-a59a-49fbd3fd4503",
+ "metadata": {},
+ "source": [
+ "Die Länge einer Liste kann mit *len* ermittelt werden"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "94b02b13-20d9-4bf9-be0c-e0a6ecde5594",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "4\n"
+ ]
+ }
+ ],
+ "source": [
+ "eineListe=[3,2,\"Apfel\",0.3]\n",
+ "print(len(eineListe))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9b58aa7b-4331-4462-b5b3-70e010543595",
+ "metadata": {},
+ "source": [
+ "Listen sind mutable-Objects. Sie können verändert werden. Zum Beispiel können Elemente neu zugewisen werden"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "842e45ce-a760-44ba-be95-b53985519159",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "['neues erstes Element', 2, 'Apfel', 0.3]\n"
+ ]
+ }
+ ],
+ "source": [
+ "eineListe=[3,2,\"Apfel\",0.3]\n",
+ "eineListe[0]=\"neues erstes Element\"\n",
+ "print (eineListe)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5b37db27-5f0f-4d3c-b6a8-19e9637dee58",
+ "metadata": {},
+ "source": [
+ "An eine Liste können neue Elemente angehängt werden:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "58a32990-c491-4e01-95e6-0dcb3c2aaf71",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[3, 2, 'Apfel', 0.3, 'neues Element', 'neues Element']\n"
+ ]
+ }
+ ],
+ "source": [
+ "eineListe=[3,2,\"Apfel\",0.3]\n",
+ "eineListe.append(\"neues Element\")\n",
+ "eineListe.append(\"neues Element\")\n",
+ "print (eineListe)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a35ab2e3-bffa-417b-8356-c0f939234bfe",
+ "metadata": {},
+ "source": [
+ "Aus einer Liste können Elemente gelöscht werden. Das geht einmal, indem ein Element mit einem bestimmten Wert gelöscht wird. Es wird immer das letzte Element mit diesem Wert gelöscht!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "39347685-8d1d-4eea-a815-c773bdb8a3a7",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[3, 2, 'Apfel', 0.3, 'neues Element']\n"
+ ]
+ }
+ ],
+ "source": [
+ "eineListe=[3, 2, 'Apfel', 0.3, 'neues Element', 'neues Element']\n",
+ "eineListe.remove(\"neues Element\")\n",
+ "print(eineListe)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2ec360f9-f9f4-42db-8ca4-392cdb9e0d87",
+ "metadata": {},
+ "source": [
+ "Es kann auch ein Element mit einem bestimmten Index gelöscht werden"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "id": "9ec6db60-ed5d-4a90-a496-ba7317c344e9",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[2, 'Apfel', 0.3]\n"
+ ]
+ }
+ ],
+ "source": [
+ "eineListe=[3, 2, 'Apfel', 0.3]\n",
+ "del(eineListe[0])\n",
+ "print(eineListe)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "05f69918-2e07-413b-8c24-61d740522338",
+ "metadata": {},
+ "source": [
+ "Außerdem kann das letzte Element einer Liste entfernt und zurückgegeben werden. Das wäre alternativ auch über die bereits gezeigten Funktionen möglich, funktioniert so aber einfacher."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "id": "72af9201-6a31-4b32-99a7-4f06d553ef6c",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[3, 2, 'Apfel']\n",
+ "das gelöschte Element hatte den Wert 0.3\n"
+ ]
+ }
+ ],
+ "source": [
+ "eineListe=[3, 2, 'Apfel', 0.3]\n",
+ "elem=eineListe.pop()\n",
+ "print(eineListe)\n",
+ "print(\"das gelöschte Element hatte den Wert \",elem)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5e21ddcb-eccc-46ef-95a8-559c6c6c7083",
+ "metadata": {},
+ "source": [
+ "### Indexing und Slicing\n",
+ "Neben der Indexierung von 0 an können auch negative Indizes verwendet werden. -1 steht für das letzte Element der Liste, -2 für das vorletzte etc. In beiden Richtungen darf mit der Indizierung die Länge der Lite nicht überschritten werden, da das einen Fehler auslöst"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "id": "1c8d9c27-81e5-43df-befb-e646ef99049c",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "8\n",
+ "7\n"
+ ]
+ }
+ ],
+ "source": [
+ "eineListe=[1,2,3,4,5,6,7,8]\n",
+ "print(eineListe[-1])\n",
+ "print(eineListe[-2])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cff27297-f7af-48b9-8773-ec4cce928ecf",
+ "metadata": {},
+ "source": [
+ "Als Slicing wird das erstellen einer Teilliste aus einer Liste bezeichnet. Die Teilliste ist immer eine echte Kopie der Ursprungsliste. Die Ursprungsliste wird nicht verändert. Für Das Slicing wird der *:* verwendet. Zum Beispiel können das 4,5 und 6 Element einer Liste als neue Liste erstellt werden. Ähnlich wie bei *range* bezeichnet die erste Zahl das erste Element, das in der Teilliste enthalten ist, die zweite Zahl der erste Element, das nicht mehr enthalten ist"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "id": "06c9ab21-3d0c-490a-b5d1-e0ed9bdd4f95",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[5, 6, 7]\n"
+ ]
+ }
+ ],
+ "source": [
+ "eineListe=[1,2,3,4,5,6,7,8]\n",
+ "print(eineListe[4:7])#Ergebnis enthält die Elemente 4,5 und 6 der Ursprungsliste"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8d01f05f-def8-45c1-83b2-5048d715f4f4",
+ "metadata": {},
+ "source": [
+ "Ein Element kann auch durch seinen \"negativen Index\", also vom Ende her gezählt, angegeben werden. Der Slice behält allerdings immer die selbe Richtung, wie die Ursprüngliche Liste. Ist der Index hinter dem Doppelpunkt kleiner als der vor dem Doppelpunkt, wird eine leere Liste zurückgegeben"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "id": "c09a498e-624e-433b-b239-03b7f9009339",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[1, 2, 3, 4, 5, 6, 7]\n",
+ "[1, 2, 3, 4, 5]\n",
+ "[]\n"
+ ]
+ }
+ ],
+ "source": [
+ "eineListe=[1,2,3,4,5,6,7,8]\n",
+ "print(eineListe[0:-1])#enthält alle Elemente der Liste, bis auf das letzte\n",
+ "print(eineListe[0:-3])\n",
+ "print(eineListe[-1:-3])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ac85a715-087e-4a91-be38-c47fdf8472d8",
+ "metadata": {},
+ "source": [
+ "Es ist auch möglich einen zweiten Doppelpunkt einzufügen, um zusätzlich nur z.B. jedes 2te Element auszuwählen"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 18,
+ "id": "fc563b4b-ed67-4fb1-b86f-b1c1d560be26",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[2, 4, 6]\n"
+ ]
+ }
+ ],
+ "source": [
+ "eineListe=[1,2,3,4,5,6,7,8]\n",
+ "print (eineListe[1:-1:2])#Enthält das Element 1,3 und 5. Die -1 entspricht dem Element 7, das damit nicht enthalten ist"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5086e388-6716-47c1-919e-beefb777b1ba",
+ "metadata": {},
+ "source": [
+ "Wird die Zahl vor, oder nach dem ersten Doppelpunkt weggelassen, fängt der Slice beim ersten Element an, bzw. geht bis zum letzten Element. Es können auch beide weggelassen werden. Das erzeugt eine Kopie der kompletten Liste, da Slices immer Kopien sind"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 20,
+ "id": "e70a2133-2065-45ae-a771-a5d089e61318",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[1, 2, 3, 4, 5, 6, 7, 8]\n",
+ "[1, 2, 3, 4, 5, 6, 7]\n"
+ ]
+ }
+ ],
+ "source": [
+ "eineListe=[1,2,3,4,5,6,7,8]\n",
+ "listeZwei=eineListe[:]#ListeZwei ist eine komplette Kopie von eineListe\n",
+ "print(listeZwei)\n",
+ "print(eineListe[:-1])#enthält alle Elemente, bis auf das letzte"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6e151f22-fedd-4933-91a7-2207632591ce",
+ "metadata": {},
+ "source": [
+ "\n",
+ "# <font color='blue'>*Tupel*</font>\n",
+ "Tupel sind den Listen sehr ähnlich, nur das sie immutable-Objects sind. Das heißt, man kann auf Elemente zugreifen, aber die Elemente nicht verändern und weder Elemente löschen, noch hinzufügen. Im Bezug auf ihre Indexierung und das Slicing verhalten sie sich wie Listen. Sie werden mit runden Klammern erzeugt"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 100,
+ "id": "4abc4557-2c28-4f03-8547-c190091dcd29",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "einTupel=(1,2,3)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2c0b7f06-52ad-4742-8638-998241526fd9",
+ "metadata": {},
+ "source": [
+ "man begegnet Tupeln sehr selten explizit. Sie werden z.B. von Funktionen mit mehreren Rückgabewerten zurückgegeben, oder bei Funktionen mit variabler Parameterzahl genutzt. Ihre Besonderheit besteht im sogenannten \"automatic unpacking\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 102,
+ "id": "f844479d-f604-4caf-b61c-fb59d88b0f0d",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "1\n",
+ "Apfel\n",
+ "3\n"
+ ]
+ }
+ ],
+ "source": [
+ "a,b,c=(1,\"Apfel\",3)\n",
+ "print(a)\n",
+ "print(b)\n",
+ "print(c)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fd95c9fc-23d7-4aae-9fbb-891450a5eeb0",
+ "metadata": {},
+ "source": [
+ "So kann man auf einmal mehreren Variablen in einer Zeile einen Wert zuweisen. Tupel tauchen in Python im Verborgenen sehr häufig auf. Schaue dir z.B. die Funktion *zip* weiter unten an, die sehr praktisch ist.\n",
+ "Tupel können auch als Parameterliste beim Funktionsaufruf entpackt werden. Das geht allerdings nicht automatisch, sondern mit einem *. Das ist aber eher ein exotisches Anwendungsbeispiel"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 27,
+ "id": "5881c41d-91c5-4378-a2c6-eeb1438b2f6b",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "3 hallo apfel\n"
+ ]
+ }
+ ],
+ "source": [
+ "def funktion(a,b,c):\n",
+ " print (a,b,c)\n",
+ "einTupel=(3,\"hallo\",\"apfel\")\n",
+ "funktion(*einTupel)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a55eb167-9512-4181-9e68-594112295a2f",
+ "metadata": {},
+ "source": [
+ "## <font color='blue'>*Dictionaries*</font>\n",
+ "Dictionaries haben den Datentypen *dict*. Sie Werden über geschweifte Klammern definiert. Sie stellen sogenannte assoziative Listen dar, auch als Schlüssel-Wert Tabelle bezeichnet. In weiten Teilen funktionieren Dictionaries wie Listen, nur dass die Elemente nicht durchnummeriert sind, sondern jedes Element einen Schlüssel hat. Als Schlüssel können beliebige Werte verwendet werden, die mit dem *==* Operator vergleichbar sind. Also z.B. Zahlen oder Zeichenketten. In Einem Dictionary können auch Schlüssel verschiedener Typen verwendet werden. Zu jedem Schlüssel existiert ein Wert"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 21,
+ "id": "2a7dc78a-29bb-4189-bf3f-626053b0ec13",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Gelb\n",
+ "hat keine Farbe\n"
+ ]
+ }
+ ],
+ "source": [
+ "Farben={\"Apfel\":\"Gelb\",\"Auto\":\"Grün\",7:\"hat keine Farbe\"}\n",
+ "print(Farben[\"Apfel\"])\n",
+ "print(Farben[7])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a248370f-921b-4b65-923f-561e7b71823e",
+ "metadata": {},
+ "source": [
+ "Wie auch Listen sind Dictionaries mutable-Objects. Werte können verändert und neue Schlüssel hinzugefügt werden. Schlüssel können auch gelöscht werden"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 119,
+ "id": "52a4bd3a-d14b-40ad-ae06-02bdfc12d14b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "Farben[\"Apfel\"]=\"Rot\" #Ändert einen Wert\n",
+ "Farben[\"Sonne\"]=\"Gelb\" #fügt einen Schlüssel mit Wert hinzu\n",
+ "del(Farben[7])#Löscht den unsinnigen Schlüssel"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "21365ded-40f4-434f-a819-2b257a0305b3",
+ "metadata": {},
+ "source": [
+ "Wie auch über Listen können for-Schleifen über Dictionaries laufen. Dabei nimmt die Laufvariable standardmäßig die Werte der Schlüssel an"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 120,
+ "id": "da28b7d8-96c2-44fb-b37d-6b6d1d84b9a8",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Apfel\n",
+ "Auto\n",
+ "Sonne\n"
+ ]
+ }
+ ],
+ "source": [
+ "for x in Farben:\n",
+ " print(x)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cbc6a52b-2725-46fd-bbfb-e8fe8d300152",
+ "metadata": {},
+ "source": [
+ "Falls man über die Werte iterieren möchte, was gelegentlich auch praktisch vorkommt, geht das auch"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 122,
+ "id": "d1639439-084b-4172-a81e-0a5621e2ff89",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Rot\n",
+ "Grün\n",
+ "Gelb\n"
+ ]
+ }
+ ],
+ "source": [
+ "for x in Farben.values():\n",
+ " print(x)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b81ee375-582a-4e16-a64f-53029d602a8a",
+ "metadata": {},
+ "source": [
+ "Die Funktion Farben.values() generiert dabei etwas ähnliches wie eine Liste aus den Werten des Dictionaries. Die Elemente der Dictionaries folgen nicht zwingend einer logischen Reihenfolge in den for-Schleifen."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8fd71347-061b-45a3-8fca-785f716b3725",
+ "metadata": {},
+ "source": [
+ "# <font color='blue'> **Verzweigungen** </font> <a name=\"Verzweigungen\"> </a>\n",
+ "## Formale Beschreibung der Syntax\n",
+ "**if** \\<boolscher Ausdruck\\> :\\\n",
+ " Codeblock\\\n",
+ "**{elif** \\<boolscher Ausdruck\\>:\\\n",
+ " Codeblock **}** optional, beliebig oft wiederholbar \\\n",
+ "**{else** :\\\n",
+ " Codeblock **}** optional \n",
+ "## Erklärung\n",
+ "An vielen Stellen eines Programms ist es nötig, den Programmfluss bedingt aufzuteilen. Das soll heißen, eine Entscheidung zu treffen, was als nächstes geschehen Soll. Ein einfaches Beispiel, das für sich selbst spricht:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "id": "8d703152-4a03-4dc3-b4a5-efd7e75318bc",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "2 ist größer 1\n",
+ "Hier geht das Programm in jedem Fall weiter\n"
+ ]
+ }
+ ],
+ "source": [
+ "x=2\n",
+ "if x>1:\n",
+ " print(x,\" ist größer 1\")\n",
+ "else:\n",
+ " print(x, \"ist kleiner oder gleich eins\")\n",
+ "print (\"Hier geht das Programm in jedem Fall weiter\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "55cd13b8-749a-43c8-86e4-ebeb8db482e7",
+ "metadata": {},
+ "source": [
+ "Dabei wird eine Bedingung in Form eines boolschen Ausdrucks formuliert und je nachdem wie, das Ergebnis dieses Ausdrucks ausgewertet wird, wird der eine oder der andere Programmpfad eingeschlagen. Falls der Ausdruck *True* ergibt, folgt der Programmpfad dem Codeblock hinter dem *if*, ansonsten dem Codeblock hinter dem *else*. Anschließend läuft das Programm weiter. Das *else* darf optional weggelassen werden. In diesem Fall wird der Codeblock hinter dem *if* ausgeführt, wenn der boolsche Ausdruck *True* ergibt, ansonsten wird der Block übersprungen. Das *else* muss direkt auf den Code-Block des *if* folgen\\\n",
+ "Bei mehr als 2 Optionen steht das Keyword *elif* zur Verfügung, das für else-if, also eine Kombination steht"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "id": "a7cbfb29-afb9-4444-9304-a919585a0190",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "2 ist genau 2\n"
+ ]
+ }
+ ],
+ "source": [
+ "x=2\n",
+ "if x<2:\n",
+ " print (x,\" ist kleiner als 2\")\n",
+ "elif x==2:\n",
+ " print (x,\" ist genau 2\")\n",
+ "elif x==3:\n",
+ " print (x,\" ist genau 3\")\n",
+ "else:\n",
+ " print(x, \"ist größer als 3\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "df9758a7-3a0b-484e-98a4-2ec562116ce3",
+ "metadata": {},
+ "source": [
+ "Die Logik ist, dass zu erst der boolsche Ausdruck hinter dem *if* geprüft wird und ggf. der Code-Block hinter *if* ausgeführt wird. Wenn der Ausdruck *False* ergibt und nur dann, wird der boolsche Ausdruck des ersten *elif* geprüft. Ist es *True*, wird der entsprechende Codeblock ausgeführt. Ansonsten wird zum ggf. vorhanden nächsten *elif* und seinem boolschen Ausdruck weitergegangen. Es kann also beliebig viele *elif* Ausdrücke geben (eben auch 0 davon, was zum ersten Fall führt). Falls keiner ausgeführt wurde, wird der Codeblock vom *else* ausgeführt, der auch hier optional ist. Es wird insgesammt also immer maximal ein Code-Block ausgeführt, oder ggf. keiner, wenn das optionale *else* nicht vorhanden ist.\\\n",
+ "Frage:\n",
+ "Was passiert wenn du in der letzten Codezelle z.B. ein 2.5 für x einträgst?"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "91971230-a3f7-4d61-aa1f-5fb0fee3bfae",
+ "metadata": {},
+ "source": [
+ "# <font color='blue'> **Schleifen** </font> <a name=\"Schleifen\"> </a>\n",
+ "Schleifen sind Möglichkeiten, einen Code-Block mehrmals zu durchlaufen. In Python gibt es zwei Arten von Schleifen.\n",
+ "## <font color='blue'>*for-Schleifen*</font>\n",
+ "Sind die vermutlich häufiger genutzten Schleifen\n",
+ "## Formale Beschreibung der Syntax\n",
+ "**for** \\<Variablenname\\> **in** \\<iterierbares Objekt\\> **:** \\\n",
+ " Codeblock\n",
+ "## Beschreibung\n",
+ "Eine for-Schleife besitzt eine Zähl-Variable. Der Name ist frei wählbar. Diese Variable nimmt nacheinander den Wert der einzelnen Elemente eines iterierbaren Objekts an. Für jeden Wert, den die Variable annimmt wird der Codeblock einmal durchlaufen. Die Variable ist dabei innerhalb des Codeblocks als Variable nutzbar. Nach Beendigung des Codeblocks ist die Zählervariable weiterhin verfügbar.\\\n",
+ "Ein iterierbares Objekt ist im einfachsten Fall eine Liste oder ein Dictionary. Bei Einer Liste werden die Elemente in der Reihenfolge, in der sie in der Liste stehen, durchlaufen"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "id": "305daac1-7ce2-4ada-b243-995b363bb16c",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "1\n",
+ "2\n",
+ "3\n",
+ "0\n",
+ "2\n",
+ "3\n",
+ "1\n",
+ "Die Variable x hatte im letzten Durchlauf der Schleife den Wert 1\n"
+ ]
+ }
+ ],
+ "source": [
+ "for x in [1,2,3,0,2,3,1]:\n",
+ " print(x)\n",
+ "print (\"Die Variable x hatte im letzten Durchlauf der Schleife den Wert\",x)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "610eb112-9035-409b-954f-4d5d40e2e8e2",
+ "metadata": {},
+ "source": [
+ "Falls die Zählvariable über ein bestimmtes Interval laufen soll, kann die Funktion *range* verwendet werden. Siehe das Kapitel über range"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 18,
+ "id": "bf3ed766-7c1e-470a-82dd-ca5af7234a58",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "2\n",
+ "3\n",
+ "4\n"
+ ]
+ }
+ ],
+ "source": [
+ "for i in range(2,5):\n",
+ " print (i)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a062192a-6642-47bb-8cf8-560ab14c6c9b",
+ "metadata": {},
+ "source": [
+ "Im Verlauf der Übung werden wir noch andere Möglichkeiten kennen lernen, iterierbare Objetkte zu erzeugen. Ein großer Vorteil der for-Schleife gegenüber der while-Schleife ist, dass es nicht so einfach ist, Endlosschleifen zu erzeugen (es gibt iterierbare Objekte mit unendlich vielen Elementen, was aber eher selten ist).\n",
+ "\n",
+ "Es gibt außerdem die Möglichkeit zwei oder mehr Zählvariablen zu verwenden. Dazu siehe die Funktion *zip*. Das kann auch verwendet werden, um die Anzahl der Durchläufe einer for-Schleife zu zählen"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cb1fbafe-3474-4801-9932-0fc88c603212",
+ "metadata": {},
+ "source": [
+ "## <font color='blue'>*while-Schleifen*</font>\n",
+ "## Formale Beschreibung der Syntax\n",
+ "**while** \\<boolscher Ausdruck\\> **:** \\\n",
+ " Codeblock\n",
+ "## Beschreibung\n",
+ "while-Schleifen führen ihren Code-Block so lange aus, bis der boolsche Ausdruck hinter dem while *False* wird. Die Überprüfung des boolschen Ausdrucks findet immer vor der Ausführung des Code-Blocks statt, sodass es möglich ist, dass die Schleife 0-mal durchlaufen wird, der Code-Block also übersprungen wird."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 22,
+ "id": "446f94a9-3c60-4c8f-bf13-ff4417c28598",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "0\n",
+ "1\n",
+ "2\n",
+ "3\n"
+ ]
+ }
+ ],
+ "source": [
+ "i=0\n",
+ "while i<4:\n",
+ " print(i)\n",
+ " i+=1"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "27c3a307-15c3-4446-ab1c-054d187e00a0",
+ "metadata": {},
+ "source": [
+ "Diese Art von Schleife gibt es so gut wie in jeder Programmiersprache. Man muss aufpassen, dass der boolsche Ausdruck auch irgendwann *False* wird, da die Schleife sonst endlos weiterläuft. Wenn man z.B. das Hochzählen in der Variablen i vergisst, wird die Variable niemals größer oder gleich 4, womit die Schleife ewig läuft.\n",
+ "Diese Form der Schleife ist zusammen mit *break* sehr vielseitig einsetzbar."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "4183acfa-0afd-424e-a989-256a0326305d",
+ "metadata": {},
+ "source": [
+ "## <font color='blue'>*weitere Besonderheiten beider Schleifentypen*</font>\n",
+ "### break\n",
+ "*break* kann innerhalb einer Schleife verwendet werden, um die Ausführung der Schleife zu beenden. Der Codeblock wird an der Stelle des *break* verlassen (ähnlich wie bei *return*) und die Ausführung der Schleife beendet. Unabhängig, ob bei der for-Schleife noch weitere Elemente folgen würden, oder ob der boolsche Ausdruck der while-Schleife noch *True* ist. Dabei darf *break* auch innerhalb einer if-else-Abfrage in der Schleife stehen. Die nächste umgebene Schleife wird beendet (*break* darf allerdings nicht innerhalb einer Funktion, die innerhalb einer Schleife aufgerufen wurde stehen. Das funktioniert nicht mehr)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 24,
+ "id": "47f1027a-0e88-4ac8-a6d1-a860ff688bb2",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "i ist 0\n",
+ "i ist 1\n",
+ "i ist 2\n",
+ "i ist 3\n",
+ "bei i ist 4 wird die Schleife an dieser Stelle verlassen\n"
+ ]
+ }
+ ],
+ "source": [
+ "i=0\n",
+ "while True:\n",
+ " if i==4:\n",
+ " print (\"bei i ist 4 wird die Schleife an dieser Stelle verlassen\")\n",
+ " break\n",
+ " print (\"i ist\",i)\n",
+ " i+=1"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9920fce0-14fa-469a-bf67-780c73b19a70",
+ "metadata": {},
+ "source": [
+ "wie im Beispiel zu erkennen, kommt die Schleife bei ihrem Durchlauf für 'i==4' nicht mehr bei der *print*-Answisung unter dem *break* an."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "208adf05-6d8e-42b8-a9c8-72a384a059ba",
+ "metadata": {},
+ "source": [
+ "### continue\n",
+ "*continue* funktioniert ähnlich dem *break*. Der Code-Block wird beim *continue* verlassen, bzw. der Rest des Code-Blocks überspungen. Allerdings wird die Schleife nicht beendet. Falls der boolsche Ausdruck der while Schleife noch *True* ist, oder bei der for-Schleife noch weitere Elemente vorhanden sind, geht die Schleife normal mit dem nächsten Durchlauf des Code-Blocks weiter. Dabei darf *continue* auch innerhalb einer if-else-Abfrage in der Schleife stehen (*continue* darf allerdings nicht innerhalb einer Funktion, die innerhalb einer Schleife aufgerufen wurde stehen. Das funktioniert nicht mehr)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 23,
+ "id": "fb74c30e-0fe7-4a16-926a-bb47a522a3a3",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "i ist jetzt 0\n",
+ "i ist jetzt 1\n",
+ "i ist jetzt 2\n",
+ "Wir überspringen die normale Ausgabe für die 3\n",
+ "i ist jetzt 4\n",
+ "i ist jetzt 5\n",
+ "i ist jetzt 6\n",
+ "i ist jetzt 7\n"
+ ]
+ }
+ ],
+ "source": [
+ "for i in range(0,8):\n",
+ " if i==3:\n",
+ " print(\"Wir überspringen die normale Ausgabe für die 3\")\n",
+ " continue\n",
+ " print (\"i ist jetzt\",i)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2bbafb2f-3fee-4b2f-90bd-c721a3e94edd",
+ "metadata": {},
+ "source": [
+ "### else\n",
+ "das *else* darf auch im Anschluss an Schleifen optional verwendet werden. Der Code-Block wird ausgeführt, wenn die Schleife nicht mit *break* beendet wurde, also komplett durchlaufen wurde. Dieses Verhalten erscheint etwas merkwürdig, es ist in der Praxis aber tatsächlich in manchen Fällen praktisch. Ein Beispiel:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 24,
+ "id": "de2a2fb3-dca1-4d64-ae03-248b3b34e77d",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Die Stadt Braunschweig liegt in Deutschland\n",
+ "Die Stadt Paris wurde nicht gefunden\n"
+ ]
+ }
+ ],
+ "source": [
+ "deutsche_staedte=[\"Braunschweig\",\"Erfurt\",\"Magdeburg\"]\n",
+ "def sucheStadt(name,staedte):\n",
+ " for x in staedte:\n",
+ " if x==name:\n",
+ " print (\"Die Stadt \"+name+\" liegt in Deutschland\")\n",
+ " break\n",
+ " else:\n",
+ " print (\"Die Stadt \"+ name+ \" wurde nicht gefunden\")\n",
+ "sucheStadt(\"Braunschweig\",deutsche_staedte)\n",
+ "sucheStadt(\"Paris\",deutsche_staedte)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8124efd5-cd06-4107-830c-56cc98e1280c",
+ "metadata": {},
+ "source": [
+ "# <font color='blue'> **Funktionen** </font> <a name=\"Funkt\"> </a>"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "32cfb153-4c37-4729-84ea-b75a24eba111",
+ "metadata": {},
+ "source": [
+ "Funktionen, oder Unterprogramme können genutzt werden, um ein Programm zu strukturieren und Codeabschnitte wiederzuverwenden\n",
+ "### Formale Beschreibung der Syntax\n",
+ "**def** \\<Funktionsname\\> (parameterliste) **:** \\\n",
+ " Codeblock\n",
+ "### Erklärung\n",
+ "In einer Funktion kann ein beliebig langer Abschnitt eines Programms unter einem Namen zusammengefasst werden. Der Programmabschnitt kann dann mit diesem Namen aufgerufen werden. Dadurch wird der in der Funktion enthaltene Quelltext einmal komplett ausgeführt. Dass kann innerhalb eines Programms auch mehrfach passieren, sodass Programmabschnitte, die mehrfach in einem Programm vorkommen, wiederverwendet werden können.\n",
+ "Funktionen werden in einem Programm durch ihren Namen gefolgt von runden Klammern aufgerufen "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 53,
+ "id": "9d8ca0b0-f5d3-47a3-a4ce-f030f64f1bce",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Inhalt der Funktion\n",
+ "Inhalt der Funktion\n"
+ ]
+ }
+ ],
+ "source": [
+ "def eineFunktion():\n",
+ " print(\"Inhalt der Funktion\")\n",
+ "eineFunktion()\n",
+ "eineFunktion()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "484d941a-07f9-418c-a24a-6ad1e1d23883",
+ "metadata": {},
+ "source": [
+ "Variablen, die innerhalb einer Funktion definiert werden, sind standardmäßig lokale Variablen. Sie können nur innerhalb der Funktion verwendet werden. Bei der Beendigung der Funktion wird sämtlicher lokaler Zustand der Funktion gelöscht (also die lokalen Variablen, die zu diesem Funktionsaufruf gehören). Wird in einer Funktion eine weitere Funktion aufgerufen, hat auch diese keinen Zugriff auf die lokalen Variablen der aufrufenden Funktion.} Auf globale Variablen kann zugegriffen werden, so lange keine lokale Variable gleichen Namens potentiell in der Funktion erzeugt wird, der Variablen also ein neuer Wert mit dem Zuweisungsoperator zugewiesen wird. Es wird nicht überprüft, ob der Code überhaupt erreichbar ist!\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 39,
+ "id": "46ff8f9c-712c-4f7b-a7da-e9ff9f8ef9b2",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def Testfunktion():#Diese Funktion kann auf keine globale Variable mit dem Namen x Zugreien, da potentiell eine Variable gleichen Namens erzeugt wird. Auch wenn der Code hinter dem return niemals erreicht werden kann!\n",
+ " return\n",
+ " x=3"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0803cbb1-988f-47ec-b451-93f6e6512cdf",
+ "metadata": {},
+ "source": [
+ "#### return\n",
+ "Funktionen können Werte als Ergenis ihres Aufrufs zurückgeben. Das Funktioniert mit dem Keyword *return*. Das beendet gleichzeitig die Ausführung der Funktion an dieser Stelle! Das Return kann auch ohne Ergebnis verwendet werden, um die Ausführung der Funktion zu beenden. Das geht auch aus if-else Konstruktionen oder Schleifen heraus"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 25,
+ "id": "75bb7898-438a-4e6d-8ce9-e7715503ce25",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Das Ergebnis ist 3\n"
+ ]
+ }
+ ],
+ "source": [
+ "def gibDrei():\n",
+ " return 3\n",
+ "print(\"Das Ergebnis ist\",gibDrei())"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e6f473d9-f20e-4e4d-a5cd-2fbfe7047a1b",
+ "metadata": {},
+ "source": [
+ "Eine Funktion kann auch mehrere Werte zurückgeben. Genau betrachtet gibt die Funktion allerdings ein Tupel zurück"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 55,
+ "id": "0d5e18c6-686f-461d-8f4e-fe534b432c98",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "(3, 5)\n",
+ "3 5\n"
+ ]
+ }
+ ],
+ "source": [
+ "def zweiWerte():\n",
+ " return 3,5\n",
+ "a=zweiWerte() #Ergebnis als Tuple\n",
+ "print (a)\n",
+ "x,y = zweiWerte() # mit Unpacking\n",
+ "print(x,y)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e1d9813e-5395-42fb-a2d7-e9fa08cce8c3",
+ "metadata": {},
+ "source": [
+ "#### Parameterlisten\n",
+ "Funktionen können optional Parameter erhalten. Diese werden innerhalb der Funktion wie normale, lokale Variablen behandelt. Der Startwert bei Ausführung der Funktion muss beim Aufruf übergeben werden. Mehrere Parameter werden mit einem Komma getrennt"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 43,
+ "id": "6edc369c-c685-46e6-af1b-b252285b65a8",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "5\n"
+ ]
+ }
+ ],
+ "source": [
+ "def addiere(a,b):\n",
+ " return a+b\n",
+ "print(addiere(3,2))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "49b8a576-79db-4092-a1f3-163cf3637301",
+ "metadata": {},
+ "source": [
+ "Für einzelne Parameter dürfen Standardwerte angegeben werden. Diese Parameter müssen am Ende der Parameterliste stehen und dürfen beim Aufruf weggelassen werden. Die Funktion wird dann mit dem Standardwert gestartet"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 44,
+ "id": "f41d10b4-76b4-497d-a353-d8c8afa5d7bc",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "6\n",
+ "8\n"
+ ]
+ }
+ ],
+ "source": [
+ "def addiere(a,b=3):\n",
+ " return a+b\n",
+ "print (addiere(3))#gleichbedeutend mit addiere(3,3), da der zweite Parameter standardmäßig 3 ist\n",
+ "print (addiere(3,5))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "17400d59-90d2-469f-a091-fd0a1800fac5",
+ "metadata": {},
+ "source": [
+ "Bei Funktionen mit vielen optionalen Parametern, ist es manchmal sinnvoll Parameter nicht nach Position, sondern nach Namen zu übergeben. Das ist prinzipiell auch möglich."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 46,
+ "id": "c86bdea4-81b9-4265-97a7-701f3ccced92",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "1 3 4 letzter Parameter\n"
+ ]
+ }
+ ],
+ "source": [
+ "def benannteParameter(a,b=3,c=4,d=5):\n",
+ " print (a,b,c,d)\n",
+ "benannteParameter(1,d=\"letzter Parameter\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fe12c1e0-aa6c-4e3a-b408-05fb5377bbb5",
+ "metadata": {},
+ "source": [
+ "Python Funktionen können auch eine variable Anzahl an Parametern haben. Diese sind innerhalb der Funktion als Tupel vorhanden. Das funktioniert mit einem * Symbol"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 49,
+ "id": "761dda55-73ee-4ede-b450-c68b5f47a1b6",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "ich\n",
+ "akzeptiere\n",
+ "beliebig\n",
+ "viele\n",
+ "Parameter\n"
+ ]
+ }
+ ],
+ "source": [
+ "def VarFunktion(*mehrereParameter):\n",
+ " for x in mehrereParameter:\n",
+ " print (x)\n",
+ "VarFunktion(\"ich\",\"akzeptiere\",\"beliebig\",\"viele\",\"Parameter\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "36f405fe-2dbe-45dd-946b-b4049069b684",
+ "metadata": {},
+ "source": [
+ "Es gibt noch weiter Möglichkeiten von Parameterlisten, z.B. eine beliebige Anzahl an Parametern, die beim Aufruf zusätzlich benannt werden können. Für eine vollständige Beschreibung kannst du in die offizielle Python-Dokumentation schauen."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "81a79184-461a-4d2d-ace2-837c732adb2a",
+ "metadata": {},
+ "source": [
+ "#### global\n",
+ "Soll durch die Zuweisung einer Variablen keine lokale Variable erzeugt werden, sondern eine globale Variable erzeugt oder neu zugewiesen werden, funktioniert das mit dem Keyword global"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 52,
+ "id": "f800c97c-c078-410c-981d-036cede092d1",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "10\n"
+ ]
+ }
+ ],
+ "source": [
+ "def funktion():\n",
+ " global x #im folgenden Verlauf der Funktion ist x immer eine globale Variable\n",
+ " x=10 #erzeugt eine globale Variable mit dem Namen x oder weißt ihr einen neuen Wert zu\n",
+ "funktion()\n",
+ "print (x)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c5d11b85-f34f-4855-9387-a217c60ad3ec",
+ "metadata": {},
+ "source": [
+ "# <font color='blue'> **wichtige, vordefinierte Funktionen** </font> <a name=\"STDFunc\"> </a>\n",
+ "## <font color='blue'>range</font>"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e23f7e5f-dd8a-42e8-bbe1-eca51f76182c",
+ "metadata": {},
+ "source": [
+ "range erzeugt ein iterierbares Objekt, dass ganze Zahlen in einem gegebenen Intervall erzeugt. Es kann für for-Schleifen verwendet werden. Es kann allerdings genauso in eine Liste überführt werden, was hier zu Demonstrationszwecken gemacht wird. Wird muss mit mindestens einem Parameter aufgerufen werden. Bei einem Parameter, ist dieser Parameter die Obergrenze des Intervalls, die selbst allerdings nicht enthalten ist"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 57,
+ "id": "83f38ca2-513b-4900-b863-66b598dc8e4f",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[0, 1, 2, 3]"
+ ]
+ },
+ "execution_count": 57,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "list(range(4))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "848b619d-bb17-4835-b3dd-51d50b0986ea",
+ "metadata": {},
+ "source": [
+ "*range* kann auch mit zwei Parametern aufgerufen werden.Dabei bestimmt der erste Parameter den Startwert des Intervalls (der enthalten ist) und der zweite Parameter das Ende des Intervalls (das selbst nicht enthalten ist)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 58,
+ "id": "ddc2c57e-378b-4292-a9f3-0699dfd15fe3",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[2, 3, 4, 5, 6, 7, 8]"
+ ]
+ },
+ "execution_count": 58,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "list(range(2,9))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5db0a2ec-e9fc-4349-b972-4b2a70d4c2bd",
+ "metadata": {},
+ "source": [
+ "Optional kann als dritter Parameter noch die Schrittweite zwischen den Elementen des Intervalls angegeben werden"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 59,
+ "id": "12c859a4-29dd-4ac6-9d1e-4dea3142ea80",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "[2, 4, 6, 8]"
+ ]
+ },
+ "execution_count": 59,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "list(range(2,9,2))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a67b1a58-b914-40bd-9428-d4a5562d2ae6",
+ "metadata": {},
+ "source": [
+ "## <font color='blue'>len</font>\n",
+ "*len* erwartet als Argument ein Objekt, das iterierbar ist, also in for-Schleifen verwendet werden kann, und gibt die Länge dieses Objekts zurück. Das funktioniert beispielsweise mit Zeichenketten, Listen, Tupeln, Dictionaries und vielen anderen Objekten"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "257d4d61-ffd9-4e6a-bc5a-e22f977a713f",
+ "metadata": {},
+ "source": [
+ "## <font color='blue'>zip</font>\n",
+ "erzeugt aus zwei oder mehr iterierbaren Objekten, z.B. zwei Listen, eine neues iterierbares Objekt mit der Länge des kürzesten Parameters und der Logik:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 105,
+ "id": "d999cddb-0256-496f-9af1-dc7afe9fdd3f",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd')]\n"
+ ]
+ }
+ ],
+ "source": [
+ "liste1=[1,2,3,4]\n",
+ "liste2=[\"a\",\"b\",\"c\",\"d\"]\n",
+ "erg=zip(liste1,liste2)\n",
+ "print(list(erg))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 106,
+ "id": "373fc764-1257-463f-b165-2882ed518320",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[(1, 'a'), (2, 'b'), (3, 'c')]\n"
+ ]
+ }
+ ],
+ "source": [
+ "liste1=[1,2,3,4]\n",
+ "liste2=[\"a\",\"b\",\"c\"]\n",
+ "erg=zip(liste1,liste2)\n",
+ "print(list(erg))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "62704d35-7eb1-43c3-8360-e2e2d5bd7f7d",
+ "metadata": {},
+ "source": [
+ "Sinn ist es, über zwei Listen gleichzeitig in einer for-Schleife iterieren zu können"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 109,
+ "id": "1c94a548-ce0e-4760-9161-e38b9e92f9e0",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Das Element aus liste1 ist 1\n",
+ "Das Element aus liste2 ist a\n",
+ "Das Element aus liste1 ist 2\n",
+ "Das Element aus liste2 ist b\n",
+ "Das Element aus liste1 ist 3\n",
+ "Das Element aus liste2 ist c\n"
+ ]
+ }
+ ],
+ "source": [
+ "for zahl,buchstabe in zip(liste1,liste2):\n",
+ " print(\"Das Element aus liste1 ist \",zahl)\n",
+ " print(\"Das Element aus liste2 ist \",buchstabe)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "49f79e88-7afc-4848-bcf0-c1280c929143",
+ "metadata": {},
+ "source": [
+ "Man kann auch bei einer Schleife über eine Liste mitzählen, beim wie vielten Element man gerade ist. Das wird sehr häufig in der Praxis benötigt"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 110,
+ "id": "ced4b45c-570c-479d-8c2e-7228000f9e0e",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Durchlauf nummer 0 Das Listenelement ist a\n",
+ "Durchlauf nummer 1 Das Listenelement ist b\n",
+ "Durchlauf nummer 2 Das Listenelement ist c\n"
+ ]
+ }
+ ],
+ "source": [
+ "liste2=[\"a\",\"b\",\"c\"]\n",
+ "for element,x in zip(liste2,range(len(liste2))):\n",
+ " print (\"Durchlauf nummer \",x, \"Das Listenelement ist \",element)"
+ ]
+ }
+ ],
+ "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/Uebung02/Uebung02.ipynb b/Uebung02/Uebung02.ipynb
new file mode 100644
index 0000000..370f570
--- /dev/null
+++ b/Uebung02/Uebung02.ipynb
@@ -0,0 +1,959 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "757b9a6c-6599-4cd6-93c5-c4fb30ed5b53",
+ "metadata": {},
+ "source": [
+ "# <font color='blue'>**Ãœbung 2 - Steuerung des Programmablaufs**</font>"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d3a49027-9186-48a6-ba9f-332428e93bd9",
+ "metadata": {},
+ "source": [
+ "## <font color='blue'>**Die Grundlagen von Python Teil 2**</font>\n",
+ "Dieses Notebook wird in der zweiten Übung verwendet. Im ersten Teil der Python Grundlagen wurden Zahlen, Zeichenketten und Variablen behandelt. Die Übungsprogramme haben Rechenabläufe automatisiert, der Programmablauf innerhalb der Programme war aber immer linear und bei jeder Ausführung gleich, von den vorgegebenen Zahlenwerten abgesehen. Um wirklich sinnvolle Programme schreiben zu können reicht das noch nicht aus. In dieser Übung wird gezeigt, wie sich der Programmablauf verändern lässt. Außerdem wird die Liste als neuer Variablentyp eingeführt, die etwas anderen Regeln folgt als die bisher gezeigten Variablen. Wie in folgenden Notebooks, musst du dir für diese Übung etwas mehr Informationen aus dem Grundlagen-Notebook zusammensuchen. Die Regeln über lokale und globale Variablen und die mutable-Objects sind in diesem Notebook etwas detaillierter in ihrer Theorie beschrieben. Auch wenn nicht alles davon unmittelbar in dieser Übung wichtig wird, ist dieses grundsätzliche Verhalten für folgende Übungen immer wieder wichtig und gerade ohne Programmiererfahrung etwas schwierig zu durchblicken.\\\n",
+ "Die Aufgaben in dieser Übung erfüllen schon eher einen konkreten Zweck, in der nächsten Übung werden wir anfangen, auch konkrete Ingenieursproblem zu betrachten.\n",
+ "\n",
+ "### **Weitere Notebooks, die dir helfen könnten**\n",
+ "* Python Grundlagen Teil 1\n",
+ "* Python Grundlagen Teil 2\n",
+ "\n",
+ "### **Vorkenntnisse**\n",
+ "* Ãœbung 1\n",
+ "\n",
+ "### **Lernziele**\n",
+ "* Schleifen\n",
+ "* Funktionen\n",
+ "* Verzweigungen\n",
+ "* Listen\n",
+ "* lokale und globale Variablen\n",
+ "* mutable Objects"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b0e426c9-9a66-4bc6-a0be-fc8e08c18858",
+ "metadata": {},
+ "source": [
+ "# <font color='blue'>**Abschnitt 1 - Schleifen**</font>\n",
+ "## <font color='blue'>*Aufgabe*</font>\n",
+ "Berechne die 25. Fibonacci-Zahl\n",
+ "## <font color='blue'>*Grundlagen*</font>\n",
+ "Die Fibonacci-Zahlen sind eine Folge ganzer Zahlen. In der hier verwendeten Definition beginnt die Folge mit:\n",
+ "\n",
+ "$0,1,1,2,3,5,8,13,...$\n",
+ "\n",
+ "Für die Zahlen gilt die Berechnungsvorschrift\\\n",
+ "$f_{n}=f_{n-2}+f_{n-1}$ wenn $n>=3$\\\n",
+ "$f_{1}=0$\\\n",
+ "$f_{2}=1$\n",
+ "\n",
+ "d.h. nach den ersten beiden vorgegebenen Zahlen ist jede Zahl die Summe ihrer beiden vorhergehenden Zahlen."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b29c819a-aedd-4232-bcd7-eedcd810695c",
+ "metadata": {},
+ "source": [
+ "## <font color='blue'>*Lösung*</font>"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "6b0c8c9d-f3b6-47fc-9de7-04f557ed5511",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "4086f815-c7a9-42d5-84ce-0068818069b7",
+ "metadata": {
+ "tags": []
+ },
+ "source": [
+ "## <font color='blue'>*Hintergründe*</font>\n",
+ "Mit den Informationen aus der ersten Übung sollte es dir bereits möglich sein zwei Zellen zu Programmieren, wobei die Zweite Zelle das Gewünschte Ergebnis nach 23 maliger Ausführung liefert. Probiere es einfach aus. Du brauchst für die Berechnung einer Fibonacci-Zahl die beiden vorhergehenden Zahlen. Definiere zwei Variablen fn_2 und fn_1 für die vorletzte und letzte Fiboncci-Zahl (also $f_{n-2}$ und $f_{n-1}$) und initialisiere sie mit 0 und 1, den ersten beiden Elementen der Folge. In einer zweiten Zelle kannst du das fn ($f_{n}$), also die nächste Fibonacci-Zahl aus den beiden anderen Variablen berechnen. Um für den nächsten Durchlauf alles vorzubereiten, speicherst du die Zahl aus fn_1 in fn_2 und die Zahl aus fn in fn_1. Damit wird beim nächsten Ausführen der Zelle die nächste Fibonacci-Zahl berechnet"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "7309e508-227e-4431-901b-4125b0f8ed65",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "8e27cc1a-62c2-4003-a6ab-4c8baff3cfaf",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a9309ddf-6566-4b7c-aa99-65df4a673004",
+ "metadata": {},
+ "source": [
+ "Natürlich ist dieses Vorgehen nicht besonders zielführend. Du müsstest den Quellcode der zweiten Zelle mehrmals automatisch ausführen können. Das bezeichnet man als Schleife. Du kanst dir entsprechende Möglichkeiten im Grundlagen-Notebook anschauen und dir die Möglichkeit aussuchen, die dir besser gefällt. Wenn du die Zählervariable der Schleife bei 3 beginnen lässt, dann kannst du mit ihr auch ermitteln, welche Fibonacci-Zahl du tatsächlich berechnet hast."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "46d21f3a-b37e-49d3-864f-587b09ba0b89",
+ "metadata": {},
+ "source": [
+ "# <font color='blue'>**Abschnitt 2 - Funktionen**</font>\n",
+ "Ermögliche eine komfortablere Möglichkeit, beliebige Fibonacci-Zahlen zu berechnen. Erstelle dazu eine Funktion mit dem Namen \"Fib\", die als Parameter eine Zahl übergeben bekommt die bestimmt, die wie vielte Fibonacci-Zahl berechnet werden soll. Du kannst hierfür davon ausgehen, dass nur Parameter größer oder gleich 3 eingegeben werden. Die Fibonacci-Zahl sollte deine Funktion sinnvollerweise als Ergebnis zurückliefern\n"
+ ]
+ },
+ {
+ "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": "dc85e62c-a188-46ab-b7c5-55fc44d8bbbf",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ba7ac092-04ed-4dac-99a6-9e4f702bd8f9",
+ "metadata": {},
+ "source": [
+ "## <font color='blue'>*Grundlagen*</font>\n",
+ "Funktionen werden manchmal auch als Unterprogramme bezeichnet, was genauer beschreibt, was sie sind. In einer Funktion kann ein beliebig langer Abschnitt eines Programms unter einem Namen zusammengefasst werden. Der Programmabschnitt kann dann mit diesem Namen ausgeführt werden. Dadurch wird der in der Funktion enthaltene Quelltext einmal komplett ausgeführt. Dass kann innerhalb eines Programms auch mehrfach passieren, sodass Programmabschnitte, die mehrfach in einem Programm vorkommen, wiederverwendet werden können."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 20,
+ "id": "38945dd8-5519-4e80-8ae8-e1856287ac48",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Ausgabe von Text aus einer Funktion\n",
+ "Ausgabe von Text aus einer Funktion\n"
+ ]
+ }
+ ],
+ "source": [
+ "def ausgabe():\n",
+ " print (\"Ausgabe von Text aus einer Funktion\")\n",
+ " \n",
+ "ausgabe()\n",
+ "ausgabe()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f64925ee-5bc6-4fb6-a3ae-34fa4ecb0bfd",
+ "metadata": {},
+ "source": [
+ "Funktionen können optional Parameter besitzen. Diese werden in den runden Klammern angegeben. Die Parameter können bei der Definition der Funktion beliebig benannt werden und stehen dann innerhalb der Funktion als Variablen bereit. Den Wert, den diese Variablen am Start der Funktion haben, wird beim Aufruf der Funktion angegeben"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 61,
+ "id": "c239c355-f89f-4c6a-9be1-7d5b50cf8c9e",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Der Wert mit dem Namen X hat den Wert 5\n",
+ "Der Wert mit dem Namen Y hat den Wert 10\n"
+ ]
+ }
+ ],
+ "source": [
+ "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(\"Y\",y)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8a2f2e31-b96a-4fcd-9ce5-88d9d2c5cee4",
+ "metadata": {},
+ "source": [
+ "In diesem Beispiel wird die Funktion *ausgabe* mit zwei Parametern aufgerufen. \"X\" und 5. Statt einem Festwert können auch die Werte einer Variablen verwendet werden. Wenn die Funktion aufgerufen wird, muss die Anzahl der Parameter der Anzahl an Parametern in der Funktionsdefinition entsprechen. In diesem Fall werden die Parameter beim Aufruf in der selben Reihenfolge angegeben, wie sie in der Definition erscheinen. Im Grundlagen-Notebook sind weitere Möglichkeiten beschrieben.\\\n",
+ "Wird eine Funktion ausgeführt, werden zu erst lokale Variablen mit dem Namen, wie in der Funktionsdefinition angegeben, erzeugt. Diesen wird dann das \"X\" und die 5 zugewiesen. Das Verhalten entspricht dabei dem des Zusweisungsoperators. Anschließend wird die Funktion ausgeführt. Die Variablen *name* und *wert* sind dabei lokale Variablen der Funktion. Das heißt, dass sie nach Beendigung der Funktion gelöscht werden.\\\n",
+ "Funktionen können auch Werte zurückgeben. Zum Beispiel wenn sie etwas berechnet haben. Das Funktioniert mit einem *return*"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 22,
+ "id": "5a7265f9-0db7-4972-8a68-40381455fd29",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "10\n"
+ ]
+ }
+ ],
+ "source": [
+ "def addiere(x,y):\n",
+ " return x+y\n",
+ "y=addiere(3,2)\n",
+ "print(addiere(y,5))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "30600ff2-390a-4f5d-abae-310f67cc4dfd",
+ "metadata": {},
+ "source": [
+ "Das *return* beendet die Ausführung der Funktion sofort. Wenn noch Anweisungen hinter dem *return* stehen, werden diese nicht ausgeführt. Das *return* kann auch ohne anschließenden Wert verwendet werden, um die Funktion einfach nur zu beenden. Der Funktionsaufruf liefert einen Wert, als ob an der Stelle des Funktionsaufrufs eine Variable oder ein Festwert stehen würde. Daher kann das Ergebnis einer Funktion einer Variablen zugewiesen werden, oder auch direkt als Funktionsparameter (z.B. für print) verwendet werden.\n",
+ "Wenn ein Funktionsaufruf beendet wird, dann geht das Programm dort weiter, wo es durch den Funktionsaufruf unterbrochen wurde. Innerhalb einer Funktion können also weitere Funktionen aufgerufen werden"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 64,
+ "id": "7fcac190-6fbf-461a-a458-6916577529f5",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Funktion 2 startet\n",
+ "Funktion 1 startet\n",
+ "Funktion 1 endet\n",
+ "Funktion 2 endet\n"
+ ]
+ }
+ ],
+ "source": [
+ "def funktion1():\n",
+ " print(\"Funktion 1 startet\")\n",
+ " print (\"Funktion 1 endet\")\n",
+ "def funktion2():\n",
+ " print(\"Funktion 2 startet\")\n",
+ " funktion1()\n",
+ " print(\"Funktion 2 endet\")\n",
+ "funktion2()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e858cbbf-331e-458b-ba55-907b2eb53a72",
+ "metadata": {},
+ "source": [
+ "### lokale und globale Variablen in Python\n",
+ "In Python werden globale und lokale Variablen unterschieden. Das sind Ausdrücke mit denen die Sichtbarkeit und die Lebensdauer von Variablen beschrieben wird. In Python unterliegen die Regeln für diese Unterscheidung teilweise impliziten Regeln. Diese Regeln sind nicht zwingend logisch, sondern einfach definiert.\n",
+ "Eine kurze Beschreibung der Regeln:\n",
+ "* Auf globale Variablen kann überall im Programm zugegriffen werden\n",
+ "* Auf eine lokale Variable kann nur innerhalb der Funktion zugegriffen werden, in der sie erstellt wurde. Sie wird am Ende der Funktion wieder gelöscht\n",
+ "* Eine Variable die Außerhalb jeglicher Funktion definiert wird ist immer eine globale Variable \n",
+ "* Eine Variable, die innerhalb einer Funktion definiert wird, ist standardmäßig immer eine lokale Variable\n",
+ "* Besteht die Möglichkeit, dass innerhalb einer Funktion eine lokale Variable mit gleichem Namen wie eine globale Variable definiert wird, ist die globale Variable innerhalb der Funktion unsichtbar\n",
+ "* Soll innerhalb einer Funktion eine globale Variable definiert werden oder eine globale Variable neu zugewiesen werden, dann muss das Schlüsselwort global verwendet werden\n",
+ "\n",
+ "\n",
+ "Eine kurze Erläuterung zu den Regeln:\\\n",
+ "Eine Variable, die außerhalb einer Funktion definiert wird ist global. Sofern innerhalb einer Funktion keine lokale Variable gleichen Namens vorhanden ist, kann auf globale Variablen zugegriffen werden"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "id": "38b648f0-321b-43ec-aeaf-82fd5efdefb7",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "10\n"
+ ]
+ }
+ ],
+ "source": [
+ "def ausgabe():#Eine Funktion kann mehrfach mit dem gleichen Namen definiert werden. Die alte Funktion wir dann einfach überschrieben!\n",
+ " print(x)\n",
+ "x=10#x wird außerhalb einer Funktion definiert, also ist sie global\n",
+ "ausgabe()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bc02bae8-1a39-4b31-9659-500ab692579e",
+ "metadata": {},
+ "source": [
+ "Regel: Eine Variable, die innerhalb einer Funktion definiert wird ist eine lokale Variable. Sie wird am Ende der Funktion gelöscht und auf sie kann nur innerhalb der Funktion zugegriffen werden"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 29,
+ "id": "589ff0c2-7acc-4771-900f-bb22f6b62106",
+ "metadata": {},
+ "outputs": [
+ {
+ "ename": "NameError",
+ "evalue": "name 'meineVariable' 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 [29], line 6\u001b[0m\n\u001b[0;32m 4\u001b[0m meineVariable\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m10\u001b[39m\n\u001b[0;32m 5\u001b[0m funktion1()\n\u001b[1;32m----> 6\u001b[0m \u001b[43mfunktion2\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n",
+ "Cell \u001b[1;32mIn [29], line 5\u001b[0m, in \u001b[0;36mfunktion2\u001b[1;34m()\u001b[0m\n\u001b[0;32m 3\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mfunktion2\u001b[39m():\n\u001b[0;32m 4\u001b[0m meineVariable\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m10\u001b[39m\n\u001b[1;32m----> 5\u001b[0m \u001b[43mfunktion1\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n",
+ "Cell \u001b[1;32mIn [29], line 2\u001b[0m, in \u001b[0;36mfunktion1\u001b[1;34m()\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mfunktion1\u001b[39m():\n\u001b[1;32m----> 2\u001b[0m \u001b[38;5;28mprint\u001b[39m (\u001b[43mmeineVariable\u001b[49m)\n",
+ "\u001b[1;31mNameError\u001b[0m: name 'meineVariable' is not defined"
+ ]
+ }
+ ],
+ "source": [
+ "def funktion1():\n",
+ " print (meineVariable)\n",
+ "def funktion2():\n",
+ " meineVariable=10#meineVariable ist eine lokale Variable der Funktion 'funktion2', sie ist nur innerhalb von 'funktion2' vorhanden \n",
+ " funktion1()\n",
+ "funktion2()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "82b6ce17-16ee-4317-a37f-da9a4eea6e4a",
+ "metadata": {},
+ "source": [
+ "Die Variable *meineVariable* ist bzgl. der Funktion *funktion2* lokal. Wenn innerhalb dieser Funktion eine weitere Funktion aufgerufen wird, kann diese nicht auf lokale Variablen anderer Funktionen zugreifen.\n",
+ "\n",
+ "Dieses Verhalten ist in vielen Programmiersprachen existend. Es ist zu beachten, dass alle lokalen Variablen einer Funktion mit beendigung der Funktion gelöscht werden. Sollten Funktionen von innerhalb der Funktion aufgerufen werden, sind die lokalen Variablen der aufrufenden Funktion für diese auch nicht sichtbar. Deshalb heißen diese Varialben lokal. Die lokalen Variablen sind genau genommen nicht einer Funktion zugeordnet sondern einem Funktionsaufruf (das heißt Funktionen können sich selbst aufrufen, jeder Aufruf hat dann seine eigenen lokalen Variablen)\n",
+ "\n",
+ "Regel: Besteht die Möglichkeit, dass innerhalb einer Funktion eine lokale Variable mit gleichem Namen, wie eine globale Variable definiert wird, ist die globale Variable innerhalb der Funktion unsichtbar.\\"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "id": "c29f7a95-9657-414f-9f23-26b1668c9f90",
+ "metadata": {},
+ "outputs": [
+ {
+ "ename": "UnboundLocalError",
+ "evalue": "local variable 'globaleVariable' referenced before assignment",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[1;31mUnboundLocalError\u001b[0m Traceback (most recent call last)",
+ "Cell \u001b[1;32mIn [15], line 5\u001b[0m\n\u001b[0;32m 3\u001b[0m \u001b[38;5;28mprint\u001b[39m(globaleVariable)\u001b[38;5;66;03m#auf die globale Variable 'globaleVariable' kann nicht zugegriffen werden. Sie ist für die Funktion unsichtbar, da in der nächsten Zeile eine lokale Variable gleichen Namens angelegt wird. Sie ist damit innerhalb der kompletten Funktion unsichtbar.\u001b[39;00m\n\u001b[0;32m 4\u001b[0m globaleVariable\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m30\u001b[39m\n\u001b[1;32m----> 5\u001b[0m \u001b[43mmeineFunktion\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 6\u001b[0m \u001b[38;5;28mprint\u001b[39m(globaleVariable)\n",
+ "Cell \u001b[1;32mIn [15], line 3\u001b[0m, in \u001b[0;36mmeineFunktion\u001b[1;34m()\u001b[0m\n\u001b[0;32m 2\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mmeineFunktion\u001b[39m():\n\u001b[1;32m----> 3\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[43mglobaleVariable\u001b[49m)\u001b[38;5;66;03m#auf die globale Variable 'globaleVariable' kann nicht zugegriffen werden. Sie ist für die Funktion unsichtbar, da in der nächsten Zeile eine lokale Variable gleichen Namens angelegt wird. Sie ist damit innerhalb der kompletten Funktion unsichtbar.\u001b[39;00m\n\u001b[0;32m 4\u001b[0m globaleVariable\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m30\u001b[39m\n",
+ "\u001b[1;31mUnboundLocalError\u001b[0m: local variable 'globaleVariable' referenced before assignment"
+ ]
+ }
+ ],
+ "source": [
+ "globaleVariable=20#Eine globale Variable wird angelegt\n",
+ "def meineFunktion():\n",
+ " print(globaleVariable)#auf die globale Variable 'globaleVariable' kann nicht zugegriffen werden. Sie ist für die Funktion unsichtbar, da in der nächsten Zeile eine lokale Variable gleichen Namens angelegt wird. Sie ist damit innerhalb der kompletten Funktion unsichtbar.\n",
+ " globaleVariable=30\n",
+ "meineFunktion()\n",
+ "print(globaleVariable)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "92de3175-347e-4132-9d1a-c24776bed021",
+ "metadata": {},
+ "source": [
+ "Innerhalb der Funktion \"meineFunktion\" wird in der Zeile 4 eine lokale Variable mit dem Namen \"globaleVariable\" angelegt. Deshalb ist die Globale Variable in der ganzen Funktion nicht sichtbar. Das heißt, man kann auch vor Definition der lokalen Variable nicht auf sie zugreifen. Das ist eine Art Schutzmechanismus, da ansonsten Programme extrem schwer verständlich geschrieben werden könnten.\\\n",
+ "Dieses Verhalten geht so weit, dass der Fehler selbst ausgelöst wird, wenn die Erstellung der lokalen Variable unmöglich passieren kann (vgl. return beendet die Funktion sofort)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 65,
+ "id": "81dacbb1-4bd4-4300-857b-f16db227d023",
+ "metadata": {},
+ "outputs": [
+ {
+ "ename": "UnboundLocalError",
+ "evalue": "local variable 'globaleVariable' referenced before assignment",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[1;31mUnboundLocalError\u001b[0m Traceback (most recent call last)",
+ "Cell \u001b[1;32mIn [65], line 6\u001b[0m\n\u001b[0;32m 4\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m\n\u001b[0;32m 5\u001b[0m globaleVariable\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m30\u001b[39m\n\u001b[1;32m----> 6\u001b[0m \u001b[43mmeineFunktion\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 7\u001b[0m \u001b[38;5;28mprint\u001b[39m(globaleVariable)\n",
+ "Cell \u001b[1;32mIn [65], line 3\u001b[0m, in \u001b[0;36mmeineFunktion\u001b[1;34m()\u001b[0m\n\u001b[0;32m 2\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mmeineFunktion\u001b[39m():\n\u001b[1;32m----> 3\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[43mglobaleVariable\u001b[49m)\n\u001b[0;32m 4\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m\n\u001b[0;32m 5\u001b[0m globaleVariable\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m30\u001b[39m\n",
+ "\u001b[1;31mUnboundLocalError\u001b[0m: local variable 'globaleVariable' referenced before assignment"
+ ]
+ }
+ ],
+ "source": [
+ "globaleVariable=20\n",
+ "def meineFunktion():\n",
+ " print(globaleVariable)#Das gleiche Problem wie oben, obwohl praktisch gesehen die lokale Variable nie angelegt werden kann\n",
+ " return#Die Funktion endet hier garantiert. Die folgenden Zeilen der Funktion werden nie ausgeführt\n",
+ " globaleVariable=30\n",
+ "meineFunktion()\n",
+ "print(globaleVariable)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "92237f17-bbf2-483d-b95a-3b42ee6a1cd4",
+ "metadata": {},
+ "source": [
+ "Falls innerhalb einer Funktion für eine Variable, die links vom Zuweisungsoperator steht, eine globale statt einer lokalen Variable angelegt werden soll, dann kann dieses Verhalten mit dem Schlüsselwort global ausgelöst werden. Die Verändert die Regel, dass in Funktionen angelegte Variablen lokale Variablen sind. Somit können sowohl neue globale Variablen angelegt werden als auch globale Variablen neu zugewiesen werden"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 35,
+ "id": "02ef67a7-0708-4489-9a51-cda0335d62e5",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "20\n",
+ "30\n",
+ "10\n"
+ ]
+ }
+ ],
+ "source": [
+ "globaleVariable=20\n",
+ "def meineFunktion():\n",
+ " global globaleVariable#der Name 'globaleVariable' bezieht sich jetzt für den Rest der Funktion immer auf die globale Variable mit diesem Name\n",
+ " global globaleVariable2#Das geht auch mit Variablen, die noch nicht angelegt wurden\n",
+ " globaleVariable2=10\n",
+ " print (globaleVariable)\n",
+ " globaleVariable=30\n",
+ "meineFunktion()\n",
+ "print(globaleVariable)#Die Variable wurde in der Funktion 'meineFunktion' verändert\n",
+ "print(globaleVariable2)#Die Variable wurde in der Funktion 'meineFunktion' neu erstellt"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9bf73a54-e24d-44ac-b2b6-0ba3e2072507",
+ "metadata": {},
+ "source": [
+ "Globale Variablen sollten nur im Notfall innerhalb einer Funktion verändert werden. Oft kennt ein Programmierer beim Aufruf nur die Funktionsdefinition und einen Hilfetext zur Funktion und möchte sie nutzen, ohne den Inhalt komplett nachvollzogen zu haben. Bei der Funktion *meineFunktion* werden potentiell globale Variablen des Programms (man spricht auch von Zustand) verändert, ohne das von außen ersichtlich ist, dass das passiert. Gerade bei großen Programmen, an denen mehrere Personen beteiligt sind, ist so ein Verhalten äußerst problematisch, da die Auswirkungen auf das gesamte Programm unvorhersehbar wird (Jede globale Variable gibt es nur ein mal mit diesem Namen im gesamten Programm). Prinzipiell werden wir noch verschiedene Möglichkeiten kennen lernen, diese Effekte zu vermeiden. Vor dem Verändern von globalen Variablen in einer Funktion sollte man sich immer die Frage stellen, ob es nicht eine andere Möglichkeit gibt, das gleiche Verhalten zu erzeugen. In den allermeisten Fällen, sind die Alternativen besser."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e7c122a8-ae90-4fb2-9b17-4380442fb15f",
+ "metadata": {},
+ "source": [
+ "# <font color='blue'>**Abschnitt 3 - Verzweigungen**</font>\n",
+ "## <font color='blue'>**Aufgabe**</font>\n",
+ "Programmiere eine Funktion \"istPrimzahl\", die eine ganze Zahl als Parameter bekommt und ermittelt, ob es sich bei dieser Zahl um eine Primzahl handelt. Du kannst in dieser Ãœbung den Parameter einfach in eine ganze Zahl umwandeln um sicherzustellen, das alles wie geplant funktioniert\n",
+ "## <font color='blue'>**Grundlagen**</font>\n",
+ "Eine ganze Zahl ist dann eine Primzahl, wenn sie durch keine andere Zahl als sich selbst und 1 ohne Rest teilbar ist. Die 0 und die 1 sind keine Primzahlen! \\\n",
+ "Für eine Zahl $x$ sind potentielle ganzzahlige Teiler $[2,x//2]$. Das ist eine sehr einfache und daher auch sehr ineffiziente Einschränkung, aber für diese Aufgabe zum Üben in Ordnung. Beachte das die Hälfte der Zahl innerhalb des Intervals liegt (sonst würde die 4 fälschlicherweise als Prinzahl erkannt werden). Überprüfe anschließend die Zahlen von 1 bis 100, ob sie Primzahlen sind, und gebe alle Primzahlen aus und ermittle, wie viele Primzahlen bis 100 es gibt. (Zum Überprüfen deines Erbebnisses, es sind 25)\n",
+ "## <font color='blue'>**Lösung**</font>"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a13a6dc5-a537-4104-ae5c-6e6fb3700a69",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "b4c83fc4-ac7f-4384-a442-a7a268696085",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5ac65721-daea-43d8-937c-021b2dfa8502",
+ "metadata": {},
+ "source": [
+ "## Hinweise\n",
+ "Prinzipiell muss für jeden potentiellen Teiler überprüft werden, ob die Zahl teilbar ist. Um das herauszufinden kannst du den % Operator verwenden. Dieser gibt den Rest bei einer ganzzahligen Division aus. Ist der Rest für einen Teiler gleich 0, dann ist die Zahl keine Primzahl. Die Funktion kann an diesem Punkt beendet werden. Also je nachdem, ob der Rest gleich Null ist oder nicht, kann die Funktion mit negativem Ergebnis beendet werden, oder muss weiterlaufen. Wenn alle potentiellen Teiler probiert wurden und keiner die Zahl teilt, dann ist die Zahl eine Primzahl und die Funktion kann mit positivem Ergebnis beendet werde. Es ist also nötig, dass das Programm je nach Ergebnis unterschiedlich weiterläuft. Dieses Verhalten wird Verzweigung genannt. Im Grundlagen-Notebook wird erklärt, wie eine Verzweigung funktioniert. Beachte außerdem, dass 0 und 1 keine Primzahlen sind"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f6f121ed-0501-42c8-bbf4-2dddb87d25cb",
+ "metadata": {},
+ "source": [
+ "# <font color='blue'>**Abschnitt 4 - Listen**</font>"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2c306592-95a5-4c6c-a7e0-ce8499772057",
+ "metadata": {},
+ "source": [
+ "## <font color='blue'>**Augabe**</font>\n",
+ "Schreibe eine Funktion \"statistik\", die eine Liste von Werten als Parameter erhält und von diesen Werten den Mittelwert und die Standardabweichung berechnet. Probiere die Funktion mit der Liste, die in der zweiten Zelle gegebenen Liste.\\\n",
+ "(Zur Kontrolle, der Mittelwert ist ca. 0.516, die Standardabweichung liegt bei ca. 0.289)\n",
+ "## <font color='blue'>**Grundlagen**</font>\n",
+ "der Mittelwert einer Liste von $n$ Zahlen ist\\\n",
+ "$\\overline{x}=\\frac{\\sum_{i=1}^{n}(x_{i})}{ n}$\\\n",
+ "Die Standardabweichung ist definiert als die Wurzel der Varianz, bzw. der durchschnittlichen quadratischen Abweichung der Werte vom Mittelwert\\\n",
+ "$\n",
+ "\\sigma=\\sqrt{\\frac{1}{n}\\sum_{i=1}^{n}(x_{i}-\\overline{x})^{2}}\n",
+ "$\n",
+ "## <font color='blue'>**Lösung**</font>"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "62f4cfe0-7e29-42eb-939f-87de2b568c13",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 23,
+ "id": "12c1ee6c-2e1f-453f-b530-d89638bf1ecd",
+ "metadata": {},
+ "outputs": [],
+ "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)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "764a11d8-b96c-471a-83c0-38765c41a5e3",
+ "metadata": {},
+ "source": [
+ "## <font color='blue'>**Hintergründe**</font>\n",
+ "Es gibt in Python einen weiteren Variablentyp namens *list*. Listen sind Variablen, die mehrere Werte (potentiell unterschiedlichen Typs) zusammenfassen. Listen können also selbst aus Listen bestehen. Die einzelnen Werte dieser Liste sind über ihre Position innerhalb der Liste erreichbar (Zählung beginnt bei 0!). Um auf einen Wert der Liste zuzugreifen werden eckige Klammern verwendet. Man sagt, dass eine Liste indizierbar ist. Das erste Element hat den Index 0 nicht 1!"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 19,
+ "id": "565d45c1-30f9-47bc-aed6-c95d29a744fd",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "1\n",
+ "hallo\n"
+ ]
+ }
+ ],
+ "source": [
+ "meineListe=[1,2,\"hallo\",9.9]\n",
+ "print(meineListe[0])\n",
+ "print(meineListe[2])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8578e730-1027-4094-a423-91b0fabc0954",
+ "metadata": {},
+ "source": [
+ "for-Schleifen können genutzt werden, um über die Elemente einer Liste zu iterieren. Dabei nimmt die Zählvariable dür Jeden durchlauf ein Element der Liste an "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 20,
+ "id": "c0f9ea13-2d67-4921-8612-86108808225c",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "4\n",
+ "Apfel\n",
+ "3\n",
+ "9.3\n"
+ ]
+ }
+ ],
+ "source": [
+ "eineListe=[4,\"Apfel\",3,9.3]\n",
+ "for x in eineListe:\n",
+ " print(x)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "eb7d5ae9-3a54-44d2-a89a-b09d855df6eb",
+ "metadata": {},
+ "source": [
+ "Die einzelnen Einträge einer Liste sind veränderbar. Die Liste ist ein sogenanntes mutable-Object. Es können auch Elemente entfernt oder hinzugefügt werden"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 37,
+ "id": "09a9d888-f5f2-4914-a803-594fd43d9f7c",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[1, 'ein neuer Wert', 'hallo', 9.9]\n"
+ ]
+ }
+ ],
+ "source": [
+ "meineListe[1]=\"ein neuer Wert\"\n",
+ "print(meineListe)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ac5cea15-5204-44e6-bed9-882e408a8bde",
+ "metadata": {},
+ "source": [
+ "Auch Zeichenketten sind in Python indizierbar! Der Einzelbuchstabe an der betreffenden Position wird ausgegeben. Eine Zeichenkette ist allerdings immutable, die Buchstaben können nur gelesen werden. Die Zeichenkette lässt sich aber nicht verändern"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 82,
+ "id": "13659f43-ff9d-4039-892e-d5aa01dcc773",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Der zweite Buchstabe der Zeichenkette ist: C\n"
+ ]
+ }
+ ],
+ "source": [
+ "Zeichenkette=\"ABCDEFG\"\n",
+ "print(\"Der zweite Buchstabe der Zeichenkette ist: \" +Zeichenkette[2])"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 83,
+ "id": "2582827c-b3a9-47df-9dc5-ab13064fe2e8",
+ "metadata": {},
+ "outputs": [
+ {
+ "ename": "TypeError",
+ "evalue": "'str' object does not support item assignment",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)",
+ "Cell \u001b[1;32mIn [83], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43mZeichenkette\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m2\u001b[39;49m\u001b[43m]\u001b[49m\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mA\u001b[39m\u001b[38;5;124m\"\u001b[39m\n",
+ "\u001b[1;31mTypeError\u001b[0m: 'str' object does not support item assignment"
+ ]
+ }
+ ],
+ "source": [
+ "Zeichenkette[2]=\"A\"#das Funktioniert nicht, da Zeichenketten nicht veränderbar sind"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "af12b75c-a6e1-45b9-9b04-6d00b7a14bcf",
+ "metadata": {},
+ "source": [
+ "Generell kannst du dir merken, dass die Datentypen list, dict und alle selbst definierten Objekte (dazu kommen wir in der nächsten Übung) mutable-Objects sind, alle anderen Datentypen, wie auch die, die wir bereits kennengelernt haben, immutable-Objects sind. Diese Unterscheidung hat praktischen Einfluss auf die Verwendung von Variablen. Schaue dir das nächste Beispiel an"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 85,
+ "id": "b138b8bb-6766-4e77-ba01-8606459aa438",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "9\n",
+ "[9, 2, 3, 4, 5]\n"
+ ]
+ }
+ ],
+ "source": [
+ "var1=9\n",
+ "Liste1=[1,2,3,4,5]\n",
+ "Liste2=Liste1\n",
+ "var2=var1\n",
+ "var2=12\n",
+ "Liste2[0]=9\n",
+ "print (var1)\n",
+ "print (Liste1)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "01035473-7d4c-4e0b-9bee-20e93522cd48",
+ "metadata": {},
+ "source": [
+ "In diesem Beispiel scheint es, als ob die Zuweisung bei Listen etwas anderes tut, als bei anderen Variablen. Das stimmt nicht ganz. Im Grundsatz folgt die Zuweisung einer etwas anderen Idee. Du kannst dir das Verhalten so vorstellen, dass das Literal '9' ein ganze Zahl mit dem Wer 9 erzeugt. Das ist ein immutable-Objekt, daher bleibt es immer eine 9. Die Zuweisung 'var2=var1' hat zur Folge, dass *var2* und *var1* auf die selbe 9 verweisen, also zwei Namen für die selbe 9 sind. Eine erneute Zuweisung 'var2=12' hat zur Folge, dass eine ganze Zahl 12 erzeugt wird und *var2* auf die neu erzeugte 12 verweist, *var1* aber weiterhin auf die 9. Bei den Listen ist es genau so. Nur das die Liste eben veränderbar ist. Weißt du der Variable *Liste2* einen neuen Wert zu, dann verändert das die Liste, auf die *Liste1* verweist nicht."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 88,
+ "id": "ecc55c5d-e9d2-40aa-b2bd-189f176c19be",
+ "metadata": {},
+ "outputs": [
+ {
+ "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"
+ ]
+ }
+ ],
+ "source": [
+ "Liste2=5\n",
+ "print(\"Liste2 ist jetzt eine Zahl mit dem Wert \",Liste2)\n",
+ "print(\"Liste1 ist weiterhin die Liste\",Liste1)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "434bd101-84bc-49d4-9cf6-7060aa1208ed",
+ "metadata": {},
+ "source": [
+ "Manchmal möchtest du allerdings, dass bei der Zuweisung eine Liste wirklich kopiert wird. Dafür gibt es zwei Möglichkeiten. Das erste Beispiel nutzt aus, dass Slicing immer eine Kopie erzeugt und ist eine Art kurze Schreibweise. Quellcode dieser Art kommt in Python Programmen häufig vor"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "id": "2c4d9b94-1a38-450f-b108-7ba9b9ace6c8",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[1, 2, 3, 4, 5]\n"
+ ]
+ }
+ ],
+ "source": [
+ "Liste1=[1,2,3,4,5]\n",
+ "Liste2=Liste1[:]\n",
+ "Liste2[0]=9\n",
+ "print (Liste1)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 18,
+ "id": "1fb4d0ec-a224-446b-8796-77acdb4650eb",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[1, 2, 3, 4, 5]\n"
+ ]
+ }
+ ],
+ "source": [
+ "Liste1=[1,2,3,4,5]\n",
+ "Liste2=list(Liste1)\n",
+ "Liste2[0]=9\n",
+ "print (Liste1)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b31bc586-1c3f-4220-a7af-eeed643df660",
+ "metadata": {},
+ "source": [
+ "Der Effekt, dass die Zuweisung nicht wirklich eine Kopie ist, ist in dieser Form meist nicht sonderlich hilfreich. Allerdings kann man das Verhalten im Kontext von Funktionen nutzen"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 46,
+ "id": "12ab3408-fcab-4cd4-a96a-7114e4cd02fe",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[10, 2, 3, 4, 5]\n"
+ ]
+ }
+ ],
+ "source": [
+ "def meineFunktion(parameter):\n",
+ " parameter[0]=10\n",
+ "meineListe=[1,2,3,4,5]\n",
+ "meineFunktion(meineListe)\n",
+ "print(meineListe)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "73036041-e0cd-48c8-8d8b-2a751e48413d",
+ "metadata": {},
+ "source": [
+ "Wie oben beschrieben funktioniert das erstellen der Parameter-Variablen wie eine Zuweisung, es folgt also den gleichen Regeln. \n",
+ "\n",
+ "Hier siehst du schon ein Beispiel, wie globale Variablen vermieden werden können. Die Liste kann innerhalb der Funktion verändert werden. Da die Funktion die Liste allerdings als Parameter übergeben bekommt, ist besser verständlich, wieso sie auch innerhalb der Funktion veränderbar ist.\n",
+ "\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": [
+ "Versuche in einem Programm Alle Primzahlen bis zur 100.000 zu finden. Das Wird nicht mehr mit dem oben programmierten Primzahltest funktionieren, da zu viele Probedivisionen durchgeführt werden müssen. Es gibt eine Methode, die Primzahlen schneller zu identifizieren, wenn man die Primfaktorzerlegung als Ausgangspunkt nimmt. Jede nicht-Primzahl $n$ ist durch eine Primzahl $p$ mit $2\\le$p$\\le\\sqrt{n}$ ganzzahlig teilbar. Damit muss ausgehend von der 2, die bekanntermaßen die erste Primzahl ist, eine Liste geführt werden, welche Primzahlen bereits gefunden wurden. So kann man ausgehend von der 3 jede Zahl nacheinander darauf testen, ob sie eine Primzahl ist. Falls dir die Beschreibung nicht reicht einen Algorithmus zu entwickeln, gibt es in der nächsten Zelle noch einige Hinweise. (Es gibt bis 100.000 9.592 Primzahlen. Bis 1.000.000 sind es 78.498, das kannst du mit diesem Algorithmus auch herausfinden; probiere das aber bitte nicht auf dem GITZ-Server aus, auf deinem Laptop sollte es jedoch kein Problem sein)\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": []
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "59d7ecb7-feec-40a9-a3a5-a93dacdcec76",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0109a144-56cc-40a7-8457-df445d8b92ae",
+ "metadata": {},
+ "source": [
+ "## <font color='blue'>**Hinweise - falls du nicht weißt, wie du anfangen sollst**</font>\n",
+ "\n",
+ "Zu erst einmal musst du alle Primzahlen finden und benötigst die Gefundenen später auch noch. Also brauchst du eine Liste, um gefundene Primzahlen zu speichern. Die sollte am Anfang, wie oben beschrieben, bereits die 2 enthalten.\\\n",
+ "Anschließend musst du bei jeder Zahl von 3 bis 100.000 testen, ob sie eine Primzahl ist. Falls ja, musst du sie hinten an die Liste der bekannten Primzahlen anhängen.\\\n",
+ "Für den Test schreibst du am besten eine Funktion. Die benötigt als Parameter die Zahl n, die du testen möchtest und die Liste der bekannten Primzahlen. diese Funktion muss alle Elemente der Liste durchlaufen. Für jedes Element überprüfst du, ob n durch das Element restlos teilbar ist. Falls ja, dann ist n keine Primzahl. Anschließend überprüfst du, ob das Element größer als $\\sqrt{n}$ ist, falls ja ist n eine Primzahl. Das funktioniert, da die Liste nach größe aufsteigend sortiert angelegt wurde. Die restlichen Elemente müssen gar nicht mehr getestet werden, da die Zahl n nicht ganzzahlig durch sie teilbar sein kann. Falls die Schleife über die Elemente das Ende der Primzahlen erreicht, dann ist n auch eine Primzahl, da kein Teiler gefunden wurde"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "34903ede-f475-4cf9-a5ff-29840f89f44f",
+ "metadata": {},
+ "source": [
+ "# <font color='blue'>**Beispiel zum nachvollziehen**</font>\n",
+ "die folgende Funktion berechnet auf eine andere Art eine beliebige Fibonacci-Zahl. Sie funktioniert sogar für die erste und Zweite. Kannst du nachvollziehen, wieso sie funktioniert?"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "0e29c3dd-bd64-4e61-a1f5-5d17bb1e44ac",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def Fib(n):\n",
+ " if n<1:\n",
+ " print (\"Die Reihe der Fibonacci-Zahlen beginnt mit der ersten Zahl!\")\n",
+ " return\n",
+ " if n==1:\n",
+ " return 0\n",
+ " if n==2:\n",
+ " return 1\n",
+ " return Fib(n-2)+Fib(n-1)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "57b03415-9dfb-4a08-9733-5cdfc6e6a782",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "5"
+ ]
+ },
+ "execution_count": 6,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "Fib(6)"
+ ]
+ }
+ ],
+ "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