Summary  
This chapter demonstrates how to embed if/else conditional logic inside a while loop to iterate through a list by index, evaluate each element against a condition, and perform different actions based on the result.

General domain of usage  
Categorizing list items based on their attributes (e.g., string length)

**If/else-strukturen** kan kombineres med en `while`-løkke for å legge til betinget logikk for hver iterasjon. Dette gjør det mulig å utføre ulike handlinger basert på spesifikke betingelser mens løkken kjører.


La oss bruke dette konseptet på vår `travel_list`. Programmet vil kategorisere byer som har **korte** eller **lange** navn avhengig av lengden (mindre enn 8 tegn for korte, 8 eller flere for lange).

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

# Initialize index
i = 0

# Categorize cities by name length
while i < len(travel_list):
    if len(travel_list[i]) < 8:
        print(travel_list[i], 'has a short name.')
    else:
        print(travel_list[i], 'has a long name.')
    i += 1

1. Indeksen `i` initialiseres til 0 for å starte fra den første byen;
2. `while`-løkken kjører så lenge `i` er mindre enn lengden på `travel_list`;
3. **Betinget logikk**:
   - **`if`**: sjekker om lengden på det nåværende bynavnet er mindre enn 8 tegn og skriver ut en melding deretter;
   - **`else`**: håndterer alle andre tilfeller der navnelengden er 8 eller flere tegn;
4. Variabelen `i` økes på slutten av hver iterasjon for å gå videre til neste by.

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

    def test_short_name_count_is_correct(self):
        try:
            user_code = importlib.import_module("user_code")
            expected_count = sum(1 for country in user_code.countries if len(country) < 7)
            _dynamic_test(
                self,
                user_code.short_name_count == expected_count,
                "The `short_name_count` contains the correct count.",
                f"Expected `short_name_count` to be `{expected_count}`, but got `{user_code.short_name_count}`."
            )
        except AttributeError:
            _dynamic_test(self, False, "", "Expected `short_name_count` 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.

Bruk av Betingelsesuttrykk i en While-løkke

Løsning