Python-Steuerstrukturen-Tutorial: Beherrschen von Bedingungen und Schleifen

Einführung

In diesem Lab werden Sie die grundlegenden Kontrollstrukturen von Python erkunden: bedingte Anweisungen und Schleifen. Basierend auf Ihrem Wissen aus früheren Labs werden Sie lernen, wie Sie den Programmablauf mit if-else-Anweisungen, for-Schleifen und while-Schleifen steuern können. Diese praktische Erfahrung wird Ihr Verständnis der Kernkonzepte von Python vertiefen und Sie auf das Schreiben komplexerer und dynamischerer Programme vorbereiten.

Dies ist ein Guided Lab, das schrittweise Anweisungen bietet, um Ihnen beim Lernen und Üben zu helfen. Befolgen Sie die Anweisungen sorgfältig, um jeden Schritt abzuschließen und praktische Erfahrungen zu sammeln. Historische Daten zeigen, dass dies ein Labor der Stufe Fortgeschrittener mit einer Abschlussquote von 79% ist. Es hat eine positive Bewertungsrate von 96% von den Lernenden erhalten.

Verständnis von bedingten Anweisungen

In diesem Schritt werden Sie sich mit bedingten Anweisungen in Python befassen, insbesondere mit der if-else-Struktur.

Öffnen Sie den Python-Interpreter, indem Sie den folgenden Befehl in Ihrem Terminal eingeben:
```
python
```
Sie sollten die Python-Eingabeaufforderung (>>>) sehen, was darauf hinweist, dass Sie jetzt in der interaktiven Python-Shell sind.

Beginnen wir mit einer einfachen if-Anweisung. Geben Sie im Python-Interpreter Folgendes ein:
```
>>> age = 20
>>> if age >= 18:
...     print("You are an adult.")
...
You are an adult.
```
Tipp 1: Achten Sie auf die Einrückung, sie ist in Python wichtig. Es wird empfohlen, vier Leerzeichen für die Einrückung zu verwenden.

Tipp 2: Die >>>-Eingabeaufforderung markiert den Anfang einer neuen Zeile, und die ...-Eingabeaufforderung zeigt an, dass die vorherige Zeile fortgesetzt wird. Sie sollten diese Eingabeaufforderungen nicht eingeben; sie werden automatisch vom Python-Interpreter angezeigt.

Tipp 3: Sie können die Enter-Taste drücken, um zur nächsten Zeile zu gelangen oder den Code in derselben Zeile fortzuschreiben. Drücken Sie Enter zweimal, um den Code auszuführen.

Die if-Anweisung prüft, ob die Bedingung age >= 18 wahr ist. Wenn dies der Fall ist, wird der eingerückte Codeblock ausgeführt.

Fügen wir nun eine else-Klausel hinzu:

>>> age = 15
>>> if age >= 18:
...     print("You are an adult.")
... else:
...     print("You are a minor.")
...
You are a minor.

Die else-Klausel bietet eine alternative Aktion, wenn die Bedingung falsch ist.

Für komplexere Bedingungen können wir elif- (else if) Klauseln verwenden:

>>> age = 65
>>> if age < 13:
...     print("You are a child.")
... elif age < 20:
...     print("You are a teenager.")
... elif age < 65:
...     print("You are an adult.")
... else:
...     print("You are a senior citizen.")
...
You are a senior citizen.

Die elif-Klauseln ermöglichen es Ihnen, mehrere Bedingungen nacheinander zu prüfen.

Denken Sie daran, dass die Einrückung in Python von entscheidender Bedeutung ist. Sie definiert die Codeblöcke, die jeder Bedingung zugeordnet sind.

Erkundung von for-Schleifen

In diesem Schritt werden Sie sich mit for-Schleifen befassen, die in Python verwendet werden, um über Sequenzen (wie Listen, Strings oder Bereiche) zu iterieren.

Beginnen wir mit einer einfachen for-Schleife unter Verwendung eines Bereichs (range). Geben Sie im Python-Interpreter Folgendes ein:
```
>>> for i in range(5):
...     print(i)
...
0
1
2
3
4
```
Die range(5)-Funktion erzeugt eine Sequenz von Zahlen von 0 bis 4, und die Schleife iteriert über jede Zahl.
Die range()-Funktion kann mehrere Argumente nehmen, um den Start-, End- und Schrittwert anzugeben. Probieren wir einen anderen Bereich aus:
```
>>> for i in range(1, 10, 2):
...     print(i)
...
1
3
5
7
9
```
- Die range(1, 10, 2)-Funktion erzeugt eine Sequenz von Zahlen, die bei 1 beginnt, bis (aber nicht einschließlich) 10 geht und einen Schritt von 2 hat.

Lassen Sie uns nun über eine Liste iterieren:

>>> fruits = ["apple", "banana", "cherry"]
>>> for fruit in fruits:
...     print(f"I like {fruit}")
...
I like apple
I like banana
I like cherry

Hier iteriert die Schleife über jedes Element in der fruits-Liste.

Sie können auch for-Schleifen mit Strings verwenden:
```
>>> for char in "Python":
...     print(char.upper())
...
P
Y
T
H
O
N
```
Diese Schleife iteriert über jedes Zeichen im String "Python".

Kombinieren wir eine for-Schleife mit bedingten Anweisungen:

>>> numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> for num in numbers:
...     if num % 2 == 0:
...         print(f"{num} is even")
...     else:
...         print(f"{num} is odd")
...
1 is odd
2 is even
3 is odd
4 is even
5 is odd
6 is even
7 is odd
8 is even
9 is odd
10 is even

Diese Schleife prüft jede Zahl in der Liste und gibt aus, ob sie gerade oder ungerade ist.

Verständnis von while-Schleifen

In diesem Schritt werden Sie sich mit while-Schleifen befassen, die verwendet werden, um einen Codeblock so lange wiederholt auszuführen, wie eine Bedingung wahr ist.

Beginnen wir mit einer einfachen while-Schleife. Geben Sie im Python-Interpreter Folgendes ein:
```
>>> count = 0
>>> while count < 5:
...     print(count)
...     count += 1
...
0
1
2
3
4
```
Diese Schleife wird so lange ausgeführt, wie count kleiner als 5 ist.

while-Schleifen werden oft verwendet, wenn Sie nicht im Voraus wissen, wie oft Sie iterieren müssen. Hier ist ein Beispiel:

>>> import random
>>> number = random.randint(1, 10)
>>> guess = 0
>>> while guess!= number:
...     guess = int(input("Guess a number between 1 and 10: "))
...     if guess < number:
...         print("Too low!")
...     elif guess > number:
...         print("Too high!")
... print(f"Congratulations! You guessed the number {number}!")

Dies erstellt ein einfaches Ratespiel, bei dem der Benutzer so lange rät, bis er die richtige Zahl errät.

Seien Sie vorsichtig mit while-Schleifen - wenn die Bedingung niemals falsch wird, erstellen Sie eine Endlosschleife. Sehen wir uns ein Beispiel an (führen Sie dies aber nicht tatsächlich aus):
```
>>> while True:
...     print("This will print forever!")
```
Wenn Sie versehentlich eine Endlosschleife ausführen, können Sie sie durch Drücken von Ctrl+C stoppen.
Sie können eine break-Anweisung verwenden, um eine Schleife vorzeitig zu beenden:
```
>>> count = 0
>>> while True:
...     print(count)
...     count += 1
...     if count >= 5:
...         break
...
0
1
2
3
4
```
Diese Schleife würde normalerweise für immer laufen, aber die break-Anweisung beendet sie, wenn count 5 erreicht.

Verschachtelte Schleifen und Schleifen-Steueranweisungen

In diesem Schritt werden Sie sich mit verschachtelten Schleifen und zusätzlichen Schleifen-Steueranweisungen befassen.

Verschachtelte Schleifen sind Schleifen, die innerhalb anderer Schleifen liegen. Hier ist ein Beispiel für verschachtelte for-Schleifen:
```
>>> for i in range(3):
...     for j in range(2):
...         print(f"i: {i}, j: {j}")
...
i: 0, j: 0
i: 0, j: 1
i: 1, j: 0
i: 1, j: 1
i: 2, j: 0
i: 2, j: 1
```
Die innere Schleife führt alle ihre Iterationen für jede Iteration der äußeren Schleife aus.
Zusätzlich zu break bietet Python die continue-Anweisung, die den Rest der aktuellen Iteration überspringt und zur nächsten Iteration springt:
```
>>> for num in range(10):
...     if num % 2 == 0:
...         continue
...     print(num)
...
1
3
5
7
9
```
Diese Schleife gibt nur ungerade Zahlen aus und überspringt die geraden.

Sie können else-Klauseln mit Schleifen verwenden. Der else-Block wird ausgeführt, wenn die Schleife normal beendet wird (ohne dass eine break-Anweisung auftaucht):

>>> for num in range(2, 10):
...     for i in range(2, num):
...         if num % i == 0:
...             print(f"{num} is not prime")
...             break
...     else:
...         print(f"{num} is prime")
...
2 is prime
3 is prime
4 is not prime
5 is prime
6 is not prime
7 is prime
8 is not prime
9 is not prime

Diese verschachtelte Schleife prüft auf Primzahlen. Die else-Klausel wird ausgeführt, wenn eine Zahl eine Primzahl ist.

Alles zusammenführen

In diesem letzten Schritt werden Sie ein einfaches Programm erstellen, das die Steuerstrukturen nutzt, die Sie in diesem Lab gelernt haben.

Beenden Sie den Python-Interpreter, indem Sie exit() eingeben oder Ctrl+D drücken.
Öffnen Sie die WebIDE in der LabEx VM-Umgebung.

Erstellen Sie eine neue Datei mit dem Namen number_analyzer.py im Verzeichnis ~/project mit dem folgenden Befehl:
```
touch ~/project/number_analyzer.py
```
Öffnen Sie die neu erstellte Datei im WebIDE-Editor.

Kopieren Sie den folgenden Code und fügen Sie ihn in die Datei ein:

def analyze_numbers():
    numbers = []
    while True:
        user_input = input("Enter a number (or 'done' to finish): ")
        if user_input.lower() == 'done':
            break
        try:
            number = float(user_input)
            numbers.append(number)
        except ValueError:
            print("Invalid input. Please enter a number or 'done'.")

    if not numbers:
        print("No numbers entered.")
        return

    total = sum(numbers)
    average = total / len(numbers)
    maximum = max(numbers)
    minimum = min(numbers)

    print(f"\nAnalysis of {len(numbers)} numbers:")
    print(f"Total: {total}")
    print(f"Average: {average:.2f}")
    print(f"Maximum: {maximum}")
    print(f"Minimum: {minimum}")

    print("\nNumber distribution:")
    for num in numbers:
        if num < average:
            print(f"{num} is below average")
        elif num > average:
            print(f"{num} is above average")
        else:
            print(f"{num} is equal to average")

if __name__ == "__main__":
    analyze_numbers()

Dieses Programm demonstriert die Verwendung von while-Schleifen, for-Schleifen, bedingten Anweisungen und Ausnahmebehandlung (exception handling).

Speichern Sie die Datei (Autospeichern ist aktiviert) und führen Sie sie mit dem folgenden Befehl im Terminal aus:
```
python ~/project/number_analyzer.py
```

Geben Sie bei entsprechender Aufforderung einige Zahlen ein und geben Sie dann 'done' ein, um die Analyse anzuzeigen. Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Enter a number (or 'done' to finish): 10
Enter a number (or 'done' to finish): 20
Enter a number (or 'done' to finish): 30
Enter a number (or 'done' to finish): 40
Enter a number (or 'done' to finish): done

Analysis of 4 numbers:
Total: 100.0
Average: 25.00
Maximum: 40.0
Minimum: 10.0

Number distribution:
10.0 is below average
20.0 is below average
30.0 is above average
40.0 is above average

Wenn Sie beim Eingeben der Daten einen Fehler machen, können Sie das Programm erneut ausführen. Dies ist eine gute Gelegenheit, das Ausführen von Python-Skripten mehrmals mit verschiedenen Eingaben zu üben.

Zusammenfassung

In diesem Lab haben Sie die grundlegenden Python-Steuerstrukturen erkundet: bedingte Anweisungen (if-else), for-Schleifen und while-Schleifen. Sie haben gelernt, wie Sie den Programmablauf steuern, Entscheidungen basierend auf Bedingungen treffen und über Datenfolgen iterieren können. Sie haben auch die Verwendung von verschachtelten Schleifen und Schleifen-Steueranweisungen wie break und continue geübt.

Diese Steuerstrukturen bilden das Rückgrat der Python-Programmierung und ermöglichen es Ihnen, komplexere und dynamischere Programme zu erstellen. Sie haben gesehen, wie diese Konzepte kombiniert werden können, um ein nützliches Programm zu erstellen, das eine Menge von vom Benutzer eingegebenen Zahlen analysiert.

Wenn Sie Ihre Python-Reise fortsetzen, werden Sie feststellen, dass diese Steuerstrukturen unerlässlich sind, um eine Vielzahl von Programmierproblemen zu lösen. Denken Sie daran, diese Konzepte regelmäßig zu üben und mit verschiedenen Kombinationen und Anwendungsfällen zu experimentieren, um Ihr Verständnis zu festigen.

Python-Steuerstrukturen