Seriál: V zajatí Pythona / 4. časť: Moduly

Pyt­hon ver­zie 1.6 med­zi­ča­som po­vy­rás­tol z be­ty na fi­nál­nu ver­ziu a stal sa prís­tup­ným ce­lé­mu sve­tu. No zme­ny op­ro­ti star­šej ver­zii 1.52 sú ne­pod­stat­né op­ro­ti zlep­še­niam, kto­ré pri­ne­sie ver­zia 2.0. Z ver­zie 2.0 je mo­men­tál­ne dos­tup­ná pr­vá be­ta. Naj­dô­le­ži­tej­šie zme­ny v tej­to no­vej ver­zii pred­sta­vu­jú:

  •   skrá­te­né pri­ra­ďo­va­nie, syn­tax ako v C (x += 10)
  •   zdo­ko­na­le­ná prá­ca s po­ľa­mi ([x*2 for x in ran­ge (9)])
  •   mož­nosť im­por­to­vať mo­dul pod iným me­nom (im­port string as re­ta­zec)
  •   zlep­še­ný vý­raz print (print >> fi­le, "Ahoj")

Po­sled­né dve zme­ny vám bu­dú jas­né až po pre­čí­ta­ní toh­to (naj­nes­kôr ďal­šie­ho) čís­la se­riá­lu. Ok­rem týc­hto zmien pri­bud­ne vo ver­zii 2.0 pár mo­du­lov a zo­pár sa ich zme­ní. V tej­to čas­ti se­riá­lu bu­de reč o mo­du­loch, jed­nej z hlav­ných „zbra­ní” Pyt­ho­na.

Mo­du­ly

Ako sme už uvied­li v pr­vej čas­ti se­riá­lu, prog­ra­my, kto­ré nec­hce­me stra­tiť po opus­te­ní inter­pre­ta (ak chce­me čas­ti ich kó­du vy­užiť viac­krát), pí­še­me v texto­vom edi­to­re a uk­la­dá­me do sú­bo­ru, naj­lep­šie s prí­po­nou .py. Ten­to po­stup sa na­zý­va skrip­to­va­nie. Keď sa ča­som skrip­ty zväč­šia, zvy­čaj­ne sa pre ľah­šiu sprá­vu roz­de­lia na via­ce­ré sú­bo­ry. V rám­ci jed­né­ho sú­bo­ru na­zý­va­me zos­ku­pe­nia ta­kýc­hto med­zi se­bou sú­vi­sia­cich skrit­pov mo­dul. Po­mo­cou mo­du­lov te­da ľah­ko spra­vu­je­me na­še prog­ra­my. Mo­dul mô­že vy­uží­vať de­fi­ní­cie z iných mo­du­lov. Prá­cu s mo­dul­mi si uká­že­me na fun­kciách pr­vo­cis­lo a pr­vo­cis­lo2 z pred­chád­za­jú­cej čas­ti se­riá­lu. Tie­to fun­kcie umies­tni­me do sú­bo­ru mo­dul1.py v ad­re­sá­ri, z kto­ré­ho spus­tí­me Pyt­hon. Sú­bor mo­dul1.py by mal vy­ze­rať tak­to:

#jed­no­duc­he fun­kcie na pra­cu s pr­vo­cis­la­mi

def pr­vo­cis­lo(n):
       "vy­pi­se ci je n pr­vo­cis­lo"
       for x in ran­ge(2,n):
               if n % x == 0:
                       print n, '=', x, '*', n/x
                       break
       el­se:
               print n, 'je pr­vo­cis­lo'


def pr­vo­cis­lo2(n):
        "vra­ti po­le s pr­vo­cis­la­mi do n"
        vy­sle­dok=[]
        for n in ran­ge(2, n):
                for x in ran­ge(2,n):
                        if n% x == 0:
                                break
                el­se:
                        vy­sle­dok.ap­pend(n)
        re­turn vy­sle­dok

Pre kaž­dý im­por­to­va­ný mo­dul vy­tvo­rí Pyt­hon šty­ri glo­bál­ne pre­men­né, pri­čom pre nás sú za­ují­ma­vé tri. Me­no mo­du­lu (napr. mo­dul1) je prís­tup­né cez glo­bál­nu pre­men­nú __na­me__. V pre­men­nej __fi­le__ je me­no im­por­to­va­né­ho sú­bo­ru (napr. mo­dul1.py). Ako sme si už uká­za­li v pre­doš­lých čís­lach, po­mo­cou __doc__ pris­tu­pu­je­me k do­ku­men­tač­né­mu re­ťaz­cu ob­jek­tu. K tým­to pre­men­ným pris­tu­pu­je­me konštruk­ciou me­no_mo­du­lu.__pre­men­na__.

>>> im­port mo­dul1
>>> mo­dul1.__fi­le__
'C:\\Prog­ram Fi­les\\Pyt­hon\\mo­dul1.pyc'

Asi ste po­streh­li, že prí­po­na mo­du­lu je .pyc, a nie .py. Pre­čo je to tak, to sa vy­svet­ľu­je v od­se­ku „Kom­pi­lo­va­né“ pyt­ho­nov­ské sú­bo­ry.

Na tom­to mies­te je tiež vhod­né uviesť, čo sú ta­buľ­ky sym­bo­lov. Ide o dopl­ne­nie pre­doš­lé­ho čís­la, kde sme sa zmie­ni­li o lo­kál­nych pre­men­ných. Pre kaž­dý blok v Pyt­ho­ne sa vy­tvo­rí ta­buľ­ka sym­bo­lov, kto­rá ob­sa­hu­je všet­ky iden­ti­fi­ká­to­ry v da­nom blo­ku. Ta­ká­to ta­buľ­ka ob­sa­hu­je te­da lo­kál­ne pre­men­né, pre­to ho­vo­rí­me, že je to lo­kál­na ta­buľ­ka sym­bo­lov. Glo­bál­ne pre­men­né ob­sa­hu­je glo­bál­na ta­buľ­ka sym­bo­lov. Glo­bál­ne pre­men­né sú prís­tup­né z kaž­dej čas­ti náš­ho prog­ra­mu, lo­kál­ne len z blo­ku, kde bo­li de­fi­no­va­né. Po ukon­če­ní blo­ku za­nik­nú je­ho lo­kál­ne pre­men­né. Ak to­mu chce­me za­brá­niť, po­mo­cou prí­ka­zu glo­bal (napr. glo­bal a) de­fi­nu­je­me glo­bál­nu pre­men­nú v blo­ku:

>>> def a():
	glo­bal x #glo­bal­na pre­men­na
	def fun­kcia():
		print "asdf"
	x=fun­kcia
>>> fun­kcia()
>>> x()
Asdf

Všet­ky de­fi­ní­cie (fun­kcie pr­vo­cis­lo a pr­vo­cis­lo2) z mo­du­lu mo­dul1 im­por­tu­je­me prí­ka­zom im­port:

>>> im­port mo­dul1 

a po­uží­va­me tak­to: 

>>> mo­dul1.pr­vo­cis­lo(23)
23 je pr­vo­cis­lo
>>> a = mo­dul1.pr­vo­cis­lo2(10)
>>> a
[2, 3, 5, 7] 

Ako ste si už ur­či­te všim­li, k de­fi­ní­ciám z mo­du­lov im­por­to­va­ných po­mo­cou prí­ka­zu im­port pris­tu­pu­je­me po­dob­ne ako ku glo­bál­nym pre­men­ným mo­du­lu, a to po­mo­cou konštruk­cie me­no_mo­du­lu.me­no_de­fi­ní­cie. Keď­že vy­pi­so­vať pri kaž­dom po­uži­tí de­fi­ní­cie me­no_mo­du­lu mô­že byť po­mer­ne nep­rak­tic­ké (ak napr. plá­nu­je­me vy­uží­vať im­por­to­va­nú fun­kciu viac­krát), pri­ra­dí­me jej no­vé me­no:

 
>>> pr­vo­cis­lo = mo­dul1.pr­vo­cis­lo 

Im­por­to­vať však ne­mu­sí­me rov­no ce­lé mo­du­ly. Ak plá­nu­je­me vy­uží­vať len niek­to­ré de­fi­ní­cie z da­né­ho mo­du­lu, po­uži­je­me prí­kaz from me­no_mo­du­lu im­port de­fi­ní­cia1, de­fi­ní­cia2, ..., de­fi­ní­ciaN, pri­čom si pri po­uží­va­ní tak­to im­por­to­va­ných de­fi­ní­cií ušet­rí­me vy­pi­so­va­nie me­na mo­du­lu v sa­mot­ných prí­ka­zoch.

>>> from mo­dul1 im­port pr­vo­cis­lo, pr­vo­cis­lo2
>>> pr­vo­cis­lo(78)
78 = 2 * 39

Po­mo­cou prí­ka­zu from me­no_mo­du­lu im­port * im­por­tu­je všet­ky de­fi­ní­cie z da­né­ho mo­du­lu, kto­ré sa ne­za­čí­na­jú zna­kom "_".

>>> from mo­dul1 im­port *
>>> pr­vo­cis­lo(2)
4 = 2 * 2

Kde hľa­dá Pyt­hon mo­du­ly?

Pod Unix OS je ces­ta k mo­du­lom ulo­že­ná v shellov­skej pre­men­nej $PYT­HON­PATH. Syn­tax je tá is­tá ako pri pre­men­nej $PATH, kto­rá udá­va ces­tu k spus­ti­teľ­ným sú­bo­rom. Eš­te pred ces­tou v pre­men­nej $PYT­HON­PATH sa mo­du­ly hľa­da­jú v ad­re­sá­ri, kde sme spus­ti­li inter­pre­ta Pyt­ho­na. Pod Win­dows je ces­ta k mo­du­lom uda­ná v da­ta­bá­ze Re­gis­try, pri­čom mo­du­ly sa naj­prv tiež hľa­da­jú v ad­re­sá­ri, od­kiaľ sme spus­ti­li inter­pret. S ces­tou k mo­du­lom pra­cu­je­me po­mo­cou po­ľa ap­pend z mo­du­lu sys:

>>> im­port sys
>>> sys.path.ap­pend(“c:\\”) #mo­du­ly sa bu­du hla­dat aj na c:\

Mo­dul sys sprís­tup­ňu­je fun­kcie a pre­men­né, kto­ré úz­ko sú­vi­sia s inter­pre­tom Pyt­ho­na, ok­rem ďal­ších aj pre­men­né ps1 a ps2, kto­ré de­fi­nu­jú vý­zor prom­ptu (vý­zva inter­pre­ta na za­da­nie prí­ka­zu). Tie­to pre­men­né sú prís­tup­né len vte­dy, ak sa nac­hád­za­me v inter­ak­tív­nom re­ži­me.

>>> print sys.ps1; print sys.ps2
>>>
...
>>> sys.ps1="za­daj nie­co >"
za­daj nie­co >

Štan­dar­dné mo­du­ly

Jed­ným z naj­väč­ších lá­ka­diel Pyt­ho­na sú asi štan­dar­dné mo­du­ly. Aby sme si pre väč­ši­nu bež­ných ope­rá­cií ne­mu­se­li pí­sať vlas­tné fun­kcie, do­dá­va sa spo­lu s Pyt­ho­nom ko­lek­cia mo­du­lov, kto­ré nám uľah­ču­jú prá­cu s re­ťaz­ca­mi, sie­ťo­vý­mi pro­to­kol­mi, kryp­tog­ra­fiou, kom­pri­mo­va­ný­mi sú­bor­mi, GUI ap­li­ká­cia­mi. Sprís­tup­nia nám ma­te­ma­tic­ké fun­kcie, de­bug­ger, pro­fi­ler, re­gu­lár­ne vý­ra­zy atď. K štan­dar­dným mo­du­lom neod­de­li­teľ­ne pat­rí aj spo­mí­na­ný mo­dul sys. Väč­ši­na týc­hto mo­du­lov je dos­tup­ná pre všet­ky plat­for­my (Unix, Win­dows, Ma­cOS), niek­to­ré sú však dos­tup­né len pre ten či onen OS. Me­ná a opis všet­kých štan­dar­dných mo­du­lov náj­de­te v do­ku­men­tá­cii k Pyt­ho­nu.

„Kom­pi­lo­va­né“ pyt­ho­nov­ské mo­du­ly

Pyt­hon po­dob­ne ako os­tat­né skrip­to­va­cie ja­zy­ky je po­dstat­ne po­mal­ší ako tie ja­zy­ky, kto­rých zdro­jo­vé kó­dy sa kom­pi­lu­jú. Pre­to­že rých­losť je veľ­mi dô­le­ži­tým as­pek­tom dob­ré­ho prog­ra­mu, mo­der­nej­šie skrip­to­va­cie ja­zy­ky kom­pi­lu­jú kód do aké­ho­si „bi­nár­ne­ho med­zi­kó­du” – baj­tkó­du –, kto­rý po­tom vy­ko­ná­va­jú. Pri po­uži­tí ne­ja­ké­ho mo­du­lu (pri je­ho im­por­to­va­ní) sa v ad­re­sá­ri, kde sa do­tyč­ný mo­dul nac­hád­za, hľa­dá rov­no­men­ný sú­bor s prí­po­nou .pyc. Ta­ký­to sú­bor ob­sa­hu­je baj­tkód rov­no­men­né­ho sú­bo­ru s prí­po­nou .py. Ak sú­bor s prí­po­nou .pyc neexis­tu­je, Pyt­hon ho auto­ma­tic­ky vy­tvo­rí. Sú­bor .pyc ob­sa­hu­je aj čas po­sled­nej mo­di­fi­ká­cie rov­no­men­né­ho sú­bo­ru .py. Ak sa čas v sú­bo­re s prí­po­nou .pyc nez­ho­du­je s ča­som mo­di­fi­ká­cie .py sú­bo­ru, sú­bor .pyc bu­de pre­pí­sa­ný no­vou „kom­pi­lo­va­nou” ver­ziou sú­bo­ru .py. Spus­te­ním Pyt­ho­na s pre­pí­na­čom „-O” (pyt­hon -O) spô­so­bí­me, že „bi­nár­ny med­zi­kód” sa bu­de viac op­ti­ma­li­zo­vať (pre­to pre­pí­nač „O” z an­glic­ké­ho slo­va op­ti­mi­ze). Ten­to med­zi­kód sa po­tom ne­bu­de uk­la­dať do sú­bo­ru s prí­po­nou .pyc, ale do sú­bo­ru s prí­po­nou .pyo (me­no sú­bo­ru bu­de, sa­moz­rej­me, to is­té čo me­no mo­du­lu). Aby sme moh­li .pyo sú­bo­ry im­por­to­vať, tre­ba spus­tiť Pyt­hon s uve­de­ným ar­gu­men­tom „–O”. Ok­rem rých­los­ti spo­čí­va vý­ho­da po­uží­va­nia „kom­pi­lo­va­ných” mo­du­lov v tom, že na im­por­to­va­nie mo­du­lu nie je po­treb­ný je­ho zdro­jo­vý kód (sú­bor s prí­po­nou .py). Na po­uži­tie mo­du­lu nám pre­to sta­čí je­ho bi­nár­ny med­zi­kód (v sú­bo­re s prí­po­nou .pyc ale­bo .pyo), tak­to ne­mu­sí­me prez­ra­diť al­go­rit­my náš­ho prog­ra­mu.

Fun­kcia dir()

Vsta­va­ná fun­kcia dir() slú­ži na zis­te­nie mien, kto­ré de­fi­nu­je ne­ja­ký mo­dul. Vra­cia abe­ced­ne zo­ra­de­né po­le re­ťaz­cov. Prík­lad:

>>> dir(mo­dul1)
['__buil­tins__', '__doc__', '__fi­le__', '__na­me__', 'pr­vo­cis­lo', 'pr­vo­cis­lo2']

Bez ar­gu­men­tov vrá­ti fun­kcia dir() prá­ve de­fi­no­va­né me­ná:

>>> a,b,c = 3,12,-9
>>> im­port sys, mo­dul1
>>> dir()
['__buil­tins__', '__doc__', '__na­me__', 'a', 'b', 'c', 'mo­dul1', 'sys']

Fun­kcia dir() nev­ra­cia me­ná vsta­va­ných pre­men­ných a fun­kcií (napr. tup­le, ran­ge). Aby sa tak sta­lo, mu­sí­me im­por­to­vať štan­dard­ný mo­dul __buil­tin__ a naň po­užiť fun­kciu dir():

>>> im­port __buil­tin__
>>> dir(__buil­tin__) 

Ba­líč­ky

Mož­nos­ti štruk­tú­ro­va­nia zdro­jo­vých kó­dov v Pyt­ho­ne sa ne­kon­čia pri mo­du­loch. Mô­že sa stať, že mo­du­ly sa roz­ras­tú do neú­nos­ných roz­me­rov a sa­my ose­be ne­bu­dú môcť po­skyt­núť dos­ta­toč­né mož­nos­ti na štruk­tú­ro­va­nie na­šich prog­ra­mov. V ta­kom prí­pa­de nám prí­du vhod tzv. ba­líč­ky (pac­ka­ges), ad­re­sá­re so zos­ku­pe­ním nav­zá­jom sú­vi­sia­cich mo­du­lov. Prá­ca s ba­líč­ka­mi je po­dob­ná prá­ci s mo­dul­mi. Je ne­vyh­nut­ná na roz­siah­lych pro­jek­toch. Z pries­to­ro­vých dô­vo­dov (v se­riá­li nep­lá­nu­jem pí­sať prog­ra­my s 1000 a viac riad­ka­mi;) sa ba­líč­ka­mi ne­bu­dem za­obe­rať. Ak sa chce­te bliž­šie oboz­ná­miť s ba­líč­ka­mi, od­po­rú­čam do­ku­men­tá­ciu Pyt­ho­na.

Na­bu­dú­ce

Po­zrie­me sa na prob­le­ma­ti­ku vstu­pov a vý­stu­pov v Pyt­ho­ne.

Ďal­šie čas­ti >>

Zdroj: PC Revue



Ohodnoťte článok:
   
 
 
  Zdieľaj cez Facebook Zdieľaj cez Google+ Zdieľaj cez Twitter Zdieľaj cez LinkedIn Správy z RSS Správy na smartfóne Správy cez newsletter