U Cebnice Jazyka Python (Aneb Létající Cirkus) : Release 2.2

U ebnice jazyka Python c (aneb Ltajc cirkus)
Release 2.2
Jan vec
16. prosince 2002
PyCZ Email: honza@py.cz
Copyright c 2002 Jan vec honza@py.cz. Vechna prva vyhrazena Viz konec dokumentu, kde najdete kompletn informace o podmnkch uvn tohoto dokumentu.
Peklad z originlnho anglickho dokumentu "Python Tutorial" autor Guida van Rossuma a Freda L. Drakea. Origr u inln copyright: Copyright c 2001 Python Software Foundation. All rights reserved. Copyright c 2000 BeOpen.com. All rights reserved. Copyright c 1995-2000 Corporation for National Research Initiatives. All rights reserved. Copyright c 1991-1995 Stichting Mathematisch Centrum. All rights reserved.
Abstrakt Python je vysoce vkonn programovac jazyk pouvajc efektivn vysokorov ov datov typy, pi em jednodue a n rc elegantn e otzku objektov orientovanho programovn. Jeho syntaxe a dynamick typy spolu s interpretovnm er e kdu dotv pov st idelnho nstroje pro psan skript a rychl vvoj aplikac (Rapid Application Development, r e u RAD). Samotn interpretr jazyka je spustiteln na velkm mnostv platforem v etn Linuxu, Windows, MacOS a c e DOS. Zdrojov kdy interpretru Pythonu a standardnch knihoven jsou voln ke staen z domovsk strnky Pythonu e (http://www.python.org/) a je mon je dle voln modikovat a distribuovat. Na tto strnce tak najdete pedkome r pilovan instala n bal ky pro v tinu podporovanch platforem a nechyb ani mnostv odkaz na dal moduly, c c e u programy a nstroje ur en uivatel m Pythonu. c u Prosted jazyka je snadno roziiteln pomoc funkc a datovch typ napsanch v jazycch C nebo C++. Python lze r r u tak pout jako skriptovac jazyk pro aplikace v jinch jazycch. Tato u ebnice jazyka Python vs zasv t do logiky jazyka a jeho zkladnch vlastnost. Rovn se dozvte vce o c e e b hovm systmu, pi em je ideln mt tento systm pmo nainstalovan na vaem systmu a veker pklady si e rc r r zkouet pmo v n m. Kad ukzka je ale psna s ohledem na nzornost, proto by m la bt snadno pochopiteln i pro r e e za te nka, kter nem pmo monost si ji hned vyzkouet. c c r Pro podrobn j popis standardnch objekt a modul nahldn te do dokumentu "Python Library Reference", zatmco e u u e v dokumentu "Python Reference Manual" naleznete formln denici jazyka (vechny zde uvd n dokumenty jsou e sou st distribu nho bal ku zdrojovch kd ). T m, kte potebuj Python roziovat o sv vlastn dopl ky v jazyc c c u e r r r n cch C nebo C++, se budou hodit dokumenty "Extending and Embedding the Python Interpretr" a "Python/C API Reference". Tyto dokumenty m ete zrove najt na strnkch http://www.python.org. u n Tato publikace se nesna bt vy erpvajc, vysv tluje pouze nejzkladn j vlastnosti jazyka Python. S jej pomoc c e e si ale m ete vytvoit pedstavu o tom, jak samotn jazyk vypad. Po jejm pe ten dokete pochopit strukturu ji u r r r c existujcho kdu. Zrove se nau te potebn zklady pro psan novch program v jazyce Python. Po zvldnut tto n c r u u ebnice m ete pokra ovat studovnm dokumentace k mnoha modul m popsanch dokumentem "Python Library c u c u Reference".
OBSAH
1 2
Pro pouvat zrovna Python? c 1.1 Obsah tto u ebnice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . c Pouvme interpretr jazyka Python 2.1 Sput n b hovho systmu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . e e 2.2 B hov prosted jazyka Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . e r vod do jazyka Python 3.1 Python jako kalkultor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.2 Prvn kroky . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . P kazy pro rzen toku programu r 4.1 Konstrukce if . . . . . . . . . . . . . . . . . . . . . . . 4.2 Konstrukce for . . . . . . . . . . . . . . . . . . . . . . 4.3 Funkce range() . . . . . . . . . . . . . . . . . . . . . 4.4 Podmnky . . . . . . . . . . . . . . . . . . . . . . . . . 4.5 Pkazy break a continue a v tev else pkazu for r e r 4.6 Pkaz pass . . . . . . . . . . . . . . . . . . . . . . . . r 4.7 Denovn funkce . . . . . . . . . . . . . . . . . . . . . 4.8 Dal monosti pi denici funkce . . . . . . . . . . . . . r Datov struktury 5.1 Seznamy . . . . . . . . . . . . . . 5.2 Pkaz del . . . . . . . . . . . . . r 5.3 Tuple a sekvence . . . . . . . . . . 5.4 Slovnky . . . . . . . . . . . . . . 5.5 Porovnvn sekvenc a dalch typ u Moduly 6.1 Pouvme moduly . . 6.2 Standardn moduly . . . 6.3 Funkce dir() . . . . 6.4 Bal ky . . . . . . . . . c . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1 2 3 3 4 7 7 17 19 19 20 20 21 22 22 22 24 31 31 35 36 37 37 39 40 42 43 44 49 49 52 57 57
. . . .
Vstup a vstup 7.1 Formtovn vstupu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.2 Prce se soubory . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Chyby a vjimky 8.1 Syntaktick chyby . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8.2 8.3 8.4 8.5 8.6 9
Vjimky . . . . . . . . . . . . Obsluhovn vjimek . . . . . Vyvoln vjimek . . . . . . . Vjimky denovan uivatelem Denovn clean-up akci . . . . . . . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . .
57 58 60 61 62 65 65 66 68 72 73 75 76 79 81 81 81 81 85 87 89 89 89 90
T dy r 9.1 Pouit terminologiie . . . 9.2 Prostory jmen . . . . . . . 9.3 Tdy poprv ... . . . . . . . r 9.4 Tdy podruh ... . . . . . . r 9.5 Tdy potet (D di nost) ... r r e c 9.6 Pseudo-soukrom atributy . 9.7 Poznmky . . . . . . . . .
10 Co nyn? A Interaktivn pravy p kazovho rdku a historie p kazu r r A.1 pravy pkazovho dku . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . r r A.2 Historie pkaz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . r u A.3 Klvesov zkratky . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . B Artitmetika v plovouc rdov crce: Problmy a jejich nprava B.1 Chyby v reprezentaci csel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . C Licence C.1 Historie Pythonu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . C.2 Pod kovn ... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . e C.3 Licence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
ii
KAPITOLA
PRVN
Pro pouvat zrovna Python? c

Jestlie jste ji n kdy napsali opravdu velk shellovsk skript, jist znte tuto situaci: chcete do programu pidat e e r n jakou novou funkci, ale ten je ji pli pomal, rozshl a komplikovan, ppadn tato nov vlastnost vyaduje e r r e volat jinou funkci, kter je pstupn pouze z jazyka C . . . Oby ejn tento problm nen natolik podstatn, abyste se r c e rozhodli cel skript pepsal do C, teba pouvte et zce prom nn dlky nebo dal vysokorov ov datov typy r r r e e n (jako teba seznamy nebo asociativn pole), je m ete snadno pouvat v shellu ale ji ne v C. Jist , vechny tyto typy r u e lze implementovat v C, ale zabralo by to pravd podobn mnoho casu a nejsp si na to ani netroufte. e e Stejn tak jin situace: pracujete na projektu, kter pouv mnostv C knihoven a cyklus napi/zkompiluj/otestuj je e ji pli zdlouhav. Vy ale potebujete prav opak - rychl a efektivn vvoj. Teba dokonce chcete napsat program, r r r kter bude pouvat skriptovac jazyk, ale nechcete navrhovat a ladit vlastn interpretr. V t chto ppadech je prv Python vhodnm jazykem pro vs. Lze se jej velice snadno nau it (mluv se o n kolika e r e c e mlo dnech pro zskn zkladnch znalost), pesto se jedn o skute n programovac jazyk nabzejc mnoho typ a r c u struktur. Nechaj se v n m napsat opravdu velk a rozshl projekty. Tak je vce odoln proti chybm programtora e ne oby ejn C, pi em t ze vech vhod vysokorov ovho jazyka, m vestav n vysokorov ov datov typy c rc e n e n jako seznamy nebo asociativn pole, dky cemu uette mnoho casu, kter byste jinak v novali jejich implementovn r e v C. Kv li t mto obecn jm datovm typ m je Python vhodn j pro mnohem vce problm ne jazyky Awk nebo u e e u e u Perl, mnoho kol se za pouit Pythonu e dokonce snadn ji ne v t chto jazycch. u r e e Python umo uje rozd lit vae programy do samostatnch modul , kter mohou bt snadno pouity i v jinch pron e u gramech a projektech. Ji zkladn distribuce Pythonu obsahuje velk mnostv standardnch modul , kter m ete u u pout jako zklad vaich program , ppadn se z nich m ete piu it hodn b n programtorskch obrat . Mezi u r e u r c e e e u nimi najdete tak moduly pro prci se soubory, systmovmi volnmi, sokety a tak moduly slouc jako rozhran ke grackmu uivatelskmu rozhran Tk. Python je interpretovan jazyk, cm programtorovi et mnostv casu. Ji dn kompilovn a linkovn pror gram . Interpretr m e bt pouit interaktivn , co vm umon snadn experimentovn s jazykem samotnm stejn u u e e jako s jednotlivmi moduly. Jednodue takto lze testovat tak vae uivatelsk funkce a tdy. S trochou zru nosti je r c pouiteln i jako vkonn kalkultor obohacen o mnoho matematickch funkc. Programy v Pythonu jsou velice kompaktn a snadno pochopiteln. Zrove jsou typicky mnohem krat ne ekvivan lentn kd implementovan v C nebo C++ a to z mnoha d vod : u u vysokorov ov datov typy umo ujc rychl a komplexn operace v jedinm vrazu; n n seskupovn vraz se d je pomoc odsazen narozdl od pouvn otevrac a uzavrac sloen zvorky v C a u e C++; nen nutn deklarovat prom nn a argumenty funkc, jazyk dokonce nerozliuje ani jejich typ; e Python je roziiteln: umte-li programovat v jazyce C pak pro vs bude hra kou pidvn novch internch funkc r c r nebo modul pro zajit n maximln rychlosti casov nro nch operac, ppadn takto m ete interpretovanmu u e e c r e u kdu zajistit pstup ke knihovnm, kter jsou distribuovan pouze v binrn form (nap. knihovny od vrobc hardr e r u
ware apod.). M ete tak pilinkovat interpretr k va aplikaci napsan v C a naplno tak vyut potencilu tohoto u r jazyka, kter je jako stvoen pro lohu idelnho skriptovacho jazyka. r Jazyk Python je pojmenovan podle poadu spole nosti BBC "Monty Pythons Flying Circus" a jeho nzev tedy nem r c nic spole nho s hady.1 Guido van Rossum je vnivm fanoukem tohoto poadu a pi prci s Pythonem se doslova c r r na kadm rohu setkte s proprietami majcmi sv j p vod v tomto poadu. u u r
1.1
Obsah tto u ebnice c
Jestlie jste do etli a sem, jist jste ji poznali, e Python nen jen jednm z rady interpretovanch jazyk . Chcete c e u poznat tento skv l jazyk vce do hloubky? Pak pravd podobn nejlep cestou, jak se ho nau it, je pe ten tto e e e c r c u ebnice spolu s jeho pouvnm. c V dal kapitole tto u ebnice ji zskte zkladn znalosti pro ovldn samotnho interpretru - b hovho prosted c e r jazyka. Tato kapitola se pohybuje spe v teoretick rovin , ale po jejm pe ten ji budete pipraveni za t s jazykem e r c r c pracovat naplno. Zbytek u ebnice na jednoduchch pkladech ukazuje, jak pouvat jazyk co nejefektivn ji, pi em vysv tluje i c r e rc e nezbytn nutnou teorii jako jsou jednoduch vrazy, pkazy a datov typy, pot budou nsledovat vklad funkc a e r modul a nakonec nastnme problematiku pokro ilejch vlastnost jazyka jako jsou vjimky a tdy v etn impleu c r c e mentace objektov orientovanho programovn v jazyce Python. e
1 "Python"
v angli tin znamen hrozn c e
Kapitola 1. Pro pouvat zrovna Python? c
KAPITOLA
DRUH
Pouvme interpretr jazyka Python

2.1 Sputen behovho systmu
Interpretr jazyka Python je v tinou nainstalovn jako soubor /usr/local/bin/python. Mte-li zaazen adres e r r /usr/local/bin do cesty, v n shell vyhledv spustiteln soubory, m ete prosted jazyka spustit pmo zapsnm u r r pkazu r
python
Jmno adrese, v n m je Python nainstalovn, je zvisl na volbch nastavench pi jeho pekladu, proto je mon, r e r r e ve vaem systmu tomu bude jinak. Vce informac vm jist sd l sprvce vaeho systmu. e e Pro ukon en interpretru stiskn te znak konce souboru (EOF, Control-D v systmu U NIX, Control-Z v sysc e tmech Dos a Windows). V tomto ppad ped prosted jazyka shellu nvratovou hodnotu 0. Nelze-li interpretr r e r r takto opustit, lze pout nsledujc pkaz: import sys; sys.exit(). r Editovn pkazovho dku v interpretru jazyka Python nen pli pohodln. Proto lze interpretr v U NIXovm r r r prosted zkompilovat s podporou knihovny GNU Readline, kter zpstupn historii pkaz i dopl ovn jmen r r r u n pkaz a prom nnch. Velice rychl zp sob, jak zjistit, zda v interpretr podporuje tuto knihovnu, je zapsn r u e u znaku Control-P po prvn vzv , kterou dostanete po sput n Pythonu. Jestlie se ozve ppnut, m interpretr e e pravd podobn podporu knihovny Readline zakompilovnu. Jestlie se objev znaky ^P, pak nejsou rozen pravy e e r pkazovho dku podporovny a vy m ete pouvat pouze klvesu Backspace pro smazn pedchozho znaku. r r u r Pro dal informace o konguraci sou innosti interpretru a knihovny GNU Readline se podvejte do Dodatku A. c Interpretr pracuje podobn jako shell systmu U NIX: kdy je sput n a jeho standardn vstup je spojen s terminlovm e e zazenm, na t a spout pkazy interaktivn . Je-li mu pi sput n pedno jako argument jmno souboru, ppadn r c r e r e r r e je standardn vstup pesm rovn z n jakho souboru, cte a spout pkazy pmo z tohoto souboru - skriptu. r e e r r Tet zp sob, jak lze provst libovoln kd jazyka Python, je sput n pkazu python -c pkazy [argumenty] r u e r r ..., jen rovnou vykon pkazy. Jde o obdobu stejnojmenn volby unixovho shellu. Jeliko pkazy jazyka Python r r casto obsahuj mezery nebo jin speciln znaky mus se uvodit nejlpe dvojitmi uvozovkami, aby se zabrnilo jejich interpretovn shellem. Pamatujte, e je rozdl mezi sput nm pkazu python soubor a python < soubor. V ppad prvnm se e r r e nejprve na te a zkontroluje cel soubor, na ppadn chyby v syntaxi se tud pijde ihned, jet ped sput nm prvnho c r r e r e pkazu. Ve druhm ppad se na taj pkazy jeden po druhm, nsledn jsou kontrolovny a spout ny, je-li n kter r r e c r e e e pkaz syntakticky chybn , zjist se to a t sn ped jeho sput nm. Pozornost je teba tak v novat pkaz m, kter r e e e r e r e r u ctou vstup od uivatele, pesm rovn standardnho vstupu toti plat i pro n a ty tud (necht n ) na tou nsledujc r e e e e c kd programu. Velice castm poadavkem je po vykonn skriptu spustit interaktivn md a tm pdem pedat zen programu uir r vateli, ceho lze s vhodou vyut pi lad n program apod. To zajist volba -i pedan pkazu python (tato volba r e u r r
nefunguje sprvn v ppad pesm rovanho standardnho vstupu). e r e r e
2.1.1
Pedvn argumentu r
Jmno skriptu a dal argumenty pedan z pkazovho rdku jsou uloeny v prom nn sys.argv. Jedn se o r r e seznam et zc obsahujc minimln jeden prvek - jmno skriptu. Pouze je-li aktivn interaktivn md, pak je prvek r e u e sys.argv[0] roven przdnmu et zce. Jde-li o skript cten ze standardnho vstupu, je sys.argv[0] nastaven na r e hodnotu -. Pi pouit volby -c pkazy odpovd nult prvek seznamu sys.argv hodnot -c. Zde je d leit r r e u podotknout, e vechny argumenty pedan za -c pkazy ji nejsou interpretrem zpracovny, dojde pouze k jejich r r uloen do seznamu sys.argv.
2.1.2
Interaktivn md
Jsou-li pkazy cteny z terminlu, rkme, e interpretr je v interaktivnm mdu. V tomto mdu se nejprve zobraz r uvtac zprva obsahujc informace o verzi a autorskch prvech. Nsledn b hov prosted vytiskne primrn vzvu e e r (v tinou >>> ) a cek na zadn pkazu. Pro vstup sloit jch pkaz rozloench pes vce dk se pouv i e r e r u r r u sekundrn vzva (implicitn ... ). e
python Python 1.5.2b2 (#1, Feb 28 1999, 00:02:06) [GCC 2.8.1] on sunos5 Copyright 1991-1995 Stichting Mathematisch Centrum, Amsterdam >>>
Typickm pkladem vcedkovho pkazu jsou konstrukce pro zen toku programu. Jako pklad si uvedeme konr r r r r strukci if:
>>> zeme_je_placka = 1 >>> if zeme_je_placka: ... print "Bacha, at z n nespadnete!" ... Bacha, at z n nespadnete!
2.2
2.2.1
Behov prosted jazyka Python r

Obsluha chyb
Pi vskytu chyby vytiskne interpretr chybovou zprvu obsahujc vpis volanch funkc a popis chyby samotn. r Dojde-li k chyb v interaktivnm mdu, vrt se zen zp t k primrn vzv , pi vzniku chyby ve skriptu se nejprve e r e e r vytiskne hlen o chyb a pot se skript ukon s nenulovm nvratovm kdem (v tomto ppad nejsou vjimky e c r e obslouen v tv except pkazu try brny jako chyby). Vechna chybov hlen jsou vypisovna na standardn e r chybov vstup, cm se zabrn pomchn chybovch vpis s vstupem samotnho programu (ten je vypisovn na u e standardn vstup). Fatln chyby jako vnitn nekonzistence datovch struktur ci n kter ppady vy erpn pam ti r r c e m ou zp sobit rovnou ukon en interpretru s nenulovm nvratovm kdem. u u c Stisk kombinace Control-C (ppadn DEL) vyvol peruen. To v interaktivnm mdu zp sob okamit nvrat k r e r u primrn vzv . 1 Peruen vznikl za b hu pkazu ho ukon a vyvol vjimku KeyboardInterrupt, kterou lze e r e r c
1 Chybn e
nakongurovan knihovna GNU Readline m e tento stisk odchytit, k peruen pak nedojde u r
Kapitola 2. Pouvme interpretr jazyka Python
odchytit obvyklm zp sobem pkazem try. 2 u r
2.2.2
Spustiteln skripty
Na BSD kompatibilnch systmech U NIX m ete libovoln skript jazyka Python u init spustitelnm souborem uveu c denm tto "magick" sekvence na za tku souboru: c
#!/usr/bin/env python
(Stejn postup jist znaj ti, kte p skriptu unixovho shellu.) e r Pokud m skript nastaven executable bit (viz. pkaz chmod(1), vce informac v manulovch strnkch) a spustiteln r soubor interpretru se nachz v uivatelov implicitn cest (tj. cest , kde shell vyhledv spustiteln soubory a pkazy, e e e r ur uje j prom nn prosted PATH), lze tento skript spustit pmo z pkazov dky shellu. Je d leit, aby znaky c e r r r r u #! byly prvn dva znaky celho souboru. Vimn te si, e znak # je v Pythonu pouit jako za tek komente, tud e c r sekvence #! je interpretrem povaovna za oby ejn koment. c r
2.2.3
Soubory na tan pi startu interpretru c r
Pouvte-li Python interaktivn , casto potebujete spout t n kter pkazy pi kadm startu prosted. To lze e r e e r r r snadno zajistit nastavenm prom nn prosted PYTHONSTARTUP tak, aby ukazovala na jmno souboru obsahue r jcho poadovan pkazy. Tento soubor je obdobou souboru .prole v unixovch shellech. r Podobn jako .prole je i tento soubor cten pouze v ppad interaktivnho sezen, pi spout n skript se neue r e r e u platn! Vechny pkazu na tan na za tku interaktivnho sezen jsou spout ny ve stejnm prostoru jmen, ve kterm r c c e nsledn budou interaktivn spout ny pkazy. Tud ty objekty, kter tyto pkazy denuj (nebo importuj) lze poue e e r r vat pmo v pkazech, kter spoutme v interaktivnm mdu. V ppad poteby m ete v tomto souboru nastavit i r r r e r u vzvy interpretru (primrn vzvu reprezentuje prom nn sys.ps1, sekundrn sys.ps2). e Pokud potebujete na tat i soubor, kter je uloen v pracovnm adresi (pro nastaven r znch voleb pro r zn r c r u u projekty apod.), muste v hlavnm souboru, na n j ukazuje prom nn PYTHONSTARTUP, zapsat pkazy na zp sob: e e r u
if os.path.isfile(.pythonrc.py): execfile(.pythonrc.py)
Pejete-li si na tat soubor uveden v prom nn PYTHONSTARTUP i v ppad skript , muste tento soubor spustit r c e r e u sami. To u in tyto pkazy uveden na za tku skriptu: c r c
import os filename = os.environ.get(PYTHONSTARTUP) if filename and os.path.isfile(filename): execfile(filename)
2 Vce
o vjimkch viz. kapitola 8.
2.2. Behov prosted jazyka Python r
KAPITOLA
TRET
vod do jazyka Python

Ve vech pkladech v tto knize, kter uvd j ukzky vzorovho sezen je vstup pro interpretr ozna en uvedenm r e c vzvy (primrn >>> a sekundrn ... ). Vstup z programu je uvd n na samotnm dku pesn tak, jak e r r e jej pkaz print vytiskl. Sekundrn vzva uveden na samostatnm dku znamen przdn dek a je pouita k r r r ukon en vcedkovho pkazu. c r r Mnoho pklad v tto publikaci, pestoe jsou ur eny pro zpis v interaktivnm mdu, obsahuje komente. Kad r u r c r koment v jazyce Python za n znakem kek # a pokra uje do konce fyzickho dku. Koment se m e obr c r c r r u jevit jak na za tku dky, tak m e nsledovat po "blch znacch" 1 nebo kdu. Znak # uveden uvnit et zce c r u rr e neznamen koment, je povaovn za znak et zce: r r e
# toto je prvn koment r SPAM = 1 # a toto je druh koment r # ... a nyn tet! r STRING = # Toto nen koment. r
3.1 Python jako kalkultor

Nyn si vyzkoume n kolik jednoduchch pkaz jazyka Python. Spustte si interpretr a po kejte na zobrazen e r u c primrn vzvy >>> .
3.1.1
Csla
Interpretr se chov jako jednoduch kalkultor. M ete zapsat libovoln vraz a on vype jeho hodnotu. Zpis vraz u u je jednoduch: opertory +, -, * a / funguj stejn jako v jinch jazycch (napklad Pascal nebo C), rovn m ete e r e u pouvat zvorky pro zm nu priority vraz . Napklad: e u r
1 Tzv.
bl znaky jsou vechny znaky, kter reprezentuj bl msta v textu, cili mezery, tabultory, konce dk apod. r u
>>> 4 >>> ... 4 >>> 4 >>> 5 >>> ... 2 >>> -3
2+2 # Toto je koment r 2+2 2+2 # a toto je koment na stejnm dku jako kd r r
(50-5*6)/4 # Dlen celch sel vrt cel slo: e c c 7/3 7/-3
Stejn jako v C je znak rovntko (=) ur en pro piazen hodnoty prom nn. Hodnota prom nn po piazen ji nen e c rr e e rr interaktivnm interpretrem vypsna:
>>> vyska = 20 >>> sirka = 5*9 >>> vyska * sirka 900
Hodnota m e bt piazena i vce prom nnm najednou: u rr e

>>> >>> 0 >>> 0 >>> 0 x = y = z = 0 x y z # Vynuluj x, y a z
Python pln podporuje operace v plovouc rdov crce (tj. desetinn csla). Opertor pracujc s r znmi typy e u operand si nejprve zkonvertuje cel csla na csla v plovouc dov crce a nsledn provede vpo et (obdobn u r e c chovn mon znte z jazyka C):
>>> 3 * 3.75 / 1.5 7.5 >>> 7.0 / 2 3.5
Python tak pln podporuje komplexn csla, pi em imaginrn cslo je zapisovno s pponou j nebo J. Kome rc r plexn csla zapisujeme ve tvaru (Re + Imj) nebo je m eme vytvoit pomoc intern funkce complex(Re, u r Im):
Kapitola 3. vod do jazyka Python
>>> 1j * 1J (-1+0j) >>> 1j * complex(0,1) (-1+0j) >>> 3+1j*3 (3+3j) >>> (3+1j)*3 (9+3j) >>> (1+2j)/(1+1j) (1.5+0.5j)
Komplexn csla jsou vdy reprezentovna dvojic desetinnch csel, relnou a imaginrn cst. Chceme-li zskat velikosti t chto cst csla z, pouijeme zpisu z.real a z.imag: e
>>> z=1.5+0.5j >>> z.real 1.5 >>> z.imag 0.5
Pon vad v matematice neexistuje zp sob, jak pevst komplexn cslo na reln, ani Python nedovoluje pouit kone u r verznch funkc float(), int() a long() s komplexnm argumentem. Rad ji pouijte funkci abs(z) pro zskn e absolutn hodnoty komplexnho csla, nebo zpis z.real reprezentuj relnou cst csla:
>>> a=3.0+4.0j >>> float(a) Traceback (most recent call last): File "<stdin>", line 1, in ? TypeError: cant convert complex to float; use e.g. abs(z) >>> a.real 3.0 >>> a.imag 4.0 >>> abs(a) # sqrt(a.real**2 + a.imag**2) 5.0 >>>
Pokud pouvte Python jako stoln kalkultor, pak se m ete velice snadno vrtit k pedchozmu vsledku ten u r reprezentuje prom nn _, napklad: e r
>>> urok = 12.5 / 100 >>> penize = 100.50 >>> penize * urok 12.5625 >>> penize + _ 113.0625 >>> round(_, 2) 113.06 >>>
Hodnota prom nn _ by nikdy nem la bt modikovna uivatelem. Pokud byste j piadili hodnotu, vytvoili byste e e rr r
3.1. Python jako kalkultor
nezvislou lokln prom nnou se stejnm jmnem, kter by zakryla intern prom nnou s tmto chovnm. e e
3.1.2
Retezce
Podobn jako s csly m ete v Python pracovat i s et zci. Ty mohou bt zapsny mnoha zp soby, pedevm je mon e u r e u r je uvodit jak jednoduchmi, tak i dvojitmi uvozovkami:
>>> houby s voctem houby s voctem >>> rock\n\roll "rocknroll" >>> "rocknroll" "rocknroll" >>> "To je vrada," napsala. "To je vrada," napsala. >>> "\"To je vrada,\" napsala." "To je vrada," napsala. >>> "To je rock\n\roll," ekla. r "To je rock\n\roll," ekla. r
e Mnohdy programtor potebuje ret zec, kter je rozloen pes vce dk . Doshnout toho op t m eme n kolika r r r u e u e zp soby. Prvn z nich, kter se neve pouze na et zce, je spojen dvou po sob jdoucch dk znakem zp tnho u r e e r u e lomtka:
e hello = Toto je dlouh retzec obsahujc mnoho\n\ dek textu, stejn jej zapisujete i v C.\n\ r e "Bl" znaky na zatku dku se samozejm\ c r r e berou v vahu. print hello
Nevhodou tohoto pstupu je nutnost vechny dky ukon it vloenm znak \n. Zp tn lomtko zp sob ignorovn r r c u e u nsledujcho znaku novho dku, et zec tak m e pokra ovat na dalm dku, ani by bylo nutn ho ukon it r r e u c r c uvozovkami. To demonstruje pedchoz pklad, jeho vstupem je tento text: r r
Toto je dlouh etzec obsahujc mnoho r e dek textu, stejn jej zapisujete i v C. r e "Bl" znaky na zatku dku se samozejm berou v vahu. c r r e
e e Python podporuje i tzv. raw ret zce (cosi jak ryz, syrov ret zce), u nich se dc (escape) sekvence nepevd r r na odpovdajc znaky.2 . Raw et zce charakterizuje pedpona r. Potom et zec r\n odpovd dv ma znak m r e r r e e u zp tnmu lomtku a znaku n, kdeto et zec \n je jedin znak novho dku: e r e r
e hello = rToto je dlouh retzec obsahujc mnoho\n\ dek textu, stejn jej zapisujete i v C. r e print hello
Tento pklad vytiskne text: r

2 Escape
sekvenc je napklad \n - znak novho dku nebo \t - tabultor r r
10
e Toto je dlouh retzec obsahujc mnoho\n\ dek textu, stejn jej zapisujete i v C. r e
Dal monost, jak vytvoit vcedkov et zec je jeho uzaven mezi odpovdajc pr trojitch uvozovek (""" nebo r r r e r ). To m tu vhodu, e nemusme explicitn zapisovat konce dk , ty bude et zec obsahovat pesn tak, jak jsou e r u r e r e zapsny ve zdrojovm kdu:
print """ Pouit: naklada [VOLBY] c -h -H hostname """
Zobraz tuto zprvu Pipoj se na tento pota r c c
Tato ukzka vytiskne nsledujc vstup:
Pouit: naklada [VOLBY] c -h -H hostname
Zobraz tuto zprvu Pipoj se na tento pota r c c
Abychom v d li pesnou podobu et zce, vytiskne jej interpretr stejnm zp sobem jako jej zapisujeme, pi em e e r r e u rc i vechny speciln znaky jsou uvozeny zp tnm lomtkem. (Pokud chceme zobrazit "hodnotu" et zce, tj. to, co e r e skute n obsahuje, m eme pout pkaz print popsan pozd ji. Ten et zec vytiskne bez uvozovek a se vemi c e u r e r e specilnmi znaky.) e Ret zce m eme spojovat pomoc opertoru +, dokonce je lze opakovat opertorem *: u
>>> slovo = Help + A >>> slovo HelpA >>> < + slovo*5 + > <HelpAHelpAHelpAHelpAHelpA>
Nalezne-li interpretr v kdu dva zpisy et zc bezprostedn za sebou, spoj je dohromady jako by mezi nimi leel r e u r e opertor +. Prvn dek pkladu mohl bt tedy zapsn jako slovo = Help A. Ale pozor, takto lze spojovat r r pouze zpisy et zc , pro spojen et zce a vrazu musme pout opertor +! r e u r e
>>> import string >>> str ing string >>> string.strip(str) + ing string >>> string.strip(str) ing File "<stdin>", line 1, in ? string.strip(str) ing ^ SyntaxError: invalid syntax
# # #
<<<-
Sprvn e Sprvn e CHYBN!!! E
11
e Ret zce m eme (podobn jako v jazyce C) indexovat. Prvn znak et zce pak m index 0. Pon vad je Python velice u e r e e uivatelsky ptuln, nekomplikuje ivot programtora specilnm typem ur enm pro jedin znak kad znak r c et zce je op t et zec s dlkou 1. Na zskn podet zce nepotebujeme dn speciln funkce, samotn jazyk r e e r e r e r (podobn jako jazyk Icon) podporuje indexovn subsekvenc3 . Subsekvenci indexujeme podobn jako jednotliv e e znaky, pouze potebuje dva indexy (za tek a konec subsekvence), kter odd lme dvojte kou: r c e c
>>> slovo[4] A >>> slovo[0:2] He >>> slovo[2:4] lp
e Mezi et zci v C a v Pythonu ale existuje obrovsk rozdl. Ret zce v jazyce Python nelze m nit. Jde o celkem logick r e e zv r, et zec ahoj vdy bude et zec ahoj, pro bychom ho tedy m li m nit?4 . Pokusme-li se zm nit ur itou e r e r e c e e e c pozici v et zci, dojde k chyb : r e e
>>> slovo[0] = x Traceback (most recent call last): File "<stdin>", line 1, in ? TypeError: object doesnt support item assignment >>> slovo[:1] = Splat Traceback (most recent call last): File "<stdin>", line 1, in ? TypeError: object doesnt support slice assignment
Proto jedinou cestou, jak vytvet nov et zce, je jejich kombinovn, kter je velice jednoduch a pitom efektivn: r r e r
>>> x + slovo[1:] xelpA >>> Splat + slovo[4] SplatA
Slice indexy maj jet dal specick vlastnosti. Vynechme-li prvn index, je za n j automaticky dosazena nula e e (za tek et zce). Pi neuveden druhho indexu se pouije dlka et zce ( ili konec et zce): 5 . c r e r r e c r e
>>> slovo[:2] He >>> slovo[2:] lpA # Prvn dva znaky # Ve s vjimkou prvnch dvou znak u
Kd ve tvaru s[:i] + s[i:] je samozejm vyhodnocen jako s: r e

>>> slovo[:2] + slovo[2:] HelpA >>> slovo[:3] + slovo[3:] HelpA
Dal vlastnost slice index je jejich automatick "zarovnvn" na rozm r et zce. Je-li toti index pouit ve slice u e r e
3V 4 Obdobn e
originln dokumentaci slice, v tto publikaci budeme n kdy pouvat i vraz slice operace apod. e cslo 1 vdy je cslo 1, tak se nikdo nezaml nad tm, jestli jde jeho hodnota zm nit. e 5 Ve skute nosti je druh index nahrazen velikost prom nn sys.maxint ur ujc maximln velikost celho csla na dan platform . c e c e
12
konstrukci pli velk, je nahrazen dlkou et zce. Podobn pokud je doln index v t ne horn, je vsledkem r r e e e przdn et zec: r e
>>> slovo[1:100] elpA >>> slovo[10:] >>> slovo[2:1]
Pokud jsou indexy zporn csla, dojde k po tn od konce et zce. Nzorn to ukazuje nsledujc pklad i s komenc r e e r ti: r
>>> slovo[-1] A >>> slovo[-2] p >>> slovo[-2:] pA >>> slovo[:-2] Hel # Posledn znak # Pedposledn znak r # Posledn dva znaky # Ve krom poslednch dvou znak e u
Pozor ale, -0 je tot co 0, k dnmu indexovn od konce et zce tm pdem nedojde: r e

>>> slovo[-0] H # (-0 je tot co 0)
Zporn indexy pi indexaci podet zc jsou zarovnny na velikost et zce, proto nen chybou, sahaj-li indexy mimo r r e u r e et zec. To plat ale pouze pro slice indexy, indexy, kter vystupuj samostatn jsou ponechny tak, jak jsou. Pokud je r e e et zec krat a index padne mimo n j, dojde k chyb : r e e e
>>> slovo[-100:] HelpA >>> slovo[-10] # CHYBN!!! E Traceback (most recent call last): File "<stdin>", line 1, in ? IndexError: string index out of range
Pokud i pesto, e jsme se podsekvencm tolik v novali, nechpete, jak jednotliv znaky a podsekvence z nich sloen r e zskat, mon vm pijde vhod nsledujc schema. r D leit je si zapamatovat, e slice indexy ukazuj mezi znaky, pi em lev hrana prvnho znaku m cslo 0 a prav u rc hrana poslednho znaku et zce o n znacch m index n: r e
+---+---+---+---+---+ | H | e | l | p | A | +---+---+---+---+---+ 0 1 2 3 4 5 -5 -4 -3 -2 -1
13
Na prvnm rdku jsou uvedeny vechny mon slice-indexy 0...5 v et zci HelpA, na druhm pak odpovdajc r e zporn hodnoty. Rez od i do j je tedy tvoen vemi znaky mezi hranami ozna enmi mezi hranami ozna enmi i r c c a j. Pokud potebujete zjistit dlku ur itho et zce, jist vyuijete intern funkci len(): r c r e e
>>> s = supercalifragilisticexpialidociln >>> len(s) 35
Pro nezporn slice-indexy je dlka ezu rozdlem slice-index pokud oba "padnou" dovnit et zce. Napklad, dlka r u rr e r ezu word[1:3] je 2. r
3.1.3
Retezce Unicode
Vydnm Pythonu 2.0 se jazyk dostal mezi skupinku jazyk podporujcch Unicode. Od t doby Python um pracovat u e u c r e n s Unicode et zci (viz http://www.unicode.org/) pln stejnm zp sobem jako s oby ejnmi et zci. To umo uje r e snadnou integraci Unicode do ji existujcch aplikac. Dokonce je mon dky konverznm funkcm snadno pevd t r e oby ejn et zce na Unicode a zp t. c r e e Cm je Unicode tak pokrokov? Pedevm v tom, e kadmu znaku libovolnho jazyka piazuje jedine n index. r rr c Tm se li od dve pouvanho schematu, kdy se pouvalo pouze 256 index a n kolik kdovch tabulek, take r u e jednomu indexu odpovdalo vce znak (kad v jin tabulce). To vedlo k velkm zmatk m, rovn bylo nutn reu u e spektovat internacionalizaci6 program , co je zajit n sprvn funkce programu v r znch nrodnch prostedch u e u r (program akceptuje nrodn znaky, sprvn provd td n, konverzi et zc apod.). Unicode proto denuje pouze e r e r e u jedinou kdovou strnku pro vechny jazyky. Program pak zachz se vemi znaky Unicode stejnm zp sobem a u nepotebuje rozliovat mezi r znmi jazyky a kdovmi strnkami. r u Unicode et zce m eme zapisovat pmo ve zdrojovm kdu programu. Pouze ped samotn et zec vlome prex r e u r r r e u (podobn jako u raw et zc prex r): e r e u
>>> uHello World ! uHello World !
Jak vidme, Unicode et zec se bez problm vytvoil. e se jedn o Unicode et zec snadno poznme podle malho r e u r r e psmena u ped et zcem. Chcete-li do et zce vloit speciln znak, m ete tak u init dky Unicode-Escape mdu. r r e r e u c Nejlpe to uvidte na nsledujc ukzce:
>>> uHello\u0020World ! uHello World !
Escape sekvence \u0020 znamen vloen Unicode znaku s hodnotou 0x0020 (znak mezera) na dan msto v et zci. r e Vechny ostatn znaky jsou interpretovny za pouit jejich odpovdajcch hodnot v kdov strnce Unicode. Jste-li obeznmeni s pevodnmi tabulkami mezi jednotlivmi nrodnmi kdovmi strnkami a kdovou strnkou Unicode, r jist jste si vimli, e prvnch 256 znak Unicode pesn odpovd vem 256 znak m kdov strnky Latin-1. e u r e u e e u I s Unicode ret zci je mon pouvat raw md s podobnou funkc jako raw md oby ejnch ret zc . Tento md c aktivujeme pouitm prexu ur namsto standardnho u. Python pak za ne pouvat tzv. Raw-Unicode-Escape md. V c tomto mdu Python nahrazuje pouze sekvence typu \uXXXX a ostatn (teba \n) nechv tak jak jsou: r
6 Anglicky internationalization, casto psno jako i18n i + 18 znak + n. Vedle toho existuje i pojem lokalizace, localization (l10n), u proces pekladu p vodnch text programu do novho jazyka. r u u
14
>>> urHello\u0020World ! uHello World ! >>> urHello\\u0020World ! uHello\\\\u0020World !
Vhody raw mdu ocente pedevm potebujete-li zapsat v t mnostv zp tnch lomtek (nap. pi zpisu regr r e e r r ulrnch vraz ). u Nehled na tyto standardn zpisy nabz Python jet celou adu zp sob , jak Unicode et zce vytvoit. e e r u u r e r Pro konverzi znak z osmibitovho kdovn (klasick et zce) do kdovn Unicode m ete pout intern funkci u r e u unicode(), kter umo uje pstup ke vem registrovanm kodek m, kter dok vytvoit Unicode et zce z n r u r r e et zce v tm libovolnm kdovn (nap. Latin-1, ASCII, UTF-8 nebo UTF-16). Implicitn kdovn je ASCII. r e er r To pro hodnoty znak pouv pouze 7 bit (proto je mon pouvat pouze znaky v rozsahu 0 a 127). Pi pouit u u r rozench znak (nap. znaky s diakritikou apod.) dojde k chyb . r u r e Pro pevod Unicode et zce zp t na standardn lze s vhodou pout intern funkci str(). Ta pouv implicitn r r e e kdovn.7
>>> u"abc" uabc >>> str(u"abc") abc >>> u"" u\xe4\xf6\xfc >>> str(u"") Traceback (most recent call last): File "<stdin>", line 1, in ? UnicodeError: ASCII encoding error: ordinal not in range(128)
e e Chceme-li pi konverzi Unicode ret zce na 8bitov specikovat kdovn, v n m m clov ret zec bt, musme r e pout metodu encode() Unicodovho et zce. T pedme jedin argument jmno kdovn (plat, e vechna r e r jmna kdovn se p malmi psmeny):
>>> u"".encode(utf-8) \xc3\xa4\xc3\xb6\xc3\xbc
Opa nou konverzi umo uje ji zmn n funkce unicode(), kter lze op t pedat jedin argument jmno kc n e e r dovn, ve kterm je p vodn osmibitov et zec. Pevodu ve uvedenho vsledku zp t doshneme tmto volnm: u r e r e
>>> unicode(\xc3\xa4\xc3\xb6\xc3\xbc, utf-8) u\xe4\xf6\xfc
3.1.4
Seznamy
Jazyk Python podporuje i dal datov typy. Jde pedevm o tzv. sloen datov typy, kter slou k uloen jinch r hodnot. Nejuniverzln j z nich je seznam. e Seznam vznikne, zapeme-li v et libovolnch hodnot odd lench crkou mezi hranat zvorky. Nen nutn, aby c e vechny prvky seznamu m ly stejn typ: e
7 Nastavuje se v souboru site.py umst nm v hlavnm adresi b hovho prosted (nap. /usr/local/lib). Jeho jmno lze zjistit pomoc funkce e r e r r sys.getdefaultencoding()
15
>>> a = [spam, eggs, 100, 1234] >>> a [spam, eggs, 100, 1234]
e Seznamy podporuj, podobn jako ret zce, mnoho dalch operac. Namtkou jmenujme spojovn, nsoben celm e cslem, indexovn, operace s podsekvencemi (slice) a dal:
>>> a[0] spam >>> a[3] 1234 >>> a[-2] 100 >>> a[1:-1] [eggs, 100] >>> a[:2] + [bacon, 2*2] [spam, eggs, bacon, 4] >>> 3*a[:3] + [Boe!] [spam, eggs, 100, spam, eggs, 100, spam, eggs, 100, Boe!]
e e u Zsadn rozdl mezi ret zci a seznamy spo v v monosti zm ny prvk . Zatmco u ret zc to nepipad v vahu c e u r jde o typ nem nn, seznamy se j nebrn tento typ nazvme prom nn. Seznam lze zm nit pomoc piazen e e e rr novho prvku na ur it index: c
>>> a [spam, eggs, 100, 1234] >>> a[2] = a[2] + 23 >>> a [spam, eggs, 123, 1234]
Rovn lze piadit hodnotu ur it subsekvenci. Takto dokonce m eme zm nit i po et prvk seznamu: e rr c u e c u
>>> # Zmna prvk: e u ... a[0:2] = [1, 12] >>> a [1, 12, 123, 1234] >>> # Jejich odstrann: e ... a[0:2] = [] >>> a [123, 1234] >>> # Vloen novch: ... a[1:1] = [bletch, xyzzy] >>> a [123, bletch, xyzzy, 1234] >>> a[:0] = a # Vloen kopie seznamu do sebe sama >>> a [123, bletch, xyzzy, 1234, 123, bletch, xyzzy, 1234]
e Podobn jako na ret zce m eme i na seznamy aplikovat intern funkci len(). Jako jej nvratovou hodnotu pak e u obdrme po et prvk obsaench v seznamu: c u
>>> len(a) 8
16
N kdy se m e hodit i monost vytvoit seznam obsahujc jin seznamy, teba: e u r r

>>> >>> >>> 3 >>> [2, >>> 2 >>> >>> [1, >>> [2, q = [2, 3] p = [1, q, 4] len(p) p[1] 3] p[1][0] p[1].append(xtra) p [2, 3, xtra], 4] q 3, xtra] # Viz. sekce 5.1
V poslednm uvedenm pklad si vimn te jedn v ci: objekty p[1] a q jsou jeden a t seznam. Zm nou jednoho r e e e e se zm n i druh. To umo uje mechanismus odkaz na objekty. Pozd ji se k nim jet vrtme, ji nyn ale m eme e n u e e u prozradit, e se jedn o velice d leitou problematiku a bez jej znalosti Python t ko pochopte. u e
3.2
Prvn kroky
Jazyk Python lze samozejm pout k daleko komplikovan jm lohm. Napklad m eme vypsat po te n prvky r e e r u c c Fibonacciho rozvoje8 :
>>> # Fibonacci rozvoj: ... a, b = 0, 1 >>> while b < 10: ... print b ... a, b = b, a+b ... 1 1 2 3 5 8
Tento pklad demonstruje n kolik pro ns v tuto chvli novch vlastnost: r e Prvn dek kdu ukazuje pouit vcensobnho piazen. Ob ma prom nnm a a b jsou zrove piazeny r rr e e n rr dv nov hodnoty. Na posledn dce ukzky je tento obrat pouit znovu pro zskn nov dvojice csel. e r Vrazy na prav stran piazen jsou vyhodnoceny jet ped piazenm hodnoty prom nn. Vyhodnocen e rr e r rr e vrazu probh zleva doprava. Cyklus while je ukzkou sloenho pkazu, tj. pkazu kter obsahuje jin pkazy. Tyto pkazy se pak nazr r r r vaj t lo cyklu. Cyklus typu while b dokud podmnka (v naem ppad b < 10) z stv pravdiv. Test e e r e u pouit v tomto ppad (b < 10) je ukzkou jednoduchho porovnn. Paleta standardnch porovnvacch opr e ertoru je shodn s jazykem C: < (men ne), > (v t ne), == (rovno), <= (men nebo rovno), >= (v t nebo e e rovno) a != (nerovno). Vsledkem porovnn je podobn jako v C cslo. Jako podmnku vak m eme pout e u
8 Fibonacciho
rozvoj je ur en rovnic r[n+2] c
= r[n] + r[n+1]. Za n tud csly 1, 1, 2, 3, 5, 8, 13 atd.: c
3.2. Prvn kroky
17
libovolnou hodnotu. Jakkoli nenulov cslo znamen pravdivou hodnotu, nula nepravdivou. Podmnkou m e u bt dokonce i jin typ ne cslo (napklad libovoln sekvence). r T lo cyklu je odsazeno. Odsazen od kraje je geniln zp sob, jakm Python vyzna uje vnoen bloky kdu. Ine u c r terpretr Pythonu nedisponuje (zatm!) inteligentnm editovnm pkazovho dku, take tabultory nebo mezr r ery muste pst ru n . Pokud ovem budete pipravovat sloit j zdrojov kd, jist pouijete n jak kvalitn c e r e e e textov editor, pi em pro v tinu z nich existuje speciln md, kter bloky kdu odsazuje zcela automatrc e icky.9 Zadvte-li sloen pkaz v interaktivnm mdu, muste jej ukon it przdnou dkou, kter indikuje r c r konec pkazu (parser jinak nem e zjistit, zda jste se ji rozhodli blok ukon it). Kad dek v danm bloku r u c r mus bt odsazen o stejn po et mezer ci tabultor , a nelze je kombinovat (nap. na prvnm dku 2 mezery a c u r r 1 tabultor a na dalm 1 tabultor a nsledn 2 mezery). e Pkaz print, kter vytiskne hodnotu vrazu, kter jste mu pedali. M ete pout i vce vraz odd lench r r u u e crkou, pak budou jednotliv hodnoty odd leny mezerou. Vechny et zce budou samozejm vytisknuty bez e r e r e jejich vn jch uvozovek: e
>>> i = 256*256 >>> print Hodnota promnn i je, i e Hodnota promnn i je 65536 e
Pokud v et vraz ukon te crkou, nedojde k vloen znaku novho dku, dal pkaz print tedy bude c u c r r pokra ovat na tomt dku. c r
>>> a, b = 0, 1 >>> while b < 1000: ... print b, ... a, b = b, a+b ... 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 >>>
Jestlie jste ale v interaktivnm mdu, interpretr ped zobrazenm dal vzvy ukon pedchoz dek, vzva r c r r pak je zobrazena v prvnm sloupci terminlu.
9 Pro
oba nejlep editory vim a emacs tyto mdy samozejm existuj. r e
18
KAPITOLA
CTVRT
Pkazy pro zen toku programu r r

Podobn jako jin jazyky, i Python obsahuje pkazy pro zen toku programu. Krom ji zmn nho pkazu while e r r e e r pedstavenho v minul kapitole jde o dal nemn vznamn konstrukce if, for, break, continue a pedevm r e r uivatelsky denovan funkce. T m vem je v novna tato kapitola. e e
4.1
Konstrukce if
Nejznm jm, nejjednodum a nejpouvan jm pkazem pro zen toku programu je pravd podobn pkaz if. e e r r e e r S jeho pomoc lze zrealizovat jakkoli jin pkaz pro zen toku. Implementuje nejjednodu rozhodovac mechr r anismus, je-li n jak podmnka pravdiv, vykon ur it blok kdu. Casem se ujaly i rozen typu v tv else a e c r e elif.
>>> >>> ... ... ... ... ... ... ... ... ... x = int(raw_input("Zadejte cel cslo: ")) if x < 0: x = 0 print Zporn slo zmnno na nulu c e e elif x == 0: print Nula elif x == 1: print Jedna else: print Vce
Pkaz if otestuje rdc podmnku a pokud je pravdiv, spust svoje t lo. Pokud jde o jednoduchou podmnku (bez r e v tv else), je v ppad nepravdivosti podmnky zen pedno na pkaz nsledujc po t le pkazu if. e r e r r r e r Pokud je pkaz if sloen i z v tv elif, je v ppad nepravdivosti rdc podmnky otestovna dal podmnka v r e r e prvn v tvi elif. Pokud je pravdiv, vykon se t lo psluejc tto v tvi. Je-li nepravdiv, pokra uje se stejn s e e r e c e dalmi v tvemi elif. V kadm ppad se ale po vykonn libovolnho t la ped zen a za posledn v tev elif e r e e r r e (ppadn else). r e Pkaz if m e mt i maximln jednu v tev else. Ta je sput na pokud nevyhovuje ani jedna dc podmnka u r u e e e r v tv if a elif. e V tev elif by se dala nahradit i v tv else a dalm pkazem if, lo by vak o zbyte nou komplikaci, a pedevm e e r c r proto se ujala v tev elif ("elif" je zkratkou pro "else if"). Jazyk Python neobsahuje pkaz typu switch, pln ho e r e toti nahrazuje pkaz if . . . elif . . . elif . . . . r
19
4.2
Konstrukce for
Pkaz for v jinch jazycch jsou pon kud odlin od toho, jak jej poznme v jazyce Python. Od toho v jazyce r e Pascal je naprosto odlin, Pascal umo uje dc prom nn piazovat hodnoty v ur itm rozsahu csel, nanejv n r e rr c bylo mon specikovat krok mezi jednotlivmi hodnotami. Jazyk C ji nabz ti csti, kter se provedou prvn r ped samotnm sput nm cyklu, druh ur uje podmnku pro ukon en cyklu a tet se opakuje po kadm cyklu. To r e c c r nabz programtorovi irok monosti, ne kad je vak doke vyut. Python el jinou cestou, obvyklou v interpretovanch jazycch. Pkaz for umo uje iterovat prvky libovoln r n sekvence (pipome me, e sekvenc jsou krom seznam i et zce). Za dc prom nnou se postupn dosazuj vechny r n e u r e r e e prvky sekvence v tom poad, v jakm jsou v sekvenci uloeny. K ukon en cyklu dojde po vy erpn vech prvk (pr c c u r padn pkazem break nebo neodchycenou vjimkou): e r
>>> # Vytisknut dlky etzc: r e u ... a = [koka, okno, defenestrace] c >>> for x in a: ... print x, len(x) ... koka 5 c okono 4 defenestrace 12
B hem cyklu nen bezpe n modikovat dc sekvenci, by mohlo dojt bud k vynechn nebo opakovn prvku (to e c r plat pouze pro prom nn sekven n typy, u nem nnch to nelze ji z jejich principu). Potebujeme-li pesto zm nit e c e r r e poad prvk v seznamu pes n j iterujeme, musme iterovat pes prvky kopie p vodnho seznamu. Kopii seznamu r u r e r u snadno a rychle vytvome pomoc subsekvence s vynechanmi indexy: r
>>> for x in a[:]: # vytvoen kopie celho seznamu r ... if len(x) > 6: a.insert(0, x) ... >>> a [defenestrace, koka, okno, defenestrace] c
4.3
Funkce range()
Je-li teba iterovat pes prvky aritmetick posloupnosti, budeme potebovat intern funkci range(), kter vrac tuto r r r posloupnost jako klasick seznam. Funkci range() pedme kone nou hodnotu posloupnosti. Pro vechny prvky r c pak bude platit, e jsou men ne tato hodnota:
>>> range(10) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Programtor si rovn m e vydat, e chce aby posloupnost za nala jinm cslem ne nulou, ppadn lze zvolit i e u c r e jin pr stek ne jedna (v etn zpornch csel): r u c e
20
Kapitola 4. Pkazy pro zen toku programu r r
>>> range(5, 10) [5, 6, 7, 8, 9] >>> range(0, 10, 3) [0, 3, 6, 9] >>> range(-10, -100, -30) [-10, -40, -70]
Chceme-li prvky aritmetick posloupnosti pout jako indexy do n jak sekvence, je velmi vhodn zkombinovat e funkce range() a len():
>>> a = [Micinko, Lzinko, i, vylezte] c c >>> for i in range(len(a)): ... print i, a[i] ... 0 Micinko 1 Lzinko 2 i c c 3 vylezte
4.4
Podmnky
Python podporuje mnohem vce opertor psan podmnek ne teba jazyk C. Krom opertor porovnn je mon u r e u pout i dal. Pedevm jde o test na ptomnost/neptomnost prvku v ur it sekvenci to zajituj opertory in a r r r c not in. Dal dvojice opertor (is a not is) porovnv dva objekty a vrt logickou jedni ku pokud jde (resp. nejde) o ty u c sam objekty (mus se rovnat nejen jejich hodnota, ale i umst n v pam ti atd.). e e Vechny opertory porovnn maj stejnou prioritu, kter je ni ne priorita vech numerickch opertor , proto je u mon pst vraz x + 3 > y bez uzvorkovn. Porovnn m e bt zet zeno. Napklad vraz a < b == c testuje, jestli a je men ne b a zrove b je rovno c. u r e r n Jednotliv podmnky m eme kombinovat pouitm Booleovch opertor and a or. Libovoln logick vraz u u m eme znegovat opertorem not. Vechny Booleovsk opertory maj nejni prioritu ze vech opertor (z nich u u pak not m nejvy, nsleduje and a or), take A and not B or C je tot, co (A and (not B)) or C. Zvorky je mon samozejm pout na libovolnm mst pro pravu priority opertor . r e e u Booleovsk opertory and a or maj v Pythonu tzv. zkrcen vyhodnocovn, jejich argumenty jsou vyhodnocovny zleva doprava a pokud je mon denitivn ur it vsledek vrazu, dojde k ukon en vyhodnocen. Z toho vyplv, e e c c pokud A a C jsou pravdiv, ale B nepravdiv, vraz A and B and C nevyhodnot vraz C. Vsledek porovnn je mon piadit libovoln prom nn. Napklad: rr e r
>>> string1, string2, string3 = , Trondheim, Hammer Dance >>> non_null = string1 or string2 or string3 >>> non_null Trondheim
V Pythonu, narozdl od C, se nem e vyskytovat piazen uvnit vrazu. Programtor m v C to m e vadit, ale Python u rr r u u se tmto vyhb mnoha chybm, ke kterm dojde zapsnm = ve vrazu namsto ==.
4.4. Podmnky
21
4.5
Pkazy break a continue a vetev else pkazu for r r
Zrove s cykly je teba zmnit i pkazy pro jejich zen break a continue. Oba dva jist znte i z jinch n r r r e programovacch jazyk . u Pkaz break ukon aktuln cyklus for nebo while a vrt zen za tento pkaz. Naproti tomu pkaz continue r c r r r zp sob pokra ovn dal iterac. Zbytek t la za tmto pkazem je ignorovn a program se vrt zp t k dc csti a u c e r e r znovu otestuje dc podmnku (cyklus while) nebo pokra uje dosazenm dalho prvku za dc prom nnou (cyklus r c r e for). Oba typy cykl mohou mt tak v tev else. K jejmu sput n dojde vdy pi "regulrnm" ukon en cyklu, tj. stane-li u e e r c se dc podmnka nepravdivou (cyklus while) ppadn vy erpaj-li se vechny prvky dc sekvence (cyklus for). r r e c r V ppad ukon en cyklu pkazem break nebo neodchycenou vjimkou se v tev else nevykonn! Toto chovn r e c r e demonstruje ukzka hledn prvo sel mench ne deset: c
>>> for n in range(2, 10): ... for x in range(2, n): ... if n % x == 0: ... print n, je rovno, x, *, n/x ... break ... else: ... # cyklus probhl bez nalezen dlitele e e ... print n, je prvoslo c ... 2 je prvoslo c 3 je prvoslo c 4 je rovno 2 * 2 5 je prvoslo c 6 je rovno 2 * 3 7 je prvoslo c 8 je rovno 2 * 4 9 je rovno 3 * 3
4.6 Pkaz pass r

Pkaz pass je trochu neobvykl. Jedn se o przdn pkaz, ned l v bec nic. Pouv se obzvlt na mstech, kde r r e u e jazyk syntakticky vyaduje n jak pkaz, ale programtor dnou akci nepoaduje: e r
>>> while 1: ... pass # inn ekan na peruen c c r ...
4.7 Denovn funkce

V Pythonu, stejn jako v jinch jazycch, m eme pouvat mnostv funkc. Kad jazyk tak umo uje programe u n torovi denovat si sv vlastn funkce. Do t chto uivatelsky denovanch funkc lze soustedit izolovan kusy kdu s e r ur itm rozhranm. Napklad si m eme napsat funkci, jen vytiskne Fibonacciho rozvoj do zadan meze: c r u
22
>>> ... ... ... ... ... ... >>> ... 1 1
def fib(n): # vypi Fibonacci rozvoj do n """Vytiskne Fibonacciho rozvoj do n.""" a, b = 0, 1 while b < n: print b, a, b = b, a+b # Nyn zavolme funkci tak, jak jsme si ji definovali: fib(2000) 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597
Denice funkce je uvozena kl ovm slovem def. Toto kl ov slovo nsleduje jmno funkce a v et formlnch c c c argument . Nsledujc pkazy, tvoc t lo funkce, jsou zapsny na dalch dkch. T lo funkce je blok kdu a proto u r r e r e mus bt odsazeno podobn jako t lo cyklu apod. Nepovinnou sou st t la funkce m e bt i tzv. dokumenta n e e c e u c ret zec. Tento et zec je uveden bezprostedn po hlavi ce funkce. e r e r e c Existuje mnoho nstroj , kter pouvaj dokumenta n et zce k automatickmu generovn dokumentace. N kter z u c r e e nich umo uj uivateli interaktivn prochzet kd programu, pi em pro lep orientaci zobrazuj prv tyto dokun e rc e menta n et zce. Je proto dobrm zvykem pst dokumenta n et zce ke kad funkci, kterou napete. Krom funkce c r e c r e e lze dokumenta n et zce uvd t i u dalch objekt u td, metod nebo modul . c r e e u r u Zavolnm funkce se vytvo nov prostor jmen pouvan pro lokln prom nn tto funkce. To znamen, e vechna r e piazen uvnit t la funkce jdou do tohoto loklnho prostoru jmen. To zabra uje pmmu piazen hodnoty globln rr r e n r rr prom nn (tj. prom nn denovan mimo funkci). Pouijeme-li n kterou prom nnou v libovolnm vrazu, je jej e e e e jmno hledno nejprve v loklnm oboru jmen a teprve pokud tam nen nalezeno, je prohledn globln obor jmen (a pokud nen nalezeno ani tam je nakonec prohledn intern obor jmen, nen-li toto jmno nalezeno v bec, dojde k u vjimce). Je d leit podotknout, e pestoe globln prom nn nen mon z t la funkce modikovat, je stle mon u r e e je cst. (Pokud deklarujeme v t le funkce n jakou prom nnou jako globln pkazem global, je mon j takto e e e r pouvat, cili je mon i jej modikace kdem funkce). Skute n argumenty pedan funkci pi jejm zavoln jsou uloeny v loklnm prostoru jmen tto funkce. Argumenty c r r jsou pedvny hodnotou.1 Jestlie volan funkce zavol jinou funkce, je op t pro toto voln vyhrazen nov prostor r e jmen. To zabrn vzjemnmu ovliv ovn funkc, kter by zkonit nastalo, pokud by sdlely stejn prostor jmen. n e Denice funkce vytvo novou prom nnou, jej jmno je stejn jako jmno funkce a je uloeno v loklnm prostoru r e jmen. Jej hodnota m speciln typ uivatelsky denovan funkce. Tato hodnota m e bt piazena jin prom nn, u rr e kterou pot lze pout pro voln tto funkce. Tmto zp sobem lze libovoln objekt pejmenovat. u r Zde se op t uplat uje mechanismus odkaz na objekty. Objekty existuj nezvisle na svch jmnech. Jmno objektu e n u je naprosto irelevantn, jeden objekt m e vystupovat pod r znmi jmny. Dokonce objekt nemus bt pojmenovan u u v bec, to nastv v ppad , e objekt se stane sou st teba seznamu. Jmna objekt slou pouze pro jednoduchou u r e c r u orientaci programtora, jednodue pojmenovvaj objekty a umo uj snadn pstup k nim. n r
>>> fib <function object at 10042ed0> >>> f = fib >>> f(100) 1 1 2 3 5 8 13 21 34 55 89
Programtoi v jazyce Pascal zejm namtnou, e funkce fib nen funkc, ale procedurou. Python, podobn jako C, r r e e povauje procedury za speciln druh funkce, kter nevrac dnou hodnotu. Ve skute nosti procedury jazyka Python c vrac hodnotu None. Tato hodnota je obdobou hodnoty null v jazyce C. Jej vypsn je ale potla eno interpretrem, c pokud tuto nvratovou hodnotu chcete vid t, muste si o to ci sami: e r
hodnota vdy znamen odkaz na objekt, ne pmo hodnotu objektu. Pedme-li toti funkci prom nn objekt a tato funkce ho n jakm r r e e zp sobem modikuje, volajc funkce "uvid" vechny tyto zm ny. u e
1 Slovo
4.7. Denovn funkce
23
>>> print fib(0) None
Velice jednodue lze napsat funkci, kter, msto aby vytiskla vsledek, vrt Fibbonacciho rozvoj jako seznam csel:
>>> ... ... ... ... ... ... ... ... >>> >>> [1, def fib2(n): # vrt Fibonacciho rozvoj do sla n c """Vrt seznam obsahujc Fibonacciho rozvoj do sla n.""" c vysledek = [] a, b = 0, 1 while b < n: vysledek.append(b) # viz ne a, b = b, a+b return vysledek f100 = fib2(100) # zavolme funkci fib2() f100 # a vytiskneme jej vsledek 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
Tato ukzka nm nzorn ukazuje dal nov vlastnosti jazyka Python: e Vrcen hodnoty zajist pkaz return, kter ukon provd n funkce a jako jej nvratovou hodnotu pouije r c e vraz uveden za slovem return. Samotn pkaz return vrt None podobn jako vykonn vech pkaz t la funkce. r e r u e Pkaz vysledek.append(b) znamen zavoln metody seznamu vysledek. Metoda je zvltn funkce, r kter ur itm zp sobem "pat" k ur itmu objektu. Jej funkc je v tinou n jak modikovat samotn objekt. c u r c e e Proto kad objekt m svoje vlastn metody, kad modikuje pouze sv j vlastn objekt a ostatn nech na u pokoji. R zn objekty mohou obsahovat r zn metody. Dokonce lze, aby metody r znch objekt m ly stejn u u u u e jmna a pitom provd ly naprosto jinou cinnost. Za pouit td2 je mon denovat vlastn typy objekt a r e r u jejich metody. Metodu append() denuj objekty typu seznam. Ta pi svm vykonn pid na konec seznamu r r prvek, kter j byl pedn jako jedin argument. Odpovd vrazu vysledek = vysledek + [b] ale je r mnohem efektivn j. e
4.8
Dal monosti pi denici funkce r
Funkci lze denovat s mnoha r znmi argumenty. Python nabz i n kolik specilnch zpis , kter programtorovi u e u zna n usnad uj ivot. Navc vechny tyto speciln zpisy mohou bt libovoln mezi sebou kombinovny. c e n e
4.8.1
Implicitn hodnoty argumentu
Velice uite n je specikovn implicitnch hodnot argument . Pi voln funkce je pak mon tyto argumenty c u r vynechat. V tomto ppad jim bude zcela automaticky piazena implicitn hodnota. Typickm pkladem m e bt r e rr r u funkce, jen zobraz vzvu a cek na odpov d uivatele: e
2 Viz.
kapitola 9.
24
def ano_ne(vyzva, opakovani=4, upozorneni=Ano nebo ne, prosm): while 1: ok = raw_input(vyzva) if ok in (a, an, ano): return 1 if ok in (n, ne): return 0 opakovani = opakovani - 1 if opakovani < 0: raise IOError, uivatel ignorant print upozorneni
Tato funkce m e bt volna jako ano_ne(Chcete opravdu ukonit program?) ppadn jako u c r e ano_ne(Pejete si prepsat soubor?, 2). r Implicitn hodnoty argument jsou vyhodnoceny pi denici funkce, pi em jako jmenn prostor (msto, kde se u r rc vyhledvaj jmna prom nnch) je pouit prostor jmen denujcho bloku kdu take kd e
i = 5 def f(arg=i): print arg i = 6 f()
vytiskne cslo 5. Implicitn hodnoty argument jsou vyhodnoceny pouze jednou, i pi opakovanm voln funkce se pouv stle tent u r objekt. To m vznam v ppad prom nnch objekt . Nzornou ukzkou m e bt funkce shromadujc argumenty, r e e u u kter j byly pedny pi jednotlivch volnch, na e vrt seznam t chto argument : r r c e u
def f(a, L=[]): L.append(a) return L print f(1) print f(2) print f(3)
Pedchoz blok kdu potom postupn vytiskne nsledujc vstup: r e

[1] [1, 2] [1, 2, 3]
V n kterch ppadech vak m e bt toto sdlen hodnot mezi volnmi pekkou. Reenm tohoto problmu m e e r u r u bt pouit n jak znm implicitn hodnoty argumentu (teba None) a nsledn testovn hodnoty argumentu na tuto e r hodnotu. Pokud je argument roven znm implicitn hodnot , piad se mu nov hodnota (prom nn objekt, u n ho e rr e e si nepejeme sdlen), nen-li argument roven tto hodnot , pouije se pedan hodnota: r e r
4.8. Dal monosti pi denici funkce r
25
def f(a, L=None): if L is None: L = [] L.append(a) return L
4.8.2
Keyword argumenty
Pokud pouvme implicitn hodnoty argument , casto potebujeme specikovat hodnotu pouze jednoho argumentu. u r Pokud je tento argument prvn ze vech, je ve bez problm . Pot nastv v ppad , e chceme specikovat hodnotu u r e jinho argumentu. Samozejm by se nechalo do voln vepsat implicitn hodnoty pedchzejcch argument . Problm by vak nastal v r e r u ppad zm ny hodnoty jednoho z implicitnch argument . Nsledn dohledn vech voln by bylo velice t k. r e e u e Python proto m e piadit hodnotu ur itmu formlnmu argumentu. Jednodue do voln funkce napeme jmno u rr c tohoto argumentu nsledovan rovntkem a jeho hodnotou ( ili funkce(jmno_formlnho_parametru = hodc nota). V tomto ppad se formlnmu argumentu pezdv keyword argument. Keyword argumenty m eme pout r e r u i v ppad , kdy nepouvme implicitn hodnoty argument . r e u Pokud kombinujeme keyword a klasick (pozi n) argumenty, je teba d sledn dbt na to, aby pozi n argumenty byly c r u e c uvedeny ped keyword argumenty. Zrove je teba splnit poadavek pedn hodnot vem argument m, kter nemaj r n r r u implicitn hodnotu (tj. jde o povinn argumenty). Pouijeme-li neznm keyword argument, dojde pi voln funkce r k chyb . Je teba se tak vyhnout pedn hodnoty jednomu argumentu dvakrt (jednou jako pozi nmu argumentu, e r r c podruh jako keyword argumentu). Nsleduje pklad pouit keyword argument . Funkci denovanou jako r u
def papousek(napeti, xxx=Python, akce=zpvat, keczy=bla, bla, bla): print "-- Tento papouek nebude", akce, print "kdy do nj pustte", napeti, "Volt." e u print "-- A njak kecy:", keczy e print "-- A jet nco:", xxx, "!" e e
m eme volat nsledujcmi zp soby: u u

papousek(1000) papousek(akce = vt, napeti = 1000000) r papousek(tisc, xxx = Chudk papouch) papousek(milion, Papouek to nerozchod, skkat)
Vechna nsledujc voln jsou ale chybn:

papousek() papousek(napeti=5.0, ahoj) papousek(110, napeti=220) papousek(vrah=Pepa Zdepa) # # # # chybjc povinn argument e povinn argument nsledujc po keyword hodnota argumentu pedna dvakrt r neznm keyword argument
26
4.8.3
Funkce s promennm po tem argumentu c
Pokud pi voln funkce specikujeme vce pozi nch argument , ne samotn funkce poaduje, dojde pi jejm voln r c u r k chyb . Proto je mon v hlavi ce funkce specikovat speciln formln argument s pedponou * (nap. *arg). Toe c r r muto argumentu budou piazeny vechny pebvajc argumenty, pedan pi voln funkce (typem tohoto argumentu rr r r r je tuple). Pokud dn takov argumenty nejsou pedny, nabude tento argument hodnotu przdn tuple.3 . Funkce, r jen tuto monost ur it vyuije, je obdoba c kovsk funkce fprintf: c e c
def fprintf(soubor, format, *argumenty): file.write(format % argumenty)
Krom argumentu typu *arg je mon pout i argument ve tvaru **kwarg, ktermu bude piazeno asociativn pole e rr keyword argument , jejich jmna neodpovdaj denici funkce. Pak m eme funkci denovanou jako u u
def big_burger(druh, *argumenty, **keyword): print "-- Mte", druh, ? print "-- Promite,", druh, "doly." n for arg in argumenty: print arg print -*40 for kw in keyword.keys(): print kw, :, keyword[kw]
volat nsledujcmi zp soby: u

big_burger(cheesburgery, "Velice se omlouvm, pane.", "Opravdu se velice se omlouvm, pane.", zakaznik=Adam, prodavac=Bedich, r obchod=Honzv domc BigBurger) u
Jejm vstupem pak bude text

-- Mte cheesburgery ? -- Promite, cheesburgery doly. n Velice se omlouvm, pane. Opravdu se velice se omlouvm, pane. ---------------------------------------obchod : Honzv domc BigBurger u prodavac : Bedich r zakaznik : Adam
Oba speciln typy argument lze kombinovat, pak mus argument *arg pedchzet argumentu **kwarg. u r
4.8.4
Lambda funkce
Casto je poteba napsat funkci, kter vykonv velice jednoduch pkaz. Ve funkcionlnch programovacch jazycch r r (a nejen v nich) se proto ujaly tzv. lambda funkce, tj. krtk funkce, v tinou bezejmenn, ur en pro vykonvn e c jednoduchch pkaz . r u V Pythonu je mon lambda funkce tak pouvat. Nejjednodu ukzkou m e bt funkce vracejc sou et dvou u c argument : lambda a, b: a+b. Lambda funkce v Pythonu je vraz, proto, abychom zachovali jej hodnotu, u musme j piadit n jak prom nn (ppadn pedat n jak funkci apod.): rr e e r e r e
3 Vce
o tuple v 5.3 kapitole.
27
>>> soucet = lambda a, b: a+b >>> print soucet(1, 2) 3
Lambda funkce v Pythonu jsou tvoeny kl ovm slovem lambda, v tem argument , dvojte kou a samotnm t lem r c c u c e funkce. Je teba podotknout, e t lo funkce je tvoeno jedinm vrazem. Ten je pi zavoln funkce vyhodnocen a r e r r jeho hodnota je zrove nvratovou hodnotou lambda funkce. Toto omezen je teba respektovat, v t le lambda funkce n r e nelze pout pkazy typu print atd. Podobn jako je tomu u vloench funkc, i lambda funkce se mohou odkazovat r e na prom nn nadazen funkce: e r
>>> ... ... >>> >>> 42 >>> 43 def make_incrementor(n): return lambda x: x + n f = make_incrementor(42) f(0) f(1)
4.8.5
Dokumenta n etezce c r
Jak jsme si ji rekli, je dobrm zvykem pst dokumenta n ret zce ke kad funkci, modulu nebo td , kter c e r e vytvome. Nyn si povme o tom jak pst a formtovat dokumenta n et zce. r c r e Na prvnm dku dokumenta nho et zce by m la bt krtk v ta shrnujc el celho objektu. Nem la by explicitn r c r e e e c e e pojmenovvat objekt, jeho jmno je pstupn jinou cestou. Jako kad v ta by m la za nat velkm psmenem a kon it r e e c c te kou. c Je-li teba rozshlej dokumenta n et zec, je mon pout vcedkov et zec. V tomto ppad by m la bt druh r c r e r r e r e e dka przdn, odd lujc souhrn na prvn dce od zbytku popisu. Ten by m e bt tvoen i vce odstavci. Ty se mohou r e r u r tkat volajcch konvenc pouvanch u objektu, vedlejch efekt tohoto objektu apod. u e u Parser interpretru neodstra uje (!) odsazen z vcedkovch ret zc , proto by m ly nstroje, kter generuj dokun r e mentaci z dokumenta nch et zc , toto odsazen odstranit. Pitom lze pout jednoduch postup, nejprve se nahrad c r e u r tabultory odpovdajcm po tem mezer (8). Pot se ur odsazen. Protoe z prvnho dku et zce toto odsazen nelze c c r r e zjisti, pouije se prvn neprzdn dek dokumenta nho et zce. O toto zjit n odsazen se pot zkrt kad dek r c r e e r et zce. Pokud se v dokumenta nm et zci nachz dek, kter je odsazen mn , ne cin pr b n odsazen, jsou z r e c r e r e u e jeho za tku odsazeny vechny bl znaky. c Zde je pklad vcedkovho dokumenta nho et zce, jeho by se ppadn prava tkala. Jak vidte, druh dek r r c r e r r textu je opravdu odsazen:
28
>>> def moje_funkce(): ... """Nic nedl, ale zdokumentujeme ji. e ... ... Nedl opravdu nic. e ... """ ... pass ... >>> print moje_funkce.__doc__ Nic nedl, ale zdokumentujeme ji. e Nedl opravdu nic. e
29
30
KAPITOLA
PT
Datov struktury
Tato kapitola bude v novna dalm datovm typ m jazyka Python. Jmenovit si budeme povdat o seznamech, tuple e u e a slovncch, pi em si dle rozme znalosti syntaxe r znch pkaz . rc r u r u
5.1
Seznamy
O seznamech jsme se ji zmnili ve ctvrt kapitole, nyn si nae znalosti pon kud rozme. Nsleduje popis vech e r metod vech seznam , metoda je de facto funkce, kter se ur itm zp sobem ve na ur it objekt, pi svm zavoln u c u c r modikuje pouze tento objekt: append(x) Pid prvek na konec seznamu. Tato metoda je ekvivalentn zpisu a[len(a):] = [x]. r extend(L) Na konec seznamu pid vechny prvky seznamu L, je ekvivalentn zpisu a[len(a):] = L. r insert(i, x) Vlo prvek x na pozici i. Argument i znamen index prvku, ped kter se m nov poloka vloit, r tud a.insert(0, x) vlo prvek na za tek seznamu, zatmco a.insert(len(a), x) na konec (jde c o tot jako a.append(x). remove(x) Ze seznamu odstran dan prvek x, pokud prvk rovnch x se v seznamu nachz vce, odstran se prvn u jeho vskyt. Nenajde-li metoda prvek x, dojde k vjimce. pop([i ]) Odstran prvek na pozici i a vrt jeho hodnotu. Argument i je nepovinn, jeho vynechnm dojde k odstran n poslednho prvku seznamu. e index(x) Vrt index prvnho prvku seznamu, jeho hodnota je rovna x. Nen-li prvek nalezen, dojde k vjimce. count(x) Vrt po et vech vskyt prvk , jejich hodnota je rovna x. Nen-li nalezen dn prvek, vrt nulu. c u u sort() Sead prvky seznamu podle velikosti, pi em modikuje p vodn seznam.1 r rc u reverse() Zrevertuje seznam prvn prvek se stane poslednm, druh pedposlednm atd. Zm na se d je op t na r e e e p vodnm seznamu. u Nsleduje pklad ukazujc pouit jednotlivch metod seznamu. r
1V
anglickm originle je tato vlastnost nazvna "in place sorting"
31
>>> a = [66.6, 333, 333, 1, 1234.5] >>> print a.count(333), a.count(66.6), a.count(x) 2 1 0 >>> a.insert(2, -1) >>> a.append(333) >>> a [66.6, 333, -1, 333, 1, 1234.5, 333] >>> a.index(333) 1 >>> a.remove(333) >>> a [66.6, -1, 333, 1, 1234.5, 333] >>> a.reverse() >>> a [333, 1234.5, 1, 333, -1, 66.6] >>> a.sort() >>> a [-1, 1, 66.6, 333, 333, 1234.5]
5.1.1
Zsobnky
Pomoc metod append() a pop() lze ze seznam vytvoit zsobnky. Zsobnk je fronta typu LIFO2 posledn u r pidan prvek bude odebrn jako prvn. Pro pidn prvku na vrchol zsobnku pouijeme metodu append(), pro r r odebrn prvku metodu pop(). Pipome me si, e metoda pop() bez dalch argument vrt posledn prvek sezr n u namu, cili prvek na vrcholu zsobnku:
>>> >>> >>> >>> [3, >>> 7 >>> [3, >>> 6 >>> 5 >>> [3, zasobnik = [3, 4, 5] zasobnik.append(6) zasobnik.append(7) zasobnik 4, 5, 6, 7] zasobnik.pop() zasobnik 4, 5, 6] zasobnik.pop() zasobnik.pop() zasobnik 4]
5.1.2
Fronty
Obdobou zsobnk jsou i fronty FIFO3 prvn vloen prvek je odebrn jako prvn. Pro pidn prvku na konec u r fronty pouijeme op t metodu append(), pro odebrn prvnho prvku pak metodu pop(), kter pedme index 0 e r (ta tud odstran a vrt prvn prvek celho seznamu):
2 Anglicky 3 rst
last in rst out in rst out
32
Kapitola 5. Datov struktury
>>> fronta = ["Python", "Perl", "PHP"] >>> fronta.append("Ruby") >>> fronta.append("Lisp") >>> fronta.pop(0) Python >>> fronta.pop(0) Perl >>> fronta [PHP, Ruby, Lisp]
5.1.3
Funkcionln programovn v jazyce Python
Python se sna maximln uleh it prci programtorovi, proto ji od samho za tku obsahuje n kter rysy e c c e funkcionlnch programovacch jazyk . Jde pedevm o lambda funkce a stru n seznamy. u r c Lambda funkce lze velmi vhodn pouvat v sou innosti s funkcemi pro manipulaci se seznamy. Tyto funkce pebraj e c r n kolik argument , z nich jeden je vdy funkce (v tinou lambda funkce) a dal seznam. e u e Za n me funkc filter(). Jej denice vypad takto: filter(funkce, sekvence). Po zavoln s t mito arguc e e menty vrt sekvenci4 stejnho typu jako je sekvence. Tato vrcen sekvence bude obsahovat pouze ty prvky p vodn u sekvence, pro kter m voln funkce(prvek) pravdivou hodnotu. Takto lze teba napsat konstrukci, kter vybere r csla, kter nejsou d liteln dv ma ani temi: e e r
>>> def f(x): return x % 2 != 0 and x % 3 != 0 ... >>> filter(f, range(2, 25)) [5, 7, 11, 13, 17, 19, 23]
Naproti tomu funkce map(funkce, sekvence) vrt seznam prvk . Tento seznam je vytvoen z nvratovch hodu r not voln funkce(prvek). Funkce map()vlastn pemapuje prvky p vodn sekvence na nov hodnoty (od tud e r u pochz i jej nzev). Pro vpo et tetch mocnin lze tedy napsat tuto konstrukci: c r
>>> def cube(x): return x*x*x ... >>> map(cube, range(1, 11)) [1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]
Funkci map() m eme pedat i vce sekvenc, funkce pak mus mt tolik argument , kolik je sekvenc. B hem jedu r u e inho voln pak dostane prvky vech sekvenc najednou. Pokud je jedna sekvence krat ne druh, ped se msto r jejho prvku hodnota None. Dal variantou voln funkce map() je vynechn funkce. To se provede pouitm hodnoty None. V tomto ppad r e je pouita intern funkce vracejc vechny sv argumenty jako n-tici. Pokud zkombinujeme tyto dva speciln ppady, zskme voln map(None, seznam1, seznam2), kter pevede r r dvojici seznam na seznam dvojic. u
4 Vce
o sekvencch dle v tto kapitole
5.1. Seznamy
33
>>> seq = range(8) >>> def mocnina(x): return x*x ... >>> map(None, seq, map(mocnina, seq)) [(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25), (6, 36), (7, 49)]
Kone n posledn funkce reduce() s hlavi kou reduce(funkce, sekvence), kter vrac jedinou hodnotu c e c ur itm zp sobem reprezentujc celou sekvenci. Tuto hodnotu ovliv uje prv pedan funkce. T jsou nejprve c u n e r pedny prvn dva prvky sekvence, ona pro n vrt vsledek a nsledn je op t zavolna tato funkce, ped se r e e e r j nvratov hodnota pedchozho voln spolu s nsledujcm prvkem atd. Posledn nvratov hodnota funkce je r pouita jako nvratov hodnota cel funkce reduce(). Jako pklad m e slouit konstrukce pro sou et vech csel r u c 1 a 10:
>>> def add(x,y): return x+y ... >>> reduce(add, range(1, 11)) 55
Funkce reduce() oetuje jet dva speciln stavy obsahuje-li sekvence jedin prvek, je vrcena hodnota tohoto r e prvku. Je-li sekvence dokonce przdn dojde k vjimce. Nakonec si povme jet o nepovinnm argumentu funkce reduce(), hodnota tohoto argumentu je toti pouita e jako po te n hodnota a funkce je poprv volna s argumenty po te n hodnota a prvn prvek a nsleduje obvykl c c c c postup. Pokud je sekvence przdn, je vrcena ona po te n hodnota: c c
>>> def sum(seq): ... def add(x,y): return x+y ... return reduce(add, seq, 0) ... >>> sum(range(1, 11)) 55 >>> sum([]) 0
5.1.4
Stru n seznam c
Aby se Python vyhnul nadm rnmu pouvn funkc map() a filter(), zavedla se konstrukce nazvan stru n e c seznam. e Pomoc stru nho seznamu je mon denovat seznam mnohem cist ji, ne je tomu v ppad ve uvedench funkc. c r e Kad stru n seznam se skld z vrazu nsledovanho kl ovm slovem for a sekvenc. Pi vyhodnocen stru nho c c r c seznamu se prochz sekvenc a jej prvky se dosazuj do vrazu. Prvky novho seznamu pak tvo hodnoty tohoto r vrazu:
>>> ovoce = [ bann, raje , protlak c >>> [zbran.strip() for zbran in ovoce] [bann, raje, protlak] c >>> vec = [2, 4, 6] >>> [x*3 for x in vec] [6, 12, 18] ]
34
Za sekvenc je mon uvst jet klauzuli if nsledovanou podmnkou. Pak jsou ze sekvence pouity pouze ty prvky, e kter vyhovuj podmnce.
>>> [x*3 for x in vec if x > 3] [12, 18] >>> [x*3 for x in vec if x < 2] [] >>> [{x: x**2} for x in vec] [{2: 4}, {4: 16}, {6: 36}] >>> [[x,x**2] for x in vec] [[2, 4], [4, 16], [6, 36]] >>> [x, x**2 for x in vec] # CHYBA - jsou vyadovny zvorky File "<stdin>", line 1, in ? [x, x**2 for x in vec] ^ SyntaxError: invalid syntax >>> [(x, x**2) for x in vec] [(2, 4), (4, 16), (6, 36)] >>> vec1 = [2, 4, 6] >>> vec2 = [4, 3, -9] >>> [x*y for x in vec1 for y in vec2] [8, 6, -18, 16, 12, -36, 24, 18, -54] >>> [x+y for x in vec1 for y in vec2] [6, 5, -7, 8, 7, -5, 10, 9, -3] >>> [vec1[i]*vec2[i] for i in range(len(vec1))] [8, 12, -54]
5.2 Pkaz del r

Na za tku tto kapitoly jsme se dov d li od metod remove(), kter odstran ur it prvek ze seznamu. N kdy c e e e c e potebujeme odstranit prvek na ur it pozici v seznamu, pak pouijeme prv pkaz del. Takto m eme ze seznamu r c e r u vymazat dokonce i celou podsekvenci:
>>> a [-1, 1, 66.6, 333, 333, 1234.5] >>> del a[0] >>> a [1, 66.6, 333, 333, 1234.5] >>> del a[2:4] >>> a [1, 66.6, 1234.5]
Pkazem del m eme tak odstranit cel prom nn. Po odstran n tto prom nn ji nebude mon se na n odkazor u e e e vat.
>>> del a >>> print a Traceback (most recent call last): File "<stdin>", line 1, in ? NameError: name a is not defined
5.2. Pkaz del r
35
5.3
Tuple a sekvence
V pedchoz csti jsme poznali, e seznamy a et zce toho maj mnoho spole nho, lze je indexovat, pouvat jejich r r e c podsekvence apod. Krom t chto dvou datovch typ Python podporuje jet dal datov typ tuple. Tuple si lze e e u e pedstavit jako uspodanou n-tici, jej prvky nelze m nit. r r e Tuple se zapisuje jako n-prvk odd lench crkou: u e
>>> t = 12345, 54321, ahoj! >>> t[0] 12345 >>> t (12345, 54321, ahoj!) >>> # Tuple mohou bt skldny: ... u = t, (1, 2, 3, 4, 5) >>> u ((12345, 54321, ahoj!), (1, 2, 3, 4, 5))
Zvorky kolem v tu prvk nejsou povinn, v n kterch ppadech se jim vak nevyhneme (nap. pedvn argument c u e r r r u funkcm). Tuple lze vkldat do sebe, lze pouvat klasick operace jako indexovn prvk a podsekvenc. u Tuple maj mnoho pouit (nap. pry souadnic (x, y) atd.). D leit pro ns je, e jde o nem nn datov typ, tud je r r u e lze za ur itch podmnek pout jako kl e slovnk 5 . Zrove jejich nem nnost vyaduje men reii a tedy i prce s c c u n e nimi je rychlej ne prce se seznamy. Existuj dva speciln ppady tuple przdn tuple (zapisuje se prem przdnch zvorek) a tuple o jednom prvku r (prvek je nsledovn crkou, nen nutn ho uzavrat do zvorky). Napklad: r
>>> prazdna = () >>> singleton = ahoj, >>> len(prazdna) 0 >>> len(singleton) 1 >>> singleton (ahoj,)
# <-- nezapomete ukonujc rku n c c
Operac nazvanou skldn tuple se rozum piazen vce prvk jedn prom nn. Tato prom nn pak bude tvoena rr u e e r tuple obsahujc tyto prvky. Opa nou operac je rozklad sekvenc. V tomto ppad stoj na lev stran prom nn odd len crkou a stran prav c r e e e e e pak tuple obsahujc prvky, kter budou piazeny prom nn: rr e
>>> x, y, z = t
Rozklad sekvenc vyaduje, aby dlka tuple na prav stran byla stejn jako dlka v tu prom nnch na stran lev. e c e e Nakonec si vimn te mal asymetrie, zatmco skldn vdy vytvo tuple, rozklad funguje na libovolnou sekvenci (tj. e r jak na tuple, tak i na et zce a seznamy)! r e
5O
slovncch se dovme vce dle v tto kapitole
36
5.4
Slovnky
Dalm nemn d leitm datovm typem Pythonu je slovnk, n kdy nazvan t asociativn pole. Jde o neuspoe u e r danou mnoinu dvojic kl : hodnota. Hodnoty nejsou reprezentovny indexy, ale kl i. Z toho vyplv, e kl e mus c c c bt v rmci jednoho slovnku jedine n. c Na kl jsou kladeny ur it poadavky. Jde pedevm o nem nnost, kl em nem e bt dn prom nn datov typ. c c r e c u e Lze tedy pout csla, et zce a dokonce tuple, ty vak mus op t obsahovat pouze tyto typy. Seznamy nelze jako kl e r e e c nikdy pout6 . Hodnotami ve slovnku mohou bt libovoln typy, dokonce op t slovnky. e Slovnk v Pythonu zkonstruujeme zpisem dvojic kl : hodnota mezi sloen zvorky. Pro vytvoen przdnho c r slovnku vynechme zpis hodnot:
>>> slovnik1 = {1: jedna, 2: dva, 3: tri} >>> slovnik2 = {}
Slovnk je prom nn datov typ, je mon do n j ukldat hodnoty pod zadanm kl em a cst z n j hodnoty ur itho e e c e c kl e. Pkazem del je dokonce mon smazat pr kl : hodnota. Pokud do slovnku ulome novou hodnotu pod c r c kl em, kter ji slovnk obsahuje, dojde k pepsn hodnoty tohoto kl e. Pokud ze slovnku chceme zskat hodnotu c r c neexistujcho kl e, dojde k vjimce. c Slovnky maj i n kolik metod, kter jsou vesm s ur eny pro manipulaci s kl i apod. My si uvedeme pouze dv e e c c e metoda keys(), vrt seznam vech existujcch kl u pouitch ve slovnk (jejich poad je vesm s nhodn). c u r e Druh metoda has_key() vrt logickou jedni ku, pokud je kl , kter j byl pedn jako argument, obsaen ve c c r slovnku:
>>> tel = {jack: 4098, sape: 4139} >>> tel[guido] = 4127 >>> tel {sape: 4139, guido: 4127, jack: 4098} >>> tel[jack] 4098 >>> del tel[sape] >>> tel[irv] = 4127 >>> tel {guido: 4127, irv: 4127, jack: 4098} >>> tel.keys() [guido, irv, jack] >>> tel.has_key(guido) 1
5.5
Porovnvn sekvenc a dalch typu
Sekven n objekty mohou bt porovnvny s dalmi sekvencemi. Toto porovnn se d je lexikogracky, nejprve se c e porovnaj prvn dva prvky, dle dal dva atd. Pokud se na n jakm indexu li, pak tento rozdl d vsledek celmu e porovnn7 . Jestlie n kter prvky jsou op t sekven n typy, dojde k dalmu lexikograckmu porovnn. Jestlie je jedna e e c sekvence del ne druh a ve stejn dlouh csti se shoduj, je ta krat vyhodnocena jako men. Lexikograck e porovnvn et zc pouv ASCII (ppadn Unicode) kdovn. r e u r e
6 Trvme-li 7 Kad
na tom, musme nejprve seznam pevst na tuple funkc tuple() a teprve potom ho pout jako kl . r c pochop, e jde o znm porovnvn nap. et zc podle velikosti r r e u
5.4. Slovnky
37
(1, 2, 3) < (1, 2, 4) [1, 2, 3] < [1, 2, 4] ABC < C < Pascal < Python (1, 2, 3, 4) < (1, 2, 4) (1, 2) < (1, 2, -1) (1, 2, 3) == (1.0, 2.0, 3.0) (1, 2, (aa, ab)) < (1, 2, (abc, a), 4)
Porovnvn objekt r znch datovch typ Python tak umo uje. Pravidla pro toto porovnn se mohou v budoucnu u u u n m nit, nicmn je vdy zaru ena jednozna nost porovnn. R zn typy csel jsou porovnvny s ohledem na jejich e e c c u cselnou hodnotu.
38
KAPITOLA
EST
Moduly
Jak jste si jist vimli, po ukon en prosted jazyka Python pijdete o vechny prom nn a funkce, kter jste si dee c r r e novali. Proto, pete-li del programy, je vhodn j zdrojov kd uloit do souboru a interpretr nasm rovat na tento e e soubor. Ten se pak v terminologii jazyka Python nazv skript.1 . Tm, jak se program stv del a del, se casto vyskytne poteba ho rozd lit na n kolik (relativn ) nezvislch cst. Tyto csti se nazvaj moduly a lze je pout i r e e e pro vytvoen sdlench knihoven kdu, kdy jednu funkci denovanou v globln pstupnm modulu m e pouvat r e r u kterkoli jin modul, jen k n mu m pstup. Funkce a prom nn mohou bt z modulu importovny (zavedeny) do e r e jinch modul , kter je pak m ou pouvat obvyklm zp sobem. u u u Modul je soubor obsahujc kd jazyka Python (nap. denice funkc a dal pkazy). Je zvykem ukldat moduly r r do soubor s pponou .py, pak jmno souboru bez ppony znamen jmno modulu.2 . Jako pklad m poslou u r r r nsledujc kd (uloen napklad v souboru bo.py): r
# Modul obsahujc funkce pro vpoet Fibonacciho rozvoje c def fib(n): # vytiskne Fibonacciho rozvoj do sla n c a, b = 0, 1 while b < n: print b, a, b = b, a+b def fib2(n): # vrt Fibonacciho rozvoj do sla n c result = [] a, b = 0, 1 while b < n: result.append(b) a, b = b, a+b return result
Nyn pejd te do adrese, v n m se nachz v soubor bo.py, spustte interpretr Pythonu a zavedte modul nsler e r e dujcm pkazem: r
>>> import fibo
Tento pkaz vytvo v loklnm oboru jmen nov jmno (prom nnou) s nzvem fibo. Toto jmno odkazuje na objekt r r e modulu, tento objekt ji obsahuje funkce a prom nn denovan modulem fibo. Na tyto objekty se odkazujeme e pouitm te kov notace: c
skript plat veobecn , pouv se u vech interpretovanch jazyk . e u .py je nutn, b hov prosted jazyka podle n ho rozpozn, e soubor je modulem a umon ho importovat, toto chovn lze zm nit e r e e pepsnm intern funkce __import__ r
2 Ppona r 1 Termn
39
>>> fibo.fib(1000) 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 >>> fibo.fib2(100) [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89] >>> fibo.__name__ fibo
e Pokud n jakou prom nnou nebo funkci budeme potebovat cast ji, je mon si vytvoit lokln jmno odkazujc na e e r r objekt uvnit modulu. Pstup k loklnm prom nnm je rychlej a hlavn uette svoj klvesnici, protoe nebudete r r e e r muset neustle opisovat jmno modulu:
>>> fib = fibo.fib >>> fib(500) 1 1 2 3 5 8 13 21 34 55 89 144 233 377
6.1
Pouvme moduly
Moduly mohou obsahovat libovoln kd, jejich pouit se tedy neomezuje na pouh denovn rady funkc. Ped r prvnm zavedenm modulu interpretr nalezne soubor obsahujc modul, na te ho a spust vechny pkazy, kter obc r sahuje. Tento proces se nazv inicializace modulu. Pi inicializaci vznikaj objekty reprezentujc funkce uvnit modr r ulu a je mon pi n nastavit i globln prom nn modulu do ur itho stavu. Pokud chce program importovat modul, r e c kter je ji zinicializovn, nedojde k op tovnmu sput n kdu, nbr se pouije objekt modulu vytvoen pi iniciale e r r izaci. Zavedenm modulu vznikne nov prostor jmen ur en pro globln prom nn tohoto modulu. Dky tomuto mechc e anismu m e autor modulu pouvat libovoln nzvy prom nnch a pesto nedojde ke kolizi s prom nnmi u e r e jinho modulu. Prom nn v tomto jmennm prostoru jsou pstupn za pouit objektu modulu (klasicky jako e r jmno_modulu.promnn). Nedoporu uje se ovem libovolnm zp sobem modikovat soukrom prom nn e c u e modulu, mohli byste toti naruit konzistenci dat modulu a ten by mohl za t chybn pracovat. c e Je samozejm, e moduly mohou importovat jin moduly. V Pythonu je zvykem umstit veker pkazy import na r r za tek modulu ci skriptu. Denice jazyka to ovem nevyaduje, uznte-li za vhodn, m ete pkaz import pout c u r napklad ve v tvi pkazu if nebo uvnit funkce. r e r r Jak jsme si rekli ve, pkaz import zavede do loklnho prostoru jmen objekt modulu. Existuje ale i varianta r pkazu import, kter rovnou zavede n kter (pop. vechny) objekty z ur itho modulu. Nemusme tedy pouvat r e r c piazen pro vytvoen loklnho jmna: rr r
>>> from fibo import fib, fib2 >>> fib(500) 1 1 2 3 5 8 13 21 34 55 89 144 233 377
Toto pouit pkazu import nevytvo jmno, odkazujc na objekt modulu, v pklad ve je tedy prom nn fibo r r r e e (reprezentujc modul fibo) nedenovna. Pro zaveden vech jmen z modulu je zde dal varianta pkazu import:3 r
>>> from fibo import * >>> fib(500) 1 1 2 3 5 8 13 21 34 55 89 144 233 377
3 Je znmo, e import je pkaz s nejv tm mnostvm r znch variac. Zrove jde o velmi pouvan pkaz, proto byste m li dokonale v det r e u n r e e co a jak provd. Ve o syntaxi tohoto pkazu se dozvte z dokumentu Python Language Reference. r
40
Kapitola 6. Moduly
Tento pkaz zavede z modulu vechna jmna s vjimkou t ch, kter za naj znakem podtrtko. Je teba podotr e c r knout, e tento zp sob pouit modul je velmi zrdn. Jednak nen znmo, na kterm mst je kter prom nn deu u e e novna a jednak ji m e dojt ke kolizi jmen a proto u n kterch modul je vslovn zakzno pouit from ... u e u e import *. Snate se proto pouvn tohoto pkazu omezit pouze na interaktivn sezen a ve skriptech ho rad ji r e v bec nepouvejte. u
6.1.1
Vyhledvn modulu
Co se stane, pokud importujeme modul fibo poprv? Kde vude interpretr hled soubory obsahujc denici tohoto modulu? Pedevm nejprve se interpretr podv do pracovnho adrese, jestlie zde najde soubor bo.py, veker r r jeho prce kon a pokus se zavst tento modul. c Pokud vak tento soubor v tomto adresi nenalezne, za ne ho vyhledvat podle pesnch pravidel specikor c r vanch denic jazyka. Tedy: nejprve se podv na prom nnou prosted PYTHONPATH, kter by m la mt e r e stejnou syntaxi jako prom nn prosted PATH. Nen-li prom nn PYTHONPATH nastavena nebo v adresch, e r e r kter specikuje, nen poadovan soubor nalezen, pokra uje vyhledvn v implicitn cest . Tu specikuje c e prom nn sys.path, jde o seznam et zc reprezentujcch adrese. Obsah tto prom nn je zvisl na ine r e u r e stalaci interpretru a jeho nastaven v modulu site. M e vypadat teba takto: [/usr/lib/python2.2, u r /usr/lib/python2.2/plat-linux2]. Je teba d sledn dbt na to, aby n jak soubor v pracovnm adresi nem l stejn jmna jako n jak standardn r u e e r e e modul. Uzaveli bychom si tak cestu k tomuto standardnmu modulu, protoe pi pokusu o zaveden tohoto modulu r r bychom ve skute nosti obdreli modul ze souboru v pracovnm adresi. Pro vce informac o standardnch modulech c r nahldn te do sekce 6.2. e Pokud interpretr poadovan modul nenalezne, dojde k vjimce, kter se roz z pkazu import4 . Obdobn je r r e tomu i v ppad , kdy se poadovan modul podailo nalzt, ale pi jeho inicializaci dolo k vjimce. Zde je teba r e r r r dvat pozor na to, e pestoe modul nebyl korektn zinicializovan, pi dalm pokusu o jeho zaveden se ji druh r e r inicializace konat nebude a modul bude mon pouvat nezinicializovan.
6.1.2
"Kompilovan" moduly
Pro zrychlen spout n (nikoli b hu!) krtkch program pouvajcch velk mnostv standardnch modul pouv e e u u Python soubory s pponou .pyc, tzv. kompilovan moduly. Pokud se kd pokus zavst modul fibo a interpretr r najde vedle souboru bo.py i soubor bo.pyc, povauje tento soubor za zkompilovan modul. Proto porovn cas modikace souboru bo.py s casem zaznamenanm v souboru bo.pyc. Jestlie jsou tyto casy shodn, rozhodne, e soubor bo.pyc byl vytvoen ze souboru bo.py a pouije ho msto n j. Tm dojde k vznamnmu urychlen r e zaveden modulu, nen teba jeho kd znovu pekldat do bytekdu, protoe se pouije ji peloen verze. r r r O vytvoen souboru bo.pyc se programtor nemus v bec starat, interpretr ho vytv zcela sm kdykoli, kdy se mu r u r poda kd souboru bo.py sp n peloit do bytovho kdu. Jestlie se soubor nepoda vytvoit (d vodem m e r e e r r r u u bt pln disk nebo nedostate n prva uivatele), nedojde k chyb , protoe pi ptm importu modulu bude byte kd c e r r vytvoen znovu. Stejn tak tomu bude i v ppad , kdy se sice soubor bo.pyc poda vytvoit, ale nebude mon ho r e r e r r zapsat cel, ppadn jeho obsah bude chybn, interpretr na zklad kontrolnch sou t tento soubor vyhodnot jako r e e cu nevyhovujc a po importu souboru bo.py ho vytvo znovu. r Nsleduje n kolik d leitch poznmek tkajcch se peloench modul : e u r u Pro administrtory U NIXovch systm je d leit v d t, e obsah souboru bo.pyc je nezvisl na platform , u u e e e je tud mon ho sdlet mezi po ta i v sti (i heterogenn, obsah nezvis ani na pouitm OS). c c Pokud interpretr jazyka Python spustte s volbou -O, bude generovat optimalizovan bytov kd, kter bude ukldat do soubor .pyo. Je teba podotknout, e optimalizace nen (zatm) pli dokonal, prosted odstran u r r r
4 Vce
o vjimkch v kapitole Vjimky
6.1. Pouvme moduly
41
pouze pkazy assert a instrukce SET_LINENO. Pi pouvn optimalizace jsou ignorovny vechny r r soubory .pyc. Pi pouit volby -OO dojde ke generovn byte kdu, kter m e ve vjime nch ppadech stit v chybnou r u c r cinnost programu. Nyn j verze interpretru odstra uj dokumenta n et zce, dky cemu vzniknou kompake n c r e tn j .pyo soubory, naproti tomu ty programy, kter zvis na korektnosti dokumenta nch et zc , za nou e c r e u c pracovat chybn . e Zopakujme, e programy, jejich moduly jsou cten ze zkompilovanch soubor , nepob rychleji, dojde pouze u e k rapidnmu zkrcen doby potebn pro zaveden modulu r Pokud pedvte jmno skriptu, kter si pejete spustit, pmo interpretru, nebude se pro n j generovat komr r r e pilovan soubor .pyc (pop. .pyo). Rychlost startu skript proto m e bt zvena pesunutm v tiny kdu r u u r e do speciln modulu. Interpretru potom pedme pouze mal skript, kter spust hlavn vkonn kd z tohoto r modulu. Interpretr doke pouvat soubory .pyc (.pyo), ani by existoval jejich originl v podob souboru .py. e Interpretru je dokonce mon pedat jmno .pyc souboru a ten ho bez problm spust. Obsah souboru .pyc je r u vytvoen tak, e nen mon zskat p vodn podobu souboru .py. Takto je mon bezpe n vytvet proprietrn r u c e r kd. Python nabz utilitu ve form modulu compileall, kter doke vytvoit .pyc nebo .pyo soubory pro e r vechny moduly v ur itm adresi. c r
6.2
Standardn moduly
Zkladn distribuce Pythonu obsahuje velk mnostv modul (jsou popsny v samostatnm dokumentu Python Liu brary Reference). Dky nim je mon realizovat mnostv loh spojench s internetem, unixovmi databze dbm, prac se soubory, opera nm systmem a mnoho a mnoho dalch. c N kter moduly jsou pmo sou st interpretru, umo uj toti pstup k operacm, kter nejsou pmo sou st jdra e r c n r r c prosted, ale jsou mu velice blzk (nap. v dan aplikaci zvis na rychlosti vykonvn nebo je teba volat funkce r r r opera nho systmu ci dalch knihoven). Zahrnut t chto modul je zvisl na konguraci a pekladu interpretru. c e u r (Napklad modul Tkinter ur en jako rozhran ke grack knihovn Tk je ptomn pouze na systmech s knihovr c e r nou Tk). Mezi vemi moduly najdeme jeden, kter nabz samotn jdro b hovho systmu, modul sys a obsahuje ho kad e interpretr. Jeho prom nn sys.ps1 a sys.ps2 umo uj v interaktivnm mdu nastaven primrn a sekundrn e n vzvy interpretru:
>>> import sys >>> sys.ps1 >>> >>> sys.ps2 ... >>> sys.ps1 = C> C> print Ahoj! Ahoj! C>
Jak ji jist vte, prom nn sys.path je seznam et zc , kter ur uje cesty v nich interpretr vyhledv moduly. Je e e r e u c inicializovna z prom nn prosted PYTHONPATH pp. je nastavena v modulu site. Jde o klasick seznam, kter e r r m ete m nit b nmi operacemi denovanmi nad seznamy: u e e
42
Kapitola 6. Moduly
>>> import sys >>> sys.path.append(/ufs/guido/lib/python)
6.3
Funkce dir()
Intern funkci dir() pouijete v ppad , e chcete zjistit vechna jmna, kter jsou denovna uvnit n jakho r e r e objektu. Tato funkce vrac seznam et zc setd n podle abecedy, jeho pouvn reprezentuje nsledujc pklad: r e u r e r
>>> import fibo, sys >>> dir(fibo) [__name__, fib, fib2] >>> dir(sys) [__displayhook__, __doc__, __excepthook__, __name__, __stderr__, __stdin__, __stdout__, _getframe, argv, builtin_module_names, byteorder, copyright, displayhook, exc_info, exc_type, excepthook, exec_prefix, executable, exit, getdefaultencoding, getdlopenflags, getrecursionlimit, getrefcount, hexversion, maxint, maxunicode, modules, path, platform, prefix, ps1, ps2, setcheckinterval, setdlopenflags, setprofile, setrecursionlimit, settrace, stderr, stdin, stdout, version, version_info, warnoptions]
Bez argument vrt seznam jmen, kter jsou denovny v aktulnm prostoru jmen: u
>>> a = [1, 2, 3, 4, 5] >>> import fibo, sys >>> fib = fibo.fib >>> dir() [__name__, a, fib, fibo, sys]
Seznam vrcen funkc dir() zahrnuje vechna jmna denovan v objektu, nejde tud pouze o prom nn, ale e i o funkce, moduly, tdy apod. Do tohoto seznamu nejsou zahrnuta jmna internch funkc a prom nnch (tj. t ch r e e denovanch modulem __builtin__). Pokud potebujete seznam internch funkc pouijte r
6.3. Funkce dir()
43
>>> import __builtin__ >>> dir(__builtin__) [ArithmeticError, AssertionError, AttributeError, DeprecationWarning, EOFError, Ellipsis, EnvironmentError, Exception, FloatingPointError, IOError, ImportError, IndentationError, IndexError, KeyError, KeyboardInterrupt, LookupError, MemoryError, NameError, None, NotImplemented, NotImplementedError, OSError, OverflowError, OverflowWarning, ReferenceError, RuntimeError, RuntimeWarning, StandardError, StopIteration, SyntaxError, SyntaxWarning, SystemError, SystemExit, TabError, TypeError, UnboundLocalError, UnicodeError, UserWarning, ValueError, Warning, ZeroDivisionError, _, __debug__, __doc__, __import__, __name__, abs, apply, buffer, callable, chr, classmethod, cmp, coerce, compile, complex, copyright, credits, delattr, dict, dir, divmod, eval, execfile, exit, file, filter, float, getattr, globals, hasattr, hash, help, hex, id, input, int, intern, isinstance, issubclass, iter, len, license, list, locals, long, map, max, min, object, oct, open, ord, pow, property, quit, range, raw_input, reduce, reload, repr, round, setattr, slice, staticmethod, str, super, tuple, type, unichr, unicode, vars, xrange, zip]
6.4
Bal ky c
Bal ky jsou logickm rozenm mechanismu Pythonovch modul . V Pythonu je toti iroce pouvna "te kov c r u c notace" a prv bal ky umo uj hiearchickou organizaci modul . e c n u Napklad modul se jmnem A.B znamen modul pojmenovan B v bal ku A. Bal ky umo uj dekompozici r c c n rozshlch knihoven do mench soubor - modul . Autoi jednotlivch modul se nemus zajmat o jmna globlu u r u nch prom nnch jinch modul v tomt bal ku, jazyk zajituje vzjemnou "izolaci" bal k mezi sebou. Proto se e u c c u napklad autoi jednotlivch modul rozshlch bal k (nap. NumPy nebo Python Imaging Library) nemus obvat r r u c u r stetu jmen svch globlnch prom nnch s prom nnmi jinho autora. r e e Pedstavte si modelovou situaci: chcete navrhnout bal ek (kolekci modul ) pro manipulaci se zvukovmi soubory r c u a zvukovmi daty obecn . Pon vad existuje mnoho r znch zvukovch formt , potebujete vytvoit a spravovat e e u u r r kolekci modul pro konverzi mezi t mito formty. Tak si m ete pedstavit mnoho operac, kter lze se zvukovmi u e u r daty provd t (nap. mixovn stop, pidvn ozv ny, aplikovn ekvalizru ...). Postupem casu si vytvote mnoho e r r e r modul pro tyto cinnosti. Pro jejich organizaci je mechanismus bal k naprosto ideln. Zde je mon struktura u c u vaeho bal ku (zobrazen jako hiearchick souborov systm): c
44
Kapitola 6. Moduly
Sound/ __init__.py Formats/ __init__.py wavread.py wavwrite.py aiffread.py aiffwrite.py auread.py auwrite.py ... Effects/ __init__.py echo.py surround.py reverse.py ... Filters/ __init__.py equalizer.py vocoder.py karaoke.py ...
Hlavn balek c Inicializace balku c Balek pro konverzi souborovch formt c u
Balek pro zvukov efekty c
Balek filtr c u
Jist se ptte, co znamenaj soubory __init__.py. Python podle nich rozpoznv adrese obsahujc bal ky. To e r c zabra uje nedorozum nm, kdy Python povaoval libovoln adres nachzejc se v jeho cest za bal ek. V nejn e r e c jednodum ppad je soubor __init__.py pouhopouh przdn soubor, m ete sem ale umstit inicializa n kd r e u c bal ku nebo nastavit prom nnou __all__ (jej vznam je popisovn pozd ji). c e e Uivatel bal ku z n j mohou pmo importovat jednotliv moduly: c e r
import Sound.Effects.echo
Tento pkaz na te modul Sound.Effects.echo. Jeho prom nn a funkce vak mus bt odkazovny plnm r c e jmnem:
Sound.Effects.echo.echofilter(input, output, delay=0.7, atten=4)
Jinou monost je pm importovn modulu z bal ku: r c

from Sound.Effects import echo
Tento pkaz tak na te modul echo a u in jej pstupnm za pouit jeho jmna. Funkce v n m denovan m ete r c c r e u pouvat teba nsledovn : r e
echo.echofilter(input, output, delay=0.7, atten=4)
Dal cestou je importovn ur it funkce nebo prom nn pmo: c e r
6.4. Bal ky c
45
from Sound.Effects.echo import echofilter
Tento pkaz op t na te modul echo, ale u in jeho funkci echofilter() pstupnou pmo: r e c c r r
echofilter(input, output, delay=0.7, atten=4)
Na zv r podotkn me, e pi importovn n jakch jmen (prom nnch, modul apod.) za pouit pkazu import e e r e e u r m eme na mst objektu, z n ho chceme import provst uvst pouze bal ek nebo modul. Pkaz from u e e c r objekt_rzn_od_modulu_i_balku import jeho_atribut je povaovn za b hovou chybu a u c c e z msta jeho pouit se roz vjimka. Jako nhradu takovto konstrukce lze pout jeho_atribut = r objekt_rzn_od_modulu_i_balku.jeho_atribut. u c c
6.4.1
Importovn * z bal ku c
Co se nyn stane, nape-li uivatel from Sound.Effects import *? Nejideln j, ale nereln cesta by e mohla vypadat takto: interpretr projde souborov systm, najde moduly patc tomuto bal ku a zavede je. Bohuel. r c Na platformch Mac a Windows toti souborov systm neuchovv informace o velikosti psmen jmen soubor ! u Neexistuje zde dn zruka, e soubor echo.py nebude importovn jako modul echo, Echo nebo dokonce ECHO. V opera nm systmu DOS se k t mto problm m jet pidv omezen dlky jmen soubor na 8 znak + 3 znaky c e u e r u u ppony. r Python proto nabz sv platformn nezvisl reen: autor bal ku prost interpretru sd l, jak moduly bal ek e c e e c obsahuje. Pkaz import byl modikovn a pouv nsledujc konvenci: jestlie kd v souboru __init__.py r (vzpome te si, e jde o inicializa n soubor celho bal ku) denuje prom nnou pojmenovanou __all__ typu sezn c c e nam, pak je tato prom nn povaovna za v et vech modul , kter maj bt importovny pi vykonn pkazu e c u r r from balek import *. Udrovn tohoto seznamu v aktulnm stavu je povinnost autora bal ku. Ten c c se m e rozhodnout ho dokonce nepodporovat, pokud povauje importovn * za bezvznamn. Napklad soubor u r Sounds/Effects/__init__.py by mohl obsahovat nsledujc kd:
__all__ = ["echo", "surround", "reverse"]
Tm interpretru kme, e bal ek Sound.Effects obsahuje celkem ti moduly: echo, surround a reverse. r c r Jestlie prom nn __all__ nen denovna, pkaz from Sound.Effects import * pouze spust iniciale r iza n kd bal ku (soubor __init__.py) a poslze zavede vechna jmna denovan tmto kdem. Tento kd m e c c u explicitn zavst n jak z modul bal ku do hlavnho prostoru jmen bal ku. Import vech jmen pak zavede i tento e e u c c modul. Existuje jet jedna nuance pi importovn modul z bal k . Pokud ped provedenm from balek import * e r u c u r c zavedete explicitn n jak modul tohoto bal ku, bude pi importovn vech jmen z modulu mezi nimi i tento modul. e e c r Ve snad nzorn vysv tl nsledujc kd (pedpokld, e soubor __init__.py je przdn soubor): e e r
import Sound.Effects.echo import Sound.Effects.surround from Sound.Effects import *
Po poslednm pkazu import budou v loklnm prostoru jmen na teny moduly echo a surround, protoe ji byly r c na teny pedchozmi pkazy import. (Toto chovn je nezvisl na prom nn __all__ a je vcelku logick, pokud c r r e jsme n jak modul zavedly a interpretr o n m "nev d l", pro pt si ho zapamatuje a pouv ho.) e e e e r e
46
Kapitola 6. Moduly
Stejn jako u modul , i u bal k plat: s konstrukc from ... import * zachzejte obezetn , nsledn starosti e u c u r e s nefunk nm a nepehlednm kdem vs propt vyl . Pokuste se j pouvat pouze v interaktivnch sezench. c r r e c
6.4.2
Odkazovn se na moduly uvnit bal ku r c
Mnohdy se potebuje jeden modul odkazovat na jin modul tho bal ku. Vyjd me z naeho modelovho pkladu. r c e r Modul surround bude potebovat n jakou funkci z modulu echo. V tomto ppad plat nsledujc: pkaz import r e r e r se nejprve podv do aktulnho bal ku a a pot prohled standardn cestu (ur enou prom nnou sys.path). c c e Proto m e modul surround jednodue pout import echo. Pokud by modul echo nebyl sou st aktulu c nho bal ku, pily by na adu standardn pravidla pro vyhledvn modulu. c r r Je-li bal ek strukturovan na podzen bal ky (v modelovm pklad napklad bal ek Sound), neexistuje c r c r e r c dn zp sob, jak se odkazovat na modul rodi ovskho bal ku, musme pout jeho pln jmno. Pokud teba u c c r modul Sound.Filters.vocoder potebuje modul echo bal ku Sound.Effects, mus pout pkaz from r c r Sound.Effects import echo.
6.4. Bal ky c
47
48
KAPITOLA
SEDM
Vstup a vstup
Kad program je vlastn pedpis, transforma n funkce, kter ur itm zp sobem pevd vstupn data na vstupn. e r c c u r Cel toto kapitola bude v novna zp sob m, ktermi m e program vstupn data zskat a naopak jak m e uivateli e u u u u vrtit svoje vstupn data. Program m e vstupn data vrtit dv ma zp soby, budto je naformtuje do ur itho tvaru tak, aby je uivatel mohl u e u c bez problm pe st a zape je na standardn vstup, nebo vstupn data ur itm zp sobem zakduje a ulo do u r c c u souboru.1
7.1
Formtovn vstupu
Cten, kter se dostal a sem, jist poznal dva zp soby, ktermi lze na obrazovku vytisknout n jakou hodnotu. Prvn, r e u e kter pichz v vahu pouze v ppad interaktivnho interpretru, je vyhodnocen vrazu, kdy interpretr vytiskne hodr r e notu tohoto vrazu na obrazovku. Druhou monost, pouitelnou vude, nabz pkaz print. Ten vype argumenty r jemu pedan na standardn vstup.2 r S nejv t pravd podobnost budete potebovat v t kontrolu nad formtovnm vstupu vaho programu. Samotn e e r e pkaz print vm nabz pouh vytisknut hodnot, je-li jich vce, odd l je mezerou. Jak jist ctte, nebude to to r e e prav oechov. Nyn mte dv cesty, ktermi se m ete dt, prvn - sloit j - spo v v napsn veker formtovac r e u e c logiky, druh - jednodu - pouv standardn modul string. Python umo uje pevst libovolnou hodnotu na et zec. K tomu slou dvojice funkc str() a repr(). Ekvivalenn r r e tem posledn jmenovan funkce je zapsn vrazu mezi obrcen apostrofy . e Funkce str() by m la vracet takovou reprezentaci argumentu, kter je srozumiteln pedevm pro clov ka. Proto e r pro et zce vrt jejich cistou hodnotu, pro reln csla vrt et zec, obsahujc desetinn rozvoj na 12 platnch cslic. r e r e Naproti tomu funkce repr() (a jej ekvivalent v podob obrcench apostrof ) vrac reprezentaci argumentu, kter je e u vhodn pro interpretr. Cili vrac hodnotu tak, jak bychom j zapsali do zdrojovho souboru. Nap. k et zc m pidv r r e u r vodn a ukon ovac uvozovky, reln csla vrac s pesnost na 17 platnch mst. Pro ty objekty, pro n neexistuje c r e citeln reprezentace, vrac funkce repr() stejnou hodnotu jako str(), to plat pedevm pro strukturovan datov r typy (seznamy, slovnky):
1 Poznamenejme, e na U NIX ovch systmech se str rozdl mezi ob ma pstupy, lze zde toti pesm rovat standardn vstup do souboru. To e r r e je ovem dno lozo tohoto vbornho systmu. 2 Dal monost je pouvat objekty reprezentujc standardn vstup (resp. standardn chybov vstup) sys.stdout (sys.stderr). Pomoc jejich metody write() do nich m ete zapsat libovoln et zec. Vce informac o t chto standardnch souborovch objektech zskte z dokumentu u r e e Python Library Reference.
49
>>> s = Ahoj svte. e >>> str(s) Ahoj svte. e >>> s "Ahoj svte." e >>> str(0.1) 0.1 >>> 0.1 0.10000000000000001 >>> x = 10 * 3.25 >>> y = 200 * 200 >>> s = Hodnota x je + x + a y + y + ... >>> print s Hodnota x je 32.5 a y 40000... >>> # Obrcen uvozovky je mon pout i s jinmi typy: ... p = [x, y] >>> ps = repr(p) >>> ps [32.5, 40000] >>> # Konvertovn etzc pid uvozovky a zptn lomtka: r e u r e ... ahoj = ahoj svte\n e >>> ahojs = ahoj >>> print ahojs ahoj svte\n e >>> # Zptn uvozovky meme pout i na tuple: e u ... x, y, (spam, eggs) "(32.5, 40000, (spam, eggs))"
Vratme se vak k problematice formtovn vstupu programu. Nejprve si uvedeme krtk pklad - program vypisur jc tabulku druhch a tetch mocnin: r
>>> import string >>> for x in range(1, 11): ... print string.rjust(x, 2), string.rjust(x*x, 3), ... # Nezapomete ukonujc rku na pedchozm rdku n c c r ... print string.rjust(x*x*x, 4) ... 1 1 1 2 4 8 3 9 27 4 16 64 5 25 125 6 36 216 7 49 343 8 64 512 9 81 729 10 100 1000
e Tento pklad je ukzkou pouit formtovac funkce string.rjust(), kter zarovn ret zec mezerami r vpravo, pi em jako ku sloupce pouije druh argument. Stejn tak existuj i funkce string.ljust() a rc r e string.center(). Jde o standardn funkce, kter pouze vrt upraven et zec. Pro vypsn jejich hodnoty musme pout pkaz print. r e r V pedchozm pklad si vimn te, jak pkaz print vloil mezi svoje argumenty mezery. (Pro zkrcen dku jsme r r e e r r ho rozloili na dva, prvn pkaz print je ukon en crku a nevypisuje tud znak konce dku). r c r U vech funkc, kter ovliv uj zarovnn et zce se setkme s problmem, kdy obsah pole m v t ku ne poaduje n r e e r
50
Kapitola 7. Vstup a vstup
e programtor. Zde si zapamatujte, e ve uveden funkce v tomto ppad zachovvaj p vodn ret zec, co sice r e u pokaz vae formtovn, nicmn data z stanou korektn. Pokud opravdu vte, e potebujete vsledek pevn oznout, e u r e r pouijte cosi jako string.ljust(x, n)[0:n]. Pro plnost si uvedeme jet ctvrtou funkci string.zfill(). Ta dopln et zec, kter reprezentuje n jak cslo, e r e e zleva nulami na poadovanou ku sloupce, pi em sprvn interpretuje znamnko plus a mnus ped cslem: r rc e r
>>> import string >>> string.zfill(12, 5) 00012 >>> string.zfill(-3.14, 7) -003.14 >>> string.zfill(3.14159265359, 5) 3.14159265359
Pro ely formtovn vstupu je mon pout i opertor %. Jak je vm zcela jist znmo, jde o opertor modulo c e (zbytek po d len), nicmn , pokud na mst prvnho operandu uvedete et zec, zm n se zcela jeho funkce. Za ne e e e r e e c toti pracovat obdobn jako C funkce sprintf(), prvn et zec je pouit jako tzv. formtovac et zec, pi em e r e r e rc vskyty specilnch znak jako %s, %r a dalch jsou nahrazeny ur itou hodnotou. u c Nyn se ve uveden vpis kdu pro vytit n tabulky druhch a tetch mocnin pepeme za pouit opertoru %: e r r
>>> for x in range(1,11): ... print %2d %3d %4d % (x, x*x, x*x*x) ... 1 1 1 2 4 8 3 9 27 4 16 64 5 25 125 6 36 216 7 49 343 8 64 512 9 81 729 10 100 1000
e Opertor % prochz ret zec - prvn argument a hled v n m pedlohy ve tvaru %<formt>. Posloupnost znak e r u <formt> specikuje, jak bude interpretovna hodnota pedan jako druh operand. M e se ur it jak konverzn r u c funkce (f - pevod z csla v plovouc dov crce na et zec, d - pevod cslo na et zec), tak i formt vsledku, r r r e r r e lze specikovat celkovou ku pole a po et cslic za desetinnou crkou. Vsledek konverzn funkce bude "dosazen" r c do p vodnho et zce:3 u r e
>>> import math >>> print Hodnota Ludolfova sla je piblin %5.3f. % math.pi c r e Hodnota Ludolfova sla je piblin 3.142. c r e
Budete-li chtt do jednoho et zce dosadit vce hodnot, mus bt prav operand tuple. To nm nzorn ukazuje dal r e e pklad: r
3 Poznamenejme,
e plnou tabulku kontrolnch znak a popis opertoru % najdete ve specikaci jazyka Python. u
7.1. Formtovn vstupu
51
>>> tabulka = {Adolf: 4127, Bta: 4098, Cyril: 7678} e >>> for jmeno, telefon in tabulka.items(): ... print %-10s ==> %10d % (jmeno, telefon) ... Bta e ==> 4098 Adolf ==> 4127 Cyril ==> 7678
Pro programtory v C bude dobrou zprvou, e formtovac sekvence opertoru % pracuj v tinou stejn jako v e e C. Pokud C funkci sprintf() pedte chybn argument, program v tinou skon s neoprvn nm pstupem do r e c e r pam ti, zatmco v Pythonu se z tohoto msta "pouze" roz vjimka. e r I vznam pkazu %s je mnohem voln j, originl v jazyce C pipout l na mst argumentu pouze et zec, zatmco r e r e e r e v Pythonu m ete pout libovoln typ. Jeho et zcovou reprezentaci opertor zsk pomoc nm ji d v rn znm u r e u e e funkce str().4 Podobn pr tvo pkaz %r a funkce repr(). r r Dal variantou, kterou Python usnad uje programtorovi ivot, je monost se ve formtovacm et zci (tj. tom, kter n r e stoj vlevo od opertoru %) odkazovat na poloku n jakho slovnku, ten je opertoru pedn jako druh argument. e r Formtovac pkaz pak bude mt tvar %(jmno_kle)<formt>: r c
>>> tabulka = {Adolf: 4127, Bta: 4098, Cyril: 8637678} e >>> print Bta: %(Bta)d; Adolf: %(Adolf)d; Cyril: %(Cyril)d % tabulka e e Bta: 4098; Adolf: 4127; Cyril: 8637678 r
Takto m eme velice "vkusn " vytisknout hodnotu n jak prom nn. Vyuijeme pitom funkce vars(), kter vrac u e e e r slovnk, obsahujc vechny prom nn (kl e jsou jmna prom nnch, hodnoty pak skute n hodnoty prom nnch): e c e c e
>>> ahoj = Vtme Vs >>> print Mme pro vs nsledujc zprvu: %(ahoj)s! % vars() Mme pro vs nsledujc zprvu: Vtme Vs!
7.2
Prce se soubory
Velice casto programtor potebuje pe st/zapsat n jak data z/do souboru. Pomineme-li monost U NIXovho shellu, r r c e jen doke pesm rovat standardn vstup a vstup programu, mus se o to programtor postarat sm. r e Ve v tin programovacch jazycch je soubor reprezentovn jako souborov objekt, kter obsahuje data o samotnm e e souboru. Ped jeho pouvnm programem ho musme otevt, cm vytvome v pam ti objekt reprezentujc tento r r r e soubor. Pi oteven specikujeme i dal potebn informace - jmno souboru, md pstupu (pouze ke cten, pouze r r r r pro zpis, pidvn, cten i zpis), velikost vyrovnvac pam ti pouit k pstupu k tomuto souboru atd. r e r Nov souborov objekt vytvome pomoc funkce open()5 . Tato funkce m jeden povinn argument - jmno souboru r a dal dva nepovinn, prvn z nich specikuje md pstupu (implicitn pouze pro cten) a druh velikost vyrovnvac r e pam ti (tento daj je d leit pro knihovnu jazyka C, je je pouita pro implementaci prce se soubory): e u
>>> f=open(/tmp/workfile, w) >>> print f <open file /tmp/workfile, mode w at 80a0960>
4 Oproti 5V
C vak nejsou podporovny n kter pkazy, jmenovit %n a %p. e r e nov jch verzch jazyka je preferovna funkce file() se stejnm rozhranm. e
52
Kapitola 7. Vstup a vstup
Z sta me na chvli u et zce, reprezentujcho md pstupu k souboru. Prvn monost je et zec r ur ujc pstup u n r e r r e c r pouze pro cten, v naem pklad jsme pouili md w, kter specikuje pstup pouze pro zpis. Dal monost je r e r a, kter oteve soubor pro pidvn, co je tot jako zpis, jen data se budou pidvat na konec souboru. Dejte r r r si pozor pi pouvn mdu w, pokud soubor existuje, budou data bez jakhokoli varovn smazna. Posledn md r r+ umo uje cten i zpis. n Na systmech Windows a Macintosh se setkte jet s modem b, kter zp sob oteven souboru v binrnm mdu. e u r Tyto systmy toti rozliuj mezi textovmi a binrnmi soubory. Z toho vyplv, e exituj i mdy jako rb, wb a r+b. Opomenut znaku b m e zp sobit nemal problmy, proto se ho snate pouvat i na platformch, kter u u sice tento md nepouvaj. Brzy byste toti mohli chtt v program portovat na jinou platformu a mohli byste se do kat nemilch pekvapen. c r
7.2.1
Cten a zpis souboru
Pedpokldejme, e existuje souborov objekt, pojmenovan f. Tento objekt nm poskytuje n kolik metod (funkc, r e kter se vou na tento objekt), pomoc nich m eme na tat obsah tohoto souboru. u c Prvn operac, kterou souborov objekty podporuj je cten jejich obsahu, k tomu slou metoda f.read(). Jako argument j m eme pedat i po et byt , kter se maj ze souboru pe st. Vsledn byty vrt jako et zec. Pokud bylo u r c u r c r e pi tomto voln f.read() dosaeno konce souboru, vrt se pouze ty znaky, kter v souboru zbvaly. Pi opakor r vanm cten za koncem souboru vrac tato metoda przdn et zec. Argument, specikujc po et byt je voliteln, v r e c u ppad , e se rozhodnete ho nespecikovat, pe te se cel obsah souboru. r e r c
>>> f.read() Toto je obsah celho souboru.\n >>> f.read()
Metoda f.readline() pe te ze souboru jeden dek a vrt ho jako et zec. Znak konce dku \n je obsaen r c r r e r na konci et zce. V ppad cten za koncem souboru vrac przdn et zec. To umo uje programu rozliit mezi r e r e r e n przdnm dkem a koncem souboru, przdn dek pak obsahuje jedin znak konce dku. r r r
>>> f.readline() Toto je prvn dka souboru.\n r >>> f.readline() Druh dka souboru\n r >>> f.readline()
Uite n metoda f.readlines() pe te n kolik dk ze souboru a vrt je jako seznam. Pokud j program neped c r c e r u r dn argument, pe te vechny dky, jinak pouze tolik byt , kolik ur uje argument a navc jet ty, kter jsou teba r c r u c e r k dokon en aktuln dky. Pro znak konce dku plat stejn pravidla jako u metody f.readline(). c r r
>>> f.readlines() [Toto je prvn dka souboru.\n, Druh dka souboru\n] r r
Z pomoci metody f.write() m eme do souboru zapisovat. Pedme j vdy et zec, kter se zape do souboru u r r e pesn tak, jak je. Tato metoda vdy vrac hodnotu None. r e
>>> f.write(Zkouka mikrofonu - 1 ... 2 ... 3\n)
V souboru je mon se i pohybovat a zjitovat aktuln pozici (tj. pozici, ze kter bude probhat dal cten a kam se 7.2. Prce se soubory 53
budou zapisovat dal data). Pomoc metody f.tell() m eme zjisti aktuln pozici (offset) ukazatele v souboru, u m enou v bytech od za tku souboru. Pro posunut tohoto ukazatele pouijete metodu f.seek(), jej prvn arer c gument bude specikovat offset a druh pozici vzhledem ke kter se offset vztahuje. Jestlie pozici nespecikujete (nebo pouijete hodnotu 0), bude offset reprezentovat novou vzdlenost ukazatele od za tku souboru, hodnota 1 bude c znamenat posun relativn k aktuln pozici (zporn hodnota posouv zp t), kone n hodnota 2 posun o offset byt e e c e u od konce souboru.
>>> >>> >>> >>> 5 >>> >>> d f=open(/tmp/workfile, r+) f.write(0123456789abcdef) f.seek(5) # Jdi na est byte v souboru f.read(1) f.seek(-3, 2) # Jdi na 3 byte ped koncem souboru r f.read(1)
Pokud jste skon ili vekerou prci se souborem, je slun ho uzavt, cm uvolnte systmov prostedky vyhrazen c r r k manipulaci s tmto souborem. K uzaven souboru slou metoda f.close(), po uzaven souboru ji nen mon r r k souboru jakmkoli zp sobem pistupovat: u r
>>> f.close() >>> f.read() Traceback (most recent call last): File "<stdin>", line 1, in ? ValueError: I/O operation on closed file
Dal metody souborovch objekt (f.isatty() nebo f.truncate()) se pouvaj pouze zdka a proto se jim u r zde nebudeme v novat, ppadn zjemce najde veker informace v Python Library Reference. e r
7.2.2
Modul pickle
e Jak jsme si ukzali, Python doke bez problm zapsat do souboru ret zce. Jestlie vak potebujete cst nebo zau r pisovat csla, neobejdete se bez dalho kdu, kter bude provd t ppadnou konverzi z csla na et zec a naopak. e r r e V ppad , kdy budete chtt zapisovat komplexn j datov typy jako teba seznamy, tuple, slovnky nebo dokonce r e e r instance uivatelskch td, budete muset bud napsat hodn kdu nebo pout ji pipraven modul pickle. r e r Ten um ukldat do souboru veker intern datov typy Pythonu, v tinu instanc uivatelskch td a dokonce i n ke r e ter formy kdu. Pro implementaci tohoto zpisu pouv pevod na et zcovou reprezentaci (tento proces se nazv r r e pickling nebo t serializace). Zrove doke z et zcov reprezentace zrekonstruovat p vodn objekt (unpickling, n r e u e deserializace). Ret zcov reprezentace objektu obsahuje veker informace o jeho vnitnm stavu, m ete j penst r u r po po ta ov sti nebo uloit do souboru a pesto pi deserializaci zskte zp t objekt s p vodnm obsahem. c c r r e u Pedpokldejme, e chcete do souboru f uloit n jak objekt x. Jednodue tak u inte funkc pickle.dump(): r e c
import pickle pickle.dump(x, f)
Pro rekonstrukci objektu ze souboru f sta pout funkci pickle.load(): c

x = pickle.load(f)
Modul pickle podporuje mnohem vce funkc, ne jsme si zde v krtkosti na rtli, kompletn pehled op t poskytne c r e 54 Kapitola 7. Vstup a vstup
Python Library Reference. Pipome me, e modul pickle je standardn modul pro implementaci perzistentnch objekt , tj. objekt , kter mohou r n u u bt uloeny a znovu pouity jinm programem, "ij" nezvisle na programu. A jeliko module pickle najdete v kad instalaci Pythonu, existuje siln tlak na tv rce novch modul , kte mus cht necht podporovat rozhran u u r e e tohoto modulu. Dky tomu je mon pomoc pickle ukldat i dal datov typy (nap. matice balku NumPy apod.). r
7.2. Prce se soubory
55
56
KAPITOLA
OSM
Chyby a vjimky
V pedchozm vkladu jsme ml ky pehleli jednu d leitou skute nost - dn program nen bez chyby. Pokud r c r u c uvaujeme chyby programtora, m e jt o syntaktick chyby (v tinou peklepy, patn napsan zdrojov kd) nebo u e r e chyby v logice programu (patn nvrh programu, chybn pouvn funkc atd.). Syntaktick chyby lze pom rn e e snadno odstranit, chyby v logice vak nikoli. Pokud ji program pracuje jak m, stle na n j p sob jaksi vn j vlivy e u e (opera n systm, ostatn programy, omezen vyplvajc z hardware apod.). Pokud se teba program sna zapisovat c r na disk a pitom je tento disk zapln n, b hov prosted Pythonu mu to sd l pomoc vjimek. Prv jim proto bude r e e r e e v novna pevn cst tto kapitoly. e r
8.1
Syntaktick chyby
Pokud jste si zkoueli jednotliv pklady v tto knize, ur it jste na n jak syntaktick chyby narazili. Syntaktick r c e e chyby vznikaj pi zpisu programu, pkladem budi nsledujc dka kdu: r r r
>>> while 1 print Ahoj, svte e File "<stdin>", line 1, in ? while 1 print Ahoj, svte e ^ SyntaxError: invalid syntax
Jist jste si vimli chyb jc dvojte ky za pkazem while. Pokud se takto zapsan kd pokuste pedat interpretru, e e c r r pak ho vyhodnot1 jako chybn zapsan a vyvol chybu (vjimku). e D sledkem vjimky je vytisknut chybov hlky, kterou vidte na pedchoz ukzce. Vimn te si pedevm mal u r e r "ipky", kter ukazuje na msto, kde byla chyba detekovna (tj. na pkaz print). Vskyt chyby lze pedpokldat v r r t snm okol tto ipky (v naem ppad ped pkazem print). Sou st chybovho vpisu je tak jmno souboru e r e r r c a cslo dky, take pesn vte, kde chybu hledat. r r e
8.2
Vjimky
Pokud je pkaz nebo vraz syntakticky sprvn , pokus se ho interpretr spustit. I v tto fzi vak m e dojt k chyb , r e u e proto interpretr podporuje mechanismus vjimek. Pomoc nich lze tyto chybov stavy indikovat a zajistit tak npravu. Kad vjimka nejprve vznikne, je vyvolna n jakm pkazem. Po vyvoln vjimky je ukon en aktuln pkaz a e r c r vjimka se z tohoto pkazu do funke, kter tento pkaz spustila, z tto funkce do funkce, kter j volala atd. stle r r r ve v zsobnku volanch funkc. Kad funkce m e vjimku odchytit, cm zastav jej en a m e j zpracovat. u r u
1 Syntaxe
programu se zpracovv v csti nazvan parser, proto se tak syntaktickm chybn n kdy k chyby pi parsovn. e r r
57
Pokud dn funkce vjimku neodchyt (tzv. neodchycen vjimka), odchyt ji interpretr, ukon program a vytiskne c chybov hlen:
>>> 10 * (1/0) Traceback (most recent call last): File "<stdin>", line 1, in ? ZeroDivisionError: integer division or modulo >>> 4 + spam*3 Traceback (most recent call last): File "<stdin>", line 1, in ? NameError: spam >>> 2 + 2 Traceback (most recent call last): File "<stdin>", line 1, in ? TypeError: illegal argument type for built-in operation
Jak vidte v ukzce, chybovch hlen existuje mnoho. Kad indikuje, k jakmu druhu chyby dolo, na jakm mst e v programu a krtk popis chyby. V pkladu ve najdeme nsledujc vjimky: ZeroDivisionError (d len r e nulou), NameError (neexistujc jmno prom nn) a TypeError (chybn datov typ). Vem t mto vjimkm e e odpovdaj intern prom nn, narozdl od jinch jazyk , kde v n kterch ppadech jde o kl ov slova! Popis chyby e u e r c se li v zvislosti na typu vjimky. V tinou ble specikuje okolnosti chyby. e Sou st chybovho vpisu je i vpis zsobnku volanch funkc. Tak lze chybu snadno lokalizovat, ur it jej p iny c c rc a zajistit npravu. Jako sou st vpisu funkc jsou vypsnu i csla dek, jmna soubor a samotn dek, na kterm k c r u r chyb dolo. Detailn popis vech internch vjimek hledejte v Python Library Reference, csti, zabvajc se modulem e exceptions.
8.3
Obsluhovn vjimek
Kad blok kdu v programu m e odchytit libovolnou vjimku, kter vznikne v jeho t le. Ukame si pklad: u e r
>>> while 1: ... try: ... x = int(raw_input("Zadejte cel slo: ")) c ... break ... except ValueError: ... print "Nebylo zadno sprvn, zkuste to znovu..." e ...
Jist jste pochopili, e jde o nekone n cyklus, kter se dotazuje uivatele na cel cslo (funkce raw_input()), e c kter nsledn peveden na cel cslo (funkce int()). "Vtip" je v tom, pokud funkce int() dostane patn argument e r (nep jde o cel cslo, nap. 1.0 nebo nula atd.), vyvol vjimku ValueError. u r U tohoto programu se setkme jet s jednou vjimkou. I kdy to nen na prvn pohled zejm, m e v libovolnm e r u mst programu vzniknout vjimka KeyboardInterrupt. Ta indikuje peruen od uivatele (tj. stisk kombinace e r klves Control-C). Tato vjimka odchycena nebude, tud cyklus se ukon . c Mon jste si vimli novho pkazu try, kter pracuje nsledovn : r e Nejprve je sput no t lo pkazu try (tj. kd mezi kl ovmi slovy try a except). e e r c Pokud tento kd nevyvol dnou vjimku, pokra uje b h programu a za pkazem try. c e r Dojde-li ovem k vyvoln vjimky, je program peruen v mst vzniku vjimky. Nsleduje porovnn typu r e vjimky s v tem vjimek za kl ovm slovem except (poznamenejme, e t chto v tv m e bt vce, kad c c e e u 58 Kapitola 8. Chyby a vjimky
s jinm v tem vjimek). Je-li odpovdajc v tev nalezena, vjimka je odchycena a je sput n kd odpovdajc c e e tto v tvi. Po jeho vykonn pokra uje b h normln za pkazem try. V ppad , e nen nalezena v tev e c e e r r e e (n kdy t handler) obsluhujc tuto vjimku, vjimka nen odchycena a se dle v zsobnku volanch e r funkc, pi em m e bt odchycena n jakm jinm pkazem try. rc u e r Pokud vjimka nebude odchycena a roz se a do hlavnho programu a odtud jet ve, odchyt ji interpretr, r e kter vytiskne chybov hlen (traceback) a ukon program. c Jak jsme si ekli o pr odstavc ve, m e mt pkaz try vce ne jednu v tev except, kadou denovanou pro r u u r e jin vjimky. V kadm ppad ale bude sput n vdy nejve jeden (tj. bud dn nebo jeden) handler obsluhujc r e e vjimku. Pokud u dvou r znch v tv except budou uvedeny stejn typy vjimek, Python to nevyhodnot jako u e chybu, ale je teba dt pozor, e ta v tev, kter je ve zdrojovm souboru uvedena jako druh nebude na tuto vjimku r e reagovat! V tev except m e specikovat vce jak jednu vjimku formou tuple2 n kolika typ vjimek. e u e u
... except (RuntimeError, TypeError, NameError): ... pass
U posledn v tve m eme dokonce vynechat v et vjimek pln . Pak tento handler funguje jako olk - zpracuje e u c e vechny vjimky, kter nebyly odchyceny pedchozmi v tvemi. Ovem i zde plat znm "veho s mrou", protoe r e unhlenm pouitm except bez vpisu vjimek m eme skrt n jakou chybu kdu, se kterou jsme pedem nepo u e r c tali. Pouit samotnho except se pmo nabz v ppad , kdy chceme vjimku sice odchytit, nsledn vypsat n jak r r e e e chybov hlen a vjimku znovu pustit do sv ta (vce o vyvoln vjimek se dozvte ne): e
import string, sys try: f = open(myfile.txt) s = f.readline() i = int(string.strip(s)) except IOError, (errno, strerror): print "I/O error(%s): %s" % (errno, strerror) except ValueError: print "Nemohu pevst data na cel slo." r c except: print "Neznm chyba:", sys.exc_info()[0] raise
Podobn jako jin pkazy, i pkaz try m volitelnou v tev else. Ta se zapisuje po vech handlerech a jej kd je e r r e sput n v ppad , kdy dn vjimka nenastala: e r e
for arg in sys.argv[1:]: try: f = open(arg, r) except IOError: print nemohu otevt, arg r else: print arg, obsahuje, len(f.readlines()), dk r u f.close()
2 Pipome me, r n
e pi zpisu tuple, v ppad , kdy nem e dojt k dvojzna nostem, m eme vynechat kulat zvorky. r r e u c u
8.3. Obsluhovn vjimek
59
Pokud n jak vjimka vznikla, pak m e mt piazenu n jakou hodnotu nazvanou argument vjimky. Jeho typ a e u rr e vznam se d typem vjimky. Pokud m n jak vjimka piazen argument, m eme uvst ve v tvi except za r e rr u e jmnem vjimky i jmno prom nn, kter se v ppad odchycen vjimky tmto handlerem piad argument vjimky. e r e rr Podle tohoto argumentu m eme rozhodnout o p inch chyby a zajistit nslednou akci programu na jej odstran n: u rc e
>>> try: ... spam() ... except NameError, x: ... print jmno, x, nen definovno ... jmno spam nen definovno
V ppad , kdy vjimka m n jak argument, je tento pouit jako popis vjimky (detail) v chybovm hlen interr e e pretru. Jeliko se vjimka v zsobnku volanch funkc vdy sm rem vzh ru, odchytv pkaz try nejen vjimky r e u r vzniknuv v bloku "jeho" kdu, ale i ve vech funkcch, kter vol. Napklad: r
>>> def chyba(): ... x = 1/0 ... >>> try: ... chyba() ... except ZeroDivisionError, detail: ... print Bhov chyba:, detail e ... Bhov chyba: integer division or modulo e
8.4
Vyvoln vjimek
Pkaz raise umo uje programov vyvolat vjimku ur itho typu, pi em lze specikovat i argument vjimky: r n e c rc
>>> raise NameError, Ahoj Traceback (most recent call last): File "<stdin>", line 1, in ? NameError: Ahoj
e V naem pklad bylo jmno vjimky NameError a jej argument ret zec Ahoj. Je zvykem vechny vjimky r e nazvat r znmi variacemi na tma Error, nap. TypeError, SyntaxError, ImportError a dal. Vznam a u r typ argumentu je, jak jsme si ji ekli, zvisl na typu vjimky. r V ppad , o n m jsme hovoili ve (viz except bez v tu vjimek) pouijeme pkaz raise bez argument . V r e e r c r u takovm ppad vyvol posledn vjimku, ke kter dolo, tedy: r e
60
Kapitola 8. Chyby a vjimky
>>> try: ... raise NameError, Ahoj ... except NameError: ... print Dolo k vjimce! ... raise ... Dolo k vjimce! Traceback (most recent call last): File "<stdin>", line 2, in ? NameError: Ahoj
8.5
Vjimky denovan uivatelem
Program m e denovat svoje vlastn vjimky jako tdy odvozen od tdy Exception (vce o tdch a objektovm u r r r programovn se dozvte z nsledujc kapitoly), nap.: r
>>> class MyError(Exception): ... def __init__(self, value): ... self.value = value ... def __str__(self): ... return self.value ... >>> try: ... raise MyError(2*2) ... except MyError, e: ... print Vyskytla se vjimka s hodnotou:, e.value ... Vyskytla se vjimka s hodnotou: 4 >>> raise MyError, oops! Traceback (most recent call last): File "<stdin>", line 1, in ? __main__.MyError: oops!
Tda vjimky m e bt denovna i jako potomek jin tdy ne Exception, v praxi se to ale nepouv. Vjimka r u r je plnohodnotnou tdou, m e denovat mnostv atribut a metod. V praxi t chto monost ale pli nevyuijeme, r u u e r vjimky by toti m ly bt jednoduch tdy slouc hlavn k informovn programu o chyb a jej p in . e r e e rc e Pokud pete n jak modul, kter pouv mnostv vjimek, je vhodn denovat spole nho pedka t chto vjimek, e c r e teba s nzvem Error a teprve od n j odvozovat vechny ostatn chyby. Pokud toti uivatel vaeho modulu bude r e chtt odchytit vechny vjimky, kter mohou ve vaem modulu vzniknout, m e napsat jedinou v tev except u e jmno_modulu.Error. Napklad: r
8.5. Vjimky denovan uivatelem
61
class Error(Exception): """Zkladn tda vech vjimek v tomto modulu.""" r pass class InputError(Error): """Vjimky vyvolan pro chyby vstupu. Atributy: expression -- vstupn vraz, ve kterm dolo k chyb e message -- popis chyby """ def __init__(self, expression, message): self.expression = expression self.message = message class TransitionError(Error): """Vyvolna, kdy se program pokus o nepovolenou zmnu stavu modulu. e Atributy: previous -- stav ped zmnou r e next -- nov stav message -- vysvtlen, pro dan zmna nen povolena e c e """ def __init__(self, previous, next, message): self.previous = previous self.next = next self.message = message
Mnoho standardnch modul Pythonu denuje vlastn tdy vjmek, jejich hiearchie je podobn ve uveden. Pokud u r jste zde uvedenmu vkladu td neporozum li, nelmejte si s tm hlavu. Pe t te si nsledujc kapitolu v novanou r e r ce e objektov orientovanmu programovn a pak se k tto csti vratte. e
8.6
Denovn clean-up akci
Pkaz try m e mt msto v tv except jedinou v tev finally. Ta se pouv pro tzv. clean-up akce, tj. kd, kter r u e e by m l bt sput n za vech podmnek a kter se star o korektn ukon en t la pkazu try (nap. zave oteven e e c e r r r r soubory nebo smae do asn data). Ukzkovou clean-up akci, reprezentovanou pkazem print vidte v nsledujcm c r pklad : r e
>>> try: ... raise KeyboardInterrupt ... finally: ... print Mjte se, lidi! e ... Mjte se, lidi! e Traceback (most recent call last): File "<stdin>", line 2, in ? KeyboardInterrupt
V tev finally je sput na za vech okolnost, pokud v bloku chrn nm pkazem try dojde k vjimce, je nejprve e e e r vykonna v tev finally a a pot je standardnm zp sobem vyvolna vjimka. Clean-up akce je vak sput na i e u e
62
Kapitola 8. Chyby a vjimky
v ppad , kdy k dn vjimce nedolo a blok je oput n normlnm zp sobem, ppadn pomoc pkazu return r e e u r e r apod. Castou chybou za te nk je pokus zkombinovat v tve except a finally. Pkaz try vdy mus mt bud pouze c c u e r v tve except nebo pouze v tve finally, v dnm ppad ne ob zrove . Pokud chcete vjimku odchytit a e e r e e n zrove denovat n jakou clean-up akci, pouijte dva do sebe vloen pkazy try, pi em jeden bude denovat n e r rc v tve except a druh v tev finally. e e
8.6. Denovn clean-up akci
63
64
KAPITOLA
DEVT
Tdy r
Jeden z hlavnch rys jazyka Python jsme dosud nezmnili. Jedn se o objektov orientovan programovn (OOP). u e Tento "modern" trend1 se v posledn dob cm dl tm vce rozmh. N kter lohy si bez n ho dokeme pouze t ko e e e e pedstavit (nap. komplikovan uivatelsk rozhran implementovan pomoc strukturovanho programovn by byla r r profesionln sebevrada). Pedeleme, e Python je v otzce objektov orientovanho pstupu k nvrhu programu r e r velice pokro il a obzvlt ve verzi 2.2 najdeme mnoho novch vlastnost. c e Obecn lze ci, e Python dky svmu akademickmu nvrhu (vznikl na univerzit v Amsterdamu) pouv to nejlep e r e z jinch objektov orientovanch jazyk . Hlavn mechanismy byly inspirovn jazykem C++ a Modula-3. Toho veho e u bylo dosaeno za pouit minima nov syntaxe, co umo uje snadn pochopen objektovho nvrhu pomoc jazyka n Python. Python tedy jmenovit podporuje tyto vlastnosti: d di nost (samozejmost je vcensobn d di nost), polymorse e c r e c mus (libovolnou metodu m e potomek pedenovat, slovy jazyka C++ jsou vechny metody virtuln), zapouzden u r r - vechny pedchoz vlastnosti mus podporovat kad jazyk, kter si chce kat objektov orientovan. Dal vlastr r e nosti, kter bud pmo nebo nepmo souvis s objektov orientovanm programovnm jsou: pet ovn opertor , r r e r e u mechanismus metatd, dynamick atributy a mechanismus vlastnost (properties), kooperativn voln metod, monost r odvodit tdu od internho typu atd. V dalch verzch jazyka lze po tat s dalm vvojem objektovho modelu jazyka, r c lze pedeslat, e jazyk bude podporovat rozhran (interfaces) a jet vce se v t chto verzch sete rozdl mezi internmi r e e r typy a uivatelskmi objekty.
9.1
Pouit terminologiie
Za objekt je v jazyce Python libovoln entita, nap. et zec, cslo, slovnk, seznam, modul ... to vechno jsou objekty. r r e Kad objekt m e mt svoje atributy. Jak jsme ji poznali, k pstupu k atribut m se pouv te kov notace, cili u r u c zpis ve stylu objekt.jmno_atributu. A pon vad jsme ped chvl ekli, e objekt je kad entita, i atribut je e r r op t objekt. Proto m eme pst i daleko rozshlej konstrukce, nap. window.button1.OnClick.handlers e u r apod. Mezi atributy m zvltn postaven metoda. Jde o funkci, kter ur itm zp sobem pat pouze k tomuto objektu. c u r Metody lze pouvat obvyklm zp sobem jako klasick funkce. Jsou vak v tinou ur eny pro modikovn vnitnho u e c r stavu objektu. Pro pochopen metod je d leit si uv domit, e kad metoda modikuje pouze "sv j" objekt. Podveu e u jme se na nsledujc kd:
1 Pestoe se zd, e jde o pom rn nov pstup, byl poprv pouit ji v sedmdestch letech v jazyce Simula. Od t doby do nyn jka se r e e r e objevilo mnostv jazyk pyncch se nlepkou objektov orientovan. u e
65
>>> >>> >>> >>>
list1 = [1, 3, 2, 0] list2 = [ahoj, bbbbbbb, AAA, root] list1.sort() list2.sort()
Nadenovali jsme si dva objekty seznamy a nsledn jsme pro n zavolali jejich metody sort(). Vimn t si, e e ee e ob metody, i kdy se jmenuj stejn , jsou r zn, protoe se kad ve k jinmu objektu. Metoda tedy modikuje e e u pouze ten objekt, k n mu se ve, ppadn vol jin metody jinch objekt . M e samozejm volat i jin funkce, e r e u u r e fantazii se meze nekladou. Pro d kladn vklad objektov orientovanho programovn bych vm doporu il n jakou u e c e z odbornch knich, kter na toto tma vychzej. Pokud pouijeme terminologii jazyka C++ jako zklad terminologie pouvan v jazyce Python, m eme rci, e u vechny metody objekt jsou virtuln ( ili libovoln odvozen tda m e tuto metodu pedenovat, pi em tuto u c r u r rc novou verzi budou pouvat vechny ostatn metody tohoto objektu). Zrove lze ci, e vechny atributy (tj. metody n r a data tdy) jsou veejn, jinmi slovy m k nim pstup jakkoli jin objekt. Tato vlastnost je pro Python kl ov, r r r c nic ped uivatelem neskrv a uivatel m e, pokud v co d la, modikovat intern data a tm doclit poadovanho r u e (nap. nestandardnho) chovn objektu. Veejn jsou i pseudo-privtn atributy, kter vyuvaj mechanismu nhrady r r soukromch jmen (vce o tto problematice si povme dle). V Pythonu neexistuj dn konstruktory a destruktory namsto nich zde existuje dvojice metod __init__ a __del__, kter maj obdobnou, ne vak stejnou funkci jako konstruktory a destruktory. Jazyk Python je zcela exaktn jazyk, cili mte pouze to, o co jste si ekli, prosted tm nikdy nemysl za vs. Proto nen mon z jedn metody r r er volat pmo jinou metodu tho objektu! Kad metoda proto pejm jeden speciln argument (v tinou pojmenovan r r e self ), kter reprezentuje objekt, jeho metoda je provd na. Chceme-li tedy z n jak metody vyvolat metodu tho obe e jektu se jmnem ekn me foo, pouijeme zpisu: self.foo(). Takto m eme pesn specikovat objekt, jeho r e u r e metodu chceme volat a nem e dojt k dnm nejednozna nostem. u c Obdobn jako v jazyce Smalltalk, i v Pythonu je tda tak objekt. To ale plat v Pythonu obecn libovoln datov e r e struktura je objekt, objektem jsou i intern datov typy, moduly, bloky kdu, instance td i tdy samotn. Jako v ji r r zmn nm Smalltalku, i Python umo uje od verze 2.2 d dit tdy od internch datovch typ , cm lze implementovat e n e r u specick zm ny v chovn tohoto typu (nap. vytvoit datov typ odvozen od seznamu, kter bude slouit pouze k e r r uloen et zc ). r e u Z n kterch jazyk (nap. C++) je znma monost pet ovn opertor . Python zavd radu "specilnch" metod, e u r r e u kter slou pro implementaci takto petench opertor . Proto nen problm nadenovat tdu Matice a implemenr u r tovat metodu __add__, kter je volna pi pouit opertoru + a kter tyto dv matice se te. Pet ovn opertor r e c r e u tedy velice zpr hled uje vsledn kd programu. u n
9.2
Prostory jmen
Jet ped samotnm vkladem td si n co povme o prostorech a oborech jmen v jazyce Python. Pochopen t chto e r r e e mechanism je d leit pro nsledn sprvn porozum n problematice td a objekt . Op t za neme denovnm u u e r u e c n kolika pojm . e u Jako prostor jmen se v Pythonu (a jinch jazycch) ozna uje zobrazen mezi jmny prom nnch a objekty kter c e reprezentuj. Lze to chpat nsledujcm zp sobem: objekty existuj nezvisle na jejich jmnech. Pokud vytvome u r n jakou prom nnou pomoc piazen, nevytvome tm nov objekt, pouze odkaz na objekt, kter stoj na prav stran e e rr r e piazen. Pokud si uvedeme nsledujc pklad: rr r
>>> d1 = {1: ahoj, 2: bla, 3: cvok} >>> d2 = d1
66
Kapitola 9. Tdy r
Pak skute n d1 a d2 odkazuj na tent objekt. Pokud nyn modikujeme jeden z t chto objekt , zm na se projev c e e u e i ve "druhm":
>>> d2[3] = cyril >>> print d1 {3: cyril, 2: bla, 1: ahoj}
Jmna lze tedy chpat i jako pouh odkazy na objekty. Proto pokud pedvme n jak objekt libovoln funkci, vdy r e se pedv odkazem. Pokud tento objekt modikujeme, zm na se projev i ve volajc funkci. r e Prostor jmen existuje v prosted Pythonu mnoho. Nap. kad modul m sv j prostor jmen, kad denice tdy zau r r u r vd tak nov prostor jmen, pi kadm voln funkce dojde k vytvoen novho (do asnho) prostoru jmen, dokonce r r c kad objekt m sv j prostor jmen ur en pro uchovn jeho atribut atd. Jmna uvnit jednoho prostoru jmen mus u c u r u u bt jedine n.2 V r znch prostorech jmen se ovem mohou nachzet stejn jmna odkazujc na r zn objekty. c Pi kadm vyvoln funkce je vytvoen nov prostor jmen, do n ho se ukldaj lokln prom nn a formln paramer r e e try. Tento prostor jmen zanikne po ukon en funkce. Pi rekurzivnm vyvoln funkce vznikne nov prostor jmen, tud c r jednotliv voln nesdl spole n objekty. c Jak jsme si ji rekli, objekty mohou mt mnoho atribut , jejich jmna m objekt uloen ve svm prostoru jmen. u Z hlediska pstupu k atribut m jsou vechny atributy veejn a dle se clen na atributy pouze pro cten a atributy r u r zapisovateln. To, o jak typ atributu se jedn se dozvte v tinou z dokumentace tohoto objektu. Napklad vechny e r atributy modul (tj. obsah modulu) je zapisovateln, tud kd m e m nit vechny atributy - hodnoty uvnit tohoto u u e r modulu. Obecn je mon zapisovateln atribut tak smazat pkazem del. e r Protoe kad jmno prom nn je sou st n jakho prostoru jmen, pouv Python tzv. obory jmen. Kadmu oboru e c e jmen je piazem jmenn prostor a vechna jmna z tohoto prostoru jmen je mon dky tomu, e jsou sou st oboru rr c jmen, pouvat bez kvalikace, tj. bez uveden prostoru jmen. I kdy to zn pon kud krkolomn , je za tm skryto e e logick chovn vech prom nnch. Pokud programtor n kde nape jmno promenna, ani by uvedl, e se jedn o e e atribut n jakho objektu, nap: e r
>>> vysledek = 3 * promenna
za ne interpretr prohledvat vechny obory jmen v pesn denovanm poad. Pon vad obor jmen nen nic jinho ne c r e r e jmenn prostor, m e obsahovat prom nn. Pokud prvn obor jmen hledanou prom nnou neobsahuje, je prohledvn u e e druh obor jmen a pak dal atd. V po tcch jazyka Python existovaly pesn vymezen ti obory jmen: lokln, globln a internch jmen. Jim c r e r piazen prostory jmen se li v zvislosti na prv provd nm kdu. Tak teba pi vyvoln funkce obsahuje lokln rr e e r r obor jmen lokln jmenn prostor funkce, cili obsahuje lokln prom nn, globln obor jmen pak odpovd jmene nmu prostoru modulu, kter danou funkci obsahuje, cili denuje globln prom nn. Intern obor jmen vdy obsahuje e jmenn prostor modulu __builtin__, kter denuje intern funkce (nap. abs() nebo file()). r Kad piazen vytv novou prom nnou v loklnm oboru jmen, uvnit funkce tedy kad piazen vytv novou rr r e r rr r lokln prom nnou. Zde si vimn te jist asymetrie, pestoe Python umo uje pouvn jak loklnch, tak globlnch e e r n a internch jmen zrove , kad piazen vytvo pouze lokln prom nnou, nelze proto piadit hodnotu globln n rr r e rr prom nn nebo dokonce intern. e K tomu je v Pythonu pkaz global3 , jen umo uje specikovat, e tato prom nn je globln a tud i kad r n e piazen tto prom nn zm n hodnotu odpovdajc prom nn v globlnm oboru jmen: rr e e e
2 Ve skute nosti je v tina prostor jmen implementovno jako datov typ slovnk, jeho kl e tvo jmna prom nnch a hodnoty jsou objekty, c e u c r e ne n tyto prom nn odkazuj e e 3 Spe ne o pkaz se jedn o direktivu. r
9.2. Prostory jmen
67
>>> def f(): ... global x ... x = 1 ... >>> x Traceback (most recent call last): File "<stdin>", line 1, in ? NameError: name x is not defined >>> f() >>> x 1
Ve co jsme si rekli o piazen plat i o jinch pkazech, kter vytvej nov jmna prom nnch. Napklad jde o rr r r e r pkaz import nebo o pkazy vytvejc nov pojmenovan objekty jako def nebo class. Obdobn se chov i r r r e pkaz pro odstran n jmna prom nn del. r e e V sou asnosti Python pouv novou architekturu obor jmen, kdy ke standardnm tem obor pibyl ctvrt, kter je c u r u r umst n mezi lokln a globln. Jde o tzv. nadzen obor jmen. Pedstavte si nsledujc situaci: mme funkci f(), e r r kter ve svm t le denuje funkci g(). Chceme-li nyn, aby funkce g() pouvala prom nn z nadzen funkce f(), e e r budeme k nim pistupovat zrovna pes nadzen obor jmen. Jde tud o obor jmen obsahujc prostory jmen volajcch r r r funkc.
9.3
Tdy poprv ... r
Abychom mohli pouvat sv vlastn objekty (v mluv objektov orientovanch jazyk se jim k instance td) e e u r r musme si nejprve nadenovat tdu, z n lze pot jednoduchm zp sobem vytvoit instanci. r u r V n kterch jazycch se tda chov podobn jako datov typ, v Pythonu vak tda je klasick objekt, stejn se s n e r e r e pracuje a vechno co plat pro objekty plat i pro tdy. r Co je pro tdy ale obzvlt d leit dvaj vem instancm stejn vlastnosti. V praxi to znamen, e nap. metodu si r e u r nadenujeme uvnit tdy a automaticky j zskaj i vechny instance tto tdy. Nzorn si tuto situaci m ete pedstavit r r r e u r teba takto: mme obecnou tdu auto, kter denuje spole n vlastnosti, teba metodu jezdi() nebo tankuj(). r r c r Ve skute nosti je ale tda auto jaksi automobilka, teprve jej instance jsou skute n auta. Automobilka pouze ur , c r c c jak se budou auta chovat (to odpovd implementovn metod) a a samotn auto budou toto chovn vykonvat (co neznamen nic jinho zavoln metody na n jak instanci). e Tda je tedy jaksi ablona ur ujc chovn vem jejm instancm. Proto lze zm nou denice tdy doshnou zm ny r c e r e chovn vech jej instanc objekt . u
9.3.1
Denovn td r
Python pro denici tdy zavd nov pkaz class, kter vytvo novou tdu. Pkaz class se chov podobn jako r r r r r e denice funkce, kter vytvo funkci z pkaz , kter obsahuje jej t lo. Obdobn i pkaz pro vytvoen tdy, kter r r u e e r r r vytvo novou tdy se zadanm jmnem, jej chovn (metody, atributy apod.) budou ur ovat pkazy v jejm t le: r r c r e
68
Kapitola 9. Tdy r
class Jmno_tdy: r <pkaz-1> r . . . <pkaz-N> r
Podobn jako u funkc, i u td mus bt ped prvnm pouit tdy tato tda zadenovna. Jinmi slovy, mus bt e r r r r sput na jej denice. Z toho nm plynou n kter uite n vlastnosti Pythonu, napklad denici tdy m eme umstit e e c r r u do v tve pkazu if a podle n jak podmnky se m eme rozhodnout, jak tdu denujeme. e r e u r Uvnit t la denice tdy jsou specick pkazy, ktermi se denuje chovn tdy. V tinou se jedn o denice funkc, r e r r r e uvnit t la tdy se ale pkaz def chov pon kud odlin ji od standardnho pkazu denice funkce, tak jak ho znme r e r r e e r z pedchozho povdn. Nenabvejte ale dojmu, e zde nen povoleno nic vce ne denice metod, Python dovoluje r do t la tdy umstit libovoln pkazy, kter budou vykonny pi sput n denice tto tdy. e r r r e r Pi vykonn denice tdy je vytvoen nov prostor jmen, kter je pouit jako lokln obor jmen uvnit t la tdy. r r r r e r Z vlastnost obor jmen je nm ji jasn, e vechna jmna prom nnch, kter uvnit t la tdy vytvome budou u e r e r r umst na v prostoru jmen tto tdy. e r Pokud se denice tdy provede normln (tj. nedojde v t le k dn vjice), pak je vytvoen objekt tdy, cili r e e r r Pythonov objekt reprezentujc tuto tdu. Objekt tdy je uloen pod jmnem, kter bylo zadno pi denici funkce. r r r Tento objekt, krom jinho, vytv jaksi obal nad vytvoenm prostorem jmen. Po vytvoen objektu tdy je obnoven e r r r r lokln obor jmen, kter je nastaven zp t tak, aby obsahoval stejn obor jmen jako ped sput nm denice funkce. e r e
9.3.2
Objekty typu tda r
Tdn objekty obsahuj, jak ji bylo e eno, prostor jmen uchovvajc objekty, kter byly denovny v t le funkce. r r c e Krom toho ale podporuje i dal dva druhy operac zpstupn n atribut a vytvoen instance. e r e u r Nejprve se budeme v novat atribut m tdy. Jak jsme si rekli hned na za tku tto kapitoly, kad objekt m e mt e u r c u mnoho atribut a ani tdy nejsou vjimkou. Jmna atribut odpovdaj jmn m ve jmennm prostoru tdy. Pokud u r u u r tedy budeme uvaovat tdu MojeTda, kter je denovna takto: r r
class MojeTda: r "Jednoduch tda" r i = 12345 def f(self): return ahoj
pak MojeTda.i a MojeTda.f jsou atributy tdy MojeTda. Prvn z nich odkazuje na objekt csla 12345 r r r r a druh na funkci f. Vechny atributy tdy jsou jak pro cten, tak je do nich umon n i zpis. r e e Vimn te si ret zce, kter je uveden na druhm dku denice tdy. Jde o dokumenta n et zec, kter funguje e r r c r e pln stejnm zp sobem jako dokumenta n et zec n jak funkce. Tento et zec je mon zpstupnit jako atribut e u c r e e r e r __doc__. Vytven instanc pouv zpis funk nho voln. Nenechte se vak zmlit, opertor voln funkce a vytvoen inr c r stance m pln jin vznam a funkci. Pokud pouijeme tdu MojeTda a jej denici, kterou jsme si uvedli ve, e r r pak instanci tto tdy m eme vytvoit pomoc pkazu: r u r r
x = MojeTda() r
Nyn ji bude jmno x odkazovat na instanci tdy. Tato instance, jinmi slovy t instan n objekt je przdn, nem r c 9.3. Tdy poprv ... r 69
nastaveny dn atributy. Pokud bychom tento objekt cht li hned po vytvoen nastavit do n jakho stavu, jinmi slovy e r e nastavit n jak jeho atributy, m eme denovat speciln metodu s nzvem __init__(). Prozatm bych poprosil e u ctene o trochu shovvavosti, pojem metoda si rozvedeme dle v tto kapitole. r
def __init__(self): self.data = []
Metoda (funkce) __init__() je zavolna pi vytvoen instance tdy, pi em za argument self je dosazena tato r r r rc instance. Novou ziniciovanou instanci zskme op t pomoc objektu tdy: e r
x = MojeTda() r
Metoda __init__() nm nabz i dal monost denovat ji s vce argumenty, pak budou tyto argumenty vyadovny pi vytvoen instance, budeme je tedy muset pedat objektu tdy, kter nsledn zavol metodu r r r r e __init__() a vechny argumenty j ped: r
>>> class Complex: ... def __init__(self, realpart, imagpart): ... self.r = realpart ... self.i = imagpart ... >>> x = Complex(3.0, -4.5) >>> x.r, x.i (3.0, -4.5)
9.3.3
Instan objekty c
Ji mme vytvoeny instance tdy. kla operac, kterou nm instance nabz je ale jet u ne umo uj tdy, jde r r e n r o pouh zpstupn n atribut . Jazyk Python rozliuje dva druhy atribut , jednak jde o datov atributy a pak o tzv. r e u u metody. Datov atributy Datov atributy se nazvaj v terminologii r znch objektovch jazyk r zn , nap. Smalltalk je nazv "instan n u u u e r c prom nn" a C++ "datov cleny". Datov atributy vznikaj podobn jako prom nn pi denici, tj. pi prnm piazen e e e r r rr n jak hodnoty jejich jmnu. Pokud budeme pokra ovat v pedchozm pkladu s tdou MojeTda a budeme pede c r r r r r pokldat, e x je jmno odkazujc na instanci tto tdy, pak nsledujc fragment kdu vytiskne hodnotu 16: r
x.counter = 1 while x.counter < 10: x.counter = x.counter * 2 print x.counter del x.counter
Metody Krom datovch atribut rozliuje Python jet metody. Ji n kolikrt v tto publikaci zazn lo, e metoda je funkce e u e e e patc k ur itmu objektu. O pr dk ve jsme si ekli, e i instance jsou objekty a proto tdy umo uj denovn r c r u r r n 70 Kapitola 9. Tdy r
metod, kter se chovaj naprosto stejn jako metody jinch objekt (nap. seznam ). e u r u Jmna metod se specikuj v denici tdy. Python pi rozliovn mezi datovmi atributy a metodami postupuje velice r r jednodue. Pokud je n jak objekt v t le tdy funkce, pak jde o metodu, jinak jde o datov atribut. e e r Pokud se op t zam me na pklad s instanc x tdy MojeTda, potom x.f je metoda, protoe tda MojeTda e er r r r r r denuje funkci f, oproti tomu x.i je datov atribut, jeliko t lo tdy denuje i jako cslo 12345. e r Dejte si pozor na nsledujc: Zatmco x.f je metoda f instance x, MojeTda.f je funkce. Zapamatujte si proto, r e o metodu se jedn pouze v ppad , kdy k tto metod existuje i instance. Funkce MojeTda.f je pouze jaksi r e e r prototyp metody x.f, metoda z n vznikne spojenm s instanc. Kad metoda se chov stejn jako funkce (jedin rozdl oproti funkci je jej provzanost s instanc), m eme j tedy e u volat jako funkci:
x.f()
Protoe MojeTda.f kdykoli vrac et zec ahoj, pak i tato metoda vrt ahoj. Metodu ale nemusme volat r r e pmo, m eme j uloit do n jak prom nn a zavolat pozd ji. Zde si, prosm, uv domte, e instance, pro kterou r u e e e e bude metoda volna se neur uje podle objektu "ped te kou", ale je pevn zapsn v t kter metod . Proto je mon c r c e e metody uchovvat pod jinmi jmny a v bec, pracovat s nimi jakoby to byly oby ejn funkce, co nejlpe demonstruje u c nsledujc pklad: r
xf = x.f while 1: print xf()
Podvejme se tedy na to, co se stane, je-li metoda zavolna. Protoe Python provd roztd n mezi datovmi atributy r e a metodami ihned pi vytvoen instance, m ji v tuto chvli "jasno" ohledn toho, e je 100% volna metoda. r r e Kad metoda je sloena z odpovdajc funkce a instance tdy. B hov prosted Pythonu proto z metody tyto dv r e r e vlastnosti zsk a nsledn zavol prv vyextrahovanou funkci s t mito atributy: prvn bude instance (je vm ji jasno, e e e pro kad metoda m prvn argument self?) a pak nsleduj ty atributy, kter byly pedny pi voln metody. c r r Proto je nutn kadou metodu denovat s jednm argumentem "navc". Za tento atribut se pak pi voln metody r dosad instance, pro kterou byla metoda zavolna. A co vc, pomoc tohoto argumentu se odkazujeme na datov atributy instance. Instanc toti m e bt vytvoeno mnoho, ale pi b hu metody dky ve popsanmu mechanismu u r r e mme jistotu, e vdy pouvme tu sprvnou instanci (tj. tu, pro n jsme metodu volali). Python dokonce umo uje toto rozloen na instanci a funkci nechat na programtorovi, kter m e tuto funkci zavolat n u a msto prvnho argumentu j pedat rovnou instanci: r
x.f() MojeTda.f(x) r
Tyto dva zpisy jsou ekvivalentn. Dobe si je zapamatujte, protoe v n kterch situacch muste metody volat takto r e explicitn , protoe chcete pout jinou funkci, ne kterou by pouil interpretr. e Poznamenejme, e jako prvn argument m ete funkci, kter de facto reprezentuje metodu pedat pouze instanci jej u r tdy. Pokud se pokuste o jakkoli jin postup, nekompromisn dojde k vjimce: r e
MojeTda.f(fooo) r Traceback (most recent call last): File "<stdin>", line 1, in ? TypeError: unbound method f() must be called with instance as first argument
9.3. Tdy poprv ... r
71
9.4
Tdy podruh ... r
Nyn nsleduj nhodn poznmky, kter se (pevn ) tkaj problematiky objektov orientovanho programovn v r e e jazyce Python. Pon vad datov atributy a metody sdl ve stejnm jmennm prostoru, dojde pi piazen n jak hodnoty n jakmu e r rr e e jmnu uvnit t la promn nn k pepsn metody, kter m la stejn jmno. To nejlpe demostruje nsledujc fragment r e e r e kdu:
class Trida: def foo(self, x): return x + 1 foo = novy text
Pak ji atribut instance tdy Trida neobsahuj metodu foo, nbr datov atribut tdy Trida.foo. Proto je vhodn r r u pouvat ur itou konvenci pro pojmenovvn datovch clen a metod. Podle jedn z nich m ete nap. datov atributy c u r pst s malm a metody s velkm po te nm psmenem. Dal monost je pojmenovvat datov atributy podstatnmi c c jmny a metody slovesy. Podobnch konvenc existuje mnoho a jist si brzy osvojte tu "svoji". e Datov atributy n jak instance jsou pstupn jak metodm tto instance, tak i jakmukoli jejmu uivateli (klientovi). e r Python nepodporuje modiktory atribut , ktermi by bylo mon ur it datov atributy prohlsit za soukrom. Je u c mon pouvat pouze pseudo-soukrom atributy o nich si budeme povdat dle v tto kapitole. e Z pedchozho odstavce plyne i nemonost vytvoen cist abstraktnch datovch typ v jazyce Python, protoe dn r r u tda nedoke skrt svoje atributy ped zraky ostatnch objekt . Pokud vak tuto tdu pepete do C, implementa n r r u r r c detaily se skryj a pouv se pouze rozhran tto tdy. V jazyce C se ale programuje velice nepohodln (v porovnn r e s Pythonem) a tud se tento krok nedoporu uje. c Pestoe vechny datov atributy instanc jsou veejn, m li by je klientsk objekty pouvat s obezetnost. Klient r r e r toti m e poruit sloit zvislosti mezi daty uvnit instance a metody instance by pak nemusely pracovat sprvn . u r e Pokud ovem vte, e v pstup nenaru konzistenci instan nch dat, pak vm nikdo nebrn tyto datov atributy r c modikovat a doshnout tak poadovanho chovn objekt . Klienti instance dokonce mohou do jejho jmennho u prostoru ukldat sv vlastn atributy, cm lze nap. ozna kovat ur it instance apod. Jedinm pedpokladem je, e r c c r pouijete uniktn jmno atributu. Tm se vyhnete kolizi s datovmi atributy instance. Jak jsme si ji jednou ekli, v Pythonu neexistuje dn zkratka, kterou se lze odkazovat na datov atributy, ppadn r r e jin metody z metody tto instance. Vdy muste tyto atributy a metody kvalikovat, co neznamen nic jinho, ne ped n uvst jmno self a te ku. Toto opaten vysoce zvyuje citelnost kdu, i pi letmm pohledu na zdrojov kd r e c r r nelze zam nit lokln a instan n prom nnou. e c e Podle ustlench konvenc je prvn argument metod vdy pojmenovn self. Pestoe jde pouze o konvenci a nikdo r vm nebrn v pouvn vlastnho jmna, nedoporu uje se to. Kdykoli, kdy tuto konvenci porute, pinejmenm c r zmatete ctene zdrojovho kdu. N kter programy, kter umo uj interaktivn prochzet datovmi strukturami a r e n e objekty denovanmi v prosted interpretru, mohou bt tak zmateny. r Kad jmno uloen ve jmennm prostoru tdy a odkazujc na funkci, znamen zaveden nov metody pro instance r tto tdy. Pitom nen nutn, aby tato funkce byla pmo uloena v t le denice tdy. Lze j napklad denovat ped r r r e r r r tdou samotnou a v t le tdy pouze tento funk n objekt piadit n jakmu jmnu: r e r c rr e
72
Kapitola 9. Tdy r
# Funkce definovan mimo tdu r def f1(self, x, y): return min(x, x+y) class C: f = f1 def g(self): return ahoj h = g
Po proveden t chto denici jsou f, g a h atributy tdy C, odkazuj vak na jedinou funkci f1. Zrove jsou f, g a e r n h jmna metod instanc tdy C. Kad z t chto metod vak m stejnou implementaci funkci f1. T mto praktikm r e e se pokud mono vyhn te, protoe dok dokonale zmst, v n kterch ppadech je ale jejich pouit ospravedlniteln e e r zjednoduenm kdu ppadn zvenm funk nosti vslednho programu. r e c Jak ji bylo n kolikrt e eno, jedna metoda m e volat druhou pomoc argumentu self. Ten reprezentuje instanci e r c u pro n byla metoda zavolna a tud obsahuje vechny jeho metody:
class Bagl: def __init__(self): self.data = [] def pridej(self, x): self.data.append(x) def pridej_dvakrat(self, x): self.pridej(x) self.pridej(x)
Protoe krom speciln chovn metod, kter umo uje jejich provzn s instancemi jde o oby ejn funkce, lze z nich e n c pouvat i globln prom nn a dal vymoenosti funkc jako jsou argumenty pro prom nn po et parametr apod. e e c u Podobn jako u funkc, i metody maj jako sv j globln obor jmen jmenn prostor modulu, je obsahuje denici tdy e u r (zde pozor na cast omyl: jmenn prostor tdy nikdy nen globlnm oborem jmen!). r
9.5
c Tdy potet (Dedi nost) ... r r
Jedna ze t zkladnch vlastnost objektov orientovanho programovn se nazv d di nost. Protoe tato publikace r e e c nechce bt u ebnic programovn, ale pouze pr vodcem jazykem Python, nebudeme zde zachzet do detail , to c u u ponechme fundovanm u ebnicm objektov orientovanho programovn. c e Proto si pouze ekneme, co nm d di nost umo uje. Jedn se vlastn o odvozen nov tdy z n jak p vodn, pi em r e c n e r e u rc nov a p vodn tda jsou v ur itm vztahu a pedpokld se, e odvozen tda denuje vechny metody svho pedka u r c r r r a jet m e denovat n kter metody navc. Tyto nov denovan metody mohou roziovat nebo dokonce pln e u e e r e pedenovvat chovn pedka. r r Pokud tedy budeme uvaovat tdu Bagl ze zv ru pedchoz csti tto kapitoly a budeme j chtt rozit tak, aby pi r e r r r pidn n jakho novho prvku vytiskla jet hlen o tom, jak prvek pidv, pouijeme nsledujc denici tdy: r e e r r
c 9.5. Tdy potet (Dedi nost) ... r r
73
class Bagl_s_tiskem(Bagl): def __init__(self): print iniciuji bagl Bagl.__init__(self) def pridej(self, x): print pridavam prvek %s % x Bagl.pridej(self, x) def pridej_dvakrat(self, x): print pridavam dvakrat: Bagl.pridej_dvakrat(self, x) def pridej_trikrat(self, x): print pridavam trikrat: self.pridej_dvakrat(x) self.pridej(x)
Tm jsme denovali novou tdu, kter je odvozen od tdy Bagl (viz hlavi ka denice). V tto td jsme peder r c r e r novali chovn p vodnch metod tak, e nejprve vytisknou hlen a pot zavolaj metodu tak, jak byla denovna v u pedkovi (viz zpis pomoc atributu nadzen tdy Bagl.pridej(self, x)). r r r Velice d leitou vlastnost, kterou by m lo podporovat tak kad objektov orientovan prosted je polymorsmus. u e e r V Pythonu je jeho podpora samozejmost. Proto si vimn te metody Bagl_s_tiskem.pridej_dvakrat(). Ta r e nejprve vytiskne klasick hlen a poslze zavol metodu svho pedka. Nyn se podvejte na to, jak je denovna r metoda Bagl.pridej_dvakrat() dvakrt zavol metodu pridej(). Tato metoda je ovem hledna v instanci, kde se jako prvn naraz na metodu Bagl_s_tiskem.pridej(). Tm vlastn p vodn kd vyvol a pouije e u na novou metodu. Podailo se nm ji dokonale pedenovat. r r Hledn atribut (je jedno jestli datovch atribut nebo metod) instance se d je velice jednoduchm zp sobem. Nejprve u u e u se prohled tda tto instance, pokud je atribut denovn zde, kon me a pouije se jeho hodnota. Pokud se zde atribut r c nenajde, zkus Python prohledat pedky tto tdy, pokud n jac existuj. Existuje toti monost, e n jak metoda, r r e e kterou v potomkovi nechceme pedenovat, bude denovna v pedkovi. A protoe pedek op t m e bt potomkem r r r e u n jakho prapedka, zkus se atribut najt v ppad nesp chu i v tomto prapedkovi. Pokud se dosp je ke koeni e r r e e r e r stromu td, ale dn odpovdajc atribut nen nalezen, dojde k vjimce AttributeError. r Protoe metoda denovan v potomkovi v tinou pouze roziuje funk nost p vodn metody, je casto nutn volat e r c u metodu pedka. Python nepodporuje pm vyvoln metody pedka, tud muste pout druhou monost voln r r r metody, kter vyuv funk nho objektu odpovdajcho metod . V potomkovi proto zavolme tuto funkci denoc e vanou v pedkovi a jako argument mu pedme argument self a dal argumenty. Takto nemusme volat pmo r r r metodu pmho pedka, postup lze pout i na prapedky apod. r r r Nae vzorov odvozen tda dokonce roziuje paletu metod svch instanc, protoe denuje metodu r r pridej_trikrat(), kter ke sv implementaci vyuv metody pridej() a pridej_dvakrat(). Obecn e lze ci, e instance zd d n tdy je svoj funk nost nadmnoinou instance svho pedka, co znamen, e denuje r e e r c r ve co pedek a jet n jak metody nebo datov atributy navc. Proto lze v tinou instance potomka pouvat na r e e e mstech, kde jsou o ekvny instance pedka. c r Je-li n jak objekt instanc ur it tdy nm umo uje zjistit intern funkce isinstance(), kter jako prvn argue c r n ment pedme objekt a druh argument tdu. Funkce pak vrt 1, jestlie objekt je instanc tdy, 0 je-li tomu jinak. r r r Zrove plat, e instance n jak odvozen tdy je vdy i instanc rodi ovsk tdy: n e r c r
74
Kapitola 9. Tdy r
>>> >>> >>> 1 >>> 1 >>> 0 >>> 1
batoh1 = Bagl() batoh2 = Bagl_s_tiskem() isinstance(batoh1, Bagl) isinstance(batoh2, Bagl) isinstance(batoh1, Bagl_s_tiskem) isinstance(batoh2, Bagl_s_tiskem)
9.5.1
c Vcensobn dedi nost
V Pythonu je samozejmost vcensobn d di nost. Tdu s vce pedky denujeme podobn jako tdu s jednm r e c r r e r rodi em: c
class OdvozenTda(Rodi1, Rodi2, Rodi3): r c c c <pkaz-1> r . . . <pkaz-N> r
Zkladn a jedin pravidlo, kter muste uvaovat pi prci s instancemi td, kter maj vce pedk je "nejprve cel r r r u strom, a pak dal tdy zleva doprava". Tato magick v ta nm dva tuen o tom, jak funguje vyhledvn atribut r e u u td s vce pedky. Pokud toti atribut nen nalezen ve td tto instance, hled se u jejch pedk . Ve uveden r r r e r u pravidlo pak ur uje poad v jakm jsou prohledvny rodi ovsk tdy. Prvn cst v ty znamen jednodue, e nejprve c r c r e Python bude prohledvat prvn rodi ovskou tdy (v naem ppad Rodi1) a jej pedky. A pokud dan atribut nen c r r e c r nalezen (m e jm bt jak datov clen tak metoda), prohledv se druh rodi ovsk tda (Rodi2) a jej pedci. A u c r c r v ppad selhn i zde se pokra uje posledn rodi ovskou tdou (Rodi3) a jejmi pedky. M e nastat situace, kdy r e c c r c r u dan atribut nen nalezen ani v tto td , pak ale dojde k vjimce AttributeError a b h programu se peru. r e e r Sou st kad u ebnice, kter se alespo okrajov zmi uje o objektov orientovanm programovn v libovolnm c c n e n e jazyce, jen podporuje vcensobnou d di nost, je tm vdy varovn ped zneuvnm tohoto mechanismu. Ani e c er r nae publikace v tomto sm ru nebude vjimkou. Nadm rn pouvn vcensobn d di nosti vede dve nebo pozd ji e e e c r e ke zmaten jak ctenu kdu, tak samotnho programtora. Plat zde vce ne kdekoli jinde nutnost dodrovn pedem r r danch konvenc. Jedin tak lze udret kd pehledn a snadno udrovateln. Dalm znmm problmem je tzv. e r diamantov struktura td, jak je nazvn ppad, kdy od jednoho pedka jsou odvozeny dv tdy a od t chto dvou r r r e r e td zrove je odvozena tet. V tomto ppad si s mechanismy zde popsanmi t ko pom ete a na adu mus pijt r n r r e e u r r n jak jin, sostikovan j metoda. e e
9.6
Pseudo-soukrom atributy
Jak ji n kolikrte zazn lo v textu ve, Python podporuje tzv. pseudo-soukrom atributy. Jako pseudo-soukrom e e atribut je pouvn kad identiktor ve tvaru __identifiktor. Tento speciln zpis je tvoen jmnem idenr tiktoru, jemu pedchzej minimln dv podtrtka a je ukon eno nejve jednm podtrtkem. Kad vskyt r e e c takovho identiktoru je nahrazeno novm identiktorem _jmnotdy_identifiktor, kde jmnotdy r r je jmno aktuln tdy. Jako aktuln tda se pouije tda, v jejm kdu (tj. kdu jej metody) se takovto zpis r r r vyskytl. Takto lze zajistit, e dv r zn tdy mohou denovat dva stejn soukrom atributy a pesto nedojde ke kolizi e u r r identiktor . Pomoc pseudo-soukromch atribut m eme pojmenovvat jak datov cleny, tak i metody. Co je vak u u u velmi d leit - tento mechanismus m eme pout i pro uloen ur itch informac instance jedn tdy uvnit inu u c r r
9.6. Pseudo-soukrom atributy
75
stance druh. Nakonec poznamenejme, e mimo kd tdy stejn jako v ppad , kdy jmno tdy je tvoeno sammi r e r e r r podtrtky, k dnmu nahrazovn nedojde. Nzev pseudo-soukrom atributy se pouv proto, e pestoe dojde ke zm n jmna, je toto jmno stle pstupn r e e r jako _jmnotdy_identifiktor a to pro pln libovoln kd. Toho m ete vyut napklad v ppad , kdy r e u r r e chcete pi lad n programu zkontrolovat hodnotu ur it prom nn.4 r e c e Je teba podotknout, e kd pedan pkazu exec a funkcm pro dynamick vykonvn kdu nepovauje jmno r r r volajc tdy za jmno aktuln tdy a tud se neprovd roziovn identiktor . S obdobnm problmem se potkte r r r u v ppad pouvn funkc getattr(), setattr() a delattr(), podobn se chov i pstup ke jmennmu r e e r prostoru n jak instance pomoc atributu __dict__. V t chto ppadech vdy muste provst nahrazen ru n ! e e r c e
9.7
Poznmky
N kdy se programtorovi m e hodit datov typ podobn pascalovskmu zznamu nebo strukturm v jazyce C. Tyto e u u typy obsahuj n kolik datovch clen k nim se pistupuje na zklad jejich jmen. Tento typ zskme jednodue e r e denovnm przdn tdy: r
class Zamestnanec: pass honza = Zamestnanec() # Vytvo przdn zznam o zamstnanci r e # Vypln jednotliv poloky zznamu honza.jmeno = Honza vec honza.skupina = PyCZ honza.plat = 0
Kd, kter pedpokld, e mu pedte ur it abstraktn datov typ (tj. typ u n j je znmo pouze rozhran a nezle r r c e na jeho implementaci) lze casto "olit" a pedat mu instanci jin tdy, kter vak implementuje poadovan metody. r r Napklad si pedstavte funkci, kter pedte souborov objekt, ona pomoc jeho metody read() pe te jeho obsah r r r r c r a vrt ho jako et zec, v n m nahrad vechny vskyty tabultoru ctymi mezerami. Pak msto souborovho objektu r e e m eme pedat i libovolnou jinou tdu, kter m metodu read() denovnu stejnm zp sobem jako souborov u r r u objekt. Objekt metody, kter je svzna s ur itou instanc m tak svoje vlastn datov atributy. Jsou jimi im_self, kter c reprezentuje instanci, na n se metoda ve a im_func reprezentujc funk n objekt, kter metodu implementuje. c Jde o funkci, kter je denovna v t le tdy a kter se vyvol pi sput n metody. e r r e
9.7.1
Vjimky mohou bt tdy r
e Uivatelsky denovan vjimky ji v Pythonu dvno nejsou omezeny pouze na ret zce. Nesrovnateln lpe toti e mohou poslouit tdy. Dky nim m eme vytvoit rozshlou hiearchii vjimek, ve kter se mezi tdami d d atributy r u r r e a jejich ppadn metody apod. r Kv li monosti pouvn td byl rozen i pkaz raise. Jeho syntaxe nyn vypad nsledovn : u r r r e
raise tda, instance r raise instance
V prvnm ppad mus bt prom nn instance instanc tdy tda nebo tdy, kter je od n odvozen. Druh r e e r r r
4 To je tak jedin d vod, pro jsou pseudo-soukrom atributy veejn pstupn. Nebyl by toti problm je pln skrt ped nepovolanmi zraky. u c r e r e r
76
Kapitola 9. Tdy r
tvar je pak zkrceninou zpisu:

raise instance.__class__, instance
e V tve except pkazu try mohou uvd t tdy stejnm zp sobem jako ret zce. Dan handler se spust, pokud e r e r u vjimka je instanc jedn ze td uvedench za pslunm kl ovm slovem except. Pro ilustraci m eme uvst r r c u nsledujc vyum lkovan pklad. Ten vytiskne psmena B, C a D pesn v tomto poad: e r r e r
class B: pass class C(B): pass class D(C): pass for c in [B, C, D]: try: raise c() except D: print "D" except C: print "C" except B: print "B"
Pokud bychom v tve except zapsali v opa nm poad (tj. except B jako prvn), vytisklo by se B, B, B, e c r protoe vdy by se spustil pouze prvn handler! Pokud vjimka nebude odchycena a byde prohlena za neobslouenou vjimku, bude jako popis chyby nejprve uvedeno jmno tdy nsledovan dvojte kou a et zcovou reprezentac tdy, kterou vrt intern funkce str(). r c r e r
9.7. Poznmky
77
78
KAPITOLA
DEST
Co nyn?
Pokud jste do etli a sem, lze jen doufat, e v zjem o jazyk Python jet vce zeslil a ji jste dychtiv pout Python c e k een n jakch opravdovch problm . V tto kapitole si popeme n kolik informa nch zdroj , pomoc nich r e u e c u m ete zskat dal informace o Pythonu. u e V prvn rad byste si m li po pe ten tto u ebnice alespo prolistovat dokument Python Library Reference (Refe r c c n eren n pru ka standardnch knihoven). Tato pru ka je kompletnm zdrojem informac. Najdete v n popis vech c r c r c standardnch datovch typ , funkc a modul . Vechny tyto moduly jsou navreny tak, aby programtorovi co neu u jvce usnadnili prci s Pythonem. Mnohokrt je programtor-za te nk vskutku zasko en mnostvm knihoven a c c c jednoduchost jejich pouvn. Nejednou jsem byl sv dkem otzky "Co tedy mm programovat, kdy to u vechno e obsahuje?" Jen namtkou jmenujme seznam t chto modul a bal k , kter za n moduly, je zpstup uj stane u c u c r n dardn sluby opera nho systmu denovan normou POSIX, pokra uje moduly pro cten e-mailovch schrnek v c c systmech U NIX, zskvn dokument protokolem HTTP, pes modul pro generovn nhodnch csel, modul pro u r zskvn voleb pedanch na pkazovm dku a kon e moduly pro psan CGI program . Pokud se do cten pru ky r r r c u r c standardn knihovny nechcete pustit, alespo si ji prolistujte, zskte pedstavu, co ve vm m e Python nabdnout. n r u Dal zdroje informac jsou webov strnky r znch sdruen a organizac. Mezi nimi je na prvnm mste hlavn u r webov strnka Pythonu na http://www.python.org. Zde naleznete zdrojov kdy, pipraven binrn distribuce pro nejrozen j opera n systmy, dokumentaci a odkazy na sv tov webov strnky v nujc se Pythonu. Domc strnky r e c e e Pythonu jsou zrcadleny na r znch mstech po celm sv t , proto se pokuste stahovat data vdy z toho nejbliho, u ee uette tak penosov kapacity ptench linek a odleh te vzdlenm server m. r r r c u Pro ceskoslovenskho ctene budou pravd podobn nejbli strnky Ceskho sdruen programtor a uivatel r e e u u jazyka Python (zkrcen PyCZ, adresa http://py.cz). Zde naleznete nejnov j verzi tto u ebnice a dal dokumentaci e e c peloenou do cetiny. PyCZ tak provozuje e-mailovou konferenci python@py.cz, kompletn instrukce jak se do r konference pihlsit, jak se odhlsit a archv konference najdete na strnkch PyCZ. r Dalm zajmavm sdlem je http://starship.python.net/. Jedn se o informativn webov strnky. Mnoho uivatel u Pythonu zde m domovsk strnky na nich je publikovno mnostv program , utilitek a modul ur ench voln ke u u c e staen. Anglicky mluvcm uivatel m mon pijde vhod newsov skupina comp.lang.python a jej e-mailov zrcadlo pythonu r list@python.org. Ob tyto konference jsou propojeny, vechny psp vky zaslan do jedn jsou automaticky peposlny e r e r do druh. Frekvence zprv v tto konferenci je kolem 120 novch zprv denn a zahrnuj otzky a odpov di, nvrhy e e novch vlastnost a oznmen novch modul . u Ped zaslnm otzky do e-mailov konference se nejprve pesv d te, zda podobnou otzku nepoloil n kdo ped vmi. r r e c e r Projd te si proto archv konference (http://www.python.org/pipermail/) nebo se podvejte do nej ast ji kladench otzek e c e (FAQ, http://www.python.org/doc/FAQ.html). Jejich obdobu najdete i v adresi Misc/ libovoln zdrojov distribuce r Pythonu. Mon v nich bude i een prv toho vaeho problmu! r e
79
80
DODATEK
Interaktivn pravy pkazovho dku a r r historie pkazu r

Jak jsme si ji rkali na samm za tku na u ebnice, interpretr Pythonu m e bt zkompilovn s knihovnou GNU c c u Readline, kter zpstup uje rozen pravy pkazovho dku. Tuto knihovnu pouv napklad U NIXov shell r n r r r r GNU Bash. Tuto knihovnu m ete dokonce nakongurovat tak, e bude pouvat klvesov zkratky ve stylu obou u nejpouvan jch editor - Emacs a vi. Pestoe m tato knihovna sv j vlastn manul, zmnme zde zklady jej e u r u kongurace, je by se mohli hodit kadmu za te nkovi. c c
A.1 pravy pkazovho dku r r

Po celou nsledujc kapitolu budeme pedpokldat, e v interpretr je zkompilovn s podporou knihovny Readline. r Rozen pravy pkazovho rdku pro zadn vstupu pro interpretr je mon pouvat kdykoli, pi em nezle, r r rc zda interpretr zobrazil primrn nebo sekundrn vzvu. Aktuln dka m ete upravovat nap. za pouit pkaz , r u r r u kter mon znte z programu Emacs1 . Jde pedevm o klvesy C-F (C-B), je slou pro pohyb o jeden znak r vped (vzad). Dal dvojice klves M-F a M-B posouvaj kurzor o jedno slovo vped resp. vzad. Pro pohyb na konec r r ppadn za tek dku pouijete klvesy C-E a C-A. Klvesou C-K smaete ve od kurzoru do konce dku, C-Y r e c r r vlo naposledy smazan et zec. Kone n C-podtrtko vrt posledn zm nu na tomto dku. r e c e e r
A.2 Historie pkazu r

Historie pkaz pracuje naprosto stejn jako v libovolnm jinm programu, kter jako svoje rozhran pouv pkar u e r zov dek. Klvesa C-P vs pesune na pedchoz pkaz v historii, C-N na nsledujc. Kad dek, kter jste r r r r r vyvolali z historie m e bt upraven. Po dokon en vaich prav stiskn te klvesu Return a aktuln dek bude u c e r pedn interpretru k op tovnmu sput n. Pro vyhledvn v historii pouijte stisk klves C-R. Pomoc klves C-S r e e spustte vyhledvn v opa nm sm ru. c e
A.3 Klvesov zkratky

Klvesov zkratky a dal parametry knihovny GNU Readline m ete nastavovat pomoc pkaz v inicializa nm u r u c souboru ./inputrc. V n m jsou klvesov zkratky zapisovny ve tvaru: e
1V
dokumentaci Emacsu znamen zpis C-B sou asn stisknut klves Control a psmena B. Podobn M-B stisk klvesy Meta (Alt) a psmena c e
B.
81
jmno-klvesy: jmno-funkce
nebo:
"etzec": jmno-funkce r e
R zn parametry se pak nastavuj pkazy u r

set parametr hodnota
Zde si uvedeme jednu monou konguraci knihovny Readline:

# Preferuji pravy ve stylu vi: set editing-mode vi # pravy na jedin rdce: set horizontal-scroll-mode On # Upravme njak klvesov zkratky: e Meta-h: backward-kill-word "\C-u": universal-argument "\C-x\C-r": re-read-init-file
Knihovna Readline obvykle pouv klvesu Tab pro dopl ovn jmen soubor a pkaz , v Pythonu vak slou n u r u pro vloen znaku tabultor. Jestlie si pejete pouvat dopl ovn vzan na klvesu Tab, zapite do svho souboru r n /.inputrc nsledujc dek: r
Tab: complete
Za pouit tohoto namapovn klves se ale pipravte o monost pmo vkldat znaky tabultor na pkazov rdce r r r interpretru. Dopl ovn jmen prom nnch a modul je dal rozen, kter pin knihovny GNU Readline do inn e u r r terpretru Pythonu. Pokud si pejete dol ovn jmen pouvat, pidejte nsledujc dky do inicializa nho souboru r n r r c Pythonu:2
import rlcompleter, readline readline.parse_and_bind(tab: complete)
Tento kd sve klvesu Tab s funkc dopl ovn jmen (complete). Pi dopl ovn jmen se prohledv seznam vech n r n pkaz jazyka Python, aktuln lokln prostor jmen a jmna modul . Pro vrazy, kter pouvaj te kovou notaci jako r u u c nap. string.a se nejprve vyhodnot vraz ped posledn te kou a pak se vyvol dopl ovn jmen na vslednm obr r c n jektu. Takto m e dojt i k necht nmu sput n kdu programu. Sta aby objekt denoval metodu __getattr__() u e e c a pi prvnm dopl ovn sloit jho vrazu, kter se odkazuje na atributy takov instance se spust kd tto metody. r n e Inicializa n soubor m e nabzet i vce monost. Jako pklad m e poslouit nsledujc vpis souboru. Podotkn me, c u r u e e inicializa n soubor se spout ve stejnm prostoru jmen, ve kterm budou pozd je vykonvny interaktivn pkazy. c e r Proto je slunost zanechat toto prosted " ist", kv li cemu skript po sob snae nepotebn jmna z tohoto jmennho r c u e r prostoru odstran:
2 Python
po svm startu spout obsah souboru, na n j ukazuje prom nn prosted PYTHONSTARTUP. Vce viz druh kapitola. e e r
82
Dodatek A. Interaktivn pravy pkazovho dku a historie pkazu r r r
# # # # # # # # # # #
Pidv doplovn pkaz a ukld historii pkaz vaeho interaktivnho r n r u r u interpretru. Vyaduje verzi Python 2.0 nebo vy, readline. Doplovn n je svzno s klvesou Esc (tuto vazbu mete zmnit - viz dokumentace u e knihovny readline). Ulote tento soubor jako ~/.pystartup a nastavte promnnou prosted tak, e r aby na nj ukazovala, tj. export PYTHONSTARTUP=/home/honza/.pystartup e v bashi Promnn PYTHONSTARTUP _neexpanduje_ znak ~, take muste zadat celou e cestu k vaemu domcmu adresi. r atexit os readline rlcompleter
import import import import
historyPath = os.path.expanduser(~/.pyhistory) def save_history(historyPath=historyPath): import readline readline.write_history_file(historyPath) if os.path.exists(historyPath): readline.read_history_file(historyPath) atexit.register(save_history) del os, atexit, readline, rlcompleter, save_history, historyPath
V porovnn s prvnmi verzemi interpretru jsou tyto monosti pmo pohdkov. Stle ale zbv implementovat n kor e lik dalch vlastnost, kter by editovn pkazovho dku ud laly jet pohodln j ne je nyn. r r e e e
A.3. Klvesov zkratky
83
84
DODATEK
Artitmetika v plovouc dov crce: r Problmy a jejich nprava

Tato kapitola se v nuje problematice csel v plovouc dov crce. Vysv tluje specika tohoto datovho typu, kter e r e u se tkaj nejen jazyka Python. Tak vysv tluje, jakm zp sobem pistupuje Python k relnm csl m. e u r Jak jist dobe vte, v po ta i jsou csla uloena ve dvojkov soustav (tj. cseln soustav o zkladu 2). Stejn e r c c e e e jsou uloena i desetinn csla. Ta jsou reprezentovna jako zlomky se jmenovatelem, je je roven mocnimm csla 2. Napklad desetinn cslo r
0.125
m hodnotu 1/10 + 2/100 + 5/1000. Jde stejn cslo reprezentuje i binrn zpis
0.001
Tento zpis znamen 0/2 + 0/4 + 1/8. Oba zpisy reprezentuj stejn cslo, ovem pokad zapsan v jin soustav . e Bohuel mnoho desetinn csel zapsanch v destkov soustav nem odpovdajc binrn tvar. Proto jsou tato csla e uloena pouze jako piblin hodnota. r Tento problm si demonstrujeme na zlomku jedna tetina. V destkov soustav ho m eme napsat pouze piblin r e u r e jako desetinn cslo:
0.3
nebo lpe:
0.33
nebo jet lpe: e

0.333
a tak dle. Nezle na tom, kolik cslic napete, vsledek nikdy nebude pesn 1/3, vdy p jde o pesn j a pesn j r e u r e r e aproximaci csla 1/3. 85
Podobn je ve dvojkov soustav periodick jedna desetina. Vdy p jde nekone n periodick rozvoj e e u c
0.0001100110011001100110011001100110011001100110011...
Pouitm pouze kone nho po tu cslic zskme pouze piblinou hodnotu. Dky tomu m eme o interpretru zskat c c r u vsledky podobn tomuto: e
>>> 0.1 0.10000000000000001
Jak vidte, Python vytiskl cslo 0.1 tak, jak ho on "vid". Na n kterch platformch m eme zskat i jin vsledek. e u Jednotliv stroje se toti mezi sebou (krom jinho) li i po tem bit , kter pouvaj pro aritmetiku v plovouc dov e c u r crce. Proto ns nesm pekvapit i aproximace podobn tto: r
>>> 0.1 0.1000000000000000055511151231257827021181583404541015625
e Interaktivn interpretr Pythonu pouv pro zskn ret zcov reprezentace n jak hodnoty intern funkce repr(). e Ta desetinn csla zaoukrouhluje na 17 platnch cifer.1 Tato cifra byla vypo tna programtory Pythonu, pokud by c pouili 16 cifer, nebyla by ji ve uveden podmnka platn pro vechna reln csla. Zapamatujte si, e problm s reprezentac relnch csel nen problmem Pythonu. Tak nejde o chybu ve vaem kdu. Se stejnmi problmy se setkte i v jinch jazycch, kter pouvaj klasick matematick funkce. Tyto jazyky vak mohou bt napsny tak, e rozdly mezi jednotlivmi reprezentacemi nemus implicitn zobrazovat. e Oproti funkci repr() zde existuje i intern funkce str(), kter vrac reln cslo s pesnost na 12 platnch cslic. r V n kterch ppadech ji proto m ete pouvat namsto funkce repr(), pon vad jej vstup vypad v mnoha e r u e ppadech lpe: r
>>> print str(0.1) 0.1
Muste mt na pam ti, e to co vidte je jaksi "iluze", hodnota ve skute nosti nen pesn 1/10, ale jej aproximace e c r e zaokrouhlen na 12 platnch cslic. M ete se do kat i dalch pekvapen. Pokud nepou en programtor nape 0.1 a uvid nsledujc vsledek u c r c
>>> 0.1 0.10000000000000001
m e se pokusit vsledek zaokrouhlit pomoc funkce round(). Ta ale neprovede dn zaokrouhlen! u

>>> round(0.1, 1) 0.10000000000000001
V cem je problm? Binrn desetinn cslo s hodnotou 0.1 je uloeno jako nejlep aproximace zlomku 1/10. Pokusteli se j nyn zaokrouhlit, lep aproximaci ji nezskte! Jin pekvapen 0.1 nen pesn 1/10! Se tete-li tedy desetkrt cslo 0.1, nedostanete 1.0: r r e c
1 17
cifer je pouito aby byla spln na rovnost eval(repr(x)) e
== x.
86
Dodatek B. Artitmetika v plovouc dov crce: Problmy a jejich nprava r
>>> sum = 0.0 >>> for i in range(10): ... sum += 0.1 ... >>> sum 0.99999999999999989
Binrn reprezentace relnch csel obn jet dal podobn problmy. O n kterch jejich d sledcch a npravch e e u se do tete na dalch dcch. Kompletn v et monch "chyb" najdete na adrese http://www.lahey.com/oat.html. c r c Uv domte si, e na tyto problmy nikdy neexistuje jednozna n nprava. Aritmetiky v plovouc rdov crce se ale e c bt nemuste! Chyby v plovouc dov crce jsou zvisl na pouitm po ta i a jejich vskyt je pom rn sporadick. r c c e e To je pro v tinu loh naprosto posta ujc okolnost. e c Vdy se ale snate jednotliv operace skldat tak, aby nedochzelo ke zv tovn chyby. Konkrtn postup se li lohu e od lohy. Pokud jste ji zkuen j programtor, jist si dokete sami pomoci. A za te nky nezbv ne odkzat na e e c c pslunou literaturu ci internetov strnky. r
B.1
Chyby v reprezentaci csel
Tto podkapitole se ble podvme na to, jak jsou v po ta i intern ukldna reln csla a jakm zp sobem se c c e u vyvarovat v tin problm spojench s pouvnm relnch csel na dnench po ta ovch platformch. e e u c c Chyba v reprezentaci csel znamen, e n kter desetinn csla v destkov soustav pesn neodpovdaj binrnm e e r e u desetinnm csl m. To je d vod pro n kd Python (nebo Perl, C, C++, Java, Fortran a dal jazyky) nezobraz pesn u c e r e to cslo, kter jste o ekvali: c
>>> 0.1 0.10000000000000001
V cem je problm? Jak jsme si ji rekli, cslo 0.1 nem v binrn soustav odpovdajc zpis. V dnen dob tm e e er vechny po ta e pouvaj relnou aritmetiku podle standardu IEEE-754 a tm na vech platformch odpovd c c er Pythonovsk datov typ oat cslu s dvojitou pesnost. r Tato csla obsahuj 53 bit ur ench k reprezentaci hodnoty csla (matisa). Pi ukldn reln hodnoty se tato v u c r po ta i nejprve petransformuje na zlomek ve tvaru J/2**N, kde J je cel cslo obsahujc pesn 53 bit . Pepemec c r r e u r li
1 / 10 \~= J / (2**N)
jako
J \~= 2**N / 10
a za pedpokladu, e J m pesn 53 bit (tj. plat >= 2**53 ale < 2**53), je nejlep hodnotou pro N 56. r r e u
B.1. Chyby v reprezentaci csel
87
>>> 2L**52 4503599627370496L >>> 2L**53 9007199254740992L >>> 2L**56/10 7205759403792793L
56 je jedin hodnota N, kter zajist, e J je dlouh pesn 53 bit . Nejlep monou hodnotu J zskme zaokrouhlenm: r e u
>>> q, r = divmod(2L**56, 10) >>> r 6L
>>> q, r = divmod(2L**56, 10) >>> r 6L
Jeliko je zbytek v t ne polovina z 10, nejlep aproximaci zskme zaokrouhlenm nahoru: e

>>> q+1 7205759403792794L
Take nejlep monou reprezentac 1/10 v IEEE-754 typu double precision je tato hodnota vyd len 2**56, tedy e
7205759403792794 / 72057594037927936
Protoe jsme zaokrouhlovali nahoru, je vsledek o trochu v t ne 1/10. Pokud bychom zaokrouhlen neprovedli, e vsledek by byl trochu men ne 1/10. Ale nikdy nebude pesn 1/10! r e Take po ta e nikdy "neuvid" 1/10: vdy bude pouvat zlomek 7205759403792794 / 72057594037927936: c c
>>> .1 * 2L**56 7205759403792794.0
Vynsobme-li tuto hodnotu cslem 10**30, uvidme hodnotu jejch 30 nejvznamn jch dekadickch cslic: e
>>> 7205759403792794L * 10L**30 / 2L**56 100000000000000005551115123125L
Cslo uloen v po ta i je tedy piblin rovno dekadickmu cslu 0.100000000000000005551115123125. Zaokrouhc c r e lenm na 17 platnch cslic zskme prv onu hodnotu 0.10000000000000001, kterouto Python zobrazuje namsto e hodnoty 0.1!
88
Dodatek B. Artitmetika v plovouc dov crce: Problmy a jejich nprava r
DODATEK
Licence
C.1 Historie Pythonu
Vvoj Python za al v roce 1990 na Stichtig Mathematisch Centrum (CWI, viz. http://www.cwi.nl/) v Nizozem. U c jeho zrodu stl Guido vam Rossum. Hlavn ideu Pythonu pevzal z jazyku, kter doposud vyvjel, z jazyka ABC. r A koli Guido z stal hlavnm programtorem a ideologem Pythonu, pouil v jeho interpretru mnoho kdu jinch c u programtor . u V roce 1995 Guido pokra oval v prci na Pythonu na p d Corporation for National Research Initiatives (CNRI, viz. c u e http://www.cnri.reston.va.us/) v Restonu ve Virginii kde vydal n kolik verz programu. e V kv tnu roku 200 zaloil Guido a dal jemu blzc vvoji Pythonu tm pod hlavi kou spole nosti BeOpen.com e r c c tm BeOpen PythonLabs. V jnu tho roku se PythonLabs pesunuly pod rmu Zope Corporation (poslze Digital r r Creations, viz http://www.zope.com/). V roce 2001 byla zaloena neziskov organizace Python Software Foundation (PSF, viz http://ww.python.org/psf/), kter vlastn vechno "intelektuln jm n" kolem jazyka Python. Spole nost Dige c ital Creations je i nadle jednm ze sponzor PSF. u Vechny verze Pythonu maj oteven kd (viz http://ww.opensource.org/). V tina, ale ne vechny verze Pythonu r e jsou kompatibiln s licenc GPL. Nsledujc tabulka proto shrnuje informace o vech doposud vydanch verzch interpretru: Verze 0.9.0 a 1.2 1.3 a 1.5.2 1.6 2.0 1.6.1 2.1 2.0.1 2.1.1 2.2 Odvozena z n/a 1.2 1.5.2 1.6 1.6 2.0+1.6.1 2.0+1.6.1 2.1+2.0.1 2.1.1 Rok 1991-1995 1995-1999 2000 2000 2001 2001 2001 2001 2001 Vlastnk CWI CNRI CNRI BeOpen.com CNRI PSF PSF PSF PSF GPL kompatibiln? ano ano ne ne ne ne ano ano ano
Poznmka: Sl vko GPL kompatibiln neznamen, e Python je distribuovn pod licenc GPL. Vechny licence u Pythonu narozdl od GPL umo uj distribuovat modikovan verze jazyka ani byste byli nuceni uvolnit v zdrojov n kd. GPL kompatibiln lecence umo uj kombinovat na jednom mediu Python spole n s dalm software uvoln nm n c e e pod GPL. Ostatn licence toto neumo uj! n
C.2
Podekovn ...
Na zv r tto knihy bych cht l pod kovat vem dobrovolnk m, kte ur itm zp sobem pisp li k prci na jazyce e e e u r c u r e Python. Rovn bych cht l pod kovat vem, kte mi pomhali s pekladem. Dle lidem z Ceskho sdruen programe e e r r 89
tor a uivatel jazyka Python - PyCZ. M j obdiv pat i vem lidem, kte uvolnili zdrojov kdy svch program ve u u u r r u smyslu hnut OpenSource. M speciln pod kovn pat i Ka ence . e r c
C.3
Licence
Copyright c 2002 Jan vec honza@py.cz. Vechna prva vyhrazena. Tento dokument je distribuovn pod licenc GPL. M ete jej distribuovat a/nebo modikovat podle ustanoven tto u licence vydvan Free Software Foundation a to bud verze 2 a nebo (podle vaeho uven) kterkoli pozd j verze. e Tento dokument je roziovn v nad ji, e bude uite n, avak BEZ JAKKOLI ZRUKY. r e c Dal podrobnosti hledejte v licenci GPL. Kopii licence GPL jste m l obdret spolu s tmto programem; pokud se tak nestalo, napite o ni Free Software Foune dation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. Peklad z originlnho anglickho dokumentu "Python Tutorial". Originln copyright: r Copyright c 2001 Python Software Foundation. All rights reserved. Copyright c 2000 BeOpen.com. All rights reserved. Copyright c 1995-2000 Corporation for National Research Initiatives. All rights reserved. Copyright c 1991-1995 Stichting Mathematisch Centrum. All rights reserved.
90
Dodatek C. Licence

U Cebnice Jazyka Python (Aneb Létající Cirkus) : Release 2.2

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

U Cebnice Jazyka Python (Aneb Létající Cirkus) : Release 2.2

Uploaded by

Copyright:

Available Formats

U ebnice jazyka Python c (aneb Ltajc cirkus)

16. prosince 2002

PyCZ Email: honza@py.cz

8.2 8.3 8.4 8.5 8.6 9

Pro pouvat zrovna Python? c

Obsah tto u ebnice c

v angli tin znamen hrozn c e

Kapitola 1. Pro pouvat zrovna Python? c

Pouvme interpretr jazyka Python

nefunguje sprvn v ppad pesm rovanho standardnho vstupu). e r e r e

Behov prosted jazyka Python r

Kapitola 2. Pouvme interpretr jazyka Python

odchytit obvyklm zp sobem pkazem try. 2 u r

Soubory na tan pi startu interpretru c r

o vjimkch viz. kapitola 8.

2.2. Behov prosted jazyka Python r

vod do jazyka Python

3.1 Python jako kalkultor

>>> 4 >>> ... 4 >>> 4 >>> 5 >>> ... 2 >>> -3

(50-5*6)/4 # Dlen celch sel vrt cel slo: e c c 7/3 7/-3

Hodnota m e bt piazena i vce prom nnm najednou: u rr e

Kapitola 3. vod do jazyka Python

3.1. Python jako kalkultor

Tento pklad vytiskne text: r

sekvenc je napklad \n - znak novho dku nebo \t - tabultor r r

Kapitola 3. vod do jazyka Python

Zobraz tuto zprvu Pipoj se na tento pota r c c

Tato ukzka vytiskne nsledujc vstup:

Pouit: naklada [VOLBY] c -h -H hostname

Zobraz tuto zprvu Pipoj se na tento pota r c c

Sprvn e Sprvn e CHYBN!!! E

3.1. Python jako kalkultor

Kd ve tvaru s[:i] + s[i:] je samozejm vyhodnocen jako s: r e

Kapitola 3. vod do jazyka Python

Pozor ale, -0 je tot co 0, k dnmu indexovn od konce et zce tm pdem nedojde: r e

3.1. Python jako kalkultor

Kapitola 3. vod do jazyka Python

>>> urHello\u0020World ! uHello World ! >>> urHello\\u0020World ! uHello\\\\u0020World !

3.1. Python jako kalkultor

Kapitola 3. vod do jazyka Python

N kdy se m e hodit i monost vytvoit seznam obsahujc jin seznamy, teba: e u r r

rozvoj je ur en rovnic r[n+2] c

= r[n] + r[n+1]. Za n tud csly 1, 1, 2, 3, 5, 8, 13 atd.: c

3.2. Prvn kroky

oba nejlep editory vim a emacs tyto mdy samozejm existuj. r e

Kapitola 3. vod do jazyka Python

Pkazy pro zen toku programu r r

Kapitola 4. Pkazy pro zen toku programu r r

Pkazy break a continue a vetev else pkazu for r r

4.6 Pkaz pass r

4.7 Denovn funkce

Kapitola 4. Pkazy pro zen toku programu r r

>>> ... ... ... ... ... ... >>> ... 1 1

4.7. Denovn funkce

>>> print fib(0) None

Dal monosti pi denici funkce r

Implicitn hodnoty argumentu

Kapitola 4. Pkazy pro zen toku programu r r

Pedchoz blok kdu potom postupn vytiskne nsledujc vstup: r e

4.8. Dal monosti pi denici funkce r

def f(a, L=None): if L is None: L = [] L.append(a) return L

m eme volat nsledujcmi zp soby: u u

Vechna nsledujc voln jsou ale chybn: