Level 2: Grammatik und Tippfehler

YtvwlD · YtvwlD · commit 808ed57a090d · 2019-03-11T20:09:56.000+01:00
diff --git a/Level_02/Level_2.ipynb b/Level_02/Level_2.ipynb
@@ -20,7 +20,7 @@
    },
    "source": [
     "## Einstieg\n",
-    "In diesem Level werden wir lernen, wie wir Bedingungen stellen, die erfüllt werden müssen, damit bestimmter Code ausgeführt wird. Dafür werden wir erst den Typ des __boolean__ einführen und im Anschluss unsere erste Kontrolstruktur, die if-Bedingung. Wir  werden die Schlüsselwörter `True`, `False`, `if`, `elif`, `else` und `is` kennenlernen."
+    "In diesem Level werden wir lernen, wie die Ausführung von bestimmten Code an Bedingungen knüpfen. Dafür werden wir erst den Typ des __boolean__ einführen und im Anschluss unsere erste Kontrollstruktur, die if-Bedingung. Wir werden die Schlüsselwörter `True`, `False`, `if`, `elif`, `else` und `is` kennenlernen."
    ]
   },
   {
@@ -47,8 +47,8 @@
     }
    },
    "source": [
-    "Schauen wir uns obigen Code an. Wir erwarten eine Eingabe und versuchen aus dieser Eingabe einen integer zu entnehmen. Dies klappt auch, wenn der Benutzer eine ganze Zahl eingibt, gibt er jedoch keine ganze Zahl, sondern zum Beispiel eine Zeichenkette ein, wird ein `ValueError` geworfen. Ebenso wird ein Fehler geworfen, wenn der Benutzer nichts eingibt.\n",
-    "Im Verlaufe dieses Levels werden wir lernen Benutzereingaben zu prüfen und entsprechend zu reagiern."
+    "Schauen wir uns obigen Code an. Wir erwarten eine Eingabe und versuchen aus dieser Eingabe einen integer zu entnehmen. Dies klappt auch, wenn der Benutzer eine ganze Zahl eingibt - gibt er jedoch stattdessen zum Beispiel eine Zeichenkette ein, wird ein `ValueError` geworfen. Ebenso wird ein Fehler geworfen, wenn der Benutzer nichts eingibt.\n",
+    "Im Verlauf dieses Levels werden wir, lernen Benutzereingaben zu prüfen und entsprechend zu reagieren."
    ]
   },
   {
@@ -121,7 +121,9 @@
     "Genauso wie integer und floats gibt es auch für booleans Operatoren:\n",
     "* `and` das logische \"und\"\n",
     "* `or` das logische \"oder\"\n",
-    "* `not` die logische Negation"
+    "* `not` die logische Negation\n",
+    "\n",
+    "Außerdem lässt sich auch xor (`^`) auf booleans anwenden."
    ]
   },
   {
@@ -137,7 +139,8 @@
    "source": [
     "print(\"not True:\", not True)\n",
     "print(\"True or False:\", True or False)\n",
-    "print(\"True and False:\", True and False)"
+    "print(\"True and False:\", True and False)\n",
+    "print(\"True ^ False:\", True ^ False)"
    ]
   },
   {
@@ -180,7 +183,7 @@
    "metadata": {},
    "source": [
     "### \"==\" und \"is\"\n",
-    "`==` prüft, ob die Variablen auf die gleichen Objekte zeigen. <br>\n",
+    "`==` prüft, ob die Objekte, auf die die Variablen zeigen, äquivalent sind. <br>\n",
     "`is` prüft, ob die Variablen auf dasselbe Objekt zeigen."
    ]
   },
@@ -201,12 +204,12 @@
    "metadata": {},
    "source": [
     "## if-Bedingung\n",
-    "Nun da wir gelernt haben, was boolean-Werte sind können wir diese in einer if-Abfrage benutzen, Codeteile nur dann auszuführen, wenn eine Bedingung erfüllt ist. Sehen wir uns zunächst die Syntax einer if-Abfrage in Python an:\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",
+    "```python\n",
     "if Bedingung:\n",
     "    Befehle\n",
     "```\n",
-    "Wir starten mit dem Schlüsselwort `if`, dann kommt eine Bedingung, diese sollte einen boolschen Ausdruck zurückgeben, wir können diesen explicit angeben, der Interpreter ruft allerdings auf unsere Bedingung `bool()` auf und führt unsere Befehle aus, wenn diese `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."
+    "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."
    ]
   },
   {
@@ -226,7 +229,7 @@
    "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",
+    "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."
    ]
   },
@@ -252,8 +255,8 @@
    "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."
+    "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."
    ]
   },
   {

Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@`
`20`	`20`	`},`
`21`	`21`	`"source": [`
`22`	`22`	`"## Einstieg\n",`
`23`		- "In diesem Level werden wir lernen, wie wir Bedingungen stellen, die erfüllt werden müssen, damit bestimmter Code ausgeführt wird. Dafür werden wir erst den Typ des __boolean__ einführen und im Anschluss unsere erste Kontrolstruktur, die if-Bedingung. Wir werden die Schlüsselwörter `True`, `False`, `if`, `elif`, `else` und `is` kennenlernen."
	`23`	+ "In diesem Level werden wir lernen, wie die Ausführung von bestimmten Code an Bedingungen knüpfen. Dafür werden wir erst den Typ des __boolean__ einführen und im Anschluss unsere erste Kontrollstruktur, die if-Bedingung. Wir werden die Schlüsselwörter `True`, `False`, `if`, `elif`, `else` und `is` kennenlernen."
`24`	`24`	`]`
`25`	`25`	`},`
`26`	`26`	`{`
`@@ -47,8 +47,8 @@`
`47`	`47`	`}`
`48`	`48`	`},`
`49`	`49`	`"source": [`
`50`		- "Schauen wir uns obigen Code an. Wir erwarten eine Eingabe und versuchen aus dieser Eingabe einen integer zu entnehmen. Dies klappt auch, wenn der Benutzer eine ganze Zahl eingibt, gibt er jedoch keine ganze Zahl, sondern zum Beispiel eine Zeichenkette ein, wird ein `ValueError` geworfen. Ebenso wird ein Fehler geworfen, wenn der Benutzer nichts eingibt.\n",
`51`		`- "Im Verlaufe dieses Levels werden wir lernen Benutzereingaben zu prüfen und entsprechend zu reagiern."`
	`50`	+ "Schauen wir uns obigen Code an. Wir erwarten eine Eingabe und versuchen aus dieser Eingabe einen integer zu entnehmen. Dies klappt auch, wenn der Benutzer eine ganze Zahl eingibt - gibt er jedoch stattdessen zum Beispiel eine Zeichenkette ein, wird ein `ValueError` geworfen. Ebenso wird ein Fehler geworfen, wenn der Benutzer nichts eingibt.\n",
	`51`	`+ "Im Verlauf dieses Levels werden wir, lernen Benutzereingaben zu prüfen und entsprechend zu reagieren."`
`52`	`52`	`]`
`53`	`53`	`},`
`54`	`54`	`{`
`@@ -121,7 +121,9 @@`
`121`	`121`	`"Genauso wie integer und floats gibt es auch für booleans Operatoren:\n",`
`122`	`122`	"* `and` das logische \"und\"\n",
`123`	`123`	"* `or` das logische \"oder\"\n",
`124`		- "* `not` die logische Negation"
	`124`	+ "* `not` die logische Negation\n",
	`125`	`+ "\n",`
	`126`	+ "Außerdem lässt sich auch xor (`^`) auf booleans anwenden."
`125`	`127`	`]`
`126`	`128`	`},`
`127`	`129`	`{`
`@@ -137,7 +139,8 @@`
`137`	`139`	`"source": [`
`138`	`140`	`"print(\"not True:\", not True)\n",`
`139`	`141`	`"print(\"True or False:\", True or False)\n",`
`140`		`- "print(\"True and False:\", True and False)"`
	`142`	`+ "print(\"True and False:\", True and False)\n",`
	`143`	`+ "print(\"True ^ False:\", True ^ False)"`
`141`	`144`	`]`
`142`	`145`	`},`
`143`	`146`	`{`
`@@ -180,7 +183,7 @@`
`180`	`183`	`"metadata": {},`
`181`	`184`	`"source": [`
`182`	`185`	`"### \"==\" und \"is\"\n",`
`183`		- "`==` prüft, ob die Variablen auf die gleichen Objekte zeigen. <br>\n",
	`186`	+ "`==` prüft, ob die Objekte, auf die die Variablen zeigen, äquivalent sind. <br>\n",
`184`	`187`	"`is` prüft, ob die Variablen auf dasselbe Objekt zeigen."
`185`	`188`	`]`
`186`	`189`	`},`
`@@ -201,12 +204,12 @@`
`201`	`204`	`"metadata": {},`
`202`	`205`	`"source": [`
`203`	`206`	`"## if-Bedingung\n",`
`204`		`- "Nun da wir gelernt haben, was boolean-Werte sind können wir diese in einer if-Abfrage benutzen, Codeteile nur dann auszuführen, wenn eine Bedingung erfüllt ist. Sehen wir uns zunächst die Syntax einer if-Abfrage in Python an:\n",`
`205`		- "```\n",
	`207`	`+ "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",`
	`208`	+ "```python\n",
`206`	`209`	`"if Bedingung:\n",`
`207`	`210`	`" Befehle\n",`
`208`	`211`	"```\n",
`209`		- "Wir starten mit dem Schlüsselwort `if`, dann kommt eine Bedingung, diese sollte einen boolschen Ausdruck zurückgeben, wir können diesen explicit angeben, der Interpreter ruft allerdings auf unsere Bedingung `bool()` auf und führt unsere Befehle aus, wenn diese `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."
	`212`	+ "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."
`210`	`213`	`]`
`211`	`214`	`},`
`212`	`215`	`{`
`@@ -226,7 +229,7 @@`
`226`	`229`	`"cell_type": "markdown",`
`227`	`230`	`"metadata": {},`
`228`	`231`	`"source": [`
`229`		- "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",
	`232`	+ "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",
`230`	`233`	`"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."`
`231`	`234`	`]`
`232`	`235`	`},`
`@@ -252,8 +255,8 @@`
`252`	`255`	`"cell_type": "markdown",`
`253`	`256`	`"metadata": {},`
`254`	`257`	`"source": [`
`255`		`- "Wie wir sehen können passiert im obigen Codebeispiel eine Menge auf einmal, gehen wir es also in Ruhe durch.\n",`
`256`		- "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."
	`258`	`+ "Wie wir sehen können, passiert im obigen Codebeispiel eine Menge auf einmal, gehen wir es also in Ruhe durch.\n",`
	`259`	+ "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."
`257`	`260`	`]`
`258`	`261`	`},`
`259`	`262`	`{`