#LyX 1.3 created this file. For more info see http://www.lyx.org/
\lyxformat 221
\textclass scrbook
\begin_preamble
\usepackage{multicol}
\usepackage{pslatex}
\end_preamble
\language basque
\inputencoding auto
\fontscheme default
\graphics default
\paperfontsize 12
\spacing onehalf 
\papersize a4paper
\paperpackage a4
\use_geometry 1
\use_amsmath 0
\use_natbib 0
\use_numerical_citations 0
\paperorientation portrait
\leftmargin 2.5cm
\topmargin 3cm
\rightmargin 2.5cm
\bottommargin 3cm
\secnumdepth 3
\tocdepth 3
\paragraph_separation indent
\defskip medskip
\quotes_language english
\quotes_times 2
\papercolumns 1
\papersides 2
\paperpagestyle headings

\layout Title

Python-en Tutoretza
\layout Author

Axlor Elorza Eizagirre
\newline 
<axlor@zundan.com>
\layout Standard


\begin_inset LatexCommand \tableofcontents{}

\end_inset 


\layout Chapter

Sarrera
\layout Standard

Python programazio hizkuntza interpretatua 90.\SpecialChar ~
hamarkada hasieran sortu zen
 
\noun on 
Guido van Rossum
\noun default 
-en eskutik.
 Python-ek maila altuko datu estrukturak eta objetuei zuzenduriko programazioare
kiko soluzio simple eta eraginkorrak ditu, honela script-ak eta aplikazioen
 garapen azkarrerako hizkuntza egokia delarik.
\layout Standard

Python-ek aginduen lerroak (shell) baino laguntza eta azpiegitura gehiago
 eskaintzen ditu.
 Bestalde C-k baino errore egiaztapen gehiago du eta, maila altuko hizkuntza
 izatean, matrize malgu edota hiztegien moduko maila altuko datu motak barneratz
en ditu.
 Erraza delarik funtzio berri eta C edo C++-n landuriko datu motak erabiliz
 Python interpretea hedatzea eragiketa kritikoak abiadura handienean burutzeko
 edo Python programak modu bitarrean dauden liburutegiekin lotzeko.
 Honela Python interpretea C-n idatziriko aplikazio bati lotu daiteke eta
 aplikazio honentzat makroen hizkuntza moduan erabili.
\layout Standard

Python-en programak C edo C++-en baino motzagoak dira, honako arrazoiak
 direla medio:
\layout Itemize

Maila altuko datuen erabilerak eragiketa konplexuak lerro bakar batean idazten
 laguntzen du.
\layout Itemize

Sententzien taldekatzea koskatzea erabiliz egiten da, 
\family typewriter 
begin
\family default 
/
\family typewriter 
end
\family default 
 edo giltzen 
\family typewriter 
{
\family default 
/
\family typewriter 
}
\family default 
 ordez.
\layout Itemize

Argumentuak eta aldagaiak deklaratu beharrik ez dago.
\layout Standard

Modu elkarreragilean ere erabili daiteke, aginduak irakurri eta exekutatuz.
 Hizkuntzaren ezaugarriekin frogak egin daitezkelarik, programa baten azpi-funtz
ioak adibidez.
 Gaitasun handiko kalkulagailu bezala ere erabili daiteke.
\layout Chapter

Datu motak
\layout Standard

Datu mota ezberdinekin frogak egiteko interpretea erabiltzea gomendatzen
 da.
 Interpretea abiaraztean gonbit nagusia 
\begin_inset Quotes eld
\end_inset 


\family typewriter 
>>>
\family default 

\begin_inset Quotes erd
\end_inset 

 ageri arte itxaron (ez luke asko tardatu behar).
\layout Standard

Sarrerak gonbit edo indikatzaileak (
\begin_inset Quotes eld
\end_inset 


\family typewriter 
>>>
\family default 

\begin_inset Quotes erd
\end_inset 

 eta 
\begin_inset Quotes eld
\end_inset 


\family typewriter 
...
\family default 

\begin_inset Quotes erd
\end_inset 

) ageri direnean emango dira, gonbitik ageri ez den lerroetan interpretearen
 irteera emango delarik.
 Adibide askotan iruzkinak azalduko dira, beti ere 
\begin_inset Quotes eld
\end_inset 


\family typewriter 
#
\family default 

\begin_inset Quotes erd
\end_inset 

 karaktereaz hasiko dira, lerroearen amaieraraino luzatuko direlarik.
 Iruzkinak lerro haseran edo kodearen atzetik joango dira eta ez konstante
 literal baten barruan.
 Kate baten barruko traol (#) hutsa da, besterik gabe.
\layout Section

Zenbakiak
\layout Standard

Interpreteak kalkulagailu xume bat bezala jokatuko du: adierazpena idatzi
 eta berak emaitza erakutsiko du: +, -, * eta / operadoreak beste hizkuntzetan
 bezala jokatzen dute.
 Parentesiak erabili daitezke operazioak taldekatzeko.
\layout Standard

Zenbakiak adierazteko modu ezberdinak:
\layout LyX-Code

123456789         # osoa
\layout LyX-Code

0x003f            # sistema hamartarraz gain, besteen erabilera
\layout LyX-Code

0776              # aurretik 0 bat izanda ere berdin da
\layout LyX-Code

10L               # long
\layout LyX-Code

2134865345657L    # long
\layout LyX-Code

0.5               # erreala
\layout LyX-Code

5e10              # exponentziala
\layout LyX-Code

1.5+0.3j          # zenbaki konplexuak
\layout Section

Kateak
\layout Standard

Kateak adierazteko modu ezberdinak:
\layout LyX-Code

>>> 'elurra ari du' 
\layout LyX-Code

'elurra ari du'
\layout LyX-Code

>>> 'L
\backslash 
'Hospitalet'
\layout LyX-Code

"L'Hospitalet" 
\layout LyX-Code

>>> "L'Hospitalet" 
\layout LyX-Code

"L'Hospitalet" 
\layout LyX-Code

>>> '"Bai," esan zuen.' 
\layout LyX-Code

'"Bai," esan zuen.' 
\layout LyX-Code

>>> "
\backslash 
"Bai,
\backslash 
" esan zuen." 
\layout LyX-Code

'"Bai," esan zuen.' 
\layout LyX-Code

>>> '"L
\backslash 
'Hospitalet," esan zuen.'
\layout LyX-Code

'"L
\backslash 
'Hospitalet," esan zuen.'
\layout Standard

Kateek lerro ezberdinak bete ditzakete modu ezberdinetara.
 Lerro fisikoaren amaiera lerro logikoaren amaieraez izatea lortu daiteke
 alderantzizko barra erabiliz:
\layout LyX-Code

kaixo = "Hau lerro bat baino gehiago dituen
\backslash 
n
\backslash 

\layout LyX-Code

testua da, C izango balitz bezala.
\backslash 
n
\backslash 

\layout LyX-Code

    Ohar zaitez lerro haserako zuriunea
\backslash 
 
\layout LyX-Code

 esanguratsua dela.
\backslash 
n"
\layout LyX-Code

print kaixo
\layout Standard

Hau erakutsiko du:
\layout LyX-Code

Hau lerro bat baino gehiago dituen
\layout LyX-Code

testua da, C izango balitz bezala.
\layout LyX-Code

    Ohar zaitez lerro haserako zuriunea esanguratsua dela.
\layout Standard

Gako hirukoitzak 
\family typewriter 
"""
\family default 
 edo 
\family typewriter 
'''
\family default 
 erabiliz ez dago alderantziko barrarik erabili beharrik lerro jauziak adierazte
ko.
\layout LyX-Code

print """ Erabilera: gauzatxoa [AUKERAK]
\layout LyX-Code

     -h                        Erabilera mezua erakutsi
\layout LyX-Code

     -H ZerbitzariIzena        Konektatu beharreko zerbitzariaren izena
 
\layout LyX-Code

"""
\layout Standard

Hau erakutsiko du:
\layout LyX-Code

Erabilera: gauzatxoa [AUKERAK]
\layout LyX-Code

     -h                        Erabilera mezua erakutsi
\layout LyX-Code

     -H ZerbitzariIzena        Konektatu beharreko zerbitzariaren izena
 
\layout Standard

Kateak lotzeko 
\family typewriter 
+
\family default 
 operadorea erabiliko dugu eta errepikatzeko 
\family typewriter 
*
\family default 
:
\layout LyX-Code

>>> hitza = 'Laguntza' + 'Z' 
\layout LyX-Code

>>> hitza 'LaguntzaZ' 
\layout LyX-Code

>>> '<' + hitza*4 + '>' 
\layout LyX-Code

'<LaguntzaZLaguntzaZLaguntzaZLaguntzaZ>'
\layout Standard

Kateak lotzeko beste modu batzuk:
\layout LyX-Code

>>> 'kat' 'ea'                   #  <-  Honek balio du 'katea'
\layout LyX-Code

>>> import string
\layout LyX-Code

>>> string.strip('kat') + 'ea'   #  <-  Honek balio du 'katea'
\layout LyX-Code

>>> string.strip('kat') 'ea'     #  <-  Honek ez du balio
\layout LyX-Code

  File "<stdin>", line 1
\layout LyX-Code

    string.strip('kat') 'ea'
\layout LyX-Code

                           ^ 
\layout LyX-Code

SyntaxError: invalid syntax
\layout Standard

Kateak indexatu daitezke eta lehenego karakterearen indizea 0 izango da.
 Ez dago karaktere mota ezberdinik; karakterea bat luzerako katea da.
 Azpikateak mozketa oharpen bitartez zehazten dira: bi puntuz bananduriko
 bi indize.
\layout LyX-Code

>>> hitza[4]
\layout LyX-Code

'n'  
\layout LyX-Code

>>> hitza[:2]               # Lehen bi karaktereak
\layout LyX-Code

'La'
\layout LyX-Code

>>> hitza[2:]               # Lehen biak ezik beste guztiak
\layout LyX-Code

'guntzaZ'
\layout Standard

Ondorioz:
\layout LyX-Code

>>> hitza[:3]+hitza[3:]     # Lehen hiruak + beste guztiak
\layout LyX-Code

'LaguntzaZ'
\layout LyX-Code

>>> hitza[2:4]              # Lehen 4 karakteretatik lehen biak ez besteak
\layout LyX-Code

'gu'
\layout Standard

Python-en kateak ezin dira aldatu.
 Posizio indexatu bat asignatzen saiatzen bagara errorea emango digu.
\layout LyX-Code

>>> hitza[0]='X'
\layout LyX-Code

Traceback (most recent call last):
\layout LyX-Code

  File "<stdin>", line 1, in ? 
\layout LyX-Code

TypeError: object doesn't support item assignment 
\layout Standard

Eduki bateratuarekin kate berri bat sortzea erraza eta eraginkorra da:
\layout LyX-Code

>>> 'X' + hitza[1:]
\layout LyX-Code

'XaguntzaZ'
\layout Standard

Indizeak negatiboak ere izan daitezke, zenbatzea atzetik hasi dadin:
\layout LyX-Code

>>> hitza[-3]    # Azken hirugarren karakterea
\layout LyX-Code

'z'
\layout LyX-Code

>>> hitza[-3:]   # Azken hiru karaktereak
\layout LyX-Code

'zaZ'
\layout LyX-Code

>>> hitza[:-3]   # Azken hiru karaktereak ez beste guztiak
\layout LyX-Code

'Lagunt'
\layout LyX-Code

>>> hitza[-100:]
\layout LyX-Code

'LaguntzaZ'
\layout LyX-Code

>>> hitza[-10]
\layout LyX-Code

Traceback (most recent call last):
\layout LyX-Code

  File "<stdin>", line 1, in ?
\layout LyX-Code

IndexError: string index out of range
\layout Standard


\family typewriter 
len()
\family default 
 barne-funtzioak katearen luzera itzultzen du:
\layout LyX-Code

>>> len(hitza)
\layout LyX-Code

9
\layout Section

Zerrendak (array-ak)
\layout Standard

Python-ek datu mota 
\shape italic 
konposatu
\shape default 
 ezberdinak erabiltzen ditu, beste balio batzuk taldekatzeko.
 Joko gehiena eskaintzen dutenak zerrendak dira, kortxete artean komaz bananduz
 idatziko dira balio edo elementuak.
 Zerrendako elementu guztiek ez dute zertan mota berdinekoak izan behar.
\layout LyX-Code

>>> a = ['arkatza', 100.9, 1234] 
\layout LyX-Code

>>> a 
\layout LyX-Code

['arkatza', 100.90000000000001, 1234]
\layout Standard

Zerrenden indizeak kateenak bezalaxe 0-rekin hasten dira.
 Zerrendak ere moztu, lotu, etb.
 egin daitezke.
\layout LyX-Code

>>> a[0] 
\layout LyX-Code

'arkatza'
\layout LyX-Code

>>> a[3]
\layout LyX-Code

1234
\layout LyX-Code

>>> a[-2]
\layout LyX-Code

100.90000000000001
\layout LyX-Code

>>> a[1:-1]
\layout LyX-Code

100.90000000000001
\layout LyX-Code

>>> a[:2] + ['elurra', 2*2] 
\layout LyX-Code

['arkatza', 100.90000000000001, 'elurra', 4]
\layout LyX-Code

>>> 3*a[:3] + ['Eurre!'] 
\layout LyX-Code

['arkatza', 100.90000000000001, 1234, 'arkatza', 100.90000000000001,
\layout LyX-Code

   1234, 'arkatza', 100.90000000000001, 1234, 'Eurre!'] 
\layout Standard

Kateek ez bezala zerrendek aldaketak jasan ditzakete:
\layout LyX-Code

>>> a 
\layout LyX-Code

['arkatza', 100.9, 1234]
\layout LyX-Code

>>> a[3] = a[3] + 23 
\layout LyX-Code

>>> a 
\layout LyX-Code

['arkatza', 100.90000000000001, 1257]
\layout Standard

Mozketa bat ere asignatua izan daiteke, zerrendaren tamaina ere aldatua
 izan daitekeelarik:
\layout LyX-Code

>>> # Elementuak aldatu:
\layout LyX-Code

...
 a[0:2] = [1, 12] 
\layout LyX-Code

>>> a
\layout LyX-Code

[1, 12, 1234] 
\layout LyX-Code

>>> # Elementuak kendu:
\layout LyX-Code

...
 a[0:2] = []
\layout LyX-Code

>>> a 
\layout LyX-Code

[1234]
\layout LyX-Code

>>> # Elementuak gehitu:
\layout LyX-Code

...
 a[1:1] = ['ZimZum', 'Duran'] 
\layout LyX-Code

>>> a 
\layout LyX-Code

[1234, 'ZimZum', 'Duran']
\layout LyX-Code

>>> a[:0] = a     # Kopia bat sartu bere haseran
\layout LyX-Code

>>> a 
\layout LyX-Code

[1234, 'ZimZum', 'Duran', 1234, 'ZimZum', 'Duran']
\layout Standard


\family typewriter 
len()
\family default 
 funtzioaren erabilera kateetan bezalakoxea da:
\layout LyX-Code

>>> len(a) 
\layout LyX-Code

6
\layout Standard

Zerrendak habitzea (elementu bezala zerrendak dituzten zerrendak) ere posible
 da, adibidez:
\layout LyX-Code

>>> q = [2, 3]
\layout LyX-Code

>>> p = [1, q, 4] 
\layout LyX-Code

>>> len(p)
\layout LyX-Code

3 
\layout LyX-Code

>>> p[1]
\layout LyX-Code

[2, 3] 
\layout LyX-Code

>>> p[1][0]
\layout LyX-Code

2
\layout LyX-Code

>>> p[1].append('xtra')     # Consulte la sección 5.1 
\layout LyX-Code

>>> p 
\layout LyX-Code

[1, [2, 3, 'xtra'], 4]
\layout LyX-Code

>>> q
\layout LyX-Code

[2, 3, 'xtra']
\layout Standard

Ohar zaitez azken adibidean p[1] eta q objetu berataz ari direla.
\layout Subsection

Funtzioak
\layout Description

range() Barne-funtzio hau zenbaki sekuentzia baten barneko elementuak banan
 bana emaitz bezala kaleratzeko oso baliagarria da.
 Progresio arimetikoekin zerrendak sortzen ditu, adibidez:
\layout LyX-Code

>>> range(10) 
\layout LyX-Code

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
\layout Standard

Adierazitako azken puntua ez da sorturiko zerrendaren parte izango, hau
 da, 
\family typewriter 
range(10)
\family default 
-ek 10-eko luzerako zerrenda baten indizeen balioak sortuko ditu.
 Nahi izanez gero zerrenda beste zenbaki batean hasi dezakegu edo gehikuntza
 ezberdin bat zehaztu (step):
\layout LyX-Code

>>> range(5, 10) 
\layout LyX-Code

[5, 6, 7, 8, 9] 
\layout LyX-Code

>>> range(0, 10, 3) 
\layout LyX-Code

[0, 3, 6, 9] 
\layout LyX-Code

>>> range(-10, -100, -30)
\layout LyX-Code

[-10, -40, -70]
\layout Standard

Sekuentzia baten indizeak hartzen joateko, 
\family typewriter 
range()
\family default 
 eta 
\family typewriter 
len()
\family default 
 modu honetara konbinatu daitezke:
\layout LyX-Code

>>> a = ['Cure', 'for', 'pain'] 
\layout LyX-Code

>>> for i in range(len(a)):
\layout LyX-Code

...
     print i, a[i]
\layout LyX-Code

...
 
\layout LyX-Code

0 Cure
\layout LyX-Code

1 for 
\layout LyX-Code

2 pain
\layout Paragraph

Lista motako datuek dituzten metodoak
\layout Description

append(x) Zerrenda baten amaieran elementu bat sartu; 
\family typewriter 
a[len(a):]\SpecialChar ~
=\SpecialChar ~
[x]
\family default 
 -en baliokidea litzateke.
\layout Description

extend(L) Zerrenda luzatzeko beste zerrenda bat erantsiz; 
\family typewriter 
a[len(a):]\SpecialChar ~
=\SpecialChar ~
L
\family default 
 -en baliokidea.
\layout Description

insert(i,\SpecialChar ~
x) Elementu bat emaniko posizio batean gehitzen du, eta ez ordeztu.
\layout Description

remove(x)
\family typewriter 
 x
\family default 
-en balioa duen zerrendako lehen elementua ezabatuko du.
 Elementu hori existitzen ez bada errorea emango du.
\layout Description

index(x) Zerrendan 
\family typewriter 
x
\family default 
 balioa duen lehen elementuaren indizea itzuliko digu.
\layout Description

count(x) Zerrendan x balioa zenbat aldiz dagoen itzuliko digu.
\layout Description

sort() Zerrenda txikitik handira ordenatuko du.
 Zerrenda aldatua geldituko da.
\layout Description

reverse() Zerrenda alderantzikatuko du.
\layout Paragraph

Zerrendak 
\size large 
pila
\size default 
 moduan (LIFO)
\layout LyX-Code

>>> pila = [3, 4, 5]
\layout LyX-Code

>>> pila.append(6) 
\layout LyX-Code

>>> pila.append(7)
\layout LyX-Code

>>> pila 
\layout LyX-Code

[3, 4, 5, 6, 7]
\layout LyX-Code

>>> pila.pop() 7
\layout LyX-Code

>>> pila [3, 4, 5, 6] 
\layout LyX-Code

>>> pila.pop()
\layout LyX-Code

6 
\layout LyX-Code

>>> pila.pop()
\layout LyX-Code

5 
\layout LyX-Code

>>> pila 
\layout LyX-Code

[3, 4]
\layout Paragraph

Zerrendak 
\size large 
kola
\size default 
 moduan (FIFO)
\layout LyX-Code

>>> cola = ["Patton", "Fantomas", "Lonbardo"]
\layout LyX-Code

>>> cola.append("Buzz") 
\layout LyX-Code

>>> cola.append("Dunn")
\layout LyX-Code

>>> cola.pop(0)
\layout LyX-Code

'Patton' 
\layout LyX-Code

>>> cola.pop(0) 
\layout LyX-Code

'Fantomas' 
\layout LyX-Code

>>> cola 
\layout LyX-Code

['Lonbardo', 'Buzz', 'Dunn']
\layout Paragraph

Programazio funtzionaleko herremintak
\layout Standard

Zerrendekin lan egiteko hiru funtzio baliagarri ditugu: 
\family typewriter 
filter(), map()
\family default 
 eta 
\family typewriter 
reduce()
\family default 
.
\layout Description

filter(funtzioa,\SpecialChar ~
zerrenda) Funtzioa(elementua) egia deneko elementuen zerrenda
 itzuliko digu.
 Zenbaki lehen batzuk kalkulatzeko adibidea:
\layout LyX-Code

>>> def f(x): return x % 2 != 0 and x % 3 != 0 
\layout LyX-Code

...
\layout LyX-Code

>>> filter(f, range(2, 25))
\layout LyX-Code

[5, 7, 11, 13, 17, 19, 23]
\layout Description

map(funtzioa,\SpecialChar ~
zerrenda) Zerrendako elementu bakoitzari funtzioa aplikatuz
 lorturiko zerrenda itzuliko digu.
\layout LyX-Code

>>> def kubo(x): return x*x*x 
\layout LyX-Code

...
 
\layout LyX-Code

>>> map(kubo, range(1, 11)) 
\layout LyX-Code

[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]
\layout Description

reduce(funtzioa,\SpecialChar ~
zerrenda) Funtzioari zerrendaren lehen bi elementuak pasako
 dizkio haseran, gero lehen bi hauen artean lortuiko emaitza eta hurrengo
 elementua, eta horrela hurrenez hurren azken emaitza lortu arte.
 Adibidez 1-etik 10-erako zenbakien arteko batura kalkulatzeko:
\layout LyX-Code

>>> def batura(x,y): return x+y 
\layout LyX-Code

...
 
\layout LyX-Code

>>> reduce(batura, range(1, 11)) 
\layout LyX-Code

55
\layout Standard

Zerrendan elementu bakarra badago, bere balioa itzuliko digu; zerrenda hutsik
 badago, exzepzio bat jaurtiko du.
\layout Standard

Hirugarren argumentu bat pasa geniezaiokegu haserako balioa zehazteko.
 Kasu honetan balio hau itzuliko luke zerrenda hutsik balego eta funtzioa
 lehen elementuari aplikatuko zaio, gero bigarrenari eta horrela hurrenez
 hurren.
 Adibidez:
\layout LyX-Code

>>> def batu(sekuentzia):
\layout LyX-Code

...
     def batu(x,y): return x+y 
\layout LyX-Code

...
     return reduce(batu, sekuentzia, 0)
\layout LyX-Code

...
 
\layout LyX-Code

>>> batu(range(1, 11)) 
\layout LyX-Code

55 
\layout LyX-Code

>>> batu([]) 
\layout LyX-Code

0
\layout Paragraph

LC-ak
\layout Standard

LC-ek 
\family typewriter 
map()
\family default 
, 
\family typewriter 
filter()
\family default 
 edota 
\family typewriter 
lambda
\family default 
 funtzioak erabili gabe zerrendak sortzeko modu zehatza dira.
 LC-en egitura adierazpen bat, 
\family typewriter 
for
\family default 
 sententzia bat eta 
\family typewriter 
for
\family default 
 edo 
\family typewriter 
if
\family default 
 (zero edo gehiago) adierazpenez eratuak daude.
 Emaitza izango den zerrenda adierazpenaren ondoren datozen 
\family typewriter 
for
\family default 
 eta 
\family typewriter 
if
\family default 
 sententzietan adierazpena ebaluatu ondoren lortuko da.
 Adierazpenak emaitz bezala tupla bat itzuli behar badu parentesi artean
 itxi beharko da.
\layout LyX-Code

>>> fruitufreskoa = ['  platano', '  sagarra ', 'marrubia  ']
\layout LyX-Code

>>> [arma.strip() for arma in fruitufreskoa] 
\layout LyX-Code

['  platano', '  sagarra ', 'marrubia  ']
\layout LyX-Code

>>> bec = [2, 4, 6]
\layout LyX-Code

>>> [3*x for x in bec] 
\layout LyX-Code

[6, 12, 18] 
\layout LyX-Code

>>> [3*x for x in bec if x > 3] 
\layout LyX-Code

[12, 18] 
\layout LyX-Code

>>> [3*x for x in bec if x < 2] 
\layout LyX-Code

[] 
\layout LyX-Code

>>> [{x: x**2} for x in bec]
\layout LyX-Code

[{2: 4}, {4: 16}, {6: 36}]
\layout LyX-Code

>>> [[x,x**2] for x in bec]
\layout LyX-Code

[[2, 4], [4, 16], [6, 36]] 
\layout LyX-Code

>>> [x, x**2 for x in bec]  # error - tupletan parentesia behar da
\layout LyX-Code

  File "<stdin>", line 1
\layout LyX-Code

    [x, x**2 for x in bec]
\layout LyX-Code

               ^ 
\layout LyX-Code

SyntaxError: invalid syntax 
\layout LyX-Code

>>> [(x, x**2) for x in bec] 
\layout LyX-Code

[(2, 4), (4, 16), (6, 36)] 
\layout LyX-Code

>>> bec1 = [2, 4, 6] 
\layout LyX-Code

>>> bec2 = [4, 3, -9] 
\layout LyX-Code

>>> [x*y for x in bec1 for y in bec2]
\layout LyX-Code

[8, 6, -18, 16, 12, -36, 24, 18, -54]
\layout LyX-Code

>>> [x+y for x in bec1 for y in bec2] 
\layout LyX-Code

[6, 5, -7, 8, 7, -5, 10, 9, -3]
\layout Paragraph


\family typewriter 
del
\family default 
 sententzia
\layout Standard

Indizea edo mozketa pasata elementuak zerrendatik ezabatzeko balio du, baita
 aldagai osoa ezabatzeko ere.
 Adibidez:
\layout LyX-Code

>>> a [-1, 1, 66.6, 333, 333, 1234.5] 
\layout LyX-Code

>>> del a[0] 
\layout LyX-Code

>>> a 
\layout LyX-Code

[1, 66.6, 333, 333, 1234.5]
\layout LyX-Code

>>> del a[2:4]
\layout LyX-Code

>>> a 
\layout LyX-Code

[1, 66.6, 1234.5]
\layout LyX-Code

>>> del a
\layout Section

Tupla / sekuentziak
\layout Standard

Zerrenda eta kateak bezala tuplak ere datu mota sekuentzialak dira.
 Tuplek zenbait balio komaz bananduak izaten dituzte:
\layout LyX-Code

>>> t = 12345, 54321, 'Rosemary' 
\layout LyX-Code

>>> t[0] 
\layout LyX-Code

12345 
\layout LyX-Code

>>> t 
\layout LyX-Code

(12345, 54321, 'Rosemary')
\layout LyX-Code

>>> # Tuplak habitzea posible da:
\layout LyX-Code

...
 u = t, (1, 2, 3, 4, 5)
\layout LyX-Code

>>> u 
\layout LyX-Code

((12345, 54321, 'Rosemary'), (1, 2, 3, 4, 5))
\layout Standard

Tuplak oso erabilgarriak dira, adibidez koordenada bikoteetan (x,y), datu
 base baten langileen erregistroetan, etab.
 Tuplak kateak bezala, aldaezinak dira: elementu indibidualei ezin zaie
 baliorik asignatu (nahiz eta mozketa eta kateatzea erabili daitezken).
 Zerrendak bezalako objetu aldakorrez osaturiko tuplak posible dira.
\layout Standard

Elementu bakarreko edo elementurik gabeko tuplak adierazteko parentesi hutsak
 eta elementu bakarraren ondoren koma bat gehituz lortuko da.
\layout LyX-Code

>>> hutsa = () 
\layout LyX-Code

>>> vendetta = 'charade',    # <-- Begiratu amaierako koma 
\layout LyX-Code

>>> len(hutsa)
\layout LyX-Code

0 
\layout LyX-Code

>>> len(vendetta)
\layout LyX-Code

1 
\layout LyX-Code

>>> vendetta
\layout LyX-Code

('charade',)
\layout Section

Hiztegiak
\layout Standard

Hiztegiak Python-eko barne-datu mota erabilgarriak dira.
 Sekuentziekin alderatuz, zenbakiez indexatu beharrean 
\shape slanted 
gakoak
\shape default 
 erabiliz indexatuko dira, edozein mota aldaezinekoak izango direlarik,
 zenbaki eta kateak bezala.
 Tupla gako bezala erabiltzeko baldintza tupla, kate edo zenbakiez bakarrik
 eratzea da.
 Tupla batek zuzenean edo zeharka objetu aldakor bat badu ezingo da gako
 bezala erabili.
 Listak ezingo dira gako bezala erabil 
\family typewriter 
append()
\family default 
 edo 
\family typewriter 
extend()
\family default 
 metodoak erabiliz aldatzeko gaitasuna baitute, mozketa asignazio eta asignazio
 aniztuez gain.
\layout Standard

Egokiena hiztegiak ordenarik gabeko 
\shape italic 
gakoa : balioa
\shape default 
 bikoteen talde bezala hartzea da, gakoak hiztegi barruan bakarrak izango
 diren baldintzarekin.
 {} giltz pareak hiztegi huts bat adierazten du eta 
\shape italic 
gakoa : balioa
\shape default 
 pare bat sartuz gero 
\shape italic 
gakoa : balioa
\shape default 
 pare haseratuak sartzen dira hiztegian.
\layout Standard

Hiztegien eragiketa nagusiak bertan gako bat erabiliz balio bat gorde eta
 gako bat emanik balioak ateratzea dira.
 Hauez gain 
\family typewriter 
del
\family default 
 erabiliz 
\shape italic 
gakoa : balioa
\shape default 
 bikote bat ezabatu daiteke.
 Iada hiztegian dagoen gako bat sartuz gero lehendik dagoen balioa ezabatu
 egingo du.
 Existitzen ez den gako bat ateratzen saiatzeak errorea emango du.
\layout Standard

Objetu baten 
\family typewriter 
keys()
\family default 
 metodoak hiztegiaren gako guztiak itzuliko dizkigu ausazko ordena batean
 (ordenaturik nahi badira 
\family typewriter 
sort()
\family default 
 metodoa aplikatu beharko zaio gako zerrendari).
\layout Standard

Gako bat hiztegian ba al dagoen jakiteko hiztegiaren 
\family typewriter 
has_key()
\family default 
 metodoa erabili behar da.
\layout Standard

Hona hemen hiztegi bat erabiltzen duen adibide bat:
\layout LyX-Code

>>> tel = {'mikel': 4098, 'xabier': 4139}
\layout LyX-Code

>>> tel['alex'] = 4127 
\layout LyX-Code

>>> tel 
\layout LyX-Code

{'alex': 4127, 'mikel': 4098, 'xabier': 4139} 
\layout LyX-Code

>>> tel['mikel'] 
\layout LyX-Code

4098 
\layout LyX-Code

>>> del tel['xabier']
\layout LyX-Code

>>> tel['axlor'] = 4127 
\layout LyX-Code

>>> tel
\layout LyX-Code

{'alex': 4127, 'mikel': 4098, 'axlor': 4127}
\layout LyX-Code

>>> tel.keys()
\layout LyX-Code

['alex', 'mikel', 'axlor'] 
\layout LyX-Code

>>> tel.has_key('axlor')
\layout LyX-Code

true
\layout Chapter

Fluxu kontrola
\layout Section


\family typewriter 
if
\family default 
 sententzia
\layout Standard

Nahi adina 
\family typewriter 
elif
\family default 
 eta 
\family typewriter 
else
\family default 
 izan ditzake, aukerakoa delarik hauen erabilera.
 
\family typewriter 
if ...
 elif ...
 elif...

\family default 
 sekuentziak beste hizkuntza batzuetako 
\family typewriter 
switch
\family default 
 edo 
\family typewriter 
case
\family default 
 bezala jokatzen du.
\layout Paragraph*

Formatua:
\layout LyX-Code

>>> if baldintza1: sententzia1
\layout LyX-Code

    elif baldintza2: sententzia2
\layout LyX-Code

\layout LyX-Code

       ...
\layout LyX-Code

\layout LyX-Code

 else: sententziaN
\layout Paragraph*

Adibidea:
\layout LyX-Code

>>> x = int(raw_input("Sartu zenbaki bat: "))
\layout LyX-Code

>>> if x < 0: 
\layout LyX-Code

...
      x = 0
\layout LyX-Code

...
      print 'Zenbaki negatiboa zerora bihurtu da.'
\layout LyX-Code

...
 elif x == 0: 
\layout LyX-Code

...
      print 'Zero' 
\layout LyX-Code

...
 elif x == 1: 
\layout LyX-Code

...
      print 'Bat' 
\layout LyX-Code

...
 else: 
\layout LyX-Code

...
      print 'Gehiago'
\layout LyX-Code

...
\layout Section


\family typewriter 
while
\family default 
 sententzia
\layout Paragraph*

Formatua:
\layout LyX-Code

while baldintza :
\layout LyX-Code

    sententzia
\layout Paragraph*

Adibidea:
\layout LyX-Code

>>> # Fibonacci seriea
\layout LyX-Code

...
 # Aurreko bi zenbakiren baturak emango digu hurrengoaren balioa
\layout LyX-Code

...
 a, b= 0, 1
\layout LyX-Code

>>> while b < 10:
\layout LyX-Code

...
    print b,
\layout LyX-Code

...
    a, b = b, a+b
\layout LyX-Code

...
\layout LyX-Code

1 1 2 3 5 8
\layout Standard

Python-en, C-n bezala, zeroren ezberdina den edozein balio egiazkoa da eta
 0 berriz gezurrezkoa.
 Baldintza, zerrenda edo beste edozein sententzia izan daiteke, edozer gauz
 zero ez den luzerarekin egiazkoa da eta sekuentzia hutsak berriz gezurrezkoak.
\layout Section


\family typewriter 
for
\family default 
 sententzia
\layout Standard


\family typewriter 
for
\family default 
 sententziak C edo Pascal-ekiko ezberdintasun bat du.
 Progresio arimetiko bateko elementu denak banan bana pasa beharrean edo
 programatzaileari inizializazio, egiaztapen eta urrats-jauzia aukeratzeko
 askatasuna utzi beharrean, Python-en sekuentzia baten (zerrenda edo kate
 bat, adibidez) elementu guztiak banan bana pasako ditu, sekuentzian azaltzen
 diren ordenean.
\layout Paragraph*

Formatua:
\layout LyX-Code

>>> for elementua in zerrenda:
\layout LyX-Code

...
     sententzia
\layout Paragraph*

Adibidea:
\layout LyX-Code

>>> # kateak nehurtzeko:
\layout LyX-Code

...
 a = ['katu', 'lehioa', 'hitzluzeagoa']
\layout LyX-Code

>>> for x in a:
\layout LyX-Code

...
     print x, len(x)
\layout LyX-Code

...
\layout LyX-Code

katu 4 lehioa 6 hitzluzeagoa 12
\layout Standard

Kasuren batean for sententziaren barruan banan bana pasatzen ari garen sekuentzi
an (zerrendak adibidez) aldaketak egin behar baditugu kopia bat pasatu behar
 da.
 Hau errazteko mozketa oharpena erabili dezakegu.
 
\layout Standard


\family typewriter 
zerrenda[:]
\layout LyX-Code

>>> for x in a[:]: # lista osoaren mozketa kopia egin behar da 
\layout LyX-Code

...
    if len(x) > 7: a.insert(0, x) 
\layout LyX-Code

...
  
\layout LyX-Code

>>> a 
\layout LyX-Code

['hitzluzeagoa', 'katu', 'lehioa', 'hitzluzeagoa']
\layout Section


\family typewriter 
break
\family default 
, 
\family typewriter 
continue
\family default 
 eta 
\family typewriter 
else
\family default 
 eraketak bukletan
\layout Standard


\family typewriter 
break
\family default 
 sententziak, C-n bezala, aribidean dagoen barrueneko 
\family typewriter 
for
\family default 
 edo 
\family typewriter 
while
\family default 
 bukletik irteera bultzatuko du.
\layout Standard


\family typewriter 
continue
\family default 
 sententziak buklearen hurrengo errepikapenean jarraitzera behartzen du.
\layout Standard

Bukleko eraketek 
\family typewriter 
else
\family default 
 klausula izan dezakete.
 Hau, buklean izanez gero, bukletik irtetean baldintza gezurrezkoa delako
 (
\family typewriter 
while
\family default 
-en) edo zerrenda amaierara iritsi denean (
\family typewriter 
for
\family default 
-en) exekutatuko da, baina ez 
\family typewriter 
break
\family default 
 sententziarekin amaitu bada.
\layout Section

Baldintzei buruz
\layout Standard

Lehenago deskribaturiko 
\family typewriter 
for
\family default 
 eta 
\family typewriter 
while
\family default 
 eraketetan erabilitako baldintzek konparazioez gain beste baldintza mota
 batzuk erabili ditzakete.
\layout Standard


\family typewriter 
in
\family default 
 eta 
\family typewriter 
not\SpecialChar ~
in
\family default 
 konparazio operadoreek balio bat sekuentzi baten barrun ba al dagoen begiratzen
 dute.
 
\family typewriter 
is
\family default 
 eta 
\family typewriter 
is\SpecialChar ~
not
\family default 
 bi objetu benetan bera al diren begiratzen dute.
 Hauek listak bezalako objetu aldakorretan bakarrik dute garrantzia.
 Konparazio operadore guztiek lehentasun bera dute, zenbakizko operadoreena
 baino baxuagoa.
\layout Standard

Konparazioak elkartu daitezke: Adibidez, 
\family typewriter 
a\SpecialChar ~
<\SpecialChar ~
b\SpecialChar ~
==\SpecialChar ~
d,
\family default 
 
\family typewriter 
a
\family default 
 
\family typewriter 
b
\family default 
 baino txikiagoa al den eta 
\family typewriter 
b
\family default 
 eta 
\family typewriter 
d
\family default 
 berdinak al diren egiaztatzen du.
\layout Standard


\family typewriter 
and
\family default 
 eta 
\family typewriter 
or
\family default 
 operadore logikoak erabiliz ere egin daitezke konparazioak, 
\family typewriter 
not
\family default 
-ek emaitza ezeztatuko lukeelarik.
 Konparazio operadoreek baino lehentasun baxuagoa dute.
 Beraien artean lehentasuna 
\family typewriter 
not
\family default 
-ek izango du, baxuenak 
\family typewriter 
or
\family default 
-ek izango lukeelarik, ondorioz 
\family typewriter 
A\SpecialChar ~
and\SpecialChar ~
not\SpecialChar ~
B\SpecialChar ~
or\SpecialChar ~
C
\family default 
 
\family typewriter 
,(A\SpecialChar ~
and\SpecialChar ~
(not\SpecialChar ~
B))\SpecialChar ~
or\SpecialChar ~
C
\family default 
-ren berdina da.
 Emaitza ezkerretik eskubira ebaluatuko da eta emaitza zehaztu orduko ebaluazioa
 moztu egingo da.
 Adibidez, 
\family typewriter 
A
\family default 
 egia da eta 
\family typewriter 
B
\family default 
 gezurra, ondorioz 
\family typewriter 
A\SpecialChar ~
and\SpecialChar ~
B\SpecialChar ~
and\SpecialChar ~
D
\family default 
-k ez du ebaluatuko 
\family typewriter 
D
\family default 
 adierazpena.
 Orokorrean, lasterbide deituriko operadore hauek itzuliko duten balioa,
 balio orokor bezala erabiltzean eta ez balio logiko bezala, ebaluaturiko
 azken argumentua izango da:
\layout LyX-Code

>>> str1, str2, str3 = '', 'Norbegia', 'Mailu dantza' 
\layout LyX-Code

>>> non_null = str1 or str2 or str3 
\layout LyX-Code

>>> non_null 
\layout LyX-Code

'Norbegia'
\layout Standard

Python-en, C-n ez bezala, ezin da adierazpen baten barruan asignaziorik
 egin.
\layout Section

Sekuentzia eta beste mota batzuen arteko konparazioa
\layout Standard

Sekuentzia objetuak mota berdineko sekuentziez alderatu daitezke, ordenazio
 
\shape italic 
lexikografikoa
\shape default 
 erabiliko delarik.: Lehenendabizi lehen bi elementuak konparatuko ditu,
 ezberdinak badira emaitza hauek emango digute, eta berdinak badira hurrenez
 hurren sekuentzia bakoitzeko elementuak alderatzen joango da, sekuentzietako
 bat amaitu arte.
 Elementuetako bat sekuentzia bat bada, konparazio lexikografiko habitu
 bat emango da.
 Konparazio lexikografikoa egiteko ASCII kodearen ordena erabiliko da.
 Hona hemen mota berdineko sekuentzien arteko alderapen batzuk:
\layout LyX-Code

(1, 2, 3)              < (1, 2, 4) 
\layout LyX-Code

[1, 2, 3]              < [1, 2, 4] 
\layout LyX-Code

'ABC' < 'C' < 'Pascal' < 'Python' 
\layout LyX-Code

(1, 2, 3, 4)           < (1, 2, 4) 
\layout LyX-Code

(1, 2)                 < (1, 2, -1) 
\layout LyX-Code

(1, 2, 3)             == (1.0, 2.0, 3.0)
\layout LyX-Code

(1, 2, ('aa', 'ab'))   < (1, 2, ('abc', 'a'), 4)
\layout Standard

Mota ezberdineko konparazioak egitean motak izenez ordenatzen dira.
 Honela, lista edo zerrenda bat kate bat baino txikiagoa izango da, katea
 tupla baino txikiagoa, etab.
 Mota ezberdinetako zenbakizko balioen artean zenbakizko balio hoiek konparatuko
 dira, 
\family typewriter 
0 0.0
\family default 
-ren berdina izango delarik.
\layout Subsection*

Adibidea:
\layout Standard

Honako adibide honek telefono zenbakiak gordeko ditu hiztegi batetan:
\layout LyX-Code

#
\layout LyX-Code

# Zenbakiak.py fitxategiaren hasera
\layout LyX-Code

#
\layout LyX-Code

def menua():
\layout LyX-Code

    print '1.
 Telefono zenbakiak erakutsi'
\layout LyX-Code

    print '2.
 Zenbaki berri bat sartu'
\layout LyX-Code

    print '3.
 Zenbaki bat ezabatu'
\layout LyX-Code

    print '4.
 Zenbaki bat bilatu'
\layout LyX-Code

    print '5.
 Irten'
\layout LyX-Code

    print
\layout LyX-Code

zenbakiak = {}
\layout LyX-Code

aukera = 0
\layout LyX-Code

menua()
\layout LyX-Code

while aukera != 5:
\layout LyX-Code

    aukera = input("Sartu aukera (1-5):")
\layout LyX-Code

    if aukera == 1:
\layout LyX-Code

        print "Zenbaki telefonikoak: "
\layout LyX-Code

        for x in zenbakiak.keys():
\layout LyX-Code

            print "Izena: ",x," 
\backslash 
tZenbakia: ",zenbakiak[x]
\layout LyX-Code

        print
\layout LyX-Code

    elif aukera == 2:
\layout LyX-Code

        print "Sartu izena eta zenbakia"
\layout LyX-Code

        izena = raw_input("Izena: ")
\layout LyX-Code

        telefonoa = raw_input("Zenbakia: ")
\layout LyX-Code

        zenbakiak[izena] = telefonoa
\layout LyX-Code

    elif aukera == 3:
\layout LyX-Code

        print "Ezabatu izena eta zenbakia"
\layout LyX-Code

        izena = raw_input("Izena: ")
\layout LyX-Code

        if zenbakiak.has_key(izena):
\layout LyX-Code

            del zenbakiak[izena]
\layout LyX-Code

        else:
\layout LyX-Code

            print "Ezin izan da ", nombre, " aurkitu"
\layout LyX-Code

    elif aukera == 4:
\layout LyX-Code

        print "Zenbakia bilatu"
\layout LyX-Code

        izena = raw_input("Nombre:")
\layout LyX-Code

        if zenbakiak.has_key(izena):
\layout LyX-Code

            print "Zenbakia: ",zenbakiak[izena]
\layout LyX-Code

        else:
\layout LyX-Code

            print "No pude encontrar a ",izena
\layout LyX-Code

    elif aukera != 5:
\layout LyX-Code

        menua()
\layout LyX-Code

# Zenbakiak fitxategiaren amaiera
\layout Chapter

Funtzioak
\layout Standard

Adibidea:
\layout LyX-Code

>>> def fib(n):
\layout LyX-Code

...
    
\begin_inset Quotes eld
\end_inset 

n-rainoko Fibonacci seriea idatzi
\begin_inset Quotes eld
\end_inset 


\layout LyX-Code

...
    a, b = 0, 1
\layout LyX-Code

...
    while b < n:
\layout LyX-Code

...
        print b,
\layout LyX-Code

...
        a, b = b, a+b
\layout LyX-Code

...
\layout LyX-Code

>>> # Orain funtzio definitu berriari deituko diogu:
\layout LyX-Code

...
 fib(1000)
\layout LyX-Code

1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
\layout Standard


\family typewriter 
def
\family default 
 hitz-gakoak funtzio baten definiziora garamatza, hau funtzioaren izenaz
 eta parentesi artean parametro formalen zerrendak jarraituko dute.
 Funtzioaren gorputza osatzen duten sententziak hurrengo hilaran hasten
 dira eta koskatuak egon behar dute.
 Funtzioaren gorputzeko lehen sententzia kate-konstante bat izan liteke,
 non funtzioaren zeregina argituko ligukeen.
 Hau dokumentazio idatzi/elektronikoa sortzeko edo erabiltzailea kodean
 zehar interktiboki nabigatzeko baliagarria da.
\layout Standard

Funtzio baten exekuzioak Python-en aldagai lokalentzat sinbolo-taula berri
 bat sortzen du.
 Zehazki, funtzio baten aldagaien asignazio guztiek balioa sinbolo-taula
 lokalean gordetzen dute; honela, aldagaien erreferentziek lehenengo sinbolo-tau
la lokalean begiratuko dute, gero sinbolo-taula orokorrean eta, azkenik,
 barneko izen-taulan.
 Arrazoi honexegatik ezin izango diogu aldagai orokor bati baliorik ezarri
 funtzio baten barruan (
\family typewriter 
global
\family default 
 sententzi batean aipatzen ez bada behintzat), nahiz eta beraiei erreferentzia
 egin daitekeen.
\layout Standard

Funtzio bati argumentuak balioz pasatuko zaizkio, balioa beti objeturi erreferen
tzia bat izango delarik eta ez objetuaren balioa.
\layout Standard

Funtzioaren definizioak funtzioaren izena indarrean dagoen sinbolo-taulan
 gordeko du, izenaren balioa interpreteak onarturiko mota izango du erabiltzaile
ak definituriko funtzio bezala.
 Honela berizendapen-generiko bezala balio duelarik:
\layout LyX-Code

>>> fib
\layout LyX-Code

<function fib at 0x403f6bc4>
\layout LyX-Code

>>> f = fib
\layout LyX-Code

>>> f (50)
\layout LyX-Code

1 1 2 3 5 8 13 21 34
\layout Standard

Python-en prozedurak baliorik itzultzen ez duten funtzioak dira.
 Teknikoki ordea, 
\family typewriter 
None
\family default 
 balioa itzuliko lukete.
\layout LyX-Code

>>> fib(0)
\layout LyX-Code

None
\layout Standard

Zenbakiak idatzi beharrean, hauek itzuliko dizkigun funtzioa:
\layout LyX-Code

>>> def fib2(n):
\layout LyX-Code

...
    
\begin_inset Quotes eld
\end_inset 

n-rainoko Fibonacci seriea itzuli
\begin_inset Quotes eld
\end_inset 


\layout LyX-Code

...
    a, b = 0, 1
\layout LyX-Code

...
    emaitza = []
\layout LyX-Code

...
    while b < n:
\layout LyX-Code

...
        emaitza.append(b)   # Edo: emaitza = emaitza + [b]
\layout LyX-Code

...
        a, b = b, a+b
\layout LyX-Code

...
    return emaitza
\layout LyX-Code

...
\layout LyX-Code

>>> f10 = fib2(10)    # funtzioari deitu
\layout LyX-Code

>>> f10               # emaitza idatzi
\layout LyX-Code

[1, 1, 2, 3, 5, 8]
\layout Standard

Funtzioak argumentu kopuru aldakorrez definitzea ere zilegi litzateke, konbinatu
 daitezken hiru modu daude:
\layout Section*

Balio lehenetsiak argumentuetan
\layout Standard

Modurik errazena da argumentu bat edo gehiagori balio lehenetsiak zehazteko.
 Honela dituena baino argumentu gutxiagorekin deitu dezakegun funtzioa sortu
 dezakegu:
\layout LyX-Code

def baieztatu(adierazlea, ahaleginak=3, kexua='Bai edo ez!'):
\layout LyX-Code

    while 1:
\layout LyX-Code

        erantzuna = raw_input(adierazlea) 
\layout LyX-Code

        if erantzuna in ('b', 'bai'): return 1 
\layout LyX-Code

        if erantzuna in ('e', 'ez'): return 0
\layout LyX-Code

        ahaleginak = ahaleginak - 1
\layout LyX-Code

        if ahaleginak < 0: raise IOError, 'Erabiltzailea ukatua'
\layout LyX-Code

        print kexua
\layout Standard

Funtzioari honela deitu diezaiokegularik: 
\family typewriter 
baieztatu ('Irteterik nahi?')
\family default 
 edo: 
\family typewriter 
baieztatu ('Ezabatu fitxategia?', 2).
\layout Standard

Balio lehenetsiak funtzioa defintzean ebaluatuko dira:
\layout LyX-Code

i = 5 
\layout LyX-Code

def f(arg = i): print arg
\layout LyX-Code

i = 6
\layout LyX-Code

f()
\layout Standard

Honek 
\family typewriter 
5
\family default 
 erakutsiko liguke.
\layout Standard

Kontuz! Argumentu lehenetsiak behin bakarrik ebaluatzen dira.
 Emaitza ezberdinak lortuko ditugu balio lehenetsiak zerrenda edo hiztegien
 moduko balio aldakorrak direnean.
 Adibidez:
\layout LyX-Code

def f(a, l = []):
\layout LyX-Code

    l.append(a)
\layout LyX-Code

    return l 
\layout LyX-Code

print f(1) 
\layout LyX-Code

print f(2) 
\layout LyX-Code

print f(3)
\layout Standard

Honek erakutsiko ligukena:
\layout LyX-Code

[1]
\layout LyX-Code

[1, 2] 
\layout LyX-Code

[1, 2, 3]
\layout Standard

Ez badugu nahi balio lehenetsia hurrendo deiekin konpartitzerik honela egin
 genezake:
\layout LyX-Code

def f(a, l = None):
\layout LyX-Code

    if l is None:
\layout LyX-Code

        l = []
\layout LyX-Code

    l.append(a)
\layout LyX-Code

    return l
\layout Section*

Argumentuak gakoz
\layout Standard


\shape slanted 
"gakoa = balioa"
\shape default 
 modua erabiliz ere deitu diezaiokegu funtzioari.
 Adibidez:
\layout LyX-Code

def txoria(tentsioa, egoera='frijitua', ekintza='lehertu', mota='Grisa'):
\layout LyX-Code

   print "-- Txori honek ezingo luke ", ekintza,
\layout LyX-Code

   print tentsioa, " boltio jasanaraziz ere."
\layout LyX-Code

   print "-- Lumatza ederra ", mota,"rena." 
\layout LyX-Code

   print "-- ", egoera, " dago!"
\layout Standard

Modu hauetara deitu diezaiokegu:
\layout LyX-Code

txoria(13000)
\layout LyX-Code

txoria(ekintza = "DANBA!", tentsioa = 1000)
\layout LyX-Code

txoria('bi mila', egoera = 'antzarrak perratzen')
\layout LyX-Code

txoria('milioika', 'hilda', 'salto egin')
\layout Standard

Honako hauek berriz ez lirateke ondo egongo:
\layout LyX-Code

txoria()                      # Derrigorrezko argumentu bat falta da
\layout LyX-Code

txoria(tentsioa=5.0, 'hilda') # Gako argumentua argumentu ez-gakoaren
\layout LyX-Code

                              # ondoren
\layout LyX-Code

txoria(110, tentsioa=220)     # Argumentuaren balioa bikoiztua
\layout LyX-Code

txoria(hegokopurua='bat')     # Gako ezezaguna
\layout Standard

Orokorrean, argumentu zerrenda batek argumentu posizionalak gakodun argumentuz
 jarraiturik izango ditu, non gakoak parametro formalen izenen arabera aukeratuk
o diren.
 Parametro formalek balio lehenetsia izan edo ez izateko aukera dute.
 Argumentuek ezin dute balio bat baino gehiago jaso (argumentu posizionalei
 dagozkien parametro formalen izenak ezin dira erabili funtzioari deitzean).
 Hona hemen arazo honexengatik errorea ematen duen adibide bat:
\layout LyX-Code

>>> def funtzioa (a):
\layout LyX-Code

...
    pass
\layout LyX-Code

...
\layout LyX-Code

>>> funtzioa(0, a=0)
\layout LyX-Code

Traceback (most recent call last):
\layout LyX-Code

  File "<stdin>", line 1, in ? 
\layout LyX-Code

TypeError: funtzioa() got multiple values for keyword argument 'a'
\layout Standard

Azken parametro formalak 
\shape slanted 
**izena
\shape default 
 egitura duenean parametro formalekin bat ez datozen gako argumentu guztiak
 dituen hiztegi bat jasoko du.
 Hau 
\shape slanted 
*izena
\shape default 
 egitura duen parametro formal batekin konbinatu daiteke, honek parametro
 formalen zerrendatik at dauden tupla jasoko du.
 Beti ere 
\shape slanted 
*izena
\shape default 
-ak 
\shape slanted 
**izena
\shape default 
-ren aurretik agertu beharko du.
 Adibidez:
\layout LyX-Code

def garagardotegia(mota, *argumentuak, **gakoak):
\layout LyX-Code

    print "-- Ba al duzu", mota, "-ik?" 
\layout LyX-Code

    print "-- Barkatu, ez dugu", mota, "-ik"
\layout LyX-Code

    for arg in argumentuak: print arg 
\layout LyX-Code

    print '-'*30
\layout LyX-Code

    for kw in gakoak.keys(): print kw, ':', gakoak[kw]
\layout Standard

Honela deitu diezaiokegularik:
\layout LyX-Code

garagardotegia ('duff', "Samielak ditugu, jauna.", 
\layout LyX-Code

                "Zuk hala nahi izanez gero", bezeroa='dooteo',
\layout LyX-Code

                dendaria='axlor')
\layout Standard

Honakoa erakutsiko luke:
\layout LyX-Code

-- Ba al duzu duff -ik?
\layout LyX-Code

-- Barkatu, ez dugu duff -ik 
\layout LyX-Code

Samielak ditugu, jauna.
 
\layout LyX-Code

Zuk hala nahi izanez gero 
\layout LyX-Code

------------------------------
\layout LyX-Code

bezeroa : dooteo 
\layout LyX-Code

dendaria : axlor 
\layout Section*

Aukerazko argumentu zerrendak
\layout Standard

Azkenik, gutxien erabiltzen den aukera funtzio bati zehaztugabeko argumentu
 kopuru batekin deitu diezaiokegunekoa da.
 Argumentu hauek tupla batean bilduko dira.
 Zehaztugabeko argumentu kopuruaren aurretik argumentu arruntak izan ditzake,
 bat ere ez edo nahi adina.
\layout LyX-Code

def fprintf(file, formatua, *args):
\layout LyX-Code

    file.write(formatua % args)
\layout LyX-Code

\layout Section

lambda egiturak
\layout Standard

Erabiltzaileen beharren arabera, Python-en Lisp programazio hizkuntza funtzional
etako ezaugarri batzuk gehitu dira.
 
\family typewriter 
lambda
\family default 
 hitza erabiliz funtzio ezezagun txikiak gehitu daitezke.
 Funtzio honek bere bi argumentuen batura itzuliko digu: 
\family typewriter 
lambda a, b: a+b
\family default 
.
 Lambda egiturak funtzio objetu bat behar direnean bakoitzean erabil daitezke.
 Sintaktikoki adierazpide simple batetara mugaturik daude.
 Funtzio habiaratuak (anidadas) bezala lambda egiturek ezin dute dituen
 esparruko aldagaiei erreferentziarik egin, nahiz eta hori, lehenetsiriko
 argumentuen balioak erabiliz konpondu daitekeen, adibidez:
\layout LyX-Code

def muntatu_gehitzailea(n):
\layout LyX-Code

    return lambda x, gehi=n: x+gehi
\layout Section

Dokumentazio kateak
\layout Standard

Nahiz eta ez den derrigorrezkoa, komenigarria da funtzioen lehen hilaran
 funtzioaren zeregina azalduko digun esaldi labur bat sartzea Maiuskulaz
 hasiz eta '.' puntuz amaituz.
 Funtzio baten dokumentazio katea ikusteko:
\layout LyX-Code

>>> print funtzioizena.__doc__
\layout LyX-Code

Dokumentazio katea.
\layout Chapter

Moduluak
\layout Standard

Python interpretetik irten eta berriz sartzean, lehenxeago eginiko definizioak
 (funtzio eta aldagaiak) galdu egin direla ohartuko zara.
 Horregatik, programa luzeago bat idatzi nahi bada, hobe izango da testu
 editore batetan prestatzea interpreterako sarrera eta fitxategi horrekin
 sarrera moduan exekutatzea.
 Honi gidoi bat sortzea deitzen zaio.
 Gehitzen doazen einean fitxategi gehiagotan banatzea komeniko da hauen
 mantenimendua errazteko.
\layout Standard

Honetarako, Python-ek badu definizioak fitxategi batetan utzi eta gidoi
 batetan edo interpretearen ekinaldi interaktibo batetan erabiltzeko modu
 bat.
 Fitxero hori 
\shape italic 
modulua
\shape default 
 deitzen da; modulu baten funtzioak beste modulu batzuetara edo modulu 
\shape slanted 
nagusi
\shape default 
ra (goragoko mailatik eta kalkulagailu moduan exekutatutako gidoi batetik
 sarbidedun den aldagai bilduma) 
\shape slanted 
inportatu
\shape default 
 daitezke.
\layout Standard

Modulu bat Python sententziak eta definizioak dituen fitxategi bat da.
 Fitxategiaren izena moduluarena izango da 
\series bold 
.py
\series default 
 atzizkiarekin.
 Modulu baten barruan, moduluaren izena (kate bezala) 
\family typewriter 
__name__
\family default 
 aldagai orokorrak emango digu.
 Adibidez, erabili gustokoen duzun testu editorea 
\series bold 
fibo.py
\series default 
 izeneko fitxategi bat sortzeko uneko direktorioan, hurrengo edukinarekin:
\layout LyX-Code

# Fibonacci zenbakien modulua
\layout LyX-Code

\layout LyX-Code

def fib(n):   # n-rainoko Fibonacci seriea idatzi
\layout LyX-Code

    a, b = 0, 1
\layout LyX-Code

    while b < n:
\layout LyX-Code

        print b,
\layout LyX-Code

        a, b = b, a+b
\layout LyX-Code

\layout LyX-Code

def fib2(n):  # n-rainoko Fibonacci seriea itzuli
\layout LyX-Code

    emaitza = []
\layout LyX-Code

    a, b = 0, 1
\layout LyX-Code

    while b < n:
\layout LyX-Code

        emaitza.append(b)
\layout LyX-Code

        a, b = b, a+b 
\layout LyX-Code

    return emaitza
\layout Standard

Orain sartu Python-en interpretean eta importatu modulu hau honela:
\layout LyX-Code

>>> import fibo
\layout Standard

Honekin ez dira 
\family typewriter 
fibo
\family default 
n definituriko funtzioen izenak zuzenean uneko sinboloen taulan sartuko;
 
\family typewriter 
fibo
\family default 
 moduluaren izena bakarrik.
 Moduluaren izena erabiliz erabil ditzakegu funtzioak:
\layout LyX-Code

>>> fibo.fib(1000)
\layout LyX-Code

1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 
\layout LyX-Code

>>> fibo.fib2(100)
\layout LyX-Code

[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
\layout LyX-Code

>>> fibo.__name__ 
\layout LyX-Code

'fibo'
\layout Standard

Funtzio bat askotan erabili behar bada, lekuko izen bati ezarri dakioke:
\layout LyX-Code

>>> fib = fibo.fib 
\layout LyX-Code

>>> fib(500)
\layout LyX-Code

1 1 2 3 5 8 13 21 34 55 89 144 233 377
\layout Section

Moduluei buruz gehiago
\layout Standard

Modulu batek funtzioen definizioez gain, modulua haseratzeko balio duten
 sententziak izan ditzake.
 Hauek inportatzen diren lehenengo aldian bakarrik exekutatuko dira.
\layout Standard

Modulu bakoitzak bere sinbolo-taula du, moduluan definituriko funtzio guztiek
 sinbolo-taula orokor bezala erabiliko dutelarik.
 Ondorioz, modulu baten egileak moduluaren barnean aldagai orokorrak erabili
 ditzake moduluaren erabiltzaile baten aldagai orokorrekin izan ditzakeen
 arazoekin kezkatu gabe.
 Bestalde, modulu baten aldagai orokorrak aldatzeko 
\family typewriter 
modIzena.elemIzena
\family default 
 erabil genezake.
\layout Standard

Moduluek beste modulu batzuk inportatu ditzakete.
 Ez da derrigorrezko ohitura 
\family typewriter 
import
\family default 
 sententzia guztiak modulu (edo gidoiaren) haseran jartzea.
 Inportaturiko moduluaren izenak inportatzen duen modulu orokorraren sinbolo-tau
la orokorrean kokatzen dira.
\layout Standard

Bada 
\family typewriter 
import
\family default 
 sententziaren bariazio bat, non modulu baten izenak inportatzen duen moduluaren
 sinbolo taulara zuzenean inportatzen diren:
\layout LyX-Code

>>> from fibo import fib, fib2 
\layout LyX-Code

>>> fib(500)
\layout LyX-Code

1 1 2 3 5 8 13 21 34 55 89 144 233 377
\layout Standard

Honek ez du sinbolo-taula lokalean inportatu diren elementuen moduluaren
 izena sartuko (adibidean 
\family typewriter 
fibo
\family default 
 ez dago definitua).
\layout Standard

Gainera badago modulu batek definituriko izen guztiak inportatzen dituen
 aldakuntza bat:
\layout LyX-Code

>>> from fibo import *
\layout LyX-Code

>>> fib(500) 
\layout LyX-Code

1 1 2 3 5 8 13 21 34 55 89 144 233 377
\layout Standard

Honek azpi-marrarekin (
\family typewriter 
_
\family default 
) hasten ez diren izen guztiak inportatuko ditu.
\layout Section


\family typewriter 
dir()
\family default 
 funtzioa
\layout Standard


\family typewriter 
dir()
\family default 
 barne-funtzioak modulo batek zein izen zehazten dituen jakiteko erabiltzen
 da.
 Kate zerrenda ordenatu bat itzultzen du:
\layout LyX-Code

>>> import fibo, sys
\layout LyX-Code

>>> dir(fibo) 
\layout LyX-Code

['__name__', 'fib', 'fib2']
\layout LyX-Code

>>> dir(sys)
\layout LyX-Code

['__name__', 'argv', 'builtin_module_names', 'copyright', 'exit',
\layout LyX-Code

    'maxint', 'modules', 'path', 'ps1', 'ps2', 'setprofile', 
\layout LyX-Code

    'settrace', 'stderr', 'stdin', 'stdout', 'version']
\layout Standard

Argumenturik gabe unean (norberak edo sistemak) zehazturiko izen zerrenda
 idazten du:
\layout LyX-Code

>>> a = [1, 2, 3, 4, 5] 
\layout LyX-Code

>>> import fibo, sys
\layout LyX-Code

>>> fib = fibo.fib
\layout LyX-Code

>>> dir()
\layout LyX-Code

['__name__', 'a', 'fib', 'fibo', 'sys']
\layout Standard

Izen mota guztiak erakusten ditu: aldagai, modulu, funtzio, etab.
\layout Standard


\family typewriter 
dir()
\family default 
-ek funtzio eta barne-aldagaien izenik ez du itzuliko.
 Izen hoiek lortzea nahi bada, 
\family typewriter 
__builtin__
\family default 
 modulu estandarrean daude zehaztuta:
\layout LyX-Code

>>> import __builtin__ 
\layout LyX-Code

>>> dir(__builtin__) 
\layout LyX-Code

['AccessError', 'AttributeError', 'ConflictError', 'EOFError',
\layout LyX-Code

    'IOError', 'ImportError', 'IndexError', 'KeyError', 
\layout LyX-Code

    'KeyboardInterrupt', 'MemoryError', 'NameError', 'None',
\layout LyX-Code

    'OverflowError', 'RuntimeError','SyntaxError',
\layout LyX-Code

    'SystemError', 'SystemExit', 'TypeError', 'ValueError',
\layout LyX-Code

    'ZeroDivisionError', '__name__', 'abs', 'apply', 'chr',
\layout LyX-Code

    'cmp', 'coerce', 'compile', 'dir', 'divmod', 'eval',
\layout LyX-Code

    'execfile', 'filter', 'float', 'getattr', 'hasattr', 
\layout LyX-Code

    'hash', 'hex', 'id', 'input', 'int', 'len', 'long',
\layout LyX-Code

    'map', 'max', 'min', 'oct', 'open', 'ord', 'pow', 'range',
\layout LyX-Code

    'raw_input', 'reduce', 'reload', 'repr', 'round', 
\layout LyX-Code

    'setattr', 'str', 'type', 'xrange']
\layout Section

Paketeak
\layout Standard

Paketeak Python-eko moduluen izendatze-formak egituratzeko bidea dira, "modulu
 izenak puntuaz" erabiliz.
 Adibidez 
\family typewriter 
A.B
\family default 
 moduluaren izenak "
\family typewriter 
A
\family default 
" izeneko modulu baten "
\family typewriter 
B
\family default 
" izeneko azpimodulu bati egiten dio erreferentzia.
\layout Standard

Adibide bezala, soinu fitxategi eta soinu datuak lantzeko modulu talde bat
 (paketea) diseinatzea nahi da.
 Soinu fitxategi mota ezberdinak daude (luzapenaz bereiztua, .wab, .aiff edo
 .au) eta ondorioz formatu ezberdinen artean bihurketa moduluen taldea sortu
 eta mantendu beharko genuke.
 Soinu datuen gain eragiketa ezberdinak daude (nahastu, ohiartzuna gehitu,
 ekualizatu edo efektuak sartu), eragiketa hauek burutzeko hainbat modulu
 idazten ari garelarik.
 Hona hemen paketearen egituraketa posible bat:
\layout LyX-Code

Soinua/                          Maila goreneko paketea
\layout LyX-Code

      __init__.py                Soinuen pakatea inizializatu
\layout LyX-Code

      Formatuak/                 Fitxategien formatuen eragiketen
\layout LyX-Code

                                 azpipaketea
\layout LyX-Code

              __init__.py
\layout LyX-Code

              irakurwav.py
\layout LyX-Code

              idatziwav.py
\layout LyX-Code

              irakuraiff.py
\layout LyX-Code

              idatziaiff.py
\layout LyX-Code

              irakurau.py
\layout LyX-Code

              idatziau.py
\layout LyX-Code

              ...
\layout LyX-Code

      Efektuak/                  Soinu efektuen azpipaketea
\layout LyX-Code

              __init__.py
\layout LyX-Code

              ohiartzuna.py
\layout LyX-Code

              surround.py
\layout LyX-Code

              alderantzizkatu.py
\layout LyX-Code

              ...
\layout LyX-Code

      Filtroak/                  Filtroen azpipaketea
\layout LyX-Code

              __init__.py
\layout LyX-Code

              ekualizadorea.py
\layout LyX-Code

              vocoder.py
\layout LyX-Code

              karaoke.py
\layout LyX-Code

              ...
\layout Standard


\series bold 
__init__.py
\series default 
 fitxategiak Python-ek direktorioak paketeen edukiontzi bezala jokatzeko
 beharrezkoak dira.
 Honela izen arruntdun direktorioek, adibidez "
\family typewriter 
test
\family default 
", bilaketa bidean agertzen diren moduluak ustekabez ezkutatzea saiesten
 du.
 
\series bold 
__init__.py
\series default 
 fitxategi huts bat izan daiteke, paketearen inizializazioa landuko duen
 kodea eduki edo 
\series bold 
__all__
\series default 
 aldagaia eguneratu dezake.
\layout Standard

Paketearen erabiltzaileek paketearen modulu bakanak inportatu ditzakete:
\layout LyX-Code

import Soinua.Efektuak.ohiartzuna
\layout Standard

Honela 
\family typewriter 
Soinua.Efektuak.ohiartzuna
\family default 
 azpimodulua kargatu daiteke.
 Izen osoari egin beharko zaio erreferentzia:
\layout LyX-Code

Soinua.Efektuak.ohiartzuna.
\family typewriter 
ohiartzunfiltroa
\family default 
(sarrera, irteera,
\layout LyX-Code

    atzerapena=0.3, aten=5)
\layout Standard

Azpimodulu bat inportatzeko beste modu bat:
\layout LyX-Code

from Soinua.Efektuak import ohiartzuna
\layout Standard

Honela 
\family typewriter 
ohiartzuna
\family default 
 azpimodulua ere kargatu daiteke eta paketearen aurreizena erabili gabe:
\layout LyX-Code

ohiartzuna.
\family typewriter 
ohiartzunfiltroa
\family default 
(sarrera, irteera, atzerapena=0.3, aten=5)
\layout Standard

Nahi den funtzio edo aldagaia zuzenean inportatuz:
\layout LyX-Code

from Soinua.Efektuak.ohiartzuna import 
\family typewriter 
ohiartzunfiltroa
\layout Standard

Berriro kargatuko da 
\family typewriter 
ohiartzuna
\family default 
 azpimodulua baina honela 
\family typewriter 
ohiartzunfiltroa
\family default 
 funtzioa zuzenean erabilgarri dago:
\layout LyX-Code


\family typewriter 
ohiartzunfiltroa
\family default 
(sarrera, irteera, atzerapena=0.3, aten=5)
\layout Standard


\family typewriter 
from
\family default 
 
\shape italic 
paketea
\shape default 
 
\family typewriter 
import
\family default 
 
\shape italic 
elementua
\shape default 
 erabiltzean, elementua paketearen azpimodulua (edo azpipaketea) edo paketeak
 zehazturiko beste edozein izen, funtzio, klase edo aldagai, izan daiteke.
 
\family typewriter 
import
\family default 
 sententziak lehenengo elementua paketearen barruan al dagoen begiratzen
 du.
 Hala ez bada, modulu bat dela pentsatuz kargatzen saiatuko da.
 Lortzen ez badu 
\family typewriter 
ImportError
\family default 
 eszepzioa jaurtiko du.
\layout Standard


\family typewriter 
import
\family default 
 
\shape italic 
elementua.azpielementua.azpiazpielementua
\shape default 
 sintaxia erabiltzean, elementu bakoitza, azkena ez ezik, paketea izango
 da.
 Azken elementua paketea edo modulua izan daiteke baina ez goiko mailan
 zehazturiko funtzio, klase edo aldagaia.
\layout Subsection

Pakete batetik * inportatu
\layout Standard

Eragiketa hau Windows-en ez da oso zuzen ibiltzen fitxategien sistemak ez
 baitu fitxategien miuskulataz ideia zehatzik.
 
\series bold 
OHIARTZUNA.PY
\series default 
 fitxategia ezin dugu jakin 
\series bold 
ohiartzuna
\series default 
, 
\series bold 
Ohiartzuna
\series default 
 edo 
\series bold 
OHIARTZUNA
\series default 
 bezala inportatuko duen.
 DOS-en berriz izen luzedun moduluentzat arazoa da 8 hizkitik ezin baita
 pasatu.
 Berez, 
\family typewriter 
from\SpecialChar ~
Soinua.Efektuak\SpecialChar ~
import\SpecialChar ~
*
\family default 
 landuz paketean dauden azpimodulu denak aurkitu eta denak inportatu beharko
 lituzke.
\layout Standard

Hau konpontzeko paketearen egileak paketeari ezaugarri esplizitu bat ezartzea
 da.
 Import sententziak honako ohitura du: pakete baten 
\series bold 
__init__.py
\series default 
-ren kodeak 
\family typewriter 
\series bold 
__all__
\family default 
\series default 
 izeneko zerrenda bat zehazten badu, 
\family typewriter 
from
\family default 
\shape italic 
\SpecialChar ~
paketea
\family typewriter 
\shape default 
\SpecialChar ~
import\SpecialChar ~
*
\family default 
 aurkitzean inportatu beharreko moduluen izen zerrenda izango da.
 Paketearen bertsio berri bat kaleratzean egilearen esku dago zerrrenda
 hori eguneratzea.
 Adibidez 
\series bold 
Soinua/Efektuak/__init__.py
\series default 
 fitxategiak hurrengo kodea izan lezake:
\layout LyX-Code

__all__ = ["ohiartzuna", "surround", "alderantzizkatu"]
\layout Standard


\series bold 
__all__
\series default 
 zehaztu gabe badago 
\family typewriter 
from\SpecialChar ~
Soinua.Efektuak\SpecialChar ~
import\SpecialChar ~
*
\family default 
 sententziak ez ditu 
\family typewriter 
Soinua.Efektuak
\family default 
 azpipaketeko modulu guztiak inportatuko uneko izendatze gunera.
 
\family typewriter 
Soinua.Efektuak 
\family default 
paketea (haseratze kodea landuz) eta paketean zehazturiko izenak inportatzeaz
 arduratuko da, 
\series bold 
__init__.py
\series default 
-n zehazturiko edozein izen eta lehenagoko inport sententziez inportaturiko
 paketearen edozein azpimodulu inportatzeaz ere bai.
 Adibidez:
\layout LyX-Code

import Soinua.Efektuak.ohiartzuna
\layout LyX-Code

import Soinua.Efektuak.surround
\layout LyX-Code

from Soinua.Efektuak import *
\layout Standard

Adibide honetan ohiartzuna eta surround moduluak uneko izendatze eremura
 inportatuko dira, 
\family typewriter 
Soinua.Efektuak
\family default 
 paketean zehazturik daudelako 
\family typewriter 
from\SpecialChar ~
...\SpecialChar ~
import
\family default 
 sententzia lantzean (
\series bold 
__all__
\series default 
 zehaztua badago ere balio du).
\layout Chapter

Sarrera irteerak
\layout Standard

Programa baten irteerak erakusteko modu ezberdinak daude; gizakiek ulertzeko
 moduan datuak inprimatu edo geroago erabiltzeko fitxategi batean idatzi
 daitezke.
 Kapitulu honetan aukera batzuk ikusiko ditugu.
\layout Section

Irteera formatu hobetua
\layout Standard

Orain arte bi modu ezberdin erabili ditugu balioak idazteko: 
\shape italic 
expresio sententziak
\shape default 
 eta 
\family typewriter 
print
\family default 
 sententzia.
 Hirugarren modu bat ere badago: fitxategi objetuen 
\family typewriter 
write()
\family default 
 metodoa, 
\family typewriter 
sys.stdout
\family default 
-i esker da zilegi.
\layout Standard

Irteerei formatua emateko bi modu daude: lehenengoan norberak eratu beharko
 ditu kateak, mozketa eta elkarketak erabilz.
 
\family typewriter 
string
\family default 
 modulu estandarrak baditu kateak zutabe zabalera jakin batzuetara egokitzeko
 eragiketak.
 Bigarrengo modua 
\family typewriter 
%
\family default 
 operadorea ezker argumentu bezala kate batekin erabiltzea litzateke.
 
\family typewriter 
%
\family default 
 operadoreak ezker argumentua C-ko 
\family typewriter 
sprintf()
\family default 
 formatu estiloko kate bat bezala azalduko du eta eskuin argumentuari aplikatu
 beharko zaio formatuaren emaitz katea itzultzeko.
\layout Standard

Python-ek balioak kateetara itzultzeko repr() funtzioa du, edo komatxo simple
 alderantzizkatu artean idatziz balioa.
 Adibide batzuk:
\layout LyX-Code

>>> x = 10 * 3.14
\layout LyX-Code

>>> y = 200*200 
\layout LyX-Code

>>> s = '"x"-en balioa: ' + `x` + ' eta "y"-rena ' + `y` + '...' 
\layout LyX-Code

>>> print s 
\layout LyX-Code

"x"-en balioa: 31.4 eta "y"-rena 40000...
 
\layout LyX-Code

>>> # Komatxo alderantzizkatuek zenbakiez gain beste mota batzuei
\layout LyX-Code


\hfill 
ere eragiten die:
\layout LyX-Code

...
 p = [x, y]
\layout LyX-Code

>>> ps = repr(p)
\layout LyX-Code

>>> ps 
\layout LyX-Code

'[31.4, 40000]' 
\layout LyX-Code

>>> # Katera itzultzeak kateei komatxo eta alderantzizko barrak 
\layout LyX-Code


\hfill 
gehitzen dizkie:
\layout LyX-Code

...
 kaixo = 'kaixo mundua
\backslash 
n'
\layout LyX-Code

>>> katkaixo = `kaixo` 
\layout LyX-Code

>>> print cadhola
\layout LyX-Code

'kaixo mundua
\backslash 
012'
\layout LyX-Code

>>> # Komatxo alderantzizkatuen argumentu tupla bat ere izan daiteke: 
\layout LyX-Code

...
 `x, y, ('euria', 'elurra')`
\layout LyX-Code

"(31.4, 40000, ('euria', 'elurra'))"
\layout Standard

Hona hemen karratu eta kuboak idatziko dituzten bi modu:
\layout LyX-Code

>>> import string 
\layout LyX-Code

>>> for x in range(1, 11): 
\layout LyX-Code

...
     print string.rjust(`x`, 2), string.rjust(`x*x`, 3), 
\layout LyX-Code

...
     # Ohar zaitez aurreko lerroko amaierako komaz 
\layout LyX-Code

...
     print string.rjust(`x*x*x`, 4) 
\layout LyX-Code

...
  
\layout LyX-Code

 1   1    1  
\layout LyX-Code

 2   4    8 
\layout LyX-Code

 3   9   27 
\layout LyX-Code

 4  16   64 
\layout LyX-Code

 5  25  125 
\layout LyX-Code

 6  36  216
\layout LyX-Code

 7  49  343 
\layout LyX-Code

 8  64  512
\layout LyX-Code

 9  81  729
\layout LyX-Code

10 100 1000
\layout LyX-Code

>>> for x in range(1,11):
\layout LyX-Code

...
     print '%2d %3d %4d' % (x, x*x, x*x*x)
\layout LyX-Code

...
 
\layout LyX-Code

 1   1    1 
\layout LyX-Code

 2   4    8 
\layout LyX-Code

 3   9   27
\layout LyX-Code

 4  16   64
\layout LyX-Code

 5  25  125 
\layout LyX-Code

 6  36  216  
\layout LyX-Code

 7  49  343 
\layout LyX-Code

 8  64  512 
\layout LyX-Code

 9  81  729 
\layout LyX-Code

10 100 1000
\layout Standard


\family typewriter 
print
\family default 
-ek bere argumentuen artean zuriune bat gehitzen du.
 Adibide honetan 
\family typewriter 
string.rjust()
\family default 
 erabili da katea eskubiruntz egokitzeko ezkerraldean zuriuneak gehituz,
 
\family typewriter 
string.ljust()
\family default 
 eta 
\family typewriter 
string.center()
\family default 
 ere erabili genitzazke.
 
\family typewriter 
string.zfill()
\family default 
 zenbakizko katea ezker aldetik zeroz betetzeko erabiliko da:
\layout LyX-Code

>>> import string 
\layout LyX-Code

>>> string.zfill('12', 5) 
\layout LyX-Code

'00012' 
\layout LyX-Code

>>> string.zfill('-3.14', 7)
\layout LyX-Code

'-003.14'
\layout LyX-Code

>>> string.zfill('3.14159265359', 5) 
\layout LyX-Code

'3.14159265359'
\layout Standard


\family typewriter 
%
\family default 
 operadorearen erabilera:
\layout LyX-Code

>>> import math
\layout LyX-Code

>>> print 'PI-ren balioa gutxigorabehera: %5.3f.' % math.pi 
\layout LyX-Code

PI-ren balioa gutxigorabehera: 3.142.
\layout Standard

Katean formatu bat baino gehiago badago, tupla bat pasa beharko zaio eskuin
 eragingai bezala:
\layout LyX-Code

>>> taula = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 7678}
\layout LyX-Code

>>> for izena, telef in taula.items():
\layout LyX-Code

...
     print '%-10s ==> %10d' % (izena, telef) 
\layout LyX-Code

...
  
\layout LyX-Code

Jack       ==>       4098
\layout LyX-Code

Dcab       ==>       7678
\layout LyX-Code

Sjoerd     ==>       4127
\layout Standard

Formatu gehienek C-n bezala jokatzen dute eta modu zehatza pasa beharko
 zaie, horrela ez bada exzepzio jaurtiko da.
 
\family typewriter 
%s
\family default 
-ri ordea ez badiogu kate bat bidaltzen 
\family typewriter 
str()
\family default 
 barne-funtzioa erabiliz katera itzuliko du.
 
\family typewriter 
*
\family default 
 argumentu (osoa) bezala pasatuz gero zabalera edo zehaztasuna adierazi
 genezake.
\layout Standard

Oso luzea den eta banatzea nahi ez den formatuko katea izatean, aldagaiei
 erreferentzia bere izenez egitea komeni da, hau lortzeko 
\family typewriter 
%(izena)formatua
\family default 
 erabil daiteke:
\layout LyX-Code

>>> tabla = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}
\layout LyX-Code

>>> print 'Jack: %(Jack)d; Sjoerd: %(Sjoerd)d; Dcab: %(Dcab)d' % tabla
\layout LyX-Code

Jack: 4098; Sjoerd: 4127; Dcab: 8637678
\layout Section

Fitxategien idazketa eta irakurketa
\layout Standard


\family typewriter 
open()
\family default 
-ek fitxategi objetu bat itzuliko digu.
 Bi argumenturekin erabili ohi da: 
\family typewriter 

\newline 
open(
\shape italic 
fitxategiIzena
\shape default 
,
\shape italic 
modua
\shape default 
)
\family default 
.
\layout LyX-Code

>>> f=open('C:/fitxategiizena', 'w') 
\layout LyX-Code

>>> print f 
\layout LyX-Code

<open file 'C:/fitxategiizena', mode 'w' at 80a0960>
\layout Standard

Lehen argumentuak fitxategiaren izena izango du eta bigarrenak fitxategi
 hau erabiliko den modua.
 Modua '
\family typewriter 
r
\family default 
' (ikakurtzeko bakarrik), '
\family typewriter 
w
\family default 
' (idazteko bakarrik, izen bereko beste bat badago ezabatu egingo du) eta
 '
\family typewriter 
a
\family default 
' (fitxategiari zerbait gehitzeko) izan daiteke.
 '
\family typewriter 
a
\family default 
' moduan idazten den edozer lehendik dauden datuen atzetik idatziko da.
 Fitxategiaren izena bakarrik pasatuz gero argumentu bezala, '
\family typewriter 
r
\family default 
' moduan irekiko du.
\layout Standard

Windows eta Macintosh-en moduari '
\family typewriter 
b
\family default 
' gehituz fitxategia modu bitarrean irekiko du, ondorioz '
\family typewriter 
rb
\family default 
', '
\family typewriter 
wb
\family default 
' edo '
\family typewriter 
r+b
\family default 
' moduak existitzen dira.
 Windows-ek testu-fitxategi eta fitxategi-bitarren artean ezberdintasunak
 ditu: fitxategien lerro amaierako karaktereak arinki aldatuak izango dira
 automatikoki, irakurtzean edo datuak idaztean.
 Ezkutuko aldaketa hauek ASCII testudun fitxategien gain ez dute eraginik,
 modu bitarreko (JPEG edo .EXE) fitxategiek ez bezala.
\layout Subsection

Fitxategi objetuen metodoak
\layout Subsubsection*

read(
\shape italic 
kopurua
\shape default 
)
\layout Standard

Fitxategitik datu kopuru bat irakurri eta kate bezala itzuliko ditu.
 
\shape italic 
Kopurua
\shape default 
 argumentua aukeakoa da, honen faltan edo negatiboa bada, fitxategi osoa
 irakurriko du.
 Argumentua positiboa bada gehienez byte kopuru hori irakurri eta itzuliko
 du.
 Iada fitxategi amaierara iritsi bada kate hutsa ("") itzuliko du.
\layout LyX-Code

>>> f.read() 
\layout LyX-Code

'Hau da fitxategi osoa.
\backslash 
012'
\layout LyX-Code

>>> f.read()
\layout LyX-Code

''
\layout Subsubsection*

readline()
\layout Standard

Fitxategiko lerro bakarra irakurtzen du.
 Katearen bukaeran lerro aldaketako karaktere bat (
\family typewriter 

\backslash 
n
\family default 
) uzten da, azken lerroan bakarrik kentzen delarik, beti ere fitxategia
 lerro-jauzi batean amaitzen ez bada.
 
\family typewriter 
readline()
\family default 
-ek kate hutsa itzultzen badigu fitxategia amaierara iritsi dela esan nahi
 du eta fitxategiko lerro hutsa, lerro-jauzia bakarrik duena, '
\family typewriter 

\backslash 
n
\family default 
' bitartez adieraziko da.
\layout LyX-Code

>>> f.readline() 
\layout LyX-Code

'Fitxategiaren lehen lerroa.
\backslash 
012'
\layout LyX-Code

>>> f.readline()
\layout LyX-Code

'Fitxategiaren bigarren lerroa.
\backslash 
012'
\layout LyX-Code

>>> f.readline() 
\layout LyX-Code

''
\layout Subsubsection*

readlines()
\layout Standard

Fitxategiaren lerro guztiak dituen zerrenda bat itzuliko digu.
 Nahi izanez gero 
\shape italic 
sizehint
\shape default 
 parametroa pasa geniezaiokegu, byte kopuru hori irakurriko du eta lerroa
 amaitu arte jarraitu, itzuliko dizkigun lerroak osorik egongo dira.
\layout LyX-Code

>>> f.readlines() 
\layout LyX-Code

['Fitxategiaren lehen lerroa.
\backslash 
012', 'Fitxategiaren bigarren lerroa.
\backslash 
012']
\layout Subsubsection*

write(
\shape italic 
katea
\shape default 
)
\layout Standard


\shape italic 
Katea
\shape default 
ren edukia fitxategian idatzi eta 
\family typewriter 
None
\family default 
 itzuliko du.
\layout LyX-Code

>>> f.write('Frogak egiten...
\backslash 
n')
\layout Subsubsection*

tell()
\layout Standard

Fitxategian fitxategi objetuak duen posizioa itzultzen du, honen haseratik
 bytetan nehurtua.
\layout Subsubsection*

seek(
\shape italic 
desplazamendua, nondik
\shape default 
)
\layout Standard

Fitxategi objetuaren posizioa aldatzeko erabiltzen da, 
\shape italic 
nondik
\shape default 
 argumentua hasera bezala hartuta 
\shape italic 
desplazamendua
\shape default 
 aplikatuz lortzen den posiziora.
 
\shape italic 
nondik
\shape default 
 0 erabiliz fitxategi haseratik hasiko da kontatzen, 1 erabiliz uneko posiziotik
 eta 2 erabiliz fitxategi amaiera hartuko da erreferentzi bezala.
\layout LyX-Code

>>> f=open('/tmp/fichTrabajo', 'r+') 
\layout LyX-Code

>>> f.write('0123456789abcdef') 
\layout LyX-Code

>>> f.seek(5)     # Fitxategiaren 5.
 bytera joan
\layout LyX-Code

>>> f.read(1)         
\layout LyX-Code

'5'
\layout LyX-Code

>>> f.seek(-3, 2) # Amaiera aurretik hirugarren bytera joan
\layout LyX-Code

>>> f.read(1) 
\layout LyX-Code

'd'
\layout Subsubsection*

close()
\layout Standard

Fitxategiaren erabilera amaitzean hau isteko eta sistemaren errekurtsoak
 askatzeko erabiltzen da.
 
\family typewriter 
close()
\family default 
 egin ostean fitxategi objetua erabiltzeko saiakera guztiek huts egingo
 dute.
\layout LyX-Code

>>> f.close()
\layout LyX-Code

>>> f.read()
\layout LyX-Code

Traceback (innermost last):
\layout LyX-Code

  File "<stdin>", line 1, in ? 
\layout LyX-Code

ValueError: I/O operation on closed file
\layout Subsection


\family typewriter 
pickle
\family default 
 modulua
\layout Standard

Fitxategietan kateak ez diren datu mota ezberdinak erabilera errazteko modulua
 da.
 Python-eko ia edozein objetu hartu eta kate modura pasatzen ditu.
 Prozesu honi 
\shape italic 
zamatzea
\shape default 
 deitzen zaio, eta kontrako prozesuari 
\shape italic 
arintzea
\shape default 
.
 Zamatze eta arintzearen artean, objetua irudikatzen duen katea fitxategi
 batean, memorian gorde edo sare konexio baten bitartez hurruneko makina
 batetara bidali ahal izango da.
\layout Standard


\family typewriter 
x
\family default 
 objetu bat eta 
\family typewriter 
f
\family default 
 lehendik idazteko moduan irekitako fitxategi bat baditugu objetua zamatzeko:
\layout LyX-Code

pickle.dump(x, f)
\layout Standard

Eta arintzeko:
\layout LyX-Code

x = pickle.load(f)
\layout Section*

Adibidea:
\layout Standard

Hiztegien ataleko adibide berbera da, baina telefono zenbakiak fitxategi
 batetan gorde edo idazteko gaitasunarekin:
\layout LyX-Code

#
\layout LyX-Code

# Zenbakiakfitx.py fitxategiaren hasera
\layout LyX-Code

#
\layout LyX-Code

import string
\layout LyX-Code

\layout LyX-Code

egia = 1
\layout LyX-Code

gezurra = 0
\layout LyX-Code

\layout LyX-Code

def erakutsi(zenbakiak):
\layout LyX-Code

    print "Telefono zenbakiak:"
\layout LyX-Code

    for x in zenbakiak.keys():
\layout LyX-Code

        print "Izena: ",x," 
\backslash 
tZenbakia: ",zenbakiak[x]
\layout LyX-Code

    print
\layout LyX-Code

\layout LyX-Code

def gehitu(zenbakiak,izena,zenbakia):
\layout LyX-Code

    zenbakiak[izena] = zenbakia
\layout LyX-Code

\layout LyX-Code

def bilatu(zenbakiak,izena):
\layout LyX-Code

    if zenbakiak.has_key(izena):
\layout LyX-Code

        return "Zenbakia: "+zenbakiak[izena]
\layout LyX-Code

    else:
\layout LyX-Code

        return "Ezin izan dut aurkitu "+izena
\layout LyX-Code

\layout LyX-Code

def ezabatu(zenbakiak,izena):
\layout LyX-Code

    if zenbakiak.has_key(izena):
\layout LyX-Code

        del zenbakiak[izena]
\layout LyX-Code

    else:
\layout LyX-Code

        print "Ezin izan dut aurkitu ", izena
\layout LyX-Code

\layout LyX-Code

def kargatu(zenbakiak,fitxizena):
\layout LyX-Code

    fitx_sarrera = open(fitxizena,"r")
\layout LyX-Code

    while egia:
\layout LyX-Code

        sarrera = fitx_sarrera.readline()
\layout LyX-Code

        if sarrera == "":
\layout LyX-Code

            break
\layout LyX-Code

        sarrera = sarrera[:-1]
\layout LyX-Code

        [izena,zenbakia] = string.split(sarrera,",")
\layout LyX-Code

        zenbakiak[izena] = zenbakia
\layout LyX-Code

    fitx_sarrera.close()
\layout LyX-Code

\layout LyX-Code

def gorde(zenbakiak,fitxizena):
\layout LyX-Code

    fitx_irteera = open(fitxizena,"w")
\layout LyX-Code

    for x in zenbakiak.keys():
\layout LyX-Code

        fitx_irteera.write(x+","+zenbakiak[x]+"
\backslash 
n")
\layout LyX-Code

    fitx_irteera.close()
\layout LyX-Code

\layout LyX-Code

def menua():
\layout LyX-Code

    print
\layout LyX-Code

    print '1.
 Zenbakiak ikusi'
\layout LyX-Code

    print '2.
 Zenbaki bat gehitu'
\layout LyX-Code

    print '3.
 Zenbaki bat ezabatu'
\layout LyX-Code

    print '4.
 Zenbaki bat bilatu'
\layout LyX-Code

    print '5.
 Zenbakiak kargatu'
\layout LyX-Code

    print '6.
 Zenbakiak gorde'
\layout LyX-Code

    print '7.
 Irten'
\layout LyX-Code

    print
\layout LyX-Code

\layout LyX-Code

telzerrenda = {}
\layout LyX-Code

aukera= 0
\layout LyX-Code

while aukera!= 7:
\layout LyX-Code

    menua()
\layout LyX-Code

    aukera = input("Zer nahi duzu egitea? ")
\layout LyX-Code

    if aukera == 1:
\layout LyX-Code

        erakutsi(telzerrenda)
\layout LyX-Code

    elif aukera == 2:
\layout LyX-Code

        print "Sartu izena eta zenbakia"
\layout LyX-Code

        izena = raw_input("Izena:")
\layout LyX-Code

        zenbakia = raw_input("Zenbakia:")
\layout LyX-Code

        gehitu(telzerrenda,izena,zenbakia)
\layout LyX-Code

    elif aukera == 3:
\layout LyX-Code

        print "Ezabatu izena eta zenbakia"
\layout LyX-Code

        izena = raw_input("Izena:")
\layout LyX-Code

        ezabatu(telzerrenda,izena)
\layout LyX-Code

    elif aukera == 4:
\layout LyX-Code

        print "Bilatu zenbakia"
\layout LyX-Code

        izena = raw_input("Izena:")
\layout LyX-Code

        print bilatu(telzerrenda,izena)
\layout LyX-Code

    elif aukera == 5:
\layout LyX-Code

        fitxizena = raw_input("Kargatzeko fitxategia:")
\layout LyX-Code

        kargatu(telzerrenda,fitxizena)
\layout LyX-Code

    elif aukera == 6:
\layout LyX-Code

        fitxizena = raw_input("Gordetzeko fitxategia:")
\layout LyX-Code

        gorde(telzerrenda,fitxizena)
\layout LyX-Code

    elif aukera == 7:
\layout LyX-Code

        pass
\layout LyX-Code

    else:
\layout LyX-Code

        menua()
\layout LyX-Code

print "Agur ta hurrenarte"
\layout LyX-Code

# Zenbakiakfitx.py fitxategiaren amaiera
\layout Chapter

Erroreak eta eszepzioak
\layout Standard

Badira (gutxienez) bi errore mota ezberdin: 
\shape italic 
sintaxi erroreak
\shape default 
 eta 
\shape italic 
eszepzioak
\shape default 
.
\layout Section

Sintaxi erroreak
\layout Standard

Interprete sintaktikoak akatsa izan duen lerroa errepikatuko du errorea
 eman deneko lehen puntua gezitxo batez seinalatuko du.
 Errorearen arrazoia gezitxoaren aurreko sinboloan egongo da:
\layout LyX-Code

>>> while 1 print 'Iepa mundua!'
\layout LyX-Code

  File "<stdin>", line 1
\layout LyX-Code

    while 1 print 'Iepa mundua!'
\layout LyX-Code

                ^ 
\layout LyX-Code

SyntaxError: invalid syntax
\layout Standard

Adibide honetan, errorea 
\family typewriter 
print
\family default 
 hitz-gakoan antzeman da, honen aurretik bi puntu (
\family typewriter 
:
\family default 
) falta direlako.
 Fitxategiaren izena eta lerro zenbakia erakusten ditu non bilatu jakiteko,
 sarrera fitxategi batetik etorriz gero.
\layout Section

Eszepzioak
\layout Standard

Nahiz eta sententzia edo espresio bat sintaktikoki zuzen egon, hau exekutatzean
 errore bat sortu liteke.
 Exekuzioan sortzen diren erroreak eszepzioak deitzen dira eta ez dira derrigorr
ez itzulezinak.
 Harrapatu ez diren eszepzioek ondorengoa bezalako errore mezuak sortzen
 dituzte:
\layout LyX-Code

>>> 10 * (1/0)
\layout LyX-Code

Traceback (most recent call last):
\layout LyX-Code

  File "<stdin>", line 1, in ?
\layout LyX-Code

ZeroDivisionError: integer division or modulo by zero
\layout LyX-Code

>>> 4 + fantomas*3
\layout LyX-Code

Traceback (most recent call last):
\layout LyX-Code

  File "<stdin>", line 1, in ?
\layout LyX-Code

NameError: name 'fantomas' is not defined
\layout LyX-Code

>>> '2' + 2
\layout LyX-Code

Traceback (most recent call last):
\layout LyX-Code

  File "<stdin>", line 1, in ?
\layout LyX-Code

TypeError: cannot concatenate 'str' and 'int' objects
\layout Standard

Errore mezuaren azken lerroak zer gertatu den azaltzen du.
 Eszepzioak mdu ezberdinetakoak izan daitezke eta mezuaren zati bezala azalduko
 dira, adibideetakoak: 
\family typewriter 
ZeroDivisionError
\family default 
, 
\family typewriter 
NameError
\family default 
 eta 
\family typewriter 
TypeError.
 
\family default 
Eszepzio estandarren izenak barne-identifikadoreak dira (ez hitz-erreserbatuak).
\layout Section

Eszepzioen kudeaketa
\layout Standard

Hurrengo adibidean erabiltzaileak zenbaki bat sartu arte datuak eskatzen
 jarraituko du:
\layout LyX-Code

>>> while 1:
\layout LyX-Code

...
     try: 
\layout LyX-Code

...
         x = int(raw_input("Sartu zenbaki bat: "))
\layout LyX-Code

...
         break 
\layout LyX-Code

...
     except ValueError: 
\layout LyX-Code

...
         print "Ez da zenbakia.
 Saiatu berriro..."
\layout LyX-Code

...
\layout Standard


\family typewriter 
try
\family default 
 sententziaren erabilera:
\layout Itemize

Lehenengo 
\shape italic 
try klausula
\shape default 
 (
\family typewriter 
try
\family default 
 eta 
\family typewriter 
except
\family default 
-en arteko sententziak) exekutatuko da.
\layout Itemize

Eszepziorik jaurtitzen ez bada 
\shape italic 
except klausula
\shape default 
 ez da landuko eta 
\family typewriter 
try
\family default 
 sententziaren exekuzioa amaitu egingo da.
\layout Itemize

Try klausula lantzen ari den bitartean eszepzio bat jaurtitzen bada klausulatik
 zuzenaen saltatu egingo du.
 Ondoren 
\family typewriter 
except
\family default 
 hitz-gakoaren ondoren aipatzen den eszepzio motarekin bat baldin badator
 bere mota except klausula exekutatuko da eta exekuzioak 
\family typewriter 
try
\family default 
 sententziaren atzetik jarraituko du.
\layout Itemize

Except klausulan aipaturiko eszepzioarekin bat ez datorren eszepzio bat
 jaurtitzen bada kanpotik habituriko 
\family typewriter 
try
\family default 
 sententzitara joko du.
 Eszepzio kudeatzailerik aurkitzen ez bada 
\shape italic 
ezusteko eszepzio
\shape default 
 bilakatzen da eta exekuzioa lehen ikusi dugun moduko mezu batekin amaituko
 da.
\layout Standard


\family typewriter 
try
\family default 
 sententziak except klausula bat baino gehiago izan ditzake, eszepzio ezberdinak
 harrapatzeko.
 Eszepzio batentzat kudeatzaile bakarra exekutatzen da.
 Kudeatzaileek kasuan kasuko try klausulan saltatzen duten eszepzioak bakarrik
 harrapatzen dituzte, ez 
\family typewriter 
try
\family default 
 sententzia bereko beste kudeatzaileetan.
 Try klausula batek eszepzio bat baino gehiago harrapatu ditzake, zerrenda
 baten izendatuz:
\layout LyX-Code

...
 except (RuntimeError, TypeError, NameError):
\layout LyX-Code

...
     pass
\layout Standard

Azken except klausulak ez du zertan eszepziorik izendatu behar, honela edozein
 eszepzio harrapatu dezakelarik.
 Errore mezu bat erakusteko eta eszepzioa berriro jaurtitzeko (hotsegiten
 duenetariko batek kudeatuko duelarik eszepzioa) erabili daiteke.
\layout LyX-Code

import string, sys
\layout LyX-Code

try:
\layout LyX-Code

    f = open('fitxategia.txt')
\layout LyX-Code

    s = f.readline()
\layout LyX-Code

    i = int(string.strip(s))
\layout LyX-Code

except IOError, (errno, strerror):
\layout LyX-Code

    print "S/I errorea(%s): %s" % (errno, strerror) 
\layout LyX-Code

except ValueError:
\layout LyX-Code

    print "Ezin izan dira datuk osora itzuli." 
\layout LyX-Code

except:
\layout LyX-Code

    print "Errore ezezaguna:", sys.exc_info()[0]
\layout LyX-Code

    raise
\layout Standard


\family typewriter 
try ...
 except
\family default 
 sententziak aukerazko else klausula du, except klausularen ondoren azalduko
 da.
 Try klausulak eszepziorik jaurtzitzen ez duen kasuan erabiltzen da:
\layout LyX-Code

for arg in sys.argv[1:]:
\layout LyX-Code

    try:
\layout LyX-Code

        f = open(arg, 'r')
\layout LyX-Code

    except IOError:
\layout LyX-Code

        print 'Ezin da ireki', arg
\layout LyX-Code

    else:
\layout LyX-Code

        print arg, '-ek', len(f.readlines()), 'lerro ditu'
\layout LyX-Code

        f.close()
\layout Standard

Eszepzio bat saltatzean, 
\shape italic 
eszepzioaren argumentu
\shape default 
 bezala ezagutzen den balio elkartu bat izango du.
 Balio hau izan edo ez eta honen mota eszepzio motaren gain daude.
 Argumentu hau duten eszepzioetan except klausulak eszepzio izenaren (edo
 zerrendaren) ondoren aldagai bat adierazi dezake eta argumentuaren balioa
 jasoko du:
\layout LyX-Code

>>> try: 
\layout LyX-Code

...
     fantomas() 
\layout LyX-Code

...
 except NameError, x:
\layout LyX-Code

...
     print x
\layout LyX-Code

...
\layout LyX-Code

name 'fantomas' is not defined
\layout Standard

Harrapatu ez den eszepzio batek argumentua badu errore mezuaren amaieran
 azalduko da.
\layout Standard

Eszepzio kudeatzaileek ez dituzte try klaulan jaurti direlako bakarrik kudeatuko
, try klausulan deitzen (zuzenean edo zeharka) zaien funtzioetan saltatzen
 badute ere kudeatuko dituzte.
 Adibidez:
\layout LyX-Code

>>> def fun():
\layout LyX-Code

...
     x = 1/0 
\layout LyX-Code

...
  
\layout LyX-Code

>>> try:
\layout LyX-Code

...
     fun() 
\layout LyX-Code

...
 except ZeroDivisionError, xehetasuna: 
\layout LyX-Code

...
     print 'Errore kudeaketa:', xehetasuna
\layout LyX-Code

...
  
\layout LyX-Code

Errore kudeaketa: integer division or modulo by zero
\layout Section

Eszepzioak jaurtiarazi
\layout Standard


\family typewriter 
raise
\family default 
 (saltarazi) sententzia erabiliz programatzaileak eszepzio bat azalduarazi
 dezake.
 Adibidez:
\layout LyX-Code

>>> raise NameError, 'Atsaldeon'
\layout LyX-Code

Traceback (most recent call last):
\layout LyX-Code

  File "<stdin>", line 1, in ? 
\layout LyX-Code

NameError: Atsaldeon
\layout LyX-Code

\layout Section

Erabiltzaileak zehazturiko eszepzioak
\layout Standard

Programek beraien eszepzioak izendatu ditzakete aldagai bat kate bat asignatuz
 edo eszepzio mota berri bat sortuz.
 Adibidez:
\layout Standard

Lehen argumentuak zein eszepzio jaurti behar duen adierazten du eta bigarrenak
 (aukerazkoa) eszepzioaren argumentua.
\layout LyX-Code

>>> class NireErrorea:
\layout LyX-Code

...
     def __init__(self, balioa):
\layout LyX-Code

...
         self.valor = balioa 
\layout LyX-Code

...
     def __str__(self):
\layout LyX-Code

...
         return `self.balioa`
\layout LyX-Code

...
 
\layout LyX-Code

>>> try:
\layout LyX-Code

...
     raise raise NireErrorea(2*2) 
\layout LyX-Code

...
 except NireErrorea, e: 
\layout LyX-Code

...
     print 'Nire eszepzioak saltatu du, balioa:', e.balioa
\layout LyX-Code

...
 
\layout LyX-Code

Nire eszepzioak saltatu du, balioa: 4
\layout LyX-Code

>>> raise mi_exc, 1 
\layout LyX-Code

Traceback (innermost last):
\layout LyX-Code

  File "<stdin>", line 1
\layout LyX-Code

mi_exc: 1
\layout Section

Garbiketa ekintzak
\layout Standard

Edozein momentutan exekutatuko beharko diren garbiketa ekintzak zehazteko
 balio duen aukerazko beste klausula bat du 
\family typewriter 
try
\family default 
 sententziak:
\layout LyX-Code

>>> try: 
\layout LyX-Code

...
     raise KeyboardInterrupt 
\layout LyX-Code

...
 finally:
\layout LyX-Code

...
     print 'Aio danoi!'
\layout LyX-Code

...
\layout LyX-Code

Aio danoi!
\layout LyX-Code

Traceback (most recent call last):
\layout LyX-Code

  File "<stdin>", line 2, in ?
\layout LyX-Code

KeyboardInterrupt
\layout Standard

Finally klausula beti (eszepzioak jaurti edo ez) exekutatuko da.
 
\family typewriter 
try
\family default 
 sententzia 
\family typewriter 
break
\family default 
 edo 
\family typewriter 
return
\family default 
 erabiliz uzten bada ere finally exekutatu egingo da.
\layout Standard

try sententzia batek except klausula bat edo gehiago edo finally klausula
 eduki beharko du, baina ez biak.
\layout Chapter

Klaseak
\layout Standard

Python-en, C++-eko terminologia erabiliz, klaseko atalak (datuak barne)
 
\shape italic 
public
\shape default 
oak dira eta atal funtzio guztiak 
\shape italic 
virtual
\shape default 
ak.
 Ez dago eraikitzaile eta destruktore berezirik.
 Metodo funtzioa, objetua adierazten duen lehen argumentu esplizituarekin
 zehazten da eta funtzioari inplizituki deitzen laguntzen du.
 Klaseak objetuak dira, Python-en datu mota guztiak diren bezala.
 "Objetu" hitzak ez du derrigorrez klase baten instantzia denik esan nahi.
 Nahiz eta datu mota guztiak ez diren klaseak (fitxategi, zerrenda edo osoak),
 denek dute semantika zati bat berdina.
 Sintaxi berezia duten barne operadore gehienak klaseetan birzehaztu daitezke.
\layout Standard

Objetuek banakotasuna dute.
 Izen bat baino gehiago izan ditzake objetu batek, "alias"ak sortzea deitzen
 zaio honi beste hizkuntza batzuetan.
 Kasu batzutan alias-as erakusle bezala jokatzen dute.
 Adibidez, objetu bat pasatzea erraza da, erakuslea bakarrik pasatzen baita.
 Funtzioak argumentu bezala pasatako objetua aldatzen badu, funtzioari deitzen
 dionak ikusiko ditu aldaketok.
\layout Section

Izen eremu eta esparruak
\layout Standard

Klaseen erabilera ulertzeko beharrezkoa da izen taldeek nola jokatzen duten
 jakitea.
\layout Standard

Izen eremu bat izenak eta objetuen arteko egokitzapena da.
 Gehienak hiztegi bezala inplementatzen dira.
 Izen eremuen adibideak:
\layout Itemize

Barne izen taldeak (
\family typewriter 
abs()
\family default 
 bezalako funtzioak eta barne eszepzioak).
\layout Itemize

Modulu baten izen orokorrak.
\layout Itemize

Izen lokalak funtzio bati deitzean.
\layout Standard

Objetu baten atributuen (puntu baten atzetik datorren edozein izen.
 Adibidez, z.erreala adierazpenean erreala z objetuaren atributu bat da)
 taldeek ere izen esparru bat osatzen dute.
 Izen eremuetan ez dago inungo erlaziorik eremu ezberdinetako izenen artean,
 bi moduluk izen bereko funtzioak zehaztu ditzakete nahasteko arriskurik
 gabe (izena moduluaren izenaren ondoren baitator).
 
\layout Standard

Atributuak soilik irakurtzeko edo irakurri/idaztezko izan daitezke.
 Atributuei balioak asignatu dakizkiokete.
 Moduluen atributuak irakurri/idazteko dira eta 
\family typewriter 
del
\family default 
 sententzia erabiliz ezabatu daitezke.
\layout Standard

Izen eremuak momentu ezberdinetan sortzen dira eta bizi-denbora ezberdina
 dute.
 Barne izenak dituen izen eremua Python interpretea abiaraztean sortzen
 da eta ez da ezabatzen.
 Modulu baten izen eremu orokorra moduluaren definizioa irakurtzean sortuko
 da eta interpretetik irten arte iraungo dute.
 Eta funtzio baten izen eremua funtzioari deitzean sortu eta irtetean ezabatuko
 da.
 Deitura errekurtsiboek bakoitzak bere izen eremua sortuko du.
\layout Standard

Esparru bat (
\shape italic 
ambito
\shape default 
) Python programa baten gune testual bat da, non izen eremuara zuzenean
 iritsi daiteken.
 Kontestu honetan kalifikatu gabeko (punturik gabe) izen bat izen eremuan
 bilatzen saiatuko da.
\layout Standard

Nahiz eta esparruak estatikoki finkatzen diren, dinamikoki erabiltzen dira.
 Exekuzioaren edozein puntutan hiru esparru habitu daude, zuzenean heldu
 daitezken hiru izen eremu: barne esparrua (lehenengo hemen bilatzen da
 izena, izen lokalak ditu), erdiko esparrua (hemen jarraituko du bilaketa,
 moduluaren izen orokorrak izango ditu) eta kanpo esparrua (bilaketan azkena,
 barne izenak ditu).
\layout Standard

Esparru lokalak lantzen ari den funtzioaren izenak edukiko ditu.
 Funtzioetatik kanpo, esparru lokalak esparru orokorraren izen eremu berari
 egiten dio erreferentzia: moduluaren izen eremua.
 Klaseen definizioek esparru lokalean beste izen eremu bat hartzen dute.
\layout Standard

Modulu baten zehazturiko funtzio baten esparru orokorra modulu beraren izen
 eremua da.
 Bestalde, izenen benetako bilaketa dinamikoki egiten da, exekuzio garaian.
 Baina hizkuntzaren definizioak izenen ebazpen estatikora garamatza.
\layout Standard

Asignazioak beti barnekoeneko esparruan doaz.
 Asignazioek ez dute daturik kopiatzen, soilik izenak objetuei estekatzen
 dizkie eta berdin ezabatzean (
\family typewriter 
del\SpecialChar ~
x
\family default 
 sententziak 
\family typewriter 
x
\family default 
-en esparru lokalak erreferentzia egiten dion izen eremuko esteka kenduko
 du.
\layout Section

Klaseen definizioen sintaxia
\layout Standard

Klase baten definizioaren itxurarik sinpleena:
\layout LyX-Code

class klaseIzena:
\layout LyX-Code

    <sententzia-1>
\layout LyX-Code

    .
\layout LyX-Code

    .
\layout LyX-Code

    .
\layout LyX-Code

    <sententzia-N>
\layout Standard

Normalean klase baten definizio barneko sententziak funtzioen definizioak
 izango dira, nahiz eta beste sententzi mota batzuk ere zilegi diren.
 Klase baten definizioan sartzean, izen eremu berri bat sortzen da eta esparru
 lokal bezala erabiliko du.
 Klase baten definizioa arruntki uztean (azken lerroa amaitzean) klaseko
 objetu bat sortuko da.
 Klasearen definizioan sartzean dagoen esparru lokala berriro instantziatua
 izango da eta klase objetua funtzioaren goiburuan emaniko klase izenarekin
 estekatuko da.
\layout Section

Klase objetuak
\layout Standard

Klaseko objetuek bieragiketa mota jasan ditzakete: atributuei erreferentzia
 eta instantziazioa.
\layout Standard


\shape italic 
Atributuei erreferentziek
\shape default 
 Python-eko sintaxi estandarra erabiltzen dute: 
\family typewriter 
obj.izena
\family default 
.
 Atributuentzat balio duten izenak klasea sortzean klasearen izen eremuan
 zeuden izen guztiak izango dira.
 Ondorioz klasearen definizioa:
\layout LyX-Code

class klaseIzena:
\layout LyX-Code

    "Adibiderako klasea"
\layout LyX-Code

    i = 37
\layout LyX-Code

    def f(x):
\layout LyX-Code

        return 'iepa mundue!'
\layout Standard


\family typewriter 
klaseIzena.i
\family default 
 eta 
\family typewriter 
klaseIzena.f
\family default 
, atributuei erreferentzia posibleak dira, oso bat eta metodo objetu bat
 itzuliko dituzte.
 
\family typewriter 
i
\family default 
 atributuari balioren bat asignatu geniezaiokegu.
 Dokumentazio katea ikusteko 
\family typewriter 
__doc__
\family default 
 erabiliko dugu.
\layout Standard

Klaseen 
\shape italic 
instantziazioak
\shape default 
 funtzioen notazioa erabiltzen du:
\layout LyX-Code

x = klaseIzena()
\layout Standard

Klasearen instantzia berri bat sortu eta 
\family typewriter 
x
\family default 
 aldagai lokalari asignatuko dio.
 Instantziazioak objetu huts bat sortzen du.
 Klase askok objetuak haserako egoera jakin batean sortzen dituzte 
\family typewriter 
__init__()
\family default 
 erabiliz, honela klaseen intantziazioak honi deituko dio automatikoki:
\layout LyX-Code

    def __init__(self):
\layout LyX-Code

        self.hustu()
\layout Standard

Metodo honek argumentuak ere izan litzake.
 Adibidez:
\layout LyX-Code

>>> class Konplexua: 
\layout LyX-Code

...
     def __init__(self, zatiErreala, zatiIrudikaria):
\layout LyX-Code

...
         self.r = zatiErreala
\layout LyX-Code

...
         self.i = zatiIrudikaria 
\layout LyX-Code

...
\layout LyX-Code

>>> x = Konplexua(3.0,-4.5) 
\layout LyX-Code

>>> x.r, x.i
\layout LyX-Code

(3.0, -4.5)
\layout Section

Instantzia objetuak
\layout Standard

Instantzia objetuekin atributuei erreferentzia bakarriak egin geniezaiokegu.
 Bi atributu izen mota bakarrik daude: metodoak eta datuen atributuak.
\layout Standard


\shape italic 
Datuen atributuak
\shape default 
 deklaratu beharrik ez dago aldagai lokalak bezala.
\layout Standard


\shape italic 
Metodoak
\shape default 
 objetuei dagozkien funtzioak dira.
 
\layout Standard

Objetu instantzia baten metodoen izenak klasearen araberakoak izango dira.
 Funtzio objetuak diren klase baten atributu guztiak instantziei dagozkien
 metodoak zehazten dituzte.
 Adibidez, 
\family typewriter 
klaseIzena.f
\family default 
 funtzioa denez 
\family typewriter 
x.f
\family default 
 metodo bati erreferentzia da, baina ez 
\family typewriter 
x.i
\family default 
, 
\family typewriter 
klaseIzena.i
\family default 
 ez delako funtzioa.

\family typewriter 
 x.f
\family default 
 ez da 
\family typewriter 
klaseIzena.f
\family default 
-ren berdina, 
\shape italic 
objetu metodoa
\shape default 
 baita eta ez objetu funtzioa.
\layout Section

Metodo objetuak
\layout Standard


\shape italic 
klaseIzena
\shape default 
 klasearen adibidean 
\family typewriter 
x.f()
\family default 
-ri deituz 
\family typewriter 
'iepa mundue!'
\family default 
 itzuliko liguke.
 Baina ez beharrezkoa bereala deitzea: 
\family typewriter 
x.f
\family default 
 metodo objetua denez, gorde eta geroago berreskuratu bait genezake, adibidez:
\layout LyX-Code

xf = x.f
\layout LyX-Code

while 1:
\layout LyX-Code

    print xf()
\layout Standard


\family typewriter 
'iepa mundue!'
\family default 
 erakutsiko digu geuk geldiarazi arte.
\layout Standard


\family typewriter 
f
\family default 
 metodoaren definizioak argumentu bat behar zuela ohartuko zinen.
 Deitzen duen objetua pasako zaio lehen argumentu bezala.
 Orokorrean, metodo bati argumentu zerrenda batekin deitzea, metodo objetua
 haserako argumentu zerrendan sartuz lortuko genuken argumentu zerrendarekin
 deitzearen berdina da.
\layout Standard

Funtzio objetua den klaseko atributua erakusten badu izenak, metodo objetu
 bat sortuko da objetu instantzia eta objetu abstraktu batean aurkituriko
 objetu funtzioa (metodo objetua) bateratuz.
\layout Section*
\pagebreak_top 
Adibidea:
\layout LyX-Code

#
\layout LyX-Code

# Ajedreza.py fitxategiaren hasera
\layout LyX-Code

#
\layout LyX-Code

class alfil:
\layout LyX-Code

    "Alfilaren klasea"
\layout LyX-Code

    def __init__(self, x, y):
\layout LyX-Code

        self.posX=x
\layout LyX-Code

        self.posY=y
\layout LyX-Code

    def pX(self):
\layout LyX-Code

        return self.posX
\layout LyX-Code

    def pY(self):
\layout LyX-Code

        return self.posY
\layout LyX-Code

    def mugitu(self,x,y):
\layout LyX-Code

        if ((x<=0)or(x>8)or(y<=0)or(y>8)):
\layout LyX-Code

            return False
\layout LyX-Code

        import math
\layout LyX-Code

        if (abs(self.posX-x))!=(abs(self.posY-y)):
\layout LyX-Code

            return False
\layout LyX-Code

        if ((self.posX==x)and(self.posY==y)):
\layout LyX-Code

            return False
\layout LyX-Code

        self.posX=x
\layout LyX-Code

        self.posY=y
\layout LyX-Code

        return True
\layout LyX-Code

\layout LyX-Code

print '
\backslash 
nAlfilaren jokuan hastera goaz
\backslash 
n'
\layout LyX-Code

auk='b'
\layout LyX-Code

pieza=alfil(1,1)
\layout LyX-Code

while ((auk=='b')or(auk=='B')):
\layout LyX-Code

    print 'Alfilaren posizioa:',pieza.pX(),',',pieza.pY()
\layout LyX-Code

    x=int(raw_input("Zein X-en posiziora nahi duzu mugitu? "))
\layout LyX-Code

    y=int(raw_input("Zein Y-en posiziora nahi duzu mugitu? "))
\layout LyX-Code

    if (pieza.mugitu(x,y)):
\layout LyX-Code

        print 'Mugitu dut.'
\layout LyX-Code

    else:
\layout LyX-Code

        print 'Ezin da mugimendu hori burutu'
\layout LyX-Code

    auk=raw_input('Beste mugimendu saiakerarik nahi? (b/e) ')
\layout LyX-Code

# Ajedreza.py fitxategiaren amaiera
\layout Section

Herentzia
\layout Standard

Eratorritako klase baten definizioaren sintaxiak honako itxura du:
\layout LyX-Code

class klaseEratorriIzena (klaseOinarriIzena):
\layout LyX-Code

    <sententzia-1>
\layout LyX-Code

    .
 
\layout LyX-Code

    .
\layout LyX-Code

    .
\layout LyX-Code

    <sententzia-N>
\layout Standard


\family typewriter 
klaseOinarriIzena
\family default 
 izena klase eratorria zehaztu den esparruan zahaztu beharko da.
 Klase oinarriaren izen baten ordez espresio bat idatzi liteke, adibidez
 klase oinarria beste modulu batetan dagoenean zehaztua:
\layout LyX-Code

class klaseEratorriIzena (modIzena.klaseOinarriIzena)
\layout Standard

Klase eratorriaren definizioaren exekuzioa klase oinarriaren modu berean
 emango da, eta klase objetua sortzean klase oinarria gogoratuko da.
 Klasean eskatzen den atributu bat aukitzen ez bada, klase oinarrian bilatuko
 da, eta honela jarraituko da klase oinarria eratorria bada.
\layout Standard


\family typewriter 
klaseEratorriIzena()
\family default 
 landuz klasearen instantzia berri bat sortuko da.
 Metodoei erreferentziak egiteko: dagokion klaseko atributua bilatuko du,
 behar izanez gero klase oinarrietatik jeitxiz, eta metodoaren erreferentzia
 ondo egongo da modu honetan funtzio objetu bat lortzen bada.
\layout Standard

Klase eratorriek klase oinarrietan zehaztutako metodoak berriro definitu
 ditzakete.
 Metodoek objetu bereko beste metodoei deitzean ez dutenez lehentasun berezirik,
 klase oinarri batean zehazturiko metodo batek klase oinarri bereko metodo
 bati deitzean, berriro definituko duen klase eratorri batetako metodo bati
 deitzen amaitu lezake.
\layout Standard

Eratorritako klase batetan metodo bat berriro definitzean, baliteke ordeztu
 beharrean gehiago sakontzea klase oinarriko izen bereko metodoa.
 Klase oinarriko metodoari zuzenean deitzeko: 
\family typewriter 
klaseOinarriIzena.metodoIzena(self,\SpecialChar ~
argumentuak) 
\family default 
erabiliz.
 
\layout Subsection

Herentzia anizkoitza
\layout Standard

Klase oinarri anitzdunetatik eratorritako klase baten definizioaren sintaxiak
 honako itxura du:
\layout LyX-Code

class klaseEratorriIzena (Oinarria1, Oinarria2, Oinarria3):
\layout LyX-Code

    <sententzia-1>
\layout LyX-Code

    .
 
\layout LyX-Code

    .
\layout LyX-Code

    .
\layout LyX-Code

    <sententzia-N>
\layout Standard

Klasearen atributuen erreferentzietan lehenengo sakoneran biatuko da eta
 gero ezkerreti eskubira.
 Honela, 
\family typewriter 
klaseEratorriIzena
\family default 
n atributu bat bilatzean 
\family typewriter 
Oinarria1
\family default 
en bilatuko da, 
\family typewriter 
Oinarria1
\family default 
en klase oinarrietan eta aurkitzen ez bada 
\family typewriter 
Oinarria2
\family default 
n, honen klase oinarrietan eta honela hurrenez hurren.
 Lehenengo sakoneran bilatzeak 
\family typewriter 
Oinarri1
\family default 
en atributu zuzen eta eratorrien artean ez ezberdintasunik egingo.
\layout Standard

Herentzia anizkoitzaren arazo bat klase oinarrietako bat berdina duten bi
 klasetatik eratorritako klaseena da.
 Nahiz eta erraza izan, kasu honeta zer gertatuko den jakitea (instantziak
 "instantzia aldagaien" edo elkarbanatzen duten oinarriak erabilitako datuen
 atributuen kopia bakarra izango du), ez da garbi ikusten.
\layout Section

Aldagai pribatuak
\layout Standard

Modu mugatu batetan klaseko identifikadore pribatuak erabili daitezke.
 
\family typewriter 
__fantomas
\family default 
 formako edozein identifikadore 
\family typewriter 
_klaseIzena__fantomas
\family default 
-ekin testualki ordezkatuko da, non 
\family typewriter 
klaseIzena
\family default 
 uneko klasea den haserako azpi-marrak kenduz.
 Berriro idazte hau indentifikadorearen posizio sintaktikoa kontutan hartu
 gabe egingo da, modu pribatuan klase eta instantziako aldagaiak, metodoak
 eta aldagai orokorrak zehazteko erabili daitekelarik.
 Beste klase batzuetako instantzietan klase honetako instantzia pribatuko
 aldagaiak gordetzeko ere balio du.
 Baliteke berriro idatzitako izenak 255 karaktere baino gehiago izatean
 izenak moztea.
 Klaseetatik kanpo edo klasearen izenak azpi marrak bakarrik dituenean,
 izenak ez dira berriro idatziko.
\layout Standard

Izenen berridazpenak klaseei metodoak eta instantzia aldagai "pribatuak"
 zehazteko modu errazagoa ematen dute, klase eratorrietan zehazturiko instantzia
 aldagaietaz ahaztuz.
 Aldagai pribatuak aldatu edo irakurri liteke, nahiz eta zaila izan.
 Akats txiki bat dago: klase oinarriaren izen berdinarekin eratortzean klasea
 bat, klase oinarriaren aldagai pribatuak erabiltzea posible da.
\layout Standard

Hona hemen
\family typewriter 
 __getattr__
\family default 
 eta 
\family typewriter 
__setattr__
\family default 
 bere metodoak inplementatzen dituen eta atributu denak aldagai pribatuetan
 gordeko dituen klase bat:
\layout LyX-Code

class atributuBirtualak:
\layout LyX-Code

    __vdic = None
\layout LyX-Code

    __vdic_izena = locals().keys()[0]
\layout LyX-Code

         def __init__(self):
\layout LyX-Code

             self.__dict__[self.__vdic_izena] = {}
\layout LyX-Code

         def __getattr__(self, izena):
\layout LyX-Code

             return self.__vdic[izena]
\layout LyX-Code

         def __setattr__(self, izena, balioa):
\layout LyX-Code

             self.__vdic[izena] = balioa
\layout Section

Amaitzeko
\layout Standard

Askotan Pascal-eko "record" edo C-ko "struct"-en antzeko datu egiturak erabiltze
a oso baiogarria da.
 Hau lortzeko klase huts baten definizioa erabili genezake, adibidez:
\layout LyX-Code

class Langilea:
\layout LyX-Code

    pass
\layout LyX-Code

ion = Langilea() # Langile fitxa huts bat sortzen da
\layout LyX-Code

# Fitxaren eremuak beteko ditugu
\layout LyX-Code

ion.izena = 'Ion Elorza' 
\layout LyX-Code

ion.departamentua = 'Kalkulu zentrua' 
\layout LyX-Code

ion.soldata = 2000
\layout Subsection

Eszepzioak ere klaseak izan daitezke
\layout Standard

erabiltzaileak zehaztutako eszepzioak iada ez daude testu-kate objetuetara
 mugatuta; klaseen bitartez ere identifikatu daitezke.
 Mekanismo hauek erabiliz eszepzioen jerarkia zabalkorra sortu liteke.
\layout Standard


\family typewriter 
raise
\family default 
 sententziaren bi modu berri:
\layout LyX-Code

raise Klasea, instantzia
\layout LyX-Code

raise instantzia
\layout Standard

Lehenengo moduan, 
\family typewriter 
instantzia
\family default 
k 
\family typewriter 
Klasea
\family default 
ren edo bere eratorri baten instantzia izan beharko du.
 Bigarrengo modua berriz 
\family typewriter 
raise.instantzia.__class__,\SpecialChar ~
instantzia
\family default 
-ren bidelabur bat izango da.
\layout Standard

Except klausula batek kate objetuak bezalaxe klaseak zenbakitu ditzake.
 Except klausula baten klase batek jaurti den eszepzioaren klase berekoa
 edo bere klase oinarrikoa bada eszepzioa harrapatuko du (alderantziz ez;
 klase eratorri batek ez du harrapatuko bere klase oinarrienik).
 Ondorengo adibidea landuz gero, B, C, D erakutsiko du, ordena horretan:
\layout LyX-Code

class B:
\layout LyX-Code

    pass
\layout LyX-Code

class C(B):
\layout LyX-Code

    pass
\layout LyX-Code

class D(C):
\layout LyX-Code

    pass
\layout LyX-Code

for c in [B,C,D]:
\layout LyX-Code

    try:
\layout LyX-Code

        raise c()
\layout LyX-Code

    except D:
\layout LyX-Code

        print "D"
\layout LyX-Code

    except C:
\layout LyX-Code

        print "C"
\layout LyX-Code

    except B:
\layout LyX-Code

        print "B"
\layout Standard

Except klausulak alderantziz jarriko bagenitu, B, B, B, erakutsiko liguke,
 lehenengo klausulak eszepzio guztiak harrapatuko bailituzke, denen klase
 oinarria izateagatik.
\layout Subsection*

Adibidea:
\layout Standard

Alfilaren jokuaren egokitzapena da, hemen alfilaz gain zaldiarekin ere jolastu
 genezake biak pieza klasearen eratorriak direlarik.
 Honez gain mugimenduen erabilera okerra eszepzioak erabiliz landuko da:
\layout LyX-Code

#
\layout LyX-Code

# Ajedreza01.py fitxategiaren hasera
\layout LyX-Code

#
\layout LyX-Code

class pieza:
\layout LyX-Code

    "Piezen klasea"
\layout LyX-Code

    def __init__(self, x, y):
\layout LyX-Code

        self.posX=x
\layout LyX-Code

        self.posY=y
\layout LyX-Code

    def pX(self):
\layout LyX-Code

        return self.posX
\layout LyX-Code

    def pY(self):
\layout LyX-Code

        return self.posY
\layout LyX-Code

\layout LyX-Code

class alfila(pieza):
\layout LyX-Code

    "Piezatik eratorritako alfilaren klasea"
\layout LyX-Code

    def mugitu(self,x,y):
\layout LyX-Code

        if ((x<=0)or(x>8)or(y<=0)or(y>8)):
\layout LyX-Code

            raise Taula
\layout LyX-Code

        import math
\layout LyX-Code

        if ((abs(self.posX-x)) != (abs(self.posY-y))):
\layout LyX-Code

            raise Mugimendua
\layout LyX-Code

        if ((self.posX==x)and(self.posY==y)):
\layout LyX-Code

            raise Batez
\layout LyX-Code

        self.posX=x
\layout LyX-Code

        self.posY=y
\layout LyX-Code

\layout LyX-Code

class zaldia(pieza):
\layout LyX-Code

    "piezatik eratorritako zaldiaren klasea"
\layout LyX-Code

    def mugitu(self,x,y):
\layout LyX-Code

        if ((x<=0)or(x>8)or(y<=0)or(y>8)):
\layout LyX-Code

            raise Taula
\layout LyX-Code

        import math
\layout LyX-Code

        if ((self.posX==x)and(self.posY==y)):
\layout LyX-Code

            raise Batez
\layout LyX-Code

        if((abs(self.posX-x)!=2)and(abs(self.posY-y)!=1)or
\layout LyX-Code

           (abs(self.posX-x)!=1)and(abs(self.posY-y)!=2)):
\layout LyX-Code

            raise Mugimendua
\layout LyX-Code

        self.posX=x
\layout LyX-Code

        self.posY=y
\layout LyX-Code

\layout LyX-Code

class Ajedreza:
\layout LyX-Code

    pass
\layout LyX-Code

\layout LyX-Code

class Taula(Ajedreza):
\layout LyX-Code

    pass
\layout LyX-Code

\layout LyX-Code

class Mugimendua(Ajedreza):
\layout LyX-Code

    pass
\layout LyX-Code

\layout LyX-Code

class Batez(Ajedreza):
\layout LyX-Code

    pass
\layout LyX-Code

\layout LyX-Code

def piezalortu():
\layout LyX-Code

    "Zein piezarekin jolastuko dugun zehaztuko da" 
\layout LyX-Code

    auk=int(raw_input( '''Sartu:
\backslash 
n
\backslash 
t1 alfilarekin jolasteko
\backslash 
n
\backslash 
t2
\layout LyX-Code

                         zaldiarekin jolasteko
\backslash 
n'''))
\layout LyX-Code

    if auk==1:
\layout LyX-Code

        pieza=alfila(1,1)
\layout LyX-Code

        return pieza
\layout LyX-Code

    elif auk==2:
\layout LyX-Code

        pieza=zaldia(1,1)
\layout LyX-Code

        return pieza
\layout LyX-Code

\layout LyX-Code

jokoan=piezalortu()
\layout LyX-Code

jarraitu='b'
\layout LyX-Code

while ((jarraitu=='b')or(jarraitu=='B')):
\layout LyX-Code

    print 'Zure pieza',jokoan.pX(),',',jokoan.pY(),'posizioan aurkitzen da.'
\layout LyX-Code

    try:
\layout LyX-Code

        x=int(raw_input('Zein da mugitu nahi duzun X posizioa?
\backslash 
n'))
\layout LyX-Code

        y=int(raw_input('Zein da mugitu nahi duzun Y posizioa?
\backslash 
n'))
\layout LyX-Code

        jokoan.mugitu(x,y)
\layout LyX-Code

        jarraitu=raw_input('Beste saiakerarik nahi? (b/e)
\backslash 
n')
\layout LyX-Code

    except Taula:
\layout LyX-Code

        print 'Pieza tulatik kanpo atera duzu!'
\layout LyX-Code

    except Mugimendua:
\layout LyX-Code

        print 'Horrela ezin duzu mugitu!'
\layout LyX-Code

    except Batez:
\layout LyX-Code

        print 'Toki berean utzi duzu!'
\layout LyX-Code

    except ValueError:
\layout LyX-Code

        print 'Zein herritan da hori zenbakia? Nirean ez behintzat!'
\layout LyX-Code

# Ajedreza01.py fitxategiaren amaiera
\the_end