Summary  
This chapter covers how to use a for loop to iterate over any sequence (like lists or strings) in Python, executing a block of code (for example, printing or appending) for each element and emphasizing clear, meaningful loop variable naming.

General domain of usage  
Text processing

In this video, you will learn what a for loop is and how it works in Python. You will see how to use a for loop to iterate over sequences such as lists and strings, allowing you to process each element in a sequence with minimal code. The video demonstrates iterating through the string 'iteration', appending each letter to a list to show how the loop steps through each character. You will also learn why using meaningful variable names in loops, like 'country' when looping through a list of countries, makes your code clearer and easier to understand. Finally, you will be guided through the interactive travel list task, where you apply your knowledge to build a list of countries to visit, reinforcing how for loops help automate repetitive tasks efficiently.

**Silmukka** on joukko ohjeita, jotka toistuvat jatkuvasti, kunnes tietty ehto täyttyy. Silmukat ovat olennaisia toistuvien tehtävien automatisoinnissa ja datan tehokkaassa käsittelyssä.

Määritelmä

Silmukoiden avulla voit käydä läpi jonoja, kuten `lists`, `strings` tai numeeriset `ranges`-alueet. Ne mahdollistavat suurten tietomäärien käsittelyn vähällä koodilla.

```py
for item in sequence:
    # Perform some operation
```

- `item` on muuttuja, joka saa **kunkin alkion arvon** sekvenssissä yksi kerrallaan;
- `sequence` on data, jota käydään läpi, kuten **lista**, **merkkijono** tai **range**;
- `for`-lauseen lohko suoritetaan jokaiselle `item`:lle sekvenssissä.

Kuvittele, että sinulla on merkkijonomuuttuja ja haluat tulostaa jokaisen sen kirjaimen omalle rivilleen. Koska merkkijono on kirjainjono, voit käyttää silmukkaa tämän saavuttamiseksi.

word = 'iteration'
letters = []

# Adding every letter in the word to the list
for letter in word:
    letters.append(letter)
    print(letters)

- Muuttuja `word` sisältää merkkijonon `'iteration'`;  
- `for`-silmukka käy läpi jokaisen merkin merkkijonossa;  
- Jokainen merkki lisätään `letters`-listaan jokaisella iteraatiolla;  
- Silmukan jälkeen `letters` sisältää kaikki merkkijonon `'iteration'` merkit yksittäisinä alkioina.

Varmista, että nimeät muuttujan `item` kuvaavasti. Esimerkiksi, jos iteroit listan nimeltä `people` läpi, sopiva muuttujan nimi olisi `person`.

import unittest
import importlib

EXPECTED_COUNTRIES = [
    'Wales', 'Denmark', 'Belgium', 'Japan', 'South Korea',
    'South Africa', 'Indonesia', 'Singapore', 'Australia',
    'India', 'Saudi Arabia', 'Mexico', 'Turkey', 'Greece',
    'Netherlands', 'Finland', 'Monako', 'United Arab Emirates',
    'Egypt', 'Morocco', 'Brazil', 'Argentina', 'Ireland',
    'Portugal', 'Chile', 'Spain', 'Czech Republic', 'Sweden',
    'Switzerland', 'Thailand', 'Luxemburg', 'New Zealand',
    'France', 'Italy', 'Germany', 'China', 'Canada', 'Hungary',
    'Scotland', 'Norway', 'Austria', 'Ukraine', 'Poland'
]

# Helper function to dynamically generate test names 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_your_travel_list_is_declared(self):
        try:
            user_code = importlib.import_module("user_code")
            _ = user_code.travel_list
            _dynamic_test(self, True, "The `travel_list` variable is declared.", "")
        except AttributeError:
            _dynamic_test(self, False, "", "Expected `travel_list` to be declared.")
        except ImportError as e:
            self.fail(f"Failed to import module: {e}")

    def test_your_travel_list_is_list(self):
        try:
            user_code = importlib.import_module("user_code")
            _dynamic_test(
                self,
                isinstance(user_code.travel_list, list),
                "The `travel_list` is of type `list`.",
                "Expected `travel_list` to be of type `list`."
            )
        except AttributeError:
            _dynamic_test(self, False, "", "The `travel_list` variable is not declared.")
        except ImportError as e:
            self.fail(f"Failed to import module: {e}")

    def test_your_travel_list_contains_correct_countries(self):
        try:
            user_code = importlib.import_module("user_code")
            _dynamic_test(
                self,
                user_code.travel_list == EXPECTED_COUNTRIES,
                "The `travel_list` contains the correct countries.",
                f"Expected `travel_list` to be `{EXPECTED_COUNTRIES}`, but got `{user_code.travel_list}`."
            )
        except AttributeError as e:
            _dynamic_test(self, False, "", f"Missing variable: {e}")
        except ImportError as e:
            self.fail(f"Failed to import module: {e}")

if __name__ == '__main__':
    unittest.main()

test_main.py

Rakenna varmuutta Python-silmukoiden hallinnassa! Aloita for- ja while-silmukoiden perusteista ja etene edistyneisiin aiheisiin, kuten sisäkkäisiin silmukoihin, ohjausrakenteisiin ja dynaamisiin ehtoihin. Käytännön harjoitusten ja tosielämän esimerkkien avulla opit kirjoittamaan tehokasta, selkeää ja vaikuttavaa koodia. Sopii aloittelijoille ja kaikille, jotka haluavat syventää Python-osaamistaan!

Hallitse sekvenssien läpikäynti for-silmukalla, käytä range()-funktiota tehokkaasti, tutki ehtoja if/else-rakenteilla sekä ohjaa silmukoita break- ja continue-komennoilla. Valmistaudu kirjoittamaan tehokasta, selkeää ja käytännöllistä koodia ratkoessasi mielenkiintoisia haasteita.

Käytännön kokemusta while-silmukasta. Ehtojen käsittely, äärettömien silmukoiden välttäminen, ohjaus break- ja continue-lauseilla sekä else-lauseen yhdistäminen silmukoihin. Ymmärrys siitä, milloin while-silmukkaa kannattaa käyttää todellisissa tilanteissa, ja ongelmanratkaisutaitojen kehittäminen.

Opi yhdistämään silmukoita tehokkaasti, käyttämään if/else-ehtoja sekä hallitsemaan break- ja continue-lauseita ohjaamaan ohjelman kulkua. Kurssin lopussa pystyt ratkaisemaan monimutkaisia ongelmia vaivattomasti ja tarkasti.

Tehosta Python-koodiasi lista- ja sanakirjakehitelmillä. Opiskele, kuinka luoda listoja ja sanakirjoja tiiviisti ja elegantisti samalla parantaen luettavuutta ja suorituskykyä. Hallitse käytännön esimerkit ja opi yksinkertaistamaan monimutkaisia tehtäviä, kuten tietojen suodattamista ja muuntamista, kaikki yhdellä koodirivillä.

Ensimmäinen For-silmukka

Ratkaisu