Bajtové řetězce jsou neproměnnýsekvenční datový typ, jehož prvky jsou celá čísla v rozmezí <0, 255> (tedy vlastně sekvence bajtů).
Existuje k nim i příslušný proměnný protějšek – bajtová pole (vlastně seznamy bajtů). Rozdíl mezi těmito dvěma objekty je podobný, jako mezi řetězci na jedné straně a seznamy znaků na straně druhé – oboje vypsané po prvcích dá to samé, ale do řetězců nemůžeme „hrabat“, zatímco se seznamy si můžeme dělat, co chceme.
PS: Narozdíl od Python'u 2.x, kde jste si práci s unicodovými řetězci museli explicitně vyžádat a jinak bylo všechno jakýmsi tajemně se konvertujícím bajtovým objektem, musíte si naopak v Python'u 3.x explicitně vyžádat práci s bajtovými objekty a k žádným konverzím bez vašeho zapřičinění nedochází. *SLÁVA*
Bajtový řetězec je v podstatě „řetězec bajtů“, a tak ho nepřekvapivě nejsnáze zavedeme pomocí přímé (literal) notace jako řetězec s identifikátorem b:
>>> xb = b"ahoj"
>>> xb
b'ahoj'
>>> type(xb)
<class 'bytes'>
Jelikož různých znaků vyjádřitelných pomocí jednoho bajtu je právě 256 a znich pouze část spodní poloviny představuje tisknutelné znaky (stará dobrá ASCII-tabulka), setkáte se s bajtovými literály spíše v podobě hexadecimální, např. b'\xf0\xf1\xf2'.
Podobně jako u tzv. „raw-řetězců“ můžete k identifikaci bajtových řetězců použít i velké písmeno B:
Řetězce obsahují unicodové znaky, tj. sekvence bajtů, které daným kódováním určují odkazy do tabulky unicodových znaků:
>>> [x for x in 'ahoj']
['a', 'h', 'o', 'j']
Bajtové řetězce na druhou stranu obsahují pouze bajty, tj. čísla 0-255:
>>> [x for x in b'ahoj']
[97, 104, 111, 106]
A nepřekvapivě tedy platí například následující srovnání:
b'\x61\x68\x6f\x6a' == b'ahoj' # hexadecimálně
b'\141\150\157\152' == b'ahoj' # oktalově
S výjimkou metod encode(), format() a isidentifier() sdílejí bajtové řetězce s řetězci unicodovými také stejné atributy:
>>> dir(xb)
['__add__', '__class__', '__contains__', '__delattr__', '__doc__', '__eq__',
'__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__',
'__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__',
'__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__',
'__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__',
'capitalize', 'center', 'count', 'decode', 'endswith', 'expandtabs', 'find',
'fromhex', 'index', 'isalnum', 'isalpha', 'isdigit', 'islower', 'isspace',
'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans',
'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit',
'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title',
'translate', 'upper', 'zfill']
Většina z nich nám ale pro práci s bajtovými objekty moc užitečná není. Pokud ovšem nepracujete třebas na úrovni ASCII (síťové protokoly a podobně), kde se pak k bajtovým řetězcům můžete chovat jako ke skutečným a ušetříte si odbočku do UTF-8 se všemi z toho plynoucími komplikacemi.
Druhou variantou zavedení bajtového řetězce je pomocí funkce bytes(). Narozdíl od přímé notace její použití už není tak snadné a přímočaré – výsledek totiž závisí na typu vstupního parametru:
Při volání bez parametru zavede funkce bytes() bajtový řetězec o nulové délce:
>>> xb = bytes()
>>> xb
b''
Je-li vstupním parametrem řetězec, musíme navíc přidat i kódování, které bude řídit jeho transformaci na bajtový řetězec:
>>> xb = bytes('Ahoj!', 'utf-8')
>>> xb
b'Ahoj!'
Na pozadí se zavolá metoda řetězce 'Ahoj!'.encode('utf-8'), která provede příslušnou konverzi.
Při vstupním parametru celé číslo je vytvořen bajtový řetězec odpovídající délky obsahující samé nuly:
Další možností je zadat na vstupu iterovatelný objekt (iterable), který vrací čísla v rozmezí <0, 255>. Tato čísla budou následně použita pro inicializaci (bajtového) řetězce.
Tohle je mimochodem způsob, jak převést jedno konkrétní číslo na bajt – kód bytes([123]) převede číslo 123 na odpovídající bajtovou hodnotu 0x7b (která se umí zobrazit jako b'{', protože náleží do tisknutelné části spodní poloviny ASCII-tabulky).
Poslední možností je použít na vstupu bafr (buffer), v klasickém případě tedy odkaz na otevřený soubor. V takovém případě se pro inicializaci bajtového řetězce použijí data (jednotlivé bajty) z bafru.
Stejně jako unicodové řetězce podporují bajtové řetězce tradiční sekvenční operace:
>>> xb = b'ahoj'
# délka sekvence
>>> len(xb)
4
# konkrétní prvek
>>> xb[3]
106
>>> xb[-3]
104
# různé výřezy
>>> xb[1:3]
b'ho'
>>> xb[1::2]
b'hj'
>>> xb[2:]
b'oj'
>>> xb[-3:]
b'hoj'
# dotaz na výskyt prvku
>>> 111 in xb
True
>>> 110 in xb
False
>>> b'a' in xb
True
>>> b'\xf1' in xb
False
>>> xb.index(b'h')
1
>>> xb.index(b'D')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: substring not found
>>> xb.count(b'a')
1
# dvě spojené kopie
>>> xb * 2
b'ahojahoj'
Na předchozím slajdu jste si mohli všimnout, že přístup k prvkům bajtového řetězce není tak úplně konzistentní s pojmenováním „řetězec“ – pro více prvků obdržíte (bajtový) řetězec, pro jeden prvek ovšem dostanete číslo:
U (normálního) řetězce je jeden prvek prostě zase jen řetězec, byť jednoprvkový, takže má stejné vlastnosti. U bajtového řetězce se vlastnosti jednoprvkového výřezu těžce odlišují od vlastností výřezu delšího – prostě je to úplně jiný typ (celé číslo). Tak pozor na to.
„Well, it's not a bug, it's a feature.“
A samozřejmě máme k dispozici i oblíbenou smyčku for-in ve všech jejích variantách:
>>> xb = b'ahoj'
>>> for x in xb:
... print(x)
...
97
104
111
106
>>> for i, x in enumerate(xb):
... print(i, x)
...
0 97
1 104
2 111
3 106
>>> for x in reversed(xb):
... print(x)
...
106
111
104
97
>>> for x in sorted(xb):
... print(x)
...
97
104
106
111
Stejně jako „obyčejné“ unicodové řetězce jsou řetězce bajtové neměnné (immutable):
>>> xb = b'ahoj'
>>> xb[1]
104
>>> xb[1] = b'H'
Traceback (most recent call last):
File "<pyshell#42>", line 1, in <module>
xb[1] = b'H'
TypeError: 'bytes' object does not support item assignment
Jedna z užitečných metod, která bajtovým řetězcům oproti jejich unicodovým bráškům chybí, je format() (a s ní i formátované řetězce – fb'' bohužel opravdu neprojde). Světe ale div se, funguje interpolace pomocí starší varianty s operátorem %:
# jeden bajt
>>> b'%c' % 66
b'B'
>>> b'%c' % b'B'
b'B'
# delší bajtový řetězec
>>> b'%b' % b'abc'
b'abc'
>>> b'%b' % bytearray([65, 66, 67])
b'ABC'
# reprezentace objektu
>>> b'%a' % 3.14
b'3.14'
>>> b'%a' % 'abc'
b"'abc'"
>>> b'%a' % b'abc'
b"b'abc'"
%a je vlastně ekvivalentem repr(OBJEKT).encode('ascii', 'backslashreplace'). Příklady převzaty z dokumentace.
Kromě uvedených formátovacích kódů (a několika dalších kvůli kompatibilitě s řadou 2.x) podporuje procentítková interpolace všechny ostatní existující.
PS: Popravdě to ale ve trojkové řadě funguje až od verze 3.5, kdy byly konečně vyslyšeny hlasy pythoních nízkoúrovňových programátorů (ne všichni kvůli tomu jedou Céčko ;-) a do Python'u byla vrácena funkcionalita dvojkové řady. Ostatně to byla jedna z velkých kritik a hlavních důvodů, proč v těchto případech zůstat u Python'u 2.x.
Na úrovni binárních dat představují textové řetězce jisté sekvence bajtů. Přitom typicky podle zvoleného kódování zabírají různé znaky různý počet bajtů. Python poskytuje metody pro konverzi mezi řetězci a jejich odpovídajícím bajtovým vyjádřením.
Konverzi řetězce na odpovídající bajtový řetězec zajišťuje metoda řetězceencode(KÓDOVÁNÍ). Ukažme si pro příklad tři různé způsoby bajtového zakódování téhož řetězce:
# Testovací řetězec o délce čtyř (unicodových) znaků:
>>> xs = '狼.cz'
>>> len(xs)
4
# a) v kódování UTF-8 zabírá šest bajtů
>>> xs.encode('utf-8')
b'\xe7\x8b\xbc.cz'
>>> len( xs.encode('utf-8') )
6
# b) v kódování GB18030 zabírá pět bajtů
>>> xs.encode('gb18030')
b'\xc0\xc7.cz'
>>> len( xs.encode('gb18030') )
5
# c) v kódování Big5 zabírá jiných pět bajtů než v předchozím kódování
>>> xs.encode('big5')
b'\xafT.cz'
>>> len( xs.encode('big5') )
5
Metoda encode() tedy vezme řetězec a znak po znaku ho při zvoleném kódování převede na odpovídající sekvenci bajtů (často delší).
Zpětnou konverzi z bajtového řetězce na textový řetězec (při daném kódování) zajišťuje metoda bajtového řetězcedecode(KÓDOVÁNÍ). Příklad:
# Testovací řetězec:
>>> xs = '狼.cz'
# Převod „tam a zpět“ je pochopitelně jednoznačný:
# řetězec → bajtový řetězec → řetězec
>>> xs.encode('big5').decode('big5')
'狼.cz'
Metoda decode() tedy vezme bajtový řetězec a podle zvoleného kódování ho po odpovídajících skupinách bajtů převede na odpovídající sekvenci znaků (často kratší).
PS: Častěji ale budou bajtové objekty představovat „skutečná“ binární data, např. obrázek nebo zvuk. Pak jsou samozřejmě výše uvedené konverze k ničemu, protože takováto data málokdy budou mít rozumnou textovou podobu.