0 dní v řadě · 0 bodů

Rozhodování a cykly · 20 min

Cyklus while

Program začne opakovat práci, dokud platí podmínka. Budeš krokovat cykly v tabulkách a naučíš se poznat ty, co nikdy neskončí.

Hloubka
Úkoly
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!")
Výstup
3
2
1
Start!

Nejlíp se cyklus čte, když si ho krokuješ na papír a každé kolo zapíšeš do tabulky:

Kolon při kontrolen > 0Vypíšen po kole
13True32
22True21
31True10
konec0Falsenic, jde se za cyklus0

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)
Výstup
Součet: 10
Koloi při kontrolei <= 4soucet po kolei po kole
11True12
22True33
33True64
44True105
konec5False105

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.

Úkol

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
Výstup

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:

python
n = 3
while n > 0:
    print(n)
    # chybí n -= 1, takže n zůstává 3

Takové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čí:

python
n = 5
while n != 0:     # 5, 3, 1, -1, -3 ... nula nikdy nepřijde
    n -= 2

Pomůž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)
Výstup
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.

Kvíz

Kolikrát proběhne blok? n = 10, while n > 0:, v bloku n -= 3.

Kvíz

Co udělá n = 1, while n != 10:, v bloku n += 2?

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)
Výstup
Kroků: 6
Kolocislo před kolemcislo po kolekroky
1100501
250252
325123
41264
5635
6316

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)
Výstup
Ciferný součet: 13
Kolocislocislo % 10soucet po kolecislo po kole
1407222407
24077940
340094
444130
Úkol

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
Výstup
Úkol

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
Výstup

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.")
Výstup
Pokus 1
Pokus 2
Pokus 3
Vítej.
KontrolazadanopokusyPodmínka cyklu
1""0True
2"kocka"1True
3"heslo123"2True
4"sezame"3False

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)
Výstup
Součet: 245
Úkol

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
Výstup
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)
Výstup
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.

python
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)