====== Schleifenkonstruktionen und logische Ausdrücke ======

Source: [[https://python-lernen.com/schleifen/|python-lernen.de|python-lernen.com]]
 --- //[[Karlheinz.Schubert@ksbg.ch|Karlheinz Schubert]] 2023/10/29 17:18//

===== Die while Schleife =====

Mit **Schleifen** kann man Programmteile (beliebig oft) wiederholen.

Wir könnten zum Beispiel einen Linienblatt ausgeben, indem wir 30 mal ''%%print('_' * 50)%%'' schreiben.

Besser ist aber eine Schleife zu verwenden. Dafür benötigen wir eine Hilfsvariable die wir hoch zählen (inkrementieren) werden. Diese Variable nennen wir ''%%ZeilenNr%%'' und initialisieren sie mit ''%%0%%''. Damit wir wissen, was die Zahl 30 bedeutet, schreiben wir diese in eine Variable mit einem //sprechenden Namen//: ''%%AnzahlLinien = 30%%''.

<code python>
AnzahlLinien = 30
ZeilenNr = 0
while ZeilenNr < AnzahlLinien:
    ZeilenNr += 1
    print('_' * 50)
</code>

Nachdem wir die Variablen definiert und gesetzt haben, benutzen wir das **KeyWord** ''%%while%%'' und geben genauso wie bei den ''%%if%%'' Bedingungen einen Vergleich an.

Wir fragen, ob ''%%LinienNr%%'' kleiner als ''%%AnzahlLinien%%'' ist. Sollte das der Fall sein, wird der **Block** in der **Schleife** ausgeführt.

Im **Block** selbst geben wir unsere Zeile ''%%print('_'*50)%%'' aus und (sehr wichtig) erhöhen die ''%%LinienNur%%'' um ''%%1%%'': ''%%LinienNr += 1%%''. Sollten wir dies vergessen, so bleibt ''%%LinienNr%%'' immer ''%%0%%'' also kleiner als ''%%AnzahlLinien%%'' und die **Schleife** läuft ewig weiter.

===== Die for Schleife und die range() Funktion =====

Wollen wir eine Aktion n-mal wiederholen, so wie beim Linienblatt, kann man auch eine ''%%for%%'' **Schleife** verwenden. Diese benötigt keinen Inkrementor ''%%LinienNr += 1%%'', dafür aber die ''%%range()%%'' Funktion. Diese erwartet als Paramter eine Anzahl und gibt uns ein Range **Objekt** zurück. Was ein **Objekt** genau ist, interessiert uns momentan nicht. Wir können uns vorstellen, dass das Range **Objekt** uns eine List von Zahlen zurück gibt.

Also anstatt unserer Hilfsvariable ''%%LinienNr%%'' hoch zu zählen benutzen wir die ''%%range()%%'' Funktion mit unserem Zahlenbereich.

<code python>
for ZeilenNr in range(30):
    print('_' * 50)
</code>

Achtung die ''%%range(10)%%'' gibt den Zahlenbereich von ''%%0%%'' bis ''%%9%%'' zurück. Die **Schleife** läuft also 10 mal. Wenn wir ''%%ZeilenNr%%'' mit ausgeben, sehen wir aber das diese bei ''%%0%%'' beginnt und bei ''%%9%%'' endet.

===== Sprünge in Schleifen: break und continue =====

Es kann vorkommen das wir aus einer **Schleife** springen wollen und diese abrechen. Dafür verwenden wir das **break** statement.

<code python>
for iIndex in range(10):
    if Index == 5:
        break
    print("Hallo Welt")
</code>

In diesem Beispiel wird nur 5 mal, statt 10 mal “Hallo Welt” ausgegeben. Da sobald ''%%Index%%'' gleich 5 ist wir aus der **Schleife** springen.

<code python>
for Index in range(10):
    print(Index)
    if Index % 2 == 0:
        continue
    print("Hallo Welt")
</code>

In diesem Beispiel geben wir die Zahlen von 0 bis 9 aus. Sollte i nicht ganzzahlig durch 2 geteilt werden können, geben wir “Hallo Welt” aus. Wenn i durch 2 glatt teilbar ist springen wir wieder zum Anfang der **Schleife** und überspringen somit das Ausgeben von “Hallo Welt”.

===== Der Modulo Operator % =====

Das ''%%%%%'' Zeichen ist ein ganz normaler Rechen-Operator wie ''%%+%%''oder ''%%*%%''. Das ''%%%%%'' steht für Modulo und gibt den Rest einer Ganzzahl-Division.

  * ''%%3 % 2%%''ergibt also ''%%1%%''
  * ''%%4 % 2%%'' ist ''%%0%%'', da kein Rest übrig bleibt.

===== Der Datentyp boolean =====

Sowohl bei den ''%%if%%'' , als auch bei den **Schleifen** Anweisungen haben entweder eine Variable oder eine (Un-)Gleichungen als Bedingung angegeben. Dies funktioniert, weil verschiedene Operatoren und Operationen in Python einen **booleschen** Wert zurückgeben.

<code python>
print(42==42)
</code>

So gibt dieses ''%%print()%%'' einfach ein “True” aus.

Die beiden boolschen Werte ''%%True%%'' und ''%%False%%'' lassen sich auch direkt Variablen zuweisen:

<code python>
Variable1 = False
Vairable2 = True
</code>

Ein boolscher Wert aber auch aus anderen Datentypen durch s.g. **casten** erzeugt werden:

<code python>
bool(0)            # False
bool(1)            # True
bool(2)            # True
bool("Hallo Welt") # True
bool("")           # False
bool(1==2)         # False
bool(1==1)         # True
bool(1<2)          # True
</code>

Dieses **casten** erfolgt in **Schleifen** und **if** Abfragen oft implizit. Daher können wir eine endlos Schleife so schreiben:

<code python>
while 1:          
    print("Hey, bool(1) ist True!")
</code>

Diese Schleife läuft unendlich lange, da ''%%1%%'' immer ''%%True%%'' ist.

Im Terminal (Unix) bzw. im Command Fenster (Windows) kann man eine solche Endlosschleife mit ''%%Ctrl+C%%'' abrechen.

==== Boolsche Werte umkehren ====

Wenn wir überprüfen wollen ob etwas nicht der Fall ist können wir den **boolean** auch invertieren. Das machen wir indem wir ein ''%%not%%'' vor den **boolean** Wert schreiben.

<code python>
b = False

if not b:
    print("in dem if drin")
</code>

Das funktioniert natürlich auch mit den bereits bekannten Vergleichen.

<code python>
Zahl = 42

if not Zahl == 43:
    print("Die Zahl ist nicht 43")
</code>

==== Und und Oder ====

Es kommt durchaus mal vor das wir mehrere Bedingungen zusammen hängen wollen. Zum Beispiel das wir prüfen wollen ob die Zahl in einem gewissen Bereich ist.

<code python>
for Index in range(100):
    if Index > 50 and Index < 60:
        print(Index)
</code>

Die **Schleife** selbst ist relativ trivial, sie zählt von ''%%0%%'' bis ''%%99%%''. Das Neue ist in dem Code im ''%%if%%'' Statement. Wenn ''%%Index%%'' größer (''%%>%%'') als ''%%50%%'' UND kleiner (''%%<%%'') als ''%%60%%'' ist, geben wir den ''%%Index%%'' aus.

Das Gleiche gibt es auch noch mit oder hier ist das **Keyword** ''%%or%%'':

<code python>
Zahl = 1
if Zahl == 1 or Zahl == 42:
    print("Zahl ist 1 oder 42")

Zahl = 42
if Zahl == 1 or Zahli == 42:
    print("Zahl ist 1 oder 42")
</code>

In beiden Fällen haben wir die gleiche Abfrage und beide sind **Wahr** (''%%True%%'') obwohl wir ''%%Zahl%%'' im Laufe des Programmes überschreiben.

==== Boolean und Vergleichsperatoren ====

Verschiedene Operatoren die einen **booleschen** Wert zurückgeben:

<code python>
print(True == True) # True
print(not True == True) # False
print(True == True and True == False) # False
print(True == True or True == False)  # True
print(42 > 1)  # True
print(42 < 1)  # False
print(42 >= 1) # True
print("Hallo Welt" < "Hallo") # False
print("Hallo Welt" > "Hallo") # True
print("Hallo" == "Hallo")    # True
</code>

===== Beispiel Python Taschenrechner =====

Jetzt kann man mit ''%%if%%'' Abfragen einen kleinen Python Rechner bauen. Durch eine While-Schleife führt er Berechnungen aus, bis man 'exit' eingibt:

<code python>
print("\nMini-Calculator\n")

while True:
    Operator = input('Welche Operation (+,-,*,/,^,exit): ')
    Zahl1 = float(input('Zahl1: '))
    Zahl2 = float(input('Zahl2: '))
    Ergebnis = ''
    
    if Operator == '+':
        Ergebnis = Zahl1 + Zahl2
    elif Operator == '-':
        Ergebnis = Zahl1 - Zahl2
    elif Operator == '/':
        Ergebnis = Zahl1 / Zahl2
    elif Operator == '*':
        Ergebnis = Zahl1 * Zahl2
    elif Operator == 'exit':
        break
    else:
        print("Fehler: Die Eingabe konnte nicht interpretiert werden!")

    print(f'{Zahl1} {Operator} {Zahl2} = {Ergebnis}')
    
print('Adieu.')
</code>

Wir fügen eine **nochmal** Variabel hinzu und geben ihr den Wert ''%%True%%'' . Gibt der Benutzer statt eines Rechen Operator ein ‘E’ ein setzten wir **nochmal** auf **False** . Was dazu führt das wir die Schleife verlassen und das Programm beendet wird.