Summary  
Demonstrates how to control flow in nested loops by using a break statement to exit the inner loop early when a condition is met.

General domain of usage  
Travel expense processing

La oss bruke konseptene `break` og `continue` for å analysere reisekostnader i praksis. Vi kombinerer en `while`-løkke og en `for`-løkke for å behandle utgifter på tvers av flere reiser.

Tenk deg at du har flere reiser, og hver reise har en liste med utgifter. Hvis en utgift overstiger en bestemt budsjettgrense, stopper vi behandlingen av den reisen umiddelbart.

# List of trips with their respective expenses
travel_costs = [
    [100, 150, 300, 50],   # Trip 1
    [200, 500, 100, 80],   # Trip 2
    [120, 180, 400, 150]   # Trip 3
]

# Budget threshold
budget = 200

# Outer while loop to iterate through trips
i = 0
while i < len(travel_costs):
    print(f"Processing expenses for Trip {i + 1}:")
    
    # Inner for loop to iterate through expenses
    for cost in travel_costs[i]:
        # If expense exceeds the budget
        if cost > budget:  
            print('Expense', cost, 'exceeds the budget. Stopping this trip.')
            break
        print('Expense:', cost)
    
    i += 1  # Move to the next trip
    print('')  # Add a new line for readability

- **Ytre løkke**: itererer gjennom listen over reiser ved hjelp av indeksen `i`;
- **Indre løkke**: behandler hver utgift i den nåværende reisen;
- `break` **i den indre løkken**:
hvis en utgift overstiger `budget`, vil `break`-setningen stoppe behandlingen av utgifter for den aktuelle reisen.

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

    def test_significant_expenses_correct_values(self):
        try:
            user_code = importlib.import_module("user_code")
            expected_expenses = [
                next((cost for cost in trip if cost > 200), None)
                for trip in user_code.travel_costs
            ]
            _dynamic_test(
                self,
                user_code.significant_expenses == expected_expenses,
                "The `significant_expenses` list contains correctly identified values.",
                f"Expected `significant_expenses` to be `{expected_expenses}`, but got `{user_code.significant_expenses}`."
            )
        except AttributeError:
            _dynamic_test(self, False, "", "Expected `significant_expenses` 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.

Break/continue i en nøstet løkke

Løsning