previous up next hi end end

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    
numbers[-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čí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"]

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.


8.10 Komprehence

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 = [f(x) for x in <objekt> if <podmínka>]
případně jako komprehence setu:
>>> 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.


Dále si ukážeme komprehenci s podmínkou:

>>> [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
Výrazových předpisů může být v jedné komprehenci více:
>>> [(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
Může být více i poskytnutých objektů:
>>> 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)]

8.11 Glosář

seznam (list)
Měnitelná kolekce objektů (případně různého typu), kde každý objekt je označen indexem.
položka (element)
Jedna z hodnot seznamu (nebo jiné sekvence). Operátor z hranatých závorek vybere položku ze seznamu.
sekvence (sequence)
Jakýkoliv datový typ, skládající se z uspořadané řady položek, kde každá položka je určena indexem.
vnořený seznam (nested list)
Seznam, který je položkou jiného seznamu.
krok (step)
Interval mezi sousedními položkami v lineární sekvenci. Také třetí (a nepovinný) argument fce range. Není-li zadán, jeho implicitní hodnotou je 1.
traverzování seznamem (list traversal)
Postupný výběr každé položky seznamu.
alias
Vícero proměnných, odkazujících na stejný objekt.
klonovat (clone)
Vytvořit nový objekt, který má stejnou hodnotu jako stávající objekt. Kopírování odkazu na objekt vytvoří alias, nikoliv klon.
komprehence seznamu (list comprehension)
Určení položek seznamu nikoliv jejich výčtem ale popisem jejich vlastností.
oddělovač (separator, delimiter)
Znak nebo řetězec použitý k označení místa, kde má být jiný řetězec rozdělen.

8.12 Cvičení

  1. Napište smyčku, která traverzuje seznamem:
    ['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?
  2. Vytvořte soubor doctests.py do něhož budeme postupně přidávat úlohy ad a, b, c, d podle následující šablony:
    # zde napište zadání úlohy
    """
    # zde překopírujte doctest úlohy
    """
    # zde napište řešení úlohy 
    
    1. 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
      """
      
    2. 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'
      """
      
    3. 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
      """
      
    4. Vytvořte funkci list_range s naznačeným výstupem:

      """
         >>> list_range(a, b, c)
         [5,9,13,17]
      """
      
  3. Tři argumenty pro funkci range jsou start, stop, step. Co se stane, když start < stop a step < 0 ?
    >>> 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).

  4. Nakreslete schematické zobrazení vztahu mezi a, b před provedením třetího řádku a po jeho provedení.
    a = [1, 2, 3]
    b = a[:]
    b[0] = 5
    
  5. Jaký bude výstup následujícího programu?
    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ů.

  6. Následující tři úlohy zapište do souboru dedukce.py. Doctest při tom nebudete potřebovat.
    1. 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]
      """
      
    2. 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
      """
      
    3. Podle výstupu z metody .split() sestavte hodnotu proměnné retiazka:

      """
         >>> retiazka.split()
         ['this', 'and', 'that']
      """
      
  7. Napište funkci add_lists(a,b) která přijme dva seznamy stejné délky s celými čísly a vrátí nový seznam se součty odpovídajících položek.
    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.

  8. Napište funkci mult_lists(a, b) která přijme dva seznamy stejné délky s celými čísly a vrátí součet součinů odpovídajících položek.
    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.

  9. Vyzkoušejte si různé separátory u funkcí join a split.
  10. Napište funkci replace(s, old, new), která zamění všechny výskyty old za new v řetězci s.
    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.
  11. Uveďte odezvy konzoly na následující zápisy:
    1. >>> nums = [1, 2, 3, 4]
      >>> [x**3 for x in nums]
      
    2. >>> nums = [1, 2, 3, 4]
      >>> [x**2 for x in nums if x**2 != 4]
      
    3. >>> nums = [1, 2, 3, 4]
      >>> [(x, y) for x in nums for y in nums]
      
    4. >>> nums = [1, 2, 3, 4]
      >>> [(x, y) for x in nums for y in nums if x != y]
      
    Měl byste předjímat výsledky předtím, než vám je ukáže konzola interpreta.

previous up next hi end end