{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "45369e9c",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "toc": true
   },
   "source": [
    "<h1>Table of Contents<span class=\"tocSkip\"></span></h1>\n",
    "<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#for-Schleifen\" data-toc-modified-id=\"for-Schleifen-1\"><span class=\"toc-item-num\">1&nbsp;&nbsp;</span>for-Schleifen</a></span><ul class=\"toc-item\"><li><span><a href=\"#break-und-continue\" data-toc-modified-id=\"break-und-continue-1.1\"><span class=\"toc-item-num\">1.1&nbsp;&nbsp;</span><strong>break</strong> und <strong>continue</strong></a></span></li><li><span><a href=\"#Nützliche-built-in-Funktionen\" data-toc-modified-id=\"Nützliche-built-in-Funktionen-1.2\"><span class=\"toc-item-num\">1.2&nbsp;&nbsp;</span>Nützliche built-in Funktionen</a></span></li></ul></li><li><span><a href=\"#while-Schleife\" data-toc-modified-id=\"while-Schleife-2\"><span class=\"toc-item-num\">2&nbsp;&nbsp;</span>while Schleife</a></span></li><li><span><a href=\"#Comprehensions\" data-toc-modified-id=\"Comprehensions-3\"><span class=\"toc-item-num\">3&nbsp;&nbsp;</span>Comprehensions</a></span><ul class=\"toc-item\"><li><span><a href=\"#für-Listen-(list-comprehension)\" data-toc-modified-id=\"für-Listen-(list-comprehension)-3.1\"><span class=\"toc-item-num\">3.1&nbsp;&nbsp;</span>für Listen (list comprehension)</a></span></li><li><span><a href=\"#für-Wörterbücher-(dictionary-comprehension)\" data-toc-modified-id=\"für-Wörterbücher-(dictionary-comprehension)-3.2\"><span class=\"toc-item-num\">3.2&nbsp;&nbsp;</span>für Wörterbücher (dictionary comprehension)</a></span></li><li><span><a href=\"#für-Mengen-(set-comprehension)\" data-toc-modified-id=\"für-Mengen-(set-comprehension)-3.3\"><span class=\"toc-item-num\">3.3&nbsp;&nbsp;</span>für Mengen (set comprehension)</a></span></li><li><span><a href=\"#für-Generatoren\" data-toc-modified-id=\"für-Generatoren-3.4\"><span class=\"toc-item-num\">3.4&nbsp;&nbsp;</span>für Generatoren</a></span></li><li><span><a href=\"#geschachtelter-Aufruf\" data-toc-modified-id=\"geschachtelter-Aufruf-3.5\"><span class=\"toc-item-num\">3.5&nbsp;&nbsp;</span>geschachtelter Aufruf</a></span></li></ul></li><li><span><a href=\"#Funktionen-mit-beliebig-vielen-Argumenten\" data-toc-modified-id=\"Funktionen-mit-beliebig-vielen-Argumenten-4\"><span class=\"toc-item-num\">4&nbsp;&nbsp;</span>Funktionen mit beliebig vielen Argumenten</a></span><ul class=\"toc-item\"><li><span><a href=\"#Packing-und-Unpacking-mit-*\" data-toc-modified-id=\"Packing-und-Unpacking-mit-*-4.1\"><span class=\"toc-item-num\">4.1&nbsp;&nbsp;</span>Packing und Unpacking mit *</a></span></li></ul></li></ul></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "46eb9600",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Schleifen (loops)\n",
    "\n",
    "Schleifen sind Strukturelemente, die ein wiederholtes Durchlaufen von Programmblöcken ermöglichen. Man unterscheidet zwischen <code>while</code>-Schleifen und <code>for</code>-Schleifen.\n",
    "\n",
    "In der letzten Woche hatten wir gesehen, dass auch mit rekursiven Funktionsaufrufen ein wiederholtes Abarbeiten von Anweisungen möglich ist. Oft sind Schleifen aber naheliegender."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6efc0d7e",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## for-Schleifen\n",
    "Der Aufbau einer for Schleife ist wie folgt, wobei das <code> else </code> optional ist\n",
    "```python\n",
    "    for element in iterierbarers_objekt:\n",
    "        block von anweisungen\n",
    "    [else:]\n",
    "        block von anweisungen\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "42243bc6",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "for i in [1, 2, 4]:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "156c7fd8",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "for i in (1, 2, 3):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a03a94fc",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Das geht einfacher mit dem Range Objekt (siehe Blatt 1). Damit erhält man alle ganzen Zahlen in einem Bereich.\n",
    "```python \n",
    "range([anfang],ende)\n",
    "```\n",
    "Wird der optionale Anfangsindex <code>anfang</code> nicht angegeben, beginnt der Bereich bei 0. Der Endeindex <code>ende</code> ist wieder exklusiv."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "eda27bce",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "for i in range(1, 4):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ffe837a",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Auch Wörterbücher, Mengen und Zeichenketten sind iterierbar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "b089ed0d",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Key k=1 \t Eintrag: a\n",
      "Key k=2 \t Eintrag: b\n",
      "Key k=(1, 2) \t Eintrag: a+b\n",
      "Key k=0 \t Eintrag: Null\n"
     ]
    }
   ],
   "source": [
    "wb = {1: 'a', 2: 'b', (1, 2): 'a+b', 0: 'Null'}\n",
    "# Iteration über die Schlüssel (keys)\n",
    "for k in wb:\n",
    "    print(f'Key {k=} \\t Eintrag: {wb[k]}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "00e1f8eb",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pear\n",
      "apple\n",
      "orange\n",
      "banana\n"
     ]
    }
   ],
   "source": [
    "menge =  {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}\n",
    "for element in menge:\n",
    "    print(element)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "033eb48a",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+\n",
      "-\n",
      "+\n",
      "-\n"
     ]
    }
   ],
   "source": [
    "for zeichen in '+-+-':\n",
    "    print(zeichen)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3de92c57",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<code>print</code> beendet jede Ausgabe mit einer neuer Zeile. Mit dem <code>end</code> Paramater kann man das Ende der Ausgabe festlegen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "330be2ac",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+,-,+,-,"
     ]
    }
   ],
   "source": [
    "for zeichen in '+-+-':\n",
    "    print(zeichen, end=',')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc357380-44ae-4ddd-ad80-b2c5329f416c",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### __break__ und __continue__ \n",
    "Mit <code>break</code> verlässt man eine Schleife vorzeitig, mit <code>continue</code> springt man zum Anfang und überspringt den Rest."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "24033a02-a09c-493c-a2ef-0338f9ec211d",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "n=2 teilbar durch 2:2 = 2*1\n",
      "n=4 teilbar durch 4:4 = 4*1\n"
     ]
    }
   ],
   "source": [
    "for n in range(1, 10):\n",
    "    if n % 4 == 0:\n",
    "        print(f'{n=} teilbar durch 4:{n} = 4*{n//4}')\n",
    "        break\n",
    "    if n % 2 == 0:\n",
    "        print(f'{n=} teilbar durch 2:{n} = 2*{n//2}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "d54ab037-4278-432d-ab8b-4c8e5bef7451",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "n=2 teilbar durch 2: 2 = 2*1\n",
      "n=4 teilbar durch 4: 4 = 4*1\n",
      "n=6 teilbar durch 2: 6 = 2*3\n",
      "n=8 teilbar durch 4: 8 = 4*2\n"
     ]
    }
   ],
   "source": [
    "for n in range(1, 10):\n",
    "    if n % 4 == 0:\n",
    "        print(f'{n=} teilbar durch 4: {n} = 4*{n//4}')\n",
    "        continue\n",
    "    if n % 2 == 0:\n",
    "        print(f'{n=} teilbar durch 2: {n} = 2*{n//2}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6716d5cb",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Das optionale <code>else</code> in einer for-Schleife wird selten verwendet. Es ist vermutlich nur nützlich, wenn man mit einem <code>break</code> eine Schleife abbricht.\n",
    "\n",
    "Beispiel aus https://docs.python.org/3/tutorial/controlflow.html Abschnitt 4.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "f82d40e0",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4 ist 2 * 2\n",
      "6 ist 2 * 3\n",
      "8 ist 2 * 4\n",
      "9 ist 3 * 3\n"
     ]
    }
   ],
   "source": [
    "for n in range(2, 10):\n",
    "    for x in range(2, n):\n",
    "        if n % x == 0:  # x teilt n\n",
    "            print(f'{n} ist {x} * {int(n/x)}')\n",
    "            break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "ab92c42e",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 ist prim\n",
      "3 ist prim\n",
      "4 ist 2 * 2\n",
      "5 ist prim\n",
      "6 ist 2 * 3\n",
      "7 ist prim\n",
      "8 ist 2 * 4\n",
      "9 ist 3 * 3\n"
     ]
    }
   ],
   "source": [
    "for n in range(2, 10):\n",
    "    for x in range(2, n):\n",
    "        if n % x == 0:  # x teilt n\n",
    "            print(f'{n} ist {x} * {int(n/x)}')\n",
    "            break\n",
    "    else:  # die Schleife  x in 2..n-1 wurde nicht abgebrochen oder die Schleife ist leer\n",
    "        print(f'{n} ist prim')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb6e4465",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Es kommt etwas anderes raus, wenn wir das <code>else</code> ein- oder ausrücken"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "4039ddfc",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 ist prim\n",
      "4 ist 2 * 2\n",
      "5 ist prim\n",
      "5 ist prim\n",
      "5 ist prim\n",
      "6 ist 2 * 3\n",
      "7 ist prim\n",
      "7 ist prim\n",
      "7 ist prim\n",
      "7 ist prim\n",
      "7 ist prim\n",
      "8 ist 2 * 4\n",
      "9 ist prim\n",
      "9 ist 3 * 3\n"
     ]
    }
   ],
   "source": [
    "for n in range(2, 10):\n",
    "    for x in range(2, n):\n",
    "        if n % x == 0:  # x teilt n\n",
    "            print(f'{n} ist {x} * {int(n/x)}')\n",
    "            break\n",
    "        else:  # hier gehört das else zum if, also falls x kein Teiler von n ist\n",
    "            print(f'{n} ist prim')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e2e3431",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Nützliche built-in Funktionen\n",
    "Built-in Funktionen, die das Programmieren mit <code>for</code>-Schleifen vereinfachen, sind\n",
    "<code>zip(), enumerate(), reversed(), sorted()</code>.\n",
    "\n",
    "\n",
    "<code>zip()</code> Reißverschluss: Verbindet Elemente aus mehreren Listen oder Iterables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "320e3541",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A wie Affe\n",
      "E wie Esel\n",
      "I wie Igel\n",
      "O wie Otter\n",
      "U wie Uhu\n"
     ]
    }
   ],
   "source": [
    "str1 = 'AEIOU'\n",
    "lst1 = ['Affe', 'Esel', 'Igel', 'Otter', 'Uhu', 'Zebra']\n",
    "\n",
    "for i, j in zip(str1, lst1):\n",
    "    print(f'{i} wie {j}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "44f23227",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<code>reversed()</code> dreht die Reihenfolge um. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "8d3ce03d",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Zebra\n",
      "Uhu\n",
      "Otter\n",
      "Igel\n",
      "Esel\n",
      "Affe\n"
     ]
    }
   ],
   "source": [
    "for i in reversed(lst1):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e91ca9d",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<code>enumerate()</code> zählt zusätzlich die durchiterierten Elemente ab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "c95d581e",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 Affe\n",
      "1 Esel\n",
      "2 Igel\n",
      "3 Otter\n",
      "4 Uhu\n",
      "5 Zebra\n"
     ]
    }
   ],
   "source": [
    "for index, element in enumerate(lst1):\n",
    "    print(index, element)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "c7d94771",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 Affe\n",
      "2 Esel\n",
      "3 Igel\n",
      "4 Otter\n",
      "5 Uhu\n",
      "6 Zebra\n"
     ]
    }
   ],
   "source": [
    "for i, element in enumerate(lst1, start=1):  # fängt bei start zu zählen an\n",
    "    print(i, element)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "892108d6-27c3-4cea-97b9-8c0e4e6b784a",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(0, ('A', 'Affe')),\n",
       " (1, ('E', 'Esel')),\n",
       " (2, ('I', 'Igel')),\n",
       " (3, ('O', 'Otter')),\n",
       " (4, ('U', 'Uhu'))]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(enumerate(zip(str1, lst1)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "72b1ffaf",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## while Schleife"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fbcf61a2",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Der Aufbau einer <code>while</code>-Schleife ist wie folgt, wobei das <code>else</code> optional ist. Der Block anweisung1 wird ausgeführt solange <code>bedingung</code> ein Ausdruck ist, der __True__ ist.\n",
    "```python\n",
    "    while bedingung:\n",
    "        anweisung1\n",
    "    [else]\n",
    "        anweisung2\n",
    "```\n",
    "Wieder kann man mit <code>break</code>  die Schleife abbrechen, oder mit <code>continue</code> zum Anfang der Schleife springen. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "744126e0",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n",
      "7\n",
      "15\n"
     ]
    }
   ],
   "source": [
    "a = 1\n",
    "print(a)\n",
    "while a <= 10:\n",
    "    a = a + (a + 1)\n",
    "    print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "80100f8b",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n",
      "7\n",
      "15\n"
     ]
    }
   ],
   "source": [
    "a = 1\n",
    "print(a)\n",
    "while True:\n",
    "    if a > 10:\n",
    "        break\n",
    "    a = a + (a + 1)\n",
    "    print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "feffaa22",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n",
      "7\n",
      "15\n"
     ]
    }
   ],
   "source": [
    "def arek(a):\n",
    "    print(a)\n",
    "    if a > 10:\n",
    "        return a\n",
    "    return arek(a + (a + 1))\n",
    "\n",
    "\n",
    "a = arek(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "389e739b",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "rng = np.random.default_rng() # Zufallszahlengenerator (random number generator)\n",
    "c = rng.integers(1, 7) # integers(1,7) \"würfelt\" zufällig Zahl zwischen 1 und 7 (exklusive) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "b2480916",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nach 24 mal würfeln ist die Augensumme 101\n"
     ]
    }
   ],
   "source": [
    "zaehler = 0\n",
    "summe = 0\n",
    "while summe < 100:\n",
    "    summe += 1 + rng.integers(1, 7)  # += inplace plus (summe = summe + 1 + random integer in [1,6]\n",
    "    zaehler += 1 # zaehler = zaehler + 1\n",
    "print(f'Nach {zaehler} mal würfeln ist die Augensumme {summe}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e23b92f",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Comprehensions\n",
    "### für Listen (list comprehension)\n",
    "Statt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "8ffee2d4",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 5, 7, 9]"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = []\n",
    "for j in range(5):\n",
    "    a.append(2 * j + 1)\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7d941b0c",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "verwendet man auch die kompaktere Form"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "cd3e840f",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 5, 7, 9]"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "aa = [2*j+1 for j in range(5)] \n",
    "aa"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "48f5c35d",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### für Wörterbücher (dictionary comprehension)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "49fe5299",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{i: i**2 for i in range(5)}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2688cc47",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### für Mengen (set comprehension)\n",
    "Die Menge der Quadratzahlen bis $4^2$ \n",
    "\n",
    "$\\{i^2 : i \\in \\mathbb{N}_0 \\land i < 5\\}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "6295b5d5",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0, 1, 4, 9, 16}"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{i**2 for i in range(5)}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58772880",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "man kann dabei auch Bedingungen abfragen\n",
    "$\\{i^2 : i \\in \\mathbb{N}_0 \\land i < 5 \\land ggT(i^2,2)=1\\}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "0c3964c1",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 9}"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{i**2 for i in range(5) if (i**2) % 2 != 0}  # alle ungeraden Quadratzahlen bis 16"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "fbbe0695",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 9}"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from math import gcd #gcd greatest common divisor (deutsch ggT) \n",
    "{i**2 for i in range(5) if gcd(i**2,2)== 1}  # alle ungeraden Quadratzahlen bis 16"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d24dd19d",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### für Generatoren "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "88c14e6d",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "g = (i**2 for i in range(5)) # !!keine tuple comprehension!!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "ce845808",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<generator object <genexpr> at 0x770264354790>"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "e275cede",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 4, 9, 16]"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(g)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aac03bb3",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Generatoren brauchen weniger Speicher, da Sie faul (lazy) sind und das jeweils nächste Element erst berechnen, wenn es benötigt wird."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "261f43ec",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### geschachtelter Aufruf\n",
    "Primzahlen bis N"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "01ae2220",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 3, 5, 7, 11, 13, 17, 19]"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N = 20\n",
    "[n for n in range(2, N) if all((n % m > 0 for m in range(2, n)))]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7a372d2c",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Funktionen mit beliebig vielen Argumenten\n",
    "\n",
    "Ein Beispiel: Minimum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "8de496c4",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def mymin(a, b):\n",
    "    \"\"\" Berechnet das Minimum von zwei Argumenten\"\"\"\n",
    "    if a < b:\n",
    "        return a\n",
    "    else:\n",
    "        return b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "ef7262a7",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.1"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mymin(3.2, 2.1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "34fad88d",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Packing und Unpacking mit *\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "cc6c9bbe-8982-4741-b6cf-bfb1c94f48f1",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "*b, = 1, 2, 3\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "5946d7ea-4c89-4322-83da-33138526741a",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 3, 4]"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lst = list(range(5))\n",
    "a, b, *c, = lst\n",
    "c"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e5dab10c",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Der <code>*</code> hier wird als unpacking operator bezeichnet. Die rechte Seite (der Tupel (1,2,3) bzw. die Liste [0,1,2,3,4,5]) wird entpackt und in b bzw c gespeichert."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "4d5bdb03",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "def mymin(*eingabewerte):\n",
    "    ''' Berechnet das betragsweise Minimum von beliebig vielen Argumenten\n",
    "        mymin(1, -1, 1+j) \n",
    "        Output: 1\n",
    "    '''\n",
    "    #print(eingabewerte, type(eingabewerte))\n",
    "    minimum = abs(eingabewerte[0])\n",
    "    for a in eingabewerte:\n",
    "\n",
    "        assert isinstance(\n",
    "            a, (float, int, complex)), 'Eingabewerte müssen Zahlen sein'\n",
    "\n",
    "        if abs(a) < minimum:\n",
    "            minimum = abs(a)\n",
    "\n",
    "    return minimum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "4175aa5a",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mymin(2, 2.1, 3, 1 + 2j)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3fdc249f",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Der Stern <code>*</code> hier wird als packing operator bezeichnet, weil er die Argumente 2, 2.1, 3, 1 + 2j in das Tupel eingabewerte packt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "8befbafd",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "liste = [2, 3, 4, 1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "1e162e9d",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mymin(*liste) #unpacking"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "04d11d60",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "bad operand type for abs(): 'list'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[41], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mmymin\u001b[49m\u001b[43m(\u001b[49m\u001b[43mliste\u001b[49m\u001b[43m)\u001b[49m\n",
      "Cell \u001b[0;32mIn[37], line 7\u001b[0m, in \u001b[0;36mmymin\u001b[0;34m(*eingabewerte)\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m''' Berechnet das betragsweise Minimum von beliebig vielen Argumenten\u001b[39;00m\n\u001b[1;32m      3\u001b[0m \u001b[38;5;124;03m    mymin(1, -1, 1+j) \u001b[39;00m\n\u001b[1;32m      4\u001b[0m \u001b[38;5;124;03m    Output: 1\u001b[39;00m\n\u001b[1;32m      5\u001b[0m \u001b[38;5;124;03m'''\u001b[39;00m\n\u001b[1;32m      6\u001b[0m \u001b[38;5;66;03m#print(eingabewerte, type(eingabewerte))\u001b[39;00m\n\u001b[0;32m----> 7\u001b[0m minimum \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mabs\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43meingabewerte\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m      8\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m a \u001b[38;5;129;01min\u001b[39;00m eingabewerte:\n\u001b[1;32m     10\u001b[0m     \u001b[38;5;28;01massert\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(\n\u001b[1;32m     11\u001b[0m         a, (\u001b[38;5;28mfloat\u001b[39m, \u001b[38;5;28mint\u001b[39m, \u001b[38;5;28mcomplex\u001b[39m)), \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mEingabewerte müssen Zahlen sein\u001b[39m\u001b[38;5;124m'\u001b[39m\n",
      "\u001b[0;31mTypeError\u001b[0m: bad operand type for abs(): 'list'"
     ]
    }
   ],
   "source": [
    "mymin(liste)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "f73ec239-0bdb-4cde-9f6b-84b36b4d1e1e",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "min(liste) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "b3a07b9a-2d03-4cd8-aa99-6755ad7070fe",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "?min"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "91cf050e",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "min(*liste)"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "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.12.6"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": true,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": true,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "426.667px"
   },
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
