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 defini funkcion kiu skribas la Fibonacci-an serion ĝis definita 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 definis
... fib(2000)
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597

La vorto def enkondukas funkcian definon. 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 defino) 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 donita, la vokanto vidos iu ajn ŝanĝojn faritajn de vokato. Kiam funkcio vokas alian funkcion, nova simboltabelo estas kreita por ĉi tiu voko.

Funkcia defino 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 definitaj. Ekz.:

   def petu_ok(invito, reprovoj=4,plendo='Jes aŭ ne, mi petas!'):
while True:
ok = raw_input(invito)
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 defino 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 donitajn, 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 mankas
papago(voltkvanto=5.0, 'morta')
# ne-ŝlosilvorta arg-o
                       
#sekvas ŝlosilvortan argo-n
papago(110, kvanto=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 nedefinitajn ŝ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 definas 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 presado de la vortaro. Se oni ne faras tion, la presordo estas nedefinita.

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