4  Flusskontrolle

Die Flusskontrolle ermöglicht es, die Ausführung von Programmteilen zu steuern. Anweisungen können übersprungen oder mehrfach ausgeführt werden.

Abzweigungen

Abzweigungen ermöglichen eine Fallunterscheidung, bei der abhängig von einer oder mehreren Bedingungen verschiedene Teile des Skripts ausgeführt werden.

In Python werden Abzweigungen mit dem Schlüsselwort if eingeleitet. Dieses wird von der Abzweigbedingung gefolgt und mit einem Doppelpunkt : abgeschlossen. Falls die Abzweigbedingung wahr ist, wird der eingerückte Anweisungsblock ausgeführt.

if Bedingung:
    Anweisungsblock

# Beispiel: Zahl kleiner als ein Schwellwert

a = 7
if a < 10:
    print( 'Die Zahl', a, 'ist kleiner als 10.')

Die Zahl 7 ist kleiner als 10.

Es ist auch möglich einen alternativen Anweisungsblock zu definieren, welcher ausgeführt wird, wenn die Bedingung falsch ist. Dieser wird mit dem else Schlüsselwort umgesetzt.

if Bedingung:
    # Bedingung ist wahr
    Anweisungsblock
else:
    # Bedingung ist falsch
    Anweisungsblock

# Beispiel: Zahl kleiner als ein Schwellwert mit alternativer Ausgabe

a = 13
if a < 10:
    print( 'Die Zahl', a, 'ist kleiner als 10.')
else:
    print( 'Die Zahl', a, 'ist nicht kleiner als 10.')

Die Zahl 13 ist nicht kleiner als 10.

Es können auch mehrere Bedingungen übergeben werden.

# Beispiel: Zahl im Wertebereich zwischen 10 und 20

a = 1
if a < 20 and a > 10:
    print( 'Die Zahl', a, 'liegt zwischen 10 und 20.')
else:
    print( 'Die Zahl', a, 'liegt nicht zwischen 10 und 20.')

Die Zahl 1 liegt nicht zwischen 10 und 20.

Schließlich können mehrere alternative Bedingungen geprüft werden. Dies ist zum einen durch das Verschachteln von Abzweigungen möglich.

# Beispiel: Zahl im Wertebereich zwischen 10 und 20 mit verschachtelten Abzweigungen

a = 12
if a > 10:
    print( 'Die Zahl', a, 'ist größer als 10.' )
    
    if a < 20:
        print( 'Die Zahl', a, 'ist kleiner als 20.' )
        print( 'Damit liegt die Zahl zwischen 10 und 20.')
    else:
        print( 'Die Zahl', a, 'ist größer als 20 und liegt nicht im gesuchten Wertebereich.' )
else:
        print( 'Die Zahl', a, 'ist kleiner als 10 und liegt nicht im gesuchten Wertebereich.' )

Die Zahl 12 ist größer als 10.
Die Zahl 12 ist kleiner als 20.
Damit liegt die Zahl zwischen 10 und 20.

Zum anderen ist dies mit dem Schlüsselwort elif möglich.

# Beispiel: Zahl im Wertebereich zwischen 10 und 20 mit elif

a = 112
if a < 20 and a > 10:
  print('Die Zahl', a, 'liegt zwischen 10 und 20.')
elif a < 10:
  print('Die Zahl', a, 'ist kleiner als 10 und liegt nicht im gesuchten Wertebereich.' )
elif a > 20 and a <= 100:
  print('Die Zahl', a, 'ist größer als 20, aber nicht größer als 100.')
elif a > 20 and a <= 1000:
  print('Die Zahl', a, 'ist größer als 20, aber nicht größer als 1000.')
else:
  print('Die Zahl', a, 'liegt nicht zwischen 10 und 20 und ist größer als 1000.')

Die Zahl 112 ist größer als 20, aber nicht größer als 1000.

Schleifen

Schleifen ermöglichen es, Anweisungen zu wiederholen. In Python können while- und for-Schleifen definiert werden. Beide benötigen:

• einen Schleifenkopf, welcher die Ausführung des Anweisungsblocks steuert, und

• einen Anweisungsblock, also eine Gruppe von Anweisungen, welche bei jedem Schleifendurchlauf ausgeführt werden.

Die while-Schleife kommt mit nur einer Bedingung im Schleifenkopf aus und ist die allgemeinere von beiden. Jede for-Schleife kann zu einer while-Schleife umgeschrieben werden (indem ein Zähler in den Anweisungsblock integriert wird.) Welcher der beiden Typen verwendet wird, hängt von der jeweiligen Aufgabe ab.

while-Schleifen

Eine while-Schleife führt den Anweisungsblock immer wieder aus, solange die Ausführbedingung wahr ist. Die Schleife wird mit dem Schlüsselwort while eingeleitet, gefolgt von der Ausführbedingung. Dieser Schleifenkopf wird mit einem Doppelpunkt : abgeschlossen. Darunter wird der eingerückte Anweisungsblock definiert.

while Bedingung:
    Anweisungsblock

Beim Beginn der Schleife und nach jedem Durchlauf wird die Bedingung geprüft. Ist sie wahr, so wird der Anweisungsblock ausgeführt, wenn nicht, ist die Schleife beendet und die nächste Anweisung außerhalb der Schleife wird ausgeführt.

# Beispiel: Erhöhen eines Variablenwertes

# Setze Startwert
a = 5

# Definiere Schleife, welche solange ausgeführt 
# wird, wie a kleiner als oder gleich 10 ist
while a <= 10:
    # Anweisungsblock der Schleife:
    
    # 1. Ausgabe des aktuellen Werts von a 
    print('aktueller Wert von a', a)
    
    # 2. Erhöhung von a um Eins
    a += 1

# Ausgabe des Wertes nach der Schleife
print('Wert von a nach der Schleife', a)

aktueller Wert von a 5
aktueller Wert von a 6
aktueller Wert von a 7
aktueller Wert von a 8
aktueller Wert von a 9
aktueller Wert von a 10
Wert von a nach der Schleife 11

Hinweis 4.1: Endlosschleife

while-Schleifen führen zu einer Endlosschleife, wenn die Abbruchbedingung nicht erreicht werden kann. Beispielsweise fehlt in der folgenden Schleife eine Möglichkeit für die Laufvariable x den Wert 5 zu erreichen.

x = 1

while x < 5:
  print(x)

In diesem Fall können Sie die Programmausführung durch Drücken von Strg+ C beenden.

for-Schleifen

Während die while-Schleife ausgeführt wird, solange eine Bedingung erfüllt ist, wird die for-Schleife über eine Laufvariable gesteuert, die eine Sequenz durchläuft. Die Syntax sieht wie folgt aus:

for Laufvariable in Sequenz:
  Anweisungsblock

Zur Definition des Schleifenkopfs gehören die beiden Schlüsselworte for und in und der Kopf wird mit einem Doppelpunkt : abgeschlossen. Auch hier wird der Anweisungsblock eingerückt.

Die Sequenz wird mit einem range-Objekt erstellt, das mit der Funktion range(start = 0, stop, step = 1) erzeugt wird. range() nimmt ganzzahlige Werte als positionale Argumente entgegen und erzeugt Ganzzahlen von start bis nicht einschließlich stop mit der Schrittweite step. Dabei ist wichtig, dass Python exklusiv zählt, das heißt, Python beginnt standarmäßig bei 0 zu zählen und der als Argument stop übergebene Wert wird nicht mitgezählt.

Die Funktion range() gibt ein range-Objekt zurück, das mit print() nicht unmittelbar die erwartete Ausgabe erzeugt.

# range(start = 1, stop = 5) - step wird nicht übergeben, es gilt der Standardwert step = 1
print(range(1, 5), type(range(1, 5)))

range(1, 5) <class 'range'>

Dieses Verhalten wird faule Auswertung (lazy evaluation) genannt: Die Werte des range-Objekts werden erst erzeugt, wenn Sie benötigt werden. Im Folgenden Code wird das range-Objekt mit einer Schleife durchlaufen und für jeden Durchlauf der Wert der Laufvariable i ausgegeben.

for i in range(1, 5):
  print(i)

1
2
3
4

Mit dem Parameter step kann die Schrittweite gesteuert werden.

for i in range(1, 15, 3):
  print(i)

1
4
7
10
13

Nützlich ist die Ausgabe des range-Objekts in eine Liste oder in ein Tupel, Sammeltypen, die im nächsten Kapitel behandelt werden.

# Ausgabe der geraden Zahlen 1-10 in eine Liste
print("Liste:", list(range(2, 11, 2)))

# Ausgabe der ungeraden Zahlen 1-10 in ein Tupel
print("Tupel:", tuple(range(1, 11, 2)))

Liste: [2, 4, 6, 8, 10]
Tupel: (1, 3, 5, 7, 9)

start und stop können auch negativ sein, step muss immer größer 0 sein.

for i in range(-5, -1):
  print(i)

-5
-4
-3
-2

stop muss immer größer als start sein. Um eine absteigende Zahlenfolge zu erzeugen, wird die Funktion reversed(sequenz) verwendet.

# Die Ausgabe bleibt leer
print(list(range(5, 0)))

# Mit der Funktion reversed geht es
print(list(reversed(range(0, 5))))

[]
[4, 3, 2, 1, 0]

Listennotation

Die sogenannte Listennotation ist eine Kurzschreibweise für for-Schleifen. In Listennotation geschriebene Schleifen müssen in einer Zeile stehen und haben die folgende Syntax:

quadratzahlen = [wert ** 2 for wert in range(10, 0, -1)]
print(quadratzahlen)

[100, 81, 64, 49, 36, 25, 16, 9, 4, 1]

(Matthes (2017), S. 71)

Die Schlüsselwörter break und continue

Manchmal kann es notwendig sein, den Anweisungsblock einer Schleife vorzeitig zu verlassen. Dafür können die Schlüsselwörter break und continue benutzt werden. Das Schlüsselwort break bewirkt, dass die Schleife sofort verlassen wird. Dagegen führt das Schlüsselwort continue dazu, dass der aktuelle Schleifendurchlauf beendet und der nächste Durchlauf begonnen wird.

x = 0
while x < 10:

  x += 1

  # keine geraden Zahlen ausgeben
  if x % 2 == 0:
    continue

  # Schleife bei x == 7 beenden
  if x == 7:
    break

  print(x)

1
3
5

Ausnahmebehandlung

Die Ausnahmebehandlung erlaubt es, Python alternative Anweisungen zu geben, die beim Auftreten eines Fehlers ausgeführt werden sollen. Dies ist beispielsweise beim Einlesen von Datensätzen nützlich, um sich die Ursache von Fehlermeldungen ausgeben zu lassen - eine Technik, die im Methodenbaustein Einlesen strukturierter Datensätze vorgestellt wird.

In Python gibt es zwei Arten von Fehlern. Dies sind erstens Syntaxfehler, die Python mit einer Fehlermeldung ähnlich wie der folgenden quitiert. Syntaxfehler werden durch das Schreiben von syntaktisch korrektem Programmcode behoben.

print(1}

closing parenthesis '}' does not match opening parenthesis

Die zweite Art von Fehlern sind Ausnahmen (exceptions), die auch bei syntaktisch korrektem Programmcode auftreten können. Ausnahmen führen auch zu Fehlermeldungen.

# Beispiel 1: Division durch Null
print(1 / 0)

division by zero

# Beispiel 2: undefinierte Variable
print(undefinierte_variable)

name 'undefinierte_variable' is not defined

Fehlermeldungen wie diese können in Python mit der Ausnahmebehandlung abgefangen werden. Diese wird mit dem Schlüsselwort try eingeleitet, das mit dem Doppeltpunkt : abgeschlossen wird. In der nächsten Zeile folgt eingrückt der Anweisungblock, der auf Ausnahmen getestet werden soll. Hinweis: Der Anweisungsblock wird tatsächlich ausgeführt, Änderungen an Daten oder Dateien sind also möglich. Anschließend wird mit dem Schlüsselwort except, das von einem Doppelpunkt : und in der nächsten Zeile von einem eingerückten Anweisungsblock gefolgt wird, festgelegt, was beim Aufkommen einer Ausnahme passieren soll. Optional kann mit dem Schlüsselwort else nach dem gleichen Schema ein weiterer Anweisungsblock definiert werden, der bei einer erfolgreichen Ausführung des Anweisungsblocks unter try zusätzlich ausgeführt wird. Der allgemeiner Aufbau lautet wie folgt:

try:
  Anweisungsblock_1 
except:
  Anweisungsblock falls Anweisungblock_1 eine Ausnahme erzeugt
else:
  optionaler Anweisungsblock falls Anweisungsblock_1 keine Ausnahme erzeugt

Mithilfe der Ausnahmebehandlungen können die Elemente angezeigt werden, die zu einer Fehlermeldung führen.

a = 1
b = 2

try:
  differenz = a - b
except:
  print(f"Die Differenz aus {a} und {b} konnte nicht gebildet werden.")
else:
  print(f"Die Differenz aus {a} und {b} ist {differenz}.")

Die Differenz aus 1 und 2 ist -1.

a = 1
b = 'abc'

try:
  differenz = a - b
except:
  print(f"Die Differenz aus {a} und {b} konnte nicht gebildet werden.")
else:
  print(f"Die Differenz aus {a} und {b} ist {differenz}.")

Die Differenz aus 1 und abc konnte nicht gebildet werden.

Auch ist es möglich, die Fehlermeldung abzufangen und auszugeben. Dafür wird die Zeile except: wie folgt modifiziert except Exception as error:

a = 1
b = 'abc'

try:
  differenz = a - b
except Exception as error:
  print(f"Die Differenz aus {a} und {b} konnte nicht gebildet werden.")
  print(error)
else:
  print(f"Die Differenz aus {a} und {b} ist {differenz}.")

Die Differenz aus 1 und abc konnte nicht gebildet werden.
unsupported operand type(s) for -: 'int' and 'str'

4.1 Aufgaben Flusskontrolle

1. Schreiben Sie ein Programm, das von 1 bis 25 und von 38 bis 50 zählt und jeden Wert, der ganzzahlig durch 7 teilbar ist, mit print() ausgibt.

2. Roulette: Schreiben Sie ein Programm, das für eine Zahl prüft, ob diese im Wertebereich des Spieltischs liegt. Falls nein, soll eine Fehlermeldung ausgegeben werden. Falls ja, soll das Programm ausgeben, ob die Zahl

• gerade oder ungerade ist,

• rot oder schwarz ist,

• niedrig (1-18) oder hoch (19-36) ist und

• im 1., 2. oder 3. Dutzend liegt.

Roulette Tableau

European roulette von Betzaar.com ist lizensiert unter CC 3.0 BY-SA und verfügbar auf wikimedia.org. 2010

 

Die Musterlösung kann Marc machen.

Musterlösung Aufgaben Flusskontrolle

 
(Arnold (2023))

Arnold, Simone. 2023. „Datenanalyse mit Python. Schleifen und Abzweigungen.“ Fachhochschule Dortmund.

Matthes, Eric. 2017. Python Crashkurs: Eine praktische, projektbasierte Programmiereinführung. 1. Aufl. Heidelberg: dpunkt.verlag.