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

`if`-**satsen** är ett grundläggande verktyg i Python som möjliggör beslutsfattande i koden.

Här är de viktigaste delarna av if-satsens syntax:
- **Nyckelord** `if`: detta nyckelord inleder det villkorliga uttrycket. Observera att det är skiftlägeskänsligt—att använda `If` istället för `if` leder till ett fel;
- **Villkor**: villkoret är ett uttryck som utvärderas till `True` eller `False`. I detta exempel kontrolleras om en variabel uppfyller ett visst krav;
- **Kolon** `:`: kolonet markerar att den efterföljande indragna koden tillhör `if`-satsen;
- **Indragen kodblock**: detta block innehåller koden som endast körs om villkoret är `True`.

#### Exempel 1: Standardutförande

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.")

### Förklaring

1. **Villkoret** `steps_taken < step_goal` kontrollerar om antalet tagna steg är mindre än det dagliga målet;
2. Om villkoret är **True** körs koden inuti `if`-blocket;
3. Meddelandet använder en **f-sträng** för att dynamiskt inkludera antalet återstående steg, vilket gör utdata användarvänlig och exakt.

**f-strängar** möjliggör inbäddning av uttryck i en sträng med hjälp av klamrar `{}`, för enklare och mer läsbar strängformatering. För att skapa en f-sträng, sätt ett `f` före strängen.
Till exempel: `f"Your goal is {step_goal} steps"`.

Notering

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.")

I det här fallet utvärderas villkoret `steps_taken < step_goal` till `False` eftersom `steps_taken` är lika med `step_goal`. Eftersom villkoret inte är uppfyllt körs inte kodblocket inuti `if`-satsen och inget skrivs ut i konsolen. Detta visar att koden endast körs när villkoret utvärderas till `True`.

Bilden visar flödet för en if-sats:
- **Villkorskontroll**: programmet utvärderar om villkoret är `True` eller `False`;
- **Exekvering**: om villkoret är `True` körs det indragna kodblocket. Annars hoppar programmet över det.

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

Utforska nyanserna av den villkorliga if-else-operatorn i Python genom tydliga förklaringar och praktiska exempel. Förstärk din förståelse med praktiska uppgifter som befäster varje koncept, och upptäck hur du använder if-elif-else-satser effektivt för mer komplexa beslutsfattanden.

Upptäck mångsidigheten hos det villkorliga if-operatorn och dess förmåga att påverka programmets resultat. Fördjupa dig i logiska operatorer, bemästra deras praktiska användning och lär dig hur du prioriterar dem effektivt för att skriva tydlig och effektiv kod.

Lär dig fatta beslut baserat på villkor, förenkla koden med hjälp av else-nyckelordet och förbättra både effektivitet och läsbarhet. Upptäck effektiviteten i enradiga beslut med den ternära operatorn!

Upptäck den mest avancerade formen av villkorssatser: if-elif-else. Bekanta dig med dess syntax och lär dig hur du korrekt använder denna konstruktion för att hantera flera beslutsfattande scenarier i dina program.

Syntax för If-sats i Python

Exempel 1: Standardutförande

Förklaring

Exempel 2: När inget utförs

Lösning