Instruilo por la programlingvo Pitono

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

Funkcioj

Implicitaj Argumentaj Valoroj
Ŝlosilvortaj Argumentoj en Funkcioj
Arbitraj Argumentaroj
Dokumentaj Ĉenoj

Ni povas difini funkcion kiu skribas la Fibonacci-an serion ĝis difinita limo:

   >>> def fib(n): #skribu Fibonacci-an serion ĝis n 
... """Skribu Fibonacci-an serion ĝis n"""
...   a, b = 0, 1
...   while b < n:
...    print b,
...      a, b = b, a+b
...
>>>
# Nun voku la funkcion ni ĵus difinis
... fib(2000)
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597

La vorto def enkondukas funkcian difinon. Sekve, devas esti funkcia nomo kaj interkrampa listo de formalaj parametroj (argumentoj). La kodogrupo kiu formas la korpon de la funkcio komencas je la sekvonta linio, kun pli de marĝeno.

La unua linio(j)en la kodogrupo povas esti ĉena(j) datumo(j); tiu(j) estas dokumento por la funkcio. Estas iloj, kiu uzas tiajn dokumentajn ĉenojn por aŭtomate krei presitan dokumentadon, aŭ lasu la uzanto interaktive trarigardi la fontkodon; estas bona praktiko enhavigi tiajn dokumentajn ĉenojn en kodo kiun vi skribas, do provu fari tion kutime.

Funkcia plenumo (ne difino) enkondukas novan simboltabelon kiu enhavas la lokajn variablojn de la funkcio. Pli priceze, ciu variabla valorizo en funkcio staplas la valoron en la loka simboltabelo. Tamen variablaj referencoj unue kontrolas la lokan simboltabelon, poste la mallokan simboltabelon. poste la tabelon de primitivaj nomoj. Do, oni ne povas valorizi mallokajn variablojn interne al funkcio (krom la variablo estas nomita en instrukcio 'global'), tamen oni povas referenci ilin. (Kontrolu lecionon pri 'Nomospacoj kaj Valorizado' por plua klarigo kaj ekzemploj)

La argumentoj de funkcio estas enkondukitaj en la lokan simboltabelon de la vokata funkcio kiam ĝi estas vokata; do, la argumentoj estas pasigita per objekta referenco. Se ŝanĝebla objekto estas pasigita, la vokanto vidos iu ajn ŝanĝojn faritajn de vokato. Kiam funkcio vokas alian funkcion, nova simboltabelo estas kreita por ĉi tiu voko.

Funkcia difino enkondukas la funkcian nomon en la aktuala simboltabelo. Vi povas asigni funkcian nomon al alia variablo, kiun vi povas uzi por voki la originalan funkcion. Rezulto estas kaŝnomo.

   >>> fib
<function object at 10042ed0>
>>> f = fib
>>> f(100)
1 1 2 3 5 8 13 21 34 55 89

En Pitono, proceduro estas nur tipo de funkcio kiu ne resendas valoro(j)n. Fakte, proceduroj resendas valoron None (primativa vorto kiu signifas nenion).

>>> print fib(0)
None

Estas simpla afero skribi funkcion kiu resendas liston de la numeroj el la Fibonacci-a serio, anstataŭ videbligi ĝin:

   >>> def fib2(n): 
...    """Resendi Fibonacci-an serion ĝis n"""
...    rezulto = []
...    a, b = 0, 1
...    while b < n:
...       rezulto.append(b)

...       a, b = b, a+b
...    return rezulto
...
>>> f100 = fib2(100)
# voku funkcion
>>> f100
# skribu rezulton
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

Ĉi tiu ekzemplo montras novajn Pitonajn trajtojn:

Implicitaj Argumentaj Valoroj

Vi povas provizi implicitan valoron por unu aŭ pluraj argumentoj. Ĉi tiu kreas funkcion kiun vi povas voki kun malpli da argumentoj ol tiuj, kiuj estas difinitaj. Ekz.:

>>>def petu_ok(invito, reprovoj=4,plendo='Jes aŭ ne, mi petas!'):
... while True:
... ok = raw_input(invito) #'raw_input' estas funkcio kiu kaptas respondon
... if ok in ('j', 'je', 'jes'): return True
... if ok in ('n', 'ne'): return False
... reprovoj = reprovoj - 1
... if reprovoj < 0:
... raise IOError, 'refuzema uzanto'
... print plendo
...

Vi povas voki ĉi tiun funkcion jene:

>>>petu_ok('ĉu vi ja volas rezigni?')            

aŭ jene:

>>>petu_ok('ĉu reskribi dosieron estas permesata?', 2)

La implicitaj valoroj estas kalkulitaj je la punkto en la programa fluo kie funkcia difino okazas, do ekz:

>>>i = 5
>>>def f(arg = i):
... print arg
...
>>>i = 6
>>>f()

 videbligos 5.

Grava averto: La implicita valoro estas elvalorigita nur unufoje. Tio havas signifon, kiam implicito estas ŝanĝebla objekto kiel listo, k.t.p. Ekzemple, la jena funkcio akumulas argumentojn pasigitajn, kiam vokata multfoje.

>>>def f(a, L=[]):
... L.append(a)
...    return L
...
>>>print f(1)
>>>print f(2)
>>>print f(3)

la rezulto estas:

   [1]
[1, 2]
[1, 2, 3]

Se vi ne volas akumuli argumentojn, skribu anstataŭe:

>>>def f(a, L=None):
...  if L is None:
...      L = []
...    L.append(a)
...    return L

Ŝlosilvortaj Argumentoj en Funkcioj

Funkcioj ankaŭ povas esti vokata per la uzo de ŝlosilvortaj argumentoj en la formo 'ŝlosilvorto = valoro'. Ekzemple:

La jena funkcio

>>>def papago(voltkvanto, stato='morta', agado='voom'):
...    print "-- ĉi tiu papago ne volas", agado,
...    print "se vi aplikas ", voltkvanto, "voltoj al ĝi."
...    print "-- "Estas", stato, "!"

povas esti vokata per iu ajn de la sekvaj maneroj:

>>>papago(1000)
>>>papago(agado = 'VOOOOOM', voltkvanto = 1000000)
>>>papago('mil', stato = 'preta por entombiĝo')
>>>papago('miliono', 'tute senviva', 'salti')

sed la sekvaj maneroj estus nevalidaj:

>>>papago() # necesa argumento voltkvanto mankas
>>>papago(voltkvanto=5.0, 'morta')
# ne-ŝlosilvorta argo sekvas ŝlosilvortan argo-n                       
>>>papago(110, voltkvanto=220)
# du valoroj por sama argumento
>>>papago(acto
r='John Cleese') #nekonata ŝlosilvorto

Generale, en argumentaro, la ŝlosilvortaj argumentoj sekvas la poziciajn argumentojn. Ne gravas, se formala parametro havas implicitan valoron aŭ ne. Argumento ne povas ricevi valoron pli ol unufoje. Du argumentoj ne povas havi la saman nomon.

   >>> def function(a):
...     pass
...
>>> function(0, a=0)

Traceback (most recent call last):
File "<stdin>", line 1, in ?
TypeError: function() got multiple values for keyword argument 'a'

Arbitraj Argumentaroj

Pitono permesas, ke vi povas prezenti nedifinitajn ŝlosilvortajn argumentojn kaj kromajn poziciajn argumentojn kiam vi vokas funkcion. Kiam la lasta formala parametro estas en la formo **nomo, ĝi ricevas vortaron kiu enhavas ĉiun ŝlosilvortan argumenton kies ŝlosilvorto ne egalas formala parametro. Kiam formala parametro estas en la formo *nomo, ĝi ricevas opon kiu enhavas poziciajn argumentojn preter la formala parametra listo. (*nomo devas okazi antaŭ **nomo.) Ekz., se vi difinas funkcion jene:

>>>def fromaĝvendejo(tio, *argumentoj,**ŝlosilvort_argoj):
...    print "-- ĉu vi havas iom da", tio, '?'
...    print "-- Mi bedaŭras, ni ne havas", tio
...    for arg in argumentoj:
...        print arg
... print '-'*40
...    keys = keywords.keys  
...    keys.sort()
...    for kw in ŝlosilvort_argoj.keys():
...        print kw, ':', ŝlosilvort_argoj[kw]
...

Vi povas voki ĝin jene:

>>>fromaĝvendejo('Limburger', "Estas tre fluema, sinjoro.", 
...       "Estas ja tre ege fluema, sinjoro.",
...       cliento='John Cleese',
...       vendisto='Michael Palin',
...       skizo='Fromaĝvendeja Skizo')

kaj ĝi videbligas, kompreneble:

   -- ĉu vi havas iom da Limburger ?
-- Mi bedaŭras, ni ne havas Limburger
"Estas tre fluema, sinjoro.",
"Estas ja tre ege fluema, sinjoro.",
----------------------------------------
cliento : John Cleese
vendisto : Michael Palin
skizo : Fromaĝvendeja Skizo

Rimarku, ke la metodo 'sort()' estas vokata antaŭ la printado de la vortaro. Se oni ne faras tion, la printordo estas nedifinita.

Malpaki Argumentajn Listojn

La mala situacio okazas kiam la argumentoj jam estas en listo aŭ opo, sed oni devas malpaki ilin por funkcio kiu postulas apartajn argumentojn. Ekzemple, la primativa funkcio range() anticipas apartajn argumentojn 'komencu' kaj 'haltu'. Vi povas uzi *-operacion por malpaki argumentojn el listo aŭ opo.

   >>>args = [3,6]
>>>range(*args)

[3, 4, 5]

Dokumentaj Ĉenoj

Aperas kutimoj pri la enhavo kaj formato de dokumentaraj ĉenoj

La unua linio ĉiam devus esti mallonga konciza resumo de la celo de la objekto. Ĝi ne devus ekspicite enhavi la nomon aŭ tipon de la objekto, ĉar tiuj estas havabla aliamaniere (escepto estas, se la nomo estas verbo, kiu priskribas la operacion de funkcio). Ĉi tiu linio devus komenci per majuskla litero, kaj fini per periodo.

Se ekzistas pluaj dokumentaj ĉenoj, la dua linio devus esti vaka, do vide apartigas la unuan linion kaj la ceteron de la priskribo. La sekvaj linioj devus esti unu aŭ pli alineoj priskribante la vok-konvenciojn, flankefikojn, k.t.p.

La unua non-vaka linio post la unua linio decidas la kvanton de marĝeno por la tuta dokumenta ĉenaro (Ni ne povas uzi la unuan linion, ĉar pro la citiloj, la vera marĝeno ne estas evidenta) Blankospaco:"egala" al ĉi tiu marĝeno estos senigita el la komenco de ĉiu linio de la ĉeno. Linioj kiu havas malpi da marĝeno (ne devus okazi) devus esti senigita same. Vi devus testi la egalecon de blankospaco post grandigo de taboj (al 8 spacoj, kutime)

Jen ekzempo:

   >>> def my_function():
...     """Faru nenion, sed dokumentu ĝin.
...
...     Ne, fakte, ĝi faras nenion.
...     """
...     pass
...
>>> print my_function.__doc__

Faru nenion, se dokumentu ĝin.

Ne, fakte, gi faras nenion.

Supren