Utolsó frissítés: 2006. február 26.
Python Software Foundation Foundation Email: .
A fordításhoz észrevételek: E-mail:
Ez a fordítás Horváth Árpád Python tutorial fordításának a folytatása és aktualizált verziója. A fordítás a 2.1-es verziójú tutoriallal kezd ˝ kezd ˝ odött, ezt a verziót teljes egészében a 2.4.1-es verzióhoz igazítottam. A tutorial fordítását Horváth Árpád kezdte el, én az o˝ munkáját folytatom. Árpád elérhet ˝ elérhet ˝ osége: ahorvath ahorvath at szgti.ka szgti.kando. ndo.hu hu (at helyett @ kell, és egybeírni, így talán kevesebb spam-et kap) A tutorialt tutorialt jelenleg jelenleg gondozza: gondozza: Nyír ˝ Nyír ˝ o Balázs ( diogenes diogenesz z revételed a fordítással kapcsolatban, írd meg!)
at pergamen pergamen.hu .hu
– ha van valamilyen ész-
Nem kell megijedni, nem nehéz LATEX-ben lév ˝ lév ˝ o szöveget szöveget írni, egyszer˝ egyszer˝ u szövegszerkeszt ˝ szövegszerkeszt ˝ o (notepad, emacs, joe, A vim.. vim. . . ) kell hozzá, hozzá, és segítek segítek ha kell. kell. Túl sok ismeret nem szükséges szükséges a L TEX-b ˝ X-b ˝ ol. Hogy könnyebben ellen ˝ ellen ˝ orizhet ˝ orizhet ˝ o legyen, a fordításnál érdemes benne hagyni a forrásban az angol szöveget meg jegyzésbe téve – % a sor elején, példa itt: % % % %
Fina Finall lly, y, the the leas least t freq freque uent ntly ly used used opti option on is to spec specif ify y that that a func functi tion on can can be call called ed with with an arbi arbitr trar ary y numb number er of argu argume ment nts. s. Thes These e argu argume ment nts s will will be wrap wrappe ped d up in a tupl tuple. e. Befo Before re the vari variab able le numbe number r of argu argume ment nts, s, zero zero or more more norm normal al argu argume ment nts s may may occu occur. r.
ez már nincs nincs megjeg megjegyzé yzésbe sbe téve téve
A LATEX-ben üres sor jelöli, hogy új bekezdés jön. A LATEX-ben találkozhatsz utasításokkal és környezetekkel. Azokat hagyd ugyanúgy. Az alábbi példában a code egy utasítás, a print az argumentuma. (A kapcsos zárójel kötelez ˝ kötelez ˝ o, a szögletes opcionális argumentumot jelöl.) Az item is egy utasítás. Az itemize egy környezet (rendezetlen (sorszámozatlan) listát készíthetsz vele).
A \code{print \code{print} } utasítással utasítással ... \begin{itemize} \item ˝ a magasszint˝ magasszint˝ u adattí adattípus pusok ok lehet lehet˝ ové ové teszik számodra egyetlen utasításban utasításban egy összet összetett ett m˝ uvelet uvelet kifejtését; kifejtését; \item az utasít utasításo ások k csopor csoportos tosítá ítása sa a sorok sorok elején elejének ek behúzá behúzásáv sával al történ történik ik ˝ és végzár a kezd kezd˝ o végzáróje ójelek lek helyet helyett; t; \item nem szüksé szükséges ges a változ változók ók és argume argumentu ntumok mok deklar deklarálá álása. sa. \end{itemize}
A kritikus részeket tripla kérd ˝ kérd ˝ ojellel ojellel (???) jelöljük jelöljük meg. Itt azokra a helyekre gondolok, gondolok, amit másnak másnak érdemes átnéznie, hogy jó-e úgy, ami érthet ˝ érthet ˝ oség, pontosság, magyar nyelv szempontjából valószín˝ uleg javítandó. A Python dokumentációkészítésr ˝ dokumentációkészítésr ˝ ol a oldalon b ˝ b ˝ ovebb leírást leírást találha találhatsz. tsz. Fent van egy egy link: Documentati Documentation on » Download Current Current Documenta Documentation tion (középtáj (középtájt) t) » Documenting Documenting Python (lent). (lent). (url: ) A Python dokumentáció egyben is letölthet ˝ letölthet ˝ o ugyanitt html, pdf formátumban. Ha Linuxod van, és van fent LATEX (tetex-* csomagok), és latex2html ( latex2html csomag), akkor megpróbálhatod lefordítani a forrást html-lé. Tapasztalat apasztalatok: ok: a fordítást fordítást a teljes teljes Python forrással forrással együtt érdemes letölteni, letölteni, ekkor m uködött ˝ nekem rendesen a beépített html és pdf generálási funkció. A Python dokumentáció el ˝ ore elkészített generátorral rendelkezik, ami a LATEX fájl alapján a html-t és a pdf-et automatikusan generálja.
Gondban vagyok a ´string literal’ szóval. A ’prompt’ szóra sem tudtam jó magyar megfelel ˝ megfelel ˝ ot, hagytam az eredetit. A backslash jelölését a LaTeX könyv ötletes rep-jel megnevezésével fordítottam el ˝ el ˝ oször. oször. Újabb tanács tanács alapján kicseréltem az elterjedtebb vissza-per jel megnevezésre. A tuple szóra eddig a vektor szót használtuk – hosszútávon az eredeti tuple kifejezést fogjuk visszaállítani. Várom a javaslatokat. Szívesen veszek minden ötletet, ami a magyarosabbá-tételt m agyarosabbá-tételt segíti.
Kivonat A Python egy könnyen tanulható, sokoldalú programozási nyelv. Jól használható magas szint˝ u adatstruktúrákkal rendelkezik, és egyszer˝ u – ugyanakkor eredményes az objektum-orientált programozás nyelvi megvalósítása. A Python nyelvtana elegáns, elegáns, a nyelv dinamikusan típusos. Parancsértemlez ˝ Parancsértemlez ˝ o jelleg˝ u nyelv, mely a bájtfordítást is ˝ támogatja támogatja (mint pl. a Java), ideális ideális szkriptek szkriptek készítésére készítésére,, továbbá továbbá nagyon gyors alkalmazás alkalmazásfejle fejlesztést sztést tesz lehet lehet ˝ ové több platfromon, szerteágazó területeken. A Python értelmez ˝ értelmez ˝ o és a sokrét˝ u, alaposan kidolgozott alap-könyvtár (Standard Library) szabadon elérhet ˝ elérhet ˝ o és felhasználható akár forráskódként, akár bináris formában minden jelent ˝ jelent ˝ osebb platformra a Python weboldaláról: . Ugyanitt hivatkozások is vannak küls ˝ küls ˝ o fejlesztés˝ u modulokra, programokra és eszközökre, és kiegészít ˝ kiegészít ˝ o dokumentációkra. A Python értelmez ˝ értelmez ˝ o egyszer egyszeruen ˝ kiegészíthet ˝ kiegészíthet ˝ o C vagy C++ nyelven (vagy más, C-b ˝ C-b ˝ ol hívható nyelven) új függvényekkel és adattípusokkal. A Python maga is alkalmas kiegészít ˝ kiegészít ˝ o nyelv már elkészült alkalmazások b ˝ b ˝ ovítéséhez. Ez az oktató megismerteti az olvasóval a Python alapvet ˝ alapvet ˝ o gondolkodásmódját, nyelvi lehet ˝ lehet ˝ oségeit és rendszerét. Segít a gyakorlott felhasználóvá válásban. A példák a dokumentumba ágyazottak, internet elérés nem szükséges az olvasásukhoz. A nyelvbe épített szabványos objektumok és modulok leírásához nézd meg a Python Library Reference (Python készül ˝ o magyar fordítását (és ha van kedved, segíts a fordításban!). szabványos könyvtár) készül ˝ A Python Reference Manual a nyelv részletes definícióját tartalmazza. C vagy C ++kiegészítések írásához hasznos olvasnivaló az Extending Ezenkívül van van Extending and Embedding Embedding the Python Interpreter Interpreter és a Python/C API Reference. Ezenkívül néhány könyv, amely a Pythonnal komolyan foglalkozik. Ez nem egy minden apró részletre kiterjed ˝ kiterjed ˝ o oktatóanyag. Bemutatja a Python legfontosabb lehet ˝ lehet ˝ oségeit, és megismerteti ismerteti veled a nyelv gondolkodás gondolkodásmódját módját és stílusát. Ha végigcsinálod, végigcsinálod, képes leszel Python modulok és programok írására, és ami a legfontosabb: a további tanulásra. Az oktató után érdemes a Python Library Reference (Python szabványos könyvtár)-ban leírt modulokkal megismerkedni.
˝ 1. Étvágygerje Étvágygerjeszt szt ˝ o
1
˝ 2. A Python Python értelmez értelmez ˝ o használata 2.1. 2.1. Az értel értelme mezz ˝ o elindítása . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.2. 2.2. Az értel értelme mezz ˝ o és környezete . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3 3 4
˝ 3. Kötetlen Kötetlen bevezet bevezet ˝ o a Pythonba 7 3.1. A Python has használata számológépként . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7 3.2. Els Els ˝ o lépések a programozás felé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17 ˝ 4. További ovábbi vezérl vezérl ˝ o utasítások 4.1. Az if utasítás . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.2. A for utasítás . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.3. A range() függvény . . . . . . . . . . . . . . . . . . . . . . 4.4. A break és a continue utasítások, az else ág a ciklusokban 4.5. A pass utasítás . . . . . . . . . . . . . . . . . . . . . . . . . . 4.6. Függvények definiálása . . . . . . . . . . . . . . . . . . . . . . 4.7. 4.7. Még Még több több tudn tudniivaló a függ függvé vénnyek yek defin definiá iálá lásá sáró róll . . . . . . . . . . 5. Adatstruktúrák 5.1. Még több dolog a listákról . . . . . . . . . . . . . 5.2. A del utasítás . . . . . . . . . . . . . . . . . . . 5.3. Tuplék és sorozatok . . . . . . . . . . . . . . . . 5.4. A halmazok (Set) . . . . . . . . . . . . . . . . . . 5.5. Szótárak . . . . . . . . . . . . . . . . . . . . . . 5.6. Ciklustechnikák . . . . . . . . . . . . . . . . . . 5.7. Még több dolog a feltételekr feltételekr ˝ ˝ ol . . . . . . . . . . 5.8. 5.8. Soro Sorozzatok atok és más más típu típuso sokk össz összeehaso hasonl nlít ítás ásaa . . . . 6. Modulok (2.4 doc) 6.1. 6.1. A mod modulo ulokról król b ˝ ovebben... 6.2. Standard modulok . . . . 6.3. A dir() függvény . . . 6.4. A csomagok . . . . . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . . . . . . . . . . . . . . . . . .. .. . . . . .
. . . .
. . . .
. . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . .. .. .. . . . .
. . . .
. . . .
. . . .
. . . . . . .
. . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . .. .. .. . . . .
. . . .
. . . .
. . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . . .
. . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . .. .. . . . .
. . . .
. . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . .
. . . . . . .
. . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . .. . .. . . . . .
. . . .
. . . .
. . . .
. . . . . . .
. . . . . . . . . . . . . . . . . . . .
. . . .
. . . . . . .
19 19 19 20 21 21 21 23
. . . . . . . . . . . . .. . .
29 29 33 34 35 36 37 38 39
. . . .
41 42 44 44 46
. . . . . . .
. . . .
7. Bemenet és kimenet (2.4 doc) 51 7.1. Esz Esztétikus kimenet kialakítása . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51 7.2. Fájlok írása és olvasása . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54 8. Hibák és kivételek 8.1. Szintaktikai hibák . . 8.2. Kivételek . . . . . . . 8.3. Kivételek kezelése . . 8.4. Kivételek létrehozása
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
59 59 59 60 62
8.5. User-defined Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62 8.6. 8.6. Takarít akarító-l ó-lezá ezáró ró m˝ uveletek definiálása . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
9. Osztályok 9.1. Néhány gondolat a szóhaszn sználatról ról . . 9.2. Hatókör körök és névterek a Pythonban ban . . 9.3. Els Els ˝ o találkozás az osztályokkal . . . . 9.4. Öröklés . . . . . . . . . . . . . . . . 9.5. Private Variables . . . . . . . . . . . . 9.6. Egyéni változók . . . . . . . . . . . . 9.7. Egyebek... . . . . . . . . . . . . . . . 9.8. Kivételek alkal kalmazása az osztályokban 9.9. Bejárók . . . . . . . . . . . . . . . . . 9.10. Generátorok . . . . . . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
10. A Python alap-könyvtár rövid bemutatása - Standard Library 1. 10.1. Felület az operác rációs rendszerhe rhez . . . . . . . . . . . . . . . . . 10.2. Karakterhelyettesít ˝ Karakterhelyettesít ˝ o jelek – dzsóker karakterek rek . . . . . . . . . 10.3. Parancssori paraméterek . . . . . . . . . . . . . . . . . . . . . 10.4 10.4.. Hiba Hiba-k -kim imen enet et átir átirán ányí yítá tása sa,, prog progra ramf mfut utás ás megs megsza zakí kítá tása sa . . . . . 10.5 10.5.. Regulá gulári riss kife kifeje jezé zése sekk - kara karakt kteerlá rláncok ncok . . . . . . . . . . . . . . 10.6. Matematika . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.7. Internet elérés . . . . . . . . . . . . . . . . . . . . . . . . . . 10.8. A dátumok dátumok és és az id ˝ id ˝ o kezelése . . . . . . . . . . . . . . . . . . 10.9. Töm Tömörítés - zip, gzip, tar... . . . . . . . . . . . . . . . . . . . . 10.10.Te .Teljesítménymérés . . . . . . . . . . . . . . . . . . . . . . . . 10.11.Min ˝ 10.11.Min ˝ oségellen ˝ oségellen ˝ orzés . . . . . . . . . . . . . . . . . . . . . . . . 10.12.El .Elemekkel együtt... . . . . . . . . . . . . . . . . . . . . . . . . 11. Az alap-könyvtár bemutatása 2. rész 11.1. A kimenet formázása . . . . . . . 11.2. Szöveg-sablonok . . . . . . . . . 11.3. Bináris adatblokkok használata . 11.4. Többszálúság . . . . . . . . . . . 11.5. Naplózás . . . . . . . . . . . . . 11.6. Gyenge hivatkozások . . . . . . . 11.7. Listakezel Listakezel ˝ ˝ o eszközök . . . . . . . 11.8. Lebeg ˝ Lebeg ˝ opontos Aritmetika . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . .
65 65 66 67 71 72 72 73 73 74 75
. . . . . . . . . . . .
77 77 78 78 78 78 79 79 80 80 80 81 81
. . . . . . . .
83 83 84 85 86 87 87 88 89
12. What Now?
91
A. Interactive Input Editing and History Substitution A.1. Line Editing . . . . . . . . . . . . . . . . . . . A.2. History Substitution . . . . . . . . . . . . . . . A.3. Key Bindings . . . . . . . . . . . . . . . . . . A.4. Commentary . . . . . . . . . . . . . . . . . . .
93 93 93 93 95
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
B. Floating Point Arithmetic: Issues and Limitations 97 B.1. Representation Error . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99 C. History and License 101 C.1. History of the software . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101 C.2. C.2. Terms erms and and condi conditi tions ons for acce access ssin ingg or othe otherw rwis isee usin usingg Pyth Python on . . . . . . . . . . . . . . . . . . . 102 102 C.3. C.3. Licen License sess and and Ackn Acknow owle ledg dgem emen ents ts for for Incorp Incorpora orate tedd Softw Softwar aree . . . . . . . . . . . . . . . . . . . . 104 104 D. Glossary
113
Tárgymutató
117
1. fejezet
Étvágygerjeszt ˝ Étvágygerjeszt ˝ o ˝ Ha valaha valaha is írtál hosszú shell szkriptet, szkriptet, feltehet feltehet ˝ oen ismered ismered azt az érzést érzést,, hogy hogy amikor amikor új alaptul alaptulajdons ajdonságot ágot szeretszeretnél hozzáadni, a program lassúvá és bonyolulttá válik; vagy az új tulajdonság magában foglal egy rendszerhívást vagy más függvényt, amely csak C programból érhet ˝ érhet ˝ o el...Gyakran a probléma nem olyan komoly, hogy a Cben történ ˝ történ ˝ o újraírást indokolná; talán a programnak szüksége van változó hosszúságú karakterláncokra vagy más adattípusra (mint amilyen a fájlnevek rendezett listája), melyet könny˝ u létrehozni a shell-ben, de rengeteg munka C-ben, vagy talán nem ismered eléggé a C nyelvet. Más helyze helyzet: t: talán talán több több különbö különbözz ˝ o C könyvtárakka könyvtárakkall kell dolgoznod, dolgoznod, és a gyakori gyakori írás/fordítás írás/fordítás/tesz /tesztelés telés/újrafo /újrafordítás rdítás ciklus túl lassú. Sokkal gyorsabban gyorsabban kellene kellene szoftvert szoftvert fejlesztened fejlesztened.. Talán írtál egy programot amely amely képes kiegészít ˝ egészít ˝ o nyelv használatára – és te nem akarsz csak emiatt tervezni egy nyelvet, írni és javítgatni egy fordítót (interpretert). Ha valamelyik állítás igaz rád, a Python megfelel ˝ megfelel ˝ o nyelv lehet számodra. A Pythont egyszer˝ u kezelni, mégis igazi programnyelv, sokkal több szerkezetet használ és több támogatást nyújt nagyméret˝ u programok számára, mint a ˝ shell. Ezzel egyid ˝ egyid ˝ oben sokkal több hibaellen hibaellen ˝ orzési lehet ˝ lehet ˝ oséget tartalmaz mint a C, és – lévén magas szint szintu˝ nyelv – ˝ magas szint˝ u beépített beépített adattípusai adattípusai vannak, úgymint rugalmasan méretezhet méretezhet ˝ o sorozatok és szótárak, amelyeket C-ben létrehozni létrehozni napokba tellene. Az általánosa általánosabban bban megfogalmazott megfogalmazott adattípusa adattípusaiva ivall a Python jóval nagyobb problématerü problématerületen letenalkalm alkalmazhat azhatóó mint az Awk vagy vagy akár akár a Perl, ugyanakkor ugyanakkor sok dolog legalább legalább ugyanolyan ugyanolyan könny˝ u Pythonban, mint ezekben a nyelvekben. A Python lehet ˝ lehet ˝ ové teszi, hogy a programodat modulokra oszd fel, amelyek felhasználhatók más Python programokban is. A nyelvhez tartozó alap-könyvtár alaposan kidolgozott modulgy˝ ujteményt tartalmaz, melyeket a programod alapjául használhatsz – vagy példáknak példáknak a Python tanulásához. Vannak Vannak beépített modulok is mint a fájl I/O, rendszerhívások, socket-ek kezelése és interfészek olyan grafikus felülethez, mint a Tk. A Python futási id ˝ id ˝ o alatt értelmezett (interpretált) nyelv, amely id ˝ id ˝ ot takarít meg neked a programfejlesztés alatt, mivel nincs szükség gépi kódra történ ˝ történ ˝ o fordításra és a gépi kódok összeszerkesztésére. Az értelmez ˝ értelmez ˝ o interaktívan is használható, lehet kísérletezni a nyelv tulajdonságaival, vagy függvényeket tesztelni az alulról felfelé történ ˝ o programfejlesztés során. Egyben egy ügyes asztali számológép is! A Python Python nagyon tömör és olvas olvasható ható programok programok írását írását teszi teszi lehet ˝ lehet ˝ ové. A Pythonban Pythonbanírt írt programok programokáltal általában ában sokkal ++ rövidebbek mint a C vagy C megfelel ˝ megfelel ˝ ojük, mert: • a magas magasszi szint˝ nt˝ u adattípusok lehet ˝ lehet ˝ ové teszik egyetlen utasításban egy összetett m˝ uvelet kifejtését; • az utasítások csoportosítása a sorok elejének egyenl ˝ egyenl ˝ o mérték mértéku˝ jobbra tolásával történik a kezd ˝ kezd ˝ o és végzáró jelek helyett; • nem szükséges szükséges a változók és és argumentumok argumentumok deklarálása deklarálása.. A Python bovíthet˝ u új beépített függvényt vagy modult hozzáadni ˝ o: ha tudsz C-ben programozni, akkor könny˝ az értelmez ˝ értelmez ˝ ohöz, vagy azért, hogy hogy a kritikus eljárások a lehet ˝ lehet ˝ o leggyorsabban fussanak, vagy például olyan könyvtárakra linkelni Pythonból, amelyek csak bináris formában érhet ˝ érhet ˝ ok el (amilyenek a forgalmazóspecifikus grafikai programok). Hogyha a nyelv valóban mélyen megfogott, akkor a Python értelmez ˝ ot hozzákötheted egy C-ben írt alkalmazáshoz, és azt a program kiterjesztéseként vagy vagy parancs-nyelvként használhatod.
A nyelv a „Monthy Python-ék Repül ˝ Repül ˝ o Cirkusza” nev˝ u BBC-s BBC-s sóm˝ sóm usor ˝ után kapta a nevét és semmi köze nincs a nyálas hüll ˝ hüll ˝ ohöz.. . Utalásokat Utalásokat tenni tenni a dokumentáci dokumentációban óban a Monty Pythonra nemcsak nemcsak szabad, hanem ajánlott! ajánlott! Most, hogy már felkeltet felkeltette te az érdekl érdekl ˝ odésedet odésedet a Python, Python, reméljük reméljük szeretnéd szeretnéd megtekinte megtekinteni ni valamiv valamivel el részleteseb részletesebben. ben. Mivel a nyelvtanulás legjobb módja annak használata, meghívunk Téged egy kis gyakorlásra. ˝ A következ ˝ következ ˝ o fejezetben fejezetben az értelmez értelmez ˝ o használatának használatának minkéntjét minkéntjét magyarázzuk. magyarázzuk. Ezek kissé unalmas dolgok, de szükségesek ahhoz, hogy a kés ˝ kés ˝ obbiekeben mutatott példákat kipróbálhasd. Az oktató többi része példákon keresztül mutatja be a Python nyelv és a rendszer sok-sok tulajdonságát, kezdve az az egyszer˝ u kifeje kifejezés zésekk ekkel, el, utasít utasításo ásokka kkall és adattí adattípus pusokka okkall – folyta folytatv tvaa a függvé függvénye nyekke kkell és a modulok modulokkal kal.. Végül Végül érinti érinti a legújabb programozási módszereket, mint például a kivételkezelés, és a felhasználó által definiált osztályok.
2. fejezet
A Python értelmez ˝ értelmez ˝ o használata
The Python interpreter is usually installed as ‘ ’ on those machines where it is available; putting ‘ ’ in your U NI X shell’s search path makes it possible to start it by typing the command ˝ A Python Python értlem értlemez ez ˝ o szokásos helye a ‘ ’ könyvt könyvtár ár,, ahol ahol ilyen ilyen létezik; létezik; helyez helyezdd el a ‘ ’ útvonalat a U NI X shell keresési útvonalán, és ekkor a python
utasítás beírásával az értelmez ˝ értelmez ˝ o elindítható. Mivel a telepítés helye telepítési opció, más helyen is lehet a program; ha nem tudod az értelmez ˝ ot elindítani, kérj segítséget egy nagyobb tudású embert ˝ embert ˝ ol. (Például a ‘ ’ is egy gyakori hely.) Fájlvége karaktert ( Control-D U NI X-on, Control-Z Windows-on) írva a Python els ˝ els ˝ odleges promptjára, az értelmez ˝ értelmez ˝ o nulla kilépési státusszal (zero exit status) lép ki. Ha ez nem m˝ uködik, akkor az értelmez ˝ értelmez ˝ ot a következ ˝ következ ˝ o import sys; sys.exit sys.exit() ()’. utasításokkal hagyhatod el: ‘ import A szövegsori szerkesztés szerkesztés támogatottságának talán leggyorsabb ellen ˝ ellen ˝ orzése a Control-P megnyomása megnyomása az els ˝ els ˝ o meg jelen ˝ jelen ˝ o promptnál. Ha ez sípol, akkor van; lásd az Appendix bemutatja az érvényes billenty˝ uket. Ha semmi nem jelenik meg, vagy csak egy ^P, akkor a szövegsori szerkesztés nem elérhet ˝ elérhet ˝ o; ekkor csak a backspace karakterrel törölhetsz karaktert az aktuális sorból. Az értelmez ˝ értelmez ˝ o a UNIX shellhez hasonlóan m˝ uködik: ha a szabváyos bemenettel van meghívva, akkor interaktívan olvas és hajt végre utasításokat; ha fájlnév argumentummal vagy egy fájllal, mint szabványos bemenettel hívjuk meg, akkor szkript -ként -ként lefuttatja a megadott fájlt. [arg] ...’ parancsor, Egy másik lehet ˝ lehet ˝ oség az értelmez ˝ értelmez ˝ o indítására a ‘ python python -c command [arg] parancsor, amely amely végrevégrehajtja az utasítás(oka)t a command -ban, -ban, hasonlóan a shell -c opciójához. opciójához. Mivel Mivel a Python utasításo utasításokk gyakran tartalmaznak szóközöket, vagy más speciális karaktereket, amelyeknek speciális jelentésük van a shell számára, jobb, ha a parancs részt idéz ˝ idéz ˝ ojelbe (double quote) tesszük.
Some Python Python modules are also useful useful as scripts. These can be invoke invokedd using ‘ python python -m module [arg] ...’, which executes the source file for module as if you had spelled out its full name on the command line. Némelyik Python modul önálló programként is használható, ha így hívod meg: ‘ python python -m module ...’ – ez az utasítás végrehajtja a module forráskódját.
[arg]
Érdemes megjegyezni, hogy különbség van a ‘ python python file’ és a ‘ python python
Sokszor hasznos, ha egy szkript fájl futtatása után rögtön interaktív üzemmódba kerülünk. Ezt egyszer˝ u elérni, a szkript neve el ˝ el ˝ ott adjuk meg az -i kapcsolót. (Ez nem m˝ uködik ha a szkriptet a szabványos bemeneten keresztül olvassuk be, a fentebb leírtak szerint.)
Ha az értelmez ˝ értelmez ˝ ot szkrip-fájllal indítjuk, akkor a szkript fájl neve és a nevet esetleg követ ˝ o argumentumok a sys.argv, string-lista típusú változóba kerülnek. Ennek hossza leglább 1; amennyiben sem szkrip-nevet, sem semmilyen argumentumot nem adunk meg, a sys.argv[0] változó értéke üres string lesz. Ha a szkript neveként ’-’-t adunk meg (ez a szabványos bemenetnek felel meg), sys.argv[0] értéke ’-’ lesz. Argumentumként -c parancs-ot megadva sys.argv[0] értéke ’-c’ lesz. A -c parancs után álló kapcsolókat az értelmez ˝ értelmez ˝ o nem dolgozza fel, hanem a sys.argv-ben eltárolva a parancs-ra hagyja annak feldolgozását.
Amikor a parancs a tty-r ˝ tty-r ˝ ol (pl. (pl. billen billenty˝ ty˝ uzet) érkezik, az értelmez ˝ értelmez ˝ o úgynevezett interaktív (párbeszédes) üzemmódban m˝ uködik. Ekkor az els˝ következ ˝ o parancs megadását, amely szoodleges prompt megjelenítésével kéri a következ ˝ kásosan három egymás után következ ˝ következ ˝ o nagyobb-jel (‘ >>> ’); a sorok folytatásához folytatásához ezek a folytatólago folytatólagoss sorok – a másodlagos promptot jeleníti meg, szokásos értéke három egymás után írt pont (‘ ... ’). Azt érte értelme lmezz ˝ o ˝ elindulásakor, miel ˝ miel ˝ ott az els ˝ els ˝ odleges odleges prompt megjelenne, megjelenne, egy üdvözl ˝ üdvözl ˝ o-szöveget o-szöveget ír ki, tartalmazv tartalmazvaa az értelmez értelmez ˝ o verziószámát és a jogi védettséget python Pyth Python on 1.5. 1.5.2b 2b2 2 (#1, (#1, Feb Feb 28 1999 1999, , 00:0 00:02: 2:06 06) ) [GCC [GCC 2.8. 2.8.1] 1] on suno sunos5 s5 Copyright Copyright 1991-1995 1991-1995 Stichting Stichting Mathematisc Mathematisch h Centrum, Centrum, Amsterdam Amsterdam >>>
Folytatólagos sorok szükségesek, ha többsoros szerkezeteket írsz be. Például a következ ˝ o if utasítás esetén: >>> a_vila a_vilag_s g_sik ik = 1 >>> if a_vila a_vilag_s g_sik: ik: ... ... prin print t "Vig "Vigyá yázz zz, , neho nehogy gy lees leess! s!" " ... Vigyázz, Vigyázz, nehogy leess!
Hiba esetén az értelmez ˝ értelmez ˝ o hibaüzenetet küld és kiírja a hiba nyomvonalát (stack trace). Párbeszédes üzemmódban az els ˝ els ˝ odleges promt jelenik meg; ha az adatok beolvasása fájlból történt, kiírja a hibanyomvonalat és nullától eltér ˝ tér ˝ o kilépési értékkel tér vissza. (A programon belül fellép ˝ fellép ˝ o és a program által kezelt kivételek ( except - try ) nem jelentenek hibát ebben a környezetben.) Vannak feltétel nélküli, ú.n. fatális hibák, amelyek azonnal, nullától eltér ˝ eltér ˝ o visszatérési értékkel történ ˝ történ ˝ o programmegszakítást és kilépést eredményeznek, ilyenek a bels ˝ bels ˝ o inkonzisztenciát okozó, valamint a memóriából kifutó programok hibái. Minden hibaüzenet a szabványos hibakimenetre (standard standard error error) kerül, a futtatott parancsok rendes kimenete pedig a szabványos kimenetre ( standard output) íródik. Ha az els ˝ els ˝ odleges, vagy a másodlagos promptnál a megszakítás-karaktert gépeljük be (rendszerint Control-C vagy a DEL billenty˝ u), az törli az eddigi bemenetet és visszaadja a vezérlést az els ˝ els ˝ odleges promtnak. 1 1
A GNU Readline csomag hibája ennek a funkciónak a m˝ uködését megakadályozhatja.
Ha a megszakításkérelmet valamely parancs/program végrehajtása alatt adjuk ki, az kivételt generál; ez programból a try utasítással ’kapható el’.
KeyboardInterrupt
A BSD-szer BSD-szeru˝ U NI X rendszereken (Linuxon is) a Python szkripteket ugyanúgy, mint a shell szkripteket - közvetlenül futtathatóvá lehet tenni, legels ˝ legels ˝ o sorként megadva a #! /usr/bin/en /usr/bin/env v python python
˝ (feltételez (feltételezve, ve, hogy a Python értelmez értelmez ˝ o elérési útvonala útvonala a felhasználó PATH változójában be van állítva és a szkript fájl végrehajtható tulajdonsággal bír). Ford. megjegyzés: Debian rendszeren a Python elérési útvonalát adtam meg a programjaim elején, ez nálam #!/usr/bin/python
volt – így nem volt szükség környezeti változó beállítására. A fenti esetekben a fájlnak a ‘ #!’ karakterekk karakterekkel el kell kell kezd ˝ kezd ˝ odnie. Ezt a sort néhány néhány platformon platformon U NI X-típusú sorvéggel (‘\n’) kell lezárni, nem pedig Mac OS (‘ \r’) vagy windows-os (‘ \r\n’) sorvéggel. Figyelem: ha láthatatlan ‘ \r’ karaktert tartalmaz az els ˝ els ˝ o sor vége, nem fog lefutni a program, és a hibát nagyon nagyon nehezen lehet észrevenni! Tipikusan akkor fordul el ˝ el ˝ o, ha Windows-os Windows-os szövegszerkeszt ˝ szövegszerkeszt ˝ ovel (pl. notepad) notepad) készítjük készítjük a programot. Megjegyezend ˝ Megjegyezend ˝ o: a ‘#’ karakterrel a Pythonban Python ban a megjegyzéseket kezdjük. A szkriptnek a chmod paranccsal adhatunk végrehajtási engedélyt az alábbi módon: $ chmod chmod +x szkrip szkriptem tem.py .py
A Python-os forrásfájlokban az ASCII (7-bites) karakterkódolástól eltér ˝ eltér ˝ o kódlapokat (karakterkészletek) is használhatunk. Legegyszer˝ ubben a #!-vel kezd ˝ kezd ˝ od ˝ od ˝ o sort követ ˝ követ ˝ oen az alábbi módon adhatjuk meg a használt karakterkészletet/kódtáblát: # -*- coding coding: : iso-88 iso-885959-1 1 -*-
Ezt követ ˝ követ ˝ oen a forráskód minden karaktere az iso-8859-1 karaktertáblázat alapján értelmez ˝ értelmez ˝ odik, ezáltal közvetlenül unikódos (Unicode) beégetett szövegrészeket (string literal) használhatunk a programunkban. A választható kódlapok/karakterkészletek listája a Python Library Reference -ben a codecs fejezetben található. For example, to write Unicode literals literals including including the Euro currency symbol, the ISO-8859-15 ISO-8859-15 encoding encoding can be used, with the Euro symbol having having the ordinal value value 164. This script will print the value 8364 (the Unicode codepoint corresponding to the Euro symbol) and then exit: Például olyan Unicode karaktereket akarsz írni, amelyek tartalmazzák az Euro pénznem jelét, az ISO-8859-15-ös kódolást használhatod – melyben az Euro a 164-es karakterhelyen található. A következ ˝ következ ˝ o kis program Windows XP-n tesztelve 128-as értéket ír ki. (az el ˝ el ˝ obbi 164-es értéket nem tudom miért írták a tutorialba, és miért 128-at ad vissza nálam a példaprogram - ford.)
# -*- coding coding: : iso-88 iso-885959-15 15 -*curr curren ency cy = u" " # itt itt az euro euro szim szimbó bólu lumo mot t gépe gépelt ltük ük be. be. print print ord(cu ord(curre rrency ncy) ) # kimene kimenete te XP-n XP-n 128 print print chr(12 chr(128) 8) # euro euro szimbó szimbólum lumot ot ír ki.
Amennyiben a szövegszerkeszt ˝ szövegszerkeszt ˝ od lehet ˝ lehet ˝ ové teszi a fájl UTF-8-ként való elmentését byte-sorrend megjelöléssel (BOM), akkor akkor elég így elmenteni elmenteni a fájlt és nem kell a fenti deklaráció. deklaráció. A fejleszt ˝ fejleszt ˝ okörnyezet (IDLE) ezt az Options/General/Defaul Options/General/Default t Source Encoding/UTF-8 Encoding/UTF-8menü útvonalon keresztüli beállítással támogatja. Megjegyzend ˝ Megjegyzend ˝ o, hogy ezt a tulajdonságot csak a Python 2.3-as és a fejlettebb verziók kezelik helyesen; az operációs rendszer nem kezeli le, és ebben az esetben U NI X rendszereken nem is tudja a #! sorozattal kezd ˝ kezd ˝ od ˝ od ˝ o (parancs)fájlokat értelmezni! UTF-8 használatáv használatával al (vagy (vagy a BOM, BOM, vagy a kódolás kódolás program program eleji megadásáv megadásával) al) beégetett beégetett szövegek szövegek (string literals) literals) és a megjegyzések a világ legtöbb nyelvén beírhatók a programba – egy fájlban több nyelvet is használhatunk. A változók neveiben továbbra is csak ASCII karaktereket szabad használni. A szövegszerkeszt ˝ szövegszerkeszt ˝ o csak akkor jeleníti meg hibátlanul hibátlanul a karaktereke karaktereket,t, ha felismeri felismeri hogy UTF-8 fájlról van szó – és olyan bet ˝ ukészletet használ, amely minden megjelenítend ˝ megjelenítend ˝ o karakter képét tartalmazza.
Párbeszédes (interaktív) üzemmódban használva a Pythont, sokszor kívánatos, hogy az értelmez ˝ értelmez ˝ o futtatása el ˝ el ˝ ott bizonyos parancsok mindig lefussanak. Ez a PYTHONSTARTUP nev˝ u környezeti változó értékének megadásával történhet; történhet; itt kell megadni megadni a futtatni kívánt parancsfá parancsfájl jl nevét. Ez a megoldás megoldás azonos a U NI X ‘ ’ fájl megoldásával. Az indítófájl beolvasása csak párbeszédes üzemmódban történik; nem történik beolvasás ha a parancsok fájlból jönnek, jönnek, vagy ha bemenetként bemenetként a ‘ ’ explicit módon lett megadva (amelyet egyébként párbeszédes üzemmódban az értelmez ˝ értelmez ˝ o alaphelyzetben használ). Az indítófájl a futása során ugyanazt a névterületet (name space) használja mint a párbeszédes üzemmód, így a benne definiált vagy bele importált objektumok változatlanul, további pontosítás pontosítás nélkül használhatók használhatók párbeszéde párbeszédess üzemmódban is. Ebben a fájlban fájlban a sys.ps1 és sys.ps2 értékeinek átírásával változtathatod a promtok értékeit. Amennyiben az aktuális könyvtárból egy másik indítófájlt is szeretnél futtatni, megteheted a globális indítófájl szerkeszté szerkesztéséve sével,l, ahogy ezt az alábbi példa mutatja: mutatja: ‘ if os.path.isfile(’.pyth os.path.isfile(’.pythonrc.py’): onrc.py’): execfile(’.pythonrc.py’)’. import import os filename filename = os.environ. os.environ.get(’P get(’PYTHON YTHONSTARTU STARTUP’) P’) if filename filename and os.path.isf os.path.isfile(f ile(filenam ilename): e): execfile(filename)
3. fejezet
Kötetlen bevezet ˝ bevezet ˝ o a Pythonba A következ ˝ következ ˝ o példákban a kimenetet és a bemenetet az els ˝ els ˝ odleges odleges és másodlagos másodlagos készenléti készenléti jelek – promptok promptok – (‘>>> ’ és ‘... ’) meglétével, illetve hiányával különböztetjük meg. A példák kipróbálásához mindent be kell írnod írnod a promp prompto tokk után után,, amik amikor or a promp promptt megj megjel elen enik ik;; azok azok a soro sorok, k, amel amelye yekk el ˝ el ˝ ott nincs prompt, a fordító kimenetei. kimenetei. Jegyez Jegyezdd meg, meg, hogy az önmagáb önmagában an álló álló másodl másodlago agoss prompt prompt a példa egyik egyik sorában sorában azt jelent jelenti, i, hogy nem kell kell semmit semmit írni a sorba; ez jelzi egy többsoros utasítás végét. Ennek a kézikönyvne kézikönyvnekk sok példájában példájában – még azokban is, amelyeket amelyeket interaktív interaktív módon írtunk be – szerepelne szerepelnekk megjegyzések. A Pythonban a megjegyzések kett ˝ kett ˝ oskereszttel (hash, ‘ #’) kezd ˝ kezd ˝ odnek és a sor végéig tartanak. Egy megjegyzés megjegyzéslehet lehet sor elején, elején, vagy követhet követhet szóközt, szóközt, tabulátor tabulátor-karak -karaktert, tert, de ha egy karakterlán karakterláncc belsejébe belsejébe teszed, teszed, az nem lesz megjegyzés megjegyzés (lásd a példában!). A kett ˝ kett ˝ oskereszt karakter egy karakterláncon belül csak egy kett ˝ kett ˝ oskereszt. Példák: ˝ megjegyzés # ez az els˝ elso megjegyzés SPAM = 1
# ez a második megjegyzés # ... ... és ez a harm harmad adik ik. . STRI STRING NG = "# Ez nem nem megj megjeg egyz yzés és." ." ˝ sor: prin print t STRIN STRING G # ennek ennek a kimen kimenet ete e a köve követk tkez ez˝ o sor: # Ez nem megjegyzé megjegyzés. s.
Próbáljunk ki néhány Python utasítást. Indítsuk el az értelmez ˝ értelmez ˝ ot, és várjuk meg az els ˝ els ˝ odleges promptot: ‘ >>> ’. (Nem kell sokáig várni.)
A parancsértelmez ˝ parancsértelmez ˝ o úgy m˝ uködik, uködik, mint egy sima számológép: számológép: be lehet írni egy kifejezést, kifejezést, és az kiszámolja kiszámolja az értékét. értékét. A kifejezések kifejezések nyelvta nyelvtana na a szokásos: szokásos: a +, -, * és / muveletek ˝ ugyanúgy m˝ uködnek, mint a legtöbb nyelvben (például, Pascal vagy C); zárójeleket használhatunk a csoportosításra. Például:
>>> 4 >>> >>> ... 4 >>> >>> 4 >>> 5 >>> ... 2 >>> -3
2+2 # Ez egy egy megj megjeg egyz yzés és 2+2 2+2 2+2
# és egy egy megj megjeg egyz yzés és ugyana ugyanabb bban an a sorb sorban an, , ahol ahol utas utasít ítás ás van
(50-5*6)/4 (50-5*6)/4 # Egésze Egészek k osztás osztása a az eredmé eredmény ny lefelé lefelé kerekí kerekítet tett t értéké értékét t adja: adja: 7/3 7/-3 7/-3
A C-hez hasonlóan az egyenl ˝ egyenl ˝ oségjellel (‘ =’) lehet értéket adni egy változónak. Az értékadás után az értelmez ˝ értelmez ˝ o újabb utasításra vár, látszólag nem történik semmi: >>> >>> szél széles essé ség g = 20 >>> >>> maga magass sság ág = 5*9 5*9 >>> széles szélesség ség * magass magasság ág 900
(Az ékeze ékezetek tek nekem nekem m˝ uködtek uködtek interaktív interaktív módban, módban, lehet, lehet, hogy a régebbi programváltoz programváltozatok atokmiatt miatt érdemes érdemes kerülni. kerülni. A a program prog ram elején adjuk meg hogy milyen kódtáblával dolgozunk, például windows alatt: >>> >>> # -*-*- codi coding ng: : cp12 cp1250 50 -*-*...
Linux Linux alatt alatt is m˝ uködik az ékezetk ékezetkezelé ezelés, s, a Linux Linux telepítések telepítésekor or a magyar magyar nyelvet nyelvet állítottam állítottam be, a Pythonba Pythonbann semmit nem kellett állítanom. – A fordító megjegyzése.) Több változónak egyszerre tudunk értéket adni: >>> >>> >>> 0 >>> >>> 0 >>> >>> 0
x = y = z = 0 x
# N ul ulla l es esz a z x, x, y és z
y z
A programnyelv támogatja a lebeg ˝ lebeg ˝ opontos opontos számábrázolást; számábrázolást; azok a m uveletek ˝ amelyeknél keverednek a típusok, az egészeket lebeg ˝ lebeg ˝ opontossá alakítják: >>> 3 * 3.75 / 1.5 7.5 >>> 7.0 / 2 3.5
Complex Complex numbers numbers are also also supporte supported; d; imaginary imaginary numbers are written written with a suffix suffix of ‘j’ or ‘J’. Comple Complexx numbers numbers with a nonzero real component are written as ‘ (real+imagj)’, or can be created with the ‘ complex(real, imag)’ function.
A Python komplex számokat is tud kezelni – a képzetes részt a ‘ j’ vagy ‘J’ jellel képezhetjük. A komplex komplex számot ‘(valós+képzetes j)’ alakban vagy ‘ complex(valós, képzetes)’ alakban írhatjuk, ha a képzetes rész nem nulla. >>> 1j * 1J (-1+0j) >>> 1j * comple complex(0 x(0,1) ,1) (-1+0j) >>> 3+1j*3 3+1j*3 (3+3j) >>> (3+1j)*3 (3+1j)*3 (9+3j) >>> (1+2j)/(1+1 (1+2j)/(1+1j) j) (1.5+0.5j)
A komplex számokat gyakran két lebeg ˝ lebeg ˝ opontos számmal ábrázolják – a képzetes és a valós résszel. A z komplex számnak ezeket a részeit a z.real és z.imag utasításokkal olvashatjuk vissza. >>> a=1.5+0.5j a=1.5+0.5j >>> a.real a.real 1.5 >>> a.imag a.imag 0.5
The conversion functions to floating point and integer ( float(), int() and long()) don’t work for complex numbers — there is no one correct way to convert convert a complex number number to a real number. number. Use abs( z) to get its magnitude (as a float) or z.real to get its real part. A lebeg ˝ lebeg ˝ opontosés opontos és egész egész típusú konverz konverziós iós függvények függvények (float(), int() és long()) nem nem m˝ uködnek uködnek komplex komplex számokra. számokra. A komplex - valós számok közötti konverz konverziónak iónak több több lehetségesmódja lehetségesmódja is van – ahhoz, hogy egy komplex számból valósat csinálj, használd az abs( z) utasítást, hogy megkapd a nagyságát (lebeg ˝ (lebeg ˝ opontosként) vagy a z.real utasítást, ha a valós része kell. >>> a=3.0+4.0j a=3.0+4.0j >>> float(a) float(a) Traceb Traceback ack (most (most recent recent call call last): last): File File "
n>", ", line line 1, in ? TypeEr TypeError ror: : can’t can’t conver convert t comple complex x to float; float; use abs(z) abs(z) >>> a.real a.real 3.0 >>> a.imag a.imag 4.0 >>> abs(a) abs(a) # sqrt(a.re sqrt(a.real* al**2 *2 + a.imag** a.imag**2) 2) 5.0 >>> >>> float( float(8) 8) # lebego lebegopon pontos tos alakra alakra konver konvertal tal. . kimene kimenete: te: 8.0
(alsóvonás) ás) változóban Interaktív Interaktív módban az utoljára utoljára kiírt kifejezés kifejezés értéke a ’_’ (alsóvon változóban van. van. Így ha a Pythont asztali számológépként használod, akkor egyszer˝ ubb folytatni a számolásokat, például:
>>> >>> adó = 12.5 12.5 / 100 100 >>> >>> ár = 100. 100.50 50 >>> >>> ár * adó adó 12.5625 >>> ár + _ 113.0625 >>> round( round(_, _, 2) 113.06 >>>
Ezt a változót csak olvasható változóként kezelhetjük. Ne adjunk értéket neki – mert ha adunk, akkor létrehozunk egy függetl független en helyi helyi változ változót ót azonos azonos névvel névvel,, amely amely meggát meggátolj oljaa a beépít beépített ett változ változóó elérés elérését. ét. (Ha egy globál globális is változ változóó nevével létrehozunk egy helyi változót, akkor az értelmez ˝ értelmez ˝ o a helyit használja.
A számok mellett a Python karakterláncokkal is tud m˝ uveleteket végezni. A karakterláncokat idéz ˝ idéz ˝ ojelek vagy aposztrófok közé kell zárni: >>> ’spam ’spam eggs’ eggs’ ’spam eggs’ >>> ’doesn\’t’ ’doesn\’t’ "doesn’t" >>> "doesn’t" "doesn’t" "doesn’t" >>> ’"Yes, ’"Yes," " he said.’ said.’ ’"Yes, ’"Yes," " he said.’ said.’ >>> "\"Yes "\"Yes,\" ,\" he said." said." ’"Yes, ’"Yes," " he said.’ said.’ >>> ’"Isn\ ’"Isn\’t, ’t," " she said.’ said.’ ’"Isn\’t," ’"Isn\’t," she said.’ said.’
Egy karakerláncot többféle módon bonthatunk szét több sorba. Azt a sort, amelyet folytatni szeretnénk, visszaperjellel (back-slash-jellel: \-el) zárjuk le, ezzel jelezve, hogy a következ ˝ következ ˝ o sor ennek a sornak a logikai folytatása hello hello = "Ez egy nagyon nagyon hosszú hosszú karakt karakterl erlánc ánc, , amely\ amely\n\ n\ több több sorból sorból áll. áll. Ugyanú Ugyanúgy gy válasz választha tható tó el mint mint C-ben. C-ben.\n\ \n\ Jegyez Jegyezd d meg, meg, hogy hogy a sorele soreleji ji szóköz szóközök ök és tabulá tabulátor torok\ ok\ fontosak.\n" print hello
A soremelést a \n
jellel adtuk meg. Ez a következ ˝ következ ˝ oket fogja kiírni: Ez egy nagyon nagyon hosszú hosszú karakt karakterl erlánc ánc, , amely amely több több sorból sorból áll. áll. Ugyanú Ugyanúgy gy válasz választha tható tó el mint mint C-ben. C-ben. Jegyez Jegyezd d meg, meg, hogy hogy a sorele soreleji ji szóköz szóközök ök és tabulá tabulátor torok ok fontos fontosak. ak.
Ha „raw” (nyers, bármiféle konverzió nélkül pontosan azt adja vissza, amit beírsz) karakterláncot szeretnél készítesz, a \n karakterpár nem konvertálódik újsor karakterre. A forráskódban lév ˝ lév ˝ o összes sortörés és sorvégi \ jel megmarad:
hello hello = r"Ez r"Ez egy hosszú hosszú karakt karakterl erlánc ánc, , amely amely több több sorból sorból áll,\n áll,\n\ \ ahogy C-ben csinálnád!" csinálnád!" print hello
Ezt fogja kiírni: Ez egy hosszú hosszú karakt karakterl erlánc ánc, , amely amely több több sorból sorból áll,\n áll,\n\ \ ahogy C-ben csinálnád!. csinálnád!.
Vagy a karakterláncot hármas idéz ˝ idéz ˝ ojellel vehetjük körül: mert azok jelölés nélkül benne lesznek a karakterláncban. print print """ Usage: Usage: thingy [OPTIONS] -h -H hostname """
"""
vagy
’’’.
Ilyenkor Ilyenkor az újsort nem kell jelölnöd jelölnöd
Display this usage message Hostname to connect to
Ez a következ ˝ következ ˝ o kimenetet adja: Usage: Usage: thingy [OPTIONS] -h -H hostname
Display this usage message Hostname to connect to
Az értelmez ˝ értelmez ˝ o ugyanúgy írja ki a karakterlánc-m˝ uveletek eredményét, ahogy begépeltük a bemenetre: idéz ˝ idéz ˝ ojelekben, a bels ˝ bels ˝ o idéz ˝ idéz ˝ ojeleket és más érdekes karaktereket vissza-perjelekkell megvédve, hogy a pontos értéket megmutassa. (Az ékezetes bet˝ uknek a kódját adja vissza vissza-perrel vissza-perrel az elején. elején. A vissza-perrel vissza-perrel kezd ˝ kezd ˝ od ˝ od ˝ o speciális jelentés˝ u részeket nevezik escape sorozatoknak, escape karaktereknek... – a ford.) A karakterlánc dupla idéz ˝ o ˝ jelben jelben van, ha egyszeres egyszeres idéz ˝ idéz ˝ ojelet tartalmaz, de kétszereset nem, különben egyszeres idéz ˝ idéz ˝ ojelben. ojelben. (A kés kés ˝ obb sorrakerül ˝ sorrakerül ˝ o print utasítást használhatjuk a karakterláncok idéz ˝ idéz ˝ ojel és escape sorozatok nélküli kiíratásához.) Karakterláncokat a + muvelettel ˝ ragaszthatunk össze és *-gal ismételhetünk. >>> >>> szo szo = ’Seg ’Segít ít’ ’ + ’s’ ’s’ >>> szo ’Segíts’ >>> >>> ’<’ ’<’ + szo* szo*5 5 + ’>’ ’>’ ’’
Két egymást követ ˝ követ ˝ o karakterláncot az értelmez ˝ értelmez ˝ o magátó magátóll össze összevon von;; az els ˝ els ˝ o sor fentebb lehetne ‘ szo = oleges karakterlánc’Segít’ ’Segít’ ’s’’ is; ez csak két a beégetett karakterláncokra (string literal) érvényes, tesz ˝ kifejezésekre nem: >>> import import string string >>> ’str’ ’ing’ ’string’ >>> >>> s str trin ing. g.st stri rip( p(’s ’str tr’) ’) + ’ ’in ing’ g’ ’string’ >>> >>> strin tring. g.st stri rip( p(’s ’str tr’) ’) ’ing ’ing’ ’ File File "" n>", , line line 1 string.strip(’str’) ’ing’ ^ SyntaxError SyntaxError: : invalid invalid syntax
#
<-
helyes.
#
<-
hely helyes es. .
#
<-
ez nem nem meg megy.
A karakterlánc karakterláncokat okat fel lehet bontani al-karakterlánc al-karakterláncokra okra (indexelni); (indexelni); ahogy a C-ben is, a karakterlánc karakterlánc els ˝ els ˝ o karaktere a nullás index˝ u. Nincs külön karakter karakter típus; egy karakter, karakter, az egy egységnyi hosszúság hosszúságúú karakterlánc. karakterlánc. Ahogy az Icon-ban, az rész-karakterláncokat szeletel˝ dal jelölhetünk ki: a két indexet kett ˝ kett ˝ osponttal o jelölési mód dal választjuk el. >>> szo[4] szo[4] ’t’ >>> szo[0:2] szo[0:2] ’Se’ >>> szo[2:4] szo[2:4] ’gí’
A szeletek indexeinek hasznos alapértékei vannak; az elhagyott els ˝ o index nullát jelent, ha a másodikat hagyjuk el, akkor a karakterlánc végéig tart a szelet. >>> szo[:2] ’Se’ >>> >>> szo[ szo[2: 2:] ] ’gíts’
˝ két karakter # Az elso karakter ˝ kett ˝ # Mind Minden en kar karak akte ter, r, az az els elso kett˝ ot ot kivéve kivéve
A C-vel szemben a karakterláncot nem lehet megváltoztatni. Ha egy indexelt helynek értéket adunk, hibaüzenetet kapunk: >>> >>> szo[ szo[0] 0] = ’x’ ’x’ Traceb Traceback ack (most (most recent recent call call last): last): File File " n>", ", line line 1, in ? TypeError: TypeError: object doesn’t doesn’t support support item assignment >>> szo[:1 szo[:1] ] = ’Splat ’Splat’ ’ Traceb Traceback ack (most (most recent recent call call last): last): File File " n>", ", line line 1, in ? TypeError: TypeError: object doesn’t doesn’t support support slice assignment assignment
Jóllehet, új karakterláncot létrehozni a részeik összerakásával könnyen és hatékony módon lehet: >>> >>> ’x’ ’x’ + szo[ szo[1: 1:] ] ’xegíts’ >>> ’Vidít ’Vidít’ ’ + szo[5] szo[5] ’Vidíts’
Itt van egy hasznos, az eredeti változóval azonos érték˝ u karakterlánc: s[:i s[:i] ]
egyenl ˝ o az s-el. + s[i: s[i:] ] egyenl ˝
>>> szo[:2 szo[:2] ] + szo[2: szo[2:] ] ’Segíts’ >>> szo[:3 szo[:3] ] + szo[3: szo[3:] ] ’Segíts’
A valótlan méret˝ u szeleteket az értelmez ˝ értelmez ˝ o okosan kezeli: egy indexet indexet ami túl nagy helyettesí helyettesíti ti a karakterlánc karakterlánc méretével, ha az alsó határ nagyobb mint a fels ˝ fels ˝ o, akkor egy üres karakterlánccal tér vissza.
>>> szo[1:100] szo[1:100] ’egíts’ >>> szo[10:] szo[10:] ’’ >>> szo[2:1] szo[2:1] ’’
Az indexek negatív számok is lehetnek, ekkor jobb oldalról számol. Például: >>> szo[-1] ’s’ >>> szo[-2] ’t’ >>> >>> s sz zo[-2 o[-2:] :] ’ts’ >>> >>> szo[ szo[::-2] 2] ’Segí’
# Az utolsó karakter ˝ # Az utolsó elotti otti ˝ karakt # Az utol utolsó só kett kett˝ o karakter er ˝ # Az öss össze zes, s, kiv kivév éve e az uto utols lsó ó kett kett˝ o
Jegyezd meg, hogy a -0 valóban azonos a 0-val, így ez nem jobbról számol! >>> sz szo[-0] ’S’
˝ # (mivel -0 és és 0 eg egyenloek) oek)
A tartományon kívüli negatív indexeket megcsonkítja a Python, de ez nem m˝ uködik egyetlen elemmel (azaz egyetlen karakterláncra): >>> szo[-100:] szo[-100:] ’Segíts’ >>> szo[-10] # hiba Traceb Traceback ack (most (most recent recent call call last): last): File File "" n>", , line line 1 IndexE IndexErro rror: r: string string index index out of range range
(Mivel kívül van az index a megengedett tartományon.) Úgy a legkönnyebb megjegyezni hogy m˝ uködnek a szeletek, ha azt képzeljük, hogy az indexek a karakterek els ˝ o karakter bal élét számozzuk számozzuk nullának. nullának. Ekkor az n karakterb ˝ karakterb ˝ ol álló karakterlánc karakterlánc utolsó közé mutatnak, az els ˝ karakterének jobb éle az n, például: +---+---+---+---+---+---+ | S | e | g | í | t | s | +---+---+---+---+---+---+ 0 1 2 3 4 5 6 -6 -5 -4 -3 -2 -1
Az els ˝ els ˝ o sorban álló számok adják a 0. . . 5 indexeket a karakterláncban; a második sor mutatja a megfelel ˝ megfelel ˝ o negatív indexeket. Az i-t ˝ -t ˝ ol j-ig terjed ˝ terjed ˝ o szelet mindazokat a karaktereket tartalmazza, amelyek az i és j jel˝ u élek között vannak. A nem negatív indexek esetén a szelet hossza az indexek különbségével egyenl ˝ o, ha mindkett ˝ mindkett ˝ o a valódi szóhatá˝ rokon belül van. Például a szo[1:3] hossza 2 (szo[ett˝ szo[ettol:eddig] ol:eddig]). Ford.: az indexek valójában egy-egy konkrét karakterre mutatnak, ezért a fenti ábra így helyénvaló: helyénvaló:
+---+---+---+---+---+---+ | S | e | g | í | t | s | +---+---+---+---+---+---+ 0 1 2 3 4 5 6 -6 -5 -4 -3 -2 -1
Ebb ˝ Ebb ˝ ol világosan világosan látszik, látszik, hogy a 0. elem az ’S’, ’S’, és a 3. elem az ’í’ bet˝ u. A Python szeletelés szeletelésii paraméterei paraméterei pozíciótól pozíciótól ˝ pozícióig (szo[ett˝ muködik, ˝ de az utolsó elem már nem tartozik a halmazba: szo[ettol:eddig] ol:eddig]) m˝ ˝ prin print t szo[0 szo[0:6 :6] ] # a 0. kara karakt kter ert tol o l a 6.-i 6.-ig g (de (de 6-os 6-os már már nem! nem!) ) # kiír kiírja ja a szót szót. .
A beépített len() függvény a karakterlánc hosszával tér vissza: >>> s = ’legeslegel ’legeslegelkáposz káposztásít tásíthatatl hatatlanságo anságoskodá skodásaito saitokért’ kért’ >>> len(s) len(s) 47
See Also: Sorozat jelleg˝ u típusok (
)
Itt található az Ascii és a Unicode karakterláncok leírása; példák a sorozat jelleg˝ u típusokra, illetve az ezen típusokkal végezhet ˝ végezhet ˝ o m˝ muveletek ˝ leírása. Karakterlánc metódusok (
)
A hagyományos és a Unicode karakterláncok is sok metódussal rendelkeznek az alapvet ˝ o karakerlánc m˝ uveletek, keresés területén. Karakterlánc formázó m˝ uveletek (
)
A formázó m˝ uveletek akkor kerülnek használatba, amikor egy karakterlánc a dusa – további részletek itt olvashatók.
%
operátor baloldali operan-
A Python 2.0-tól kezdve egy új adattípust használhatnak a programozók: az Unicode objektumot. Ezt Unicode adatok (lásd ) tárolására és feldolgozására használhatjuk. Ez együtt használható a többi karakterláncot tartalmazó objektummal: automatikus átalakítás (konverzió) (konverzió) jön létre, ahol szükséges. ˝ irat minden karakteréhez egy sorszámot rendel. KoAz Unicode-nak megvan az az el ˝ el ˝ onye, hogy a modern és osi rábban csak 256 lehetséges sorszámot használtak a karakterek leírásához, és egy szöveg rendszerint kapcsolódott egy kódlaphoz, amely leképezte a sorszámokat a karakterekre. Ez rengeteg kavarodáshoz vezetett, f ˝ f ˝ oleg a programok más nyelvekre fordításakor (internationalization = ‘ i18n’, azaz ‘ i’ + 18 karakter + ‘ n’). Az Unicode megoldotta a problémát azzal, hogy egyetlen kódlapot definiál a világ valamennyi nyelvéhez. Unicode karakterláncokat ugyanolyan egyszer˝ u Pythonban létrehozni, mint a hagyományos szövegeket: >>> u’Hell u’Hello o World World !’ u’Hell u’Hello o World World !’
Az idéz ˝ idéz ˝ ojel el ˝ el ˝ otti kis ‘u’ mutatja, hogy Unicode karakterláncot kell létrehozni. Ha speciális karaktereket szeretnénk használni a szövegben, ezt megtehetjük Python Unicode-Escape kódolásával. A következ ˝ következ ˝ o példa megmutatja, hogyan:
>>> u’Hello\u00 u’Hello\u0020Wor 20World ld !’ u’Hell u’Hello o World World !’
A \u0020 escape-sorozat jelzi, hogy egy 0x0020 (a szóköz karakter) sorszámú Unicode karaktert kell beszúrni az adott helyen. Más karaktereket úgy értelmez, hogy az illet ˝ illet ˝ o karakter sorszámát felhasználja közvetlenül Unicode sorszámként. Ha szabványos Latin-1 kódolású szöveget használunk (ezt a kódolást használják sok nyugat-európai államban) észrevehetjük, hogy az Unicode els ˝ els ˝ o 256 karaktere ugyanaz, mint a Latin-1-es kódolás els ˝ els ˝ o 256 karaktere. Szakért ˝ Szakért ˝ oknek: Van Van egyfajta nyers mód (raw (raw mode), amilyen a normál karakterláncoknál is. Az idéz ˝ idéz ˝ ojel elé ’ur’-et kell írni, hogy a Python a Raw-Unicode-Escape kódolást kódolást használja. használja. Ez a fenti \uXXXX konverziót csak akkor fogja alkalmazni, ha páratlan számú vissza-per jel van a kis ’u’ el ˝ el ˝ ott. >>> ur’Hello\u0 ur’Hello\u0020Wo 020World rld !’ u’Hell u’Hello o World World !’ >>> ur’Hello\\u ur’Hello\\u0020W 0020World orld !’ u’Hello\\\\u0020World !’
A nyers mód akkor a leghasznosabb, ha sok vissza-per jelet kell beírni, mint például reguláris kifejezéseknél. A szabványos kódoláson kívül is számos egyéb mód van a Pythonban Unicode szövegek létrehozására valamely ismert kódolás alapján. ˝ A beépített unicode() függvény függvény gondoskodik gondoskodik a használhat használhatóó Unicode Unicode kódolók kódolók és dekódolók dekódolók elérésér elérésér ˝ ol. Néhány közismertebb az ilyen kódolások közül, amelyeket átkódolhatunk: Latin-1, ASCII , UTF-8, és UTF-16 . Az utóbbi kett ˝ kett ˝ o változó hosszúságú kódolás, amely minden Unicode karaktert egy vagy két bájton tárol. Az alapértelmezett kódolás az ASCII, amely a 0-tól 127-ig terjed ˝ terjed ˝ o karaktereket alakítja át, a többit hibautasítással elutasítja. Ha az Unicode karakterláncot kiíratjuk, fájlba írjuk, vagy az str() függvénnyel átalakítjuk eszerint a kódolás szerint megy végbe. >>> u"abc" u"abc" u’abc’ >>> str(u"abc") str(u"abc") ’abc’ >>> u"äöü" u"äöü" u’\xe4\xf6\xfc’ >>> str(u"äöü") str(u"äöü") Traceb Traceback ack (most (most recent recent call call last): last): File File " n>", ", line line 1, in ? Unicod UnicodeEn eEncod codeEr eError ror: : ’ascii ’ascii’ ’ codec codec can’t can’t encode encode charac character ters s in positi position on 0-2: 0-2: ordina ordinal l not in ra
Ahhoz, hogy a Unicode karakterláncot egy 8-bites karakterlánccá alakítsuk a Unicode objektum egy encode() metódussal szolgál, amely egy argumentumot vár, a kódolás nevét. Kisbet˝ us kódolásneveket használjunk. >>> u"äöü".encode(’utf-8’) ’\xc3\xa4\xc3\xb6\xc3\xbc’
˝ Ha van van egy egy speciá speciális lis kódolá kódolású sú adatunk adatunk,, és meg szeretnén szeretnénkk kapni kapni a megfel megfelel el ˝ o Unicode karakterláncot, karakterláncot, a nevével. unicode() függvényt használjuk második argumentumként a kódolás nevével. >>> unicode(’\xc3\xa4\xc3\xb6\xc3\xbc’, ’utf-8’) u’\xe4\xf6\xfc’
A Python többfajta összetett adattípust ismer, amellyel több különböz ˝ különböz ˝ o értéket csoportosíthatunk. A legsokoldalúbb a lista, amelyet vessz ˝ vessz ˝ okkel elválasztott értékekként írhatunk be szögletes zárójelbe zárva. A lista elemeinek nem kell azonos típusúaknak lenniük. >>> a = [’spam [’spam’, ’, ’tojás ’tojások’ ok’, , 100, 100, 1234] 1234] >>> >>> a [’spam’, [’spam’, ’tojások’, ’tojások’, 100, 1234]
˝ Ahogy a karakterlánc-indexek, úgy a lista-indexek is 0-val kezd kezd ˝ odnek, és a listákat is szeletelhetjük, összeilleszthetjük és így tovább: >>> a[0] a[0] ’spam’ >>> a[3] a[3] 1234 >>> a[-2] a[-2] 100 >>> a[1:-1] a[1:-1] [’tojások’, [’tojások’, 100] >>> a[:2] a[:2] + [’sonk [’sonka’, a’, 2*2] [’spam’, [’spam’, ’tojások’, ’tojások’, ’sonka’, 4] >>> 3*a[:3 3*a[:3] ] + [’Boe! [’Boe!’] ’] [’spam [’spam’, ’, ’tojás ’tojások’ ok’, , 100, 100, ’spam’ ’spam’, , ’tojás ’tojások’ ok’, , 100, 100, ’spam’ ’spam’, , ’tojás ’tojások’ ok’, , 100, 100, ’Boe!’ ’Boe!’] ]
A karakterláncokkal ellentétben – amelyek megváltoztathatatlanok – a listák egyes elemeit módosíthatjuk: >>> >>> a [’spam’, [’spam’, ’tojások’, ’tojások’, 100, 1234] >>> >>> a[2] [2] = a[2] a[2] + 23 >>> >>> a [’spam’, [’spam’, ’tojások’, ’tojások’, 123, 1234]
A szeleteknek értékeket is adhatunk és ez akár a lista elemszámát is megváltoztathatja: >>> >>> # Pár Pár elem elem átír átírás ása: a: ... ... a[0: a[0:2] 2] = [1, [1, 12] 12] >>> >>> a [1, [1, 12, 12, 123, 123, 1234 1234] ] >>> >>> # Pár Pár elem elem törl törlés ése: e: ... ... a[0: a[0:2] 2] = [] >>> >>> a [123, 1234] >>> >>> # Pár Pár elem elem besz beszúr úrás ása: a: ... a[1:1] a[1:1] = [’blet [’bletch’ ch’, , ’xyzzy ’xyzzy’] ’] >>> >>> a [123, ’bletch’, ’xyzzy’, 1234] >>> >>> a[:0] a[:0] = a # Beszú Beszúrj rja a magát magát (pon (ponto tosa sabb bban an egy egy másol másolat atát át) ) a sajá saját t elejé elejére re. . >>> >>> a [123, [123, ’bletc ’bletch’, h’, ’xyzzy ’xyzzy’, ’, 1234, 1234, 123, 123, ’bletc ’bletch’, h’, ’xyzzy ’xyzzy’, ’, 1234] 1234]
A beépített len() függvény listákra is alkalmazható:
>>> len(a) len(a) 8
A listák egymásba ágyazása is lehetséges: >>> >>> >>> 3 >>> [2, [2, >>> 2 >>> >>> >>> >>> [1, [1, >>> >>> [2,
q = [2, 3] p = [1, q, 4] len(p) len(p) p[1] p[1] 3] p[1][0] p[1][0] p[1] p[1].a .app ppen end( d(’x ’xtr tra’ a’) ) p [2, [2, 3, ’xtr ’xtra’ a’], ], 4] q 3, ’xtra’ ’xtra’] ]
# Nézd Nézd meg meg az az 5.15.1-es es sza szaka kasz szt! t!
Figyeld meg, hogy az utolsó példában p[1] és visszatérünk az objektumok értelmezésére.
q
valóban valóban ugyanarra az objektumra objektumra hivatkozik! hivatkozik! Még kés ˝ kés ˝ obb
Természetesen a Pythont sokkal összetettebb feladatokra is használhatjuk annál, minthogy kiszámoljuk 2+2 értékét. Például írhatunk egy rövid ciklust a Fibonacci-sorozat kiszámolására: >>> ... ... >>> >>> ... ... ... 1 1 2 3 5 8
# Fibonacci-s Fibonacci-soroza orozat: t: ˝ ˝ két ˝ # az el˝ eloz˝ ozo két elem elem össz összeg ege e adja adja a köve követk tkez ez˝ ot ot a, b = 0, 1 whil while e b < 10: 10: print b a, b = b, a+b
Ebben a példában a Python több új tulajdonságát megtaláljuk: • Az els ˝ els ˝ o sor egy többszörös értékadást tartalmaz: a és b egyszerre egyszerre veszi veszi fel a 0 és 1 értékeket. értékeket. Az utolsó sorban sorban újból újból ezt haszná használju ljuk, k, hogy hogy megmut megmutass assuk, uk, hogy el ˝ el ˝ obb a jobboldal jobboldal értékel értékel ˝ ˝ odik ki, és csak azután azután megy végbe az értékadás. A jobboldali kifejezések jobbról balra értékel ˝ értékel ˝ odnek ki. • A while ciklus addig hajtódik végre, amíg a feltétel (itt: b < 1 0) igaz marad. A Pythonban Pythonban – ahogy a C-ben is – minden nullától eltér ˝ eltér ˝ o egész érték igazat, a nulla hamisat jelent. A feltétel lehet egy karakterlánc vagy egy lista (gyakorlatilag bármilyen sorozat): minden aminek nem nulla a hossza – igaz, az üres sorozatok hamisak. A példában használt feltétel egy egyszer˝ u összehasonlítás. A legalapvet ˝ legalapvet ˝ obb összehasonlító relációkat a C-vel azonosan jelöljük: < (kisebb mint), > (nagyobb mint), == (egyenl ˝ (egyenl ˝ oek), <= (kisebb vagy egyenl ˝ egyenl ˝ o), >= (nagyobb vagy egyenl ˝ egyenl ˝ o) and != (nem egyenl ˝ egyenl ˝ o). • The body of the the loo loopp is indented : indent indentati ation on is Python’ Python’ss way of groupin groupingg statem statement ents. s. Python Python does does not (yet!) (yet!)
provide an intelligent input line editing facility, so you have to type a tab or space(s) for each indented line. In practice you will prepare more complicated input for Python with a text editor; most text editors have an auto-indent facility. facility. When a compound statement is entered interactively, interactively, it must be followed by a blank b lank line to indicate completion (since the parser cannot guess when you have have typed the last line). Note that each line within a basic block must be indented by the same amount. • A ciklus magját beljebb húzzuk : a behúzás a Python jelölése az utasítások csoportosítására. A Pythonnak ˝ (még!) nincs intelligen intelligenss sorszerkeszt sorszerkeszt ˝ oje, tehát neked kell egy tabulátort vagy (néhány) szóközt beírnod ˝ minden behúzott sor elé. Gyakorlatban az összetettebb összetettebb bemeneteket úgyis szövegszerkeszt szövegszerkeszt ˝ ovel fogod elkészíteni, a legtöbb szövegszerkeszt ˝ szövegszerkeszt ˝ onek van eszköze az automatikus behúzásra. Ha egy összetett utasítást írunk be párbeszédes (interaktív) módban, azt egy üres sornak kell követnie (mivel az értelmez ˝ értelmez ˝ o nem tudja kitalálni, lesz-e még újabb sor). Jegyezd meg, hogy minden sort ugyanannyival ugyanannyival kell beljebb húzni. • A print utasítás kiírja annak a kifejezésnek az értékét, amelyet megadtunk. Ez abban különbözik attól, mintha a kifejezést kifejezést csak önmagában önmagában írnánk be (mint ahogy számológépk számológépként ént használtuk) használtuk),, ahogy a többszörös többszörös értékeket és a karakterláncokat kezeli. A karakterláncokat idéz ˝ idéz ˝ ojelek nélkül írja ki, és szóközöket illeszt az egyes tagok közé, így széppé teheted a kimenetet: >>> >>> i = 256* 256*25 256 6 >>> >>> prin print t ’Az ’Az i érté értéke ke:’ :’, , i Az i érté értéke ke: : 6553 65536 6
Egy lezáró vessz ˝ vessz ˝ o meggátolja az újsor karaktert a kimeneten: >>> a, b = 0, 1 >>> >>> whil while e b < 1000 1000: : ... print b, ... a, b = b, a+b ... 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
Vegyük észre, hogy az értelmez ˝ értelmez ˝ o újsort illeszt be miell ˝ miell ˝ ott visszaadja a következ ˝ következ ˝ o promptot, ha nem zárult le a sor.
4. fejezet
További vezérl ˝ vezérl ˝ o utasítások Az imént említett while utasítás mellett a Python ismeri a más nyelvekben szerepl ˝ szerepl ˝ o leggyakoribb vezérl ˝ vezérl ˝ o utasításokat is – némi változtatással.
if Talán a legjobban ismert utasítástípus az if utasítás. Példa: >>> >>> ... ... ... ... ... ... ... ... ... ... ... ...
x = int(ra int(raw_i w_inpu nput(" t("Írj Írjon on egy számot számot: : ")) if x < 0: x = 0 prin print t ’Neg ’Negat atív ív, , lecs lecser erél élte tem m null nullár ára’ a’ elif lif x == 0: print ’Nulla’ elif lif x == 1: print ’Egy’ else: else: print ’Egynél több.’
Hiányozhat, de lehet egy vagy akár egynél több elif rész, a else rész szintén elmaradhat. Az ‘ elif’ kulcsszó – amely az ‘else if’ rövidítése – hasznos a felesleges behúzások elkerülésésre. Egy if . . . elif . . . elif .. . sor sor helyettesíti a más nyelvekben található switch és case utasításokat.
for A for utasítás utasítás különbözik attól, attól, amely a C-ben és a Pascalban Pascalban található. található. Ahelyett, Ahelyett, hogy mindíg egy számtani sorozattal dolgozna (mint a Pascalban), vagy hogy megadná a lehet ˝ lehet ˝ oséget a felhasználónak, hogy saját maga határozza meg mind az iterációs lépést, mind a kilépési feltételt (ahogy a C-ben van) a Python for utasítása végighalad végighalad a sorozat (pl. szövegek szövegek listája) listája) összes elemén elemén olyan sorrendben, sorrendben, ahogy a listában listában szerepelnek. szerepelnek. Például: Például:
>>> # Megmér Megmérjük jük a szavak szavak hosszát: hosszát: ... a = [’cat’ [’cat’, , ’windo ’window’, w’, ’defen ’defenest estrat rate’] e’] >>> >>> for x in a: ... print x, len(x) ... cat cat 3 window window 6 defenestrat defenestrate e 12
Nem biztonságos dolog megváltoztatni a sorozatot, amelyen ciklussal végighaladunk (ez csak megváltoztatható sorozattal, például listával történhet meg). Ha mégis szükséges megváltoztatnod a listát, akkor a másolatát használd a for ciklusban. A szelet (slice) jelölési móddal ezt kényelmesen megteheted: >>> >>> for for x in a[:]: a[:]: # egy egy máso másola lato tot t csin csinál ál az ered eredet eti i list listár áról ól ... ... if len( len(x) x) > 6: 6: a.i a.ins nser ert( t(0, 0, x) ... >>> >>> a [’defenestr [’defenestrate’, ate’, ’cat’, ’cat’, ’window’, ’window’, ’defenestrat ’defenestrate’] e’]
range() Ha egy számso számsoroz rozato atonn kell kell végigh végighala aladnun dnunk, k, a range() beépített beépített függvény függvény lehet szolgálatunk szolgálatunkra. ra. Ez egy számtani számtani sorozatot állít el ˝ el ˝ o lista formában, pl.: >>> range(10) range(10) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
A megadott végpont sohasem része a listának; range(10) 10 elem˝ u listát hoz létre, pontosan egy tízelem˝ u sorozat indexeit. Lehet ˝ Lehet ˝ oség van rá, hogy a sorozat más számmal kezd ˝ kezd ˝ odjön, vagy hogy más lépésközt adjunk meg (akár negatívat is): >>> range( range(5, 5, 10) [5, [5, 6, 7, 8, 9] >>> >>> rang range( e(0, 0, 10, 10, 3) [0, [0, 3, 6, 9] >>> range( range(-10 -10, , -100, -100, -30) -30) [-10, [-10, -40, -40, -70] -70]
Ha egy sorozat indexein akarunk végighaladni, használjuk a pen:
következ ˝ oképrange() és len() függvényeket a következ ˝
>>> a = [’Mary [’Mary’, ’, ’had’, ’had’, ’a’, ’littl ’little’, e’, ’lamb’ ’lamb’] ] >>> for i in range( range(len len(a) (a)): ): ... print i, a[i] ... 0 Mary Mary 1 had had 2 a 3 little little 4 lamb lamb
break
continue
else
A break utasítás – ahogy a C-ben is – a break-et tartalmazó legmélyebb for vagy while ciklusból ugrik ki. A continue utasítás – ez is a C-b ˝ C-b ˝ ol származik – a ciklus további utasításait átugorva a következ ˝ következ ˝ o elemre ugrik (és elkezdi a következ ˝ következ ˝ o ciklus-hurkot). A ciklus-szervez ˝ ciklus-szervez ˝ o utasításoknak lehet egy else águk. Ez akkor hajtódik végre, ha a ciklus végighaladt a listán (for esetén), illetve ha a feltétel hamissá vált ( when esetén), de nem hajtódik végre, ha a ciklust a break utasítással szakítottuk meg. Ezt a következ ˝ következ ˝ o példával szemléltetjük, amely a prímszámokat keresi meg: >>> >>> for for n in rang range( e(2, 2, 10): ... for x in range(2, n): ... if n % x == 0: ... print n, ’felbontható:’, x, ’*’, n/x ... break ... else: ... print n, ’prímszám.’ ... 2 prímszám. prímszám. 3 prímszám. prímszám. 4 felb felbon onth that ató: ó: 2 * 2 5 prímszám. prímszám. 6 felb felbon onth that ató: ó: 2 * 3 7 prímszám. prímszám. 8 felb felbon onth that ató: ó: 2 * 4 9 felb felbon onth that ató: ó: 3 * 3
pass A pass utasítás utasítás nem csinál csinál semmit. Akkor használhat használható, ó, ha szintaktika szintaktikailag ilag szükség szükség van egy utasításra, utasításra, de a programban nem kell semmit sem csinálni. Például: >>> >>> whil while e 1: ˝ ˝ megszakítás ... pass # Elfoglalt - billentyuzetr˝ u ˝zetrol ol érkez érkez˝ o megszakításra ra vár. ...
Létrehozhatunk egy függvényt, amely egy megadott értékig írja ki a Fibonacci-sorozatot: >>> >>> ... ... ... ... ... ... ... >>> ... 1 1
def def fib( fib(n) n): : # Kiír Kiír egy egy Fib Fibon onac acci ci-s -sor oroz ozat atot ot n-i n-ig g "Kií "Kiír r egy egy Fibo Fibona nacc ccii-so soro roza zato tot t n-ig n-ig." ." a, b = 0, 1 while b < n: print b, a, b = b, a+b # Hívjuk Hívjuk meg a függvé függvényt nyt amit létreh létrehozt oztunk unk: : fib(2000) fib(2000) 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597
A def kulcsszó a függvény definícióját jelzi. Ezt egy függvénynévnek, majd zárójelben a paraméterek paraméterek listájának
kell követnie. Az utasítások – amelyek a definíció testét alkotják – a következ ˝ következ ˝ o sorban kezd ˝ kezd ˝ odnek, és behúzással kell kezdeni azokat. A függvény testének els ˝ els ˝ o utasítása lehet egy szöveges ’emberi mondat’ is; ez a karakterlánc a függvény dokumentációs karakterlánca, angolul röviden docstring. Vannak eszközök, amelyek a docstring-et használják ahhoz, hogy az online vagy a nyomtatott dokumentációt elkészítsék, vagy hogy a felhasználót segítsék a kódban történ ˝ történ ˝ o interaktív böngészéshez. Bevált gyakorlat, hogy a docstringet beleírjuk a kódba, kérünk téged hogy te is szokjál rá. A függvény végrehajtása egy új szimbólum-táblázatot hoz létre a függvény helyi változói számára. Pontosabban: minden értékadás a függvényben a helyi szimbólum-táblázatban tárolódik; a változókra való hivatkozások esetén el ˝ el ˝ oször a Python helyi szimbólum-táblázatban, aztán a globális szimbólum-táblázatban, végül a bels ˝ o (built-in) nevek közt keresgél. Így globális változóknak nem adhatunk közvetlenül értéket egy függvényben (hacsak nem nevezzük meg egy global utasításban), jóllehet hivatkozhatunk rá. Ford.: Ez a kód a fenti leírással ellentétbe ellentétbenn a ’gyumolcsok’ függvény függvényen en kívüli kívüli változót módosítani módosítani tudja. tudja. A ’penztarcaban’ valtozot olvasni tudjuk, de ha ertekadassal probalkozunk, az olvasast is hibanak jelzi jelzi az ertelmezo: gyumolcsok gyumolcsok = ["alma"] ["alma"] penzta penztarca rcaban ban = 22
def kosar_kiira kosar_kiirasa(): sa(): print gyumolcsok gyumolcsok gyumolcsok.append(’barack’) print gyumolcsok gyumolcsok # erde erdeke kes: s: ha csak csak ez a prin print t sor sor van, van, es a trytry-ba ban n nem nem adun adunk k # erteke erteket, t, akkor akkor mukodi mukodik. k. # ha adun adunk k erte erteke ket, t, hiba hibasn snak ak jelo jeloli li ezt ezt a sort sort is. is. print penztarcaba penztarcaban, n, "Ft" try: # penz penzta tarc rcab aban an = 33 print print penzta penztarca rcaban ban, , "Ft - try blokkb blokkbol, ol, erteka ertekadas das kiprob kiprobala alasna snal" l" pass except: print print "a penzta penztarca rcaban ban valtoz valtozot ot nem tudtam tudtam modosi modositan tani" i" kosar_kiirasa() print print "kosar "kosar kiiras kiirasa a utan: utan: ", gyumol gyumolcso csok k
A függvényhívás függvényhívás aktuális aktuális paraméterei paraméterei bekerülnek bekerülnek a hívott függvény függvény helyi szimbólum-t szimbólum-tábláz áblázatába atába amikor amikor azt meghívjuk, így az argumentumok mindig értékeket adnak át. (ahol az érték mindig az objektumra történ ˝ történ ˝ o hivatkozás, 1 nem az objektum értéke). Ha a függvény egy másik függvényt hív, akkor az új híváshoz egy új helyi szimbólumtábla jön létre. A függvénydefiníció a függvény nevét beírja az aktuális szimbólumtáblába. A függvénynév értékének van egy típusa, amelyet a fordító a felhasználó által definiált függvényként ismer fel. Ezt az értéket átadhatjuk egy másik változónak, amely ekkor szintén függvényként használható. Ez egy általános átnevezési eljárás: >>> fib d0> >>> f = fib >>> f(100) f(100) 1 1 2 3 5 8 13 21 34 55 89
Kifogásolhatja bárki, hogy a 1
fib
nem függvény, hanem eljárás. A Pythonban – ahogy a C-ben is – az eljárások
o hivatkozással történ˝ o meghívás jobb elnevezés lenne erre, mert ha egy megváltoztatható objektumot Pontosabban a objektumra történ˝ adunk át, a hívó minden változást látni fog, amit a hívott függvény csinál vele (pl. ha elemet szúr a listába).
olyan függvények, amelyek nem adnak vissza értéket. értéket. Gyakorlatilag egy nagyon különös értéket adnak vissza, ez az érték a None – ez egy bels ˝ bels ˝ o (built-in) név. A None érték kiírását általában elnyomja az értelmez ˝ értelmez ˝ o, kivéve ha csak ezt az értéket kell kiírnia. Err ˝ Err ˝ ol meggy ˝ meggy ˝ oz ˝ oz ˝ odhetünk, ha akarunk: >>> print print fib(0) fib(0) None
Könnyen írhatunk olyan függvényt, amely visszatér a Fibonacci-sorozat értékeit tartalmazó listával listával ahelyett, hogy kiíratná azokat. >>> ... ... ... ... ... ... ... ... ... >>> >>> >>> [1, [1,
def fib2(n fib2(n): ): # Vissza Visszaadj adja a a Fibona Fibonacci cci-so -soroz rozato atot t n-ig n-ig "A Fibo Fibona nacc ccii-so soro roza zat t n-né n-nél l kise kisebb bb elem elemei eit t adja adja viss vissza za egy egy list listáb ában an." ." eredmeny = [] a, b = 0, 1 while b < n: eredmeny.append(b) # lásd lejjebb a, b = b, a+b return eredmeny f10 f100 0 = fib2 fib2(1 (100 00) ) # hív hívju juk k me meg f100 # írjuk ki az eredményt 1, 2, 3, 5, 8, 13, 13, 21, 21, 34, 34, 55, 55, 89] 89]
Ez a példa néhány új vonását mutatja a Pythonnak: • A return utasítás egy értékkel tér vissza a függvény futásának bejezésekor. Ha a return utasítás paraméter nélkül None értéket ad vissza. Ha egy függvény lefutott, de te nem adtál meg return utasítást, a függvény None értékkel tér vissza. • A eredmeny.append(b) utasítás meghívja az eredmeny-lista objektum egy metódusát. A metódus egy olyan függvény, amely egy objektumhoz „tartozik”, obj.metódusnév alakban írjuk, ahol az obj valamelyi valamelyikk objektum objektum (lehet egy kifejezés), kifejezés), és a metódusnév egy olyan metódus neve, amelyet az ob ˝ ˝ jektumtípus jektumtípus definiál. definiál. Különböz Különböz ˝ o típusoknak típusoknak különböz ˝ különböz ˝ o metódusai metódusai vannak. vannak. Különböz Különböz ˝ o típusoknak lehet azonos nev˝ u metódusa metódusa mindenféle kétértelm kétértelm uség ˝ veszélye veszélye nélkül. nélkül. (Lehet ˝ (Lehet ˝ oség van rá, hogy definiáljunk saját objektumokat és metódusokat az osztályok használatával, ahogy kés ˝ kés ˝ obb azt látni fogjuk az oktatóban.) A példában szerepl ˝ szerepl ˝ o append() metódus a lista-objektumokra lett definiálva; ez hozzáad egy új elemet a lista végéhez. Ebben az esetben esetben azonos az ‘ ered eredme meny ny = ered eredme meny ny + [b] [b]’ alakkal, de ez sokkal hatékonyabb.
Lehet ˝ Lehet ˝ oségünk van függvényeket változó argumentummal definiálni. Ennek három formája van, amelyek variálhatók.
A leghasznosabb alak az, ha egy vagy több argumentumnak is meghatározott alapértéket adunk meg (azaz egy olyan értéket, amit ez az argumentum felvesz, ha nem adunk értéket neki. Ez így egy olyan függvényt hoz létre, amelyet kevesebb argumentummal argumentummal is meghívhatunk, mint amennyivel definiáltuk:
def ask_ok(szov ask_ok(szoveg, eg, probalkozas probalkozasok=4, ok=4, hibauzenet= hibauzenet=’igen ’igen vagy nem!’): nem!’): while while 1: ok = raw_input(s raw_input(szoveg) zoveg) if ok in (’i’, (’i’, ’igen’ ’igen’,’I ,’I’,’ ’,’IGE IGEN’) N’): : return return 1 if ok in (’n’ (’n’, , ’nem ’nem’, ’, ’N’, ’N’,’N ’NEM EM’) ’): : retu return rn 0 probal probalkoz kozaso asok k = probal probalkoz kozaso asok k - 1 if probal probalkoz kozaso asok k < 0: raise raise IOErro IOError, r, ’értel ’értelmet metlen len haszná használat lat’ ’ print hibauzenet hibauzenet
Ez a függvény ehhez hasonlóan hívható meg:
ask_ok(’ ask_ok(’Való Valóban ban ki akarsz akarsz lépni?’) lépni?’) ask_ok(’ ask_ok(’Felü Felülírh lírhatom atom a fájlt?’, fájlt?’, 2).
vagy így:
Az el ˝ el ˝ oz ˝ oz ˝ o progr program am egybe egybenn példa példa az in kulcsszó kulcsszó használatára használatára is. Így tesztelhet tesztelhetjük, jük, hogy a sorozat sorozat vajon vajon tartalmaz-e tartalmaz-e egy adott értéket, vagy nem. Az alapértékeket a fordító akkor határozza meg, amikor a függvény definíciójával el ˝ oször találkozik, emiatt ezek kiszámítása csak egyszer történik meg! (defining) Így például a következ ˝ következ ˝ o program eredménye 5lesz: i = 5 def f(arg=i): f(arg=i): print print arg i = 6 f()
határozza meg! meg! Emiatt különbség különbség van, van, ha az Fontos figyelmeztetés: Az alapértékeket a fordító csak egyszer határozza alapérték megváltoztatható objektum, mint amilyen a lista, szótár vagy a legtöbb példányosodott osztály. Például az alábbi függvény összegy˝ ujti az egymás utáni hívások során neki adott paramétereket: def f(a, f(a, L=[]): L=[]): L.append(a) return return L print print f(1) f(1) print print f(2) f(2) print print f(3) f(3)
A program kimenete: [1] [1, [1, 2] [1, [1, 2, 3]
Ha nem akarod az alapértékeket láthatóvá tenni az egymást követ ˝ követ ˝ o hívások számára, akkor ehhez hasonlóan írd a függvényt: def f(a, f(a, L=None L=None): ): if L is None: None: L = [] L.append(a) return return L
A függvényeket akár ‘ kulcsszó dául a következ ˝ következ ˝ o függvény:
= érték ’ formában megadott argumentumok használatával is meghívhatjuk. Pél-
def parrot(volt parrot(voltage, age, state=’a state=’a stiff’, stiff’, action=’voo action=’voom’, m’, type=’Norwe type=’Norwegian gian Blue’): Blue’): print print "-- This This parrot parrot wouldn wouldn’t" ’t", , action action, , print print "if you put", put", voltag voltage, e, "Volts "Volts throug through h it." it." print print "-- Lovely Lovely plumag plumage, e, the", the", type type print print "-- It’s", It’s", state, "!"
meghívható az összes alábbi módon: parrot(1000) parrot parrot(ac (actio tion n = ’VOOOO ’VOOOOOM’ OM’, , voltag voltage e = 100000 1000000) 0) parrot parrot(’a (’a thousa thousand’ nd’, , state state = ’pushi ’pushing ng up the daisie daisies’) s’) parrot parrot(’a (’a millio million’, n’, ’beref ’bereft t of life’, life’, ’jump’ ’jump’) )
de a következ ˝ következ ˝ o hívások mind érvénytelenek: parrot() parrot(volt parrot(voltage=5. age=5.0, 0, ’dead’) parr parrot ot(1 (110 10, , volt voltag age= e=22 220) 0) parrot parrot(ac (actor tor=’J =’John ohn Cleese Cleese’) ’)
# # # #
˝ argumentum a kötelezo argumentum hiányzik nem-kulcssz nem-kulcsszavas avas argumentum argumentum kulcsszavas kulcsszavas után kétsz kétszer eres es ért érték ékad adás ás egy egy arg argum umen entu tumn mnak ak ismere ismeretle tlen n kulcss kulcsszó zó
Általában egy argumentumlistában néhány helyhez kötött argumentum után néhány kulcsszavas argumentumnak kell szerepelnie, szerepelnie, ahol a kulcsszav kulcsszavakat akat a formális formális paraméterek paraméterek közül kell választani. választani. Nem lényeges, lényeges, hogy egy formális paraméternek van-e alapértéke vagy nincs. Egy hívás során nem kaphat egy argumentum egynél több alkalommal értéket – helyhez kötött argumentumhoz tartozó formális paraméter nem használható kulcsszóként ugyanannál a hívásnál. Itt van egy példa, amely nem hajtódik végre emiatt a megkötés miatt: >>> def function(a): function(a): ... pass ... >>> function(0, function(0, a=0) Traceb Traceback ack (most (most recent recent call call last): last): File File " n>", ", line line 1, in ? TypeEr TypeError ror: : functi function( on() ) got multip multiple le values values for keywor keyword d argume argument nt ’a’
Ha van egy **név alakú formális paraméter utolsóként, akkor egy ilyen nev˝ u szótárban tárolódik az összes kulcsszavas argumentum, amelynek a kulcsszava nem illeszkedik egyetlen formális paraméterre sem. Ez együtt használható egy *név alakú formális paraméterrel (ez a következ ˝ következ ˝ o alszakaszban lesz leírva) amely belerakja az összes olyan nem-kulcssz nem-kulcsszava avass argumentumo argumentumot,t, amely nincs nincs benne a formális paraméterlist paraméterlistában, ában, egy tupléba. tupléba. (A *név-nek mindíg a **név el ˝ el ˝ ott kell lennie.) Például, ha egy ilyen függvényt definiálunk: def sajtuzlet(s sajtuzlet(sajtfa ajtfajta, jta, *argumentum *argumentumok, ok, **kulcsszav **kulcsszavak): ak): print print "-- Van Önökné Önöknél l néhány néhány", ", sajtfa sajtfajta jta, , ’?’ print "-- Sajnálom, Sajnálom, teljesen teljesen kifogytunk kifogytunk a", sajtfajta+’ sajtfajta+’ból’ ból’ for arg in argume argumentu ntumok mok: : print print arg print ’-’*40 for kw in kulcss kulcsszav zavak. ak.key keys() s(): : print print kw, ’:’, ’:’, kulcss kulcsszav zavak[ ak[kw] kw]
Ez meghívható így is:
sajtuzlet(’ sajtuzlet(’Pálpus Pálpusztai’, ztai’, "Ez nagyon nagyon büdös, uram.", uram.", "Ez nagyon nagyon, , NAGYON NAGYON büdös, büdös, uram." uram.", , vevo=’Sajti vevo=’Sajti János’, János’, boltos=’Pálinkás Mihály’, helyszin=’Sajtbolt’)
és természetesen ezt fogja kiírni: -- Van Önöknél Önöknél néhány néhány Pálpuszta Pálpusztai i ? -- Sajnálom, Sajnálom, teljesen kifogytunk kifogytunk a Pálpusztaib Pálpusztaiból ól Ez nagyon nagyon büdös, büdös, uram. uram. Ez nagyon nagyon, , NAGYON NAGYON büdös, büdös, uram. uram. ---------------------------------------vevo vevo : Sajt Sajti i Jáno János s boltos boltos : Pálink Pálinkás ás Mihály Mihály helysz helyszin in : Sajtbo Sajtbolt lt
Megjegyzend ˝ Megjegyzend ˝ o, hogy a kulcsszavak nev˝ u szótár tartalmának kinyomtatása el ˝ el ˝ ott hívtuk meg a kulcsszóargumentum neveinek listájához tartozó sort() eljárást; ha nem ezt tesszük, akkor az argumentumok listázási sorrendje határozatlan.
Végül itt a legritkábban használt lehet ˝ lehet ˝ oség, amikor egy függvénynek tetsz ˝ tetsz ˝ oleges számú argumentuma lehet. Ezeket az argumentumokat egy tupléba helyezi el a Python. A változó számosságú argumentum el ˝ el ˝ ott akárhány (akár egy sem) egyszer˝ u argumentum is el ˝ el ˝ ofordulhat. def fprintf(fil fprintf(file, e, format, format, *args): *args): file.write( file.write(forma format t % args)
Enne Ennekk ford fordít ítot ottj tjaa tört történ énik ik,, ha list listáába vagy agy tupl tuplééba bec becsoma somago golt lt argu argume ment ntum umok okat at ki kelellene lene csom csomag agol olni ni olya olyann függ függvé vénny megh meghív ívás ásáához hoz, ame amely elkü elkülö löní níte tett tt,, hely helyhe hezz-kö kötö tött tt vált váltoozókat vár. Például a beépített range() függ függvé vény ny egym egymás ástó tóll elkü elkülö löní nítv tvee várj várjaa a start és stop érté értékkeket. ket. Ha ezek zek nem nem egymá gymást stól ól elvá elvála lasz sztv tvaa állna llnakk rend rendel elkkezés ezésre re,, akkor kkor a függvényhívásban a * muveletjele uvele ˝ tjelett tegyük tegyük az összetett-t összetett-típusú ípusú változó neve elé, ez kicsomagolj kicsomagoljaa a listából listából vagy tupléb ˝ tupléb ˝ ol az adatokat. >>> >>> [3, [3, >>> >>> >>> >>> [3, [3,
r ran ange ge(3 (3, , 6) 4, 5] args args = [3, [3, 6] rang range( e(*a *arg rgs) s) 4, 5]
# norm normál ális is függ függvé vény nyhí hívá vás, s, külö különá náll lló ó para paramé méte tere rekk kkel el
˝ függvényhív # list listáb ából ól kic kicso soma mago golt lt par param amét éter erek ekke kel l tör törté tén no függvényhívás ás
Többek kívánságára néhány olyan vonás került a Pythonba, amelyek a funkcionális programozási nyelvekben és a Lisp-ben is megtalál megtalálhatóa hatóak. k. A lambda kulcsszóva kulcsszóvall rövid névtelen névtelen függvényeket függvényeket lehet létrehozni. létrehozni. Íme egy ambda a a, b: b: a+b’. A lambda formákat függvény, amely a két argumentumának összegével tér vissza: ‘ lambd
mindenhol használhatjuk, ahol függvény objektumok szerepelhetnek. Szintaktikai Szintaktikailag lag egyetlen kifejezés kifejezés szerepelhe szerepelhett bennük. Általánossá Általánosságban gban tekintve ’hab’ a normális normális függvények függvények ˝ meghívó környezet minden változóját. ’tortáján’. Beágyazott függvénydefinícióként látja az ot >>> ... ... >>> >>> 42 >>> 43
def make_increm make_incrementor( entor(n): n): return lambda x: x + n ˝ f = make_i make_incr ncreme emento ntor(4 r(42) 2) # make_i make_incr ncreme emento ntor r magyar magyarul ul kb.: kb.: csinál csinálj j növel növelo-t o-t f(0) f(0) f(1) f(1)
A dokumentáció dokumentációss szövegek szövegek tartalmáv tartalmával al és formájáva formájávall kapcsolatba kapcsolatbann egy kialakult kialakult és és bevált bevált szokásról szokásról beszélhetü beszélhetünk. nk. Az els ˝ els ˝ o sor mindig az objektum objektum céljának céljának rövid, tömör összegzése összegzése.. Rövidsége Rövidsége miatt nem kell tartalmaznia tartalmaznia az objektum nevét vagy típusát, hiszen ezek az adatok más úton is kinyerhet ˝ kinyerhet ˝ ok (kivéve, ha az objektum neve a függvény függvény m m˝ uködését ˝ leíró ige). A szöveg nagybet˝ uvel kezd ˝ kezd ˝ odik és ponttal végz ˝ végz ˝ odik. Ha a dokumentáci dokumentációs ós szöveg szöveg ( docstring) több sorból áll, a második sor üres lesz – ezzel vizuálisan elkülönítjük a fejrészt/összegzést a leírás további részét ˝ részét ˝ ol. Az üres sort egy vagy több rész követheti, ahol leírjuk az objektum hívásának módját, a mellékhatásokat stb. Maga a Python értelmez ˝ értelmez ˝ o nem szedi le a helyközöket a többsoros beégetett szöveb ˝ szöveb ˝ ol – ha ezek kisz˝ urése szükséges, akkor ehhez külön szövegfeldolgoz szövegfeldolgozóó progit kellene használni. használni. Ezt a problémát problémát a következ következ ˝ ˝ o konvenció használatával kezeljük. Az els ˝ els ˝ o sor után a legels ˝ legels ˝ o nem üres sorban megjelen megjelen ˝ ˝ o szöveg behúzási távolsága határozza meg az egész dokumentáci dokumentációs ós szöveg behúzását. behúzását. (A legels ˝ legels ˝ o sort azért nem hassználjuk erre a célra, mert a szöveg els ˝ els ˝ o bet˝ uje általában szorosan követi a karakterláncot nyitó macskakörmöt, ennek eltolása nem lenne nyilvánvaló nyilvánvaló dolog.) A docstring – fejrészt követ ˝ követ ˝ o minden els ˝ els ˝ o sorának elejér ˝ elejér ˝ ol levágunk pont ennyi helyközt. Ha ennél kevesebb helyközt tartalmaz valamely valamely sor – bár ilyennek nem kéne lennie – csak a helyközök törl ˝ odnek, karakter nem vész el. A behúzások egyenl ˝ egyenl ˝ oségét ajánlott mindig a tabulátorokat kibontva ellen ˝ ellen ˝ orizni (általában 1 tabulátort 8 helyközzel helyettesítünk). Itt van egy példa a többsoros docstring-re: >>> def fuggvenyem( fuggvenyem(): ): ... ... """N """Nem em csin csinál ál semm semmit it, , de de ez ez dok dokum umen entá tálv lva a van van. . ... ... ... Való Valóba ban n nem nem csiná sinál l semm semmit it. . ... """ ... pass ... >>> print fuggvenyem. fuggvenyem.__doc_ __doc__ _ Nem csinál csinál semmit semmit, , de ez dokume dokumentá ntálva lva van. van. Valóba Valóban n nem csinál csinál semmit semmit. .
5. fejezet
Adatstruktúrák Ez a fejezet az eddig tanultakból pár dolgot részletesebben is leír, és pár új dolgot is megmutat.
A lista adattípusnak a már megismerteken kívül több eljárása (method) is van. Az összes eljárás ismertetése: append( x)
a[len( n(a) a):] :] Egy elemet hozzáad a lista végéhez; megegyezik az a[le
= [x] utasítással.
extend( L)
A lista végéhez hozzáf hozzáf uzi ˝ az L listát (mindegyik elemét egyenként); ugyanaz, mint az L.
a[le a[len( n(a) a):] :]
=
insert(i, x )
Beszúr Beszúr egy egy elemet elemet az adott adott helyre. helyre. Az els ˝ els ˝ o argumentum az elem indexe, amely elé beszúrjuk, így a.insert a.insert(0, (0, x) a lista elejére szúr be, és az a.insert(len(a), a.insert(len(a), x) ugyanazt jelenti mint az a.append(x). remove( x)
Eltávolítja a legels ˝ legels ˝ o olyan elemet a listából, amelynek értéke x. Hiba, ha nincs ilyen. pop([i ])
Eltávolítj Eltávolítjaa az adott helyen lév ˝ lév ˝ o elemet a listából, és visszaadja visszaadja az értékét. Ha nem adtunk meg indexet, indexet, akkor akkor az a.pop() az utolsó elemmel tér vissza. (Ekkor is eltávolítja az elemet.) (A függvény-argumentum megadásánál használt szögletes zárójel azt jelenti, hogy a paraméter megadása tetsz ˝ tetsz ˝ oleges, és nem azt, hogy a [] jeleket jeleket be kell gépelni gépelni az adott helyen. Ezzel a jelöléssel jelöléssel gyakran találkozha találkozhatsz tsz a Python Standard Library-ban (Szabványos Python könyvtárban)) index( x)
Visszatér Visszatér az els ˝ els ˝ o olyan elem indexével, aminek az értéke x. Hiba, ha nincs ilyen. count( x)
Visszaadja x el ˝ el ˝ ofordulásának a számát a listában. sort()
Rendezi a lista elemeit. A rendezett lista az eredeti listába kerül. reverse()
Megfordítja az elemek sorrendjét a listában - szintén az eredeti lista módosul. Egy példa, amely tartalmazza a legtöbb eljárást:
>>> >>> a = [66. [66.25 25, , 333, 333, 333, 333, 1, 1234 1234.5 .5] ] >>> print a.count(333 a.count(333), ), a.count(66. a.count(66.25), 25), a.count(’x’ a.count(’x’) ) 2 1 0 >>> a.inse a.insert( rt(2, 2, -1) >>> a.append(33 a.append(333) 3) >>> >>> a [66. [66.25 25, , 333, 333, -1, -1, 333, 333, 1, 1234 1234.5 .5, , 333] 333] >>> a.index(333 a.index(333) ) 1 >>> a.remove(33 a.remove(333) 3) >>> >>> a [66.25 [66.25, , -1, 333, 1, 1234.5 1234.5, , 333] 333] >>> a.reverse() a.reverse() >>> >>> a [333, [333, 1234.5 1234.5, , 1, 333, 333, -1, 66.25] >>> a.sort() a.sort() >>> >>> a [-1, [-1, 1, 66.25, 66.25, 333, 333, 333, 1234.5 1234.5] ]
A lista eljárásai megkönnyítik a lista veremként (stack) történ ˝ történ ˝ o használatát ahol az utolsó lerakott elemet vesszük ki el ˝ el ˝ oször („utoljára be, el ˝ el ˝ oször ki”, LIFO). Ahhoz, hogy a verem tetejére egy elemet adjunk, használjuk az append() utasítást. A lista legels ˝ legels ˝ o/legfels ˝ o/legfels ˝ o elemének kivételéhez használjuk a >>> >>> >>> >>> >>> [3, [3, >>> 7 >>> [3, [3, >>> 6 >>> 5 >>> [3, [3,
pop() utasítást mindenféle index nélkül. Például:
stac stack k = [3, [3, 4, 5] stack.appen stack.append(6) d(6) stack.appen stack.append(7) d(7) stack stack 4, 5, 6, 7] stack.pop() stack.pop() stack stack 4, 5, 6] stack.pop() stack.pop() stack.pop() stack.pop() stack stack 4]
A listát használhatjuk úgy is mint egy sort, ahol az els ˝ els ˝ o hozzáadott elemet vesszük ki el ˝ el ˝ oször („first-in, first-out”, FIFO). Ahhoz, hogy elemet hozzáadjunk a sor végéhez, használjuk az append() utasítást. A sor els ˝ els ˝ o elemét elemét visszakaphatjuk a pop() utasítással, ha az argumentuma 0. Például:
>>> sor = ["Maca ["Maca", ", "János "János", ", "Mihál "Mihály"] y"] >>> sor.append("Teri") # Teri megérkezett >>> sor.append("Gergely") # Gergely megérkezett >>> sor.pop(0) sor.pop(0) ’Maca’ >>> sor.pop(0) sor.pop(0) ’János’ >>> sor [’Mihály’, [’Mihály’, ’Teri’, ’Teri’, ’Gergely’] ’Gergely’]
Három olyan beépített függvényünk van, amelyek nagyon hasznosak hasznosak a listáknál – ezek a a reduce().
filter(), map(), és
A ‘filter( függvény, sorozat )’ egy– egy – lehet lehet ˝ oség szerint szerint azonos azonos típusú – sorozatta sorozattall tér vissza, vissza, mely a sorozatna sorozatnakk azokat az elemeit tartalmazza, amelyekre függvény(elem) igaz. Például a következ ˝ következ ˝ o mó módo donn sz˝ urhetjük urhetjük ki a 3-mal 3-mal és 2-vel nem osztható számokat: >>> def f(x): return x % 2 != 0 and x % 3 != 0 ... >>> filter filter(f, (f, range( range(2, 2, 25)) 25)) [5, [5, 7, 11, 13, 17, 17, 19, 19, 23] 23]
A ‘map( függvény, sorozat )’ kiszámolja a függvény(elem) értéket a sorozat minden elemére és az eredmények listájával tér vissza. Például így számolhatjuk ki az els ˝ els ˝ o néhány köbszámot: >>> def cube(x cube(x): ): return return x*x*x x*x*x ... >>> map(cu map(cube, be, range( range(1, 1, 11)) 11)) [1, [1, 8, 27, 64, 64, 125, 125, 216, 216, 343, 343, 512, 512, 729, 729, 1000 1000] ]
Egynél több sorozatot is feldolgozhatunk; a függvénynek ekkor annyi argumentumának kell lennie, ahány sorozat van. Ekkor a függvényt az egymáshoz tartozó értékpárokkal hívja meg a Python (vagy None-t ad, ha valamelyik sorozat rövidebb a másiknál). Ha a függvény helyére None-t írunk, akkor a függvény a saját argumentumait adja vissza. >>> >>> >>> >>> ... >>> [0, [0,
seq seq = rang range( e(8) 8) def def add( add(x, x, y): y): retu return rn x+y x+y map(ad map(add, d, seq, seq, seq) seq) 2, 4, 6, 8, 10, 12, 12, 14] 14]
A két esetet összevetve láthatjuk, hogy a ‘ map(None, lista1, lista2)’ elegáns módja annak, hogy két listát párok listájává alakítsunk. Például: >>> >>> sor sor = rang range( e(8) 8) >>> def negyze negyzet(x t(x): ): return return x*x ... >>> map(No map(None, ne, seq, seq, map(ne map(negyz gyzet, et, seq)) seq)) [(0, [(0, 0), 0), (1, (1, 1), 1), (2, (2, 4), 4), (3, (3, 9), 9), (4, (4, 16), 16), (5, (5, 25), 25), (6, (6, 36), 36), (7, (7, 49)] 49)]
A ‘reduce( függv, sorozat )’ egyetlen értékkel tér vissza, melyet úgy kapunk, hogy a bináris, bináris, kétváltozós függv
függvényt meghívjuk a sorozat els ˝ els ˝ o két elemével, majd az eredménnyel és a következ ˝ következ ˝ o elemmel, és így tovább. Például az 1-t ˝ 1-t ˝ ol 10-ig terjed ˝ terjed ˝ o egész számokat így adhatjuk össze: >>> def add(x,y): add(x,y): return return x+y ... >>> reduce(add, reduce(add, range(1, 11)) 55
Ha csak egy érték van a sorozatban, akkor azt az értéket kapjuk; ha a sorozat üres, kivételdobás történik. A harmadik argumentum használatával megadhatjuk a kezd ˝ kezd ˝ oértéket. oértéket. Ekkor úgy m uködik, ˝ mintha a sorozat legelején ez az érték állna. Ekkor tehát egy üres sorozat a kezdeti értéket adja vissza. Például: >>> def sum(se sum(seq): q): ... def add(x,y): return x+y ... ... retu return rn redu reduc ce(ad e(add, d, seq, seq, 0) ... >>> sum(range(1 sum(range(1, , 11)) 55 >>> sum([]) sum([]) 0
Ne használd a példában definiált sum() függvényt: mivel számok összegzésére gyakran van igény, a beépített sum(sequence) függvényt használjuk erre, amely pontosan ugyanúgy m˝ uködik, mint a fenti példában definiált függvény. New in version 2.3.
Ha megértjük, hogyan m˝ uködnek a listák, akkor rövid és átlátható programokat készíthetünk listafeldolgozásra a követ ˝ o újrarendezés nélkül is. Az eredménymap(), filter() vagy lambda függvények használata és az ezt követ ˝ ként kapott listadefiníció gyakran világosabb, mintha a beépített eljárásokkal kaptuk volna. Minden magas fokú listakezelés így épül fel: a kifejezést egy for ág követi, ezt pedig nulla vagy több for vagy if ág. Az eredmény egy olyan lista, amely a for és if ágak alapján a kifejezés kiértékelésével keletkezik. Ha a kifejezés tuple típust eredményez, akkor zárójelbe kell tenni a kifejezést.
>>> >>> fres freshf hfru ruit it = [’ bana banana na’, ’, ’ loga loganb nber erry ry ’, ’pas ’passi sion on frui fruit t ’] >>> [weapo [weapon.s n.stri trip() p() for weapon weapon in freshf freshfrui ruit] t] [’banana’, [’banana’, ’loganberry ’loganberry’, ’, ’passion ’passion fruit’] fruit’] >>> >>> vec = [2, [2, 4, 6] >>> >>> [3*x [3*x for x in vec] vec] [6, [6, 12, 12, 18] 18] >>> [3*x for x in vec if x > 3] [12, [12, 18] >>> [3*x for x in vec if x < 2] [] >>> >>> [{x: [{x: x**2 x**2} } for for x in vec] vec] [{2: [{2: 4}, 4}, {4: {4: 16}, 16}, {6: {6: 36}] 36}] >>> >>> [[x, [[x,x* x**2 *2] ] for for x in vec] vec] [[2, [[2, 4], 4], [4, [4, 16], 16], [6, [6, 36]] 36]] >>> >>> [x, [x, x**2 x**2 for for x in vec] vec] # hiba hiba - a tupl tuple e típu típus s záró záróje jele let t kívá kíván n File File "" n>", , line line 1 [x, [x, x**2 x**2 for x in vec] vec] ^ SyntaxError SyntaxError: : invalid invalid syntax >>> >>> [(x, [(x, x**2 x**2) ) for for x in vec] vec] [(2, [(2, 4), 4), (4, (4, 16), 16), (6, (6, 36)] 36)] >>> >>> vec1 ec1 = [2, [2, 4, 6] >>> >>> vec2 vec2 = [4, [4, 3, -9] >>> >>> [x*y [x*y for x in vec1 vec1 for for y in vec2] vec2] [8, [8, 6, -18, -18, 16, 16, 12, 12, -36, -36, 24, 24, 18, 18, -54] -54] >>> >>> [x+y [x+y for x in vec1 vec1 for for y in vec2] vec2] [6, [6, 5, -7, -7, 8, 7, -5, -5, 10, 10, 9, -3]
A magasfokú listakezelés a map() eljárásnál sokkal rugalmasabb, és egynél több argumentummal rendelkez ˝ rendelkez ˝ o függvényekre, valamint beágyazott (nested) függvényekre is alkalmazható: >>> [str(r [str(roun ound(3 d(355/ 55/113 113.0, .0, i)) for i in range( range(1,6 1,6)] )] [’3.1’, [’3.1’, ’3.14’, ’3.14’, ’3.142’, ’3.142’, ’3.1416’, ’3.1416’, ’3.14159’] ’3.14159’]
del Egy listaelem eltávolításának egyik módja, hogy az elem értéke helyett az indexét adjuk meg: ez a del utasítás. Ez arra is használható, hogy szeleteket töröljünk a listából (amit már megtettünk ezel ˝ ott úgy, hogy a szeletnek az üres lista értékét adtuk). Például: >>> >>> >>> >>> >>> >>> [1, >>> >>> >>> [1,
a = [-1, [-1, 1, 66.2 66.25, 5, 333, 333, 333, 1234 1234.5 .5] ] del del a[0] a[0] a 66.25, 66.25, 333, 333, 333, 1234.5 1234.5] ] del a[2:4] a[2:4] a 66.25, 66.25, 1234.5 1234.5] ]
A del utasítást arra is használhatjuk, hogy az egész változót töröljük: >>> >>> del del a
A továbbiakban hibát generál, ha az
a
névre hivatkozunk (kivéve, ha új értéket adunk neki). Más alkalmazásával
is találkozunk kés ˝ kés ˝ obb a del utasításnak.
Láttuk Láttuk,, hogy hogy a listák listáknak nak és a karakt karakterl erlánc áncokn oknak akren renget geteg eg közös közös tulajd tulajdons onsága ágava van, n, példáu példáull az index indexelé eléss és a szelet szeletek ek ˝ használata. használata. Ez két Mindkett Mindkett ˝ o példa a sorozat ../lib/types ../lib/typesseq.ht seq.html-ada ml-adattípus ttípusra. ra. Mivel Mivel a Python egy folyamatos folyamatos fejl ˝ fejl ˝ odésben lév ˝ lév ˝ o nyelv, másfajta sorozat adattípusok is hozzáadhatóak. Egy másik beépített sorozat-adattípusa a tuple1. A tuple objektumokat tartalmaz vessz ˝ vessz ˝ okkel elválasztva, például: >>> >>> t = 1234 12345, 5, 5432 54321, 1, ’hel ’hello lo!’ !’ >>> t[0] t[0] 12345 >>> >>> t (12345, (12345, 54321, ’hello!’) ’hello!’) >>> # A tuplék tuplékat at egymás egymásba ba ágyazh ágyazhatj atjuk: uk: ... u = t, (1, 2, 3, 4, 5) >>> >>> u ((12 ((1234 345, 5, 5432 54321, 1, ’hel ’hello lo!’ !’), ), (1, (1, 2, 3, 4, 5)) 5))
Az objektumok különböz ˝ különböz ˝ o típusúak is lehetnek. A tuple nem megváltoztatható adattípus, viszont lehetnek megváltoztatható elemei. Példa:
>>> megtan megtanuln ulni i = [’mate [’matek’, k’, ’angol ’angol’] ’] # Ez egy megvál megváltoz toztat tathat ható ó lista, lista, [] jelölé jelölés! s! >>> oraren orarendem dem = (’tesi (’tesi’, ’, ’nyelv ’nyelvtan tan’, ’, megtan megtanuln ulni) i) # ket string string elem, elem, es egy lista lista a tupléb tupléban an ˝ órát >>> >>> orar oraren ende dem[ m[0] 0] = ’raj ’rajz’ z’ # az els elso órát át akar akarom om írni írni, , nem nem lehe lehet t Traceb Traceback ack (most (most recent recent call call last): last): File File " n>", ", line line 1, in ? TypeError: TypeError: object doesn’t doesn’t support support item assignment assignment >>> oraren orarendem dem[2] [2][0] [0]=’v =’vers ersek’ ek’ # viszon viszont t a tuple tuple lista lista elemén elemén belül belül -- ami megvál megváltoz toztat tathat ható ó tí
Ahogy látható, a kimeneten a tuplék mindig zárójelezve vannak, így azok egymásba ágyazva is helyesen értelmezhet ˝ mezhet ˝ ok; megadhatjuk zárójelekkel és anélkül is, néha azonban feltétlenül szükségesek a zárójelek (amikor az egy nagyobb kifejezés része). A tuple típust sokféle sokféle dologra felhasználhat felhasználhatod. od. Például: Például: (x, y) koordinátapá koordinátapárr tárolása, dolgozók dolgozók rekordjai rekordjai egy adatbázisban. . . A tuplék a karakterláncokhoz hasonlóan hasonlóan megváltoztathatatlanok: megváltoztathatatlanok: nem adhatunk értéket egyetlen egyetlen elemének (további hasonlóságok vannak a szeleteléssel és az összef˝ uzéssel kapcsolatban is). Létrehozható olyan tuple, amely megváltoztatható elemeket – például tömböket – tartalmaz. Egy különös probléma nulla vagy egy elemet tartalmazó tuple létrehozása: a nyelv szintaxisa lehet ˝ ové teszi ezt. Az üres zárojellel zárojellel hozható létre a nulla elem u; ˝ az egy elem˝ u pedig az érték után tett vessz ˝ vessz ˝ ovel (nem elég, ha az értéket zárójelbe tesszük). Csúnya, de hatékony. Például: 1
A lista és a tuple hasonló a PHP tömb típusához – a lista egy írható tömb, a tuple egy csak olvasható tömbnek felel meg els ˝ o közelítésre. közelítésre.
>>> >>> ures ures = () >>> >>> egys egysze zere res s = ’hell ’hello’ o’, , >>> len(ures) len(ures) 0 >>> len(egyszer len(egyszeres) es) 1 >>> egyszeres egyszeres (’hello’,)
˝ # <-<-- figy figyel eljü jünk nk a vess vessz zore o re a végé végén n
A
értékadás egy példa a tuple változó feltöltésére feltöltésére 2 és újbóli a 12345, t = 1234 12345, 5, 5432 54321, 1, ’hel ’hello lo!’ !’ értékadás különböz ˝ o objektumok objektumok értékei értékei egy tupléba kerülnek. kerülnek. A fordított m˝ uvelet is lehetséges, 54321 és ’hello!’ különböz ˝ például: >>> x, y, z = t
This is called, appropriately enough, sequence unpacking . Sequence unpacking requires that the list of variables on the left have the the same number of elements as as the length of the sequence. Note that multiple assignment is really just a combination of tuple packing and sequence unpacking! Ezt hívják, elég helyesen, sorozat szétbontásnak . A sorozat sorozat szétbontásá szétbontásához hoz az szükséges, szükséges, hogy hogy a bal oldalon oldalon annyi elem szerepeljen, ahány elem van a tupléban. Jegyezzük meg, hogy a többszörös értékadás csak egy változata a tuple lehetséges feltöltésének! Van egy kis asszimetria asszimetria itt: a különböz ˝ különböz ˝ o objektumokkal való feltöltés mindig tuplét eredményez, ugyanakkor a szétbontás minden sorozatra m˝ uködik.
A Python a set adattípust (sets) is alaptípusként definiálja. a set: elemek rendezetlen halmaza, amelyben minden elem csak egyszer fordulhat el ˝ el ˝ o. Alapvet ˝ Alapvet ˝ o használata: megadott elem meglétének ellen ˝ ellen ˝ orzése, elemek kett ˝ kett ˝ ozésének kisz˝ urése. A set objektumok támogatják az olyan matematikai m˝ uveleteket, mint az egyesítés (union), közös metszet (intersection), különbség (difference), és a szimmetrikus eltérés (symmetric difference). Íme egy rövid bemutató: 2
Ha a változó már tartalmazott objektumokat, az összes eleme törl ˝ törl ˝ odik, és az új – feltöltésnél megadott elemeket tartalmazza csak
>>> kosar kosar = [’alma [’alma’, ’, ’naran ’narancs’ cs’, , ’alma’ ’alma’, , ’korte ’korte’, ’, ’naran ’narancs’ cs’, , ’banan ’banan’] ’] >>> gyumolcsok = set(kosar) # set létrehozása egyedi elemekkel >>> gyumolcsok gyumolcsok set([’naran set([’narancs’, cs’, ’korte’, ’korte’, ’alma’, ’alma’, ’banan’]) ’banan’]) ˝ >>> ’narancs’ in gyumolcsok # gyors ellenorzés: orzés: benne benne van-e van-e True >>> ’kakuk ’kakukkfu kfu’ ’ in gyumol gyumolcso csok k False >>> >>> # Péld Példa: a: set set m˝ uvelet uveletek ek két szó egyedi egyedi bet˝ betuin u ˝in ... >>> a = set(’a set(’abra bracad cadabr abra’) a’) >>> b = set(’a set(’alac lacaza azam’) m’) >>> a # ’a’-nak egyedi elemei set([’ set([’a’, a’, ’r’, ’r’, ’b’, ’b’, ’c’, ’c’, ’d’]) ’d’]) ˝ >>> a - b # ’a’-ban megvan, b-bol ol hiányzik hiányzik set([’r’, set([’r’, ’d’, ’b’]) >>> a | b # vagy ’a’-ban, vagy ’b’-ben megvan set([’ set([’a’, a’, ’c’, ’r’, ’r’, ’d’, ’d’, ’b’, ’b’, ’m’, ’m’, ’z’, ’z’, ’l’]) ’l’]) >>> a & b # ’a’-ban és ’b’-ben is megvan set([’a’, set([’a’, ’c’]) >>> a ^ b # vagy ’a’-ban, vagy ’b’-ben megvan, de ˝ # egyszerre egyszerre mindkett mindkett˝ oben oben nem set([’ set([’r’, r’, ’d’, ’d’, ’b’, ’b’, ’m’, ’m’, ’z’, ’z’, ’l’]) ’l’])
Egy másik hasznos adattípus a Pythonban a szótár . A szótárakat más nyelvekben „asszociatív tömböknek” nevezik. Szemben a sorozatokkal – amelyek számokkal vannak indexelve – a tömböket kulcsokkal indexeljük, amely mindenféle megváltoztathatatlan típus lehet; karakterláncok és számok mindig lehetnek kulcsok. Tuplék is használhatók kulcsnak, ha csak számokat, karakterláncokat vagy tuplékat tartalmaznak; ha egy tuple megváltoztatható megváltoztatható objektumot tartalmaz – közvetlenül vagy közvetve, akkor nem lehet kulcs. Listát nem lehet kulcsként használni, mert annak értékei az append(), szeletel ˝ szeletel ˝ o vagy indexelt értékadásokkal (helyben) módosíthatók.
extend()
eljárásokkal, valamint a
Gondoljunk úgy a szótárra, mint kulcs: érték párok rendezetlen halmazára, azzal a megkötéssel, hogy a szótárban a kulcsoknak egyedieknek kell lenniük. Egy kapcsos zárójelpárral egy üres szótárat hozhatunk létre: {}. Ha a zárójelbe vessz ˝ vessz ˝ okkel elválasztott elválasztott kulcs:érték kulcs:érték párokból álló listát listát helyezünk, helyezünk, akkor ez belekerül belekerül a szótárba; szótárba; egy szótár tartalma is ilyen módon jelenik meg a kimeneten. A legfont legfontosabb osabbm˝ m˝ uvelet uveletek ek egy szótár szótáron: on: eltárol eltárolni ni egy értéke értékett egy kulccs kulccsal al együtt együtt,, visszak visszakapn apnii egy értéke értékett megadv megadvaa a kulcsát. kulcsát. Lehet törölni törölni is egy kulcs:ért kulcs:érték ék párt a del-lel. Ha olyan kulccsal kulccsal tárolsz tárolsz egy új értéket, értéket, amilyen kulcsot már használtál, a kulcs az új értékre fog vonatkozni, a régi érték elveszik. Hiba, ha egy nemlétez ˝ o kulcsra hivatkozol. A szótár objektum keys() eljárása a kulcsok listáját adja vissza véletlenszer˝ u sorrendben (ha rendezni akarod, ˝ haszná használd ld a sort() eljárá eljárást st a kulcsok kulcsok listáj listájára ára). ). Ha ellen ellen ˝ orizni orizni szeret szeretnéd néd,, vajon vajon egy egy kulcs kulcs benne benne van-e van-e a szótár szótárban ban,, használd a szótárak has_key() eljárását. Íme egy kis példa a szótár használatára:
>>> tel = {’Jáno {’János’: s’: 4098, ’Simon ’Simon’: ’: 4139} 4139} >>> tel[’G tel[’Géza éza’] ’] = 4127 4127 >>> tel {’Simo {’Simon’: n’: 4139, 4139, ’Géza’ ’Géza’: : 4127, 4127, ’János ’János’: ’: 4098} 4098} >>> tel[’János’ tel[’János’] ] 4098 >>> del tel[’Simon’] tel[’Simon’] >>> tel[’P tel[’Pist isti’] i’] = 4127 4127 >>> tel {’Géza {’Géza’: ’: 4127, 4127, ’Pisti ’Pisti’: ’: 4127, 4127, ’János ’János’: ’: 4098} 4098} >>> tel.keys() tel.keys() [’Géza’, [’Géza’, ’Pisti’, ’Pisti’, ’János’] ’János’] >>> tel.has_key tel.has_key(’Géz (’Géza’) a’) True
A dict() konstruktor közvetlenül tuplékban tárolt kulcs-érték párok listájából is létre tudja hozni a szótárat. Ha a párok valamilye valamilyenn mintát követnek, követnek, akkor lista-m˝ lista-m˝ uveletekke uveletekkell rövidebb rövidebb módon is megadhatju megadhatjukk a kulcs-érték kulcs-érték listát. listát. >>> dict([(’sap dict([(’sape’, e’, 4139), (’guido’, (’guido’, 4127), (’jack’, (’jack’, 4098)]) 4098)]) {’sape {’sape’: ’: 4139, 4139, ’jack’ ’jack’: : 4098, 4098, ’guido ’guido’: ’: 4127} 4127} >>> >>> dict dict([ ([(x (x, , x**2 x**2) ) for for x in (2, (2, 4, 4, 6)]) 6)]) # use use a list list com compr preh ehen ensi sion on {2: {2: 4, 4: 16, 6: 36} 36}
Later in the tutorial, we will learn about Generator Expressions which are even better suited for the task of supplying key-values pairs to the dict() constructor. Az oktató egy kés ˝ kés ˝ obbi részben tanulni fogunk a ’Generátor kifejezésekr ˝ kifejezésekr ˝ ol’ (Generator Expressions), melyek még alkalmasabbak a kulcs-érték párok beillesztésére, mint a dict() konstruktor.
Ha végig szeretnénk menni egy szótár elemein, akkor az kapjuk a kulcsot, és a hozzá tartozó értéket.
iteritems() eljáással lépésenként egyid ˝ egyid ˝ oben meg-
>>> lovago lovagok k = {’Gall {’Gallaha ahad’: d’: ’a tiszta tiszta’, ’, ’Robin ’Robin’: ’: ’a bátor’ bátor’} } >>> for k, v in lovago lovagok.i k.iter terite items( ms(): ): ... print k, v ... Gallah Gallahad ad a tiszta tiszta Robi Robin n a báto bátor r
Ha sorozaton megyünk végig, akkor az pozíciót p ozíciót jelz ˝ jelz ˝ o index értékét és a hozzá tartozó értéket egyszerre kaphatjuk meg az enumerate() eljárással. Példa:3 >>> for i, v in enumer enumerate ate([’ ([’tic tic’, ’, ’tac’, ’tac’, ’toe’] ’toe’]): ): ... print i, v ... 0 tic tic 1 tac tac 2 toe toe
3
A tic-tac-toe az am ˝ am ˝ oba játék angol nyelvterületen nyelvterületen elterjedt neve.
Két vagy több sorozat egyszerre történ ˝ történ ˝ o feldolgozásához a sorozatokat a
zip() függvénnyel kell párba állítani.
>>> kerdes kerdesek ek = [’neve [’neved’, d’, ’csoda ’csoda, , amit amit kerese keresel’, l’, ’kedve ’kedvenc nc szined szined’] ’] >>> answer answers s = [’Lanc [’Lancelo elot’, t’, ’A szent szent Gral’, Gral’, ’Kek’] ’Kek’] >>> for q, a in zip(ke zip(kerde rdesek sek, , valasz valaszok) ok): : ... print ’Mi a %s? %s.’ % (q, a) ... Mi a neve neved? d? It is lanc lancel elot ot. . Lancel Lancelot ot. . Mi a csod csoda, a, amit amit kere kerese sel? l? A szen szent t Gral Gral. . Mi a kedv kedven enc c szin szined ed? ? Kek. Kek.
Egy sorozaton visszafelé haladáshoz el ˝ el ˝ oször add meg a sorozatot, majd utána hívd meg a vényt.
reversed()
függ-
>>> for i in revers reversed( ed(xra xrange nge(1, (1,10, 10,2)) 2)): : ... print i ... 9 7 5 3 1
Rendezett Rendezett sorrendben való listázáshoz listázáshoz használd a változatlanul hagyva a régi listát.
sorted()
függvényt, amely új, rendezett listát ad vissza,
>>> kosar kosar = [’alma [’alma’, ’, ’naran ’narancs’ cs’, , ’alma’ ’alma’, , ’korte ’korte’, ’, ’naran ’narancs’ cs’, , ’banan ’banan’] ’] >>> for f in sorted sorted(se (set(b t(bask asket) et)): ): ... print f ... alma banan korte narancs
A while és az if utasításokban eddig használt feltételek egyéb m˝ uveleteket is tartalmazhatnak az összehasonlítás mellett. Az in és not ellen ˝ orzik, hogy az érték el ˝ el ˝ ofordul-e ofordul-e egy sorozatban. sorozatban. Az is és is not not in relációk ellen ˝ not relációk összehasonlítják, hogy két dolog valóban azonos-e; ez csak olyan változékony dolgoknál fontos, amilyenek például a listák. listák. Minden összehasonl összehasonlító ító relációnak relációnak azonos precedenciá precedenciája ja van, mely magasabb magasabb mint a számokkal számokkal végzett végzett m˝ muveleteké. ˝ Relációkat láncolhatunk is, például: az egyenl ˝ egyenl ˝ o-e c-vel.
a < b = == = c
megvizsgálja, hogy az a kisebb-e mint b, és ezen felül
b
A relációkat összef˝ uzhetjük and és or logikai m˝ uveletekkel is, és a reláció erdményét (vagy bármely logikai muveletét) ˝ ellentettjére változtathatjuk a not muvelettel. ˝ Ezeknek mindnek kisebb precedenciájuk van, mint a relációknak, és közülük a not rendelkezik a legmagasabbal és az or a legkisebbel. Tehát az A and not B or C ugyanazt and (not (not B)) B)) or C. Természetesen ugyanazt jelenti, jelenti, mint az (A and Természetesen a zárójeleket használhatjuk használhatjuk a kívánt feltétel eléréséhez. Az and és or logikai m˝ uveletek úgynevezett shortcat (lusta/rövid kiértékelés˝ u) m˝ uveletek: Az argumentumaik balról jobbra fejt ˝ fejt ˝ odnek ki, és a kifejtés kifejtés rögtön megáll, megáll, mihelyt a végeredmény végeredmény egyértelm˝ egyértelm˝ u. Például: ha A és C
mindkett ˝ mindkett ˝ o igaz de B hamis, akkor a A é s B é s C kifejezés során a C értékét a Python már nem vizsgálja. Általában a shortcut m˝ uveletek visszatérési értéke – ha általános értékeket és nem logikai értéket használunk – az utolsónak kifejtett kifejtett argumantummal argumantummal egyezik. Lehetséges, hogy egy reláció vagy más logikai kifejezés értékét egy változóba rakjuk. Például: >>> string string1, 1, string string2, 2, string string3 3 = ’’, ’Trond ’Trondhei heim’, m’, ’Hamme ’Hammer r Dance’ Dance’ >>> >>> non_ non_nu null ll = stri string ng1 1 or stri string ng2 2 or stri string ng3 3 >>> non_null non_null ’Trondheim’
Jegyezzük meg, hogy a Pythonban – szemben a C-vel – nem lehet értékadás egy kifejezés belsejében. Lehet, hogy a C programozók morognak morognak emiatt, emiatt, de így kikerülhet kikerülhet ˝ o egy gyakori gyakori probléma, amelyet amelyet a C programokban programokban gyakran gyakran elkövetnek: = jelet írnak ott, ahol == kellene.
Sorozat Sorozat objektumokat objektumokat összehasonlít összehasonlíthatunk hatunk másik azonos típusú objektummal. objektummal. Az összehasonlí összehasonlítás tás a lexikograrendezést használja: használja: el ˝ el ˝ oször az els ˝ els ˝ o elemeket elemeket hasonlítja össze, ha ezek különböznek, különböznek, ez meghatározz meghatározzaa az fikai rendezést összehasonlítás eredményét; ha egyenl ˝ egyenl ˝ oek, akkor a második elemeket hasonlítja össze, és így tovább, amíg az egyik sorozatnak vége nem lesz. Ha a két összehasonlítandó elem azonos típusú sorozat, akkor az összehasonítás ˝ rekurzívan rekurzívan történik. történik. Ha a két sorozat minden eleme azonos, azonos, akkor tekinthet tekinthet ˝ oek a sorozatok egyenl ˝ egyenl ˝ oeknek. Ha sz egyik sorozat a másiknak másiknak kezd ˝ kezd ˝ o rész-sorozata, rész-sorozata, akkor a rövidebb rövidebb sorozat a kisebb. kisebb. A karakterlánc karakterláncok ok lexikografikai elemzésére az egyes karakterek ASCII rendezését alkalmazzuk. Néhány példa azonos típusú sorozatok összehasonlítására: (1, 2, 3) < [1, 2, 3] < ’ABC ’ABC’ ’ < ’C’ ’C’ < ’Pas ’Pasca cal’ l’ < (1, 2, 3, 4) < (1, 2) < (1, 2, 3) == (1, (1, 2, (’aa’ (’aa’, , ’ab’) ’ab’)) ) <
(1, 2, 4) [1, 2, 4] ’Pyt ’Pytho hon’ n’ (1, 2, 4) (1, 2, -1) (1.0, 2.0, 3.0) (1, 2, (’ab (’abc’ c’, , ’a’), ’a’), 4)
Jegyezzük meg, hogy különböz ˝ különböz ˝ o típusú objektumok összehasonlítása is szabályos. A kimenet jól meghatározott, ˝ de önkényes: a típusok a típusneveik szerint rendez rendez ˝ odnek. Így egy lista mindig kisebb, mint egy karakterlánc, egy 4 karakterlánc mindig kisebb, mint egy tuple, stb. Vegyes számtípusok a számértékeik szerint rendez ˝ rendez ˝ odnek, így például 0 egyenl ˝ egyenl ˝ o 0.0-val.
4
A különböz ˝ különböz ˝ o típusú objektumok összehasonlítási szabályai nem megbízhatóak – a Python kés ˝ obbi verzióiban változhatnak.
6. fejezet
Modulok (2.4 doc) Ha a Pythont Pythont interaktív interaktív módban használod, használod, és kilépsz kilépsz az értelme értelmezz ˝ ob ˝ ob ˝ ol, majd újra visszalépsz, visszalépsz, minden függvénydefüggvényde ˝ finíció és definiált változó elvész. Emiatt ha nagyobb programot akarsz írni, jobban jársz ha valamilyen szerkeszt szerkeszt ˝ o programot használsz az értelmez ˝ értelmez ˝ o számára el ˝ el ˝ okészteni a bemeneti adatokat, és az értelmez ˝ értelmez ˝ ot úgy futtatod, hogy a bemenet a szövegfájlod legyen. Ezt a folyamatot script írásnak nevezik. Ahogy a programod egyre hosszabb lesz, el ˝ el ˝ obb-utóbb részekre (fájlokra) akarod majd bontani, bontani, a könnyebb könnyebb kezelhet ˝ kezelhet ˝ oség végett. végett. Valószín alószín uleg ˝ lesznek praktikus függvényeid, függvényeid, amit már megírt programjaidból szeretnél szeretnél használni a függvénydefiníciók másolása nélkül. Ennek a támogatására a Python el tudja helyezni a függvénydefiníciókat egy adott fájlba, amik aztán elérhet ˝ ok lesznek egy szkriptb ˝ szkriptb ˝ ol, vagy az interaktív értelmez ˝ értelmez ˝ ob ˝ ob ˝ ol. Ezeket a fájlokat moduloknak hívjuk. A modulban használt definíciók importálhatók más modulokba (például a modulok hierarchiájában hierarchiájában legfelül lév lév ˝ o main modulba is). (A következ ˝ következ ˝ o példákhoz: a felhasznált változók mind a legfels ˝ legfels ˝ o névtérben helyezkednek el, a modulok függvényeit itt futtatjuk, interaktív módban.) A modul egy olyan szöveges szöveges file, ami Python definíciókat definíciókat és utasításokat utasításokat tartalmaz. A file neve egyben egyben a modul neve is (a ‘ ’ kiterjesztést kiterjesztést nem beleértve). beleértve). A programból az aktuális modul neve a __name__ globális változóból elérhet ˝ elérhet ˝ o (karakterláncként). Kérlek egy neked megfelel ˝ megfelel ˝ o szövegszerkeszt ˝ szövegszerkeszt ˝ ovel hozd létre a ‘
’ fájlt, a következ ˝ következ ˝ o tartalommal:
# Fibona Fibonacci cci szamok szamok modul modul def def fib( fib(n) n): : # kiir kiirja ja a Fibo Fibona nacc cci i soro soroza zato tot t n-ig n-ig a, b = 0, 1 whil while e b < n: print print b, a, b = b, a+b def fib2(n fib2(n): ): # vissza visszater ter a Fibona Fibonacci cci soroza sorozatta ttal, l, n-erte n-ertekig kig resu result lt = [] a, b = 0, 1 whil while e b < n: result.append(b) a, b = b, a+b return return result
Most lépj be a Python értelmez ˝ értelmez ˝ obe, és importáld a fenti modult a következ ˝ következ ˝ o paranccsal: >>> import import fibo fibo
Ez a parancs a fibo-ban definiált definiált függvényneveke függvénynevekett közvetlenül közvetlenül nem emeli be az aktuális szimbólumtábl szimbólumtáblába; ába; csak magát a modul nevét, fibo-t emeli be. (ford.: mivel mivel a függvények függvények a fibo modul részei, ezért elérhet ˝ elérhet ˝ ové válnak
fibo-n keresztül: fibo.fib(szam) ) >>> fibo.fib(10 fibo.fib(1000) 00) 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 >>> fibo.fib2(1 fibo.fib2(100) 00) [1, [1, 1, 2, 3, 5, 8, 13, 13, 21, 21, 34, 34, 55, 55, 89] 89] >>> fibo.__name fibo.__name__ __ ’fibo’
Ha egy függvényt gyakran szeretnél használni használni az importált modulból, hozzárendelheted azt egy lokális függvénynévhez: >>> >>> fib fib = fibo fibo.f .fib ib >>> fib(500) fib(500) 1 1 2 3 5 8 13 21 34 55 89 144 233 377
A modulok végrehajtható utasításokat ugyanúgy tartalmazhatnak, mint függ vénydefiníciókat. Ezeket az utasításokat rendszerint a modul inicializálásához használjuk. Kizárólag a modul els˝ o importálásakor 1 futnak le. Minden modulnak megvan a saját szimbólumtáblája, ami a modulban definiált függvények számára globális. Emiatt a modul létrehozója nyugodtan használhatja a modulban lév ˝ lév ˝ o globális változókat, változókat, és nem kell aggódnia egy esetleges névütközés miatt. (hiába ugyanaz a neve neve két változónak, ha külön névtérben vannak, nem írják felül egymás értékét) Másrészr ˝ Másrészr ˝ ol ha pontos pontosan an tudod tudod hogy hogy mit csinál csinálsz, sz, el tudod tudod érni érni a modul globál globális is változ változóit óit a változó változónév név teljes teljes elérés elérésii útjának a használatával: modulnev.elemnev. A modulok importálhatnak más modulokat. Szokás – de nem kötelez ˝ kötelez ˝ o – az import utasításokat a modul elején ˝ elhelyezni (vagy a szkript elején, lásd kés ˝ kés ˝ obb). Az importált modulnev modulneveket eket az értelmez értelmez ˝ o az importáló modul globális szimbólumtáblájába helyezi el. Az import utasítás egyik felhasználási módja, hogy az importált függvényeket közvetlenül az importáló modul szimbólumtáblájába helyezzük el. Például: >>> >>> from from fibo fibo impo import rt fib, fib, fib2 fib2 >>> fib(500) fib(500) 1 1 2 3 5 8 13 21 34 55 89 144 233 377
Az el ˝ el ˝ obbi példa a helyzi szimbólumtáblába nem helyezi el a modul nevét, amib ˝ ol az importálás importálás történt. történt. (fibo objektum nem jön létre a névtérben) Ha a modulban modulban lév ˝ lév ˝ o összes nevet nevet közvetlenül a helyi szimbólumtáblába szeretnéd importálni, így tudod megtenni: megtenni: >>> >>> from from fibo fibo impo import rt * >>> fib(500) fib(500) 1 1 2 3 5 8 13 21 34 55 89 144 233 377
Ha így használod az import utasítást, a forrásmodul minden nevét a helyi szimbólumtáblába emeled, kivéve az aláhúzással kezd ˝ kezd ˝ od ˝ od ˝ oeket ( _). 1
Valójában a függvénydefi níciók szintén végrehajtható utasítások; A függvény neve a végrehajtás során kerül bele a modul globális szimbólumtáblájába.
Amikor a spam modult importáljuk, az értelmez ˝ értelmez ˝ o el ˝ el ˝ oször az aktuális könyvtárban keresi a ‘ ’ fájlt. Ha itt nem találja, tovább keres a PYTHONPATH környezeti változóban felsorolt könyvtárakban. Ennek a változónak a szintaktisa ugyanolyan, mint a PATH héj-változónak (Linuxon). Egyszer uen ˝ könyvtárnevek könyvtárnevek listáját tartalmazza. Ha a PYTHONPATH változó nincs beállítva, vagy az abban felsorolt könyvtárak a keresett fájlt nem tartalmazzák, a keresés keresés az alapértelme alapértelmezett zett könyvtárban könyvtárban folytatódi folytatódik. k. Ez már függ az installálástól, installálástól, U NI X-on rendszerint ‘ ’. Jelenleg a modulokat az értelmez ˝ értelmez ˝ o a sys.path változóban felsorolt könyvtárakban keresi. Ez a változó az aktuális könyvtárból (ahonnan a programot futtatjuk), a PYTHONP PYTHONPA ATH-ban lév ˝ lév ˝ o könyvtárakból, és az installálástól függ ˝ függ ˝ o alapértelmezett könyvtárból áll. Így a Python programoknak módjuk nyílik a modulok keresési útvonalát módosítani, vagy akár teljesen kicserélni. Fontos megemlíteni, hogy mivel az aktuális könyvtár is a keresési útvonal része, a programnak még véletlenül se legyen ugyanaz a neve, mint valamely valamely standard modulnak. modulnak. Ebben az esetben ugyanis a Python megkísérli megkísérli a programot modulként modulként betölteni betölteni annak importálásakor importálásakor,, ami hibaüzenethe hibaüzenethezz vezet. További ovábbi információk: információk: 6.2, „Standard Modules,”. Modules,”.
Fontos a standard modulokat használó programok indulási idejét lerövidíteni. Ha ‘ ’ fájl létezik abban a könyvtárban, ahol ‘ ’ is megtalálható, az értelmez ˝ értelmez ˝ o feltételezi, hogy a ‘ ’ fájl a ‘ ’ fájlnak az el ˝ el ˝ ore lefordított lefordított változata. változata. (A Python a .py fájlokat fájlokat el ˝ el ˝ oször .pyc bájtkódra fordítja, ami már egy bináris, ember számára nem értelmes, olvasható állomány – ezt hajtja végre az értelmez ˝ o. Ez a m˝ uködés a Java nyelvhez hasonló konstrukció) A fordítás során a ‘ ’ fájl ugyanazzal a módosítási id ˝ id ˝ ovel jön létre, mint a ‘ módosítási ideje különbözik, a ‘ ’ fájlt újrafordítja a Python. Rendszerint nem kell tenni semmit a ‘ sakor automatikusan létrejön.
’ fájl létrehozásáért, mert az a ‘
’ fájl. fájl. Ha a két fájl fájl utolsó utolsó ’ sikeres bájtkódra fordítá-
Nem hiba, ha ez az automatizmus automatizmus látszólag nem m ˝ uködik. uködik. Ha bármi oknál fogva fogva a ‘ ’ írása félbesza félbeszakad, kad, a ˝ fájl-t a Python kés ˝ kés obb mindenképpen érvénytelen fájl-nak fogja felismerni. A lefordított ‘ ’ fájl tartalma platform független, ezért a Python modulkönyvtárat nyugodtan megoszthatod megoszthatod különböz ˝ különböz ˝ o achitektúrájú gépek között. Néhány tipp haladóknak: ˝ • Amikor Amikor a Python értelmez értelmez ˝ ot a -O paraméterrel hívjuk meg, az optimalizált kódot generál és tárol a ‘ ’ fájlokban. Az optimalizáló jelenleg nem túl sok segítséget nyújt – egyszer˝ uen csak eltávolítja az assert utasításokat utasításokat.. Amikor Amikor a -O paramétert használjuk, minden bájtkód bájtkód optimalizál optimalizáltt lesz. A .pyc fájlokat az értelmez ˝ értelmez ˝ o figyelmen kívül hagyja, és a .py fájlokat optimalizált bájtkódra fordítja. ˝ • Amik Amikor or két két -O paramét paraméterr errel el hívjuk hívjuk meg a Python Python értelm értelmez ez ˝ ot,(-OO) a bájtkód bájtkód-fordító -fordítóúgy úgy optimalizál optimalizál,, hogy hogy az optimalizáció ritka esetekben hibás programm˝ uködést okoz??? ???optimizations that could in some rare cases result in malfunctioning programs. Jelenleg csak a __doc__ szövegeket törli a bájtkódból, tömörebb ‘ ’ fájlt eredményezve. Mivel néhány program számít a dokumentációs változó elérhet ˝ elérhet ˝ oségére, csak akkor használd ezt az opciót, ha pontosan tudod hogy mit csinálsz. • A program semmivel sem fut gyorsabban, ha ‘ ’ vagy ‘ ’ kiterjeszté kiterjesztéssu˝ bájtkódot futtatunk – a sebességnövekedés a betöltési id ˝ id ˝ oben jelentkezik. Ha a ‘ ’ fálj bájtkódra fordított verziója rendelkezésre áll, nincs szükség a fordításra, rögtön lehet futtatni a bájtkódot tartalmazó verziót. • Amikor egy szkriptet a parancssorból futtatunk a nevének megadásával, megadásával, a futó program bájtkódja soha nem ˝ íródik ‘ ’ vagy ‘ ’ fájlba fájlba.. Ebb ˝ Ebb ˝ ol kifolyólag kifolyólag a program indulási indulási ideje lerövidíthet lerövidíthet ˝ o, ha a kód nagy részét modulokba helyezzük át, és az indítóprogramunk kis méret˝ u, és importálja a szükséges modulokat. ??? Lehet ˝ Lehet ˝ oség van a ‘ ’, vagy ‘ ’ fájlok közvetlen futtatására is.???
• Lehetséges, hogy van egy ‘ ’ (vagy ‘ ’ fájlod, ha a -O fordítási paramétert használták) – úgy, hogy nincs mellette ‘ ’ fájlod. Ez egy módja a Python könyvtárak közzétételének úgy, hogy a könyvtárat nem tudják módosítani, megváltoztatni (hiszen nincs meg a forráskód, amib ˝ amib ˝ ol fordították). • A compileall modul‘ ’ fájlok fájlokat at tud készít készíteni eni az aktuáli aktuáliss könyvt könyvtár ár összes összes moduljá moduljából. ból. (vagy (vagy ‘ ha a -O kapcsolót használtad)
’-t,
A Python funkciójuk szerint csoportokba sorolt szabványos modulokkal rendelkezik – egy könyvtárral – részletesen: Python Library Reference Reference – Python referencia referenciakönyv könyvtár tár a kés˝ obbiekben obbiekben A modulok modulok tételes tételes felsorolása felsorolása – értelmez ˝ obe építettünk be, ezeken keresztül olyan funkciók megvalósítása lehet Module index Néhány modult az értelmez ˝ séges, amelyek ugyan nem tartoznak szorosan a nyelvhez, de például az operációs rendszerrel való kapcsolathoz szükségesek – ilyenek például a rendszerhívások. Ezen modulok függenek a használt operációs rendszert ˝ rendszert ˝ ol, hiszen annak m˝ uködtetéséhe uködtetéséhezz kellenek. kellenek. Például Például az azokon a rendszereke rendszerekenn elérhet ˝ elérhet ˝ o, amik támogatják az Amoeba Amoeba primitívek primitívek használatát használatát.. A amoeba modul csak azokon másik figyelemre méltó – és különleges modul a sys , ami minden Python értelmez ˝ értelmez ˝ obe be van építve. építve. Például Például ˝ ˝ ˝ a sys.ps1 és sys.ps2 változók tartalmazzák az értelmez ˝ értelmez oben megjelen ˝ megjelen o els ˝ elsodleges odleges és másodlagos másodlagos prompt karakterláncát: >>> import import sys >>> sys.ps1 sys.ps1 ’>>> ’>>> ’ >>> sys.ps2 sys.ps2 ’... ’... ’ >>> >>> sys. sys.ps ps1 1 = ’C> ’C> ’ C> print print ’Yuck! ’Yuck!’ ’ Yuck! C>
Ez a két változó csak akkor létezik, ha az értelmez ˝ értelmez ˝ o interaktív módban fut. A sys.path változó karakterláncok listáját tartalmazza, melyek meghatározzák meghatározzák az értelmez ˝ értelmez ˝ o keresési keresési útvonalát, útvonalát, amit az a modulok importálásakor bejár. Kezdeti értékét a PYTHONPA PYTHONPATH környezeti változóból veszi, vagy ha ez nem létezik, akkor az értelmez ˝ értelmez ˝ obe beépített alapértelmez alapértelmezett ett útvonalakból. útvonalakból. A változó változó értékét ugyanúgy módosíthatod, mint egy listáét: >>> import import sys >>> sys.path.append(’/ufs/guido/lib/python’)
dir() A beépített dir() függvénnyel listázhatjuk ki a modulban definiált neveket. A rendezett listájával tér vissza.
dir() meghívása után a nevek
>>> import import fibo, sys >>> dir(fibo) dir(fibo) [’__name__’ [’__name__’, , ’fib’, ’fib2’] ’fib2’] >>> dir(sys) dir(sys) [’__display [’__displayhook__ hook__’, ’, ’__doc__’, ’__doc__’, ’__exceptho ’__excepthook__’ ok__’, , ’__name__’, ’__name__’, ’__stderr__ ’__stderr__’, ’, ’__stdin__’ ’__stdin__’, , ’__stdout__ ’__stdout__’, ’, ’_getframe’ ’_getframe’, , ’api_versio ’api_version’, n’, ’argv’, ’argv’, ’builtin_mo ’builtin_module_ dule_names’ names’, , ’byteorder’ ’byteorder’, , ’callstats’ ’callstats’, , ’copyright’ ’copyright’, , ’displayhoo ’displayhook’, k’, ’exc_clear’ ’exc_clear’, , ’exc_info’, ’exc_info’, ’exc_type’, ’exc_type’, ’excepthook ’excepthook’, ’, ’exec_prefi ’exec_prefix’, x’, ’executable ’executable’, ’, ’exit’, ’exit’, ’getdefault ’getdefaultencodi encoding’, ng’, ’getdlopenf ’getdlopenflags’ lags’, , ’getrecursi ’getrecursionlim onlimit’, it’, ’getrefcoun ’getrefcount’, t’, ’hexversion ’hexversion’, ’, ’maxint’, ’maxint’, ’maxunicode ’maxunicode’, ’, ’meta_path’ ’meta_path’, , ’modules’, ’modules’, ’path’, ’path’, ’path_hooks ’path_hooks’, ’, ’path_impor ’path_importer_c ter_cache’, ache’, ’platform’, ’platform’, ’prefix’, ’prefix’, ’ps1’, ’ps2’, ’ps2’, ’setcheckin ’setcheckinterval terval’, ’, ’setdlopenf ’setdlopenflags’, lags’, ’setprofile ’setprofile’, ’, ’setrecursi ’setrecursionlim onlimit’, it’, ’settrace’, ’settrace’, ’stderr’, ’stderr’, ’stdin’, ’stdin’, ’stdout’, ’stdout’, ’version’, ’version’, ’version_in ’version_info’, fo’, ’warnoption ’warnoptions’] s’]
Ha paraméterek nélkül hívjuk meg a
dir() függvényt, az aktuális névtérben definiált nevekkel tér vissza:
>>> a = [1, 2, 3, 4, 5] >>> import import fibo, sys >>> >>> fib fib = fibo fibo.f .fib ib >>> dir() dir() [’__name__’ [’__name__’, , ’a’, ’fib’, ’fib’, ’fibo’, ’fibo’, ’sys’] ’sys’]
Fontos, hogy az így kapott lista az összes névfajtát tartalmazza. Változókat, modulokat, függvényeket, stb. nem list listáz ázza za ki a nyel nyelvb vben en el ˝ el ˝ ore dir() nem __builtin__ modulban vannak definiálva: A
definiál definiáltt (beépít (beépített ett)) függvé függvénye nyeket ket és változó változókat kat..
Ezek Ezek a
>>> import import __builtin__ __builtin__ >>> dir(__built dir(__builtin__) in__) [’ArithmeticError’, ’AssertionError’, ’AttributeError’, ’Deprecatio ’DeprecationWarn nWarning’, ing’, ’EOFError’, ’EOFError’, ’Ellipsis’, ’Ellipsis’, ’Environmen ’EnvironmentErro tError’, r’, ’Exception’ ’Exception’, , ’False’, ’False’, ’FloatingPo ’FloatingPointErr intError’, or’, ’IOError’, ’IOError’, ’ImportError ’ImportError’, ’, ’Indentatio ’IndentationErro nError’, r’, ’IndexError ’IndexError’, ’, ’KeyError’, ’KeyError’, ’KeyboardIn ’KeyboardInterru terrupt’, pt’, ’LookupErro ’LookupError’, r’, ’MemoryErro ’MemoryError’, r’, ’NameError’ ’NameError’, , ’None’, ’None’, ’NotImpleme ’NotImplemented’, nted’, ’NotImplementedError’, ’OSError’, ’OverflowError’, ’OverflowWarning’, ’PendingDeprecationWarning’, ’ReferenceError’, ’RuntimeErr ’RuntimeError’, or’, ’RuntimeWar ’RuntimeWarning’ ning’, , ’StandardErr ’StandardError’, or’, ’StopIterat ’StopIteration’, ion’, ’SyntaxErro ’SyntaxError’, r’, ’SyntaxWarn ’SyntaxWarning’, ing’, ’SystemErro ’SystemError’, r’, ’SystemExit ’SystemExit’, ’, ’TabError’, ’TabError’, ’True’, ’True’, ’TypeError’ ’TypeError’, , ’UnboundLoc ’UnboundLocalErro alError’, r’, ’UnicodeErr ’UnicodeError’, or’, ’UserWarnin ’UserWarning’, g’, ’ValueError ’ValueError’, ’, ’Warning’, ’Warning’, ’ZeroDivisi ’ZeroDivisionErro onError’, r’, ’__debug__’ ’__debug__’, , ’__doc__’, ’__doc__’, ’__import__ ’__import__’, ’, ’__name__’, ’__name__’, ’abs’, ’apply’, ’apply’, ’bool’, ’bool’, ’buffer’, ’buffer’, ’callable’, ’callable’, ’chr’, ’classmethod ’classmethod’, ’, ’cmp’, ’coerce’, ’coerce’, ’compile’, ’compile’, ’complex’, ’complex’, ’copyright’ ’copyright’, , ’credits’, ’credits’, ’delattr’, ’delattr’, ’dict’, ’dict’, ’dir’, ’dir’, ’divmod’, ’divmod’, ’enumerate’ ’enumerate’, , ’eval’, ’eval’, ’execfile’, ’execfile’, ’exit’, ’file’, ’file’, ’filter’, ’filter’, ’float’, ’float’, ’getattr’, ’getattr’, ’globals’, ’hasattr’, ’hash’, ’help’, ’help’, ’hex’, ’id’, ’input’, ’input’, ’int’, ’intern’, ’intern’, ’isinstance’ ’isinstance’, , ’issubclass ’issubclass’, ’, ’iter’, ’iter’, ’len’, ’len’, ’licen ’license’ se’, , ’list’ ’list’, , ’local ’locals’, s’, ’long’ ’long’, , ’map’, ’map’, ’max’, ’max’, ’min’, ’min’, ’object’, ’object’, ’oct’, ’open’, ’open’, ’ord’, ’pow’, ’property’, ’property’, ’quit’, ’range’, ’range’, ’raw_input’ ’raw_input’, , ’reduce’, ’reduce’, ’reload’, ’reload’, ’repr’, ’repr’, ’round’, ’round’, ’setattr’, ’setattr’, ’slice’, ’slice’, ’staticmeth ’staticmethod’, od’, ’str’, ’string’, ’string’, ’sum’, ’super’, ’super’, ’tuple’, ’tuple’, ’type’, ’type’, ’unichr’, ’unichr’, ’unicode’, ’unicode’, ’vars’, ’xrange’, ’xrange’, ’zip’] ’zip’]
A csomagok csomagok adnak lehet ˝ lehet ˝ oséget a Python modulok névtereinek struktúrálására, a pontozott modulnevek használatával. Például a A.B modulnév hivatkozik a ‘ B’ modulra, ami az ‘ A’ modulban található (ott importáltuk). Ha a programozók a fenti példa szerint használják a modulokat, nem kell amiatt aggódniuk, hogy egymás globális neveiv neveivel el ütközés lép fel. Például Például a több modulból álló álló csomagok (NumPy, (NumPy, Python Imaging Library...) Library...) írói is a pontozott modulnevek használatával kerülik el a változónevek ütközését. Tegyük fel, hogy egy modulokból álló csomagot akarsz tervezni, hogy egységesen tudd kezelni a hangfájlokat és a bennük lév ˝ lév ˝ o adattartalmat. adattartalmat. Több különböz ˝ különböz ˝ o hangfájlformátum létezik (rendszerint a kiterjesztésük alapján ˝ beazonosítan lehet oket beazonosítani,i, pl.: ‘ ’, ‘ ’, ‘ ’) – valószín˝ uleg egy b ˝ b ˝ ovül ˝ ovül ˝ o modulcsoportot kell készítened és karbantartanod a fájlformátumok közötti konvertálásra. There are also many different operations you might want to perform on sound data (such as mixing, adding echo, applying an equalizer function, creating an artificial stereo effect), so in addition you will be writing a neverending stream of modules to perform these operations. Here’s a possible structure for your package (expressed in terms of a hierarchical filesystem): Ráadásul még többfajta m˝ uveletet uveletet is el kell tudnod végezni végezni a hanganyagon hanganyagon,, például például keverést keverést,, visszhang készítését, készítését, hangszínszabályzást, m˝ uvészeti sztereo effekteket – szóval a fentiek tetejébe még írni fogsz egy végeláthatatlan modulfolyamot, ami ezeket a m˝ uveleteket elvégzi. elvégzi. A csomagok egy lehetséges struktúrája – a hierarchikus fájlrendszereknél használatos jelöléssel: 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 ...
˝ szint˝ Legfelso szint˝ u csomag csomag a sound csomag inicializálása A fájlformátum konverziók alcsomagja
A hangeffektek alcsomagja
˝ A szur˝ u ˝rok ok alcsomagja alcsomagja
A csomag: olyan hierarchikus könyvtárszerkezet, amely egymással összefügg ˝ összefügg ˝ o modulokat tartalmaz. Egy csomag importálása során a Python bejárja a sys.path változóban szerepl ˝ szerepl ˝ o könyvtárakat, a csomag alkönyvtárak után kutatva. A sys.path az el ˝ el ˝ ore meghatározott keresési útvonalakat tartalmazza. A Python az ‘ ’ fájlok jelenlétéb ˝ jelenlétéb ˝ ol tudja, hogy egy könyvtárat csomagként kell kezelnie – és ez a fájl segít abban is, hogy az alkönyvtárakban alkönyvtárakban lév ˝ lév ˝ o csomagokat is érzékelje a Python. A legegyszer˝ ubb esetben az ‘ inicializáló kódot, vagy beállíthatja az
’ egy üres fájl, de tartalmazhat tartalmazhat és végrehajthat végrehajthat a csomaghoz tartozó tartozó __all__ változót (lásd lejjebb).
A csomag felhasználói egyenként is importálhatnak modulokat a csomagból:
import import Sound.Effec Sound.Effects.ech ts.echo o
Ez betölti a Sound.Effects.echo almodult. A hivatkozást teljes útvonallal kell megadni. Sound.Effec Sound.Effects.ech ts.echo.echo o.echofilter filter(input (input, , output, output, delay=0.7, delay=0.7, atten=4) atten=4)
Egy másik alternatíva almodulok importálására: from Sound.Effec Sound.Effects ts import import echo
Ez szintén betölti az el ˝ el ˝ otag).
echo
almodult, és elérhet ˝ elérhet ˝ ové teszi a csomagnevek nélkül is (nem kell a Sound.Effects
echo.echofi echo.echofilter(i lter(input, nput, output, output, delay=0.7, delay=0.7, atten=4) atten=4)
Van még egy lehet ˝ lehet ˝ oség a kiválasztott függvény importálására: from Sound.Effec Sound.Effects.ec ts.echo ho import echofilter echofilter
Ez szintén betölti az echo almodult, de a echofilter() függvény közvetlenül elérhet ˝ elérhet ˝ ové válik: echofilter( echofilter(input, input, output, output, delay=0.7, delay=0.7, atten=4) atten=4)
Fontos, Fontos, hogya from csomag import elem haszná használat latako akorr az elem elem az import importált ált csomag csomag almodul almodulja ja (submod (submodule ule)) vagy vagy alcsom alcsomagj agjaa (subpac (subpackag kage) e) is lehet, lehet, vagy vagy valam valamily ilyen en más, más, a csomag csomagban ban definiá definiált lt ’elem’ ’elem’ nev˝ nev˝ u objekt objektum, um, példáu példáull függvény, osztály vagy változó. Az import utasítás el ˝ el ˝ oször ellen ˝ ellen ˝ orzi, hogy az importálandó importálandó elem definiálv definiálvaa van-e a csomagban. csomagban. Ha nem, akkor az elemr ˝ elemr ˝ ol feltételezi, feltételezi, hogy az egy modul, és megkísérli megkísérli azt betölteni. betölteni. Ha a modul keresése keresése sikertelen, sikertelen, ImportError kivétel váltódik ki. Ezzel ellentétben az import elem.alelem.alelem_aleleme utasításforma használatakor használatakor az utolsó alelem_aleleme kivét kivételé elével vel mindeg mindegyik yikele elemne mnekk csomag csomagnak nak kell kell lennie lennie.. Az utolsó utolsó elem elem lehet lehet mod modul ul vagy vagy csomag csomag is, de de a fentie fentiekke kkell ellentétben nem lehet osztály, függvény vagy definiált változó.
Mi történik, amikor a programozó kiadja a from from Sound. Sound.Eff Effect ects s impor import t * utasítást? Ideális esetben az értelmez ˝ értelmez ˝ o a fájlrendszerben megtalálja a csomagban lév ˝ lév ˝ o almodulokat, és mindet importálja. Sajnos ez a m˝ uvelet Mac vagy Windows platformon nem igazán jól m˝ uködik – ennek oka a fájlrendszerek hiányosságában keresend ˝ keresend ˝ o, hiszen az nem tartalmaz pontos információkat a fájlnév pontos kisbet˝ us - nagybet˝ us írásmódjáról. A fenti platformokon nincs garantált módszer annak kiderítésére, hogy az ‘ ’ fájlt visszhang, Visszhang vagy VISSZHANG modulként kell-e importálni. Például a Windows 95 egyik bosszantó tulajdonsága, hogy minden fájlnevet nagy kezd ˝ kezd ˝ obet˝ uvel jelenít meg. A DOS 8+3 bet˝ us névhosszúsága szintén érdekes problémákat pro blémákat vet fel hosszú modulnevek esetében. A csomagkészít ˝ csomagkészít ˝ ok számára az egyedüli megoldás az, ha a csomagot egyértelm˝ u index-el index-el látják látják el. Az import utasítás a következ ˝ következ ˝ o szabályokat szabályokat használja használja:: ha a csomag ‘ ’ állományának kódjában szerepel az u lista, az abban felsorolt nevek lesznek az importálandó modulnevek a from package import __all__ nev˝ végrehajtásakor. * utasítás végrehajtásakor.
A csomag készít ˝ készít ˝ ojének feladata, hogy ezt a listát naprakészen tartsa, mikor a csomag újabb verzióját készíti. A csomagkészít ˝ csomagkészít ˝ ok dönthetnek úgy, hogy ezt a funkciót nem támogatják, ha valószín˝ utlennek tartják hogy valaki az import ’ fájl a következ ˝ következ ˝ o kódot import * utasítást használja a csomagra. Például a ‘ tartalmazhatja: __all__ __all__ = ["echo", ["echo", "surround", "surround", "reverse"] "reverse"]
A fentiek értelmében a Sound csomagból.
from Sound.Ef Sound.Effect fects s import import * importálni
fogja a három felsorolt almodult a
Ha az tálja a
__all__ lista Sound.Effect fects s import import * utasítás nem imporlista nem meghat meghatáro ározot zott, t, a from Sound.Ef Sound.Effects csomag összes almodulját az aktuális névtérbe – csupán azt biztosítja, hogy a Sound.Effects csomag importálva legyen (talán, ha az ‘ ’ inicializáló kódból adod ki az uta-
sítást ???) és aztán a csomagban található összes nevet importálja. Ebbe beleértend ˝ beleértend ˝ o minden név, amit az ‘ lesz a csomag minden almodulja, amit a
from
’-ben vagy az almoduljaiban definiáltak. Szintén importálva el ˝ ott importáltunk. Sound.Ef Sound.Effect fects s import import * utasítás el ˝
Figyeljük meg, mi történik ebben a kódban: import import Sound.Effec Sound.Effects.ech ts.echo o import Sound.Effects.surround from from Sound. Sound.Eff Effect ects s import import *
Ebben a példában az ’echo’ és a ’surround’ modulokat az értelmez ˝ értelmez ˝ o a helyi (bels ˝ (bels ˝ o) névtérbe importálja, mert a utasítás végrehajtásak végrehajtásakor or.. (Ez szintén m˝ uködik, Sound.Effects csomag részei voltak a from...import utasítás amikor az __all__ változó definiálva van) ˝ import t * importálási Jó tudni, tudni, hogy az impor importálási mód használata használata kerülend kerülend ˝ o, mert mert a kódot kódot neheze nehezenn olvash olvasható atóvá vá teszi. teszi. Ámbár ennek az importálási módnak a használatával egyszer˝ ubben dolgozhatunk az értelmez ˝ értelmez ˝ o interaktív módjában, egyes modulokat úgy terveznek, hogy csak az __all__ változóban megadott neveket exportálják. Emlékezzünk rá, hogy semmi probléma nincs a from Package Package import import specific specific_sub _submodu module le szerkezet kezet használatá használatával! val! Valójában alójában ez az ajánlott importálási importálási mód, hacsak hacsak az importáló modulnak nincs szüksége különböz ˝ különböz ˝ o csomagokból származó azonos nev˝ u almodulok használatára.
Az almodulok gyakran hivatkoznak egymásra – például a echo modult.
surround
modul elképzelhet ˝ elképzelhet ˝ o hogy használja az
Valójában ha a példához hasonló hivatkozás történik, az import utasítás el ˝ el ˝ oször a már importált csomagokban keres, miel ˝ miel ˝ ott a standard modulok keresési útvonalát végignézi. import echo vagy a from from echo echo import import Ennélfog Ennélfogva va a surround surround mod modul ul egysz egyszer˝ er˝ uen használhatja az import echofilter importálási utasítást. Ha az importált modul nem található meg az aktuális csomagban (az a csomag, amelyiknek az aktuális modul is része – almodulja), az import utasítás a fels ˝ fels ˝ o szint˝ u modulokban keresi a megadott nevet.
Amikor a csomagok kisebb egységekb ˝ egységekb ˝ ol – alcsomagokból épülnek fel, a fenti példában szerepl ˝ szerepl ˝ o Sound csomaghoz hasonlóan, az almodulok egymásra teljes – pontozott, hierarchikus nevükkel kell hivatkozzanak. Például ha a Sound.Filters.vocoder-nek használnia használnia kell kell a Sound.Effects csomagban található echo modult, a következ ˝ következ ˝ oképpen oképpen érheti érheti azt el: from Sound.Ef Sound.Effect fects s import import echo
A csomagok rendelkeznek r endelkeznek egy egyedi tulajdonsággal, melyet __path__ -nak hívunk. Ez egy lista, amelyben az ‘ ’ fájlt tartalmazó könyvtár nevét találjuk – miel ˝ miel ˝ ott az aktuális fájlban lév ˝ lév ˝ o kód végrehajtódna.
Ez egy módosítható változó, amely befolyásolja a csomagban található modulok és alcsomagok keresését. Bár erre a lehet ˝ lehet ˝ oségre ritkán van szükség, a csomagot újabb modulokkal egészíthetjük ki vele.
7. fejezet
Bemenet és kimenet (2.4 doc) Egy program kimenete többféleképpen jelenhet meg: például ember által olvasható nyomtatott formában, vagy kés ˝ kés ˝ obbi feldolgozás céljából fájlba írva. Ez a fejezet a lehet ˝ oségek közül többet is bemutat.
˝ Az értékek értékek kiírására kiírására két lehet lehet ˝ oségünk oségünk van: Saját kimenet-for kimenet-formázás mázás függvények függvényekkel kel ??? és a print utasítás. (a fent ˝ említett harmadik lehet ˝ lehet oség a write() metódust használja fájl objektumok kezelésére; a szabványos kimeneti fájlt a sys.stdout -ként érhetjük el. A referencia könyvtárt érdemes megnézni (Library Reference), ott több információt találunk a szabványos kimenet használatáról. Gyakori igény, hogy a programozó az egyszer˝ u - szóközökkel tagolt kimeneti formázásnál több lehet ˝ lehet ˝ oséget szeretne. A kétféleképpen formázhatod a kimenetet: • A kimeneti karakterláncok teljes formázását te kezeled – a karakterláncok szétvágásával és összeillesztésével bármilyen elképzelt kimenetet el ˝ el ˝ oállíthatsz. A szabváyos modulok között található string számos hasznos karakterlánc-kezel ˝ karakterlánc-kezel ˝ o rutint tartalmaz (pl. karakterlánc kitöltése adott szélesség eléréséhez) – ezek rövid bemutatása lejjebb található. ˝ • A második második lehet lehet ˝ oség a % operátor használata, ahol a formázandó karakterlánc baloldali argumentum argumentum (Példa pár sorral lentebb!). A % operator operator feldolgozza feldolgozza a baloldali baloldali karakterláncot karakterláncot,, mintha az sprintf() függvényt használtuk volna – és a formázott karakterláncot adja visszatérési értékként. ˝ Egy kérdés maradt hátra: hogy hogyan konvertál konvertálhatsz hatsz egy számjegyekb számjegyekb ˝ ol álló karakterláncot értékkel bíró számmá? számmá? Szerencsére Szerencsére a Python Python erre több lehet lehet ˝ oséget oséget is biztosít: add át a karakterlánc karakterláncot ot a repr() vagy az idéz ˝ ojelek ( ‘‘) használata egyenérték˝ u a repr() függvény hívástr() függvényeknek. A fordított egyszeres idéz ˝ sával, de használatuk helyett a függvényhívást f üggvényhívást javasoljuk. javasoljuk. Az str() függvény az értékek ember által olvasható olvasható formájával tér tér vissza, míg a repr() függvény függvény visszatérés visszatérésii értéke az interpreter számára értelmezhet ˝ értelmezhet ˝ o adat. (vagy SyntaxError kivételt vált ki nem megfelel ˝ megfelel ˝ o szintaxis esetén.) Azon objektumok objektumokeseté esetében, ben, amelyeknek amelyeknek nincs emberi emberi olvasásra olvasásra szánt ábrázolása ábrázolása,, az str() függvény függvény ugyanazzal ugyanazzal az értékkel tér vissza, mintha a repr() függvényt függvényt hívtuk volna volna meg. Néhány Néhány érték, például a számok vagy a struktúrák esetében – mint például a listák vagy a szótárak, bármely két fent említett funkciót használva ugyanazt az eredményt kapjuk. Karakterláncok és lebeg ˝ lebeg ˝ opontos számoknak két eltér ˝ eltér ˝ o ábrázolási módjuk van: Néhány példa:
>>> >>> s = ’Hel ’Helló ló, , vilá világ. g.’ ’ >>> str(s) str(s) ’Helló, ’Helló, világ.’ világ.’ >>> repr(s) repr(s) "’Helló, "’Helló, világ.’" világ.’" >>> str(0.1) str(0.1) ’0.1’ >>> repr(0.1) repr(0.1) ’0.10000000000000001’ >>> x = 10 * 3.25 >>> y = 200 * 200 >>> >>> s = ’x érték értéke: e: ’ + repr repr(x (x) ) + ’, és y érté értéke ke: : ’ + repr repr(y (y) ) + ’... ’...’ ’ >>> >>> prin print t s x érté értéke ke: : 32.5 32.5, , és y érté értéke ke: : 4000 40000. 0... .. % >>> >>> # The The repr repr() () of a stri string ng adds adds stri string ng quot quotes es and and back backsl slas ashe hes: s: >>> >>> # A repr repr() () függ függvé vény ny idéz idéz˝ ojelek ˝ ojelek közé közé rakja rakja a string stringet, et, >>> # és kijelz kijelzi i a különl különlege eges s (escap (escape) e) karakt karaktere ereket ket is: ... hello hello = ’helló ’helló világ\ világ\n’ n’ >>> hellos hellos = repr(h repr(hell ello) o) >>> print print hellos hellos ’helló ’helló világ\n’ világ\n’ >>> # A repr() repr() függvé függvényn nynek ek akár akár objekt objektumo umokat kat is átadha átadhatun tunk: k: ... repr(( repr((x, x, y, (’hús’ (’hús’, , ’tojás ’tojás’)) ’))) ) "(32.5, "(32.5, 40000, (’hús’, ’tojás’))" ’tojás’))" % >>> # revers reverse e quotes quotes are conven convenien ient t in intera interacti ctive ve sessio sessions: ns: >>> >>> # A viss vissza zaha hajl jló ó idéz idéz˝ ojeleket ˝ ojeleket (‘) interaktív interaktív módban használhatjuk, használhatjuk, >>> >>> # ugya ugyana nazt zt érjü érjük k el, el, mint mint ha a repr repr() () függ függvé vény nyt t hívt hívtuk uk voln volna a meg: meg: ... ‘x, y, (’spam (’spam’, ’, ’eggs’ ’eggs’)‘ )‘ "(32.5, "(32.5, 40000, (’spam’, ’eggs’))" ’eggs’))"
Ha akarunk készíteni egy táblázatot, amiben a számok második és harmadik hatványai szerepelnek, két lehet ˝ oségünk is van:
>>> >>> for for x in rang range( e(1, 1, 11): ... ... prin print t repr repr(x (x). ).rj rjus ust( t(2) 2), , repr repr(x (x*x *x). ).rj rjus ust( t(3) 3), , %... %... # Not Note e tra trai iling ling comm comma a on on pr previo evious us line line ˝ ˝ sor ˝ vess ˝ miat ... # Figyelem! az eloz˝ ozo sor végé végén n szer szerep epl lo vessz zo miatt t a ˝ prin ˝ ˝ sor ... # következo print t az el˝ eloz˝ ozo sor végé végén n foly folyta tatj tja a a kiír kiírás ást! t! ... ... prin print t repr repr(x (x*x *x*x *x). ).rj rjus ust( t(4) 4) ... 1 1 1 2 4 8 3 9 27 4 16 16 64 5 25 125 6 36 216 7 49 343 8 64 512 9 81 729 10 100 100 1000 1000 >>> >>> for for x in rang range( e(1, 1,11 11): ): ... print ’% ’%2d %3 %3d %4 %4d’ % (x (x, x* x*x, x* x*x*x) ... 1 1 1 2 4 8 3 9 27 4 16 16 64 5 25 125 6 36 216 7 49 343 8 64 512 9 81 729 10 100 100 1000 1000
(Megjegyzés: az oszlopok között 1 szóköznyi helyet a mindig 1 szóközt hagy.)
print utasítás hagyott – az utasítás a paraméterei között
Ez a példa bemutatja a szöveges (karakterlánc) objektumok rjust() metódusát, ami a megadott karakterláncot jobbra igazítja, majd a megadott szélességig feltölti üres karakterekkel a baloldalt. Ehhez hasonlóak a ljust() és a center() függvények. Ezek írási m˝ uveletet nem végeznek, egyszer˝ uen visszatérnek az új karakterlánccal. Ha a bemenetkén bemenetkéntt megadott megadott szöveg túl hosszú, azt nem csonkolják csonkolják – változatlanul változatlanul adják adják vissza az eredeti karakterláncot. karakterláncot. Ez elrontja ugyan a kimenet kimenet rendezettségét, rendezettségét, de rendszerint rendszerint jobb, mintha a függvény függvény valótlan (csonkított) (csonkított) értékkel térne vissza. vissza. (Ha valóban szeletelni szeletelni akarod a karakterlán karakterláncot, cot, ezt így tudod megtenni: megtenni: ‘x.ljust( x.ljust( n)[:n] n)[:n]’.) Létezik egy másik metódus, a zfill(), amely az adott numerikus num erikus karakterláncot balról nulla karakterekkel tölti ˝ fel. Ez könnyen megérthet ˝ megérthet o a plusz és minusz jelek esetében: >>> ’12’.zfill( ’12’.zfill(5) 5) ’00012’ >>> ’-3.14’.zfi ’-3.14’.zfill(7) ll(7) ’-003.14’ >>> ’3.14159265359’.zfill(5) ’3.14159265359’
A % operátort használata így néz ki: >>> import import math math ˝ >>> print print ’PI értéke értéke megköz megközelí elít toleg oleg %5.3f. %5.3f.’ ’ % math.p math.pi i ˝ PI értéke értéke megközelít megközelít˝ oleg oleg 3.142.
Ha a karakterláncban egynél több formázást szeretnél használni, akkor az alábbi példát követve egy tuple változót
kell paraméterként használnod: >>> table table = {’Sjoe {’Sjoerd’ rd’: : 4127, 4127, ’Jack’ ’Jack’: : 4098, 4098, ’Dcab’ ’Dcab’: : 7678} 7678} >>> for name, name, phone phone in table. table.ite items( ms(): ): ... ... prin print t ’%’%-10 10s s ==> ==> %10d %10d’ ’ % (na (name me, , pho phone ne) ) ... Jack ==> 4098 Dcab ==> 7678 Sjoerd ==> 4127
A legtöbb formázás pontosan ugyanúgy m˝ uködik, mint C-ben, és a megfelel ˝ megfelel ˝ o típusú változó átadását igényli. Ha kivétel váltódik ki, és azt a kódodban nem kapod el, ???not a core dump???. A %s formázás ennél rugalmasabb: ha a csatolt paraméter nem egy karakterlánc, akkor a str() beépített függvény használatáv használatával al automatikusa automatikusann azzá konvertál konvertálja. ja. A * használata használata a szélesség, szélesség, vagy a pontosság meghatározá meghatározására sára egy külön paraméterként (integer) lehetséges. A következ ˝ következ ˝ o C formázások nem támogatottak: %n, %p. Ha egy nagyon hosszú formázott karakterláncot szeretnél használni, amit nem akarsz darabokra felosztani, szép lenne, ha hivatkozni tudnál a formázandó változókra azok neveivel, pozíciójuk helyett. Ezt a %(name)format forma használatával teheted meg, például így:
>>> table table = {’Bea’ {’Bea’: : 1975, 1975, ’Balaz ’Balazs’: s’: 1978, ’Fanni ’Fanni’: ’: 2003} 2003} >>> print print ’Fanni ’Fanni: : %(Fann %(Fanni)d i)d; ; Bea: Bea: %(Bea) %(Bea)d; d; Balazs Balazs: : %(Bala %(Balazs) zs)d’ d’ % table table Fanni: Fanni: 2003; 2003; Bea: Bea: 1975; 1975; Balazs Balazs: : 1978 1978
Ez különösen hasznos az új vars() függvénnyel együtt, amely egy szótár típusú változóval tér vissza, amely az összes helyi változót tartalmazza.
Az open() függvé függvény ny egy object object objekt objektumm ummal al tér vissza vissza,, és rendsz rendszeri erint nt két paramét paraméterr errel el haszná használju ljuk: k: ‘open( filename, mode)’. >>> f=open(’/tm f=open(’/tmp/mun p/munkafile kafile’, ’, ’w’) >>> >>> prin print t f 0>
˝ Az els ˝ els ˝ o paraméter egy fájlnevet fájlnevet tartalmazó karakterlánc. A második paraméter néhány karakterb karakterb ˝ ol áll csupán, és a fájl használatána használatánakk a módját (írás, (írás, olvasás) olvasás) állíthatjuk állíthatjuk be vele. A megnyitás megnyitás módja ( mode) lehet ’r’ mikor csak olvassuk a fájlt – ’w’, ha kizárólag írni szerenténk (a már esetleg ugyanezen néven létez ˝ létez ˝ o fájl tartalma törl ˝ törl ˝ odik!) – és ’a’, amikor hozzáf hozzáf uzés ˝ céljából nyitjuk meg a fájlt; ilyenkor bármilyen adat, amit a fájlba írunk, ˝ automatikusan hozzáf˝ uz ˝ uzodik annak annak a végéhez végéhez.. A ’r+’ megnyitási mód egyszerre nyitja meg a fájlt írásra és olvasásra. A mode paraméter beállítása nem kötelez ˝ kötelez ˝ o; elhagyása esetén ’r’ alapértelmezett értéket vesz fel. Window Windowss és Macintosh Macintosh rendszereke rendszerekenn a megny megnyitási itási módhozhozzá módhoz hozzáf˝ f˝ uzött ’b’ karakterrel karakterrel bináris bináris módbannyith módban nyithatjuk atjuk meg a fájlt, például így: ’rb’, ’wb’ vagy ’r+b’. A Windows megkülönbözteti a szöveges és bináris fájlokat; a szöveges fájlban a sorvéget jelz ˝ jelz ˝ o karakterek (end-of-line) (end-of-line) kis mértékban automatiku automatikusan san megváltozna megváltoznakk adat írása vagy olvasása esetén. Ez a háttérben zajló módosítás ugyan megfelel ˝ megfelel ˝ o az ASCII szöveges fájlok számára, de a bináris fájlokat használhatatlan nálhatatlanná ná teszi teszi (pl. ‘ ’ vagy ‘ ’ fájlokat). Ezért nagyon figyelj figyelj oda, hogy a bináris bináris módot használd olvasásko olvasáskorr és íráskor. íráskor. (Megjegyezz (Megjegyezzük, ük, hogy Macintosh-on a használt C könyvtártól könyvtártól függ a megnyitási megnyitási módok pontos m˝ uködése.
A fejezet további példái feltételezik, hogy már létezik az
f fájl objektum.
A fájl tartalmának olvasásához hívd meg az f.read(size) metódust, ami a megadott adatmennyiségnek megfelel ˝ felel ˝ o hossszúságú karakterlánccal tér vissza. A size egy opcionális paraméter – elhagyása, vagy negatív értéke esetén a teljes tartalmat visszaadja a metódus – ha esetleg a fájl kétszer akkora, mint a gépedben lév ˝ lév ˝ o memória, az esetleg problémát jelenthet neked. Ha használod a size paramétert, akkor a visszatérési értékként kapott karakterlánc hosszát maximalizálni tudod. Ha eléred a fájl végét, az f.read() egy üres karakterlánccal tér vissza ( ""). >>> f.read() f.read() ’Ez a fájl fájl teljes teljes tartal tartalma. ma.\n’ \n’ >>> f.read() f.read() ’’
A f.readline() egy sort olvas olvas ki a fájlból. A sor végét az újsor karakter karakter ( \n) jelenti, jelenti, amely a beolvasott beolvasott karakterlánc végén található. Ez a karakter egyetlen esetben maradhat ki a visszaadott karakterlácból: ha a fájl utolsó sorát olvassuk be, és az nem újsor karakterre végz ˝ végz ˝ odik. Ez a visszatérés visszatérésii értéket értéket egyértelm egyértelm uvé ˝ teszi: ha a f.readline() metódus üres karakterlánccal tér vissza, az olvasás olvasás elérte elérte a fájl végét. Ekkor az üres üres sort a ’\n’ karakter jelképezi – a karakterlánc egyetlen egy újsor karaktert tartalmaz. >>> f.readline( f.readline() ) ˝ sora.\ ’Ez ’Ez a fájl fájl els elso sora.\n’ n’ >>> f.readline( f.readline() ) ’A fájl fájl másodi második k sora.\ sora.\n’ n’ >>> f.readline( f.readline() ) ’’
A f.readlines() metódus metódus egy listával listával tér vissza, amely a fájl minden sorát tartalmazza tartalmazza.. Ha megadjuk a o sizehint paramétert, a metódus a megadott számú byte-ot kiolvassa a fájlból, és még annyit, amennyi a következ ˝ újsor karakterig karakterig tart. (A fordító megjegyzése: megjegyzése: sizehint paramétert hiába adtam meg, 2.1-es pythont használva a teljes fájltartalmat kiolvasta.) >>> f.readlines f.readlines() () ˝ sora.\ [’Ez [’Ez a fájl fájl els elso sora.\n’, n’, ’Ez pedig pedig a másodi második\n k\n’] ’]
A f.write(string) metódus a string tartalmát a fájlba írja, és
None értékkel tér vissza.
>>> f.write(’Te f.write(’Tesztsz sztszöveg, öveg, az írás bemutatásár bemutatására\n’) a\n’)
Ha egy karakterlánctól eltér ˝ eltér ˝ o típusú változót szeretnénk kiírni, akkor azt el ˝ el ˝ obb karakterlánccá kell konvertálni: >>> >>> valu value e = (’a (’a vala valasz sz’, ’, 42) 42) >>> >>> s = str( str(va valu lue) e) >>> f.write(s) f.write(s)
Ford.: Ha megnézzük a keletkezett fájl tartalmát, az
(’a valas valasz’, z’, 42) lesz.
Az f.tell() metódussal a fájl objektum aktuális pozícióját kérdezhetjük le – bájt-ban, a fájl kezdetét ˝ ol számolva. (pl.: hányadik bájt-ot olvassuk most éppen)
A fájl objektum pozíciójának (a kurzornak) a megváltoztatásának módja: ‘ f.seek(léptetés, innen_kezdve)’. Az innen_kezdve ponttól léptetés mennyiséggel mozgatjuk a kurzort. (Példa: ha van egy 100 bájtos fájl, amiben éppen a 39. karakternél állunk, akkor az aktuális pozícióhoz képest ugorhatunk tovább, megadott lépésekben) A from_what value of 0 measures from the beginning of the file, 1 uses the current file position, and 2 uses the end of the file as the reference point. from_what can be omitted and defaults to 0, using the beginning of the file as the reference point. Az innen_kezdve paraméter a következ ˝ következ ˝ o értékeket veheti fel: • 0: a fájl eleje lesz a hivatkozási pont • 1: az aktuális pozíció lesz a hivatkozási pont • 2: a fájl vége az aktuális hivatkozási pont
>>> >>> >>> >>> >>> ’5’ >>> >>> ’d’
f = open(’ open(’/tm /tmp/m p/munk unkafa afajl’ jl’, , ’r+’) ’r+’) f.write(’0123456789abcdef’) f.s f.see eek( k(5) 5) # Ugo Ugorj rj a 6. 6. baj bajth thoz oz a faj fajlb lban an f.read(1) f.read(1) f.seek f.seek(-3 (-3, , 2) # Ugorj Ugorj a fajl fajl vegehe vegehez z kepest kepest harom harom karakt karakterr errel el vissza vissza f.read(1) f.read(1)
Ha már minden módosítást elvégeztél a fájl-al, hívd meg a f.close() metódust a fájl bezárásához (a rendszerer ˝ rer ˝ oforrások felszabadításához). A f.close() hívása után a fájl objektum használatára tett kísérletek automatikusan meghiúsulnak. >>> f.close() f.close() >>> f.read() f.read() Traceb Traceback ack (most (most recent recent call call last): last): File File " n>", ", line line 1, in ? ValueE ValueErro rror: r: I/O operat operation ion on closed closed file file
A fájl objektumoknak van néhány kiegészít ˝ kiegészít ˝ o metódusuk, például az isatty() és a truncate() – ezek ritkábban használtak. A Referencia könyvtárban teljes útmutatót találsz a fájl objektumok használatához. pickle
A karakterlánco karakterláncokat kat könny˝ u fájlba írni és onnan kiolvasni. A számokkal kicsit nehezebb a helyzet, mert a read() metódus mindent karakterként ad vissza, amit aztán át a számmá történ ˝ o átalakítás miatt például az int() függvénynek kell átadnunk, ami a ’123’ karakterláncból a 123-as értéket adja vissza. Hogyha összetettebb adattípusokat akarsz menteni, például listákat, szótárakat vagy osztály-példányokat, egyre bonyolultabbá válik a dolgod. Ahelyett, hogy a felhasználóknak állandóan adatment ˝ adatment ˝ o algoritmusokat kelljen írnia és javítania, a Python rendelkezik a pickle modullal. modullal. Ez egy elképeszt elképeszt ˝ o modul, ami képes a legtöbb Python objektumot karakterláncként ábrázolni. (even some forms of Python code!???) Ezt a folyamatot pickling-nek hívják. Az objektum karakterláncból történ ˝ történ ˝ o létrehozását pedig unpickling-nek nevezik. A karakterlánccá történ ˝ történ ˝ o konvertálás és a visszakonvertálás visszakonvertálás között a karakterlánc jelképezi jelképezi az objektumot. Ezt akár fájlban, akár más formában tárolhatjuk. (hálózaton elküldve másik gépen, vagy adatbázisban) Ha van egy x objektumod, objektumod, és létezik létezik az írásra megnyitott megnyitott tárolására a következ ˝ következ ˝ o egysoros kód:
f
fájl objektum, a legegyszer˝ ubb út az objektumod
pickle.dump pickle.dump(x, (x, f)
Ha újból el ˝ el ˝ o kívánod állítani az objektumot, és az
f egy olvasásra megnyitott fájl objektum:
x = pickle pickle.lo .load( ad(f) f)
(Vannak (Vannak más variáció variációii is ennek, amik több több objektum objektum tárolásánál tárolásánál / újbóli újbóli el ˝ el ˝ oállításánál használatosak, illetve akkor, ha nem akarod a tárolási formába alakított objektumodat ténylegesen fájlba írni; a téma teljes dokumentációja: pickle a Python Library Reference-ben.) A pickle a szabályos módja a Python objektumok készítésének, amiket tárolhatsz, vagy újra felhasználhatsz más programokkal, vagy akár a jöv ˝ jöv ˝ obeni felhasználás céljából a jelenlegi programoddal. Ennek a technikai megnevezése: persistent objektumok objektumok (állandó, (állandó, tartós). tartós). Azért, Azért, mert a pickle széles széles körben elterjedt, elterjedt, a legtöbb legtöbb Python kiegészítést készít ˝ készít ˝ o programozó figyelmeztet, hogy bizonyosodj meg arról, hogy az új adattípusok tárolhatók és újra el ˝ el ˝ oállíthatók (mintha egy matricát leragasztanál, majd újra felvennéd).
8. fejezet
Hibák és kivételek Eddig csak említettük a hibajelzéseket, de ha kipróbáltad a példákat feltehet ˝ oen láttál néhányat. Kétfajta megkülönböztetend ˝ lönböztetend ˝ o hibafajta van (legalább): szintaktikai hiba (syntax error) és kivétel (exception) .
A szintaktikai hibák, vagy másképp elemzési hibák, hib ák, talán a leggyakoribb hibaüzenetek, amíg tanulod a Pythont: >>> >>> whil while e 1 prin print t ’Hel ’Hello lo vilá világ’ g’ File File "" n>", , line line 1 while while 1 print print ’Hello ’Hello világ’ világ’ ^ SyntaxError SyntaxError: : invalid invalid syntax
Az elemz ˝ elemz ˝ o megismétli a hibás sort, és kitesz egy kis „nyilat” amely a sorban el ˝ el ˝ oforduló legels ˝ legels ˝ onek észlelt hibára mutat. A hibát a nyilat megel˝ értelemez ˝ o): a példában, példában, ozo˝ szócska (token) okozza (vagy legalábbis itt észlelte az értelemez ˝ a hibát a print utasításnál észlelte, mivel a kett ˝ kett ˝ ospont (‘:’) hiányzik el ˝ el ˝ ole. A fájl neve és és a sorszám kiíródik, kiíródik, így tudhatod, hol keressed, ha egy szkriptet futtattál.
Ha egy állítás állítás vagy kifejezés kifejezés szintaktikaila szintaktikailagg helyes, akkor is okozhat okozhat hibát, ha megpróbáljuk megpróbáljuk végrehajtani. végrehajtani. A végrehajtás során észlelt hibákat kivételeknek (execptions) nevezzük és nem feltétlenül végzetesek: nemsokára megtanulod, hogyan kezeld ezeket a Python programban. A legtöbb kivételt általában nem kezelik a programok, ekkor az alábbiakhoz hasonló hibaüzeneteket adnak: >>> >>> 10 * (1/0 (1/0) ) Traceb Traceback ack (most (most recent recent call call last): last): File File "" n>", , line line 1 ZeroDivisio ZeroDivisionError nError: : integer integer division division or modulo >>> >>> 4 + spam spam*3 *3 Traceb Traceback ack (most (most recent recent call call last): last): File File "" n>", , line line 1 NameError: NameError: spam >>> ’2’ + 2 Traceb Traceback ack (most (most recent recent call call last): last): File File "" n>", , line line 1 TypeEr TypeError ror: : illega illegal l argume argument nt type type for builtbuilt-in in operat operation ion
˝ A hibaüzenetek hibaüzenetek utolsó sora mutatja, mutatja, mi történt. történt. Különböz Különböz ˝ o típusú kivételeket kaphatunk, és a típus az üzenet részeként kerül kiíratásra: a típusok a példákban: ZeroDivisionError (nullával való osztás), NameError (név hiba) és TypeError (típussal kapcsolatos hiba). A kivétel típusaként kiírt szöveg a fellép ˝ fellép ˝ o kivétel bels ˝ bels ˝ o (built-in) (built-in) neve. neve. Ez minden bels ˝ bels ˝ o kivételre igaz, de nem feltétlenül igaz a felhasználó által definiált kivételekre (habár ez egy hasznos megállapodás). A szokásos kivételnevek kivételnevek bels ˝ bels ˝ o azonosítók (nem fenntartott kulcsszavak). ku lcsszavak). A sor fennmaradó része egy részletezés, amelynek alakja a kivétel fajtájától függ. Az ezt megel ˝ megel ˝ oz ˝ oz ˝ o része a hibaüzenet hibaüzenetnek nek megmutatja megmutatja a szövegkörnye szövegkörnyezetet zetet – ahol a kivétel kivétel történt – egy veremvisszakövetés (stack backtrace) formájában. Általában ez veremvisszakövetést tartalamazza egy listában a forrás sorait. jóllehet, ez nem fog megjeleníteni a sztenderd bementer ˝ ol kapott sorokat. A Python Library Reference felsorolja a bels ˝ bels ˝ o kivételeket és a jelentéseiket.
˝ Van rá lehet lehet ˝ oség, oség, hogy hogy olyan olyan program programoka okatt írjunk, írjunk, amik amik kezeli kezelikk a különbö különbözz ˝ o kivételek kivételeket et (exception). (exception). Nézzük Nézzük csak a következ ˝ következ ˝ o példát, amely addig kérdezi a felhasználótól az értéket amíg egy egész számot nem ír be, de megengedi a felhasználónak, hogy megszakítsa a program futását (a Control-C használatá használatával, val, vagy amit az operációs operációs rendszer rendszer támogat). Jegyezzük Jegyezzük meg, hogy a felhasználó felhasználó által létrehozott létrehozott megszakítás megszakítás KeyboardInterrupt kivételként lép fel. >>> >>> whil while e 1: ... try: ... x = int(raw_input("Írj be egy számot: ")) ... bre ak ... except ValueError: ... print "Ez nem egész szám. Próbáld újra... " ...
A try utasítás a következ ˝ következ ˝ okép oképpe penn m˝ uködik. • El ˝ El ˝ oször a try mellékág hajtódik végre, azaz a try és except közötti utasítások. • Ha nem lép fel kivétel, az except ágat a program átugorja, és a
befejez ˝ odik. try utasítás befejez ˝
• Ha kivétel lép fel a try ág végrehajtása során, az ág maradék része nem hajtódik végre. Ekkor – ha a típusa megegyezik az except kulcsszó után megnevezett kivétellel, ez az expect ág hajtódik végre, és ezután a végrehajtás a try–except blokk után folytatódik. • Ha olyan kivétel lép fel, amely nem egyezik a az expect expect ágban megnevezett megnevezett utasítássa utasítással,l, akkor a kivételt kivételt átadja egy küls ˝ küls ˝ obb try utasításnak. utasításnak. Ha nincs kezelve kezelve a kivétel, kivétel, akkor ez egy kezeletlen kivétel a futás megáll egy utasítással, ahogy korábban láttuk. A try utasításnak lehet egynél több except ága is, hogy a különböz ˝ különböz ˝ o kivételek kivételeket et kezelhessük kezelhessük.. Egynél több több kezel ˝ kezel ˝ o hajtódha hajtódhatt végre. végre. A kezel kezel ˝ ok csak a hozzájuk tartozó try ágban fellép ˝ fellép ˝ o kivételt kezelik a try utasítás másik kezel ˝ kezel ˝ ojében fellép ˝ fellép ˝ o kivételt nem. Egy expect ágat több névvel is illethetünk egy kerek zárójelbe tett lista segítségével, például: ... except except (RuntimeErr (RuntimeError, or, TypeError, TypeError, NameError): NameError): ... pass
(Magyarul: Futásidej˝ u hiba, TípusHiba, NévHiba) Az utolsó expect ág esetén elhagyható a kivétel neve. Rendkívül óvatosan használjuk, mert elfedhet valódi programozási hibákat! Arra is használható, hogy kiírjunk egy hibaüzenetet, majd újra kivételdobást hajtsunk végre, (megengedve a hívónak, hogy lekezelje a kivételt):
import import string string, , sys try: f = open(’file. open(’file.txt’) txt’) s = f.read f.readlin line() e() i = int(string. int(string.strip( strip(s)) s)) except except IOError, IOError, (errno, (errno, strerror): strerror): print print "I/O "I/O error( error(%s) %s): : %s" % (errno (errno, , strerr strerror) or) except except ValueError: ValueError: print print "Nem "Nem képes képes az adatot adatot egész egész számmá számmá alakít alakítani ani." ." except: print "Váratlan "Váratlan hiba:", hiba:", sys.exc_info sys.exc_info()[0] ()[0] raise
A try . . . except utasításnak lehet egy else ága is, amelyet – ha létezik – az összes except ágnak meg kell el ˝ el ˝ oznie. oznie. Ez nagyon hasznos olyan kódokban, amelyeknek amelyeknek mindenképpen mindenképpen végre végre kell hajtódniuk, hajtódniuk, ha a try ágban nem lép fel kivétel. Például: for arg in sys.ar sys.argv[ gv[1:] 1:]: : try: f = open open(a (arg rg, , ’r’) ’r’) except except IOError: IOError: print print ’nem ’nem nyitha nyitható tó meg’, meg’, arg else: print arg, len(f.readl len(f.readlines( ines()), )), ’sorból ’sorból áll.’ f.close()
Az else ág használata jobb, mintha a kódot a try ághoz adnánk, mivel ez elkerüli egy olyan kivétel elkapását, amely nem a try . . . except utasítások által védett ágban vannak. Ha kivétel lép fel, lehetnek hozzátartozó értékei, amelyeket a kivétel argumentumának is nevezünk. A megléte és a típusa a kivétel fajtájától is függ. Azokra a kivételtípusokra, amelyek argumentummal rendelkeznek, az except ág el ˝ el ˝ oírhat egy változót a kivétel neve neve (vagy a lista) után, amely felveszi felveszi az argumentum értékét, ahogy itt látható: >>> try: try: ... spam() ... except except NameEr NameError ror, , x: ... ... prin print t ’A(z ’A(z)’ )’, , x, ’név ’név ninc nincs s defi defini niál álva va.’ .’ ... A(z) A(z) spam spam név nincs nincs defini definiálv álva. a.
Ha a kivételnek argumentuma van, az mindíg utolsó részeként kerül a képerny ˝ képerny ˝ ore. A kivételkezel ˝ kivételkezel ˝ ok nem csak akkor kezelik a kivételeket, ha azok ténylegesen a try ágban szerepelnek, hanem akkor is, ha azok valamelyik try ágban meghívott meghívott függvényben szerepelnek (akár közvetve is). Például: >>> def ez_ros ez_rossz( sz(): ): ... x = 1 /0 ... >>> try: try: ... ez_ros sz() ... except except ZeroDivisio ZeroDivisionError nError, , detail: detail: ... ... prin print t ’Ha ’Hand ndli ling ng runrun-ti time me erro error: r:’, ’, deta detail il ... Handli Handling ng run-ti run-time me error: error: intege integer r divisi division on or modulo modulo
A raise utasítás lehet ˝ lehet ˝ ové teszi a programozó számára, hogy egy új, általa megadott kivételt hozzon létre. Például: >>> raise NameError, NameError, ’IttVagyok’ ’IttVagyok’ Traceb Traceback ack (most (most recent recent call call last): last): File File "" n>", , line line 1 NameError: NameError: IttVagyok IttVagyok
A raise els ˝ els ˝ o argumentuma argumentuma a kivétel kivétel neve amit létrehozunk. létrehozunk. Az esetleges esetleges második argumentum argumentum adja meg a kivétel argumentumát.
A programok elnevezhetik a saját kivételeiket, ha karakterláncot rendelnek egy változóhoz, vagy egy új kivételosztályt hoznak létre. Például: >>> class class MyErro MyError: r: ... ... def def __in __init it__ __(s (sel elf, f, valu value) e): : ... self.value = value ... def __str__(self): ... return ‘self.value‘ ... >>> try: try: ... raise MyError(2*2) ... except except MyErro MyError, r, e: ... ... prin print t ’A kivé kivéte tele lem m fell fellép épet ett, t, érté értéke ke:’ :’, , e.v e.val alue ue ... A kivéte kivételem lem fellép fellépett ett, , értéke értéke: : 4 >>> raise raise MyErro MyError, r, 1 Traceb Traceback ack (most (most recent recent call call last): last): File File "" n>", , line line 1 __main__.My __main__.MyError: Error: 1
Sok – a Pythonban megtalálható – modul ezt használja a függvényekben el ˝ el ˝ oforduló esetleges hibák megjelenítésére. B ˝ ovebb információ az osztályokról a 9 fejezetben található.
A try utasításnak van egy másik opcionális ága, mely takarító-rendberakó m ˝ uveletek tárolására szolgál – ezeket a megel ˝ megel ˝ oz ˝ oz ˝ o ágak lefutása után kell végrehajtani. Például:
>>> try: try: ... ... rais raise e Keyb Keyboa oard rdIn Inte terr rrup upt t ... finally: finally: ... ... prin print t ’Vis ’Viszl zlát át vilá világ! g!’ ’ ... Viszlát Viszlát világ! Traceb Traceback ack (most (most recent recent call call last): last): File File "" n>", , line line 2 KeyboardInterrupt
A végs˝ o záradék akár kivételdobás történt a try záradékban, akár nem – mindenképpen végrehajtódik. Ha kivételdobás vételdobás történt, a kivétel kivétel a finally záradék záradék végrehajtása végrehajtása után újra kiváltódik kiváltódik.. A finally – a kivételdo kivételdobás bás utószeleként, lefutása végeként – hajtódik végre, amikor a try utasítás elhagyja a break vagy a return utasítást. (Fontos: (Fontos: függvényeknél függvényeknél ha nem helyezün helyezünkk el return utasítást, akkor rejtetten egy return return None utasítás fut le – tehát ha nem látunk egy utasítást, az esetleg rejtetten akkor is lefuthat!) A try utasítás vagy except záradékok(at) tartalmazhat, vagy egy finally záradékot, de a kett ˝ ot együtt nem.
9. fejezet
Osztályok A Python osztálymecha osztálymechanizmus nizmusaa osztályokat osztályokat ad a nyelvhez nyelvhez a lehet ˝ lehet ˝ o legkevesebb szintaxissal és szemantikával. ++ A Python osztályok a C és a Modula-3 –ban található osztálymechanizmusok keveréke. Ahogy a modulokra is igaz, az osztályokban a Python nem határolja el élesen a definíciót és a felhasználót: megbízik a felhasználó ítél ˝ ítél ˝ oképességében, hogy nem akar a "mindent definiálni fogok" hibájába esni. Az osztályok legfontosabb tulajdonságai teljes egészében megmaradnak: az örökl ˝ odési mechanizmus lehet ˝ lehet ˝ ové ˝ ˝ teszi a több ost ˝ ost ol való származtatást; a származtatott osztályok a szül ˝ szül ˝ ok bármely metódusát felül tudják írni; a ˝ metódusok ugyanazon a néven érhetik el a szül ˝ szül ˝ oosztály oosztály metódusait. metódusait. Az objektumok tetsz tetsz ˝ oleges számú egyéni adatot tartalmazhatnak. C++ szóhasználattal élve az osztály minden eleme (beleértve az adatokat is) publikus, és minden tagfüggvény virNincsenek konstruktor konstruktor és destruktor destruktor függvények. függvények. A Modula-3 Modula-3 –hoz hasonlóan hasonlóan nincsen nincsen rövidített rövidített hivatkoz hivatkozás ás tuális. Nincsenek az objektum alkotóelemeire annak metódusaiból: az objektum függvényeinek deklarálásakor els ˝ o paraméterként az objektumot jelképez ˝ jelképez ˝ o változót adjuk át, melynek értéke értelemszer˝ uen objektumonké objektumonként nt változik. változik. A Smalltalk-hoz hasonlóan az osztályok önmaguk is objektumok, a szó tágabb értelmében, mert a Pythonban minden adattípus objektum. Ez biztosítja a szó felismerését importáláshoz és átnevezéshez A C++-tól és a Modula-3 -tól eltér ˝ eltér ˝ oen a beépített beépített típusok szül ˝ szül ˝ oosztályokké oosztályokként nt felhasználha felhasználhatók. tók. S végül a C ++hoz hasonlóan, de a Modula-3 Modula-3 –tól eltér ˝ eltér ˝ oen a legtöbb, egyéni szintaktikával bíró beépített operátor (aritmetikai muveletek, ˝ alprogramok (???: metódusokra gondol?) , stb.) újradefiniálhatók az osztály példányaiban.
Nem lévén általánosan elfogadott szóhasználat az osztályok témakörére, alkalmanként Smalltalk és C ++ kifejezéseket fogok használni. (Szerettem volna Modula-3 kifejezéseket alkalmazni, mert annak hasonlít leginkább az objektum-orientáció értelmezése a Pythonhoz, de sajnos nagyon kevesen kevesen ismerik ezt a nyelvet.) Szeretnélek figyelmeztetni a szóhasználatban rejl ˝ rejl ˝ o csapdára: A Pythonban az objektum szó nem feltétlenül feltétlenül egy ++ osztály példányát jelenti. A C -hoz és a Modula-3 -hoz hasonlóan, de a Smalltalk-tól eltér ˝ eltér ˝ oen nem minden típus ˝ osztály: osztály: az alapvet alapvet ˝ o beépít beépített ett típuso típusok, k, példáu példáull az egész egész számok számok és a listá listákk (integ (integer er,, list) list) nem azok, azok, és néhán néhányy eléggé eléggé egzotikus típus sem az. (Például a file-ok.) file-ok.) Akárhogy is, minden Python típus osztozik az általános jelölésen, amit a legérthet ˝ legérthet ˝ obben az objektum kifejezés közelít meg. Az objektumoknak egyéni jellege van, és többszörösen is el lehet nevezni ugyanazt az objektumot (különböz ˝ o névterekben). Ez a lehet ˝ lehet ˝ oség fed ˝ fed ˝ onévként onévként (aliasing) (aliasing) ismert más nyelvekben. nyelvekben. Ezt a lehet ˝ lehet ˝ oséget a nyelvvel való els ˝ els ˝ o találkozáskor rendszerint nem becsülik meg – egyébként a fed ˝ fed ˝ onév használata nyugodtan mell ˝ mell ˝ ozhet ˝ ozhet ˝ o megváltoztathatatlan típusok használatakor (például számok, karakterláncok, tuple-ek esetében). Ugyanakkor a fed ˝ fed ˝ onév használata szándékosan része a Python nyelvtanának a megváltoztatható típusok esetében, mint például a listák, szótárak – és a legtöbb, programon kívüli entitást jelképez ˝ jelképez ˝ o típus esetében (file-ok, ablakok, stb.). stb.). A fed ˝ fed ˝ onevek általában a program hasznára válnak, különösen amióta a mutatókhoz hasonlítanak néhány vonatkozásban. Például egy objektum átadása kevés er ˝ er ˝ oforrásfelhasználással jár, mióta csak egy mutató (az ob-
jektumra) kerül átadásra a végrehajtás során. Ha a meghívott funkció módosítja a neki átadott objektumot, a hívó látja a változást – ez szükségtelenné teszi két különböz ˝ különböz ˝ o paraméter átadását ( mint például a Pascal-ban). (nincs szükség visszatérési értékre a meghívott függvényb ˝ függvényb ˝ ol, mert a megváltoztatott objektum közvetlenül elérhet ˝ elérhet ˝ oa hívó névteréb ˝ névteréb ˝ ol. A fordító megjegyzése)
Miel ˝ Miel ˝ ott megismerkednénk az osztályokkal, beszélnünk kell a hatókörökr ˝ hatókörökr ˝ ol. Az osztálydefiníciók néhány ügyes trükköt adnak el ˝ el ˝ o a névterekkel, és neked ismerned kell a névterek és hatókörök m˝ uködését ahhoz, hogy teljesen átlásd, mi is történik. történik. Egyébként Egyébként ennek a témakörnek témakörnek az ismerete minden haladó Python programozóna programozónakk a hasznára válik. Kezdetnek nézzünk meg néhány definíciót. A névtér a neveket objektumokra képezi le. A legtöbb névtér jelenleg Python szótárakként van megvalósítva, de ez a teljesítmény kivételével normális esetben nem észlelhet ˝ észlelhet ˝ o – a jöv ˝ jöv ˝ oben ez egyébként egyébként változni változni fog. Példák Példák a névterekre: névterekre: a foglalt nevek nevek listája (függvények, (függvények, például az abs(), vagy a beépített kivételek nevei); a modulokban jelenlév ˝ jelenlév ˝ o globális nevek; vagy a helyi nevek függvényhívások során. Bizonyos értelemben egy objektum tulajdonságai is külön névteret alkotnak. Fontos tudni, hogy különböz ˝ különböz ˝ o névterekben lév ˝ lév ˝ o két név között semmilyen kapcsolat nem létezik. Például ha két különböz ˝ különböz ˝ o modul egyaránt definiálhat egy „maximum_beallitas” nev˝ u függvényt függvényt bármilyen következmény következmény nélkül, mert a modulok modulok használóinak használóinak a függvénynév függvénynév el ˝ el ˝ otagjában otagjában a modul nevével egyértelm˝ uen jelezniük kell, hogy pontosan melyik függvényt f üggvényt fogják használni. Apropó — a tulajdonság jelz ˝ jelz ˝ ot használom bármilyen névre, ami a pontot követi — például a codez.real kifejezésben a real a z objektum egyik tulajdonsága. Az igazat megvallva egy modulbeli névre névr e való hivatkozás egy tulajdonság-hivatkozás: a codemodname.funcname kifejezésbe kifejezésbenn a modname egymodu egy modull objektu objektum m és a funcname annak annak egy tulajd tulajdonsá onsága. ga. Ebben Ebben az esetbe esetbenn egyene egyeness hozzárendelés történik a modul tulajdonságai és a modulban definiált globális nevek között: ezek egy névtéren osztoznak. 1 A tulajdonságok lehetnek csak olvashatóak, vagy írhatóak is. Az utóbbi esetben értéket rendelhetünk a tulajdonsághoz – például így: így: ‘ modname. törölhet ˝ ok modname.the_ the_answ answer er = 42’. Az írható tulajdonságok a del utasítással törölhet ˝ is, például a ‘ del modname.the_answer modname.the_answer’ törli a a modname objektum the_answer tulajdonságát. ˝ A névterek különböz ˝ különböz ˝ o id ˝ id ˝ opontokban opontokban születnek, születnek, és élettartamu élettartamukk is változó. változó. Tartalmazzá artalmazzákk a Python értelmez értelmez ˝ o beépített neveit, melyek nem törölhet ˝ törölhet ˝ ok. A modulok részére részére a globális globális névtér a modul definíció olvasása olvasásakor kor jön létre – általános esetben a modul névterek az értelmez ˝ értelmez ˝ ob ˝ ob ˝ ol való kilépésig kilépésig megmaradnak. megmaradnak. Az utasítások utasítások az értelmez ˝ értelmez ˝ o fels ˝ fels ˝ o szint˝ u hívásai alapján futnak le, vagy file-ból kiolvasva, vagy az értelmez ˝ obe begépelt utasítások alapján – a __main__ modul megkülönböztetett ???considered??? részeként, ezért saját névtérrel rendelkeznek. (A beépített nevek szintén a modulban léteznek, __builtin__ név alatt.). A függvények helyi névtere a függvény hívásakor keletkezik, és a függvény lefutásakor, vagy le nem kezelt kivételek létrejöttekor sz˝ unnek meg. (Talán a felejtés szó pontosabb jelz ˝ jelz ˝ o lenne a törlés helyett.) Természetesen a rekurzív hívások mindegyike saját, helyi névtérrel rendelkezik. r endelkezik. A hatókör (scope) a Python kód azon szöveges része ahol a névtér közvetlenül elérhet ˝ elérhet ˝ o. A közvetlen elérhet ˝ elérhet ˝ oség itt azt jelenti, hogy a név a teljes elérési útjának kifejtése nélkül elérhet ˝ o a névtérben. (például a codez.real-ban a . jelzi, hogy a codez objektumhoz tartozó tulajdonságról van szó, ez itt most teljesen kifejtett.) ˝ Ámbár a névterek meghatározása statikus, dinamikusan használjuk oket. Bármikor Bármikor a program futása futása során legalább három közvetlenül közvetlenül elérhet ˝ elérhet ˝ o névtér névtér létezik: létezik: a bels ˝ bels ˝ o névtér, amiben az értelmez ˝ értelmez ˝ o el ˝ el ˝ oször keres, és helyi neveket valamint függvények neveit tartalmazza (a függvényeket mindig a legközelebbi zárt névtérben keresi az értelmez ˝ értelmez ˝ o) — a másodszor vizsgált középs ˝ középs ˝ o névtér, ami az aktuális modul globális változóinak neveit tartalmazza — valamint az utoljára vizsgált küls ˝ küls ˝ o névtér, ami a beépített neveket tárolja. ˝ Ha egyvál egy változ tozóné ónévv globál globálisa isann deklar deklarált ált,, minden minden hiva hivatko tkozásés zásés m˝ uvelet uvelet közvet közvetlen lenül ül a középs középs ˝ o névtér névtérben ben keres, keres,mer mertt ott találhatók a modul globális nevei. Fontos tudni, hogy a bels ˝ bels ˝ o névtéren kívül található nevek csak olvashatóak. 1
Kivéve Kivéve egy esetet: a modul objektumoknak van egy rejtett csak olvasható tulajdonságuk, tulajdonságuk, a __dict__ amit kiolvasva megkapjuk a modul névterében lév ˝ lév ˝ o nevek listáját listáját egy szótár típusú változóban. változóban. A __dict__ egy tulajdonság, tulajdonság, de nem egy globális globális név. Használata Használata nyilvánv nyilvánvalóan alóan megsérti a névtér-elv alkalmazásának alkalmazásának tisztaságát, és csak olyan végs ˝ o esetekben alkalmazható, mint a program-kiakadások program-kiakadások után futtatott hibakeres ˝ hibakeres ˝ ok.
Rendszerint a helyi névtér a szövegkörnyezetben található helyi változókra hivatkozik az aktuális függvényben. A függvényeken függvényeken kívül a helyi névtér a globális névtérhez névtérhez hasonlóan egyben egyben az aktuális aktuális modul névtere is. Az osztálydefiníciók pedig újabb névtereket helyeznek el a helyi névtérben. Tudatosítani kell, hogy a névterek a szövegkörnyezet által meghatározottak: a modulban definiált függvény globális névtere a modul névterében jön létre – a függvény nevei kizárólag itt elérhet ˝ ok. Másrészr ˝ Másrészr ˝ ol az aktuális aktuális nevek nevek keresése keresése még még dinamikusan, dinamikusan, futásid futásid ˝ oben oben történ történik, ik, – a nyelvi nyelvi definíc definíció ió akárme akármenny nnyireis ireis törekszik törekszik a fordításkori fordításkori,, statikus statikus névfeloldás névfeloldásra, ra, szóval szóval hosszútávo hosszútávonn ne számíts számíts a dinamikus dinamikus névfeloldásr névfeloldásra! a! (Igazság (Igazság szerint a helyi változók már statikusan meghatározottak) A Python egy különleges tulajdonsága, hogy a hozzárendelés h ozzárendelés mindig a bels ˝ bels ˝ o névtérben történik. A hozzárendelés nem másol adatokat — csak kötést hoz létre a nevek és az objektumok között. A törlésre ugyanez igaz: a ‘ del x’ utasítás eltávolítja az x kötését a helyi névtér nyilvántartásából, Valójában minden m˝ uvelet, ami új név használatát vezeti be, a helyi névteret használja – például utasítások importálása, és függvénydefiníciók modulbeli létrehozása vagy vagy kötése. A global kulcsszóval jelezheted hogy bizonyos változók a globális névtérben léteznek.
Az osztályok használatához szükségünk van valamennyi új nyelvtanra, három új objektumtípusra, és néhány új kifejezés használatára.
A legegyszer˝ ubb osztálydefin osztálydefiníció íció így néz ki: class Osztalynev: Osztalynev: . . .
Az osztálydefiníciók hasonlítanak a függvények definíciójára ( def statements) abból a szempontból, hogy az osztály deklarációjának meg kell el ˝ el ˝ oznie az els ˝ els ˝ o használato használatot.t. Osztálydefin Osztálydefiníciót íciót elhelyzehet elhelyzehetsz sz egy if utasítás valamely ágában is, vagy egy függvénybe beágyazva. A gyakorlatban az osztályokon belüli utasítások többsége általában függvénydefiníció, de bármilyen más utasítás is megengedett, és néha hasznos is — erre még kés ˝ kés ˝ obb visszatérünk. Az osztályon belüli függvényeknek egyedi argumentumli argumentumlistájuk stájuk (és hívási módjuk) módjuk) van az osztály metódusainak metódusainak hívási módja miatt — ezt szintén kés ˝ kés ˝ obb fogjuk megvizsgálni. Egy osztálydefinícióba való belépéskor új névtér jön létre és helyi névtérré válik — ebb ˝ ebb ˝ ol kifolyólag kifolyólag minden helyi helyi változóra történ ˝ történ ˝ o hivatkoz hivatkozás ás átkerül ebbe az új névtére. névtére. ???A gyakorlatban gyakorlatban általában általában az új függvénydefi függvénydefiníciók níciók kerülnek ide.??? Az osztálydefin osztálydefiníciókb íciókból ól való való normális normális kilépéskor kilépéskor egy class object objektum jön lére. Ez lényegébe lényegébenn egybefoglal egybefoglalja, ja, object objektum beburkolja az osztálydefiníciókor létrejött új névtér tartalmát – az osztályobjektumokról a következ ˝ o alfejezetben fogunk többet tanulni. Az eredeti helyi névtér (az osztálydefinícióba való belépés el ˝ otti állapotában) helyreállítódik, és az osztályobjektum neve is a helyi névtér része lesz (az Osztalynev a példában).
Az osztályob osztályobjektum jektumok ok a m˝ uveletek kétféle típusát támogatják: attribútum m˝ uveletek és a példányosítás. Az Attribútum tulajdonságok az általánosan használt Python jelölésmódot használják: objektum.attribútumnév.
Az összes név érvényes attribútumnév ami az osztály névterében volt az osztályobjektum létrehozásakor. Ha egy osztály definíció valahogy így néz ki: class Osztalyom: Osztalyom: "Egy "Egy egysze egyszeru ru pelda pelda osztal osztaly" y" i = 1234 12345 5 def f(self): f(self): return return ’hello ’hello vilag’ vilag’
akkor codeOsztalyom.i és Osztályom.f egyaránt érvényes attribútum hivatkozás – egy egész számmal és egy objektum-eljárással térnek vissza. Az osztályattribútumoknak ugyanúgy adhatunk értéket mint egy normális változónak (Osztal lév ˝ o Osztalyom yom.i .i = 2). A __doc__ eljárás is érvényes attribútum, ami az osztály definíciójában lév ˝ els ˝ els ˝ o szabad, nem hozzárendelt string-objektummal tér vissza: "Egy egyszeru egyszeru pelda pelda osztaly" osztaly" Class instantiation uses function notation. notation. Just pretend pretend that the class object object is a parameterless parameterless function function that returns a new instance of the class. For example (assuming the above class): Egy osztály példányosítása a függvények jelölésmódjához hasonló. Egyszer˝ uen úgy kell tenni, mintha az osztályobjektum egy paraméter nélküli függvény lenne, amit meghívva az osztály egy új példányát kapjuk visszatérési értékként. Például (a fenti osztályt alapul véve): x = Osztal Osztalyom yom() ()
creates a new instance of the class and assigns this object to the local variable x. készít egy új példányt az osztályból, és hozzárendeli a visszatérési értékként kapott objektumot az zóhoz.
x
helyi válto-
//::::::::::::::::::::::::::::::::::::::::::::::::::::::: // 2004. okt. 7: A példán példányos yosítá ításs m˝ uvelet uveletee (az objekt objektum um „hívás „hívása”) a”)egy egy üres üres objekt objektumothoz umothoz létre. létre. Elképze Elképzelhe lhett ˝ o, hogy hogy az új péld példán ányt yt egy ismert kezdeti állapotba állítva szeretnénk szeretnénk létrehozni. Ezt egy különleges metódussal, az __init__()-el tudjuk elérni: def __init__(se __init__(self): lf): self.d self.data ata = []
Ha az osztály definiálja az __init__() metódust, egy új egyed létrehozásakor annak __init__() metódusa automatikusan lefut. Lássunk egy példát egy új, inicializált egyedre: x = Osztal Osztalyom yom() ()
Természetesen az __init__() metódusnak paramétereket is átadhatunk. A paraméterek az osztály példányosítása során az inicializáló metódushoz jutnak. Lássunk egy példát: >>> class class Comple Complex: x: ... ... def def __in __init it__ __(s (sel elf, f, real realpa part rt, , imag imagpa part rt): ): ... self.r = realpart ... self.i = imagpart ... >>> x = Comple Complex(3 x(3.0, .0, -4.5) >>> >>> x.r, x.r, x.i x.i (3.0, -4.5)
És most mihez tudunk kezdeni kezdeni az új egyedekke egyedekkel? l? Fontos Fontos hogy tisztában tisztában legyünk az új objektumok objektumok lehetséges lehetséges alkotóelem alkotóelemeiv eivel. el. Két lehetséges lehetséges alkotóelem alkotóelem van: a bels ˝ bels ˝ o változók (adat tulajdonságok) és az ezekkel dolgozó függvények. A Pythonban használt adat tulajdonságok fogalma megegyezik a Smalltalk „példány változó” fogalmával, és a C++„adat tagok” tagok” fogalmával fogalmával.. Az adat tulajdonságo tulajdonságokat kat nem kell a használatuk használatuk el ˝ el ˝ ott deklarálni, a helyi változókhoz hasonlatosan hasonlatosan m˝ muködnek uködne ˝ k – az els ˝ els ˝ o használatukkor automatikusan létrejönnek. Például ha x az Osztalyom egy példánya, a következ ˝ következ ˝ o kódrészlet 16-ot fog kiírni: ("anélkül, hogy letérnénk az útról", Ford. javítani!) x.szam x.szamlal lalo o = 1 while while x.szam x.szamlal lalo o < 10: x.szam x.szamlal lalo o = x.szam x.szamlal lalo o * 2 print x.szamlalo x.szamlalo del x.szamlalo x.szamlalo
Fentebb már említettük, hogy az objektumnak lehetnek saját függvényei (más néven metódusai) is. Fontos hogy ezek m˝ uködését uködését is megértsük. megértsük. A metódus pontosan egy objektumhoz objektumhoz tartozó tartozó függvényt függvényt jelöl. jelöl. (A Pythonban a metódus kifejezés nem kizárólag egy osztály példányát jelenti – más objektum típusok is rendelkezhetnek metódusokkal. Például a lista objektumoknak vannak saját metódusai: append, insert, remove, sort, és így tovább. A ford. megjegyzése: valójában ezek is egy – a nyelvbe beépített osztály példányai, csak tudatosítani kell, hogy itt a Python helyettünk helyettünk elvégzi elvégzi a példányosít példányosítást, ást, és mi ennek a példánynak példánynak a metódusait metódusait használjuk. használjuk. Az alábbi sorokban sorokban a metódus kifejezést kifejezést kizárólag egy osztály metódusaira metódusaira értjük, értjük, hacsak nincs külön kihangsúlyozva, kihangsúlyozva, hogy most egy másik objektum metódusáról van szó. A létreh létrehozo ozott tt objektu objektum m metódu metódusai sainak nakne neve ve a szül szül ˝ oosztálytól oosztálytól függ. (Egy osztály osztály bels ˝ bels ˝ o elemei elemei lehetnek: lehetnek: függvénye függvényekk vagy változók) Meghatározás Meghatározás szerint minden felhasználó által definiált definiált osztályfüggvényt az adott (létez ˝ (létez ˝ o) példány nevével nevével kell kell hívni. Például Például x.f egy érvényes függvényhivatkozás, ha az Osztalyom.f függvény létezik ( x objektum az Osztalyom példánya), de x.i nem érvényes ha Osztalyom.i változót nem hoztuk létre az osztály definiálásakor. Fontos, hogy x.f nem ugyanaz, mint Osztalyom.f — ez egy Objektum metódus, nem egy függvény objektum. Fordító megjegyzése: az osztálydefiníció egy minta, ami alapján a konkrét objektumokat létrehozza létrehozza a Python. Van egy prototípus, prototípus, ami alapján alapján legyártható legyártható több példány példány - a prototípus prototípus nyilván nyilván nem ugyanaz, ugyanaz, mint a róla mintázott mintázott újabb egyedek. egyedek. Más nyelvekben nyelvekben jártas jártas programozóknak programozóknak zavaró zavaró lehet hogy a tutorial a függvényeket ugyanúgy jelöli, mint a változókat: x.f egy függvény, míg például a php-ban ezt a tényt az üres zárójelekkel külön jelölik: x.f()
Többnyire a metódusokat közvetlenül használjuk: x.f()
//::::::::::::::::::::::::::::::::::::::::::::::::::::::: // 2004. okt. 9: ’hello vilag’ vilag’ string-el tér vissza. Ezt a függfényt nem csak közvetlenül hívhatjuk meg: Példánkban x.f a ’hello ?? x.f egy objektum metódus, tárolható és kés ˝ kés ˝ obb is hívható, például így:
xf = x.f while True: print print xf() xf()
Ez a kód az örökkévalósá örökkévalóságig gig a ‘ hello hello
vilag vilag’ üzenetet írja ki.
Pontosan Pontosan mi történik történik egy objektummetódus objektummetódus hívásakor? hívásakor? Lehet, Lehet, hogy már észrevetted észrevetted hogy a x.f()-t a fenti példában paraméterek nélkül hívtuk meg - annak ellenére, hogy f függvénydefiníciója egy paraméter használatát
˝ el ˝ el ˝ oírja. Mi van ezzel a paraméterrel paraméterrel?? Szerencsére Szerencsére a Pythonban Pythonban ha egy paramétert paramétert igényl igényl ˝ o függvényt paraméter nélkül próbálunk használni, kivételdobás történik. ˝ tartalmazó Lehet hogy már kitaláltad kitaláltad a választ: választ: az a különleges különleges a metódusokban, metódusokban, hogy hívásukkor hívásukkor az oket osztálypéldányt megkapják az els ˝ els ˝ o változ változób óban an.. A példán példánkb kban an x.f() hívása hívása pontosan pontosan ugyanaz, ugyanaz, mintha metódust hívnánk. hívnánk. Ford. megjegyzé megjegyzése: se: valójában valójában a függvénynek függvénynek itt itt is jelezzük, jelezzük, hogy az Osztalyom.f(x) metódust egyedr ˝ ol van szó, a paraméter miatt. Általában metódusok hívása n paraméterrel ugyanaz, mintha az osztálydex egyedr ˝ finíció függvényét hívnánk meg úgy, hogy a legels ˝ legels ˝ o paraméter elé az aktuális példány nevét beillesztjük. Ha nem értené értenéll valam valamit it a metódu metódusok sok m˝ uködésér ˝ uködésér ˝ ol, nézz nézz meg meg kérlek kérlek néhány néhány gyakor gyakorlat latii példát példát.. Amikor Amikor egy példán példányy tulajdonságára hivatkozol, és az nem létezik a változók között, az értelmez ˝ o az osztálydefinícióban fogja keresni. Ha a név egy érvényes osztálytulajdonságra mutat, ami egy fügvény, a fenti példában szerepl ˝ o folyamat történik: az értelmez ˝ értelmez ˝ o az x.f() hívást átalakítja – a paramétereket kigy˝ ujti, majd els ˝ els ˝ o paraméterként x-et tartalmazva Osztalyom.f( m.f(x, x, paraméte paraméter1, r1, p2...) p2...) függvényt. létrehoz egy új paraméterlistát és meghívja a Osztalyo függvényt. Az adott példányban tehát a függvény valójában nem is létezik (absztrakt objektum). Az adat attribútumok felülírják az ugyanolyan nev˝ u metódusokat; a névütközések elkerülése végett (amelyek nagyon nehezen megtalálható programhibákhoz vezethetnek) érdemes betartani néhány elnevezési szabályt, melyekkel minimalizálható az ütközések esélye. Ezek a szabályok például a metódusok nagybet˝ uvel írását, az adat attribútumok kisbet˝ us írását – vagy alsóvonás karakterrel történ ˝ történ ˝ o írását jelentik; vagy igék használatát a metódu onevekét ˝ sokhoz, és f ˝ az adat attribútumokhoz. Az adat attribút attribútumokra umokra a metódusok metódusok is hivatkoz hivatkozhatna hatnak, k, éppúgy mint az objektum objektum hagyományos hagyományosfelha felhasználó sználói.i. Más szavakkal az osztályok nem használhatók csupasz absztrakt adattípusok megvalósítására. Valójában a Pythonban jelenleg semmi sincs, ami az adatrejtés elvét biztosítani tudná – minden az elnevezési konvenciókra épül. Másrészr ˝ részr ˝ ol az eredeti C alapú Python képes teljesen elrejteni a megvalósítási részleteket és ellen ˝ orizni az objetkum elérését, ha szükséges; ehhez egy C nyelven írt kiegészítést kell használni. A kliensek az adat-atribútumokat csak óvatosan használhatják, mert elronthatják azokat a variánsokat, amelyeket olyan eljárások tartanak karban, amelyek id ˝ id ˝ opont-pecsételéssel dolgoznak. Az objektum felhasználói saját adat attribútumaikat bármiféle ellen ˝ ellen ˝ orzés nélkül hozzáadhatják az objektumokhoz amíg ezzel nem okoznak névütközést — az elnevezési konvenciók használatával használatával elég sok fejfájástól megszabadulhatunk! A metódusokon belül belül nem létezik létezik rövidítés, gyors hivatkozás hivatkozás az adat attribútumokra. attribútumokra. Én úgy látom, hogy ez növeli a metódusok olvashatóságát, és nem hagy esélyt a helyi és a példányosított változók összekeverésére, mikor a metódus forráskódját olvassuk. A hagyomá hagyományokho nyokhozz h˝ uen a metódusok els ˝ els ˝ o paraméterének neve rendszerint self. Ez valóban csak egy szokás: a self névnek semmilyen speciális jelentése nincs a Pythonban. (Azért vegyük figyelembe, hogy ha eltérünk a hagyományokt hagyományoktól, ól, akkor a program nehezebben nehezebben olvashatóv olvashatóváá válik, válik, és a class browser - osztály böngész˝ o is a tradicionális változónevet használja. Az osztály definíciójában megadott függvények az osztály példányai számára hoznak létre metódusokat (a példányhoz dányhoz tartozó tartozó függvényeket függvényeket). ). Nem szükségszer˝ szükségszer˝ u azonban azonban hogy egy függvénydefiní függvénydefiníció ció kódja az osztálydefi osztálydefiníció níció része legyen: egy definíción kívüli függvény helyi változóhoz való rendelése is megfelel a célnak. Például: % # Functi Function on define defined d outsid outside e the class class # Egy osztál osztályon yon kívül kívül defini definiált ált függvé függvény ny def def f1(s f1(sel elf, f, x, y): y): return return min(x, min(x, x+y) x+y) class class C: f = f1 def g(self): g(self): return return ’hello ’hello vilag’ vilag’ h = g
Most f, g és h egyaránt C osztály attribútumai (gyakorlatilag objektum hivatkozások) — következésképpen C osztály minden példányának metódusai is— h és g pedig valójában valójában ugyanazt ugyanazt a függvényt jelenti jelentik. k. Azért ne feledjük, hogy a fenti f enti példa használata a program pr ogram olvasóját összekavarhatja! összekavarhatja! Az osztályon belüli metódusok egymást is hívhatják a
self argumentum használatával:
class Taska: Taska: def __init__(se __init__(self): lf): self.t self.tart artalo alom m = [] def belerak(sel belerak(self, f, x): self.tartalom.append(x) def belerak_ket belerak_ketszer(s szer(self, elf, x): self.belerak(x) self.belerak(x)
A metódus metódusok ok a globáli globáliss névtérben névtérben lév ˝ lév ˝ o függvényekre függvényekreis is hasonlókép hasonlóképpp hivatkoz hivatkozhatnak hatnak.. (Maguk az osztálydefin osztálydefiníciók íciók soha nem részei a globális globális névtérnek!) névtérnek!) Míg egy kivételes kivételes esetben esetben a globális globális névtér változóinak változóinak használata használata jól jöhet, több esetben is jól jöhet a globális névtér elérése: a globális névtérbe importált függvényeket és modulokat ˝ az adott osztálymetódusból is használhatjuk, mintha az adott függvényben vagy osztályban definiálták volna oket. Rendszerint az osztály az önmaga által definiált metódust a globális névtérben tartja, és a következ ˝ o részben meglátjuk majd, miért jó ha a metódusok a saját osztályukra hivatkozhatnak!
Természetesen az öröklés támogatása nélkül nem sok értelme lenne az osztályok használatának. A származtatott osztályok definíciója a következ ˝ következ ˝ oképpen oképpen néz ki: ki: class SzarmaztatottOsztalyNeve(SzuloOsztalyNeve): . . .
a SzuloOsztalyNeve névnek a származtatott osztály névterében léteznie kell. Abban az esetben, ha a szül ˝ oosztály másik modulban lett definiálva, a modulnev.szuloosztalyne modulnev.szuloosztalynevv formát is használhatjuk: % class DerivedClas DerivedClassName( sName(modna modname.Bas me.BaseClass eClassName) Name): : class SzarmaztatottOsztalyNeve(modulnev.SzuloOsztalyNev SzarmaztatottOsztalyNeve(modulnev.SzuloOsztalyNeve): e):
A származtatott osztály definíciójának feldolgozása hasonló a szül ˝ szül ˝ oosztályokéhoz — az osztályobjektum létrehozásakor a szül ˝ szül ˝ oosztály is a példány része lesz. Ha egy osztály-attribútumra hivatkozunk, és az nincs jelen az osztályban, az értelmez ˝ értelmez ˝ o a szül ˝ szül ˝ oosztályban keresi azt — és ha az szintén származtatott osztály, akkor annak a ˝ szül ˝ szülojében folytatódik a keresés, rekurzívan. A származtato származtatott tt osztályok osztályok példányosítá példányosításában sábannincs nincs semmi különleges: különleges: SzarmaztatottOsztalyNeve() létrehozza az osztály új példányát. A metódusok nyilvántartását a következ ˝ oképp oldja meg az értelmez ˝ értelmez ˝ o: el ˝ el ˝ oször az aktuális osztály megfelel ˝ megfelel ˝ o nev˝ u osztály-objektumait vizsgálja meg, majd ha nem találja a keresett metódust, elindul a szül ˝ szül ˝ oosztályok láncán. Ha a keresési folyamat eredményes, tehát valamelyik szül ˝ szül ˝ oosztályban megtalálta a keresett nev˝ u objektumot, az adott objektumnév hivatkozása érvényes lesz: a talát objektumra mutat. A származtatott osztályok felülírhatják a szül ˝ szül ˝ oosztályok oosztályok metódusait metódusait.. A metódusoknak metódusoknak nincsenek nincsenek különlekülönleges jogaik jogaik más, más, ugyana ugyanabba bbann az objektu objektumba mbann lév ˝ lév ˝ o metódu metóduso sokk hívás hívásak akor or.. A szül szül ˝ oosztály oosztály egy metódusa /a_eredeti()/, amely ugyanazon ugyanazon szül ˝ szül ˝ oosztály egy másik metódusát hívja /b(), lehet hogy nem fog m˝ u/a_uj()/, )/, ami nem hívja hívja már b()-t b()-t. (C ködni, ha a származtatott osztályból felülírják /a_uj( ( C++ programozóknak: a Pythonban minden metódus valójában virtual típusú. A származtatott osztály metódusa, amely felülírja a szül ˝ szül ˝ oosztály egy metódusát, valójában inkább kiterjeszti az eredet eredetii metódus metódust, t, és nem egyszer˝ egyszer˝ uen uen csak csak kic kicse seré réli li.. A szül szül ˝ oosztály oosztály metódusára metódusára így hivatkoz hivatkozhatunk hatunk:: ‘SzuloOsztalyNev.metod jól jöhet. jöhet. (Fontos, (Fontos, hogy ez ez csak SzuloOsztalyNev.metodusnev(self, usnev(self, paraméterek) paraméterek)’. Ez néha jól akkor m˝ uködik, ha a szül ˝ szül ˝ oosztáy a globális névtérben lett létrehozva, vagy közvetlenül beimportálva.) beimportálva.)
A python korlátozottan támogatja a többszörös öröklést is. Egy ilyen osztály definíciója a következ ˝ oképp néz ki: % class DerivedClas DerivedClassName( sName(Base1 Base1, , Base2, Base2, Base3): Base3): % class Szarmaztatot SzarmaztatottOszta tOsztalyNeve lyNeve(Szulo (Szulo1, 1, Szulo2, Szulo2, Szulo3): Szulo3): . . . %
Az egyedüli nyelvtani nyelvtani szabály szabály amit ismerni kell, az osztály attribútumok attribútumok feloldásána feloldásánakk a szabálya. szabálya. Az értelmez ˝ mez ˝ o el ˝ el ˝ oször a mélyebb mélyebb rétegekben rétegekben keres, balról jobbra. A fenti példában példában ha az attribútum nem található található meg a SzarmaztatottOsztaly-ban, akkor el ˝ el ˝ oször a Szulo1-ben keresi azt, majd rekurzívan a Szulo2-ben, és ha ott nem találja, akkor lép tovább rekurzívan a többi szül ˝ szül ˝ oosztály felé. Néhányan els ˝ els ˝ o pillanatban arra gondolnak, hogy a Szulo2 -ben és a Szulo3-ban kellene el ˝ el ˝ obb keresni, a Szulo1 el ˝ el ˝ ott — mondván hogy ez természetesebb lenne. Ez az elgondolás viszont igényli annak ismeretét, hogy mely attribútumot definiáltak a Szulo1-ben vagy annak egyik szül ˝ szül ˝ oosztályában, és csak ezután tudod elkerülni a Szulo2-ben lév ˝ lév ˝ o névütközések névütközéseket. et. A mélyebb el ˝ el ˝ oször szabály nem tesz különbséget a helyben definiált és öröklött változók között. Ezekb ˝ Ezekb ˝ ol gondolom már látszik, hogy az átgondolatlanul használt többszörös örökl ˝ örökl ˝ odés a program karbantartását rémálommá rémálommá teheti – a névütközések névütközések elkerülése elkerülése végett pedig a Python csak a konvenc konvenciókra iókra támaszkod támaszkodhat. hat. A többszörös öröklés egyik jól ismert problémája ha a gyermekosztály két szül ˝ oosztályának egy közös nagyszül ˝ nagyszül ˝ o osztálya osztálya van. van. Ugyan egyszer˝ egyszer˝ u kitalálni hogy mi történik ebben az esetben (a nagyszül ˝ o adat attribútumainak egypéldány egypéldányos os változatát változatát használja a gyermek) gyermek) – az még nem tisztázott, tisztázott, hogy ez a nyelvi nyelvi kifejezésmó kifejezésmódd minden esetben használható-e.
Egyedi azonosítók létrehozását az osztályokhoz a Python korlátozottan támogatja. Bármely azonosító, amely így néz ki: __spam (legalább két bevezet ˝ bevezet ˝ o alsóvonás, amit legfeljebb egy alsóvonás alsóvonás követhet) ??? ez bizonytalan szövegesen kicserél ˝ kicserél ˝ odik a _classname__spam formára, ahol a classname az aktuális osztály neve egy alsóvonással bevezetve. bevezetve. Ez a csere végrehajtódik az azonosító azonosító pozíciójára való tekintet nélkül, nélkül, úgyhogy használható osztály-egye osztály-egyedi di példányok, példányok, osztályvált osztályváltozók, ozók, metódusok metódusok definiálásár definiálásáraa — még akkor is, ha más osztályok osztályok páldányait páldányait saját privát változói közé veszi fel (Ford: ellen ˝ ellen ˝ orizni!) Ha a cserélt név hosszabb mint 255 karakter, az értelmez ˝ értelmez ˝ o csonkíthatja az új nevet. Küls ˝ Küls ˝ o osztályoknál, vagy ahol az osztálynév következetesen alsóvonásokból áll??? nem történik csonkítás. A névcsonkítás célja az, hogy az osztályoknak egyszer˝ u megoldást biztosítson a „private” változók és metódusok definiálására — anélkül, hogy aggódnunk kellene a származtatott osztályokban megjelen ˝ o privát változók miatt, vagy esetleg a származtatott osztályban már meglév ˝ meglév ˝ o változó privát változóval való való felülírása miatt. Fontos tudni, hogy a névcsonkítási szabályok els ˝ els ˝ osorban a problémák elkerülését célozzák meg — így még mindig leheséges annak, aki nagyon akarja, hogy elérje vagy módosítsa a privátnak tartott változókat. Ez speciális körülmények között nagyon hasznos lehet, például hibakeresésnél, hibakeresésnél, és ez az egyik egyik oka annak, hogy ezt a kibúvót még nem szüntették meg. (Buglet (Buglet (duda): (duda): származtatá származtatáss egy osztályból osztályból a szül ˝ szül ˝ oosztály nevével megegyez ˝ megegyez ˝ o néven – a szül ˝ szül ˝ oosztály privát változóinak használata ekkor lehetséges lesz.)
Fontos, hogy a exec, eval() vagy evalfile() által végrehajtott kód nem veszi figyelembe a hívó osztály nevét az aktuális osztály esetében — ez hasonló a global változók m˝ uködéséhez, el ˝ el ˝ ore lefordított byte-kód esetében. Hasonló korlátozások léteznek a getattr(), setattr() és delattr() esetében, ha közvetlenül hívják meg a __dict__ utasítást.
Alkalomadtán hasznos lehet a Pascal „record”, vagy a C „struct” adattípusaihoz hasonló szerkezetek használata – egybefogni néhány összetartozó adatot. A következ ˝ következ ˝ o üres osztálydefiníció ezt szépen megvalósítja: % class class Employ Employee: ee: class Alkalmazott: Alkalmazott: pass % john john = Empl Employ oyee ee() () # Crea Create te an empt empty y empl employ oyee ee reco record rd john john = Alkalm Alkalmazo azott( tt() ) # Egy üres üres alkalm alkalmazo azott tt rekord rekordot ot hoz létre létre % # Fill Fill the the fiel fields ds of the the reco record rd % john john.n .nam ame e = ’Joh ’John n Doe’ Doe’ % john.d john.dept ept = ’compu ’computer ter lab’ % john.s john.sala alary ry = 1000 1000 ˝ # A reko rekord rd mez˝ mezoinek oinek feltöltése feltöltése john.n john.nev ev = ’John ’John Doe’ Doe’ john.osztal john.osztaly y = ’számítógép ’számítógépes es labor’ labor’ john.f john.fize izetes tes = 1000 1000
Ez a kis kódrészlet ami egyéni adat típusokat kezel, gyakran követ adatszerkezetek tárolására való osztálydefiníciókat. Az egyes objektumpéldányo objektumpéldányokk saját tulajdonság tulajdonságokkal okkal is rendelkezne rendelkeznek: k: m.im_self az aktuális objektumpél ˝ dányra mutat ??? ezt ki kell próbálni???, pr óbálni???, m.im_func az objektumban objektumban elérhet elérhet ˝ o metódusokat tartalmazza. ??? ezt is próbáld ki
A felhasználói kivételek az osztályokban is m˝ uködnek — használatukkal egy b ˝ b ˝ ovíthet ˝ ovíthet ˝ o, hierarchikus kivételstruktúrát építhetünk fel. A raise utasításnak kétféle használati módja lehetséges: raise Osztaly, Osztaly, peldany peldany raise peldany peldany
Az els ˝ els ˝ o esetben peldany-nak az Osztaly-ból kell származnia. A második eset egy rövidítés: % raise instance.__ instance.__class_ class__, _, instance instance raise peldany.__cl peldany.__class__, ass__, peldany peldany
˝ Az except except záradé záradékba kbann lév ˝ lév ˝ o clas classs mege megegy gyez ezik ik egy egy kife kifeje jezé zésse ssell ha az ugya ugyana nazz az oszt osztál ályy vagy vagy a szül szül ˝ oosztá oosztály ly (de nem másik kerül ˝ kerül ˝ o úton — az except záradékban lév ˝ lév ˝ o származtatott osztály figyelése nem egyezik meg a szül ˝ szül ˝ oosztály figyelésével.) Például a következ ˝ következ ˝ o kód B, C, D kimenetet fog produkálni:
class class B: pass class C(B): pass class D(C): pass for for c in [B, [B, C, D]: D]: try: raise raise c() except except D: print print "D" except except C: print print "C" except except B: print print "B"
Note that if the except clauses were reversed (with ‘ except except B’ first), it would have printed B, B, B — the first matching except clause is triggered. Fontos, hogy ha az except záradékot megfordítjuk (‘ excep el ˝ oször), B, B, B lesz a kimenet — az els ˝ els ˝ o except t B’ van el ˝ except-re való illeszkedés után a többit már nem vizsgálja az értelmez ˝ értelmez ˝ o. Mikor egy kezeletlen kivétel miatt hibaüzenetet küld az értelmez ˝ értelmez ˝ o, és a hiba egy osztályból származik, a kimenet ˝ ben szerep szerepel el az osztál osztályy neve, neve, egy kett kett ˝ ospont, ospont, egy space, space, és befejezésül befejezésül a példányt példánytstring stringgé gé konvertá konvertálja lja az értelme értelmezz ˝ o a beépített str() függvénnyel.
Valószín˝ uleg már észrevetted, hogy a legtöbb tároló objektum bejárható b ejárható a
for ciklusutasítás használatával:
for for elem elemen ent t in [1, [1, 2, 3]: 3]: print element element for for elem elemen ent t in (1, (1, 2, 3): 3): print element element for key in {’one’ {’one’:1, :1, ’two’: ’two’:2}: 2}: print print key for for char char in "123 "123": ": print print char char for line in open("myfil open("myfile.txt" e.txt"): ): print print line line
A ciklus használatán használatának ak módja tiszta, tömör és kényelmes. A ciklusok ciklusok a Python egyik nyelvi nyelvi alappillérét alappillérét alkot ják. A színfalak mögött a for utasítás meghívja a iter() függvényt, amely a bejárandó objektumhoz tartozik. Ez a függvény egy ciklus objektummal tér vissza, ami meghatározza a next() metódust, metódust, amellyel amellyel az objektum elemeit lehet elérni. elérni. Ha a függvény függvény eléri az objektum utolsó elemét, elemét, és a következ ˝ következ ˝ o elemre akarunk lépni, StopIteration kivételt okozunk, amely a for ciklust megszakítja. És lássuk mindezt a gyakorlatban:
>>> >>> s = ’abc ’abc’ ’ >>> >>> it = iter iter(s (s) ) >>> >>> it 0x00A1DB50> >>> it.next() it.next() ’a’ >>> it.next() it.next() ’b’ >>> it.next() it.next() ’c’ >>> it.next() it.next() Traceb Traceback ack (most (most recent recent call call last): last): File File " #6>", ", line line 1, in -tople -toplevel velit.next() StopIteration
A ciklusok m˝ uködésébe bepillantva már könny˝ u saját bejáró eseményt készíteni egy osztályhoz. Definiálni kell az __iter__() metódust, metódust, ami a next() függvény eredményeképp létrejöv ˝ létrejöv ˝ o objektummal objektummal tér vissza. vissza. Ha az osztály definiálja a next() metódust, akkor az __iter__() egyszer˝ uen a self objektummal tér vissza: >>> class class Revers Reverse: e: "Itera "Iterator tor for loopin looping g over over a sequen sequence ce backwa backwards rds" " def __init__(se __init__(self, lf, data): self.d self.data ata = data data self.index self.index = len(data) len(data) def __iter__(se __iter__(self): lf): return self def next(self): next(self): if self self.i .ind ndex ex == 0: raise StopIterati StopIteration on self.i self.inde ndex x = self.i self.inde ndex x - 1 return self.data[self.index] >>> for char char in Revers Reverse(’ e(’spa spam’) m’): : print print char char m a p s
A generátorok egyszer˝ u és hatékony hatékony eszközök eszközök (adat)bejárók (adat)bejárók készítésére. készítésére. A normális normális függvényekhez függvényekhez hasonló hasonló a felépítésük, de használják a yield utasítást utasítást ha adatot szeretnének szeretnének visszaadni. visszaadni. A next() metódus minden hívásakor a generátor ott folytatja az adatok feldolgozását, ahol az el ˝ el ˝ oz ˝ oz ˝ o hívásakor befejezte (emlékszik minden változó értékére, és hogy melyik utasítást hajtotta végre utoljára). Lássunk egy példát arra, hogy milyen egyszer˝ u egy generátort készíteni:
>>> def reverse(dat reverse(data): a): for index index in range( range(len len(da (data) ta)-1, -1, -1, -1): -1): yield data[index] data[index] >>> for char char in revers reverse(’ e(’gol golf’) f’): : print print char char f l o g
Bármi, amit egy generátorral megtehetsz, osztály alapú bejárókkal is kivitelezhet ˝ kivitelezhet ˝ o – az el ˝ el ˝ oz ˝ oz ˝ o részben leírtak szerint. szerint. Ami a generátorokat generátorokat teljessé teljessé??? ??? teszi, teszi, hogy a __iter__() és a next() metódusok automatikusan létrejönnek. Egy másik fontos lehet ˝ lehet ˝ oség hogy a helyi változók, és a végrehajtás állapota automatikusan tárolódik a generátor két futása között. Az automatikus metódus generálás és program állapot mentés gondolatmenetét folytatva, amikor a generátor futása megszakad, ez az esemény automatikusan StopIteration kivételt vált ki. Egymással kombinálva ezek a ˝ nyelvi nyelvi szolgáltatá szolgáltatások sok egyszer˝ egyszer˝ uvé teszik teszik a bejárók bejárók készítését készítését néhán néhányy függvény függvény megírásána megírásánakk megfelel megfelel ˝ o – viszonyla viszonylagg kis er ˝ er ˝ ofeszítéssel.
10. fejezet
A Python alap-könyvtár rövid bemutatása - Standard Library 1.
Az os modul nagyon sok függvényt tartalmaz, melyek az operációs rendszerrel kommunikálnak: >>> >>> impo import rt os >>> os.sys os.system tem(’t (’time ime 0:02’ 0:02’) ) 0 >>> os.system(’ os.system(’time’ time’) ) ˝ A pont pontos os id˝ ido: o: 0:02:08,14 0:02:08,14 ˝t: Írja Írja be az új id˝ ido
# FIGYELEM FIGYELEM: : átállíto átállítottu ttuk k a rendsz rendszer er óráját óráját! !
˝ # ezt magyar XP-n próbáltam ki. új idot ot adhatu adhatunk nk meg. meg.
>>> >>> os. os.ge getc tcwd wd() () # Az Az akt aktuá uáli lis s könyv önyvtá tár r nev nevét ét adja adja viss vissza za. . ’C:\\Python24’ >>> >>> o os. s.ch chdi dir( r(’/ ’/se serv rver er/a /acc cces essl slog ogs’ s’) ) # é és s i itt tt köny könyvt vtár árar ar vált váltot ottu tunk nk. .
Fontos, hogy az importálás során az ‘ impor import t os’ alakot használd, és ne a ‘ from from os impo import rt *’ alakot. Ez megóv attól, hogy az os.open() függvény elfedje (és használhatatlanná tegye) a beépített open() függvényt, ami teljesen másképp m˝ uködik A beépített dir() és help() függvények függvények sokat segíthetne segíthetnekk ha olyan nagy modulokkal modulokkal van dolgod, dolgod, mint például például az os: >>> >>> impo import rt os >>> dir(os) dir(os) > >>> help(os) help(os) l>
A mindennapi fájl- és könyvtár-m˝ uveletekhez az nyújt:
shutil
modul magasszint˝ u, könnyen használható felületet
>>> import import shutil shutil >>> shutil.copy shutil.copyfile( file(’data. ’data.db’, db’, ’archive.db ’archive.db’) ’) >>> shutil.move(’/build/executables’, ’installdir’)
A glob modulban lév ˝ lév ˝ o függvény segít a fájl listák elkészítésében, ha dzsóker karaktert használsz: >>> import import glob glob >>> glob.glob(’ glob.glob(’*.py’ *.py’) ) [’primes.py [’primes.py’, ’, ’random.py’ ’random.py’, , ’quote.py’] ’quote.py’]
A programoknak programoknak gyakran gyakran fel kell dolgozniuk dolgozniuk a parancssori parancssori paraméterei paramétereiket. ket. Ezek a paraméterek paraméterek a sys modul argv attribútumában tárolódnak, listaknént. Például ha kiadjuk azt a parancsot, hogy ‘ python python demo.p demo.py y egy következ ˝ o kimenetet eredményezi: ketto ketto harom harom’, az a következ ˝ >>> import import sys >>> print print sys.ar sys.argv gv [’demo [’demo.py .py’, ’, ’egy’, ’egy’, ’ketto ’ketto’, ’, ’harom ’harom’] ’] # a nullad nulladik ik argume argumentu ntum m mindig mindig a progra program m neve! neve!
A getopt modul képes feldolgozni a sys.argv elemeit a U NI X getopt() függvényének szabályai szerint. Ennél még hatékonyabb és rugalmasabb program-paraméter feldolgozást tesz lehet ˝ lehet ˝ ové az optparse modul.
The sys module also has attributes for stdin, stdout , and stderr . The latter is useful for emitting emitting warnings warnings and error messages to make them visible even when stdout has been redirected: A sys modul szintén rendelkezik stdin, stdout , és stderr attribútummal. Ez utóbbi használatos figyelmeztetések és hibaüzenetek láthatóvá tételére – például akkor, amikor a stdout át van irányítva, mondjuk egy fájlba: >>> sys.st sys.stder derr.w r.writ rite(’ e(’War Warnin ning, g, log file file not found found starti starting ng a new one\n’ one\n’) ) Warn Warnin ing, g, log log file file not not foun found d star starti ting ng a new new one one
A legrövidebb út egy program megszakítására a ‘ sys.exit()’ utasítás..
A re modul segítségével reguláris kifejezéseket használhatsz szövegfeldolgozásra. Összetett illeszkedési és módosító szabályokat határozhatsz meg – a reguláris kifejezések rövid, tömör megoldást kínálnak: >>> import re # kovetkezik: minden f-el kezdodo szot kigyujtunk: >>> re.fin re.findal dall(r l(r’\b ’\bf[a f[a-z] -z]*’, *’, ’aki ’aki felves felveszi, zi, az felmel felmelegs egszik zik, , aki nem, nem, az fazik’ fazik’) ) [’felveszi’ [’felveszi’, , ’felmelegszi ’felmelegszik’, k’, ’fazik’] ’fazik’] >>> re.sub re.sub(r’ (r’(\b (\b[a[a-z]+ z]+) ) \1’, \1’, r’\1’, r’\1’, ’macsk ’macska a a a kalapb kalapban an a a hazban hazban’) ’) ’mac ’macsk ska a a kala kalapb pban an a hazba hazban’ n’ # a peld pelda a nem toke tokele lete tes, s, ’a a a’-bo a’-bol l # ’a a’-t a’-t csinal csinal, , de szemle szemlelte ltetes tesnek nek jo
Ha egyszer egyszerubb ˝ szövegmódosítási igényed van, a string metódusokat javasoljuk, mert olvashatóak és a hibakeresés is könyebb velük.
>>> ’Teat Peternek’.r Peternek’.replace eplace(’Pet (’Peter’, er’, ’Elemer’) ’Elemer’) ’Teat Elemernek’ Elemernek’
A math modulon keresztül érhet ˝ érhet ˝ oek el a háttérben m˝ uköd ˝ uköd ˝ o C függvények, füg gvények, melyekkel lebeg ˝ lebeg ˝ opontos m˝ uveleteket végezhetsz: >>> import import math math >>> math.c math.cos( os(mat math.p h.pi i / 4.0) 4.0) 0.70710678118654757 >>> math.log(10 math.log(1024, 24, 2) 10.0
A random modullal véletlenszámokat generálhatsz: >>> import import random random >>> random.choi random.choice([’ ce([’alma’, alma’, ’korte’, ’korte’, ’banan’]) ’banan’]) ’alma’ >>> random. random.sam sample ple(xr (xrang ange(1 e(100) 00), , 10) # ismetl ismetles es nelkuli nelkuli mintave mintavetel tel [30, [30, 83, 16, 16, 4, 8, 81, 41, 50, 50, 18, 18, 33] 33] >>> >>> ran rando dom. m.ra rand ndom om() () # ran rando dom m flo float at 0.17970987693706186 >>> >>> rand random om.r .ran andr dran ange ge(6 (6) ) # véle véletl tlen en egész egész szám szám kivá kivála lasz sztá tása sa 0-6ig 0-6ig terje terjed do ˝ tartományba tartományban n 4
Több modul is van, amely lehet ˝ lehet ˝ ové teszi az Internet elérését, és különböz ˝ különböz ˝ o protokollok használatát. A két legegyszer˝ ubb az urllib2 – adatfogadás url címekr ˝ címekr ˝ ol, és az smtplib modul, amellyel levelet küldhetsz: >>> import import urllib urllib2 2 >>> for line in urllib2.url urllib2.urlopen( open(’http: ’http://www //www.pytho .python.org n.org/’): /’): # for: for: az oldal oldal soronk soronként énti i feldol feldolgoz gozása ása: : ... if ’Python’ in line: # keressük azokat a sorokat, ... print line # ahol a Python szó megtalálható
>>> import import smtpli smtplib b >>> server server = smtplib.SMT smtplib.SMTP(’loc P(’localhos alhost’) t’) >>> server.sendmail(’[email protected]’, ’[email protected]’, ’[email protected]’, """To: """To: jcaesar@exa [email protected] mple.org rg From: [email protected] Szevasz! Szevasz! Eljutottal Eljutottal a tutorial tutorial vegeig!. vegeig!. """) >>> server.quit server.quit() ()
A datetime modul biztosít osztályokat a dátumok és az id ˝ id ˝ opontok manipulálására – egyszer˝ ubbeket és összetettebbeket is. A dátum- és az id ˝ id ˝ o- aritmetikai aritmetikai m˝ m uveletek ˝ támogatottak – a középpontban a kimenet formázása és módosítása áll. A modul támogatja azokat az objektumokat is, amelyek kezelni tudják az id ˝ ozónákat. # a dátumo dátumok k könnye könnyen n létreh létrehozh ozható atóak ak és formáz formázhat hatóak óak: : >>> from from dateti datetime me import import date date >>> most most = date.t date.toda oday() y() >>> most most datetime.da datetime.date(200 te(2003, 3, 12, 2) >>> >>> most most.s .str trft ftim ime( e("% "%mm-%d %d-% -%y. y. %d %b %Y is a %A on the the %d day day of %B." %B.") ) ’12’12-02 02-0 -03. 3. 02 Dec Dec 2003 2003 is a Tues Tuesda day y on the the 02 day day of Dece Decemb mber er.’ .’ # a dátu dátumo mok k támo támoga gatj tják ák a napt naptár ári i m˝ uveleteket: >>> szulet szuletesn esnap ap = date(1 date(1964 964, , 7, 31) >>> >>> kor kor = most most - szul szulet etes esna nap p # a most most-o -ot t az eloz elozo o peld peldab aban an hataro hatarozt ztuk uk meg! >>> >>> kor. kor.da days ys # days days = napo napok, k, itt itt a napo napok k szam szamat at jele jelent nti i 14368
Az elterjedtebb archiváló és tömörít ˝ tömörít ˝ o formátumok közvetlenül támogatottak, a következ ˝ következ ˝ o modulokban: gzip, bz2, zipfile, and tarfile.
zlib,
>>> import import zlib zlib >>> >>> s = ’wit ’witch ch whic which h has has whic which h witc witche hes s wris wrist t watc watch’ h’ >>> len(s) len(s) 41 >>> t = zlib.c zlib.comp ompres ress(s s(s) ) >>> len(t) len(t) 37 >>> zlib.decomp zlib.decompress( ress(t) t) ’witch ’witch which which has which which witche witches s wrist wrist watch’ watch’ >>> zlib.crc32( zlib.crc32(s) s) 226805979
Néhány Python programozó komoly érdekl ˝ érdekl ˝ odést mutatott mutatott a különböz különböz ˝ o probléma-megoldások teljesítményének összehasonlítása iránt. A Pythonban található egy mér ˝ mér ˝ oeszköz, amely azonnali választ ad ezekre a kérdésekre. Például használhatunk tuple becsomagolást és kicsomagolást a megszokott paraméter-átadás helyett. A modul gyorsan demonstrál egy egyszer˝ u teljesítmény mérést:
timeit
>>> from from timeit timeit import import Timer >>> Timer(’t=a; Timer(’t=a; a=b; b=t’, ’a=1; b=2’).timei b=2’).timeit() t() 0.57535828626024577 >>> Timer( Timer(’a, ’a,b b = b,a’, b,a’, ’a=1; ’a=1; b=2’). b=2’).tim timeit eit() () 0.54962537085770791
A timeit modul apró kódrészletek végrehajtási idejének mérésére szolgál. Ezzel ellentétben a pstats modulok nagyobb kódrészletek futási-id ˝ futási-id ˝ o kritikus részeinek meghatározására szolgál.
profile és a
A jómin ˝ jómin ˝ oség˝ u programok fejlesztésnek egyik elmélete az, hogy minden függvényhez próbaadatokat, teszteket írunk – majd a fejlesztési folyamat során ezeket gyakran lefuttatjuk - így azonnal kiderül, ha a várttól eltér ˝ oen viselkedik a program. A The doctest modul tartalmaz olyan eszközöket, amelyekkel modulokat vizsgálhatunk, és a program dokumentációs karakterláncába ágyazott teszteket futtathatunk le. A teszt létrehozása olyan egyszer˝ u, mint kivágni és beilleszteni egy egy tipikus függvényhívás során bejöv ˝ bejöv ˝ o-keletkez ˝ o-keletkez ˝ o adatokat. Ez a lehet ˝ lehet ˝ oség el ˝ el ˝ osegíti a jobb dokumentáltságot, hiszen a felhasználónak rögtön függvényhívási példát mutathatunk – továbbá ellen ˝ ellen ˝ orizhet ˝ orizhet ˝ ové teszi a doctest modulnak, hogy a kód a dokumentációval összhangban van-e. def atlag(ertek atlag(ertekek): ek): """Lis """Listáb tában an átadot átadott t számok számok számta számtani ni közepé közepét t határo határozza zza meg a függvé függvény. ny. >>> print print atlag( atlag([20 [20, , 30, 70]) 70]) 40.0 """ return return sum(ertekek sum(ertekek, , 0.0) / len(ertekek len(ertekek) ) import import doctest doctest doctes doctest.t t.test estmod mod() ()
# a beágya beágyazot zott t tesztet tesztet automati automatikus kusan an kipróbál kipróbálja. ja.
A unittest modul kicsit bonyolultabb, mint a doctest modul – viszont több átfogó tesztkészlet kezelésér ˝ kezelésér ˝ ol gondoskodik, egy különálló fájlban: (Ehhez az el ˝ el ˝ oz ˝ oz ˝ o példa lefuttatása is szükséges - hogy létezzen az average függvény!) import import unittest unittest class StatisztikaiFuggvenyekTesztelese(unittest.TestCas StatisztikaiFuggvenyekTesztelese(unittest.TestCase): e): def atlag_tesztelese(self): self.assert self.assertEqual( Equal(atlag( atlag([20, [20, 30, 70]), 40.0) self.assert self.assertEqual( Equal(round( round(atlag( atlag([1, [1, 5, 7]), 1), 4.3) self.assertRaises(ZeroDivisionError, atlag, []) self.assert self.assertRaises Raises(TypeE (TypeError, rror, atlag, 20, 30, 70) ˝ hívás unittest.ma unittest.main() in() # A parancssorbó parancssorból l történ˝ történo hívás lefutt lefuttatj atja a a teszte teszteket ket. .
A Python filozófiája: „elemekkel együtt”. A legjobban ez úgy látszik, ha észrevesszük nagyszámú moduljainak csomagjainak kifinomultságát, összetettségét. Például: • Az xmlrpclib és a SimpleXMLRPCServer modulok a távoli eljáráshívásokat egyszer˝ u muveletté ˝ teszik számunkra. A neveik ellenére nincs közvetlen XML tudásra szükség. • Az email csomag egy könyvtár az elektronikus levelek kezelésére kezelésére – beleértve a MIME és más RFC 2822alapú üzenetek üzeneteket et is. Eltér ˝ Eltér ˝ oen az smtplib és poplib moduloktól, melyek azonnali levélküldést és fogadást valósítanak meg, az email csomag teljes eszközkészlettel rendelkezik összetett üzenet-struktúrák felépítéséhez és dekódolásához – a csatolt állományokat is beleértve. Továbbá tartalmazza az Interneten használt kódoló és fejléc protokollokat. • Az
xml.dom
és az
xml.sax
csomagok nagyon jól használhatók az elterjedt adat-cserél ˝ adat-cserél ˝ o formátumok formátumok
kezelésére, értelmezésére és feldolgozására Ugyanúgy a csv modul támogatja a csv formátum közvetlen írását és olvasását. olvasását. Mindent egybevé egybevéve ve ezek a modulok és csomagok csomagok remekül leegyszer˝ leegyszer˝ usíti a Python programok és más alkalmazások közötti adatcserét. • A kultúrális tulajdonságok beállíthatók és támogatottak számos modulban, például: és a codecs csomagban is.
gettext, locale,
11. fejezet
Az alap-könyvtár bemutatása 2. rész Ebben a részben néhány olyan modult vizsgálunk meg, amire a professzionális programozás során szükség lesz. Ezen modulok kisebb szkriptekben ritkán fordulnak el ˝ el ˝ o.
A repr modulban modulban található található repr() függvény függvény lehet ˝ lehet ˝ ové teszi a nagyméret˝ nagyméret˝ u, mélyen mélyen egymásba ágyazott ágyazott adatszeradatszer ˝ kezetek rövid, áttekinthet ˝ áttekinthet o kijelzését: >>> import import repr repr >>> repr.repr(set(’elkelkaposztastalanitottatok’)) "set([ "set([’a’ ’a’, , ’e’, ’e’, ’i’, ’i’, ’k’, ’k’, ’l’, ’l’, ’n’, ’n’, ...])" ...])"
A pprint modullal finoman szabályozhatod beépített és a felhasználó által definiált objektumok megjelenítését ˝ – úgy, úgy, hogy az az értelmez értelmez ˝ o számára számára továbbra továbbra is feldolgoz feldolgozható ható marad. Amikor Amikor az eredmén eredményy nem fér el el egy egy sorban, sorban, egy „csinos nyomtató” sortöréseket és behúzásokat b ehúzásokat ad a kimenethez, hogy az jól olvasható legyen: >>> import import pprint pprint >>> t = [[[[’b [[[[’blac lack’, k’, ’cyan’ ’cyan’], ], ’white ’white’, ’, [’gree [’green’, n’, ’red’] ’red’]], ], [[’mag [[’magent enta’, a’, ... ... ’yel ’yello low’ w’] ], ’blu ’blue’ e’]] ]]] ] ... >>> pprint.ppri pprint.pprint(t, nt(t, width=30) width=30) [[[[’black’ [[[[’black’, , ’cyan’], ’cyan’], ’white’, [’green’, [’green’, ’red’]], ’red’]], [[’magenta’, ’yellow’], ’blue’]]]
A textwrap modullal szövegblokkokak szövegblokkokak jeleníthetünk meg adott szélesség˝ u blokkban:
>>> import import textwr textwrap ap >>> >>> doc doc = """T """The he wrap wrap() () meth method od is just just like like fill fill() () exce except pt that that it retu return rns s ... ... a list list of stri string ngs s inst instea ead d of one one big big stri string ng with with newl newlin ines es to sepa separa rate te ... the wrappe wrapped d lines. lines.""" """ ... >>> print textwrap.fil textwrap.fill(doc, l(doc, width=40) The The wrap wrap() () meth method od is just just like like fill fill() () exce except pt that that it retu return rns s a list list of stri string ngs s instea instead d of one big string with newlin newlines es to separa separate te the wrappe wrapped d lines. lines.
A locale modul a különböz ˝ különböz ˝ o kultúrákhoz köt ˝ köt ˝ od ˝ od ˝ o egyedi adatformázásokhoz fér hozzá – a locale format funkciójának grouping (csoportosítás, a következ ˝ következ ˝ o példában helyiérték) tulajdonsága közvetlenül biztosítja az adott kultúrának megfelel ˝ megfelel ˝ o szám-kijelzést: >>> import import locale locale >>> locale.setl locale.setlocale( ocale(local locale.LC_A e.LC_ALL, LL, ’English_Un ’English_United ited States.1252’ States.1252’) ) ’English_United States.1252’ >>> conv = locale.localeconv() # get a mapping of conventions >>> >>> x = 1234 123456 567. 7.8 8 >>> locale.form locale.format("%d at("%d", ", x, grouping=Tr grouping=True) ue) ’1,234,567’ >>> locale.format("%s%.*f", (conv[’currency_symbol’], ... ... conv conv[’ [’in int_ t_fr frac ac_d _dig igit its’ s’], ], x), x), grou groupi ping ng=T =Tru rue) e) ’$1,234,567.80’
A string modulban található egy nagyon hasznos osztály, a Template. Ez lehet ˝ lehet ˝ oséget ad a végfelhasználóknak sablon-szövegek szerkesztésére. A szövegbe adatmez ˝ adatmez ˝ oket a ‘ $’ jellel helyezhetünk el, melyek mellé kapcsos zárójelbe Python változóneveket kell írni (ez számot, bet˝ ut és alsóvonás alsóvonás karaktert karaktert tartalmazhat). tartalmazhat). A kapcsos kapcsos zárójelpárra zárójelpárra akkor van szükség, ha nem önálló szó a beillesztett beillesztett adat, például lent a ’Peternek’ ’Peternek’ szó lesz ilyen - egyébként egyébként a zárójelpár zárójelpár elhagyható. elhagyható. Egyszer˝ u ‘$’ jelet így írhatsz: ‘ $$’ >>> from from string string import import Templa Template te >>> t = Templa Template( te(’${ ’${nev nev}ne }nek k kuldun kuldunk k 10$$-t 10$$-t, , hogy hogy $csele $cseleked kedet. et.’) ’) >>> t.substitut t.substitute(nev e(nev=’Pete =’Peter’, r’, cselekedet= cselekedet=’csiz ’csizmat mat vegyen’) vegyen’) ’Peter ’Peternek nek kuldun kuldunk k 10$-t, 10$-t, hogy hogy csizma csizmat t vegyen vegyen’ ’
˝ A substitute medódus KeyError kivételd dob, ha az adatmez adatmez ˝ okben megadott megadott változónev változónevet et a paraméterkén paraméterkéntt átadott szótárban, vagy kulcsszavas kulcsszavas paraméterekben nem találja. Elképzelhet ˝ Elképzelhet ˝ o olyan helyzet, hogy valamelyik változónév (vagy kulcs, ha szótárról van szó) hiányzik - ilyenkor a safe_substitute metódust érdemes használni, ami a hiányzó adatoknál az adatmez ˝ adatmez ˝ ot változatlanul hagyja:
# ez a peld pelda a nem nem fut fut le, le, hian hianyz yzik ik $owner $owner >>> t = Templa Template( te(’Re ’Retur turn n the $item $item to $owner $owner.’) .’) >>> d = dict(i dict(item tem=’u =’unla nladen den swallo swallow’) w’) >>> t.substitut t.substitute(d) e(d) Traceb Traceback ack (most (most recent recent call call last): last): . . . KeyError: KeyError: ’owner’ ’owner’ >>> >>> t.sa t.safe fe_s _sub ubst stit itut ute( e(d) d) # ez a peld pelda a lefu lefut, t, pedig pedig hian hianyz yzik ik $owner $owner:b :bro rows wse e conf confir irm m save saveas as ’Retur ’Return n the unlade unladen n swallo swallow w to $owner $owner.’ .’
A Template alosztály egyedi határolójelet is tud használni. Például egy tömeges fájl-átnevez ˝ o funkció esetében ˝ (pl. fénykép-karbantartó programnál) az adatmez ˝ adatmez ok jelzésére használhatod a százalék jelet is, az aktuális dátum, a kép sorszáma, vagy a fájl formátumának jelzése esetén: >>> >>> >>> ... >>> Add
import import time, time, os.pat os.path h photofiles photofiles = [’img_1074. [’img_1074.jpg’, jpg’, ’img_1076.j ’img_1076.jpg’, pg’, ’img_1077.j ’img_1077.jpg’] pg’] class BatchRename BatchRename(Templ (Template): ate): delimiter = ’%’ fmt = raw_in raw_input put(’A (’Add dd meg az atneve atnevezes zes modjat modjat: : (%d-da (%d-datum tum %n-faj %n-fajl_s l_sors orszam zama a %f-fil %f-filefo eforma rmatu tu meg az atneve atnevezes zes modjat modjat: : (%d-da (%d-datum tum %n-faj %n-fajl_s l_sors orszam zama a %f-fil %f-filefo eforma rmatum tum): ): Ashley Ashley_%n _%n%f %f
>>> t = BatchR BatchRena ename( me(fmt fmt) ) >>> date = time.strfti time.strftime(’%d me(’%d%b%y’ %b%y’) ) >>> for i, filena filename me in enumer enumerate ate(ph (photo otofil files) es): : ... ... base base, , ext ext = os.p os.pat ath. h.sp spli lite text xt(f (fil ilen enam ame) e) ... ... newn newnam ame e = t.su t.subs bsti titu tute te(d (d=d =dat ate, e, n=i, n=i, f=ex f=ext) t) ... ... prin print t ’%s ’%s --> --> %s’ %s’ % (fi (file lena name me, , new newna name me) ) img_1074.jp img_1074.jpg g --> Ashley_0.jp Ashley_0.jpg g img_1076.jp img_1076.jpg g --> Ashley_1.jp Ashley_1.jpg g img_1077.jp img_1077.jpg g --> Ashley_2.jp Ashley_2.jpg g
Another application for templating is separating program logic from the details of multiple output formats. The makes it possible to substitute custom templates for XML files, plain text reports, and HMTL web reports. A szövegsablonok másik felhasználási lehet ˝ lehet ˝ osége a többféle kimeneti formátumot támogató programokban van. ˝ Itt a vezérl vezérlési ési logika logikaaa kimene kimenett tt ˝ ol el van van válasz választva tva–– A kimene kimeneti ti fájl fájl felépí felépítés tésee más XML fájlok fájloknál nál,, szöve szövegfá gfájlo jlokná knál, l, vagy html kimenet esetében, viszont az adattartalom értelemszer˝ uen megegyezik.
A struct modulban található a pack() és az unpack() függvények, melyekkel változó hosszúságú bináris adatblokkokat kezelhetsz. A következ ˝ következ ˝ o példa bemutatja a ZIP fájlok fejléc információinak feldolgozását (a "H" és az "L" kódcsomag jelképezi a két és négybájtos el ˝ el ˝ ojel nélküli számokat):
import import struct data = open(’fajlo open(’fajlom.zip’ m.zip’, , ’rb’).read( ’rb’).read() ) star start t = 0 for i in range(3): # megnezzuk az elso harom fajl fejlecet star start t += 14 fields = struct.unpa struct.unpack(’LL ck(’LLLHH’, LHH’, data[start: data[start:start+ start+16]) 16]) crc32, crc32, comp_s comp_size ize, , uncomp uncomp_si _size, ze, filena filenames mesize ize, , extra_ extra_siz size e = fields fields star start t += 16 filename filename = data[start: data[start:start start+filen +filenamesi amesize] ze] start += filenamesiz filenamesize e extra = data[start: data[start:start+ start+extra_ extra_size] size] print filename, filename, hex(crc32), hex(crc32), comp_size, comp_size, uncomp_size uncomp_size star start t += ext extra ra_s _siz ize e + comp comp_s _siz ize e
# tova tovabb bble lepe pes s a kove kovetk tkez ezo o fejl fejlec eche hez z
A szálkezelés szálkezeléssel sel lehet az egymástól egymástól sorrendileg sorrendileg nem függ ˝ függ ˝ o folyamatokat folyamatokat párhuzamossá párhuzamossá tenni. A szálakkal szálakkal egyid ˝ egyid ˝ oben fogadhatjuk a program felhasználójának utasításait, miközben a háttérben a program egy feladaton dolgozik a két folyamat (kommunikáció, és háttérben munka) egymással egymással párhuzamosan fut. A következ ˝ következ ˝ o kód bemutatja a threading modul magasszint˝ u használatát, ami egy külön háttérfolyamatot indít, miközben a program fut tovább: import import threading, threading, zipfile zipfile class AsyncZip(threading.Thread): def __init__(se __init__(self, lf, infile, infile, outfile): outfile): threading.Thread.__init__(self) self.i self.infi nfile le = infile infile self.outfil self.outfile e = outfile outfile def run(self): run(self): f = zipfile.ZipF zipfile.ZipFile(s ile(self.ou elf.outfile, tfile, ’w’, zipfile.ZIP zipfile.ZIP_DEFL _DEFLATED) ATED) f.write(self.infile) f.close() print print ’Kesz ’Kesz a zip tomori tomorites tese e ennek ennek a fajlna fajlnak: k: ’, self.i self.infi nfile le background background = AsyncZip(’va AsyncZip(’valami.t lami.txt’, xt’, ’myarchive. ’myarchive.zip’) zip’) background.start() print print ’A foprog foprogram ram tovabb tovabb fut az eloter eloterben ben.’ .’ backgr backgroun ound.j d.join oin() () # Vara Varakoz kozas as a hatt hatterm ermuve uvelet let befeje befejezes zesere ere print print ’A foprog foprogram ram megvar megvarja, ja, hogy hogy a hatter hattermuv muvele elet t befeje befejezod zodjon jon.’ .’
A többszálú programok egyik legfontosabb feladata azon szálak m˝ uködésének koordinálása, melyek megosztott adatokon, vagy közös er ˝ er ˝ oforrásokon oforrásokon dolgozn dolgoznak. ak. (pl. mi történik történik ha két szál egyid egyid ˝ oben akar akar egy fájlt fájlt írni?) írni?) A Threading modul több szinkronizációs elemet tartalmaz – ilyen a zárolás, zárolás, az eseménykezelés, eseménykezelés, a feltételes változók és a szemaforok. Igaz ugyan, hogy ezek hatékony eszközök – ám el ˝ el ˝ ofordulhatnak kisebb tervezési hibák is, melyek nehezen megismételhet ˝ ismételhet ˝ ok, és nehezen kinyomozhatók. Mivel a szálak egymástól függetlenül futnak, még végrehajtásuk sorrendje sem biztos - emiatt el ˝ el ˝ ofordulhat, hogy a program nem ugyanúgy viselkedik, ha egymás után többször lefuttatjuk – így a hibakeresés is nehezebbé válik. A szálak koordinálására azt javasoljuk, hogy az er ˝ er ˝ oforrások elérését egy szál biztosítsa, és használd a
Queue
modult a többi szálból érkez ˝ érkez ˝ o kérések kezelésére. Ha egy programban a szálak közötti kommunikációt a Queue objektumokkal biztosítod, a program koordinálásának megtervezése egyszer˝ ubb, olvashatóbb és megbízhatóbb lesz.
A logging modul egy összetett, összetett, finoman beállítható beállítható naplózó naplózó rendszert tartalmaz. tartalmaz. A legegysze legegyszerr ˝ ubb esetben a naplózandó üzenetek fájlba, vagy a sys.stderr (szabványos hibacsatornára) - küldhet ˝ küldhet ˝ ok: import import logging logging logging.debug(’Debugging information’) logging.info(’Informational message’) logging.war logging.warning( ning(’Warni ’Warning:co ng:config nfig file %s not found’, found’, ’server.con ’server.conf’) f’) logging.error(’Error occurred’) logging.cri logging.critical tical(’Crit (’Critical ical error -- shutting shutting down’) down’)
A fenti példa kimenete: WARNING:roo WARNING:root:War t:Warning:c ning:config onfig file server.conf server.conf not found ERROR:root:Error occurred CRITICAL:ro CRITICAL:root:Cr ot:Critical itical error -- shutting shutting down
Alapértelmezés szerint az információs és debug üzenetek elfojtottak, és a kimenet a szabványos hiba csatornára kerül. A kimenet célja más is lehet, például email, datagram, socket vagy akár egy HTTP szerver. Az új sz˝ ur ˝ ur ˝ ok az üzenet prioritásától függ ˝ függ ˝ oen más-más kimenetre terelhetik a naplózandó üzenetet. A prioritások: DEBUG, INFO, WARNING, ERROR, és CRITICAL. A naplózó rendszer közvetlenül a Pythonból is beállítható, vagy használhatsz konfigurációs fájlt, s így a programból való kilépés nélkül megváltoztathatod m egváltoztathatod a naplózás beállításait.
A memóriakezelést a Python automatikusan végzi (hivatkozásszámlálás a legtöbb objektum esetében, és szemétgy˝ gyujtés). ˝ Az utolsó objektum-hivatkozás megsemmisülése után az elfoglalt memória felszabadul. Ez az automatizmus a legtöbb esetben jó és hasznos, de néha szükség van az objektumok követésére mindaddig, amíg használatban használatban vannak. vannak. Érdekes, Érdekes, hogy éppen ez a követés követés az, ami a hivatkoz hivatkozásoka ásokatt állandóvá állandóvá teszi (nem sz˝ szunnek ˝ meg). object object is no longer longer needed needed,, it is automa automatic ticall allyy remov removed ed froma from a weakref weakref table table and a callba callback ck is trigge triggered red for weakref weakref objects. Typical applications include caching objects that are expensive to create: A weakref modulban olyan eszközök vannak, amelyekkel úgy lehet nyomon követni az objektumokat, hogy a nyomkö nyomkövet vetéss éssel el nem hozol hozol létre létre újabb újabb hiva hivatko tkozás zástt az objekt objektumra umra.. Amikor Amikor az objekt objektumotmár umotmár senki senki nem haszná használja lja,, automatikusan törl ˝ törl ˝ odik a weakref (gyenge referencia) táblából, és a weakref objektum err ˝ ol értesí értesítés téstt kap. A tipikus programok tároló objektumokat tartalmaznak, melyek létrehozása er ˝ er ˝ oforrásigényes:
>>> import import weakre weakref, f, gc >>> >>> clas class s A: ... ... def def __in __ini it__( t__(se self lf, , erte ertek k): ... self.ertek = ertek ... ... def def __re __rep pr__( r__(se self lf): ): ... return str(self.ertek) ... >>> a = A(10) # hivatkozas letrehozasa >>> d = weakref.Wea weakref.WeakValue kValueDicti Dictionary( onary() ) >>> d[’primary’] = a # itt nem keletkezik hivatkozas >>> d[’primary’] # ha az objektum meg letezik, visszaadja az erteket 10 >>> del a # toroljuk az egyetlen hivatkozast >>> gc.collect() # a szemetgyujtest azonnal lefuttatjuk 0 >>> d[’primary’] # ez a bejegyzes automatikusan megszunt, nem kell kulon Traceb Traceback ack (most (most recent recent call call last): last): File File "" 8>", , line line 1, in -tople -toplevel veld[’primary’] # ez a bejegyzes automatikusan megszunt, nem kell kulon File "C:/PY24/li "C:/PY24/lib/weak b/weakref.p ref.py", y", line 46, in __getitem__ __getitem__ o = self.d self.data ata[ke [key]( y]() ) KeyError: KeyError: ’primary’ ’primary’
A legtöbb adatstruktúrá adatstruktúrának nak szüksége szüksége van a beépített beépített lista típusra. Néha el ˝ el ˝ ofordul, hogy a listák egy másfajta megvalósítására van szükség, az eredeti listáktól eltér ˝ eltér ˝ o viselkedéssel. Az array modulban található array() objektum hasonlít azokhoz a listákhoz, melyek csak hasonló adattípusokat tárolnak, de ezt a tárolást sokkal tömörebben végzi. A következ ˝ következ ˝ o példában egy számokból álló tömböt láthatunk, ahol a számok mint két bájtos el ˝ el ˝ ojel-nélküli bináris számként tárolódnak (típuskód: "H") – ellentétben a hagyományos Python int (egész szám) objektumokból álló listákkal, ahol minden bejegyzés bejegyzés 16 bájtot használ. >>> from array array import import array array >>> >>> a = arra array( y(’H ’H’, ’, [400 [4000, 0, 10, 10, 700, 700, 2222 22222] 2]) ) >>> sum(a) sum(a) 26932 >>> a[1:3] a[1:3] array(’H’, array(’H’, [10, 700])
A collections modulban lév ˝ lév ˝ o deque() objektum egy – a listához hasonló típus – viszont gyorsabban tud új elemet felvenni a lista végére és elemet kiemelni a lista elejér ˝ ol. Hátránya viszont, hogy a keresésben lassabb nehézkesebb, mint a hagyományos lista. Ez az objektumtípus hasznos várakozási sorok, listák megvalósítására:
>>> from from collec collectio tions ns import import deque deque >>> d = deque( deque(["t ["task ask1", 1", "task2 "task2", ", "task3 "task3"]) "]) >>> d.append("t d.append("task4") ask4") >>> print "Handling", "Handling", d.popleft() d.popleft() Handling Handling task1 unsearched unsearched = deque([star deque([starting_ ting_node]) node]) def breadth_first_search(unsearched): node = unsearched.p unsearched.popleft opleft() () for m in gen_mo gen_moves ves(no (node) de): : if is_goal(m): is_goal(m): return return m unsearched.append(m)
Ráadásul az Alap-Könyvtár más eszközöket is tartalmaz, például a bisect modult, ami rendezett listák módosítására szolgál: >>> import import bisect bisect >>> scores scores = [(100, [(100, ’perl’ ’perl’), ), (200, (200, ’tcl’) ’tcl’), , (400, (400, ’lua’) ’lua’), , (500, (500, ’pytho ’python’) n’)] ] >>> bisect.inso bisect.insort(sco rt(scores, res, (300, ’ruby’)) ’ruby’)) >>> scores scores [(100, [(100, ’perl’ ’perl’), ), (200, (200, ’tcl’) ’tcl’), , (300, (300, ’ruby’ ’ruby’), ), (400, (400, ’lua’) ’lua’), , (500, (500, ’pytho ’python’) n’)] ]
A heapq modulban található függvényekkel megvalósíthatók a hagyományos listákon alapuló adathalmazok kezelése. kezelése. A legalacsonyab legalacsonyabbb érték˝ u bejegyzés bejegyzés mindig a nulla pozícióba kerül. kerül. Ez hasznos, ha a programodnak programodnak gyakran kell elérnie a lista legkisebb elemét, de nem akarod a listát teljes mértékben rendezni: >>> from from heapq heapq import import heapif heapify, y, heappo heappop, p, heappu heappush sh >>> data = [1, 3, 5, 7, 9, 2, 4, 6, 8, 0] >>> heapify(data) # atrendezi a listat >>> heappush(data, -5) # uj elemet ad a listaba >>> >>> [hea [heapp ppop op(d (dat ata) a) for for i in rang range( e(3) 3)] ] # kili kilist staz azza za a haro harom m legk legkis iseb ebb b elem elemet et. . [-5, [-5, 0, 1]
A decimal modulban modulban található található a Decimal adattípus, lebeg ˝ lebeg ˝ opontos számít számításokhoz ásokhoz.. A beépített float típushoz képest, amely a bináris bináris lebeg lebeg ˝ opontos számításokhoz készült, az új osztály nagyon sokat segít pénzügyi programoknál programoknál (és ott, ahol véges decimális decimális ábrázolást ábrázolást használnak, használnak, a pontosság pontosság ellen ˝ ellen ˝ orzésével, a törvényeknek vagy a szabályoknak megfelel ˝ megfelel ˝ o kerekítés használatával, a fontos számjegyek nyomkövetésével – vagy olyan programoknál, ahol a felhasználó kézzel végzett számításokhoz akarja hasonlítani a végeredményt. Például számítsuk ki az 5%-os adóját egy 70 centes telefonköltségnek, ami különböz ˝ o eredményt ad decimális és bináris lebeg ˝ lebeg ˝ opontos számítás használata esetén. A különbség fontos lesz, ha a kerekítés a legközelebbi centhez történik: >>> >>> from from deci decima mal l impo import rt * >>> Decimal(’0. Decimal(’0.70’) 70’) * Decimal(’1. Decimal(’1.05’) 05’) Decimal("0.7350") >>> >>> .70 .70 * 1.05 1.05 0.73499999999999999
A Decimal osztály eredménye egy lezáró nullát tartalmaz, automatikusan négy számjegy˝ uen kerül ábrázolásra,
a 2*2 számjegy˝ u (tizedesjegyek) szorzás eredményeképp. A Decimal ugyanolyan matematikát használ, mint amit a papíron végzett számolás, és elkerüli azokat a kérdéseket, amikor a bináris lebeg ˝ opontos számítás nem tud abszolút pontosan ábrázolni decimális mennyiségeket. A Decimal osztály teljesen pontosan ábrázolja a maradékos osztást, és az egyenl ˝ egyenl ˝ oségtesztelést, ami a bináris lebeg ˝ lebeg ˝ opontos ábrázolás esetén helytelen eredményre vezet: >>> Decimal(’1. Decimal(’1.00’) 00’) % Decimal(’.1 Decimal(’.10’) 0’) Decimal("0.00") >>> >>> 1.00 1.00 % 0.10 0.10 0.09999999999999995 >>> sum([Decima sum([Decimal(’0. l(’0.1’)]*1 1’)]*10) 0) == Decimal(’1. Decimal(’1.0’) 0’) True >>> sum([0 sum([0.1] .1]*10 *10) ) == 1.0 False
A decimal modulban a számítások pontosságát szükség szerint beállíthatod: >>> getcon getcontex text() t().pr .prec ec = 36 >>> Decima Decimal(1 l(1) ) / Decima Decimal(7 l(7) ) Decimal("0.142857142857142857142857142857142857")
12. fejezet
What Now? Reading Reading this tutorial tutorial has probably probably reinforced reinforced your interest interest in using Python Python — you should be eager to apply apply Python to solving your real-world problems. Now what should you do? You should read, or at least page through, the Python Library Reference, which gives complete (though terse) reference material about types, functions, and modules that can save you a lot of time when writing Python programs. The standard Python distribution includes a lot of code in both C and Python; there are modules to read U NI X mailboxes, retrieve documents via HTTP, generate random numbers, parse command-line options, write CGI programs, compress data, and a lot more; skimming through the Library Reference will give you an idea of what’s available. The major Python Web site is ; it contains code, documentation, and pointers to Pythonrelated related pages around the Web. This Web Web site is mirrored mirrored in various various places around the world, such as Europe, Japan, and Australia; a mirror may be faster than the main site, depending on your geographical location. A more informal informal site is is , which which contai contains ns a bunch bunch of Python Python-rel -relate atedd person personal al homepag home pages; es; many many people have downloadable software there. Many more user-created Python modules can be found in the Python Package Index (PyPI). For Python-related questions and problem reports, you can post to the newsgroup , or send them to the mailing list at . The newsgroup and mailing list are gatewayed, so messages posted to one will automatically be forwarded to the other. There are around 120 postings a day (with peaks up to several hundred), asking (and answering) questions, suggesting new features, and announcing new modules. Before posting, be sure to check the list of Frequently Asked Questions (also called the FAQ), FAQ), or look for it in the ‘ ’ director rectoryy of the Python Python source sourcedist distrib ributi ution. on. Mailin Mailingg list list archi archives vesare are avail availabl ablee at . The FAQ answers many of the questions that come up again and again, and may already contain the solution for your problem.
A. Függelék
Interactive Input Editing and History Substitution Some versions of the Python interpreter support editing of the current input line and history substitution, similar to facilities found in the Korn Korn shell and the GNU Bash shell. This is implemented using the GNU Readline library, which supports Emacs-style and vi-style editing. This library has its own documentation which I won’t duplicate here; however, the basics are easily explained. The interactive editing and history described here are optionally available in the U NI X and CygWin versions of the interpreter. interpr eter. This chapter does not document the editing facilities of Mark Hammond’s PythonWin package or the Tk-based environment, IDLE, distributed with Python. The command line history recall which operates within DOS boxes on NT and some other DOS and Windows flavors is yet another beast.
If supported, input line editing editing is active active whenever whenever the interpreter interpreter prints a primary or secondary prompt. prompt. The current line can be edited using the conventional conventional Emacs control characters. The most important of these are: C-A (Control-A) moves the cursor to the beginning of the line, C-E to the end, C-B moves it one position to the left, C-F to the right. Backspace erases the character to the left of the cursor, C-D the character to its right. C-K kills (erases) the rest of the line to the right of the cursor, C-Y yanks back the last killed string. C-underscore undoes the last change you made; it can be repeated for cumulative effect.
History substitution works as follows. All non-empty input lines issued are saved in a history buffer, and when a new prompt is given you are positioned on a new line at the bottom of this buffer. C-P moves one line up (back) in the history buffer, C-N moves moves one down. Any line in the history buffer can be edited; edited; an asterisk appears appears in front of the prompt to mark a line as modified. Pressing the Return key passes the current line to the interpreter. r everse search; C-S starts a forward search. C-R starts an incremental reverse
The key bindings and some other parameters of the Readline library can be customized by placing commands in an initialization file called ‘ ’. Key bindings have the form key-name: key-name: function-na function-name me
or "string": "string": function-na function-name me
and options can be set with set option-name option-name value
For example: # I prefer prefer vi-style vi-style editin editing: g: set editin editing-m g-mode ode vi # Edit Edit usin using g a sing single le line line: : set horizontalhorizontal-scrol scroll-mode l-mode On # Rebi Rebind nd some some keys keys: : Meta-h: Meta-h: backward-ki backward-kill-wor ll-word d "\C-u": "\C-u": universal-a universal-argumen rgument t "\C-x\C-r": re-read-init-file
Note that the default binding for Tab in Python is to insert a Tab character instead of Readline’s default filename completion function. If you insist, you can override this by putting Tab: complete complete
in your ‘ ’. (Of course, this makes it harder to type indented continuation lines if you’re accustomed to using Tab for that purpose.) Automatic Automatic completion completion of variable variable and module names is optionally optionally available available.. To enable enable it in the interpreter’ interpreter’ss 1 interactive mode, add the following to your startup file: import import rlcompleter rlcompleter, , readline readline readline.parse_and_bind(’tab: complete’)
This binds the Tab key to the completion function, so hitting the Tab key twice suggests completions; it looks at Python statement names, the current local variables, and the available module names. For dotted expressions such as string.a, it will evaluate the expression up to the final ‘ .’ and then suggest completions from the attributes of the resulting object. Note that this may execute application-defined code if an object with a __getattr__() method is part of the expression. A more capable startup file might look like this example. Note that this deletes the names it creates once they are no longer longer needed needed;; this this is done since since the startup startup file is exec execute utedd in the same same namesp namespace ace as the intera interacti ctive ve comman commands, ds, and removing the names n ames avoids creating side effects in the interactive environment. You You may find it convenient to keep some of the imported modules, such as os, which turn out to be needed in most sessions with the interpreter. 1
Python will execute the contents of a fi le identifi ed by the PYTHONSTARTUP environment variable when you start an interactive interpreter.
# # # # # # # # #
Add Add auto auto-c -com ompl plet etio ion n and and a stor stored ed hist histor ory y file file of comm comman ands ds to your your Pyth Python on intera interacti ctive ve interp interpret reter. er. Requir Requires es Python Python 2.0+, 2.0+, readli readline. ne. Autoco Autocompl mplete ete is boun bound d to the the Esc Esc key key by defa defaul ult t (you (you can can chan change ge it - see see read readli line ne docs docs). ). Stor Store e the the file file in ~/.p ~/.pys ysta tart rtup up, , and and set set an envi enviro ronm nmen ent t vari variab able le to poin point t to it: "export "export PYTHONSTARTUP= PYTHONSTARTUP=/max/ /max/home/i home/itamar tamar/.pyst /.pystartu artup" p" in bash. Note Note that that PYTH PYTHON ONST STAR ARTU TUP P does does *not *not* * expa expand nd "~", "~", so you you have have to put put in the the full full path path to your your home home dire direct ctor ory. y.
import import import import import import import import
atexit os readline readline rlcompleter rlcompleter
historyPath historyPath = os.path.exp os.path.expanduse anduser("~/. r("~/.pyhist pyhistory") ory") def save_history(historyPath=historyPath): import import readline readline readline.write_history_file(historyPath) if os.path.exists(historyPath): readline.read_history_file(historyPath) atexit.register(save_history) del os, atexit, atexit, readline, readline, rlcompleter rlcompleter, , save_histor save_history, y, historyPath historyPath
This facility is an enormous step forward compared to earlier versions of the interpreter; however, some wishes are left: It would be nice if the proper indentation indentation were were suggested on continuation continuation lines (the parser knows if an indent token is required next). The completion mechanism might use the interpreter’s symbol table. A command to check (or even suggest) matching parentheses, quotes, etc., would also be useful.
B. Függelék
Floating Point Arithmetic: Issues and Limitations Floating-poi Floating-point nt numbers are represented represented in computer computer hardware hardware as base 2 (binary) (binary) fractions. For example, example, the decimal fraction 0.125
has value 1/10 + 2/100 + 5/1000, and in the same way the binary fraction 0.001
has value 0/2 + 0/4 + 1/8. These two fractions have identical values, the only real difference being that the first is written in base 10 fractional notation, and the second in base 2. Unfortunately, most decimal fractions cannot be represented exactly as binary fractions. A consequence is that, in general, general, the decimal floating-poi floating-point nt numbers you enter are only approximated approximated by the binary floating-point floating-point numbers actually stored in the machine. The problem is easier to understand at first in base 10. Consider the fraction 1/3. You can approximate that as a base 10 fraction: 0.3
or, better, 0.33
or, better, 0.333
and so on. No matter how many digits you’re willing to write down, the result will never be exactly 1/3, but will be an increasingly better approximation of 1/3. In the same way, no matter how many base 2 digits you’re willing to use, the decimal value 0.1 cannot be represented exactly as a base 2 fraction. In base 2, 1/10 is the infinitely repeating fraction 0.0001100110011001100110011001100110011001100110011...
Stop at any finite number of bits, and you get an approximation. This is why you see things like:
>>> 0.1 0.10000000000000001
On most machines machines today, today, that is what what you’ll see see if you enter 0.1 at a Python prompt. You You may not, though, though, because because the number of bits used by the hardware to store floating-point values can vary across machines, and Python only prints a decimal approximation to the true decimal value of the binary approximation stored by the machine. On most machines, if Python were to print the true decimal value of the binary approximation stored for 0.1, it would have to display >>> 0.1 0.1000000000000000055511151231257827021181583404541015625
instead! The Python prompt (implicitly) uses the builtin repr() function to obtain a string version of everything it displays. For floats, repr( float ) rounds the true decimal value to 17 significant digits, giving 0.10000000000000001
repr( float ) produces 17 significant digits because it turns out that’s enough (on most machines) so that eval(repr( x)) == x exactly for all finite floats x, but rounding to 16 digits is not enough to make that
true. Note that this is in the very nature of binary floating-point: this is not a bug in Python, it is not a bug in your code either. You’ll see the same kind of thing in all languages that support your hardware’s floating-point arithmetic (although some languages may not display the difference by default, or in all output modes). Python’s builtin str() function function produces only 12 significant significant digits, and you may wish to use that instead. instead. It’s It’s unusual for eval(str( x)) to reproduce x, but the output may be more pleasant to look at: >>> print print str(0. str(0.1) 1) 0.1
It’s important to realize that this is, in a real sense, an illusion: the value in the machine is not exactly 1/10, you’re simply rounding the display of the true machine value. Other surprises follow from this one. For example, after seeing >>> 0.1 0.10000000000000001
you may be tempted to use the no difference:
round() function to chop it back to the single digit you expect. But that makes
>>> round( round(0.1 0.1, , 1) 0.10000000000000001
The problem is that the binary floating-point value stored for "0.1" was already the best possible binary approximation to 1/10, so trying to round it again can’t make it better: it was already as good as it gets. Another consequence is that since 0.1 is not exactly 1/10, adding 0.1 to itself 10 times may not yield exactly 1.0, either:
>>> >>> sum sum = 0.0 0.0 >>> >>> for for i in rang range( e(10 10): ): ... sum += 0.1 ... >>> sum 0.99999999999999989
Binary Binary floating-point floating-point arithmetic arithmetic holds many surprises like this. The problem with "0.1" is explained explained in precise detail below, in the "Representation Error" section. See The Perils of Floating Point for a more complete account of other common surprises. As that says near the end, „there are no easy answers.” Still, don’t be unduly wary of floating-point! The errors in Python float operations are inherited from the floating-point hardware, and on most machines are on the order of no more than 1 part in 2**53 per operation. That’s more than adequate for most tasks, but you do need to keep in mind that it’s not decimal arithmetic, and that every float operation oper ation can suffer a new rounding error. While pathological cases do exist, for most casual use of floating-point arithmetic you’ll see the result you expect in the end if you simply round the display of your final results to the number of decimal digits you expect. expect. str() usually suffices, and for finer control see the discussion of Python’s % format operator: the %g, %f and %e format codes supply flexible and easy ways to round float results for display.
This section explains the „0.1” example in detail, and shows how you can perform an exact analysis of cases like this yourself. Basic familiarity with binary floating-point representation is assumed. Representation error refers to that
some (most, actually) decimal fractions cannot be represented exactly as binary (base 2) fractions. fractions. This is the chief reason why Python Python (or Perl, C, C ++, Java, Fortran, and many others) often won’t display the exact decimal number you expect: >>> 0.1 0.10000000000000001
Why is that? 1/10 is not exactly representable as a binary fraction. Almost all machines today (November 2000) use IEEE-754 floating point arithmetic, and almost all platforms map Python floats to IEEE-754 "double precision". 754 doubles contain contain 53 bits of precision, precision, so on input the computer computer strives to convert convert 0.1 to the closest fraction it can of the form J /2** N where J is an integer containing exactly 53 bits. Rewriting 1 / 10 ~= J / (2**N)
as J ~= 2**N / 10
and recalling that J has exactly 53 bits (is >= >>> 2**52 2**52 4503599627370496L >>> 2L**53 2L**53 9007199254740992L >>> 2L**56/10 2L**56/10 7205759403792793L
2**52 2**52 but < 2**5 2**53 3), the best value for N is 56:
That is, 56 is the only value for N that leaves J with exactly exactly 53 bits. The best possible possible value for J is then that quotient rounded: >>> >>> q, r = divm divmod od(2 (2L* L**5 *56, 6, 10) 10) >>> >>> r 6L
Since the remainder is more than half of 10, the best approximation is obtained by rounding up: >>> q+1 7205759403792794L
Therefore the best possible approximation to 1/10 in 754 double precision is that over 2**56, or 72057594037 7205759403792794 92794 / 72057594037 7205759403792793 927936 6
Note that since we rounded up, this is actually a little bit larger than 1/10; if we had not rounded up, the quotient would have been a little bit smaller than 1/10. But in no case can it be exactly 1/10! So the computer never „sees” 1/10: what it sees is the exact fraction given above, the best 754 double approximation it can get: >>> >>> .1 * 2L** 2L**56 56 7205759403792794.0
If we multiply that fraction by 10**30, we can see the (truncated) value of its 30 most significant decimal digits: >>> 720575 720575940 940379 379279 2794L 4L * 10L**3 10L**30 0 / 2L**56 2L**56 100000000000000005551115123125L
mean meanin ingg that that the the exac exactt numb number er store storedd in the the comp comput uter er is appro approxi xima mate tely ly equa equall to the the deci decima mall valu valuee 0.100000000000000005551115123125. Rounding that to 17 significant digits gives the 0.10000000000000001 that Python displays (well, will display on any 754-conforming platform that does best-possible input and output conversions in its C library — yours may not!).
Note: GPL-compatible doesn’t mean that we’re distributing Python under the GPL. All Python licenses, unlike the GPL, let you distribute a modified version without making your changes open source. The GPL-compatible licenses make it possible to combine Python with other software that is released under the GPL; the others don’t. Thanks to the many outside volunteers who have worked under Guido’s Guido’s direction to make these releases possible.
PSF LICENSE AGREEMENT FOR PYTHON 2.4.1 1. This LICENSE AGREEMENT is between the Python Software Foundation („PSF”), and the Individual or Organization („Licensee”) accessing and otherwise using Python 2.4.1 software in source or binary form and its associated documentation. 2. Subject Subject to the terms and conditions conditions of this License License Agreement, Agreement, PSF hereby grants grants Licensee a nonexclunonexclusive, royalty-free, world-wide license to reproduce, analyze, test, perform and/or display publicly, prepare derivativ derivativee works, distribu distribute, te, and otherwise otherwise use Python 2.4.1 alone or in any derivativ derivativee version, version, provided, provided, however, that PSF’s License Agreement and PSF’s notice of copyright, i.e., „Copyright © 2001-2004 Python Software Foundation; All Rights Reserved” are retained in Python 2.4.1 alone or in any derivative version prepared by Licensee. 3. In the event Licensee prepares a derivative work that is based on or incorporates Python 2.4.1 or any part thereof, and wants to make the derivative work work available to others as provided herein, then Licensee hereby agrees to include in any such work a brief summary of the changes made to Python 2.4.1. 4. PSF is making making Python 2.4.1 availab available le to Licensee Licensee on an „AS IS” basis. basis. PSF MAKES NO REPRESEN REPRESENT TATIONS OR WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON 2.4.1 WILL NOT INFRINGE ANY THIRD PARTY PARTY RIGHTS. 5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON 2.4.1 FOR ANY INCIDENTAL, INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES DAMAGES OR LOSS AS A RESULT RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON 2.4.1, OR ANY DERIVATIVE THEREOF, REOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF. THEREOF. 6. This License Agreement will automatically terminate upon a material breach of its terms and conditions. 7. Nothing Nothing in this License Agreement Agreement shall be deemed to create create any relationship relationship of agency, agency, partnership, partnership, or joint venture venture between between PSF and Licensee. Licensee. This License Agreement Agreement does not grant permission permission to use PSF trademarks or trade name in a trademark sense to endorse or promote products or services of Licensee, or any third party. p arty. 8. By copying, installing or otherwise using Python 2.4.1, Licensee agrees to be bound by the terms and conditions of this License Agreement.
BEOPEN.COM LICENSE AGREEMENT FOR PYTHON 2.0 BEOPEN PYTHON OPEN SOURCE LICENSE AGREEMENT AGREEMENT VERSION 1 1. This LICENSE AGREEMENT is between BeOpen.com („BeOpen”), having an office at 160 Saratoga Avenue, Santa Clara, CA 95051, and the Individual or Organization („Licensee”) accessing and otherwise using this software in source or binary form and its associated documentation („the Software”). 2. Subject to the terms and conditions of this BeOpen Python License Agreement, BeOpen hereby grants Licensee a non-exclusive, royalty-free, world-wide license to reproduce, analyze, analyze, test, perform and/or display publicly publicly,, prepare derivativ derivativee works, distribute, distribute, and otherwise otherwise use the Software alone or in any derivative derivative version, version, provided, however however,, that the BeOpen BeOpen Python License is retained retained in the Software, alone or in any derivative derivative version prepared by Licensee. 3. BeOpen BeOpen is making the Software Software availabl availablee to Licensee Licensee on an „AS IS” basis. BEOPEN BEOPEN MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF EXAMPLE, BUT NOT
LIMITATION, LIMITATION, BEOPEN MAKES NO AND DISCLAIMS ANY REPRESENTATION REPRESENTATION OR WARRANTY OF MERCHANTABILITY MERCHANTABILITY OR FITNESS FOR ANY PARTICU PARTICULAR LAR PURPOSE OR THAT THAT THE USE OF THE SOFTWARE WILL NOT INFRINGE ANY THIRD PARTY RIGHTS. 4. BEOPEN BEOPEN SHALL NOT BE LIABLE LIABLE TO LICENSEE LICENSEE OR ANY OTHER USERS USERS OF THE SOFTWARE SOFTWARE FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THE SOFTWARE, OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF. 5. This License Agreement will automatically terminate upon a material breach of its terms and conditions. 6. This License Agreement shall be governed by and interpreted in all respects by the law of the State of California, California, excluding excluding conflict of law provisions. provisions. Nothing Nothing in this License Agreement Agreement shall be deemed deemed to create any relationship of agency, agency, partnership, or joint venture between BeOpen BeOpen and Licensee. This License Agreement does not grant permission to use BeOpen trademarks or trade names in a trademark sense to endorse or promote products products or services services of Licensee, Licensee, or any third party. party. As an exception, exception, the „BeOpen „BeOpen Python”logos Python” logos availab available le at http://www http://www.pytho .pythonlabs. nlabs.com/l com/logos.h ogos.html tmlmay may be used according according to the permissions permissions granted on that web page. 7. By copying, installing or otherwise using the software, Licensee agrees to be bound by the terms and conditions of this License Agreement.
CNRI LICENSE AGREEMENT AGREEMENT FOR PYTHON 1.6.1 1.6 .1 1. This LICENSE AGREEMENT is between the Corporation for National Research Initiatives, having an office at 1895 Preston White Drive, Reston, VA 20191 („CNRI”), and the Individual or Organization („Licensee”) accessing and otherwise using Python 1.6.1 software in source or binary form and its associated documentation. 2. Subject to the terms and conditions of this License Agreement, CNRI hereby grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce, analyze, test, perform and/or display publicly, prepare derivative works, distribute, and otherwise use Python 1.6.1 alone or in any derivative version, provided, however, that CNRI’s License Agreement and CNRI’s notice of copyright, i.e., „Copyright © 1995-2001 Corporation for National Research Initiatives; All Rights Reserved” are retained in Python 1.6.1 alone or in any derivativ derivativee version prepared prepared by Licensee. Licensee. Alternately Alternately,, in lieu of CNRI’s CNRI’s License License Agreement, Agreement, Licensee Licensee may substitute substitute the following text (omitting (omitting the quotes): quotes): „Python „Python 1.6.1 is made available available sub ject to the terms and conditions conditions in CNRI’s CNRI’s License Agreement. Agreement. This Agreement Agreement together with Python 1.6.1 may be located on the Internet using the following unique, persistent identifier (known as a handle): 1895.22 1895.22/10 /1013. 13. This This Agreem Agreement ent may also also be obtain obtained ed from a proxy proxy server server on the Internet Internetusi using ng the follow following ing URL: .” 3. In the event Licensee prepares a derivative work that is based on or incorporates Python 1.6.1 or any part thereof, and wants to make the derivative work work available to others as provided herein, then Licensee hereby agrees to include in any such work a brief summary of the changes made to Python 1.6.1. 4. CNRI is making Python 1.6.1 1.6.1 available available to Licensee Licensee on an „AS IS” basis. CNRI MAKES NO REPREREPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, CNRI MAKES NO AND DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON 1.6.1 WILL NOT INFRINGE ANY THIRD PARTY ARTY RIGHTS. 5. CNRI SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON 1.6.1 FOR ANY INCIDENTAL, INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES DAMAGES OR LOSS AS A RESULT RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON 1.6.1, OR ANY DERIVATIVE THEREOF, REOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF. THEREOF. 6. This License Agreement will automatically terminate upon a material breach of its terms and conditions. 7. This License Agreement shall be governed by the federal intellectual intellectual property law of the United States, including without limitation the federal copyright law, and, to the extent such U.S. federal law does not apply, by the law of the Commonwealth of Virginia, excluding Virginia’s Virginia’s conflict of law provisions. Notwithstanding the foregoing, with regard to derivative works based on Python 1.6.1 that incorporate non-separable
material that was previously distributed under the GNU General Public License (GPL), the law of the Commonwealth of Virginia shall govern this License Agreement only as to issues arising under or with respect to Paragraphs 4, 5, and 7 of this License Agreement. Nothing in this License Agreement shall be deemed to create any relationship of agency, partnership, or joint venture between CNRI and Licensee. This License Agreeme Agreement nt does does not grant grant permis permission sion to use CNRI CNRI tradem trademark arkss or trade trade name name in a trademar trademarkk sense sense to endorse endorse or promote products or services of Licensee, or any third party. 8. By clicking on the „ACCEPT” button where indicated, or by copying, installing or otherwise using Python 1.6.1, Licensee agrees to be bound by the terms and conditions of this License Agreement. ACCEPT CWI LICENSE AGREEMENT AGREEMENT FOR PYTHON 0.9.0 THROUGH 1.2 Copyright © 1991 - 1995, Stichting Mathematisch Centrum Amsterdam, The Netherlands. All rights reserved. Permis Permissio sionn to use, use, copy copy, mod modify ify,, and distri distribut butee this this softwa software re and its docu documen mentat tation ionfor for any purpose purpose and without withoutfee fee is hereby granted, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation, and that the name of Stichting Mathematisch Centrum or CWI not be used in advertising or publicity pertaining to distribution of the software without specific, written prior permission. STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, SOFTWARE, INCLUDING ALL IMPLIED IM PLIED WARRANTIES OF MERCHANTABILITY MERCHANTABILITY AND FITNESS, IN I N NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
This section is an incomplete, but growing list of licenses and acknowledgements for third-party software incorporated in the Python distribution.
The _random mod module ule include includess code code based based on a downloa downloadd from The following are the verbatim comments from the original code:
A C-prog C-program ram for MT1993 MT19937, 7, with with initia initializ lizati ation on improv improved ed 2002/1 2002/1/26 /26. . Coded Coded by Takuji Takuji Nishim Nishimura ura and Makoto Makoto Matsum Matsumoto oto. . Before Before using, using, initia initializ lize e the state state by using using init_g init_genr enrand and(se (seed) ed) or init_by_arr init_by_array(in ay(init_key it_key, , key_length). key_length). Copyri Copyright ght (C) 1997 1997 - 2002, 2002, Makoto Makoto Matsum Matsumoto oto and Takuji Takuji Nishim Nishimura ura, , All rights rights reserved. reserved. Redist Redistrib ributi ution on and use in source source and binary forms, forms, with with or withou without t modificatio modification, n, are permitted permitted provided provided that the following following conditions conditions are met: met: 1. Redist Redistrib ributi utions ons of source source code code must must retain retain the above above copyri copyright ght notice notice, , this this list list of condit condition ions s and the follow following ing discla disclaime imer. r. 2. Redist Redistrib ributi utions ons in binary binary form form must must reprod reproduce uce the above above copyri copyright ght notice notice, , this this list list of condit condition ions s and the follow following ing disclaime disclaimer r in the documentati documentation on and/or and/or other materials provided with the distributio distribution. n. 3. The The name names s of its its cont contri ribu buto tors rs may may not not be used used to endo endors rse e or prom promot ote e produc products ts derive derived d from from this this softwa software re withou without t specif specific ic prior prior writte written n permission. THIS THIS SOFTWA SOFTWARE RE IS PROVID PROVIDED ED BY THE COPYRI COPYRIGHT GHT HOLDER HOLDERS S AND CONTRI CONTRIBUT BUTORS ORS "AS IS" AND ANY EXPRES EXPRESS S OR IMPLIE IMPLIED D WARRAN WARRANTIE TIES, S, INCLUD INCLUDING ING, , BUT NOT LIMITE LIMITED D TO, THE IMPLIE IMPLIED D WARRAN WARRANTIE TIES S OF MERCHA MERCHANTA NTABIL BILITY ITY AND FITNES FITNESS S FOR A PART PARTIC ICUL ULAR AR PURP PURPOS OSE E ARE ARE DISC DISCLA LAIM IMED ED. . IN NO EVEN EVENT T SHAL SHALL L THE THE COPY COPYRI RIGH GHT T OWNE OWNER R OR CONTRI CONTRIBUT BUTORS ORS BE LIABLE LIABLE FOR ANY DIRECT DIRECT, , INDIRE INDIRECT, CT, INCIDE INCIDENTA NTAL, L, SPECIA SPECIAL, L, EXEMPL EXEMPLARY ARY, , OR CONSEQ CONSEQUEN UENTIA TIAL L DAMAGE DAMAGES S (INCLU (INCLUDIN DING, G, BUT NOT LIMITE LIMITED D TO, PROCUR PROCUREME EMENT NT OF SUBSTI SUBSTITUT TUTE E GOODS GOODS OR SERVIC SERVICES; ES; LOSS LOSS OF USE, USE, DATA, DATA, OR PROFIT PROFITS; S; OR BUSINE BUSINESS SS INTERR INTERRUPT UPTION ION) ) HOWEVE HOWEVER R CAUSED CAUSED AND ON ANY THEORY THEORY OF LIABIL LIABILITY ITY, , WHETHE WHETHER R IN CONTRA CONTRACT, CT, STRICT STRICT LIABIL LIABILITY ITY, , OR TORT TORT (INCLU (INCLUDIN DING G NEGL NEGLIG IGEN ENCE CE OR OTHE OTHERW RWIS ISE) E) ARIS ARISIN ING G IN ANY ANY WAY WAY OUT OUT OF THE THE USE USE OF THIS THIS SOFTWA SOFTWARE, RE, EVEN EVEN IF ADVISE ADVISED D OF THE POSSIB POSSIBILI ILITY TY OF SUCH SUCH DAMAGE DAMAGE. .
Any feedba feedback ck is very very welcom welcome. e. http://www.math.keio.ac.jp/matumoto/emt.html email: [email protected]
The socket module uses the functions, source files from the WIDE Project,
getaddrinfo,
and
getnameinfo,
.
which are coded in separate
Copyri Copyright ght (C) 1995, 1995, 1996, 1996, 1997, 1997, and 1998 WIDE WIDE Projec Project. t. All rights rights reserved. reserved. Redist Redistrib ributi ution on and use in source source and binary forms, forms, with with or withou without t modificatio modification, n, are permitted permitted provided provided that the following following conditions conditions are met: met: 1. Redist Redistrib ributi utions ons of source source code code must must retain retain the above above copyri copyright ght notice notice, , this this list list of condit condition ions s and the follow following ing discla disclaime imer. r. 2. Redist Redistrib ributi utions ons in binary binary form form must must reprod reproduce uce the above above copyri copyright ght notice notice, , this this list list of condit condition ions s and the follow following ing disclaime disclaimer r in the documentati documentation on and/or and/or other materials provided with the distribution distribution. . 3. Neit Neithe her r the the name name of the the proj projec ect t nor nor the the name names s of its its cont contri ribu buto tors rs may be used used to endors endorse e or promot promote e produc products ts derive derived d from from this this softwa software re without without specific specific prior written permission. permission. THIS THIS SOFTWA SOFTWARE RE IS PROVID PROVIDED ED BY THE PROJEC PROJECT T AND CONTRI CONTRIBUT BUTORS ORS ‘‘AS IS’’ IS’’ AND GAI_AN GAI_ANY Y EXPRES EXPRESS S OR IMPLIE IMPLIED D WARRAN WARRANTIE TIES, S, INCLUD INCLUDING ING, , BUT NOT LIMITE LIMITED D TO, THE IMPLIE IMPLIED D WARRAN WARRANTIE TIES S OF MERCHA MERCHANTA NTABIL BILITY ITY AND FITNES FITNESS S FOR A PARTIC PARTICULA ULAR R PURPOS PURPOSE E ARE ARE DISC DISCLA LAIM IMED ED. . IN NO EVEN EVENT T SHAL SHALL L THE THE PROJ PROJEC ECT T OR CONT CONTRI RIBU BUTO TORS RS BE LIAB LIABLE LE FOR GAI_ANY GAI_ANY DIRECT, DIRECT, INDIRECT, INDIRECT, INCIDENTAL, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTI CONSEQUENTIAL AL DAMAGE DAMAGES S (INCLU (INCLUDIN DING, G, BUT NOT LIMITE LIMITED D TO, PROCUR PROCUREME EMENT NT OF SUBSTI SUBSTITUT TUTE E GOODS GOODS OR SERVIC SERVICES; ES; LOSS OF USE, USE, DATA, DATA, OR PROFIT PROFITS; S; OR BUSINE BUSINESS SS INTERR INTERRUPT UPTION ION) ) HOWEVE HOWEVER R CAUSED CAUSED AND ON GAI_AN GAI_ANY Y THEORY THEORY OF LIABIL LIABILITY ITY, , WHETHE WHETHER R IN CONTRA CONTRACT, CT, STRICT STRICT LIABIL LIABILITY ITY, , OR TORT TORT (INCLU (INCLUDIN DING G NEGLIG NEGLIGENC ENCE E OR OTHERW OTHERWISE ISE) ) ARISIN ARISING G IN GAI_AN GAI_ANY Y WAY OUT OUT OF THE THE USE USE OF THIS THIS SOFT SOFTWA WARE RE, , EVEN EVEN IF ADVI ADVISE SED D OF THE THE POSS POSSIB IBIL ILIT ITY Y OF SUCH DAMAGE. DAMAGE.
The source for the fpectl module includes the following notice:
--------------------------------------------------------------------/ Copyright (c) 1996. \ | The Regents of the University of California. | | All rights reserved. | | | | Perm Permis issi sion on to to use, use, copy, copy, modi modify fy, , and and distr distrib ibut ute e this this soft softwa ware re for for | | any any purp purpos ose e with withou out t fee fee is here hereby by gra grant nted ed, , prov provid ided ed tha that t this this enen| | tire ire noti notice ce is is incl includ uded ed in in all all copi copies es of of any any soft softwa ware re whi which ch is is or | | includes a copy or modification of this software and in all | | copies of the supporting documentation for such software. | | | | This This work work was was pro produ duce ced d at at the the Univ Univer ersi sity ty of Cal Calif ifor orni nia, a, Lawr Lawren ence ce | | Live Liverm rmor ore e Nati Nation onal al Labo Labora rato tory ry unde under r cont contra ract ct no. no. W-74 W-7405 05-E -ENG NG-4 -48 8 | | between the U.S. Department of Energy and The Regents of the | | University of California for the operation of UC LLNL. | | | | DISCLAIMER | | | | This his soft softwa ware re was was pre prepa pare red d as an an acco accoun unt t of wor work k spon sponso sore red d by an an | | agen agency cy of the the Unit United ed Stat States es Gov Gover ernm nmen ent. t. Nei Neith ther er the the Unite United d Stat States es | | Gover overnm nmen ent t nor nor the the Univ Univer ersi sity ty of of Cali Califo forn rni ia nor nor any any of thei their r emem| | ploye loyees es, , mak make es any any warr warran anty ty, , exp expre ress ss or impl implie ied, d, or assu assum mes any any | | liabi iabili lity ty or resp respon onsi sibi bili lity ty for for the the accu accur racy, acy, comp comple lete tene ness ss, , or | | usefu sefuln lnes ess s of any info inform rmat atio ion, n, appa appara ratu tus, s, prod produc uct, t, or proc proces ess s | | disclosed, or represents that its use would not infringe | | priv privat atel elyy-ow owne ned d rig right hts. s. Ref Refer eren ence ce her herei ein n to any any spe speci cifi fic c comm commer er| | cial products, process, or service by trade name, trademark, | | manu manufa fact ctur urer er, , or or oth other erwi wise se, , do does not not nece neces ssari sarily ly cons consti tit tute ute or | | impl imply y its its endo endors rsem emen ent, t, reco recomm mmen enda dati tion on, , or or favo favori ring ng by the the Unit United ed | | Stat States es Gov Gover ernm nmen ent t or or the the Univ Univer ersi sity ty of Cal Calif ifor orni nia. a. The The view views s and and | | opin opinio ions ns of aut autho hors rs exp expre ress ssed ed here herein in do do not not nec neces essa sari rily ly stat state e or | | refl reflec ect t tho those se of the the Uni Unite ted d St States ates Gove Govern rnme ment nt or the the Univ Univer ersi sity ty | | of Cali Califo forn rnia ia, , and and sha shall ll not not be be use used d for for adve advert rtis isin ing g or or pr produc oduct t | \ endorsement purposes. / ---------------------------------------------------------------------
The source code for the md5 module contains the following notice:
Copyri Copyright ght (C) 1991-2 1991-2, , RSA Data Data Securi Security, ty, Inc. Inc. Create Created d 1991. 1991. All rights rights reserved. reserved. Lice Licens nse e to copy copy and and use use this this soft softwa ware re is gran grante ted d prov provid ided ed that that it is identi identifie fied d as the "RSA "RSA Data Data Securi Security, ty, Inc. Inc. MD5 Messag Message-D e-Dige igest st Algori Algorithm thm" " in all materi material al mentio mentionin ning g or refere referenci ncing ng this this softwa software re or this this functi function. on. Licens License e is also also grante granted d to make make and use deriva derivativ tive e works works provid provided ed that that such such work works s are are iden identi tifi fied ed as "der "deriv ived ed from from the the RSA RSA Data Data Securi Security, ty, Inc. Inc. MD5 Messag Message-D e-Dige igest st Algori Algorithm thm" " in all materi material al mentio mentionin ning g or refere referenci ncing ng the derive derived d work. work. RSA Data Data Securi Security, ty, Inc. Inc. makes makes no repres represent entati ations ons concer concernin ning g either either the mercha merchanta ntabil bility ity of this this softwa software re or the suitab suitabili ility ty of this this softwa software re for any partic particula ular r purpos purpose. e. It is provid provided ed "as is" withou without t expres express s or implie implied d warran warranty ty of any kind. kind. Thes These e noti notice ces s must must be reta retain ined ed in any any copi copies es of any any part part of this this documentati documentation on and/or and/or software. software.
The asynchat and asyncore modules contain the following notice: Copyri Copyright ght 1996 1996 by Sam Rushin Rushing g All Rights Rights Reserv Reserved ed Permis Permissio sion n to use, use, copy, copy, modify modify, , and distri distribut bute e this this softwa software re and its docume documenta ntatio tion n for any purpos purpose e and withou without t fee is hereby hereby grante granted, d, provid provided ed that that the above above copyri copyright ght notice notice appear appear in all copies copies and that that both both that that copyri copyright ght notice notice and this this permis permissio sion n notice notice appear in suppor supportin ting g docume documenta ntatio tion, n, and that that the name name of Sam Rushin Rushing g not be used used in advert advertisi ising ng or public publicity ity pertaini pertaining ng to distri distribut bution ion of the softwa software re withou without t specif specific, ic, writte written n prior prior permission. SAM RUSHIN RUSHING G DISCLA DISCLAIMS IMS ALL WARRAN WARRANTIE TIES S WITH WITH REGARD REGARD TO THIS THIS SOFTWA SOFTWARE, RE, INCLUD INCLUDING ING ALL IMPLIE IMPLIED D WARRAN WARRANTIE TIES S OF MERCHA MERCHANTA NTABIL BILITY ITY AND FITNES FITNESS, S, IN NO EVEN EVENT T SHAL SHALL L SAM SAM RUSH RUSHIN ING G BE LIAB LIABLE LE FOR FOR ANY ANY SPEC SPECIA IAL, L, INDI INDIRE RECT CT OR CONSEQ CONSEQUEN UENTIA TIAL L DAMAGE DAMAGES S OR ANY DAMAGE DAMAGES S WHATSO WHATSOEVE EVER R RESULT RESULTING ING FROM FROM LOSS LOSS OF USE, USE, DATA DATA OR PROF PROFIT ITS, S, WHET WHETHE HER R IN AN ACTI ACTION ON OF CONT CONTRA RACT CT, , NEGL NEGLIG IGEN ENCE CE OR OTHE OTHER R TORT TORTIO IOUS US ACTI ACTION ON, , ARIS ARISIN ING G OUT OUT OF OR IN CONNEC CONNECTIO TION N WITH WITH THE USE OR PERFOR PERFORMAN MANCE CE OF THIS THIS SOFTWA SOFTWARE. RE.
The Cookie module contains the following notice:
Copyright Copyright 2000 by Timothy Timothy O’Malley O’Malley > All Rights Rights Reserv Reserved ed Permis Permissio sion n to use, use, copy, copy, modify modify, , and distri distribut bute e this this softwa software re and its docume documenta ntatio tion n for any purpose purpose and without without fee is hereby hereby grante granted, d, provid provided ed that that the above above copyri copyright ght notice notice appear appear in all copies copies and that that both both that that copyri copyright ght notice notice and this this permis permissio sion n notice notice appear appear in suppor supportin ting g docume documenta ntatio tion, n, and that that the name name of Timo Timoth thy y O’Ma O’Mall lley ey not not be used used in adve advert rtis isin ing g or publ public icit ity y pertai pertainin ning g to distri distribut bution ion of the softwa software re withou without t specif specific, ic, writte written n prior permission. permission. Timoth Timothy y O’Mall O’Malley ey DISCLA DISCLAIMS IMS ALL WARRAN WARRANTIE TIES S WITH WITH REGARD REGARD TO THIS THIS SOFTWARE, SOFTWARE, INCLUDING ALL IMPLIED IMPLIED WARRANTIES WARRANTIES OF MERCHANTABI MERCHANTABILITY LITY AND AND FITN FITNES ESS, S, IN NO EVEN EVENT T SHAL SHALL L Timo Timoth thy y O’Ma O’Mall lley ey BE LIAB LIABLE LE FOR FOR ANY SPECIA SPECIAL, L, INDIRE INDIRECT CT OR CONSEQ CONSEQUEN UENTIA TIAL L DAMAGE DAMAGES S OR ANY DAMAGE DAMAGES S WHATSO WHATSOEVE EVER R RESULT RESULTING ING FROM LOSS LOSS OF USE, USE, DATA DATA OR PROFIT PROFITS, S, WHETHE WHETHER R IN AN ACTION ACTION OF CONTRA CONTRACT, CT, NEGLIGEN NEGLIGENCE CE OR OTHER OTHER TORTIO TORTIOUS US ACTI ACTION ON, , ARIS ARISIN ING G OUT OUT OF OR IN CONN CONNEC ECTI TION ON WITH WITH THE THE USE USE OR PERFOR PERFORMAN MANCE CE OF THIS THIS SOFTWA SOFTWARE. RE.
The profile and pstats modules contain the following notice: Copyri Copyright ght 1994, 1994, by InfoSe InfoSeek ek Corpor Corporati ation, on, all rights rights reserv reserved. ed. Writte Written n by James James Roskin Roskind d Permis Permissio sion n to use, use, copy, copy, modify modify, , and distri distribut bute e this this Python Python softwa software re and its associ associate ated d docume documenta ntatio tion n for any purpos purpose e (subje (subject ct to the restri restricti ction on in the follow following ing senten sentence) ce) withou without t fee is hereby hereby grante granted, d, provid provided ed that that the above above copyri copyright ght notice notice appear appears s in all copies copies, , and that that both both that that copyri copyright ght notice and this this permis permissio sion n notice notice appear appear in suppor supportin ting g docume documenta ntatio tion, n, and that the name of InfoSe InfoSeek ek not be used used in advert advertisi ising ng or public publicity ity pertai pertainin ning g to distri distribut bution ion of the softwa software re withou without t specif specific, ic, written written prior prior permis permissio sion. n. This This permis permissio sion n is explic explicitl itly y restri restricte cted d to the copyin copying g and modifi modificat cation ion of the softwa software re to rema remain in in Pyth Python on, , comp compil iled ed Pyth Python on, , or othe other r lang langua uage ges s (suc (such h as C) wherei wherein n the modifi modified ed or derive derived d code code is exclus exclusive ively ly import imported ed into into a Python Python module. module. INFOSE INFOSEEK EK CORPOR CORPORATI ATION ON DISCLA DISCLAIMS IMS ALL WARRAN WARRANTIE TIES S WITH WITH REGARD REGARD TO THIS THIS SOFTWA SOFTWARE, RE, INCLUD INCLUDING ING ALL IMPLIE IMPLIED D WARRAN WARRANTIE TIES S OF MERCHA MERCHANTA NTABIL BILITY ITY AND FITNES FITNESS. S. IN NO EVENT EVENT SHALL SHALL INFOSE INFOSEEK EK CORPOR CORPORATI ATION ON BE LIABLE LIABLE FOR ANY SPECIA SPECIAL, L, INDIRE INDIRECT CT OR CONSEQ CONSEQUEN UENTIA TIAL L DAMAGE DAMAGES S OR ANY DAMAGE DAMAGES S WHATSO WHATSOEVE EVER R RESU RESULT LTIN ING G FROM FROM LOSS LOSS OF USE, USE, DATA DATA OR PROF PROFIT ITS, S, WHET WHETHE HER R IN AN ACTI ACTION ON OF CONTRA CONTRACT, CT, NEGLIGENC NEGLIGENCE E OR OTHER OTHER TORTIO TORTIOUS US ACTION ACTION, , ARISIN ARISING G OUT OF OR IN CONNEC CONNECTIO TION N WITH WITH THE USE OR PERFOR PERFORMAN MANCE CE OF THIS THIS SOFTWA SOFTWARE. RE.
The trace module contains the following notice:
portio portions ns copyri copyright ght 2001, 2001, Autono Autonomou mous s Zones Zones Indust Industrie ries, s, Inc., Inc., all rights rights... ... err. err... .. rese reserv rved ed and offe offere red d to the the publ public ic under under the the term terms s of the the Python Python 2.2 licens license. e. Author: Author: Zooko O’Whielacro O’Whielacronx nx http://zooko.com/ mailto:[email protected] Copyri Copyright ght 2000, 2000, Mojam Mojam Media, Media, Inc., Inc., all rights rights reserv reserved. ed. Author: Author: Skip Montanaro Montanaro Copyri Copyright ght 1999, 1999, Biorea Bioreason son, , Inc., Inc., all rights rights reserv reserved. ed. Author: Author: Andrew Dalke Copyright Copyright 1995-1997, Automatrix, Automatrix, Inc., all rights rights reserved. reserved. Author: Author: Skip Montanaro Montanaro Copyright Copyright 1991-1995, 1991-1995, Stichting Stichting Mathematisc Mathematisch h Centrum, Centrum, all rights reserved.
Permis Permissio sion n to use, use, copy, copy, modify modify, , and distri distribut bute e this this Python Python softwa software re and its associ associate ated d docume documenta ntatio tion n for any purpos purpose e withou without t fee is hereby hereby grante granted, d, provid provided ed that that the above above copyri copyright ght notice notice appear appears s in all copies copies, , and that that both both that that copyri copyright ght notice notice and this this permis permissio sion n notice notice appear appear in suppor supportin ting g docume documenta ntatio tion, n, and that that the name name of neithe neither r Automa Automatri trix, x, Biorea Bioreason son or Mojam Mojam Media Media be used used in advert advertisi ising ng or public publicity ity pertai pertainin ning g to distri distribut bution ion of the softwa software re withou without t specif specific, ic, writte written n prior prior permis permissio sion. n.
The uu module contains the following notice: Copyri Copyright ght 1994 1994 by Lance Lance Elling Ellinghou house se Cathed Cathedral ral City, City, Califo Californi rnia a Republ Republic, ic, United United States States of Americ America. a. All Rights Rights Reserv Reserved ed Permis Permissio sion n to use, use, copy, copy, modify modify, , and distri distribut bute e this this softwa software re and its docume documenta ntatio tion n for any purpos purpose e and withou without t fee is hereby hereby grante granted, d, provid provided ed that that the above copyright copyright notice notice appear appear in all copies copies and that that both both that that copyri copyright ght notice notice and this this permis permissio sion n notice notice appear appear in suppor supportin ting g docume documenta ntatio tion, n, and that that the name name of Lance Lance Elling Ellinghou house se not be used used in advert advertisi ising ng or public publicity ity pertai pertainin ning g to distri distribut bution ion of the softwa software re withou without t specif specific, ic, writte written n prior prior permis permissio sion. n. LANCE LANCE ELLING ELLINGHOU HOUSE SE DISCLA DISCLAIMS IMS ALL WARRAN WARRANTIE TIES S WITH WITH REGARD REGARD TO THIS THIS SOFTWA SOFTWARE, RE, INCLUD INCLUDING ING ALL IMPLIE IMPLIED D WARRAN WARRANTIE TIES S OF MERCHA MERCHANTA NTABIL BILITY ITY AND FITNES FITNESS, S, IN NO EVENT EVENT SHALL SHALL LANCE LANCE ELLING ELLINGHOU HOUSE SE CENTRU CENTRUM M BE LIABLE LIABLE FOR ANY SPECIA SPECIAL, L, INDIRE INDIRECT CT OR CONSEQ CONSEQUEN UENTIA TIAL L DAMAGE DAMAGES S OR ANY DAMAGE DAMAGES S WHATSO WHATSOEVE EVER R RESULT RESULTING ING FROM LOSS LOSS OF USE, USE, DATA DATA OR PROFIT PROFITS, S, WHETHE WHETHER R IN AN ACTION ACTION OF CONTRA CONTRACT, CT, NEGLIG NEGLIGENC ENCE E OR OTHER OTHER TORTIO TORTIOUS US ACTION ACTION, , ARISIN ARISING G OUT OF OR IN CONN CONNEC ECTI TION ON WITH WITH THE THE USE USE OR PERF PERFOR ORMA MANC NCE E OF THIS THIS SOFT SOFTWA WARE RE. . Modifi Modified ed by Jack Jack Jansen Jansen, , CWI, CWI, July July 1995: 1995: - Use binascii binascii module module to do the actual actual line-by-l line-by-line ine conversio conversion n betw betwee een n asci ascii i and and bina binary ry. . This This resu result lts s in a 1000 1000-f -fol old d spee speedu dup. p. The The C versio version n is still still 5 times times faster faster, , though though. . - Argume Arguments nts more more compli compliant ant with with python python standa standard rd
The xmlrpclib module contains the following notice: The XML-RP XML-RPC C client client interf interface ace is Copyri Copyright ght (c) 1999-2 1999-2002 002 by Secret Secret Labs AB Copyri Copyright ght (c) 1999-2 1999-2002 002 by Fredri Fredrik k Lundh Lundh By obtain obtaining ing, , using, using, and/or and/or copyin copying g this this softwa software re and/or and/or its associ associate ated d docume documenta ntatio tion, n, you agree agree that that you have have read, read, unders understoo tood, d, and will will comply comply with with the follow following ing terms and condit condition ions: s: Permis Permissio sion n to use, use, copy, copy, modify modify, , and distri distribut bute e this this softwa software re and its associ associate ated d docume documenta ntatio tion n for any purpos purpose e and withou without t fee is hereby hereby grante granted, d, provid provided ed that that the above above copyri copyright ght notice notice appear appears s in all copies copies, , and that that both both that that copyri copyright ght notice and this this permis permissio sion n notice notice appear appear in suppor supportin ting g docume documenta ntatio tion, n, and that that the name name of Secr Secret et Labs Labs AB or the the auth author or not not be used used in adve advert rtis isin ing g or publ public icit ity y pertai pertainin ning g to distri distribut bution ion of the softwa software re withou without t specif specific, ic, writte written n prior permission. permission. SECRET SECRET LABS AB AND THE AUTHOR DISCLAIM DISCLAIMS S ALL WARRAN WARRANTIE TIES S WITH WITH REGARD REGARD TO THIS THIS SOFTWA SOFTWARE, RE, INCLUD INCLUDING ING ALL IMPLIE IMPLIED D WARRAN WARRANTIE TIES S OF MERCHA MERCHANTNTABIL ABILIT ITY Y AND AND FITN FITNES ESS. S. IN NO EVENT EVENT SHAL SHALL L SECR SECRET ET LABS AB OR THE AUTH AUTHOR OR BE LIABLE LIABLE FOR ANY SPECIA SPECIAL, L, INDIRE INDIRECT CT OR CONSEQ CONSEQUEN UENTIA TIAL L DAMAGE DAMAGES S OR ANY DAMAGE DAMAGES S WHATSO WHATSOEVE EVER R RESULT RESULTING ING FROM FROM LOSS LOSS OF USE, USE, DATA DATA OR PROFIT PROFITS, S, WHETHE WHETHER R IN AN ACTION ACTION OF CONTRA CONTRACT, CT, NEGLIGEN NEGLIGENCE CE OR OTHER OTHER TORTIO TORTIOUS US ACTI ACTION ON, , ARIS ARISIN ING G OUT OUT OF OR IN CONN CONNEC ECTI TION ON WITH WITH THE THE USE USE OR PERF PERFOR ORMA MANC NCE E OF THIS THIS SOFTWA SOFTWARE. RE.
D. Függelék
Glossary >>>
The typical Python prompt of the interactive shell. Often seen for code examples that can be tried right away in the interpreter.
...
The typical Python prompt of the interactive shell when entering code for an indented code block.
BDFL Benevolent Dictator For Life, a.k.a. Guido van Rossum, Python’s creator. byte code The internal representation of a Python program in the interpreter. The byte code is also cached in the .pyc and .pyo files so that executing the same file is faster the second time (compilation from source to byte code can be saved). This „intermediate language” is said to run on a „virtual machine” that calls the subroutines corresponding to each bytecode. classic class Any class which does not inherit from object. See new-style class. coercion The implicit conversion of an instance of one type to another during an operation which involves two arguments arguments of the same type. For example, example, int(3.15) converts the floating point number to the integer 3, but in 3+4.5, each argument is of a different type (one int, one float), and both must be converted to the same type before they can be added or it will raise a TypeError. Coerci Coercion on betwe between en two operands can be performed with the coerce builtin function; thus, 3+4.5 is equivalent to calling ithout cooperator.add(*coerce(3, operator.add(*coerce(3, 4.5)) and results in operator.add(3.0, operator.add(3.0, 4.5). Without ercion, all arguments of even compatible types would have to be normalized to the same value by the programmer, programmer, e.g., float(3)+4.5 rather than just 3+4.5. complex number An extension of the familiar real number system in which all numbers are expressed as a sum of a real part and an imaginary part. Imaginary numbers are real multiples of the imaginary unit (the square root of -1), often written i in mathematics or j in engineering. engineering. Python has builtin builtin support for complex complex numbers, numbers, which are written written with this latter latter notation; notation; the imaginary imaginary part is written written with a j suffix, e.g., 3+1j. To get access to complex equivalents of the math module, use cmath. Use of complex numbers is a fairly advanced mathematical feature. If you’re not aware of a need for them, it’s almost certain you can safely ignore them. descriptor Any new-style object that defines the methods __get__(), __set__(), or __delete__(). When a class attribute is a descriptor, its special binding behavior is triggered upon attribute lookup. Normally, writing a.b looks up the object b in the class dictionary for a, but if b is a descriptor, the defined method gets called. called. Understandi Understanding ng descriptors descriptors is a key to a deep understanding understanding of Python because they are the basis for many features including functions, methods, properties, class methods, static methods, and reference to super classes. dictionary An associative array, where arbitrary keys are mapped to values. The use of dict much resembles that for list, but the keys can be any object with a __hash__() function, not just integers starting from zero. Called a hash in Perl. duck-typing Pythonic programming style that determines an object’s type by inspection of its method or attribute signature rather than by explicit relationship to some type object ("If it looks like a duck and quacks like a duck, it must be a duck.") By emphasizing interfaces rather than specific types, well-designed code
improves its flexibility by allowing polymorphic substitution. Duck-typing avoids tests using isinstance(). Instead, it typically employs hasattr() tests or EAFP programming.
type() or
EAFP Easier to ask for forgiveness than permission. This common Python coding style assumes the existence of valid keys or attributes and catches exceptions if the assumption proves false. This clean and fast style is characterized by the presence of many try and except statements. The technique contrasts with the LBYL style that is common in many other languages such as C. compa__future__ A pseudo module which programmers can use to enable new language features which are not compatible with the current interpreter. For example, the expression 11/4 currently evaluates to 2. If the module in which it is executed had enabled true division by executing: from __future__ __future__ import division division
the expression 11/4 would evaluate to 2.75. By actually importing the __future__ module and evaluating its variables, you can see when a new feature was first added to the language and when it will become the default: >>> import import __future__ __future__ >>> __future__. __future__.divis division ion _Fe _Feat atur ure( e((2 (2, , 2, 0, ’alp ’alpha ha’, ’, 2), 2), (3, (3, 0, 0, ’alp ’alpha ha’, ’, 0), 0), 8192 8192) )
iterator. It looks like a normal function except except that values are returned to the generator A function that returns an iterator. caller using a yield statement instead of a return statement. Generator functions often contain one or more for or while loops that yield elements back to the caller. caller. The function execution is stopped at the yield keyword (returning the result) and is resumed there when the next element is requested by calling the next() method of the returned iterator.
generator expression An expression expression that returns a generator generator.. It looks like a normal expression expression followed by a for expression defining a loop variable, range, and an optional if expression. The combined expression generates values for an enclosing function: >>> su sum(i*i fo for i in ra range(10)) 285
# su sum of of sq squares 0, 1, 1, 4, 4, .. ... 81 81
GIL See global interpreter lock . global interpreter lock The lock used by Python threads to assure that only one thread can be run at a time. This simplifies Python by assuring that no two processes can access the same memory at the same time. Locking the entire interpreter makes it easier for the interpreter to be multi-threaded, at the expense of some parallelism on multi-processor machines. Efforts have been made in the past to create a „free-threaded” interpreter terpreter (one which which locks shared data data at a much finer granularity), granularity), but performance performance suffered suffered in the common single-processor case. IDLE An Integrated Development Environment for Python. IDLE is a basic editor and interpreter environment that ships with the standard distribution of Python. Good for beginners, it also serves as clear example code for those wanting to implement a moderately sophisticated, multi-platform GUI application. immutable An object with fixed value. value. Immutable Immutable objects objects are numbers, strings or tuples (and more). Such an object cannot be altered. A new object has to be created if a different value has to be stored. They play an important role in places where a constant hash value is needed, for example as a key in a dictionary. integer division Mathematical division discarding any remainder. For example, the expression 11/4 currently evaluates to 2 in contrast to the 2.75 returned by float division. Also called floor division. When dividing two integers the outcome will always be another integer (having the floor function applied to it). However, if one of the operands is another numeric type (such as a float), the result will be coerced (see coercion) to a common type. For example, example, an integer integer divided divided by a float will result in a float value, possibly possibly with a decimal fraction. Integer division can be forced by using the // operator instead of the / operator. See also __future__.
interactivee interpreter interpreter which means that you can try out things and immediately immediately see interactive Python has an interactiv their results. Just launch python with no arguments (possibly by selecting it from your computer’s main menu). menu). It is a very very powerful powerful way to test out new ideas ideas or inspec inspectt modules modules and package packagess (remember (remember help(x)). language, as opposed to a compiled compiled one. This means that the source files interpreted Python is an interpreted language, can be run directly without first creating an executable which is then run. Interpreted languages typically have a shorter development/debug development/debug cycle than than compiled ones, though their programs generally also run more slowly. slowly. See also interactive. object capable of returning its members one at a time. Examples Examples of iterables include all iterable A container object sequence types (such as list, str, and tuple) and some non-sequence types like dict and file and objects of any classes you define with an __iter__() or __getitem__() method. Iterables can be used in a for loop and in many other places where a sequence is needed ( zip(), map(), ...). When an iterable object is passed as an argument to the builtin function iter(), it returns an iterator for the object. This iterator iterator is good for one pass over the set of values. values. When using iterables iterables,, it is usually not necessary necessary to call iter() or deal with iterator objects yourself. The for statement does that automatically for you, creating creating a temporary temporary unnamed variable variable to hold the iterator iterator for the duration duration of the loop. See also iterator , sequence, and generator . representing a stream stream of data. Repeated Repeated calls to the iterator’s iterator’s next() method return suciterator An object representing cessi cessive ve items items in the stream. stream. When When no more more data is avail availabl ablee a StopIteration exception is raised instead. At this point, the iterator object is exhausted and any further calls to its next() method just raise StopIteration again. Iterators are required to have an __iter__() method that returns the iterator object itself so every iterator is also iterable and may be used in most places where other iterables are accepted. One notable exception is code that attempts multiple iteration passes. A container object (such as a list) produces a fresh new iterator each time you pass it to the iter() function or use it in a for loop. Attempting this with an iterator will just return the same exhausted iterator object used in the previous iteration pass, making it appear like an empty container.
list comprehension A compact way to process all or a subset of elements in a sequence and return a list with the results. resu result lt = ["0x ["0x%0 %02x 2x" " %x for for x in rang range( e(25 256) 6) if x %2 == 0]generates a list of strings containing hex numbers (0x..) that are even and in the range from 0 to 255. The if clause is optional. If omitted, all elements in range(256) are processed. LBYL Look before you leap. This coding style explicitly tests for pre-conditions before making calls or lookups. This style contrasts with the EAFP approach and is characterized by the presence of many if statements. mapping A container object (such as __getitem__().
dict)
that supports arbitrary key lookups using the special method
metaclass The class of a class. Class definitions create a class name, a class dictionary, and a list of base classes. The metaclass is responsible for taking those three arguments and creating the class. Most object oriented programming languages provide a default implementation. What makes Python special special is that it is possible to create custom metaclasses. Most users never need this tool, but when the need arises, metaclasses can provide powerful, elegant solutions. They have been used for logging attribute access, adding thread-safety, tracking object creation, implementing singletons, and many other tasks. mutable Mutable objects can change their value but keep their
id(). See also immutable.
namespace The place where a variable variable is stored. Namespaces Namespaces are implemente implementedd as dictionaries. dictionaries. There are the local, global and builtin namespaces namespaces as well asnested asnested namespaces namespaces in objects objects (in methods). methods). Namespaces Namespaces support modularity by preventing naming conflicts. For instance, the functions __builtin__.open() and os.open() are distinguished by their namespaces. Namespaces also aid readability and maintainability by making it clear which modules modules implement a function. For instance, instance, writing random.seed() or itertools.izip() makes it clear that those functions are implemented by the random and itertools modules respectively. respectively. nested scope The ability to refer to a variable in an enclosing definition. For instance, a function defined inside another function can refer to variables variables in the outer function. Note that nested scopes work only for reference and not for assignment which will always always write to the innermost scope. In contrast, local variables both read and write in the innermost scope. Likewise, global variables read and write to the global namespace.
includes all built-in built-in types types like list and dict. new-style class Any class that inherits from object. This includes Only new-style classes can use Python’s newer, versatile features like __slots__, descriptors, properties, __getattribute__(), class methods, and static methods. no t required be backward compatible, with telepathic interface. Python3000 A mythical python release, not pr e-declaring space for instance attributes __slots__ A declaration inside a new-style class that saves memory by pre-declaring and eliminating instance dictionaries. Though popular, the technique is somewhat tricky to get right and is best reserved for rare cases where there are large numbers of instances in a memory-critical application.
sequence An iterable which supports efficient element access using integer indices via the __getitem__() and __len__() special methods. Some built-in sequence types are list, str, tuple, and unicode. Note that dict also supports __getitem__() and __len__(), but is considered a mapping rather than a sequence because the lookups use arbitrary immutable keys rather than integers. Zen of Python Listing of Python design principles and philosophies that are helpful in understanding and using the language. The listing can be found by typing „ import import this” at the interactive prompt.
..., 113 »>, 113 __all__, 47 __builtin__ (built-in module), 45
__future__, 114 __slots__, 116 append() (list method), 29
BDFL, 113 byte code, 113 classic class, 113 coercion, 113 compileall (standard module), 44 complex number, 113 count() (list method), 29 descriptor, 113 dictionary, 113 docstrings, 27 documentation strings, 27 dokumentációs karakterlánc, 22 duck-typing, 113 EAFP, 114 environment variables PATH, 5, 43 PYTHONPATH, 43, 44 PYTHONSTARTUP, 6, 94 extend() (list method), 29 file object, 54 generator, 114 generator expression, 114
GIL, 114 global interpreter lock, 114 help() (built-in function), 77
IDLE, 114 immutable, 114 index() (list method), 29 insert() (list method), 29 integer division, 114 interactive, 114 interpreted, 115 iterable, 115 iterator, 115 karakterláncok, dokumentáció, 22 LBYL, 115 list comprehension, 115 mapping, 115 metaclass, 115 method object, 69 module search path, 43 mutable, 115 namespace, 115 nested scope, 115 new-style class, 115 object file, 54 method, 69 open() (built-in function), 54 PATH, 5, 43
path module search, 43 pickle (standard module), 56 pop() (list method), 29
Python3000, 116 PYTHONPATH, 43, 44 PYTHONSTARTUP, PYTHONSTARTUP, 6, 94 readline (built-in module), 94 remove() (list method), 29 reverse() (list method), 29 rlcompleter (standard module), 94
search path, module, 43 sequence, 116 sort() (list method), 29 string (standard module), 51 strings, documentation, 27 sys (standard module), 44 unicode() (built-in function), 15
Zen of Python, 116