Lidsky řečeno
Představ si balónky na provázcích. Každé jméno v programu drží jeden provázek. Dokud někdo drží aspoň jeden, balónek zůstává. Pustí-li ho poslední člověk, balónek uletí a místo se uvolní. Háček: dva balónky můžou být přivázané jeden k druhému. Nikdo z lidí je nedrží, ale provázky existují, takže samy neuletí. Na ty chodí uklízeč. Jmenuje se garbage collector, česky sběrač odpadků.
Počítadlo referencí
Každý objekt v CPythonu, tedy v běžné verzi Pythonu, si nese číslo: kolik věcí na něj právě ukazuje. Říká se tomu počet referencí. Referencí je jméno proměnné, položka seznamu, atribut objektu. Zjistíš ho funkcí sys.getrefcount. Vrací o jedničku víc, protože i její vlastní argument je dočasná reference.
import sys
data = ["a"]
print(sys.getrefcount(data))
druhe = data
print(sys.getrefcount(data))
seznam = [data, data]
print(sys.getrefcount(data))
del druhe
seznam.clear()
print(sys.getrefcount(data))
2 3 5 2
Když počet klesne na nulu, objekt se uvolní okamžitě, ne někdy později. Je to vidět na metodě __del__, kterou Python zavolá těsně před zánikem objektu.
class Stopa:
def __init__(self, jmeno):
self.jmeno = jmeno
print("vznikla", jmeno)
def __del__(self):
print("zanikla", self.jmeno)
a = Stopa("A")
b = a
del a
print("po del a: objekt žije, drží ho b")
b = None
print("po b = None")
def funkce():
lokalni = Stopa("L")
print("konec funkce")
funkce()
print("za funkcí")
vznikla A po del a: objekt žije, drží ho b zanikla A po b = None vznikla L konec funkce zanikla L za funkcí
Cykly a garbage collector
Počítadlo má slepé místo. Když se dva objekty drží navzájem, nikdy neklesnou na nulu, i když se k nim program už nedostane. Tady přichází sběrač z modulu gc. Abys viděl, co dělá, vypneme ho a spustíme ručně. Sledujeme to přes slabou referenci, ukazatel, který objekt nedrží naživu. Volání hlidac() vrátí objekt, nebo None, když už neexistuje.
import gc
import weakref
class Uzel:
def __init__(self):
self.soused = None
gc.disable()
a = Uzel()
b = Uzel()
a.soused = b
b.soused = a
hlidac = weakref.ref(a)
del a, b
print("po del žije:", hlidac() is not None)
gc.collect()
print("po collect žije:", hlidac() is not None)
gc.enable()
po del žije: True po collect žije: False
Bez cyklu by objekt zmizel už při del. Běžně se o nic starat nemusíš, sběrač je zapnutý a spouští se sám. Cykly ale znamenají, že paměť se uvolní později a v dávkách.
Slabé reference se hodí i jindy, typicky pro cache. Slovník WeakValueDictionary drží hodnoty jen tak dlouho, dokud je používá někdo jiný.
import weakref
class Obrazek:
def __init__(self, jmeno):
print("načítám", jmeno)
self.jmeno = jmeno
cache = weakref.WeakValueDictionary()
def nacti(jmeno):
obrazek = cache.get(jmeno)
if obrazek is None:
obrazek = Obrazek(jmeno)
cache[jmeno] = obrazek
return obrazek
a = nacti("logo.png")
b = nacti("logo.png")
print(a is b, len(cache))
del a, b
print(len(cache))
načítám logo.png True 1 0
Slabá reference nejde udělat na všechno. int, str, tuple ani obyčejný list ji nepodporují, instance vlastních tříd ano.
Strom bez cyklů
Dítě v téhle třídě drží rodiče silně a rodič drží dítě, takže vzniká cyklus. Uprav Uzel tak, aby si dítě rodiče drželo přes weakref.ref. Atribut rodic se má dál číst stejně: vrátí rodiče, nebo None, když rodič neexistuje nebo žádný nebyl.
import weakref
class Uzel:
def __init__(self, jmeno, rodic=None):
self.jmeno = jmeno
self.deti = []
self.rodic = rodic
if rodic is not None:
rodic.deti.append(self)
Co udělá del x, když na stejný objekt ukazuje i y?
del jen zruší jedno jméno a sníží počet referencí. Objekt zanikne, až počet klesne na nulu.
Kolik co zabírá
sys.getsizeof vrací velikost samotného objektu. Seznam ale své prvky v sobě nemá, drží jen ukazatele na ně. Výsledek proto nezávisí na tom, jak velké jsou prvky.
import sys
maly = ["x"]
velky = ["x" * 1_000_000]
print(sys.getsizeof(maly) == sys.getsizeof(velky))
print(sys.getsizeof(velky[0]) > 1_000_000)
print(sys.getsizeof(range(10)) == sys.getsizeof(range(10**9)))
print(sys.getsizeof(list(range(1000))) > sys.getsizeof(range(1000)))
True True True True
range si pamatuje jen začátek, konec a krok, proto mu nezáleží na délce. Stejný princip mají generátory z lekce Generátory a líné zpracování.
Seznam navíc zabírá místo dopředu. Kdyby se při každém append přesouval celý, bylo by přidávání pomalé. Kapacitu zjistíš z velikosti: odečteš prázdný seznam a vydělíš velikostí ukazatele.
import struct
import sys
ukazatel = struct.calcsize("P")
prazdny = sys.getsizeof([])
seznam = []
kapacita = 0
for i in range(70):
seznam.append(i)
nova = (sys.getsizeof(seznam) - prazdny) // ukazatel
if nova != kapacita:
print(f"délka {len(seznam):>2}: místo pro {nova}")
kapacita = nova
délka 1: místo pro 4 délka 5: místo pro 8 délka 9: místo pro 16 délka 17: místo pro 24 délka 25: místo pro 32 délka 33: místo pro 40 délka 41: místo pro 52 délka 53: místo pro 64 délka 65: místo pro 76
Skutečnou spotřebu programu měří tracemalloc. Tady porovnává instance běžné třídy a třídy se __slots__, která nemá slovník a atributy drží na pevných místech.
import tracemalloc
class Bezna:
def __init__(self, x, y):
self.x = x
self.y = y
class Sloty:
__slots__ = ("x", "y")
def __init__(self, x, y):
self.x = x
self.y = y
def bajtu_na_objekt(trida, pocet=20_000):
tracemalloc.start()
objekty = [trida(0, 0) for _ in range(pocet)]
pouzito, _ = tracemalloc.get_traced_memory()
tracemalloc.stop()
return pouzito / len(objekty)
print(bajtu_na_objekt(Sloty) < bajtu_na_objekt(Bezna))
print(hasattr(Sloty(1, 2), "__dict__"), hasattr(Bezna(1, 2), "__dict__"))
True False True
Skutečná velikost
Napiš hluboka_velikost(obj). Sečte sys.getsizeof objektu a všeho, co je v něm: prvků seznamů, n-tic a množin a klíčů i hodnot slovníků, do libovolné hloubky. Každý objekt počítej jen jednou (podle id), takže sdílené prvky ani seznam obsahující sám sebe nic nerozbijí.
import sys
def hluboka_velikost(obj):
return sys.getsizeof(obj)
Malá čísla a sdílené objekty
Některé objekty Python používá opakovaně, aby šetřil. Celá čísla od -5 do 256 existují předem a texty podobné identifikátorům se často internují, tedy sdílejí. Proto is občas „funguje“ na číslech a pak přestane.
import sys
a = int("256")
b = int("256")
print(a is b)
c = int("257")
d = int("257")
print(c is d, c == d)
e = "".join(["kl", "íč"])
f = "".join(["kl", "íč"])
print(e is f, sys.intern(e) is sys.intern(f))
True False True False True
Bytecode: co se doopravdy spouští
Python tvůj text neprovádí přímo. Nejdřív ho přeloží do bytecodu, posloupnosti jednoduchých instrukcí pro virtuální stroj, a ty teprve vykonává smyčka interpretu. Prohlédneš si je modulem dis.
import dis
def mzda(hodiny, sazba):
return hodiny * sazba + 500
for i in dis.get_instructions(mzda):
print(f"{i.opname:<14}{i.argrepr}")
print(mzda.__code__.co_varnames, mzda.__code__.co_consts)
RESUME
LOAD_FAST hodiny
LOAD_FAST sazba
BINARY_OP *
LOAD_CONST 500
BINARY_OP +
RETURN_VALUE
('hodiny', 'sazba') (None, 500)Tenhle stroj je zásobníkový. Nemá proměnné pro mezivýsledky, odkládá je na hromádku a každá operace bere vrchní hodnoty. RESUME je technická značka začátku funkce a pro výpočet nic nedělá. Pro hodiny = 10 a sazba = 200 to vypadá takto:
instrukce zásobník (vrchol vpravo)
LOAD_FAST hodiny 10
LOAD_FAST sazba 10 200
BINARY_OP * 2000
LOAD_CONST 500 2000 500
BINARY_OP + 2500
RETURN_VALUE vrátí 2500Překladač přitom dělá drobné optimalizace. Výraz ze samých konstant spočítá rovnou a do bytecodu uloží výsledek. A na jménech vidíš, proč jsou lokální proměnné rychlé: LOAD_FAST sáhne na číslované místo, zatímco LOAD_GLOBAL hledá ve slovníku.
import dis
import math
def den():
return 60 * 60 * 24
def odmocnina(x):
return math.sqrt(x)
for f in (den, odmocnina):
print(f.__name__)
for i in dis.get_instructions(f):
print(f" {i.opname:<14}{i.argrepr}")
den RESUME RETURN_CONST 86400 odmocnina RESUME LOAD_GLOBAL NULL + math LOAD_ATTR sqrt LOAD_FAST x CALL RETURN_VALUE
Rozklad na instrukce vysvětluje i jednu klasickou chybu. pocet += 1 vypadá jako jeden krok, ale jsou to čtyři: načíst, načíst jedničku, sečíst, uložit. Mezi nimi se může dostat ke slovu jiné vlákno, což řeší lekce Vlákna, procesy a GIL.
import dis
pocet = 0
def pridej():
global pocet
pocet += 1
print([i.opname for i in dis.get_instructions(pridej)])
['RESUME', 'LOAD_GLOBAL', 'LOAD_CONST', 'BINARY_OP', 'STORE_GLOBAL', 'RETURN_CONST']
Přeložený kód importovaných modulů si Python ukládá do složky __pycache__, aby ho příště nemusel překládat znovu. Rychlejší je tím start, ne samotný běh. Skript spuštěný přímo se nekešuje.
import importlib.util
from pathlib import Path
print(Path(importlib.util.cache_from_source("nastroje.py")).name)
nastroje.cpython-312.pyc
Vlastní virtuální stroj
Napiš spust(program), malý zásobníkový stroj. Program je seznam dvojic (instrukce, argument). PUSH dá argument na zásobník. ADD a MUL vezmou dvě vrchní hodnoty a vrátí na zásobník součet nebo součin. SUB vezme vrchol b a pod ním a a uloží a - b. U ostatních než PUSH je argument None. Funkce vrátí vrchol zásobníku po posledním kroku.
def spust(program):
zasobnik = []
# doplň
return None
print(spust([("PUSH", 2), ("PUSH", 3), ("ADD", None), ("PUSH", 4), ("MUL", None)]))
Proč je čtení lokální proměnné obvykle rychlejší než globální?
Jména lokálních proměnných zná překladač předem a převede je na indexy. Globální jména se dohledávají, i když to interpret umí výrazně urychlit.
Co přesně měří sys.getsizeof(seznam)?
Prvky jsou samostatné objekty. Pro celkovou velikost je musíš projít, jako v úkolu o hluboké velikosti.
Pod kapotou · garbage collector v CPythonu 3.12
Sběrač sleduje jen kontejnery, tedy objekty, které mohou tvořit cyklus. Čísla a texty v něm nejsou a n-tice nebo slovníky s atomickými hodnotami se umí ze sledování vyřadit. Algoritmus: pro každý objekt v generaci zkopíruje refcount, odečte reference vedoucí zevnitř generace, a co zůstane nad nulou, je dosažitelné zvenčí. Zbytek je odpad.
import gc
import sys
print(gc.is_tracked(1), gc.is_tracked("text"), gc.is_tracked([]))
print(gc.is_tracked({"a": 1}), gc.is_tracked({"a": []}))
print(sys.getrefcount(None) > 10**8)
False False True False True True
Generace jsou tři, výchozí prahy gc.get_threshold() jsou (700, 10, 10). Nejmladší se sbírá, když počet alokací kontejnerů mínus dealokací překročí 700. Nejstarší navíc jen tehdy, když čekajících objektů přibylo aspoň o čtvrtinu proti naposledy prošlým, jinak by plné sběry dělaly celkovou práci kvadratickou. Od 3.12 sběr běží jen v mechanismu eval breaker mezi instrukcemi, ne přímo uvnitř alokace, takže finalizéry už nenaskočí uprostřed C kódu, který si jen říká o paměť.
V PEP 683 přibyly nesmrtelné objekty (None, True, malá čísla a další): mají refcount zafixovaný na obří hodnotě a nikdy se nemění. Odpadá tím zápis do jejich stránek paměti. To pomáhá serverům, které po fork() sdílejí paměť přes copy-on-write, kde obyčejné čtení objektu jinak špiní stránku kvůli refcountu. Stejný účel má gc.freeze() před forkem: přesune vše do permanentní generace, aby sběr v potomcích nesahal na zděděné objekty.
Od PEP 442 cykly s __del__ nekončí v gc.garbage, finalizéry se zavolají a jsou bezpečné. Dál ale platí, že objekt může z __del__ „vstát z mrtvých“ a že výjimky z __del__ se jen vypíší.
Pod kapotou · alokátor a proč proces paměť nevrací
Objekty do 512 bajtů obsluhuje pymalloc: paměť bere v arénách (1 MiB na 64bitových systémech), dělí je na pooly po 16 KiB a každý pool drží bloky jedné velikostní třídy, zarovnané na 16 bajtů. Větší požadavky jdou do malloc. Aréna se vrátí systému až celá prázdná, takže jediný přeživší objekt ji drží. Proto po uvolnění milionu objektů RSS často neklesne, i když Python má paměť volnou pro další alokace. Není to nutně únik. Rozlišíš to přes tracemalloc.take_snapshot() a porovnání dvou snímků: skutečný únik roste v čase na stejném řádku.
Diagnostika: sys._debugmallocstats() vypíše stav arén, PYTHONMALLOC=debug zapne ochranné zóny, PYTHONTRACEMALLOC=25 měří od startu. Pro dlouho běžící workery je pragmatický lék recyklace procesů (max_tasks_per_child, max_requests u gunicornu).
Časté skutečné úniky: neomezené functools.lru_cache(maxsize=None) nad metodou (drží self), uložené výjimky s tracebackem (drží všechny rámce a jejich lokální proměnné) a registry callbacků bez WeakMethod.
Pod kapotou · adaptivní interpret a sys.monitoring
Od 3.11 se bytecode za běhu přepisuje (PEP 659). Po několika průchodech se obecná instrukce nahradí specializovanou podle skutečných typů a při změně typů se zase vrátí. Inline cache leží přímo v kódu za instrukcí, ukáže je dis.dis(f, show_caches=True). Stav vidíš přes adaptive=True.
import dis
def soucet(a, b):
return a + b
def operace():
return [i.opname for i in dis.get_instructions(soucet, adaptive=True) if i.opname.startswith("BINARY")]
print(operace())
for _ in range(1000):
soucet(1, 2)
print(operace())
['BINARY_OP'] ['BINARY_OP_ADD_INT']
Bytecode není stabilní rozhraní. Mění se mezi verzemi, proto je v hlavičce .pyc magické číslo a kód závislý na konkrétních opkódech se při upgradu rozbije. marshal je formát, kterým se code objekty ukládají. Není určený pro nedůvěryhodná data.
PEP 669 přidal ve 3.12 sys.monitoring: události pro profilery a debuggery, které se dají zapnout jen tam, kde jsou potřeba, a mají výrazně nižší režii než sys.settrace.
import importlib.util
import marshal
import sys
print(int.from_bytes(importlib.util.MAGIC_NUMBER[:2], "little"))
kod = compile("print('z marshalu', 6 * 7)", "<ukazka>", "exec")
exec(marshal.loads(marshal.dumps(kod)))
def fib(n):
return n if n < 2 else fib(n - 1) + fib(n - 2)
mon = sys.monitoring
NASTROJ = mon.PROFILER_ID
pocty = {}
def pri_startu(kod, offset):
pocty[kod.co_name] = pocty.get(kod.co_name, 0) + 1
mon.use_tool_id(NASTROJ, "pocitadlo")
try:
mon.register_callback(NASTROJ, mon.events.PY_START, pri_startu)
mon.set_events(NASTROJ, mon.events.PY_START)
fib(10)
finally:
mon.set_events(NASTROJ, 0)
mon.register_callback(NASTROJ, mon.events.PY_START, None)
mon.free_tool_id(NASTROJ)
print(pocty["fib"])
3531 z marshalu 42 177
Comprehensions jsou od 3.12 vložené přímo do funkce (PEP 709), takže nevzniká zvláštní rámec. V disassembly uvidíš LOAD_FAST_AND_CLEAR místo volání vnořené funkce. Generátorové výrazy dál svůj code objekt mají.
Vyzkoušej si: Počítání odkazů
Vytvářej a ruš odkazy na objekt a sleduj čítač. Ukáže i cyklus, který čítač sám neuvolní.