Level2.ipynb: Überarbeitung

dodonator · dodonator · commit 2c63aabd9e52 · 2022-10-13T21:07:44.000+02:00
Ich habe den nächsten Abschnitt überarbeitet
diff --git a/Level_02/Level_2.ipynb b/Level_02/Level_2.ipynb
@@ -216,14 +216,16 @@
    "source": [
     "## if-Bedingung\n",
     "\n",
-    "Nun da wir gelernt haben, was boolean-Werte sind, können wir diese in einer if-Abfrage benutzen: Codeteile nur dann ausführen, wenn eine Bedingung erfüllt ist. Sehen wir uns zunächst die Syntax einer if-Abfrage in Python an:\n",
+    "Nachdem du den Datentyp boolean kennengelernt hast, lernst du nun, wie du eine `if`-Bedingung benutzt. Eine `if`-Bedingung dient dazu einen Code-Abschnitt nur auszuführen, wenn eine Bedingung erfüllt ist. Bei dieser Bedingung handelt es sich um einen boolschen Ausdruck. Im folgendem Code-Ausschnitt siehst du eine beispielhafte if-Bedingung.\n",
     "\n",
     "```python\n",
-    "if Bedingung:\n",
-    "    Befehle\n",
+    "if True:\n",
+    "    print(\"True\")\n",
     "```\n",
     "\n",
-    "Wir starten mit dem Schlüsselwort `if`, dann kommt eine Bedingung, diese sollte einen boolschen Ausdruck zurückgeben, wir können diesen explizit angeben, der Interpreter ruft allerdings auf unsere Bedingung `bool()` auf und führt unsere Befehle aus, wenn dies `True`zurück gibt. Nach der Bedingung folgt ein Doppelpunkt `:`. Die nächste Zeile wird nun eingerückt, hierbei hat man sich auf __vier Leerzeichen__ geeinigt."
+    "### Einrückung und Gültigkeitsbereiche\n",
+    "\n",
+    "Beachte, dass der Code, welcher von der Bedingung beeinflusst werden soll um vier Leerzeichen eingerückt ist. Das ist kein Zufall. Anders als andere Programmiersprachen erkennt Python die Gültigkeitsbereiche nicht anhand von Klammern (Java benutzt zum Beispiel `{` und `}`), sondern anhand der Einrückung am Anfang der Zeile. Zu einem Gültigkeitsbereich gehören dabei alle aufeinanderfolgenden Zeilen gleicher Einrückung.\n"
    ]
   },
   {
@@ -243,79 +245,80 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Im obigen Codebeispiel prüft die if-Bedingung, ob der String `eingabe` leer ist. Dies geschieht implizit, d.h. es wird ausgenutzt, dass der Interpreter die Bedingung in einen boolean umwandelt. In dem Kommentar sind alternative Bedingungen beschrieben, die daselbe erreichen, allerdings umständlicher sind. <br>\n",
-    "Wenn wir uns aber an unser Problem aus der Einleitung erinnern, war unser Ziel eine Zahl aus der Eingabe zu lesen und Fehler durch falsche Benutzereingaben abzufangen. Wir wollen also darauf reagieren, wenn nichts eingegeben wurde, wenn eine Zahl eingegeben wurde und wenn eine Zeichenkette eingegeben wurde, die nicht als integer interpretiert werden kann."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "scrolled": false
-   },
-   "outputs": [],
-   "source": [
-    "eingabe = input(\"Bitte etwas eingeben: \")\n",
+    "Im obigen Beispiel siehst du ein interaktives Beispiel für eine einfache if-Bedingung. In dem Fall soll überprüft werden, ob die Eingabe leer ist. Beachte, dass die als Bedingung lediglich die Variable `eingabe` also ein string benutzt wird. Dies ist deshalb möglich, da der Python-Interpreter intern auf den Ausdruck, welchen du als Bedingung angibst, versucht mittels der `bool()`-Funktion in einen `boolean` umzuwandeln.  \n",
     "\n",
-    "if eingabe.isdigit():\n",
-    "    zahl = int(eingabe)\n",
-    "    print(zahl)\n",
+    "Eine if-Bedingung kann auch beliebig viele (optionale) `elif`-Zweige und einen (ebenfalls optionalen) `else`-Zweige enthalten. Das Schlüsselwort `elif` ist eine Abkürzung für `else if`. In einem `elif`-Zweig kannst du weitere Bedingungen prüfen. Es wird aber stets der erste Zweig ausgeführt, dessen Bedingung wahr ist. Der `else`-Zweig wird nur dann ausgeführt, wenn keine Bedingung wahr ist. Unten siehst du den schematischen Aufbau einer if-Bedingung (Achtung es handelt sich *nicht* um validen Python-Code).\n",
+    "```python\n",
+    "if Bedingung:\n",
+    "    Anweisungen\n",
+    "\n",
+    "elif Bedingung:\n",
+    "    Anweisungen\n",
+    "\n",
+    "...\n",
     "\n",
     "else:\n",
-    "    print(\"Ungültige Eingabe:\", eingabe)"
+    "    Anweisungen\n",
+    "```"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Wie wir sehen können, passiert im obigen Codebeispiel eine Menge auf einmal, gehen wir es also in Ruhe durch.\n",
-    "In der if-Abfrage wird mit der `str.isdigit()` Methode geprüft, ob der string `eingabe` nicht leer ist und nur aus Ziffern besteht; wenn dem so ist, erstellen wir einen integer `zahl` aus der Eingabe und geben diesen aus. In einem `else` Zweig, der ausgeführt wird, wenn die Bedingung der if-Abfrage nicht zutraf, geben wir dem Benutzer Feedback über seine falsche Eingabe zurück."
+    "Wenn du dich an das Problem im [Einstieg](#einstieg) erinnerst kannst du nun die if-Bedingung anwenden, um einen `Value-Error` bei Eingabe von falschen Werten zu vermeiden."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "scrolled": false
+   },
    "outputs": [],
    "source": [
-    "eingabe = input(\"Bitte eine Zahl eingeben: \")\n",
+    "eingabe = input(\"Bitte etwas eingeben: \")\n",
+    "\n",
+    "if eingabe.isdigit():\n",
+    "    zahl = int(eingabe)\n",
+    "    print(zahl)\n",
     "\n",
-    "if eingabe:\n",
-    "    # die Eingabe ist nicht leer.\n",
-    "    if eingabe.isdigit():\n",
-    "        zahl = int(eingabe)\n",
-    "        print(zahl, \"ist eine gültige Zahl.\")\n",
-    "    else:\n",
-    "        print(\"Die Eingabe ''\" + eingabe + \"' ist keine gültige Zahl\")\n",
     "else:\n",
-    "    print(\"Die Eingabe ist leer.\")"
+    "    print(\"Ungültige Eingabe:\", eingabe)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "if-Bedingungen können auch verschachtelt werden, d.h. wir können also in einer if-Bedingung eine weitere if-Bedingung definieren. Allerdings können wir dies durch die Benutzung des Schlüsselwortes `elif` vereinfachen:"
+    "Im obigen Beispiel wird die `str.isdigit()` Methode verwendet. Diese Methode gibt `True` zurück, sobald alle Zeichen in dem string Nummern sind. Durch Benutzung dieser Methode kannst du verhindern, dass dein Programm wegen eines `ValueError`s abstürzt. Du kannst natürlich auch zusätzlich prüfen, ob die Eingabe leer ist:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 5,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "23 ist eine gültige Zahl.\n"
+     ]
+    }
+   ],
    "source": [
     "eingabe = input(\"Bitte eine Zahl eingeben: \")\n",
     "\n",
     "if eingabe.isdigit():\n",
     "    # die Eingabe ist eine gültige Zahl\n",
     "    zahl = int(eingabe)\n",
     "    print(zahl, \"ist eine gültige Zahl.\")\n",
-    "    \n",
+    "\n",
     "elif not eingabe:\n",
     "    # die Eingabe ist leer\n",
     "    print(\"Die Eingabe ist leer\")\n",
-    "    \n",
+    "\n",
     "else:\n",
     "    # die Eingabe ist nicht leer, aber auch keine\n",
     "    # gültige Zahl\n",
@@ -326,15 +329,45 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Eine if-Bedingung enthält einen if-Zweig, beliebig viele optionale elif-Zweige und optional einen else-Zweig. Dabei wird immer der erste Zweig, dessen Bedingung zutrifft ausgeführt und nachher keine weiteren.\n",
-    "Daher ist es wichtig auf die Reihenfolge der Zweige zu achten."
+    "Du kannst if-Bedingungen auch ineinander verschachteln. Das kann bei komplexeren Bedingungen hilfreich sein. Unten siehst du das Beispiel von oben als verschachtelte if-Bedingung. Gerade bei längeren Bedingungen kann es hilfreich sein, diese zu verschachteln. Beachte beim Verschachteln von if-Bedingungen die Einrückung!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Die Eingabe 23  ist eine gültige Zahl.\n"
+     ]
+    }
+   ],
+   "source": [
+    "eingabe = input(\"Bitte eine Zahl eingeben: \")\n",
+    "\n",
+    "if eingabe:\n",
+    "    if eingabe.isdigit():\n",
+    "        # die Eingabe ist eine gültige Zahl\n",
+    "        zahl = int(eingabe)\n",
+    "        print(\"Die Eingabe\", zahl, \" ist eine gültige Zahl.\")\n",
+    "    else:\n",
+    "        # die Eingabe ist keine gültige Zahl\n",
+    "        print(\"Die Eingabe\", eingabe, \" ist keine gültige Zahl\")\n",
+    "\n",
+    "else:\n",
+    "    # die Eingabe ist leer\n",
+    "    print(\"Die Eingabe ist leer.\")"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## while-Schleife\n",
+    "\n",
     "Bisher ist es sehr schwierig Code mehrfach auszuführen, wenn wir unsere Programme wiederholen müssen wir sie neu starten. Nicht nur das, sondern haben wir keine Möglichkeit Befehle beliebig häufig auszuführen. Die Möglichkeit Code wiederholt auszuführen ist allerdings für viele Programme ein elementarer Bestandteil. Daher möchten wir uns im dritten Abschnitt dieses Levels mit der while-Schleife beschäftigen, die diese Probleme löst.\n",
     "\n",
     "Die while-Schleife ist im Aufbau ähnlich der if-Bedingung:\n",
