Moduł wprowadza mechanizm pętli warunkowej while w Pythonie, który pozwala na automatyzację powtarzalnych zadań bez ręcznego powielania kodu. Omówiono składnię pętli while, zasadę ewaluacji warunku na wejściu (pre-test loop) oraz anatomię iteracji, ze szczególnym uwzględnieniem modulacji stanu zmiennej warunkowej. Przedstawiono zaawansowane techniki sterowania przebiegiem pętli, takie jak liczniki (inkrementacja/dekrementacja), akumulatory, flagi logiczne oraz instrukcje break i continue, wraz z typowymi pułapkami (nieskończona pętla, NameError, pominięcie inkrementacji). Moduł zawiera praktyczne projekty, w tym interaktywne menu główne, zbieranie kapitału na skarbonkę oraz symulację losowania z modułem random, a także omówienie unikalnej konstrukcji while...else.

Kluczowe zagadnienia modułu:

• Pętla while – składnia z dwukropkiem, warunek początkowy (pre-test loop) i anatomia iteracji z obowiązkową modulacją stanu
• Liczniki i operatory przypisania – inkrementacja (+=), dekrementacja (-=) oraz skróty arytmetyczne (*=, /=) do precyzyjnego sterowania liczbą obrotów
• Akumulatory i flagi logiczne – gromadzenie danych w pętli i sterowanie jej działaniem za pomocą zmiennych boolowskich
• Break i continue – gilotyna zrywająca pętlę oraz trampolina do następnego obrotu, wraz z pułapką pominięcia inkrementacji
• Zaawansowane konstrukcje – while True jako główna pętla programu, while...else, pętla z input(), time.sleep() oraz integracja z modułem random

• Wyobraź sobie, że piszesz grę i chcesz, aby bohater uderzył wroga 1000 razy. Czy napiszesz w kodzie 1000 razy polecenie `print("Uderzam!")` metodą kopiuj-wklej?
• Jeśli przeszło Ci to przez myśl, to zgrzeszyłeś przeciwko naczelnej zasadzie informatyki, która brzmi: "Niech maszyna odwala nudną robotę".
• Komputery powstały nie po to, by tylko dodawać liczby, ale przede wszystkim po to, by robić rzeczy powtarzalne miliony razy na sekundę, bez najmniejszego zmęczenia.
• Pomyśl o algorytmie Google, który codziennie skanuje miliardy stron. Nikt nie napisał miliarda instrukcji. Zastosowano automatyzację.
• W tym module wkraczamy w najważniejszy wymiar profesjonalnego programowania: Zarządzanie Czasem i Powtarzalnością.
• Poznasz mechanizm zwany pętlą (cyklem), który "kręci" całą maszyną od środka, wyręczając Cię z mozolnej pracy, dopóki sędzia logiczny nie pozwoli jej przestać.

• Do tego momentu naszych rozważań, przewidywalnie używaliśmy instrukcji `while` wyłącznie jako prostej maszyny z twardym limitem obrotów.
• Jednakże, prawdziwa, rynkowa potęga i unikalność pętli warunkowej objawia się w algorytmach, gdy kategorycznie NIE ZNAMY z góry ostatecznej liczby iteracji!
• Wyobraź sobie klasyczny program finansowy, surowo pytający klienta o jego 4-cyfrowy kod PIN przy bankomacie.
• Klient może wpisać go idealnie za pierwszym podejściem, a roztargniona osoba może próbować zrobić to po raz setny. Oś czasu jest tu całkowicie płynna i silnie uzależniona od działań zjawisk zewnętrznych.
• W takich momentach zaprzęgamy do boju swobodny tzw. warunek logiczny, na którym polega główna istota polecenia "dopóki" we współczesnym IT.
• Zasada mówi: Dopóki zebrana fizycznie od człowieka zmienna z PINem posiada złe wartości, pętla nie zwalnia, tylko potężnie więzi użytkownika żądając ciągłej poprawy aż do zwycięstwa logiki.

# Teoretyczny model myślowy:
# Dopóki (są pieniądze w portfelu):
#     1. Kup chleb
#     2. Odejmij 5 zł z portfela
#     [Winda do góry - wróć do słowa "Dopóki"]
            

• Konstrukcja fizyczna (składnia) wygląda u samego szczytu niemal identycznie jak znana nam już bramka `if`.
• Zaczynamy od napisania słowa kluczowego `while`, następnie stawiamy Warunek będący Pytaniem do sędziego.
• Całą linijkę bezwzględnie kończymy magicznym dwukropkiem `:`, który informuje interpreter o otwarciu wymuszonego bloku podległego.
• Po wciśnięciu Enter, edytor otwiera ciało pętli przesunięte w prawo o rygorystyczne 4 spacje, tworząc silnik wewnętrzny maszyny.
• Wszystko, co znajdzie się w tym wcięciu, powtarza się w ramach procesu tzw. iteracji.
• Z kolei wszystko, co przylega twardo do lewej krawędzi dokumentu poniżej wcięcia pętli, nie należy do ciała pętli i nie wykonuje się podczas jej obrotów.
• Kod zewnętrzny doczeka się wykonania DOPIERO po tym, gdy pętla oficjalnie "umrze", a sędzia na samej górze wyda ostateczny wyrok False.

zapalniki = 3

while zapalniki > 0:
    # Ten blok wcięty wykonuje się jako "Wirnik" maszyny
    print("Płonę!")
    zapalniki = zapalniki - 1
    
# Ta linijka wykona się tylko raz, na samym końcu, gdy pętla padnie
print("Gra skończona.")
            

• Z technicznego punktu widzenia, pętla `while` w języku Python zawsze sprawdza strażnika ZANIM ktokolwiek wejdzie do środka wcięcia.
• Dlatego w informatyce nazywamy ją pętlą z *warunkiem początkowym* sprawdzanym na zewnątrz bloku (tzw. "pre-test loop").
• Stanowi to ogromną różnicę w stosunku do struktur "do-while" z innych języków (np. C++), których Python celowo nie posiada w ramach czystości kodu.
• Co to rygorystyczne sprawdzanie na wejściu oznacza dla Ciebie w praktyce? Oznacza, że obrót wcale nie jest gwarantowany.
• Jeśli zażądasz, aby pętla działała dopóki wróg jest żywy, a ty w wyniku błędu gry dostarczysz jej na starcie od razu zmarłą postać...
• ...program popatrzy na zmienną HP wynoszącą 0 przy wejściu `while 0 > 0:`, natychmiast stwierdzi False i ominie całe wcięcie nie wykonując go ani razu!

# Test z zerowym wejściem
hp_bossa = 0

# Pytanie pada od razu na starcie. 0 nie jest większe od 0. Wynik: False!
while hp_bossa > 0:
    print("Bijemy bossa!") # Ta linijka NIGDY NIE UJRZY ŚWIATŁA DZIENNEGO.

print("Idziemy zbierać nagrody.") # Skrypt skacze od razu tutaj.
            

• Zdefiniujmy najpierw słowo kluczowe w profesjonalnym żargonie. Każde pełne wykonanie bloku kodu we wcięciu nazywamy Iteracją.
• Pojęcie to wywodzi się bezpośrednio z łaciny, od słowa *iteratio*, oznaczającego dosłownie powtórzenie czynności.
• Jeśli zaprogramowana pętla wjechała windą na dół wcięcia 5 razy, Starszy Inżynier powie: "Algorytm zrealizował 5 pełnych iteracji".
• Najczęstszym, potężnym w skutkach błędem myślowym początkujących jest wierzenie, że sędzia cały czas obserwuje zmienną. Tak nie jest!
• Sędzia bada warunek tylko przez ułamek sekundy w momencie przekraczania górnych drzwi `while`, i zamyka za Tobą wrota.
• Z tego powodu pętla nigdy nie przerwie się w połowie swojego własnego wcięcia, nawet jeśli warunek umrze będąc w 3 linijce bloku.
• Raz wpuszczona maszyna dociera zawsze twardo do ostatniej instrukcji wciętej, i DOPIERO po powrocie do góry uderza o zamknięty sufit, umierając.

# Wyobraź sobie krople drążące skałę (Iteracje)
krople = 2
while krople > 0:
    print("Spada kropla...") # 1. Wykonanie i wyjazd do dołu
    krople -= 1 # 2. Tu jest 0. Pętla jedzie na góre, zderza się z while 0 > 0. Wyrok: FALSE!
    
print("Skała wydrążona po 2 iteracjach.")
            

• Zanurzmy się teraz w mroczny, owiany złą sławą sekret, będący przekleństwem wszystkich początkujących (i czasami zaawansowanych) koderów.
• Zastanów się analitycznie, co się stanie, jeśli zaprosisz sędziego i podasz mu Prawdę, wykonasz milion ciężkich zadań z bloku wcięcia...
• ...ale zapomnisz fizycznie uszkodzić lub matematycznie zmodyfikować tę konkretną zmienną wewnątrz pętli, na której opiera się warunek?
• Ponieważ zmienna nie ulega zmianie, pętla powraca na górę pytając o to samo 5, które wciąż jest większe od 0. Powstaje potwór: Infinite Loop.
• Zablokowany algorytm będzie pędził z pełną prędkością rdzenia procesora (miliardy instrukcji na sekundę), na zawsze wykonując to samo.
• Rezultat jest tragiczny: procesor pracuje na 100% mocy, terminal zapełnia się tekstem, a program przestaje reagować na komendy.

• Aby lepiej zrozumieć naturę błędu, przeanalizujmy wspólnie w pamięci ten z pozoru niewinny skrypt, próbujący napisać "Cześć".
• Tworzymy w pamięci RAM zmienną zwaną limit, przypisując jej pożądaną liczbę iteracji wynoszącą twarde 5.
• Bramka przy słowie `while` z zadowoleniem stwierdza Prawdę, ponieważ 5 jest ewidentnie większe matematycznie od zera. Wchodzimy.
• Drukujemy napis na konsolę. Po druku uderzamy w sam dół wcięcia i jedziemy niewidzialną windą na górę, zapytać interpreter co dalej.
• Maszyna pyta ponownie: "Ile teraz wynosi limit?". Z przerażeniem uświadamiamy sobie, że w kodzie wciętego ciała pętli nie ma polecenia zmiany!
• Procesor utknął w klatce, z której nie ma już ratunku dla tego dokumentu. Skrypt zawiesza się nieustannie rzucając napisem w terminal.

# OSTRZEŻENIE: Ten kod po odpaleniu zawiesi Ci komputer.
limit = 5

while limit > 0:
    print("Cześć, uczę się pętli!")
    # Tutaj brakuje magicznej linijki która zmniejsza zmienną limit!
    # Python pomyśli: Skoro na górze 5 > 0 to zrobie to jeszcze raz. Na wieki.

# Program NIGDY nie osiągnie tej linijki kodu na zewnątrz.
print("Koniec.")
            

• Zatem podstawową, nadrzędną misją inżyniera projektującego maszyny cykliczne jest nieustanne pamiętanie o mechanice zwanej modulacją stanu.
• Jeżeli jakakolwiek pętla otwiera się sprawdzając warunek dynamiczny, wewnątrz jej wcięcia bezwzględnie MUSI znajdować się instrukcja uderzająca w ten warunek.
• Pętla jest z definicji mechanizmem samozniszczenia. Każdy poprawny obrót musi w minimalnym choćby stopniu zbiegać do sfałszowania i śmierci sędziego.
• Najprostszą i najbardziej niezawodną formą uratowania się od wieszającej pętli jest odejmowanie wartości z każdym cyklem: `zmienna = zmienna - 1`.
• Dzięki temu jeden ułamek milisekundy później warunek osłabia się (limit staje się mniejszy), by po kilku iteracjach ostatecznie z hukiem pęknąć i wyzwolić procesor!

# Bezpieczny cykl kontrolowany
limit = 3

while limit > 0:
    print("Zostało obrotów: " + str(limit))
    # TA LINIJKA JEST BEZCENNA - to ratunek przed zawieszeniem komputera
    limit = limit - 1 
    # 1 iteracja (limit staje się 2)
    # 2 iteracja (limit staje się 1)
    # 3 iteracja (limit staje się 0). Winda na górze łapie FALSE (0 nie jest > 0) !

print("Bezpieczne wylądowanie z dala od Pętli.")
            

• Współczesne procesory (zwłaszcza architektura z rodziny Intel i7/i9) są zaprojektowane do wykonywania monstrualnych miliardów instrukcji zegarowych w sekundę.
• Dla maszyny obrót prostej matematycznej pętli to pestka. Rozwiąże ona tysiąc iteracji zanim mrugniesz okiem, zrzucając rzygawicę tekstu błyskawicznie w dół okna.
• W rezultacie nie zobaczysz tego ruchu, nie uświadczysz upływu czasu tak potrzebnego do symulowania systemów życia, ataków w grze, czy paska postępu.
• Aby zobaczyć, jak kod na ekranie oddycha i żyje własnym życiem, programiści nakazują zamrożenie cyklu pętli pomiędzy iteracjami.
• Służy do tego wbudowana biblioteka `time`. Aby ją zaprząc, dodajemy `import time` na absolutnym, zerowym poziomie dokumentu u jego szczytu.
• Wewnątrz pętli uderzamy z zaklęciem `time.sleep(1)`. Rozkazujemy tym samym procesorowi zapaść w stan, w fizyczny letarg trwający dokładnie tyle sekund.

import time # Podpięcie biblioteki z czasem

rakieta = 3

while rakieta > 0:
    print("Start za: " + str(rakieta) + "...")
    time.sleep(1) # Komputer zastyga w bezruchu na 1 sekundę! Magia w akcji.
    rakieta = rakieta - 1

print("START BŁYSKAWICZNY! BOOOM!")
            

• Uwieńczmy zdobyty na dotychczasowych slajdach fundament wiedzy i zaprojektujmy solidną mechanikę niszczenia wirtualnej bramy obronnej.
• W naszej symulacji bohater posiada określoną z góry siłę ciosu rzędu 2 punktów, a potężna brama chroniąca zamek posiada wyjściowe twarde zdrowie.
• Pętla jest skonstruowana tak genialnie, aby kręcić się zawzięcie dotąd, dopóki cel operacji wojskowej nie ustąpi ze swojej pozycji.
• Moduł snu czasowego pozwala widzowi emocjonować się postępem bitwy co równe, powolne uderzenia trwające pół sekundy każde.
• Zwróć bezwzględną uwagę na klarowność, spójność logiczną i nienaruszalną matematykę wciętego rozwiązania.
• To właśnie na tym konkretnym etapie nauki przestajesz być skrypterem wykonującym instrukcje liniowe, a ewoluujesz w Programistę nadającego procesom powtarzalne życie.

import time

hp_bramy = 4
sila_ciosu = 2

print("[SYSTEM] Rozpoczęto natarcie!")

while hp_bramy > 0:
    print("Uderzasz z siłą 2! Aktualne zdrowie Bramy: " + str(hp_bramy))
    time.sleep(0.5)
    hp_bramy = hp_bramy - sila_ciosu # Kruszenie - zmienna warunkowa osłabiana o 2

print("[SUKCES] Brama w pył! Pętla ataku zakończona, silnik zatrzymany.")
            

• Zastanawiałeś się kiedyś, skąd pozbawiony świadomości komputer wie, że wykonał zadanie dokładnie 5 razy, a nie 6 czy 100?
• Maszyna nie ma wyobraźni ani wrodzonej pamięci podręcznej dla samej struktury pętli, dlatego bezwzględnie potrzebuje zmiennej pomocniczej, swoistej "karteczki z wyliczeniami".
• Tę karteczkę inżynierowie definiują twardo przed otwarciem pętli i nazywają w żargonie Licznikiem lub potocznie z matematyki literą `i` (skrót od słowa Iterator).
• Zasada działania opiera się na żelaznej logice: Najpierw na spokojnie ustalasz zmienną `i = 0` całkowicie na zewnątrz, poza silnikiem obrotowym.
• Następnie bezpiecznie wpuszczasz ją do weryfikacji sędziego np. `while i < 5:`, zmuszając do obrotów.
• Wewnątrz głębokiego bloku pętli musisz na samym końcu wcięcia ręcznie podnieść wartość zliczającą, by napędzić ją o jeden wyżej za pomocą uderzenia `i = i + 1`.

• Zapisywanie matematycznego `x = x + 1` bywa uciążliwe wizualnie i wydłuża pisanie kodu.
• Python, wychodząc naprzeciw czytelności (tzw. "cukier składniowy"), udostępnia nam potężne operatory przypisania skróconego.
• Zapis z połączonym plusem `+=` oznacza wprost: Weź to co masz, dodaj wartość z prawej strony i zapisz gotowy wynik z powrotem do samego siebie.
• Używamy tego genialnego mechanizmu bez przerwy przy obsłudze wszelkich liczników pętli obrotowych.
• Oczywiście środowisko udostępnia pełen wachlarz tych skrótów. Istnieją również instrukcje `-=` (odejmowanie od siebie), `*=` (mnożenie samego siebie) oraz `/=` (dzielenie).
• Dzięki nim, zarządzanie postępem indeksu w pętli `while` ogranicza się do minimalnej, estetycznej i niezwykle wydajnej linijki przed powrotem na górę.

# Szybkie liczenie od zera do czterech
i = 0 # Nasza karteczka

while i < 5:
    print("Pracuję... Iteracja nr: " + str(i))
    i += 1 # Krótkie i eleganckie powiększenie licznika!

print("Pętla skończona. Licznik wybił ostatecznie: " + str(i))
            

• Oprócz konsekwentnego powiększania liczników w górę (`+=`), maszyna algorytmiczna równie sprawnie i dobrze radzi sobie ze stanowczym ścinaniem warunków z góry na sam dół.
• Specjalny operator arytmetyczny `-=` (Minus-Równa-Się) oznacza natychmiastową, potężną komendę dla serca układu scalonego procesora.
• Jego bezpośrednie znaczenie to: "Odejmij od samego siebie twardo podaną z prawej strony wartość i błyskawicznie zapisz nowy mniejszy wynik z powrotem w swoich komórkach RAM".
• Zjawisko to nazywamy formalnie Dekrementacją (czyli celowym, programowym zmniejszaniem wartości referencyjnej) i jest to nieodłączny element symulacji czasowych.
• Dekrementacji używa się powszechnie we wszystkich złożonych grach komputerowych czy bazach danych, chociażby do rygorystycznego zliczania pozostałych sekund życia tykającej bomby pułapkowej.
• Stanowi też idealne rozwiązanie do nadzorowania uciekającego czasu operacyjnej misji lotniczej czy ubywających w próżni zapasów paliwa w symulowanym statku kosmicznym.

# Rakieta uderzająca w ziemię!
wysokosc = 1000

while wysokosc > 0:
    print("Spadamy! Jesteśmy na: " + str(wysokosc) + "m")
    wysokosc -= 200 # Ostry spadek o 200 metrów w każdym obrocie wirnika!

print("[ZDERZENIE Z ZIEMIĄ!]")
            

• Skoro możemy coś błyskawicznie i wydajnie dodawać oraz odejmować, środowisko Python wychodzi ze swoistym prezentem, oferując jeszcze więcej możliwości.
• Podarowuje on rzeszom inżynierów fantastyczne skróty literowe do absolutnie wszystkich operatorów matematycznych poznanych z modułu drugiego!
• Potrzebujesz pętli gładko symulującej wykładniczy rozrost śmiercionośnych bakterii w naczyniu, w której ich ilość podwaja się niebezpiecznie co sekundę?
• Użyj do tego operatora wielokrotności skróconej `*=`, która natychmiastowo zmusza zmienną do wchłonięcia mnożnika z prawej flanki równania.
• Z kolei jeśli piszesz wyrafinowany algorytm połowienia binarnego z dziedziny fizyki czy informatyki, szybko i bezlitośnie tnij zmienną przez dwa przy pomocy nożyc `/=`.
• Daje Ci to w efekcie nieograniczoną, profesjonalną moc nad kształtowaniem potężnego matematycznie programu bez zaśmiecania dokumentu niepotrzebnym powtarzającym się blokiem tekstu.

bakterie = 1

while bakterie < 1000:
    print("Ilość organizmów: " + str(bakterie))
    bakterie *= 2 # 1, 2, 4, 8, 16, 32, 64... Błyskawiczny wzrost wykładniczy!

print("[OSTRZEŻENIE] Inwazja osiągnęła masę krytyczną.")
            

• Często w procesach biznesowych potrzebujemy pętli nie tylko do suchego odliczania iteracji, ale również do ciągłego zbierania i kumulowania spływających danych numerycznych.
• Zmienną architektoniczną, która zbiera, chłonie i kumuluje bezpowrotnie wyniki matematyczne z każdego potężnego obrotu nazywamy w branży Akumulatorem (lub Kolektorem).
• W przeciwieństwie do zwykłego małego licznika `i`, worek akumulatora musi udźwignąć potężne liczby, dlatego zazwyczaj nosi wyrazistą nazwę opisową, np. `suma_miesieczna`.
• Aby zadziałał poprawnie, Akumulator ZAWSZE deklarujemy PRZED wejściem do gorącej pętli maszynowej, ustawiając go na pożądany punkt początkowy (najczęściej 0).
• Następnie głęboko wewnątrz aktywnej pętli, z każdym nowym przejazdem iteracyjnym, bezlitośnie dorzucamy do niego zarobione świeże kwoty, używając operatora `+=`.
• Dzięki temu na samym końcu pliku programistycznego, po wygaśnięciu cyklu, dysponujemy pełnym zsumowanym kapitałem gotowym do przekazania interfejsowi użytkownika.

# Sumowanie zarobków firmy dniówka po dniówce:
dni = 1
zysk_calkowity = 0 # Pusty worek akumulatorowy

while dni <= 3:
    zysk_calkowity += 500 # Firma zarabia dziennie 500 zł (Rzucamy do worka)
    dni += 1 # Pchnięcie czasu do przodu by kiedyś zatrzymać symulację!

print("Łączny zysk po 3 dniach: " + str(zysk_calkowity) + " zł")
            

• Nawiązując bezpośrednio do poprzednich założeń akumulatora, musisz uważać na brutalną pułapkę czyhającą w konstrukcji bloku opartego o wcięcia i zagnieżdżenia.
• Zbudujmy mentalny system logowania danych numerycznych, w którym zapytasz klienta o podanie swojego rzetelnego zysku z trzech kolejnych dni z użyciem standardowej klawiatury.
• Jeśli w ramach roztargnienia popełnisz potężną zbrodnię architektoniczną na zjawisku Scope (Zasięgu Zmiennych) i niefortunnie zadeklarujesz zmienną sumy GŁĘBOKO wewnątrz wciętej pętli... dojdzie do tragedii!
• Każde nowo zainicjowane przejście iteracji gilotyny z góry na dół zmasakruje Twój stworzony worek, ustawiając go bezwzględnie od nowa w stan początkowy "0"!
• W wyniku błędu pętla będzie złośliwie zbierała cenne dane od użytkownika, zjadała je z zadowoleniem i natychmiast zapominała je przed startem kolejnego obrotu, wydając na końcu samą wartość 0.

• W pierwszych modułach kursu poznaliśmy funkcję `input()` pozwalającą rzucić pytanie na terminal dla widza.
• Niestety w liniowym skrypcie odpalona raz i odpowiedziana instrukcja brutalnie zamykała skrypt i nie pozwalała klientowi decydować dalej o losach aplikacji.
• Sytuacja zmienia się diametralnie, kiedy wepchniemy mądrze funkcję interaktywną bezpośrednio pomiędzy bloki aktywnego wcięcia Pętli warunkowej `while`, gdzie dzieją się prawdziwe programistyczne cuda!
• Połączonym mechanizmem stworzysz od podstaw prawdziwe, użyteczne oprogramowanie "Czekające na rozkaz", czyli interaktywną piaskownicę.
• Rozwiązanie polega na zbudowaniu twardego warunku sędziowskiego np. `while haslo != "sekret":` tuż na samym szczycie cyklu przed wcięciem.
• W ciele wciętej pętli pytamy nieustannie użytkownika z zablokowanej klawiatury by nadpisał to słowo próbując używać ponownej komendy `haslo = input("Spróbuj ponownie:")`.
• Nieustępliwy sędzia z całą pewnością nie wyjdzie z powtarzanego systemu weryfikacji bankowej, dopóki z zewnątrz ostatecznie nie nadejdzie odpowiednia komenda tekstowa łamiąca Prawdę wymuszoną na szczycie!

# Maszyna weryfikacyjna wyciągnięta wprost ze skarbców bankowych
podane_haslo = "" # Zmienna inicjacyjna, pusty String

while podane_haslo != "1234":
    # Ta linijka MROZI fizycznie maszynę wewnątrz obrotu! Czeka na klawiaturę!
    podane_haslo = input("Podaj PIN dostępu do konta: ")
    
print("Witamy w Banku Centralnym. Uzyskano zgodność PIN.")
            

• Niezmiernie wydajnym technicznie, branżowym sposobem zarządzenia życiem wygenerowanej pętli obrotowej jest opanowanie w locie potęgi tzw. Flagi Stanu (State Flag).
• Flaga to silne pojęcie abstrakcyjne w inżynierii, fizycznie oznaczające w kodzie po prostu zwykłą, małą zmienną przetrzymującą w sobie twardy typ logiczny Prawda/Fałsz (Boolean).
• Zamiast zlecać pracującemu procesorowi mozolne sprawdzanie skomplikowanych równań arytmetycznych czy rozwiązywanie wielokrotnych nierówności, cała kontrola opiera się oszczędnie na pojedynczej, prostej deklaracji np. `gra_trwa = True`.
• Powołana w ten sposób maszyna staje się od tego momentu sterowana banalnym binarnym włącznikiem rzuconym z zewnątrz jak hebel.
• Cały moduł kręci się powtarzalnie z absolutnie absurdalną prędkością herców, czerpiąc Prawdę życiową i tlen z wywieszonej na zewnątrz flagi.
• Prawdziwa magia logiczna dzieje się jednak w ułamku sekundy, gdy na skutek obcych ingerencji spełniony zostanie niepożądany w grze warunek, i na przykład znużony gracz niefortunnie straci w walce swój ostatni punkt cennego życia.
• Z poziomu wciętego, bezpiecznie schowanego wewnątrz pętli silnika, program uderza z całą wściekłą mocą we flagę nadrzędną, na stałe opuszczając ją poleceniem maszynowym: `gra_trwa = False`, czym automatycznie uśmierca cały ciąg zdarzeń bez używania gilotyn.

system_dziala = True

while system_dziala:
    print("Obracanie wirnika chłodzenia...")
    rozkaz = input("Napisz 'stop' aby zatrzymać maszynę: ")
    
    if rozkaz == "stop":
        system_dziala = False # Ścięcie Flagi! Za chwile silnik opadnie!
        
print("Wirnik został unieruchomiony.")
            

• Z nowatorską pętlą używającą inteligentnych flag lub na siłę wymuszającą zgodność z twardą zmienną wejściową wiąże się błąd nowicjusza wyskakujący natychmiast na poziomie interpretacji - osławiony NameError.
• Jeśli bramą startową wejściową do bazy danych jest sztywny warunek postaci `while wpisane_imie != "Anna":`, a Ty jako inżynier zapomniałeś o tym i nie zadeklarowałeś wyżej w liniach czym ta zmienna właściwie na samym początku ma być...
• Twój pieczołowicie złożony system zawiesi się i wybuchnie brzydkim komunikatem natychmiastowo po rzuceniu kodu w środowisku wykonawczym!
• Dlaczego tak brutalnie się dzieje? Pamiętaj, że potężny Python na bieżąco ewaluuje obiektywną Prawdę i Fałsz na wejściu DO samej pętli podczas pierwszego czytania skryptu z góry.
• Kompilator staje bezradny przed bramą weryfikacyjną i w myślach pyta: "Słuchaj, powiedz mi tylko rzetelnie czy ta kompletnie niewidzialna dla mnie na tym etapie i pusta przestrzeń w RAM to czasem nie wrogi napis Anna?".
• Z braku możliwości odpowiedzi na to paranienormalne zapytanie, wbudowany sędzia natychmiast panikuje, rzucając bezkompromisowym, rażącym po oczach `NameError: name is not defined` i ubijając Twój proces od razu!

# Interpreter wybucha na słowie wpisane_slowo, bo go tu fizycznie jeszcze nie ma w RAM!

# TUTAJ BRAKUJE INICJALIZACJI! (wpisane_slowo = "")
while wpisane_slowo != "wyjdz":
    wpisane_slowo = input("Czekam na slowo 'wyjdz': ") 
    # System nigdy nie dotrze do odczytu by ją zadeklarować.
            

• W tej części lekcji ostatecznie i sprytnie zintegrujemy omówiony wcześniej akumulator oszczędnościowy z naocznym, ciągłym odczytem danych z fizycznej klawiatury!
• Skonstruujemy użyteczną, symulowaną maszynę finansową, która po włączeniu do zasilania bezlitośnie domaga się zasilenia wirtualnego kapitału wpłacanymi drobnymi kwotami.
• Cykl powtarzalny maszyny będzie trwał w nieskończoność w trybie czuwania dopóki cyfrowy sędzia operacyjny na górze nie zarządzi z radością osiągnięcia wielkiego sukcesu i zablokowania wejścia!
• Użyjemy głęboko wewnątrz logicznego wcięcia potężnego połączenia funkcji rzutującej `int(input(...))` by precyzyjnie w locie chwytać kwoty wprowadzane przez klienta na ekranie monitora.
• Natychmiast po udanym przechwycie, będziemy rzucać je z silną konwersją typów jako Twarde Liczby inżynieryjne prosto do trzewi pamięci układów.
• Liczby te następnie nasza pętlowa maszyna księgowa potrafi w mgnieniu oka pochłonąć do skarbca przez genialny skrót operatora kumulującego `+=`, skutecznie windując cel zbiórki charytatywnej na niespotykany dotąd poziom.

cena_auta = 15000
zebrane = 0 # Pusty akumulator (Worek) na starcie

print("Rozpoczęto zbiórkę charytatywną na potężnego Poldka!")

while zebrane < cena_auta:
    brakuje = cena_auta - zebrane
    print("Cel: 15k. Stan konta: " + str(zebrane) + ". Brakuje: " + str(brakuje))
    wplata = int(input("Wpisz kwotę wpłaty z bankomatu: "))
    
    zebrane += wplata # Skarb się powiększa! Kiedyś warunek na górze zostanie połamany!

print("WSPANIAŁY SUKCES! ZEBRANO PIENIĄDZE! WYDANIE POJAZDU W TOKU...")
            

• Na wczesnym etapie nauki usilnie uczyliśmy się na błędach jak strzec zasobów przed zabójczymi pętlami nieskończonymi.
• Czas na potężny zwrot akcji w architekturze: większość prawdziwych, komercyjnych programów ma w swoim silniku ZAMIERZONĄ pętlę nieskończoną.
• Zastanów się analitycznie: Jeśli serwer Google wyłączył się po twardych 100 obrotach logiki, internet przestałby bezpowrotnie działać po milisekundzie.
• Każdy serwer z natury musi bezwzględnie nasłuchiwać zapytań przychodzących przez złącza sieciowe przez całą wieczność, w dzień i w nocy.
• Pozostaje on w stanie nieprzerwanej iteracyjnej czujności dopóki administrator fizycznie nie odetnie mu zasilania lub nie rzuci sygnału przerwania bazy.
• Aby zbudować Pętlę Główną aplikacji (tzw. Main Loop), z premedytacją omijamy tworzenie zmiennych warunkowych z zewnątrz i wstawiamy na sztywno absolutną Prawdę logiczną prosto w bramie sędziowskiej: `while True:`.

• Skoro w ramach Main Loopa napisaliśmy z całą odpowiedzialnością deklarację `while True:`, zamykamy interpreter w złotej klatce.
• Domyślna brama wejściowa absolutnie NIGDY w nieskończoności przebiegu czasu nie opadnie w dół, by naturalnie wypuścić program niżej, gdyż wbudowana wartość True z definicji matematycznej się nie zmieni.
• Jeśli we wcięciu zrobisz całą ciężką pracę obliczeniową i zapiszesz pliki na dysk, jak bezpiecznie kazać rozpędzonej maszynie się zatrzymać?
• Potrzebujemy brutalnego mechanicznego łomu rzuconego celowo prosto w kręcące się tryby silnika przez strażnika warunkowego, który zatrzyma katastrofę.
• W języku Python (i większości innych języków branżowych) ten twardy łom sprzętowy nazywa się instrukcją sterującą `break` (z ang. Złam / Przerwij).
• Gdy interpreter, czytając posłusznie wcięcie linijka po linijce z góry na dół, natknie się na osamotnione, zarezerwowane słowo `break`, NATYCHMIAST anuluje wszystko dookoła!
• Wtedy już nie wraca grzecznie do góry, nie weryfikuje nawet żadnego warunku sędziego, lecz bezlitośnie rozrywa klatkę pętli w strzępy i program bezpiecznie opada do kodu poniżej.

# Skrypt celowo uwięziony z jedynym ratunkiem w locie
while True:
    print("Pracuję w kopalni bez końca...")
    
    # Jeśli po tej linijce wstawimy break, to kod zadziała tylko RAZ i wyjdzie!
    break
    
    # Ta linijka NIGDY się nie wywoła, break uderzył wyżej!
    print("To jest zignorowane.")

print("Wolność! Wyrwaliśmy się z okowów pętli.")
            

• Samo niszczycielskie słowo `break`, bezmyślnie rzucone zupełnie luzem gdzieś w głównym kodzie wcięcia, nie ma najmniejszego sensu operacyjnego.
• Obecne samotnie w bloku, brutalnie zabiłoby działającą pętlę od razu przy pierwszym obrocie rotora, czyniąc ją pod względem architektury zwykłym nudnym kodem liniowym bez iteracji.
• Potęga instrukcji ucieczkowej objawia się i nabiera sensu dopiero wtedy, gdy świadomie połączymy znany nam moduł logicznego sterowania warunkowego (IF) z kręcącą się Pętlą!
• Wówczas głęboko wewnątrz aktywnego silnika pętlowego pozycjonujemy i montujemy zaawansowane bramki bezpieczeństwa i monitory warunkowe.
• Jeśli nagle w locie wydarzy się coś całkowicie niezwykłego: np. klient kliknie przycisk wyjścia "X" na oknie, lub plik straci spójność systemową...
• ...wówczas bezbłędny strażnik IF wpuszcza rurę w mniejsze zagnieżdżenie, a tam, głęboko ukryta, czeka na realizację twarda komenda `break`!
• Maszyna sprawnie mieli gigabajty powtarzalnych danych przez wiele długich minut, w nieskończoność, dopóki IF na jakimś wczesnym lub późnym etapie nie złapie wyroku winnego.

# Symulator przegrzania reaktora jądrowego
temperatura = 0

while True:
    temperatura += 100 # Gwałtowny wzrost!
    print("Rdzeń osiąga: " + str(temperatura) + " stopni!")
    
    # Strażnik z zagnieżdżeniem drugiego stopnia (8 spacji!)
    if temperatura >= 400:
        print("[ALARM] Wyłączam natychmiast reaktor awaryjnym hamulcem!")
        break # Zerwanie obrotów main loopa!

print("Udało się opanować sytuację. Reaktor opuszczony.")
            

• Być może powiesz jako doświadczony kursant: "Przecież z powodzeniem mogłem ustawić potężną flagę `gramy = False` natychmiast po uszkodzeniu systemu i pętla sama by spadła!".
• Owszem, flagowanie bywa bezpieczniejsze, ale należy pamiętać o jednej kardynalnej zasadzie: niszczycielskie polecenie `break` jest w swym działaniu absolutnie BRUTALNE w czasie rzeczywistym.
• Jeśli projektowana pętla serwera ma w środku aż 500 linii kodu analitycznego, a nagła awaria chłodzenia reaktora nastąpi już w 10 linijce... to po rzuceniu zwykłej flagi na False, zmuszony procedurą sędzia i tak DOKOŃCZY ten obrót!
• Wszystkie nieświadome katastrofy 490 linijek znajdujących się poniżej bezlitośnie wykona swe procedury na spalonych danych, co wywoła masowe błędy i wysypie aplikację w logach.
• Flaga pozwoli wyłączyć silnik dopiero przy powrocie na samą górę, podczas gdy słowo `break` nie uznaje absolutnie żadnych kompromisów i na nic twardo nie czeka.
• Przypomina on znane Ci guard clauses (warunki ucieczkowe z modułu 4). Instrukcja break jest po prostu rzuconą do mechanizmu metalową gilotyną awaryjną.
• Raz celowo uderzona - tnie okrutnie i obcina dostęp do jakichkolwiek instrukcji poniżej zbrodni, wypluwając natychmiast całą pętlę na zewnątrz, omijając uszkodzone obwody w ułamku sekundy.

i = 0
while True:
    i += 1
    if i == 3:
        break # Ścięcie! Wszystko poniżej jest pomijane bezpowrotnie w tej iteracji.
    print("To na dole nigdy nie wystąpi dla 3ciej iteracji.")
            

• To właśnie za pomocą omówionej, zamierzonej i kontrolowanej pętli głównej `while True:` oraz instrukcji ucieczki `break` buduje się legendarne menu wyboru.
• Taka elastyczna architektura stanowi serce potężnych, czarnych skryptów terminalowych znanych wszystkim inżynierom (np. w systemach bankowych, giełdowych lub administracji systemów z rodziny Linux).
• Zasada biznesowa i flow są w tym konkretnym przypadku niezwykle wręcz banalne i piękne w swej konstrukcyjnej prostocie działania iteracyjnego.
• Wspomniana maszyna operacyjna praktycznie cały czas, z każdym pojedynczym i nowym obrotem, tuż na samym początku swojego bloku prezentuje listę opcji przez wielokrotny strumień `print`.
• Bezpośrednio po rysowaniu UI, zawiesza swój czas i stanowczo żąda wejścia tekstowego lub komendy numerycznej ze strony aktywnego klienta (`input`).
• Pod owym interaktywnym inputem znajduje się potężna i ukryta dla widza drabinka wyboru `if-elif-else` (lub nowatorska konstrukcja decyzyjna `match-case` ze współczesnego podejścia).
• Drabinka w zależności od precyzyjnego wejścia wykonuje powierzone jej małe bloki i grzecznie wraca z powrotem by narysować to nieskończone menu ponownie. Wyjątkiem jest wpisanie ukrytej komendy "WYJDŹ", która uderza w ukryty zapalnik `break` i z gracją schodzi na linię twardo zamykającą całą aplikację!

• Z wielką dumą inżynierską zobaczmy to niesamowite zjawisko strukturalne na własne, profesjonalne oczy w okienku terminala.
• Całkowite i biegłe opanowanie w locie tego fundamentalnego szablonu to niezaprzeczalnie absolutnie pierwszy krok w karierze do tytułu profesjonalnego programisty oprogramowania serwerowego.
• Uruchomiony kod nie jest jednorazowym strzałem liniowym znanym ze wczesnych lekcji z pierwszego tygodnia kursu językowego.
• To w pełni powtarzalna, responsywna aplikacja, która chętnie odpowiada na ciągłe komendy bez potrzeby nieustannego restartowania przez system operacyjny.
• Zwróć w analizie kodu silną uwagę na piękne zagnieżdżenia strukturalne i wyjątkową, akademicką wręcz czystość fizycznego wykonania poleceń odseparowanych blokami wcięć.
• Szablon ten pozwala dodawać z biegiem lat w łatwy sposób coraz to nowe funkcjonalności do korporacyjnej bazy bez uderzania i niszczenia reszty nienaruszalnego kodu bazy rdzeniowej!

print("--- ZARZĄDZANIE FLOTĄ ---")

while True:
    print("\n1. Odpal silniki\n2. Skanuj kosmos\n0. Odetnij prąd")
    komenda = input("Podaj rozkaz komandorze: ")
    
    if komenda == "1":
        print("[WZIUUUM] Silniki gotowe!") # Skoczy na górę wyświetlić nowe menu!
    elif komenda == "2":
        print("[BIP] Zeskanowano dwie czarne dziury.")
    elif komenda == "0":
        print("Ewakuacja pokładu!")
        break # CZYSTE ROZBICIE KOKPITU
    else:
        print("Nierozpoznana komenda!")

# System wyrzucony w to miejsce!
print("Program zatrzymany i zwrócony do systemu operacyjnego.")
            

• Niszczycielska instrukcja `break` ma fenomenalne zastosowanie przy tworzeniu skanerów i pętli zliczających swobodny napływ danych z zewnątrz.
• Niezmiernie często jako wdrożeniowiec IT musisz napisać program do zasilania bazy danych personalnych w wielkiej korporacji z sektora HR.
• Problem polega na tym, że absolutnie nigdy w praktyce nie wiesz z wyprzedzeniem, czy użytkowniczka systemu zamierza dzisiaj wpisać 10 imion nowych pracowników, czy być może zrzucić masowo półtora miliona rekordów!
• Jeśli wpisalibyśmy starą i twardą zaporę `while i < 10:`, wmurowalibyśmy twardy beton, który wściekle uniemożliwiłby wprowadzenie jedenastej osoby i zablokował biznes.
• Optymalnym i polecanym rozwiązaniem jest zastosowanie szeroko otwartej bramy `while True:` by bezwzględnie przyjmować nieustanny grad danych numerycznych uderzających o system w czasie ciągłym.
• Operator przed monitorem na początku zostaje poproszony o wklejenie imienia... lub wciśnięcie specjalnie zaprogramowanego w systemie tajnego słowa-wytrychu: ukrytego znaku "x", wciśnięcia samego Enter (puste słowo), lub konkretnej frazy "koniec".
• Czuwający niżej strażnik IF nieprzerwanie nasłuchuje czy tekstowy String na wejściu od klawiatury jest magicznie równy z tą pożądaną frazą. Dopiero w momencie uderzenia w ten ciąg, używa ciężkiej gilotyny `break`, zamykając otwarte wcześniej wrota i wypluwając użytkowniczkę w dół w taktyczny, elegancki sposób!

• Ustaliliśmy wcześniej i ugruntowaliśmy zjawisko polegające na tym, że kod można dowolnie i logicznie zagnieżdżać używając wcięć jak warstwy pięknej rosyjskiej Matrioszki.
• Zastanów się przez chwilę: Co tragicznego może się stać na poziomie wykonawczym procesora, jeśli celowo wrzucisz i otworzysz nową bramę w bramie, ukrytą w jeszcze innej potężnej bramie?
• Sytuacja wymyka się spod jakiejkolwiek kontroli nowicjusza w chwili implementacji wewnętrznego silnika kręcącego Pętlę w PĘTLI! Jeśli w jednym rdzeniu kręci się obrotowa, wielka rura `while True:` a w samym jej środku otworzysz drugi, ukryty w głębokim wcięciu mały młynek...
• Zastosowanie rzuconego w gniewie łomu w tej MALEŃKIEJ matrioszce na samym środku spowoduje, że rygorystyczna instrukcja ewakuacyjna `break` wymyka się spod kontroli!
• Zapamiętaj najważniejszą żelazną i fundamentalną zasadę oprogramowania iteracyjnego: Niszczycielskie słowo kluczowe Break zabija TYLKO najniższą (czyli wizualnie najbliższą mu w kodzie po lewej stronie wcięcia) pętlę docelową!
• Twardo użyty w samym środku gorącego, małego młynka bezlitośnie rozerwie go i rzuci resztki logiki na suchą podłogę młynka ZEWNĘTRZNEGO nadrzędnego, a nie od razu poza całą, podwójną gigantyczną architekturę oprogramowania.
• Wielki gigant i brat pętla bazowa będzie bez mrugnięcia tranzystorem kręcić się dalej po dawnym zderzeniu, i w następnym powtarzanym locie w dół znowu narysuje i stworzy od nowa zniszczony wcześniej młynek wewnętrzny w swej pamięci podręcznej!

• Wielu początkujących lub wręcz leniwych koderów nagminnie nadużywa potężnego, niszczącego całą tkankę granatu w postaci wezwania z Modułu 4: procedury `sys.exit()`.
• Zjawisko to jest powszechne i nasila się, gdy z powodu nagłego, nieopanowanego chaosu zagnieżdżeń nie potrafią sprawnie opanować plączącej się pętli za pomocą eleganckiego cięcia instrukcją `break`.
• Zrozum i uświadom sobie różnicę w skali i potędze tych dwóch komend. Komenda `break` jest dokładnie jak sterylne i ostre chirurgiczne cięcie precyzyjnym inżynieryjnym skalpelem.
• Odcina ona idealnie tylko celowany chory fragment rotora (wirnik) i z szacunkiem pozwala maszynie żyć dalej, opadając spokojnie w dolne partie liniowego pliku pod spodem pętli. Skrypt poniżej bez problemu dokończy bezpieczny zapis do bazy z zewnątrz czy wyśle miły e-mail użytkownikowi z ładnym podsumowaniem!
• Z kolei uderzenie bezlitosnym wywołaniem systemowym `sys.exit()` to zrzucenie masywnej bomby jądrowej centralnie na zatłoczonym stadionie wykonawczym i wyrwanie absolutnie wszystkich zasilających wtyczek wprost ze ściany na raz.
• W ułamku sekundy, z hukiem, następuje twarde zgniecenie wirtualnego serwera z ramienia twardego systemu Windows. Nigdy po czymś takim nie wyśle się żaden podsumowujący grzecznościowy e-mail na zewnątrz zabitej struktury.
• Twoi zdezorientowani użytkownicy pomyślą z żalem, że cały skomplikowany program po prostu padł niespodziewanie przez tragiczny błąd dewelopera i zamknął ekran (tzw. "Crash to Desktop"). Używaj tak agresywnego eksitu na samym dnie piekła wyłącznie do obsługi naprawdę i absolutnie krytycznych i fatalnych awarii!

# Rozgrzewająca się bomba pułapkowa:
import sys

while True:
    reakcja = input("Czy chcesz wyjsc brzydko (exit) czy ładnie (break)? ")
    
    if reakcja == "break":
        break # Zerwanie rdzenia. Skok NA DÓŁ by wypisać raport końcowy!
    elif reakcja == "exit":
        sys.exit() # Śmierć całkowita procesu w locie. Skrypt zamienia się w mgłę.
        
print("Tę wiadomość zobaczysz TYLKO jeśli wpisałeś eleganckie 'break'!")
            

• Teraz wspaniale i spektakularnie zintegrujmy opanowaną nową, potężną wiedzę z pętli logicznych z absolutnie bezcennym narzędziem ze świata informatyki - niesamowitym modułem prawdziwej losowości liczbowej.
• Z wielką premedytacją wstrzykniemy i wykorzystamy fizyczny, twardy silnik biblioteki wbudowanej `random`, aby brutalnie zmusić algorytm pętlowy by mechanicznie grał za nasze środki w kasynie.
• Proces symulacyjny wewnątrz zamkniętej wirtualnej klatki będzie nieugięcie i ze złowrogą determinacją mielił zasoby prądu w procesorze dopóki systematycznie nie padnie nam poszukiwana przez sędziego wielka wygrana.
• Jako flagowej, legendarnej i niesamowicie pożądanej w obrocie głównym nagrody użyjemy matematycznej, mistycznej liczby "777". Maszyna sprawdzi każdą próbkę wewnątrz rozciągniętego zagnieżdżenia za pomocą uderzającego warunku if.
• Jeśli w jednym z tysięcy obrotów ukryta na zewnątrz szczęśliwa wytypowana przez układ wylosowana liczba fizycznie wyjdzie z cyfrowej ściany, następuje uderzenie o ścianę!
• Wspomniane wyżej w module potężne i wyzwolicielskie ostrze awaryjne uderzy jak skalpel ratunkowy - instrukcja awaryjna rzuci z impetem `break`!
• W wyniku tej gwałtownej w skutkach ucieczki, pętla definitywnie i dumnie kończy swoją trwającą bezproduktywną agonię hazardzisty, wypisując podsumowujący print do terminala z cenną i twardą informacją obiektywną u dołu ekranu w jakiej i której z rzędu iteracyjnej zliczonej na boku próbie faktycznie nam się u maszyny na szczęście poszczęściło!

import random
liczba_prob = 0

print("Zaczynamy losowanie!")

while True:
    # Generowanie liczby z koszyka od 1 do 1000 w każdej iteracji Pętli:
    wylosowany_los = random.randint(1, 1000) 
    liczba_prob += 1
    
    if wylosowany_los == 777:
        print("JACKPOT! Znaleziono legendarną liczbę 777!")
        break # Ostrze gilotyny zakańcza bezlitośnie losowania!

print("Sukces nadszedł po " + str(liczba_prob) + " żmudnych obrotach wirtualnego bębna.")
            

• Opanowaliśmy już działanie bezlitosnej gilotyny z użyciem słowa kluczowego `break`, która raz uruchomiona, niszczy całą maszynę pętli definitywnie.
• Co w sytuacji, gdy biznesowo chcemy przekazać interpreterowi znacznie delikatniejszą intencję: "Ten konkretny, pojedynczy obrót ewidentnie poszedł źle. Zostawmy go."?
• Jeśli system przetwarza masowe dane i jeden pomidor jest zepsuty, program powinien po prostu ominąć tego pomidora, a następnie płynnie przejść do weryfikacji i procesu dla kolejnego, dobrego surowca na pasie.
• Do osiągnięcia tego wyrafinowanego efektu służy dedykowane słowo kluczowe w architekturze Pythona: `continue` (z języka angielskiego tłumaczone jako Kontynuuj).
• Nie daj się jednak zgubnie zwieść jego naturalnej nazwie! To słowo w inżynierii absolutnie NIE oznacza pospolitego "idź krok w dół i rób grzecznie swoje instrukcje dalej".
• Instrukcja ta niesie w sobie inną energię; w rzeczywistości oznacza wprost: "Błyskawicznie ODBIJ się z powrotem do górnej bramy weryfikacyjnej sędziego, ignorując kod poniżej!".
• W praktyce algorytmicznej polecenie `continue` działa zawsze jak niezwykle mocna i sprężysta trampolina umieszczona bardzo celowo wewnątrz najgłębszego wcięcia aktywnej pętli.

• Zastosowanie praktyczne trampoliny `continue` ujawnia się najczęściej podczas budowy profesjonalnych filtrów sortujących strumienie danych wejściowych w wielkich bazach informacji.
• Jest też ono niezbędne w krytycznych dla bezpieczeństwa i matematyki obliczeniach inżynieryjnych na uczelni, gdy specyficzne napotkane nagle wartości mogłyby doszczętnie zrujnować wynik całego bloku.
• Typowym i podręcznikowym przypadkiem jest brutalna w skutkach iteracyjna próba celowego (bądź nie) wykonania zakazanej operacji dzielenia aktywnego zbioru liczb przez twarde zero algebraiczne.
• Jeśli mechanizm programowy na bieżąco napotka zanieczyszczoną lub nieobsługiwaną daną w potoku, mądry inżynier przepuszcza ją najpierw przez ukrytego strażnika warunkowego IF zagnieżdżonego w bloku z boku.
• Ten wyspecjalizowany strażnik wymierza bez skrupułów trampolinę wywoławczą komendy `continue` i siłą wyrzuca proces w górę skryptu.
• Interpreter tym zgrabnym ruchem ulega celowej amnezji iteracyjnej: ignoruje po prostu WSZYSTKIE skomplikowane i zagrażające stabilności operacje znajdujące się POD trampoliną zaledwie w tym jednym, rygorystycznym i konkretnym obrocie!

pudelko = 5

while pudelko > 0:
    pudelko -= 1
    
    if pudelko == 3:
        print("[OMIJAM TRÓJKĘ!]")
        continue # Błyskawiczny skok na górę w ułamku sekundy
        
    # Ta linijka nie ma prawa bytu, jeśli pudelko to 3!
    print("Pracuję nad pudełkiem o numerze: " + str(pudelko))

print("Fabryka skończyła pracę.")
            

• Wykorzystajmy nowo nabytą ogromną, algorytmiczną potęgę skoków i przesunięć modułowych `continue` prosto we wspaniałym silniku tworzonego interaktywnego czatbota tekstowego.
• Kluczowym, zdefiniowanym zadaniem tego biznesowego bota dla firm jest rzetelne przechwytywanie i odrzucanie brzydkich, zakazanych lub wulgarnych słów przesyłanych kanałem, z użyciem bazy weryfikacyjnej w locie.
• Operacja tego dynamicznego czyszczenia strumieni znakowych musi być z rygorem wykonana stanowczo na gładko przed poddaniem ich jakiejkolwiek dalszej i cennej operacyjnie obróbce.
• Dalsza obróbka oznacza chociażby ostateczne, wieloletnie zarchiwizowanie takiego przefiltrowanego ciągu znakowego na dysku fizycznym do dużego korporacyjnego pliku bazy w formacie txt.
• Kiedy testujący system klient niefortunnie wstrzyknie na kanale niedozwolone w regułach słowo, szybki jak błyskawica bot warunkowo natychmiast skacze jak żaba na samą górę powtarzalnego pętlowego silnika logicznego.
• Wymusza w ten sposób automatycznie od interfejsu klawiatury wejście i poproszenie natarczywego klienta o kompletnie nowe wpisanie danych od początku okienka konsoli.
• Jednocześnie taki ukryty algorytm z całkowitą i celową premedytacją zapomina o zaplanowanej w głębi kodu niżej próbie trwałego uwiecznienia w bazie danych i obronie spójności twardego dysku za każdą logiczną cenę.

print("Witaj w bezpiecznym czacie!")

while True:
    wiadomosc = input("Napisz coś ('exit' aby wyjść): ")
    
    if wiadomosc == "exit":
        break # Ścięcie gilotyną zamyka czat
        
    if wiadomosc == "cholera":
        print("[OSTRZEŻENIE] Użyto słowa zabronionego!")
        continue # Odbicie z trampoliny przed ZAPISANIEM do logów na dole!
        
    # Cała logika zapisywania na dysk twardy czystych wiadomości leżałaby tutaj
    print("Pomyślnie przetworzono: " + wiadomosc)
            

• Z nową potężną i skuteczną bronią wiąże się też równie niszczycielska odpowiedzialność. Instrukcja `continue` stwarza najniebezpieczniejszą i najczęstszą w początkach nauki pułapkę dla bloku uogólnionej pętli `while`.
• Ten fatalny w architekturze, cichy błąd logiczny powszechnie nazywany jest w programistycznym żargonie u nowicjuszy okrutnym "Błędem odbicia lustrzanego" (bądź Błędem pominiętego zegara).
• Rozważ z przerażeniem następujący scenariusz: Jeśli przed samą blokadą poprawnie zadeklarujesz sobie początkową zmienną licznikową, ustalając spokojnie jej zerowy start jako wpisane po prostu `i = 0`.
• Następnie, jako sędziowski warunek cyklu, zbudujesz sztywną weryfikację do góry do nieprzekraczalnej granicy twardej w kodzie pod postacią formuły `while i < 10:`. Wewnątrz bloku ustawisz bramkę decyzyjną sprawdzającą `if i == 5:` rzucającą z woli `continue`.
• Gdy popełnisz zbrodnię na strukturze pliku i ostateczną, kluczową inkrementację podwyższającą liczydło krok po kroku (`i += 1`) rzucisz zlekceważoną NA SAMYM DOLE wcięcia poniżej ramy logiki, właśnie samodzielnie z premedytacją zbudowałeś morderczy program-kamikadze.
• Kiedy dynamiczny zegar iteracyjny `i` swoim naturalnym tokiem uderzy w ułamku sekundy w niebezpieczną wartość 5, strażnik systemu pomyśli od razu: "Ojej, to pechowa w konfiguracji magiczna liczba 5! Szybko stąd uciekajmy na trampolinę i lećmy z wiatrem do góry!".
• W wyniku skoku cały zdesperowany system programistyczny ignoruje na moment liniowy upływ powszechnego czasu. Jedzie wirtualną windą skryptu bezpośrednio do bramki Sędziego: `while 5 < 10`, od razu przechodzi zatwierdzenie Prawdy i opada z powrotem niżej.
• Spada znów powoli, dochodzi ponuro do pechowej zablokowanej bramki w bloku `if 5 == 5:` i po prostu znowu bezradnie skacze na umieszczoną tam ciągle zepsutą zablokowaną logicznie trampolinę. Powyższa fatalna seria z powtarzanego schematu będzie uderzała o te same bariery już w całkowitą i nieprzerwaną nieskończoność w czasie!
• Ta zepsuta wewnętrznie i pozostawiona na dnie skryptu pod spodem instrukcją zapory obwodów ZMIENNA czasu `i` NIGDY już nie zrobi się o punkt większa niż te ostateczne i fatalne w skutkach zablokowane zapętleniem powielania numerologiczne 5!
• Cała Pętla bezpowrotnie i stanowczo zablokuje się w zaledwie ułamku mikrosekundy i stanie twardo w jednym miejscu w czasie i przestrzeni. Zaś proces zacznie dziko uderzać w rdzeń maszyny odpalając z uporem powtarzalne żądania operacyjne w próżni i błyskawicznie pożerając całkowicie wirtualny czas rdzenia procesora.
• Twoja potężnie uszkodzona architektonicznie aplikacja kręci się na wieki sztywno i samotnie do upadku serwera operacyjnego zamknięta szczelnie w ciasnym tunelu tylko miedzy jednym logicznym IF-em oraz jedną wyjętą z kontroli bezsensowną komendą wybijania CONTINUE, w ten sposób blokując na absolutne wieki dalszy upływ czasu zegara u dołu pliku w RAM-ie!

# UWAGA: TEN KOD ZAWIESI KOMPUTER!
i = 0
while i < 10:
    if i == 5:
        continue # TRAMPOLINA UDERZA ZA SZYBKO!
    
    i += 1 # Na dole programu. Kiedy i wynosi 5, komputer już nigdy tu nie dotrze!
            

• Aby skutecznie i niezwykle szybko wyleczyć zablokowaną w swoim obrocie maszynę z błędu przedstawionego i opisanego wyraźnie na poprzednim fatalnym slajdzie, doświadczony Inżynier posiada konkretne algorytmiczne narzędzia do naprawy.
• Istnieją w gruncie rygorystycznych rozwiązań dokładnie dwa powszechne, bezpieczne i stosowane powszechnie w korporacjach wyjścia, wynikające logicznie i wprost ze znajomości zaawansowanej wiedzy na temat działania i wpływu zjawiska wcięć składni.
• Radykalne Podejście numer 1: Jako architekt oprogramowania umieść po prostu najważniejszą operacyjną instrukcję czasową napędzającą `i += 1` odważnie i ryzykownie w samej początkowej architekturze, jeszcze NA CAŁKIEM SAMYM SZCZYCIE głównego otwieranego operacyjnie bloku silnika i wcięć komendy `while`.
• Dzięki przeniesieniu inkrementacji licznika na sam początek ciała pętli (zaraz po słowie kluczowym `while`), jest on zwiększany w każdym obrocie, zanim program dotrze do instrukcji warunkowych `if` i ewentualnego skoku `continue`.
• W ten sposób unikamy zablokowania pętli, ponieważ zmiana stanu licznika następuje niezależnie od późniejszego awaryjnego powrotu na górę za pomocą trampoliny `continue`.
• Awaryjne Podejście numer 2: (Stosowane powszechnie jako łata i łatwy trik w kodzie jeśli precyzyjne serce aplikacji oraz zegar upływu `i` nie może z twardych względów biznesowych i uwarunkowań wzoru matematycznego z natury absolutnie rosnąć w nieskończoność zaraz na szczycie przy bramie wejściowej po odpaleniu pętli).
• W tej drugiej specyficznej i niepożądanej technicznie sytuacji wymuszonej ułomnością kodu: Wstaw proste, szybkie i operacyjnie zwinne malutkie awaryjne brudne rozwiązanie polecenia matematycznego popychającego licznik `i += 1` GŁĘBOKO DO SAMEGO WNĘTRZA ukrytej groty, w szczeliny operacyjne i łapy wewnętrzne zagnieżdżonego strażnika bezpieczeństwa blokowego systemu zapory `if`.
• Ta rzucona zapasowa mikrozapora matematyczna popchnie awaryjnie maszynę dosłownie ułamek jednej linijki i milisekundę szybciej przed brutalnym wybiciem i zmasakrowaniem i przerwaniem struktury upływu czasu wyrzuconym bezwzględnie rzuconym awaryjnie lotem do niebios warunkowych wykonanym gwałtownie w przód rzuconym obrotem z wbudowaną i uderzającą zapasową mocą poprzez zrzuconą instrukcję i trampolinę `continue`!

# Bezpieczny projekt z awaryjnym popchnięciem
i = 0
while i < 10:
    if i == 5:
        i += 1 # Ratunkowe wepchnięcie licznika na poziom 6!
        print("[Omijam piątkę i skaczę dalej]")
        continue # Teraz skaczemy, a na górze sędzia widzi 6. Problem rozwiązany!
    
    print("Bezpieczne wykonanie logiki dla i = " + str(i))
    i += 1 # Naturalne pchanie czasu (dla każdego innego obrotu oprócz 5)
            

• Podsumowując zjawiska awaryjnych wyjść z pętli, ustaliliśmy bezpowrotnie fakt, że współcześni programiści systemowi nie tylko tworzą potężne obroty, ale muszą nad nimi bezwzględnie panować.
• Najważniejszą linią obrony przed wymykającym się spod kontroli chaosem oprogramowania są rygorystyczne instrukcje ucieczki, odpalane warunkowo ze środka wirnika.
• Niszczycielskie polecenie `break` to odpowiednik wielkiego, czerwonego przycisku awaryjnego na hali produkcyjnej.
• Pociągnij ten przycisk odważnie, a cała pętla natychmiast ulega twardemu zatrzymaniu, niezależnie od stanu, spuszczając bezpiecznie proces na dół skryptu.
• Używamy tej bezkompromisowej metody gilotyny, gdy odnaleźliśmy docelowy wynik operacji, lub gdy wystąpił tak krytyczny błąd, że jakikolwiek dalszy obrót traci inżynieryjny sens.
• Z kolei instrukcja `continue` to potężny mechanizm sortujący. Działa jak zapadnia usuwająca zniszczoną część z taśmy montażowej z powrotem na górę do interpretera.
• Pociągnij trampolinę, a pojedynczy wadliwy obieg zostanie zniszczony i ominięty, ale sama pętla będzie pracować nadal i kręcić się niezachwiana na bezpiecznych obrotach.

• Czy wiedziałeś, że w potężnej architekturze Pythona słowo `else` nie jest zarezerwowane wyłącznie dla klasycznych instrukcji warunkowych IF?
• Python posiada wysoce unikatowy twór architektoniczny, który ułatwia procesowanie baz: Pętlę Z Klauzulą Końcową.
• Dzięki temu mechanizmowi, możesz bez obaw przykleić na poziomie głównego wcięcia słowo `else:` dokładnie tam, gdzie gaśnie blok `while`!
• Po co mielibyśmy konstruować tak nietypowy i na pozór dziwny system przepływu instrukcji?
• Zastosowanie zyskuje sens operacyjny, gdy uznamy, że pętla `while` dostaje w ten sposób swoją całkowicie dedykowaną linijkę na pożegnanie z interpreterem.
• Jest to wspaniała okazja na zorganizowanie bankietu pożegnalnego lub wygenerowanie ostatecznego raportu w systemie, zaraz po całkowitym przetworzeniu zadania.

# Połączenie while oraz else!
i = 0
while i < 3:
    print("Obrót nr: " + str(i))
    i += 1
else:
    # Ten blok wykonuje się jako ostatnie tchnienie kodu po pętli.
    print("Silnik zagasł naturalnie po wykonaniu wszystkich przelotów.")
            

• Zastanówmy się analitycznie, dlaczego inżynier IT miałby używać bloku `else` zamiast po prostu dopisać instrukcję `print` na tej samej szerokości wcięcia, ale już pod pętlą?
• Sekret działania systemu leży w rygorystycznej mechanice wewnętrznego wyzwalania bloku `else` przez sędziego.
• Zostanie on wyzwolony TYLKO I WYŁĄCZNIE WTEDY, gdy pracująca pętla umarła i zakończyła się całkowicie naturalnie z braku tlenu.
• Oznacza to moment, w którym obiektywny sędzia na samej górze cyklu wydał ostateczny wyrok `False` dla ewaluowanego warunku operacyjnego.
• Jeśli pętla wykona milion rzetelnych obrotów i naturalnie wyczerpie swój licznik schodząc do poziomu akceptacji, uruchamia pożegnanie z bloku `else`.
• Wybuchnie on na końcu jak wspaniałe fajerwerki komunikujące jasny przekaz dla inżyniera: "Wszystkie zadeklarowane obroty zrobione, zadanie wykonane z godnością w 100%!".

zadania = 2

while zadania > 0:
    print("Pracuję... zostało: " + str(zadania))
    zadania -= 1
else:
    # Wydrukuje się, bo zadania naturalnie dobiły do 0 u sędziego.
    print("[RAPORT KOŃCOWY] Pomyślnie zrobiono 100% obrotów. Bez awarii.")
            

• Tutaj wkracza wreszcie prawdziwa, nieskazitelna logika znana doświadczonym architektom oprogramowania. Co w systemie stanie się, jeśli pętla zostanie brutalnie uśmiercona przed swoim czasem?
• Zastanów się: Co jeśli cała iteracyjna Pętla zostanie od wewnątrz celowo roztrzaskana użyciem ratunkowej gilotyny `break`?
• Odpowiedź interpretera jest bezkompromisowa i ostateczna: Blok `else` całkowicie ZNIKA z drogi uruchomienia.
• Zostaje natychmiast, świadomie i precyzyjnie ominięty - absolutnie nie wykona się z niego ani jedna ratunkowa linijka raportu końcowego!
• To bezwzględne zjawisko czyni z operacyjnej konstrukcji `while... else` wręcz wspaniały mechanizm do obsługi wszelkich algorytmów przeszukujących wielkie bazy.
• Logika to: "Szukaj wirusa, i jeśli go znalazłeś, użyj break, by uciec na zewnątrz, uciszając radosny blok else, ALE jeśli przez miliony prób go nie było, niech else potwierdzi 100% czystość systemu!".

i = 0
while i < 5:
    i += 1
    if i == 3:
        print("Błąd krytyczny na obrocie 3. Odcinam zasilanie (BREAK)!")
        break
else:
    # Ta linijka NIGDY się nie uaktywni, bo pętla uległa zniszczeniu od środka!
    print("Zakończono sukcesem w 100%.")
            

• Na sam koniec spójrzmy na potężną i przemyślaną inżynieryjnie strukturę `while... else` celowo wdrożoną w symulowanym, inteligentnym systemie ochrony przed cyberatakami.
• Nasz uroczy i skuteczny nowo zaprogramowany antywirus iteracyjnie sprawdza bazę, badając rygorystycznie plik po pliku ze złącza internetowego pod kątem wejścia obcych sygnatur.
• Dla celów testowych wykorzystaliśmy silnik `random`, wprowadzając element niespodziewanego losowania, by imitować ukryte infekcje wirusowe atakujące z ukrycia interpreter.
• Zasada działania opiera się na wybitnym bezpieczniku: Jeśli w trakcie skanowania nagle padnie fatalna liczba z sygnaturą wirusa - system awaryjnie wzywa ostrze `break`.
• Po udanym uderzeniu gilotyny we wcięcie uszkodzona pętla operacyjna zostaje natychmiast rozszarpana i dezaktywowana, a ukryty na jej końcu świetlisty i wesoły raport z bloku `else` - wyciszony!
• Z kolei jeśli w ciągu wyznaczonych prób testowych żaden intruz z sieci nie zostanie wpuszczony, bezpieczna pętla po cichu wygasa, oddając stery chwalebnemu blokowi `else` drukującemu wielki raport.

import random
plik_id = 1

print("Rozpoczęto skanowanie partycji C:")

while plik_id <= 5:
    kod = random.randint(1, 20) # Analiza behawioralna od 1 do 20
    print("Skanuję plik nr: " + str(plik_id) + " (Kod: " + str(kod) + ")")
    
    if kod == 13:
        print("[ALARM] WYKRYTO TROJANA! Gilotyna odcina program!")
        break # ZERWANIE PROCESU. Brak skanowania dalszych plików.
        
    plik_id += 1
else:
    # Cudowne zwieńczenie czystego przebiegu!
    print("\n[CERTYFIKAT] Komputer czysty! Skanowanie w 100% udane.")
            

• Najwyższy poziom kontroli nad algorytmami to Zagnieżdżanie (Nesting).
• W Pythonie potrafisz już wstawić instrukcję warunkową `if` do wewnątrz pętli.
• Jednak inżynieria pozwala pójść znacznie dalej: możesz wstawić całą nową Pętlę do absolutnego wnętrza innej Pętli.
• Zasada działania opiera się na mechanice zębatek. Pętla Zewnętrzna obraca się bardzo powoli.
• Wewnętrzna za to obraca się szaleńczo szybko, wykonując kompletną pracę na KAŻDY jeden obrót swojego zewnętrznego rodzica.
• Jeśli silnik z góry nakazuje 3 wielkie obroty, a ten w środku ma przypisane 5 szybkich iteracji...
• Serce serwera w dolnym wcięciu odnotuje łącznie aż 15 zrealizowanych na twardo operacji.

• Zobrazujmy zjawisko zagnieżdżenia za pomocą fizycznego mechanizmu znanego z Twojego własnego nadgarstka - obwodów zegarka.
• Wskazówki obracają się w ułożonych systematycznie kołach zębatych, jedno zawsze zamknięte precyzyjnie w obwodzie drugiego.
• Pętla godzin u samej góry (zewnętrzna obręcz) jest ociężała i porusza się w systemie ledwie zauważalnie dla procesora.
• Aby ostatecznie i definitywnie przeskoczyć naprzód o zaledwie jedną dużą godzinę, zmuszona jest do cierpliwości i uśpienia.
• Czeka ona twardo w napięciu na szybką podległą Pętlę minut (znajdującą się architektonicznie we wcięciu z boku obwodu).
• Główny pierścień puści o jeden krok proces do przodu u dołu, dopiero gdy wewnętrzna minuta przetnie swoje szaleńcze, wymagane logiką 60 obrotów.

godzina = 0

while godzina < 3: # Zewnętrzny obrót powolny (3 razy)
    minuta = 0 # Wyzerowanie minuty PRZED wejściem do małej pętli!
    
    while minuta < 60: # Wewnętrzny obrót szybki
        print("Jest " + str(godzina) + ":" + str(minuta))
        minuta += 1 # Popychamy wskazówkę minutową
        
    # Tutaj maszyna wypada po zrobieniu 60 minut! Skacze powiększyć godzinę!
    godzina += 1
            

• Połączenie potęgi rzutowanych obrotów warunkowych i twardych bramek decyzyjnych to samo bijące serce prawdziwej analityki danych.
• Zbudujemy w terminalu maszynę analizującą, która w swojej konstrukcji iteracyjnie pyta i pobiera losowe dane od zwykłego klienta.
• Jednak z setek podanych zmiennych, skrypt musi ostatecznie wyciągnąć i zamrozić tylko jedną: wartość o największej wartości arytmetycznej.
• W inżynierii programowania tworzymy przed całym wirem pudełko z pozycją startową (np. deklarując zmienną z przypisanym twardym zerem).
• Rozpoczyna się masowe kręcenie pętli, z każdą nową iteracją system zachłannie wrzuca nowy ciężar zgłoszony przez wpis z klawiatury użytkownika na wagę.
• Zagnieżdżony strażnik IF ocenia wynik z góry: "Jeżeli dopiero wpisana wartość jest mierzalnie cięższa od tej zamkniętej w uśpionym pudełku, zniszcz starą cyfrę i zachowaj do logiki wyłącznie nową!".

print("Wpisuj liczby. 0 przerywa proces.")
najwieksza = 0 # Pudełko Króla

while True:
    wpisana = int(input("Podaj liczbę (0 by wyjść): "))
    
    if wpisana == 0:
        break # Wyjście awaryjne na komendę
        
    # Weryfikacja Siły nowej liczby
    if wpisana > najwieksza:
        najwieksza = wpisana # Detronizacja! Mamy nowego Lidera.

print("[WYNIK] Najpotężniejszą ze wpisanych liczb była: " + str(najwieksza))
            

• Podobny w schemacie projektowym mechanizm pamięciowy służy branży bezpieczeństwa w korporacjach do łapania groźnych incydentów w bazach.
• Opracujemy algorytm weryfikujący ostatecznie, czy jakakolwiek jednostka wpisana nagle w wielką sieć rzutowaną na chmurę stanowi słowo zakazane i objęte cenzurą.
• Przed włączeniem silnika powtarzalności ustalamy awaryjną flagę z naiwnym, optymistycznym założeniem startowym: `korki_wybite = False`. Świat pozostaje bezpieczny.
• Uruchamiamy setki szybkich wirtualnych obrotów, sprawdzających po jednym zgłoszonym zdaniu na raz strażnikiem warunkowym w locie.
• Jeżeli ktokolwiek w procesie zarzuci niszczące zasady brzydkie hasło, strażnik jednym rygorystycznym uderzeniem logiki przebija cichy bezpiecznik alarmowy: `korki_wybite = True`.
• Nawet jeżeli potem przez sieć przejdzie nienaruszone sto pięknych i poprawnych komunikatów powitalnych od klientów, po śmierci pętli alarm pozostanie wyrwany, a cała sesja definitywnie zgłosi nieodwracalną i stanowczą awarię.

korki_wybite = False
i = 0
while i < 3:
    stan_maszyny = input("Podaj temperaturę dysku nr " + str(i) + ": ")
    if int(stan_maszyny) > 100:
        korki_wybite = True # Zarejestrowano niebezpieczeństwo na zawsze!
    i += 1

# Koniec pętli. Sędzia ogląda korki.
if korki_wybite:
    print("EWAKUACJA! Przynajmniej jeden dysk płonie!")
            

• Budowanie złożonych i interaktywnych programów biznesowych niemal zawsze opiera się na wielopoziomowych pętlach sterujących oknami.
• Najwyższa, pracująca ciągle w tle Pętla Zewnętrzna, odgrywa dla użytkownika prestiżową rolę Menu Głównego systemu.
• Z niej klient dokonuje strategicznego wyboru i gładko przeskakuje pod komendy do rozbudowanych modułów pomocniczych za pomocą wewnętrznych cykli wcinających ekran.
• Pojawia się tu niestety rygorystyczny i niebezpieczny problem z zamknięciem procedur w całości: gilotyna awaryjna `break` niszczy zawsze wyłącznie jedno najniższe okno pętli, podnosząc program na kolejny pod-poziom wzwyż.
• Odpalenie klasycznego `break` gdzieś w środku wewnętrznego sub-menu wyrzuci nas tylko twardo do tyłu, zmuszając interfejs do ponownego wymalowania nadrzędnego ekranu bazowego.
• Aby ostatecznie, awaryjnie i bezpiecznie ubić program z dowolnego zakopania proceduralnego w drzewie zagmatwanych pętli i wyjść cicho do widoku pulpitu Windowsa, uderz z całą mocą biblioteczną, podpinając system z impetem rozkazem wyrzutowym `sys.exit()`.

import sys

gra_trwa = True

while gra_trwa: # Menu Główne
    print("Witaj w grze. 1-Opcje, 0-Wyjście")
    komenda = input()
    if komenda == "0":
        break
    if komenda == "1":
        
        while True: # Pod-Menu Opcji
            print("Zmieniasz opcje. Wcisnij 0 by wrócic do menu głównego!")
            opcja = input()
            if opcja == "0":
                break # Break tu wyrzuca gracza z powrotem do ekranu 'Witaj w grze'
            elif opcja == "9":
                sys.exit() # JEDYNE rozsądne zniszczenie by wyjść całkiem
            

• Złota zasada Architektów Seniorów brzmi jasno i twardo: Zagnieżdżaj swoją logikę operacyjną maksymalnie do dwóch, góra trzech bezpiecznych poziomów.
• Jeśli kiedykolwiek zobaczysz w swoim pliku 16 fizycznych spacji wcięcia (np. dla małej instrukcji `if` wciśniętej wewnątrz wielkiej pętli `while`, z kolei uwięzionej wewnątrz innej pętli)... popełniłeś śmiertelny błąd.
• Taka okropna i nielogiczna pajęczyna strukturalna znana jest w inżynierii jako "Zupa Spaghetti".
• Zupa Spaghetti jest kodem z natury absolutnie niemożliwym do debugowania przez drugiego członka zespołu.
• Jeżeli w tak głębokim zagnieżdżeniu nieoczekiwanie wybuchnie zablokowana pętla nieskończona pożerająca RAM, nie zorientujesz się nawet, z którego dokładnie poziomu wcięcia maszyna została zawieszona na stałe!
• Profesjonalna Rada Projektowa: Wyciskaj zawsze całe te grube, powtarzalne warstwy algorytmu wprost do izolowanych Funkcji (`def`), które szczegółowo poznasz i opanujesz już wkrótce!
• Wtedy w Twojej schludnej Pętli Głównej będziesz tylko wywoływał proste, czytelne jak poezja słowa ludzkich komend, jak eleganckie `uruchom_menu()`, które hermetycznie zamkną w sobie cały ten operacyjny brud.

• Najbardziej popularne i doceniane komercyjnie zastosowanie pętli `while True:` w bankowości to potężna i niezawodna walidacja typu dla klienta.
• Polega to na ciągłym i nieustępliwym sprawdzaniu wpisywanych surowo danych, po to by upewnić się, czy dany wirtualny użytkownik zachował się formalnie poprawnie na oknie.
• Zrozum problem: Jeśli poprosisz twardo programem np. o liczbowy wiek rzutując przez `int(input())`, a użytkownik dla żartu wpisze słowo "Ziemniak" - system wysadzi czerwony błąd `ValueError` i po prostu żałośnie zgaśnie.
• Zbudujmy więc wspólnie odpornego Inspektora Danych! Pętla pyta użytkownika o jakikolwiek uformowany napis, pobierając surowego str.
• Twardy strażnik iteracyjny ocenia następnie bez sentymentów, czy cały podany ciąg ułożony z liter JEST w ogóle w pełni ułożony z CYFR, używając wbudowanej metody narzędziowej `.isdigit()`.
• Dopóki w wyniku poprawnej cyfrowej oceny sędzia nie wyzwoli w końcu zwalniającego ostrza komendy `break`...
• Inspektor nigdy, za żadne skarby nie przepuści Twojego klienta fizycznie do następnej klatki kodu, iteracyjnie i bezlitośnie nękając go w oknie o poprawność wpisu!

while True:
    wiek_string = input("Wpisz swój wiek liczbowo: ")
    
    # isdigit sprawdza, czy wszystkie znaki w napisie to cyfry 0-9
    if wiek_string.isdigit():
        wiek_poprawny = int(wiek_string) # TERAZ BEZPIECZNIE RZUTUJEMY!
        break # Gilotyna przepuszcza nas poza kontrolę dokumentów!
    else:
        print("BŁĄD! Wpisano litery. Musisz wpisać liczbę całkowitą.")

print("Użytkownik zalogowany. Potwierdzony wiek w bazie: " + str(wiek_poprawny))
            

• Na mały deser u samej mety przed finałem projektu wstrzykniemy w ramy pętli `while` potężny symbol specjalny ukrytej karetki wydruku, od dawna wbudowany w terminal.
• Symbolem sterującym fizycznie wyświetlaniem czarnej i sztywnej zwykle konsoli jest `\r` (z języka starodawnych maszyn jako Powrót Karetki - Return).
• Spróbuj teraz gładko wydrukować jakikolwiek napis, dołączając to zjawiskowe `\r` fizycznie na samym początku łańcucha jako pierwszą literę wewnątrz wcięcia cyklicznego.
• Następnie, połączysz tę sztuczkę mechaniczną z całkowitym uciszeniem i stanowczym zablokowaniem automatycznego i natywnego przechodzenia do nowej linii za pomocą modyfikatora `end=""`.
• W wyniku tej magii konsoli, wiersz zostanie bezpowrotnie i twardo skasowany w pamięci graficznej, a nadrukowany i zastąpiony całkowicie przez wypluty za pomocą funkcji `print` nowy napis z wcięcia.
• Osiągniesz w ten prosty algorytmiczny sposób spektakularną, czystą ANIMACJĘ TEKSTU kręcącą się szybko w stałym, jednym wierszu! Pętla ożywi Twój martwy terminal i zamieni w film akcji.

import time

czas = 5
while czas > 0:
    # \r wraca kursor na początek Omijając ENTER (end="") !
    print("\rOdliczanie do startu: " + str(czas) + " ", end="")
    time.sleep(1)
    czas -= 1

print("\n[START!]") # \n na początku niszczy uwięzienie!
            

• Nadszedł czas, aby wykorzystać całą zebraną architektoniczną wiedzę i zbudować autoryzacyjną maszynę z realnego świata bankowości.
• Wymóg biznesowy jest prosty, lecz surowy: wkładający kartę klient ma maksymalnie 3 bezpieczne próby na poprawne wprowadzenie PIN-u.
• Konstruujemy przed pętlą zegar zjazdowy odliczający próby w dół, a w samym wcięciu umieszczamy silnych, warunkowych strażników wejścia `if`.
• Gdy system wykryje w końcu właściwe numery przypisane w logice do konta z wirtualnej klawiatury użytkownika - natychmiast odpalamy ostrze `break` na dowód uiszczenia autoryzacji.
• Skutecznie ścina to zabezpieczenia obrotowe po poprawnym haśle, niszczy pętlę ochronną i ostatecznie przepuszcza zadowolonego klienta niżej w głąb programu.
• Natomiast jeśli użytkownik zawiedzie aż trzy razy, i naturalnie wykrwawi logikę prób zjazdowo do twardego zera - elegancki, wydzielony blok `else` na dole wyda fatalny raport: "Karta zablokowana!".

proby = 3
poprawny_pin = "9999"

print("Proszę wsunąć kartę (Symulacja Banku).")

while proby > 0:
    wpisany = input("Podaj PIN (" + str(proby) + " prób zostało): ")
    
    if wpisany == poprawny_pin:
        print("[ZALOGOWANO POMYŚLNIE]")
        break # Odcinamy usterkę awaryjnym hamulcem i omijamy else
        
    print("Błędny PIN!")
    proby -= 1
else:
    # Wykona się TYLKO gdy wyczerpie się 3 (czyli break nas nie uratował)
    print("ZBYT WIELE BŁĘDNYCH PRÓB. KARTA ZABLOKOWANA!")
            

• Oto ostateczny i spektakularny wielki finał dla całego tego modułu - projekt łączący całą wiedzę z pętli w miniaturową, interaktywną Grę RPG!
• Z pewnością siebie wykorzystamy pętlę nieskończoną `while True:` do wykreowania na wirtualnym terminalu brutalnego pola walki pomiędzy graczem a orkiem.
• Każdy pojedynczy, wymuszony poleceniem `input()` obrót skryptu operacyjnie reprezentuje jedną napiętą wymianę ciosów i zdefiniowaną rundę w potyczce.
• Obrażenia, na które obie cyfrowe strony są wzajemnie narażone, są wyliczane i symulowane twardo w każdym wcięciu przez potężny i dynamiczny silnik losowości `random`.
• Z kolei cała gra ulega awaryjnemu, uwarunkowanemu w kodzie zakończeniu całkowicie automatycznie i błyskawicznie w momencie tego nieszczęsnego obrotu, w którym...
• Któremukolwiek z wyczerpanych matematycznie dwóch dzielnych wojowników pasek zmiennej przypisanej do jego wirtualnego zdrowia spadnie tragicznie grubo poniżej progu twardego zera!

import time, random
hp_bohatera = 100
hp_orka = 50

print("--- ARENA ZBLIŻA SIĘ WIELKIMI KROKAMI ---")
while True:
    print("Stan: [TY]: " + str(hp_bohatera) + " HP | [ORK]: " + str(hp_orka) + " HP")
    input("[Wciśnij ENTER aby uderzyć...]")
    
    cios_ty = random.randint(10, 25)
    hp_orka -= cios_ty
    print("-> Uderzasz z potęgą " + str(cios_ty) + " punktów!")
    if hp_orka <= 0:
        print("!!! ZWYCIĘSTWO! Ork upada na piach.")
        break
        
    cios_ork = random.randint(5, 20)
    hp_bohatera -= cios_ork
    print("<- Ork kontratakuje za " + str(cios_ork) + " punktów!")
    if hp_bohatera <= 0:
        print("!!! PRZEGRAŁEŚ. Widzisz napis 'GAME OVER'.")
        break