8. Seznamy I

1. Vytvoření seznamu
2. Přístup k položkám
3. Délka seznamu
4. Operace se seznamy
5. Úseky seznamu
6. Seznamy jsou měnitelné
7. Smazání položek
8. Kopírování objektů
9. Seznamy a smyčky 'for'
10. Komprehence
11. Glosář
12. Cvičení

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.

8.1 Vytvoření seznamu

Taxativním výčtem

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] []

Funkcí list()

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

Komprehencí seznamu

Komprehenci (viz odstavec 8.10) použijeme hlavně při úpravě stávajícího seznamu.

8.2 Přístup k položkám

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 range    

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čítadlo
while i < 4:
    print(horsemen[i], end=" ")
    i = i + 1

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.

8.3 Délka seznamu

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 = 0
while i < len(horsemen):
    print( horsemen[i], end=" ")
    i = i + 1

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.

8.4 Operace se seznamy

Společné operace pro seznamy a řetězce

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.

Vestavěné metody a funkce pro seznamy

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, split       jsou společné i pro řetězce

Funkce
len, max, min                      jsou společné pro všechny iterábly
list

Příslušnost položky

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

8.5 Úseky seznamu

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']

8.6 Seznamy jsou měnitelné

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']

8.7 Smazání položek

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.

8.8 Kopírování objektů

Úč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ánlivá kopie - 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]

Mělká kopie

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 

Hluboká kopie

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

8.9 Seznamy a smyčky 'for'

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 ovoce in fruit:
    print("I like to eat " + ovoce + "s!") 

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 elem in 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.

S = { 2*x | x € N, x² > 3 }

>>> kompr = [f(x) for x in <objekt> if <podmínka>]

>>> kompr = {f(x) for x in <objekt> if <podmínka>}

>>> 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>

>>> [x**2 for x in numbers if x**2 > 3]
[4, 9, 16]                             # 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]   # 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']

>>> [v*2 for v in ("a", 5, True)]
['aa', 10, 2]                                 # 2*True = 2*1 = 2

>>> boys = ["Pavel", "Petr", "Jan"]
>>> synci = ["{} Novotný".format(boy) for boy in boys]
>>> synci
['Pavel Novotný', 'Petr Novotný', 'Jan Novotný']

>>> s = {v for v in "ABCDABCD" if v not in "CB"}
>>> s
{'A', 'D'}

>>> 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)]

8.11 Glosář

8.12 Cvičení