0 dní v řadě · 0 bodů

Datové struktury · 22 min

Reference, mutabilita a kopie

Pochopíš, proč změna „kopie“ někdy rozbije originál, co je měnitelný objekt a kdy stačí mělká a kdy hluboká kopie.

Hloubka
Úkoly
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)
Výstup
['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.

text
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)
Výstup
[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, Nonelist
str, bytesdict
tuple, frozensetset

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

Kvíz

Co vypíše tento kód: a = [1], b = a, b = b + [2], print(a)?

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)
Výstup
[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"])
Výstup
{'tema': 'tmavé', 'upozorneni': {'email': True, 'sms': True}}
{'tema': 'světlé', 'upozorneni': {'email': True, 'sms': True}}
True

Té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ý.

text
vychozi ──► { "tema": "tmavé",  "upozorneni": ─┐ }
                                               ├──► {"email": True, "sms": True}
eva     ──► { "tema": "světlé", "upozorneni": ─┘ }
Úkol

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

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"])
Výstup
{'email': True, 'sms': False}
{'email': True, 'sms': True}
False

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

Kvíz

Co vypíše tento kód: a = [[1]], b = a.copy(), b[0].append(2), print(a)?

Úkol

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

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

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)
Výstup
['kniha', 'dárek']
['kniha', 'dárek']
Úkol

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

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)
Výstup
True
False
True
Kvíz

Kdy je správné použít is?

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)
Výstup
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že s += "ab" projde a přidá dva znaky, kdežto s + "ab" je TypeError.
  • deepcopy si vede memo (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:

  • deepcopy je 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řes types.MappingProxyType (pozor, chrání jen první úroveň).
  • deepcopy objektu 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 je def 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.