PYTHON liburua/Funtzioak, klaseak eta metodoak

5. Funtzioak, klaseak eta metodoak

5.1. SARRERA

Ohiko diren prozedura-lengoaien modura, Pythonek azpiprogramak idazteko aukera ematen digu. Lengoaiaren arabera azpiprogramei izen desberdinak ematen zaizkie: prozedura, funtzioa, errutina, azpirrutina, etabar. Izendapen horien guztien arteko diferentziak garrantzi txikiko ezaugarriak dira, eta horretan funtzio kontzeptuaren ezaugarri nagusia zera da: funtzioak emaitza bat itzuliko duela suposatzen da.

Funtzioen helburua, azpiprograma guztiena bezala, programen diseinua eta idazketa erraztea da; beraien bidez posible baita problema konplexu bat azpiproblema errazagotan banatzea, horietako bakoitza geroago programa errazagoekin ebazteko asmoz. Behe-mailako funtzioek eragiketa sinpleak burutzen dituzte, eta goi-mailako funtzioek behe-mailako funtzioak erabiltzen dituzte. Teknika horri beheranzko programazio edo programazio modular esaten zaio, hari esker programak ulergarriago eta sendoagoak izaten dira, eta programatzaileen eraginkortasuna handitzen da.

Funtzio baten izena programa-zati bat erreferentziatzeko laburdura bat dela pentsa daiteke. Funtzioa behin definitzen da, baina sarritan deitua izan daiteke gero. Maiz exekutatzen den sententzia-multzoa funtzio gisa definitu ohi da edozein programazio-metodologia erabiltzen denean. Funtzioen erabilerak, programaren irakurgarritasuna bultzatzeaz gain, handitzen du programak idazteko eta aldatzeko erraztasuna, malgutasuna eta fidagarritasuna.

Funtzioak erabiltzea eta programazio modularraren teknika ia programazioaren hasieratik datoz, baina urte batzuk geroago beste ideia ahaltsu bat azaldu zen: objektu kontzeptua. Objektuei orientatutako programazioa dator hortik, eta Pythonek ere barneratu du kontzeptu hori. Objektuak (datu-motak edo) klase gisa definitzen dira eta modulutan kapsulatzen dira, testuinguru bat emanez. Modulu baten barruan pakete moduan definitzen diren konstante, aldagai, objektu eta horri dagozkion funtzioen artean lotura estua sortzen da. Klase barruko funtzioei metodo esaten zaie.

Beraz, objektu bati dagozkion metodoak eta bestelako definizioak (bertako aldagaiak, adibidez) klase baten barruan definitzen dira. Gainera, funtzioak edozein esparrutan erabil daitezke eta behar den informazio guztia parametro bidez jakinarazten zaien bitartean, metodoak dagokien objektuaren gainean bakarrik aplika daitezke, eta parametroetan agertzen ez diren balio lagungarri batzuk erabil ditzakete klasean definituta badaude. Programaziorako interesgarri eta ahaltsuak diren kontzeptu batzuk balia ditzakegu objektuen bidez, herentzia eta polimorfismoa esaterako. 8. kapituluan arituko gara horietaz.

Kapitulu honen hasieran funtzioen erabilera aztertuko dugu, eta ondoren objektuak eta beraiei dagozkien metodoak.

5.2. FUNTZIOAK

Ikus dezagun adibide bat, faktoriala kalkulatzeko funtzioa esaterako. Aurreko kapituluan, 4.3. programan, zenbaki oso baten faktoriala kalkulatzen zuen programa bat azaldu da, baina dena agindu-segida bakar batean bilduta. Hori ez da aukera bakarra; zeren faktorialaren kalkulua azpiprograma edo funtzio batean programatu baitaiteke behin betirako, eta programa nagusi desberdinetatik erabili 5.1. programan azaltzen den legez.

5.1. programa. Faktorial funtzioa:

# Zenbaki baten faktoriala kalkulatu
# Funtzioaren definizioa 
def faktorial (n): 
	fakt = 1
	i = 2
	while i <= n: 
		fakt = fakt * i 
		i=i+1 
	return (fakt) 

# Programa nagusia, funtzioa erabiltzen duena 
m=int(input('Idatzi zenbaki bat, bere faktoriala kalkulatzeko: ')) 
if m <= 0: 
	print ("Errorea: zenbaki positiboa behar da") 
else: 
	print(faktorial(m))

Exekuzioaren adibide bat:

>>>  
Idatzi zenbaki bat, bere faktoriala kalkulatzeko: 4 
24

5.2.1. Definizioa, deia eta emaitzak

Adibide horretan bi hitz erreserbatu erabili dira: def definiziorako eta return emaitza itzultzeko. Beste sententzia batzuetan bezala (if kontrol-egituran, adibidez), definizioaren lehen lerroaren bukaeran ':' karakterea zehaztu behar izan da.

Hasieran definitu den faktorial funtzioa geroago erabili da programaren azken lerroan (funtzioari deitu egiten zaiola esaten da). Bestalde, gogoratu tabulazioek berebiziko garrantzia dutela Python programazioan, funtzioaren definizioko gorputzean sartzen diren agindu guztiak tabulazio-maila berean azaltzen dira, hasierako def lerroa baino maila bat barrurago.

Orain funtzioaren definizioari helduko diogu. def hitz erreserbatuaren ondoan funtzioaren izena eta parentesien artean argumentuak agertzen dira. Ondoko lerroetan funtzioaren gorputza osatzen duten aginduak, eta bukaeran emaitza itzultzeko return sententzia azaltzen da. Azken sententzia horrek bi helburu ditu: azaltzen den funtzioaren exekuzioaren amaiera behartzea, eta itzuli beharreko balioa zehaztea. Itzultzeko baliorik zehazten ez bada, None balioa (hitz erreserbatua, 'ezer ez' adieraztekoa) itzuliko da.

Aurreko programan faktorial da funtzioaren izena, bera da funtzioa deitzeko erabiliko den identifikadorea, eta n definizioko argumentua. Argumentu bat baino gehiago egonez gero, koma karakterez bereiziko dira. Itzultzen den balioa, berriz, fakt aldagaiarena da. Funtzioa erabiltzen denean (deitu egiten zaionean), normalean esleipen baten eskuinaldean agertu ohi da deia. Dei hori ebaluatuko denean, emaitza lortuko da, eta pentsatu behar dugu deiaren emaitza dela esleituko den balioa. Hala ere, espresio baten erdian edo beste funtzio baten parametro gisa ere ager daiteke, ondoko adibideetan bezala:

print(faktorial(m)) 
print(10 * faktorial(4))

Oro har, pentsatu behar dugu funtzioaren deia bere emaitzaren balioaren ordez erabiltzen dugula programan. Balio bat esleipen batean edo beste espresio batean erabil daitekeenez, funtzio bati egiten zaion dei bat ere esleipen batean edo beste espresio batean agertu ahal izango da.

Python lengoaia interpretatua denez, funtzioaren definizioa deia baino lehen behar du interpretatzaileak, bestela errorea adieraziko du.

5.2.2. Argumentuak

Aldagaietan bezalaxe, funtzioetan eta argumentuetan Python lengoaian ez da datu-mota zehazten, baina modu inplizituan inferitzen dira. Horrela, return sententzian zehazten den balioaren arabera inferitzen da funtzioaren emaitzaren mota, eta funtzioari deitzean pasatzen zaizkion balioen motaren arabera inferitzen da argumentu bakoitzaren mota. Gogoratu Python interpretatua dela eta exekuzioan zehar egingo direla moten arteko bateragarritasun-egiaztapenak. Horrela, 5.1. programan arreta jarriz, funtzioaren emaitza fakt aldagaiaren balioa da, osokoa, hasierako balioa 1 delako; eta argumentu gisa m aldagaia, osokoa ere bai, erabiltzen da. Beraz, bateragarritasunaren aldetik arazorik ez dago funtzio-dei horretan.

Bestalde, definizioan argumenturen bat zehazten bada, deian argumentuari dagokion balioa zehaztu beharko da, bestela interpretatzaileak errorea adieraziko du. Batzuetan errore hori ez gertatzea nahi dugu, horrelakoetan parametroaren balio lehenetsia definitu beharko da definizioan. Adibidez, faktorial funtzioa definitzean balio lehenetsia 1 izatea nahi badugu:

def faktorial(n=1):

5.2.3. Kanpoko funtzio bat erabiltzea

Aurreko adibidean muga bat antzematen da: funtzioaren definizioa eta deia fitxategi edo modulu berean daude, horrela ez da erraza izango faktorial funtzioa beste programa batzuetan berrerabiltzea. Muga hori gainditzeko, funtzioaren definizioa aparteko fitxategi batean kokatzen da, eta funtzioa erabili nahi duten programek funtzioa inportatuko dute funtzioaren definizioa duen fitxategitik.

Horrela, 5.2. programan definizioa kendu dugu eta lerro hau gehitu dugu:

from funtz import faktorial

non from eta import hitz erreserbatuak diren, eta funtz da funtzioaren definizioa daukan fitxategia (funtz.py).

5.2. programa. faktorial (faktoriala) funtzioaren inportazioa:

# n faktoriala (2)
# Importatu faktorial funtzioa funtz modulutik
from funtz import faktorial

# Exekuzioa
m=int(input('Sakatu zenbaki bat, faktoriala kalkulatzeko: '))
if m <= 0:
	print ("Errorea: zenbaki positiboa behar da")
else:
	print(faktorial(m))

Ikusiko duzunez, dena berdin-berdin dabil, baina funtzioari beste hainbat programatatik ere dei dakioke bertan definitu behar izan gabe.

Funtzioetan erabiltzen diren aldagaiak, argumentuak barne, aldagai lokalak dira. Beraz, modulu bereko bi funtzioetan identifikadore bera erabiltzen bada barruko aldagai bat erabiltzeko, n aldagaia adibidez, bi aldagai horiek diferenteak izango dira, funtzio horietako batean n aldagaian egingo diren esleipenek ez dute inolako eraginik izango beste funtzioko n aldagaian. Gauza bera gertatzen da programa deitzailearen aldetik, horretan ere n aldagaia erabiltzen bada, hori hirugarren aldagai bat izango da, bere balio propioa izango duena. Propietate hau funtsezkoa da programazio lana taldekideen artean banatu ahal izateko, kide bakoitzak egin ditzake hainbat funtzio bere aldetik, beste kideen funtzioetan zer identifikadore erabili diren jakin behar izan gabe. Aldagaiak lokalak direnez, kideen artean ez dago interferentziarik programazio-lanean.

Programatzaileak kontuan hartu behar ditu bakarrik funtzioari argumentu gisa pasatuko zaizkion balioak, eta return bidez itzuli behar duena. Harentzat argumen tuak izango duen balioa definizioko argumentuan agertzen den identifikadorea da, berau aldagai moduan erabilita.

Aldagai globalak ere erabil daitezke. Hainbat funtziok konpartitzen duten aldagaia da aldagai globala, n aldagaia esaterako; funtzio horietako batean n aldagaian egingo diren esleipenek eragin zuzena izango dute beste funtzioetako n aldagaian, aldagai bera da eta. Baina ez da gomendatzen aldagai globalen erabilera. Halakorik beharrezkoa denean hobe da objektuak erabiltzea geroago ikusiko dugun moduan.

5.2.4. Funtzioak: kontzeptu aurreratuak

Parametroak, posizioaren arabera pasa beharrean (ohikoa dena, deiko lehen balioa funtzioko lehen argumenturako da, deiko bigarren balioa bigarren argumenturako, eta abar), gakoen bidez ere (keyword arguments ingelesez) pasa daitezke. Funtzio-deian esplizitu idazten dira argumentu bakoitzaren identifikadorea eta hartuko duen balioa. Horrela, balioak azaltzen diren ordena ez da garrantzitsua izango. Kasu horretan definizioan erabiltzen diren argumentuek eta deian erabilitako balioek bateragarriak izan behar dute.

Adibidez, 5.3. programan berreketa kalkulatzeko funtzio bat definitzen da, gako bidezko bi argumentu duena eta berretzailean (ber) balio lehenetsia (2) esleituta duena. Lehen deian ez da ordena betetzen eta bigarrenean argumentu bakarra erabiltzen da.

5.3a. programa. Gako bidezko argumentuak:

def berrek (oin,ber=2):
   return(oin**ber)
print(berrek(ber=3,oin=4))
## 64
print(berrek(oin=4))
## 16

Argumentu bakar batean balio-multzo bat jaso nahi denean funtzioaren definizioko argumentu listan '*' karakterea erabiltzen da argumentuaren identifikadorearen aurrean. Horrela *arg espresioa ikusten denean, funtzio baten argumentu-listako bukaeran, zera ulertu behar da: parametro bakar horretan hainbat balio pasako direla (gehienetan egitura errepikakor batean erabiltzeko).

Aurreko bi ezaugarriak (balio-multzoa eta gako bidez) **kwargs egiturak barneratzen ditu. Hurrengo kapituluan azalduko diren hiztegiekin lotuta dago, argu mentuan hiztegi oso bat (hash taula bat) txertatzen baita. Hiztegi horretako gakoak indize gisa erabil daitezke, eta 5.3b. programan dokumentatzen da haien erabilera.

5.3b. programa. Balio anitzeko argumentuak:

def berrek2 (**kwargs):
	return(kwargs['oin']**kwargs['ber'])

def berrek3 (*args):
	return(args[0]**args[1])

print(berrek2(ber=3,oin=4))
## 64
print(berrek3(4,3))
## 64

5.3. ADIBIDEAK FUNTZIOEKIN

Atal honetan funtzioak definitzeko hainbat adibide azaltzen dira. Azken adibidean funtzio horien erabilera egiten da. Funtzio guztiak funtz.py fitxategian daude definituta.

5.3.1. 1. enuntziatua: Zenbaki handiena

Balio handiena itzultzen duen funtzioa. 4.1. programan egin da, baina funtzioa erabili gabe. Ohartu kasu honetan bi argumentu daudela.

Hau da funtz moduluko handiena funtzioa:

# Zenbaki handiena
def handiena(a,b):
   if a > b:
      return(a)
   else:
      return(b)

5.3.2. 2. enuntziatua: Mezu laburrena

Jasotako bi mezuren artean laburrena selekzionatzeko funtzioa. Bigarren kapituluan aipatutako len funtzioa berrerabiliko da funtzio honen barruan.

Hau da funtz moduluko mezu_labur funtzioa:

# mezu laburrena
def mezu_labur(m1,m2):
   if (len(m1) < len(m2)):
      return(m1)
   else:
      return(m2)

5.3.3. 3. enuntziatua: Faktoriala funtzio errekurtsibo gisa

Faktoriala modu errekurtsiboan kalkulatzea. Modu errekurtsiboan funtzioaren definizioan bertan erabiltzen da funtzioaren deia.

Hau da funtz moduluko fakto_errek funtzio errekurtsiboa.

# n faktoriala
# Funtzio errekurtsiboaren definizioa
def fakto_errek(n):
   if n < 2:
      return (1) # kasu nabaria
   else:
      return (n * fakto_errek(n-1)) # kasu errekurtsiboa

Ikusten denez parametroa 1 bada, emaitza ere 1 izango da, eta bestelako kasuetan bere buruari deitzen dio parametroaren balioari bat kenduta.

5.3.4. 4. enuntziatua: Funtzioen proba

Aurreko funtzioak programa batetik erabili nahi dira. 5.4. programan azaltzen da hori. Ohartu from/import sententzien erabileraz eta nola funtzioak deitzean parametroen izenak desberdinak diren (x eta y, definizioan a eta b diren bitartean handiena funtzioaren kasuan).

5.4. programa. Funtzioen probak.

# Probak

# zenbaki handiena kalkulatzeko
from funtz import handiena
x = int(input("sakatu bi zenbakietako bat: "))
y = int(input("sakatu bestea: "))
print("handiena:", handiena(x,y))

# mezu laburrena inprimatzeko
from funtz import mezu_labur
x = input("sakatu mezu bat: ")
y = input("sakatu beste bat: ")
print("mezu laburrena:", mezu_labur(x,y))

# n faktoriala errekurts
from funtz import fakto_errek
m=int(input('Sakatu zenbaki bat, faktoriala kalkulatzeko: '))
if m <= 0:
	print ("errorea: zenbaki positiboa behar da")
else:
	print(fakto_errek(m))

5.4. OBJEKTUAK, KLASEAK ETA METODOAK

Esan bezala Python objektuei orientatutako lengoaia da, prozedura-lengoaien ezaugarriak ere barneratzen dituen arren. Paradigma honetan eragiketak datu egiturekin daude estuki lotuta klaseak osatuz. Klase batean objektuak (datu-mota bat aurreko terminologian) eta dagozkien metodoak (eragiketak edo funtzioak) definitzen dira.

Are gehiago, oinarrizko datu-mota batzuk ere objektu moduan ikus daitezke, eta aurredefinitutako metodo batzuk dituzte barneratuta. Adibidez, karaktere-kateetan ondoko metodoak daude aurredefinituta: lower (letra xehea) eta upper (letra larria) besteak beste.

Metodo bat programa batean erreferentziatu nahi denean (erabili nahi denean), objektuaren identifikadorea azaltzen da aurretik, gero puntua eta metodoaren identifikadorea, eta, azkenean parametroa(k) parentesi artean. Azter dezagun ondoko kodea:

st = “PYTHON Lengoaia”
print(st.lower())

Bi agindu horiek egikarituta, letra xehez inprimatuko da esleitutako karaktere katea ("python lengoaia"). Kasu sinple honetan ez dago parametrorik, baina metodoa objektuaren balioaren gainean aplikatzen da zuzenean.

Zerrenden kasuan aurrez definituta dagoen metodoetako bat append da. Horren bidez, zerrenda bati elementu berri bat eransten zaio bukaeran. Adibidez 4.6. programan agertzen den taulan (3 elementu zuen) 2 elementu eransteko hauxe egin daiteke:

taula = [2, 4, 6]
...
taula.append(8); taula.append(10)
...

Hori eginda, taula objektuaren balioa [2, 4, 6, 8, 10] izango da. Ikus daitekeenez, append metodoak parametro bat hartzen du, erantsi nahi den elementua. Beraz, append metodoa taula-ri berari aplikatzen zaio 8 parametroarekin.

Ariketa moduan proposatzen da 4.4. programa osatzea aldaketa honekin: zerrendako 'negatiboa', 'zero' eta 'positiboa' balioei 'infinitua' balioa gehitzea eta berriro idaztea zerrenda.

5.5. KLASE BERRIAK DEFINITZEN

Ohikoa denez, adibideak erabiliko ditugu kontzeptu berriak azaltzeko. Saila klasearekin hasiko gara, obj_saila.py programan kontsulta daitekeena.

Hau da obj_saila.py programa, sail bati dagokion objektua klase berri gisa.

class Saila(object):
   def __init__(self, izena=None, url=None, luzapena=None):
      self.izena = izena
      self.url = url
      self.luzapena = luzapena

   def eskura(self):
      return(self.izena + ", " + self.url + ", " + self.luzapena)

s1 = Saila("ekonomia", "www.ueu.eus/ekonomia", "23")
s2 = Saila("zuzenbidea", "www.ueu.eus/zuzenbidea", "33")
print(s1.eskura())
print(s2.eskura())

## ekonomia, www.ueu.eus/ekonomia, 23
## zuzenbidea, www.ueu.eus/zuzenbidea, 33

Bertan Saila klasea sortzen da bi metodorekin: init metodo eraikitzailea eta eskura izeneko metodoa. Lehenengoan klasearen informazioa definitzen da (kasu honetan izena, url eta luzapena). Metodo horrekin Saila klaseko objektu berri bat sor daiteke, hasierako balio batzuk esleituta. Beste metodoa, eskura izenekoa, Saila klaseko objektuak barruan duen informazioa jasotzeko definitu da. Ikus daitekeenez, hainbat hitz erreserbatu erabiltzen dira: class, def, self, None eta init besteak beste. Programako azken 4 lerroetan klasearen bi metodoen erabilera erakusten da. C programazio-lengoaiaz hau struct egituraren bidez egin ohi da.

Ohikoagoa da erabilera beste fitxategi batean egitea funtzioetan egiten den bezala (from/import sententzia erabiliz). Hain zuzen ere, horixe egiten da obj_pila.py eta 5.5 programetan. Pilak LIFO motako ilarak (sartzen azkena irteten lehena, last input first output) inplementatzeko erabiltzen dira.

Lehen moduluan, obj_pila.py programan, Pila klasea definitzen da hiru metodorekin: pila bat sortzeko metodo eraikitzailea (init), push eta pop. Lehenak zerrenda hutsa sortzen du, bigarrenak elementu bat gehitzen du, eta hirugarrenak gehitutako azken elementua kentzen du eta kendutako balioa itzultzen du.

class Pila :
  # Hasieraketa
  def __init__(self) :
     self.osagaiak = []
     
  # Elementu bat gainean
  def push(self, osag) :
     self.osagaiak.append(osag)
     
  # Eskuratu tontorrekoa
  def pop(self) :
     return self.osagaiak.pop()

Behin definituta, hainbat programatatik erabil daiteke, 5.5. programa horren adibide bat izanik. Bertan hiru datuak pilaratzen dira eta gero azken biak berreskuratu eta idatzi.

5.5. programa Pila klasearen erabilera:

from obj_pila import Pila

p = Pila()

p.push(4)
p.push(-7)
p.push(5)

print(p.pop())
print(p.pop())

Exekuzioaren adibidea:

>>>
5
-7

Klaseek oso mekanismoa ahaltsua eskaintzen dute, objektuei orientatutako programazioaren ezaugarri interesgarriak eskuratuz. Horrela, objektuak babestuta geratzen dira eta objektu horiek erabiltzeko metodoak dira modu bakarra.

Hurrengo kapituluan, aurredefinitutako klaseetako metodo erabilgarri batzuk azalduko dira.

5.6. ADIBIDEAK KLASEEKIN

5.6.1. 1. enuntziatua: Denbora ordu eta minututan

Denbora (ordu eta minututan) objektua definitzea bi metodo barneraturekin: inprimaketa eta batuketa. obj_denbora.py programan dago emaitza. Adibidea webgune honetatik hartu eta moldatu da: http://www.greenteapress.com/thinkpython/thinkCSpy/html/chap14.html.

Hau da obj_denbora.py programa, denbora kudeatzeko klasea:

class Denb:
   def __init__(self, ord, min):
      self.ord = ord
      self.min = min

   def inpri(self):
      print(str(self.ord) + ":" + str(self.min))

   def batu(self, t2):
      self.ord += t2.ord
      self.min += t2.min
      if self.min > 60:
         self.ord += 1
         self.min -= 60
      if self.ord > 24:
         self.ord -= 24

Funtzionamendua testatzeko kode hau erabil daiteke:

from obj_denbora import Denb
t1 = Denb(23,59)
t2 = Denb(5,55)
t1.inpri()
t2.inpri()
t1.batu(t2)
t1.inpri()

Ikus daitekeenez, 23:59 eta 5:55 denborak inprimatu eta gero haien batura inprimatzen da: 5:54. Ariketa gisa kenketa gehitzea proposatzen da.

5.7. PROGRAMA NAGUSIARI PARAMETROAK PASATZEA

Batzuetan programei parametroak pasa behar zaizkie, programa ahaltsuagoa eta malguagoa izan dadin. Horretarako, programa exekutagarria martxan jartzeko komandoan izenaren ondoren parametroak idatziko dira. Eta komandoan erantsi diren parametroen balioak jasotzeko, sys moduluko argv argumentu-zerrenda erabiltzen da. Parametroak banaka atzitu nahi badira, argv zerrendako osagaiak indizeen bidez lortu beharko dira. Horrela, argv[0] programaren izena da; argv[1] lehen argumentua, eta abar. Argumentu kopurua len funtzioaren bidez lor daiteke: len(sys.argv).

Adibidez, 5.6. programak programaren izena eta argumentu guztiak inprimatzen ditu komando-lerrotik oihartzuna lortuz. Ondoren argumentu kopurua ere inprimatzen du:

5.6. programa. Argumentuen oihartzuna:

import sys
for arg in sys.argv:
   print arg
print "Argumentu kopurua:", len(sys.argv)

Adibidez komando-lerroan ondokoa zehazten bada: python3 p5-6.py a b c Ondokoa agertuko da irteeran:

p5-6.py
a
b
c
argumentu kopurua: 4

Batzuetan programaren izena ez zaigu interesatzen eta orduan sys.arg[1:] erabil daiteke. Ariketa gisa probatu aldaketa hori 5.8. programan (for egituran).

Programaren hasieran parametroak jasotzeko erabili ohi da argv. Argumentuek fitxategi baten izena edo aukera bat adierazten dute askotan. Aukeren kasuan C lengoaian ohikoa da getopt funtzioa erabiltzea eta Pythonen horren pareko klaseak ere badaude: getopt eta argparse klaseak (<https://docs.python.org/3/library/getopt.html> kontsulta daiteke adibidez informazioa zabaltzeko).

5.8. PROPOSATUTAKO ARIKETAK

funtz moduluko mezu_labur funtzioan oinarrituta, mezu_luze funtzioa osatu eta probatu.
Kalkulatu 8 elementu 5naka konbinatzeko aukera kopurua, kalkulatzeko faktoriala erabiltzen da. Honako hau da formula:

  faktorial(m) / (faktorial(n) * faktorial(m-n))

5.2. programan oinarrituta Faktoriala maiz erabiltzen da konbinatorian. Adibidez, m elementu n-ka konbinatzeko aukera kopurua

obj_saila.py programan oinarrituta, egin klase berri bat liburuen katalogaziorako. Ondoko metodoak izan behar ditu: eraikitzailea, inprimaketa eta egilearen zein ISBN bidezko bilaketa.
obj_denbora.py modulua osatu denboren artean kenketa eta konparaketa bideratzeko. Bi metodo berri beharko dira horretarako: ken eta handiago.
getopt klaseaz irakurri eta egin programa bat 4 parametro erabiltzen dituena, lehena karaktere bat eta gainerako hirurak zenbakiak. Lehen parametroaren arabera hauxe egin behar da: '+' bada, zenbakiak gehitu; '-' bada, batuketa baina baturari balio negatiboa eman, eta, '*' bada, zenbakiak biderkatu. Parametroen balioak egokiak direla egiaztatuko da.