Poznámky k datovým typům

Python Jiří Znamenáček Poznámky k datovým typům 2011-11-24

proměnné (mutable)	neproměnné (immutable)	typ
—	`int()`	číselný
—	`float()`	číselný
—	`complex()`	číselný
—	`str()`, `''`, `""`	sekvenční
`bytearray()`	`bytes()`, `b''`, `b""`	sekvenční
`list()`, `[]`	`tuple()`, `()`, `,`	sekvenční
—	`range()`	sekvenční
`set()`	`frozenset()`	množinový
`dict()`, `{}`	—	mapovací

PS: Konstruktory základních typů volané funkcí jsou pomalejší než jejich přímé varianty – zatímco přímé variantě odpovídá přímo příslušný bajtkód, nepřímá zahrnuje standardní dohledání odpovídající funkce v seznamu jmen volatelných objektů a teprve poté její následné vykonání.

Naprosto základní věcí, se kterou se musí každý uživatel Python'u sžít, je:

Proměnné (mutable) typy jsou v Python'u předávány odkazem, neproměnné (immutable) hodnotou!

(Na začátku si na tom asi párkrát nabijete nos, ale časem na tuhle nakonec celkem logickou podivnost – zvanou, pokud vůbec nějak, předávání objektem – zvyknete.)

Pro vysvětlení porovnejme kódy na následujících dvou slajdech.

Nejdříve se podíváme na typ proměnný (mutable) (zde zastoupený seznamem):

# A) zde 'xs' a 'ys' označují dva různé objekty >>> xs = ['a', 'h', 'o', 'j'] >>> ys = ['a', 'h', 'o', 'j'] >>> xs.remove('o') >>> xs ['a', 'h', 'j'] >>> ys ['a', 'h', 'o', 'j'] # B) zde jsou 'xs' a 'ys' pouze dvě různá pojmenování téhož objektu >>> xs = ['a', 'h', 'o', 'j'] >>> ys = xs >>> ys ['a', 'h', 'o', 'j'] >>> xs.remove('o') >>> xs ['a', 'h', 'j'] >>> ys ['a', 'h', 'j']

Podobná operace pro typ neproměnný (immutable, zde zastoupený řetězcem) dopadne ale takto:

# Zaveďme řetězcovou proměnnou 'xs'... >>> xs = "jedna" >>> xs 'jedna' # ...a přidejme na ni alias pod jménem 'ys': # (obě jména tedy ukazují na stejný objekt) >>> ys = xs >>> ys 'jedna' # Změňme nyní hodnotu proměnné 'xs': # (jméno 'xs' nyní odkazuje na jiný objekt, protože řetězec nemůžeme změnit) >>> xs = "dva" >>> xs 'dva' # Proměnná 'ys' ovšem nadále odkazuje na původní objekt: >>> ys 'jedna'

S předáváním proměnných z předchozího slajdu souvisí i rozdíl mezi mělkou a hlubokou kopií u složitějších objektů. Ukažme si to na slovnících a seznamech:

>>> xs = ['a', 'b', 'c'] # a) Zaveďme seznam a slovník, které obsahují podseznam.. >>> ys = [1, xs] >>> zs = { 1: xs } # ..a mělce je zkopírujme: >>> ys2 = ys[:] >>> zs2 = zs.copy() # Výsledek je zatím nepřekvapivý: >>> ys [1, ['a', 'b', 'c']] >>> ys2 [1, ['a', 'b', 'c']] >>> zs {1: ['a', 'b', 'c']} >>> zs2 {1: ['a', 'b', 'c']} # b) Odstraňme nyní z podseznamu poslední prvek: >>> xs.pop() 'c' >>> xs ['a', 'b'] # Nyní už se děje něco, co ne každý očekával: >>> ys [1, ['a', 'b']] >>> ys2 [1, ['a', 'b']] >>> zs {1: ['a', 'b']} >>> zs2 {1: ['a', 'b']}

Potřebujeme-li obejít uvedený problém, dává nám Python k dispozici metodu copy.deepcopy():

>>> xs = ['a', 'b', 'c'] # a) Zaveďme seznam a slovník, které obsahují podseznam.. >>> ys = [1, xs] >>> zs = { 1: xs } # ..a hluboce je zkopírujme: >>> import copy >>> ys2 = copy.deepcopy(ys) >>> zs2 = copy.deepcopy(zs) # Výsledek je zatím nepřekvapivý: >>> ys 0: [1, ['a', 'b', 'c']] >>> ys2 1: [1, ['a', 'b', 'c']] >>> zs 2: {1: ['a', 'b', 'c']} >>> zs2 3: {1: ['a', 'b', 'c']} # b) Odstraňme nyní z podseznamu poslední prvek: >>> xs.pop() 4: 'c' >>> xs 5: ['a', 'b'] # Nyní už se to vše chová úplně jinak: >>> ys 6: [1, ['a', 'b']] >>> ys2 7: [1, ['a', 'b', 'c']] >>> zs 8: {1: ['a', 'b']} >>> zs2 9: {1: ['a', 'b', 'c']}

Aby to nebylo tak průhledné – referencovaný objekt můžete klidně zrušit:

# použijme v seznamu odkaz na jiný seznam >>> xs = ['a', 'b', 'c'] >>> ys = [1, xs, 3] >>> ys [1, ['a', 'b', 'c'], 3] # jméno 'xs' použijeme pro jiný objekt, ale Python si zapamatuje, kam dříve odkazoval >>> xs = 666 >>> ys [1, ['a', 'b', 'c'], 3]

Pravda, pak se v něm už nemůžete „hrabat“, takže se zase vyhnete předchozím (možná nečekaným) efektům.

Proměnné (mutable) a neproměnné (immutable) datové typy se od sebe liší tím, že druhé z nich představují objekty s fixní hodnotou (nemohou být tedy změněny), zatímco prvé nikoli. Prakticky to znamená, že neproměnné typy jsou hešovatelné (hashable), což obnáší:

dají se převést na svoji heš-hodnotu, která se během jejich existence nikdy nezmění Tuto hodnotu můžeme zjistit pomocí funkce hash(OBJEKT). Tu na pozadí zajišťuje „magická“ metoda __hash__().
dají se porovnávat s dalšími objekty Porovnatelnost zjišťují porovnávací operátory, přičemž na pozadí stojí „magická“ metoda __eq__().

Hešovatelnost tak umožňuje použít neproměnné typy jako prvky množin a klíče slovníků.

Několik poznámek:

Heš-hodnoty jsou celá čísla.
Rozdílné číselné typy stejné hodnoty mají samozřejmě stejnou heš (aby se porovnávaly stejně):

>>> x, y = 1, 1.0 >>> type(x) <class 'int'> >>> type(y) <class 'float'> >>> hash(x) == hash(y) True

Zdánlivě velmi podobná funkce id(OBJEKT) vrací „identifikátor“ objektu. Ten je po dobu života objektu jedinečný a konstantní, ale dva různé objekty existující v navzájem se nepřekrývajícím čase ho mohou mít stejný.
Instance uživatelem definovaných tříd jsou z principu hešovatelné – porovnávají se jako nerovné a jejich heš-hodnotou je jejich id().

Vzhledem k interní stavbě základních datových struktur Python'u platí pro náročnost operací následující:

seznamy, n-tice, řetězce:
1. náhodný přístup: O(1)
2. dotaz na prvek (in): O(n)
3. vložení/smazání prvku (pouze pro seznamy): O(n)
slovníky, množiny:
1. náhodný přístup: O(1)
2. dotaz na prvek (in): O(1)
3. vložení/smazání prvku: O(1)

Kromě toho u slovníků (a množin) neexistuje lineární uspořádání prvků.

http://www.cis.upenn.edu/~lhuang3/cse399-python/ Rance D. Necaise: „Data Structures and Algorithms Using Python“. John Wiley & Sons, 2011. Je to ještě pravda? V trojkovém Pythonu jsou přece řetězce unicodové a ty si uchované jako pole sice dokážu představit, i když každý znak může zabírat proměnný počet bajtů, ale...

Vynecháme-li rozšiřující moduly, máme v základním Python'u k dispozici tři číselné typy s odpovídajícími konverzními funkcemi:

int() – celá čísla (s libovolnou přesností)
float() – reálná čísla (s přesností aktuální implementace)
complex() – komplexní čísla (jako dvojice reálných čísel)

Uvedené v podstatě konstruktory neproměnných číselných typů mají jednu šikovnou vlastnost – zavolány bez argumentů vrací nulu v odpovídajícím typu:

>>> int() 0 >>> float() 0.0 >>> complex() 0j

Celá a reálná čísla můžeme zapsat několika různými způsoby. U reálných je to ještě poměrně jednoduché..

>>> 3.14 3.14 >>> 3.14e2 314.0 >>> 3.14e-2 0.0314

..ale u celých je způsobů mnohem více:

# klasicky desítkově >>> 26 26 # binárně >>> 0b11010 26 # hexadecimálně >>> 0x1a # nebo 0x1A 26 # oktalově >>> 0o32 26

U komplexních čísel není moc co řešit – písmenka j, resp. J, slouží k označení imaginární části komplexního čísla.

Celá a reálná čísla na sebe můžeme převádět, stejně jako se můžeme pokusit vyextrahovat číslo z řetězce:

>>> float(1) 1.0 >>> int(1.2) 1 >>> float('1.23') 1.23 >>> int('23') 23 Ale celé číslo z „reálného řetězce“ neuděláte: >>> int('1.23') Traceback (most recent call last): File "<pyshell#72>", line 1, in <module> int('1.23') ValueError: invalid literal for int() with base 10: '1.23'

PS: S komplexními čísly to takhle z pochopitelných důvodů nejde.

Funkce int() dokáže zpracovat čísla v nejrůznějších základech:

>>> int("f", base=16) 15 >>> int("10", base=16) 16 >>> int("7", base=8) 7 >>> int("10", base=8) 8 >>> int("2", base=3) 2 >>> int("10", base=3) 3

Řetězce obsahují unicodové znaky, tj. sekvence bajtů, které daným kódováním určují odkazy do tabulky unicodových znaků:

>>> for x in 'ahoj': ... print(x) a h o j

Bajtové řetězce na druhou stranu obsahují pouze bajty, tj. čísla 0-255:

>>> for x in b'ahoj': ... print(x) 97 104 111 106

Znakové a bajtové řetězce mezi sebou můžeme pomocí zvolených kódování navzájem převádět:

>>> xs = '狼.cz' >>> len(xs) 4 # ukázka tří různých způsobů bajtového zakódování téhož řetězce >>> xs.encode('utf-8') b'\xe7\x8b\xbc.cz' >>> len( xs.encode('utf-8') ) 6 >>> xs.encode('gb18030') b'\xc0\xc7.cz' >>> len( xs.encode('gb18030') ) 5 >>> xs.encode('big5') b'\xafT.cz' >>> len( xs.encode('big5') ) 5 # řetězec → bajtový řetězec → řetězec >>> xs.encode('big5').decode('big5') '狼.cz'

Zatímco řetězce a bajtové řetězce jsou neměnné, tak k bajtovým řetězcům existuje proměnný protějšek – bajtová pole:

# A) řetězce >>> xs = 'ahoj' >>> xs[1] 19: 'h' >>> xs[1] = 'H' Traceback (most recent call last): File "<pyshell#39>", line 1, in <module> xs[1] = 'H' TypeError: 'str' object does not support item assignment # B) bajtové řetězce >>> xs = b'ahoj' >>> xs[1] 20: 104 >>> xs[1] = 'H' Traceback (most recent call last): File "<pyshell#42>", line 1, in <module> xs[1] = 'H' TypeError: 'bytes' object does not support item assignment # C) bajtová pole >>> xs = bytearray(b'ahoj') >>> xs 21: bytearray(b'ahoj') >>> xs[1] 22: 104 >>> xs[1] = 72 >>> xs 23: bytearray(b'aHoj')

Řetězce i bajtové objekty typu bytes jsou neměnitelné a tudíž hešovatelné. Bajtová pole jako měnitelný protějšek bajtových řetězců ovšem nikoli:

>>> hash( 'ahoj' ) -1425894204 >>> hash( b'ahoj' ) 1425894204 >>> hash( bytearray(b'ahoj') ) Traceback (most recent call last): File "<pyshell#22>", line 1, in <module> hash( bytearray(b'ahoj') ) TypeError: unhashable type: 'bytearray'

Přirozeným konstruktorem prázdného seznamu je [], seznam s jedním prvkem se zapíše jednoduše jako [a,], přičemž ukončovací čárka není nutná.

U n-tic to už není tak jednoduché: N-tice totiž „vyrábí“ operátor ,, nikoli závorky. N-tice o jednom prvku se tak – kde to jde – zapisuje jako a,, případně se závorkami (a,), jenže prázdnou n-tici získáme přímou notací jen a pouze jako () a žádná čárka tam dokonce být nesmí.

Nebo můžete samozřejmě napsat tuple(), ale to je jasné.

N-tice jsou všude prezentovány jako jakési „zamrzlé“ seznamy. Ve skutečnosti je mezi n-ticemi a seznamy poněkud hlubší rozdíl: Chcete-li kupříkladu zachytit souřadnice konkrétního bodu ve 3D-prostoru jako jeho jakýsi identifikátor (nebudou se tudíž měnit), je zcela přirozené použít pro to n-tici o třech prvcích, která jasně evokuje, že každá z položek n-tice má jistý konkrétní význam (souřadnice x-ová, y-ová a z-ová). Seznam by v tomto případě byl dosti zavádějící – sice by na jednu stranu umožňoval měnit souřadnice objektu, ale na druhou by také umožňoval měnit jejich počet, což má samozřejmě úplně jiné vyznění.

N-tice jsou narozdíl od seznamů neměnné a tudíž hešovatelné (a tudíž použitelné jako prvky množin či jako klíče slovníků):

>>> ts = (1, 2, 3) >>> hash(ts) -378539185 >>> xs = [1, 2, 3] >>> hash(xs) Traceback (most recent call last): File "<pyshell#3>", line 1, in <module> hash(xs) TypeError: unhashable type: 'list'

Nesmíme to ovšem smíchat dohromady:

>>> xs = [1, 2, 3] >>> ts = (1, 2, xs) >>> ts (1, 2, [1, 2, 3]) >>> type(ts) <class 'tuple'> >>> hash(ts) Traceback (most recent call last): File "<pyshell#6>", line 1, in <module> hash(ts) TypeError: unhashable type: 'list' Algoritmus pro „výrobu“ heše jednoduše „cestou“ narazil ve třetí položce n-tice na nehešovatelný typ.

Zatímco skoro všude jsou následující dva zápisy n-tice ekvivalentní..

prvek1, prvek2, prvek3 (prvek1, prvek2, prvek3)

..uvnitř závorek při volání funkcí to už není pravda:

funkce( prvek1, prvek2, prvek3 ) # zavolej funkci se třemi parametry funkce( (prvek1, prvek2, prvek3) ) # zavolej funkci s jedním parametrem

O množinách můžeme celkem bez problémů uvažovat jako o slovnících bez hodnot – prvky množiny stejně jako klíče slovníku musí být jedinečné a navíc oboje neproměnného (a tudíž hešovatelné) typu. Přitom:

Přirozeným konstruktorem prázdného slovníku je {}, slovník s jedním prvkem se zapíše jednoduše jako {KLÍČ: HODNOTA, }, přičemž ukončovací čárka není nutná.
Vzhledem k historické volbě konstruktoru slovníku to s množinou už bohužel není tak jednoduché – prázdnou množinu tak získáme pouze pomocí konstruktoru set() a jinak to nejde. Delší množiny už jsou od slovníků snadno k rozeznání, protože neobsahují dvojtečku: {PRVEK, } (čárka při tom opět není povinná)

Narozdíl od dychotomie mezi n-ticemi a seznamy, kde souvislost „neměnná n-tice – proměnný seznam“ není zcela košer, u množin je to jednoduché: Potřebujeme-li neproměnnou množinu (a tudíž i hešovatelnou), využijeme konstrukturu frozenset(). Tuto „zamrzlou“ množinu je pak samozřejmě možné používat jako prvek jiných množin nebo klíč do slovníků.

Slovníky a množiny jako proměnné typy hešovatelné nejsou, zmražené množiny jako typ neproměnný pak ano:

# zmražená množina >>> hash( frozenset({1,}) ) 593349751 # množina >>> hash( {1,} ) Traceback (most recent call last): File "<pyshell#58>", line 1, in <module> hash( {1,} ) TypeError: unhashable type: 'set' # slovník >>> hash( {1: 1,} ) Traceback (most recent call last): File "<pyshell#57>", line 1, in <module> hash( {1: 1,} ) TypeError: unhashable type: 'dict'

Ačkoli operace ds.clear() a ds = {} poskytnou pro (předtím již existující) slovník ds stejný výsledek, je mezi nimi velký rozdíl z hlediska vnitřní (nejen paměťové) náročnosti obou operací:

ds.clear() vezme existující slovník (tedy jisté místo v paměti, ke kterému se interpretr chová jako ke slovníku) a jednoduše ho vyprázdní.
ds = {} nejdříve vyrobí nový prázdný slovník (tedy zabere úplně nové místo v paměti, které připraví tak, aby s ním mohl zacházet jako se slovníkem) a teprve poté přemapuje jméno z původního slovníku (který tak celý zůstane „viset“ v paměti, než ho při svém příštím běhu „smaže“ garbage collector) na tento nový.

Proto při zadání.. >>> d1 = d2 = { 'a': 1, 'b': 123, } >>> d1 {'a': 1, 'b': 123} >>> d2 {'a': 1, 'b': 123} ..metoda clear() smaže (v paměti) příslušný objekt, na nějž ukazují dvě jména.. >>> d1.clear() >>> d1 6: {} >>> d2 7: {} ..ale přiřazení jména prázdnému slovníku dopadne pochopitelně úplně jinak: >>> d1 = {} >>> d1 {} >>> d2 {'a': 1, 'b': 123}

Úplně to samé platí pro množiny, které nepřekvapivě mají metodu clear() také k dispozici.

Rozsahy se konstruují pomocí funkce range(). Na první pohled se tváří jako sekvence, ale nepodporují výřezy (slicing), spojování (concatenation) ani opakování (repetition):

>>> xs = range(10) >>> xs range(0, 10) >>> xs[5] 5 # výřez >>> xs[:3] Traceback (most recent call last): File "<pyshell#50>", line 1, in <module> xs[:3] TypeError: sequence index must be integer, not 'slice' # spojování >>> xs + range(3) Traceback (most recent call last): File "<pyshell#51>", line 1, in <module> xs + range(3) TypeError: unsupported operand type(s) for +: 'range' and 'range' # opakování >>> 2 * xs Traceback (most recent call last): File "<pyshell#52>", line 1, in <module> 2 * xs TypeError: unsupported operand type(s) for *: 'int' and 'range' Jinými slovy typ je to sice iterovatelný, ale nikoli sekvenční.

Podobně používat na nich operátorů in, not in a funkcí min(), max() sice jde, ale není to moc efektivní, protože rozsah je kvůli nim třeba nejdříve vyrobit (což „poněkud“ nabourává jeho pojetí jako líné datové struktury, alespoň v Python'u 3.x):

>>> 6 in range(10) True >>> 10 in range(10) False >>> max( range(10) ) 9 >>> min( range(10) ) 0

Prakticky všechny iterovatelné typy se dají převádět navzájem na sebe. Pár příkladů:

>>> xs = 'ahoj' >>> tuple(xs) ('a', 'h', 'o', 'j') >>> list(xs) ['a', 'h', 'o', 'j'] >>> xs = 'ahoj ahoj' >>> set(xs) {'a', 'h', 'j', 'o', ' '}

Převody mezi čísly a řetězci jsme už viděli na dřívějším slajdu:

>>> float(1) 1.0 >>> int(1.2) 1 >>> float('1.23') 1.23 >>> int('23') 23

Jak jsme viděli, složitější datové typy (jako seznamy či slovníky) se v Python'u skládají z libovolných typů. Například zde jsou prvky slovníku seznamy:

ds = { 1: [1, 2, 3], 2: [4, 5, 6], }

Všimněte si následující důležité vlastnosti vybírání prvků (nejen) ze slovníku ds:

# Prvkem odpovídajícím klíči 1 slovníku je seznam „[1, 2, 3]“.. >>> ds[1] [1, 2, 3] # ..a proto jeho prvkem na indexu 2 je číslo „3“: >>> ds[1][2] 3 Komu to připadá na první pohled zmatené, rozložte si na chvilku uvedený kód takhle: >>> prvek_slovníku_s_klíčem_1 = ds[1] >>> prvek_slovníku_s_klíčem_1 [1, 2, 3] >>> prvek_slovníku_s_klíčem_1[2] 3 „Fór“ je v tom, že pro adresování podtypů typů nemusíte žádné pomocné proměnné zavádět – prostě se rovnou odkážete na příslušný typ a následně pak jeho prvky.

Toto adresování prvků typů v typech funguje samozřejmě pro libovolné typy a do libovolné hloubky:

# Seznam obsahující dvojce, jejichž prvky je číslo a řetězec: >>> xs = [ ... (1, 'první'), ... (2, 'druhý'), ... (3, 'třetí'), ... ] # Druhým prvkem (tedy prvkem na indexu 1) daného seznamu je uvedená dvojce: >>> xs[1] (2, 'druhý') # Druhým prvkem (tedy prvkem na indexu 1) dané dvojce je uvedený řetězec: >>> xs[1][1] 'druhý' # Druhým prvkem (tedy prvkem na indexu 1) daného řetězce je uvedené písmeno: >>> xs[1][1][1] 'r'

Mimochodem – dejte si pozor, abyste si omylem neměnili datovou strukturu pod rukama, když nechcete ^_~

„Chudák“ iterátor, který zajišťuje průchod po prvcích řetězce, pečlivě v každém kole přičte k poslednímu indexu jedničku, ale nemá ani ponětí, že jste mu pod rukama vyměnili přiřazení indexů na prvky.