Summary  
This chapter covers using a loop with a counter (accumulator) variable to iteratively aggregate values from a collection.

General domain of usage  
Data aggregation from lists or arrays.

プログラミングでは、ループ内で基本的な算術演算を行うためにカウンター変数を使用することがよくあります。この方法により、値の合計や合計値の追跡など、データを反復的に処理できます。

例えば、特定の範囲内のすべての数値の合計を計算したい場合、**カウンター**変数を初期化し、各イテレーションで更新することができます。

この概念を、よく使われる `travel_list` を使った例に適用してみましょう。リスト内のすべての都市名の合計文字数を計算したいとします。

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)

`+=` 演算子は加算と代入の省略記法です。左側の変数に右側の値を加算し、その変数を更新します。 </br>例えば、`x += 5` は `x = x + 5` と同じ意味になります。

ノート

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

Pythonのループをマスターする自信を身につけましょう。forループやwhileループの基本から始め、ネストされたループ、制御文、動的条件などの高度な概念へと進みます。実践的な演習や実例を通じて、効率的でクリーンかつ強力なコードを書くスキルを習得できます。初心者やPythonの専門知識を磨きたい方に最適です。

forループを使用したシーケンスの反復方法の習得、range()の効果的な活用、if/elseによる条件分岐の探求、breakおよびcontinueによるループ制御。効率的でクリーンかつ実用的なコード作成に備え、楽しい課題に取り組む準備。

ループによるカウント

解答