____###___Python_Crashkurs.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Python Crashkurs.ipynb",
      "provenance": []
    },
    "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 Text aus und nimmt dafür den Wert, der in den Klammern steht. print() kann auch mehrere Werte nehmen. 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 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": "nJY1QrEAid6F"
      },
      "source": [
        "mit der Funktion type() kann man den Datentyp eines Wertes bestimmen\n",
        "\n",
        "Man unterscheidet zwischen ganzen Zahlen(integer, kurz 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": "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": "7lEIf4uamzLk"
      },
      "source": [
        "Der operator / gibt immer eine Float zurück.\n",
        "\n",
        "Der Ergebnistyp der anderen Rechenoperatoren hängt davon ab, ob die Operation mit Integern oder mit Floats durchgeführt wird.\n",
        "\n",
        "Wenn ein Integer und ein Float in der gleichen Operation verwendet wird, 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"
      ]
    },
    {
      "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": "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": "b549c783-159e-4404-8f47-b5097be07fa7"
      },
      "source": [
        "eingabe=input(\"Wie heißt du?\")\n",
        "print(\"Hallo, \"+eingabe)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Wie heißt du?Abcde\n",
            "Hallo, Abcde\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "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": "yf48GiGluhQG"
      },
      "source": [
        "Es gibt sogenannte Module, die Zusatzfunktionen bereitstellen. Eins von denen Heß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"
      ]
    },
    {
      "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": "jnfk9ZuLxKVX"
      },
      "source": [
        "Es gibt einen weiteren Datentyp, den Typ Bool (auch Boolean 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) kommt zwischen zwei Bools und gibt zurück, ob beide wahr sind\n",
        "\n",
        "or (oder) kommt zwischen zwei Bools 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 eine 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": "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, in der Daten nach Zahlen geordnet sind. Man kann arrays neu erstellen, indem man die Werte in eckige Klammern tut und mit Kommas trennt. 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."
      ]
    },
    {
      "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"
      },
      "source": [
        "b=[0,1,2,3,4,5]\n",
        "len(b)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "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": "-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": "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": "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": "1HWv2kXalo45"
      },
      "source": [
        "Ein interessantes Konzept mit Funktionen ist Rekursion. Rekursion bedeutet, dass eine Funktion sich selbst aufruft.\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):\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": [
        "Einen Datentyp gibt es noch, das dictionary.\n",
        "Ein Dictionary ist eine Datenstruktur, die nach Strings geordnet ist.\n",
        "Ein Dictionary wird durch `{}` gekennzeichnet."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gBp0U83z1b5D",
        "outputId": "28bb7ce2-c7df-48ca-ecfc-aee4054c669e"
      },
      "source": [
        "d={\"blume\":\"rose\"}#dictionary definieren, mit einem Anfangswert (es geht auch ohne Anfangswert)\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"
        }
      ]
    }
  ]
}