Známe spoustu matematických operací, které se zapisují symboly – třeba plus a minus. Python se snaží používat stejné symboly jako matematici:
S násobením a dělením už je to složitější, matematický zápis se na běžné klávesnici nedá napsat:
V Pythonu si ale pořád vystačíme se symbolem, byť trochu jiným – *, /.
Matematici ale píšou na papír, a tak si můžou dovolit vymýšlet stále zajímavější klikyháky, které se pak na klávesnici píšou dost špatně:
Ne že by neexistovaly programovací jazyky, na které je potřeba speciální klávesnice. Třeba program v jazyce APL laik jednoduše ani nenapíše, ani nepřečte:
⍎’⎕’,∈Nρ⊂S←’←⎕←(3=T)∨M∧2=T←⊃+/(V⌽”⊂M),(V⊖”⊂M),(V,⌽V)⌽”(V,V←1¯1)⊖”⊂M’Expert v APL může být vysoce produktivní, ale Python se zaměřuje spíš na to, aby se dal snadno naučit. A tak používá symboly jen pro ty nejčastější operace. Je jich dokonce tak málo, že už jich zhruba půlku znáš!
Pro zajímavost, tady jsou všechny operátory v Pythonu, které používají symboly:
== !=
< >
<= >=
| ^
&
<< >>
+ -
* @ /
// %
~
**
[ ] ( )
{ }
.
Všechno ostatní vyjádříme slovně.
Jedna operace, na kterou v Pythonu není symbol, je zjištění délky řetězce.
Matematik by něco takového napsal třeba pomocí svislých čárek (s poznámkou, co přesně ty čárky reprezentují):
V Pythonu má operace „délka řetězce“ místo symolu název.
Jmenuje se len (z angl. length, délka), a píše se len(s):
s = 'Ahoj'
delka = len(s) # Vypočítání délky
print(delka)
Ono len(s) výraz – operace, která něco udělá podle hodnoty s a výsledek
dá k dispozici.
Funguje podobně jako jiné výrazy – třeba a + b, což je operace, která něco
udělá podle hodnot a a b a výsledek dá k dispozici.
V první případě je výsledkem délka; ve druhém součet.
To len je funkce a zápisu len(s) se říká volání funkce.
Pojďme se si je popsat trochu zevrubněji.
Pro matematičky
Máš-li ráda matematiku, dej pozor! Funkce v Pythonu je něco jiného než funkce v matematice, i když se stejně jmenují a podobně zapisují. Pythonní funkce může např. dávat pro jeden argument různé hodnoty.
Funkci voláme jménem, například len.
Je to jméno jako u proměnných. (Vlastně to je proměnná, jen místo čísla nebo řetězce označuje funkci.)
Za jméno funkce patří závorky,
do nichž uzavřeme argument (neboli vstup) funkce.
To je informace, se kterou bude naše funkce
pracovat – třeba len ze svého argumentu vypočítá délku.
Volání funkce je výraz a jeho výsledek, takzvaná návratová hodnota (angl. return value) se dá třeba přiřadit do proměnné.
# jméno funkce
# │
# ╭┴╮
x = len('Ahoj!')
# ▲ ╰──┬──╯
# │ argument
# │
# ╰── návratová hodnota
Nebo se volání funkce dá použít místo čísla v součtu:
delka = len('Ahoj') + len('!')
Nebo v podmínce ifu:
if len('Ahoj!') < 3:
Nebo dokonce jako argument jiné funkce:
print(len('Ahoj'))
Nebo to zkombinovat dohromady:
print(len('Ahoj') + 1)
… a podobně.
Možná sis všimla, že příkaz print(x) vypadá podobně jako volání funkce.
To není vůbec náhoda – print je totiž taky funkce!
Stejně jako len dostává v závorkách argument – hodnotu, se kterou pracuje.
Na rozdíl od len ane print nic nevrací.
Výsledek volání print('Ahoj') není žádná smysluplná hodnota.
Místo vypočítání nějaké hodnoty print něco udělá – vypíše text na obrazovku.
Funkcím, které nic nevrací (jen něco udělají) se občas říká procedury. V Pythonu není hranice mezi „normální“ funkcí a procedurou příliš ostrá, ale přesto se hodí tento koncept znát. Pár příkladů:
Na rozdíl od ostatních termínů, které se tu učíš, není „procedura“ v Pythonu zavedený pojem. Je vypůjčený z jazyka Pascal. Kdybys o něm diskutovala s nějakým zkušeným programátorem, odkaž ho prosím na tyto materiály.
Argument je to, co funkci „předhodíš“ – dáš k dispozici.
Chceš-li délku řetězce Ahoj!, použiješ funkci len která umí vypočítat
délku jakéhokoli řetězce – a jako argument, v závorkách, jí dáš tu svoji
konkrétní hodnotu: len('Ahoj!').
Podobně funkce print umí vypsat jakoukoli hodnotu.
Tu, kterou má vypsat v tvém konkrétním případě, jí předáš jako argument.
Některým funkcím můžeš předat i více argumentů.
Třeba zrovna funkci print, která všechny své argumenty vypíše na řádek.
Jednotlivé argumenty se oddělují čárkami:
print(1, 2, 3)
print("Jedna plus dva je", 1 + 2)
Některé funkce nepotřebují žádný argument.
Příkladem je zase print.
Je ale nutné napsat závorky – i když jsou prázdné.
Hádej, co tohle volání udělá?
print()
Některé funkce umí pracovat i s pojmenovanými argumenty. Píšou se podobně jako přiřazení do proměnné, s rovnítkem, ale uvnitř závorek.
Třeba funkce print normálně ukončí výpis novým řádkem,
ale pomocí argumentu end se dá vypsat i něco jiného.
Tenhle příklad je potřeba napsat do souboru; v interaktivní konzoli nebude výstup vypadat, jak má.
print('1 + 2', end=' ') # Místo přechodu na nový řádek jen napiš mezeru
print('=', end=' ')
print(1 + 2, end='!')
print()
Pozor na to, že když nenapíšeš závorky, funkce se nezavolá!
Výraz len(s) je volání funkce, ale len bez závorek označuje
funkci samotnou.
Výsledek len(s) je číslo; len je funkce.
Čísla můžeš sečítat, můžeš tedy napsat len(s) + 1.
Funkce ale sečítat nejde – len + 1 nedává smysl.
Často se ale stane, že závorky prostě zapomeneš. Zkus si, co dělají následující příklady, a pozorně si přečti výsledky a chybové hlášky, abys pak podobné chyby poznala:
print(len('a')) # Volání funkce (a vypsání výsledku)
print(len) # Vypsání samotné funkce
print(len + 1) # Sečtení funkce a čísla
Nakonec si ukážeme pár základních funkcí, které nám Python nabízí. Můžeš si stáhnout i přehled, který se rozdává na srazech.
Tyhle funkce už známe.
print vypíše nepojmenované argumenty, oddělené mezerou.
Pojmenovaný argument end určuje, co se vypíše na konci (místo přechodu
na nový řádek);
sep zase, co se vypíše mezi jednotlivými argumenty (místo mezery).
Příklad opět spusť ze souboru, ne interaktivně:
print(1, 'dvě', False)
print(1, end=' ')
print(2, 3, 4, sep=', ')
Základní funkce na načtení vstupu, input,
vypíše otázku, počká na text od uživatele a ten vrátí jako řetězec.
input('zadej vstup: ')
Kontrolní otázky:
input „normální“ funkce, nebo procedura?input jako argument?input?Co ale když nechceme pracovat s řetězcem, ale třeba s číslem?
Tady nám pomůže skupina funkcí, které umí převádět čísla na řetězce a zpátky.
Každý ze tří typů (angl. types) proměnných, které zatím známe,
má funkci, která vezme nějakou hodnotu a vrátí podobnou hodnotu „svého“ typu.
Na celá čísla je funkce int (z angl. integer), na reálná čísla je float
(z angl. floating-point), a pro řetězce str (z angl. string).
int(x) # převod na celé číslo
float(x) # převod na reálné číslo
str(x) # převod na řetězec
Příklady:
3 == int('3') == int(3.0) == int(3.141) == int(3)
8.12 == float('8.12') == float(8.12)
8.0 == float(8) == float('8') == float(8.0)
'3' == str(3) == str('3')
'3.141' == str(3.141) == str('3.141')
Ne všechny převody jsou možné:
int('blablabla') # chyba!
float('blablabla') # chyba!
int('8.9') # chyba!
…a jak si poradit s chybou, která nastane, když použiješ špatnou hodnotu, si řekneme později.
inputPřevádění typů se často používá při načítání vstupu, třeba jako:
cislo = int(input('Zadej číslo: '))
Jak Python vyhodnotí tento výraz?
Zadá-li uživatel 42, funkce input vrátí řetězec'42'.
Ten pak funkce int vezme jako argument, udělá z něj číslo a to číslo vrátí:
cislo = int(input('Zadej číslo: '))
# ╰─────────┬─────────╯
cislo = int( '42' )
# ╰────────────┬────────────╯
cislo = 42
Matematika je občas potřeba, takže se pojďme podívat, jak v Pythonu pracovat s čísly.
Jedna zajímavá matematická funkce je k dispozici vždy:
round(cislo) # zaokrouhlení
Spousta dalších není k dispozici od začátku programu.
Ne každý má rád matematiku, a ne ve všech druzích programu jsou takové operace
potřeba.
Proto musíme předem – typicky na začátku souboru – říct, že je budeme používat.
To se dělá naimportováním z modulu math:
from math import sin, cos, tan, sqrt, floor, ceil
Naimportované funkce pak můžeš použít:
sin(uhel) # sinus
cos(uhel) # kosinus
tan(uhel) # tangens
sqrt(cislo) # druhá odmocnina
floor(cislo) # zaokrouhlení dolů
ceil(cislo) # zaokrouhlení nahoru
Import a pojmenování souborů
Při importování je potřeba si dávat pozor na pojmenování souborů:
importuješ-li from math, nesmí se tvůj program jmenovat math.py.
Proč? Když Python v adresáři, ze kterého program pouštíš, najde soubor
math.py, bude se snažit importovat sin z něho místo
z předpřipravené sady matematických funkcí.
Nakonec si ukážeme dvě funkce, které vrací náhodná čísla:
randrange a uniform.
Jsou užitečné třeba pro hry, ve kterých se hází kostkou nebo tahají
náhodné karty.
Opět nejsou potřeba tak často a je potřeba je naimportovat.
Tentokrát z modulu random:
from random import randrange, uniform
Pak už se dají použít:
randrange(a, b) # náhodné celé číslo od a do b-1
uniform(a, b) # náhodné reálné číslo od a do b
Pozor na to, že randrange(a, b)
nikdy nevrátí samotné b.
Pokud potřebujeme náhodně vybrat ze tří možností,
použij randrange(0, 3),
což vrátí 0, 1, nebo
2:
from random import randrange
cislo = randrange(0, 3) # číslo je od 0, 1, nebo 2
if cislo == 0:
print('Kolečko')
elif cislo == 1:
print('Čtvereček')
else: # 2
print('Trojúhelníček')
Pamatuj, když importuješ z modulu random, nesmí se tvůj soubor
jmenovat random.py.
Python dává k dispozici obrovské množství dalších funkcí a modulů, i když ne všem budeš ze začátku rozumět. Všechny jsou – anglicky – popsány v dokumentaci Pythonu, např. vestavěné funkce, matematika.
{
"data": {
"sessionMaterial": {
"id": "session-material:2019/brno-podzim-pondeli:cycles:0",
"title": "Funkce",
"html": "\n \n \n\n <h1>Funkce</h1>\n<p>Známe spoustu matematických operací, které se zapisují symboly – třeba plus\na minus.\nPython se snaží používat stejné symboly jako matematici:</p>\n<ul>\n<li>3 + 4</li>\n<li><var>a</var> - <var>b</var></li>\n</ul>\n<p>S násobením a dělením už je to složitější,\nmatematický zápis se na běžné klávesnici nedá napsat:</p>\n<ul>\n<li>3 · 4</li>\n<li>¾</li>\n</ul>\n<p>V Pythonu si ale pořád vystačíme se symbolem, byť trochu jiným – <code>*</code>, <code>/</code>.</p>\n<p>Matematici ale píšou na papír, a tak si můžou dovolit vymýšlet stále\nzajímavější klikyháky, které se pak na klávesnici píšou dost špatně:</p>\n<ul>\n<li><var>x</var>²</li>\n<li><var>x</var> ≤ <var>y</var></li>\n<li>sin θ</li>\n<li>Γ(<var>x</var>)</li>\n<li>∫<var>x</var></li>\n<li>|<var>s</var>|</li>\n<li>⌊<var>x</var>⌋</li>\n<li><var>a</var> ★ <var>b</var></li>\n<li><var>a</var> ⨁ <var>b</var></li>\n</ul>\n<p>Ne že by neexistovaly programovací jazyky,\nna které je potřeba speciální klávesnice.\nTřeba program v jazyce APL laik jednoduše ani nenapíše, ani nepřečte:</p>\n<p><!--z http://catpad.net/michael/apl/ --></p>\n<div class=\"highlight\"><pre><code>⍎’⎕’,∈Nρ⊂S←’←⎕←(3=T)∨M∧2=T←⊃+/(V⌽”⊂M),(V⊖”⊂M),(V,⌽V)⌽”(V,V←1¯1)⊖”⊂M’</code></pre></div><p>Expert v APL může být vysoce produktivní, ale Python se zaměřuje spíš na to,\naby se dal snadno naučit.\nA tak používá symboly jen pro ty nejčastější operace.\nJe jich dokonce tak málo, že už jich zhruba půlku znáš!</p>\n<div class=\"admonition note\"><p>Pro zajímavost, tady jsou všechny operátory v Pythonu, které používají\nsymboly:</p>\n<div>\n <code>==</code> <code>!=</code>\n <code><</code> <code>></code>\n <code><=</code> <code>>=</code>\n <code class=\"text-muted\">|</code> <code class=\"text-muted\">^</code>\n <code class=\"text-muted\">&</code>\n <code class=\"text-muted\"><<</code> <code class=\"text-muted\">>></code>\n <code>+</code> <code>-</code>\n <code>*</code> <code class=\"text-muted\">@</code> <code>/</code>\n <code>//</code> <code>%</code>\n <code class=\"text-muted\">~</code>\n <code>**</code>\n <code class=\"text-muted\">[ ]</code> <code class=\"text-muted\">( )</code>\n <code class=\"text-muted\">{ }</code>\n <code class=\"text-muted\">.</code>\n</div></div><p>Všechno ostatní vyjádříme slovně.</p>\n<h2>Délka řetězce</h2>\n<p>Jedna operace, na kterou v Pythonu není symbol, je zjištění délky řetězce.</p>\n<p>Matematik by něco takového napsal třeba pomocí svislých čárek\n(s poznámkou, co přesně ty čárky reprezentují):</p>\n<ul>\n<li><var>s</var> = “Ahoj!”</li>\n<li><var>delka</var> = |<var>s</var>|</li>\n</ul>\n<p>V Pythonu má operace „délka řetězce“ místo symolu název.\nJmenuje se <code>len</code> (z angl. <em>length</em>, délka), a píše se <code>len(s)</code>:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">s</span> <span class=\"o\">=</span> <span class=\"s1\">'Ahoj'</span>\n<span class=\"n\">delka</span> <span class=\"o\">=</span> <span class=\"nb\">len</span><span class=\"p\">(</span><span class=\"n\">s</span><span class=\"p\">)</span> <span class=\"c1\"># Vypočítání délky</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">delka</span><span class=\"p\">)</span>\n</pre></div><p>Ono <code>len(s)</code> výraz – operace, která něco udělá podle hodnoty <code>s</code> a výsledek\ndá k dispozici.\nFunguje podobně jako jiné výrazy – třeba <code>a + b</code>, což je operace, která něco\nudělá podle hodnot <code>a</code> a <code>b</code> a výsledek dá k dispozici.\nV první případě je výsledkem délka; ve druhém součet.</p>\n<p>To <code>len</code> je <em>funkce</em> a zápisu <code>len(s)</code> se říká <em>volání funkce</em>.\nPojďme se si je popsat trochu zevrubněji.</p>\n<div class=\"admonition note\"><p class=\"admonition-title\">Pro matematičky</p>\n<p>Máš-li ráda matematiku, dej pozor!\nFunkce v Pythonu je něco jiného než funkce v matematice,\ni když se stejně jmenují a podobně zapisují.\nPythonní funkce může např. dávat pro jeden argument různé hodnoty.</p>\n</div><h2>Volání funkcí</h2>\n<p>Funkci voláme <em>jménem</em>, například <code>len</code>.</p>\n<p>Je to jméno jako u proměnných.\n(Vlastně to je proměnná, jen místo čísla nebo řetězce označuje funkci.)</p>\n<p>Za jméno funkce patří závorky,\ndo nichž uzavřeme <em>argument</em> (neboli <em>vstup</em>) funkce.\nTo je informace, se kterou bude naše funkce\npracovat – třeba <code>len</code> ze svého argumentu vypočítá délku.</p>\n<p>Volání funkce je výraz a jeho výsledek, takzvaná <em>návratová</em> hodnota\n(angl. <em>return value</em>) se dá třeba přiřadit do proměnné.</p>\n<div class=\"highlight\"><pre><span></span><span class=\"c1\"># jméno funkce</span>\n<span class=\"c1\"># │</span>\n<span class=\"c1\"># ╭┴╮</span>\n <span class=\"n\">x</span> <span class=\"o\">=</span> <span class=\"nb\">len</span><span class=\"p\">(</span><span class=\"s1\">'Ahoj!'</span><span class=\"p\">)</span>\n<span class=\"c1\"># ▲ ╰──┬──╯</span>\n<span class=\"c1\"># │ argument</span>\n<span class=\"c1\"># │</span>\n<span class=\"c1\"># ╰── návratová hodnota</span>\n</pre></div><p>Nebo se volání funkce dá použít místo čísla v součtu:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">delka</span> <span class=\"o\">=</span> <span class=\"nb\">len</span><span class=\"p\">(</span><span class=\"s1\">'Ahoj'</span><span class=\"p\">)</span> <span class=\"o\">+</span> <span class=\"nb\">len</span><span class=\"p\">(</span><span class=\"s1\">'!'</span><span class=\"p\">)</span>\n</pre></div><p>Nebo v podmínce ifu:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"k\">if</span> <span class=\"nb\">len</span><span class=\"p\">(</span><span class=\"s1\">'Ahoj!'</span><span class=\"p\">)</span> <span class=\"o\"><</span> <span class=\"mi\">3</span><span class=\"p\">:</span>\n</pre></div><p>Nebo dokonce jako argument jiné funkce:</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=\"s1\">'Ahoj'</span><span class=\"p\">))</span>\n</pre></div><p>Nebo to zkombinovat dohromady:</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=\"s1\">'Ahoj'</span><span class=\"p\">)</span> <span class=\"o\">+</span> <span class=\"mi\">1</span><span class=\"p\">)</span>\n</pre></div><p>… a podobně.</p>\n<h3>Funkce a procedury</h3>\n<p>Možná sis všimla, že příkaz <code>print(x)</code> vypadá podobně jako volání funkce.\nTo není vůbec náhoda – <code>print</code> je totiž taky funkce!\nStejně jako <code>len</code> dostává v závorkách argument – hodnotu, se kterou pracuje.</p>\n<p>Na rozdíl od <code>len</code> ane <code>print</code> nic nevrací.\nVýsledek volání <code>print('Ahoj')</code> není žádná smysluplná hodnota.\nMísto vypočítání nějaké hodnoty <code>print</code> něco <em>udělá</em> – vypíše text na obrazovku.</p>\n<p>Funkcím, které nic nevrací (jen něco udělají) se občas říká <em>procedury</em>.\nV Pythonu není hranice mezi „normální“ funkcí a procedurou příliš ostrá,\nale přesto se hodí tento koncept znát.\nPár příkladů:</p>\n<ul>\n<li>Funkce, která vybere náhodné číslo, je „normální“.\nSvůj výsledek vrátí; program s ním může dál pracovat.</li>\n<li>Funkce, která vykreslí na obrazovku kolečko, je <em>procedura</em>.\nŽádnou zajímavou hodnotu programu nevrací.</li>\n<li>Funkce, která spočítá průměrný věk obyvatelstva podle informací ze sčítání\nlidu je „normální“. Svůj výsledek vrátí a program s ním může dál pracovat.</li>\n<li>Funkce, která přehraje písničku reproduktorem, je <em>procedura</em>.\nNic zajímavého programu nevrací.</li>\n</ul>\n<div class=\"admonition note\"><p>Na rozdíl od ostatních termínů, které se tu učíš, není\n„procedura“ v Pythonu zavedený pojem.\nJe vypůjčený z jazyka Pascal.\nKdybys o něm diskutovala s nějakým zkušeným programátorem,\nodkaž ho prosím na tyto materiály.</p>\n</div><h3>Argumenty</h3>\n<p>Argument je to, co funkci „předhodíš“ – dáš k dispozici.\nChceš-li délku řetězce <code>Ahoj!</code>, použiješ funkci <code>len</code> která umí vypočítat\ndélku <em>jakéhokoli</em> řetězce – a jako argument, v závorkách, jí dáš tu svoji\nkonkrétní hodnotu: <code>len('Ahoj!')</code>.</p>\n<p>Podobně funkce <code>print</code> umí vypsat jakoukoli hodnotu.\nTu, kterou má vypsat v tvém konkrétním případě, jí předáš jako argument.</p>\n<p>Některým funkcím můžeš předat i více argumentů.\nTřeba zrovna funkci <code>print</code>, která všechny své argumenty vypíše na řádek.\nJednotlivé argumenty se oddělují čárkami:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"k\">print</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</pre></div><div class=\"highlight\"><pre><span></span><span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s2\">"Jedna plus dva je"</span><span class=\"p\">,</span> <span class=\"mi\">1</span> <span class=\"o\">+</span> <span class=\"mi\">2</span><span class=\"p\">)</span>\n</pre></div><p>Některé funkce nepotřebují žádný argument.\nPříkladem je zase <code>print</code>.\nJe ale nutné napsat závorky – i když jsou prázdné.\nHádej, co tohle volání udělá?</p>\n<div class=\"highlight\"><pre><span></span><span class=\"k\">print</span><span class=\"p\">()</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/functions/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>Funkce <code>print</code> zavolaná bez argumentů napíše prázdný řádek.</p>\n<p>(Je to přesně podle definice – funkce <code>print</code> všechny své argumenty vypíše\nna řádek.)</p>\n </div>\n</div><h3>Pojmenované argumenty</h3>\n<p>Některé funkce umí pracovat i s <em>pojmenovanými</em> argumenty.\nPíšou se podobně jako přiřazení do proměnné,\ns rovnítkem, ale uvnitř závorek.</p>\n<p>Třeba funkce <code>print</code> normálně ukončí výpis novým řádkem,\nale pomocí argumentu <code>end</code> se dá vypsat i něco jiného.</p>\n<div class=\"admonition note\"><p>Tenhle příklad je potřeba napsat do souboru; v interaktivní konzoli\nnebude výstup vypadat, jak má.</p>\n</div><div class=\"highlight\"><pre><span></span><span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s1\">'1 + 2'</span><span class=\"p\">,</span> <span class=\"n\">end</span><span class=\"o\">=</span><span class=\"s1\">' '</span><span class=\"p\">)</span> <span class=\"c1\"># Místo přechodu na nový řádek jen napiš mezeru</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s1\">'='</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><span class=\"mi\">1</span> <span class=\"o\">+</span> <span class=\"mi\">2</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><h3>Funkce je potřeba volat</h3>\n<p>Pozor na to, že když nenapíšeš závorky, funkce se nezavolá!\nVýraz <code>len(s)</code> je <em>volání funkce</em>, ale <code>len</code> bez závorek označuje\n<em>funkci samotnou</em>.</p>\n<p>Výsledek <code>len(s)</code> je číslo; <code>len</code> je funkce.</p>\n<p>Čísla můžeš sečítat, můžeš tedy napsat <code>len(s) + 1</code>.\nFunkce ale sečítat nejde – <code>len + 1</code> nedává smysl.</p>\n<p>Často se ale stane, že závorky prostě zapomeneš.\nZkus si, co dělají následující příklady, a pozorně si přečti výsledky\na chybové hlášky, abys pak podobné chyby poznala:</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=\"s1\">'a'</span><span class=\"p\">))</span> <span class=\"c1\"># Volání funkce (a vypsání výsledku)</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"nb\">len</span><span class=\"p\">)</span> <span class=\"c1\"># Vypsání samotné funkce</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"nb\">len</span> <span class=\"o\">+</span> <span class=\"mi\">1</span><span class=\"p\">)</span> <span class=\"c1\"># Sečtení funkce a čísla</span>\n</pre></div><h2>Užitečné funkce</h2>\n<p>Nakonec si ukážeme pár základních funkcí, které nám Python nabízí.\nMůžeš si stáhnout i\n<a href=\"https://github.com/encukou/cheatsheets/raw/master/basic-functions/basic-functions-cs.pdf\">přehled</a>,\nkterý se rozdává na srazech.</p>\n<h3>Vstup a výstup</h3>\n<p>Tyhle funkce už známe.\n<code>print</code> vypíše nepojmenované argumenty, oddělené mezerou.\nPojmenovaný argument <code>end</code> určuje, co se vypíše na konci (místo přechodu\nna nový řádek);\n<code>sep</code> zase, co se vypíše mezi jednotlivými argumenty (místo mezery).</p>\n<div class=\"admonition note\"><p>Příklad opět spusť ze souboru, ne interaktivně:</p>\n</div><div class=\"highlight\"><pre><span></span><span class=\"k\">print</span><span class=\"p\">(</span><span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"s1\">'dvě'</span><span class=\"p\">,</span> <span class=\"bp\">False</span><span class=\"p\">)</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"mi\">1</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><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=\"n\">sep</span><span class=\"o\">=</span><span class=\"s1\">', '</span><span class=\"p\">)</span>\n</pre></div><p>Základní funkce na načtení vstupu, <code>input</code>,\nvypíše otázku, počká na text od uživatele a ten vrátí jako řetězec.</p>\n<div class=\"highlight\"><pre><span></span><span class=\"nb\">input</span><span class=\"p\">(</span><span class=\"s1\">'zadej vstup: '</span><span class=\"p\">)</span>\n</pre></div><p>Kontrolní otázky:</p>\n<ul>\n<li>Je <code>input</code> „normální“ funkce, nebo procedura?</li>\n<li>Co bere funkce <code>input</code> jako argument?</li>\n<li>Jaká je návratová hodnota funkce <code>input</code>?</li>\n</ul>\n<div class=\"solution\" id=\"solution-1\">\n <h3>Řešení</h3>\n <div class=\"solution-cover\">\n <a href=\"/2019/brno-podzim-pondeli/beginners/functions/index/solutions/1/\"><span class=\"link-text\">Ukázat řešení</span></a>\n </div>\n <div class=\"solution-body\" aria-hidden=\"true\">\n <p>Funkce <code>input</code> vrací hodnotu, se kterou může program dál pracovat.\nZařadil bych ji tedy mezi „normální“ funkce.</p>\n<p>Jako argument bere <code>input</code> otázku, na kterou se uživatele zeptá.</p>\n<p>Návratová hodnota funkce <code>input</code> je uživatelova odpověď.</p>\n </div>\n</div><h3>Převádění typů</h3>\n<p>Co ale když nechceme pracovat s řetězcem, ale třeba s číslem?\nTady nám pomůže skupina funkcí, které umí převádět čísla na řetězce a zpátky.\nKaždý ze tří <em>typů</em> (angl. <em>types</em>) proměnných, které zatím známe,\nmá funkci, která vezme nějakou hodnotu a vrátí podobnou hodnotu „svého“ typu.\nNa celá čísla je funkce <code>int</code> (z angl. <em>integer</em>), na reálná čísla je <code>float</code>\n(z angl. <em>floating-point</em>), a pro řetězce <code>str</code> (z angl. <em>string</em>).</p>\n<div class=\"highlight\"><pre><span></span><span class=\"nb\">int</span><span class=\"p\">(</span><span class=\"n\">x</span><span class=\"p\">)</span> <span class=\"c1\"># převod na celé číslo</span>\n<span class=\"nb\">float</span><span class=\"p\">(</span><span class=\"n\">x</span><span class=\"p\">)</span> <span class=\"c1\"># převod na reálné číslo</span>\n<span class=\"nb\">str</span><span class=\"p\">(</span><span class=\"n\">x</span><span class=\"p\">)</span> <span class=\"c1\"># převod na řetězec</span>\n</pre></div><p>Příklady:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"mi\">3</span> <span class=\"o\">==</span> <span class=\"nb\">int</span><span class=\"p\">(</span><span class=\"s1\">'3'</span><span class=\"p\">)</span> <span class=\"o\">==</span> <span class=\"nb\">int</span><span class=\"p\">(</span><span class=\"mf\">3.0</span><span class=\"p\">)</span> <span class=\"o\">==</span> <span class=\"nb\">int</span><span class=\"p\">(</span><span class=\"mf\">3.141</span><span class=\"p\">)</span> <span class=\"o\">==</span> <span class=\"nb\">int</span><span class=\"p\">(</span><span class=\"mi\">3</span><span class=\"p\">)</span>\n<span class=\"mf\">8.12</span> <span class=\"o\">==</span> <span class=\"nb\">float</span><span class=\"p\">(</span><span class=\"s1\">'8.12'</span><span class=\"p\">)</span> <span class=\"o\">==</span> <span class=\"nb\">float</span><span class=\"p\">(</span><span class=\"mf\">8.12</span><span class=\"p\">)</span>\n<span class=\"mf\">8.0</span> <span class=\"o\">==</span> <span class=\"nb\">float</span><span class=\"p\">(</span><span class=\"mi\">8</span><span class=\"p\">)</span> <span class=\"o\">==</span> <span class=\"nb\">float</span><span class=\"p\">(</span><span class=\"s1\">'8'</span><span class=\"p\">)</span> <span class=\"o\">==</span> <span class=\"nb\">float</span><span class=\"p\">(</span><span class=\"mf\">8.0</span><span class=\"p\">)</span>\n<span class=\"s1\">'3'</span> <span class=\"o\">==</span> <span class=\"nb\">str</span><span class=\"p\">(</span><span class=\"mi\">3</span><span class=\"p\">)</span> <span class=\"o\">==</span> <span class=\"nb\">str</span><span class=\"p\">(</span><span class=\"s1\">'3'</span><span class=\"p\">)</span>\n<span class=\"s1\">'3.141'</span> <span class=\"o\">==</span> <span class=\"nb\">str</span><span class=\"p\">(</span><span class=\"mf\">3.141</span><span class=\"p\">)</span> <span class=\"o\">==</span> <span class=\"nb\">str</span><span class=\"p\">(</span><span class=\"s1\">'3.141'</span><span class=\"p\">)</span>\n</pre></div><p>Ne všechny převody jsou možné:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"nb\">int</span><span class=\"p\">(</span><span class=\"s1\">'blablabla'</span><span class=\"p\">)</span> <span class=\"c1\"># chyba!</span>\n<span class=\"nb\">float</span><span class=\"p\">(</span><span class=\"s1\">'blablabla'</span><span class=\"p\">)</span> <span class=\"c1\"># chyba!</span>\n<span class=\"nb\">int</span><span class=\"p\">(</span><span class=\"s1\">'8.9'</span><span class=\"p\">)</span> <span class=\"c1\"># chyba!</span>\n</pre></div><p>…a jak si poradit s chybou, která nastane,\nkdyž použiješ špatnou hodnotu, si řekneme později.</p>\n<h4>Převádění a <code>input</code></h4>\n<p>Převádění typů se často používá při načítání vstupu, třeba jako:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">cislo</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\">'Zadej číslo: '</span><span class=\"p\">))</span>\n</pre></div><p>Jak Python vyhodnotí tento výraz?\nZadá-li uživatel <kbd>4</kbd><kbd>2</kbd>, funkce <code>input</code> vrátí řetězec<code>'42'</code>.\nTen pak funkce <code>int</code> vezme jako argument, udělá z něj číslo a to číslo vrátí:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">cislo</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\">'Zadej číslo: '</span><span class=\"p\">))</span>\n <span class=\"c1\"># ╰─────────┬─────────╯</span>\n<span class=\"n\">cislo</span> <span class=\"o\">=</span> <span class=\"nb\">int</span><span class=\"p\">(</span> <span class=\"s1\">'42'</span> <span class=\"p\">)</span>\n <span class=\"c1\"># ╰────────────┬────────────╯</span>\n<span class=\"n\">cislo</span> <span class=\"o\">=</span> <span class=\"mi\">42</span>\n</pre></div><h3>Matematické funkce</h3>\n<p>Matematika je občas potřeba, takže se pojďme\npodívat, jak v Pythonu pracovat s čísly.</p>\n<p>Jedna zajímavá matematická funkce je k dispozici vždy:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"nb\">round</span><span class=\"p\">(</span><span class=\"n\">cislo</span><span class=\"p\">)</span> <span class=\"c1\"># zaokrouhlení</span>\n</pre></div><p>Spousta dalších není k dispozici od začátku programu.\nNe každý má rád matematiku, a ne ve všech druzích programu jsou takové operace\npotřeba.\nProto musíme předem – typicky na začátku souboru – říct, že je budeme používat.\nTo se dělá <em>naimportováním</em> z modulu <code>math</code>:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"kn\">from</span> <span class=\"nn\">math</span> <span class=\"kn\">import</span> <span class=\"n\">sin</span><span class=\"p\">,</span> <span class=\"n\">cos</span><span class=\"p\">,</span> <span class=\"n\">tan</span><span class=\"p\">,</span> <span class=\"n\">sqrt</span><span class=\"p\">,</span> <span class=\"n\">floor</span><span class=\"p\">,</span> <span class=\"n\">ceil</span>\n</pre></div><p>Naimportované funkce pak můžeš použít:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">sin</span><span class=\"p\">(</span><span class=\"n\">uhel</span><span class=\"p\">)</span> <span class=\"c1\"># sinus</span>\n<span class=\"n\">cos</span><span class=\"p\">(</span><span class=\"n\">uhel</span><span class=\"p\">)</span> <span class=\"c1\"># kosinus</span>\n<span class=\"n\">tan</span><span class=\"p\">(</span><span class=\"n\">uhel</span><span class=\"p\">)</span> <span class=\"c1\"># tangens</span>\n<span class=\"n\">sqrt</span><span class=\"p\">(</span><span class=\"n\">cislo</span><span class=\"p\">)</span> <span class=\"c1\"># druhá odmocnina</span>\n\n<span class=\"n\">floor</span><span class=\"p\">(</span><span class=\"n\">cislo</span><span class=\"p\">)</span> <span class=\"c1\"># zaokrouhlení dolů</span>\n<span class=\"n\">ceil</span><span class=\"p\">(</span><span class=\"n\">cislo</span><span class=\"p\">)</span> <span class=\"c1\"># zaokrouhlení nahoru</span>\n</pre></div><div class=\"admonition warning\"><p class=\"admonition-title\">Import a pojmenování souborů</p>\n<p>Při importování je potřeba si dávat pozor na pojmenování souborů:\nimportuješ-li <code>from math</code>, nesmí se tvůj program jmenovat <code>math.py</code>.</p>\n<p>Proč? Když Python v adresáři, ze kterého program pouštíš, najde soubor\n<code>math.py</code>, bude se snažit importovat <code>sin</code> z něho místo\nz předpřipravené sady matematických funkcí.</p>\n</div><h3>Náhoda</h3>\n<p>Nakonec si ukážeme dvě funkce, které vrací náhodná čísla:\n<code>randrange</code> a <code>uniform</code>.\nJsou užitečné třeba pro hry, ve kterých se hází kostkou nebo tahají\nnáhodné karty.</p>\n<p>Opět nejsou potřeba tak často a je potřeba je <em>naimportovat</em>.\nTentokrát z modulu <code>random</code>:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"kn\">from</span> <span class=\"nn\">random</span> <span class=\"kn\">import</span> <span class=\"n\">randrange</span><span class=\"p\">,</span> <span class=\"n\">uniform</span>\n</pre></div><p>Pak už se dají použít:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">randrange</span><span class=\"p\">(</span><span class=\"n\">a</span><span class=\"p\">,</span> <span class=\"n\">b</span><span class=\"p\">)</span> <span class=\"c1\"># náhodné celé číslo od a do b-1</span>\n<span class=\"n\">uniform</span><span class=\"p\">(</span><span class=\"n\">a</span><span class=\"p\">,</span> <span class=\"n\">b</span><span class=\"p\">)</span> <span class=\"c1\"># náhodné reálné číslo od a do b</span>\n</pre></div><p>Pozor na to, že <code>randrange(a, b)</code>\nnikdy nevrátí samotné <code>b</code>.\nPokud potřebujeme náhodně vybrat ze tří možností,\npoužij <code>randrange(0, 3)</code>,\ncož vrátí <code>0</code>, <code>1</code>, nebo\n<code>2</code>:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"kn\">from</span> <span class=\"nn\">random</span> <span class=\"kn\">import</span> <span class=\"n\">randrange</span>\n\n<span class=\"n\">cislo</span> <span class=\"o\">=</span> <span class=\"n\">randrange</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=\"c1\"># číslo je od 0, 1, nebo 2</span>\n<span class=\"k\">if</span> <span class=\"n\">cislo</span> <span class=\"o\">==</span> <span class=\"mi\">0</span><span class=\"p\">:</span>\n <span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s1\">'Kolečko'</span><span class=\"p\">)</span>\n<span class=\"k\">elif</span> <span class=\"n\">cislo</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=\"s1\">'Čtvereček'</span><span class=\"p\">)</span>\n<span class=\"k\">else</span><span class=\"p\">:</span> <span class=\"c1\"># 2</span>\n <span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s1\">'Trojúhelníček'</span><span class=\"p\">)</span>\n</pre></div><div class=\"admonition note\"><p>Pamatuj, když importuješ z modulu <code>random</code>, nesmí se tvůj soubor\njmenovat <code>random.py</code>.</p>\n</div><h3>A další</h3>\n<p>Python dává k dispozici obrovské množství dalších\nfunkcí a modulů, i když ne všem budeš ze začátku\nrozumět.\nVšechny jsou – anglicky – popsány v dokumentaci Pythonu, např.\n<a href=\"https://docs.python.org/3/library/functions.html\">vestavěné funkce</a>,\n<a href=\"https://docs.python.org/3/library/math.html\">matematika</a>.</p>\n\n\n "
}
}
}