Zápis řetězců
Teď se podíváme na zoubek řetězcům. Už s nimi trochu umíš, tak začneme rekapitulací.
Textový řetězec (angl. string) je datový typ (druh hodnot), který obsahuje text – třeba slovo nebo větu.
Když řetězec zadáváš do programu, musíš ho označit – uzavřít do uvozovek, buď jednoduchých nebo dvojitých:
'tohle je řetězec'
"tohle taky"
Je velký rozdíl mezi print('cislo') – vypiš slovo „cislo“ –
a print(cislo) – vypiš hodnotu výrazu cislo.
Jednou je cislo pět konkrétních písmen; podruhé instrukce k použití
proměnné.
Počítač, na rozdíl od lidí, rozdíl mezi textem a instrukcí nepozná z kontextu,
a tak je uvozovky potřeba používat důsledně.
Znaky
Texty sestávají z jednotlivých písmenek. Řetězce víceméně taky, ale aby bylo jasné, co přesně tím písmenkem myslíme, říkáme, že řetězce sestávají ze znaků (angl. characters).
Takový znak může být písmenko (např. A) nebo číslice (3),
ale i jiný symbol (!).
Každý řetězec má určitý počet znaků.
Kolik, to nám umí říct funkce len().
Třeba řetězec Ahoj! má znaků pět:
>>> len('Ahoj!')
5
Jeden ze zajímavějších znaků je mezera. Je to taky znak. V řetězci se tedy chová stejně jako písmenko:
>>> len(' ')
1
>>> len('K ní')
4
>>> len('3 + 2')
5
Mimochodem, řetězec může být i prázdný – pak má nula znaků:
>>> len('')
0
>>> len("")
0
Uvozovky
K uvození řetězce můžeš použít jednoduché nebo dvojité rovné uvozovky.
Není mezi nimi rozdíl.
Podobně 4.0 a 4.000 jsou dva zápisy téhož čísla,
tak 'slovo' a "slovo" pro Python označuje stejnou
hodnotu, skládající se ze stejných pěti písmen.
Použité uvozovky nejsou součástí hodnoty – python si „nepamatuje“, jakým způsobem byl řetězec uvozen. Když má nějaký řetězec vypsat, jedny si k tomu vybere – většinou ty jednoduché:
>>> "python"
'python'
>>> 'slovo'
'slovo'
Předchozí příklad je z interaktivního režimu Pythonu, který ukazuje hodnoty
výrazů „programátorsky“ – pokud možno tak, jak se zapisují v Pythonu.
Funkce print() vypisuje hodnoty „hezky“, „pro uživatele“ – v případě
řetězců tedy bez uvozovek.
Uvozovky v uvozovkách
Proč si při zadávání textu můžeš vybrat mezi dvěma druhy uvozovek?
Občas se stane, že v rámci textu potřebuješ použít samotnou uvozovku (nebo apostrof). Pak musíš „kolem“ řetězce použít tu druhou:
>>> len('Zpívala si: "Tralala!"')
22
>>> len("Byl to Goa'uld, parazit z planety P3X-888")
41
Když v rámci textu použiješ stejnou uvozovku jako „kolem něj“, tak bude Python naprosto zmatený.
>>> len("Zpívala si: "Tralala"")
Traceback (most recent call last)
File "<>", line 1
len("Zpívala si: "Tralala"")
^
SyntaxError: invalid syntax
Pokud používáš chytrý editor, doporučuju si zvyknout na to, jakou barvou máš řetězce zvýrazněné. Často to pomáhá odhalit chybky.
Sekvence se zpětným lomítkem
Co dělat, když v řetězci potřebuješ oba druhy uvozovek,
jako ve větě Vtom vnuk křik': "Hleď!"?
Můžeš si pomoci tím, že spojíš dva řetězce:
>>> print("Vtom vnuk křik': " + '"Hleď!"')
Vtom vnuk křik': "Hleď!"
Ale lepší způsob je použít speciální zápis se zpětným lomítkem.
Kdykoli se v řetězci objeví sekvence \' nebo \", Python dá do řetězce danou
uvozovku.
>>> print("Vtom vnuk křik': \"Hleď!\"")
Vtom vnuk křik': "Hleď!"
>>> print('"Jen ho nech," řek\' děd. "Kdo zná líp kraj?"')
"Jen ho nech," řek' děd. "Kdo zná líp kraj?"
Ve výsledném řetězci pak ovšem žádné zpětné lomítko není.
Sekvence \' je jen způsob, jak v Pythonu zadat ' – jediný znak.
Tomu je celkem důležité porozumět.
Zkus si, jestli předpovědět výsledek těchto příkazů:
print(".\".")
len(".\".")
".\"." # (v interaktivním režimu)
Řešení
Znaků, které se zadávají sekvencí se zpětným lomítkem je více.
Jedna ze zajímavějších je \t, představující tabulátor – jediný znak, který
se, když ho vypíšeš, „roztáhne“ na víc mezer.
>>> print("a\tb") # Výpis "pro lidi"
a b
>>> "a\tb" # Výpis "pro programátory"
'a\tb'
>>> len("a\tb") # Počet znaků v řetězci
3
Se zpětným lomítkem zadat jakýkoli znak – včetně emoji – podle jména
(\N{…}) nebo identifikačního čísla (\x.., \u...., \U........)
standardu Unicode.
Délka všech následujících řetězců je 3:
>>> print('-\N{GREEK CAPITAL LETTER DELTA}-')
-Δ-
>>> print('-\N{SECTION SIGN}-')
-§-
>>> print('-\N{GRINNING CAT FACE WITH SMILING EYES}-')
-😸-
>>> print('-\x60-')
-`-
>>> print('-\u30C4-')
-ツ-
>>> print('-\U0001F0BD-')
-🂽-
Zpětné lomítko
Zpětné lomítko tedy začíná speciální sekvenci (známou pod anglickým termínem escape sequence), kterou zadáš jediný znak.
Tahle vychytávka má jeden, někdy nepříjemný, důsledek: pokud chceš mít jako
součást řetězce zpětné lomítko (třeba ve jménech souborů na Windows),
nemůžeš použít přímo \.
Musíš použít speciální sekvenci \\ – tedy lomítko zdvojit:
print('C:\\PyLadies\\Nový adresář')
Podobně jako \" je zápis pro uvozovku a \' pro apostrof, sekvence \\
je zápis pro znak \.
Nový řádek
Někdy potřebuješ řetězce, které obsahují více řádků. Pythonní řetězce ale můžeš normálně napsat jen na jeden řádek. (Python se tak snaží ulehčit hledání chyby, kdybys koncovou uvozovku zapoměla: kdyby mohla být kdekoli ve zbytku souboru, špatně by se hledala.)
Můžeš ale do řetězce znak pro nový řádek vložit pomocí sekvence \n:
>>> print('Haló haló!\nCo se stalo?')
Haló haló!
Co se stalo?
Ono \n do řetězce vloží znak nového řádku.
Ten při výpisu ukončí stávající řádek a přede na nový – ale jinak se chová
jako jakýkoli jiný znak:
>>> print('-\n-')
-
-
>>> len('-\n-')
3
Trojité uvozovky
Kromě \n je i druhý způsob, jak zadat řetězec se znakem nového řádku:
ohraničit ho třemi uvozovkami (jednoduchými nebo dvojitými)
na každé straně.
Dají se tak zadávat delší víceřádkové řetězce:
basen = '''Haló haló!
Co se stalo?
Prase kozu potrkalo!'''
Víceřádkové řetězce se často používají jako dokumentační řetězce funkcí. U nich nevadí, že jsou na začátku řádků mezery.
def vynasob(a, b):
"""Vynásobí argumenty a vrátí výsledek.
Oba argumenty by měly být čísla.
"""
return a * b
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 tohle nevadí, tam se s odsazením počítá.)
Formátovací řetězce
A ještě přidám jednu vychtytávku: šablony, kterými můžeš do řetězce vložit hodnotu.
Řekněme, že chceš vypsat určitou hodnotu uživatelovi s nějakou „omáčkou“ okolo.
Dá se na to použít print(), kterému můžeš předat „mix“ řetězců a čísel:
>>> soucet = 3 + 4
>>> print('Součet je', soucet)
Co ale když chceš celý tento výpis uložit do proměnné – jako jeden řetězec?
Čárka tu fungovat nebude, ta odděluje argumenty ve volání funkce.
Je potřeba soucet převést na řetězec a ten pak připojit k „omáčce“:
>>> hlaska = 'Součet je ' + str(soucet)
To ale není tak přehledné, jak by mohlo. Lze to zpřehlednit použitím šablony – formátovacího řetězce (angl. format string nebo f-string).
Takovou šablonu si představ jako formulář s vynechanými místy:
Mil[ý/á] _______,
Váš výsledek je __________.
S pozdravem,
_________Aby Python věděl, kam co doplnit, jednotlivá vynechaná místa označíš jmény v „kudrnatých“ závorkách:
Mil{y_a} {osloveni},
Váš výsledek je {soucet}.
S pozdravem,
{podpis}.A nakonec, aby Python věděl že jde o šablonu, před první uvozovku dej
písmenko f.
Pro náš první případ bude šablona f'Součet je {soucet}':
>>> soucet = 3 + 4
>>> hlaska = f'Součet je {soucet}'
>>> print(hlaska)
Program s dlouhou šablonou může vypadat jako:
y_a = 'á'
osloveni = 'Anežko'
soucet = 3 + 4
podpis = 'Váš Program'
print(f"""Mil{y_a} {osloveni},
Váš výsledek je {soucet}.
S pozdravem,
{podpis}""")
A nakonec – v šabloně můžeš použít nejen jména proměnných, ale jakékoli výrazy.
>>> hlaska = f'Součet je {3 + 4}'
Ale nepřežeň to! Většinou je program přehlednější, když si každou vypisovanou hodnotu zvlášť pojmenuješ.
Cvičení
Jaká je délka těchto řetězců?
Výsledek zjistíš snadno, zkus se ale zamyslet a Python použít jen pro ověření.
print(len('ahoj'))
print(len("""Ahoj!"""))
print(len(' a b '))
print(len('\N{SNOWMAN}ové'))
print(len('a\nb'))
print(len('a\tb'))
print(len('"\'"'))
print(len("""
abc"""))
if True:
print(len("""a
b"""))
print(len('C:\new_dir'))
print(len(f'{print}')){
"data": {
"sessionMaterial": {
"id": "session-material:2019/brno-podzim-pondeli:turtle:1",
"title": "Zápis řetězců",
"html": "\n \n \n\n <h1>Zápis řetězců</h1>\n<p>Teď se podíváme na zoubek řetězcům.\nUž s nimi trochu umíš, tak začneme rekapitulací.</p>\n<p>Textový <em>řetězec</em> (angl. <em>string</em>) je datový typ (druh <em>hodnot</em>),\nkterý obsahuje text – třeba slovo nebo větu.</p>\n<p>Když řetězec zadáváš do programu, musíš ho označit – uzavřít do\n<em>uvozovek</em>, buď jednoduchých nebo dvojitých:</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>Je velký rozdíl mezi <code>print('cislo')</code> – vypiš slovo „cislo“ –\na <code>print(cislo)</code> – vypiš hodnotu výrazu <code>cislo</code>.\nJednou je <code>cislo</code> pět konkrétních písmen; podruhé <em>instrukce</em> k použití\nproměnné.\nPočítač, na rozdíl od lidí, rozdíl mezi textem a instrukcí nepozná z kontextu,\na tak je uvozovky potřeba používat důsledně.</p>\n<p><span class=\"figure\"><a href=\"/2019/brno-podzim-pondeli/beginners/str/static/quote-comic.svg\"><img src=\"/2019/brno-podzim-pondeli/beginners/str/static/quote-comic.svg\" alt=\"(Ilustrační komiks. Člověk říká robotovi: "Řekni Pavlovi, ať mi zavolá!". Robot odpoví: "PAVLOVI AŤ MI ZAVOLÁ!")\"></a></span></p>\n<h2>Znaky</h2>\n<p>Texty sestávají z jednotlivých písmenek.\nŘetězce víceméně taky, ale aby bylo jasné, co přesně tím <em>písmenkem</em>\nmyslíme, říkáme, že řetězce sestávají ze <em>znaků</em> (angl. <em>characters</em>).</p>\n<p>Takový znak může být písmenko (např. <code>A</code>) nebo číslice (<code>3</code>),\nale i jiný symbol (<code>!</code>).</p>\n<p>Každý řetězec má určitý počet znaků.\nKolik, to nám umí říct funkce <code>len()</code>.\nTřeba řetězec <code>Ahoj!</code> má znaků pět:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"gp\">>>> </span><span class=\"nb\">len</span><span class=\"p\">(</span><span class=\"s1\">'Ahoj!'</span><span class=\"p\">)</span>\n<span class=\"go\">5</span>\n</pre></div><p>Jeden ze zajímavějších znaků je <em>mezera</em>.\nJe to taky znak. V řetězci se tedy chová stejně jako písmenko:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"gp\">>>> </span><span class=\"nb\">len</span><span class=\"p\">(</span><span class=\"s1\">' '</span><span class=\"p\">)</span>\n<span class=\"go\">1</span>\n<span class=\"gp\">>>> </span><span class=\"nb\">len</span><span class=\"p\">(</span><span class=\"s1\">'K ní'</span><span class=\"p\">)</span>\n<span class=\"go\">4</span>\n<span class=\"gp\">>>> </span><span class=\"nb\">len</span><span class=\"p\">(</span><span class=\"s1\">'3 + 2'</span><span class=\"p\">)</span>\n<span class=\"go\">5</span>\n</pre></div><p>Mimochodem, řetězec může být i prázdný – pak má nula znaků:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"gp\">>>> </span><span class=\"nb\">len</span><span class=\"p\">(</span><span class=\"s1\">''</span><span class=\"p\">)</span>\n<span class=\"go\">0</span>\n<span class=\"gp\">>>> </span><span class=\"nb\">len</span><span class=\"p\">(</span><span class=\"s2\">""</span><span class=\"p\">)</span>\n<span class=\"go\">0</span>\n</pre></div><h2>Uvozovky</h2>\n<p>K uvození řetězce můžeš použít jednoduché nebo dvojité rovné uvozovky.\nNení mezi nimi rozdíl.\nPodobně <code>4.0</code> a <code>4.000</code> jsou dva zápisy téhož čísla,\ntak <code>'slovo'</code> a <code>"slovo"</code> pro Python označuje stejnou\nhodnotu, skládající se ze stejných pěti písmen.</p>\n<p>Použité uvozovky nejsou součástí hodnoty – python si „nepamatuje“, jakým\nzpůsobem byl řetězec uvozen.\nKdyž má nějaký řetězec vypsat, jedny si k tomu vybere – většinou ty jednoduché:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"gp\">>>> </span><span class=\"s2\">"python"</span>\n<span class=\"go\">'python'</span>\n<span class=\"gp\">>>> </span><span class=\"s1\">'slovo'</span>\n<span class=\"go\">'slovo'</span>\n</pre></div><div class=\"admonition note\"><p>Předchozí příklad je z interaktivního režimu Pythonu, který ukazuje hodnoty \nvýrazů „programátorsky“ – pokud možno tak, jak se zapisují v Pythonu.\nFunkce <code>print()</code> vypisuje hodnoty „hezky“, „pro uživatele“ – v případě\nřetězců tedy bez uvozovek.</p>\n</div><h3>Uvozovky v uvozovkách</h3>\n<p>Proč si při zadávání textu můžeš vybrat mezi dvěma druhy uvozovek?</p>\n<p>Občas se stane, že v rámci textu potřebuješ použít samotnou uvozovku (nebo\napostrof).\nPak musíš „kolem“ řetězce použít tu druhou:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"gp\">>>> </span><span class=\"nb\">len</span><span class=\"p\">(</span><span class=\"s1\">'Zpívala si: "Tralala!"'</span><span class=\"p\">)</span>\n<span class=\"go\">22</span>\n<span class=\"gp\">>>> </span><span class=\"nb\">len</span><span class=\"p\">(</span><span class=\"s2\">"Byl to Goa'uld, parazit z planety P3X-888"</span><span class=\"p\">)</span>\n<span class=\"go\">41</span>\n</pre></div><p>Když v rámci textu použiješ stejnou uvozovku jako „kolem něj“, tak bude Python\nnaprosto zmatený.</p>\n<div class=\"highlight\"><pre><span></span><span class=\"gp\">>>> </span><span class=\"nb\">len</span><span class=\"p\">(</span><span class=\"s2\">"Zpívala si: "</span><span class=\"n\">Tralala</span><span class=\"s2\">""</span><span class=\"p\">)</span>\n<span class=\"go\">Traceback (most recent call last)</span>\n File <span class=\"nb\">"<>"</span>, line <span class=\"m\">1</span>\n <span class=\"nb\">len</span><span class=\"p\">(</span><span class=\"s2\">"Zpívala si: "</span><span class=\"n\">Tralala</span><span class=\"s2\">""</span><span class=\"p\">)</span>\n <span class=\"o\">^</span>\n<span class=\"gr\">SyntaxError</span>: <span class=\"n\">invalid syntax</span>\n</pre></div><p>Pokud používáš chytrý editor, doporučuju si zvyknout na to, jakou barvou\nmáš řetězce zvýrazněné.\nČasto to pomáhá odhalit chybky.</p>\n<h2>Sekvence se zpětným lomítkem</h2>\n<p>Co dělat, když v řetězci potřebuješ <em>oba</em> druhy uvozovek,\njako ve větě <code>Vtom vnuk křik': "Hleď!"</code>?</p>\n<p>Můžeš si pomoci tím, že spojíš dva řetězce:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"gp\">>>> </span><span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s2\">"Vtom vnuk křik': "</span> <span class=\"o\">+</span> <span class=\"s1\">'"Hleď!"'</span><span class=\"p\">)</span>\n<span class=\"go\">Vtom vnuk křik': "Hleď!"</span>\n</pre></div><p>Ale lepší způsob je použít speciální zápis se <em>zpětným lomítkem</em>.\nKdykoli se v řetězci objeví sekvence <code>\\'</code> nebo <code>\\"</code>, Python dá do řetězce danou\nuvozovku.</p>\n<div class=\"highlight\"><pre><span></span><span class=\"gp\">>>> </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=\"go\">Vtom vnuk křik': "Hleď!"</span>\n<span class=\"gp\">>>> </span><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<span class=\"go\">"Jen ho nech," řek' děd. "Kdo zná líp kraj?"</span>\n</pre></div><p>Ve výsledném řetězci pak ovšem žádné zpětné lomítko <em>není</em>.\nSekvence <code>\\'</code> je jen způsob, jak v Pythonu zadat <code>'</code> – jediný znak.\nTomu je celkem důležité porozumět.\nZkus si, jestli předpovědět výsledek těchto příkazů:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s2\">".</span><span class=\"se\">\\"</span><span class=\"s2\">."</span><span class=\"p\">)</span>\n<span class=\"nb\">len</span><span class=\"p\">(</span><span class=\"s2\">".</span><span class=\"se\">\\"</span><span class=\"s2\">."</span><span class=\"p\">)</span>\n<span class=\"s2\">".</span><span class=\"se\">\\"</span><span class=\"s2\">."</span> <span class=\"c1\"># (v interaktivním režimu)</span>\n</pre></div><div class=\"solution\" id=\"solution-0\">\n <h3>Řešení</h3>\n <div class=\"solution-cover\">\n <a href=\"/2019/brno-podzim-pondeli/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 <div class=\"highlight\"><pre><span></span><span class=\"gp\">>>> </span><span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s2\">".</span><span class=\"se\">\\"</span><span class=\"s2\">."</span><span class=\"p\">)</span>\n<span class=\"go\">.".</span>\n<span class=\"gp\">>>> </span><span class=\"nb\">len</span><span class=\"p\">(</span><span class=\"s2\">".</span><span class=\"se\">\\"</span><span class=\"s2\">."</span><span class=\"p\">)</span>\n<span class=\"go\">3</span>\n<span class=\"gp\">>>> </span><span class=\"s2\">".</span><span class=\"se\">\\"</span><span class=\"s2\">."</span>\n<span class=\"go\">'.".'</span>\n</pre></div>\n </div>\n</div><p>Znaků, které se zadávají sekvencí se zpětným lomítkem je více.\nJedna ze zajímavějších je <code>\\t</code>, představující tabulátor – jediný znak, který\nse, když ho vypíšeš, „roztáhne“ na víc mezer.</p>\n<div class=\"highlight\"><pre><span></span><span class=\"gp\">>>> </span><span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s2\">"a</span><span class=\"se\">\\t</span><span class=\"s2\">b"</span><span class=\"p\">)</span> <span class=\"c1\"># Výpis "pro lidi"</span>\n<span class=\"go\">a b</span>\n<span class=\"gp\">>>> </span><span class=\"s2\">"a</span><span class=\"se\">\\t</span><span class=\"s2\">b"</span> <span class=\"c1\"># Výpis "pro programátory"</span>\n<span class=\"go\">'a\\tb'</span>\n<span class=\"gp\">>>> </span><span class=\"nb\">len</span><span class=\"p\">(</span><span class=\"s2\">"a</span><span class=\"se\">\\t</span><span class=\"s2\">b"</span><span class=\"p\">)</span> <span class=\"c1\"># Počet znaků v řetězci</span>\n<span class=\"go\">3</span>\n</pre></div><p>Se zpětným lomítkem zadat jakýkoli znak – včetně <em>emoji</em> – podle jména\n(<code>\\N{…}</code>) nebo identifikačního čísla (<code>\\x..</code>, <code>\\u....</code>, <code>\\U........</code>)\nstandardu Unicode.\nDélka všech následujících řetězců je 3:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"gp\">>>> </span><span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s1\">'-</span><span class=\"se\">\\N{GREEK CAPITAL LETTER DELTA}</span><span class=\"s1\">-'</span><span class=\"p\">)</span>\n<span class=\"go\">-Δ-</span>\n<span class=\"gp\">>>> </span><span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s1\">'-</span><span class=\"se\">\\N{SECTION SIGN}</span><span class=\"s1\">-'</span><span class=\"p\">)</span>\n<span class=\"go\">-§-</span>\n<span class=\"gp\">>>> </span><span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s1\">'-</span><span class=\"se\">\\N{GRINNING CAT FACE WITH SMILING EYES}</span><span class=\"s1\">-'</span><span class=\"p\">)</span>\n<span class=\"go\">-😸-</span>\n<span class=\"gp\">>>> </span><span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s1\">'-</span><span class=\"se\">\\x60</span><span class=\"s1\">-'</span><span class=\"p\">)</span>\n<span class=\"go\">-`-</span>\n<span class=\"gp\">>>> </span><span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s1\">'-</span><span class=\"se\">\\u30C4</span><span class=\"s1\">-'</span><span class=\"p\">)</span>\n<span class=\"go\">-ツ-</span>\n<span class=\"gp\">>>> </span><span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s1\">'-</span><span class=\"se\">\\U0001F0BD</span><span class=\"s1\">-'</span><span class=\"p\">)</span>\n<span class=\"go\">-🂽-</span>\n</pre></div><h3>Zpětné lomítko</h3>\n<p>Zpětné lomítko tedy začíná speciální sekvenci (známou pod anglickým\ntermínem <em>escape sequence</em>), kterou zadáš <em>jediný znak</em>.</p>\n<p>Tahle vychytávka má jeden, někdy nepříjemný, důsledek: pokud chceš mít jako\nsoučást řetězce zpětné lomítko (třeba ve jménech souborů na Windows),\nnemůžeš použít přímo <code>\\</code>.\nMusíš použít speciální sekvenci <code>\\\\</code> – tedy lomítko zdvojit:</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>Podobně jako <code>\\"</code> je zápis pro uvozovku a <code>\\'</code> pro apostrof, sekvence <code>\\\\</code>\nje zápis pro znak <code>\\</code>.</p>\n<h3>Nový řádek</h3>\n<p>Někdy potřebuješ řetězce, které obsahují více řádků.\nPythonní řetězce ale můžeš normálně napsat jen na <em>jeden</em> řádek.\n(Python se tak snaží ulehčit hledání chyby, kdybys koncovou uvozovku\nzapoměla: kdyby mohla být kdekoli ve zbytku souboru, špatně by se hledala.)</p>\n<p>Můžeš ale do řetězce znak pro nový řádek vložit pomocí sekvence <code>\\n</code>:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"gp\">>>> </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<span class=\"go\">Haló haló!</span>\n<span class=\"go\">Co se stalo?</span>\n</pre></div><p>Ono <code>\\n</code> do řetězce vloží znak nového řádku.\nTen při výpisu ukončí stávající řádek a přede na nový – ale jinak se chová\njako jakýkoli jiný znak:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"gp\">>>> </span><span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s1\">'-</span><span class=\"se\">\\n</span><span class=\"s1\">-'</span><span class=\"p\">)</span>\n<span class=\"go\">-</span>\n<span class=\"go\">-</span>\n<span class=\"gp\">>>> </span><span class=\"nb\">len</span><span class=\"p\">(</span><span class=\"s1\">'-</span><span class=\"se\">\\n</span><span class=\"s1\">-'</span><span class=\"p\">)</span>\n<span class=\"go\">3</span>\n</pre></div><h2>Trojité uvozovky</h2>\n<p>Kromě <code>\\n</code> je i druhý způsob, jak zadat řetězec se znakem nového řádku:\nohraničit ho <em>třemi</em> uvozovkami (jednoduchými nebo dvojitými)\nna každé straně.\nDají se tak zadávat delší víceřádkové řetězce:</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>Víceřádkové řetězce se často používají jako dokumentační řetězce funkcí.\nU nich nevadí, že jsou na začátku řádků mezery.</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>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 tohle nevadí, tam se s odsazením počítá.)</p>\n<h2>Formátovací řetězce</h2>\n<p>A ještě přidám jednu vychtytávku: <em>šablony</em>, kterými můžeš do řetězce vložit\nhodnotu.</p>\n<p>Řekněme, že chceš vypsat určitou hodnotu uživatelovi s nějakou „omáčkou“ okolo.\nDá se na to použít <code>print()</code>, kterému můžeš předat „mix“ řetězců a čísel:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"gp\">>>> </span><span class=\"n\">soucet</span> <span class=\"o\">=</span> <span class=\"mi\">3</span> <span class=\"o\">+</span> <span class=\"mi\">4</span>\n<span class=\"gp\">>>> </span><span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s1\">'Součet je'</span><span class=\"p\">,</span> <span class=\"n\">soucet</span><span class=\"p\">)</span>\n</pre></div><p>Co ale když chceš celý tento výpis uložit do proměnné – jako jeden řetězec?\nČárka tu fungovat nebude, ta odděluje argumenty ve volání funkce.\nJe potřeba <code>soucet</code> převést na řetězec a ten pak připojit k „omáčce“:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"gp\">>>> </span><span class=\"n\">hlaska</span> <span class=\"o\">=</span> <span class=\"s1\">'Součet je '</span> <span class=\"o\">+</span> <span class=\"nb\">str</span><span class=\"p\">(</span><span class=\"n\">soucet</span><span class=\"p\">)</span>\n</pre></div><p>To ale není tak přehledné, jak by mohlo.\nLze to zpřehlednit použitím šablony – <em>formátovacího řetězce</em>\n(angl. <em>format string</em> nebo <em>f-string</em>).</p>\n<p>Takovou šablonu si představ jako formulář s vynechanými místy:</p>\n<div class=\"highlight\"><pre><code>Mil[ý/á] _______,\nVáš výsledek je __________.\n\nS pozdravem,\n_________</code></pre></div><p>Aby Python věděl, kam co doplnit, jednotlivá vynechaná místa označíš jmény\nv „kudrnatých“ závorkách:</p>\n<div class=\"highlight\"><pre><code>Mil{y_a} {osloveni},\nVáš výsledek je {soucet}.\n\nS pozdravem,\n{podpis}.</code></pre></div><p>A nakonec, aby Python věděl že jde o šablonu, před první uvozovku dej\npísmenko <code>f</code>.\nPro náš první případ bude šablona <code>f'Součet je {soucet}'</code>:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"gp\">>>> </span><span class=\"n\">soucet</span> <span class=\"o\">=</span> <span class=\"mi\">3</span> <span class=\"o\">+</span> <span class=\"mi\">4</span>\n<span class=\"gp\">>>> </span><span class=\"n\">hlaska</span> <span class=\"o\">=</span> <span class=\"n\">f</span><span class=\"s1\">'Součet je {soucet}'</span>\n<span class=\"gp\">>>> </span><span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">hlaska</span><span class=\"p\">)</span>\n</pre></div><p>Program s dlouhou šablonou může vypadat jako:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">y_a</span> <span class=\"o\">=</span> <span class=\"s1\">'á'</span>\n<span class=\"n\">osloveni</span> <span class=\"o\">=</span> <span class=\"s1\">'Anežko'</span>\n<span class=\"n\">soucet</span> <span class=\"o\">=</span> <span class=\"mi\">3</span> <span class=\"o\">+</span> <span class=\"mi\">4</span>\n<span class=\"n\">podpis</span> <span class=\"o\">=</span> <span class=\"s1\">'Váš Program'</span>\n\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">f</span><span class=\"s2\">"""Mil{y_a} {osloveni},</span>\n<span class=\"s2\">Váš výsledek je {soucet}.</span>\n\n<span class=\"s2\">S pozdravem,</span>\n<span class=\"s2\">{podpis}"""</span><span class=\"p\">)</span>\n</pre></div><p>A nakonec – v šabloně můžeš použít nejen jména proměnných, ale jakékoli výrazy.</p>\n<div class=\"highlight\"><pre><span></span><span class=\"gp\">>>> </span><span class=\"n\">hlaska</span> <span class=\"o\">=</span> <span class=\"n\">f</span><span class=\"s1\">'Součet je {3 + 4}'</span>\n</pre></div><p>Ale nepřežeň to!\nVětšinou je program přehlednější, když si každou vypisovanou hodnotu zvlášť\npojmenuješ.</p>\n<h2>Cvičení</h2>\n<p>Jaká je délka těchto řetězců?</p>\n<p>Výsledek zjistíš snadno, zkus se ale zamyslet a Python použít jen pro ověření.</p>\n<div class=\"highlight\"><pre><code>\nprint(len('ahoj'))\nprint(len("""Ahoj!"""))\nprint(len(' a b '))\nprint(len('\\N{SNOWMAN}ové'))\nprint(len('a\\nb'))\nprint(len('a\\tb'))\nprint(len('"\\'"'))\n\n\nprint(len("""\nabc"""))\n\n\nif True:\n print(len("""a\n b"""))\n\n\nprint(len('C:\\new_dir'))\n\nprint(len(f'{print}'))</code></pre></div>\n\n\n "
}
}
}