Tahle kapitola je plná nových věcí. Doufám, že vydržíš až do konce. A kdyby něco zatím nedávalo úplně smysl, nevěš hlavu: věci, které si teď vysvětlíme, se opravdu naučíš až v dalších lekcích, kde je budeme využívat prakticky.
Encyklopedické informace z této stránky shrnuje Tahák na seznamy, který si doporučuji vytisknout.
Každý příklad v tomto textu si vyzkoušej; to, co Python vypíše, je důležitá součást lekce, i když v materiálech není přímo napsaná.
Dnes si ukážeme, jak pracovat se seznamy (angl. lists). Doufám, že víš, kde máš na klávesnici hranaté závorky, protože právě těmi se seznamy vytváří:
cisla = [1, 1, 2, 3, 5, 8, 13]
print(cisla)
Nemůžeš najít hranaté závorky? Na české klávesnici zkus pravý Alt + F a G.
Seznam je hodnota, která může obsahovat spoustu dalších hodnot.
Tak jako řetězec obsahuje sekvenci znaků,
seznam obsahuje sekvenci... čehokoliv. Třeba čísel.
A tak jako můžeme pomocí cyklu for
procházet řetězec po znacích,
seznam můžeme procházet po jednotlivých prvcích:
for cislo in cisla:
print(cislo)
Seznamy se v programech vyskytují velice často:
soubor se dá načíst jako seznam řetězců
s jednotlivými řádky,
seznam řetězců jako '7♥'
a 'K♣' může posloužit jako balíček karet,
matematika je plná číselných řad,
každá online služba má seznam uživatelů.
Hodnoty v seznamu můžou být jakéhokoli typu, dokonce můžeme různé typy míchat v jednom seznamu (i když s takovými namixovanými seznamy se příliš často nesetkáme – více se používají v n-ticích, o kterých si povíme později):
seznam = [1, 'abc', True, None, range(10), len]
print(seznam)
Nejzákladnější operaci se seznamy,
cyklus for, už jsme si ukázaly.
Druhá nejdůležitější operace je vybírání
jednotlivých prvků.
To funguje jako u řetězců: do hranatých závorek
se dá číslo prvku. Čísluje se, jako u řetězců,
od nuly; záporná čísla označují prvky od konce.
print(cisla[2])
Hranatými závorkami můžeme získávat podseznamy. Diagram z materiálů k řetězcům ukazuje, jak u takového „sekání” číslovat: funguje to stejně, jen místo menšího řetězce dostaneme menší seznam.
print(cisla[2:-3])
Důležitá vlastnost seznamů, kterou nemají ani čísla, ani řetězce
(a True/False/None už vůbec ne), je,
že seznamy se dají měnit.
Čísla měnit nejdou – máš-li a = 3 a
napíšeš a = a + 1, číslo 3 se nezmění.
Vypočítá se nové číslo 4 a proměnná a
se nastaví na toto nové číslo.
Oproti tomu seznamy se dají měnit bez nastavování proměnné.
Základní způsob, jak změnit seznam, je přidání
prvku na konec pomocí metody append.
Ta nic nevrací (resp. vrací None),
ale „na místě” (angl. in place) změní
seznam, na kterém pracuje. Vyzkoušej si to:
prvocisla = [2, 3, 5, 7, 11, 13, 17]
print(prvocisla)
prvocisla.append(19)
print(prvocisla)
Takové měnění hodnoty může být občas překvapující, protože stejnou hodnotu může mít více proměnných. Protože se mění hodnota samotná, může to vypadat, že se proměnná „mění aniž na ni sáhneme”:
a = [1, 2, 3] # vytvoření seznamu
b = a # tady se nový seznam nevytváří
# seznam vytvořený v prvním řádku má teď dvě jména: "a" a "b",
# ale stále pracujeme jenom s jedním seznamem
print(b)
a.append(4)
print(b)
Kromě metody append, která přidává
jediný prvek, existuje metoda extend,
která umí přidávat prvků víc.
Prvky k přidání jí předáme ve formě seznamu:
dalsi_prvocisla = [23, 29, 31]
prvocisla.extend(dalsi_prvocisla)
print(prvocisla)
Metoda extend umí pracovat i s jinými
typy než se seznamy – ráda zpracuje cokoli, přes
co umí cyklit for: např.
jednotlivé znaky řetězců, řádky souborů, nebo čísla z range().
seznam = []
seznam.extend('abcdef')
seznam.extend(range(10))
print(seznam)
Ale dost přidávání. Seznamům se dají i měnit jednotlivé prvky a to jednoduše tak, že do prvku přiřadíme, jako by to byla proměnná:
cisla = [1, 0, 3, 4]
cisla[1] = 2
print(cisla)
Přiřazovat se dá i do podseznamu – v tomto případě
se podseznam nahradí jednotlivými prvky z toho,
co přiřazujeme.
Jako u extend můžeš do podseznamu opět přiřadit cokoli, co umí
zpracovat for – seznam, řetězec, range() apod.
cisla = [1, 2, 3, 4]
cisla[1:-1] = [6, 5]
print(cisla)
Přiřazením do podseznamu se dá i změnit délka seznamu, nebo některé prvky úplně odstranit:
cisla = [1, 2, 3, 4]
cisla[1:-1] = [0, 0, 0, 0, 0, 0]
print(cisla)
cisla[1:-1] = []
print(cisla)
Tenhle zápis pro mazání prvků je ale docela
nepřehledný, a proto na to máme zvláštní příkaz
jménem del.
Jak už jeho název (z angl. delete, smazat)
napovídá, smaže, co mu přijde pod ruku – jednotlivé
prvky seznamů, podseznamy, … a dokonce i proměnné!
cisla = [1, 2, 3, 4, 5, 6]
del cisla[-1]
print(cisla)
del cisla[3:5]
print(cisla)
del cisla
print(cisla)
Další mazací metody jsou:
pop, která odstraní a vrátí poslední prvek v seznamu – například pokud
mám seznam karet v balíčku, jde takhle jednoduše „líznout” kartu,remove, která najde v seznamu daný prvek a odstraní ho,clear, která vyprázdní celý seznam.cisla = [1, 2, 3, 'abc', 4, 5, 6, 12]
posledni = cisla.pop()
print(posledni)
print(cisla)
cisla.remove('abc')
print(cisla)
cisla.clear()
print(cisla)
A taky tu máme metodu sort, která prvky seznamu seřadí.
seznam = [4, 7, 8, 3, 5, 2, 4, 8, 5]
seznam.sort()
print(seznam)
Aby se daly seřadit, musí být prvky seznamu vzájemně
porovnatelné – konktrétně na ně musí fungovat
operátor <.
Seznam s mixem čísel a řetězců tedy seřadit nepůjde.
Operátor < definuje i
jak přesně se řadí (např. čísla podle velikosti;
řetězce podle speciální „abecedy” která řadí
velká písmena za malá, česká až za anglická, atd.).
Metoda sort zná pojmenovaný argument
reverse. Pokud ho nastavíš na True, řadí se „naopak”.
seznam = [4, 7, 8, 3, 5, 2, 4, 8, 5]
seznam.sort(reverse=True)
print(seznam)
Spousta toho, co můžeme dělat s řetězci, má stejný účinek i u seznamů. Třeba sečítání a násobení číslem:
melodie = ['C', 'E', 'G'] * 2 + ['E', 'E', 'D', 'E', 'F', 'D'] * 2 + ['E', 'D', 'C']
print(melodie)
Stejně jako u řetězců, sečítat jde jen seznam se seznamem – ne třeba seznam s řetězcem.
Další staří známí jsou funkce len,
metody count a index, a operátor in.
print(len(melodie)) # Délka seznamu
print(melodie.count('D')) # Počet 'D' v seznamu
print(melodie.index('D')) # Číslo prvního 'D'
print('D' in melodie) # Je 'D' v seznamu?
Poslední tři se ale přece jen chovají kapku jinak:
u řetězců pracují s podřetězci,
u seznamů jen s jednotlivými prvky.
Takže ačkoliv naše melodie obsahuje prvky
'D' a 'E' vedle sebe, 'DE' v seznamu není:
print('DE' in melodie)
print(melodie.count('DE'))
print(melodie.index('DE'))
Seznam se dá použít v příkazu if (nebo while) jako podmínka,
která platí, když v tom seznamu něco je.
Jinými slovy, seznam je tu „zkratka“ pro len(seznam) > 0.
if seznam:
print('V seznamu něco je!')
else:
print('Seznam je prázdný!')
Podobně se dají v podmínce použít i řetězce. A dokonce i čísla – ta jako podmínka platí, pokud jsou nenulová.
Tak jako funkce int převádí na
celá čísla a str na řetězce,
funkce list (angl. seznam) převádí na seznam.
Jako argument jí předáme jakoukoli hodnotu,
kterou umí zpracovat příkaz for.
Z řetězců udělá seznam znaků, z otevřeného souboru
udělá seznam řádků, z range udělá
seznam čísel.
abeceda = list('abcdefghijklmnopqrstuvwxyz')
cisla = list(range(100))
print(abeceda)
print(cisla)
I ze seznamu udělá funkce list seznam.
To může znít zbytečně, ale není – vytvoří se
totiž nový seznam.
Bude mít sice stejné prvky ve stejném pořadí,
ale nebude to ten samý seznam:
měnit se bude nezávisle na tom starém.
a = [1, 2, 3]
b = list(a)
print(b)
a.append(4)
print(b)
Další způsob, jak tvořit seznamy
(zvláště složitější), je nejdřív udělat prázdný
seznam a pak ho postupně naplnit pomocí funkce append.
Třeba pokud z nějakého důvodu chceš seznam
mocnin dvou, projdi čísla, kterými chceme mocnit,
cyklem for a pro každé z nich
do seznamu přidej příslušnou mocninu:
mocniny_dvou = []
for cislo in range(10):
mocniny_dvou.append(2 ** cislo)
print(mocniny_dvou)
Chceš-li seznam, který reprezentuje balíček karet,
zavolej append pro všechny kombinace barev a hodnot.
balicek = []
for barva in '♠', '♥', '♦', '♣': # (Na Windows použij textová jména)
for hodnota in list(range(2, 11)) + ['J', 'Q', 'K', 'A']:
balicek.append(str(hodnota) + barva)
print(balicek)
Seznamy a řetězce jsou druhy „sekvencí”,
takže snad nepřekvapí, že se dá různě převádět
z jednoho typu na druhý.
Funkce list vytvoří z řetězce
seznam znaků.
Když chceme dostat seznam slov, použijeme
na řetězci metodu split (angl. rozdělit):
slova = 'Tato věta je složitá, rozdělme ji na slova!'.split()
print(slova)
Metoda split umí brát i argument.
Pokud ho předáme, místo mezer (a nových řádků)
se řetězec „rozseká” daným oddělovačem.
Takže když máme nějaká data oddělená čárkami,
není nic jednoduššího než použít split s čárkou:
zaznamy = '3A,8B,2E,9D'.split(',')
print(zaznamy)
Chceme-li spojit seznam řetězců zase dohromady
do jediného řetězce, použijeme metodu
join (angl. spojit).
Pozor, tahle metoda se volá na oddělovači,
tedy řetězci, kterým se jednotlivé kousky „slepí”
dohromady; a jako argument bere seznam jednotlivých
řetězců.
veta = ' '.join(slova)
print(veta)
Představ si, že ti uživatelé zadávají jména a příjmení a ty si je ukládáš do seznamu pro další použití např. v evidenci studentů. Ne všichni jsou ale pořádní, a tak se v seznamu sem tam objeví i jméno s nesprávně zadanými velkými písmeny. Například:
zaznamy = ['pepa novák', 'Jiří Sládek', 'Ivo navrátil', 'jan Poledník']
Úkolem je:
Výsledné funkce by měly fungovat takto:
zaznamy = ['pepa novák', 'Jiří Sládek', 'Ivo navrátil', 'jan Poledník']
chybne_zaznamy = vyber_chybne(zaznamy)
print(chybne_zaznamy) # → ['pepa novák', 'Ivo navrátil', 'jan Poledník']
spravne_zaznamy = vyber_spravne(zaznamy)
print(spravne_zaznamy) # → ['Jiří Sládek']
opravene_zaznamy = oprav_zaznamy(zaznamy)
print(opravene_zaznamy) # → ['Pepa Novák', 'Jiří Sládek', 'Ivo Navrátil', 'Jan Poledník']
Snadný způsob jak zjistit, zda je řetězec složen jen z malých písmen,
je metoda islower(), která vrací True, pokud řetězec obsahuje jen malá
písmena, jinak vrací False. Například 'abc'.islower() == True ale
'aBc'.islower() == False.
Snadný způsob jak převést první písmenko na velké je metoda capitalize():
např. 'abc'.capitalize() == 'Abc'
Modul random obsahuje dvě funkce, které se hodí k seznamům.
Jako random.randrange, obě mají něco
společného s náhodou.
Funkce shuffle seznam „zamíchá” – všechny prvky náhodně popřehází.
Jako metoda sort i funkce shuffle nic nevrací.
import random
balicek = []
for barva in '♠', '♥', '♦', '♣':
for hodnota in list(range(2, 11)) + ['J', 'Q', 'K', 'A']:
balicek.append(str(hodnota) + barva)
print(balicek)
random.shuffle(balicek)
print(balicek)
A funkce choice ze seznamu vybere jeden náhodný prvek.
S použitím seznamu tak můžeme výrazně zjednodušit
úvodní část naší staré hry kámen/nůžky/papír:
import random
mozne_tahy = ['kámen', 'nůžky', 'papír']
tah_pocitace = random.choice(mozne_tahy)
A perlička na konec! Na začátku tohoto textu je napsáno, že seznam může obsahovat jakýkoli typ hodnot. Může třeba obsahovat i další seznamy:
seznam_seznamu = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
Takový seznam se chová docela normálně – jdou z něj třeba brát jednotlivé prvky (které jsou ovšem taky seznamy):
prvni_seznam = seznam_seznamu[0]
print(prvni_seznam)
A protože jsou prvky samy seznamy, můžeme mluvit o věcech jako „první prvek druhého seznamu”:
druhy_seznam = seznam_seznamu[1]
prvni_prvek_druheho_seznamu = druhy_seznam[0]
print(prvni_prvek_druheho_seznamu)
A protože výraz seznam_seznamu[1]
označuje seznam, můžeme brát prvky přímo z něj:
prvni_prvek_druheho_seznamu = (seznam_seznamu[1])[0]
Neboli:
prvni_prvek_druheho_seznamu = seznam_seznamu[1][0]
A má tahle věc nějaké použití, ptáš se?
Stejně jako vnořené cykly for
nám umožnily vypsat tabulku, vnořené seznamy
nám umožní si tabulku „zapamatovat”.
def vytvor_tabulku(velikost=11):
seznam_radku = []
for a in range(velikost):
radek = []
for b in range(velikost):
radek.append(a * b)
seznam_radku.append(radek)
return seznam_radku
nasobilka = vytvor_tabulku()
print(nasobilka[2][3]) # dva krát tři
print(nasobilka[5][2]) # pět krát dva
print(nasobilka[8][7]) # osm krát sedm
# Vypsání celé tabulky
for radek in nasobilka:
for cislo in radek:
print(cislo, end=' ')
print()
Co s takovou „zapamatovanou” tabulkou? Můžeš si do ní uložit třeba pozice figurek na šachovnici nebo křížků a koleček ve 2D piškvorkách.
{
"data": {
"sessionMaterial": {
"id": "session-material:2018/czechitas-ostrava-jaro:def-str-list:3",
"title": "Seznamy",
"html": "\n \n \n\n <p>Tahle kapitola je plná nových věcí.\nDoufám, že vydržíš až do konce. A kdyby něco\nzatím nedávalo úplně smysl, nevěš hlavu:\nvěci, které si teď vysvětlíme, se opravdu naučíš\naž v dalších lekcích, kde je budeme využívat\nprakticky.</p>\n<p>Encyklopedické informace z této stránky shrnuje\n<a href=\"https://github.com/pyvec/cheatsheets/blob/master/lists/lists-cs.pdf\">Tahák na seznamy</a>,\nkterý si doporučuji vytisknout.</p>\n<p>Každý příklad v tomto textu si vyzkoušej;\nto, co Python vypíše, je důležitá součást lekce,\ni když v materiálech není přímo napsaná.</p>\n<h1>Seznamy</h1>\n<p>Dnes si ukážeme, jak pracovat se <em>seznamy</em> (angl. <em>lists</em>).\nDoufám, že víš, kde máš na klávesnici hranaté\nzávorky, protože právě těmi se seznamy vytváří:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">cisla</span> <span class=\"o\">=</span> <span class=\"p\">[</span><span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">2</span><span class=\"p\">,</span> <span class=\"mi\">3</span><span class=\"p\">,</span> <span class=\"mi\">5</span><span class=\"p\">,</span> <span class=\"mi\">8</span><span class=\"p\">,</span> <span class=\"mi\">13</span><span class=\"p\">]</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">cisla</span><span class=\"p\">)</span>\n</pre></div><div class=\"admonition note\"><p>Nemůžeš najít hranaté závorky?\nNa české klávesnici zkus pravý <kbd>Alt</kbd> + <kbd>F</kbd> a <kbd>G</kbd>.</p>\n</div><p>Seznam je hodnota, která může obsahovat spoustu dalších hodnot.\nTak jako řetězec obsahuje sekvenci znaků,\nseznam obsahuje sekvenci... čehokoliv. Třeba čísel.\nA tak jako můžeme pomocí cyklu <code>for</code>\nprocházet řetězec po znacích,\nseznam můžeme procházet po jednotlivých prvcích:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"k\">for</span> <span class=\"n\">cislo</span> <span class=\"ow\">in</span> <span class=\"n\">cisla</span><span class=\"p\">:</span>\n <span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">cislo</span><span class=\"p\">)</span>\n</pre></div><p>Seznamy se v programech vyskytují velice často:\nsoubor se dá načíst jako seznam řetězců\ns jednotlivými řádky,\nseznam řetězců jako <code>'7♥'</code>\na <code>'K♣'</code> může posloužit jako balíček karet,\nmatematika je plná číselných řad,\nkaždá online služba má seznam uživatelů.</p>\n<p>Hodnoty v seznamu můžou být jakéhokoli typu,\ndokonce můžeme různé typy míchat v jednom seznamu\n(i když s takovými namixovanými seznamy se\npříliš často nesetkáme – více se používají v\n<var>n</var>-ticích, o kterých si povíme později):</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">seznam</span> <span class=\"o\">=</span> <span class=\"p\">[</span><span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"s1\">'abc'</span><span class=\"p\">,</span> <span class=\"bp\">True</span><span class=\"p\">,</span> <span class=\"bp\">None</span><span class=\"p\">,</span> <span class=\"nb\">range</span><span class=\"p\">(</span><span class=\"mi\">10</span><span class=\"p\">),</span> <span class=\"nb\">len</span><span class=\"p\">]</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">seznam</span><span class=\"p\">)</span>\n</pre></div><h2>Vybírání ze seznamů</h2>\n<p>Nejzákladnější operaci se seznamy,\ncyklus <code>for</code>, už jsme si ukázaly.\nDruhá nejdůležitější operace je vybírání\njednotlivých prvků.\nTo funguje jako u řetězců: do hranatých závorek\nse dá číslo prvku. Čísluje se, jako u řetězců,\nod nuly; záporná čísla označují prvky od konce.</p>\n<div class=\"highlight\"><pre><span></span><span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">cisla</span><span class=\"p\">[</span><span class=\"mi\">2</span><span class=\"p\">])</span>\n</pre></div><p>Hranatými závorkami můžeme získávat podseznamy.\n<a href=\"/2018/czechitas-ostrava-jaro/beginners/str/#slicing-diagram\">Diagram z materiálů k řetězcům</a>\nukazuje, jak u takového „sekání” číslovat:\nfunguje to stejně, jen místo menšího řetězce\ndostaneme menší seznam.</p>\n<div class=\"highlight\"><pre><span></span><span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">cisla</span><span class=\"p\">[</span><span class=\"mi\">2</span><span class=\"p\">:</span><span class=\"o\">-</span><span class=\"mi\">3</span><span class=\"p\">])</span>\n</pre></div><h2>Měnění seznamů</h2>\n<p>Důležitá vlastnost seznamů, kterou nemají ani čísla, ani řetězce\n(a <code>True</code>/<code>False</code>/<code>None</code> už vůbec ne), je,\nže seznamy se dají měnit.</p>\n<p>Čísla měnit nejdou – máš-li <code>a = 3</code> a\nnapíšeš <code>a = a + 1</code>, číslo <code>3</code> se nezmění.\nVypočítá se nové číslo <code>4</code> a proměnná <code>a</code>\nse nastaví na toto nové číslo.</p>\n<p>Oproti tomu seznamy se dají měnit bez nastavování proměnné.\nZákladní způsob, jak změnit seznam, je přidání\nprvku na konec pomocí metody <code>append</code>.\nTa <em>nic nevrací</em> (resp. vrací <code>None</code>),\nale „na místě” (angl. <em>in place</em>) změní\nseznam, na kterém pracuje. Vyzkoušej si to:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">prvocisla</span> <span class=\"o\">=</span> <span class=\"p\">[</span><span class=\"mi\">2</span><span class=\"p\">,</span> <span class=\"mi\">3</span><span class=\"p\">,</span> <span class=\"mi\">5</span><span class=\"p\">,</span> <span class=\"mi\">7</span><span class=\"p\">,</span> <span class=\"mi\">11</span><span class=\"p\">,</span> <span class=\"mi\">13</span><span class=\"p\">,</span> <span class=\"mi\">17</span><span class=\"p\">]</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">prvocisla</span><span class=\"p\">)</span>\n<span class=\"n\">prvocisla</span><span class=\"o\">.</span><span class=\"n\">append</span><span class=\"p\">(</span><span class=\"mi\">19</span><span class=\"p\">)</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">prvocisla</span><span class=\"p\">)</span>\n</pre></div><p>Takové měnění hodnoty může být občas překvapující,\nprotože stejnou hodnotu může mít více proměnných.\nProtože se mění hodnota samotná, může to vypadat,\nže se proměnná „mění aniž na ni sáhneme”:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">a</span> <span class=\"o\">=</span> <span class=\"p\">[</span><span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">2</span><span class=\"p\">,</span> <span class=\"mi\">3</span><span class=\"p\">]</span> <span class=\"c1\"># vytvoření seznamu</span>\n<span class=\"n\">b</span> <span class=\"o\">=</span> <span class=\"n\">a</span> <span class=\"c1\"># tady se nový seznam nevytváří</span>\n\n<span class=\"c1\"># seznam vytvořený v prvním řádku má teď dvě jména: "a" a "b",</span>\n<span class=\"c1\"># ale stále pracujeme jenom s jedním seznamem</span>\n\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">b</span><span class=\"p\">)</span>\n<span class=\"n\">a</span><span class=\"o\">.</span><span class=\"n\">append</span><span class=\"p\">(</span><span class=\"mi\">4</span><span class=\"p\">)</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">b</span><span class=\"p\">)</span>\n</pre></div><h2>Další způsoby, jak měnit seznamy</h2>\n<p>Kromě metody <code>append</code>, která přidává\njediný prvek, existuje metoda <code>extend</code>,\nkterá umí přidávat prvků víc.\nPrvky k přidání jí předáme ve formě seznamu:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">dalsi_prvocisla</span> <span class=\"o\">=</span> <span class=\"p\">[</span><span class=\"mi\">23</span><span class=\"p\">,</span> <span class=\"mi\">29</span><span class=\"p\">,</span> <span class=\"mi\">31</span><span class=\"p\">]</span>\n<span class=\"n\">prvocisla</span><span class=\"o\">.</span><span class=\"n\">extend</span><span class=\"p\">(</span><span class=\"n\">dalsi_prvocisla</span><span class=\"p\">)</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">prvocisla</span><span class=\"p\">)</span>\n</pre></div><p>Metoda <code>extend</code> umí pracovat i s jinými\ntypy než se seznamy – ráda zpracuje cokoli, přes\nco umí cyklit <code>for</code>: např.\njednotlivé znaky řetězců, řádky souborů, nebo čísla z <code>range()</code>.</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">seznam</span> <span class=\"o\">=</span> <span class=\"p\">[]</span>\n<span class=\"n\">seznam</span><span class=\"o\">.</span><span class=\"n\">extend</span><span class=\"p\">(</span><span class=\"s1\">'abcdef'</span><span class=\"p\">)</span>\n<span class=\"n\">seznam</span><span class=\"o\">.</span><span class=\"n\">extend</span><span class=\"p\">(</span><span class=\"nb\">range</span><span class=\"p\">(</span><span class=\"mi\">10</span><span class=\"p\">))</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">seznam</span><span class=\"p\">)</span>\n</pre></div><h2>Měnění prvků</h2>\n<p>Ale dost přidávání.\nSeznamům se dají i měnit jednotlivé prvky\na to jednoduše tak, že do prvku přiřadíme,\njako by to byla proměnná:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">cisla</span> <span class=\"o\">=</span> <span class=\"p\">[</span><span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"mi\">3</span><span class=\"p\">,</span> <span class=\"mi\">4</span><span class=\"p\">]</span>\n<span class=\"n\">cisla</span><span class=\"p\">[</span><span class=\"mi\">1</span><span class=\"p\">]</span> <span class=\"o\">=</span> <span class=\"mi\">2</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">cisla</span><span class=\"p\">)</span>\n</pre></div><p>Přiřazovat se dá i do podseznamu – v tomto případě\nse podseznam nahradí jednotlivými prvky z toho,\nco přiřazujeme.\nJako u <code>extend</code> můžeš do podseznamu opět přiřadit cokoli, co umí\nzpracovat <code>for</code> – seznam, řetězec, <code>range()</code> apod.</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">cisla</span> <span class=\"o\">=</span> <span class=\"p\">[</span><span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">2</span><span class=\"p\">,</span> <span class=\"mi\">3</span><span class=\"p\">,</span> <span class=\"mi\">4</span><span class=\"p\">]</span>\n<span class=\"n\">cisla</span><span class=\"p\">[</span><span class=\"mi\">1</span><span class=\"p\">:</span><span class=\"o\">-</span><span class=\"mi\">1</span><span class=\"p\">]</span> <span class=\"o\">=</span> <span class=\"p\">[</span><span class=\"mi\">6</span><span class=\"p\">,</span> <span class=\"mi\">5</span><span class=\"p\">]</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">cisla</span><span class=\"p\">)</span>\n</pre></div><h2>Mazání prvků</h2>\n<p>Přiřazením do podseznamu se dá i změnit délka\nseznamu, nebo některé prvky úplně odstranit:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">cisla</span> <span class=\"o\">=</span> <span class=\"p\">[</span><span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">2</span><span class=\"p\">,</span> <span class=\"mi\">3</span><span class=\"p\">,</span> <span class=\"mi\">4</span><span class=\"p\">]</span>\n<span class=\"n\">cisla</span><span class=\"p\">[</span><span class=\"mi\">1</span><span class=\"p\">:</span><span class=\"o\">-</span><span class=\"mi\">1</span><span class=\"p\">]</span> <span class=\"o\">=</span> <span class=\"p\">[</span><span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">]</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">cisla</span><span class=\"p\">)</span>\n<span class=\"n\">cisla</span><span class=\"p\">[</span><span class=\"mi\">1</span><span class=\"p\">:</span><span class=\"o\">-</span><span class=\"mi\">1</span><span class=\"p\">]</span> <span class=\"o\">=</span> <span class=\"p\">[]</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">cisla</span><span class=\"p\">)</span>\n</pre></div><p>Tenhle zápis pro mazání prvků je ale docela\nnepřehledný, a proto na to máme zvláštní příkaz\njménem <code>del</code>.\nJak už jeho název (z angl. <em>delete</em>, smazat)\nnapovídá, smaže, co mu přijde pod ruku – jednotlivé\nprvky seznamů, podseznamy, … a dokonce i proměnné!</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">cisla</span> <span class=\"o\">=</span> <span class=\"p\">[</span><span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">2</span><span class=\"p\">,</span> <span class=\"mi\">3</span><span class=\"p\">,</span> <span class=\"mi\">4</span><span class=\"p\">,</span> <span class=\"mi\">5</span><span class=\"p\">,</span> <span class=\"mi\">6</span><span class=\"p\">]</span>\n<span class=\"k\">del</span> <span class=\"n\">cisla</span><span class=\"p\">[</span><span class=\"o\">-</span><span class=\"mi\">1</span><span class=\"p\">]</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">cisla</span><span class=\"p\">)</span>\n<span class=\"k\">del</span> <span class=\"n\">cisla</span><span class=\"p\">[</span><span class=\"mi\">3</span><span class=\"p\">:</span><span class=\"mi\">5</span><span class=\"p\">]</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">cisla</span><span class=\"p\">)</span>\n<span class=\"k\">del</span> <span class=\"n\">cisla</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">cisla</span><span class=\"p\">)</span>\n</pre></div><p>Další mazací metody jsou:</p>\n<ul>\n<li><code>pop</code>, která odstraní <em>a vrátí</em> poslední prvek v seznamu – například pokud\nmám seznam karet v balíčku, jde takhle jednoduše „líznout” kartu,</li>\n<li><code>remove</code>, která najde v seznamu daný prvek a odstraní ho,</li>\n<li><code>clear</code>, která vyprázdní celý seznam.</li>\n</ul>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">cisla</span> <span class=\"o\">=</span> <span class=\"p\">[</span><span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">2</span><span class=\"p\">,</span> <span class=\"mi\">3</span><span class=\"p\">,</span> <span class=\"s1\">'abc'</span><span class=\"p\">,</span> <span class=\"mi\">4</span><span class=\"p\">,</span> <span class=\"mi\">5</span><span class=\"p\">,</span> <span class=\"mi\">6</span><span class=\"p\">,</span> <span class=\"mi\">12</span><span class=\"p\">]</span>\n<span class=\"n\">posledni</span> <span class=\"o\">=</span> <span class=\"n\">cisla</span><span class=\"o\">.</span><span class=\"n\">pop</span><span class=\"p\">()</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">posledni</span><span class=\"p\">)</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">cisla</span><span class=\"p\">)</span>\n\n<span class=\"n\">cisla</span><span class=\"o\">.</span><span class=\"n\">remove</span><span class=\"p\">(</span><span class=\"s1\">'abc'</span><span class=\"p\">)</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">cisla</span><span class=\"p\">)</span>\n\n<span class=\"n\">cisla</span><span class=\"o\">.</span><span class=\"n\">clear</span><span class=\"p\">()</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">cisla</span><span class=\"p\">)</span>\n</pre></div><h2>Řazení</h2>\n<p>A taky tu máme metodu <code>sort</code>, která prvky seznamu seřadí.</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">seznam</span> <span class=\"o\">=</span> <span class=\"p\">[</span><span class=\"mi\">4</span><span class=\"p\">,</span> <span class=\"mi\">7</span><span class=\"p\">,</span> <span class=\"mi\">8</span><span class=\"p\">,</span> <span class=\"mi\">3</span><span class=\"p\">,</span> <span class=\"mi\">5</span><span class=\"p\">,</span> <span class=\"mi\">2</span><span class=\"p\">,</span> <span class=\"mi\">4</span><span class=\"p\">,</span> <span class=\"mi\">8</span><span class=\"p\">,</span> <span class=\"mi\">5</span><span class=\"p\">]</span>\n<span class=\"n\">seznam</span><span class=\"o\">.</span><span class=\"n\">sort</span><span class=\"p\">()</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">seznam</span><span class=\"p\">)</span>\n</pre></div><p>Aby se daly seřadit, musí být prvky seznamu vzájemně\n<em>porovnatelné</em> – konktrétně na ně musí fungovat\noperátor <code><</code>.\nSeznam s mixem čísel a řetězců tedy seřadit nepůjde.\nOperátor <code><</code> definuje i\njak přesně se řadí (např. čísla podle velikosti;\nřetězce podle speciální „abecedy” která řadí\nvelká písmena za malá, česká až za anglická, atd.).</p>\n<p>Metoda <code>sort</code> zná pojmenovaný argument\n<code>reverse</code>. Pokud ho nastavíš na <em>True</em>, řadí se „naopak”.</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">seznam</span> <span class=\"o\">=</span> <span class=\"p\">[</span><span class=\"mi\">4</span><span class=\"p\">,</span> <span class=\"mi\">7</span><span class=\"p\">,</span> <span class=\"mi\">8</span><span class=\"p\">,</span> <span class=\"mi\">3</span><span class=\"p\">,</span> <span class=\"mi\">5</span><span class=\"p\">,</span> <span class=\"mi\">2</span><span class=\"p\">,</span> <span class=\"mi\">4</span><span class=\"p\">,</span> <span class=\"mi\">8</span><span class=\"p\">,</span> <span class=\"mi\">5</span><span class=\"p\">]</span>\n<span class=\"n\">seznam</span><span class=\"o\">.</span><span class=\"n\">sort</span><span class=\"p\">(</span><span class=\"n\">reverse</span><span class=\"o\">=</span><span class=\"bp\">True</span><span class=\"p\">)</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">seznam</span><span class=\"p\">)</span>\n</pre></div><h2>Známé operace se seznamy</h2>\n<p>Spousta toho, co můžeme dělat s řetězci, má stejný\núčinek i u seznamů.\nTřeba sečítání a násobení číslem:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">melodie</span> <span class=\"o\">=</span> <span class=\"p\">[</span><span class=\"s1\">'C'</span><span class=\"p\">,</span> <span class=\"s1\">'E'</span><span class=\"p\">,</span> <span class=\"s1\">'G'</span><span class=\"p\">]</span> <span class=\"o\">*</span> <span class=\"mi\">2</span> <span class=\"o\">+</span> <span class=\"p\">[</span><span class=\"s1\">'E'</span><span class=\"p\">,</span> <span class=\"s1\">'E'</span><span class=\"p\">,</span> <span class=\"s1\">'D'</span><span class=\"p\">,</span> <span class=\"s1\">'E'</span><span class=\"p\">,</span> <span class=\"s1\">'F'</span><span class=\"p\">,</span> <span class=\"s1\">'D'</span><span class=\"p\">]</span> <span class=\"o\">*</span> <span class=\"mi\">2</span> <span class=\"o\">+</span> <span class=\"p\">[</span><span class=\"s1\">'E'</span><span class=\"p\">,</span> <span class=\"s1\">'D'</span><span class=\"p\">,</span> <span class=\"s1\">'C'</span><span class=\"p\">]</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">melodie</span><span class=\"p\">)</span>\n</pre></div><p>Stejně jako u řetězců, sečítat jde jen seznam\nse seznamem – ne třeba seznam s řetězcem.</p>\n<p>Další staří známí jsou funkce <code>len</code>,\nmetody <code>count</code> a <code>index</code>, a operátor <code>in</code>.</p>\n<div class=\"highlight\"><pre><span></span><span class=\"k\">print</span><span class=\"p\">(</span><span class=\"nb\">len</span><span class=\"p\">(</span><span class=\"n\">melodie</span><span class=\"p\">))</span> <span class=\"c1\"># Délka seznamu</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">melodie</span><span class=\"o\">.</span><span class=\"n\">count</span><span class=\"p\">(</span><span class=\"s1\">'D'</span><span class=\"p\">))</span> <span class=\"c1\"># Počet 'D' v seznamu</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">melodie</span><span class=\"o\">.</span><span class=\"n\">index</span><span class=\"p\">(</span><span class=\"s1\">'D'</span><span class=\"p\">))</span> <span class=\"c1\"># Číslo prvního 'D'</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s1\">'D'</span> <span class=\"ow\">in</span> <span class=\"n\">melodie</span><span class=\"p\">)</span> <span class=\"c1\"># Je 'D' v seznamu?</span>\n</pre></div><p>Poslední tři se ale přece jen chovají kapku jinak:\nu řetězců pracují s <em>podřetězci</em>,\nu seznamů jen s <em>jednotlivými</em> prvky.\nTakže ačkoliv naše melodie obsahuje prvky\n<code>'D'</code> a <code>'E'</code> vedle sebe, <code>'DE'</code> v seznamu není:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s1\">'DE'</span> <span class=\"ow\">in</span> <span class=\"n\">melodie</span><span class=\"p\">)</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">melodie</span><span class=\"o\">.</span><span class=\"n\">count</span><span class=\"p\">(</span><span class=\"s1\">'DE'</span><span class=\"p\">))</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">melodie</span><span class=\"o\">.</span><span class=\"n\">index</span><span class=\"p\">(</span><span class=\"s1\">'DE'</span><span class=\"p\">))</span>\n</pre></div><h2>Seznam jako podmínka</h2>\n<p>Seznam se dá použít v příkazu <code>if</code> (nebo <code>while</code>) jako podmínka,\nkterá platí, když v tom seznamu něco je.\nJinými slovy, <code>seznam</code> je tu „zkratka“ pro <code>len(seznam) > 0</code>.</p>\n<div class=\"highlight\"><pre><span></span><span class=\"k\">if</span> <span class=\"n\">seznam</span><span class=\"p\">:</span>\n <span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s1\">'V seznamu něco je!'</span><span class=\"p\">)</span>\n<span class=\"k\">else</span><span class=\"p\">:</span>\n <span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s1\">'Seznam je prázdný!'</span><span class=\"p\">)</span>\n</pre></div><p>Podobně se dají v podmínce použít i řetězce.\nA dokonce i čísla – ta jako podmínka platí, pokud jsou nenulová.</p>\n<h2>Tvoření seznamů</h2>\n<p>Tak jako funkce <code>int</code> převádí na\ncelá čísla a <code>str</code> na řetězce,\nfunkce <code>list</code> (angl. <em>seznam</em>) převádí na seznam.\nJako argument jí předáme jakoukoli hodnotu,\nkterou umí zpracovat příkaz <code>for</code>.\nZ řetězců udělá seznam znaků, z otevřeného souboru\nudělá seznam řádků, z <code>range</code> udělá\nseznam čísel.</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">abeceda</span> <span class=\"o\">=</span> <span class=\"nb\">list</span><span class=\"p\">(</span><span class=\"s1\">'abcdefghijklmnopqrstuvwxyz'</span><span class=\"p\">)</span>\n<span class=\"n\">cisla</span> <span class=\"o\">=</span> <span class=\"nb\">list</span><span class=\"p\">(</span><span class=\"nb\">range</span><span class=\"p\">(</span><span class=\"mi\">100</span><span class=\"p\">))</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">abeceda</span><span class=\"p\">)</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">cisla</span><span class=\"p\">)</span>\n</pre></div><p>I ze seznamu udělá funkce <code>list</code> seznam.\nTo může znít zbytečně, ale není – vytvoří se\ntotiž <em>nový</em> seznam.\nBude mít sice stejné prvky ve stejném pořadí,\nale nebude to ten samý seznam:\nměnit se bude nezávisle na tom starém.</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">a</span> <span class=\"o\">=</span> <span class=\"p\">[</span><span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">2</span><span class=\"p\">,</span> <span class=\"mi\">3</span><span class=\"p\">]</span>\n<span class=\"n\">b</span> <span class=\"o\">=</span> <span class=\"nb\">list</span><span class=\"p\">(</span><span class=\"n\">a</span><span class=\"p\">)</span>\n\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">b</span><span class=\"p\">)</span>\n<span class=\"n\">a</span><span class=\"o\">.</span><span class=\"n\">append</span><span class=\"p\">(</span><span class=\"mi\">4</span><span class=\"p\">)</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">b</span><span class=\"p\">)</span>\n</pre></div><p>Další způsob, jak tvořit seznamy\n(zvláště složitější), je nejdřív udělat prázdný\nseznam a pak ho postupně naplnit pomocí funkce <code>append</code>.\nTřeba pokud z nějakého důvodu chceš seznam\nmocnin dvou, projdi čísla, kterými chceme mocnit,\ncyklem <code>for</code> a pro každé z nich\ndo seznamu přidej příslušnou mocninu:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">mocniny_dvou</span> <span class=\"o\">=</span> <span class=\"p\">[]</span>\n<span class=\"k\">for</span> <span class=\"n\">cislo</span> <span class=\"ow\">in</span> <span class=\"nb\">range</span><span class=\"p\">(</span><span class=\"mi\">10</span><span class=\"p\">):</span>\n <span class=\"n\">mocniny_dvou</span><span class=\"o\">.</span><span class=\"n\">append</span><span class=\"p\">(</span><span class=\"mi\">2</span> <span class=\"o\">**</span> <span class=\"n\">cislo</span><span class=\"p\">)</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">mocniny_dvou</span><span class=\"p\">)</span>\n</pre></div><p>Chceš-li seznam, který reprezentuje balíček karet,\nzavolej <code>append</code> pro všechny kombinace barev a hodnot.</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">balicek</span> <span class=\"o\">=</span> <span class=\"p\">[]</span>\n<span class=\"k\">for</span> <span class=\"n\">barva</span> <span class=\"ow\">in</span> <span class=\"s1\">'♠'</span><span class=\"p\">,</span> <span class=\"s1\">'♥'</span><span class=\"p\">,</span> <span class=\"s1\">'♦'</span><span class=\"p\">,</span> <span class=\"s1\">'♣'</span><span class=\"p\">:</span> <span class=\"c1\"># (Na Windows použij textová jména)</span>\n <span class=\"k\">for</span> <span class=\"n\">hodnota</span> <span class=\"ow\">in</span> <span class=\"nb\">list</span><span class=\"p\">(</span><span class=\"nb\">range</span><span class=\"p\">(</span><span class=\"mi\">2</span><span class=\"p\">,</span> <span class=\"mi\">11</span><span class=\"p\">))</span> <span class=\"o\">+</span> <span class=\"p\">[</span><span class=\"s1\">'J'</span><span class=\"p\">,</span> <span class=\"s1\">'Q'</span><span class=\"p\">,</span> <span class=\"s1\">'K'</span><span class=\"p\">,</span> <span class=\"s1\">'A'</span><span class=\"p\">]:</span>\n <span class=\"n\">balicek</span><span class=\"o\">.</span><span class=\"n\">append</span><span class=\"p\">(</span><span class=\"nb\">str</span><span class=\"p\">(</span><span class=\"n\">hodnota</span><span class=\"p\">)</span> <span class=\"o\">+</span> <span class=\"n\">barva</span><span class=\"p\">)</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">balicek</span><span class=\"p\">)</span>\n</pre></div><h2>Seznamy a řetězce</h2>\n<p>Seznamy a řetězce jsou druhy „sekvencí”,\ntakže snad nepřekvapí, že se dá různě převádět\nz jednoho typu na druhý.\nFunkce <code>list</code> vytvoří z řetězce\nseznam znaků.\nKdyž chceme dostat seznam slov, použijeme\nna řetězci metodu <code>split</code> (angl. <em>rozdělit</em>):</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">slova</span> <span class=\"o\">=</span> <span class=\"s1\">'Tato věta je složitá, rozdělme ji na slova!'</span><span class=\"o\">.</span><span class=\"n\">split</span><span class=\"p\">()</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">slova</span><span class=\"p\">)</span>\n</pre></div><p>Metoda <code>split</code> umí brát i argument.\nPokud ho předáme, místo mezer (a nových řádků)\nse řetězec „rozseká” daným oddělovačem.\nTakže když máme nějaká data oddělená čárkami,\nnení nic jednoduššího než použít <code>split</code> s čárkou:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">zaznamy</span> <span class=\"o\">=</span> <span class=\"s1\">'3A,8B,2E,9D'</span><span class=\"o\">.</span><span class=\"n\">split</span><span class=\"p\">(</span><span class=\"s1\">','</span><span class=\"p\">)</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">zaznamy</span><span class=\"p\">)</span>\n</pre></div><p>Chceme-li spojit seznam řetězců zase dohromady\ndo jediného řetězce, použijeme metodu\n<code>join</code> (angl. <em>spojit</em>).\nPozor, tahle metoda se volá na <em>oddělovači</em>,\ntedy řetězci, kterým se jednotlivé kousky „slepí”\ndohromady; a jako argument bere seznam jednotlivých\nřetězců.</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">veta</span> <span class=\"o\">=</span> <span class=\"s1\">' '</span><span class=\"o\">.</span><span class=\"n\">join</span><span class=\"p\">(</span><span class=\"n\">slova</span><span class=\"p\">)</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">veta</span><span class=\"p\">)</span>\n</pre></div><h2>Úkol</h2>\n<p>Představ si, že ti uživatelé zadávají jména a příjmení a ty si je ukládáš do\nseznamu pro další použití např. v evidenci studentů. Ne všichni jsou ale pořádní,\na tak se v seznamu sem tam objeví i jméno s nesprávně zadanými velkými písmeny.\nNapříklad:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">zaznamy</span> <span class=\"o\">=</span> <span class=\"p\">[</span><span class=\"s1\">'pepa novák'</span><span class=\"p\">,</span> <span class=\"s1\">'Jiří Sládek'</span><span class=\"p\">,</span> <span class=\"s1\">'Ivo navrátil'</span><span class=\"p\">,</span> <span class=\"s1\">'jan Poledník'</span><span class=\"p\">]</span>\n</pre></div><p>Úkolem je:</p>\n<ul>\n<li>Napsat funkci, která vybere jen ty správně zadané záznamy, které mají správně\njméno i příjmení s velkým počátečním písmenem.</li>\n<li>Napsat funkci, která vybere naopak jen ty nesprávně zadané záznamy.</li>\n<li><em>(Nepovinný)</em> – Napsat funkci, která vrátí seznam s opravenými záznamy.</li>\n</ul>\n<p>Výsledné funkce by měly fungovat takto:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">zaznamy</span> <span class=\"o\">=</span> <span class=\"p\">[</span><span class=\"s1\">'pepa novák'</span><span class=\"p\">,</span> <span class=\"s1\">'Jiří Sládek'</span><span class=\"p\">,</span> <span class=\"s1\">'Ivo navrátil'</span><span class=\"p\">,</span> <span class=\"s1\">'jan Poledník'</span><span class=\"p\">]</span>\n\n<span class=\"n\">chybne_zaznamy</span> <span class=\"o\">=</span> <span class=\"n\">vyber_chybne</span><span class=\"p\">(</span><span class=\"n\">zaznamy</span><span class=\"p\">)</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">chybne_zaznamy</span><span class=\"p\">)</span> <span class=\"c1\"># → ['pepa novák', 'Ivo navrátil', 'jan Poledník']</span>\n\n<span class=\"n\">spravne_zaznamy</span> <span class=\"o\">=</span> <span class=\"n\">vyber_spravne</span><span class=\"p\">(</span><span class=\"n\">zaznamy</span><span class=\"p\">)</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">spravne_zaznamy</span><span class=\"p\">)</span> <span class=\"c1\"># → ['Jiří Sládek']</span>\n\n<span class=\"n\">opravene_zaznamy</span> <span class=\"o\">=</span> <span class=\"n\">oprav_zaznamy</span><span class=\"p\">(</span><span class=\"n\">zaznamy</span><span class=\"p\">)</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">opravene_zaznamy</span><span class=\"p\">)</span> <span class=\"c1\"># → ['Pepa Novák', 'Jiří Sládek', 'Ivo Navrátil', 'Jan Poledník']</span>\n</pre></div><div class=\"admonition note\"><p>Snadný způsob jak zjistit, zda je řetězec složen jen z malých písmen,\nje metoda <code>islower()</code>, která vrací True, pokud řetězec obsahuje jen malá\npísmena, jinak vrací False. Například <code>'abc'.islower() == True</code> ale\n<code>'aBc'.islower() == False</code>.</p>\n<p>Snadný způsob jak převést první písmenko na velké je metoda <code>capitalize()</code>:\nnapř. <code>'abc'.capitalize() == 'Abc'</code></p>\n</div><div class=\"solution\" id=\"solution-0\">\n <h3>Řešení</h3>\n <div class=\"solution-cover\">\n <a href=\"/2018/czechitas-ostrava-jaro/beginners/list/index/solutions/0/\"><span class=\"link-text\">Ukázat řešení</span></a>\n </div>\n <div class=\"solution-body\" aria-hidden=\"true\">\n <div class=\"highlight\"><pre><span></span><span class=\"k\">def</span> <span class=\"nf\">vyber_chybne</span><span class=\"p\">(</span><span class=\"n\">seznam</span><span class=\"p\">):</span>\n <span class=\"n\">vysledek</span> <span class=\"o\">=</span> <span class=\"p\">[]</span>\n <span class=\"k\">for</span> <span class=\"n\">zaznam</span> <span class=\"ow\">in</span> <span class=\"n\">seznam</span><span class=\"p\">:</span>\n <span class=\"n\">jmeno_a_prijmeni</span> <span class=\"o\">=</span> <span class=\"n\">zaznam</span><span class=\"o\">.</span><span class=\"n\">split</span><span class=\"p\">(</span><span class=\"s1\">' '</span><span class=\"p\">)</span>\n <span class=\"n\">jmeno</span> <span class=\"o\">=</span> <span class=\"n\">jmeno_a_prijmeni</span><span class=\"p\">[</span><span class=\"mi\">0</span><span class=\"p\">]</span>\n <span class=\"n\">prijmeni</span> <span class=\"o\">=</span> <span class=\"n\">jmeno_a_prijmeni</span><span class=\"p\">[</span><span class=\"mi\">1</span><span class=\"p\">]</span>\n <span class=\"k\">if</span> <span class=\"n\">jmeno</span><span class=\"p\">[</span><span class=\"mi\">0</span><span class=\"p\">]</span><span class=\"o\">.</span><span class=\"n\">islower</span><span class=\"p\">()</span> <span class=\"ow\">or</span> <span class=\"n\">prijmeni</span><span class=\"p\">[</span><span class=\"mi\">0</span><span class=\"p\">]</span><span class=\"o\">.</span><span class=\"n\">islower</span><span class=\"p\">():</span>\n <span class=\"n\">vysledek</span><span class=\"o\">.</span><span class=\"n\">append</span><span class=\"p\">(</span><span class=\"n\">zaznam</span><span class=\"p\">)</span>\n <span class=\"k\">return</span> <span class=\"n\">vysledek</span>\n\n<span class=\"k\">def</span> <span class=\"nf\">vyber_spravne</span><span class=\"p\">(</span><span class=\"n\">seznam</span><span class=\"p\">):</span>\n <span class=\"n\">vysledek</span> <span class=\"o\">=</span> <span class=\"p\">[]</span>\n <span class=\"k\">for</span> <span class=\"n\">zaznam</span> <span class=\"ow\">in</span> <span class=\"n\">seznam</span><span class=\"p\">:</span>\n <span class=\"n\">jmeno_a_prijmeni</span> <span class=\"o\">=</span> <span class=\"n\">zaznam</span><span class=\"o\">.</span><span class=\"n\">split</span><span class=\"p\">(</span><span class=\"s1\">' '</span><span class=\"p\">)</span>\n <span class=\"n\">jmeno</span> <span class=\"o\">=</span> <span class=\"n\">jmeno_a_prijmeni</span><span class=\"p\">[</span><span class=\"mi\">0</span><span class=\"p\">]</span>\n <span class=\"n\">prijmeni</span> <span class=\"o\">=</span> <span class=\"n\">jmeno_a_prijmeni</span><span class=\"p\">[</span><span class=\"mi\">1</span><span class=\"p\">]</span>\n <span class=\"k\">if</span> <span class=\"ow\">not</span> <span class=\"n\">jmeno</span><span class=\"p\">[</span><span class=\"mi\">0</span><span class=\"p\">]</span><span class=\"o\">.</span><span class=\"n\">islower</span><span class=\"p\">()</span> <span class=\"ow\">and</span> <span class=\"ow\">not</span> <span class=\"n\">prijmeni</span><span class=\"p\">[</span><span class=\"mi\">0</span><span class=\"p\">]</span><span class=\"o\">.</span><span class=\"n\">islower</span><span class=\"p\">():</span>\n <span class=\"n\">vysledek</span><span class=\"o\">.</span><span class=\"n\">append</span><span class=\"p\">(</span><span class=\"n\">zaznam</span><span class=\"p\">)</span>\n <span class=\"k\">return</span> <span class=\"n\">vysledek</span>\n\n<span class=\"k\">def</span> <span class=\"nf\">oprav_zaznamy</span><span class=\"p\">(</span><span class=\"n\">seznam</span><span class=\"p\">):</span>\n <span class=\"n\">vysledek</span> <span class=\"o\">=</span> <span class=\"p\">[]</span>\n <span class=\"k\">for</span> <span class=\"n\">zaznam</span> <span class=\"ow\">in</span> <span class=\"n\">seznam</span><span class=\"p\">:</span>\n <span class=\"n\">jmeno_a_prijmeni</span> <span class=\"o\">=</span> <span class=\"n\">zaznam</span><span class=\"o\">.</span><span class=\"n\">split</span><span class=\"p\">(</span><span class=\"s1\">' '</span><span class=\"p\">)</span>\n <span class=\"n\">jmeno</span> <span class=\"o\">=</span> <span class=\"n\">jmeno_a_prijmeni</span><span class=\"p\">[</span><span class=\"mi\">0</span><span class=\"p\">]</span>\n <span class=\"n\">prijmeni</span> <span class=\"o\">=</span> <span class=\"n\">jmeno_a_prijmeni</span><span class=\"p\">[</span><span class=\"mi\">1</span><span class=\"p\">]</span>\n <span class=\"n\">vysledek</span><span class=\"o\">.</span><span class=\"n\">append</span><span class=\"p\">(</span><span class=\"n\">jmeno</span><span class=\"o\">.</span><span class=\"n\">capitalize</span><span class=\"p\">()</span> <span class=\"o\">+</span> <span class=\"s1\">' '</span> <span class=\"o\">+</span> <span class=\"n\">prijmeni</span><span class=\"o\">.</span><span class=\"n\">capitalize</span><span class=\"p\">())</span>\n <span class=\"k\">return</span> <span class=\"n\">vysledek</span>\n</pre></div>\n </div>\n</div><h2>Seznamy a náhoda</h2>\n<p>Modul <code>random</code> obsahuje dvě funkce, které se hodí k seznamům.\nJako <code>random.randrange</code>, obě mají něco\nspolečného s náhodou.</p>\n<p>Funkce <code>shuffle</code> seznam „zamíchá” – všechny prvky náhodně popřehází.\nJako metoda <code>sort</code> i funkce <code>shuffle</code> nic nevrací.</p>\n<div class=\"highlight\"><pre><span></span><span class=\"kn\">import</span> <span class=\"nn\">random</span>\n\n<span class=\"n\">balicek</span> <span class=\"o\">=</span> <span class=\"p\">[]</span>\n<span class=\"k\">for</span> <span class=\"n\">barva</span> <span class=\"ow\">in</span> <span class=\"s1\">'♠'</span><span class=\"p\">,</span> <span class=\"s1\">'♥'</span><span class=\"p\">,</span> <span class=\"s1\">'♦'</span><span class=\"p\">,</span> <span class=\"s1\">'♣'</span><span class=\"p\">:</span>\n <span class=\"k\">for</span> <span class=\"n\">hodnota</span> <span class=\"ow\">in</span> <span class=\"nb\">list</span><span class=\"p\">(</span><span class=\"nb\">range</span><span class=\"p\">(</span><span class=\"mi\">2</span><span class=\"p\">,</span> <span class=\"mi\">11</span><span class=\"p\">))</span> <span class=\"o\">+</span> <span class=\"p\">[</span><span class=\"s1\">'J'</span><span class=\"p\">,</span> <span class=\"s1\">'Q'</span><span class=\"p\">,</span> <span class=\"s1\">'K'</span><span class=\"p\">,</span> <span class=\"s1\">'A'</span><span class=\"p\">]:</span>\n <span class=\"n\">balicek</span><span class=\"o\">.</span><span class=\"n\">append</span><span class=\"p\">(</span><span class=\"nb\">str</span><span class=\"p\">(</span><span class=\"n\">hodnota</span><span class=\"p\">)</span> <span class=\"o\">+</span> <span class=\"n\">barva</span><span class=\"p\">)</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">balicek</span><span class=\"p\">)</span>\n\n<span class=\"n\">random</span><span class=\"o\">.</span><span class=\"n\">shuffle</span><span class=\"p\">(</span><span class=\"n\">balicek</span><span class=\"p\">)</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">balicek</span><span class=\"p\">)</span>\n</pre></div><p>A funkce <code>choice</code> ze seznamu vybere jeden náhodný prvek.\nS použitím seznamu tak můžeme výrazně zjednodušit\núvodní část naší staré hry kámen/nůžky/papír:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"kn\">import</span> <span class=\"nn\">random</span>\n<span class=\"n\">mozne_tahy</span> <span class=\"o\">=</span> <span class=\"p\">[</span><span class=\"s1\">'kámen'</span><span class=\"p\">,</span> <span class=\"s1\">'nůžky'</span><span class=\"p\">,</span> <span class=\"s1\">'papír'</span><span class=\"p\">]</span>\n<span class=\"n\">tah_pocitace</span> <span class=\"o\">=</span> <span class=\"n\">random</span><span class=\"o\">.</span><span class=\"n\">choice</span><span class=\"p\">(</span><span class=\"n\">mozne_tahy</span><span class=\"p\">)</span>\n</pre></div><h2>Vnořené seznamy</h2>\n<p>A perlička na konec!\nNa začátku tohoto textu je napsáno, že seznam\nmůže obsahovat jakýkoli typ hodnot.\nMůže třeba obsahovat i další seznamy:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">seznam_seznamu</span> <span class=\"o\">=</span> <span class=\"p\">[[</span><span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">2</span><span class=\"p\">,</span> <span class=\"mi\">3</span><span class=\"p\">],</span> <span class=\"p\">[</span><span class=\"mi\">4</span><span class=\"p\">,</span> <span class=\"mi\">5</span><span class=\"p\">,</span> <span class=\"mi\">6</span><span class=\"p\">],</span> <span class=\"p\">[</span><span class=\"mi\">7</span><span class=\"p\">,</span> <span class=\"mi\">8</span><span class=\"p\">,</span> <span class=\"mi\">9</span><span class=\"p\">]]</span>\n</pre></div><p>Takový seznam se chová docela normálně – jdou\nz něj třeba brát jednotlivé prvky\n(které jsou ovšem taky seznamy):</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">prvni_seznam</span> <span class=\"o\">=</span> <span class=\"n\">seznam_seznamu</span><span class=\"p\">[</span><span class=\"mi\">0</span><span class=\"p\">]</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">prvni_seznam</span><span class=\"p\">)</span>\n</pre></div><p>A protože jsou prvky samy seznamy,\nmůžeme mluvit o věcech jako „první prvek druhého seznamu”:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">druhy_seznam</span> <span class=\"o\">=</span> <span class=\"n\">seznam_seznamu</span><span class=\"p\">[</span><span class=\"mi\">1</span><span class=\"p\">]</span>\n<span class=\"n\">prvni_prvek_druheho_seznamu</span> <span class=\"o\">=</span> <span class=\"n\">druhy_seznam</span><span class=\"p\">[</span><span class=\"mi\">0</span><span class=\"p\">]</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">prvni_prvek_druheho_seznamu</span><span class=\"p\">)</span>\n</pre></div><p>A protože výraz <code>seznam_seznamu[1]</code>\noznačuje seznam, můžeme brát prvky přímo z něj:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">prvni_prvek_druheho_seznamu</span> <span class=\"o\">=</span> <span class=\"p\">(</span><span class=\"n\">seznam_seznamu</span><span class=\"p\">[</span><span class=\"mi\">1</span><span class=\"p\">])[</span><span class=\"mi\">0</span><span class=\"p\">]</span>\n</pre></div><p>Neboli:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">prvni_prvek_druheho_seznamu</span> <span class=\"o\">=</span> <span class=\"n\">seznam_seznamu</span><span class=\"p\">[</span><span class=\"mi\">1</span><span class=\"p\">][</span><span class=\"mi\">0</span><span class=\"p\">]</span>\n</pre></div><p>A má tahle věc nějaké použití, ptáš se?\nStejně jako vnořené cykly <code>for</code>\nnám umožnily vypsat tabulku, vnořené seznamy\nnám umožní si tabulku „zapamatovat”.</p>\n<div class=\"highlight\"><pre><span></span><span class=\"k\">def</span> <span class=\"nf\">vytvor_tabulku</span><span class=\"p\">(</span><span class=\"n\">velikost</span><span class=\"o\">=</span><span class=\"mi\">11</span><span class=\"p\">):</span>\n <span class=\"n\">seznam_radku</span> <span class=\"o\">=</span> <span class=\"p\">[]</span>\n <span class=\"k\">for</span> <span class=\"n\">a</span> <span class=\"ow\">in</span> <span class=\"nb\">range</span><span class=\"p\">(</span><span class=\"n\">velikost</span><span class=\"p\">):</span>\n <span class=\"n\">radek</span> <span class=\"o\">=</span> <span class=\"p\">[]</span>\n <span class=\"k\">for</span> <span class=\"n\">b</span> <span class=\"ow\">in</span> <span class=\"nb\">range</span><span class=\"p\">(</span><span class=\"n\">velikost</span><span class=\"p\">):</span>\n <span class=\"n\">radek</span><span class=\"o\">.</span><span class=\"n\">append</span><span class=\"p\">(</span><span class=\"n\">a</span> <span class=\"o\">*</span> <span class=\"n\">b</span><span class=\"p\">)</span>\n <span class=\"n\">seznam_radku</span><span class=\"o\">.</span><span class=\"n\">append</span><span class=\"p\">(</span><span class=\"n\">radek</span><span class=\"p\">)</span>\n <span class=\"k\">return</span> <span class=\"n\">seznam_radku</span>\n\n<span class=\"n\">nasobilka</span> <span class=\"o\">=</span> <span class=\"n\">vytvor_tabulku</span><span class=\"p\">()</span>\n\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">nasobilka</span><span class=\"p\">[</span><span class=\"mi\">2</span><span class=\"p\">][</span><span class=\"mi\">3</span><span class=\"p\">])</span> <span class=\"c1\"># dva krát tři</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">nasobilka</span><span class=\"p\">[</span><span class=\"mi\">5</span><span class=\"p\">][</span><span class=\"mi\">2</span><span class=\"p\">])</span> <span class=\"c1\"># pět krát dva</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">nasobilka</span><span class=\"p\">[</span><span class=\"mi\">8</span><span class=\"p\">][</span><span class=\"mi\">7</span><span class=\"p\">])</span> <span class=\"c1\"># osm krát sedm</span>\n\n<span class=\"c1\"># Vypsání celé tabulky</span>\n<span class=\"k\">for</span> <span class=\"n\">radek</span> <span class=\"ow\">in</span> <span class=\"n\">nasobilka</span><span class=\"p\">:</span>\n <span class=\"k\">for</span> <span class=\"n\">cislo</span> <span class=\"ow\">in</span> <span class=\"n\">radek</span><span class=\"p\">:</span>\n <span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">cislo</span><span class=\"p\">,</span> <span class=\"n\">end</span><span class=\"o\">=</span><span class=\"s1\">' '</span><span class=\"p\">)</span>\n <span class=\"k\">print</span><span class=\"p\">()</span>\n</pre></div><p>Co s takovou „zapamatovanou” tabulkou?\nMůžeš si do ní uložit třeba pozice\nfigurek na šachovnici nebo křížků a koleček\nve <em>2D</em> piškvorkách.</p>\n\n\n "
}
}
}