![]() |
![]() |
![]() |
![]() |
![]() |
![]() |
Seznam (list
) je uspořádaná sekvence hodnot libovolného typu. Jednotlivým hodnotám říkáme položky a tyto položky jsou měnitelné.
Položkou seznamu může být i další seznam. Takový seznam se nazyvá vnořený seznam.
Nový seznam vytvoříme nejjednodušeji uzavřením položek do hranatých závorek:
[10, 20, 30, 40] ["spam", "bungee", "swallow"]
Prvním příkladem je seznam čtyř celých čísel. Druhým je seznam tří řetězců. Položky seznamu nemusí být stejného typu. Následující seznam obsahuje řetězec, float, integer a (mirabile dictu!) další seznam:
["hello", 2.0, 5, [10, 20]]
Seznamu uvnitř jiného seznamu říkáme, že je vnořený.
Konečně, existuje speciální seznam, který neobsahuje žádné položky. Nazývá se prázdný seznam a značí se [ ].
Stejně jako číselná hodnota 0 a prázdný řetězec, je prázdný seznam nepravdivý v booleovských výrazech:.
>>> bool(["hello", 2.0]) True >>> bool([]) False >>>
Vytvořený seznam můžeme samozřejmě přiřadit k proměnné nebo zadat jako parametr či argument funkce.
>>> vocabulary = ["ameliorate", "castigate", "defenestrate"] >>> numbers = [17, 123] >>> empty = [] >>> print(vocabulary, numbers, empty) ['ameliorate', 'castigate', 'defenestrate'] [17, 123] []
Funkce list(~) vytvoří seznam a jako argument přijímá hodnoty typu str, bytes, bytearray, tuple, range, dict, set, frozenset, neboli všechny kontejnery (sekvence a kolekce), zadané jako jeden argument. Společnou vlastností argumentů je to, že to jsou všechno iterábly - viz Kap. 4.6.
>>> list("osel")# typ str ['o', 's', 'e', 'l'] >>> list(b"osel")# typ bytes [111, 115, 101, 108] >>> list(("a", 5, True))# typ tuple ['a', 5, True] >>> list(range(4))# typ range [0, 1, 2, 3] >>> list({"a", 5, True})# typ set [True, 5, 'a'] >>> list({"a":2, "b":False, "c":"d"})# typ dict ['a', 'b', 'c']
Převod řetězce na seznam s manipulací lze provést metodou split - viz kapitola 9.1
Komprehenci (viz odstavec 8.10) použijeme hlavně při úpravě stávajícího seznamu.
Syntaxe pro přístup k položkám seznamu je stejná jako syntaxe pro přístup ke znakům řetězce – pomocí hranatých závorek s indexem. Nezapomeňte, že indexy začínají nulou:
>>> nested = ["hello", 123, [10,20]] >>> print(nested[1]) 123
Jako index lze použít jakýkoli celočíselný výraz:
>>> nested[9-8]# == 1 123 >>> nested[1.0] Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: list indices must be integers
Pokusíme-li se číst nebo psát položku, která neexistuje, dostaneme chybu při běhu programu:
>>> nested[3] Traceback (most recent call last): File "<stdin>", line 1, in <module> IndexError: list index out of range
Má-li index zápornou hodnotu, počítá se od konce seznamu:
>>> nested[-1] [10, 20] >>> nested[-3] 'hello' >>> numbers[-4] Traceback (most recent call last): File "<stdin>", line 1, in <module> IndexError: list index out of rangenumbers[-1] je poslední položka seznamu, numbers[-4] zde neexistuje.
Pro prvek vnořeného seznamu uvedeme rovněž jeho index:
>>> nested[2][1] 20
Je obvyklé použít proměnnou jako index seznamu:
horsemen = ["war", "famine", "pestilence", "death"] i = 0 # proměnná pro smyčku - počítadlowhile
i < 4:
Tato smyčka počítá od 0 do 4. Jakmile má proměnná hodnotu 4, podmínka nevyhoví a smyčka končí. Takže tělo smyčky je provedeno pro i = 0, 1, 2 a 3.
Při každém cyklu smyčky je proměnná i použita jako index položky, která se tiskne. Tento způsob výpočtu se nazývá traverzování seznamem.
Funkce len vrací délku seznamu, což je počet jeho položek. Tato hodnota se výhodně používá jako horní mez smyčky místo konstanty. Tím si zajistíme, že pokaždé, když se změní velikost seznamu, nemusíme procházet programem, abychom opravili všechny dotčené smyčky:
horsemen = ["war", "famine", "pestilence", "death"] i = 0while
i <len
(horsemen):
Po posledním provedením těla smyčky je i=len(horsemen)-1, což je index poslední položky. Je-li i=len(horsemen), podmínka není splněna a tělo se neprovede.
I když jeden seznam může obsahovat další seznam, ten vnořený se stále počítá jako jedna položka. Délka tohoto seznamu je 4:
['spam!', 1, ['Brie', 'Roquefort', 'Pol le Veq'], [1, 2, 3]]
Traverzování i vnořeným seznamem popisuje text kap. 13.2.
U seznamu lze uplatnit stejné operace jako u řetězců - viz 6.5.1
Operátor +
zřetězí seznamy:
>>> a = [1, 2, 3] >>> b = [4, 5, 6] >>> c = a + b >>> print( c ) [1, 2, 3, 4, 5, 6]
Podobně, operátor *
opakuje seznam v zadaném počtu:
>>> [0]*4 [0, 0, 0, 0] >>> [1, 2, 3]*3 [1, 2, 3, 1, 2, 3, 1, 2, 3]
První příklad opakuje [0] čtyřikrát. Druhý příklad opakuje seznam [1, 2, 3] třikrát.
Pro seznamy neexistuje modul list
jako existuje modul string
pro řetězce.
Podrobnosti o metodách nejlépe zjistíme na stránce List Methods & Functions nebo programiz.com, kde nalezneme popis skladby i s příklady pro tyto metody a funkce:
Metody append, extend, index, insert, clear, copy, count, pop, remove, reverse, sort, splitjsou společnéi pro řetězce Funkce len, max, minjsou společné pro všechny iterábly list
Klíčové slovo in je booleovský operátor, který testuje příslušnost prvku k sekvenci. Použili jsme jej už u řetězců a pracuje také se seznamy a s jinými uspořádanými množinami:
>>> horsemen = ['war', 'famine', 'pestilence', 'death'] >>> 'pestilence'in
horsemen True >>> 'debauchery'in
horsemen False
Protože pestilence je částicí seznamu horsemen, vrátí operátor in hodnotu True. Jelikož debauchery v seznamu není, vrátí False.
Můžeme použít slovo not ve spojení s in, abychom ověřili, že položka není částicí seznamu:
>>> 'debauchery' not in
horsemen
True
Operace s úseky, které jsme poznali u řetězců, platí také u seznamů:
>>> a_list = ['a', 'b', 'c', 'd', 'e', 'f'] >>> a_list[1:3] ['b', 'c'] >>> a_list[:4] ['a', 'b', 'c', 'd'] >>> a_list[3:] ['d', 'e', 'f'] >>> a_list[:] ['a', 'b', 'c', 'd', 'e', 'f']
Na rozdíl od řetězců jsou seznamy měnitelné, což znamená, že můžeme měnit jejich položky. Použitím závorkového operátoru [ ] můžeme měnit hodnotu položek:
>>> fruit = ["banana", "apple", "quince"] >>> fruit[0] = "pear" >>> fruit[-1] = "orange" >>> print(fruit) ['pear', 'apple', 'orange']
Přiřazení hodnoty položce stringu se nazývá položkové přiřazení (item assignment). Takovéto přiřazení nejde použít u řetězců:
>>> 'TEST'[2] = 'X' Traceback (most recent call last): File "<stdin >", line 1, in <module > TypeError: 'str' object does not support item assignment
ale je podporováno u seznamu řetězců:
>>> my_list = ['T', 'E', 'S', 'T'] >>> my_list[2] = 'X' >>> my_list ['T', 'E', 'X', 'T']
Úsekovým operátorem můžeme změnit několik položek najednou:
>>> a_list = ['a', 'b', 'c', 'd', 'e', 'f'] >>> a_list[1:3] = ['x', 'y'] >>> print(a_list) ['a', 'x', 'y', 'd', 'e', 'f']
Můžeme také odstranit položky ze seznamu tím, že je nahradíme prázdným seznamem:
>>> a_list = ['a', 'b', 'c', 'd', 'e', 'f'] >>> a_list[1:3] = [] >>> print(a_list) ['a', 'd', 'e', 'f']
A můžeme také přidat položky do seznamu vmáčknutím do prázdného úseku v potřebném místě:
>>> a_list = ['a', 'd', 'f'] >>> a_list[1:1] = ['b', 'c'] >>> print(a_list) ['a', 'b', 'c', 'd', 'f'] >>> a_list[4:4] = ['e'] >>> print(a_list) ['a', 'b', 'c', 'd', 'e', 'f']
Použití úseků k výmazu položek je neohrabané a proto náchylné k chybám. Python poskytuje šikovnější alternativu.
Příkaz del odstraní položku ze seznamu:
>>> a = ['one', 'two', 'three']
>>> del
a[1]
>>> a
['one', 'three']
Nepřekvapí nás, že del manipuluje také se zápornými indexy a vyvolá chybu při běhu programu, je-li index mimo dovolený rozsah.
Jako indexy pro del můžeme použít také úseky:
>>> a_list = ['a', 'b', 'c', 'd', 'e', 'f'] >>> del a_list[1:5] >>> print(a_list) ['a', 'f']
Jako obvykle, úseky vyberou všechny položky zadaného rozsahu, kromě horní meze.
Účelem kopírování je vytvoření nezávislé, autonomní kopie objektu. Tuto kopii lze provést jako mělkou (shallow) nebo důkladnou (deep).
Rozhodující vlastností kopírovaného objektu je jeho složení. Jednoprvkový objekt nebo jednoduché prvky kontejneru (list, tuple, set, dict) lze nezávisle reprodukovat jako shallow copy. Kontejner s vnořenými složenými prvky lze nezávisle reprodukovat pouze jako deep copy.
Za kopii nelze považovat přiřazení téhož objektu k více proměnným - viz alias.
Zdánlivou kopii neboli alias vytvoříme přiřazením téhož objektu k více jménům, což lze provést najednou v jednom řádku:
>>> a = b = [1, 2, 3] >>> id(a), id(b), id([1, 2, 3]) (59931496, 59931496, 59931400)
nebo postupně
>>> orig = [2, [True, False], "asi"]# prosté přiřazení >>> kopie = orig# kopie přiřazením (alias) >>> id(orig), id(kopie), id([2, [True, False], "asi"]) (59931464, 59931464, 59931688)
Schema vztahů může vypadat takto:
Proměnné se shodnými ID odkazují na stejný objekt. Změny objektu provedené prostřednictvím jednoho aliasu se projeví i u dalšího aliasu:
>>> b[0] = 5 >>> a [5, 2, 3]
Při mělké (shallow) kopii se v možném rozsahu vytvoří nový samostatný klon originálu. Mělkou kopii můžeme provést čtverým způsobem - například pro seznam:
>>> orig = [2, [True, False], "asi"]
Použitím vestavěné metody copy():
>>> orig_shall_one = orig.copy()
Konverzí seznamu na entici (případně obráceně):
>>> orig_shall_two = list(orig)
Použitím úsekového operátoru:
>>> orig_shall_three = orig[:]
Použitím metody copy z modulu copy:
>>> import copy >>> orig_shall_four = copy.copy(orig)
Ve všech čtyřech uvedených případech se nezávisle kopírují pouze jednoduché členy kopírovaného seznamu. Prvky vloženého seznamu jsou závisle propojeny se svým originálem:
>>> orig[2] = "yes"; orig[1][1] = 8 >>> orig_shall_three; orig [2, [True, 8], 'asi']# orig_shall_three [2, [True, 8], 'yes']# orig
Při hluboké (deep) kopii složeného objektu se vytvoří nový složený objekt, do něhož se vkládají nezávislé kopie objektů, nalezených v originálu.
Hlubokou kopii vytvoříme importovanou metodou deepcopy z modulu copy:
>>> from copy import deepcopy >>> orig_deep = deepcopy(orig) >>> orig[2] = "snad"; orig[1][1] = True >>> orig_deep; orig [2, [True, False], 'asi']# orig_deep [2, [True, True], 'snad']# orig
Interní mechanizmus smyčky for - viz kap 4.7. Použití smyčky for je velmi rozmanité, např.:
fruit = ["banana", "apple", "quince"]# proveďte v IDLE for
ovocein
fruit:
Měnitelnost seznamu nám umožňuje při jeho procházení (traverzování) upravit každou jeho položku. Následující kód vytvoří druhé mocniny čísel od 1 do 3:
numbers = [1, 2, 3]for
elemin
range(len(numbers)): print(numbers[elem], "-->", numbers[elem]**2, end =", ")
Výstup v IDLE:
======== RESTART: F:/Codetest/HowTo/trump_one.py ======== 1 --> 1, 2 --> 4, 3 --> 9,
Zamyslete se nad příkazem range(len(numbers)) a snažte se pochopit, jak tento příkaz pracuje. Uvnitř seznamu nás zajímá jak původní hodnota položky, tak i její změněná hodnota.
Funkce enumerate generuje při traverzování seznamem jak index, tak i odpovídající hodnotu. Pro lepší pochopení práce příkazu enumerate si vyzkoušejte následující příklad:
>>> for index, value in enumerate(['banana', 'apple', 'pear']): ... print(index, value ) ... 0 banana 1 apple 2 pear >>>
Jiné příklady využití funkce enumerate() - viz kap. 4.9.
Komprehence je skladebný předpis pro vytvoření seznamu, setu či entice z poskytnutého objektu typu list, tuple, string, bytes, dict s použitím kompaktního předpisu, případně ještě při splnění jisté (avšak nepovinné) podmínky.
Komprehenci lze ilustrovat matematickým výrazem:
S = { 2*x | x € N, x² > 3 }jenž lze slovně interpretovat asi takto: Pro všechna x z oboru přirozených čísel N jejichž druhé mocniny jsou větší než 3 se provede výraz 2*x.
V jazyce Python lze uvedený výraz vyjádřit konstrukcí, kterou si označíme jako komprehence seznamu:
>>> kompr =případně jako komprehence setu:[
f(x) for x in <objekt> if <podmínka>]
>>> kompr ={
f(x) for x in <objekt> if <podmínka>}
Jak vidno, rozdíl mezi komprenencí seznamu a komprehencí setu spočívá pouze v použitých závorkách. Pro komprehenci entice bychom použili kulaté závorky.
Ukažme si výše uvedený obecný matematický výraz převedený do komprehence seznamu a setu (prozatím bez podmínky):
>>> numbers = [1, 2, 3, 4] >>> [x**2 for x in numbers]# komprehence seznamu ze seznamu [1, 4, 9, 16] >>> {x**2 for x in numbers}# komprehence setu ze seznamu {16, 1, 4, 9} >>> (x**2 for x in numbers)# komprehence entice ze seznamu <generator object <genexpr> at 0x0343B680>
Komprehence entice (tuple) vytváří generátorový objekt, jímž se budeme zabývat v kap. 13.5.
>>> [x**2 for x in numbers if x**2 > 3] [4, 9, 16]Výrazových předpisů může být v jedné komprehenci více:# komprehence seznamu ze seznamu >>> >>> files = ('bin', 'Data', 'Desktop', '.bashrc', '.ssh', '.vimrc') >>> [name for name in files if name[0] != '.'] ['bin', 'Data', 'Desktop']# komprehence seznamu z entice
>>> [(x, x**2, x**3) for x in numbers]Může být více i poskytnutých objektů:# komprehence seznamu ze seznamu [(1, 1, 1), (2, 4, 8), (3, 9, 27), (4, 16, 64)]# ohraničení výrazu v zadání určuje ohraničení elementů ve výstupu # nahraďte kulaté závorky v zadání složenými a proveďte vyhodnocení vstupu
>>> numbers = (1, 2, 3, 4) >>> letters = ['a', 'b', 'c'] >>> [n*letter for n in numbers for letter in letters] ['a', 'b', 'c', 'aa', 'bb', 'cc', 'aaa', 'bbb', 'ccc', 'aaaa', 'bbbb', 'cccc']
Zajímavá je úprava argumentu v této komprehenci:
>>> [v*2 for v in ("a", 5, True)] ['aa', 10, 2]# 2*True = 2*1 = 2
Za povšimnutí stojí i toto spojení komprehence s formátováním řetězce dle kap. 6.16:
>>> boys = ["Pavel", "Petr", "Jan"] >>> synci = ["{} Novotný".format(boy) for boy in boys] >>> synci ['Pavel Novotný', 'Petr Novotný', 'Jan Novotný']
Ukázka komprehence setu z řetězce:
>>> s = {v for v in "ABCDABCD" if v not in "CB"} >>> s {'A', 'D'}Komprehencí setu z řetězce lze s pomocí funkce enumerate (kap. 4.9) vytvořít výběrový slovník:
>>> d = {key:val for key,val in enumerate ('ABCD') if val not in "CB"} >>> d {0: 'A', 3: 'D'}
Zajímavé je použití pojmenovaného výrazu (mroží operátor - 2.8.6) při komprehenci seznamu:
>>> def f(x): ... return x + 2 >>> print([[y := f(x), x/y] for x in range(3)]) [[2, 0.0], [3, 0.3333333333333333], [4, 0.5]]případně s podmínkou a přehledněji: >>> print([(x, y, x/y) for x in range(3) if (y := f(x)) > 0]) [(0, 2, 0.0), (1, 3, 0.3333333333333333), (2, 4, 0.5)]
Následující komprehencí vybereme ze zadané množiny bodů ty, které leží uvnitř kružnice o poloměru r = 2:
>>> import math >>> radius = 2 >>> [(x, y) for x in range(-2,3) for y in range(-2,3) if ... math.sqrt(x**2 + y**2) < radius] [(-1,-1), (-1,0), (-1,1), (0,-1), (0,0), (0,1), (1,-1), (1,0), (1,1)]
|
|
['spam!', 1, ['Brie', 'Roquefort', 'Pol le Veq'], [1, 2, 3]]a vytiskne délku každé položky. Co se stane, zadáme-li funkci len jako argument celé číslo?
# zde napište zadání úlohy""" # zde překopírujte doctest úlohy """ # zde napište řešení úlohy
Podle naznačených výsledků sestavte možnou hodnotu seznamu a_list:
""" >>> a_list[3] 42 >>> a_list[6] 'Ni!' >>> len(a_list) 8 """
Podle naznačených výsledků sestavte možnou hodnotu seznamu b_list a c_list:
""" >>> b_list[1:] ['Stills', 'Nash'] >>> group = b_list + c_list >>> group[-1] 'Young' """
Podle naznačených výsledků sestavte možnou hodnotu seznamu mystery_list:
""" >>> 'war' in mystery_list False >>> 'peace' in mystery_list True >>> 'justice' in mystery_list True >>> 'oppression' in mystery_list False >>> 'equality' in mystery_list True """
Vytvořte funkci list_range s naznačeným výstupem:
""" >>> list_range(a, b, c) [5,9,13,17] """
>>> range(10, 0, -2)
Po opětovném prostudování odstavce 4.8 napište funkci my_range(...), která vrátí výpis prvků range(a,b,c).
a = [1, 2, 3] b = a[:] b[0] = 5
this = ['I', 'am', 'not', 'a', 'crook'] that = ['I', 'am', 'not', 'a', 'crook'] print("Test 1: %s" % (id(this) == id(that))) that = this print("Test 2: %s" % (id(this) == id(that)))Přidejte podrobné vysvětlení výsledků.
Určete hodnoty proměnných junk, a, b tak, aby po naznačených úkonech měl seznam junk hodnotu stejnou jako na posledním řádku:
""" >>> 13 in junk True >>> del junk[4] >>> junk [3, 7, 9, 10, 13, 17, 21, 24, 27] >>> del junk[a:b] >>> junk [3, 7, 27] """
Nakreslete schema seznamu nlist, do kterého doplníte dále uvedené hodoty 0, 17, 5:
""" >>> nlist[2][1] 0 >>> nlist[0][2] 17 >>> nlist[1][1] 5 """
Podle výstupu z metody .split() sestavte hodnotu proměnné retiazka:
""" >>> retiazka.split() ['this', 'and', 'that'] """
def add_lists(a, b): """ >>> add_lists([1,1], [1,1]) [2, 2] >>> add_lists([1,2], [1,4]) [2, 6] >>> add_lists([1,2,1], [1,4,3]) [2, 6, 4] """
Fce add_lists musí být ve shodě s uvedenými doctesty.
def mult_lists(a, b): """ >>> mult_lists([1,1], [1,1]) 2 >>> mult_lists([1,2], [1,4]) 9 >>> mult_lists([1,2,1], [1,4,3]) 12 """
Ověřte si, že fce mult_lists vyhovuje uvedeným doctestům.
def replace (s, old, new): """ >>> replace ('Mississippi','i', 'I') 'MIssIssIppI' >>> s = 'I love spom! Spom is my favorite food. Spom, spom, spom, yum!' >>> replace(s, 'om', 'am') 'I love spam! Spam is my favorite food. Spam, spam, spam, yum!' >>> replace(s, 'o', 'a') 'I lave spam! Spam is my favarite faad. Spam, spam, spam, yum!' """Řešení musí zajisté vyhovovat doctestům. Použije se split a join.
>>> nums = [1, 2, 3, 4] >>> [x**3 for x in nums]
>>> nums = [1, 2, 3, 4] >>> [x**2 for x in nums if x**2 != 4]
>>> nums = [1, 2, 3, 4] >>> [(x, y) for x in nums for y in nums]
>>> nums = [1, 2, 3, 4] >>> [(x, y) for x in nums for y in nums if x != y]
![]() |
![]() |
![]() |
![]() |
![]() |
![]() |