8. Seznamy I

1. Vytvoření seznamu
2. Přístup k položkám
3. Délka seznamu
4. Příslušnost položky
5. Operace se seznamy
6. Úseky seznamu
7. Seznamy jsou měnitelné
8. Smazání položek
9. Identita objektů
10. Další jméno - alias
11. Klonování seznamů
12. Funkce range()
13. Seznamy a smyčky 'for'
14. Komprehence seznamu
15. Metamorfózy
16. Seznam jako argument
17. Čisté funkce a modifikátory II
18. Glosář
19. Cvičení

Seznam (list) je uspořádaná kolekce hodnot libovolného typu. Jednotlivým hodnotám říkáme položky a tyto položky jsou měnitelné. Seznamy, řetězce a jiné entity, které se chovají jako uspořádané řady, nazýváme sekvence.

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 (číslo v plovoucí řádové čárce), integer (celé číslo) 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
>>>

Při všech těchto možnostech tvorby seznamů by bylo zklamáním, kdybychom nemohli přiřadit seznam hodnot k proměnné, nebo zadat seznam jako parametr či argument funkce. Věc se má tak, že můžeme.

>>> vocabulary = ["ameliorate", "castigate", "defenestrate"]
>>> numbers = [17, 123]
>>> empty = []
>>> print(vocabulary, numbers, empty)
['ameliorate', 'castigate', 'defenestrate'] [17, 123] []

Funkcí list()

Funkce list(arg) přijímá jeden argument, jímž může být kontejner typu string, list, tuple, set, dict   a z prvků těchto kontejnerů vytvoří seznam

str = "afrodité"                        # řetězec
lst = ["pí", 3.14, 8]                   # seznam
tup = ("g", 9.89, 8)                    # entice
set = {"e", 2.72, 8}                    # množina
dct = {"pí":3.14, "g": 9.89, "e":2.72}  # slovník

Tyto proměnné postupně použijeme jako argumenty funkce:

>>> list(str)
['a', 'f', 'r', 'o', 'd', 'i', 't', 'é']
>>>
# další volání si zkuste sami

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:

>>> print(numbers[0])
17

Jako index lze použít jakýkoli celočíselný výraz:

>>> numbers[9-8]  #  = 1
123
>>> numbers[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:

>>> numbers[2]
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:

>>> numbers[-1]
123
>>> numbers[-2]
17
>>> numbers[-3]
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
IndexError: list index out of range    

numbers[-1] je poslední položka seznamu, numbers[-2] je předposlední a numbers[-3] neexistuje.

Je obvyklé použít proměnnou smyčky jako index seznamu:

horsemen = ["war", "famine", "pestilence", "death"]

i = 0                  # proměnná smyčky
while i < 4:
    print(horsemen[i])
    i = i + 1

Tato smyčka počítá od 0 do 4. Jakmile má proměnná smyčky 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] )
    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, což je dobré, protože len(horsemen) není přípustný index.

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

8.4 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 Operace se seznamy

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

U seznamu lze uplatnit stejné operace jako u řetězců - viz 8.5.

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

Kromě společných procedur pro seznamy a řetězce existují rovněž předdefinované funkce, použitelné pouze pro seznamy, které většinou evokujeme formátem lst.metoda():

append, clear, copy, count, extend, index, insert, pop,
remove, reverse, sort

a dále specielní metody, spojené se zdvojenými podtržítky:

__{add, class, contains, delatr, delitem, dir, doc, eq,
format, getattribute, getitem, ge, qt, hash, iadd, imul,
init, iter, len, le, lt, mul, new, ne, reduce_ex, reduce,
repr, reversed, rmul, setattr, setitem, sizeof, str, 
subclasshook}__

Podrobnosti o metodách opět nejlépe zjistíme v editoru PyScripter při zápisu >>> muj_list . . U některých specielních metod se dozvíme, že je lze volat alternativním způsobem.

Pro seznamy neexistuje modul list jako existuje modul string pro řetězce.

8.6 Ú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.7 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 [ ] na levé straně přiřazení 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 se nazývá položkové přiřazení (item assignment). Takovéto přiřazení nejde použít u řetězců:

>>> my_string = 'TEST'
>>> my_string[2] = 'X'
Traceback (most recent call last):
  File "<stdin >", line 1, in <module > 
TypeError: 'str' object does not support item assignment 
(objekt 'str' nepodporuje položkové přiřazení)

ale podporuje je pro seznamy:

>>> 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.8 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.9 Identita objektů

Provedeme-li tyto příkazy přiřazení,

a = "banana"
b = "banana"

víme, že a a b poukazují na řetězec s písmeny "banana". Není však zřejmé, zda se jedná o tentýž řetězec.

Jsou dvě možné situace:

V prvním případě odkazují a a b ke dvěma různým věcem, které mají stejnou hodnotu. Ve druhém případě odkazují k téže věci. Těmto "věcem" říkáme objekty. Objekt je něco, na co může proměnná odkazovat.

Každý objekt má jedinečný identifikátor, k němuž máme přístup prostřednictvím funkce id. Jeho vytištěním můžeme zjistit, zda se obě proměnné a i b odkazují ke stejnému objektu:

>>> id(a)
135044008
>>> id(b)
135044008

Dostali jsme dvakrát stejný identifikátor, což znamená, že Python vytvořil pouze jeden řetězec a jak a, tak b se k němu odkazují.

Seznamy se chovají odlišně od řetězců. Souvisí to s tím, že seznamy jsou měnitelné kolektory, zatímco řetězce (a entice) jsou neměnitelné kolektory. Vytvoříme-li dva seznamy, dostaneme dva objekty:

>>> a = [1, 2, 3]
>>> b = [1, 2, 3]
>>> id(a) == id(b)
False

Zobrazení vztahů vypadá tedy takto:

Proměnné a a b mají stejnou hodnotu ale nevztahují se ke stejnému objektu.

8.10 Další jméno - alias

Proměnné odkazují k objektům; přiřadíme-li jednu proměnnou ke druhé, potom obě proměnné odkazují ke stejnému objektu:

>>> a = [1, 2, 3]
>>> b = a
>>> id(a) == id(b)
True

V tomto případě vypadá schema vztahů takto:

Protože tentýž seznam má dvě různá jména (a, b), říkáme, že je aliasován. Změny provedené s jedním aliasem se projeví i u druhého:

>>> b[0] = 5
>>> print(a)
[5, 2, 3]

I když toto chování může být užitečné, je někdy nečekané, ba přímo nežádoucí. Obecně vzato, pracujeme-li s měnitelnými objekty, je bezpečnější se aliasování vyhnout. S neměnitelnými objekty ovšem žádný problém není. Proto se řetězce aliasují, kdykoli je to vhodné.

8.11 Klonování seznamů

Chceme-li provést úpravy v seznamu a zároveň si uchovat kopii originálu, potřebujeme zkopírovat samotný seznam, nikoliv jen jeho odkaz. Tomuto procesu někdy říkáme klonování, abychom se vyhnuli dvojznačnosti slova "kopírování".

Nejjednodušší způsob klonování je užití úsekového operátoru:

>>> a = [1, 2, 3]
>>> b = a[:]
>>> a == b  # porovnáváme hodnoty
True
>>> a is b  # porovnáváme ID
False
>>> id(a) == id(b)
False
>>>

Nyní můžeme měnit b bez obav o a.

>>> b[0] = 5
>>> print(a)
[1, 2, 3]
>>> print(b)
[5, 2, 3]

8.12 Funkce 'range'

Vestavěná funkce range(n) vytvoří skrytou posloupnost čísel od nuly po n-1. Tuto posloupnost lze použít:

>>> list(range (7))
[0, 1, 2, 3, 4, 5, 6]
>>> list(range (2,7))
[2, 3, 4, 5, 6]
>>> list(range (0,7,2))
[0, 2, 4, 6]
>>> list(range (7,5))
[]
>>> list(range (7,0,-3))
[7, 4, 1]
>>>

>>> for i in(range(7))
...   print(i, end="  ")
... 
0, 1, 2, 3, 4, 5, 6
>>>

8.13 Seznamy a smyčky 'for'

Zobecněná skladba smyčky for je tato:

for VARIABLE in LIST:
    BODY    

Tento příkaz je rovnocenný zápisu:

i = 0
while i < len(LIST):
    VARIABLE = LIST[i]
    BODY
    i += 1   

Smyčka for je stručnější, protože se obejdeme bez proměnné i.

Použití smyčky for je velmi rozmanité:

for number in range(20):
    if number%3 == 0:
        print(number, end="  ")

for fruit in ["banana", "apple", "quince"]:
    print("I like to eat " + fruit +"s!") 

První příklad vytiskne všechny násobky 3 od 0 po 18. Druhý příklad vyjádří nadšení pro různé druhy ovoce.

Měnitelnost seznamu nám umožňuje upravit při traverzování každou jeho položku. Následující kód vytvoří druhé mocniny čísel od 1 do 5:

numbers = [1, 2, 3, 4, 5]
for index in range(len(numbers)):
    numbers[index] = numbers[index]**2
# o výsledek si musíme říci:
# >>> numbers

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 hodnota položky, tak i její index.

Tento postup je natolik běžný, že Python nabízí k použití i jiný způsob:

numbers = [1, 2, 3, 4, 5]
for index, value in enumerate(numbers):
    numbers[index] = value**2

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

Příkazy break a continue se ve smyčkách for.. a while použijí pro seznamy (a entice) stejně jako u řetězců - viz kap. 7.8 a 7.9.

8.14 Komprehence seznamu

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

>>> S = [f(x) for x in <sekvence> if <podmínka>]

>>> numbers = [1, 2, 3, 4]
>>> [x**2 for x in numbers]
[1, 4, 9, 16]
>>> [x**2 for x in numbers if x**2 > 8]
[9, 16]
>>>
>>> files = ['bin', 'Data', 'Desktop', '.bashrc', '.ssh', '.vimrc']
>>> [name for name in files if name[0] != '.']
['bin', 'Data', 'Desktop']

>>> [(x, x**2, x**3) for x in numbers]
[(1, 1, 1), (2, 4, 8), (3, 9, 27), (4, 16, 64)]

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

[expr for item1 in seq1 for item2 in seq2 ... for itemx in seqx if condition]

output_sequence = []
for item1 in seq1:
    for item2 in seq2:
        ...
            for itemx> in seqx:
                if condition:
                    output_sequence.append(expr)

>>> [v for v in "lopata"]
['l', 'o', 'p', 'a', 't', 'a']

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

8.15 Metamorfózy

Umíme z řetězce vytvořit seznam (list(arg)) a ze seznamu řetězec (str(arg)), dokonce to umíme udělat jedním tahem:

>>> str (list("Žabička"))
"['Ž', 'a', 'b', 'i', 'č', 'k', 'a']"

Chceme-li z rozsypaného čaje sestavit zase žabičku, musíme použít funkci join :

>>> frog = list("Žabička")
>>> frog
['Ž', 'a', 'b', 'i', 'č', 'k', 'a']
>>> "".join(frog)
'Žabička'
>>>

Funkce split rozloží řetězec na seznam slov. :

>>> song = "The rain in Spain..."
>>> song.split()
['The', 'rain', 'in', 'Spain... ']
>>> 

Vhodně vybraný argument, nazvaný oddělovač (separátor), může být použit jako hranice mezi oddělenými úseky. Následující příklad používá jako oddělovač řetězec ai:

>>> song.split(sep='ai')
['The r', 'n in Sp','n... ']
>>> 

Všimněte si, že zadaný separátor se ve vytvořeném seznamu neobjevuje.

Fce join i split přijímá dva argumenty: seznam řetězců a separátor. Hodnota separátoru může být implicitní - split()

>>> words = ['crunchy', 'raw', 'unboned', 'real', 'dead', 'frog']
>>> " ".join(words)
'crunchy raw unboned real dead frog'
>>> "**".join(words)
'crunchy**raw**unboned**real**dead**frog'

8.16 Seznam jako argument

Při zadávání seznamu jako argument se ve skutečnosti předává odkaz, nikoliv kopie seznamu. Protože jsou seznamy měnitelné, mohou být jeho položky použitou funkcí změněny. Například, následující funkce přijme seznam jako argument a vynásobí dvěma každou jeho položku:

def double_stuff_m(a_list):
    for index, value in enumerate(a_list):
        a_list[index] = 2 * value    

Vložíme-li double_stuff_m do souboru se jménem ch09_double.py, můžeme si postup vyzkoušet:

>>> from ch09_double import double_stuff_m
>>> things = [2,5,'spam',9.5]
>>> double_stuff_m(things)
>>> things
[4, 10, 'spamspam', 19.0]
>>>

8.17 Čisté funkce a modifikátory II

Funkce, které přijmou seznam jako argument a změní jej při provádění, se nazývají modifikátory a změnám které provedou na zadaném argumentu, se říká vedlejší účinky. Funkci s uvedenými vlastnostmi jsme si zapsali v předchozím odstavci.

Čistá funkce neprodukuje vedlejší účinky. Komunikuje s okolním programem pouze prostřednictvím argumentů které nepřetváří a prostřednictvím výstupní hodnoty. Zde je double_stuff_p jako čistá funkce:

 def  double_stuff_p ( a_list ):
     new_list = [] 
     for  value in a_list:
         new_list += [2*value]       
     return  new_list    

Funkce double_stuff_p nemění své argumenty:

>>> from ch09_double import double_stuff_p
>>> things = [2,5,'spam',9.5]
>>> double_stuff_p(things)
[4, 10, 'spamspam', 19.0]
>>> things
[2, 5, 'spam', 9.5]
>>>

Chceme-li aby čistá funkce double_stuff_p změnila seznam things, přiřadíme mu výstup z čisté funkce:

>>> things = double_stuff_p(things)
>>> things 
[4, 10, 'spamspam', 19.0]
>>>

Co je lepší?

Všechno, co může být provedeno pomocí modifikátorů, může být také provedeno čistými funkcemi. Některé programovací jazyky znají vlastně jenom čisté funkce. Má se zato, že čisté funkce se snadněji tvoří a jsou méně náchylné k chybám než programy, které používají modifikátory. Nicméně, modifikátory jsou někdy vhodné a v některých případech jsou programy s čistými funkcemi méně výkonné.

Doporučujeme tedy používat čisté funkce kdykoli je to účelné, a k modifikátorům se uchylovat jen při jejich zjevné výhodnosti. Tento přístup lze označit jako funkcionální programovací styl.

8.18 Glosář

8.19 Cvičení