Python_Crashkurs_22.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Python Crashkurs.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Rr8CgeuMM6pK"
      },
      "source": [
        "Wilkommen in meinem Python-Crashkurs (von Konrad). Wenn ihr die euch präsentierten Code-Beispiele verstanden habt, könnt ihr mit ihnen herumspielen."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TLRn3pvOf2QA"
      },
      "source": [
        "print() ist eine Funktion. Sie gibt den Wert, der in den Klammern steht, als Text aus. In Jupyter Notebook erscheint der Text dann unter dem Code. print() kann auch mehrere Werte nehmen, die dann mit einem Komma getrennt sind. Die Funktion print() hat keinen Rückgabewert.\n",
        "\n",
        "ein Rückgabewert ist ein Wert, den eine Funktion zurückgibt. Diesen kann man dann weiter benutzen , um ihn z.B. einer Variable(was das ist lernen wir später) zuzuweisen oder eine Funktion mit ihm aufzurufen\n",
        "\n",
        "Alles was nach einem # in der gleichen Zeile steht ist ein Kommentar\n",
        "\n",
        "Es gibt verschiedene Datentypen, davon schauen wir uns jetzt Strings(das ist roher Text, der mit \"\"-Zeichen umgeben ist) und Zahlen an."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TLHzqDj2f9Q_",
        "outputId": "df0b38cd-af65-43ba-d8ed-192cfda6cc81"
      },
      "source": [
        "print(5)\n",
        "print(\"ich mag Boote\")\n",
        "print(\"die Superzahl ist\",6)\n",
        "#strings und integer können beide durch print() ausgegeben werden"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "5\n",
            "ich mag Boote\n",
            "die Superzahl ist 6\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uU_-fWbMrjx8"
      },
      "source": [
        "*Mache jetzt die Übung 1*"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nJY1QrEAid6F"
      },
      "source": [
        "mit der Funktion type() kann man den Datentyp eines Wertes erfahren. Der Datentyp wird als Rückgabewert zurückgegeben. (Diese Funktion wird in richtigen Programmen so gut wie nie benutzt, aber es ist gut zu Wissen, wie man den Datentyp eines Wertes erfahren kann)\n",
        "\n",
        "Man unterscheidet zwischen ganzen Zahlen(integer, kurzgesagt int) und Kommazahlen(float)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YMdcJNKCiq9e",
        "outputId": "0aec6528-9626-45da-d1e4-257f784e3f9c"
      },
      "source": [
        "print(type(3))#integer, also ganze Zahl\n",
        "print(type(3.0))#float, also Kommazahl\n",
        "print(type(\"3\"))#string, weil es in Anführungszeichen ist"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "<class 'int'>\n",
            "<class 'float'>\n",
            "<class 'str'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "c3Mk3e3ffoff"
      },
      "source": [
        "Es gibt Rechenoperationen."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ipUswpR0RbJV",
        "outputId": "ffe5b8e4-9e24-4237-f481-9c3d75326409"
      },
      "source": [
        "print(1+1)#plus\n",
        "print(4-3)#minus\n",
        "print(5*5)#mal\n",
        "print(8/7)#durch\n",
        "print(2**5)#exponent\n",
        "print(11%5)#modulo. Lernt man nicht in der Schule, ist aber für Programmierer wichtig. Es ist wie teilen mit Rest, aber der Rest ist das Ergebnis."
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2\n",
            "1\n",
            "25\n",
            "1.1428571428571428\n",
            "32\n",
            "1\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dWmqdFkNru6S"
      },
      "source": [
        "*Mache jetzt Übung 2*"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mtswP-6q2RAl"
      },
      "source": [
        "Mit Strings können keine Mathematische Operationen durchgeführt werden. Trotzdem passiert etwas, wenn man + oder * auf einen String anwendet.\n",
        "\n",
        "Wenn ein String + gerechnet wird, wird der Text zusammengefügt.\n",
        "\n",
        "Wenn ein String mit einem Integer zusammen * gerechnet wird, wird der Text soundsoviel mal kopiert"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zBTjP0zE3HvT",
        "outputId": "f1db7e7c-38a4-474b-8af1-afcafa01cd95"
      },
      "source": [
        "print(\"bla\"+\" blubb\")\n",
        "print(\"bla\"*5)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "bla blubb\n",
            "blablablablabla\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1GuqYYP4zJCC"
      },
      "source": [
        "Wenn mehrere Rechenoperatoren in einer Codezeile verwendet werden, git punkt vor strich und links vor rechts.\n",
        "\n",
        "Man kann die Reihenfolge aber durch runde Klammern ändern. Es können beliebig viele runde Klammern verwendet werden."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oVKL-XRpzdHZ",
        "outputId": "ba9b2e85-24b5-4995-fc2a-c29ac9eb046f"
      },
      "source": [
        "print(1+2*3)\n",
        "print((1+2)*3)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "7\n",
            "9\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "y-ronvNHwFjC"
      },
      "source": [
        "*mache jetzt die Übung 3*"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7lEIf4uamzLk"
      },
      "source": [
        "Der operator / gibt immer eine Float zurück.\n",
        "\n",
        "Der Ergebnistyp der anderen Rechenoperatoren hängt davon ab, ob die Rechenoperation mit Integern oder mit Floats durchgeführt wird.\n",
        "\n",
        "Wenn ein Integer und ein Float in der gleichen Operation verwendet werden, wird der Integer in ein Float umgewandelt."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "A6QiP_FToTfM",
        "outputId": "4fc73448-ab8c-4959-93f6-94e3873200e3"
      },
      "source": [
        "print(type(1+1))#zwei integer\n",
        "print(type(1.0+1.0))#zwei floats\n",
        "print(type(1+1.0))#integer und float, durch Typenumwandlung wurde der integer aber zu float umgewandelt"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "<class 'int'>\n",
            "<class 'float'>\n",
            "<class 'float'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0ViN_082qV1e"
      },
      "source": [
        "Aber kann man auch absichtlich Variablen ineinander umwandeln? ja.\n",
        "\n",
        "int() um etwas zu Integer umzuwandeln\n",
        "\n",
        "float() um etwas zu float umzuwandeln\n",
        "\n",
        "str() um etwas zu string umzuwandeln\n",
        "\n",
        "Wenn int() oder float() etwas bekommt, was nicht als Zahl erkannt wird, gibt es einen Fehler."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "skQz6eRhp-HN",
        "outputId": "cc88ebd1-ca54-4ecb-c435-895b64af065a"
      },
      "source": [
        "print(type(int(1.0)))#float zu int\n",
        "print(type(int(\"1\")))#string zu int\n",
        "print(type(float(1)))#int zu float\n",
        "print(type(float(\"4.5\")))#string zu float\n",
        "print(type(str(\"45\")))#int zu string"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "<class 'int'>\n",
            "<class 'int'>\n",
            "<class 'float'>\n",
            "<class 'float'>\n",
            "<class 'str'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gZkJgoxdj5rI"
      },
      "source": [
        "Es gibt Variablen. (gespeicherte Werte, die immer verändert werden können)\n",
        "\n",
        "Man weist ihnen mit dem Gleichzeichen einen Wert zu "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vvaCGOCbla_g"
      },
      "source": [
        "baum=1+2"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6nz-pq8Xlgxz"
      },
      "source": [
        "Man kann den Wert von der Variable benutzen, wenn man ihren Namen in den Code schreibt"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tkaJg0aDly3r",
        "outputId": "ba5b777b-cc3a-4e41-e6d2-dbae07d8dd27"
      },
      "source": [
        "baum=6\n",
        "print(baum*3)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "18\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VrkA3i9ZxQhP"
      },
      "source": [
        "*mache jetzt Übung 4*"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KNuZn0ehtFbZ"
      },
      "source": [
        "Es gibt Anweisungen, um den Code abzukürzen, wenn eine Variable auf sich selbst plus/minus/mal/durch/modulo etwas anderes gesetzt wird. In den folgenden Codebeispielen werden diese Abkürzungen vorgestellt.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0_5ByO0ztfWA",
        "outputId": "7ed44549-0b4f-4832-8eac-b01a915e5859"
      },
      "source": [
        "a=0\n",
        "a=a+1\n",
        "print(a)\n",
        "#tut das Gleiche wie\n",
        "a=0\n",
        "a+=1\n",
        "print(a)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n",
            "1\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0wxSSc7ftrtk",
        "outputId": "ab010e11-fcb1-4bfb-cef0-4b2cd1537b35"
      },
      "source": [
        "a=5\n",
        "a=a-2\n",
        "print(a)\n",
        "#tut das Gleiche wie\n",
        "a=5\n",
        "a-=2\n",
        "print(a)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "3\n",
            "3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "00z7yoK9uKAZ",
        "outputId": "70cb5be7-4d3a-4c96-e80f-92e9734d5387"
      },
      "source": [
        "a=2\n",
        "a=a*2\n",
        "print(a)\n",
        "#tut das Gleiche wie\n",
        "a=2\n",
        "a*=2\n",
        "print(a)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "4\n",
            "4\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "20OM59JiPiYD",
        "outputId": "4444ae4d-65c4-43ec-f2b9-d764e456e7d1"
      },
      "source": [
        "a=6\n",
        "a=a/2\n",
        "print(a)\n",
        "#tut das Gleiche wie\n",
        "a=6\n",
        "a/=2\n",
        "print(a)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "3.0\n",
            "3.0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AUBg9beAPpSA",
        "outputId": "2e3af0b5-918c-48aa-a428-3fd0695d4ae6"
      },
      "source": [
        "a=8\n",
        "a=a%6\n",
        "print(a)\n",
        "#tut das Gleiche wie\n",
        "a=8\n",
        "a%=6\n",
        "print(a)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2\n",
            "2\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8hshUiqFuZ3M"
      },
      "source": [
        "zusammengefasst heißt das, zum Abkürzen gibt es +=, -=, *=, /= und %= ."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ttweAL5V1MkX"
      },
      "source": [
        "Die Funktion input() fragt den Benutzer des Programms nach einem Wert und hält das Programm an, bis der Benutzer einen Wert eingibt und die Enter-Taste drückt. Der Wert, den der Benutzer eingegeben hat, wird von der Funktion zurückgegeben.\n",
        "\n",
        "Man kann einen Wert in die Klammern von input() schreiben. Dieser wird ausgegeben."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "b7Jk1zh_1c4i",
        "outputId": "b9ee5e55-9e92-4311-ef0e-c87fc6a45e07"
      },
      "source": [
        "eingabe=input(\"Wie heißt du?\")\n",
        "print(\"Hallo, \"+eingabe)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Wie heißt du?Abcde\n",
            "Hallo, Abcde\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "b_YDs8ZR3uuq"
      },
      "source": [
        "Der Rückgabewert von input() ist immer ein String. Wenn du etwas mathematisches damit machen will, musst du ihn erst umwandeln."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "s-OLSi4V4A3H",
        "outputId": "73f66148-02bc-475b-e579-99cb3276e9d4"
      },
      "source": [
        "dieZahl=input(\"was ist deine Zahl? \")\n",
        "print(\"Deine Zahl hoch Zwei ist\",float(dieZahl)**2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "was ist deine Zahl? 2\n",
            "Deine Zahl hoch Zwei ist 4.0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DAYKYDUxzY-E"
      },
      "source": [
        "*mache Aufgabe 5*"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yf48GiGluhQG"
      },
      "source": [
        "Es gibt sogenannte Module, die Zusatzfunktionen bereitstellen. Eins von denen Heißt \"math\".\n",
        "\n",
        "Man importiert sie durch das Wort import"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0O-siWTQvIAY"
      },
      "source": [
        "import math"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VI7i9IP0vU_t"
      },
      "source": [
        "mit math kann man zum Beispiel die Wurzel ziehen, aufrunden und abrunden.\n",
        "\n",
        "(wenn du nur zu der nächstweiten Zahl runden willst, brauchst du das Math-modul nicht, da kannst du einfach die Funktion round() verwenden)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JSssL_oQvkVX",
        "outputId": "e3959fc1-852d-4b73-e540-74adbc7a6602"
      },
      "source": [
        "import math\n",
        "print(math.sqrt(4))#Wurzel ziehen\n",
        "print(math.floor(1.2))#abrunden\n",
        "print(math.ceil(1.2))#aufrunden"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2.0\n",
            "1\n",
            "2\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4RZILmtlwWug"
      },
      "source": [
        "jetzt probieren wir das Modul random aus"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SBkgNvZCwmsF",
        "outputId": "a518f0b8-7c60-474b-ee7f-0c6516d637ae"
      },
      "source": [
        "import random\n",
        "random.randint(40,50) #gibt eine zufällige Zahl von 40 bis 50 aus"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "42"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 74
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ScXYYdrqzwub"
      },
      "source": [
        "*Mache jetzt Übung 6*"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jnfk9ZuLxKVX"
      },
      "source": [
        "Es gibt einen weiteren Datentyp, den Typ Bool (auch Boolean, Wahrheitswert oder boolescher Wert genannt). Ein bool ist entweder True(wahr) oder False(falsch)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JciAE2TLxUm2",
        "outputId": "33a7e4de-5d5f-46b6-f465-b1427f7bcf8a"
      },
      "source": [
        "print(type(True))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "<class 'bool'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "m-puV9dCxudM"
      },
      "source": [
        "Auf bools können logische Operationen durchgeführt werden.\n",
        "\n",
        "not (nicht) kehrt einen Wert um\n",
        "\n",
        "and (und) wird zwischen zwei Bools geschrieben und gibt zurück, ob beide wahr sind\n",
        "\n",
        "or (oder) wird zwischen zwei Bools geschrieben und gibt zurück, ob eins von beiden wahr ist\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lTUXXslYyjSi",
        "outputId": "57e4dd0c-7b3b-44f6-c8aa-39174bf70e2d"
      },
      "source": [
        "print(not False)\n",
        "print(True and True)\n",
        "print(True or False)\n",
        "print(True and False)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "True\n",
            "True\n",
            "True\n",
            "False\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-qCKNYb64ktu"
      },
      "source": [
        "Variablen(vor Allem Zahlen) können verglichen werden. Dafür tut man einen Vergleichsoperator zwischen zwei Zahlen. Das Vergleichen gibt einen Boolschen Wert zurück.\n",
        "\n",
        "Es gibt == (beide Werte sind gleich),\n",
        "\n",
        "und es gibt > (der erste Wert ist größer als der zweite Wert)\n",
        "\n",
        "und es gibt < (der erste Wert ist kleiner als der zweite Wert)\n",
        "\n",
        "und es gibt >= (der erste Wert ist größer als der zweite Wert oder beide Werte sind gleich)\n",
        "\n",
        "und es gibt <= (der erste Wert ist kleiner als der zweite Wert oder beide Werte sind gleich)\n",
        "\n",
        "und es gibt !=(beide Werte sind verschieden)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "toBv0Yie5ls4",
        "outputId": "9953e14e-b165-49bd-e0d4-ff162509c8ff"
      },
      "source": [
        "print(1==1)\n",
        "print(1<1)\n",
        "print(2>1)\n",
        "print(3>=4)\n",
        "print(4!=5)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "True\n",
            "False\n",
            "True\n",
            "False\n",
            "True\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wftFFof26hPi"
      },
      "source": [
        "Hier kommt der Nutzen von Bools:If-Verzweigungen (\"if\" bedeutet \"wenn\" auf Englisch)\n",
        "\n",
        "Der Code einer If-Verzweigung wird nur ausgeführt, wenn der gegebene boolsche Wert wahr ist.\n",
        "\n",
        "Nach einer If-Verzweigung kann noch eine Else-Verzweigung(\"else\" bedeutet \"ansonsten\" auf Englisch) kommen. Diese wird ausgeführt, wenn die If-Verzweigung nicht ausgeführt wurde, weil ihr boolescher Wert False war.\n",
        "\n",
        "Man schreibt `if bool:` und rückt den Code, der von der If-Verzweigung betroffen ist, mit der Tab-Taste ein. Danach schreibt man(nur wenn man eine else-Verzweigung braucht) `else:` und rückt den Code, der von der Else-Verzweigung betroffen ist, ein."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "U3FP4nri7Vrv",
        "outputId": "7c376a2e-fc00-4a78-8c36-a328b76ff0e5"
      },
      "source": [
        "Zahl=float(input(\"was ist deine Zahl? \"))\n",
        "if Zahl>10:\n",
        "  print(\"deine Zahl ist größer als 10\")\n",
        "else:\n",
        "  print(\"deine Zahl ist nicht größer als 10\")\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "was ist deine Zahl? 2\n",
            "deine Zahl ist nicht größer als 10\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pYF_WuqVBUgO"
      },
      "source": [
        "Es ist auch möglich, nach einer If-Verzweigung Elif zu schreiben. Elif ist kurz für Else If\n",
        "\n",
        "Elif überprüft einen booleschen Wert, aber nur, wenn die vorherige If- oder Elif-Verzweigung false war und deshalb nicht ausgeführt wurde. Wenn der boolesche Wert wahr ist, wird der Code ausgeführt.\n",
        "\n",
        "Man schreibt einfach `elif bool:`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3xw1ZJm-CqSR",
        "outputId": "7f688f2d-91cb-4ea5-bfd9-e2ac0e897f92"
      },
      "source": [
        "tier=input(\"Wähle ein Tier \")\n",
        "if tier==\"Schaf\":\n",
        "  print(\"Du hast ein Schaf gewählt\")\n",
        "elif tier==\"Schlange\":\n",
        "  print(\"Du hast eine Schlange gewählt\")\n",
        "elif tier==\"Blobfisch\":\n",
        "  print(\"Du hast einen Blobfisch gewählt\")\n",
        "elif tier==\"Mammut\":\n",
        "  print(\"Du hast ein Mammut gewählt\")\n",
        "else:\n",
        "  print(\"Du hast ein anderes Tier gewählt\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Wähle ein Tier Mammut\n",
            "Du hast ein Mammut gewählt\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tan3XCGR05Ce"
      },
      "source": [
        "*mache jetzt Übung 7*"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QmbNg7dM9eHH"
      },
      "source": [
        "Jetzt kommt die While-Schleife.\n",
        "\n",
        "Die While-Schleife überprüft einen booleschen Wert und führt den betroffenen Code aus, wenn der boolesche Wert wahr ist. Dann überprüft die While-Schleife nochmal den booleschen Wert und führt den Code nochmal aus, wenn der boolesche Wert wahr ist. Das geht immer so weiter bis der boolesche Wert nach einem Durchlauf falsch ist.\n",
        "\n",
        "Du musst vorsichtig sein, dass du keine endlose While-Schleife schreibst.\n",
        "\n",
        "Die While-Schleife schreibt man `while bool:` und der betroffene Code wird eingerückt."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WaCe96Ap--Fv",
        "outputId": "733a0151-7142-4fe1-c81f-80f4ab299f71"
      },
      "source": [
        "x=0\n",
        "while x<10:\n",
        "  print(x)\n",
        "  x+=1\n",
        "print(\"Schleife fertig\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0\n",
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n",
            "6\n",
            "7\n",
            "8\n",
            "9\n",
            "Schleife fertig\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xYKW0UmoXrb0"
      },
      "source": [
        "Arrays, auch Liste genannt, sind eine Datenstruktur. Die Daten im Array haben eine bestimmte Position. Die Position ist eine ganze Zahl. Man kann arrays neu erstellen, indem man die Werte in eckige Klammern tut und mit Kommas trennt (oder einfach nur leere eckige Klammern schreibt, dann gibt es ein leeres Array). Es ist in python egal, welchen Datentyp die Werte haben und es können auch mehrere Datentypen in dem gleichen Array sein. Ja, ein Array kann auch ein anderes Array enthalten.\n",
        "\n",
        "Anmerkung: In diesem Kurs meine ich mit den Wörtern \"Array\" und \"Liste\" das Gleiche. In anderen Programmiersprachen gibt es einen Unterschied zwischen Array und Liste."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "i7sOlcYCYUvg"
      },
      "source": [
        "a=[\"rot\",\"blau\",40]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hMKnmXSDYcKG"
      },
      "source": [
        "Auf ein Element in einem Array wird zugegriffen, indem man den Namen des Arrays schreibt, dann eckige Klammern und die Nummer des Eintrags. Vorsicht, die Numerierung fängt mit 0 an"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QYXri7WKYwMS",
        "outputId": "1316fbca-c4b2-4d6e-8d60-e6d75b733ddb"
      },
      "source": [
        "a=[\"a\",\"b\",\"c\",\"d\"]\n",
        "print(a[2])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "c\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "P2W6OZ83D-v1"
      },
      "source": [
        "Du kannst auf mehrere Elemente eines Arrays zugreifen, indem du `:` in die eckigen Klammern schreibst.\n",
        "\n",
        "schreibe `[x:]`, um alle Elemente ab der x-ten Stelle anzuzeigen (einschließlich x)\n",
        "\n",
        "schreibe `[:x]` um alle Elemente bis zur x-ten Stelle anzuzeigen (nicht einschließlich x)\n",
        "\n",
        "schreibe `[x:y]` um alle Elemente von x bis y anzuzeigen (einschließlich x aber nicht einschließlich y)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0irgcVnpEcrI",
        "outputId": "c1fa37f0-eb33-4a1d-cedc-c99ea56fe244"
      },
      "source": [
        "a=[1,2,3,4,5]\n",
        "print(a[2:])\n",
        "print(a[:3])\n",
        "print(a[1:4])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[3, 4, 5]\n",
            "[1, 2, 3]\n",
            "[2, 3, 4]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "46uvEaSLZEFB"
      },
      "source": [
        "Die Länge eines Arrays lässt sich durch die Funktion `len()` feststellen"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Yp-V17uRZUq6",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "37e49c7c-2154-4c27-be44-3b191e511372"
      },
      "source": [
        "b=[0,1,2,3,4,5]\n",
        "len(b)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "6"
            ]
          },
          "metadata": {},
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IINjx5kAb7Hv"
      },
      "source": [
        "Hier ein Beispiel, in dem Arrays ausgegeben werden."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VmWJ9RSWczU8",
        "outputId": "39fa5751-a9f2-4eb1-e99c-8c397b44f2a5"
      },
      "source": [
        "Staedte=[\"Darmstadt\",\"Düsseldorf\",\"Brandenburg\"]\n",
        "Bewertungen=[6,5,7]\n",
        "z=0\n",
        "while z<3:\n",
        "  print(Staedte[z],Bewertungen[z])\n",
        "  z+=1"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Darmstadt 6\n",
            "Düsseldorf 5\n",
            "Brandenburg 7\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "t3pLfqjo5SmV"
      },
      "source": [
        "*mache jetzt Übung 8*"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-BVOOsVIc6k5"
      },
      "source": [
        "Das gerade gezeigte Stück code lässt sich mithilfe der for-Schleife noch kürzer machen.\n",
        "\n",
        "Eine For-Schleife schreibt man `for neueVariable in liste:`\n",
        "Für jedes Element in der Liste wird das eingerückte Stück Code nochmal neu ausgeführt. Bei jedem Durchlauf ist die neueVariable ein anderes Element der Liste. Die neue Variable wird häufig `i` genannt."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "f-AIgXxIfAVg",
        "outputId": "4364e13a-3309-4fdb-f88a-05d6bccb9f1d"
      },
      "source": [
        "for i in [\"rot\",\"blau\",\"grün\",\"gelb\"]:\n",
        "  print(i)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "rot\n",
            "blau\n",
            "grün\n",
            "gelb\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "V5rzu_zOfUOd"
      },
      "source": [
        "Wenn jemand in einer For-Schleife eine Zahlenfolge will, kann das vereinfacht werden durch die Funktion `range()`\n",
        "\n",
        "Die Funktion range() benötigt mindestens einen Eingabewert und hat maximal drei Eingabewerte. Sie wird anstatt einer Liste in das For-Statement eingefügt.\n",
        "\n",
        "Nur ein Eingabewert: gibt eine Zahlenfolge aus, die mit 0 anfängt und weitergeht, bis der Wert des Eingabewertes erreicht ist(dieser ist dann nicht in der Zahlenfolge)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xHMZ76KTiH2w",
        "outputId": "61a77909-9812-4741-caf1-c7c88cdd43c0"
      },
      "source": [
        "for i in range(5):\n",
        "  print(i)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0\n",
            "1\n",
            "2\n",
            "3\n",
            "4\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dnDJigWKiT7G"
      },
      "source": [
        "Zwei Eingabewerte: gibt eine Zahlenfolge aus, die mit dem Wert des ersten Eingabewertes anfängt und bis zu dem Wert des zweiten Eingabewertes weitergeht(dieser nicht inklusive)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "L26Wg2P3iXRm",
        "outputId": "ee51477c-c614-41a7-da2e-6e39e3982fa7"
      },
      "source": [
        "for i in range(2,10):\n",
        "  print(i)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2\n",
            "3\n",
            "4\n",
            "5\n",
            "6\n",
            "7\n",
            "8\n",
            "9\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MafPOwUpiTiS"
      },
      "source": [
        "Drei Eingabewerte: gibt Zahlen vom ersten Eingabewert(inklusive) bis zum zweiten Eingabewert(nicht inklusive) aus, die Größe der Schritte ist der dritte Eingabewert."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eIgWuQutigZ5",
        "outputId": "c7c5d61a-fe36-4a2b-fbd5-ec1ac80c6f78"
      },
      "source": [
        "for i in range(1,30,4):\n",
        "  print(i)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n",
            "5\n",
            "9\n",
            "13\n",
            "17\n",
            "21\n",
            "25\n",
            "29\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fWjo1S-Sisvd"
      },
      "source": [
        "Hier das Codebeispiel Städtebewertung mit einer For-Schleife"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ag-81k4JivlY",
        "outputId": "f281329e-bc56-4120-fb40-299714789c9c"
      },
      "source": [
        "Staedte=[\"Darmstadt\",\"Düsseldorf\",\"Brandenburg\"]\n",
        "Bewertungen=[6,5,7]\n",
        "for i in range(3):\n",
        "  print(Staedte[i],Bewertungen[i])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Darmstadt 6\n",
            "Düsseldorf 5\n",
            "Brandenburg 7\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "A8QSMVd362fl"
      },
      "source": [
        "*Mache jetzt die Aufgaben 9, 10 und 11*"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "y-uwVLnq7Vz4"
      },
      "source": [
        "Du kannst einem Array ein Element hinzufügen, indem du `nameDesArrays.append(wert)` benutzt."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "plOqONix7pdp",
        "outputId": "0ce4ef57-7159-43c0-cbbe-91e83cb9c2fe"
      },
      "source": [
        "array=[1,2,3,4]\n",
        "array.append(5)\n",
        "print(array)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1, 2, 3, 4, 5]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "e0-e9XEH70tv"
      },
      "source": [
        "Es gibt auch die Funktion ´nameDesArrays.pop()`. Diese Funktion tut zwei sachen auf einmal: Sie entfernt das letzte Element eines Arrays und sie gibt das entfernte Element als Rückgabewert."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JphTkXrJ8Dwy",
        "outputId": "57cb0242-676a-44ba-da0d-d439d514f043"
      },
      "source": [
        "a=[1,2,3,4,5,6,7]\n",
        "print(a.pop(),\"wurde entfernt\")\n",
        "print(a,\"bleibt übrig\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "7 wurde entfernt\n",
            "[1, 2, 3, 4, 5, 6] bleibt übrig\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nC_1p3rEGSl3"
      },
      "source": [
        "Außerdem kann man mit der Rechenoperation `+` zwei Arrays zusammenfügen."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "701tTAXlGc2O",
        "outputId": "f6aa2edc-a74c-4c02-b4ec-36bd721e2299"
      },
      "source": [
        "a=[1,2,3,4]\n",
        "b=[5,6,7,8]\n",
        "c=a+b\n",
        "print(c)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1, 2, 3, 4, 5, 6, 7, 8]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qjcuJBGe7nL2"
      },
      "source": [
        "*mache Aufgabe 12*"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EPf0291hjBAD"
      },
      "source": [
        "Hier kommt ein wichtiger Teil von Python, das Definieren von Funktionen.\n",
        "\n",
        "Um funktionen zu definieren schreibst du `def funktion(argument1,argument2):`\n",
        "Du kannst die Argumente beliebig nennen und kannst beliebig viele benutzen. Es ist auch möglich, gar kein Argument zu benutzen. Der eingerückte Code ist der Code deiner Funktion.\n",
        "\n",
        "Die Argumente existieren nur innerhalb der Funktion und wenn die Funktion zu ende ist verschwinden sie.\n",
        "\n",
        "Um deine Funktion aufzurufen schreibst du den Namen der Funktion und danach runde Klammern. In den Klammern schreibst du die Argumente der Funktion, oder du lässt die Klammern leer wenn die Funktion keine Argumente nimmt.\n",
        "\n",
        "Wenn du willst, dass die Funktion einen Wert zurückgibt, schreibst du `return wert`.\n",
        "\n",
        "return beendet die Funktion sofort. Wenn nach dem return noch mehr Code Steht, wird dieser nicht ausgeführt."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Xt2fxV5wlgP6",
        "outputId": "1b8b2bf5-20d0-4d74-b5a0-762e6901e68d"
      },
      "source": [
        "def malZwei(zahl):\n",
        "  return zahl*2\n",
        "print(malZwei(2))\n",
        "print(malZwei(3))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "4\n",
            "6\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0Wq8Kat799rh"
      },
      "source": [
        "Hier ist etwas, das bei Funktionen zu beachten ist:\n",
        "Wenn eine Liste in eine Funktion gegeben wird, wird die Liste nicht kopiert.\n",
        "\n",
        "Der Name des Arguments, durch das du der Funktion die Liste übermittelt, ist neu, zeigt aber auf die gleiche Liste. Die Liste gibt es nur einmal im Speicher.\n",
        "\n",
        "Das heißt: wenn du einer Funktion eine Liste übermittelst und die Liste in der Funktion änderst, änderst du auch die ursprüngliche Liste.\n",
        "\n",
        "hier ein Beispiel"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "V-x6HSAUA8kv",
        "outputId": "d2f4d669-e18a-4a3f-8f01-04ad4ea71816"
      },
      "source": [
        "liste=[\"altes Element\"]\n",
        "def sinnloseFunktion(l):\n",
        "  l.append(\"neues Element\")\n",
        "\n",
        "print(liste)\n",
        "sinnloseFunktion(liste)\n",
        "print(liste)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['altes Element']\n",
            "['altes Element', 'neues Element']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4KhElTk0BxH-"
      },
      "source": [
        "Um eine Liste zu kopieren, schreibst du `nameDerListe.copy()`\n",
        "\n",
        "Hier ist der gleiche Code, aber die Liste wird in der Funktion kopiert und nur die Kopie wird verändert"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "icnEjXysByFt",
        "outputId": "85dabb2c-c578-465e-e553-881782af658a"
      },
      "source": [
        "liste=[\"altes Element\"]\n",
        "def sinnloseFunktion(l):\n",
        "  l2=l.copy()\n",
        "  l2.append(\"neues Element\")\n",
        "\n",
        "print(liste)\n",
        "sinnloseFunktion(liste)\n",
        "print(liste)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['altes Element']\n",
            "['altes Element']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wsF-JWcC9FJY"
      },
      "source": [
        "*mache Aufgabe 13, 14 und 15*"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1HWv2kXalo45"
      },
      "source": [
        "Ein interessantes Konzept mit Funktionen ist Rekursion. Rekursion bedeutet, dass eine Funktion sich selbst aufruft. Dies passiert, bis die Funktion sich nicht mehr selbst aufruft, weil eine bestimmte Bedingung erfüllt ist. Diese Bedingung heißt Rekursionsanker. Nachdem der Rekursionsanker erreicht wurde, gibt die Funktion ihr Ergebnis an die übergeordnete Funktion zurück, die auf das Ergebnis wartet. Die übergeordnete Funktion macht weiter, bis auch sie ihr Ergebnis an die nächste übergeordnete Funktion zurückgibt. Irgendwann ist die Funktion erreicht, die die Rekursion gestartet hat.\n",
        "\n",
        "Hier ist zum Beispiel eine Funktion, die alle Zahlen von 1 bis X miteinander multipliziert. Das geht auch mit einer Schleife, aber hier ist der rekursive Ansatz."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Y1h7wGOE2It1",
        "outputId": "36fdf847-6978-4d59-dbde-3469e72aa5f2"
      },
      "source": [
        "def ultimulti(zahl): #in der Mathematik heißt diese Funktion \"Fakultät\"\n",
        "  if(zahl==1):\n",
        "    return 1\n",
        "  else:\n",
        "    return ultimulti(zahl-1)*zahl\n",
        "\n",
        "print(ultimulti(10))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "3628800\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "G-DQ4s4Yl1V-"
      },
      "source": [
        "Hier ist Quicksort(ein fortgeschrittener Algorithmus zum Sortieren). Quicksort funktioniert rekursiv."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LdNrV3M82Jmn",
        "outputId": "4b9db304-c9f9-47af-9c7c-2843dc13a097"
      },
      "source": [
        "import random\n",
        "def neueUnsortierteListe():\n",
        "  neueListe=[]\n",
        "  for i in range(100):\n",
        "    neueListe.append(random.randint(0,100))\n",
        "  return neueListe\n",
        "def quicksort(liste):\n",
        "  kleiner=[]\n",
        "  groesser=[]\n",
        "  gleich=[]\n",
        "  pivot=liste[0]\n",
        "  for e in liste:\n",
        "    if e==pivot:\n",
        "      gleich.append(e)\n",
        "    elif e<pivot:\n",
        "      kleiner.append(e)\n",
        "    else:\n",
        "      groesser.append(e)\n",
        "  if(len(kleiner)>1):\n",
        "    kleiner=quicksort(kleiner)\n",
        "  if(len(groesser)>1):\n",
        "    groesser=quicksort(groesser)\n",
        "  return kleiner+gleich+groesser\n",
        "unsortierteListe=neueUnsortierteListe()\n",
        "print(unsortierteListe)\n",
        "sortierteListe=quicksort(unsortierteListe)\n",
        "print(sortierteListe)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[48, 95, 46, 24, 43, 67, 2, 19, 46, 61, 25, 80, 2, 93, 44, 19, 1, 59, 89, 67, 98, 81, 71, 3, 79, 24, 63, 26, 55, 59, 58, 62, 8, 82, 28, 12, 71, 82, 4, 8, 46, 66, 29, 78, 24, 32, 74, 23, 78, 88, 99, 0, 88, 86, 76, 42, 61, 53, 81, 64, 25, 32, 87, 69, 2, 44, 75, 61, 64, 84, 47, 76, 74, 88, 54, 85, 15, 4, 16, 58, 97, 59, 32, 14, 91, 42, 33, 87, 65, 62, 33, 42, 20, 13, 42, 97, 55, 61, 84, 11]\n",
            "[0, 1, 2, 2, 2, 3, 4, 4, 8, 8, 11, 12, 13, 14, 15, 16, 19, 19, 20, 23, 24, 24, 24, 25, 25, 26, 28, 29, 32, 32, 32, 33, 33, 42, 42, 42, 42, 43, 44, 44, 46, 46, 46, 47, 48, 53, 54, 55, 55, 58, 58, 59, 59, 59, 61, 61, 61, 61, 62, 62, 63, 64, 64, 65, 66, 67, 67, 69, 71, 71, 74, 74, 75, 76, 76, 78, 78, 79, 80, 81, 81, 82, 82, 84, 84, 85, 86, 87, 87, 88, 88, 88, 89, 91, 93, 95, 97, 97, 98, 99]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dG6R3x8Y9X1H"
      },
      "source": [
        "Ich stelle euch einen weiteren Datentyp vor: das dictionary.\n",
        "Ein Dictionary ist eine Datenstruktur, die Schlüssel und dazugehörige Werte hat. Jedem Schlüssel wird ein Wert zugewiesen. Schlüssel können zum Beispiel vom Datentyp String, Integer, Float oder Boolean sein, aber sie können nicht Listen oder Dictionaries sein. Die dazugehörigen Werte können alles sein, auch Dictionaries und Listen.\n",
        "\n",
        "Ein Dictionary wird durch `{}` gekennzeichnet.\n",
        "\n",
        "Wenn es nötig ist, dass ein Schlüssel in einem Dictionary aus mehreren Werten besteht, wird die Datenstruktur \"tuple\" verwendet. Auf Tuples gehe ich hier nicht genauer ein."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gBp0U83z1b5D",
        "outputId": "28bb7ce2-c7df-48ca-ecfc-aee4054c669e"
      },
      "source": [
        "d={\"blume\":\"rose\"}#dictionary definieren, das schon Werte enthält\n",
        "d[\"blaetter\"]=6#element verändern\n",
        "print(d)#dictionary ausgeben\n",
        "print(d[\"blume\"])#bestimmtes Element ausgeben"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'blume': 'rose', 'blaetter': 6}\n",
            "rose\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KcOQrdBk-B7c"
      },
      "source": [
        "*Mache Aufgabe 16*"
      ]
    }
  ]
}