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 å bruke løkker kan du iterere over sekvenser som `lists`, `strings` eller numeriske `ranges`, de lar deg behandle store mengder data med minimal kode.

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

- `item` er en variabel som tar **verdien av hvert element** i sekvensen én om gangen;
- `sequence` er dataene du itererer gjennom, slik som en **liste**, **streng** eller **rekkevidde**;
- `for`-setningsblokken utføres for hvert `item` i sekvensen.

Tenk deg at du har en strengvariabel og vil skrive ut hver bokstav av 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)

- Variabelen `word` inneholder strengen `'iteration'`.  
- `for`-løkken itererer over hvert tegn i strengen.  
- Hvert tegn legges til i `letters`-listen i hver iterasjon.  
- Etter løkken inneholder `letters` alle tegnene fra `'iteration'` som individuelle elementer.

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

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-Loop

Løsning

Awesome!

Den Første For-Loop

Løsning

Awesome!