Lidsky řečeno
Polévku solíš po troškách: ochutnáš, a dokud je mdlá, přisolíš a znovu ochutnáš. Předem nevíš, kolikrát to bude. Víš jen, kdy přestat. Přesně to dělá while, česky „dokud“: zeptá se, udělá práci, a znovu se zeptá.
Dokud platí podmínka
while se píše jako if: podmínka, dvojtečka, odsazený blok. Rozdíl je v tom, co se stane po dokončení bloku. if jde dál, while se vrátí nahoru a ptá se znovu. Jednomu průchodu blokem se říká kolo nebo iterace.
n = 3
while n > 0:
print(n)
n = n - 1
print("Start!")
3 2 1 Start!
Nejlíp se cyklus čte, když si ho krokuješ na papír a každé kolo zapíšeš do tabulky:
| Kolo | n při kontrole | n > 0 | Vypíše | n po kole |
|---|---|---|---|---|
| 1 | 3 | True | 3 | 2 |
| 2 | 2 | True | 2 | 1 |
| 3 | 1 | True | 1 | 0 |
| konec | 0 | False | nic, jde se za cyklus | 0 |
Dvě věci stojí za povšimnutí. Podmínka se kontroluje před každým kolem, takže když neplatí hned napoprvé, blok neproběhne ani jednou. A kontroluje se jen tam nahoře: když n klesne na nulu uprostřed bloku, zbytek bloku se ještě dokončí.
Zápis n = n - 1 je tak častý, že má zkratku n -= 1. Stejně fungují +=, *= a //=.
Počítadlo a střádač
Většina cyklů stojí na dvou proměnných. Počítadlo říká, kde právě jsi. Střádač postupně sbírá výsledek a před cyklem začíná na nule.
i = 1
soucet = 0
while i <= 4:
soucet += i
i += 1
print("Součet:", soucet)
Součet: 10
| Kolo | i při kontrole | i <= 4 | soucet po kole | i po kole |
|---|---|---|---|---|
| 1 | 1 | True | 1 | 2 |
| 2 | 2 | True | 3 | 3 |
| 3 | 3 | True | 6 | 4 |
| 4 | 4 | True | 10 | 5 |
| konec | 5 | False | 10 | 5 |
Všimni si, že po skončení je i rovno 5, tedy o jedna víc než poslední sečtené číslo. Cyklus končí právě proto, že podmínka přestala platit.
Součet sudých čísel
Pomocí while sečti všechna sudá čísla od 2 do 100 včetně. Výsledek má být v proměnné soucet.
n = 2
soucet = 0
# doplň cyklus
Když cyklus neskončí
Cyklus skončí jen tehdy, když podmínka přestane platit. A to se musí nějak stát uvnitř bloku. Tenhle kód poběží navždy, proto ho tu jen ukazujeme:
n = 3
while n > 0:
print(n)
# chybí n -= 1, takže n zůstává 3Takovému cyklu se říká nekonečný. V terminálu ho zastavíš klávesami Ctrl+C. Než cyklus spustíš, polož si dvě otázky: co se v každém kole mění a proč se tím jednou podmínka poruší?
Druhá varianta je zrádnější. Hodnota se mění, ale hranici přeskočí:
n = 5
while n != 0: # 5, 3, 1, -1, -3 ... nula nikdy nepřijde
n -= 2Pomůže podmínka s nerovností: while n > 0 skončí, i když se trefa na nulu nepovede. Totéž platí pro desetinná čísla, kde se navíc sčítá zaokrouhlovací chyba. Tenhle cyklus vypadá na deset kol:
x = 0.0
kola = 0
while x < 1.0:
x += 0.1
kola += 1
print(kola)
print(x)
11 1.0999999999999999
Po deseti přičteních je x kousek pod jedničkou, takže proběhne ještě jedenácté kolo. Když potřebuješ přesný počet opakování, počítej celými čísly.
Kolikrát proběhne blok? n = 10, while n > 0:, v bloku n -= 3.
n při kontrolách: 10, 7, 4, 1, a pak -2, kdy už podmínka neplatí. Čtyři kola.
Co udělá n = 1, while n != 10:, v bloku n += 2?
n je pořád liché: 1, 3, 5, 7, 9, 11 a dál. Desítku přeskočí a != platí navždy. Pomohlo by while n < 10.
Neznámý počet kroků
Silná stránka while je práce, u které předem nevíš, kolik kol zabere. Kolikrát se dá číslo přepůlit, než klesne na jedničku?
cislo = 100
kroky = 0
while cislo > 1:
cislo //= 2
kroky += 1
print("Kroků:", kroky)
Kroků: 6
| Kolo | cislo před kolem | cislo po kole | kroky |
|---|---|---|---|
| 1 | 100 | 50 | 1 |
| 2 | 50 | 25 | 2 |
| 3 | 25 | 12 | 3 |
| 4 | 12 | 6 | 4 |
| 5 | 6 | 3 | 5 |
| 6 | 3 | 1 | 6 |
Z milionu by to bylo jen 19 kroků. Na tomhle rychlém zmenšování stojí hledání v seřazených datech, ještě se k němu dostaneš.
Stejný vzor rozebere číslo na cifry. % 10 dá poslední cifru a // 10 ji odřízne.
cislo = 4072
soucet = 0
while cislo > 0:
soucet += cislo % 10
cislo //= 10
print("Ciferný součet:", soucet)
Ciferný součet: 13
| Kolo | cislo | cislo % 10 | soucet po kole | cislo po kole |
|---|---|---|---|---|
| 1 | 4072 | 2 | 2 | 407 |
| 2 | 407 | 7 | 9 | 40 |
| 3 | 40 | 0 | 9 | 4 |
| 4 | 4 | 4 | 13 | 0 |
Collatzova posloupnost
Vezmi číslo n. Je-li sudé, vyděl ho dvěma. Je-li liché, vynásob ho třemi a přičti 1. Opakuj, dokud není n rovno 1, a do kroky započítej každou provedenou úpravu.
n = 27
kroky = 0
# doplň cyklus
Přestupné roky
Spočítej přestupné roky od 1890 do 2010 včetně a výsledek ulož do pocet. Rok je přestupný, když je dělitelný 4, ale není dělitelný 100. Výjimka: roky dělitelné 400 přestupné jsou.
rok = 1890
pocet = 0
# doplň cyklus
Cyklus řízený člověkem
Při čtení vstupu nevíš, co a kolikrát člověk zadá. Tady má while domov. Dvě podmínky spojené přes and omezí počet pokusů.
tajne = "sezame"
zadano = ""
pokusy = 0
while zadano != tajne and pokusy < 3:
zadano = input()
pokusy += 1
print("Pokus", pokusy)
if zadano == tajne:
print("Vítej.")
else:
print("Účet zamčen.")
Pokus 1 Pokus 2 Pokus 3 Vítej.
| Kontrola | zadano | pokusy | Podmínka cyklu |
|---|---|---|---|
| 1 | "" | 0 | True |
| 2 | "kocka" | 1 | True |
| 3 | "heslo123" | 2 | True |
| 4 | "sezame" | 3 | False |
Prázdný text na začátku je jen startovní hodnota, díky které se cyklus vůbec rozběhne. Podmínka za ním neříká, proč skončil, proto se na to ptá if pod cyklem.
Druhý vzor: čti hodnoty, dokud nepřijde domluvené slovo, kterému se říká zarážka. Vstup se čte na dvou místech, před cyklem a na konci bloku.
soucet = 0
vstup = input()
while vstup != "konec":
soucet += int(vstup)
vstup = input()
print("Součet:", soucet)
Součet: 245
Bankomat
Na účtu je 1000 Kč. Program čte částky, dokud nepřijde 0. Pro každou částku vypíše jeden řádek:
- není násobkem 100:
Neplatná částka - je vyšší než zůstatek:
Nedostatek peněz - jinak ji odečte a vypíše
Vydáno, zůstatek X, kde X je nový zůstatek
Do input() nepiš žádný text.
zustatek = 1000
castka = int(input())
# doplň cyklus
Pod kapotou · smyčka v CPythonu
Překladač 3.12 smyčku invertuje: podmínka je v bytecode dvakrát, jednou při vstupu a podruhé na konci těla, kde za ní následuje JUMP_BACKWARD. Ověříš si to přes dis.dis. Zpětný skok je zároveň místo, kde interpret kontroluje tzv. eval breaker, tedy čekající signály a žádost o předání GIL. Proto Ctrl+C přeruší i while True: pass. Dlouhé volání v C, třeba výpočet s obřími celými čísly, se ale přerušit nenechá, dokud nedoběhne.
Výkon: na úrovni modulu se proměnné hledají přes slovník (LOAD_NAME), ve funkci přes pole (LOAD_FAST), takže stejná smyčka ve funkci běží rychleji. Adaptivní interpret (PEP 659) specializuje operace na konkrétní typy a for nad range má navíc vlastní rychlou instrukci. Počítanou smyčku proto piš přes for, while nech na podmínky.
int nemá pevnou šířku, takže nepřeteče. Smyčka while n > 0: n += 1, která by v C dřív nebo později skončila přetečením, tu poběží, dokud ji nezastavíš, a čísla budou jen růst.
Pozor na akumulaci floatů. sum od verze 3.12 používá kompenzované sčítání, takže sum([0.1] * 10) dá 1.0, ale ruční x += 0.1 dá 0.9999999999999999. Stabilnější je odvozovat hodnotu z celočíselného čítače: x = i * krok.
Pod kapotou · ukončení a čekání v produkci
Správnost smyčky se dokazuje dvěma věcmi: invariantem (co platí na začátku každého kola) a variantem (nezáporná veličina, která v každém kole klesá). U Collatzovy posloupnosti variant nikdo nezná a její ukončení pro všechna čísla je otevřený problém. Obecně je otázka ukončení nerozhodnutelná (halting problem), takže to za tebe žádný nástroj spolehlivě nevyřeší.
Python nemá do ... while, návrh PEP 315 byl zamítnut. Stejný efekt dá while True s break, který přijde v další části kurzu. Duplicitní čtení vstupu odstraní výraz s přiřazením z PEP 572:
soucet = 0
while (vstup := input()) != "konec":
soucet += int(vstup)
print(soucet)
200
Čekání na službu nikdy nepiš jako prázdnou smyčku, která spálí celé jádro. Potřebuje pauzu, exponenciální odstup, náhodný rozptyl proti synchronizovaným náporům a tvrdý limit. Pro měření doby použij time.monotonic, protože time.time se může při úpravě systémových hodin posunout.
import random
import time
deadline = time.monotonic() + 30
delay = 0.1
while not service_ready():
if time.monotonic() >= deadline:
raise TimeoutError("service did not start")
time.sleep(delay + random.uniform(0, delay))
delay = min(delay * 2, 5)