Seriál: V zajatí Pythona / 2. časť: Dátové typy

Ten­to­raz si pre­be­rie­me dá­to­vé ty­py Pyt­ho­na, ale naj­prv si vy­svet­lí­me všet­ky prí­pad­né ne­jas­nos­ti oko­lo prog­ra­mu lin­cal z pre­doš­lej čas­ti.

Lin­cal

Prog­ram lin­cal sa skla­dá z nas­le­du­jú­cich čas­tí:

• Pr­vý ria­dok ob­sa­hu­je tzv. ma­gic li­ne, kto­rý ho­vo­rí inter­pre­tu, aký prog­ram bu­de vy­ko­ná­vať kód v sú­bo­re. Ja up­red­nos­tňu­jem ver­ziu #!/usr/bin/env pyt­hon, ho­ci sa dá ta­kis­to bez prob­lé­mov po­užiť ver­zia #!/usr/bin/pyt­hon. Kto­rú po­uži­je­te, to je len vec vku­su. Po­uži­tie ma­gic li­ne bu­de fun­go­vať len pod unixový­mi sys­té­ma­mi, ale uvád­zaj­te ju, aj keď pí­še­te prog­ra­my pre Win­dows, tie bu­dú po­tom ľah­šie po­rta­bil­né. Pod Win­dows (mám nain­šta­lo­va­nú ver­ziu 1.52, stiah­nu­tú z ftp://ftp.gi­ga­bell.net:21/pub/Pyt­hon/win32/py152.exe) mu­sí­te spus­tiť ten­to prog­ram z prí­ka­zo­vé­ho riad­ka prí­ka­zom pyt­hon lin­cal v do­mo­vom ad­re­sá­ri Pyt­ho­na (C:\Prog­ram Fi­les\Pyt­hon\), ale­bo ak ho po­me­nu­je­te s lin­cal.py, tak ho mô­že­te spus­tiť pria­mo prí­ka­zom lin­cal.py v ľu­bo­voľ­nom ad­re­sá­ri.
• Nas­le­du­jú­ce tri riad­ky sú tak­zva­ný do­ku­men­tač­ný re­ťa­zec. Tým­to re­ťaz­com sa opi­su­jú fun­kcie, mo­du­ly, trie­dy atď. Ten­to re­ťa­zec vy­vo­lá­me po­mo­cou glo­bál­nej pre­men­nej __doc__ (po­zri ria­dok 9) a fun­kcie print.
• V šies­tom riad­ku pri­ka­zu­je­me Pyt­ho­nu, aby im­por­to­val mo­dul sys, po­mo­cou kto­ré­ho nes­kôr zis­tí­me po­čet ar­gu­men­tov od­ov­zda­ných náš­mu prog­ra­mu. Ked­že mo­du­ly sú veľ­mi za­ují­ma­vá, dô­le­ži­tá a roz­siah­la té­ma, bu­de­me sa im po­drob­ne ve­no­vať v jed­nom z nas­le­du­jú­cich po­kra­čo­va­ní se­riá­lu.
• V ôs­mom riad­ku zis­tí­me po­mo­cou fun­kcie len() po­čet ar­gu­men­tov prí­ka­zo­vé­ho riad­ka. V prí­pa­de, že prog­ram dos­ta­ne len je­den ar­gu­ment (me­no prog­ra­mu), vy­pí­še na ob­ra­zov­ku do­ku­men­tač­ný re­ťa­zec po­mo­cou fun­kcie print, ope­rá­to­ra +, kto­rý spá­ja re­ťaz­ce, a es­ca­pe sek­ven­cie no­vé­ho riad­ka ('\n'), kto­rá za­bez­pe­čí vý­pis jed­né­ho no­vé­ho riad­ka pre preh­ľad­nosť. Všim­ni­te si dvoj­bod­ku na kon­ci ôs­me­ho riad­ka. Tá ukon­čie­va de­fi­ní­cie fun­kcií a tried, blo­ky if, for, whi­le atď. Za ňou mu­sí bez­pod­mie­neč­ne nas­le­do­vať od­sa­de­nie v po­do­be med­ze­ry ale­bo ta­bu­lá­to­ra, pri­čom je pre preh­ľad­nosť lep­šie po­užiť ta­bu­lá­tor.
• Ria­dok 11 a 12 de­fi­nu­je fun­kciu llrok(), kto­rá dos­ta­ne je­den ar­gu­ment rep­re­zen­tu­jú­ci rok, pre­me­ní ho na ce­lé čís­lo po­mo­cou fun­kcie int() a od­po­čí­ta od ne­ho hod­no­tu 1991 (v ro­ku 1991 za­čal vý­voj Li­nuxu, pre priaz­niv­cov Li­nuxu je to veľ­mi vý­znam­ný rok). Ak fun­kcia ne­dos­ta­ne čí­sel­nú hod­no­tu, ale napr. re­ťa­zec, tak nes­pra­ví nič a prog­ram ig­no­ru­je ten­to ar­gu­ment.
• V po­sled­ných dvoch riad­koch po­uži­je­me cyk­lus for, kto­rý za­is­tí, že ar­gu­men­ty 1 a ďal­šie bu­dú od­ov­zda­né fun­kcii llrok. Všim­ni­te si pri tom vý­hod­né po­uži­tie tzv. sli­ce no­tá­cie, kto­rá je po­drob­ne vy­svet­le­ná ďa­lej a kto­rá za­bez­pe­čí nor­mál­ny chod prog­ra­mu aj v prí­pa­de, že ako ar­gu­ment dos­ta­ne len me­no prog­ra­mu.

Toľ­ko o prog­ra­me lin­cal. Dú­fam, že všet­ko je už jas­né. Te­raz sa už po­koj­ne mô­že­me vr­hnúť na vy­svet­le­nie dá­to­vých ty­pov Pyt­ho­na.

Pre­men­né

Pre­men­né sú zá­kla­dom kaž­dé­ho prog­ra­mu. Do pre­men­ných mô­že­me ulo­žiť čís­la, re­ťaz­ce a iné dá­to­vé štruk­tú­ry. V Pyt­ho­ne sa pre­men­né ne­dek­la­ru­jú a typ pre­men­nej je ur­če­ný auto­ma­tic­ky. Iden­ti­fi­ká­tor (me­no pre­men­nej) mô­že po­zos­tá­vať z pís­men, čí­sel a po­dčiar­kov­ní­ka "_", pri­čom iden­ti­fi­ká­to­ry sa nes­mú za­čí­nať čís­la­mi. Pri tvor­be iden­ti­fi­ká­to­rov sa vy­hý­baj­te všet­kým špe­ciál­nym zna­kom, ako napr. +, -, =, . atď., a nes­mie­te po­užiť ani tzv. re­zer­vo­va­né slo­vá, sú to: ac­cess, and, break, class, con­ti­nue, def, del, elif, el­se, except, exec, fi­nal­ly, for, from, glo­bal, if, im­port, in, is, lam­bda, not, or, pass, print, rai­se, re­turn, try, whi­le. Pyt­hon má tie­to slo­vá re­zer­vo­va­né na vlas­tné úče­ly. Dbaj­te na to, že Pyt­hon roz­li­šu­je med­zi ma­lý­mi a veľ­ký­mi pís­me­na­mi. Vo ver­zii 1.52 vďa­ka chý­ba­ju­ce­mu mo­du­lu ne­fun­gu­je di­ak­ri­ti­ka, pre­to ju za­tiaľ ne­bu­de­me po­uží­vať.

>>> pas­se = 3 #bez chy­by 
>>> pass = 3 #chy­ba, pass je re­zer­vo­va­ne slo­vo! 

V Pyt­ho­ne nie je prob­lém pri­ra­diť via­ce­rým pre­men­ným jed­nu hod­no­tu na­raz:

>>> a, b, c = 3 

Ta­kis­to sa dá po­užiť viac­ná­sob­né pri­ra­de­nie:

>>> a, b, c = 1, 2, 3 

kto­ré je ek­vi­va­len­tné prí­ka­zu:

 
>>> a = 1
>>> b = 2
>>> c = 3 

Ko­men­tá­re

V Pyt­ho­ne sa ko­men­tá­re za­čí­na­jú zna­kom # a kon­čia kon­com riad­ka. Ko­men­tár nes­mie byť v re­ťaz­ci. Prík­lad:

>>> po­cet = 1 #to­to je ko­men­tar
>>> '#to­to nie je ko­men­tar'
'#to­to nie je ko­men­tar' 

Čís­la

Jed­na z ve­cí, kto­ré mô­že­me ulo­žiť v pre­men­nej, sú čís­la. Pyt­hon ro­zoz­ná­va tie­to dru­hy čí­sel:

• in­te­gers – ce­lé čís­la
  • plain in­te­gers (int) – ce­lé čís­la s ob­med­ze­nou dĺžkou (od -2147483648 do 2147483647)
  • long in­te­gers (long) – ce­lé čís­la s neob­med­ze­nou dĺžkou (sú li­mi­to­va­né len pa­mä­ťou po­čí­ta­ča), ma­jú prí­po­nu L ale­bo l
• floa­ting po­int num­bers (float) – čís­la s de­sa­tin­nou čiar­kou
• com­plex num­bers – kom­plexné čís­la, ma­jú prí­po­nu J ale­bo j

Po­vo­le­né sú nas­le­du­jú­ce zá­pi­sy čí­sel:

>>> 100 #ce­lo­ci­sel­ny za­pis (int)
100
>>> 100L #ce­lo­ci­sel­ny za­pis (long)
100L
>>> 0255 #ok­ta­no­vy za­pis (int)
173
>>> 0x30aL #hexade­ci­mal­ny za­pis (long)
778L
>>> 123.3 #de­sa­tin­ny za­pis (float)
123.3
>>> 1e2 #expo­nen­cial­ny za­pis (float)
100.0
>>> 1e-2L #expo­nen­cial­ny za­pis (float)
0.01L
>>> 1J #za­pis kom­plexne­ho cis­la
1j

Pyt­hon po­dpo­ru­je kla­sic­ké zá­tvor­ko­va­nie po­mo­cou (). Zá­klad­né ope­rá­to­ry fun­kcie na prá­cu s čís­la­mi sú:

+, -, *, / plus, mí­nus, krát, de­le­no
pow(a,b) umoc­ní a na b
a%b Ope­rá­tor mo­du­lo, vrá­ti zvy­šok z de­le­nia a/b
hex(a) vrá­ti hod­no­tu de­ci­mál­ne­ho čís­la a v hexade­ci­mál­nej sús­ta­ve
oct(a) vrá­ti hod­no­tu de­ci­mál­ne­ho čís­la a v ok­tá­no­vej sús­ta­ve
long(a) ak je to mož­né, vrá­ti čís­lo a v ce­lo­čí­sel­nom tva­re (long), de­sa­tin­ná časť sa ig­no­ru­je
int(a) ak je to mož­né, vrá­ti čís­lo a v ce­lo­čí­sel­nom tva­re (int), de­sa­tin­ná časť sa ig­no­ru­je
float(a) ak je to mož­né, vrá­ti čís­lo a v de­sa­tin­nom tva­re
coer­ce(a,b) ak sa da­jú obid­va ar­gu­men­ty up­ra­viť na ten is­tý typ, vrá­ti tup­le s tý­mi­to up­ra­ve­ný­mi ar­gu­men­tmi, ináč vrá­ti hod­no­tu None (nič)
di­vmod(a,b) vrá­ti tup­le s ((a-a%b)/b, a%b)
com­plex(real, imag) vy­tvo­rí kom­plexné čís­lo z reálnej čas­ti a z imaginár­nej čas­ti, pri­čom imaginár­na časť je ne­po­vin­ná
abs(z) vrá­ti ab­so­lút­nu hod­no­tu ar­gu­men­tu z
z.re vrá­ti reálnu časť čís­la z
z.imag vrá­ti imaginár­nu časť čís­la z
ran­ge(start=0,ko­niec,krok=1) vrá­ti po­le s čís­la­mi od start (štan­dar­dne 0) do ko­niec s krokom (štan­dar­dne 1)
round(x,n=0) za­ok­rúh­li x na n miest (štan­dar­dne 0)
xran­ge(start=0,ko­niec,krok=1) vrá­ti tup­le s čís­la­mi od start (štan­dar­dne 0) do ko­niec s krokom (štan­dar­dne 1)

Prík­la­dy:

>>> 100L-100/4*(3-10+17)
-150L
>>> 10%3
1
>>> hex(100)
'0x64'
>>> oct(100)
'0144'
>>> a=long(3) ; a #bod­ko­ciar­kou sa od­de­lu­ju 2 pri­ka­zy
3L
>>> int(a)
3
>>> float(a)
3.0
>>> coer­ce(3.67,8)
(3.67, 8.0)
>>> di­vmod(33,5)
(6, 3)
>>> a=com­plex(3,8) ; a
(3+8j)
>>> round(abs(a),3) #ukaz­ka abs() a round()
8.544
>>> a.real
3.0
>>> a.imag
8.0
>>> ran­ge(0,10,3)
[0, 3, 6, 9]
>>> xran­ge(5)
(0, 1, 2, 3, 4)

Sek­ven­čné dá­to­vé ty­py

Re­ťaz­ce, tup­le a po­lia sú v Pyt­ho­ne sek­ven­čné dá­to­vé ty­py. Pri re­ťaz­coch sa za sek­ven­ciu po­va­žu­jú jed­not­li­vé zna­ky, pri tup­le a po­liach sú to jed­not­li­vé pr­vky. Ku všet­kým sek­ven­čným dá­to­vým ty­pom mô­že­me pris­tu­po­vať po­mo­cou in­dexov ale­bo sli­ce no­tá­cie. Re­ťaz­ce a tup­le sú ne­men­né, pr­vky po­lí sa da­jú me­niť!

In­dexova­nie, sli­ce no­tá­cia

In­dexova­nie je veľ­mi moc­ná zbraň prog­ra­má­to­rov. Dá sa po­užiť na všet­ky sek­ven­čné dá­to­vé ty­py (re­ťa­zec, po­le, tup­le). Jed­no­duc­hým in­dexova­ním pris­tu­pu­je­me k jed­not­li­vým pr­vkom týc­hto dá­to­vo­vých ty­pov. Sli­ce no­tá­cia (kús­ko­vá no­tá­cia), kto­rá je po­dob­ná tej z ja­zy­ka Icon, nám po­nú­ka prá­cu s in­dexmi v „množ­nom čís­le“, čo zna­me­ná, že nep­ris­tu­pu­je­me len k je­di­né­mu pr­vku, ale rov­no k via­ce­rým, vy­hra­de­ným dvo­ma in­dexmi med­zi dvoj­bod­kou. Pr­vý in­dex uka­zu­je na mies­to, kde s vy­zna­čo­va­ním tre­ba za­čať, a dru­hý, kde skon­čiť. Obid­va in­dexy ozna­ču­jú zľa­va dop­ra­va. Je mož­né vy­nec­hať je­den z týc­hto in­dexov. Po­tom sa ozna­ču­je od kon­ca/za­čiat­ku re­ťaz­ca (po­dľa to­ho, kto­rý in­dex vy­nec­há­me). Pri Pyt­ho­ne pla­tí, že in­dexy sa za­čí­na­jú nu­lou. Ta­kis­to je mož­né udať zá­por­né in­dexy. Pri po­uži­tí zá­por­ných in­dexov sa zme­ní smer ozna­čo­va­nia (spra­va do­ľa­va). In­dexova­nie a sli­ce no­tá­cia sa naj­ľah­šie po­cho­pia na prík­la­doch:

>>> string='re­ta­zec' #vy­tvo­ri­me re­ta­zec 
>>> string[1] #kla­sic­ke in­dexova­nie 
'e' 
>>> string[-3] 
'z' 
>>> string[1:6] #sli­ce no­tá­cia 
'eta­ze' 
>>> string[:5] 
're­taz' 
>>> string[-3:] 
'zec' 
>>> string[-5:-2] 
'taz' 
>>> string[:4]= 'be' #chy­ba, re­taz­ce su ne­men­ne 

Sché­ma in­dexova­nia pri po­uži­tí sli­ce no­tá­cie:

python2_tab.jpg

Re­ťaz­ce

Re­ťa­zec je pr­vý sek­venč­ný pr­vok, kto­rý pre­be­rie­me. Re­ťa­zec vy­tvo­rí­me tým, že ob­sah pre­men­nej uzat­vo­rí­me med­zi apos­tro­fy ale­bo med­zi úvod­zov­ky. Už pre spo­me­nu­tý chý­ba­jú­ci mo­dul ne­bu­de­me za­tiaľ vy­uží­vať di­ak­ri­ti­ku.

>>> "re­ta­zec"
're­ta­zec'
>>> '23+23' #dal­si re­ta­zec
'23+23' 

Ak má byť v sa­mot­nom re­ťaz­ci apos­trof ' ale­bo úvod­zov­ka ", je ne­vyh­nut­né dať pred ten­to znak spät­nú lom­ku \. Tým vy­tvo­rí­me tzv. es­ca­pe sek­ven­ciu, po­mo­cou kto­rej nah­rad­zu­je­me zna­ky, kto­ré ma­jú v Pyt­ho­ne re­zer­vo­va­ný vý­znam, ako aj zna­ky, s kto­rých za­dá­va­ním by sme moh­li mať prob­lé­my (napr. AS­CII zna­ky, kto­ré sú štan­dar­dne ne­vi­di­teľ­né, ako napr. med­ze­ra, no­vý ria­dok...).

Es­ca­pe sek­ven­cie
\ práz­dna es­ca­pe sek­ven­cia
\\ spät­ná lom­ka (\)
\' apos­trof (')
\" úvod­zov­ka (")
\a píp­nu­tie (BEL)
\b bac­kspa­ce (BS)
\e es­ca­pe (ESC)
\t ho­ri­zon­tál­ny ta­bu­lá­tor (HT)
\v ver­ti­kál­ny ta­bu­lá­tor (VT)
\n no­vý ria­dok (NL)
\r náv­rat vo­zí­ka (CR)
\f od­strán­ko­va­nie (FF)
\0XX AS­CII znak v ok­tá­no­vej sús­ta­ve s hod­no­tou XX
\xXX AS­CII znak v hexade­ci­mál­nej sús­ta­ve s hod­no­tou XX
>>> 'Mar­tin\'s'
"Mar­tin's"
>>> print '\"Ano\",\n po­ve­dal mi a od­isiel\a'
"Ano",
po­ve­dal mi a od­isiel
>>> print "\x50\x79\x74\x68\x6f\x6e"
Pyt­hon 

Fun­kciu print sme mu­se­li po­užiť, ináč by bol znak no­vé­ho riad­ka "\n" vy­pí­sa­ný ako AS­CII hod­no­ta. Fun­kcia print tiež vy­púš­ťa von­kaj­šie apos­tro­fy ale­bo úvod­zov­ky, kto­ré sú oko­lo re­ťaz­ca. Dl­hý re­ťa­zec, kto­rý sa nez­mes­tí na je­den ria­dok, vy­tvo­rí­te tak­to:

>>> po­zdrav="tym­to dl­ho­ciz­nym re­taz­com\n\
... zdra­vim ci­ta­te­lov PC Re­vue" 
Po­uži­tím spät­nej lom­ky \ a stla­če­ním klá­ve­su na kon­ci pr­vé­ho riad­ka sme vy­tvo­ri­li práz­dnu es­ca­pe sek­ven­ciu, kto­rá je ne­vyh­nut­ná pre preh­ľad­nosť zdro­jo­vé­ho textu. Po­mo­cou nej za­pí­še­me prí­ka­zy, kto­ré mô­žu byť len na jed­nom riad­ku, preh­ľad­nej­ším spô­so­bom do via­ce­rých riad­kov. Exis­tu­je eš­te aj dru­há mož­nosť, ako vy­tvo­riť viac­riad­ko­vý re­ťa­zec, a to po­mo­cou tro­ji­ce apos­tro­fov '''re­ťa­zec''' ale­bo úvod­zo­viek """re­ťa­zec""", pres­ne tak ako sme to vi­de­li v prog­ra­me lin­cal:
"""li­nuxov­sky ca­len­dar ver­zia 0.1\n
po­uzi­tie: ./lin­cal.py rok
./lin­cal.py rok1 rok2 ..."""

Po­spá­jať re­ťaz­ce je mož­né uve­de­ním týc­hto re­ťaz­cov ved­ľa se­ba, pri­čom mu­sí ísť len o re­ťaz­ce, nes­mú to byť fun­kcie, me­tó­dy ale­bo me­ná pre­men­ných! Ak po­tre­bu­je­me spo­jiť re­ťaz­ce s hod­no­ta­mi ulo­že­ný­mi v pre­men­ných ale­bo vý­stup­ný­mi hod­no­ta­mi fun­kcií, mu­sí­me po­užiť ope­rá­tor +.

>>> 'To­to ' 'je ' 'moj ' 're­ta­zec'
'To­to je moj re­ta­zec'
>>> a='re­ta­zec'
>>> 'To­to je ' + a + ' cis­lo 2'
'To­to je re­ta­zec cis­lo 2'

Fun­kcie na prá­cu s re­ťaz­ca­mi:

repr(s) vrá­ti ar­gu­ment s v apos­tro­foch
str(s) vrá­ti ar­gu­ment s, ak je re­ťa­zec, ak s nie je re­ťa­zec, kon­ver­tu­je ho na re­ťa­zec a vrá­ti
eval(s) vy­hod­no­tí a vrá­ti vý­raz v re­ťaz­ci s, náp­ro­ti­vok fun­kcie repr()
ord(c) vrá­ti AS­CII hod­no­tu zna­ku c
chr(i) vrá­ti AS­CII znak, kto­ré­mu zod­po­ve­dá hod­no­ta ar­gu­men­tu i, náp­ro­ti­vok fun­kcie ord(), 0 <= i < 256

Prík­la­dy:

>>> 'Slo­vo \"pes\" ma ' + repr(len("pes")) + ' pis­men(a)'
'Slo­vo "pes" ma 3 pis­men(a)'
>>> eval('23+23') #po­uzi­tie fun­kcie eval()
46
>>> ord('s') #AS­CII hod­no­ta zna­ku 's'
115
>>> chr(115) #kto­ry znak ma AS­CII hod­no­tu 115?
's' 

Ob­rá­te­né apos­tro­fy ` po­nú­ka­jú pres­ne to is­té, čo fun­kcia repr() v ele­gan­tnej a krat­šej for­me. Sta­čí uviesť `len("pes")` a je po prob­lé­me:

>>> 'Slo­vo \"pes\" ma ' + `len("pes")` + ' pis­men(a)'
'Slo­vo "pes" ma 3 pis­men(a)'

Po­lia

Ďal­ším zo sek­ven­čných dá­to­vých ty­pov je po­le. Po­le vy­tvo­rí­me pri­ra­de­ním hod­nôt v hra­na­tých zá­tvor­kách iden­ti­fi­ká­to­ru. Jed­not­li­vé pr­vky po­ľa sa da­jú me­niť a da­jú sa pri­dá­vať no­vé pr­vky.

>>> lang=['pyt­hon','c']
>>> lang[1]='tcl'
>>> lang
['pyt­hon', 'tcl'] 

Po­uži­tím sli­ce no­tá­cie je mož­né zme­niť viac pr­vkov po­ľa na­raz. Ak pri­ra­ďu­je­me me­nej hod­nôt, ako je pr­vkov, na kto­ré uka­zu­je­me, bu­dú pre­by­toč­né pr­vky zma­za­né.

>>> cis­la=[1,2,3,4,5,6,7,8,9]
>>> cis­la[:3]=[10,20,30] #zme­ni­me pr­ve 3 pr­vky
>>> cis­la
[10, 20, 30, 4, 5, 6, 7, 8, 9]
>>> cis­la[:7]=[100,200] #pr­vky 3 az 7 zmiz­nu
>>> cis­la
[100, 200, 8, 9] 

Vno­re­né po­lia nie sú pre Pyt­hon nič nez­ná­me. V iných ja­zy­koch, napr. C, sa ta­kým­to po­liam ho­vo­rí viac­roz­mer­né po­lia:

>>> lang=['pyt­hon', 'tcl', 'c']
>>> lang[2]=['ja­va','ja­vas­cript'] ; lang 
['pyt­hon', 'tcl', ['ja­va', 'ja­vas­cript']]
>>> lang[2][0]
'ja­va' 

List un­pac­king je extra­ho­va­nie pr­vkov po­ľa do jed­not­li­vých pre­men­ných:

>>> [a1, a2, a3] = lang 
>>> a1 
'pyt­hon' 
>>> a2 
'tcl' 
>>> a3 
['ja­va', 'ja­vas­cript'] 

No a eš­te tre­ba spo­me­núť nie­koľ­ko dô­le­ži­tých me­tód a fun­kcií, kto­ré sa nám zí­du pri prá­ci s po­ľa­mi:

a.ap­pend(x) na ko­niec po­ľa a pri­po­jí hod­no­tu x
a.extend(P) na ko­niec po­ľa a pri­po­jí po­le P
a.in­sert(i, x) na po­zí­ciu (in­dex) v po­li a, da­nú ar­gu­men­tomi, pri­ra­dí hod­no­tu x
a.re­mo­ve(x) zma­že pr­vý pr­vok po­ľa a s hod­no­tou x
a.pop([i]) zma­že a vrá­ti pr­vok po­ľa a z po­zí­cie i, pri po­uži­tí bez ar­gu­men­tu zma­že a vrá­ti po­sled­ný pr­vok po­ľa
a.in­dex(x) vrá­ti in­dex pr­vé­ho pr­vku s hod­no­tou x v po­li a, v prí­pa­de, že ani je­den pr­vok po­ľa ne­má hod­no­tu x, vrá­ti chy­bu
a.count(x) vrá­ti, koľ­kok­rát sa nac­hád­za pr­vok s hod­no­tou x v po­li a
a.sort() zo­ra­dí pr­vky po­ľa a po­dľa abe­ce­dy
a.re­ver­se() to is­té ako sort, len zo­ra­dí pr­vky po­ľa a v ob­rá­te­nom po­ra­dí
list(sek­ven­cia) vrá­ti po­le, kto­ré­ho pr­vky sú preb­ra­té zo sek­ven­cie
del a[x] zma­že pr­vok po­ľa a s in­dexom x, dá sa po­užiť aj so sli­ce no­tá­ciou a mô­že zma­zá­vať ce­lé pre­men­né (napr. del a)

Prík­la­dy:

>>> a=['Zu­za', 'Ju­lia'] # zoz­nam pria­te­liek
>>> a.ap­pend('Li­za') #pri­da­me Li­zu
['Zu­za', 'Ju­lia', 'Li­za']
>>> a.extend(['Mi­sa', 'Ka­ta']) #pri­da­me 2 pria­tel­ky
['Zu­za', 'Ju­lia', 'Li­za', 'Mi­sa', 'Ka­ta']
>>> a.in­sert(0, 'Pet­ra') #Pet­ru da­me na za­cia­tok
['Pet­ra', 'Zu­za', 'Ju­lia', 'Li­za', 'Mi­sa', 'Ka­ta']
>>> a.re­mo­ve('Ka­ta') #vy­ho­di­me Ka­tu 
['Pet­ra', 'Zu­za', 'Ju­lia', 'Li­za', 'Mi­sa']
>>> a.pop() #aj Mi­sa ma smo­lu
Mi­sa
>>> a.in­dex('Zu­za') #Zu­za je dru­ha,in­dexova­nie od 0!
1
>>> a.count('Ju­lia') #kol­ko ma­me Ju­lii
1
>>> a.sort() ; a
['Ju­lia', 'Li­za', 'Pet­ra', 'Zu­za']
>>> list(a[0])
['J', 'u', 'l', 'i', 'a']
>>> del a #zma­ze­me pre­men­nu "a" 

Tup­le

Po­sled­ný sek­venč­ný dá­to­vý typ je tup­le, je to aká­si zmie­ša­ni­na med­zi po­ľa­mi a re­ťaz­ca­mi. Tup­le uc­ho­vá­va sí­ce po­dob­ne ako po­le sek­ven­ciu pr­vkov, no tie­to pr­vky sú ako pri re­ťaz­coch ne­men­né! Tup­le vy­tvo­rí­me ako po­le pri­ra­de­ním via­ce­rých hod­nôt iden­ti­fi­ká­to­ru, pri­čom tie­to hod­no­ty mô­žu, ale ne­mu­sia byť uzat­vo­re­né v nor­mál­nych zá­tvor­kách.

>>> a=1,2,3 #a=(1,2,3) je to is­te 

Ak chce­me vy­tvo­riť tup­le len s jed­nou hod­no­tou, tre­ba za ňou uviesť čiar­ku:

>>> a='pyt­hon',
>>> a
('pyt­hon',) 

Pres­ne ako pri po­liach fun­gu­je aj pri dá­to­vom ty­pe tup­le vno­re­nie, extra­ho­va­nie pr­vkov. Keď­že jed­not­li­vé pr­vky tup­le sú ne­men­né, ne­fun­gu­je nah­rád­za­nie in­dexova­ných pr­vkov.

>>> t = 1, 2, 3
>>> u = t, ('a', 'b', 'c')
>>> u[1][2]
'c'
>>> [a,b,c]=u[0]
>>> a
1
>>> b
2
>>> c
3
>>> a=('pyt­hon','tcl','ja­va') #vy­tvo­ri­me tup­le
>>> a[1:] #v po­riad­ku, nic ne­nah­rad­zu­je­me
('tcl', 'ja­va')
>>> a[0]='perl' #chy­ba, tup­le je ne­men­ne!
>>> a[1:]=('c','sche­me') #chy­ba, tup­le je ne­men­ne! 

Pre tup­le exis­tu­je fun­kcia po­dob­ná fun­kcii list(), kto­rú vy­uží­va­me pri po­liach. Fun­kcia sa vo­lá tup­le() a vra­cia tup­le, kto­ré­ho pr­vky sú preb­ra­té z ar­gu­men­tu, kto­rý mu­sí byť sek­venč­ný dá­to­vý typ (re­ťa­zec, po­le, tup­le).

>>> tup­le(['pes','mac­ka']) #ar­gu­ment je po­le
('pes', 'mac­ka') #ar­gu­ment je re­ta­zec
>>> tup­le('Pyt­hon')
('P', 'y', 't', 'h', 'o', 'n') 

Spo­loč­ne pre všet­ky sek­ven­čné dá­to­vé ty­py exis­tu­jú tie­to fun­kcie:

min(s) vrá­ti naj­men­ší pr­vok zo sek­ven­cie s
max(s) vrá­ti naj­väč­ší pr­vok zo sek­ven­cie s
z [not] in s ak je pís­me­no z v sek­ven­cii s, vrá­ti 1, ináč vrá­ti 0; po­uži­tím not sa otáz­ka ne­gu­je
len(s) vrá­ti po­čet pr­vkov v po­li ale­bo tup­le pri po­uži­tí na re­ťa­zec je­ho dĺžku
s1 + s2 spo­jí sek­ven­ciu s1 so sek­ven­ciou s2
seq * x opa­ku­je sek­ven­ciu seq x-krát, x mu­sí byť pri­rod­ze­né čís­lo

Prík­la­dy:

>>> a=(3,4,'psi','mac­ka', ' ne­ma ra­da ')
>>> a[3] + a[4] + (str(min(a))) + ' ' + max(a)
'mac­ka ne­ma ra­da 3 psi'
>>> 'a' not in a[2]
1
>>> a=['Qmail','Exim']
>>> len(a), len(a[1]) #po­cet pr­vkov a dl­zka pr­vku a[1]
(2, 4)
>>> a*2 + ['Sen­dmail','Smail']
['Qmail', 'Exim', 'Qmail', 'Exim', 'Sen­dmail', 'Smail']
>>> ('Send' + a[0][1:])*2
'Sen­dmail­Sen­dmail' 

Aso­cia­tív­ne po­lia

Aso­cia­tív­ne po­lia (slov­ní­ky, has­he) sú špe­ciál­ne, veľ­mi uži­toč­né dru­hy po­lí, kto­rých in­dexy ne­mu­sia byť bez­pod­mie­neč­ne čís­la. Pr­vky toh­to po­ľa po­zos­tá­va­jú z dvoch čas­tí kľúč:hod­no­ta, pri­čom sa kľúč po­uží­va ako in­dex, vďa­ka čo­mu má­me k dis­po­zí­cii moc­ný nás­troj na vy­hľa­dá­va­nie, kto­rý nám uľah­čí prá­cu s po­ľa­mi, kde by po­uži­tie štan­dar­dné­ho čí­sel­né­ho in­dexova­nia vied­lo k nep­reh­ľad­nos­ti a cel­ko­vé­mu chao­su. Slov­ník vy­tvo­rí­me pri­ra­de­ním hod­nôt kľúč:hod­no­ta uzat­vo­re­ných v hra­na­tých zá­tvor­kách.

>>> tel­cis­la={'ro­bert':'183 426','man­fred':'684 158'}
>>> tel­cis­la['ro­bert']
'183 426' 
slov.items() vy­dá po­le s pár­mi kľúč:hod­no­ta zo slov­ní­ka slov
slov.keys() vy­dá po­le s kľúč­mi zo slov­ní­ka slov
slov.va­lues() vy­dá po­le s hod­no­ta­mi zo slov­ní­ka slov
slov.has_key(k) ak slov­ník slov ob­sa­hu­je kľúč k, vrá­ti 1, ináč 0
slov[k]=x pri­ra­dí slov­ní­ku slov kľúč k s hod­no­tou x
len(slov) vrá­ti po­čet pr­vkov v slov­ní­ku slov
del slov[k] zma­že zo slov­ní­ka slov pr­vok s kľú­čom k

Prík­la­dy:

>>> tel­cis­la.items()
[('ro­bert', '183 426'), ('man­fred', '684 158')]
>>> tel­cis­la.keys()
['ro­bert', 'man­fred']
>>> tel­cis­la.va­lues()
['183 426', '684 158']
>>> tel­cis­la.has_key('ro­bert')
1
>>> tel­cis­la['joe']='313 213' ; tel­cis­la
{'ro­bert': '183 426', 'joe': '313 213', 'man­fred': '684 158'}
>>> len(a)
3
>>> del tel­cis­la['ro­bert']; tel­cis­la
{'joe': '313 213', 'man­fred': '684 158'} 
Na­bu­dú­ce

Ria­dia­ce štruk­tú­ry, cyk­ly, de­fi­ní­cie fun­kcií a všet­ko s tým sú­vi­sia­ce.

Ra­da na zá­ver

Sta­raj­te sa o svoj Pyt­hon! Ne­za­bud­ni­te ho as­poň dvak­rát den­ne kŕmiť rôz­ny­mi dob­rý­mi zdro­jo­vý­mi texta­mi! Ak ste už expert v „cho­ve“ Pyt­ho­na, po­koj­ne mu daj­te ne­ja­ký ten zdro­ja­čik z vlas­tnej kuc­hy­ne, ak ste si ho však za­ob­sta­ra­li len pred­ne­dáv­nom, do­žič­te mu ve­ľa tes­to­va­nia a cvič­ných prog­ra­mov.

Ď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