Summary
This chapter covers defining and using Python if statements to conditionally execute an indented code block based on a Boolean expression.

General domain of usage
Fitness tracking applications

Die `if`-**Anweisung** ist ein grundlegendes Werkzeug in Python, das es ermöglicht, Entscheidungen im Code zu treffen.

Hier sind die wichtigsten Bestandteile der if-Anweisungssyntax:
- **Schlüsselwort** `if`: Dieses Schlüsselwort leitet die Bedingung ein. Es ist case-sensitiv—die Verwendung von `If` anstelle von `if` führt zu einem Fehler;
- **Bedingung**: Die Bedingung ist ein Ausdruck, der zu `True` oder `False` ausgewertet wird. In diesem Beispiel wird geprüft, ob eine Variable eine bestimmte Voraussetzung erfüllt;
- **Doppelpunkt** `:`: Der Doppelpunkt signalisiert, dass der folgende eingerückte Block zur `if`-Anweisung gehört;
- **Eingerückter Codeblock**: Dieser Block enthält den Code, der nur ausgeführt wird, wenn die Bedingung `True` ist.

#### Beispiel 1: Standardausführung

steps_taken = 7500
step_goal = 10000

if steps_taken < step_goal:
    print(f"Keep going! You need {step_goal - steps_taken} more steps to reach your goal.")

### Erklärung

1. Die **Bedingung** `steps_taken < step_goal` prüft, ob die Anzahl der gegangenen Schritte kleiner als das Tagesziel ist;
2. Wenn die Bedingung **True** ist, wird der Code im `if`-Block ausgeführt;
3. Die Nachricht verwendet einen **f-String**, um die verbleibende Schrittanzahl dynamisch einzufügen, was die Ausgabe benutzerfreundlich und präzise macht.

**f-Strings** ermöglichen das Einbetten von Ausdrücken in Zeichenfolgen mithilfe von geschweiften Klammern `{}` für eine einfachere und besser lesbare Zeichenfolgenformatierung. Um eine f-String zu erstellen, wird der Zeichenfolge ein `f` vorangestellt.
Zum Beispiel: `f"Your goal is {step_goal} steps"`.

Hinweis

#### Beispiel 2: Wenn nichts ausgeführt wird

steps_taken = 10000
step_goal = 10000

if steps_taken < step_goal:
    print(f"Keep going! You need {step_goal - steps_taken} more steps to reach your goal.")

In diesem Fall ergibt die Bedingung `steps_taken < step_goal` den Wert `False`, da `steps_taken` gleich `step_goal` ist. Da die Bedingung nicht erfüllt ist, wird der Codeblock innerhalb der `if`-Anweisung nicht ausgeführt und es wird nichts in die Konsole ausgegeben. Dies zeigt, dass der Code nur ausgeführt wird, wenn die Bedingung den Wert `True` ergibt.

Das Bild zeigt den Ablauf einer if-Anweisung:
- **Bedingungsprüfung**: Das Programm prüft, ob die Bedingung `True` oder `False` ist;
- **Ausführung**: Ist die Bedingung `True`, wird der eingerückte Codeblock ausgeführt. Andernfalls überspringt das Programm diesen.

import unittest
import importlib
import user_code  # Import user's solution
import re

# Helper function for dynamic test naming and assertions
def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

class TestUserCode(unittest.TestCase):

    def test_calories_burned_is_declared(self):
        """Check if `calories_burned` is declared."""
        _dynamic_test(
            self,
            hasattr(user_code, 'calories_burned'),
            "The `calories_burned` variable is declared.",
            "Expected `calories_burned` to be declared."
        )

    def test_calories_burned_is_integer(self):
        """Check if `calories_burned` is an integer."""
        _dynamic_test(
            self,
            isinstance(user_code.calories_burned, int),
            "The `calories_burned` variable is an integer.",
            "`calories_burned` should be an integer."
        )

    def test_calories_goal_is_declared(self):
        """Check if `calories_goal` is declared."""
        _dynamic_test(
            self,
            hasattr(user_code, 'calories_goal'),
            "The `calories_goal` variable is declared.",
            "Expected `calories_goal` to be declared."
        )

    def test_calories_goal_is_integer(self):
        """Check if `calories_goal` is an integer."""
        _dynamic_test(
            self,
            isinstance(user_code.calories_goal, int),
            "The `calories_goal` variable is an integer.",
            "`calories_goal` should be an integer."
        )

    def test_calories_goal_met_is_declared(self):
        """Check if `calories_goal_met` is declared."""
        _dynamic_test(
            self,
            hasattr(user_code, 'calories_goal_met'),
            "The `calories_goal_met` variable is declared.",
            "Expected `calories_goal_met` to be declared."
        )

    def test_calories_goal_met_is_boolean(self):
        """Check if `calories_goal_met` is a boolean."""
        _dynamic_test(
            self,
            isinstance(user_code.calories_goal_met, bool),
            "The `calories_goal_met` variable is a boolean.",
            "`calories_goal_met` should be a boolean."
        )

    def test_calories_goal_met_condition(self):
        """Check if the correct comparison operator (`>=` or `<=`) is used to update `calories_goal_met`."""
        with open('user_code.py', 'r') as file:
            user_code_source = file.read()  # Read the source code of user_code.py
        
        correct_condition = (
            re.search(r'burned\s*>=', user_code_source) or
            re.search(r'<=\s*calories_burned', user_code_source)
        )

        _dynamic_test(
            self,
            correct_condition is not None,
            "The correct comparison operator (`>=` or `<=`) is used in the condition updating `calories_goal_met`.",
            "Expected `>=` or `<=` to be used in the condition updating `calories_goal_met`, but it was not found."
        )

    def test_if_statement_used(self):
        """Check if an `if` statement is used in the code."""
        with open('user_code.py', 'r') as file:
            user_code_source = file.read()  # Read the source code of user_code.py

        _dynamic_test(
            self,
            re.search(r'if\s+', user_code_source) is not None,
            "An `if` statement is used in the code.",
            "Expected an `if` statement in the code, but none was found."
        )


# Run the tests when executing the script
if __name__ == "__main__":
    unittest.main()

test_main.py

Erkunden Sie die Feinheiten des bedingten if-else-Operators in Python anhand klarer Erklärungen und praxisnaher Beispiele. Vertiefen Sie Ihr Verständnis mit praktischen Aufgaben, die jedes Konzept festigen, und entdecken Sie, wie Sie if-elif-else-Anweisungen effektiv für komplexere Entscheidungsfindungen einsetzen können.

Entdecken Sie die Vielseitigkeit des bedingten if-Operators und seine Fähigkeit, Programmausgaben zu beeinflussen. Tauchen Sie ein in die Welt der logischen Operatoren, beherrschen Sie deren praktische Anwendung und lernen Sie, wie Sie deren Priorisierung effektiv einsetzen, um klaren und effizienten Code zu schreiben.

Erfahren Sie, wie Sie Entscheidungen basierend auf Bedingungen treffen, den Code mithilfe des else-Schlüsselworts vereinfachen und sowohl Effizienz als auch Lesbarkeit verbessern. Entdecken Sie die Effizienz von einzeiligen Entscheidungen mit dem ternären Operator!

Entdecken Sie die fortschrittlichste Form von bedingten Anweisungen: if-elif-else. Machen Sie sich mit der Syntax vertraut und lernen Sie, wie Sie diese Konstruktion korrekt anwenden, um mehrere Entscheidungsfindungen in Ihren Programmen zu steuern.

Syntax der Python-If-Anweisung

Beispiel 1: Standardausführung

Erklärung

Beispiel 2: Wenn nichts ausgeführt wird

Lösung