Instruilo por la programlingvo Pitono

Bonvolu sendi korektojn, proponojn, kaj sugestojn al vilcxjo ĉe esperanto-me.org

Enigo - Eligo

Formato por eligo
Dosiera Legado kaj Skribado
Metodoj de Dosieraj Objektoj
La Peklila modulo

 

Estas kelkaj manieroj por prezenti la eligon de programo; Oni povas montri/presi datumojn en legebla formo, aŭ skribi ilin al dosiero por estonteca uzo. Jen kelkaj eblecoj:

Formato por eligo

Ĝis nun ni renkontis du procedojn por videbligi valorojn: esprimaj instrukcioj kaj la print instrukcio. (tria procedo estas uzi la write() metodon de dosieraj objektoj; vidu Library Reference por plu da informo pri tio.)

Ofte vi volas regi la formaton de via eligo pli ol simple videbligi valorojn apartigitajn per spacoj. Estas du procedoj por formati vian eligon;

Unue, formatu ĉiun ĉenon - uzu la operaciojn tranĉan kaj kroĉan kaj krei laŭvolan formaton.

La dua procedo estas uzi la operatoron '%' kun ĉeno kiel maldeksta argumento. % interpretas la maldekstran argumenton kiel 'C sprintf'-stilan formaton, aplikas la dekstran argumenton, kaj resendas la rezultantan ĉenon.

Kompreneble, unu demando restas: kiel vi konvertas valorojn al cenoj? Feliĉe, Pitono havas solvon: sendu valoron al funkcioj str()repr(). La funkcio str() resendas valorojn kiuj estas legeblaj de homoj; funkcio repr() resendas valorojn legeblaj de la interpretilo.Ambaŭ funkcioj donas la saman rezulton se temas nombroj, listoj, kaj vortaroj. Ĉenoj kaj glitpunktaj nombroj estas traktitaj malsame.

Ekzemploj:

   >>> s = 'Saluton, mondo.'
>>> str(s)

'Saluton, mondo.'
>>> repr(s)
"'Saluton, mondo.'"
>>> str(0.1)
'0.1'
>>> repr(0.1)
'0.10000000000000001'
>>> x = 10 * 3.25
>>> y = 200 * 200
>>> s = 'La valoro de x estas '+repr(x)+', kaj y estas '+repr(y)
>>> print s

La valoro de x estas 32.5, kaj y estas 40000
>>> # repr() aldonas apostrofojn kaj retenas maloblikvojn
... saluton = 'saluton, mondo\n'
>>> rep-saluton = repr(saluton)
>>> print rep-saluton

'saluton, mondo\n'
>>> # Iu ajn Pitona objekto pvas esti argumenton al repr()
... repr((x, y, ('spamo', 'ovoj')))
"(32.5, 40000, ('spamo', 'ovoj'))"

Jen du procedoj por skribi tabelon de kvadratoj kaj kuboj:

   >>> for x in range(1, 11):
...    print repr(x).rjust(2), repr(x*x).rjust(3),
...   
# Rimarku komo je la fino de la antaŭa linio
... print repr(x*x*x).rjust(4)

1   1    1
2   4    8
3   9   27
4  16   64
5  25  125
6  36  216
7  49  343
8  64  512
9  81  729
10 100 1000
   >>> for a in range(1,11):
...     print '%2d %3d %4d' % (a, a*a, a*a*a)
...
1   1    1
2   4    8
3   9   27
4  16   64
5  25  125
6  36  216
7  49  343
8  64  512
9  81  729
10 100 1000

(Rimarku, ke unu spaco inter ĉiu kolumno estas aldonita de print. Print ĉiam aldonas spacon inter argumentoj)

La supra ekzemplo montras la metodon rjust(), kiu ĝustigis ĉenon al la dekstra en datumejo per la aldono de spacoj je la maldekstro de la ĉeno. La dua argumento definas la longecon de la datumejo. Ekzistas similaj metodojnj ljust() and center(). Ĉi tiuj metodoj ne skribas ion ajn, ili nur resendas novan ĉenon. Se la ĉeno estas tro longa, ĉi tiuj resendas ĝin senŝanĝe. Rezulto fuŝos vian eligon, sed vi ne resendas malpravan valoron. Se vi volas distranĉi iom da signoj, tranĉi la ĉenon. Ekz. x.ljust(n)[:n]

Ekzistas alia metodo, zfill(), kiu aldonas nulojn je la komenco de la ĉeno. Ĉi tiu funkcio komprenas pri pluso kaj minuso:

   >>> '12'.zfill(5)
'00012'
>>> '-3.14'.zfill(7)
'-003.14'
>>> '3.14159265359'.zfill(5)
'3.14159265359'

Uzu la operatoron % jene:

   >>> import math
>>> print 'PI estas proksimume %5.3f.' % math.pi
PI estas proksimume 3.142.

Se estas pli ol unu formato en la ĉeno, vi sendas opon kiel dekstra argumento. Ekz.:

   >>>tablo = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 3637}
>>> for nomo, fonnumero in tablo.items():
...     print '%-10s ==> %10d' %(nomo, fonnumeron)
...
Jack       ==>       4098
Dcab       ==> 3637
Sjoerd     ==>  4127

La plejparto de formatoj funkcias kiel en C, kaj postulas, ke vi sendas la taŭgan tipon; se vi fuŝos, vi ricevos eraron. La %s formato ne postulas same: se la responda argumento ne estas ĉena objekto, Pitono konvertas ĝin al ĉeno per uzo de la primativa funkcio str(). Pitono subtenas la uzon de * por sendi la larĝecon aŭ precizecon kiel aparta (entjera) argumento. Pitono ne subtenas la C formatojn %n and %p.

Se vi havas tre longan format-ĉenon, kiun vi ne volas dividi, vi povas referenci variablojn formatotajn per nomo anstataŭ pozicio. Uzu la formon %(name), ekz.

>>>tablo = {'Sjoerd': 127, 'Jack': 4098, 'Dcab': 637}
>>> print 'Jack: %(Jack)d; Sjoerd: %(Sjoerd)d; Dcab: %(Dcab)d' % tablo
Jack: 4098; Sjoerd: 127; Dcab: 637

Ĉi tiu formo estas specife utila kun la prafunkcio vars(), kiu resendas vortaron kiu enhavas ĉiun lokan variablon.

Dosiera Legado kaj Skribado

La funkcio open() resendas dosieran objekton, kaj plej ofte havas du argumentojn:
'open(dosieronomo, reĝimo)'.

   >>> f=open('provujo', 'w') #'w' signifas skribi
>>> print f
<open file 'provujo', mode 'w' at 80a0960>

La unua argumento estas ĉeno, kiu enhavas la dosieran nomon. La dua argumento (reĝimo) ankaŭ estas ĉeno, kiu enhavas signo(j)n, kiuj priskribas la manieron de dosiera uzo.

Reĝimo:

Ĉe Vindozo kaj Macintoŝo, vi alfiksas signon 'b' al la reĝimo por malfermi duuman dosieron - do 'rb', 'wb', and 'r+b' estas taŭgaj reĝimoj. Vindozo distingas inter tekstajn kaj duumajn dosierojn; je tekstaj dosieroj, la signo kiu indikas la finon de teksta linio estas aŭtomate iomete ŝanĝita dum legado aŭ skribado. Tiu aŭtomata agado koruptos duumajn dosierojn kiel JPEG-aj or EXE-aj dosieroj. Zorgu, ke vi uzas la duuman reĝimon por legi aŭ skribi tiajn dosierojn. (Ĉe Macintoŝo, malsamaj bibliotekoj C-aj donas malsamajn rezultojn.)

Metodoj de Dosieraj Objektoj

La cetero de ekzemploj en tiu sekcio supozas ke dosiera objekto f jam estas kreita.

Por legi enhavojn de dosiero, voku f.read(longeco), kiu legas kvanton de datumoj kaj resendas ĝin kiel ĉeno. Longeco estas nedeviga numera argumento. Se longeco mankas (aŭ estas negativa) la tuta enhavoj de la dosiero estos resendita - estos via problemo se la dosiero estos tro granda por via komputila memoro. Se longeco estas taŭga, ne pli ol tiom da bitokoj estos legita kaj resendita. Se la fino de dosiero jam estas atingita, f.read() resendos malplenan ĉenon ("").

   >>> f.read()
'ĉi tiu estas la tuta dosiero.\n'
>>> f.read()
''

f.readline() legas unu linio el la dosiero (ĝis la novlinian signon, kiu estas inkludita).Pitono ne aldonas novlinian signon al la lasta linio de la dosiero se la dosiero ne finiĝas per novlinian signon. Do, la resendita valoro ne estas dubasenca; se f.readline() resendas malplenan ĉenon, la fino de la dosiero estas atingita, sed resendita ĉeno kiu enhavas nur novlinian signon signifas vakan linion.

   >>> f.readline()
'Unua linio de la dosiero.\n'
>>> f.readline()
'Dua linio de la dosiero\n'
>>> f.readline()
''

f.readlines() ripetite uzas metodon f.readline(), kaj resendas liston kiu enhavas ĉiujn liniojn el la dosiero. Se vi provizas nedevigan argumenton sizehint, Pitono legas tiun kvanton de signoj, kaj daŭre legas ĝis la fino de linio. Nur kompletaj linioj estas resenditaj. Oni uzas tiun metodon por efike legi grandajn dosierijn, sen la neceso ŝargi la tutan dosiero.

   >>> f.readlines()
[Unua linio de la dosiero.\n', 'Dua linio de la dosiero \n']

f.write(ĉeno) skribas enhavojn de ĉeno al la dosiero, kaj resendas None.

   >>> f.write('ĉi tiu estas provon\n')

f.tell() resendas entjeron kiu reprezentas la aktualan pozicion de la dosiera objekto en la dosiero, i.e., la nombron de bitokoj de la komenco de la dosiero. Por ŝanĝi tiun pozicion, uzu metodon f.seek(movloko, de_kio). La nova pozicio estas kalkulita per aldono de movloko al referenca punkto. La argumento de_kio elektas la referencan punkton: 0 kalkulas de la komenco de la dosiero; 1 kalkulas de la aktuala pozicio, 2 kalkulas de la fino de la dosiero. Se de_kio mankas, implica valoro estas 0.

   >>> f=open('provujo', 'r+')
>>> f.write('0123456789abcdef')
>>> f.seek(5) 
#iru al bitoko 5 (sesa) en la dosiero
>>> f.read(1)       
'5'
>>> f.seek(-3, 2) #al la 3-a bitoko antaŭ la fino
>>> f.read(1)
'd'

Post vi finas dosieran agadon, voku f.close() por fermi dosieron kaj redoni iu ajn sistemajn rimedojn uzitajn de la dosiero. Post kiam vi fermas dosieron, vi malsukcesos se vi provos uzi la dosieran objekton.

   >>> f.close()
>>> f.read()
Traceback (innermost last):
File "<stdin>", line 1, in ?
ValueError: I/O operation on closed file

Dosieraj objektaj havas aliajn metodojn, kiu estas malofte uzitaj; kontrolu la dokumenton 'Library Reference' por kompleta gvido al dosieraj objektoj.

La Peklila Modulo

Vi povas facile dosiere legi kaj skribi ĉenojn. La problemoj pri legi kaj skribi numeroj estas nur iomete pli malfacila -vi devas uzi metodon (ekz. string.atoi()) por konverti legita ĉenoj al numeroj. Tamen, kiam vi volas legi aŭ skribi pli kompleksajn tipojn kiel listojn, vortarojn, aŭ klasajn kazojn, la problemo iĝos ege granda.

Por solvi ĉi tiun problemon por ĉiuj programistoj, Pitono havebligas pramodulon nomitan 'peklilo'. Ĉi tiu estas modulo kiu povas konverti iun ajn Pitonan objekton (eĉ iun Pitonan kodon!) al ĉena formo; Ĉi tiun procedon oni nomas 'peklado'. La rekonvertadon de ĉeno al originala objekto oni nomas 'malpeklado'. Inter peklado kaj malpeklado, vi povas sekuri objekton en dosiero, or sendi ĝin tra reto al alia maŝino.

Se vi havas objekton a, kaj dosieran objekton f kiu estas preta por skribado, vi povas pekli la objekton jene:

   pickle.dump(a, f)

Por malpekli objekton, se f estas dosiera objekto kiu estas preta por legado:

   x = pickle.load(f)

(Estas aliaj variaĵoj, por pekli multajn objekton aŭ por pekli sen dosiera legado/skribado. Kontrolu la dokumenton 'Library Reference'.)

Peklado estas la kutima rimedo por fari kaj sekuri Pitonajn objektojn, kiun iuj ajn Pitonaj programoj povas uzi; tian objekton oni teknike nomas 'persista objekto'. Ĉar peklilo estas uzita ege vaste, multaj programistoj kiu skribas Pitonajn etendaĵojn certigas, ke novaj tipoj (ekz. matricoj) taŭgas por peklado/malpeklado.

Supren