Teď se podíváme na zoubek řetězcům (angl. strings). Už víš, jak je zapisovat:
'tohle je řetězec'
"tohle taky"
Někdy potřebuješ řetězce, které obsahují více řádků. Pythonní řetězce ale můžeš normálně napsat jen na jeden řádek. Jinak by koncová uvozovka mohla být kdekoli a špatně by se hledala, kdybys na ni zapomněla.
Můžeš ale do řetězce znak pro nový řádek vložit pomocí speciálního
zápisu \n:
print('Haló haló!\nCo se stalo?')
Obecně zpětné lomítko umožňuje zapsat znaky, které by se špatně zadávaly.
Třeba uvozovka se dá zapsat jako \" a „apostrof“ jako \'.
To se dá použít, když potřebuješ mít v jednom
řetězci uvozovku i apostrof:
print("Vtom vnuk křik': \"Hleď!\"")
print('"Jen ho nech," řek\' děd. "Kdo zná líp kraj?"')
Sekvence \\ znamená „jedno zpětné lomítko“.
print('C:\\PyLadies\\Nový adresář')
Ale zpátky k řetězcům na více řádků. Kromě \n je i druhý způsob, jak takový
řetězec zadat: ohraničit ho třemi uvozovkami (jednoduchými nebo dvojitými)
na každé straně:
basen = '''Haló haló!
Co se stalo?
Prase kozu potrkalo!'''
Takové dlouhé texty nachází uplatnění třeba v dokumentačních řetězcích u funkcí.
def vynasob(a, b):
"""Vynásobí argumenty a vrátí výsledek.
Oba argumenty by měly být čísla.
"""
return a * b
Jen pozor na to, že pokud je tenhle řetězec v odsazeném kódu, každý jeho řádek bude začínat několika mezerami. (V dokumentačních řetězcích to nevadí, tam se s odsazením počítá.)
Tolik k zápisu řetězců. Teď se podíváme, jak se zadanými řetězci pracovat.
Už umíš spojovat dohromady kratší řetězce:
spojeny_retezec = 'a' + 'b'
dlouhy_retezec = 'ó' * 100
Teď se podíváme na opačný proces: jak z dlouhého řetězce dostat kratší součásti. Začneme jednotlivými znaky. Dělá se to operací vybrání prvku (angl. subscripting), která se píše podobně jako volání funkce, jen s hranatými závorkami:
pate_pismeno = 'čokoláda'[5]
print(pate_pismeno)
Funguje to? Dostala jsi opravdu páté písmeno?
Jak sis možná už všimla, programátoři počítají od nuly. „První“ prvek má vždy číslo nula, druhý číslo jedna a tak dál.
Stejně je to i s písmeny v řetězcích: první písmeno má číslo nula, druhé jedna, ... a osmé písmeno má číslo sedm.
Proč je tomu tak? K úplnému pochopení důvodů by ses potřebovala naučit něco o ukazatelích a polích, což nebude hned, takže pro teď nám bude stačit vědět, že programátoři jsou prostě divní.
A nebo že mají rádi divná čísla jako nulu.
[0] [1] [2] [3] [4] [5] [6] [7]
╭───┬───┬───┬───┬───┬───┬───┬───╮
│ Č │ o │ k │ o │ l │ á │ d │ a │
╰───┴───┴───┴───┴───┴───┴───┴───╯A když už jsme u divných čísel, co se asi stane, když budu chtít vybírat písmena pomocí záporných čísel?
Řetězce umí i jiné triky. Třeba můžeš zjistit, jak je řetězec dlouhý nebo jestli v sobě obsahuje daný menší řetězec.
| Zápis | Popis | Příklad |
|---|---|---|
len(r) |
Délka řetězce | len('čokoláda') |
x in r |
True pokud je řetězec x obsažen v r |
'oko' in 'čokoláda' |
x not in r |
Opak x in r |
'dub' not in 'čokoláda |
Řetězce vždy berou v potaz velikost písmen,
takže např. 'ČOKO' in 'čokoláda' je False.
Kdybys chtěla porovnávat bez ohledu na velikost písmen,
musela bys oba řetězce převést třeba na malá písmena
a pak je porovnat.
A jak se převádí na malá písmena? K tomu budeme potřebovat další novou vlastnost Pythonu: metody.
Metoda (angl. method) je jako funkce – něco, co se dá zavolat. Na rozdíl od funkce je svázaná s nějakým objektem (hodnotou). Volá se tak, že se za objekt napíše tečka, za ní jméno metody a za to celé se, jako u funkcí, připojí závorky s případnými argumenty.
Řetězcové metody upper() a lower()
převádí text na velká, respektive malá písmena.
retezec = 'Ahoj'
print(retezec.upper())
print(retezec.lower())
print(retezec)
Všimni si, že původní řetězec se nemění; metoda vrátí nový řetězec, ten starý zůstává.
To je obecná vlastnost řetězců v Pythonu: jednou existující řetězec se už nedá změnit, dá se jen vytvořit nějaký odvozený.
Pro procvičení metod a vybírání znaků si zkus napsat program, který se zeptá na jméno, pak na příjmení a pak vypíše iniciály – první písmena zadaných jmen.
Iniciály jsou vždycky velkými písmeny (i kdyby byl uživatel líný mačkat Shift).
Řetězcových metod je celá řada. Nejužitečnější z nich najdeš v taháku, který si můžeš stáhnout či vytisknout.
A úplně všechny řetězcové metody jsou popsány v dokumentaci Pythonu (anglicky; plné věcí, které ještě neznáš).
Všimni si, že len není metoda, ale funkce; píše se len(r), ne r.len().
Proč tomu tak je, to za nějakou dobu poznáš.
Obzvláště užitečná je metoda format,
která v rámci řetězce nahradí dvojice „kudrnatých“ závorek
za to, co dostane v argumentech:
vypis = '{}×{} je {}'.format(3, 4, 3 * 4)
print(vypis)
Řetězec '{}×{} je {}' tady funguje jako šablona (angl. template).
Představ si to jako jako formulář, do kterého Python na vyznačená místa
vpisuje hodnoty.
Pokud chceš nahradit hodnoty v jiném pořadí, nebo když chceš aby šablona byla čitelnější, můžeš do „kudrnatých“ závorek napsat jména:
vypis = 'Ahoj {jmeno}! Výsledek je {cislo}.'.format(cislo=7, jmeno='Elvíro')
print(vypis)
Formátování se používá skoro všude, kde je potřeba „hezky“ vypsat nějakou hodnotu.
Teď se vrátíme k vybírání kousků řetězců. Zkus, co dělá tenhle program:
retezec = 'čokoláda'
kousek = retezec[5:]
print(kousek)
Dá se použít i retezec[:5],
který vybere všechno až po znak číslo 5.
Ale ne znak 5 samotný, takže retezec[:5] + retezec[5:] == retezec.
Co asi udělá retezec[2:5]?
A co retezec[-4:]?
retezec = 'čokoláda'
print(retezec[:4])
print(retezec[2:5])
print(retezec[-4:])
Určování vhodných čísel, indexů, občas vyžaduje trochu zamyšlení.
U podobného „sekání“ (angl. string slicing) je lepší si číslovat „hranice“ mezi znaky. Člověk tomu pak lépe rozumí:
╭───┬───┬───┬───┬───┬───┬───┬───╮
│ Č │ o │ k │ o │ l │ á │ d │ a │
├───┼───┼───┼───┼───┼───┼───┼───┤
│ │ │ │ │ │ │ │ │
0 1 2 3 4 5 6 7 8
-8 -7 -6 -5 -4 -3 -2 -1
╰───────────────╯
'čokoláda'[:4] == 'čoko'
╰───────────────╯
'čokoláda'[2:6] == 'kolá'
╰───────────╯
'čokoláda'[-3:] == 'áda'Zkus napsat program, který vymění znak na dané pozici řetězce za jiný. Od uživatele vyžádá řetězec, pozici, na které se má provést výměna a znak, který se má na pozici zadat. Pozor na to, že řetězce v Pythonu nelze měnit. Musíš vytvořit nový řetězec poskládaný z částí toho starého.
{
"data": {
"sessionMaterial": {
"id": "session-material:2019/brno-jaro-2019-ut:var-if:3",
"title": "Řetězce",
"html": "\n \n \n\n <h1>Řetězce</h1>\n<p>Teď se podíváme na zoubek řetězcům (angl. <em>strings</em>).\nUž víš, jak je zapisovat:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"s1\">'tohle je řetězec'</span>\n<span class=\"s2\">"tohle taky"</span>\n</pre></div><p>Někdy potřebuješ řetězce, které obsahují více řádků.\nPythonní řetězce ale můžeš normálně napsat jen na jeden řádek.\nJinak by koncová uvozovka mohla být kdekoli\na špatně by se hledala, kdybys na ni zapomněla.</p>\n<p>Můžeš ale do řetězce znak pro nový řádek vložit pomocí speciálního\nzápisu <code>\\n</code>:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s1\">'Haló haló!</span><span class=\"se\">\\n</span><span class=\"s1\">Co se stalo?'</span><span class=\"p\">)</span>\n</pre></div><p>Obecně zpětné lomítko umožňuje zapsat znaky, které by se špatně zadávaly.\nTřeba uvozovka se dá zapsat jako <code>\\"</code> a „apostrof“ jako <code>\\'</code>.\nTo se dá použít, když potřebuješ mít v jednom\nřetězci uvozovku i apostrof:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s2\">"Vtom vnuk křik': </span><span class=\"se\">\\"</span><span class=\"s2\">Hleď!</span><span class=\"se\">\\"</span><span class=\"s2\">"</span><span class=\"p\">)</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s1\">'"Jen ho nech," řek</span><span class=\"se\">\\'</span><span class=\"s1\"> děd. "Kdo zná líp kraj?"'</span><span class=\"p\">)</span>\n</pre></div><p>Sekvence <code>\\\\</code> znamená „jedno zpětné lomítko“.</p>\n<div class=\"highlight\"><pre><span></span><span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s1\">'C:</span><span class=\"se\">\\\\</span><span class=\"s1\">PyLadies</span><span class=\"se\">\\\\</span><span class=\"s1\">Nový adresář'</span><span class=\"p\">)</span>\n</pre></div><p>Ale zpátky k řetězcům na více řádků. Kromě <code>\\n</code> je i druhý způsob, jak takový\nřetězec zadat: ohraničit ho <em>třemi</em> uvozovkami (jednoduchými nebo dvojitými)\nna každé straně:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">basen</span> <span class=\"o\">=</span> <span class=\"s1\">'''Haló haló!</span>\n<span class=\"s1\">Co se stalo?</span>\n<span class=\"s1\">Prase kozu potrkalo!'''</span>\n</pre></div><p>Takové dlouhé texty nachází uplatnění třeba v dokumentačních řetězcích\nu funkcí.</p>\n<div class=\"highlight\"><pre><span></span><span class=\"k\">def</span> <span class=\"nf\">vynasob</span><span class=\"p\">(</span><span class=\"n\">a</span><span class=\"p\">,</span> <span class=\"n\">b</span><span class=\"p\">):</span>\n <span class=\"sd\">"""Vynásobí argumenty a vrátí výsledek.</span>\n\n<span class=\"sd\"> Oba argumenty by měly být čísla.</span>\n<span class=\"sd\"> """</span>\n\n <span class=\"k\">return</span> <span class=\"n\">a</span> <span class=\"o\">*</span> <span class=\"n\">b</span>\n</pre></div><p>Jen pozor na to, že pokud je tenhle řetězec\nv odsazeném kódu, každý jeho řádek bude začínat\nněkolika mezerami.\n(V dokumentačních řetězcích to nevadí, tam se s odsazením počítá.)</p>\n<p>Tolik k zápisu řetězců.\nTeď se podíváme, jak se zadanými řetězci pracovat.</p>\n<h2>Výběr znaků</h2>\n<p>Už umíš spojovat dohromady kratší řetězce:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">spojeny_retezec</span> <span class=\"o\">=</span> <span class=\"s1\">'a'</span> <span class=\"o\">+</span> <span class=\"s1\">'b'</span>\n<span class=\"n\">dlouhy_retezec</span> <span class=\"o\">=</span> <span class=\"s1\">'ó'</span> <span class=\"o\">*</span> <span class=\"mi\">100</span>\n</pre></div><p>Teď se podíváme na opačný proces: jak z dlouhého\nřetězce dostat kratší součásti.\nZačneme jednotlivými znaky.\nDělá se to operací <em>vybrání prvku</em> (angl. <em>subscripting</em>),\nkterá se píše podobně jako volání funkce, jen s hranatými závorkami:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">pate_pismeno</span> <span class=\"o\">=</span> <span class=\"s1\">'čokoláda'</span><span class=\"p\">[</span><span class=\"mi\">5</span><span class=\"p\">]</span>\n\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">pate_pismeno</span><span class=\"p\">)</span>\n</pre></div><p>Funguje to? Dostala jsi opravdu páté písmeno?</p>\n<div class=\"solution\" id=\"solution-0\">\n <h3>Řešení</h3>\n <div class=\"solution-cover\">\n <a href=\"/2019/brno-jaro-2019-ut/beginners/str/index/solutions/0/\"><span class=\"link-text\">Ukázat řešení</span></a>\n </div>\n <div class=\"solution-body\" aria-hidden=\"true\">\n <p>Nedostala – dostala jsi <em>šesté</em> písmeno.</p>\n </div>\n</div><p>Jak sis možná už všimla, programátoři počítají od nuly.\n„První“ prvek má vždy číslo nula, druhý číslo jedna a tak dál.</p>\n<p>Stejně je to i s písmeny v řetězcích: první písmeno má číslo nula,\ndruhé jedna, ... a osmé písmeno má číslo sedm.</p>\n<p>Proč je tomu tak?\nK úplnému pochopení důvodů by ses potřebovala\nnaučit něco o ukazatelích a polích,\ncož nebude hned, takže pro teď nám bude\nstačit vědět,\nže programátoři jsou prostě divní.</p>\n<p>A nebo že mají rádi divná čísla jako nulu.</p>\n<div class=\"highlight\"><pre><code> [0] [1] [2] [3] [4] [5] [6] [7]\n\n ╭───┬───┬───┬───┬───┬───┬───┬───╮\n │ Č │ o │ k │ o │ l │ á │ d │ a │\n ╰───┴───┴───┴───┴───┴───┴───┴───╯</code></pre></div><p>A když už jsme u divných čísel,\nco se asi stane, když budu chtít vybírat písmena\npomocí záporných čísel?</p>\n<div class=\"solution\" id=\"solution-1\">\n <h3>Řešení</h3>\n <div class=\"solution-cover\">\n <a href=\"/2019/brno-jaro-2019-ut/beginners/str/index/solutions/1/\"><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\">print</span><span class=\"p\">(</span><span class=\"s1\">'Čokoláda'</span><span class=\"p\">[</span><span class=\"o\">-</span><span class=\"mi\">1</span><span class=\"p\">])</span> <span class=\"c1\"># → a</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s1\">'Čokoláda'</span><span class=\"p\">[</span><span class=\"o\">-</span><span class=\"mi\">2</span><span class=\"p\">])</span> <span class=\"c1\"># → d</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s1\">'Čokoláda'</span><span class=\"p\">[</span><span class=\"o\">-</span><span class=\"mi\">3</span><span class=\"p\">])</span> <span class=\"c1\"># → á</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s1\">'Čokoláda'</span><span class=\"p\">[</span><span class=\"o\">-</span><span class=\"mi\">4</span><span class=\"p\">])</span> <span class=\"c1\"># → l</span>\n</pre></div><p>Záporná čísla vybírají písmenka od konce.</p>\n<div class=\"highlight\"><pre><code> [0] [1] [2] [3] [4] [5] [6] [7]\n [-8][-7][-6][-5][-4][-3][-2][-1]\n ╭───┬───┬───┬───┬───┬───┬───┬───╮\n │ Č │ o │ k │ o │ l │ á │ d │ a │\n ╰───┴───┴───┴───┴───┴───┴───┴───╯</code></pre></div>\n </div>\n</div><p>Řetězce umí i jiné triky.\nTřeba můžeš zjistit, jak je řetězec dlouhý\nnebo jestli v sobě obsahuje daný menší řetězec.</p>\n<table class=\"table\">\n <tbody><tr>\n <th>Zápis</th>\n <th>Popis</th>\n <th>Příklad</th>\n </tr>\n <tr>\n <td><code>len(r)</code></td>\n <td>Délka řetězce</td>\n <td><code>len('čokoláda')</code></td>\n </tr>\n <tr>\n <td><code>x in r</code></td>\n <td>True pokud je řetězec <code>x</code> obsažen v <code>r</code></td>\n <td><code>'oko' in 'čokoláda'</code></td>\n </tr>\n <tr>\n <td><code>x not in r</code></td>\n <td>Opak <code>x in r</code></td>\n <td><code>'dub' not in 'čokoláda</code></td>\n </tr>\n</tbody></table><p>Řetězce vždy berou v potaz velikost písmen,\ntakže např. <code>'ČOKO' in 'čokoláda'</code> je <code>False</code>.\nKdybys chtěla porovnávat bez ohledu na velikost písmen,\nmusela bys oba řetězce převést třeba na malá písmena\na pak je porovnat.</p>\n<p>A jak se převádí na malá písmena?\nK tomu budeme potřebovat další novou vlastnost Pythonu: metody.</p>\n<h2>Metody</h2>\n<p><em>Metoda</em> (angl. <em>method</em>) je jako funkce – něco, co se dá zavolat.\nNa rozdíl od funkce je svázaná s nějakým <em>objektem</em> (hodnotou).\nVolá se tak, že se za objekt napíše tečka,\nza ní jméno metody a za to celé se, jako u funkcí, připojí závorky\ns případnými argumenty.</p>\n<p>Řetězcové metody <code>upper()</code> a <code>lower()</code>\npřevádí text na velká, respektive malá písmena.</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">retezec</span> <span class=\"o\">=</span> <span class=\"s1\">'Ahoj'</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">retezec</span><span class=\"o\">.</span><span class=\"n\">upper</span><span class=\"p\">())</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">retezec</span><span class=\"o\">.</span><span class=\"n\">lower</span><span class=\"p\">())</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">retezec</span><span class=\"p\">)</span>\n</pre></div><div class=\"admonition note\"><p>Všimni si, že původní řetězec se nemění; metoda vrátí nový řetězec, ten\nstarý zůstává.</p>\n<p>To je obecná vlastnost řetězců v Pythonu: jednou existující řetězec se už\nnedá změnit, dá se jen vytvořit nějaký odvozený.</p>\n</div><h3>Iniciály</h3>\n<p>Pro procvičení metod a vybírání znaků si zkus napsat program,\nkterý se zeptá na jméno, pak na příjmení\na pak vypíše iniciály – první písmena zadaných jmen.</p>\n<p>Iniciály jsou vždycky velkými písmeny\n(i kdyby byl uživatel líný mačkat Shift).</p>\n<div class=\"solution\" id=\"solution-2\">\n <h3>Řešení</h3>\n <div class=\"solution-cover\">\n <a href=\"/2019/brno-jaro-2019-ut/beginners/str/index/solutions/2/\"><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=\"n\">jmeno</span> <span class=\"o\">=</span> <span class=\"nb\">input</span><span class=\"p\">(</span><span class=\"s1\">'Zadej jméno: '</span><span class=\"p\">)</span>\n<span class=\"n\">prijmeni</span> <span class=\"o\">=</span> <span class=\"nb\">input</span><span class=\"p\">(</span><span class=\"s1\">'Zadej příjmení '</span><span class=\"p\">)</span>\n<span class=\"n\">inicialy</span> <span class=\"o\">=</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\">prijmeni</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=\"s1\">'Iniciály:'</span><span class=\"p\">,</span> <span class=\"n\">inicialy</span><span class=\"o\">.</span><span class=\"n\">upper</span><span class=\"p\">())</span>\n</pre></div><p>Způsobů, jak takový program napsat, je více.\nLze například zavolat <code>upper()</code> dvakrát – zvlášť na jméno a zvlášť na příjmení.</p>\n<p>Nebo to jde zapsat i takto –\nmetoda se dá volat na výsledku jakéhokoli výrazu:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">jmeno</span> <span class=\"o\">=</span> <span class=\"nb\">input</span><span class=\"p\">(</span><span class=\"s1\">'Zadej jméno: '</span><span class=\"p\">)</span>\n<span class=\"n\">prijmeni</span> <span class=\"o\">=</span> <span class=\"nb\">input</span><span class=\"p\">(</span><span class=\"s1\">'Zadej příjmení '</span><span class=\"p\">)</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s1\">'Iniciály:'</span><span class=\"p\">,</span> <span class=\"p\">(</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\">prijmeni</span><span class=\"p\">[</span><span class=\"mi\">0</span><span class=\"p\">])</span><span class=\"o\">.</span><span class=\"n\">upper</span><span class=\"p\">())</span>\n</pre></div><p>Doporučuji spíš první způsob, ten se smysluplnými názvy proměnných.\nJe sice delší, ale mnohem přehlednější.</p>\n </div>\n</div><p>Řetězcových metod je celá řada.\nNejužitečnější z nich najdeš v <a href=\"https://pyvec.github.io/cheatsheets/strings/strings-cs.pdf\">taháku</a>, který si můžeš stáhnout či vytisknout.</p>\n<p>A úplně všechny řetězcové metody jsou popsány v <a href=\"https://docs.python.org/3/library/stdtypes.html#string-methods\">dokumentaci Pythonu</a> (anglicky; plné věcí, které ještě neznáš).</p>\n<p>Všimni si, že <code>len</code> není metoda, ale funkce; píše se <code>len(r)</code>, ne <code>r.len()</code>.\nProč tomu tak je, to za nějakou dobu poznáš.</p>\n<h2>Formátování</h2>\n<p>Obzvláště užitečná je metoda <code>format</code>,\nkterá v rámci řetězce nahradí dvojice „kudrnatých“ závorek\nza to, co dostane v argumentech:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">vypis</span> <span class=\"o\">=</span> <span class=\"s1\">'{}×{} je {}'</span><span class=\"o\">.</span><span class=\"n\">format</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\">3</span> <span class=\"o\">*</span> <span class=\"mi\">4</span><span class=\"p\">)</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">vypis</span><span class=\"p\">)</span>\n</pre></div><p>Řetězec <code>'{}×{} je {}'</code> tady funguje jako <em>šablona</em> (angl. <em>template</em>).\nPředstav si to jako jako formulář, do kterého Python na vyznačená místa\nvpisuje hodnoty.</p>\n<p>Pokud chceš nahradit hodnoty v jiném pořadí, nebo když chceš aby šablona\nbyla čitelnější, můžeš do „kudrnatých“ závorek napsat jména:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">vypis</span> <span class=\"o\">=</span> <span class=\"s1\">'Ahoj {jmeno}! Výsledek je {cislo}.'</span><span class=\"o\">.</span><span class=\"n\">format</span><span class=\"p\">(</span><span class=\"n\">cislo</span><span class=\"o\">=</span><span class=\"mi\">7</span><span class=\"p\">,</span> <span class=\"n\">jmeno</span><span class=\"o\">=</span><span class=\"s1\">'Elvíro'</span><span class=\"p\">)</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">vypis</span><span class=\"p\">)</span>\n</pre></div><p>Formátování se používá skoro všude, kde je\npotřeba „hezky“ vypsat nějakou hodnotu.</p>\n<h2>Sekání řetězců</h2>\n<p>Teď se vrátíme k vybírání kousků řetězců.\nZkus, co dělá tenhle program:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">retezec</span> <span class=\"o\">=</span> <span class=\"s1\">'čokoláda'</span>\n<span class=\"n\">kousek</span> <span class=\"o\">=</span> <span class=\"n\">retezec</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\">kousek</span><span class=\"p\">)</span>\n</pre></div><div class=\"solution\" id=\"solution-3\">\n <h3>Řešení</h3>\n <div class=\"solution-cover\">\n <a href=\"/2019/brno-jaro-2019-ut/beginners/str/index/solutions/3/\"><span class=\"link-text\">Ukázat řešení</span></a>\n </div>\n <div class=\"solution-body\" aria-hidden=\"true\">\n <p>Zápis <code>retezec[5:]</code> vybere <em>podřetězec</em> od znaku číslo 5 dál.</p>\n </div>\n</div><p>Dá se použít i <code>retezec[:5]</code>,\nkterý vybere všechno <em>až po</em> znak číslo 5.\nAle ne znak 5 samotný, takže <code>retezec[:5] + retezec[5:] == retezec</code>.</p>\n<p>Co asi udělá <code>retezec[2:5]</code>?</p>\n<p>A co <code>retezec[-4:]</code>?</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">retezec</span> <span class=\"o\">=</span> <span class=\"s1\">'čokoláda'</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">retezec</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\">retezec</span><span class=\"p\">[</span><span class=\"mi\">2</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\">retezec</span><span class=\"p\">[</span><span class=\"o\">-</span><span class=\"mi\">4</span><span class=\"p\">:])</span>\n</pre></div><p>Určování vhodných čísel, <em>indexů</em>, občas vyžaduje trochu zamyšlení.</p>\n<p>U podobného „sekání“ (angl. <em>string slicing</em>)\nje lepší si číslovat „hranice“ mezi znaky.\nČlověk tomu pak lépe rozumí:</p>\n<p><a id=\"slicing-diagram\"></a></p>\n<div class=\"highlight\"><pre><code> ╭───┬───┬───┬───┬───┬───┬───┬───╮\n │ Č │ o │ k │ o │ l │ á │ d │ a │\n ├───┼───┼───┼───┼───┼───┼───┼───┤\n │ │ │ │ │ │ │ │ │\n 0 1 2 3 4 5 6 7 8\n -8 -7 -6 -5 -4 -3 -2 -1\n\n ╰───────────────╯\n 'čokoláda'[:4] == 'čoko'\n\n ╰───────────────╯\n 'čokoláda'[2:6] == 'kolá'\n\n ╰───────────╯\n 'čokoláda'[-3:] == 'áda'</code></pre></div><h2>Cvičení</h2>\n<p>Zkus napsat program, který vymění znak na dané pozici řetězce za jiný.\nOd uživatele vyžádá řetězec, pozici, na které se má provést výměna\na znak, který se má na pozici zadat. Pozor na to, že řetězce v Pythonu nelze měnit.\nMusíš vytvořit nový řetězec poskládaný z částí toho starého.</p>\n<div class=\"solution\" id=\"solution-4\">\n <h3>Řešení</h3>\n <div class=\"solution-cover\">\n <a href=\"/2019/brno-jaro-2019-ut/beginners/str/index/solutions/4/\"><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=\"n\">retezec</span> <span class=\"o\">=</span> <span class=\"nb\">input</span><span class=\"p\">(</span><span class=\"s1\">'Zadej původní řetězec: '</span><span class=\"p\">)</span>\n<span class=\"n\">pozice</span> <span class=\"o\">=</span> <span class=\"nb\">int</span><span class=\"p\">(</span><span class=\"nb\">input</span><span class=\"p\">(</span><span class=\"s1\">'Na jaké pozici provedeme výměnu? '</span><span class=\"p\">))</span>\n<span class=\"n\">znak</span> <span class=\"o\">=</span> <span class=\"nb\">input</span><span class=\"p\">(</span><span class=\"s1\">'Jaký znak tam dáme? '</span><span class=\"p\">)</span>\n\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s1\">'Po výměně to vypadá takto:'</span><span class=\"p\">)</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">retezec</span><span class=\"p\">[:</span><span class=\"n\">pozice</span><span class=\"p\">]</span> <span class=\"o\">+</span> <span class=\"n\">znak</span> <span class=\"o\">+</span> <span class=\"n\">retezec</span><span class=\"p\">[</span><span class=\"n\">pozice</span> <span class=\"o\">+</span> <span class=\"mi\">1</span><span class=\"p\">:])</span>\n</pre></div>\n </div>\n</div>\n\n\n "
}
}
}