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

Applichiamo i concetti di `break` e `continue` per analizzare i costi di viaggio in modo pratico. Combineremo un ciclo `while` e un ciclo `for` per elaborare le spese di più viaggi.

Immagina di avere diversi viaggi, e ogni viaggio ha un elenco di spese. Se una qualsiasi spesa supera una soglia di budget specifica, interromperemo immediatamente l'elaborazione di quel viaggio.

# 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

- **Ciclo esterno**: itera attraverso l'elenco dei viaggi utilizzando l'indice `i`;
- **Ciclo interno**: elabora ogni spesa nel viaggio corrente;
- `break` **nel ciclo interno**:
se una spesa supera il `budget`, l'istruzione `break` interrompe l'elaborazione delle spese per il viaggio corrente.

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

Costruisci fiducia nel padroneggiare i cicli in Python! Inizia con le basi dei cicli for e while e progredisci verso concetti avanzati come cicli annidati, istruzioni di controllo e condizioni dinamiche. Con pratica pratica ed esempi del mondo reale, acquisisci le competenze per scrivere codice efficiente, pulito e potente. Perfetto per principianti e chiunque desideri affinare la propria esperienza in Python!

Impara a padroneggiare l'iterazione attraverso sequenze con il ciclo for, usa efficacemente range(), esplora le condizioni con if/else e controlla i cicli con break e continue. Preparati a scrivere codice efficiente, pulito e pratico mentre affronti sfide divertenti!

Ottieni esperienza pratica con il ciclo while! Impara a gestire le condizioni, evitare cicli infiniti, controllare il flusso con break e continue, e persino combinare else con i tuoi cicli. Impara a padroneggiare l'uso efficace dei cicli while in scenari reali e affina le tue abilità di problem-solving!

Impara a combinare i loops in modo efficace, utilizzare le condizioni if/else e padroneggiare le istruzioni break e continue per controllare il flusso. Alla fine, sarai in grado di risolvere problemi complessi con facilità e precisione.

Ottimizza il tuo codice Python con le comprensioni di liste e dizionari! Impara a creare liste e dizionari in modo conciso ed elegante migliorando la leggibilità e le prestazioni. Padroneggia esempi pratici e scopri come semplificare compiti complessi, dal filtering dei dati alla loro trasformazione, tutto in una sola riga di codice.

Break/Continue in un Ciclo Annidato

Soluzione