Summary
This chapter covers nested while loops, applying an outer loop to traverse top-level collections and an inner loop to process sub-collections while managing separate counters and resetting them on each cycle.

General domain of usage
Aggregating numeric data in multi-dimensional lists

Watch this video to see how nested while loops work in Python. You'll learn how to process multi-dimensional data, like calculating totals for each trip in a list of travel expenses. The video covers the structure of nested while loops, step-by-step execution, and real-life scenarios where nested loops are useful. You'll also see a live coding demonstration using the travel expenses example from this chapter, helping you understand how to analyze and summarize complex datasets with nested loops.

Du kan ha behov for å organisere eller analysere data med flere nivåer, for eksempel å holde oversikt over utgifter for ulike reiser. En **nestet while-løkke** gjør det mulig å håndtere slike flerdimensjonale scenarier effektivt når antall iterasjoner ikke er forhåndsbestemt.

Tenk deg at du har flere reiser, og hver reise har en liste med utgifter (fly, hotell, mat osv.). Ved å bruke en nestet `while`-løkke kan du beregne de totale kostnadene for hver reise.

# List of trips with their respective expenses
travel_costs = [
    [500, 200, 100, 150],  # Trip 1: Flights, Hotels, Food, Activities
    [600, 250, 120, 200],  # Trip 2: Flights, Hotels, Food, Activities
    [550, 180, 130, 170]   # Trip 3: Flights, Hotels, Food, Activities
]

# Variables to track the maximum cost
max_cost = 0
max_trip = 0

# Outer loop to iterate over trips
i = 0
while i < len(travel_costs):
    total_cost = 0
    j = 0
    
    # Inner loop to iterate over expenses in each trip
    while j < len(travel_costs[i]):
        total_cost += travel_costs[i][j]
        j += 1
    
    # Print the total cost for the current trip
    print('Total cost for Trip', i + 1, ':', total_cost)
    
    # Check if this trip is the new maximum
    if total_cost > max_cost:
        max_cost = total_cost
        max_trip = i + 1
    
    i += 1

# Final output: print the trip with the highest total cost
print("Trip", max_trip, "has the highest total cost of", max_cost)

- **Ytre løkke**: `while i < len(travel_costs)` itererer gjennom listen over reiser, der hver rad representerer utgiftene for én reise;
- **Indre løkke**: `while j < len(travel_costs[i])` itererer gjennom utgiftene for den aktuelle reisen og summerer dem i variabelen `total_cost`;
- **Skrive ut resultater**: etter å ha summert utgiftene for en reise, skriver programmet ut de totale kostnadene for den reisen;  
- **Gå videre til neste reise**: øk `i` for å analysere neste reise til alle er behandlet; 
- **Endelig resultat**: etter at løkken er ferdig, skrives reise-nummeret med høyest total kostnad og verdien ut.  

Nøstede løkker brukes ofte for å iterere gjennom **n-dimensjonale matriser**, der hvert nivå av nøsting representerer en dimensjon. I våre oppgaver arbeider vi med en **2-dimensjonal matrise**, for eksempel en liste over reiser og deres utgifter. Nøstede løkker er også nyttige for dynamiske løkkescenarier, som inndatavalgidering eller navigering i flernivåmenyer, der antall iterasjoner ikke er fastsatt og avhenger av endrede forhold eller brukerinput.

Merk

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

    def test_max_costs_contains_correct_values(self):
        try:
            user_code = importlib.import_module("user_code")
            expected_max_costs = [max(trip) for trip in user_code.travel_costs]
            _dynamic_test(
                self,
                user_code.max_costs == expected_max_costs,
                "The `max_costs` list contains the correct maximum values per trip.",
                f"Expected `max_costs` to be `{expected_max_costs}`, but got `{user_code.max_costs}`."
            )
        except AttributeError:
            _dynamic_test(self, False, "", "Expected `max_costs` 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 grunnleggende for- og while-løkker og gå videre til avanserte konsepter som nøstede løkker, kontrollsetninger og dynamiske betingelser. Med praktiske øvelser og eksempler fra virkeligheten får du ferdigheter til å skrive effektiv, ryddig og kraftig kode. Perfekt for nybegynnere og alle som ønsker å forbedre sine Python-kunnskaper!

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. Forbered deg på å skrive effektiv, ryddig og praktisk kode mens du løser engasjerende utfordringer.

Få praktisk erfaring med while-løkken. Lær å håndtere betingelser, unngå uendelige løkker, kontrollere flyt med break og continue, og kombinere else med løkker. Bli trygg på når while-løkker bør brukes i virkelige situasjoner, og styrk problemløsningsevnen.

Lær hvordan du kombinerer løkker effektivt, bruker if/else-betingelser, og behersker break- og continue-setninger for å kontrollere flyten. Etter endt kapittel vil du kunne løse komplekse problemer med letthet og presisjon.

Effektiviser Python-koden med liste- og ordbokforståelser. Lær å opprette lister og ordbøker på en konsis og elegant måte, samtidig som lesbarhet og ytelse forbedres. Få innsikt i praktiske eksempler og oppdag hvordan komplekse oppgaver kan forenkles, fra filtrering til transformasjon av data, alt på én linje kode.

Nestet While-løkke

Løsning