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

**Løkke** er en serie instruksjoner som gjentas kontinuerlig til en bestemt betingelse er oppfylt. Løkker er essensielle for å automatisere repeterende oppgaver og effektivt behandle data.

Definisjon

Ved å bruke løkker kan du iterere over sekvenser som `lists`, `strings` eller numeriske `ranges`, og de gjør det mulig å behandle store datamengder med minimal kode.

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

- `item` er en variabel som tar **verdien til hvert element** i sekvensen én om gangen;
- `sequence` er dataene du itererer gjennom, for eksempel en **liste**, **streng** eller **range**;
- `for`-setningsblokken kjøres for hver `item` i sekvensen.

Tenk deg at du har en strengvariabel og ønsker å skrive ut hver bokstav i den i en kolonne. Siden en streng er en sekvens av bokstaver, kan du bruke en løkke for å oppnå dette.



word = 'iteration'
letters = []

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

- Variabelen `word` inneholder strengen `'iteration'`.  
- `for`-løkka går gjennom hvert tegn i strengen.  
- Hvert tegn legges til i listen `letters` i hver iterasjon.  
- Etter løkka inneholder `letters` alle tegnene fra `'iteration'` som individuelle elementer.

Sørg for å gi variabelen `item` et meningsfullt navn. For eksempel, hvis du itererer gjennom en liste kalt `people`, bør det riktige variabelnavnet være `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

Bygg selvtillit i å mestre Python-løkker! Start med det grunnleggende om for- og while-løkker og gå videre til avanserte konsepter som nestede løkker, kontrollsetninger og dynamiske betingelser. Med praktisk øvelse og eksempler fra virkeligheten, få ferdighetene til å skrive effektiv, ren og kraftig kode. Perfekt for nybegynnere og alle som ønsker å skjerpe sin Python-ekspertise!

Lær å iterere gjennom sekvenser med for-løkke, bruk range() effektivt, utforsk betingelser med if/else, og kontroller løkker med break og continue. Gjør deg klar til å skrive effektiv, ren og praktisk kode mens du takler morsomme utfordringer!

Få praktisk erfaring med the while loop! Lær hvordan du håndterer betingelser, unngår uendelige løkker, kontrollerer flyt med break og continue, og til og med kombinerer else med løkkene dine. Mestre når du skal bruke while-løkker effektivt i virkelige situasjoner og skjerp dine problemløsningsferdigheter!

Lær hvordan du kombinerer loops effektivt, bruker if/else-betingelser, og mestrer break- og continue-setninger for å kontrollere flyten. Innen slutten vil du kunne løse komplekse problemer med letthet og presisjon.

Effektiviser Python-koden din med liste- og ordbokforståelser! Lær hvordan du kan lage lister og ordbøker på en konsis og elegant måte samtidig som du forbedrer lesbarhet og ytelse. Mestre praktiske eksempler og oppdag hvordan du kan forenkle komplekse oppgaver, fra å filtrere data til å transformere det, alt i én enkelt linje med kode.

Den Første For-løkken

Løsning