Funktionen, Bedingungen und Schleifen hinzugefügt.

Author: barooney

.gitignore

@@ -127,3 +127,5 @@ dmypy.json
 
 # Pyre type checker
 .pyre/
+
+/**/.idea

Funktionen, Schleifen und Bedingungen/Bedingungen/lesson-info.yaml

@@ -0,0 +1,3 @@
+content:
+- task1
+- task2

Funktionen, Schleifen und Bedingungen/Bedingungen/task1/__init__.py

@@ -0,0 +1,4 @@
+hausaufgaben_gemacht = False
+
+if not hausaufgaben_gemacht:
+    essen = False

Funktionen, Schleifen und Bedingungen/Bedingungen/task1/main.py

@@ -0,0 +1,7 @@
+type: theory
+custom_name: Was sind Bedingungen?
+files:
+- name: main.py
+  visible: true
+- name: __init__.py
+  visible: false

Funktionen, Schleifen und Bedingungen/Bedingungen/task1/task-info.yaml

@@ -0,0 +1,81 @@
+# Was sind Bedingungen?
+
+"Wenn du deine Hausaufgaben nicht machst, dann gibt es heute kein Abendessen!"
+So oder so ähnlich hat jeder diesen Satz wahrscheinlich schon einmal gehört.
+
+Solche Kausalitätszusammenhänge lassen sich (vereinfacht) auch im Computer abbilden.
+Der Computer ist eine streng logisch denkende Maschine.
+Ihm fallen logische Ausdrücke und Aussagen sehr leicht und wahrscheinlich löst er Aufgaben dieses Typs schneller als du 
+selbst – solange man sie ihm begreiflich machen kann.
+
+Um einem Computer Logik nahezubringen, muss man die Aussagen, die man überprüfen möchte, in die sogenannte Boolesche
+Algebra überführen.
+In dieser haben Ausdrücke nur die Werte "wahr", `True` und `1` oder "falsch", `False` und `0`.
+
+Ein Satz wie "Ich gieße meine Blumen jeden Tag, an dem es nicht regnet oder schneit und mittwochs" ist für uns erstmal
+leicht zu erfassen und wahrscheinlich auch manuell schnell auszuwerten.
+Sätze wie "Ich mag Bücher, in denen eine Protagonistin mitspielt, die rote Haare hat, und dessen Genre Horror ist oder 
+dessen Cover blau-grün ist, aber nur wenn das Genre dann nicht Fantasy lautet, genauso gefallen mir Abenteuerberichte, 
+die eine Motorrad-Reise entlang der Ostküste Australiens beschreiben" sind auf den ersten Blick eher schwer zu 
+verstehen und nicht so leicht zu prüfen.
+
+Hier haben wir eine Vielzahl an Merkmalen, die wir für ein Buch überprüfen müssen – und bestenfalls widerspricht sich 
+keines davon.
+
+Das "Mögen" eines Buches lässt sich also in mehrere unabhängige Bedingungen zerlegen:
+
+Für den ersten Teil des Satzes erkennen wir die folgenden Merkmale:
+
+* Es muss eine Protagonistin geben (A)
+* diese muss rote Haare haben (B)
+* Das Genre des Buches muss "Horror" lauten (C)
+
+Für den zweiten Teil des Satzes finden wir die folgenden Merkmale:
+
+* Das Cover muss blau-grün sein (D)
+* Das Genre darf nicht "Fantasy" lauten (E)
+
+Der letzte Teil beschreibt die Bücher mit diesen Merkmalen:
+
+* Das Genre muss "Abenteuerbericht" sein (F)
+* Es muss um eine Motorrad-Reise gehen (G)
+* Diese Reise muss an der Ostküste Australiens stattgefunden haben (H)
+
+So weit, so gut.
+Wir möchten dieser Person nun ein Buch schenken.
+Dank der detaillierten Beschreibung der Wunschlektüre stehen wir nun im Laden und haben eigentlich das perfekte Buch
+gefunden:
+
+Wir haben eine Protagonistin mit roten Haaren, das Cover ist blau-grün und es handelt sich um einen Abenteuerbericht.
+
+Wollen wir nun prüfen, ob das Buch infrage kommt, dann müssen wir Schritt für Schritt jedes Merkmal in jeder der drei 
+Listen kontrollieren.
+Sobald wir für eine der drei Listen alle Merkmale bestätigen können, können wir dieses Buch kaufen.
+
+Fangen wir an:
+
+Wir haben eine Protagonistin, diese hat rote Haare, das Genre ist aber nicht Horror.
+Auf die erste Kategorie von Büchern trifft das Buch nicht zu.
+
+Für die zweite Kategorie sieht es besser aus:
+Das Cover ist blau-grün und das Genre ist nicht Fantasy – es ist ein Abenteuerbericht.
+Top!
+Die dritte Kategorie brauchen wir nicht mehr überprüfen, denn wir haben ja eine der drei Schubladen getroffen.
+
+Obwohl wir viele Beschränkungen haben, wie das Buch sein darf und wie nicht, so ist unsere Entscheidung letzten Endes
+ein "Ja" oder ein "Nein".
+Hier kommen wir wieder zurück zu den Boolschen Ausdrücken.
+
+<div class="hint">
+    Für die, die es interessiert:
+    Ein Boolscher Ausdruck zu dem Satz oben könnte etwa <code>(A^B^C)v(D^E)v(F^G^H)</code> lauten.
+    Die <code>v</code>s stehen dabei für "Oder" und die <code>^</code>s für "Und".
+    Es müssen also A, B <strong>UND</strong> C zutreffen <strong>ODER</strong> D <strong>UND</strong> E <strong>ODER
+    </strong> F, G <strong>UND</strong> H.
+</div>
+
+
+Wir wollen nicht damit anfangen und diesen Buchauswahl-Algorithmus in Code zwängen.
+Es soll nur ein (hoffentlich) anschauliches Beispiel sein, wie solche Bedingungen gestaltet sein können.
+
+Im folgenden Abschnitt schauen wir uns an, wie wir Bedingungen in Python implementieren können.

Funktionen, Schleifen und Bedingungen/Bedingungen/task1/task.md

@@ -0,0 +1,15 @@
+type: edu
+custom_name: if, else, elif
+files:
+- name: tests/test_task.py
+  visible: false
+- name: __init__.py
+  visible: false
+- name: tests/__init__.py
+  visible: false
+- name: task.py
+  visible: true
+  placeholders:
+  - offset: 30
+    length: 322
+    placeholder_text: return "Ein guter Anfang"

Funktionen, Schleifen und Bedingungen/Bedingungen/task2/__init__.py

@@ -0,0 +1,135 @@
+# if, else, elif
+
+Um den sogenannten Kontrollfluss in Python zu verändern, gibt es die Schlüsselwörter `if`, `else` und `elif`.
+Sie helfen uns dabei, unseren Programmablauf zu verändern, indem wir weitere Schritte ausführen, wenn nötig oder andere
+überspringen, wenn sie nicht notwendig sind.
+
+Dabei müssen wir uns auf die Boolschen Ausdrücke konzentrieren, die wir im vorigen Abschnitt kennengelernt haben.
+Wir können nur prüfen, ob eine bestimmte Bedingung zutrifft oder nicht.
+"Ein bisschen zutreffen" oder "ein bisschen nicht zutreffen" gibt es in diesem Fall nicht!
+
+Stellen wir uns vor, wir gehen wandern und kommen an eine Weggabelung.
+Um uns zu entscheiden, in welche Richtung wir gehen (nach links oder rechts), wollen wir eine Münze werfen.
+Zeigt die Münze Kopf, dann gehen wir nach links, zeigt sie Zahl, dann gehen wir nach rechts.
+
+Wir nehmen an, dass wir öfter abbiegen müssen und uns öfters mittels Münzwurf für einen der beiden Weggabelungen
+entscheiden.
+Deswegen verwenden wir eine Funktion, der wir als Parameter das Ergebnis des Münzwurfs mitgeben.
+Als Ergebnis wollen wir dann wissen, ob wir nach links oder nach rechts abbiegen:
+
+```python
+def abbiegen(seite):
+    if seite == "kopf":
+        return "links"
+    else:
+        return "rechts"
+```
+
+Hier siehst du schon wieder viele neue Konzepte:
+`if` und `else` sind zwei der drei Schlüsselwörter, die oben bereits vorgestellt wurden.
+Dabei erwartet `if` eine Bedingung, die überprüft wird (in diesem Fall ist das `seite == "kopf"`).
+Hat der Parameter `seite` also den Wert `"kopf"`, dann ist der Vergleich an dieser Stelle wahr.
+Auffällig ist hier das doppelte Gleichheitszeichen.
+In der Mathematik schreibt man ein Gleichheitszeichen, um die Gleichheit auszudrücken, in Python und vielen anderen
+Programmiersprachen verwendet man zwei davon, um Vergleiche kenntlich zu machen.
+Würden wir in der Bedingung nur ein Gleichheitszeichen verwenden, dann würde Python `"kopf"` in `seite` speichern.
+
+Wenn wir Zahlen miteinander vergleichen wollen, dann können wir nicht nur auf Gleichheit, sondern auch auf 
+Verschiedenheit prüfen.
+Vergleiche wie `<` und `>` erlauben es uns, Zahlen in Relation zu setzen.
+Außerdem gibt es die Vergleiche `>=` und `<=`, die prüfen, ob eine Zahl größer oder gleich (oder kleiner oder gleich)
+einer anderen Zahl ist.
+Wenn wir uns nicht sicher sind, ob eine Zahl größer oder kleiner ist, wir aber wissen wollen, ob eine Zahl ungleich 
+einer anderen Zahl ist, dann können wir `!=` verwenden.
+
+`else` taucht – wenn überhaupt – immer mit einem zugehörigen `if` auf und kann niemals alleine stehen, es muss aber 
+nicht auftauchen, wie wir gleich sehen werden.
+In dem Beispiel oben prüfen wir, ob `seite` den Wert `"kopf"` hat – dann wollen wir nach links abbiegen.
+Wenn wir aber nicht Kopf geworfen haben (das heißt nicht nur, dass wir Zahl geworfen haben, die Münze kann 
+beispielsweise auch auf dem Rand stehengeblieben sein), dann wollen wir in jedem Fall nach rechts gehen.
+Und das "in jedem Fall" ist hier wichtig, weil wir an das `else` keine Bedingung mehr knüpfen können.
+Der Teil unterhalb von `else` wird immer dann ausgeführt, wenn kein anderer sogenannter Zweig (also keine Bedingung)
+zutreffend war.
+
+Doch was ist, wenn wir mehr als zwei Wege haben – angenommen, wir haben drei Wege.
+Eine Münze hilft uns dabei nicht mehr weiter, weswegen wir jetzt zu einem Würfel greifen.
+Würfeln wir eine 1 oder 2, dann gehen wir nach links, bei einer 3 oder 4 gehen wir geradeaus und bei einer 5 oder 6
+biegen wir nach rechts ab:
+
+```python
+def abbiegen(augenzahl):
+    if 1 <= augenzahl <= 2:
+        return "links"
+    elif 3 <= augenzahl <= 4:
+        return "geradeaus"
+    elif 5 <= augenzahl <= 6:
+        return "rechts"
+```
+
+Python erlaubt es uns, Vergleiche von mehreren Zahlen etwas kompakter zu schreiben.
+Wollen wir also sicherstellen, dass die `augenzahl` zwischen `1` und `2` liegt, dann können wir das wie folgt notieren:
+`1 <= augenzahl <= 2`
+Damit wird ausgedrückt, dass die 1 kleiner oder gleich `augenzahl` und zusätzlich dazu auch `augenzahl` kleiner oder
+gleich 2 sein soll.
+
+Diese Ausdrücke lassen sich auch komplexer beschreiben, insbesondere dann, wenn es nicht mehr ausschließlich um Zahlen
+geht.
+Statt `1 <= augenzahl <= 2` können wir auch `1 <= augenzahl and augenzahl <= 2` schreiben.
+Hierbei prüfen wir dieselben Kriterien, allerdings in zwei Schritten und verlangen dann, dass beides zutreffen muss,
+indem wir die Bedingungen mit dem Schlüsselwort `and` verbinden.
+Erinnern wir uns nochmal an die letzte Aufgabe – hier haben wir auch mit "Und" und "Oder" gearbeitet.
+Das Äquivalent für "Oder" ist entsprechend `or`.
+
+Ein vereinfachtes Beispiel der Buchauswahl aus der letzten Aufgabe könnte wie folgt aussehen:
+
+```python
+def buchauswahl(genre, protagonistin, coverfarbe):
+    if protagonistin and genre == "Horror":
+        return True
+    if coverfarbe == "blau-grün" and genre != "Fantasy":
+        return True
+    return False
+```
+
+Hierbei beachten wir nur die ersten beiden Fälle (es gibt eine Protagonistin und das Genre entspricht Horror
+und das Buchcover ist blau-grün und das Genre ist nicht Fantasy).
+Diese Funktion ist für uns lesbar und verständlich, jedoch lässt sich diese Auswahl noch knapper zusammenfassen.
+Ich will niemanden motivieren, solchen Code zu schreiben, wenn man darüber stolpert, dann sollte man sich aber nicht
+verunsichern lassen:
+
+```python
+def buchauswahl(genre, protagonistin, coverfarbe):
+    return (protagonistin and genre == "Horror") or (coverfarbe == "blau-grün" and genre != "Fantasy")
+```
+
+Statt mit `if`, `elif` und `else` zu arbeiten, schreiben wir alles in eine Zeile und verzichten auf diese 
+Schlüsselwörter.
+Das können wir machen, weil das Schlüsselwort `or` uns gestattet, die beiden Bedingungen miteinander zu verbinden.
+Wir prüfen also, ob entweder der erste Teil vor dem `or` oder der zweite Teil nach dem `or` wahr wird.
+Es müssen nicht beide Teile wahr werden.
+
+Anders ist es bei dem Schlüsselwort `and` in den Klammern:
+Hier müssen beide (oder alle, wenn man mehrmals `and` notiert) Bedingungen erfüllt sein.
+Zum Beispiel muss es eine Protagonistin geben und das Buch zum Genre "Horror" gehören.
+
+## Aufgabe
+
+Basierend auf dem Würfel-Beispiel oben sollst du nun eine Funktion schreiben, die deine Würfelwürfe "kommentiert".
+Ein Wurf mit einer niedrigen Zahl (1 und 2) soll beispielsweise mit einem "Schade, nur eine 1" kommentiert werden.
+Würfe mit einer 3 und 4 können als "Durchschnitt" bezeichnet werden.
+Eine 5 kannst du mit einem "So knapp!" kommentieren und die 6 mit "Super! Weiter so!"
+Achte darauf, die jeweilige Zahl auch immer im Text zu verwenden.
+
+Eine Beispielausgabe des Programms könnte also wie folgt aussehen:
+
+```
+Schade, nur eine 1
+Schade, nur eine 2
+Eine durchschnittliche 3
+Eine durchschnittliche 4
+So knapp - leider nur eine 5
+Super! Eine 6
+```
+
+Teste deine Ausgabe, indem du das Programm mit dem grünen Pfeil oben links neben dem Editorfenster startest.
+Bist du mit deiner Lösung zufrieden, dann klicke unter der Aufgabe auf "Check".

Funktionen, Schleifen und Bedingungen/Bedingungen/task2/task-info.yaml

@@ -0,0 +1,19 @@
+def kommentar(augenzahl):
+    if 1 <= augenzahl <= 2:
+        return "Schade, nur eine " + str(augenzahl)
+    elif 3 <= augenzahl <= 4:
+        return "Eine durchschnittliche " + str(augenzahl)
+    elif augenzahl == 5:
+        return "So knapp - leider nur eine " + str(augenzahl)
+    elif augenzahl == 6:
+        return "Super! Eine " + str(augenzahl)
+
+
+if __name__ == '__main__':
+    print(kommentar(1))
+    print(kommentar(2))
+    print(kommentar(3))
+    print(kommentar(4))
+    print(kommentar(5))
+    print(kommentar(6))
+

Funktionen, Schleifen und Bedingungen/Bedingungen/task2/task.md

@@ -0,0 +1,29 @@
+import unittest
+
+from task import kommentar
+
+
+# todo: replace this with an actual test
+class TestCase(unittest.TestCase):
+    def test_kombinationen(self):
+        komm1 = kommentar(1).replace(str(1), "")
+        komm2 = kommentar(2).replace(str(2), "")
+        komm3 = kommentar(3).replace(str(3), "")
+        komm4 = kommentar(4).replace(str(4), "")
+        komm5 = kommentar(5).replace(str(5), "")
+        komm6 = kommentar(6).replace(str(6), "")
+
+        self.assertNotEqual(komm1, "Ein guter Anfang")
+
+        self.assertEqual(komm1, komm2)
+        self.assertEqual(komm3, komm4)
+        self.assertNotEqual(komm1, komm3)
+        self.assertNotEqual(komm1, komm4)
+        self.assertNotEqual(komm2, komm3)
+        self.assertNotEqual(komm2, komm4)
+
+        self.assertNotEqual(komm1, komm5)
+        self.assertNotEqual(komm1, komm6)
+        self.assertNotEqual(komm3, komm5)
+        self.assertNotEqual(komm4, komm6)
+        self.assertNotEqual(komm5, komm6)

Funktionen, Schleifen und Bedingungen/Bedingungen/task2/task.py

@@ -0,0 +1,3 @@
+content:
+- task1
+- task2

Funktionen, Schleifen und Bedingungen/Bedingungen/task2/tests/__init__.py

@@ -0,0 +1,17 @@
+type: choice
+is_multiple_choice: true
+options:
+- text: Funktionen geben immer den selben Wert zurück.
+  is_correct: false
+- text: Funktionen finden im echten Leben keine Anwendung.
+  is_correct: false
+- text: Funktionen helfen dabei, sich beim Programmieren seltener zu wiederholen.
+  is_correct: true
+- text: Parameter beeinflussen eine Funktion nicht.
+  is_correct: false
+files:
+- name: task.py
+  visible: true
+- name: __init__.py
+  visible: false
+custom_name: Was sind Funktionen?

Funktionen, Schleifen und Bedingungen/Bedingungen/task2/tests/test_task.py

@@ -0,0 +1,31 @@
+# Was sind Funktionen?
+
+Funktionen sind etwas Alltägliches, auch wenn uns das oft nicht so bewusst ist.
+Die Tankfüllung eines Autos ist beispielsweise eine Funktion, die unter anderem abhängig von der zurückgelegten Strecke
+ist.
+Etwas abstrakter gedacht ist auch der Kontostand eine Funktion, deren Wert sich abhängig von der Zeit verändert – zum
+Monatsbeginn gibt es Gehalt und der Kontostand steigt an.
+Mit dem ersten Einkauf nimmt der Kontostand wieder ab.
+
+Funktionen können stetig sein (wie die Tankfüllung zum Beispiel) oder unstetig (wie der Kontostand), das heißt, dass man
+die Tankfüllung in einen zweidimensionalen Graphen einzeichnen kann, ohne den Stift dafür abzusetzen.
+Der Kontostand ist eine nicht-stetige Funktion:
+Von dem einen auf den anderen Moment ist mehr oder weniger Geld auf dem Konto, das Geld wird aber nicht Cent für Cent 
+überwiesen.
+Das führt dazu, dass ich an einem Punkt aufhören und den Stift an eine andere Position bewegen muss, um dort
+weiterzuzeichnen.
+
+Python (und Programmiersprachen allgemein) nutzen das Konzept von Funktionen meist dazu, um sich wiederholende 
+Code-Fragmente nur einmal schreiben zu müssen.
+Die Funktionalität ("Funktion" steckt hier nicht ohne Grund drin) wird also nur einmal geschrieben und kann dann 
+beliebig oft wiederverwendet werden.
+
+Wie schon eingangs erwähnt, kann eine Funktion Abhängigkeiten besitzen - beispielsweise die zurückgelegte Strecke oder
+der Zeitpunkt, zu dem die Funktion aufgerufen wird.
+In der Programmierung nennt man diese Abhängigkeiten Parameter.
+Sie können Einfluss auf die Funktion nehmen.
+
+Wir wollen uns einige Funktionen anschauen – erste Beispiele siehst du bereits im Code-Editor.
+
+Doch zuerst kannst du dein Wissen zu Funktionen selbst prüfen:
+Welche Aussage(n) über Funktionen treffen zu?

Funktionen, Schleifen und Bedingungen/Funktionen/lesson-info.yaml

@@ -0,0 +1,19 @@
+# Berechne die Summe zweier Zahlen
+def add(a, b):
+    return a + b
+
+
+# Berechne die Differenz zweier Zahlen
+def sub(a, b):
+    return a - b
+
+
+# Berechne das Produkt zweier Zahlen
+def mul(a, b):
+    return a * b
+
+
+# Berechne den Quotienten zweier Zahlen
+def quot(a, b):
+    return a / b
+

Funktionen, Schleifen und Bedingungen/Funktionen/task1/__init__.py

@@ -0,0 +1,16 @@
+type: edu
+custom_name: Eine eigene Funktion definieren
+files:
+- name: task.py
+  visible: true
+  placeholders:
+  - offset: 63
+    length: 80
+    placeholder_text: '# Du kannst diesen Teil hier löschen und die Funktion selbst
+      implementieren.'
+- name: __init__.py
+  visible: false
+- name: tests/__init__.py
+  visible: false
+- name: tests/test_task.py
+  visible: true