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`-**lause** on Pythonin perustyökalu, jonka avulla voidaan tehdä päätöksiä koodissa.

Tarkastellaan if-lauseen syntaksin keskeisiä osia:
- **Avainsana** `if`: tämä avainsana aloittaa ehtolauseen. Huomaa, että se on kirjainkoon suhteen herkkä—käyttämällä `If` `if`:n sijaan syntyy virhe;
- **Ehto**: ehto on lauseke, joka arvioituu arvoon `True` tai `False`. Tässä esimerkissä tarkistetaan, täyttääkö muuttuja tietyn vaatimuksen;
- **Kaksoispiste** `:`: kaksoispiste ilmaisee, että seuraava sisennetty lohko kuuluu `if`-lauseeseen;
- **Sisennetty koodilohko**: tämä lohko sisältää koodin, joka suoritetaan vain, jos ehto on `True`.

#### Esimerkki 1: Normaali suoritus

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

### Selitys

1. **Ehto** `steps_taken < step_goal` tarkistaa, onko otettujen askelten määrä pienempi kuin päivän tavoite;
2. Jos ehto on **True**, `if`-lohkon sisällä oleva koodi suoritetaan;
3. Viestissä käytetään **f-merkkijonoa** askelten määrän dynaamiseen sisällyttämiseen, mikä tekee tulosteesta käyttäjäystävällisen ja tarkan.

**f-merkkijonot** mahdollistavat lausekkeiden upottamisen merkkijonoon käyttämällä aaltosulkeita `{}`, mikä helpottaa ja selkeyttää merkkijonojen muotoilua. f-merkkijonon luomiseksi lisää merkkijonon eteen `f`.
Esimerkki: `f"Your goal is {step_goal} steps"`.

Huomio

#### Esimerkki 2: Kun mitään ei suoriteta

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

Tässä tapauksessa ehto `steps_taken < step_goal` arvioituu arvoksi `False`, koska `steps_taken` on yhtä suuri kuin `step_goal`. Koska ehto ei täyty, `if`-lauseen sisällä olevaa koodilohkoa ei suoriteta, eikä mitään tulosteta konsoliin. Tämä osoittaa, että koodi suoritetaan vain, kun ehto arvioituu arvoksi `True`.

Kuva esittää if-lauseen kulun:
- **Ehdon tarkistus**: ohjelma arvioi, onko ehto `True` vai `False`;
- **Suoritus**: jos ehto on `True`, sisennetty koodilohko suoritetaan. Muussa tapauksessa ohjelma ohittaa sen.

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

Tutustu Pythonin if-else-ehtolauseen vivahteisiin selkeiden selitysten ja käytännön esimerkkien avulla. Vahvista ymmärrystäsi käytännön tehtävillä, jotka tukevat jokaista käsitettä, ja opi käyttämään if-elif-else-lauseita tehokkaasti monimutkaisemmassa päätöksenteossa.

Tutustu ehdollisen if-operaattorin monipuolisuuteen ja sen kykyyn vaikuttaa ohjelman lopputuloksiin. Syvenny loogisten operaattoreiden maailmaan, hallitse niiden käytännön soveltaminen ja opi priorisoimaan niitä tehokkaasti selkeän ja tehokkaan koodin kirjoittamiseksi.

Opi tekemään päätöksiä ehtojen perusteella, yksinkertaistamaan koodia käyttämällä else-avainsanaa sekä parantamaan tehokkuutta ja luettavuutta. Hyödynnä yhden rivin päätösten tehokkuus ternary-operaattorilla!

Tutustu ehtolauseiden edistyneimpään muotoon: if-elif-else. Perehdy sen syntaksiin ja opi käyttämään tätä rakennetta oikein useiden päätöksentekotilanteiden hallintaan ohjelmissasi.

Python If -Lauseen Syntaksi

Esimerkki 1: Normaali suoritus

Selitys

Esimerkki 2: Kun mitään ei suoriteta

Ratkaisu