Seriál: V zajatí Pythona / 5. časť: Vstup a výstup do súboru

Zo všet­kých dô­le­ži­tých tém Pyt­ho­na nám zos­tá­va po­zrieť sa na vstup/vý­stup, chy­by/vý­nim­ky a, sa­moz­rej­me, na ob­jek­to­vo orien­to­va­né prog­ra­mo­va­nie. Té­mou tej­to čas­ti mal byť pô­vod­ne len vstup/vý­stup, nes­kôr som sa však roz­ho­dol, že pri­be­riem aj ka­pi­to­lu o chy­bách a vý­nim­kách – veľ­mi za­ují­ma­vé čí­ta­nie! Med­zi­ča­som sa nám stih­la pre­biť na svet­lo sve­ta aj fi­nál­na ver­zia Pyt­ho­na 2.0. Zmien je toľ­ko, že ich z pries­to­ro­vých dô­vo­dov ani všet­ky ne­mô­žem vy­me­no­vať. Naj­dô­le­ži­tej­šie som aj tak spo­me­nul v pre­doš­lej čas­ti se­riá­lu a tie zvyš­né sa da­jú náj­sť pod http://www.pyt­hon.org/2.0/. Na vy­skú­ša­nie prík­la­dov v na­šom se­riá­li vám bu­de sta­čiť aj ver­zia 1.52, ak však má­te mož­nosť, download ver­zie 2.0 mô­žem len od­po­rú­čať.

Vstup a vý­stup do sú­bo­ru

Fun­kcia open('su­bor','mod') vra­cia ob­jekt s uka­zo­va­te­ľom na sú­bor, s kto­rým bu­de­me pra­co­vať („ot­vo­rí sú­bor“). Pr­vý ar­gu­ment tej­to fun­kcie udá­va ces­tu k sú­bo­ru. Dru­hý ar­gu­ment, kto­rý nie je po­vin­ný, udá­va mód, v akom bu­de­me so sú­bo­rom pra­co­vať. Ak vy­nec­há­me ten­to ar­gu­ment, po­uži­je sa mód na čí­ta­nie zo sú­bo­ru (r). Prík­lad:

>>> su­bor=open('test.txt', 'a') #ot­vo­ri­me su­bor na za­pis na ko­niec
>>> su­bor #zob­ra­zi vlas­tnos­ti uka­zo­va­te­la na su­bor
>>> 
dru­hy_su­bor=('fi­le') #su­bor fi­le sa ot­vo­ri v mo­de na ci­ta­nie
Mó­dy ot­vá­ra­nia sú­bo­rov

mód opis
r texto­vý sú­bor na čí­ta­nie
w texto­vý sú­bor na zá­pis; ak exis­tu­je rov­no­men­ný sú­bor, bu­de pre­pí­sa­ný
a texto­vý sú­bor na zá­pis na ko­niec sú­bo­ru
r+ texto­vý sú­bor na čí­ta­nie a zá­pis
w+ texto­vý sú­bor na čí­ta­nie, zá­pis ale­bo pre­pí­sa­nie v prí­pa­de, ak exis­tu­je rov­no­men­ný sú­bor
a+ texto­vý sú­bor na čí­ta­nie a zá­pis na ko­niec sú­bo­ru
rb bi­nár­ny sú­bor na čí­ta­nie
wb bi­nár­ny sú­bor na zá­pis; ak exis­tu­je rov­no­men­ný sú­bor, bu­de pre­pí­sa­ný
ab bi­nár­ny sú­bor na zá­pis na ko­niec sú­bo­ru
rb+ bi­nár­ny sú­bor na čí­ta­nie a zá­pis
wb+ bi­nár­ny sú­bor na čí­ta­nie, zá­pis ale­bo pre­pí­sa­nie v prí­pa­de, ak exis­tu­je rov­no­men­ný sú­bor
ab+ bi­nár­ny sú­bor na čí­ta­nie a zá­pis na ko­niec sú­bo­ru

Po­uží­vať bi­nár­ne mó­dy má zmy­sel len s Win­dows a Ma­cin­tosh. Pod OS Unix je jed­no, či po­uži­je­te bi­nár­ne mó­dy ale­bo texto­vé.

Zá­klad­né me­tó­dy na prá­cu so sú­bo­rom

Aby prá­ca so sú­bor­mi ma­la zmy­sel, mu­sí­me ve­dieť, ako pre­čí­tať a za­pí­sať dá­ta zo/do sú­bo­ru.

Čí­ta­nie zo sú­bo­ru

Na čí­ta­nie ob­sa­hu sú­bo­ru slú­ži me­tó­da read(kol­ko), kto­rá pre­čí­ta sú­bor a vrá­ti pre­čí­ta­né dá­ta. Jej ar­gu­ment udá­va, koľ­ko zna­kov chce­me pre­čí­tať. Ak je ten­to ar­gu­ment ne­ga­tív­ny ale­bo sa rov­ná nu­le, pre­čí­ta a vrá­ti sa ce­lý sú­bor na­raz. Nie je vhod­né čí­tať ce­lé sú­bo­ry na­raz, pre­to­že sa tým plyt­vá pa­mäť po­čí­ta­ča. Po pre­čí­ta­ní ce­lé­ho sú­bo­ru nev­ra­cia me­tó­da hod­no­tu EOF, ako je to zvy­kom v iných ja­zy­koch, ale len prázd­ny re­ťa­zec ("").

>>> f=open('test.txt') #ot­vo­ri­me su­bor na ci­ta­nie
>>> f.read(15)
'ukaz­ko­vy su­bor\012'

Čí­tať v sú­bo­re sa za­čí­na vždy úpl­ne na za­čiat­ku sú­bo­ru, na po­zí­cii 0. Po pre­čí­ta­ní ur­či­té­ho množ­stva sa bu­de čí­tať od po­zí­cie, kde sa skon­či­lo pred­chád­za­jú­ce čí­ta­nie. Nap­rík­lad v na­šom uve­de­nom prík­la­de sa za­čne ďal­šie čí­ta­nie od zna­ku 15. Po­hy­bu v sú­bo­roch je ve­no­va­ný vlast­ný od­sek.

>>> f.read() #ci­ta­ne upl­ne do kon­ca su­bo­ru
'2. ria­dok\012

Me­tó­da read­li­ne() vrá­ti je­den ria­dok zo sú­bo­ru, pri­čom vrá­ti aj znak kon­ca riad­ka (\n ale­bo \012). Pri práz­dnych riad­koch je vrá­te­ný len znak kon­ca riad­ka. Po­dob­ne ako me­tó­da read() vra­cia me­tó­da read­li­ne() prázd­ny re­ťa­zec ('') po do­siah­nu­tí kon­ca sú­bo­ru.

>>> f=open('test.txt')
>>> f.read­li­ne() #pre­ci­ta­me dru­hy ria­dok
'ukaz­ko­vy su­bor\012'
>>> f.read­li­ne() #pre­ci­ta­me pr­vy ria­dok
'2. ria­dok\012'
>>> f.read­li­ne() #ko­niec su­bo­ru
''

Ďal­šia me­tó­da read­li­nes() vrá­ti po­le ob­sa­hu­jú­ce všet­ky riad­ky v sú­bo­re.

>>> f=open('test.txt')
>>> f.read­li­nes()
['ukaz­ko­vy su­bor\012', '2. ria­dok\012']

Zá­pis do sú­bo­ru

Do sú­bo­ru, kto­rý sme ot­vo­ri­li s op­ciou zá­pi­su (po­zri ta­buľ­ku s mód­mi), je mož­né po­mo­cou me­tó­dy wri­te(re­ta­zec) za­pi­so­vať dá­ta. Tá­to me­tó­da za­pí­še re­ťa­zec, kto­rý je jej od­ov­zda­ný, ako ar­gu­ment do sú­bo­ru a vrá­ti None (aby sa to ľah­šie po­cho­pi­lo, dá sa aj po­ve­dať, že me­tó­da wri­te(re­ta­zec) nev­rá­ti ni­ja­kú hod­no­tu).

>>> f=open('test.txt','a+')
>>> f.wri­te('3. ria­dok')
>>> f.read()
''

V tom­to prí­pa­de vra­cia me­tó­da read() prázd­ny ria­dok, pre­to­že po­zí­cia v sú­bo­re sa po­su­nu­la za za­pí­sa­ný text na ko­niec sú­bo­ru.

Zme­na po­zí­cie v sú­bo­re

Ako ste si všim­li, všet­ky me­tó­dy na prá­cu so sú­bor­mi, na kto­ré sme sa do­te­raz po­zre­li, po­sú­va­jú auto­ma­tic­ky po­zí­ciu v sú­bo­re. Mo­men­tál­nu po­zí­ciu v sú­bo­re zis­tí­me me­tó­dou tell(), kto­rá vra­cia pri­rod­ze­né čís­lo udá­va­jú­ce po­čet zna­kov med­zi za­čiat­kom sú­bo­ru a mo­men­tál­nou po­zí­ciou v sú­bo­re.

Na zme­nu po­zí­cie v sú­bo­re slú­ži me­tó­da seek(kol­ko, od­kial). Po­zí­cia, kde sa pre­mies­tni­me v rám­ci sú­bo­ru, sa vy­po­čí­ta spo­čí­ta­ním ar­gu­men­tu kol­ko s ar­gu­men­tom od­kial. Ar­gu­ment od­kial mô­že mať tri hod­no­ty:

• 0 – za­čia­tok sú­bo­ru
• 1 – mo­men­tál­na po­zí­cia
• 2 – ko­niec sú­bo­ru

Ak sa ar­gu­ment od­kial vy­nec­há, bu­de sa po­čí­tať od za­čiat­ku sú­bo­ru (štan­dar­dná hod­no­ta 0). Prík­la­dy:

>>> f=open('test.txt','r')
>>> f.read(8) #me­to­da read() nas auto­ma­tic­ky pre­su­nie na 8. znak
'ukaz­ko­vy'
>>> f.seek(-1,2); f.tell() #na po­sled­ny znak
42
>>> f.seek(-10,1); f.tell() #o 10 zna­kov dop­re­du
32
>>> f.seek(5); f.tell() #na 5. znak od za­ciat­ku su­bo­ru
5

Za­tvo­re­nie ot­vo­re­né­ho sú­bo­ru

Ho­ci neu­zat­vo­re­né sú­bo­ry bu­dú auto­ma­tic­ky uzav­re­té ope­rač­ným sys­té­mom pri ukon­če­ní náš­ho prog­ra­mu, je dob­ré si zvyk­núť uzat­vá­rať sú­bo­ry me­tó­dou clo­se(). Šet­rí­me tým pa­mäť po­čí­ta­ča.

>>> f=open('test.txt','a')
>>> f.clo­se()
>>> f.read()
Tra­ce­back (in­ner­most last):
  Fi­le "", li­ne 1, in ?
Va­lueError: I/O ope­ra­tion on clo­sed fi­le

Po uzat­vo­re­ní sú­bo­ru pres­ta­ne fun­go­vať uka­zo­va­teľ na ten­to sú­bor. Po­uži­tie uka­zo­va­te­ľa už za­tvo­re­né­ho sú­bo­ru vy­vo­lá chy­bu. Chy­by a vý­nim­ky sú ďal­šia veľ­ká ka­pi­to­la Pyt­ho­na. Aby sme však nep­red­bie­ha­li, do­kon­čí­me naj­prv ka­pi­to­lu o vstu­pe/vý­stu­pe od­se­kom o veľ­mi dô­le­ži­tom mo­du­le pick­le.

Mo­dul pick­le

Do­te­raz sme pra­co­va­li len s re­ťaz­ca­mi. Ak sme nie­čo za­pí­sa­li do sú­bo­ru, tak to bol re­ťa­zec. Ta­kis­to sme pra­co­va­li s re­ťaz­ca­mi pri čí­ta­ní zo sú­bo­ru, keď­že všet­ky fun­kcie na čí­ta­nie vra­ca­jú re­ťaz­ce. Si­tuácia sa nám troš­ku skom­pli­ku­je, ak chce­me pra­co­vať s čís­la­mi. Ak za­pí­še­me čís­lo do sú­bo­ru, ulo­ží sa nám ako re­ťa­zec. Keď ho nes­kôr čí­ta­me, mu­sí­me ho skon­ver­to­vať na čís­lo po­mo­cou fun­kcie eval(). Uk­la­da­ním po­lí, tup­le, slov­ní­kov ale­bo napr. tried sa nám ži­vot eš­te viac skom­pli­ku­je. Do­kon­ca sa mô­že zdať, že je to ne­mož­né. Ako te­da ulo­žiť tie­to dá­to­vé ty­py? Keď­že nie sme je­di­ní, kto­rí ma­li po­dob­ný prob­lém, vzni­kol mo­dul pick­le, po­mo­cou kto­ré­ho ulo­ží­me aj naj­kom­pli­ko­va­nej­šie dá­to­vé ty­py Pyt­ho­na. Po im­por­to­va­ní mo­du­lu pick­le mô­že­me je­ho me­tó­dou dump(co, uka­zo­va­tel_na_su­bor) uk­la­dať roz­lič­né dá­to­vé ty­py do sú­bo­ru a po­mo­cou me­tó­dy load(uka­zo­va­tel_na_su­bor) ich čí­tať.

>>> im­port pick­le, sys
>>> f=open('no­tes','w')                                     
>>> tel­cis­la={'ro­bert':'183 426','man­fred':'684 158'}
>>> pick­le.dump(tel­cis­la,f) #ulo­zi­me slov­nik "tel­cis­la"
>>> f.clo­se() #za­tvo­ri­me su­bor
>>> sys.exit() #opus­ti­me Pyt­ho­na
>>> im­port pick­le
>>> f=open('no­tes','r')
>>> tel­cis­la=pick­le.load(f)
{'ro­bert': '183 426', 'man­fred': '684 158'}

Chy­by a vý­nim­ky

S vý­nim­kou od­se­ku Zme­na po­zí­cie v sú­bo­re som sa do­te­raz sna­žil kon­ci­po­vať prík­la­dy tak, aby som ne­mu­sel uvád­zať chy­bo­vé hlá­se­nia Pyt­ho­na. Jed­ným z dô­vo­dov bo­lo, že som vás nec­hcel iri­to­vať tý­mi­to chy­bo­vý­mi hlá­se­nia­mi. Dru­hý bol pries­to­ro­vý dô­vod. Na pr­vý po­hľad neu­ká­žu tie­to hlá­se­nia nič za­ují­ma­vé a za­be­ra­jú prie­mer­ne tri cen­né riad­ky. Te­raz vám uká­žem, že to tak cel­kom nep­la­tí a že chy­bo­vé hlá­se­nia nás upo­zor­nia na ve­ľa dô­le­ži­tých ve­ci, vý­nim­ky sa mô­žu stať veľ­mi dob­rým pria­te­ľom prog­ra­má­to­ra.

Chy­by syn­taxe

Pred­sta­vu­jú naj­čas­tej­ší druh chýb. Do­pus­tí­me sa ich, ak nie­čo nes­práv­ne na­pí­še­me a Pyt­hon na­šej po­žia­dav­ke ne­po­ro­zu­mie. Nap­rík­lad:

>>> def fun­kcia() #za­bu­dol som ":"
  Fi­le "", li­ne 1
    def fun­kcia()
                ^
Syn­taxError: in­va­lid syn­tax

V riad­ku pod na­šou nes­práv­nou de­fi­ní­ciou hneď za slo­vom Fi­le náj­de­me údaj, v kto­rom sú­bo­re sa chy­ba sta­la. Ak uvi­dí­me , zna­čí to, že chy­ba sa sta­la pri inter­ak­tív­nom vstu­pe (za­dá­va­nia prí­ka­zov). Za slo­vom li­ne vi­dí­me, na kto­rom riad­ku sa chy­ba sta­la. V ďal­šom riad­ku uvi­dí­me, kde v de­fi­ní­cii sa chy­ba vy­skyt­la. Pyt­hon sa nám to­to mies­to sna­ží uká­zať po­mo­cou ma­lej šíp­ky (^).

Vý­nim­ky

Nie všet­ky chy­by sú syn­tak­tic­ké. Aj keď je de­fi­ní­cia syn­tak­tic­ky správ­na, pri vy­ko­ná­va­ní kó­du mô­že dôjsť k chy­be. Ta­ká­to chy­ba sa po­tom vo­lá vý­nim­ka a kaž­dá ta­ká­to vý­nim­ka má svo­je me­no. Ty­pic­kým prík­la­dom vý­nim­ky je de­le­nie nu­lou (Ze­ro­Di­vi­sio­nError). Vý­raz, kde ho po­uži­je­me, je sí­ce syn­tak­tic­ky správ­ny, ale ma­te­ma­tic­ky ne­mož­ný. Je mož­né de­fi­no­vať vlas­tné vý­nim­ky. Na vy­tvo­re­nie vlas­tnej vý­nim­ky bu­de­me mu­sieť ve­dieť, ako vy­tvo­riť trie­du, čo bu­de té­mou ďal­šej čas­ti se­riá­lu. Prík­la­dy vý­ni­miek:

>>> 5/0 #de­le­nie nu­lou
Tra­ce­back (most re­cent call last):
  Fi­le "", li­ne 1, in ?
Ze­ro­Di­vi­sio­nError: in­te­ger di­vi­sion or mo­du­lo
>>> pre­me­na/4 #neexis­tu­ju­ca pre­men­na
Tra­ce­back (most re­cent call last):
  Fi­le "", li­ne 1, in ?
Na­meError: The­re is no va­riab­le na­med 'pre­me­na'

Chy­bo­vé hlá­se­nie je po­dob­né ako pri syn­tak­tic­kej chy­be. Pr­vé slo­vo po­sled­né­ho riad­ka toh­to hlá­se­nia uka­zu­je me­no vý­nim­ky, ako napr. Ze­ro­Di­vi­sio­nError ale­bo Na­meError, zvy­šok riad­ka tvo­rí opis chy­by. Me­ná vý­ni­miek sú vsta­va­né (pred­de­fi­no­va­né) iden­ti­fi­ká­to­ry, no nie sú to kľú­čo­vé slo­vá. Zoz­nam a opis všet­kých vsta­va­ných vý­ni­miek sa dá náj­sť v do­ku­men­tá­cii. Pr­vé dva úda­je stred­né­ho riad­ka chy­bo­vé­ho hlá­se­nia uka­zu­jú, v kto­rom sú­bo­re a na kto­rom riad­ku sa chy­ba sta­la. Zvy­šok chy­bo­vé­ho hlá­se­nia sa za­be­rá zá­sob­ní­kom a je pre nás ne­zau­jí­ma­vý.

Spra­co­va­nie vý­ni­miek

Krá­sa vý­ni­miek spo­čí­va v tom, že sa da­jú spra­cú­vať. Nap­rík­lad pri de­le­ní nu­lou po­koj­ne mô­že­me na­pí­sať po­uží­va­te­ľo­vi náš­ho prog­ra­mu, že nu­lou sa nes­mie de­liť, a tým mu ušet­riť me­nej preh­ľad­né chy­bo­vé hlá­se­nie.

>>> try:>
...     5/0
... except Ze­ro­Di­vi­sio­nError: ... print "nu­lou sa nes­mie de­lit!" ... nu­lou sa nes­mie de­lit!

Všet­ko to fun­gu­je tak­to:

• Blok med­zi try: a except: sa vy­ko­ná,
• ak sa ne­vys­kyt­ne ni­ja­ká vý­nim­ka, blok za try: sa vy­ko­ná a časť except je ig­no­ro­va­ná,
• ak sa v prie­be­hu vy­ko­ná­va­nia blo­ku za try: vy­skyt­ne vý­nim­ka, zvy­šok blo­ku za vý­ra­zom try: bu­de ig­no­ro­va­ný. Me­no vý­nim­ky sa po­rov­ná s vý­nim­kou/vý­nim­ka­mi uve­de­ný­mi pred vý­ra­zom except:, a ak sa me­no vý­nim­ky, kto­rá sa vy­skyt­la, zho­du­je s me­na­mi uve­de­ný­mi pri except:, vy­ko­ná sa blok za except:.
• V prí­pa­de vý­sky­tu vý­nim­ky, kto­rá nie je de­fi­no­va­ná pri except:, bu­de vy­vo­la­né hlá­se­nie vy­sky­tu­jú­cej sa vý­nim­ky, ako­by sa vý­ra­zy except: a try: ne­pou­ži­li.

Ako som už naz­na­čil, mô­že­me spra­cú­vať via­ce­ré vý­nim­ky po­mo­cou je­di­né­ho vý­ra­zu except:, napr. ak chce­me ig­no­ro­vať de­le­nie nu­lou (Ze­ro­Di­vi­sio­nError) a vý­nim­ku po­uži­tia me­na neexis­tu­jú­cej pre­men­nej (Na­meError). V jed­nom vý­ra­ze try: mô­že byť viac vý­ra­zov except:, mô­žu byť ukon­če­né prí­kaz­mi break ale­bo re­turn. Ďalej pla­tí, že except: nes­pra­cú­va len vý­nim­ky vy­sky­tu­jú­ce sa pria­mo v blo­ku za vý­ra­zom try:, ale napr. tie, kto­ré sa vy­skyt­nú vo fun­kciách vy­sky­tu­jú­cich sa v blo­ku za try:

>>> def fun­kcia():
...     pre­men­na/0
... 
>>> try:
...     fun­kcia()
... except:
...     print 'vy­skyt­la sa ne­ja­ka vy­nim­ka'
... 
vy­skyt­la sa ne­ja­ka vy­nim­ka

Po­uži­tím osa­mos­tat­ne­né­ho vý­ra­zu except: bez ar­gu­men­tov (except:), spra­cú­va­me všet­ky vý­nim­ky na­raz. Ta­ký­to osa­mos­tat­ne­ný vý­raz except: od­po­rú­čam po­uží­vať maximál­ne opatr­ne a zried­ka, pre­to­že tým mô­že­me veľ­mi ľah­ko preh­liad­nuť chy­by v na­šich prog­ra­moch.

Vý­raz try..except mô­že mať aj časť el­se: (po­dob­ne ako if, whi­le ale­bo napr. for), kto­rá sa vy­ko­ná, ak sa vy­skyt­ne vý­nim­ka, kto­rá nie je uve­de­ná pri vý­ra­ze except:

for arg in sys.argv[1:]:
         try:
             f=open(arg, 'r') #ot­vo­ri­me su­bor pre­dan­ky ako ar­gu­ment na ci­ta­nie
         except IOError:
             print 'ne­mo­zem ot­vo­rit', arg #su­bor neexis­tu­je
         el­se:
             print arg, 'ma', len(f.read­li­nes()), 'li­nes' #ak sa vy­skyt­ne ina vy­nim­ka
             f.clo­se()

Ar­gu­men­ty vý­ni­miek

Pri niek­to­rých vý­nim­kách je mož­né uviesť ar­gu­ment/y. Ta­ký­to ar­gu­ment je väč­ši­nou časť chy­bo­vé­ho hlá­se­nia uve­de­né­ho za me­nom chy­by.

>>> try:
...     f=open('su­bor.test')        
... except IOError, x:
...     print 'chy­bo­ve hla­se­nie znie:', x
... 
chy­bo­ve hla­se­nie znie: [Errno 2] Ad­re­sár ale­bo sú­bor neexis­tu­je: 'su­bor.test'

Vy­vo­lá­va­nie vý­ni­miek

Po­mo­cou vý­ra­zu rai­se mô­že­me pri­nú­tiť Pyt­hon vy­vo­lať ľu­bo­voľ­nú vý­nim­ku. Pr­vý ar­gu­ment rai­se je me­no vý­nim­ky, dru­hý je ar­gu­ment sa­mot­nej vý­nim­ky:

>>> rai­se IOError, 'mnou vy­vo­la­na vy­nim­ka'
Tra­ce­back (most re­cent call last):
  Fi­le "", li­ne 1, in ?
IOError: mnou vy­vo­la­na vy­nim­ka

Vý­raz fi­nal­ly:

Vý­raz fi­nal­ly: je špe­ciál­na časť vý­ra­zu try:, kto­rý sa vy­ko­ná v kaž­dom prí­pa­de, ne­zá­le­ží na tom, či sa blok try: opus­tí po­mo­cou prí­ka­zu break ale­bo re­turn, ta­kis­to je jed­no, či sa vy­skyt­la vý­nim­ka, ale­bo nie. Blok za vý­ra­zom fi­nal­ly: sa jed­no­duc­ho vy­ko­ná za všet­kých okol­nos­tí.

>>> try:    
...     f=open('su­bor.test')
... fi­nal­ly:
...     print 'to­to sa zob­ra­zi v kaz­dom pri­pa­de'
... 
to­to sa zob­ra­zi v kaz­dom pri­pa­de
Tra­ce­back (most re­cent call last):
  Fi­le "", li­ne 2, in ?
IOError: [Errno 2] Ad­re­sár ale­bo sú­bor neexis­tu­je: 'su­bor.test'

Je­den vý­raz try: mô­že mať je­den ale­bo viac vý­ra­zov except: ale­bo je­den vý­raz fi­nal­ly:. Mu­sí mať však pri­naj­men­šom as­poň jed­nu z týc­hto dvoch čas­tí a nes­mie ich mať obid­ve na­raz.

Na­bu­dú­ce

Pre­be­rie­me po­sled­nú, roz­hod­ne naj­dô­le­ži­tej­šiu a naj­zau­jí­ma­vej­šiu té­mu – ob­jek­to­vo orien­to­va­né prog­ra­mo­va­nie v po­da­ní Pyt­ho­na.

Ď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