Lidsky řečeno
Na vánočním řetězu nesvítí nic, protože odešla jedna žárovka. Můžeš měnit žárovky naslepo a doufat. Nebo změříš polovinu řetězu, zjistíš, ve které půlce závada je, a tu znovu rozpůlíš. Ladění je totéž: nehádáš, ale měříš a pokaždé vyloučíš kus možností.
Nejhorší chyba je ta tichá
Chyby v programu jsou tři druhy:
| druh | kdy se projeví | příklad |
|---|---|---|
| syntaktická | program se vůbec nespustí | chybí dvojtečka |
| běhová | program spadne s hláškou | dělení nulou |
| logická | program doběhne a lže | špatný výsledek |
První dvě ti Python ohlásí i s číslem řádku. Logická chyba se neohlásí nijak, protože z pohledu Pythonu je všechno v pořádku. Udělal přesně to, co stojí v kódu. Jen to není to, co chceš.
Tenhle kód má sečíst čísla od 1 do 5. Správně je 15.
n = 5
soucet = 0
for i in range(1, n):
soucet = soucet + i
print("Součet je", soucet)
Součet je 10
Žádná hláška, jen špatné číslo. Ladění (anglicky debugging) je hledání a odstraňování takových chyb.
Postup místo hádání
Začátečník mění náhodné řádky, dokud to nevyjde. Někdy to projde, ale nevíš proč, a chyba se vrátí jinde. Spolehlivější je šest kroků:
- Zopakuj chybu. Najdi vstup, se kterým se projeví pokaždé.
- Řekni přesně, co čekáš a co dostáváš. „Čekám 15, dostávám 10.“
- Zmenši problém. Co nejmenší vstup, co nejméně kódu.
- Vyslov domněnku. „Myslím, že se nepřičetla pětka.“
- Ověř ji měřením. Podívej se na skutečné hodnoty a měň jen jednu věc naráz.
- Oprav a ověř znovu, i na jiných vstupech.
Rozdíl 15 − 10 = 5 je sám o sobě stopa: chybí přesně poslední číslo.
Krokování na papíře
Nejlevnější nástroj je tabulka. Procházíš kód řádek po řádku jako počítač a zapisuješ si hodnoty. Pro náš kód:
| kolo | i | soucet po kole | správně má být |
|---|---|---|---|
| 1 | 1 | 1 | 1 |
| 2 | 2 | 3 | 3 |
| 3 | 3 | 6 | 6 |
| 4 | 4 | 10 | 10 |
| 5 | kolo neproběhne | zůstává 10 | 15 |
Tady je to vidět: range(1, n) končí u čtyřky. Oprava je range(1, n + 1).
Ať program mluví
U delšího kódu necháš tabulku vypsat počítač. Vložíš dočasné výpisy, kterým se říká ladicí print. Zápis {i=} ve f-stringu vypíše jméno proměnné i s hodnotou, takže nemusíš nic opisovat.
n = 5
soucet = 0
for i in range(1, n):
soucet = soucet + i
print(f"{i=} {soucet=}")
i=1 soucet=1 i=2 soucet=3 i=3 soucet=6 i=4 soucet=10
Tenhle zápis má ještě jednu výhodu: text ukáže v uvozovkách, takže uvidíš i to, co jinak vidět není. Uživatel napsal ano, jenže omylem s mezerou na konci, a porovnání nesedí.
odpoved = input()
print(odpoved == "ano")
print(f"{odpoved=}")
print(odpoved.strip() == "ano")
False odpoved='ano ' True
Když nevíš jistě, co v proměnné vlastně je, zeptej se funkcí type. Výsledek input() je vždy text, i když vypadá jako číslo.
vek = input()
print(vek, type(vek))
print(vek * 2)
30 <class 'str'> 3030
Text vynásobený dvěma se zopakuje, proto 3030 a ne 60.
Program vypisuje špatný součet. Co uděláš nejdřív?
Bez opakovatelného vstupu a přesného očekávání nepoznáš ani to, jestli je chyba opravená. Změny naslepo často přidají další.
Půlení
Když je kód delší a nevíš, kde chyba vznikla, nezačínej odshora. Podívej se doprostřed. Je hodnota v polovině ještě správná? Pak je chyba až za ní. Je špatná? Pak je před ní. Každé měření vyloučí půlku kódu, přesně jako u vánočního řetězu.
Košík za 1000 Kč, sleva 20 %, k tomu 21% DPH a doprava 99 Kč. Čekáme 800 po slevě, 968 s DPH a nakonec 1067.
cena = 1000
sleva = 20
po_sleve = cena - sleva / 100
print(f"{po_sleve=}")
s_dph = po_sleve * 1.21
celkem = s_dph + 99
print(round(celkem, 2))
po_sleve=999.8 1308.76
První kontrola hned ukáže 999.8 místo 800. Všechno za ní je tedy jen následek a chyba je ve výpočtu slevy: odečetli jsme 0,2 koruny místo 20 procent. Správně je cena * (1 - sleva / 100).
cena = 1000
sleva = 20
po_sleve = cena * (1 - sleva / 100)
print(f"{po_sleve=}")
s_dph = po_sleve * 1.21
celkem = s_dph + 99
print(round(celkem, 2))
po_sleve=800.0 1067.0
Oprav průměr
Kód má spočítat průměr čísel od 1 do 10, což je 5,5. Jsou v něm dvě logické chyby. Najdi je a oprav. Proměnné soucet, pocet a prumer nech.
soucet = 0
pocet = 0
for cislo in range(1, 10):
soucet = cislo
pocet += 1
prumer = soucet / pocet
print(soucet, pocet, prumer)
Galerie obvyklých podezřelých
Většina logických chyb se opakuje. Podle příznaku poznáš, kam se dívat nejdřív.
| příznak | podezřelý |
|---|---|
| výsledek je o kousek vedle, chybí poslední prvek | horní mez range, záměna < a <= |
| z celého cyklu zůstala jen poslední hodnota | akumulátor se nuluje v cyklu, nebo =+ místo += |
| podmínka platí vždy | x == "a" or "b" |
53 místo 8 | sčítáš texty, chybí int() |
| hodnoty vypadají stejně, ale rovnost neplatí | mezera v textu, "5" proti 5, desetinná čísla |
| cyklus se nikdy nezastaví | podmínka se nemění, continue přeskočil změnu |
| cyklus se neprovede ani jednou | prázdný range, špatné znaménko kroku |
Čtyři z nich naživo. Akumulátor založený uvnitř cyklu se v každém kole vynuluje, takže místo 6 dostaneš 3:
for cislo in range(1, 4):
soucet = 0
soucet = soucet + cislo
print(soucet)
3
Přehozené znaky =+ nejsou chyba syntaxe. Znamená to „přiřaď kladnou hodnotu“, takže se nic nesčítá:
soucet = 0
for cislo in range(1, 4):
soucet =+ cislo
print(soucet)
3
Podmínka s or se nepřečte tak, jak ji čte člověk. Vpravo stojí samotný neprázdný text a ten se bere jako pravda.
barva = "modrá"
if barva == "červená" or "zelená":
print("Skladem")
if barva == "červená" or barva == "zelená":
print("Tohle se nevypíše")
Skladem
A texty se porovnávají znak po znaku, ne jako čísla. Desetinná čísla zase nejsou v počítači přesná.
print("10" < "9")
print(10 < 9)
print(0.1 + 0.2 == 0.3)
print(0.1 + 0.2)
print(abs((0.1 + 0.2) - 0.3) < 0.000001)
True False False 0.30000000000000004 True
Moc samohlásek
Kód má spočítat samohlásky ve slově programovani. Má jich být 5, ale vychází číslo mnohem větší. Oprav podmínku a výsledek nech v proměnné pocet.
slovo = "programovani"
pocet = 0
for znak in slovo:
if znak == "a" or "e" or "i" or "o" or "u":
pocet += 1
print(pocet)
Sčítání, které lepí
Program načte dvě čísla a má vypsat jejich součet. Pro vstup 12 a 30 ale tvrdí, že je to 1230. Oprav to tak, aby v soucet bylo číslo 42.
a = input()
b = input()
soucet = a + b
print("Celkem:", soucet)
Pojistky v kódu
Příkaz assert je kontrola, která mlčí, dokud je všechno v pořádku. Když podmínka neplatí, program okamžitě skončí a řekne proč. Chybu tak chytíš tam, kde vznikla, a ne o sto řádků dál.
soucet = 0
for i in range(1, 5):
soucet = soucet + i
print("Součet:", soucet)
assert soucet == 15, f"čekal jsem 15, mám {soucet}"
print("Tohle se nevypíše.")
Součet: 10
Co je na logické chybě nejhorší?
Bez hlášky si jí všimneš, jen když víš, jaký výsledek čekat. Proto je druhý krok postupu tak důležitý.
Pod kapotou · debugger, f-string = a hledání chyb v produkci
Debugger. breakpoint() (PEP 553) zastaví program v pdb, proměnná PYTHONBREAKPOINT ho přesměruje na jiný debugger a hodnota 0 všechna volání vypne. Bez zásahu do kódu spustíš python -m pdb skript.py. V cyklech je nejcennější podmíněná zarážka, díky které neklikáš přes tisíc kol. Zarážka b 3, i == 3 zastaví na řádku 3 až ve chvíli, kdy je i rovno třem:
# s.py
1 soucet = 0
2 for i in range(1, 5):
3 soucet = soucet + i
4 print(soucet)
$ python -m pdb s.py
(Pdb) b 3, i == 3
(Pdb) c
-> soucet = soucet + i
(Pdb) p i, soucet
(3, 3)
(Pdb) n
-> for i in range(1, 5):
(Pdb) p soucet
6Základ: n další řádek, s dovnitř volání, c pokračuj, p/pp vypiš, ll kód, w zásobník, u/d pohyb po rámcích. python -m pdb -c continue skript.py doběhne k pádu a otevře post-mortem, stejně jako pdb.pm() v interaktivní konzoli (ta od 3.12 čte sys.last_exc).
f-string = zachovává mezery kolem rovnítka, bere i celý výraz a standardně používá repr. Se specifikací formátu přejde na format(), !s vynutí str:
cena = 19.5
jmeno = "Eva"
print(f"{cena=}")
print(f"{cena * 2 = }")
print(f"{cena=:.2f}")
print(f"{jmeno=}")
print(f"{jmeno=!s}")
cena=19.5 cena * 2 = 39.0 cena=19.50 jmeno='Eva' jmeno=Eva
Pasti ladicích nástrojů. assert zmizí při python -O, takže do něj nepatří validace vstupů ani nic s vedlejším efektem. assert (x, "zpráva") je neprázdná n-tice, tedy vždy pravda, a Python na to upozorní SyntaxWarning. Výpisy na stdout a stderr se můžou prolínat v jiném pořadí, protože stdout bývá při zápisu do roury bufferovaný (flush=True nebo python -u). Sám ladicí výpis může chybu zamaskovat: změní časování vláken nebo spustí __repr__ s vedlejším efektem. Takové chybě se říká heisenbug.
Půlení ve velkém. git bisect run ./test.sh binárně vyhledá commit, který chybu zavedl, takže tisíc commitů zvládne asi na deset kroků. Stejná myšlenka nad vstupními daty je delta debugging: automaticky zmenšuj vstup, dokud chyba trvá.
Produkce. Na zaseknutý proces platí faulthandler (python -X faulthandler, faulthandler.dump_traceback_later(60)) a externí py-spy dump --pid, který vypíše zásobníky bez úpravy kódu. python -m trace --trace skript.py vypíše každý provedený řádek. PEP 669 přinesl ve 3.12 sys.monitoring, levnější základ pro debuggery a profilery, než byl sys.settrace.