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))
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
| Znak | Význam | Příklad | Výsledek |
|---|---|---|---|
+ | sčítání | 7 + 2 | 9 |
- | odčítání | 7 - 2 | 5 |
* | násobení | 7 * 2 | 14 |
/ | dělení | 7 / 2 | 3.5 |
// | celočíselné dělení | 7 // 2 | 3 |
% | zbytek po dělení | 7 % 2 | 1 |
** | mocnina | 7 ** 2 | 49 |
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)
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)
3 min 20 s 1 7 3
Co se tu stalo:
//a%rozložily sekundy na minuty a zbytek.cislo % 2je 0 u sudých čísel a 1 u lichých.cislo % 10vrátí u kladného čísla poslední číslici.% 24zabalí č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.
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
Kolik je 17 // 5 a 17 % 5?
Pětka se do sedmnácti vejde třikrát (15) a zbydou 2.
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)
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.
Průměr, který nesedí
Program má vypsat průměr čísel 10 a 20, tedy 15.0. Vypisuje ale 20.0.
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
Kolik je 2 + 3 * 2 ** 2?
Nejdřív mocnina (2 ** 2 je 4), pak násobení (3 * 4 je 12), nakonec sčítání.
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))
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žijmath.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))
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.floorzaokrouhlí vždy dolů amath.ceilvždy nahoru. U záporných čísel pozor:int(-3.9)je -3, alemath.floor(-3.9)je -4.absvrátí vzdálenost od nuly,minamaxnejmenší a největší hodnotu.floataintpř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)
Dělím...
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
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
Co vypíše print(int(4.99))?
int desetinnou část zahodí a nezaokrouhluje. Pro zaokrouhlení slouží round.
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))
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)))
-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.