Summary  
This chapter explains how to use a for loop to iterate over each element in a sequence (such as a string, list, or range), perform operations on each item (like appending to a list or printing), and build results iteratively.  

General domain of usage  
Text processing

Genom att använda loopar kan du iterera över sekvenser som `lists`, `strings` eller numeriska `ranges`, de tillåter att bearbeta stora mängder data med minimal kod.

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

- `item` är en variabel som tar **värdet av varje element** i sekvensen en i taget;
- `sequence` är de data du itererar genom, såsom en **lista**, **sträng** eller **range**;
- `for`-satsblocket körs för varje `item` i sekvensen.

Föreställ dig att du har en strängvariabel och vill skriva ut varje bokstav i den i en kolumn. Eftersom en sträng är en sekvens av bokstäver kan du använda en loop för att uppnå detta.



word = 'iteration'
letters = []

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

- Variabeln `word` håller strängen `'iteration'`.  
- `for`-loopen itererar över varje tecken i strängen.  
- Varje tecken läggs till i listan `letters` i varje iteration.  
- Efter loopen innehåller `letters` alla tecken från `'iteration'` som individuella element.

Se till att namnge variabeln `item` meningsfullt. Till exempel, om du itererar genom en lista som heter `people`, bör det lämpliga variabelnamnet vara `person`.

import unittest
import importlib

# 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  # Rename the test for better readability
        test_case.assertTrue(True, success_message)  # Pass the test with a success message
    else:
        test_case._testMethodName = failure_message  # Rename the test with a failure description
        test_case.fail(failure_message)  # Fail the test with a 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")
            expected_travel_list = [i for i in user_code.countries]
            _dynamic_test(
                self,
                user_code.travel_list == expected_travel_list,
                "The `travel_list` contains the correct countries.",
                f"Expected `travel_list` to be `{expected_travel_list}`, 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

Bygg självförtroende i att bemästra Python-loopar! Börja med grunderna i for- och while-loopar och gå vidare till avancerade koncept som nästlade loopar, kontrollsatser och dynamiska villkor. Med praktisk övning och verkliga exempel, få färdigheter att skriva effektiv, ren och kraftfull kod. Perfekt för nybörjare och alla som vill skärpa sin Python-expertis!

Lär dig att iterera genom sekvenser med for-loopen, använd range() effektivt, utforska villkor med if/else, och kontrollera loopar med break och continue. Förbered dig på att skriva effektiv, ren och praktisk kod när du tar dig an roliga utmaningar!

Få praktisk erfarenhet med while-loopen! Lär dig hur du hanterar villkor, undviker oändliga loopar, styr flödet med break och continue, och till och med kombinerar else med dina loopar. Bemästra när du ska använda while-loopar effektivt i verkliga scenarier och skärp dina problemlösningsförmågor!

Lär dig hur du effektivt kombinerar loopar, använder if/else-villkor och bemästrar break- och continue-satser för att kontrollera flödet. I slutet kommer du att kunna lösa komplexa problem med lätthet och precision.

Förenkla din Python-kod med list- och ordbokskomprehensioner! Lär dig hur du skapar listor och ordböcker på ett kortfattat och elegant sätt samtidigt som du förbättrar läsbarhet och prestanda. Bemästra praktiska exempel och upptäck hur du kan förenkla komplexa uppgifter, från att filtrera data till att transformera den, allt i en enda kodrad.

Den Första For-Loop

Lösning

Awesome!

Den Första For-Loop

Lösning