python_roco_20120229

Bevezetés a Python 3-ba # a s z a ka s z na k " v an e gy " k ez d ö p on t ja , s e l f . extrem = Point (x2 , y2) # és "van egy" végpontja d ef __str__( s e l f ) : return ( " S egment  :  [ ( { : g } ,  { : g } ) ,  ( { : g } ,  { : g } ) ] " . format ( s e l f . ori g . px , s e l f . or ig . py , s e l f . extrem . px , s e l f . extrem . py )) s = Seg ment ( 1 . 0 , 2 . 0 , 3 . 0 , 4 . 0 ) p r i n t ( s ) # Segment : [ ( 1 , 2 ) , ( 3 , 4 ) ]  

©

7.8.2. Leszármaztatás Definíció A leszármaztatás az alosztályok specializációval történő létrehozását írja le. Ebben az esetben az öröklési mechanizmust alkalmazzuk. A Python implementáció általában a szülőosztály konstruktorát hívája a leszármaztatott osztály konstruktorában, akár névszerint, akár a super utasítással. Példa

 c l a s s Rectan gle : d ef __init__( se lf , leng th =30, width=15): s e l f . L , s e l f . l , s e l f . name = l e ng t h , wi dt h , " r e c t a n g l e " c l a s s Square ( Recta ngle ): # e g y s z e r ü ö r ö k l é s " " " A R e c ta n g l e s z up e r − c l a s s s p e c i a l i z á l t a l o s z t á l y a . " " " d ef __init__( s el f , si de =20): # A Square szuper −c l a s s e −á nak k o n s t r u k to r á t h í v j uk : super () . __init__( sid e , si de ) s e l f .name = " square " # a z a t tr i bu t um ú j r a d e f i n i á l á s a  

80

c Hungarian Translation Daróczy Péter 

©

Bevezetés a Python 3-ba

8. fejezet Haladó technikák Ez a fejezet bemutat néhány haladó programozási technikát abból a három paradigmából, amit a Python támogat : a procedurális, az objektum és a funkcionális programozásból.

8.1. Procedurális technikák 8.1.1. A dokumentálás javítása A printApi() felhasználói függvény szűri az element rendelkezésre álló metódusait és a kapcsolódó docstring -eket olvashatóbb formában írja ki, mint a help() :  def printAp i ( element ): methods = [ el f o r e l in dir (element ) i f n o t el . st ar ts wi th ( ’_’ )] f o r meth in methods : p r i n t ( g e t a t t r ( eleme nt , meth ) . __doc__) i f __name__ == "__main__" : pr in tAp i ( [ ] ) """ L . append ( ob j ec t ) −− a pp end o b j e c t t o end L. count ( val ue ) −> i n t eg e r −− r e t ur n number o f o c c u r r en c e s o f v a lu e L. extend( it er ab le ) −− e xt en d l i s t by a pp en di ng e l e me n t s f ro m t h e i t e r a b l e L. index ( value , [ sta rt , [ stop ] ] ) −> i n t e ge r −− c Robert Cordeau 

81

Bevezetés a Python 3-ba r et ur n f i r s t i nd ex o f v al ue . R a is e s V al ue Er ro r i f t he v al ue i s n ot p r es e nt . L . i n s e r t ( i n d ex , o b j e c t ) −− i n s e r t o b je ct b ef o re i nd ex L. pop ( [ index ]) −> item −− remove and r e t ur n i te m a t i n de x ( d e f a u l t l a s t ) . R a i se s I n de xE rr or i f l i s t i s empty o r i nd ex i s o ut o f r an ge . L . remove ( va lu e ) −− remove f i r s t o c cu r re n ce o f v al ue . R a is e s V al ue Er ro r i f t he v al ue i s n ot p r es e nt . L. rever se () −− r e v e r s e ∗ IN PLACE∗ L . s o r t (cmp=None , key=None , r e v e r s e=Fal se ) −− s t a b le s o r t ∗ IN PLACE ∗ ; cmp(x , y) −> −1, 0 , 1 """  © 

8.1.2. Menük készítése szótárral Egy szótár kulcs:érték párját a következő módon használhatjuk fel egy menü implementálására : - a kulcs legyen a menü egy elemének a neve; - a megfelelő érték egy hivatkozás : egy argumentum nélküli eljárás hívása. A példa egy FIFO programozását mutatja be. Ezt az adatstruktúrát egy jegypénztárnál várakozó sor illusztrálja : az első érkezőt szolgálják ki először. A függvénymodul forráskódja :  "" " Egy FIFO queue adminisztr á ci ós modulja "" " queue = [ ] # i n i c i a l i z á l á s d ef intoQueue ( ) : queue . append( in t ( inpu t ( " Irj on beegy egé sze t  :  " ))) d ef fromQueue ( ) : i f len ( queue) == 0: p r i n t ( "\ nLehe tetle n  : ür es a sor  ! " ) else : p r i n t ( "\nA’%d ’  . elem tö rö lv e van " % queue . pop (0 )) d ef writeQueue ( ) : p r i n t ( " \nqueue : " , queue )   82

© c Hungarian Translation Daróczy Péter 

Bevezetés a Python 3-ba Az adminisztrációs menü forráskódja

 " " " Egy FIFO queue implementá l ás a egy l i s t á val . Egy ( sz ót á ra t haszná l ó ) menü argumentum n é l k ü l i e l j á r á s o ka t h í v """ # import from queue_FIFO_menu_m import intoQueue , fromQueue , writeQueue # main program −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− writeQueue () CMDs = { ’ a ’ : intoQu eue , ’ v ’ : writeQu eue , ’ s ’ : fromQueue} menu = " " " (A)ppend (V)iew (S)upprimer (Q) ui t Your choice ? """ while True : while True : tr y : ch oi ce = inpu t (menu ) . st r i p ( ) [ 0 ] . lower () except : choice = ’q ’ i f c h o i c e n o t i n ’ avsq ’ : p r i n t ( " In va li d  opt ion  ! Tryaga in " ) else : break

 

i f cho ice == ’q ’ : p r i n t ( " \Qu it  ! " ) break CMDs[ ch oi ce ] ( )

c Robert Cordeau 

© 83


8.1.3. Rekurzív függvények Definíció Egy rekurziv függvény hívhatja önmagát. Például egy N elemű táblázat elemeinek növekvő sorrendbe rendezéseelőször kiválasztjuk a legkisebb elemet, majd rendezzük a maradék N-1 elemű táblázatot. Bár gyakran nehezebb megérteni és kódolni ezt a módszert, mint a klasszikus iterratívnak nevezett módszert, bizonyos esetekben ez a módszer a legközvetlenebb alkalmazása a matematikai definíciónak. A következő klasszikus példa a faktoriális függvény definíciója rekurzióval 1:

 1, n! = n ∗ (n − 1)!,

ha n = 0 , ha n ≥ 1

Megjegyzés A matematikai definíciót nagyon pontosan másolja a kód :

 d ef f a c t o r i a l ( n ) : i f n == 0: # a l a p e se t : a b e f e j e z é s f e l t é t e l e return 1 e l s e # r e ku r z í v e s e t return n ∗ f a c t o r i a l ( n−1)  ©  Ebben a definícióban az n! értéke nem ismert, amíg el nem érjük a rekurzió befejező feltételét (itt n = = 0). A program mindaddig halmozza a rekurzív függvényhívásokat, míg el nem éri a befejezés feltételét, majd a legutolsó függvényhívástól kezdve kiszámolja a függvényértékeket. Az ábra ezt a mechanizmust szemlélteti.

1

Szemben az iterrativ definícióval : n! = n*(n-1)*(n-2)*...*2*1

84



8.1. ábra. A 4! rekurzív kiszámításának modellje

8.1.4. A generátorok és a generátor-kifejezések A generátorok A generátorok egy olyan eszközt adnak a kezünkbe, amivel megvalósítható a késleltetett kiértékelésnek ("lazy evaluation " vagy call-by-need ) nevezett kiértékelési stratégia. Ennek az a lényege, hogy mindaddig késlelteti egy kifejezés kiértékelését, amíg az értékre ténylegesen szükség lesz. Ez sokkal hatékonyabbnak bizonyulhat (memóriahasználatban), mint például egy nagy lista egyszerre történő kiszámolása. A következő generátorpélda annyi értéket ad meg, amennyit kérünk :  def qua rte rs ( next_quarter =0.0 ): while True : y i e l d n e xt _ qu a rt e r next_quarter += 0.25 i f __name__ == "__main__" : result = [] for x in quarters () : re su lt . append(x ) i f x == 1 . 0 : break c Robert Cordeau 

85

Bevezetés a Python 3-ba p r i n t ( "Eredmé ny li st a  : " , re su lt ) # Eredmé n y l i s t a : [ 0 . 0 , 0 . 2 5 , 0 . 5 , 0 . 7 5 , 1 . 0 ]  

©

Egy kezdőérték is átadható a generátornak :  # import import s ys d ef qua rte rs ( next_quarter =0. 0): while True : r e c e i v e d = ( y i e l d n e xt _ qu a rt er ) i f r e c e i v e d i s None: next_quarter += 0.25 else : next_quarter += received i f __name__ == "__main__" : result = [ ] generator = quarters () while l e n ( r e s u l t ) < 5 : x = next ( generat or ) i f a b s ( x − 0 . 5 ) < s y s . f l o a t _ i n f o . e p s i l o n : x = genera tor . send (1 .0 ) # ú j r a i n i c i a l i z á l j a a g en er á t o r t re su lt . append(x ) p r i n t ( "Eredmé n yl i s ta  :  " , re s u l t ) # Eredmé n y l i s t a : [ 0 . 0 , 0 . 2 5 , 1 . 5 , 1 . 7 5 , 2 . 0 ]  ©  A generátorkifejezések Szintaxis Egy generátorkifejezésnek majdnem azonos a szintaxisa a szűkített listák szintaxisával; a különbség az, hogy egy generátorkifejezés zárójelbe van zárva.

8.1.5. Egymásba ágyazott függvények (closure) A Pythonban a függvénydefiníció szintaxisa megengedi a függvénydefiníciók egymásba ágyazását. Két alkalmazást különböztetünk meg : 86


Bevezetés a Python 3-ba • A függvénygyár-idióma visszatérési értéke egy beágyazott függvény :



d ef create _plus (add ) : " "" Függvé nygyár " " " d ef pl us ( incremen t ): " " " B eá g y a z o t t f ü g gv é ny : a c r e a t e_ p l u s ( ) l o k á l i s n e v e i t h as zn á l j a . " " " return increment + add r e t u r n plus

# Föprogram −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− ## ké t kül önbözö f üggvénygyár gener á l ása p = create_plus (23) q = create_plus (42) ## a lka lmaz á s p r i n t ( "p(100 )=" , p(1 00)) p r i n t ( "q (100) =" , q( 100) )  

©

• A függvénygyár egy osztályt ad visszatérési értékül :

 # classes c l a s s CaseNormal ( ob je ct ) : def aMethod( s e l f ) : p r i n t ( " normal " )

c l a s s CaseS pecia l ( ob jec t ) : def aMethod( s e l f ) : p r i n t ( " sp ec ia l " ) # function d ef ca se Is Su it ab le Fo r ( isNormal=True ): "" "Függvénygyár , aminek vi ss za t ér é si é rt éke e gy o s z t á l y . " " " return CaseNormal() i f isNormal e l s e CaseSpecial () # Föprogram #−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− a n _i n st a nc e = c a s e I s S u i t a b l e F o r ( ) an_insta nce . aMethod () # normal o t h e r _ in s t a n c e = c a s e I s S u i t a b l e F o r ( F a l s e ) other _inst ance . aMethod () # s p e c i a l   c Robert Cordeau 

© 87


8.1.6. A dekorátorok A Python dekorátorok olyan függvények, amik egy függvény, metódus vagy osztály hívásakor lehetővé teszik előzetes műveletek végrehajtását. Szintaxis Legyen deco() egy dekorátor. Egy függvény dekorálásához a következőt kell írnunk:

@deco d ef fu nct ion ( arg1 , arg2 , . . . ) : pass  

©

Ez az írásmód egyenértékű a következö függvénykompozícióval :  d ef fu nct ion ( arg1 , arg2 , . . . ) : pass f u n c t i o n = d ec o ( f u n c t i o n ) #−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− # Egy t ö b b sz ö r ö s e n d ek o r á l t g f ü g gv é ny p é l d á j a @f1 @f2 @f3 d ef g ( ) : pass # A j e l ö l é s e gy en é r t é kü a k ö v e t ke z ö v e l : g = f 1 ( f 2 ( f 3 ( g ) ) )  © 

Egy egyszerű példa : # függvények d ef unDecorateur ( f ): d ef _int erne ( ∗ args , ∗∗ kwargs ) : p r i n t ( " Dekorá lt  f üggvé ny ! " ) return f ( ∗ args , ∗∗ kwargs) return _interne @unDecorateur d ef uneFonction(a , b ): return a + b d ef autreFonction (a , b ): return a + b 88



# Föprogram =============================================== ## dekorá tor haszná lat a p r i n t ( uneFonction (1 , 2)) ## f üggvénykompoz í ci ó haszná la ta autreFo nction = unDecorateur( autreFo nction ) p r i n t ( autreFo nction (1 , 2)) """ Dekorá lt függvény ! 3 Dekorá lt függvény ! 3 """  © 

8.2. Technikai objektumok Amint azt az előző fejezetben láttuk, a Python teljesen objektum orientált nyelv. Minden alap- illetve leszármaztatott típus osztályként implementált absztrakt adattípus. Ezen osztályok mindegyike egyetlen szülőosztályból származik, az object osztályból.

8.2.1. __slots__ és __dict__ Vizsgáljuk meg a következő kódot :  c l a s s Poin t : __slot__ = ( " ’x " ’ ,  " ’y " ’)  def __init__( s e l f , x=0,y=0):  s e l f . x=x  s e l f . y=y  ©  Amikor egy osztályt a __slot__ utasítás alkalmazása nélkül hozunk létre, ahogyan azt idáig tettük, a Python minden osztálypéldány számára transzparens módon létrehoz egy __dict__ nevű privát szótárat és ez a szótár tartalmazza a példányok attributumait. Ez a magyarázat arra, hogy miért lehet egy objektum attributumaihoz újabbakat hozzátenni illetve belőlük törölni. Ha viszont megelégedünk olyan objektumokkal, melyek attributumaihoz se hozzátenni, sem pedig belőlük elvenni nem akarunk, akkor létrehozhatunk privát c Robert Cordeau 

89

Bevezetés a Python 3-ba szótár nélküli osztályokat, ami minden egyes objektumgeneráláskor memóriát fog megtakarítani. Ezt valósítja meg az alábbi példa egy __slot__ osztályattributum definiálásával, aminek az értéke egy tuple, amit az attributumok nevéből áll.

8.2.2. A functor A Pythonban egy függvényobjektum vagy functor egy hivatkozás minden hívható objektumra : függvényre, lambda-függvényre, metódusra, osztályra. A beépített callable() függvénnyel tesztelhetjük ezt a tulajdonságot :  >>> d ef myFunction () : p r i n t ( ’This i s " ca l la b le " ’ ) >>> c a l l a b l e ( myFunction ) True >>> chain = ’ This i s  " ca l l ab le " ’ >>> c a l l a b l e ( cha ine ) False  

©

Egy osztály példányait átalakíthatjuk functor-okká, ha az osztályban definiálva van a __call__() speciális metódus :  >>> c l a s s A: def __call__( se lf , un , deux ) : return un + deux >>> a = A() >>> ca ll a bl e (a ) True >>> a (1 , 6) 7  

©

8.2.3. Az accessor-ok Az egységbezárás problémája Az objektum orientált paradigmában egy objektum állapota privát, más ob jektumoknak nincs joguk azt sem megnézni, sem módosítani. Hagyományosan a következő láthatóságokat különböztetjük meg : 90


Bevezetés a Python 3-ba • public; • protected; • private.

A Pythonban minden attributum (adatok, metódusok) public ! Mostantól finomíthatunk ezen a tényen. Egy egyszerű és hasznos megállapodás : az egy aláhúzás karakterrel kezdődő neveket fogjuk a protected attributum jelölésére használni. Például : _attrib. A Python semmire sem kötelez, a fejlesztőn múlik a megállapodás betartása ! A Python javasol egy mechanizmust (name mangling ) a private attributumok emulálására : az osztályazonosítók két aláhúzás-karakterrel (__) kezdődnek. Például : __ident. Ez a védelem deklaratív marad és nem nyújt abszolút védelmet. A

property

megoldás

Az egységbezárás elvét a tulajdonság fogalmával dolgozták ki. Definíció Egy tulajdonság property egy példány-attributum, aminek speciális funkciói vannak. Ezt a megoldást két szintaxis implementálja. Az első explicit módon definiálja az x tulajdonságot és négy paraméterét (rendre) :  c l a s s C: d ef __init__( s e l f ) : self . _ma_propriete = None d ef getx ( s e l f ): "" " gett er . "" " return s e l f . _x d ef s e t x ( s e l f , v a l u e ) : """ sett er . "" " s e l f . _x = v a l u e c Robert Cordeau 

91

Bevezetés a Python 3-ba d ef delx ( s e l f ): "" " del ete r . "" " d el s e l f . _x x = property ( getx , setx , delx , "Envagyokaz ’x ’  tu la jd on s ág . " ) # auto − t e s t =============================== i f __name__ == ’__main__’ : t e s t = C( ) t e s t . x = 10 # s e t t e r p r i n t ( te st .x ) # g e t t e r p r i n t (C. x .__doc__) # documentation """ 10 En v ag yo k a z ’ x ’ t u l a j d o n s á g . """  

©

A második, egyszerűbb a dekorátorok szintaxisát alkalmazza. Megjegyzem, hogy a property dokumentációs stringje itt az x tulajdonság docstringje :  c l a s s C: d ef __init__( s e l f ) : s e l f ._x = None @property d ef x ( s e l f ) : " " " En v ag yo k a z ’ x ’ t u l a j d o n s á g . " " " return s e l f . _x @x. se tt er d ef x ( s e l f , v a lu e ) : s e l f . _x = v a l u e @x. dele te r d ef x ( s e l f ) : 92


Bevezetés a Python 3-ba d e l s e l f . _x # auto − t e s t =============================== i f __name__ == ’__main__ ’ : t e s t = C () t e s t . x = 10 # s e t t e r p r i n t ( te st .x ) # g e t t e r p r i n t (C. x . __doc__) # documentation """ 10 En v ag yo k a z ’ x ’ t u l a j d o n s á g . """  

©

8.3. Függvénytechnikák 8.3.1. A lambda direktíva Funkcionális nyelvek (mint amilyen a Lisp) konstrukciója, a lambda direktíva lehetővé teszi egy anonim függvény definiálását, aminek a visszatérési értéke egy kifejezésre van korlátozva. Szintaxis lambda [paraméterek] :kifejezés Például ennek a függvénynek "s" a visszatérési értéke, ha az argumentuma nem 1, különben egy üres karakterlánc :

s = lambda x : " " i f x == 1 e l s e " s "   További példák : 

©

>>> def makeIncrementor(n): retu rn lambda x : x+n >>> f2 = makeIncrementor (2 ) >>> f6 = makeIncrementor (6 ) c Robert Cordeau 

93

Bevezetés a Python 3-ba >>> p r i n t ( f2 (3) , f6 (3) ) 5 9 >>> >>> L = [ lambda x : x ∗ ∗ 2 , lambda x : x ∗ ∗ 3 , lambda x : x ∗ ∗ 4 ] >>> f o r f in L : p r i n t ( f (2 ) , end=" " ) 4 8 16  

8.3.2. A map, filter és reduce függvények A funkcionális programozás egy programozási paradigma, ami a számításokat matematikai függvények kiértékelésének tekinti és elutasítja az állappotváltozást és az adatok megváltoztatását. A függvények alkalmazását hangsúlyozza, szemben az imperatív programozással, ami az állapotváltozásokat helyezi előtérbe 2. A funkcionális paradigma nem használ állapotokat egy program leírására, hanem egymásba ágyazott függvényeket, amiket úgy tekinthetünk mint "fekete dobozokat", amiket egymásba ágyazhatunk. Minden doboznak több bemeneti paramétere van, de csak egyetlen kimenete van, minden bemeneti érték n-esre csak egy lehetséges kimeneti értéket adhat ki. Így a függvények nem bezetnek be mellékhatásokat. A program tehát egy alkalmazás matematikai értelemben, ami csak egyetlen eredményt ad minden egyes bemeneti értékegyüttesre 3 . A funkcionális programozás három fogalmon nyugszik : mapping , filtering és reducing , amiket a Pythonban három függvényel implementáltak : map(), filter() és reduce(). A

függvény : map() - egy függvényt alkalmaz egy szekvencia minden elemére és visszatérési értékként egy iterrátort ad : >>> d ef ren voi Tit res ( element ): return element . ti t l e () map()

>>> map( ren voi Tit res , [ ’ f i a t lu x ’ , " lor d  of the  f l y " ] ) >>> [ element . t i t l e () f o r element i n [ ’ f i a t lux ’ , " lord  of the fl y " ] ] [ ’ Fia t Lux ’ , ’ LordOfTheFly ’ ] 2 3

Lásd Wikipedia Lásd Wikipedia

94


©

Bevezetés a Python 3-ba >>>  

© Megjegyzem, hogy a

A

map()

helyettesíthető egy szűkített listával.

függvény : filter() - létrehoz és visszaad egy iterrátort egy listán, ami a kiindulási szekvencia mindazon elemeit tartalmazza, amik megfelelnek a következő kritériumnak : function(element) == True :  >>> f i l t e r ( lambda x : x > 0 , [ 1 , −2, 3 , − 4]) [1 , 3] >>> >>> [ x f o r x i n [ 1 , −2, 3 , − 4] i f x > 0 ] [1 , 3]  ©  filter()

Megjegyzem, hogy a A

filter()

helyettesíthető egy tesztes szűkített listával.

függvény : reduce() - a functools modul egy függvénye. Egy két argumentumos függvényt alkalmaz kumulatív módon balról jobbra egy szekvencia elemeire úgy, hogy ezt a szekvenciát egy értékre redukálja, amit visszatérési értékként ad :  >>> def somme(x , y ) : p r i n t x , ’+ ’ , y return x + y reduce()

>>> 1 + 3 + 6 + 10 >>> >>> 10  

reduce (somme, [1 , 2 , 3 , 4 ]) 2 3 4 sum( [1 , 2 , 3 , 4] )


© 95


8.3.3. Parciális függvény-alkalmazások A funkcionális programozás konstrukciója, egy n-paraméteres PFA (parciális függvényalkalmazás) az első argumentumot rögzített paraméterként veszi és visszatérési értékül egy - a maradék n-1 paramétert használó - függvényobjektumot (vagy példányt) ad. Egyszerű példa :  >>> from f u n c t o o l s import p a r t i a l >>> baseTwo = p a rt i a l ( int , base=2) >>> baseTwo ( ’ 1001 0 ’ ) 18  ©  A PFA-k nagyon hasznosak parciális widget-modellek előállításánál, amiknek gyakran számos paraméterük van. A következő példában újra definiáljuk a Button osztályt bizonyos paramétereit rögzítve (amiket mindíg felül lehet írni) : from f u n c t o o l s import p a r t i a l import t k i n t e r a s t k root = tk .Tk() # in s ta n ci a ti o n p a r t i e l l e de c l as s e : MonBouton = p a r ti a l ( tk . Button , root , fg=’ pur ple ’ , bg=’ green ’ ) MonBouton( t ex t=" Bouton1 " ) . pack ( ) MonBouton( t ex t=" Bouton2 " ) . pack ( ) MonBouton( t e xt="QUITTER" , bg= ’ re d ’ , f g=’ bl ac k ’ , command=ro o t . qu i t ) . pack ( f i l l =tk .X, expand=True ) ro ot . t i t l e ( "PFA ! " ) ro ot . mainloop ()  © 

96



9. fejezet Grafikus OO programozás Az operációs rendszerekben és az alkalmazásokban elterjedten használt grafikus interface-ek programozhatók Pythonban. A Pythonban használható különböző grafikus könyvtárak (GTK+, wxPython, Qt ...) között, a tkinter könyvtár (a standard Python interface a Tk GUI toolkithez) széles körben alkalmazott, mivel minden Python-disztribúcióban alapértelmezetten telepítve van. A tkinter lehetővé teszi egyszerű grafikus interface-ek létrehozását. A könyvtár importálása után a feladatunk a widget-ek létrehozására, konfigurálására és pozícionálására, a widget-ekhez kapcsolt függvények/metódusok kódolására, majd az eseménykezelő programhurokba való belépésre korlátozódik.

9.1. Eseményvezérelt programok Grafikus objektumok programozásakor a script szekvenciális végrehajtását egy eseménykezelő programhurokkal helyettesítik. (Lásd 9.1 ábrát.)

9.2. A tkinter könyvtár 9.2.1. Bemutatás Ez egy elég egyszerű könyvtár, ami a John K. Ousterhout által 1988-ban a Berkeley University-n kifejlesztett Tcl nyelv grafilus kiterjesztéséből, a Tk-ból származik. Ez a kiterjesztés széles körben elterjedt a Tcl/Tk-n kívül. Használhatjuk Perlben, Pythonban, Rubyban, stb. A Python esetében a kiterjesztést átnevezték tkinterre. c Robert Cordeau 

97


9.1. ábra. Szekvenciális és eseményvezérelt programozás A Tk-val párhuzamosan fejlesztettek egyéb kiterjesztéseket, melyek küzül egyeseket használnak Pythonban. Például a standard Tix modul mintegy negyven widget-et kínál a fejlesztőnek. A Tcl/Tk nyelv igen fejlett. Az aktuális 8.5 verzió egy Ttk nevű könyvtárat kínál fel, ami lehetővé teszi a widget-ek különböző stílusokban történő "felöltöztetését". Ez a modul a Python 3.1.1-ben is rendelkezésre áll. Egy egyszerű tkinter példa. 9.2

 import t k i n t e r widget = tk in te r . Label (None , text=’ Bonjourmondegraphique  ! ’ ) wid get . pack ( ) # a Label poz í cion á l ása widg et . mainloop () # a z esem é n y k e z e l ö h ur ok e l i n d í t á s a  © 

9.2. ábra. Egy egyszerű példa 98



9.2.2. A tkinter widget-ek Definíció A widget szó, ami a window és a gadget szavak összevonásával keletkezett, egy könyvtár grafikus alapelemeit jelöli. A tkinter főbb widget-jeinek listája: Widget Tk Frame Label Button Message Entry Checkbutton Radiobutton Scale PhotoImage BitmapImage Menu Menubutton Scrollbar Listbox

Funkció a legmagasabb szintű ablak más widget-ek szervezésére szoláló konténer üzenetmező gomb szöveggel vagy képpel több soros szöveg kiíratására való mező adatbeírásra való mező két állapotú gomb két - egymást kizáró - állapotú gomb többállapotú csúszka képeknek widget-re való elhelyezésére szolgál bitmap-eknek widget-re való elhelyezésére szolgál a Menubutton-hoz kapcsolódik egy menüopciót megnyitó gomb görgetősáv lehetővé teszi a felhasználó által megadott adatok kiválasztását a legördülő listából Text többsoros szöveg szerkesztése Canvas zóna rajzok és fotók számára OptionMenu legördülő menü ScrolledText a Text widget görgetősávval PanedWindow interface fülekkel (tabs) LabelFrame egy keretet és egy címet tartalmaz Spinbox többszörös kiválasztást lehetővé tevő widget 9.1. táblázat: A tkinter főbb widget-jei

9.2.3. Widget-ek pozícionálása A tkinter-nek három pozíciókezelője van :


99

Bevezetés a Python 3-ba Pozíciókezelő Funkció packer Minden egyes widget-et méretez és pozícionál egy widgetkonténerben az egyes widget-ek helyigényének megfelelően gridder Minden egyes widget-et méretez és pozícionál egy widgetkonténer egy táblázatának a celláiban placer Minden egyes w widget-et méretez és pozícionál egy widgetkonténerben annak megfelelően, amit a w igényel.

9.3. Két példa 9.3.1. tkPhone, egy menü nélküli példa Egy telefonkönyvet kezelő scriptet fogunk írni. Az alkalmazás megjelenését a 9.3 ábra mutatja. Grafikus tervezés A grafikus tervezés segíteni fog a jó widgetek kiválasztásánál. Először is természetes dolog három zónát megkülönböztetni : 1. a kiíratásra szánt felső zónát; 2. a középső zóna egy névsor szerint rendezett lista; 3. az alsó zónát a fölötte lévő listát kezelő gombok képezik. Ezen zónák mindegyikét egy-egy Frame() objektummal kódoltuk, amiket a packer metódussal pozícionáltunk egymás alá és mindhármat egy Tk() objektumba foglaltunk bele (lásd a fenti ábrát) A grafikus interface kódja A problémák elválasztása érdekében a következő módszer ajánlott : Megjegyzés Válasszuk el egymástól a grafikus interface és a callback-ek kódját. Első lépésként következzen a grafikus interface kódja. Az inicializátor létrehoz egy phoneList attributumot, egy listát, amit az adatokat tároló file adataival feltölt (ha a file nem létezik, akkor létrehozza azt), létrehozza a root alapablakot és hívja a makeWidgets() metódust. Ez a metódus követi a grafikus tervezést és feltölti a frame-ek mindegyikét. A 100



(a) A grafikus interface

(b) A grafikus terv

9.3. ábra. tkPhone callback-ek üresek (a minimális pass utasítást tartalmazzák).

Mint minden jó modul esetében, egy auto-teszttel ellenőrizni lehet az interface jó működését (ebben az esetben a jó kinézetet) :

 # −∗− co di ng : UTF−8 −∗− import t k i n t e r a s t k # class c l a s s Allo_IHM( o b j ec t ): " " " IHM d e l ’ a p p l i c a t i o n ’ r é p e r t o i r e t é l é p h on iq ue ’ . " " " d ef __init__( se lf , f i c ) : " " " I n i t i a l i s a t e u r / l a nc eu r de l a f e n e t re de b as e " " " s e l f . p h o ne L i st = [ ] self . fic = fic # f = o pen ( f i c ) tr y : f = open( f i c ) for l i n e in f : s e l f . phon eLis t . append ( l i n e [ : − 1]. s p l it ( ’ ∗ ’ ) ) except : # cr é a ti on du f i c h i e r de r é p e r t o i re c Robert Cordeau 

101

Bevezetés a Python 3-ba f = o pe n ( s e l f . f i c , "w" ) finally : f . cl os e () s e l f . phoneList . so rt () s e l f . root = tk .Tk() s e l f . root . ti t l e ( " Allo  ! " ) s e l f . roo t . co nf ig ( r e l i e f=tk .RAISED, bd=3) s e l f . makeWidgets () s e l f . roo t . mainloop () d ef makeWidgets ( s e l f ) : " Configure et pos iti onn e  le s widgets " # f ra me " s a i s i e " ( e n h au t a v ec b ou to n d ’ e f f a c e me n t ) frameH = tk . Frame( se l f . roo t , r e l i e f=tk .GROOVE, bd=2) frameH . pack () tk . Lab el ( frameH , te xt="Nom : " ) . g ri d ( row=0, column=0, sticky=tk .W) s e l f . nameEnt = tk . Entry (frameH) s e l f . nameEnt . gr id (row=0, column=1, st ic ky=tk .W, padx=5, pady=10) tk . Label (frameH , te xt=" Tel : " ) . gri d (row=1, column=0, s t i c k y=tk .W) s e l f . phoneEnt = tk . Entry ( frameH) s e l f . phoneEnt . gr id ( row=1, column=1, s ti ck y=tk .W, padx=5, pady=2) b = tk . Button( frameH , tex t=" Ef fa ce r  " , command=s e l f . c l e a r ) b . gr id (row=2, column=0, columnspan=2, pady=3) # f ra me " l i s t e " ( au m i l i e u ) frameM = tk . Frame( s e l f . ro ot ) frameM . pack () s e l f . s c r o l l = tk . Scr ol lb ar (frameM) s e l f . s el ec t = tk . Listbo x (frameM , yscrollcommand=s e l f . s c ro l l . set , height =6) s e l f . sc r o l l . co nf ig (command=s e l f . s el ec t . yview) s e l f . s c r o l l . pack( si de=tk .RIGHT, f i l l =tk .Y, pady=5) 102


Bevezetés a Python 3-ba s e l f . s e l e c t . pack ( s id e=tk .LEFT, f i l l =tk .BOTH, expand=1, pady=5) ## r e m p l i s s a g e de l a L i s t bo x f o r i in s e l f . phoneList : s e l f . se le ct . in se rt ( tk .END, i [ 0 ] ) s e l f . s e l e c t . bind ( "" , lambda e v en t : s e l f . a f f i c h e r ( e v en t ) ) # frame " boutons " (en bas) frameB = tk . Frame( s e l f . roo t , r e l i e f=tk .GROOVE, bd=3) frameB . pack ( pady=3) b1 = tk . Button( frameB , te xt=" Ajout er  " , command=s e l f . aj o u t er ) b2 = tk . Button( frameB , te xt=" Supprimer " , command=s e l f . su ppr ime r ) b3 = tk . Button( frameB , text=" Af fi ch er  " , command=s e l f . a f f i c h e r ) b1 . pack ( s i d e=tk .LEFT, pady=2) b2 . pack ( s i d e=tk .LEFT, pady=2) b3 . pack ( s i d e=tk .LEFT, pady=2) d ef a j o u t e r ( s e l f ) : pass d ef supprimer ( s e l f ): pass d ef a ff ic he r ( se lf , event=None ): pass d ef c l e a r ( s e l f ) : pass # auto − t e s t −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− i f __name__ == ’__main__ ’ : app = Allo_IHM( ’ phone s . tx t ’ ) # i n s t a n c i e l ’IHM  


©

103

Bevezetés a Python 3-ba Az alkalmazás kódja A következő képpen fogjuk használni a modult : • Az előző modulból importáljuk az Allo_IHM osztályt; • létrehozzunk egy leszármaztatott Allo osztályt; • ennek az inicializátora azért hívja a szülőosztály inicializátorát, hogy az előbbi

örökölje az utóbbi minden jellemzőjét; • újra kell definiálni a callback-eket.

Végül a script létrehoz egy alkalmazásobjektumot.  # −∗− coding : UTF−8 −∗− # imports import t k i n t e r a s t k from tkPhone_IHM import Allo_IHM # classes c l a s s Al lo (Allo_IHM ) : "" "Ré pe rt oi re té l éphonique . """ d ef __init__( se lf , f i c=’ phones . txt ’ ) : " Con str uct eur de l ’IHM. " Allo_IHM . __init__( s el f , f i c ) d ef a j o u t e r ( s e l f ) : # maj d e l a l i s t e ajo ut = [ " " , " " ] ajout [ 0 ] = s e l f . nameEnt . get () ajo ut [ 1 ] = s e l f . phoneEnt . get () i f ( aj ou t [ 0 ] == " " ) or ( aj ou t [ 1 ] == " " ) : return s e l f . phoneLi st . append ( aj out ) s e l f . phoneList . so rt () # maj de l a l i s t e b o x s e l f . s el ec t . de le te (0 , tk .END) f o r i i n s e l f . phoneList : s e l f . se le ct . in se rt ( tk .END, i [ 0 ] ) s el f . cle ar () s e l f . nameEnt . focus () 104


Bevezetés a Python 3-ba # maj du fichier f = o pen ( s e l f . f i c , " a " ) f . w ri te ( "%s ∗%s \ n " % ( a j o u t [ 0 ] , a j o u t [ 1 ] ) ) f . clo se () d ef supprimer ( s e l f ): se lf . clear () # maj d e l a l i s t e re tr ai t = [ " " , " " ] r e t r a i t [ 0 ] , r e t r a i t [ 1 ] = s e l f . p h on e Li s t [ i n t ( s e l f . s e l e c t . cu rs el ec ti on ( ) [ 0 ] ) ] s e l f . phoneList . remove( re t r a i t ) # maj d e l a l i s t e b o x s e l f . s el ec t . de le te (0 , tk .END) f o r i in s e l f . phoneList : s e l f . se le ct . in se rt ( tk .END, i [ 0 ] ) # maj du fichier f = o pe n ( s e l f . f i c , "w" ) f o r i in s e l f . phoneList : f . w r i t e ( "%s ∗%s \n " % ( i [ 0 ] , i [ 1 ] ) ) f . clo se () d ef a ff ic he r ( se lf , event=None ): se lf . clear () name, phone = s e l f . phoneList [ int ( s e l f . se le ct . cu rs el ec ti on ( ) [ 0 ] ) ] s e l f . nameEnt . ins er t (0 , name) s e l f . phoneEnt . in se rt (0 , phone) d ef c l e a r ( s e l f ) : s e l f . nameEnt . d el et e (0 , tk .END) s e l f . phoneEnt . de l et e (0 , tk .END) # föprogram #−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− app = Allo () # l é t r e h o z za a z a lk al ma z á s t  


105

©


9.3.2. IDLE, egy példa menüvel Minden Python disztribuciónak része az IDLE alkalmazás - egy Pythonban írt interpreter/editor 1 . Ez az alkalmazás egy komplett grafikus interface-szel rendelkező menüs alkalmazás (lásd 9.4 ábrát). A forráskódja hozzáférhető és és önmagában egy komplett tkinter tanfolyamot képez 2 .

(a) Az IDLE interpreter

(b) Az IDLE editor

9.4. ábra. IDLE

1 2

Egyes linuxdisztribúciókban az IDLE egy különálló csomag. De túlságosan terjedelmes ahhoz, hogy ebben a jegyzetben tárgyaljuk ...

106



10. fejezet Az agile development fogalma Az "Agile Development" gyűjtőfogalom, ami számos iterrarív és inkrementális szoftverfejlesztési stílust takar. A legnépszerűbb "Agile Development" módszerek közé tartozik az Extreme Programming (XP), Scrum, Crystal, ... stb. Bár az említett módszerek egyediek a speciális probléma megközelítésük tekintetében, azonban vannak közös jellemzőik : - valamennyien iterrarívak és inkrementálisak - a folyamatos visszacsatolás, ami fokozatos finomítást tesz lehetővé Mindannyian folyamatos tervezést, tesztelést, integrációt és a folyamatos projektilletve a szoftverfejlesztés egyéb formáit alkalmazzák. Mindannyian arra koncentrálnak, hogy képessé tegyék az embereket az együttműködésre és a gyors és hatékony döntéshozatalra. Nagyon rövid iterrációkkal építkeznek, egyszerre csak egy-két funkciót implementálnak. Az iterrációs ciklus végén egy működőképes programverzió a kimenet. 2001-ben 17 neves szoftver fejlesztő alapította meg az "Agile Allience"-t és fogalmazta meg a "Manifesto for Agile Software Development"-et. A legfontosabb elvek : • Első rendű szempont a megrendelő maradéktalan kielégítése • Flexibilitás a követelmények változásával szemben • Működő szoftver gyors átadása (inkrementálisok) • Az üzleti szakembereknek és a fejlesztőknek napi kapcsolatban kell lenniük


107

Bevezetés a Python 3-ba • Motivált szakembereket gyűjts a projekt köré, teremtsd meg a feltételeket a

munkájukhoz • Szorgalmazd a szemtől-szembeni párbeszédet a teamen belül az információ

cserére • A haladás legjobb mértéke a működő szoftver • "Agile process" fenntartható fejlődést ösztönöz • A fejlesztőknek és a megrendelőnek egy állandó ütemet kell fenntartani a fe-

jlesztési folyamatban • A kiváló műszaki színvonalra és a jó tervre folyamatosan ügyelni kell • Egyszerűség – csak az igazán fontos feladat elvégzése • Az önszerveződő, aktív teamektől származnak a legjobb megoldások (szerkezetekre,

követelményekre, tervekre) • Rendszeres időközönként a teamnek önvizsgálatot kell tartani és viselkedését

esetleg módosítani Ezen elveket követő módszerek: • Extreme Programming • Adaptive Software Development • Dynamic Software Development Method • Scrum • Crystal • Feature Driven Development • Agile Modeling

Ez a filozófia a projektfejlesztés ciklusának egészére érvényes, most viszont csak a dokumentálás és a tesztek problémájára fogunk szorítkozni. 108



10.1. A tesztek Attól kezdve, hogy egy program túljut a kisméretű script stádiumon, elkerülhetetlenül megjelenik a hibák és a tesztek problémája. Definíció Egy teszt abból áll, hogy a dokumentációban megadott jellemzőt egy ’use case’nek megfelelő forgatókönyv szerint hívunk és megvizsgáljuk, hogy ez a jellemző úgy viselkedik-e ahogyan azt terveztük. Módszer Az "agile development" filozófiájának megfelelően a teszteket a kód írásával egyidőben vagy előbb írják meg. Tesztvezérelt fejlesztésről (TDD = Test Driven Developpement ) beszélünk.

10.1.1. Unit tesztek és funkcionális tesztek Két tesztcsaládot különböztetünk meg : Unit tesztek : Unit: egy program legkisebb különállóan tesztelhető része (procedurális nyelv esetén egy függvény, objektum orientált nyelv esetén egy metódus). A tesztesetek egymástól függetlenek, a teszteket a programozók írják. Megállapodás szerint minden modul kapcsolatban van a unit test modulok egyikével, ami a csomag egy tests folderében van. Például : egy calculus.py nevű modulnak lesz egy tests/test_calculus.py nevű tesztmodulja. Funkcionális tesztek : a teljes alkalmazást egy "fekete doboznak" veszik és úgy manipulálják, ahogyan a végfelhasználó tenné. Ezeknek a teszteknek ugyanazokon az interface-eken keresztül kell történni, mint amiket a felhasználók használnak, ezért ezek a programre nézve specifikusak és nehezebb őket kidolgozni. Megemlíthetem a következő projekteket : • Mechanize : ez a könyvtár automatizálja a WEB-oldalak kiválasztását és a

velük való interakciót • Selenium : funkcionális tesztek WEB-alkalmazások számára egy valódi böngészőben; • guitest : GTK alkalmazásokat tesztel; • FunkLoad : egy benchmark és riportkészítő rendszer


109


10.1.2. A tesztvezérelt fejlesztés Az unittest modul szolgáltatja a PyUnit tool-t, amit más nyelvekben is megtalálhatunk : JUnit (Java), NUnit (.Net), JSUnit (Javascript). Ezek mind egy eredetileg a SmallTalk nyelv számára kifejlesztett tool-ból - az SUnit-ból erednek. A PyUnit a TestCase alaposztályt kínálja fel a felhasználónak. Minden, a TestCase-ből leszármaztatott osztályban implementált és test_ prefix-szel ellátott metódust unittesztnek tekint. Egy egyszerű példa. 1 A kódot unittest.py néven elmentve, a konzolról python unittest.py -ként hajtathatjuk végre.  ’ ’ ’ T hi s i s a s i m p l e p ro gra m t o d em o ns t ra t e how t o c r e a t e a u n i t t e s t i n Python . For more i n f o r m a t i o n and d oc um en ta ti on , ple ase see the o f f i c i a l documentation page here : http :/ / docs . python . org/ l ib r a ry /u ni tt es t . html ’ ’ ’ import u n i t t e s t #I n c l u d e t h e p yU ni t u n i t t e s t f ra me wo rk d ef add( a , b , c=0): ’ ’ ’ A s i m p le a dd in g f u n c t i o n t o demo u n i t t e s t ’ ’ ’ return a+b+c # The f o l l ow i n g i s th e c l a s s i n w hich a l l # fu n ct i on s w i l l be ran by u n i t t e st c l a s s AddTest( un i tt es t . TestCase ) : ’ ’ ’ Main c l a s s f o r add t e s t i n g ; Can be added t o a s u i t e ’ ’ ’ # The f u n ct i o n " s etUp " w i l l a lw ay s b e r an i n o r de r t o # se tu p t he t e s t en vi ro nmen t b e f o re a l l t he t e s t s have run . d ef setUp ( s e l f ): ’ ’ ’ Verify environment is setup properl y ’ ’ ’ # Printed i f t es t f a i l s pass # The f u n c t i o n " t earDown " w i l l a lw ay s b e r an i n o r de r t o # cl ea nu p t he t e s t e nvi ro nme nt a f t e r a l l t he t e s t s have run . d ef tearDown( se l f ) : 1

A példa forrása :

http://www.thelinuxdaily.com/2011/11/getting-started-with-python-unit-testing-pyunit/

110


Bevezetés a Python 3-ba ’ ’ ’ Verify environment i s tore down properl y ’ ’ ’ # Printed i f t es t f a i l s pass # F un ct io ns b e gi n n in g w it h " t e s t " w i l l be r an # as a u ni t t e s t . d ef test_positive_add ( s e l f ): ’ ’ ’ Verify that adding po si ti ve numbers works ’ ’ ’ # Printed i f t es t f a i l s s e l f . assert Equal (add( 10 ,23 ,22) , 55) # Test w i l l f a i l i f " f a l s e " ( b oo le an ) s e l f . assert Equal (add( 11 ,23) , 34) s e l f . assert Equal (add (1 ,1 ,17) , 19) # F un ct io ns b e gi n n in g w it h " t e s t " w i l l be r an # as a u ni t t e s t . # @unittest . skip (" demonstrating skippin g ") # Sk ip t h i s t e s t ( Python >= 2 . 7 ) d ef test_negative_add ( s e l f ): ’ ’ ’ Veri fy that adding neg ati ve numbers works ’ ’ ’ # Printed i f t es t f a i l s s e l f . assert Equal (add( − 1 2 , 2 3 ) , 1 1 ) # F un ct io ns b e gi n n in g w it h " t e s t " w i l l be r an # as a u ni t t e s t . # In t h i s ca se , t h i s t e s t w i l l be s ki pp ed . #@uni ttest . ski p (" demonstrating ski ppi ng ") d ef test_negative_add_skip ( se l f ) : ’ ’ ’ Veri fy that adding neg ati ve numbers works ’ ’ ’ # Printed i f t es t f a i l s s e l f . assert Equal (add( − 1 2 , 2 3 ) , 1 1 ) i f __name__==’__main__’ : u n i t t e s t . m ain ( )  

©

Egy másik példa :

 " " " Számolás okat végzö modul "" " # fonctions def avera ge ( ∗ args ): c Robert Cordeau 

111

Bevezetés a Python 3-ba " " " K i sz á m o lj a a z á t l a g o t . " " " length = len ( args ) sum = 0 f o r arg i n args : sum += arg return sum/length d ef d i v i s i o n ( a , b ) : "" " Kiszámolja a hányadost . "" " return a/b    " " " A s z á mol á s o k a t v é g z ö modul t e s z t m o du l j a " " " # imports import u n i t t e s t import os import s ys dirName = os . path . dirname ( __file__) i f dirName == ’ ’ : dirName = ’ . ’ dirName = os . path . re al pa th ( dirName ) upDir = os . path . sp l i t (dirName ) [ 0 ] i f upDir n o t i n s ys . path : sy s . path . append( upDir ) from c a l c u l s import a ve ra ge , d i v i s i o n # classes c l a s s CalculTes t ( un it te st . TestCase ) : d ef test_average ( s e l f ): s e l f . ass ertEqu als ( average (1 , 2 , 3) , 2) s e l f . ass ertEqu als ( average (2 , 4 , 6) , 4) d ef t e s t _ d i v i s i o n ( s e l f ) : s el f . assertEquals ( di vis ion (10 , 5) , 2) s e l f . a s s e r t R a i s e s ( Z e r oD i v is i o n Er r o r , d i v i s i o n , 1 0 , 0 ) d ef t e s t _ s u i t e ( ) : te st s = [ un it te st . makeSuite( CalculTest )] 112


©

Bevezetés a Python 3-ba return un it te st . TestSuite ( te st s ) i f __name__ == ’__main__ ’ : u n i t t e s t . m ain ( )  

©

Egy tesztsorozat végrehajtásához egy olyan scriptet kell írni, ami : • megkeres minden tesztmodult: ezeknek a neve test_ prefix-szel kezdődik és

egy test nevű folderben vannak; • a test_suite globális függvény suite visszatérési értékét begyűjti; • létrehozza a tesztek sorozatainak sorozatát és elindítja a tesztsorozatot.

10.2. A dokumentálás Egy projekt élettartama során több dokumentációtípust különböztetünk meg : • specifikációs dokumentumokat (upstream documentation ); • a kódhoz kapcsolódó technikai (mainstream documentation ); • a felhasználói kézikönyveket és más magas szintű dokumentumokat ( downstream documentation ).

A mainstream dokumentumok a kód ritmusában fejlődnek és ezért úgy kell őket kezelni, mint a kódot : egy egyszerű szövegszerkesztővel olvashatóknak és szerkeszthetőknek kell lenniük. Két fontos eszköz van a Python-alkalmazások dokumentációinak létrehozására : • a reStructuredText (vagy reST): egy rich text formátum; • a doctests : kompatibilis a reST formátummal. Lehetővé teszi a szöveg kom-

binálását a tesztekkel. c Robert Cordeau 

113


10.2.1. A reST formátum A reStructuredText formátum, amit szokásosan reSt-nek neveznek, egy szövegek formázására használt tag-rendszer. A LATEX-től eltérően a dokumentum minőségét "non intrusive" módon javítja, azaz a file-ok közvetlenül olvashatók maradnak. A reST interpretert tartalmazó docutils projekt egy sor utility-t kínál fel: • a rst2html ): html kimenetet ad integrált css-sel; • a rst2latex : egy ekvivalens LATEX-file-t generál; • a rst2s5 : egy s5 formátumú prezentációt hoz létre, ami lehetővé teszi inter-

aktív prezentációk létrehozását HTML-ben. Egy egyszerű példa reST formátumú textfile-ra. Egyebek között megjegyzem, hogy : • a fő-tag az üres sor, ami elválasztja a szöveg különböző strukturáit; • a strukturálás a különböző szintű részek címeinek = - _ : , stb. karakterekkel

történő aláhúzásával történik. Amikor az interpreter egy ilymódon aláhúzott szöveget talál, az alkalmazott karaktert összeköti egy fejezetszinttel; • egy cím alatt és felett általában ugyanaz a karaktersor van, mint a következő

példában :

 ====================== Fichier au format reST ====================== Section 1 ========= On e s t dans l a s e c ti o n 1 . Sous− s e c t i o n :::::::::::: C ec i e s t une s ou s − s e c t i o n . 114


Bevezetés a Python 3-ba Sous−sous − s e c t i o n ................. C ec i e s t une s ou s −sous − s e c t i o n . . . e t c e c i un c om me nt ai re Section 2 ========= La s e c t i o n 2 e s t ’ ’ b ea ucou p p l u s ’ ’ ∗∗ int é res san te ∗∗ q u e l a s e c t i o n 1 . Section 3 ========= La s e c t i o n 2 e s t un p eu v an ta rd e : l a s e c t i o n 1 e s t ∗ t r e s b ie n ∗ . −−−−−−−−−−−−−−−

Un t a b l ea u de t r o i s i ma ge s a u f o rm at " png " :::::::::::::::::::::::::::::::::::::::::: ======= ======= ======= Image 1 Image 2 Image 3 ======= ======= ======= | shamr | | elysT | | hel en | ======= ======= ======= . . | shamr | image : : shamr . png . . | elysT | image : : elysT . png . . | helen | image : : helen . png  

©

Az rst2html utility erre a file-ra alkalmazva ugyanezt a file-t állítja elő kiterjesztéssel.


115

.html


10.1. ábra. Példa HTML formátumú outputra

10.2.2. A doctest modul A LATEX létrehozója, Donald Knuth literate programming elvét vették át a Pythonban az API-k dokumentációs stringekkel történő dokumentálásához. Az olyan programok, mint az Epydoc ezeket ki tudják szűrni a modulokból a dokumentum előállításához. Tovább is mehetünk és alkalmazói példákat is belefoglalhatunk a dokumentációs stringekbe, melyek interaktív session-ök formájában vannak megírva. Nézzünk meg három példát. Mindegyik esetében megadom egyrészt a forráskódot a dokumentációs stringjével, amiben a standard doctest modul lehetővé teszi ezeknek a session-öknek a kinyerését, majd elindítását annak ellenőrzéséhez, hogy ezek működnek; másrészt a vé116


Bevezetés a Python 3-ba grehajtás eredményéről egy képernyőképet. Első példa : doctest1.py  " " " A d o c t e s t p r ó ba mo du lj a " " " # import import d o c t e s t # fonctions def somme(a , b ) : "" " Visszatér é si é rt éke a + b . >>> somme(2 , 2) 4 >>> somme(2 , 4) 6 """ return a+b i f __name__ == ’__main__ ’ : p r i n t ( " \{: −^40\}" . format ( " Mode s i l en c i eu x  " )) do ct es t . testmod () p r i n t ( "Haminden ren dbe n van , semmit sem l á tunk  ! " ) inpu t () p r i n t ( " \{: −^40\}" . format ( " Ré sz l e t e z ömód " )) do ct es t . testmod( verbo se=True)  



A doctest1.py script végrehajtásának eredménye :

−−−−−−−−−−− Mode silencieux −−−−−−−−−−−−

Ha minden rendben van , semmit sem l átunk ! −−−−−−−−−−−− Ré s z l e t e z ö mód −−−−−−−−−−−−

Tryin g : somme( 2 , 2) Expecting : 4 ok Tryin g : somme( 2 , 4) Expecting : c Robert Cordeau 

117

©

Bevezetés a Python 3-ba 6 ok 1 i te ms had no t e s t s : __main__ 1 i te ms p as se d a l l t e s t s : 2 t e s t s i n __main__. somme 2 t e s t s i n 2 items . 2 p a s s e d and 0 f a i l e d . Test passed .  

©

Második példa : doctest2.py  "" " Module d ’ es sa i de doct est . "" " # fonctions d ef accentEtrange ( tex te ) : " " " A jo u te un a c c en t é t r a n g e á un t e x t e . Les ’ r ’ s on t T r ip l é s , l e s ’ e ’ s u i v i d ’ un ’ u ’ Exemple : >>> te xt e = " Est−ce que tu a s r eg ar d é l a t é l é h i e r s o i r ? I l y a v a it un th éma s u r l e s r am as se ur s d ’ es ca rg ot s en Laponie , i l s en bavent . . . " >>> acc ent Etr ang e ( te xt e ) Es t−c eu qu eu t u a s r Rr eu ga rR rd é l a t é l é h i eu r Rr s o i r R r ? I l y a v a i t un t h éma s u rR r l e u s r Rr am as se uu rR rs d ’ eusca rRrgo ts eun Laponieu , i l s eun baveunt . . . C et te t e ch n i qu e per met d ’ i n t e r n a t i o n n a l i s e r l e s a p p l i c a t i o n s po ur l e s r en dr e c om pa t ib le s a vec c e r t a i ne s r é g i o ns f r a n c a i s e s . """ tex te = tex te . rep la ce ( ’ r ’ , ’ rRr ’ ) p r i n t ( tex te . re pl ac e ( ’e ’ , ’ eu ’ )) d ef _test ( ) : import d o c t e s t do ct es t . testmod( verbo se=True) 118



i f __name__ == ’__main__ ’ : _test ()  

©

A script végrehajtásának eredménye :

 Tryin g : t e x t e = " E st −c e  qu e t u  a s  r e g a r d é  l a  t é l é  h i e r  s o i r ?  Il y ava it unthémas ur  le s ramasseurs  d ’ es ca rg o ts en Laponie ,  i l s en bavent . . . " Expecting nothing ok Tryin g : accen tEtra nge ( te xt e ) Expecting : Es t−c eu queu t u a s r Rr eu ga rR rd é l a t é l é h i eu r Rr s o i r R r ? I l y a v a i t un t h éma s u rR r l e u s r Rr am as se uu rR rs d ’ eu sc ar Rr go ts eunLaponieu ,  i l s eunbaveunt . . . ok 2i temshadno te st s : __main__ __main__. _ te st 1items passed a l l  te st s :  2 t e s t s  in __main__. a cce ntE tra nge 2 te st s in 3items . 2passedand0 fa il ed . Testpassed .  © 


119

Bevezetés a Python 3-ba Harmadik példa : example.py  """ T hi s i s t h e " e x am pl e " mod ule . The exa mpl e module s u p p l i e s o ne f u n ct i o n , f a c t o r i a l ( ) . For example , >>> f a ct o ri a l (5) 120 """ d ef f a c t o r i a l ( n ) : " " " Return t he f a c t o r i a l o f n , an e xa ct i n t e g e r >= 0 . I f the r e s u l t i s s ma ll enough to f i t i n an i nt , r et u rn an i n t . E ls e r et u rn a l on g . \hypertarget{page110}{Egy} >>> [ f a c t o r i a l ( n ) f o r n i n r an ge ( 6 ) ] [ 1 , 1 , 2 , 6 , 2 4 , 1 2 0] >>> f ac t or ia l (30) 265252859812191058636308480000000 >>> f ac t or ia l ( − 1) T ra ce ba ck ( most r e c e n t c a l l l a s t ) : ... ValueError : n must be >= 0 F a c t or i a l s o f f l o a t s a re OK, but th e f l o a t must b e an e x ac t i n t e g e r : >>> f a c t o r i a l ( 3 0 . 1 ) T ra ce ba ck ( most r e c e n t c a l l l a s t ) : ... V a lu e Er r or : n must b e e x a ct i n t e g e r >>> f a c t o r i a l ( 3 0 . 0 ) 265252859812191058636308480000000 I t must a l s o not be r i d i c u l o u s l y l a r g e : >>> f ac t or ia l (1e100) T ra ce ba ck ( most r e c e n t c a l l l a s t ) : ... O v er f l ow E rr o r : n t o o l a r g e """ 120


Bevezetés a Python 3-ba import math i f n o t n >= 0: r a i s e Val ueE rro r ( "n mustbe >=0 " ) i f math . f l o o r ( n ) != n : r a i s e ValueError( "nmustbeexact  in te ge r " ) i f n+1 == n: # c at ch a v al ue l i k e 1 e3 00 r a i s e OverflowError ( "ntoo  la rg e " ) result = 1 factor = 2 while f a c t o r < = n : r e s u l t ∗= f a c to r f a c t o r += 1 return r e s u l t def _test () : import d o c t e s t do ct es t . testmod( verbo se=True) i f __name__ == "__main__" : _test () p r i n t ( "OK" )  

©

A script végrehajtásának eredménye :  Tryin g : f a c t o r i a l ( 5) Expecting : 120 ok Tryin g : [ f a c t o r i a l ( n ) f o r n in range (6 )] Expecting : [ 1 , 1 , 2 , 6 , 2 4 , 1 2 0] ok Tryin g : f a c t o r i a l ( 3 0) Expecting : 265252859812191058636308480000000 ok Tryin g : f a c t o r i a l ( − 1) c Robert Cordeau 

121

Bevezetés a Python 3-ba Expecting : T ra ce ba ck ( most r e c e n t c a l l l a s t ) : ... ValueError : n must be >= 0 ok Tryi ng : fact oria l (30.1) Expecting : T ra ce ba ck ( most r e c e n t c a l l l a s t ) : ... V a lu e Er r or : n must be e x a c t i n t e g e r ok Tryi ng : fact oria l (30.0) Expecting : 265252859812191058636308480000000 ok Tryi ng : f a c t o r i a l ( 1 e1 00 ) Expecting : T ra ce ba ck ( most r e c e n t c a l l l a s t ) : ... O v er f lo w Er r o r : n t o o l a r g e ok 1 i te ms had no t e s t s : __main__ . _ test 2 i te ms p as se d a l l t e s t s : 1 t e s t s i n __main__ 6 t e s t s i n __main__. f a c t o r i a l 7 t e s t s i n 3 items . 7 p a s s e d and 0 f a i l e d . Test passed . OK  

10.2.3. A dokumentálás vezérelt fejlesztés Amint az látható, innentől kezdve a kódba beépített dokumentáció a kódfejlesztés gyengéjét jelenti : amikor a dokumentáció mérete nő, nem látjuk a kódot ! A megoldás ennek a dokumentációnak az áthelyezése : a doctest.testfile() 122


©

Bevezetés a Python 3-ba függvény lehetővé teszi a dokumentációs file nevének megadását. Ami többlet, ezt a file-t reST formátumban írhatjuk, így két legyet ütünk egy csapásra. Egyrészt függvénybe (illetve metódusba) integrált tesztjeink vannak, más részt ugyanaz a file naprakész dokumentációt szolgáltat.


123


A. Függelék Karakterkészlet és kódolás Láttuk, hogy a számítógép minden információt kódol, amit binárisan manipulál. Az egész számok kódolásához elég az alap megváltoztatása, a lebegőpontos számok kódolásához egy szabványt használunk (IEEE 754), azonban a helyzet összetettebb a karakterek esetében. A humán nyelvek és írásbeli megjelenésük sokfélesége egy hozzájuk adaptált kódolást tesz szükségessé. Az első elképzelés az, hogy konstruáljunk egy táblázatot, ami a megjelenítendő szimbólumokat összeköti egy (általában egy byte-on kódolt) számmal : Szimbólum ←→ Szám A legnevezetesebb a 7 biten kódolt ASCII táblázat (128 kód) (lásd A.1 ábrát), de számos más táblázatot is konstruáltak (EBCDIC, ISO-8852-1...). Az Unicode táblázat A Python 3 -ban a karakterláncok (az str() típus) Unicode stringek. A Unicode-szabványban a karakterek numerikus azonosítói egyediek és univerzálisak. Mivel több százezer különböző karakterről van szó (kb. 6000 nyelv létezik), ezért ezek nyilvánvalóan nem kódolhatók egy bájton. A Unicode-szabvány semmilyen szabályt sem rögzít a kódolás számára fenntartott byte-ok ill. bitek számára vonatkozóan, egyedül az egyes karakterekhez rendelt numerikus azonosító értékét adja meg (lásd A.2 ábrát). Kódolás Miután összegyűjtöttük az összes szimbólumot és hozzárendeltünk egy számot, találnunk kell nekik egy bináris reprezentációt . 124



A.1. ábra. ASCII táblázat Az ASCII számára egyetlen byte elegendő lenne, de a Unicode milliónyi lehetőségének reprezentálására karakterenként több byte szükséges. Az ASCII számára egyetlen byte elegendő lenne, de a Unicode milliónyi lehetőségének reprezentálására karakterenként több byte szükséges. c Robert Cordeau 

125


A.2. ábra. A Unicode táblázat kivonata Mivel a szövegek többsége csak az ASCII táblázatot használja, ami éppen az Unicode táblázat alsó részének felel meg, ezért a leggazdaságosabb kódolás az UTF-8. A 0 és 127 közé eső kódokra az UTF-8 az ASCII táblázat byte-jait használja. Speciális karakterekhez (128 és 2047 közötti kódok) az az UTF-8 két byte-ot használ. A még kevésbé gyakori speciális karakterekhez (2048 és 65535 közötti kódok) az UTF-8 három byte-ot használ és így tovább. Szimbólum ←→ Szám ←→ Bitek Példa az "é" Unicode karakter UTF-8 kódolására : é ←→ 233 ←→ C3 A9 Gyakorlati alkalmazások A be- és kimenetek Fontos, hogy meg tudjuk adni, programjaink pontosan milyen formában várják az adatokat. Az adatokat a tasztaturán keresztül billentyűzzük be vagy valahonnan importáljuk őket. Ugyanígy ki kell tudnunk választani az általunk exportált adatok formátumát, amiket tetszőleges perifériaeszközön keresztül exportálunk, legyen szó egy nyomtatóról, egy diszkről, egy monitorról ... Ezeket a be- és kimeneti karakterláncokat mindíg úgy kell tekinteni, hogy konkrétan byte-sorozatokról van szó és különböző mechanizmusokat kell alkalmaznunk ezen 126


Bevezetés a Python 3-ba byte-sorozatoknak karakterlánccá alakítására illetve az ellenkező irányú átalakításra. A Python mostantól fogva egy új adattípust bocsát a rendelkezésünkre, a bytes típust, amit speciálisan byte-sorozatok (illetve karakterláncok) kezelésére terveztek. A karakterek természetesen byte-okban lehetnek kódolva és a byte-ok karakterekbe lehetnek dekódolva (speciálisan UTF-8 kódolással, amit az imént láttunk):

 >>> ch ai ne = "Egy l épé s\n " >>> of = open( " t e s t . tx t " , "w" ) >>> o f . wr it e ( ch ai ne ) 10 >>> of . c l o s e () >>> of = open ( " te st . txt " , " rb " ) >>> oc te ts = of . read () >>> typ e ( ch ai ne ) >>> p r i n t ( cha in e ) Egy l épé s >>> l en ( ch ai ne ) 10 >>> type ( o ct et s ) >>> p r i n t ( oc te ts ) b ’Egy l \xc3 \xa9p\xc3 \x a9s \n ’ >>> l en ( o c t e t s ) 12  

©

A Python scriptek esete Mivel a Python-scriptek szövegek, ezért fennáll a veszély, hogy más szabvány szerint vannak kódolva. Annak érdekében, hogy a Python korrekt módon tudja őket interpretálni, érdemes pontosan megadni a karakterkészletet (kötelezően a script 2. vagy 3. sorában). Előzőleg ismerni kell a rendszerünk által használt karakterkészletet (lásd a A.3 ábrát).  import sys p r i n t ( sy s . std ou t . enc odi ng ) # c p125 2 (Windows XP/SciTE)  ©  c Robert Cordeau 

127

Bevezetés a Python 3-ba Tehát megadjuk a scriptekben :

 # −∗− coding : cp1252 −∗−  

©

Vagy (ami a Python 3 esetében alapértelmezett):

 # −∗− coding : UTF−8 −∗−  

©

A.3. ábra. A cp1252 karakterkészlet

128


Bevezetés a Python 3-ba Az Unicode-hibák elkerüléséhez Az Unicode-hibák elkerülésére szolgáló technika abból áll, hogy be-/kimenetek pillanatában jelezzük a kódolást. Például : >>> ch ai ne = "Egy l épé s\n " >>> of = open ( " te st . txt " , "w" , encodi ng=" Latin −1" ) >>> o f . wr it e ( ch ai ne ) 10 >>> of . c l o s e () >>> of = open ( " te st . txt " , " r " , encodi ng=" Latin −1" ) >>> ch_lue = o f . rea d ( ) >>> of . c l o s e () >>> ch_lue ’Egy l épé s \n ’  © 


129


B. Függelék A logikai függvények A Boole-logika A XIX. században George Boole matematikus teljesen átalakította a logikát egy formális formális rendszerré. Ma a Boole-algebrának számos alkalmazása van informatikában és az elektromos áramkörök tervezésében. Ez egy kétértékű logika. Legyen B = { 0, 1 } definíciós halmaz, melyen definiáljuk a NO, AND és OR operátorokat. A változók értékeit néha False-sal és True-val jelöljük. Az operátorokat néha rendre mint a¯ , a.bésa + b jelöljük. Az igazságtáblák Az alap boole-operátorok igazságtáblája: Unáris NOT-operátor a

NOT(a)

0 1

1 0

Bináris AND és OR-operátorok

130

a

b

0 0 1 1

0 1 0 1

a OR b a AND b

0 1 1 1

0 0 0 1 c Hungarian Translation Daróczy Péter 

Bevezetés a Python 3-ba Kizáró, ekvivalencia és implikáció-operátorok


a

b

0 0 1 1

0 1 0 1

a XOR b a ⇐⇒ b a =⇒ b

0 1 1 0

1 0 0 1

1 1 0 1

131


C. Függelék Aritmetikai alapok Definíció A számábrázolási rendszer vagy számrendszer meghatározza, hogy hogyan ábrázolható egy adott szám különböző alapszámot használó számrendszerekben. Egy szám jegy tényleges értéke /helyiértéke/ attól függ, hogy a szám melyik pozíciójában áll, ugyanis ekkor az alaki érték még megszorzódik az alapszám adott pozíciója szerint hatványával. Ha b a számrendszer alapja, akkor a számot az a1 bk + a2 bk 1 + a3 bk 2 + . . . + ak + 1 b0 formában fejezzük ki, a szám számjegyeit a1 a2 a3 . . . ak+1 sorrendben írjuk le. A használt számjegyek a természetes számok, 0 és b-1 között. A bk és b k számok a k-adik pozícióhoz tartozó úgynevezett nagyságrendek. −

−

−

132



D. Függelék A hash-függvények Működési elv A hash függvény egy f alkalmazás, aminek a bemenete különböző hosszúságú file-ok, amiket tömörít és kimenetként egy rögzített hosszúságú bináris sorozatot ad ( lásd D.1 ábrát) : f : { 0, 1 } → { 0, 1 }k ∗

ahol f értelmezési tartománya a { 0, 1 } = { ∅, 0, 1, 10, 11, 100, 101,... } bináris sorozatok halmaza, értékkészlete a k db bitből álló { 0, 1 }k = { 0...00, 0...01, 0...10, ..., 1...11 } bináris szekvenciák halmaza. Ennek az alkalmazásnak lehetővé kell tenni a bemeneti file-ok azonosítását : f (x) = f (y ) akkor és csak akkor, ha x = y . Viszont a véges k hossz miatt nem tudjuk visszaállítani a file-okat:létezik két különböző x és y (különböző file-ok) úgy, hogy f (x) = f (y) (ugyanaz a bináris szekvencia). Ekkor ütközésről (collision ) beszélünk. Gyakorlati megvalósítás Két problémát kell megoldani : ∗

• egy elég hosszú bináris szekvencia választásával csökkenteni kell az ütközések számát. Például k = 512-vel 2512 azaz 10154 cella áll rendelkezésre. • egy megfelelő algoritmussal a kezelni kell a fennmaradó ütközéseket.


133


D.1. ábra. A hashing működési elve Alkalmazás a szótárakra S memóriánk van m adat tárolására. Mindegyik adathoz asszociatív tömb segítségével tudunk hozzáférni, ahol a szögletes zárójelben szereplő információt kulcsnak hívják : S [0], S [1],...,S [m − 1]. Például karakterkulcsokkal a következő módon definiált hash-függvényt fogunk használni : f : { a,b,c,...,z } → { 0, 1, 2,...,m − 1 }k ∗

A következő információk legyenek egy szótárban tárolva ( lásd D.2 ábrát): lapin renard hérisson ours

(a) Tárolás ütközés nélkül

12 2 4 1

(b) Ütközés kezelése lineáris próbával

D.2. ábra. Egy szótár kulcsainak hash-elése 134



E. Függelék Források E.1. WEB-es források Általános : ... www.python.org http://pypi.python.org/pypi/ http://code.google.com/p/pythonxy/wiki/Downloads?tm=2 http://rgruet.free.fr

Speciális EDI-k : www.wingware.com/downloads/wingide-101 http://eric-ide.python-projects.org/eric-download.htm www.eclipse.org/downloads/ www.scintilla.org/SciTEDownload.html

Eszközök : www.gnuplot.info/

Python 3.1 szintaxis összefoglalás : http://perso.limsi.fr/pointal/python:abrege


135


F. Függelék Fogalmak

136


python_roco_20120229

Recommend Documents