Summary  
This chapter covers using `break`, `continue`, and `pass` to control the flow of `while` loops, enabling early exit, skipping iterations, or placeholder logic.  

General domain of usage  
List traversal and element search

`break` og `continue`-setningene er kraftige verktøy for å kontrollere flyten i en `while`-løkke:

- `break`: avslutter løkken umiddelbart når en bestemt betingelse er oppfylt;
- `continue`: hopper over resten av den nåværende iterasjonen og går videre til neste.

I tillegg brukes `pass`-setningen som en plassholder og gjør ingenting når den kjøres, noe som kan være nyttig for ufullstendig logikk eller for å unngå feil i tomme blokker.

Vi skal bruke en while-løkke for å søke etter en bestemt by i `travel_list`. Hvis byen blir funnet, avsluttes løkken med `break`.

travel_list = ['Monako', 'Luxemburg', 'Liverpool', 'Barcelona', 'Munchen']

# Initialize the index
i = 0

# Search for "Barcelona"
while i < len(travel_list):
    if travel_list[i] == 'Barcelona':
        print('Found Barcelona!')
        break
    print(travel_list[i])
    i += 1

- Indeksen `i` starter på `0`, og peker til den første byen i listen;
- `while`-løkka fortsetter så lenge `i` er mindre enn lengden på `travel_list`;
- Hvis den nåværende byen er `"Barcelona"`, skrives meldingen ut, og løkka avsluttes med `break`, slik at `"Munchen"` aldri nås av løkka;
- Hvis `"Barcelona"` ikke finnes, skrives den nåværende byen ut, og `i` økes for å gå videre til neste by.

Nå skal vi telle hvor mange ganger `"Barcelona"` forekommer i `travel_list`, og hoppe over byer som ikke matcher ved å bruke `continue`.

travel_list = ['Monako', 'Barcelona', 'Liverpool', 'Barcelona', 'Munchen', 'Barcelona']

# Initialize variables
i = 0
counter = 0

# Count occurrences of "Barcelona"
while i < len(travel_list):
    if travel_list[i] != 'Barcelona':
        i += 1
        continue
    else:
        counter += 1
    i += 1

print('Total occurrences of Barcelona:', counter)

- Indeksen `i` starter på 0, og `counter` settes til 0 for å holde oversikt over forekomster av `'Barcelona'`;
- `while`-løkka kjører så lenge `i` er mindre enn lengden på `travel_list`;
- Hvis den nåværende byen ikke er `'Barcelona'`, hopper løkka over resten av koden for denne iterasjonen med `continue` og øker `i`;
- For hver forekomst av `'Barcelona'` økes `counter`, og løkka fortsetter til alle byene er sjekket.

import unittest
import importlib

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_selected_is_declared(self):
        try:
            user_code = importlib.import_module("user_code")
            _ = user_code.selected
            _dynamic_test(self, True, "The `selected` list is declared.", "")
        except AttributeError:
            _dynamic_test(self, False, "", "Expected `selected` to be declared.")
        except ImportError as e:
            self.fail(f"Failed to import module: {e}")

    def test_selected_contains_correct_values(self):
        try:
            user_code = importlib.import_module("user_code")
            expected_selected = [country for country in user_code.countries if country.startswith("S")][:3]
            _dynamic_test(
                self,
                user_code.selected == expected_selected,
                "The `selected` list contains the first 3 valid countries.",
                f"Expected `selected` to be `{expected_selected}`, but got `{user_code.selected}`."
            )
        except AttributeError:
            _dynamic_test(self, False, "", "Expected `selected` to be declared.")
        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.

Løkke Kontrollsetninger i en While-løkke

Løsning