0 dní v řadě · 0 bodů

První kroky · 23 min

Čísla a počítání

Celá a desetinná čísla, tři druhy dělení, pořadí operací, zaokrouhlování a to, proč 0.1 + 0.2 není přesně 0.3.

Hloubka
Úkoly
Lidsky řečeno

Rohlíky v košíku spočítáš přesně: jsou tři, ne „asi tři“. Mouku odvažuješ na kuchyňské váze a ta vždycky trochu zaokrouhlí. Python má pro tyhle dva světy dva druhy čísel. Celá čísla jsou kusy a sedí vždy přesně. Desetinná jsou váha: na běžné použití skvělá, ale s nepatrnou nepřesností.

Dva druhy čísel

Celému číslu se říká int (z anglického integer), desetinnému float (z floating point, plovoucí řádová čárka). Python pozná druh podle zápisu: když je v čísle desetinná tečka, jde o float. Funkce type ti druh hodnoty prozradí.

kusy = 4
cena = 24.5
celkem = kusy * cena

print(celkem)
print(type(kusy))
print(type(cena))
print(type(celkem))
Výstup
98.0
<class 'int'>
<class 'float'>
<class 'float'>

Když se při počítání potká int s float, vyjde float. Proto je výsledek 98.0, a ne 98.

Základní operace

ZnakVýznamPříkladVýsledek
+sčítání7 + 29
-odčítání7 - 25
*násobení7 * 214
/dělení7 / 23.5
//celočíselné dělení7 // 23
%zbytek po dělení7 % 21
**mocnina7 ** 249

Obyčejné dělení / vrací vždy float, i když to vyjde beze zbytku. Celá čísla přitom můžou být libovolně velká. Dlouhá čísla si zpřehledníš podtržítky a velmi velká nebo malá desetinná zapíšeš přes e, kde 1.5e3 znamená 1,5 krát 10 na třetí.

print(10 / 2)
print(2 ** 100)
print(1_000_000 + 1)
print(1.5e3)
Výstup
5.0
1267650600228229401496703205376
1000001
1500.0

Dělení se zbytkem

Vzpomeň si na první stupeň: 17 děleno 5 je 3, zbytek 2. Přesně to dělají // a %. Vypadá to jako školní drobnost, ale v programech se objevuje pořád. Hodnoty sekundy, cislo a hodina nastavuješ posuvníky, tak je zkus měnit.

print(sekundy // 60, "min", sekundy % 60, "s")
print(cislo % 2)
print(cislo % 10)
print((hodina + 5) % 24)
Výstup
3 min 20 s
1
7
3

Co se tu stalo:

  • // a % rozložily sekundy na minuty a zbytek.
  • cislo % 2 je 0 u sudých čísel a 1 u lichých.
  • cislo % 10 vrátí u kladného čísla poslední číslici.
  • % 24 zabalí čas přes půlnoc: pět hodin po desáté večer jsou tři ráno.

Když je aspoň jedno z čísel float, vyjde float i tady: 7.0 // 2 je 3.0.

Úkol

Délka filmu

Film trvá minuty minut. Vytvoř proměnné hodiny a zbyva tak, aby šlo říct „2 hodiny a 15 minut“. Obě mají být celá čísla.

minuty = 135
# doplň hodiny a zbyva
Výstup
Kvíz

Kolik je 17 // 5 a 17 % 5?

Pořadí operací

Platí to, co ze školy, jen s jedním patrem navíc: nejdřív mocnina, potom násobení a všechna dělení (*, /, //, %), nakonec sčítání a odčítání. Operace na stejné úrovni jdou zleva doprava. Závorky mají přednost před vším a nic za ně neplatíš. Tipni si všechny čtyři výsledky.

print(2 + 3 * 4)
print(100 / 10 * 2)
print(-3 ** 2)
print(2 ** 3 ** 2)
Výstup
14
20.0
-9
512

První řádek je 2 + 12. Druhý jde zleva: 100 / 10 je 10.0 a to krát 2. Poslední dva jsou záludnost. Mocnina má přednost i před znaménkem minus, takže -3 ** 2 je „minus (3 na druhou)“. A více mocnin za sebou se počítá výjimečně zprava: nejdřív 3 na druhou, pak 2 na devátou. Když si nejsi jistý, napiš závorky. Čtenáři to jen pomůže.

Najdi chybu

Průměr, který nesedí

Program má vypsat průměr čísel 10 a 20, tedy 15.0. Vypisuje ale 20.0.

Úkol

Teplota pro Američana

Převeď teplotu ve stupních Celsia na stupně Fahrenheita a výsledek ulož do proměnné fahrenheit. Vzorec: stupně Celsia vynásob devíti, vyděl pěti a přičti 32.

celsius = 37
# doplň fahrenheit
Výstup
Kvíz

Kolik je 2 + 3 * 2 ** 2?

Desetinná čísla nejsou přesná

Teď přijde věc, která každého jednou překvapí.

import math

print(0.1 + 0.2)
print(0.1 + 0.2 == 0.3)
print(round(0.1 + 0.2, 2))
print(math.isclose(0.1 + 0.2, 0.3))
Výstup
0.30000000000000004
False
0.3
True

Python se nespletl, takhle fungují desetinná čísla téměř ve všech jazycích. Třetinu taky nezapíšeš desítkově přesně, vždycky skončíš u 0.3333 a někde utneš. Počítač ukládá čísla ve dvojkové soustavě a v té dopadne stejně jedna desetina. Uloží se hodnota jen velmi blízká 0,1.

Dvě znaménka == se ptají „rovná se to?“ a odpověď je True (ano), nebo False (ne). Víc o nich v lekci Pravda, nepravda a porovnávání. import math si přinese sadu matematických nástrojů a math.isclose z ní ověří, jestli jsou dvě čísla prakticky stejná.

Z toho plynou dvě pravidla:

  • Desetinná čísla neporovnávej přes ==. Použij math.isclose.
  • Peníze, kde musí každý halíř sedět, počítej v celých haléřích, nebo přes modul decimal.

Zadej 0.1 + 0.2 a podívej se, jaká hodnota se opravdu uložila. Barvy ukazují, jak je číslo rozdělené do 64 bitů.

Zaokrouhlování a užitečné funkce

Python má několik funkcí, které se při počítání hodí pořád. Některé jsou k dispozici rovnou, jiné v modulu math.

import math

print(round(3.14159, 2))
print(round(2.5), round(3.5))
print(int(3.9), math.floor(3.9), math.ceil(3.1))
print(abs(-12), min(4, 9, 2), max(4, 9, 2))
print(float(7), int(7.0))
Výstup
3.14
2 4
3 3 4
12 2 9
7.0 7
  • round(x, 2) zaokrouhlí na dvě desetinná místa a vrátí float, round(x) zaokrouhlí na celé číslo a vrátí int.
  • int(x) desetinnou část utne, nezaokrouhluje. Z 3.9 udělá 3.
  • math.floor zaokrouhlí vždy dolů a math.ceil vždy nahoru. U záporných čísel pozor: int(-3.9) je -3, ale math.floor(-3.9) je -4.
  • abs vrátí vzdálenost od nuly, min a max nejmenší a největší hodnotu.
  • float a int převádějí mezi oběma druhy čísel.

Všimni si druhého řádku výsledku. Python u přesné poloviny nezaokrouhluje „pětky nahoru“, jak ses učil ve škole, ale k nejbližšímu sudému číslu. Z 2.5 je 2 a z 3.5 je 4. Díky tomu se chyby při sčítání mnoha zaokrouhlených čísel nehromadí jedním směrem.

Jedna věc matematicky nejde ani v Pythonu:

print("Dělím...")
print(10 / 0)
Výstup
Dělím...
Úkol

Dělení účtu

Účet v restauraci je 1250 Kč, chcete přidat 10 % spropitného a rozdělit to mezi 3 lidi. Do proměnné na_osobu ulož částku na jednoho, zaokrouhlenou na dvě desetinná místa.

ucet = 1250
osob = 3
# doplň na_osobu
Výstup
Úkol

Kolik krabic

Do jedné krabice se vejde 6 hrnků a balíš tři zásilky: 23, 24 a 25 hrnků. Žádný hrnek nesmí zůstat venku a žádná krabice nemá být zbytečná. Výpočet teď počítá špatně. Oprav ho tak, aby krabice_a, krabice_b a krabice_c obsahovaly správný počet krabic.

do_krabice = 6
hrnky_a = 23
hrnky_b = 24
hrnky_c = 25

krabice_a = hrnky_a // do_krabice
krabice_b = hrnky_b // do_krabice
krabice_c = hrnky_c // do_krabice
Výstup
Kvíz

Co vypíše print(int(4.99))?

Roztřiď

Jaký druh čísla vyjde?

Roztřiď výrazy podle druhu výsledku.

Pod kapotou · float je IEEE 754 binary64

float je na všech běžných platformách 64bitové číslo podle IEEE 754: 53 bitů přesnosti (zhruba 15 až 17 platných desítkových číslic). repr vypíše nejkratší text, ze kterého vznikne bit po bitu stejná hodnota, takže 0.1 vypadá přesně, i když přesné není. Skutečnou hodnotu ukáže Decimal:

from decimal import Decimal, ROUND_HALF_UP
import math

print(Decimal(0.1))
print(Decimal(2.675))
print(round(2.675, 2))
print(Decimal("2.675").quantize(Decimal("0.01"), rounding=ROUND_HALF_UP))

print(2.0 ** 53 + 1 == 2.0 ** 53)

soucet = 0.0
for _ in range(10):
    soucet += 0.1
print(soucet, sum([0.1] * 10), math.fsum([0.1] * 10))

nan = float("nan")
print(nan == nan, math.isnan(nan))
Výstup
0.1000000000000000055511151231257827021181583404541015625
2.67499999999999982236431605997495353221893310546875
2.67
2.68
True
0.9999999999999999 1.0 1.0
False True

round(2.675, 2) dá 2.67 ne kvůli chybě, ale proto, že uložená hodnota leží pod polovinou. Decimal vytvářej z řetězce, Decimal(0.1) si chybu přinese s sebou. math.isclose má ve výchozím stavu jen relativní toleranci, takže math.isclose(0.1 + 0.2 - 0.3, 0.0) je False. Při porovnání s nulou nastav abs_tol. Nad 2^53 už float neumí všechna celá čísla, což je důvod, proč se velká ID v JSONu pro JavaScript posílají jako text. Od verze 3.12 používá sum nad floaty kompenzované sčítání, proto se liší od ruční smyčky. Při přechodu ze starší verze se tak můžou změnit poslední číslice výsledků, a s nimi i testy, které je porovnávají přesně. NaN se nerovná ničemu včetně sebe, takže umí rozbít řazení i odstraňování duplicit. Přetečení není jednotné: 1e308 * 10 tiše dá inf, kdežto 2.0 ** 10000 vyhodí OverflowError.

Pod kapotou · int bez stropu a dělení se zápornými čísly

int má libovolnou přesnost, je to pole „číslic“ o základu 2^30 (na běžných 64bitových buildech), a velká čísla se násobí Karatsubovým algoritmem. Cena operací tedy roste s velikostí čísla. // zaokrouhluje k mínus nekonečnu a % má znaménko dělitele, aby vždy platilo a == (a // b) * b + a % b. C, Java i Go ale ořezávají k nule, takže při přepisu algoritmů vznikají chyby právě u záporných vstupů.

import math

print(-7 // 2, -7 % 2)
print(int(-7 / 2), math.fmod(-7, 2))

print(10 ** 17 // 3)
print(int(10 ** 17 / 3))

print(len(str(2 ** 10000)))
print(len(str(2 ** 20000)))
Výstup
-4 1
-3 -1.0
33333333333333333
33333333333333332
3011

Třetí a čtvrtý řádek výstupu ukazují produkční past: int(a / b) jde přes float a nad 2^53 tiše ztrácí číslice. S celými čísly vždy //, a pro zaokrouhlení nahoru -(-a // b) místo math.ceil(a / b). Poslední řádek končí ValueError záměrně. Převod mezi int a desítkovým textem má kvadratickou složitost, a proto ho Python od verze 3.11 (a v bezpečnostních opravách starších větví) omezuje na 4300 číslic jako obranu proti DoS (CVE-2020-10735). Platí to i pro int(text). Limit nastavuje sys.set_int_max_str_digits a netýká se hex() ani bin().

Vyzkoušej si: Čísla jako bity

Přepínej jednotlivé bity a sleduj, jak se mění dvojková, šestnáctková a desítková podoba stejného čísla.