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

Anwendung der Konzepte `break` und `continue` zur praktischen Analyse von Reisekosten. Kombination einer `while`-Schleife und einer `for`-Schleife zur Verarbeitung von Ausgaben über mehrere Reisen hinweg.

Angenommen, es gibt mehrere Reisen und jede Reise enthält eine Liste von Ausgaben. Überschreitet eine Ausgabe einen bestimmten Budgetgrenzwert, wird die Verarbeitung dieser Reise sofort abgebrochen.

# 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

- **Äußere Schleife**: Iteration durch die Liste der Reisen mit dem Index `i`;
- **Innere Schleife**: Verarbeitung jeder Ausgabe der aktuellen Reise;
- `break` **in der inneren Schleife**:
wenn eine Ausgabe das `budget` überschreitet, beendet die `break`-Anweisung die Verarbeitung der Ausgaben für die aktuelle Reise.

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

Gewinnen Sie Vertrauen im Umgang mit Python-Schleifen! Beginnen Sie mit den Grundlagen von for- und while-Schleifen und gehen Sie zu fortgeschrittenen Konzepten wie verschachtelten Schleifen, Kontrollanweisungen und dynamischen Bedingungen über. Mit praktischen Übungen und realen Beispielen erwerben Sie die Fähigkeiten, effizienten, sauberen und leistungsstarken Code zu schreiben. Perfekt für Anfänger und alle, die ihre Python-Kenntnisse vertiefen möchten!

Meistern Sie, wie Sie mit der for-Schleife durch Sequenzen iterieren, verwenden Sie range() effektiv, erkunden Sie Bedingungen mit if/else und steuern Sie Schleifen mit break und continue. Machen Sie sich bereit, effizienten, sauberen und praktischen Code zu schreiben, während Sie sich unterhaltsamen Herausforderungen stellen!

Sammeln Sie praktische Erfahrungen mit der while-Schleife! Lernen Sie, wie Sie Bedingungen handhaben, Endlosschleifen vermeiden, den Kontrollfluss mit break und continue steuern und sogar else mit Ihren Schleifen kombinieren. Meistern Sie, wann Sie while-Schleifen effektiv in realen Szenarien einsetzen und schärfen Sie Ihre Problemlösungsfähigkeiten!

Lernen Sie, wie Sie Schleifen effektiv kombinieren, if/else-Bedingungen verwenden und break- und continue-Anweisungen meistern, um den Ablauf zu steuern. Am Ende werden Sie in der Lage sein, komplexe Probleme mit Leichtigkeit und Präzision zu lösen.

Vereinfachen Sie Ihren Python-Code mit Listen- und Wörterbuchverständnissen! Lernen Sie, wie Sie Listen und Wörterbücher auf eine prägnante und elegante Weise erstellen können, während Sie die Lesbarkeit und Leistung verbessern. Meistern Sie praktische Beispiele und entdecken Sie, wie Sie komplexe Aufgaben vereinfachen können, vom Filtern von Daten bis zur Transformation, alles in einer einzigen Codezeile.

Break/Continue in Einer Verschachtelten Schleife

Lösung