<jupyter_start><jupyter_text>3.3 Conditions - Bedingungen 3.3.7-3.3.8 Falsy Werte & die logischen Operatoren and, not & orIm Anschluss dieser Übungseinheit kannst du ...+ falsy Werte von truthy Werten unterscheiden+ falsy Werte für Bedingungen einsetzen+ mit and, not und or mehrere Bedingungen gleichzeitig stellen und diese auch negieren+ mit dem Modul random und dessen Submodul choice ein zufälliges Element aus einer Liste auswählen  3.3.7 Truthiness & FalsinessIm Zusammenhang mit Conditions ist es notwendig, die Begriffe **True** und **False** sowie **truthy** und **falsy** zu klären. Ohne das Verständnis für diese Begriffe werden dir unerklärliche Outputs oder gar keine Outputs begegnen. Außerdem kannst du mit der Kenntnis über sie Fehler abfangen und sie im Zusammenhang mit ``if`` und Loops (Schleifen, Teil folgender Kapitel) zu deinen Gunsten einsetzen.Ein If-Satement bzw. eine Bedingung im Allgemeinen kann True oder False sein.  Werte, die zu einem True führen, werden als truthy bezeichnet.  Werte, die zu einem False führen, werden als falsy bezeichnet.  Zahlenwerte sind grundsätzlich truthy, einzig **die 0 jedes numerischen Datentyps ist falsy**.  Beispiel:<jupyter_code>number = 0

if number:
    print(f'Zahlenausgabe: {number}')<jupyter_output><empty_output><jupyter_text>Kannst du dir erklären, warum diese Zelle nicht ausgeführt wird?Unter welcher Bedingung wird das If-Satement ausgeführt?  Wenn es True ist.  0 ist aber keine truthy Zahl. Das gleiche gilt für eine 0 als Float:<jupyter_code>number = 0.0

if number:
    print(f'Zahlenausgabe: {number}')<jupyter_output><empty_output><jupyter_text>Ebenso wird auch die 0 des numerischen Datentyps complex nicht zu einer Ausgabe führen: 0j   Wofür ist das gut?Nehmen wir an, du hast einen Preis mit 0 initialisiert. Die Initialisierung ist notwendig, damit price von Python für weitere Operationen registriert wird. Der tatsächliche Preis soll erst festgelegt werden, nachdem das Produkt im Sortiment ist:<jupyter_code>price = 0

if price > 0:
    print(price)
else:
    print('Das Produkt ist nicht verfügbar.')<jupyter_output><empty_output><jupyter_text>Da der Preis 0 ist, ist das If-Statement nicht True und der Else-Block wird ausgeführt. So kannst du die falsy 0 verwenden, um Objekte auf default Werte/voreingestellte Werte festzulegen. Mit Conditions kannst du die Defaults dann behandeln.    Strings sind grundsätzlich truthy, **leere Strings sind falsy**.  In dem folgenden Beispiel wird gezeigt, was passiert, wenn ein/e UserIn nichts eingibt und nur Enter drückt. Weil ``input()`` stets einen String erzeugt, ist keine Eingabe ein leerer String:<jupyter_code>choice = input('Was ist deine Lieblingsfarbe?\n')

if choice:
    print('Das ist auch meine Lieblingsfarbe.')
else:
    print('Du hast nichts eingegeben.')

choice<jupyter_output><empty_output><jupyter_text>Ohne den Check darauf, ob choice truthy ist, könnte die fehlende Eingabe zu einem Fehler im Programmablauf führen. Ausgefeiltere Beispiele zur Behandlung unerwünschter Werte werden dir später noch gezeigt.True und False sind Konstanten. Das heißt, ihr Wert ist in Python unveränderlich festgelegt. Eine weitere Konstante ist None. **False und None sind falsy Werte**. Mit None kannst du ebenso den default Wert einer Variablen festlegen, in dem Fall den Wert einer Variablen, die später mal True oder False werden soll.  Das folgende Beispiel könnte man auch kompakter schreiben, doch es soll dir zur Demonstration dienen, wie man Werte auf Defaults setzen und diese dann mit "echten" (truthy) Werten belegen kann:<jupyter_code>win = None

points = 80

if points > 50:
    win = True
else:
    win = False
    
if win:
    print('Du hast gewonnen!')
else:
    print('Du hast verloren')<jupyter_output><empty_output><jupyter_text>Gefüllte Objekte sind grundsätzlich truthy, **leere Objekte, wie eine leere Liste, sind falsy**.  Beispiel:<jupyter_code>product_list = []

if product_list:
    print('Es befinden sich Produkte in dieser Liste.')
else:
    print('Die Produktliste ist leer.')<jupyter_output><empty_output><jupyter_text>Weil die Produktliste leer ist, ist das If-Statement nicht True und ``else`` wird ausgeführt. Listen gehören übrigens zu der Gruppe der Collections. Zu Collections gehören auch Dictionarys, Sets und Tuples (gesprochen: "Tupls"). Du lernst diese in einem späteren Kapitel kennen, wie auch die Gruppe der Sequences (Zahlenfolgen).   Übersicht zu falsy Werten:  | Gruppe | falsy-Wert ||----------|-------|| Zahlen | 0 (integer) || | 0.0 (float) || | 0j (complex) || Strings| '&nbsp;' (leerer String)|| | "&nbsp;"  (leerer String)|| Konstanten| False|| | None|| Collections| [&nbsp;]  (leere Liste)|| | {} (leeres Dictionary)|| | set(&nbsp;) (leeres Set)|| | (&nbsp;) (leeres Tuple)|| Sequence| range(0) (leere Sequenz)|      Mit der funktion ``bool()`` kannst du dir ausgeben lassen, ob ein Wert truthy oder falsy ist:  Beispiel:<jupyter_code>bool(0)<jupyter_output><empty_output><jupyter_text>Übung zu Falsy: Die test_variable soll mit einem Wert belegt werden, welcher auf Truthiness oder Falsiness getestet wird.          In der Ausgabe soll erscheinen, ob dieser Wert truthy oder falsy ist. Lass für jede Möglichkeit zusätzlich ausgeben, ob die Test-Variable zu einem True oder False führt (mit bool()).  2 Tipps zur Lösung der Aufgabe findest du weiter unten. Versuch die Aufgabe aber erst auf eigene Faust zu lösen.  **Gewünschte Ausgabe für einen falsy Wert:**  Das ist ein falsy Wert.  bool() ergibt: False<jupyter_code>test_variable =<jupyter_output><empty_output><jupyter_text>Tipp 1 zur Aufgabe: Erinnere dich daran, dass man Funktionen direkt in F-Strings anwenden kann. Du kannst bool() natürlich auch auslagern.     Tipp 2 zur Aufgabe: Du brauchst bool() hier nicht, um Bedingungen festzulegen. Sieh dir die vorgestellten Beispiele an, um auf die Lösung zu kommen.  3.3.8 Die logischen Operatoren and, not & or  3.3.8 a) andMit ``and`` werden 2 Werte oder Bedingungen verknüft. Sind beide Werte True bzw. treffen beide Bedingungen zu (sind beide True), ist das Ergebnis True, ansonsten False.Beispiele:<jupyter_code>x = True
y = False

x and y
x = True
y = True

x and y
x = False
y = False

x and y<jupyter_output><empty_output><jupyter_text>``and`` kann man einsetzen, um Bedingungen festzulegen.  Beispiel:<jupyter_code>age = 25

if age > 18 and age < 68:
    print('Sie können für uns arbeiten.')<jupyter_output><empty_output><jupyter_text>Übung zu and: Dein/e KundIn möchte nur dann eine Pizza kaufen, wenn ihr Preis zwischen 5-12 Euro liegt. Verwende das Modul randint wie in der vorherigen Einheit, um einen zufälligen Preis zwischen 2-25 Euro als den Wunschpreis deiner/s KundIn zu erhalten. Liegt der Wunschpreis in diesem Bereich, soll es zum Kaufabschluss kommen. Ansonsten soll jeweils ausgegeben werden, dass der Wunschpreis entweder zu hoch oder zu niedrig ist.  Werwende and um den Bereich des Wunschpreises abzudecken.  (Lass dir zur Überprüfung deiner Lösung den zufällig erzeugten Preis ausgeben.)<jupyter_code>from random import randint

customer_price = randint(2,25)

print(customer_price)

if customer_price >= 5 and customer_price <= 12:
    print('Die Pizza wird gekauft.')
elif customer_price < 5:
    print('Der Wunschpreis ist zu niedrig.')
else:
    print('Der Wunschpreis ist zu hoch')<jupyter_output><empty_output><jupyter_text>3.3.8 b) not``not`` (= nicht) funktioniert ähnlich wie ``!=``. Es checkt, ob ein Wert nicht der Spezifizierung entspricht. Es wird direkt nach ``if`` und ``elif`` platziert.  Beispiele:<jupyter_code>x = 3

not x == 4
income = 3000

if not income < 2000:
    print('Du verdienst mehr als 2000 Euro.')<jupyter_output><empty_output><jupyter_text>Der Unterschied zu ``!=`` liegt darin, dass man mit ``not`` größer/kleiner Vergleiche anstellen kann, wie in dem Beispiel mit income. Ob ein Wert einem anderem entspricht, ist mit beiden möglich.<jupyter_code>x = 3

x != 4
income = 3000

if income != 2000:
    print('Du verdienst nicht 2000 Euro.')<jupyter_output><empty_output><jupyter_text>Man kann über ``not`` Werte verändern, wenn sie nicht der Spezifierung entsprechen. Das wäre auch mit mit den anderen logischen Operatoren und Membership- und Identity-Operators, Funktionen mit boolschen Rückgabewerten sowie ausschließlich (ohne ``not``) den Vergleichsoperatoren möglich. Doch nun wird dir das exemplarisch anhand von ``not`` gezeigt:<jupyter_code>apple_price = 0

if not apple_price > 0:
    apple_price = 1.5
    print('Der Apfelpreis wurde auf 1,50 Euro gesetzt')<jupyter_output><empty_output><jupyter_text>Eine Erweiterung von ``not`` ist mit ``not in`` gegeben. Es checkt, ob ein Wert nicht in einem anderen enthalten ist (True) oder doch (False). Du hast es bereits in dem Kapitel "3.2.12 a)  Membership Operators" kennengelernt.  Wird ``not`` 2 Mal hintereinander eingesetzt, führt es zu einer doppelten Negierung, die sich aufhebt:<jupyter_code>value = True

value = not not value

print(value)<jupyter_output><empty_output><jupyter_text>Der Wert bleibt True bei einer doppelten Negierung. Bei einer einfachen wird er verändert:<jupyter_code>value = True

value = not value

print(value)<jupyter_output><empty_output><jupyter_text>Übung zu not: Ist die Zahl gerade oder ungerade?      In dem Kapitel "3.1.1 Python als Taschenrechner - Rechenarten" hast du den Modulo-Operator kennengelernt. Mit ihm kannst du feststellen, ob eine Zahl gerade oder ungerade ist. Eine Zahl ist gerade, wenn sie durch 2 teilbar ist, ohne Rest (in dem Kapitel ist das beschrieben).  Generiere eine zufällige Integer zwischen 0 und 100 und teste, unter dem Einsatz von not, ob sie nicht gerade und folglich ungerade sein muss.  Gib das Testergebnis aus.  (Lass dir zur Überprüfung die Zahl ausgeben.)  3.3.8 c) orMit ``or`` (= oder) werden auch 2 Werte oder Bedingungen verknüft. Sind beide Werte True bzw. treffen beide Bedingungen zu (sind beide True), ist das Ergebnis True. Ist nur einer der Werte True, ist das Ergebnis True. Sind beide False, ist das Ergebnis False.Beispiele:<jupyter_code>a = True

b = True

a or b
a = True

b = False

a or b
a = False

b = False

a or b<jupyter_output><empty_output><jupyter_text>Übung zu or: Du hast eine exemplarische Liste des Möbelhauses "Gute Laune Möbel" vorliegen.    Das Modul random wurde bereits für dich importiert, damit mit seinem Submodul choice bzw. dessen Funktion choice() ein Möbelstück zufällig aus dieser Liste ausgewählt wird.  Lass dein Programm ausgeben, ob das Möbelstück entweder ein Sitz-/Liegemöbel, ein Schrank oder ein Tisch ist.  Weiter unten findest du 5 Tipps für diese Aufgabe. Sieh sie dir nur an, wenn du nicht weiter kommst.  Gewünschte Ausgabe für z.B. 'Esstisch':  Das Möbelstück Esstisch ist ein: Tisch.<jupyter_code>from random import choice

furniture = choice(['Sofa','Sessel','Küchenschrank','Kleiderschrank','Schreibtisch','Esstisch'])<jupyter_output><empty_output><jupyter_text>Tipp 1 zur Aufgabe:Sieh dir die Liste an. Von jeder Möbelstücksorte gibt es jeweils 2.     Tipp 2 zur Aufgabe:Zeichne dir den Control-Flow des Programms auf, wenn du nicht weißt, wie du die Bedingungen strukturieren sollst.     Tipp 3 zur Aufgabe:Jeweils 2 Möbelstücke gehören zu einer Möbelstücksorte. Das heißt, du vergleichst die Auswahl durch choice mit 2 Strings. Entspricht die Auswahl diesen beiden Strings?     Tipp 4 zur Aufgabe:Da jeder dieser beiden Vergleiche einer Möbelstück-Kategorie zugeordnet werden kann, muss nur einer der Vergleiche/eine Auswahl zutreffen, um die Ausgabe mit der zugeordneten Kategorie auszulösen. Für die Verknüpfung dieser Vergleiche brauchst du also or.     Tipp 5 zur Aufgabe:Verwende F-Strings zur Formatierung der Ausgabe.  3.3.8 d) and, not & or in KombinationAll diese logischen Operatoren können in Kombination in einem If- oder Elif-Satatement miteinander verwendet werden.   and und andIn diesem Beispiel kommt es zu einem False, weil False und True ein False ergeben. False und True ergeben auch wieder False:<jupyter_code>(False and True) and True<jupyter_output><empty_output><jupyter_text>Ohne Klammern kommt es zum gleichen Ergebnis, denn die Vergleiche werden ohnehin von links nach rechts abgearbeitet:<jupyter_code>False and True and True<jupyter_output><empty_output><jupyter_text>or und andTrue oder False ergibt True, denn nur ein Wert muss bei or truthy sein, um zu einem True zu führen. Ein True und ein False ergeben dann False:<jupyter_code>(True or False) and False<jupyter_output><empty_output><jupyter_text>Sind die Klammern anders gesetzt, ist das Ergebnis hier ein anderes, denn False and False ergibt False. True or False ergibt dann True:<jupyter_code>True or (False and False)<jupyter_output><empty_output><jupyter_text>Was wird das Ergebnis dieses Beispiels sein? Überleg erst, bevor du die Code-Zelle ausführst.<jupyter_code>True or False and True<jupyter_output><empty_output><jupyter_text>Was wird wohl hier herauskommen?<jupyter_code>True and False or True<jupyter_output><empty_output><jupyter_text>Und hier?<jupyter_code>True or False and True or False<jupyter_output><empty_output><jupyter_text>and und notWas wird hier herauskommen?<jupyter_code>True and not False<jupyter_output><empty_output><jupyter_text>Das Statement vor and muss True sein, um zu einem True zu führen. Und not fordert das Gegenteil von dem nach ihm folgenden Statement. Die Werte vor und nach ``and`` müssen beide truthy sein, um zu einem True zu führen.  Mit ``not`` kann ein zuvor definiertes If-Statement negiert werden.  In dem unteren Beispiel sollen nur die Kunden einen Bonus erhalten, die entweder zwischen 1 und 10 Punkten durch Einkäufe gesammelt haben (als Ansporn) und die Kunden, die 40 und mehr Punkte gesammelt haben (als Belohnung):<jupyter_code>from random import randint

points = randint(1,50)

print(points)

points1 = 1
points10 = 10
points40 = 40

if points >= points1 and points <= points10 or points >= points40:
    print('Sie bekommen einen Bonus')
else:
    print('Sie bekommen keinen Bonus')<jupyter_output><empty_output><jupyter_text>Dieses Statement lässt sich durch ``not`` auf einen Schlag ins Gegenteil verkehren, sodass nur die Kunden einen Bonus erhalten, die mehr als 10 und weniger als 40 Punkte gesammelt haben:<jupyter_code>points = randint(1,50)

print(points)

if not (points >= points1 and points <= points10 or points >= points40):
    print('Sie bekommen einen Bonus')
else:
    print('Sie bekommen keinen Bonus')<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.07424577913091614, 'fraction_numerical': 0.01141710489897592, 'mean_word_length': 5.240500863557858, 'pattern_counts': {'":': 0, '<': 119, '<?xml version=': 0, '>': 122, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '28', 'dir': 'jupyter-structured-clean-dedup', 'id': '379438', 'license': 'MIT', 'n_tokens_mistral': 4971, 'n_tokens_neox': 5036, 'n_words': 1822, 'path': '3 Python Grundlagen/3.3 Conditions - Bedingungen/3.3.7-3.3.8 Falsy Werte & die logischen Operatoren and, not & or.ipynb', 'repo_name': 'hannesrothe/dataliteracy', 'size': '14452'}