PYTHON liburua/Eragileak eta espresioak

3. Eragileak eta espresioak

Aurreko kapituluan ikusi dugu datu sinpleak nola errepresentatu programa batean, datu horiek nola definitu eta identifikatu aldagai eta konstanteen bidez, eta zein diren datu-mota ohikoenak. Baina nola erabili aldagai eta konstante horiek kalkulatu nahi ditugun espresioak osatzeko? Hori da kapitulu honen helburua.

3.1. ESPRESIOAK

Python lengoaian eragiketa bat kalkulatu behar denean, eragile bat erabiltzen da. Aldagaiak edota konstanteak eragileekin konbinatuz zehazten da nola kalkulatu balio bat, aldagaien uneko balioekin eta programako agindu baten barruan. Formula moduko horiei espresioak esaten diegu.

Espresio bat eragigai batez edo gehiagoz, eta zero edo eragile gehiagoz osatuta dago, dena batera balio bat kalkulatzeko helburuarekin. Horrela, 'a+2' espresio bat da, a aldagaiak duen balioa eta 2 zenbakia batuz lortzen den emaitza itzultzen duena. Espresio bat da a aldagaia bera bakarrik ere, aldagaiak momentuan duen balioa itzultzen duena. 2 konstantea ere bera bakarrik beste espresio bat da.

Espresio bakoitzari mota bat dagokio beti, kalkulatuko duen balioaren motarena.

Aurreko kapituluetako programetan ohiko eragile batzuk erabili ditugu: + (batuketa), – (kenketa) eta * (biderkaketa) eragileak. Baina badira beste eragile asko ere. Banan-banan aztertu baino lehen, eragileen bi ezaugarri nagusi aztertuko ditugu: lehentasuna eta elkargarritasuna.

3.2. ERAGILEEN ARTEKO LEHENTASUNA

Espresio batean eragile bat baino gehiago dagoenean, zein ordenatan ebaluatuko dira? Adibidez, 2+3*4 espresioa kalkulatuta, zein izan beharko du emaitzak?

2+3*4 --> 5*4 --> 20 ?

Ez, ez da? Emaitzak 14 izan beharko du.

2+3*4 --> 2+12 --> 14

Pertsonok ondo dakigu hori, baina nola zehaztuko dugu hori programetako espresioetan? Batuketa bat eta biderketa bat maila berean badaude, biderketa kalkulatu behar dugu lehenago. Bada, horixe da eragileen lehentasuna. Konputagailuari zehazten diogu eragile bakoitzaren lehentasuna, maila berean dauden eragiketen artean lehenago zein kalkulatu behar duen jakin dezan.

Adibidez, 2+3*4 espresioaren ebaluazioak 14 sortzen du, biderketak batuketak baino lehentasun-maila handiagoa duelako. Parentesiek, beste lengoaietan bezala, Ebaluazioaren ordena aldatzen dute. Horrela, (2+3)*4 espresioaren ebaluazioak 20 balioa sortzen du. ebaluazio-ordena eragileen lehentasunaren arabera gertatzen da. Lehentasun handieneko eragiketak burutzen dira lehen, tarteko emaitzak lortuz. Geroago, eta lehentasunaren ordena beheranzkorrari jarraituz, beste eragileak aplikatzen dira bitarteko emaitzen gainean.

Ebaluazioaren ordenaren inguruan zalantzak edukiz gero parentesiak erabiltzea gomendatzen da, horrela, bide batez, errazago ulertuko da programa, haren irakurgarritasuna handiagoa izango baita.

3.3. ERAGILEEN ARTEKO ELKARGARRITASUNA

Espresio batean eragile bat baino gehiago dagoenean, edozein datu edozein eragilerekin aplikatu daiteke? Adibidez, 3+'kaixo' espresioa zilegi da? Posible da zenbaki baten eta karaktere-kate baten arteko batuketa? Ez, ez da? Txikitan esaten ziguten ezinezkoa zela sagarrak eta madariak batzea. Antzekoa gertatzen da programazioan: eragile bakoitzak ondo zehaztuta dauka bere eragileek zein datu motatakoak izan behar duten, eta eragiketaren emaitza ezin izango da lortu, eragigaiak mota horretakoak badira. Beraz, kontuz espresioak idazterakoan! Eragileen arteko elkargarritasuna kontuan hartu beharko da espresioak kalkulatzerakoan, espresio baten emaitza beste batentzako datua izango denean lortutako emaitza hark datu egokia izan beharko du bestearentzat.

Adibidez, ondoko espresio hau prozesatzean interpretatzaileak errorea emango du:

'8'+7

(Ikusiko dugunez, + eragilea karaktere-kate artean aplika daiteke kateatzea adierazteko.)

Baina ondoko hiru hauetan ez da errorerik gertatuko:

8+7  
int('8')+7 
'8'+str(7) # kasu honetan + sinboloak kateaketa adierazten du

Dena den eragile batzuen semantika oso zabala da eta, geroago ikusiko dugunez, ahaltsua bezain korapilatsua izan daiteke. Horrela, biderketa (*) karaktere kate bati aplika dakioke (katea hainbat aldiz errepikatuz) edo batuketa (+) kateen arteko kateaketarako erabil daiteke.

3.4. ESLEIPENA

Esleipena aldagai baten balioa aldatzeko erabiltzen da, eta Python bezalako programazio-lengoaia agintzaileen funtsezko eragiketa da. Esleipen-espresio baten eredu orokorra honakoa da:

aldagai_izena = espresioa

Noski, '=' karakterearen ondoan azaltzen den espresioa edozein izan daiteke: konstante bakar batez, aldagai bakar batez, edo konstante, aldagai eta eragilez osaturiko edozein espresio.

Esleipenaren bi aldeetako datuak mota berdinekoak izatea gomendatzen da. Ezkerreko aldagaia programan azaltzen den lehen aldia baldin bada, eskuineko espresioak zehazten du aldagai horrek hartuko dituen balioen mota. Mota esplizituki aldatzeko aurreko kapituluak azaldutako bihurketak adieraz daitezke (str(), int(), float())

3.5. KARAKTERE-KATEEN GAINEKO ERAGILEAK

Esan dugun moduan str mota oinarrizko mota da. Mota horretako aldagaiak eta konstanteak konbina daitezke esleipenetan edo kateaketaren eragilea erabilita (+). Beraz, garrantzitsua da ulertzea + eragileak esanahi bikoitza duela: zenbakien artean batuketa adierazten du, baina karaktere-kateen artean kateaketa adierazten du. Biderketa ere aplika daiteke kateen gainetik edukia errepikatzeko. 3.1. programan adibideak ditugu.

3.1. programa. Karaktere-kateen adibideak:

lengoaia = 'Python'
mezua = lengoaia + ' ' + 'ikasten'
print (mezua)
print (2*lengoaia)

Programa exekutatuz gero, emaitza hau idaztea izango da:

Python ikasten

PythonPython

3.6. ERAGILE ARITMETIKOAK

3.2. taulan ohiko eragiketak agertzen dira: batuketa (+), kenketa (-), biderketa (*) eta zatiketa erreala (/). Plus eta minus zenbaki bakar batekin eta aurrizki moduan erabilita zeinu aritmetikoa adierazi ahal da (positiboa eta negatiboa, hurrenez hurren). Horrez gain, beste eragiketa hauek ere agertzen dira:

• Modulua (%). Bi zenbaki osoren arteko zatiketa osoaren hondarra kalkulatzen du.

Adibidez: 12 % 3 -> 0; 13 % 3 -> 1; 14 % 3 -> 2; 15 % 3 -> 0

• Zatiketa osoa (//). Bi zenbaki osoren arteko zatiketa osoa edo modulua kalkulatzen du.
  

Adibidez: 12 // 3 -> 4; 13 // 3 -> 4; 14 // 3 -> 4; 15 // 3 -> 5

• Berreketa edo esponentziala (**).
  

Adibidez: 25**2 -> 625 ; 25**0.5 -> 5.0

3.1. taula. Eragile aritmetikoak.

ERAGIKETA	ERAGILEA	FORMATUA	AZALPENA
batuketa	+	x + y	x gehi y
kenketa	-	x - y	x ken y
biderketa	*	x * y	x bider y
zatiketa (erreala)	/	x / y	x zati y (emaitza beti da erreala)
zatiketa (osokoa)	//	x // y	x zati y (emaitza beti da osokoa)
modulua	%	x % y	x zati y eragiketaren hondarra
berreketa	**	x ** y	x ber y

Zatiketa osoa eta modulua, // eta % eragileak, osoko eragigaiekin baino ezin dira erabili, eta emaitza zenbaki oso bat izango da beti. Osokoekin / eta % eragileen erabilerak argitzeko, 3.2. programa proba daiteke.

# Zatidura eta zatidura osoa. Hondarra. 
x1 = 11 
x2 = 8 
y = 4 
print("Zatidura:", x1/y, x2/y) 
print("Zatidura osoa eta hondarra:", x1//y, x1%y)

Programa horren emaitzak hauek dira:

Zatidura: 2.75 2.0

Zatidura osoa eta hondarra: 2 3

Bestalde, eragile aritmetiko nagusiak +, -, * eta /) metagailu moduan erabil daitezke +=, -=, *= eta /= eragile berriak sortuz. 3.2. taulan baliokidetzak azaltzen dira.

3.2 taula. Eragile aritmetikoak metagailu gisa.

ERAGILEA	FORMATUA	BALIOKIDEA
+=	x += y	x = x+ y
-=	x -= y	x = x- y
*=	x *= y	x = x* y
/=	x /= y	x = x/ y

(+= eta *= karaktere-kateekin ere erabil daitezke, kateatzeak eta errepikapenak bideratzeko.)

3.7. ERAGILE LOGIKOAK ETA ERLAZIOAK

Erlazio-eragileak balioen arteko konparazioak adierazteko erabiltzen dira, adibidez balio bat beste bat baino handiagoa den aztertzeko. Emaitza beti izango da balio boolear bat: egiazkoa (bai, handiagoa da) edo faltsua (ez, ez da handiagoa).

Balio boolearrak konbina daitezke eragile logikoekin beste balio boolear bat lortzeko. Adibidez: (a > b) and (a > c). Espresio logiko horrek aztertzen du ea a aldagaiaren balioa b-rena eta c-rena baino handiagoa den.

Espresio erregularrak baldintzak adierazteko erabiltzen dira batik bat (ikus 3.3. taula). Hurrengo kapituluan azalduko diren programazio-egituretan (baldintzapekoak zein errepikazkoak).

3.3. taula. Erlazioak adierazteko eragileak:

ERAGIKETA	ERAGILEA	FORMATUA	AZALPENA
handiago	>	x > y	Ea x-ren balioa y-rena baino handiagoa den
txikiago	<	x < y	Ea x-ren balioa y-rena baino txikiagoa den
berdin	==	x == y	Ea x-ren balioa eta y-rena berdinak diren
ezberdin	!=	x != y	Ea x-ren balioa eta y-rena ezberdinak diren
handiago edo berdin	>=	x >= y	Ea x-ren balioa y-rena baino handiagoa edo berdina den
txikiago edo berdin	<=	x <= y	Ea x-ren balioa y-rena baino txikiagoa edo berdina den
eta	and	b1 and b2	Ea b1-en balioa eta b2-rena biak egiazkoa diren
edo	or	b1 or b2	Ea b1-en balioa edo b2-rena egiazkoa den, bietako bat gutxienez
ez	not	not b1	Ea b1-en balioa faltsua den

Kontuz! Pythoneko bertsio zaharragoetan and, or eta not eragileen ordez, &&, || eta ~ eragileak erabiltzen ziren. Kontu handia eduki behar da berdintasuneko erlazioarekin; oso erraza baita '==' eragilea jarri beharrean '=' (esleipena) jartzea, beste lengoaietan egiten den bezala. Zorionez, nahi gabe baldintza bat idaztean errore hori eginez gero, interpretatzailea gai da errorea detektatzeko, eta hori zuzentzeko eskatuko du.

Dena den, Python lengoaian edozein espresio erabil daiteke baldintza moduan, espresio aritmetikoak adibidez. Espresioaren emaitza None denean, faltsutzat jotzen da, eta, gainerako kasuetan, ordea, egiazkotzat.

Adibide batzuk azter ditzagun:

a < b # egiazkoa a b baino txikiagoa bada

a > b # egiazkoa a b baino handiagoa bada

Aurreko kapituluan azaldutako True eta False konstanteak ere mota boolearrekoak dira eta, noski, baldintzak adierazteko erabil daitezke. Adibidez, inoiz bukatuko ez den errepikapen infinitu bat programatu nahi badugu, True balioa izango da egitura errepikakorraren baldintza. Denbora errealeko aplikazioetan, esaterako, erabiltzen dira horrelakoak.

3.8. BIT-MANEIUA

Python lengoaiaren ezaugarrien artean, memoriako bitak atzitzeko gaitasuna duela aipatu behar da, eta horretarako 3.4. taulan azaldutako eragileak dauzkagu. Ez dira aplikazio askotan erabiltzen baina interesgarriak dira behe-mailako programazioari begira.

Jakina denez, AND zenbait bit 0 egoeran jartzeko erabili ohi da, OR eragiketa 1 egoeran jartzeko eta XOR eragiketa biten egoera aldatzeko. Horretarako, aldagaia kode hamaseitarrez (0x aurrizkia) adierazitako maskara batekin parekatu ohi da. Mantendu nahi diren bitei 0 balioa egokitzen zaie maskaran, eta batean jarri (OR) edo aldatu (XOR) nahi direnei bat balioa. AND eragiketan alderantziz egin behar da, hau da, mantendu nahi diren bitei 1 balioa egokitzen zaie eta horretarako ~ eragilea, osagarri bezala, erabil daiteke.

3.4. taula. Eragile bitarrak:

ERAGIKETA	ERAGILEA	FORMATUA	AZALPENA
AND	&	x & mask	x AND maskara
OR	|	x | mask	x OR maskara
XOR	^	x ^ mask	x XOR maskara
ukapen logikoa	~	~x	EZ x
ezkerrerako desplazamendua	<<	x << n	x-ren bitak n posizio ezkerrerantz
eskuinerako desplazamendua	>>	x >> n	x-ren bitak n posizio eskuinerantz

Adibidez, n aldagaia 32 bitez osatuta egonda (haien balioa jakin gabe), eta ezkerreko bita batean jarri eta eskuinekoa zeroan jarri nahi baditugu, ondokoa egin behar da:

# n <- xxxx ... xxxx 
n = n | 0x80000000    # n <- 1xxx ... xxxx 
n = n & (~0x00000001) # n <- 1xxx ... xxx0

Eragile hauen erabilera argitzeko, 3.5. taulan adibide batzuk azaltzen dira, marraren gainean dauden balioak eragigaiak eta behean daudenak emaitzak izanik.

Bit-maneiurako eragileen erabileraren adibideak:

1. adibidea:

10101010

01010101

------------------------------------

0000000 "&" eragiketa aplikatuta

2. adibidea:

10101010

01010101

------------------------------------

11111111 "|" eragiketa aplikatuta

3. adibidea:

11110000

10101010

------------------------------------

01011010 "^" eragiketa aplikatuta

4. adibidea:

01010101

------------------------------------

10101010 "~" eragiketa aplikatuta

Desplazamenduek bit-maneiua egitura errepikakorretan erabiltzeko balio dute batez ere, 4. kapituluan ikusiko dugunez.

3.9. OINARRIZKO FUNTZIO BATZUK

Aurrerago ikusiko dugunez, balio bat kalkulatzeko 'funtzioak' erabil daitezke, alegia, beste programa lagungarri batzuk. Funtzioen eta metodoen erabilera 5. kapituluan azalduko den arren, datu-motekin lotutako bi funtzio interesgarri azalduko ditugu orain: type() eta len() funtzioak. Datu-moten inguruan zalantza izanez gero, type funtzioa erabil daiteke programan bertan edota idle ingurunean. Parentesi artean aldagai baten identifikadorea edo konstante bat jarrita, dagokion mota itzultzen du. Adibidez, honako kode honen bidez:

print(type(PI))

PI lehen azaldutako PI konstantearen mota lortu eta inprimatu egingo da: <class 'float'> str motako aldagai/konstanteetan eta zerrendetan len() funtzioa erabil daiteke, karaktere kopurua eta osagai kopurua lortzeko, hurrenez hurren. Adibidez:

mezu = “Kaixo guztioi”  
print(len(mezu))

kodeaz 13 zenbakia lortuko da. Esan bezala, zerrendekin ere erabil daitezke. Adibidez, ondoko kodearen ondorioz:

aukera2 = [‘bai’, ‘ez’]  
print(type(aukera2))  
print(len(aukera2))

hauxe inprimatuko da:

<class ‘list’>

3.10. PROGRAMEN TESTUAREN FORMATUA: TABULAZIOAK ETA ZURIUNEAK

Lehen kapituluan programen egituraz azaldu dena gogoratu behar da: programen sintaxia nahiko zurruna da eta tabulazioak berebiziko garrantzia du Python lengoaian. Tabulazioa Tab tekla bitartez edo zuriuneekin sortuko da, baina modulu berean modu kontsistentean egin behar da, edo beti Tab bitartez edo beti zuriuneen bitartez. Programa bat agindu-segida bat da eta normalean programako aginduak lerro banatan idazten dira, denak tabulazio-maila berean hasita. Agindu bat konplexua bada (4. kapituluan ikusiko ditugun kontrol-egiturak, adibidez) eta haren barruan beste agindu-multzo bat sartzen bada, haren barruko agindu horiek guztiak beste tabulazio-maila batekin barrurago idatzi beharko dira beti. Hurrengo kapituluaren adibideetan argiago ikusteko aukera egongo da.

Alderantzizkoa ere egin daiteke: lerro berean agindu bat baino gehiago biltzea. Horretarako, sententzien artean ';' karakterea (puntu eta koma karakterea) jarri beharko da.

Bestalde, programak hobeto irakurri ahal izateko, zuriuneak gehi daitezke espresioetan, beti kontuan hartuz ezin direla txertatu karaktere anitzeko eragileen artean zein identifikadoreen barruan. Parentesiak erabiltzea ere komenigarria da, kalkulatu behar diren espresio luzeen ebaluazioaren ordena argitzeko, bai norberarentzat, baita programa irakurriko duen edonorentzat ere. Erredundanteak izan daitezkeen parentesiak erabiltzeak ez du errore-abisurik sortzen, ezta espresio baten ebaluazioan abiadura moteltzen ere.