Summary  
This chapter covers how to use counter variables in loops to accumulate sums or count items that meet specified conditions.

General domain of usage  
Data analysis

Get an overview of the 'Counting with Loops' chapter in the Python Loops Tutorial. In this video, you will learn how to use counters inside `for` loops to perform arithmetic operations and analyze lists. See practical examples of summing values, counting items that match certain criteria, and tracking totals as you process data in Python. This foundational skill helps you solve real-world problems, such as analyzing travel destinations or grouping items based on specific properties.

Ohjelmoinnissa laskurimuuttujaa käytetään usein suorittamaan peruslaskutoimituksia silmukan sisällä. Tämä lähestymistapa mahdollistaa tietojen käsittelyn toistuvasti, kuten arvojen yhteenlaskemisen tai kokonaismäärien seuraamisen.

Esimerkiksi, jos haluat laskea tietyn lukuvälin kaikkien lukujen summan, voit alustaa **laskuri**-muuttujan ja päivittää sitä jokaisella iteraatiolla.

Soveltakaamme tätä käsitettä tuttuun aiheeseemme, eli `travel_list`-listan käsittelyyn. Oletetaan, että haluat laskea kaikkien listan kaupunkien nimien yhteispituuden.

travel_list = ['Monako', 'Luxemburg', 'Liverpool', 'Barcelona', 'Munchen']

# Initialize counter
total_length = 0

# Iteration through the list
for city in travel_list:
    # Add the length of each city name
    total_length += len(city)

print('Total length of all city names:', total_length)

Operaattori `+=` on lyhennys yhteenlaskulle ja sijoitukselle. Se lisää oikealla olevan arvon vasemmalla olevaan muuttujaan ja päivittää muuttujan arvon. </br>Esimerkiksi `x += 5` vastaa lauseketta `x = x + 5`.

Huomio

import unittest
import importlib
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)

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'
]

class TestUserCode(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        cls.user_code = importlib.import_module("user_code")
        with open("user_code.py", "r", encoding="utf-8") as f:
            cls.source = f.read()

    def test_counter_is_declared(self):
        _dynamic_test(
            self,
            hasattr(self.user_code, "counter"),
            "The `counter` variable is declared.",
            "Expected `counter` to be declared."
        )

    def test_counter_is_integer(self):
        _dynamic_test(
            self,
            isinstance(getattr(self.user_code, "counter", None), int),
            "The `counter` variable is an integer.",
            "`counter` should be an integer."
        )

    def test_countries_is_declared_and_is_list(self):
        _dynamic_test(
            self,
            hasattr(self.user_code, "countries") and isinstance(self.user_code.countries, list),
            "The `countries` variable is declared and is a list.",
            "Expected `countries` to be declared and be a list."
        )

    def test_countries_list_matches_expected(self):
        _dynamic_test(
            self,
            getattr(self.user_code, "countries", None) == EXPECTED_COUNTRIES,
            "The `countries` list matches the expected destinations.",
            f"Expected `countries` to be `{EXPECTED_COUNTRIES}`, but got `{getattr(self.user_code, 'countries', None)}`."
        )

    def test_for_loop_used_over_countries(self):
        """Check if a `for` loop iterates over `countries` (robust AST-based check)."""
        import ast
    
        try:
            tree = ast.parse(self.source)
        except SyntaxError:
            _dynamic_test(
                self,
                False,
                "",
                "Could not parse `user_code.py` to check for a `for` loop."
            )
            return
    
        def iter_uses_countries(iter_node):
            # Accepts: countries
            if isinstance(iter_node, ast.Name) and iter_node.id == "countries":
                return True
    
            # Accepts: list(countries), tuple(countries), set(countries)
            if isinstance(iter_node, ast.Call) and isinstance(iter_node.func, ast.Name):
                if iter_node.func.id in {"list", "tuple", "set"} and iter_node.args:
                    return iter_uses_countries(iter_node.args[0])
    
            # Accepts: countries[...], countries[::2], etc.
            if isinstance(iter_node, ast.Subscript):
                return iter_uses_countries(iter_node.value)
    
            # Accepts: (countries), or other wrappers
            if isinstance(iter_node, ast.Attribute):
                # not expected here, but keep conservative
                return False
    
            return False
    
        found = False
        for node in ast.walk(tree):
            if isinstance(node, ast.For) and iter_uses_countries(node.iter):
                found = True
                break
    
        _dynamic_test(
            self,
            found,
            "A `for` loop iterating over `countries` is used in the code.",
            "Expected a `for` loop iterating over `countries` (directly or via slicing/casting), but none was found."
        )


    def test_len_check_equals_6_used(self):
        # Accepts either: len(country) == 6  OR  6 == len(country)
        has_len_eq_6 = (
            re.search(r"len\s*\(\s*\w+\s*\)\s*==\s*6", self.source) is not None
            or re.search(r"6\s*==\s*len\s*\(\s*\w+\s*\)", self.source) is not None
        )
        _dynamic_test(
            self,
            has_len_eq_6,
            "The code checks for country names with exactly 6 letters using `len(...) == 6`.",
            "Expected a check like `len(country) == 6` inside the loop, but it was not found."
        )

    def test_counter_result_is_correct(self):
        expected_result = sum(1 for c in EXPECTED_COUNTRIES if len(c) == 6)
        _dynamic_test(
            self,
            getattr(self.user_code, "counter", None) == expected_result,
            f"The result is correct: {expected_result} countries have exactly 6 letters.",
            f"Expected {expected_result} countries with 6 letters, but found {getattr(self.user_code, 'counter', None)}."
        )

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ä.

Laskeminen Silmukoilla

Ratkaisu