0 dní v řadě · 0 bodů

Rozhodování a cykly · 20 min

Ladění: jak najít chybu v logice

Program běží, ale počítá špatně. Naučíš se postup, jak chybu najít bez hádání, a poznáš nejčastější viníky.

Hloubka
Úkoly
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:

druhkdy se projevípříklad
syntaktickáprogram se vůbec nespustíchybí dvojtečka
běhováprogram spadne s hláškoudě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)
Výstup
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ů:

  1. Zopakuj chybu. Najdi vstup, se kterým se projeví pokaždé.
  2. Řekni přesně, co čekáš a co dostáváš. „Čekám 15, dostávám 10.“
  3. Zmenši problém. Co nejmenší vstup, co nejméně kódu.
  4. Vyslov domněnku. „Myslím, že se nepřičetla pětka.“
  5. Ověř ji měřením. Podívej se na skutečné hodnoty a měň jen jednu věc naráz.
  6. 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:

koloisoucet po kolesprávně má být
1111
2233
3366
441010
5kolo neproběhnezůstává 1015

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=}")
Výstup
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")
Výstup
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)
Výstup
30 <class 'str'>
3030

Text vynásobený dvěma se zopakuje, proto 3030 a ne 60.

Kvíz

Program vypisuje špatný součet. Co uděláš nejdřív?

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))
Výstup
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))
Výstup
po_sleve=800.0
1067.0
Úkol

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

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říznakpodezřelý
výsledek je o kousek vedle, chybí poslední prvekhorní mez range, záměna < a <=
z celého cyklu zůstala jen poslední hodnotaakumulátor se nuluje v cyklu, nebo =+ místo +=
podmínka platí vždyx == "a" or "b"
53 místo 8sčí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 jednouprá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)
Výstup
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)
Výstup
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")
Výstup
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)
Výstup
True
False
False
0.30000000000000004
True
Úkol

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

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

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.")
Výstup
Součet: 10
Kvíz

Co je na logické chybě nejhorší?

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:

text
# 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
6

Zá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}")
Výstup
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.