Python_Grundlagen2.ipynb

{
 "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",
    "&nbsp;&nbsp;&nbsp;&nbsp;Codeblock\\\n",
    "**{elif** \\<boolscher Ausdruck\\>:\\\n",
    " &nbsp;&nbsp;&nbsp;&nbsp;Codeblock **}** optional, beliebig oft wiederholbar \\\n",
    "**{else** :\\\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;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",
    "&nbsp;&nbsp;&nbsp;&nbsp;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",
    "&nbsp;&nbsp;&nbsp;&nbsp;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)"
   ]
  },
  {