Summary
This chapter covers the for loop construct, showing how to iterate over sequences like strings, lists, or ranges to execute a block of code for each element.

General domain of usage
Text processing

Ved hjælp af løkker kan du iterere over sekvenser som `lists`, `strings` eller numeriske `ranges`, de tillader at behandle store mængder data med minimal kode.

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

- `item` er en variabel, der tager **værdien af hvert element** i sekvensen én ad gangen;
- `sequence` er de data, du itererer igennem, såsom en **liste**, **streng** eller **range**;
- `for`-sætningens blok udføres for hvert `item` i sekvensen.

Forestil dig, at du har en strengvariabel og vil udskrive hvert bogstav af den i en kolonne. Da en streng er en sekvens af bogstaver, kan du bruge en løkke til at opnå dette.



word = 'iteration'
letters = []

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

- Variablen `word` indeholder strengen `'iteration'`.  
- `for`-løkken itererer over hvert tegn i strengen.  
- Hvert tegn tilføjes til listen `letters` i hver iteration.  
- Efter løkken indeholder `letters` alle tegnene fra `'iteration'` som individuelle elementer.

Sørg for at navngive variablen `item` meningsfuldt. For eksempel, hvis du itererer gennem en liste kaldet `people`, bør det passende variabelnavn være `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

Opbyg selvtillid i at mestre Python-løkker! Start med det grundlæggende i for- og while-løkker og gå videre til avancerede begreber som indlejrede løkker, kontroludsagn og dynamiske betingelser. Med praktiske øvelser og eksempler fra den virkelige verden, få færdighederne til at skrive effektiv, ren og kraftfuld kode. Perfekt for begyndere og alle, der ønsker at skærpe deres Python-ekspertise!

Bliv ekspert i at iterere gennem sekvenser med for-løkker, brug range() effektivt, udforsk betingelser med if/else, og kontroller løkker med break og continue. Gør dig klar til at skrive effektiv, ren og praktisk kode, mens du tackler sjove udfordringer!

Få praktisk erfaring med the while loop! Lær hvordan man håndterer betingelser, undgår uendelige loops, styrer flowet med break og continue, og endda kombinerer else med dine loops. Bliv mester i at bruge while loops effektivt i virkelige scenarier og skærp dine problemløsningsevner!

Lær hvordan man effektivt kombinerer loops, bruger if/else betingelser, og mestrer break og continue udsagn for at kontrollere flowet. Ved slutningen vil du være i stand til at løse komplekse problemer med lethed og præcision.

Strømlin din Python-kode med liste- og ordbogsforståelser! Lær hvordan du opretter lister og ordbøger på en kortfattet og elegant måde, mens du forbedrer læsbarhed og ydeevne. Mestre praktiske eksempler og opdag, hvordan du kan forenkle komplekse opgaver, fra at filtrere data til at transformere dem, alt sammen i en enkelt linje kode.

Den Første For Loop

Løsning

Awesome!

Den Første For Loop

Løsning

Awesome!