From 99c51b6889dfb68b9a69a8bdfa2abffd93c3ef62 Mon Sep 17 00:00:00 2001
From: Malte Woidt <m.woidt@tu-bs.de>
Date: Tue, 15 Nov 2022 21:24:36 +0100
Subject: [PATCH] =?UTF-8?q?Verlorengegangene=20=C3=9Cbung=202=20wieder=20h?=
=?UTF-8?q?inzugef=C3=BCgt?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
Uebung02/Uebung02.ipynb | 959 ++++++++++++++++++++++++++++++++++++++++
1 file changed, 959 insertions(+)
create mode 100644 Uebung02/Uebung02.ipynb
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