Python. základy algoritmizace

Python základy algoritmizace

Obsah

Úvod.......................................................................................................4 Algoritmus........................................................................................................................................4 Dekompozice a Abstrakce................................................................................................................5 Programovací jazyky.........................................................................................................................6 Další dělení programovacích jazyků............................................................................................8 Proč se učit programování?..............................................................................................................9 Otázky a úkoly................................................................................................................................10

Instalace Pythonu................................................................................11 Stažení potřebných souborů..........................................................................................................11 Instalace Pythonu...........................................................................................................................17 Instalace Komodo Edit....................................................................................................................20 Úvod do Komodo Edit.....................................................................................................................24 Úvodní obrazovka Komodo Edit.................................................................................................25 Projekty a Soubory.....................................................................................................................26 Vlastní nástrojové lišty..............................................................................................................29 Užitečná nastavení editoru........................................................................................................32 Pokročilé vlastnosti editoru............................................................................................................33 Označování syntaktických chyb................................................................................................33 Doplňování kódu (Code Completion).........................................................................................33 Nápověda a syntaxe funkcí.......................................................................................................34 Operace s bloky.........................................................................................................................34

Základy jazyka Python.........................................................................35 Hello World!....................................................................................................................................35 Proměnné a volání funkcí..........................................................................................................36 Typy proměnných.......................................................................................................................38 Chyby při psaní programů.........................................................................................................39 Operátory.......................................................................................................................................40 Podmíněný příkaz a bloky..............................................................................................................41 Cyklus while....................................................................................................................................43 Psaní vlastních funkcí.....................................................................................................................44 Klíčová slova...................................................................................................................................45 Otázky a úkoly................................................................................................................................46

Složitější datové typy...........................................................................47 Rekurze a vnořování............................................................................47 Objekty a Třídy.....................................................................................47 Základní Algoritmy...............................................................................47

Úvod Než začneme s programováním, je nutné se podívat na trochu teorie, abychom všichni věděli, co nás čeká. Začneme s tím, co je to vlastně program: Program je posloupnost příkazů pro počítač. Docela jednoduché, že. Snad ještě dodáme, že příkazům pro počítač budeme také říkat instrukce, a zopakujeme si, jak vlastně takový počítač vypadá: Počítač se skládá z následujících částí: procesoru (řídící jednotky počítače, která vykonává instrukce programu nad daty), operační paměti (paměť, ve které jsou uloženy právě běžící programy a jejich data1), z disku (pamět ve které jsou uloženy momentálně neaktivní programy a data) a vstupně/výstupních zařízení (zařízení sloužící ke komunikaci počítače s jeho okolím). Diskem budeme rozumět v UNIXovém významu jeden virtuální disk složený ze všech disků, které má počítač k dispozici. Na disku také předpokládáme existenci souborového systému, ve kterém jsou data i programy uloženy v souborech a adresářích. Vstupně/výstupní zařízení, kterým se také říká krátce jen I/O (z anglického Input/Output devices) jsou všecha zařízení propojující tento zjednodušený počítač s jeho okolím. Je to tedy klávesnice, grafická karta spolu s monitorem, tiskárna, síťové propojení, atd. Než se posuneme dál, stojí za to zmínit, že tato velice zjednodušená definice počítače (vynechali jsme veškeré cache, sběrnice, atd) je však již plně funkční a byla také základem prvních osobních počítačů na konci 70. let minulého století.

Algoritmus Pro nás však bude mnohem důležitější než program pojem algoritmus, ačkoli ho můžeme zjednodušeně chápat jako obecný postup, začneme s jeho přesnou definicí a rozdíl mezi algoritmem a postupem si podrobněji vysvětlíme: Algoritmus je konečná posloupnost jednoznačně určených kroků popisujících řešení nějakého problému. Ke správnému pochopení definice algoritmu potřebujeme ještě následující definici: Problém je jakákoli transformace vstupních dat na data výstupní taková, že splňuje zadaná kritéria. Instance problému je problém a jeho konkrétní vstupní data. I když by se mohlo zdát, že definovat problém jako nějaké operace nad daty je omezující, není to pravda. Každý problém, který vás napadne lze vždy převést právě na transformaci vhodně zvolených vstupních dat na data výstupní, která pak podávají informace o řešení konrétní instance problému. Řešením problému jako takového je však algoritmus. 1 To není tak docela pravda, v případě nedostatku operační paměti může počítač použít disk i k uložení aktuálně běžících programů a jejich dat. V momentě, kdy chce ale s těmito daty konkrétně pracovat, musí je nejdříve nahrát z disku zpět do operační paměti a až pak s nimi může pracovat.

Každý algoritmus musí také splňovat následující čtyři základní vlastnosti: ●

správnost, tedy schopnost opravdu zadaný problém vyřešit

●

hromadnost (generalizaci), která znamená, že algoritmus je schopen vyřešit všechny instance daného problému

●

konečnost – zajištění, že algoritmus skončí po konečném počtu kroků

●

a determinovanost, znamenající, že každý další krok je jednoznačně závislý pouze na předchozích krocích a na vstupních datech.

První tři vlastnosti jsou celkem triviální, je jasné že nesprávný program, který nelze aplikovat na všechny instance problému a u kterého nemáme záruku, že vůbec někdy skončí je k ničemu. Problémy ale nastávají v poslední vlastnosti, a to determinovanosti algoritmu, které je přitom je vlastností algoritmu. Fakt, že je algoritmus deterministický znamená, že mámeli k dispozici vstupní data a algoritmus, nemusíme ani chápat co algoritmus znamená a co dělá, a přesto jsme schopni ho správně provést. Toto je zaručeno tím, že algoritmus nepředpokládá o tom, kdo ho provádí žádnou informovanost o problému, ale vede ho svými kroky jen na základě dvou věcí, které rozhodně zná – samotného algoritmu a vstupních dat. Představte si následující příklad: Náš problém je nalézt největší a nejmenší číslo v předloženém seznamu čísel. Naše instance problému pak bude například konkrétní seznam čísel 25,11,36,75,99,5,45,25,8,16. Po přečtení předchozího odstavce jste patrně automaticky zjistili, že největší číslo je 99 a nejmenší je 5. Jak ale zapsat postup, kterým jste na tato dvě čísla přišli tak, aby pro libovolný seznam nalezli nejvetší a nejmenší číslo?

Dekompozice a Abstrakce Dekompozice a abstrakce jsou dva základní myšlenkové postupy, které je nutné zvládnout pro pochopení programování. Začneme s tím těžším, s dekompozicí. Dekompozicí rozumíme schopnost rozdělit složitější úkol na vhodně propojenou posloupnost úkolů jednodužších. Aplikováním dekompozice až na úroveň kdy nepředpokládáme žádnou další informovanost o podstatě problému je práce programátora prakticky hotová (je tedy teoreticky hotová, mohem jednodužší praktická část leží v tomto stádiu naopak před ním). Vraťme se k minulému příkladu nalezení největšího a nejmenšího čísla. Postup pro jejich nalezení „lidsky řečeno“ je jednoduchý, prostě se podíváme na seznam čísel v seznamu a najdeme největší a nejmenší. Ale my víme spoustu věcí – víme, co je to číslo, víme, co je to nejmenší a největší prvek a samozřejmě víme co to znamená podívat se na čísla v seznamu. Počítač nic takového nezná. Musíme proto všechny tyto věci buď dodefinovat, a nebo je zahrnout do algoritmu. Při programování většinou volíme právě druhou možnost. Co je největší číslo? To je číslo které je větší než všechna ostatní. Nejmenší číslo je naopak takové, které je menší než všechna ostatní čísla. Podívat se na seznam znamená postupně se podívat na každé číslo v seznamu uložené. S touto znalostí můžeme algoritmus pro nalezení největšího a nejmenšího čísla přepsat následujícím způsobem: Pro všechna čísla v seznamu proveď: Jestliže je dosud nalezené nejmenší číslo větší než právě prohlížené číslo, je toto právě prohlížené číslo tím nejmenším. Jestliže je dosud nalezené největší číslo menší než právě prohlížené číslo, je toto právě prohlížené číslo tím nejmenším.

Sice už máme algoritmus, ale jeho zápis je hodně dlouhý. Další nevýhodou je, že vzhledem k různorodosti lidí a jejich jazykových schopností je možné, že různí lidé ten samý postup popíší různými větami. Abychom tomu zabránili, snažíme se v algoritmech

co nejvíc používat obecných a všem známých matematických značek jako rovná se, plus, mínus, atd. Pro každý údaj, který si musíme pamatovat také zavedeme a pojmenujeme proměnnou, která si tento údaj pamatuje a pomocí jejího jména se na ní mužeme vždy odkázat. Jména volíme typicky tak, aby byla krátká a výstižná. Náš údaj k zapamatování dosud nalezené nejmenší číslo tak nahradíme mnohem kratší proměnnou min a podobně pro maximální číslo. Celý algoritmus můžeme přepsat takto: Pro všechna čísla v seznamu proveď: Jestliže min > číslo, pak min = číslo Jestliže max < číslo, pak max = číslo

To už vypadá mnohem lépe ne? Musíme se ale zamyslet nad tím, jestli je daný algoritmys opravdu správný, tedy jestli funguje na všechny možné seznamy. Když se opravdu zamyslíte, určitě si všimnete, že tak nějak počítáme s tím, že jsme už nějaké minimum a maximum našli, jinak řečeno, že proměnné min a max mají hodnoty. Bohužel jsme ale nespecifikovali jaké, tedy jsme porušili determinističnost algoritmu. Náprava je však tak snadná, že spolu s ní uděláme ještě jednu změnu. Většina vývoje v počítačích probíhala v anglicky mluvících zemích a tak není překvapením, že i programovací jazyky jsou vesměs založené na angličtině. Náš algoritmus proto do Angličtiny přeložíme: min = first element of list max = first element of list for all elements in list do2: if min > element then min = element if max < element then max = element

Hotovo. Zapsali jsme první plně funkční algoritmus. Bohužel jsme ho ale zapsali v Angličtině, které počítač ani trochu nerozumí, aby ho počítač opravdu provedl, musíme ho přepsat do nějakého programovacího jazyku, my si ukážeme, jak bude vypadat v jazyce Python, ve kterém se budete učit programovat: min = list[0] max = list[0] for element in list: if (min > element): min = element if (max < element): max = element

Není to skoro to samé? Kromě vynechání pár zbytečných slovíček, přidání závorek a označní prvního prvku seznamu indexem 0 jsme vlastně napsali to samé. To, co platí pro tento jednoduchý příklad platí i pro mnohem složitější programy v jazyce Python. Náš problém jsme již dekomponovali. Dá se ale předpokládat, že když budeme programovat, bude nás zajímat největší a nejmenší číslo v seznamu čísel vícekrát než jednou. I když bychom mohli pokaždé opsat tento kód, který jsme již vymysleli, můžeme použít abstrakci a udělat to elegantněji: Udělat z našeho kódu funkci, tedy naučit počítač, že pokud chceme největší a nejmenší prvek ze seznamu čísel, chceme, aby provedl přesně tento algoritmus a vrátil nám jen výsledek. Výhody tohoto přístupu jsou zřejmé. Jednak se tím zjednoduší celý velký algoritmus a nebudeme muset tolik psat, druhak když zjistíme že máme v algoritmu pro výpočet chybu, stačí upravit jen jeho definici ve funkci a počítač již automaticky všude použije jeho opravenou verzi.

Programovací jazyky Jak jsme již řekli v minulé kapitole, počítače nerozumí angličtině, nerozumí ani češtině, ani žádnému jinému lidskému jazyku, budeme-li úplně upřímní, počítače nerozumí ani programovacímu jazyku Python. Počítače rozumí jen posloupnosti čísel, která říká velice složitým mechanismem procesoru co má přesně udělat. A procesor sám je velice „hloupý“, jeho schopnosti většinou nesahají dále, než aritmetické operace. Jediný jazyk, 2 Pokud jste opravdu dávali pozor až sem napadne vás, že není nutné procházet celý seznam, protože první prvek jsme si už „prohlédli“ jeho zapamatováním jako minima a maxima. A máte pravdu, je to zbytečné.

kterému procesor rozumí se nazývá strojový jazyk, a nejedná se o nic jiného, než o posloupnost čísel. Příklad algoritmu pro výpočet konkretních největších a nejmenších prvků ze seznamu čísel ve strojovém jazyce vidíte v levém sloupci následujícího kódu: 25 10 01 01 01 02 03 04 02 05 01 02 06 01 07 08

11 36 75 99 05 45 25 08 16 01 00 -11 02 81 03 81 01 00 -12 21 01 02 81 04 02 81 03 81 -19 03 81 -25

list: size: start: cycle:

next:

done:

data 25 11 36 75 99 05 45 25 08 16 data 10 mov ax, [list] mov bx, [ax] mov cx, [ax] cmp ax, [size] je done inc ax cmp bx, [ax] jle next mov bx, [ax] cmp cx, [ax] jge cycle mov cx, [ax] jmp cycle ret

Určitě uznáte, že program zapsaný ve strojovém ḱódu je naprosto nepřehledný. Lidé proto vytvořili jeho zjednodušení, jazyk symbolických adres, jinak také assembler, který vidíte napsaný v pravém sloupci předchozí ukázky. Assembler je vlastně pořád strojový kód, jen jsme různým číselným kódum instrukcí procesoru a jeho proměnným přidali názvy, které jsou zkratky jejich anglických popisů. Například mov = 01 (z anglického move), jge = 06 (jump if greater or equal), nebo ax = 01 (proměnná procesoru). I když program v assembleru by jste velice pravděpodobně po několika minutách jeho studia pochopili a došlo by vám, že opravdu jen vypočítá nejvyšší, a nejnižší číslo ze seznamu čísel uložených v paměti, nejedná se očividně o moc velké vypelšení. Přitom si všiměte, že assembler je vlastně dekompozice dovedená do extrému. Pokud si vzpomenete na abstrakci, pochopíte další krok ve vývoji jazyků, který byl učiněn. Proč se neodprostit od příkazů pro procesor a nenapsat program v příkazech lidsky srozumitelných, které ale mají tu výhodu že jdou velice snadno převést na příkazy strojového kódu. Místo spouštění programu pak spustíme jiný program, který bude instrukce našeho programu číst a po jedné je převádět na instrukce strojového kódu, které pak bude vykonávat. Interptetované jazyky jsou jazyky, jejichž programy se nespuštějí samy, ale pomocí interpretu, tedy programu, který jejich instrukce převádí na instrukce strojového kódu a vykonává. Tento přístup má kromě jednodužšího zápisu algoritmů také další velice podstatnou výhodu: Představte si, že chcete aby jeden program fungoval na více procesorech, jenže každý procesor má typicky vlastní instrukce strojového kódu. V případě interpetovaných jazyků nemusíte přepisovat všechny vaše, programy, stačí přepsat interpret. Příkladem interpretovaného jazyku je typicky BASIC, který najdete v následující ukázce zdrojového kódu. Opět není náhodou že je v levém sloupci uveden assembler (tedy přesně ty části assembleru, které odpovídají jednotlivým řádkům BASICu). list: size: start: cycle:

data 25 11 ... data 10 mov ax, [list] mov bx, [ax] mov cx, [ax] cmp ax, [size] je done inc ax cmp bx, [ax] jle next mov bx, [ax]

10 LIST = (25,11,36,75,99,05,45,25,08,16) 20 MIN = LIST[1] 30 MAX = LIST[1] 40 FOR I=2 TO SIZE(LIST): 50 IF (MIN>LIST[I]): 60

MIN=LIST[I]

next:

done:

cmp cx, [ax] jge cycle mov cx, [ax] jmp cycle ret

70 END 80 IF (MAX
MAX=LIST[I]

100 END 110 END

Program v BASICu již vypadá mnohem čitelněji a je hodně blízký jak angličtině, tak i zápisu algoritmu v jazyce Python, který jsme ukázali dříve (čísla před řádky v BASICu jsou čísla těchto řádků a program se provádí ve vzestupném pořadí podle čísel řádků). Velikou nevýhodou interpretovaných jazyků je však to, že jsou velice pomalé (místo našeho programu běží interpret, který musí program po kouskách přeložit a pak teprve spustit). Jak tedy dosáhnout rychlého programu, který může být napsát ve vyšším jazyce (vyšší jazyky jsou obecně jazyky bližší lidem, ale vzdálené počítači)? Řešení je velice jednoduché: Kompilované jazyky jsou jazyky, kde se před prvním spuštěním programu celý program najednou převede do strojového kódu a tento kód se pak uloží na disk. Další spouštění programu již spouštějí přímo předpřipravený strojový kód. Program který převede celý program do strojového kódu se jmenuje kompilátor. Výhodou kompilovaných jazyků je jejich rychlost (stejně rychlá jako assembler). Nevýhodou však je, že pro každý nový počítač musíme program znovu zkompilovat, což může trvat i velice dlouho (například kompilace Linuxu na běžném počítači trvá řádově dny). Od té doby, co je ale program zkompilovaný bude již fungovat velice rychle. Typickým kompilovaným programovacím jazykem je Pascal. Vzhledem k tomu, že byl navržen jako jazyk pro výuku programování, je také jeho zápis algoritmu velice přehledný: var list:array of integer = [ 25,11,36,75,99,05,45,25,08,16]; min,max:integer; i:integer; begin min:=list[0]; max:=list[0]; for i:=1 to length(list)-1 do begin if (min>list[i]) then min:=list[i]; if (max<list[i]) then max:=list[i]; end; end.

Poslední skupinou jazků, které si zde uvedeme, jsou jazyky hybridní: Hybridní programovací jazyky jsou jazyky, které se nejprve kompilují do obecného strojového kódu, který se pak interpretuje na různých počítačích různými způsoby. Tomuto obecnému strojovému kódu se v této souvislosti říká bytecode a výhody tohoto způsobu jsou evidentní: Program stačí zkompilovat pouze jednou pro libovolný počet různých počítačů a interpretace jednoho strojového kódu jiným je vetšinou velice rychlá, takže interpret tolik nezpomaluje. Do této skupiny jazyků patří například Java, ale i Python.

Další dělení programovacích jazyků Jen pro úplnost ještě uveďme další možná dělení programovacích jazyků. Kromě dělení na obecné, tedy vhodné pro co největší počet problémů (například C, Java, Python) a na speciální jazyky určené jen pro konrétní množinu problémů (například jazyk VHDL pro popis HW částí počítače, nebo jazyk SQL pro práci s databázemi).

Jak již bylo řečeno, podle míry abstrakce můžeme dělit jazyky na nižší (assembler) a vyšší (prakticky všechny ostatní). Míře abstrakce jazyka se také někdy říká jeho vyjadřovací schopnost3. Vyšší jazyky pak dělíme na kompilované, interpretované a hybridní, jak bylo popsáno v předchozí kapitole. Velice důležitým dělením je ale dělení na jazyky na imperativní, funkcionální a logické: Imperativní jazyk je takový, který popisuje algoritmus jako sekvence příkazů měnícich stav programu (proměnných) a souvislostí mezi nimi. Zatím všechny jazyky, které jsme si uvedli jsou imperativní. Jedná se o nejpočetnější rodinu jazyků, protože jsou nejbližší lidskému chápání algoritmů a jejich reprezentaci. Funkcionální programovací jazyky jsou jazyky, které používají pro popis algoritmu aplikace matematických funkcí na vstupní data. Ačkoli tyto jazyky jsou obecně náročné na pochopení a efektivní práci v nich, jsou z teoretického hlediska velice důležité, protože jsou nejbližší právě matematickému chápání jazyka. Jako příklad zde uvedeme program pro výpočet faktorálu v jazyce Haskell: factorial :: Integer -> Integer factorial 0 = 1 factorial n | n > 0 = n * factorial (n-1)

Logické programovací jazyky jsou takové, které používají pro popis algoritmů formální matematickou logiku a logické odvozování. Jazyky patřící do této skupiny se používají hlavně v umělé inteligenci, jejich předností je schopnost popsat algoritmy na základě logických vlastností a operací, které se dají opět velice jednoduše matematicky popsat a analyzovat. Jako příklad si uvedeme následující program s ukázkou jeho použití. Program umí zjistit, zda jsou dva lidé sourozenci na základě vztahu jejich rodičů: sibling(X, Y) :- parent_child(Z, X), parent_child(Z, Y). parent_child(X, Y) :- father_child(X, Y). parent_child(X, Y) :- mother_child(X, Y). mother_child(trude, sally). father_child(tom, sally). father_child(tom, erica). father_child(mike, tom). ?- sibling(sally, erica). Yes

Proč se učit programování? Sice jsme vám už řekli, co to programování je, jak funguje a co zhruba můžete od programování čekat, ale zatajili jsme vám to hlavní, proč se vlastně programovat učíte. Možná, že programování není úplně správný název – algoritmizace je mnohem výstižnější. Jak jste se již dozvěděli, programování je jen triviální přepis algoritmu popsaného do detailu v lidské řeči co programovacího jazyka srozumitelnému počítači. Co je ale mnohem náročnější je vymyšlení daného algoritmu a jeho popis. Tomu se říká algoritmizace a jedná se vlastně o správné a účelné používání abstrakce a dekompozice. Abstrakce a dekompozice jsou však velice důležité myšlonkové pochody, jejichž zvládnutí vám usnadní skoro jakoukoli intelektuální činnost. Znalost obecných postupů v programování tak můžete aplikovat i sami na sebe a ulehčit si tak řešení složijějších problémů, na které byste jinak nestačili. 3 Čím větší vyjadřovací schopnost jazyka, tím méně řádků většinou potřebujete na popis složitějšího algoritmu.

Od letošního roku se také učíte programovat v jazyce Python. Ten jsme vybrali protože převod algoritmů z angličtiny do Pythonu je ten nejjednodužší možný a vy se proto nemusíte ani moc soustředit na zvládnutí programování, jako na vlastní algoritmizaci jako takovou. I přes svoji neobyčejnou jednoduchost je ale Python jazyk jako každý jiný (i lidský) a jediná šance jak se ho opravdu naučit je často a pravidelně ho používat. Na konci každé kapitoly naleznete seznam několika příkladů k naprogramování od těch nejlehčích po ty složitější, které byste si určitě měli zkusit sami naprogramovat a zkusit jestli se chovají tak, jak by měly. To, že většina otázek je tak trošku matematických (sčítání, odčítání, násobení, dělení) je dáno pouze tím, že jsou to ty nejjednodužší aplikace, takže se není čeho bát. Klasicky čím víc hvězdiček, tím těžší úkol.

Otázky a úkoly 1) Zkuste napsat algoritmus pro součet seznamu čísel. 2) Napiště algoritmus, který zjistí, zda je číslo prvočíslem. 3) ** Napište algoritmus, který setřídí seznam čísel od nejmenšího po největší.

Instalace Pythonu Python je hybridním interpretovaným jazykem a proto budeme potřebovat stáhnout a nainstalovat si jeho interpret. Aby programování v Pythonu bylo snazší, budeme potřebovat také vývojové prostředí (z anglického Integrated Development Environment, IDE). Vývojové prostředí je editor, který kromě jednoduché editace textu nabízí i další schopnosti vhodné pro programátory. V této kapitole si ukážeme jak nainstalovat IDE i Python do operačního systému Windows.

Stažení potřebných souborů Nejprve musíme stáhnout interpreter jazyka Python. Ten si můžete zdarma stáhnout ze stránek Pythonu www.python.org:

Obrázek 1: Stránky Pythonu Kliknutím na menu Download v levé části stránky se dostanete na seznam instalačních balíčků ke stažení.

Obrázek 2: Výběr Pythonu ke stažení Zde si vyberte Python 2.x.x Windows installer. Pokud máte 64bitový počítač, můžete si nainstalovat i 64bitovou verzi. Pro potřeby této učebnice je to však zcela zbytečné a je pro vás jednodužší použít standardní verzi označenou červeným rámečkem.

Obrázek 3: Uložení staženého Pythonu Zvolte uložení instalačního souboru a počkejte na jeho stažení. Jako IDE budeme používat Komodo Edit, který má tu výhodu, že je zcela zdarma, je jednoduchý na ovládání a přitom má přesně ty vlastnosti, které budeme v začátcích programování potřebovat4. Komodo je dostupné pro Windows, Linux i Mac. Komodo Edit si můžete zdarma stáhnout na adrese www.activestate.com:

4 Pokud byste chtěli používat profesionálnější IDE, které umí i ladění kódu a další funkce, můžete zkusit Python Development Toolkit pro Eclipse. Obojí najdete na www.eclipse.org.

Obrázek 4: Stránky ActiveState Na stránkách ActiveState klikněte na tlačítko Downloads v levém horním rohu (označeno červeným kroužkem).

Obrázek 5: Výběr Komodo Edit ke stažení V sekci ke stažení si pak vyberte Komodo Edit a klikněte na Get Komodo Edit, jak je opět vyznačeno kroužkem.

Obrázek 6: Potvrzení stažení Na další obrazovce pak potvrďte stažení Komodo Edit kliknutím na tlačítko Download (stažení je zdarma, můžete si objednat i DVD poštou:).

Obrázek 7: Volitelná registrace u ActiveState Pokud chcete aby někomu z vašich nepřátel zaplavovaly emaily o Pythonu a ActiveState jeho schránku, můžete jeho jméno vyplnit ve volitelné registraci. Až budete hotovi, klikněte na tlačítko Continue.

Obrázek 8: Výběr instalačního balíčku Už jsme skoro tam. Vyberte si MSI instalační balíček pro Windows (pro ostatní systémy si samozřejmě vyberte příslušné instalace).

Obrázek 9: Download Komodo Edit Po dokončení stahování se můžete pustit do instalace Pythonu a Komoda.

Instalace Pythonu Spusťte instalační program Pythonu.

Obrázek 10: Úvodní obrazovka instalace Pythonu Zašrtněte instalaci Pythonu pro všechny uživatele (Install for all users) a klikněte na tlačítko Next >.

Obrázek 11: Výběr instalační složky Na další obrazovce si můžete vybrat složku, do které se má Python nainstalovat. Pokud nemáte závažné důvody pro opak, nechte zvolenou cestu tak, jak ji přednastavil Python. Pokud chcete instalační složku změnit, mějte na paměti, že tato cesta nesmí obsahovat žádné mezery. Výběr opět potvrďte kliknutím na tlačítko Next >.

Obrázek 12: Možnosti instalace Pythonu Možnosti instalace opět nechte tak, jak jsou nastaveny instalačním programem a pokračujte kliknutím na tlačítko Next >.

Obrázek 13: Dokončení instalace Pythonu Instalaci Pythonu dokončíte kliknutím na tlačítko Finish.

Instalace Komodo Edit Po stažení instalačního souboru jej spusťte ve vašem oblíbeném souborovém manažeru, nebo průzkumníkovi Windows.

Obrázek 14: Úvodní obrazovka instalace

Úvodní obrazovku instalace odklikněte tlačítkem Next.

Obrázek 15: Licenční podmínky Odsouhlaste licenční podmínky zaškrtnutím políčka I accpet the terms in the License Agreement a klikněte na tlačítko Next.

Obrázek 16: Volby instalace Nainstalujte kompletně celé Komodo (nemusíte nic měnit, stačí jen kliknout na tlačítko Next).

Obrázek 17: Potvrzení instalace Ještě jednou potvrďte instalaci kliknutím na tlačítko Install.

Obrázek 18: Dokončení instalace Po nainstalování všech součástí dokončete instalaci kliknutím na tlačítko Finish.

Úvod do Komodo Edit Předtím, než začneme opravdu s Komodem a Pythonem pracovat, je dobré se ujistit, že instalace proběhla v pořádku. Spusťte Komodo (pokud již neběží a z menu Edit vyberte Preferences. V zobrazeném dialogovém okně pak přejděte na kartu Languages / Python tak, jak je uvedeno na následujícím obrázku:

Obrázek 19: Karta jazyka Python Rozklikněte modře zvýrazněnou položku Default Python Interpreter a vyberte si C:\Python25\Python.exe, případně cestu, kterou jste zadali při instalaci jazyka Python. Pokud se tato cesta v menu neobjeví, nemáte správně nainstalován Python, nebo Komodo. Zkuste proto restartovat počítač a tento test opakovat.

Úvodní obrazovka Komodo Edit Úvodní obrazovka Komodo Edit vypadá zhruba tak, jak je ukázáno na následujícím obrázku:

Obrázek 20: Úvodní obrazovka Komodo Edit Jako každé okno ve Windows, má i Komodo hlavní menu, ze kterého jsou dostupné všechny funkce editoru, pruh s nástrojovými lištami, kde jsou tlačítka zpřístupňující často používané operace. Velkou výhodou Komoda je, že můžete přidávat sami svá vlastní tlačítka, kterými můžete například spoštět vaše programy, jak si ukážeme později. Pod lištou s nástroji je lišta karet s otevřenými soubory. Komodo umí najednou zobrazovat více souborů a každý soubor dostane jednu kartu na této liště. Kliknutím na kartu příslušného souboru tak daný soubor zobrazíte. Na startovní stránce Komoda také naleznete seznam všech naposledy otevřených souborů a projektů, které tak můžete jednoduše a rychle znovu otevřít.

Projekty a Soubory Pokud píšete v Komodu programy, musíte nejprve otevřít projekt. Projekt je seskupení několika souborů s programy v Pythonu a dalších zdrojů které patří k sobě (například obrázků k programům a podobně). Založení nového projektu v Komodu je velice jednoduché. V hlavním menu zvolte Project / New Project. Otevře se standardní obrazovka pro otevření souboru Windows. V ní si zvolte adresář5, ve kterém bude projekt uložen, případně tento adresář založte a do položky jméno souboru napište název projektu (větsinou shodné s názvem složky projektu). Projekt v Komodu je totiž uložen v 5 Všechny cesty k vašim projektům a názvy vašich souborů nesmí obsahovat mezery a znaky jiné, než anglické abecedy.

souboru s příponou kpf (Komodo Project File), kde jsou uloženy názvy všech souborů k projektu patřícím a další nastavení projektu. Pro přehlednost je dobré založit si složku, ve které budete mít uloženy všechny projekty v Komodu. Pro každý projekt pak v této složce založíte novou složku příslušného názvu a v ní kpf soubor se stejným jménem. Až budete mít všechno hotovo, klikněte na tlačítko Uložit (Save).

Obrázek 21: Otevření nového projektu Po založení nového projektu se tento projekt objeví v seznamu naposledy otevřených projektů ve spodní straně úvodní obrazovky. Dvojitým kliknutím na jeho název ho otevřete:

Obrázek 22: Nový projekt v seznamu naposledy otevřených Po rozkliknutí projektu se otevře nová záložka v levém sloupci aplikačního okna. V této záložce se zobrazují v hierarchickém uskupení všechny otevřené projekty a jejich soubory. Dvojitým kliknutím na název souboru ho otevřete a zobrazíte v editačním okně. Zatím ale nový projekt nemá žádný soubor a tak musíme nejprve soubor vytvořit. Soubor založíme kliknutím pravým tlačítkem na název projektu v levém seznamu a zvolením položky Add / New File. Tento postup otevře dialogové okno pro zadání vlastností nového souboru (především názvu a typu). Jako typ souboru zvolíme z pravého seznamu Python. Název souboru je libovolný (bez českých znaků) s příponou .py. Nový soubor můžeme také založit z hlavního menu přes File / New / New File.

Obrázek 23: Otevřený projekt v Komodu

Obrázek 24: Založení nového souboru

Obrázek 25: Vlastnosti nového souboru

Po založení nového souboru se tento soubor automaticky otevře. Všimněte si nové karty na záložkách nově otevřených souborů stejně jako názvu souboru zobrazeného pod projektem. Hvězdička u názvu projektu znamená, že jsme v projektu udělali změny, které jsme ještě neuložili (založili jsme nový soubor). Projekt uložíte příkazem hlavního menu Project / Save Project. Ikona X v pravém rohu lišty s kartami otevřených souborů slouží ke zrušení aktálního souboru. Soubor se nevymaže, pouze se zruší jeho karta v editačním okně. Takto zrušený soubor můžete znovu otevřít dvojitým kliknutím na název souboru v seznamu souborů projektu.

Obrázek 26: Otevřený soubor v Komodu Abychom zkusili, zda všechno funguje, zkuste do nového souboru připsat následující řádek a soubor uložte (z hlavního menu File / Save a nebo klávesovou zkratklou CTRL+S): print “Ahoj”

Vlastní nástrojové lišty Právě jsme vytvořili první program v Pythonu a chtěli bychom ho spustit. K tomu se výborně hodí možnost přidat k projektu vlastní nástrojovou lištu. Pravým tlačítkem klikněte na název projektu v levém seznamu a v nabídce vyberte Add / New Custom Toolbar jako na následujícím obrázku. V následujícím dialogu pak zadejte název pro nástrojovou lištu (například Commands).

Obrázek 27: Nová nástrojová lišta Poté, co vytvoříte novou nástrojovou lištu, klikněte na ni pravým tlačítkem a ze zobrazené nabídky vyberte Add / New Command:

Obrázek 28: Nový příkaz Otevře se dialogové okno s parametry příkazu. Do položky Command napište %(python) %f a do položky Start in %D. Tím jsme řekli Komodu, že příkazem bude spustit interpreter Pythonu, který jsme již dříve nastavili s parametrem kterým je aktuálně editovaný soubor a že tento soubor se spustí v tom adresáři, ve kterém je uložen. Box Run In změňte z Command Output Tab na New Console. Zde říkáme, že program bude puštěn v novém okně, to je důležité pro správné zadávání vstupů z klávesnice. Konečně

na první řádce můžete nastavit jméno příkazu, případně po kliknutí na tlačítko Change Icon... můžete přidat příkazu jinou ikonu než která je zobrazená vlevo od názvu. Na kartě Key Binding pak můžete nastavit klávesovou zkratkou, kterou bude tento příkaz spuštěn.

Obrázek 29: Vlastnosti příkazu Po kliknutí na tlačítko OK se nový příkaz zobrazí jak v seznamu projektu, tak v nástrojové liště, jak je znázorněno na následujícím obrázku:

Obrázek 30: Hotový příkaz Nyní můžeme kliknutím na nově založený příkaz spustit aktuální soubor. Ten se spustí v novém okně terminálu, které můžete po jeho skončení zrušit buď myší, nebo stiskem jakékoli klávesy. Nezáleží na tom, kolik máte v projektu otevřených programů, tento

příkaz bude vždy fungovat na ten aktuální (tedy ten, jehož karta je aktivní a jeho kód je zobrazen v editačním okně).

Obrázek 31: Spuštěný program Spuštěný program udělá přesně to, co bychom čěkali, vypíše „Ahoj“ a skončí. Před spuštěním programu je nutné ho vždy uložit! Pokud program před spuštěním neuložíte, změny v něm provedené v editoru od posledního uložení se vůbec neprojeví a bude spuštěna jeho stará verze!

Užitečná nastavení editoru Ještě než se přesuneme k další kapitole, kde si vysvětlíme pokročilejší schopnosti editoru Komodo, ukážeme si několik důležitých nastavení, která je dobrá v editoru udělat.

Obrázek 32: Důležitá nastavení Nejprve v menu Edit / Preferences vyberte ze seznamu New Files a nastavte výchozí jazyk na Python. V levém seznamu pak vyberte Editor a zapněte zobrazení čísel řádků (Show line numbers). Na kartě Indentation pak upravte v horní i dolní části Number of spaces per ident na hodnotu 2 a Width of each Tab character také na hodnotu 2.

Pokročilé vlastnosti editoru V následující kapitole si probereme složitější vlastnosti editoru Komodo, které vám velice ulehčí práci s ním. Vzhledem k tomu, že pro jejich pochopení je nutná alespoň minimální znalost Pythonu, přeskočte teď tuto kapitolu a vraťte se k ní až zvládnete následující kapitolu o základech jazyka Python.

Označování syntaktických chyb Editor vám automaticky označí červeným podtržením ty části kódu, kde máte syntaktickou chybu, jak je uvedno na následujícím obrázku.

Obrázek 33: Označení chyby Zde jsme na řádku 3 zapomněli napsat rovnítko z přiřazení. Protože kombinace identifikátoru (y) následovaného konstantní hodnotou (5) nedává smysl, Komodo řádek vyhodnotí jako chybný.

Doplňování kódu (Code Completion) Pokud máme definovány vlastní funkce, nebo jsme funkce importovali z jiných modulů, může se stát, že si nepamatujeme jejich jména. Stačí když si zapamatujeme jen začátek jejich názvu, ten napíšete a stisknete CTRL+Space a Komodo začátek názvu funkce doplní. Pokud to pořád není funkce, kterou jste chtěli, opakujte CTRL+Space tolikrát, než se objeví vaše funkce. Tento postup funguje samozřejmě i pro názvy proměnných. Další vlastností Komoda je, že kdykoli se dostanete při editaci do stavu, kdy je možné si vybrat z více věcí, jako například při importování modulů z jakého modulu budeme importovat, Komodo zobrazí seznam všech možností, ze kterého můžete jednoduše vybrat:

Obrázek 34: Doplnění modulu

Nápověda a syntaxe funkcí V případě, že v Komodu napíšete volání funkce a začnete otevírací závorkou pro seznam parametrů, Komodo se pokusí danou funkci najít a zobrazí vám jednak její hlavičku, tedy seznam parametrů uvedený v její definici, a pokud existuje tříuvozovková nápověda, tak také tuto nápovědu:

Obrázek 35: Nápověda k funkci Parametr, který je právě třeba definovat je zvýrazněn modrou barvou.

Operace s bloky V minulém obrázku jste si mohli všimnou značek u začátků všech bloků kódu, tedy u definice funkce na řádku 3 a u dvou podmíněných příkazů na řádcích 5 a 7. Kliknutím na značky – v těchto řádcích vedle čísel řádků dojde k tomu, že se celý blok kódu schová. Tato funkce se hodí pro zpřehledňování delších souborů, kde takto můžete schovat kód již hotových a funkčních funkcí. Napříkad zabalená funkce maxOfThree vypadá následujícím způsobem:

Obrázek 36: Zabalení Vedle zabalení textu zobrazuje také Komodo tečkované vodící čáry zobrazující hloubku bloků, abyste mohli jednoduše bloky ukončovat. Tyto vodící čáry jsou patrné na řádcích 6 a 8, tedy v tělech podmíněných příkazů.

Základy jazyka Python Ačkoli je Python v mnohém odlišný od ostatních jazků, mnohé s nimi sdílí. V této kapitole se podíváme na ty úplně nejzákladnější vlastnosti nejen tohoto jazyka, a řekneme si něco o tom, jak vlastně program v Pythonu funguje. Pro ulehčení práce s odhalováním chyb si můžete stáhnout projekt do KomodoEdit, který obsahuje všechny příklady v Pythonu, které jsou zde popsány. Pro správné naučení se s Pythonem a IDE je ale opravdu třeba je všechny přepsat a ne jen si prohlédnout cizí práci. Naučíte se tak totiž nejen jazyk aktivně používat, ale zvládnete i IDE. V každé ukázce kódu je na začátku vždy číslo řádku. To slouží pouze k rychlé orientaci v textu a odkazování na konkrétní zajímavé řádky dále v textu, když budete program psát do Komoda, čísla řádek nikdy nepřepisujte. Python je citlivý na počet mezer a na malá a velká písmena. Speciálně tyto vlastnosti musíte při přepisování dodržet (například print a Print jsou dva různé příkazy).

Hello World! Tradičně každá učebnice programování začíná tím nejjednodužším, co lze naprogramovat. Následující program pouze vypíše na obrazovku řetězec „Hello World!“ a skončí. 1 print “Hello World!”

Toť vše, když program uložíte do souboru, například helloworld.py, můžete jej spustit z příkazové řádky příkazem python hello_world1.py, nebo přímo z IDE kliknutím na tlačítko vytvořené v minulé kapitole. Příkaz print vytiskne na obrazovku parametr, který je uveden za ním. To může být textový řetězec, číslo, nebo libovolná proměnná. Jednotlivé věci k vypsání na obrazovku se oddělují čárkou. Když se ale podíváte na zdrojový kód programu tak, jak je uveden v projektu ke stažení, zjistíte, že kódu je trošku více: 1 #!/usr/bin/env python 2 print "Hello World!" # Zobrazi text Hello World! na obrazovce

Komentář v programu začíná dvojkřížkem (#) a končí novým řádkem. Všechno, co do komentáře napíšete bude interpretem Pythonu ignorováno. Na druhém řádku je vidět, že komentář nemusí zabrat celý řádek, ale může následovat až po příkazu. Komentáře většinou používáme k vysvětlení nejasných míst v našem programu tak, aby je ostatní programátoři snáze pochopili. Co je ale obsahem prvního řádku? Pokud jste zkusili něco v Komodu napsat, víte, že tento řádek se napíše automaticky pro každý nový soubor. Jeho význam je jednoduchý, je to vlastně příkaz v jiném programovacím jazyce než Python, který říká: Pokud chceš spustit tento program musíš ho spustit následujícím interpretem. Na některých linuxových

distribucích tento příkaz způsobuje to, že můžete spustit Vaše programy v Pythonu tak jako každé jiné spustitelné soubory, protože ony samy řeknou operačnímu systému, jaký potřebují interpret. Vzhledem k tomu, že tento řádek není ale pro Python nijak důležitý, budeme ho ve výpisech kódu dále ignorovat. V předchozích definicích jsme použili pojem řetězec, který ale jak jste si jistě všimli zůstal zatím bez vysvětlení, což hned napravíme: Textový řetězec je v Pythonu ohraničen uvozovkami (obě dvě nahoře). Obsahem řetězce může být jakýkoli (i česky psaný) text. Takto zapsaný řetězec musí být celý na jedné řádce. Jak tedy ale zapsat do řetězce text, který se má zobrazit na více řádek? Velice jednoduše – do řetězce můžeme vložit speciální znak \n, který znamená začátek nového řádku. Ačkoli k jeho zápisu potřebujeme 2 znaky, zpětné lomítko a malé n, bude se ve výsledku jednat o pouze jeden znak. Zpětné lomítko (\) totiž říká Pythonu, že chceme zapsat speciální znak a malé n pak říká, o jaký znak se jedná. Pokud bychom chtěli v textu použít zpětné lomítko, musíme ho zdvojit, aby nedošlo k omylu a nebylo považováno za uvození speciálního znaku: 1 print "Hello World!\nJak se mate?" 2 print "Umim napsat i backslash: \\" 3 print "A dokonce i \"uvozovky\""

Předchozí ukázka obsahuje ještě další důležitý speciální znak – uvozovky. Pokud je totiž celý řetezec ohraničen uvozovkami, jak zapsat řetězec, který sám uvozovky obsahuje? Tyto uvozovky by totiž Python omylem považoval za konec řetězce a ohlásil by pak chybu. Řešení je jednoduché, před uvozovky zapíšeme zpětné lomítko a Python ví, že se jedná o součást textu. Význam \““ na konci třetího řádku je možná na první pohled nejasný, proto si ho vysvětlíme, jedná se vlastně o dva znaky za sebou, první je \“, a druhý je “. Jejich význam by teď měl být jasný. První z nich jsou druhé uvozovky v textu, druhý je pak vlastní ukončení řetězce. Podslední věc, které je třeba si na předchozím programu všimnout je to, že každé použití příkazu print na jeho konci odřádkuje automaticky. První řádka by tedy šla zapsat i takto: 1 print “Hello World” 2 print “Jak se mate?”

Proměnné a volání funkcí Velice důležitým konceptem v každém programovacím jazyce jsou proměnné. S proměnnými jsme se již setkali v úvodním příkladu pro nalezení největšího a nejmenšího čísla, kde jsme použili proměnné min a max. Co to ale proměnná je? Proměnná je přiřazení názvu (identifikátoru) určitému místu v paměti počítače. Hodnota uložená na tomto místě je pak v programu přístupná pod názvem příslušné proměnné. Proměnnou tedy použijeme tehdy, když je potřeba, aby si program nějaký údaj zapamatoval. V předchozích příkladech jsme také potřebovali, aby si program pamatoval všechny řetězce, které měl vypsat. Podstatný rozdíl je v tom, že o těchto řetězcích jsme věděli, že budou vždy stejné. Princip proměnné je však v tom, že se může kdykoli změnit (proto se jmenuje proměnná). Představte si například program, který se nejprve zeptá, jak se jmenujete a pak Vás pozdraví. Je jasné že otázka jak se jmenujete bude vždy stejná. Stejná bude asi i část pozdravu bez vašeho jména. Co se ale bude měnit je vaše jméno a to podle toho, kdo program spustí. Tohle nejde dopředu předpokládat. Potřebujeme proto proměnnou, kam si zadané jméno uložíme, abychom ho později mohli použít. Pokud v Pythonu potřebujete použít proměnnou, stačí pouze napsat její jméno a přiřadit mu (pomocí =) nějakou počáteční hodnotu (vzpomeňte si opět na úvodní příklad s

minimem a maximem, každá proměnná musí mít na začátku přiřazenou nějakou hodnotu). 1 name = raw_input("Jak na tebe vola maminka?") 2 greeting = "Ahoj " + name + "!" 3 print greeting

Spousta nových věcí najednou, že? A dokonce jsme použili hned dvě proměnné najednou (name a greeting). Co ale dělá tajemný první řádek? Tomu, co se v něm děje říkáme volání funkce: Funkce je malý program, kterému předáme vstupní data (parametry) a on nám po svém provedení může vrátit nějaký výsledek (návratová hodnota). Parametry funkce jsou uvedeny v kulatých závorkách za jménem funkce a pokud jich je víc, jsou odděleny čárkou. Tato definice je velice podobná matematické definici funkce. Skrývá se za ní jednoduchý fakt založený na abstrakci, popsané v první kapitole. Programátoři Pythonu počítali s tím, že čtení hodnoty z klávesnice bude často opakovaným problémem a udělali proto krátký program, který přesně tohle umí. Zavolání funkce raw_input doslova říká: Spusť funkci raw_input a řekni jí, ať se zeptá „Jak na tebe vola maminka?“. To co ti funkce vrátí pak ulož do proměnné name. Funkce raw_input má jediný parametr který říká na co se má program zeptat a vrací jediný výsledek, odpověď uživatele na tuto otázku. Funkce samozřejmě můžete vytvářet i vy ve svých programech, ale o tom si řekneme až pozdeji. Na druhém řádku máme proměnnou greeting, do které ukládáme celý text pozdravu. Všimněte si, že text pozdravu je složen ze dvou konstatních částí a hodnoty proměnné name, kterou jsme si uložili na řádku 1. Ke spojení řetězců za sebe použijeme operátor +. Pokud by například hodnota proměnné name byla „Petříčku“, bude proměnná greeting obsahovat „Ahoj Petříčku!“, což pro vás jistě není žádným překvapením. Na posledním řádku pak již jen zapamatovaný pozdrav vytiskneme. Zatím jsme sice proměnnou použili, ale neměnili jsme vůbec její hodnotu. Když se zamyslíte nad předchozím případem, napadne vás, že by šel napsat i jen s jedinou proměnnou. Proměnnou name jsme totiž použili jen k tomu, abychom mohli správně nastavit proměnnou greeting. Nešlo by na obojí použít jen jednu proměnnou? 1 text = raw_input("Jak na tebe vola maminka?") 2 text = "Ahoj " + text + "!" 3 print text

Kromě změny názvu proměnné, aby lépe odpovídala svého použití (proměnné je vždy dobré pojmenovávat tak, aby vyjadřovaly své určení, což zjednodušuje orientaci v kódu) jsme vlastně změnili jen řádek číslo 2. Na něm říkáme, že obsahem proměnné text se má stát „Ahoj „, za ním starý obsah6 této proměnné zakončený vykřičníkem. Tato konstrukce, kdy se proměnné přiřazuje její modifikovaná stará hodnota se velice často používá například při inkrementaci (zvětšení) hodnoty proměnné. Chceme-li napříkad zvětšit hodnotu proměnné x o 1, stačí napsat následující příkaz (předpokládáme, že proměnná je již inicializována): 1 x=x+1

Předchozí příklad můžeme ještě dále upravit když si všimneme že hodnotu přiřazenou do proměnné text na řádku jedna používáme pouze k vytvoření nové hodnoty na řádku 2. Řádky 1 a 2 tak můžeme sloučit následujícím způsobem: 6 Tato konstrukce funguje protože Python nejprve založí skrytou proměnnou, do níž uloží výsledek operací uvedených vpravo od přiřazení. Když je tento výpočet hotový, obsah této skryté proměnné se uloží do proměnné uvedené nalevo od přiřazení. Proto je možné použít v pravé čísti přiřazení starý obsah proměnné.

1 text = "Ahoj " + raw_input("Jak na tebe vola maminka?") + "!" 2 print text

Všiměte si, že k vytvoření obsahu text se při její inicializaci používá návratová hodnota funkce raw_input7. Pokud si uvědomíte, že hodnotu proměnné text vlastně potřebujeme jen proto, abychom ji zobrazili, lze celý program napsat jen v jedné řádce následujícím způsobem: 1 print "Ahoj " + raw_input("Jak na tebe vola maminka?") + "!"

V tomto případě to vypadá, že v našem programu nemáme proměnnou žádnou. To však není pravda, protože podobně jako v předchozích případech byla pouze nahrazena proměnnou skrytou, která přestane existovat ihned po provedení příkazu print. Použitím skrytých proměnných sice do určité míry zvětšujeme čitelnost kódu a píšeme méně, ale je důležité si uvědomit, že tím také přicházíme o možnost se k jejich hodnotám v budoucnosti dostat. Pokud bychom tedy chtěli vedle pozdravu vytisknout ještě nějakou informaci související se zadaným jménem, předchozí postup nelze použít.

Typy proměnných Typ proměnné je určení druhu hodnoty, který je v proměnné uložen. Každá proměnná musí mít jednoznačně určený typ, který říká Pythonu co za hodnotu je v proměnné uloženo. Podle toho, jaký druh hodnoty je v proměnné uložený totiž fungují některé příkazy v Pythonu. Například operátor +, který dvě čísla sečte se pro řetězce chová úplně jinak a zřetězí je za sebe. Na rozdíl od některých dalších jazyků Python nenutí programátora specifikovat typ proměnné při jejím prvním použití. Typ proměnné je totiž ve většine případů určen typem hodnoty, kterou jí přiřazujeme (další důvod, proč musí být každá proměnná inicializována na nějakou hodnotu). Tento typ může být samozřejmě dalším přiřazením změněn. V některých případech je ale nutné specifikovat typ hodnoty proměnné manuálně. Zkuste například následující příklad, který dělí dvě čísla: 1 2 3 4 5 6

x = 2 y = 5 print x/y print x/float(y) y = 5.0 print x/y

Zde nejprve přiřadíme do x a y hodnoty 2 a 5 a potom je různými způsoby tiskneme. Překvapivě však výsledkem prvního řádku bude nula. V x a y jsou ale pouze celá čísla. Python proto předpokládá, že nás zajímá pouze dělení v okruhu celých čísel, a skutečně 2/5 v celých číslech je 0. Pokud čísla změníte například na 11 a 5, vyjde vám 2. Pokud tedy chceme znát přesnou hodnotu dělení, musíme Pythonu nějak naznačit, že se má na tento výraz dívat jako na dělení desetinných čísel. Řádky 4 a 5 ukazují různé způsoby, jak toho docílit. Na řádku 4 voláme funkci float(). Tato funkce má jako jediný parametr libovolnou proměnnou, kterou se pokusí převést na desetinné číslo (převod z celého čísla na desetinné je jasný, v ostatních případech může být komplikovanější). Toto desetinné číslo je pak návratovou hodnotou této funkce. Významem řádku tedy je dělení celého čísla x desetinným číslem, které vrátí funkce float. Python proto ví, že výsledkem může být desetinné číslo a zobrazí jeho správnou hodnotu 0,4. Jinou možností, jak docílit stejného efektu je již při inicializaci do proměnné y (nebo x) desetinné číslo. I když 5 je vždy celé číslo, zápisem 5,0 jako na řádku 5 dáváme Pythonu najevo, že chceme aby použil desetinné číslo. Až dosud jsme se tedy setkali se třemi různými typy proměnných, které jsou uvedeny v 7 Tato hodnota se podobně jako v předchozím případě uloží opět do skryté proměnné, takže vlastně z hlediska počítače se jedná o úplně stejný princip.

následující tabulce spolu s jejich konverzními funkcemi (konverzní funkce typu A se pokouší parametr převést právě na typ A):

Název typu Celá čísla (integer)

Převodní funkce int()

Popis Celá kladná i záporná čísla

Desetinná čísla (float) float()

Desetinná kladná i záporná čísla

Řetězce (string)

Textové řetězce libovolné délky

str()

Tyto tři typy zdaleka nejsou jediné, které Python umí. Jedním ze základních znaků vyšších jazyků je existence velice komplexních datových typů, jako je například seznam, nebo slovník. O těchto složitějších typech si však povíme později.

Chyby při psaní programů Chybám při psaní programu se nevyhneme. Jak říká známý Murphyho zákon, v každém počítačovém programu je alespoň jedna chyba8. Chyby při psaní programů dělíme na dva základní druhy, syntaktické a sémantické: Syntaktické chyby jsou chyby v použití jazykových konstrukcí. Znamenají, že program není možné vůbec spustit (případně zkompilovat). Tyto chyby se dají přirovnat k použití například špatného pádu, nebo času v češtině. Sémantické chyby jsou chyby, kdy význam zapsaného kódu je jiný, než jaký jsme původně zamýšleli. Program s těmito chybami lze spustit, ale v závislosti na závažnosti těchto chyb bude buď jeho spouštění přerušeno, nebo se bude chovat nesmyslně. Syntaktické chyby obecně není problém odhalit, a i když je ze začátku budete dělat velice často, jak se s jazykem lépe seznámíte, budete jejich opravami trávit stále méně a méně času. Mnohem horší jsou chyby sémantické. Například následující jednoduchý kus kódu obsahuje sémantntickou chybu (zkuste přijít na to, jakou): 1 print “2” + 2

Asi jste správně odhadli, že chyba je v tom že se snažíme buď sečíst řetězec a číslo, nebo se snažíme řetězec a číslo spojit. Obojí není možné, protože sečíst lze pouze dvě čísla a spojit pouze dva řetězce. Pokud tento program spustíme, dostaneme následující výsledek, na kterém si ukážeme, jak se orientovat v chybových hlášeních Pythonu: Traceback (most recent call last): File "/home/peta/devel/python_tutorial/variable_types.py", line 1, in <module> print "2"+2 TypeError: cannot concatenate 'str' and 'int' objects

Python nás nejdříve informuje o tom, že nám zobrazí traceback, což je velice důležitá pomůcka k tomu, abyste mohli určit, jak a kde k dané chybě došlo. Co přesně je tracekback si povíme až později, zjednodušeně však lze říci, že se jedná o popis průchodu programem, který vám zobrazí kroky které předcházely chybovému řádku. V našem případě má program jen jeden řádek, takže traceback je mimořádně primitivní. Jeho poslední řádka však obsahuje identifikaci řádky, kde došlo k chybě. Zobrazeno je jak jméno souboru, tak i číslo řádky. Tato řádka je pak zobrazena poslední řádkou výpisu je slovní popis chyby (samozřejmě v Angličtině). Tento říká přesně to, co jsme předpokládali, že nelze spojit řetězce a celá čísla. Náprava je v tomto případě také velice přímočará, a to sjednotit typy buď převedením „2“ na číslo, nebo naopak druhé dvojky na 8 Protože se ale na jiném místě říká, že každý program obsahuje alespoň jeden zbytečný příkaz, jde z těchto dvou zákonů odvodit, že každý program lze zjednodušit na jednu zbytečnou a chybnou instrukci. Budeme doufat, že našim programům se toto nestane:)

řetězec. Podle toho, jakou metodu zvolíme bude výstup roven buď 4, nebo 22 (rozmyslete si proč). I tuto chybu šlo jednoduše opravit. V komplikovanějších programech to však již zdaleka tak jednoduché není. Ještě těžší jsou takové chyby, které nezpůsobí ukončení programu. Python vám při nich neřekne kde, ani jak vznikly a jediným důkazem o jejich existenci je nesmyslné chování programu. Primitivní případ takové chyby jsme již také potkali – stačí si vzpomenout na dělení celých čísel. Pokud by výsledek tohoto dělení nebyl ihned zobrazen, ale použil by se například jako vstup nějakého složitějšího výpočtu, jehož výsledek by tím pádem vyšel špatně, dokážete si jistě představit, že odhalení takové chyby by bylo mnohem náročnější. Tím se dostáváme k velice důležité kapitole, totiž jak chyby v programech opravovat, ale hlavně jak je hledat. Hledání a opravování chyb v programu se nazává jeho ladění. Mnoho IDE nabízí speciální nástroje právě pro tento účel, které umožňují program spustit, v libovolném místě zastavit, prohlédnout si obsah všech proměnných a dalších vlastností v zastaveném programu a případně z tohoto místa dál pokračovat. Komodo Edit tuto vlastnost nemá, a tak si budeme muset pomoci sami. Nejjednodužší a zároveň velice efektivní metodou je vkládání tzv. ladících výpisů do programu na místa, kde čekáme, že může dojít k problému. Tyto ladící výpisy specielně použijeme k tomu, abychom si vypsali pro kontrolu hodnoty některých proměnných, případně jen k tomu, abychom zjistili, zda jsme do daného místa v programu byť jen došli. V případě, že máme například problém s výsledkem nějakého složitějšího výpočtu, prvním krokem je přidat ladící výpisy ke všem vstupním proměnným (tedy těm, ze kterých se finální výsledek počítá). Pokud jsou všechny v pořádku, musíme postupným posouváním ladícího výpisu ve výpočtu ověřovat řádek po řádku.

Operátory Operátory jsou jedním ze základních stavebních kamenů každého programovacího jazyka a ani Python není vyjímkou. Několik operátorů (+, /, =) již známe. Teď si o nich ale řekneme něco víc a seznámíme se i s ostatními: Operátor označuje operaci provedenou nad svými vstupy. Operátor vždy vrací hodnotu rovnou výsledné hodnotě dané operace. Operátory dělíme na binární (které mají dvě vstupní hodnoty) a unární (s jedinou vstupní hodnotou). Vstupním hodnotám operátoru říkáme operandy. Všechny operátory, které jsme zatím potkali byly binární. Unárním operátorem je například – označující záporné číslo. Zápis -42 totiž obsahuje zprava zápis čísla 42, ne které je aplikován operátor, jehož výsledkem je záporná hodnota operandu. Není překvapením, že tento operátor je definován jako (0-x), kde x je operand. Operátorů je v Pythonu obrovské množství, nás však bude zatím zajímat jen několik těch nejzákladnějších, které většinou odpovídají triviálně jejich aritmetickým operacím: ●

operátor součtu +, pro řetězce sloučení

●

operátor rozdílu -

●

operátor násobení *

●

operátor dělení / (se zbytnem nebo bezezbytku)

●

operátor zbytku po dělení %

●

operátor přiřazení =

Pro definici dalších, velice důležitých operátorů si musíme představit další datový typ, tzv. boolean. Datový typ boolean uchovává pouze logické hodnoty pravda, nebo nepravda. V Pythonu zapsané jako True a False. Všechny následující operátory pak mají vyslednou hodnotu právě boolean: ●

operátor porovnání ==

●

operátor nerovná se !=

●

operátor je větší než >

●

operátor je větší nebo roven >=

●

operátor je menší <

●

operátor je menší nebo roven <=

●

unární operátor negace ! (negace True je False a negace False je True)

Mezi hodnotami typu boolean a čísly existuje vztah, který říká, že pokud je potřeba převést číslo na typ boolean, stane se tak automaticky a to tak, že jakékoli číslo rozdílné od 0 se převede na True a jedině nula se převede na False.

Podmíněný příkaz a bloky Všechny programy, které jsem zatím napsaly se chovaly za všech okolností stejně. Pro řešení většiny problémů však potřebujeme, aby program měl rozhodnovací schopnost, tedy aby mohl na základě vyhodnocení nějaké podmínky provést to, či ono. Představte si, že chcete například napsat krátký program, který zjistí, zda zadané číslo je větší, nebo menší než 100. 1 2 3 4 5 6 7

number = input("Zadejte cislo:") if (number<100): print "Zadane cislo je mensi nez 100" if (number>100): print "Zadane cislo je vetsi nez 100" print "To znamena, ze je vetsi nez 10x10" print "Dekujeme ze jste pouzili tento program"

Příkaz input na prvním řádku funguje úplně stejně, jako příkaz raw_input z předchozí kapitoly s jediným rozdílem, příkaz input se postará o to, aby uživatel opravdu zadal číslo a ne nesmyslný řetězec. Podmíněný příkaz slouží k provedení kódu podmíněně na základě vyhodnocení podmínky. Jeho syntaxe je následující: if (podmínka): blok příkazů Řádky 2 a 3 tak představují podmíněný příkaz. Ten je uvozen klíčovým slovem if za kterým následuje podmínka. Podmínka je libovolný výraz, jehož hodnota je typu boolean (vzpomeňte si, že operátor < má návratovou hodnotu právě typ boolean). Za podmínkou, která je vždy uzavřena do složených závorek následuje dvojtečka a za ní blok příkazů. Blok příkazů v Pythonu je skupina příkazů, které mají stejné odsazení od levého okraje. Všimněte si, že řádka 3 má jiné odsazení než řádka 2. Toto odsazení je v Pythonu nesmírně důležité, protože právě odsazením říkáme pythonu, že řádka 3 patří do bloku příkazů, které se provedou pokud bude podmínka příkazu if vyhodnocena jako True (tedy pokud bude pravdivá. Konec bloku naopak znamená návrat k původnímu odsazení tak, jak je to na řádku 4. Odsazení se vrátilo na stejnou úroveň jako řádek 1 a 2 a to znamená, že jsme příkaz if ukončili. Řádek 4 se tedy provede vždy.

V druhém ifu je použití bloků ještě markantnější, protože kladná větev (tedy ta část programu, která se provede pokud bude podmínka vyhodnocena kladně má dva řádky (5,6) které mají opět větší odsazení než hlavní kód programu. Řádek 7 se pak opět vrací k původnímu odsazení, signalizuje tím že již nepatří do těla příkazu if, a že má tedy být proveden vždy. Protože se jedná o první složitější programovací konstrukci, radši si vše ještě jednou zopakujeme: V prvním řádku uživatel zadá číslo, které se uloží do proměnné number. Druhý řádek je podmíněný příkaz, tedy se vyhodnotí podmínka, v našem případě, zda number je menší než 100. Pokud menší je, provede se tělo podmíněného příkazu, tedy řádek 3 a pokračuje se dál řádkem 4. Pokud by number nebylo menší než 100, bude se rovnou pokračovat řádkem 4. Zde se situace opakuje s tím rozdílem že nás zajímá, jestli je number větší než 100. Pokud ano, provedou se řádky 5 a 6, pokud ne, bude program rovnou pokračovat řádkem 7, který se provede vždy. Následující příklad ukazuje najednou hned dvě velice důležité věci: Tou první je fakt, že podmíněné příkazy se do sebe monou vnořovat, tedy že i v těle podmíněného příkazu může být další podmíněný příkaz (a dále) jak je vidět na řádcích 4 a 5. Věnujte opět pozornost odsazení. Druhý if, který říká, jestli je číslo rovné stu se zkontroluje vždy, když bude platit podmínka na řádku 2 (má stejné odsazení jako tělo prvního ifu), ale jeho tělo (řádek 5) se provede jen když je číslo opravdu 100, protože odsazení tohoto řádku je opět větší: 1 2 3 4 5 6 7 8

number = input("Uz je to nuda, ale zadejte cislo jeste jednou") if (number<=100): print "Tohle vetsi vazne neni." if (number==100): print "Ale chybi jen kousek." else: print "Tohle vetsi je." print "Jsme slusni, takze opet podekujeme."

Další důležitou vlastností je část else podmínky, ketrou můžete vidět na řádku 6. Tato část má stejné odsazení jako původní if, a následuje za ní blok příkazů, které se provedou tehdy, pokud původní podmínka ifu byla vyhodnocena jako nepravdivá. V našem případě tedy pokud uživatel zadá hodnotu menší nebo rovnou stovce, if na řádku 2 bude pravdivý a proto se provede jeho tělo (již se ale neprovede jeho else část na řádku 7). A naopak pokud bude číslo větší než 100, podmínka bude nepravdivá a kladná větev se neprovede, Python však skočí na else větev, kterou naopak provede. Pokud vám stále není příkaz if jasný, zkuste si napsat předchozí program v pseudokódu a poté ho přeložit do angličtiny: Zeptej se uživatel na číslo Jestliže je toto číslo menší nebo rovno stu, pak napiš že je menší a pokud je navíc stovce rovné, napiš, že chybí jen málo. Jinak napiš že je větší ask for a number if (number<=100) print “je mensi” and if (number==100) print “jen o kousek”. Else print “je vetsi”.

Anglický pseudokód je opět takřka shodný s programem v Pythonu. Všiměte si ale dvojznačnosti angličtiny i češtiny v části else. Z lidského textu není vůbec jasné, jestli máme napsat, že je číslo větší než 100 tedy pokud není pravda že je menší, nebo rovno 100 (tedy pokud neplatí první podmínka, a jedná se o else část k první podmínce), a nebo jestli není pravda že číslo je rovno stu (tedy neplatí druhá podmínka a jedná se o else část druhé podmínky. Podobně i v Pythonu by se mohlo zdát, že u else na řádku 6 není jasné, jestli se vztahuje k ifu z řádku 2, nebo 4, ale podívejte se pozorně na odsazení a dobře si zapamatujte: Else část se vztahuje vždy k tomu ifu, který je odsazen na stejné úrovni. Právě proto se část else vztahuje naprosto jednoznačně k první podmínce.

Kompletní definice podmíněného příkazu i s nepovinnou else částí tedy vypadá následujícím způsobem: if (podmínka): # tento blok se provede, pokud je podmínka True blok příkazů else: # tento blok se provede tehdy, pokud je podmínka False blok příkazů Odsazení, které používáme k ohraničení jednotlivých bloků je jednou z nejdůležitějších vlastností jazyka Python a je nutné ho opravdu pochopit a pečlivě ho dodržovat. Na rozdíl od jiných jazyků jen změnou odsazení můžete výrazně změnit chování programů, což může na začátek vypadat složitěji. Na druhé straně vás však tento systém nutí při programování opravdu myslet a uvědomit si do jakého bloku jaký příkaz patří. V neposlední řadě také odsazené výrazně zvyšuje čitelnost a orientaci v programu.

Cyklus while Představte si další z uměle vytvořených problémů. Chceme udělat program, který se uživatele zeptá na nějaké číslo. Dokud bude toto číslo menší než 100 zeptáme se vždy uživatele jaké číslo máme k našemu číslu přičíst, abychom dostali číslo větší než sto a toto číslo přičteme. V momentě, kdy náme číslo větší než 100, můžeme s klidným svědomím skončit. Jak takový program napsat v Pythonu? Základní problém je, že nevíme kolikrát se budeme muset uživatele zeptat jaké číslo máme přičíst. Možná ani jednou, možná, že jen jednou (tady by nám ještě stačil if). Možná že dokonce stokrát (i tady by stačilo ještě sto ifů za sebou), ale když uživatel bude zadávat i záporná čísla (což je teoreticky možné), mohli bychom se ho ptát klidně do nekonečna. Potřebujeme proto zavést do jazyka něco jako opakování. Potřebujeme říci Pythonu, aby určitý kód (přesněji určitý blok kódu) opakoval tak dlouho, dokud je třeba, což znamená například do té doby, dokud je splňena nějaká podmínka podobně jako u podmíněného příkazu v předchozí kapitole. Abychom si opět ukázali velikou podobnost mezi Pythonem a lidskou řečí, zkusíme napsat algirtmus nejdřív v pseudokódu, který opět přeložíme do angličtiny: Zeptej se uživatele na číslo. Dokud je toto číslo menší než sto, ptej se uživatele jaké číslo más přičíst a toto číslo vždy přičti. Když už je číslo větší nebo rovno stu, poděkuj a skonči. Ask user for a number. While (number<100) ask for number to add. Add the number. When number>=100 print thanks.

Tento kód bude v Pythonu vypadat překvapivě takto: 1 number = input("Jeste jednou bych potreboval cislo ktere je alespon sto.") 2 while (number<100): 3 print "Jste uz asi unaveny, vase cislo rozhodne neni alespon sto." 4 x = input("Kolik k nemu mam pricist, aby bylo robvno stu?") 5 number=number+x 6 print "Dekuji. uz mam cislo vetsi nebo rovne stu."

Cyklus while se provádí tak dlouho, dokud je podmínka za klíčovým slovem while vyhodnocována jako True. Po skončení každého běhu cyklu se tato podmínka znovu zkontroluje. Syntaxe cyklu while je následující: while (podmínka): blok příkazů

Na řádce 2 jsme použili cyklus. Ten začíná klíčovým slovem, za kterým je podobně jako u ifu uvedena podmínka následována dvojtečkou. Pokud je podmínka vyhodnocena jako True, pokračuje se tělem cyklu, pokud je vyhodnocena jako False, pokračuje se prvním příkazem za tělem cyklu, tedy řádkem 6. V těle cyklu, které tvoří opět odsazený blok nejprve uživatele informujeme o tom, že zadal špatné číslo, pak se zeptáme na opravu, kterou uložíme do proměnné a tuto proměnnou pak přičteme k našemu číslu. Když dojde program na konec těla cyklu, vrátí se zpět na začátek cyklu (tedy na řádek 2) a vyhodnotí opět podmínku a podle ní pokračuje. Tento příklad můžeme ještě rozšířit do následující podoby, kde ukážeme vnoření podmínky do cyklu: 1 number = input("Jeste jednou bych potreboval cislo ktere je alespon sto.") 2 while (number<100): 3 print "Mame cislo", number 4 print "Jste uz asi unaveny, vase cislo rozhodne neni alespon stovka." 5 x = input("Kolik k nemu mam pricist, aby bylo robvno stu?") 6 if (x<0): 7 print "Zapornym cislem si nepomuzete, nebudu ho proto pricitat" 8 else: 9 number=number+x 10 print "Dekuji. uz mam cislo vetsi nebo rovne stu."

Kromě trošku větší uživatelské přívětivosti programu na řádce 3 jsme hlavně přidali podmínku do těla cyklu, která číslo přičte jen pokud nám neuškodí (tedy není záporné). Pokud je záporné, informuje nás, že k žádnému přičtení nedojde. Zajímavý je také řádek 9, kde ukončujeme dva bloky najednou. Nejprve else větev podmínky z řádku 6, ale pak i vlastní tělo cyklu, protože další řádek je na stejné úrobni, jako jeho podmínka. Tento příklad ilustruje, že najednou můžete ukončit kolik bloků chcete (do té doby dokud samozřejmě váš program dává smysl).

Cyklus for Dalším cyklem v Pythonu je cyklus for. Tento cyklus je specifický pro Python (abychom byli přesní, existuje i v jiných jazycích, ale vypadá o hodně jinak. Pro pochopení funkce forcyklu potřebujeme vědět, co je to kolekce. Kolekce je seřazený seznam určitých položek. To není tak překvapivé, podobně jako bonboniéra je kolekce čokoládových bonbómů, je kolekce prostě nějakým seskupením (klidně seznamem) obecných věcí. S jedním významným rozdílem – každý prvek v kolekci má přesně dané své místo, a pokud ho prohodíte, máte najednou jinou kolekci. Kolekce proto není obyčejná bonboniéra, ale například čokoládový adventní kalendář (každá čokoláda má své číslo od 1 do 24). Cyklus for funguje pouze na kolekcích. Pokud máme kolekci a chceme postupně provést nějakou operaci s každým jejím prvkem, použijeme forcyklus: Forcyklus v Pythonu do řídící proměnné uloží v každé iteraci následující položku dané kolekce s tím, že začne od první položky a skončí u poslední: for ridici_promenna in kolekce: blok příkazů V následujícím příkladě si nejrpve vytvoříme kolekci a potom vypíšeme všechny její prvky (vytvoření kolekce zatím nevěnujte přílišnou pozornost, o tom jak správně kolekci vytvořit si povíme později): kolekce = (“mama” “mele” “maso”) for text in kolekce: print text

Tento kód na tři řádky vypíše postupně „mama“, „mele“ a „maso“, což jsou tři prvky kolekce. Pokud chceme použít forcyklus na čísla (takto se používa v klasických programovacích jazycích), tedy chceme například aby řídící proměnná měla hodnoty od nějakého čísla x do nějakého čísla y, můžeme v Pythonu použít funkci range(from,to), která vrátí kolekci čísel od čísla from až po číslo to-1. Proto tento kód vypíše čísla od 1 do 10: for i in range(1,11): print i

Psaní vlastních funkcí Nyní již umíte napsat prakticky libovolně složitý program (ano, s použitím cyklu while a podmíněného příkazu lze napsat opravdu libovolně složitý program). V dlouhých programech se ale často stane, že některé části kódu potřebujeme velice často. Typickém příkladem je například čtení z klávesnice, které pro nás dělá funkce input, nebo psaní na obrazovku, o které se stará funkce print. V této kapitole se naučíte jak si napsat vlastní funkce, která pak můžete ve svých programech používat a ušetřit si tak psaní. Nejdříve si zopakujeme, co každá funkce musí mít: Každá funkce musí samozřejmě mít svůj název. Použitím jejího názvu řekneme Pythonu jako funkci má zavolat. Funkce také má seznam parametrů, který může být i prázdný. A funkce také může vracet nějaký vysledek (jsou však funkce, které žádný výsledek nevracejí, například funkce print9, protože jen tiskne na obrazovku). Funkce samozřejmě musí mít nějaký kód, který provádí její vlastní činnost. Pokud chceme definovat novou funkci, musíme všechny tyto vlastnostu správně definovat. Představte si například funkci, která nám vrátí maximum ze dvou čísel. Tato funkce (říkejme jí maxOfTwo) bude mít tedy dva parametry, čísla x a y. Funkce bude mít také jednu návratovou hodnotu, také číslo které se bude rovnat většímu z čísel x a y. Funkci definujeme s pomocí klíčového slova def následovaného názvem funkce a seznamu parametrů v kukatých závorkách. Pokud je seznam parametrů prázdný, musíme uvést prázdné závorky (). Celá hlavička funkce končí dvojtečkou, po níž následuje blok kódu funkce. Pokud funkce vrací nějakou hodnotu, je na konci těla funkce uvedeno klíčové slovo return s hodnotou, které se má vrátit. Pokud Python dojde k provedení příkazu return uprostřed kódu funkce, provádění funkce zastaví a vrátí aktuální hodnotu. Příkazu return tak můžeme úspěšně použít k předčasnému návratu z funkce. Každá funkce by měla mít krátký komentář, který by měl stručně a jasně vyjádřit, k čemu daná funkce slouží. Ke komentování funkcí se používá speciální konstrukce – trojité uvozovky: Pokud je první řádka těla funkce text ohraničený třemi uvozovkami po sobě, bere se tento text jako nápověda k funkci. Jak se můžete dočíst v předchozí kapitole, Komodo umí tuto nápovědu k funkcím zobrazovat a ulehčovat vám tak psaní programů. Zavolání funkce probíhá zapsáním jejího jména a uvedením parametrů v závorkách. Pokud se jedná o funkci bez parametrů, musíme opět uvést prázdné závorky za jménem funkce (Python tak pozná, zda se jedná o funkci, nebo o proměnnou, která závorky nikdy nemá). 1 def maxOfTwo(x,y): 2 """Tato funkce vrati maximum ze dvou parametru x a y. 3 Vsimnete si, ze trojuvozovky mohou byt roztazeny pres 4 vice radku, je-li to treba.""" 5 if (x
9 10 11 12

x=input("Zadejte cislo 1:") y=input("Zadejte cislo 2:") max=maxOfTwo(x,y) print "Maximum z techto cisel je", max

Definice funkce začíná klíčovým slovem def, následovaným názvem funkce, seznamem parametrů, dvojtečkou a blokem kódu funkce. Funkce může být předčasně ukončena příkazem return, který také můžeme použít ke specifikaci návratové hodnoty funkce. Definice této funkce také ukazuje další z klasických programovacích struktur. Podívejte se pořádně na její tělo, zde je podmínka která zjišťuje jestli je x menší než y. Pokud je x menší, tak je jasné, že y je maximem. Na řádku 6 v těle podmínky tedy zavoláme příkaz return y, který vrátí y a ukončí předčasně funkci (tedy řádek 7 se již neprovede). Pokud naopak není pravda, že x je menší, pak to x musí být maximem (nebo jsou oba dva prvky stejně velké, a pak je jedno který z nich vrátíme). Řádek 7 proto již jen vrátí hodnotu x. Řádek 7 by mohl být else větví podmínky, ale protože jsou možné jen dve hodnoty a kladná větev podmínky zároveň ukončuje funkci můžeme else vynechat. Pokud by ale kladná větev funkci neukončila (místo návratové hodnoty bychom ji třeba jen vytiskli) nemůžeme již tuto konstrukci použít (pro x menší než y by došlo k vypsání obou dvou řádků). Připomeňme ještě, že ukončit funkci bez návratové hodnoty můžeme vždy použitím příkazu return bez specfikované návratové hodnoty. První řádek, který se spustí bude řádek 9, protože funkce je v jiném bloku (jiné odsazení), a pouze v rámci jednotlivých bloků platí, že příkazy jsou prováděny sekvenčně odshora dolů.

Klíčová slova Jistě vás zaujalo, proč jsou v ukázkách kódu vždy některá slova vysazena tučně. A možná jste si také všimli, že občaš v textu použijeme pojem klíčové slovo. Klíčová slova (česky také vyhrazená slova) jsou takové názvy, které nesmí být nikdu uživatelem změněny, ani použity pro jiný element. Vezměte si například funkci raw_input(). Jedná se o obyčejnou funkci a proto klidně můžete napsat funkci vlastní, která se bude jmenovat úplně stejně. Tím si sice znemožníte použití té staré, protože při napsání jejího jména bude Python automaticky předpokládat, že chcete volat vaši funkci, ale důležité je, že tuto funkci tzv. předefinovat můžete. O klíčových slovech toto neplatí. Nikdy nemůžete předefinovat klíčové slovo. Klíčová slova se totiž vždy chovají stejně a většinou představují ty uplně nejzákladnější vlastnosti jazyka. Dosud jste se setkali s následujícími klíčovými slovy: print, if, else, while, def, return Klíčových slov je však mnohem více a jak budete touto knížkou postupovat dále, jejich seznam si ještě o dost rozšíříme.

Otázky a úkoly Když jste dočetli až sem, je čas vrátit se k předcházející kapitole a dočíst si informace o užitečných vlastnostech Komoda. Až je budete znát, můžete se vrhnout na následující otázky:

Složitější datové typy I když už s Pythonem umíme docela dost věcí, stále nás ještě ta větší část čeká. To, co jsme zatím dělali s Pythonem by se moc nelišilo od stejných programů v jiných jazycích. Hlavní výhoda Pythonu a vyšších programovacích jazyků obecně spočívá v tom, že vedle jednoduchých datových typů (zatím známe celá čísla, reálná čísla a logické hodnoty) existuje spousta dalších, mnohem složitějších a inteligentnějších, takových, které většinu práce udělají za vás. V téhle kapitole se podíváme na některé složitější datové typy a ukážeme si, jak moc nám ulehčí práci. Když se budete učit pracovat s komplexními datovými typy, je důležité mít na paměti jednu věc – pořád pracujete na počítači, který kromě zpracování proudu čísel, sčítání, odčítání a násobení (a pár dalších ne tak zajímavých věcí) neumí nic. O žádném z těchto vyšších typů nemá ani tušení. To, že je můžete jednoduše z Pythonu používat, je možné jen díky opravdu složitému interpretu jazyka Python, tedy programu, který pro vás napsal někdo jiný.

String I když jsme si string uvedli v předchozí kapitole jako jeden ze základních typů, možná vás už tehdy napadlo, že tak základní asi nebude. Se stringy můžeme dělat spoustu věcí, sčítat je, násobit, zobrazovat a mnoho dalšího, prostě věcí obecně mnohem složitějších, než sečíst dvě čísla. To není jen tak náhodou, string v Pythonu je opravdu hodně složitý datový typ (to jak moc složitý je se přesně dozvíte ještě o něco později) a protože jeho pochopení je lidem tak nějak nejbližší, začneme s ním: String, jinak také řetězec není nic jiného, než nějaká posloupnost písmen10. Jak už víte, uložit do nějaké proměnné string není nijak těžké. Stačí hodnotu (literál) stringu zapsat do uvozovek a přiřadit ho názvu proměnné: text=”Tohle je takovy maly text”

Kromě zřetězování stringů pomocí operace plus, jak už známe umí string ještě spoustu zajímavých věcí. Každý string má metody, tedy své vlastní funkce, které nám umožní konkrétní řetězec specielně upravit. Ty nejzákladnější jsou: ●

upper, která vrátí řetězec stejný jako původní, akorát všechna písmena převede na velká

●

lower, která naopak vrátí řetězec kde jsou všechna písmena převedena na malá

●

find(substr), užitečná funkce, která zkusí najít v řetězci podřetězec substr a vrátit index jeho začátku (k indexu se ještě dostaneme).

Všechny tyto metody se dají použít tak, že je napíšeme za název proměnné typu string a oddělíme je tečkou: 10 String je také v počítači reprezentován jako posloupnost písmen (písmeno je jednoduchý datový typ). Abychom byli úplně přesní, písmeno je reprezentováno svým kódem, tedy číslem od 0 do 255 v ASCII.

text=”Vsichni radi jedi banany.” # jedna se opravdu o volani funkce, proto jsou nutne treba I prazdne zavorky print text.upper() # vytiskne: VSICHNI RADI JEDI BANANY. print text.lower() # vytiskne: vsichni radi jedi banany. print text.find(“ich”) # vytiskne 2 print text.find(“bin”) # vytiskne -1, protoze bin neni v nasem retezci

Pokud chceme zjistit délku řetězce, tedy počet písmen, použijeme k tomu funkci len() (tohle je funkce, nikoli metoda, proto se volá následujícím způsobem jako obyčejná funkce): text=”Hello!” print len(text) # vytiskne 6

Indexace stringu a string jako kolekce Co je však na stringu nejzajímavější je jeho indexování. Řekli jsme, že string je posloupnost písmen, není problém se na něj tedy dívat jako na seznam písmen, kde každé písmeno má svoji přesnou pozici. První písmeno má pozici nula, druhé pozici jedna a poslední pozici délka-1. Pokud chceme, můžeme se řetězce zeptat, jaké písmeno má na dané pozici, kde pozici specifikujeme jako číslo v hranatých závorkách, jak je uvedeno v následujícím příkladu: text=”Hello” print text[1] # vytiskne “e”

Indexování se velice hodí například tehdy, když potřebujeme řetězec zpracovat znak po znaku. Třeba následující příklad spočítá, kolik je v řetězci znaků „a“: text=”nejneobhospodarovavatelnejsi” i=0 pocet=0 while (i
Teď si zkuste vzpomenout na důležitou věc, string je posloupnost písmen. A tato písmena jdou samozřejmě za sebou v přesně daném pořadí (podle toho, kdy se objevují v daném řetězci) – pokud si ale vzpomenete ještě dál, tohle je přece přesně to, co chceme po kolekci. String by tedy mohl být kolekcí písmen! A taky že je, string je první a velice důležitá kolekce, se kterou se v Pythonu seznámíte. Když tedy víme, že string je kolekce, je třeba si vzpomenout na forcyklus. Pamatujete? Takže teď už byste měli tušit, že těžkopádný příklad nahoře jde v Pythonu napsat s elegancí jemu vlastní asi (přesně) takhle: text=”nejneobhospodarovavatelnejsi” pocet=0 for pismeno in text: if (pismeno==”a”): pocet=pocet+1 print pocet

Indexování v Pythonu je ale ještě šikovnější. Představte si, že chcete třeba z nějakého řetězce vzít jen určitou jeho část a uložit si ji do jiné proměnné. Čistě teoreticky by to šlo samozřejmě udělat pomocí nějakého cyklu a procházení po písmenkách a skládání nového řetězce po písmenkách, Python ale nabízí opět elegantnější řešení – totiž indexaci rozsahů (vzpomínejte na Ooo Calc a rozsahy ve funkcích... Skoro úpně stejně se rozsah definuje i v Pythonu, tedy index první položky rozsahu, za ním dvojtečka a nakonec index poslední položky rozsahu plus jedna. Pokud vynecháte číslo před dvojtečkou (první index) bude se brát začátek rozsahu jako začátek původního řetězce, pokud vynecháte číslo za dvojtečkou, bude se brát jako konec rozsahu konec řetězce. V obou těchto případech ale musíte dvojtečku napsat, jinak by Python nevěděl, že se jedná o definici rozsahu. Rozsah opět uvedete do indexových hranatých závorek. A jako výsledkem

jednoduchého indexu bylo dané písmeno, výsledkem indexu rozsahu je jiný řetězec, konkrétně podřetězec původního řetězce: text=”Ahoj lidi!” print text[0:2] # print text[2:7] # print text[:3] # print text[4:] #

vytiskne vytiskne vytiskne vytiskne

“Ah” “oj l” “Aho” “ lidi!”

Python jde ale ještě dál a umožňuje vám zadat i záporné indexy. Protože kladné indexy udávají pozici písmena v seznamu směrem zleva (od začátku), záporné indexy udávají indexy směrem zprava (tedy od konce). Index -1 je tedy poslední položka, -2 je předposlední, atd... Pro string jako pro kolekci platí ale jedno významné omezení. Jednotlivá písmenka, tedy položky kolekce můžete číst, nesmíte je ale zapisovat (tedy nesmíte je měnit). Naštěstí, pokud chceme změnit jedno písmenko, můžeme to udělat velice jednoduše za použití rozsahů: Dejme tomu, že v proměnné text chceme změnit písmenko na páté pozici (tedy šesté v řadě) tak, aby bylo „A“. Uděláme to následujícím způsobem: text=”Uz tam skoro budem” text=text[:5]+”A”+text[6:] print text # vytiskne “Uz taA skoro budem”

Tuple Kolekce písmenek jako je třeba string se určitě hodí. Ale určitě si dokážete představit, že kolekcí bychom mohli chtít mnohem víc. Třeba kolekci čísel, nebo klidně i kolekci řetězců. Byla by škoda, kdyby nám Python neuměl pomoci. Datový typ, který potřebujeme se nazývá tuple a jedná se o kolekci úplně čehokoli.

Rekurze a vnořování

Objekty a Třídy

Základní Algoritmy