Lidsky řečeno
Sdílený dokument v cloudu a jeho odkaz. Když kolegovi pošleš odkaz, nedostane vlastní dokument. Oba koukáte na tentýž a každá jeho úprava se objeví i u tebe. Chceš-li, aby si v něm dělal, co chce, musíš mu poslat kopii. Proměnné v Pythonu jsou takové odkazy.
Dvě jména, jeden seznam
Tenhle kód vypadá nevinně. Chtěl sis udělat zálohu nákupního seznamu a do ní připsat máslo.
nakup = ["chleba", "mléko"]
zaloha = nakup
zaloha.append("máslo")
print(nakup)
print(zaloha)
print(zaloha is nakup)
['chleba', 'mléko', 'máslo'] ['chleba', 'mléko', 'máslo'] True
Máslo je v obou. Přiřazení = totiž nic nekopíruje. Jen přilepí další jméno na tentýž objekt. Takovému ukazateli na objekt se říká reference. Operátor is se ptá, jestli jsou dvě jména opravdu tentýž objekt.
nakup ──┐
├──► ["chleba", "mléko", "máslo"]
zaloha ──┘Rozliš dvě různé věci, které vypadají podobně. Přelepit štítek znamená přiřadit jménu něco jiného. Změnit objekt znamená sáhnout dovnitř. To první druhé jméno neovlivní, to druhé ano.
a = [1, 2]
b = a
b = [9, 9] # štítek b se přelepil jinam
print(a, b)
c = [1, 2]
d = c
d[0] = 9 # změna uvnitř sdíleného seznamu
print(c, d)
[1, 2] [9, 9] [9, 2] [9, 2]
Co se změnit dá
Některé objekty mají metody a operace, které je mění na místě. Jsou měnitelné (mutable). Jiné zůstávají navždy stejné a každá „změna“ vytvoří nový objekt. Ty jsou neměnné (immutable).
| Neměnné | Měnitelné |
|---|---|
int, float, bool, None | list |
str, bytes | dict |
tuple, frozenset | set |
Proto si u čísel a textů sdílení nikdy nevšimneš. Není co změnit. Záludný je operátor +=: u neměnných hodnot vytvoří novou a přelepí štítek, u seznamu mění původní objekt.
x = 5
y = x
x += 1
print(x, y)
text = "ahoj"
kopie_textu = text
text += "!"
print(text, kopie_textu)
s = [1]
t = s
s += [2]
print(s, t)
u = [1]
v = u
u = u + [2]
print(u, v)
6 5 ahoj! ahoj [1, 2] [1, 2] [1, 2] [1]
Poslední dva případy vypadají stejně, ale liší se. s += [2] rozšíří existující seznam. u = u + [2] postaví nový seznam a jméno u přelepí na něj, takže v zůstává u starého.
Co vypíše tento kód: a = [1], b = a, b = b + [2], print(a)?
b + [2] vytvořilo nový seznam a b teď ukazuje na něj. Původní seznam, na který pořád ukazuje a, se nezměnil.
Mělká kopie
Skutečná kopie seznamu se dělá jedním ze tří rovnocenných způsobů. Slovník a množina mají také .copy().
puvodni = [1, 2, 3]
a = puvodni.copy()
b = list(puvodni)
c = puvodni[:]
a.append(4)
print(puvodni, a)
print(b == puvodni, b is puvodni)
print(c == puvodni, c is puvodni)
[1, 2, 3] [1, 2, 3, 4] True False True False
Tohle je mělká kopie. Vznikne nová vnější schránka, ale položky uvnitř jsou pořád ty samé objekty. U čísel a textů to nevadí. Problém přijde s vnořenými daty. Aplikace má výchozí nastavení a každý uživatel si z něj vezme kopii.
vychozi = {"tema": "tmavé", "upozorneni": {"email": True, "sms": False}}
eva = vychozi.copy()
eva["tema"] = "světlé"
eva["upozorneni"]["sms"] = True
print(vychozi)
print(eva)
print(eva["upozorneni"] is vychozi["upozorneni"])
{'tema': 'tmavé', 'upozorneni': {'email': True, 'sms': True}}
{'tema': 'světlé', 'upozorneni': {'email': True, 'sms': True}}
TrueTéma se změnilo jen Evě. Jenže SMS si tím Eva zapnula všem budoucím uživatelům, protože vnitřní slovník je sdílený.
vychozi ──► { "tema": "tmavé", "upozorneni": ─┐ }
├──► {"email": True, "sms": True}
eva ──► { "tema": "světlé", "upozorneni": ─┘ }Opravdová záloha
Oprav druhý řádek tak, aby zaloha byla samostatný seznam a zůstaly v ní jen původní dvě položky.
nakup = ["chleba", "mléko"]
zaloha = nakup
nakup.append("máslo")
Hluboká kopie
Funkce copy.deepcopy projde celou strukturu a zkopíruje všechno, co je měnitelné, do libovolné hloubky. Výsledek s originálem nesdílí nic, co by se dalo změnit.
import copy
vychozi = {"tema": "tmavé", "upozorneni": {"email": True, "sms": False}}
eva = copy.deepcopy(vychozi)
eva["upozorneni"]["sms"] = True
print(vychozi["upozorneni"])
print(eva["upozorneni"])
print(eva["upozorneni"] is vychozi["upozorneni"])
{'email': True, 'sms': False}
{'email': True, 'sms': True}
FalseStejný problém se sdílením se umí schovat i do zápisu, kde žádnou kopii nečekáš. Násobení seznamu nekopíruje obsah, ale opakuje reference. Totéž dělá dict.fromkeys se seznamem jako výchozí hodnotou. Herní plán nebo tabulka se proto stavějí přes comprehension, kde každý průchod vytvoří nový vnitřní seznam.
spatne = [[0] * 3] * 3
spatne[0][0] = 1
print(spatne)
print(spatne[0] is spatne[1])
dobre = [[0] * 3 for _ in range(3)]
dobre[0][0] = 1
print(dobre)
skupiny = dict.fromkeys(["a", "b"], [])
skupiny["a"].append(1)
print(skupiny)
[[1, 0, 0], [1, 0, 0], [1, 0, 0]]
True
[[1, 0, 0], [0, 0, 0], [0, 0, 0]]
{'a': [1], 'b': [1]}Jméno _ je zvyklost pro proměnnou, kterou nebudeš potřebovat.
Co vypíše tento kód: a = [[1]], b = a.copy(), b[0].append(2), print(a)?
copy je mělká kopie. a a b jsou různé vnější seznamy, ale vnitřní seznam mají společný.
Faktura ze šablony
Kód upravuje novou fakturu, ale ničí šablonu. Oprav vytvoření proměnné nova, aby sablona zůstala přesně taková, jaká je.
import copy
sablona = {"nazev": "Faktura", "polozky": [{"text": "Práce", "cena": 1000}]}
nova = sablona.copy()
nova["polozky"][0]["cena"] = 2500
nova["polozky"].append({"text": "Doprava", "cena": 300})
Jeden křížek, ne tři
Křížek se má objevit jen uprostřed, ale kvůli sdíleným řádkům je ve všech. Oprav vytvoření mrizka.
mrizka = [["."] * 3] * 3
mrizka[1][1] = "X"
Funkce a cykly
Funkce uvidíš podrobně v dalším modulu. Teď stačí vědět, že def pojmenuje kus kódu, který v závorce dostane hodnoty ke zpracování. Funkce dostane referenci na tentýž objekt, ne jeho kopii. Když do něj sáhne, uvidíš to i venku. Když jen přelepí svůj štítek, venku se nestane nic.
def pridej_darek(kosik):
kosik.append("dárek")
def vymen_kosik(kosik):
kosik = ["něco jiného"]
muj = ["kniha"]
pridej_darek(muj)
print(muj)
vymen_kosik(muj)
print(muj)
['kniha', 'dárek'] ['kniha', 'dárek']
Úklid bez přeskakování
Kód má ze seznamu cisla odstranit záporná čísla, ale některá přeskočí. Oprav ho tak, aby v cisla zůstalo [3, 5, 7].
cisla = [3, -1, -2, 5, -4, -6, 7]
for cislo in cisla:
if cislo < 0:
cisla.remove(cislo)
is nebo ==
== se ptá, jestli mají dva objekty stejnou hodnotu. is se ptá, jestli jsou jeden a tentýž objekt. Dvojčata jsou si rovná, ale nejsou jedna osoba. Skoro vždy chceš ==. Hlavní výjimka je test na None, kterého existuje jediný kus.
a = [1, 2]
b = [1, 2]
print(a == b)
print(a is b)
vysledek = None
print(vysledek is None)
True False True
Kdy je správné použít is?
U textů a čísel tě zajímá hodnota. Občas is náhodou vyjde, protože si CPython některé objekty drží v jednom exempláři, ale spolehnout se na to nedá.
Pod kapotou · identita, reference a co dělá copy
Proměnná v CPythonu je jméno navázané na PyObject*. Každý objekt má počítadlo referencí a při nule se okamžitě uvolní. Cykly dořeší garbage collector, viz Paměť, garbage collector a bytecode. Předávání argumentů se říká call by sharing: není to předání hodnotou ani referencí, jak ji zná C++.
Identitu malých neměnných hodnot nelze brát vážně. CPython drží jediné instance čísel −5 až 256, kompilátor sloučí stejné konstanty v jedné kompilační jednotce a část řetězců internuje. Od verze 3.12 jsou None, True a podobné objekty nesmrtelné (PEP 683): počítadlo se u nich nemění, takže se kvůli nim po fork zbytečně nekopírují paměťové stránky.
import copy
import sys
a = 1000
b = 1000
c = int("1000")
print(a is b, a == c, a is c)
print(int("100") is int("100"), int("257") is int("257"))
print(sys.getrefcount(None) > 1_000_000)
t = ([1], 2)
try:
t[0] += [99]
except TypeError as chyba:
print(chyba)
print(t)
smycka = []
smycka.append(smycka)
klon = copy.deepcopy(smycka)
print(klon[0] is klon, klon is smycka)
cista = (1, "a")
smisena = (1, [2])
print(copy.deepcopy(cista) is cista, copy.deepcopy(smisena) is smisena)
True True False True False True 'tuple' object does not support item assignment ([1, 99], 2) True False True False
Rozbor výstupu:
t[0] += [99]je čtení,list.__iadd__a pak zápis zpět do n-tice. Seznam se změní a potom spadne přiřazení. Výjimka a provedená změna současně.list.__iadd__je v podstatěextend, takžes += "ab"projde a přidá dva znaky, kdežtos + "ab"jeTypeError.deepcopysi vedememo(id originálu na kopii), proto zvládne cykly a zachová sdílení uvnitř struktury. Neměnný kontejner vrátí beze změny, pokud se žádná jeho položka nezkopírovala.
V praxi:
deepcopyje pomalý, protože v Pythonu prochází každý objekt, a v horké cestě bývá znát. Lepší je data nesdílet: skládat nové struktury, používat neměnné typy, nebo vystavit konstanty přestypes.MappingProxyType(pozor, chrání jen první úroveň).deepcopyobjektu se zámkem nebo otevřeným spojením skončíTypeError: cannot pickle .... Řeší se metodou__deepcopy__.- Výchozí hodnota parametru se vyhodnotí jednou při
def. Proto jedef f(x, acc=[])sdílený stav mezi voláními, viz Parametry a výchozí hodnoty. a[:]je kopie jen u seznamu. Řez pole v NumPy je pohled na stejná data, takže zápis do něj mění originál.
Vyzkoušej si: Alias, mělká a hluboká kopie
Změň vnořený seznam a podívej se, které kopie se změní spolu s ním.