Essert Python PDF

Mario Essert
Digitalni udºbenik
Python
- osnove -
Odjel za matematiku
Sveu£ili²ta Josipa Jurja Strossmayera

Osijek, 2007.
Sadrºaj
Sadrºaj 3
1 Python interpreter 7
1.1 Jezi£ne zna£ajke . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.2 Izvoenje Python programa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.3 Na² prvi Python program . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2 Tipovi podataka 11
2.1 Brojevi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.2 Nizovi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.2.1 Stringovi - nizovi alfanumeri£kih znakova . . . . . . . . . . . . . . . . . . . . . . 15
2.2.2 N-terac . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.2.3 Lista . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.3 Temeljne operacije i metode s nizovima . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.3.1 Ugraene metode string-ova . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
2.3.2 Ugraene metode listi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.4 Rje£nik . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.4.1 Ugraene metode rje£nika . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.5 Skup . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
3 Izrazi, operatori i operacije 25

3.1 Varijable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
3.2 Naredbe pridruºivanja . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
3.2.1 Obi£na pridruºba . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
3.2.2 Pro²irena pridruºba . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
3.2.3 Naredba del . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
3.2.4 Bool -ove vrijednosti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
3.3 Operatori i operacije . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
3.3.1 Numeri£ke i aritmeti£ke operacije . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
3.3.2 Prisilna i eksplicitna pretvorba . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
3.3.3 Usporedba . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
3.3.4 Operacije na bitovima cijelih brojeva . . . . . . . . . . . . . . . . . . . . . . . . . 31
3.4 Operacije na nizovima . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
3.4.1 Kri²ka (eng. slicing ) niza . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
3.4.2 Stacionarne operacije na listi i rje£niku . . . . . . . . . . . . . . . . . . . . . . . 33
3.5 Naredba Print . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
4 Programsko upravljanje 35
4.1 Naredba if . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
4.2 Naredba while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
4.3 Naredba for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
3
4.4 Iteratori . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
4.5 Funkcije range i xrange . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
4.6 Saºete liste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
4.7 Naredba break . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
5 Iznimke 41
5.1 Vrste iznimki . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
5.2 Rad s iznimkama . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
5.3 Obradba iznimki . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
5.3.1 Ignoriranje iznimke . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
5.3.2 Pronalaºenje argumenta iznimke . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
5.3.3 Obradba svih iznimki . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
5.3.4 Pokretanje programskog koda bez prisustva iznimke . . . . . . . . . . . . . . . . 47
5.3.5 Obradba vi²e iznimki . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
5.3.6 Pokretanje obaveznog kôda za £i²¢enje . . . . . . . . . . . . . . . . . . . . . . . . 48
5.3.7 Eksplicitno podizanje iznimke . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
5.4 Korisni£ki denirane iznimke . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
5.4.1 Tvorba iznimki . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
5.4.2 Dijagnosti£ko pridruºivanje . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
6 Funkcije 51
6.1 Naredba 'def ' . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
6.2 Parametri . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
6.3 Atributi funkcijskih objekata . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
6.4 Naredba 'return' . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
6.5 Poziv funkcije . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
6.5.1 Prijenos argumenata . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
6.5.2 Vrste argumenata . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
6.5.3 Prostor imena . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
6.5.4 Naredba 'global' . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
6.6 Ugnjeºene funkcije . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
7 Python - objektni jezik 59

7.1 Klase i instance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
7.2 Naredba 'class' . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
7.3 Tijelo klase . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
7.3.1 Atributi klasnog objekta . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
7.3.2 Denicija funkcije unutar tijela klase . . . . . . . . . . . . . . . . . . . . . . . . . 61
7.3.3 Varijable speci£ne za klasu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
7.3.4 Dokumentacijski string . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
7.4 Instanca klase . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
7.4.1 __init__ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
7.4.2 Atributi objekta instance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
7.4.3 Tvorni£ka funkcija . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
7.4.4 Brojanje referenci i brisanje instance . . . . . . . . . . . . . . . . . . . . . . . . . 65
7.5 Nasljeivanje . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
7.5.1 Premo²¢uju¢i atributi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
7.5.2 Posluºivanje metoda superklase . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
7.5.3 Vi²eobli£je . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
7.5.4 Skrivanje informacije (engl. information hiding) . . . . . . . . . . . . . . . . . . . 67
7.5.5 Operatorsko punjenje . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
7.6 Testovi pripadnosti klasa i tipova . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
SADRAJ 5
8 Moduli i paketi 71
8.1 Modul . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
8.1.1 Traºenje modula . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
8.1.2 U£itavanje modula i compilacija . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
8.1.3 Ponovno punjenje modula . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
8.2 Paketi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
9 Ulaz i izlaz 77
9.1 itanje naredbene linije i varijable okoli²a . . . . . . . . . . . . . . . . . . . . . . . . . . 77
9.2 Datoteke . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
9.3 Standardni ulaz, izlaz i pogre²ka (engl. Input, Output, Error) . . . . . . . . . . . . . . . 79
9.4 Naredba print . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
9.5 Otpornost . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
Literatura 83
POGLAVLJE 1
Python interpreter
Python je interpreterski, interaktivni, objektu orjentirani programski jezik, kojeg je 1990. godine prvi
razvio Guido van Rossum. Ve¢ do konca 1998., Python je imao bazu od 300.000 korisnika, a od 2000.
ve¢ su ga prihvatile ustanove kao MIT, NASA, IBM, Google, Yahoo i druge. Python ne donosi neke
nove revolucionarne zna£ajke u programiranju, ve¢ na optimalan na£in ujedinjuje sve najbolje ideje i
na£ela rada drugih programskih jezika. On je jednostavan i snaºan istodobno. Vi²e nego drugi jezici on
omogu¢uje programeru vi²e razmi²ljanja o problemu nego o jeziku. U neku ruku moºemo ga smatrati
hibridom: nalazi se izmeu tradicionalnih skriptnih jezika (kao ²to su Tcl, Schema i Perl ) i sistemskih
jezika (kao ²to su C, C++ i Java ). To zna£i da nudi jednostavnost i lako kori²tenje skriptnih jezika
(poput Matlab -a), uz napredne programske alate koji se tipi£no nalaze u sistemskim razvojnim jezicima.
Python je besplatan (za akademske ustanove i neprotnu upotrebu), open-source software, s izuzetno
dobrom potporom, literaturom i dokumentacijom.
1.1 Jezi£ne zna£ajke

Interpretacija meukôda
Python kôd sprema se u tekst datoteke koje zavr²avaju na .py. Program kompilira kôd u
niz bytecode-ova koji se spremaju u .pyc datoteke koje su prenosive na bilo koje platforme
gdje se mogu izvoditi interpretacijom tog meukôda. Na sli£an na£in izvr²ava se Java kôd -
interpretacijom meukôda. Brzina izvoenja Python kôda istog je reda veli£ine kao u Javi ili
Perlu. ANSI C i raspoloºiv za cijeli niz strojeva i operacijskih sustava
Python je napisan u
uklju£uju¢i Windows, Unix/Linux i Macintosh.
Jezik visoke razine

Osim standardnih tipova podataka (brojevi, nizovi znakova i sl.) Python ima ugraene
tipove podataka visoke razine kao ²to su liste, n-terci i rje£nici.
Interaktivnost
Python se moºe izvoditi u razli£itim okruºenjima. Za razvitak programa najlak²i je interak-
tivni na£in rada u kojem se programski kôd pi²e naredbu za naredbom. Ne postoji razlika u
razvojnom i izvedbenom (engl. runtime ) okoli²u: u prvom se izvodi naredba za naredbom ,
a u drugom odjednom £itava skripta.
ista sintaksa
7
8 Python interpreter
Sintaksa jezika je jednostavna i o£evidna. Uvlake zamjenjuju posebne znakove za deniranje

blokova kôda, pa je napisani program vrlo pregledan i jednostavan za £itanje.
Napredne zna£ajke jezika

Python nudi sve zna£ajke o£ekivane u modernom programskom jeziku: objektu orijentirano
programiranje s vi²estrukim nasljeivanjem, dohva¢anje izuzetaka ili iznimki (engl. excep-
tion ), redeniranje standardnih operatora, pretpostavljene argumente, prostore imena (engl.
namespaces), module i pakete.
Pro²irivost
Python je pisan u modularnoj C arhitekturi. Zato se moºe lako pro²irivati novi zna£ajkama
ili API-ima. (engl. application programming interface ).
Bogate knjiºnice programa
Pythonova knjiºnica (engl. library ), koja uklju£uje standardnu instalaciju, uklju£uje preko
200 modula, ²to pokriva sve od funkcija operacijskog sustava do struktura podataka potreb-
nih za gradnju web-servera. Glavni Python web site ( www.python.org ) nudi saºeti index
mnogih Python projekata i razli£itih drugih knjiºnica.
Potpora
Python ima veliku entuzijasti£ku zajednicu korisnika koja se svake godine udvostru£uje.
1.2 Izvoenje Python programa

Python kôd moºe se izvoditi na vi²e na£ina:
Interaktivni rad
To je naj£e²¢i na£in rada kod pisanja novih programa, a zapo£inje pozivom python u Li-
nux -u, odnosno dvostrukim klikom na ikonicu u Windows okruºenju. U MS-DOS okruºenju,
Python se poziva isto kao u Unix -u/Linux -u, jedino je sistemski znak (engl. prompt ) dru-
ga£iji. Pozivom interpetera otvara se njegova okolina, npr. pod PythonWin -om:
PythonWin 2.5 (r25:51908, Sep 19 2006, 09:52:17) [MSC v.1310 32 bit (Intel)] on win32.
Portions Copyright 1994-2006 Mark Hammond - see 'Help/About PythonWin'
for further copyright information.
>>>
ili pod Linux-om:
$ python
Python 2.5 (r25:51908, Oct 6 2006, 15:24:43)
[GCC 4.1.2 20060928 (prerelease) (Ubuntu 4.1.1-13ubuntu4)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>>
Interepreter dakle ispisuje svoj prompt >>>, iza kojeg korisnik unosi (utipkava) naredbu, a
koju zavr²a s ENTER tipkom (ili Return tipkom). Zatim Python izvodi tu naredbu, ispisuje
rezultat i ponovo ispisuje prompt o£ekuju¢i novu naredbu:
>>> print 'Znam zbrojiti: 1+2 =', 1+2

Znam zbrojiti: 1+2 = 3
>>>
1.3. Na² prvi Python program 9
Na ovaj na£in Python se moºe koristiti kao jednostavan, ali i vrlo sloºen kalkulator.
U slu£aju naredbi koje pretpostavljaju daljnje naredbe u nastavku, npr. naredbe petlje (for,
while, ...), Python interpreter ispisuje '...' i automatski £ini uvlaku za nove naredbe. U
Windows okruºenju postoji vi²e gra£kih rje²enja za interaktivan rad. U instalacijskom
paketu s Pythonom dolazi IDLE kojeg je razvio Python-ov autor. IDLE koristi Tkinter
GUI framework i prenosiv je na sve Python platforme koje imaju Tkinter potporu.
Bolja rje²enja od IDLE-a su PythonWin, PyScripter i novija, koja korisniku daju puno
gra£kih rje²enja za jednostavnu Python upotrebu kako u interaktivnom tako i u skriptnom
radu.
Skriptni rad
Programi se spremaju u skripte s pomo¢u obi£nog text editora ili Python orjentiranog gra-
£kog okruºenja, a onda se kao Unix /Linux ili Windows skripte pozivaju iz sistemske linije.
Ako smo na primjer gornju naredbu (ili vi²e njih) spremili u datoteku-skriptu 'moj.py', onda
se pozivom:
python moj.py
skripta izvodi i na zaslonu se dobije rezultat: Znam zbrojiti: 1+2 = 3 jer je kôd skripte
bio isti onaj utipkan u interaktivnom radu.
Umetnuti (embeded) kôd

Iako se £e²¢e unutar Pythona mogu pozivati funkcije iz drugih programa (npr. C -a za slu£aj
programskog ubrzanja), mogu¢e je Python kôd u obliku izvornih tekst naredbi izvoditi i
unutar programa pisanog u drugom programskom jeziku, koriste¢i Python runtime API, na
primjer unutar C -programa:
#include <Python.h>
. . .
Py_Initialize();
PyRun_SimpleString("x = a + 2*pi");
1.3 Na² prvi Python program

Neka se na po£etku promotri jedan primjer Python programa, kako bi se uo£ila svojstva i na£in pisanja
programskog kôda.
,
from random import randint
gotovo = False ; korak =0
broj = randint (1 , 100)
while not gotovo :
x = int ( raw_input ( " Pogodi zamisljeni broj : " ))
if x == broj :
print ' Cestitamo ! '
gotovo = True ;
elif x < broj :
print ( ' Pucaj navise ! ')
else :
print ( ' Pucaj nanize ! ')
korak +=1
print ' Pogodak iz % d . puta . ' % korak
10 Python interpreter
Prva linija programa uvla£i (engl. import ) iz modula random funkciju randint() s kojom ¢e se
generirati slu£ajan cijeli broj. Varijabla 'gotovo' postavlja se u Bool-ovo stanje neistine (engl. False ),
a varijabla 'korak' inicijalizira se sa 0. Znak ';' sluºi za odvajanje naredbi pisanih na istoj liniji. U
varijablu 'broj' sprema se slu£ajni broj (izmeu 1 i 100), kojeg korisnik pogaa. Kako se vidi, postoji
petlja while koju program u izvoenju vrti sve dok varijala gotovo ne postane istinita, tj. True, a
to se dogadja kad zami²ljeni 'broj' bude jednak, od korisnika izabranoj, vrijednosti varijable 'x'. U
slu£aju da to nije ispunjeno, program 'pomaºe' korisniku savjetom da pogaa navi²e ili naniºe. Pritom
se varijabla 'korak' svaki put pove¢ava za 1, kako bi na koncu, nakon £estitke, bilo ispisano i koliko
koraka je trebalo da se do nje doe.
Treba primjetiti kako u Pythonu ne postoje oznake po£etka i konca bloka naredbi (kao ²to su to
viti£aste zagrade u C -jeziku ili begin-end u Pascal -u), nego se to ostvaruje uvlakama. Na taj na£in
korisnik je prisiljen pisati strukturirani kod, lagan za £itanje. Sve upravlja£e naredbe (if, while, else
i sl.) zavr²avaju sa znakom dvoto£ke (':'). Treba takoer uo£iti kako je rad sa ulazom i izlazom u
Pythonu jednostavan (poput Basic -a) - postoje dvije funkcije: row_input() za ulaz i print za izlaz.
Prva ispisuje poruku korisniku i u£itava niz znakova ( string ) koji korisnik upi²e, a druga samo ispisuje
string i/ili sadrºaj varijabli. Mogu¢e je takoer i formatiranje izlaza (zadnja print naredba).
POGLAVLJE 2
Tipovi podataka
Ra£unalni program je algoritam zadan programskim naredbama koje se izvr²avaju nad nekom vrstom ili
tipom podataka. Sve podat£ane vrijednosti u Pythonu predstavljene su objektima,
(binarno spremljenih)
pa se za Python s pravom kaºe: "Sve je objekt ". Svaki objekt moºe imati najvi²e £etiri svojstva:
• identitet - adresa u memoriji gdje je objekt spremljen
• tip - veli£ina memorijskog prostora kojeg objekt zauzima i na kojem se stanovite metode (obrade)
mogu tj. smiju obavljati
• vrijednost - sadrºaj memorijskog prostora spremljenog objekta
• metodu - programski kôd koji se primjenjuje na vrijenosti(ma) objekta
Identitet i tip objekta su nepromjenljive veli£ine i deniraju se stvaranjem, generiranjem, objekta. Svaki
objekt moºe imati jednu ili vi²e vrijednosti, te jednu ili vi²e metoda. Neki objekti dolaze se Python
interpreterom, zovemo ih ugraeni objekti (engl. built-in objects ), a druge stvara sâm korisnik preko
Python klasa. Vrijednosti objekta £esto se zovu atributi. Dohva¢anje atributa u objektu ostvaruje
se sintaksom obj.atr, gdje je obj ime objekta, a atr ime atributa. Objekti kojima se vrijednost(i)
mogu mijenjati bez promjene identiteta zovu se promjenljivi (engl. mutable ) objekti, a oni kojima
se vrijednost ne moºe mijenjati bez stvaranja novog objekta istog tipa zovu se nepromjenljivi (engl.
immutable ) objekti. Promjena vrijednosti objekta obi£no se dogaa pridruºivanjem razli£itih literala
ili djelovanjem metode na vrijednost objekta. Literal ozna£uje vrijednost podatka koja se neposredno,
direktno, pojavljuje u programskoj naredbi:
2347 # Cjelobrojni literal

13.514 # Realni (Floating-point) literal
5.0J # Imaginarni literal
'hello' # String literal, niz znakova
Osim alfanumeri£kih znakova za brojeve i stringove, Python koristi i posebne simbole i to kao mea²e
ili grani£nike (npr. za po£etak i zavr²etak string literala koristi simbole jednostrukih, dvostrukih ili
trostrukih navodnika) ili kao simbole aritmeti£ko-logi£kih i odnosnih (relacijskih) operatora. Simbol '#'
koristi se za po£etak komentara i ne obrauje se od strane Python interpretera: sve napisano u linije
iza njega, udesno, interpreter ne¢e obraivati. Mea²i sluºe i kod denicije sloºenih tipova, od kojih se
naj£e²¢e koriste:
[ 63, 'faks', 8.6 ] # Listina, lista ili popis (engl. list)

( 450, 320, '600' ) # n-terac (engl. tuple)
{ 'a':72, 'b':1.4 } # rje£nik (engl. dictionary)
11
12 Tipovi podataka
Tipovi objekata mogu se sloºiti u kategorije (tablica 2.1), pa razlikujemo brojeve, nizove, klase, datoteke,
module i sl. Neki objekti su promjenljivi (npr. liste), a neki nisu (npr. stringovi).
Tablica 2.1: Ugraeni (built-in) tipovi u Python programskom jeziku
Kategorija tipa Ime tipa podatka Opis

podataka
Prazno (None) NoneType 'null' objekt
Brojevi IntType Cijeli broj
LongType Dugi cijeli broj
Realni broj s pom.
FloatType
zarezom
ComplexType Kompleksni broj
Nizovi StringType Niz znakova (string)
UnicodeType Unicode (string)
ListType Listina, popis ili lista
TupleType n-terac
XRangeType Vra¢eno iz xrange()
BufferType Vra¢eno iz buer()
Preslikavanje DictType Rje£nik
Klase, razredi ClassType Denicija klase
Instanca klase, objekt InstanceType Stvaranje instance
Datoteka - podaci na
Datoteka FileType
mediju
Moduli ModuleType Modul (skup objekata)
Objekti koji se
BuiltinFunctionType Ugraene funkcije
pozivaju
BuiltinMethodType Ugraene metode
ClassType Objekt klase
FunctionType Korisni£ka funkcija
InstanceType Instanca klase, objekt
MethodType Ograni£ena metoda
UnboundMethodType Neograni£ena metoda
Nutarnji tipovi CodeType Byte-compilirani kôd
FrameType Izvedbeni okvir
TracebackType Sloºaj slijeda izuzetaka
SliceType Tip kri²ke (odlomka)
EllipsisType Pro²ireni odlomci ()
Python program pristupa vrijednostima objekata preko njihovih identiteta, tj. njihovih adresnih
referenci. Referenca je broj, adresa memorije, na kojoj je spremljena vrijednost objekta. Vrijednost
objekta £esto se jo² zove atribut objekta. Atributi sloºenih tipova (npr. liste, stringa ili rje£nika) £esto
se jo² zovu £lanovi (engl. items ).
Identitet ili adresna referenca objekta sprema se u memorijsku lokaciju koja se zove varijabla. Varija-
bla moºe pokazivati na spremljeni literal, na isti na£in kao i na objekt koji ima vi²e vrijednosti(sadrºaja
memorijske lokacije) i/ili vi²e metoda. Svaka varijabla sa svojim sadrºajem moºe postojati samostalno,
a moºe biti i ugraena u neki objekt. Dohva¢anje varijable, tj. njezinog sadrºaja iz objekta postiºe se
sa obj.x, gdje je obj ime objekta, a x je ime varijable.
Jedna ili vi²e Python programskih naredbi moºe se spremiti u funkciju. Razlikuju se ugraene (engl.
built-in ) i korisni£ke funkcije. Funkcije, zajedno s podacima, grupiraju se u klase. Funkcije denirane
unutar klasa, zovu se metode. Od klase moºe nastati jedan ili vi²e objekata.
Korisni£ke funkcije denira korisnik, a ugraene dolaze s Python interpreterom. Dakako, i funkcija je
objekt. Ona se moºe postojati samostalno, a moºe biti ugraena unutar onekog drugog objekta. Metoda
Tipovi podataka 13
se iz klase/objekta dohva¢a sa obj.fun(), gdje je klasa/obj ime objekta, a fun() je ime funkcije. Unutar
okruglih zagrada mogu se pozvati argumenti, odnosno parametri funkcije. Funkcija moºe imati ulazne
argumente i vra¢ati izlazne vrijednosti.
Na primjer, provjera tipa nekog objekta ostvaruje se pozivom ugraene funkcije type():
>>> type("Zanimljivi Python svijet!") # string literal
<type 'str'>
>>> type(512) # numeri£ki literal
<type 'int'>
>>> k=2.178 # varijabla k
>>> type(k)
<type 'float'>
>>> type ({ 'a':72, 'b':1.4 })
<type 'dict'>
>>> z=2+3j # varijabla z
>>> type(z)
<type 'complex'>
Objekti (varijable, funkcije, klase i dr.) s programskim naredbama koje na njima rade mogu se
spremati u module, a moduli u pakete. Modul se u memoriju u£itava s pomo¢u naredbe 'import'.
import sys # ucitava se modul sistemskih funkcija
Pojedina£ni podatak ili funkcija iz modula dohva¢a se naredbom 'from ... import ... ' :
from math import sin, cos # u£itavaju se samo sin() i cos() funkcije
Dohva¢anje vrijednosti podatka preko atributa objekta postiºe se sintaksom 'objekt.atribut'.
Objekt moºe imati vi²e atributa. U slu£aju da je atribut neka funkcija, odgovaraju¢a sintaksa je
'objekt.atribut()'.
>>>import math
>>> print math.pi, math.sin(2.3)
3.14159265359 0.745705212177
Dohva¢anje vrijednosti podatka preko £lanova, £esto se naziva indeksiranje i odnosi se samo na
strukturirane tipove podataka (liste, stringove i sl.). Indeksacija po£inje s nultim (0) indeksom.
>>> x=[1, 3, 9, 16] # lista s £etiri podatka

>>> print x[3] # dohva¢anje tre¢eg podatka
16
Vrijednost reference (njena adresa u memoriji) moºe se doznati pozivom funkcije id(). Pridruºi-
vanjem objekata referenca se ponavlja, tj. objekti se ne dupliciraju. U memoriji ostaje samo jedan
podatak, a dvije varijable pokazuju na njega (imaju njegovu adresu).
>>> a=123
>>> id(a)
3695888
>>> b=a # pridruºba b sa a; objekt se ne kopira, samo adresa
>>> b
123
>>> id(b) # b kao i a pokazuje na istu memorijsku adresu
3695888
>>> a=a+1 # stvoren je novi objekt
>>> print 'a=',a,' b=',b
a= 124 b= 123
14 Tipovi podataka
>>> print 'id(a)=',id(a),' id(b)=',id(b) # ne pokazuju isto!

id(a)= 3695876 id(b)= 3695888
Izraz (engl. expression ) je kombinacija vrijednosti (literala), varijabli i operatora. Vrijednost izra£u-
natog izraza ispisuje se na zaslon ra£unala kori²tenjem naredbe ili funkcije print:
>>> print 'gruba aproksimacija pi = ', 22./7

gruba aproksimacija pi = 3.14285714286
Programske naredbe Pythona temelje se na pridruºivanju (objekata referencama), upravljanju tije-

kom programa (if, else,...), programskim petljama (for, while, ...) i pozivima funkcija i klasa.
Identikator je ime objekta, tj. ime varijable, funkcije, klase i sl. Identikatori ne smiju koristiti
neku od 30 klju£nih rije£i Python-a (tablica 2.2), jer su one pridruºene osnovnim Python naredbama.
Tablica 2.2: Python klju£ne rije£i

and del for is raise
assert elif from lambda return
break else global not try
class except if or while
continue exec import pass with
def finally in print yield
2.1 Brojevi
Ugraeni brojevni objekti u Pythonu podrºavaju cijele brojeve (obi£ne i duga£ke), brojeve s pomi£nim
zarezom (realne brojeve) i kompleksne brojeve. Objekti brojeva u Pythonu su nepromjenljivi ( immu-
table ) objekti, ²to zna£i da bilo kakva aritmeti£ka operacija na brojevnom objektu, uvijek stvara novi
brojevni objekt.
>>> a=1234
>>> id(a)
19431452
>>> a=a+0
>>> id(a)
18681652
>>> print a
1234
Literali cijelih brojeva mogu biti decimalni, oktetni, ili heksadecimalni. Decimalni literal je pred-
stavljen nizom znamenki gdje je prva znamenka razli£ita od nule. Oktetni literal je odreen s po£etnom
0 iza koje ide niz oktetnih znamenki (0 do 7). Na sli£an na£in heksadecimalni literal koristi po£etni niz
0x nakon £ega slijedi niz heksadecimalnih znamenki (0 do 9 i A do F bilo velikim ili malim slovom).
Na, primjer:
1, 23, 3493 # Decimalni cijeli brojevi

01, 027, 06645 # Oktetni cijeli brojevi
0x1, 0x17, 0xda5 # Heksadecimalni cijeli brojevi
Bilo kojem literalu cijelog broja moºe moºe se dodati slovo 'L' ili 'l' kako bi se ozna£io duga£ki cijeli
broj ( long integer ). Na primjer:
2.2. Nizovi 15
1L, 23L, 99999333493L # Duga£ki decimalni cijeli brojevi

01L, 027L, 01351033136165L # Duga£ki oktetni cijeli brojevi
0x1L, 0x17L, 0x17486CBC75L # Duga£ki heksadec. cijeli brojevi
Razlika izmeu duga£kog i obi£nog cijelog broja je u tome ²to duga£ki cijeli broj nema predodreenu
numeri£ku granicu; moºe biti toliko dug koliko ra£unalo ima memorije. Obi£an cijeli broj uzima nekoliko
okteta memorije i ima minimalnu i maksimalnu vrijednost koju diktira arhitektura stroja. sys.maxinit
je najve¢i dostupni obi£an cijeli broj, dok je sys.maxinit-1 najve¢i negativni.
>>> print sys.maxint # za uobicajeni stroj najveci cijeli broj je

2147483647
>>> 2L**500 # 2 na 500-tu potenciju 3273390607896141870013189696827599152216642046043064...
7894832913680961337964046745548832700923259041571508866841275600710092172565458853...
93053328527589376L
Realni literal (broj s pomi£nim zarezom) predstavljen je nizom decimalnih znamenki koje uklju£uju
decimalni zarez, tj. to£ku (.), exponent ( e ili E, te + ili - iza, s jednom ili vi²e znamenki na kraju), ili
oboje. Vode¢i znak decimalnog literala ne smije biti e ili E, a moºe biti bilo koja znamenka ili to£ka
(.). Na primjer:
0., 1.0, .2, 3., 4e0, 5.e0, 6.0e0
Pythonova decimalna vrijednost odgovara uobi£ajena 53 bita preciznosti na modernim ra£unalima.

Kompleksni broj sastavljen je od dviju decimalnih vrijednosti, jedne za realni, a druge za imaginarni
dio. Mogu¢e je pristupiti dijelovima kompleksnog objekta z kao samo-£itaju¢im "read-only" atributima
z.real i z.imag. Imaginarni literal dobije se dodavanjem znaka 'j' ili 'J' realnom literalu:
1j, 1.j, 1.0j, 1e0j, 1.e0j, 1.0e0j
Znak J (ili j ) na kraju literala ozna£uje kvadratni korijen od -1, ²to je uobi£ajena oznaka imaginarnog
dijela u elektrotehni£koj praksi (neke druge discipline koriste znak 'i' u tu svrhu, ali Python je izabrao
ba² znak j).
Treba primijetiti da brojevni literali ne uklju£uju predznak: ako postoji + ili - ispred broja, onda
su to posebni operatori.
x=input('Upi²ite prvi prirodni broj: ') y=input('Upi²ite drugi prirodni broj: ')
print "1) print "2)
> 1) 12 : 15 = 0 i ostatak 12 2) 12 : 15 = 0.800000 >
2.2 Nizovi
Niz je spremnik (engl. container ) £lanova (engl. items) koji se indeksiraju ili dohva¢aju ne-negativnim
cijelim brojevima. Python pruºa tri ugraene (engl. built-in ) vrste nizova za stringove (obi£ne i Uni-
code), n-terace, i liste. Knjiºni£ki i ekstenzijski moduli pruºaju druge vrste nizova, a korisnik takoer
moºe sam napisati svoje. Nizovi se mogu obraivati na vi²e na£ina.
2.2.1 Stringovi - nizovi alfanumeri£kih znakova

Ugraeni objekt string je poredan skup znakova koji se koristi za skladi²tenje i predstavljanje podataka
na tekstovnoj bazi. Nizovi znakova u Pythonu su nepromjenljivi (engl. immutable ), ²to zna£i da se
novom operaciijom na nizu znakova, uvijek proizvede novi niz, a ne modicira stari. Objekti stringa
imaju ugraeno vi²e metoda.
Literalni niz znakova moºe biti pod navodnicima jednostrukim, dvostrukim ili trostrukim navodni-
cima. String u navodnicima je niz od nula ili vi²e znakova unutar identi£nih znakova navodnika. Na
primjer:
16 Tipovi podataka
'Ovo je string literal'

"Ovo je novi string literal"
Dvije razli£ite vrste navodnika imaju identi£nu funkciju. Mogu se koristiti tako da apostroramo string
unutar stringa, ²to je £esto jednostavnije nego apostrorati string upotrebom posebnog znaka (
\'
za jednostruki ili
\"
za dvostruki navodnik):
' jel\' me netko trazio?' # eksplicitni navodnik u stringu

" jel' me netko trazio?" # Na ovaj nacin je citljivije
Ako se string ºeli prikazati u vi²e linija, onda se na koncu svake linije stavlja znak lijeve kose crte
(\):
"Ovo je prva, \
a ovo druga linija istog stringa" # Komentar nije dopusten na
# liniji sa znakom \
U stringu se dakako mogu umetati i posebni znakovi (\n za novu liniju, \t za tabulator i sl.), ako se
takav niz ºeli programom ispisivati:
"Ovo je prva, \n
a ovo druga linija istog stringa"
Drugi pristup je uporaba stringa s trostrukim navodnicima, koji se dobiju trostrukim ponavljanjem
jednostrukih ( ') ili dvostrukih navodnika (""").
"""A ovo je jedan duuugi string

koji se proteze na vise linija,
u ovom slucaju na tri""" # Komentar dopusten samo na kraju
U ovakvom literalu stringa s tri navodnika, automatski su sa£uvani novi redovi, pa se njihovi kontrolni
znakovi ne trebaju dodavati u niz. Nije dopu²tena ni upotreba nekih kontrolnih (tzv. 'escape') znakova
(tablica 2.3), kao na primjer znaka lijeve kose crte (engl. backslash;)
Tablica 2.3: 'Escape' znakovi
Niz Zna£enje ASCII/ISO kod

\ < novired > Konac linije se zanemaruje Nema ga
\\ Kosa crta ulijevo, backslash 0x5c
\0 Jednostruki navodnik 0x27
\” Dvostruki navodnik 0x22
\a Zvono, bell 0x07
2.2. Nizovi 17
Niz Zna£enje ASCII/ISO kod

\b Brisanje ulijevo, backspace 0x08
\f Nova stranica, form feed 0x0c
\n Nova linija, newline 0x0a
\r Skok u novi red, return 0x0d
\t Tabulator, tab 0x09
\v Vertikalni tabulator 0x0b
Oktalna vrijednosti ooo (\0000
\0ooo kako je zadano
do \0377)
Heksadecimalna vrijednost hh
\xhh kako je zadano
(\x00 do \xf f )
\uhhh Unicode vrijednosti Samo za Unicode str.
Unicode je novi standard za pisanje znakova. Za razliku od ASCII standarda, novi standard uklju£uje
sve znakove iz gotovo svih svjetskih jezika. Unicode literalni string ima istu sintaksu kao obi£ni literalni
string uz dodatak znaka 'u' ili 'U' koji se pi²e odmah ispred po£etnog navodnika. Unicode literalni nizovi
znakova mogu koristiti '\u' iza kojeg slijede £etiri heksadecimalne znamenke koje opisuju Unicode znak.
>>> a=u'str\xf6m gr\xfcn'

>>> print a
ström grün
Vi²e string literala bilo koje vrste napisanih u slijedu, compiler ¢e povezati u jedan string objekt.
>>> print 'koliko' 'je' 'tu' 'stringov' u'\xe4' '?'

kolikojetustringovä?
2.2.2 N-terac
N-terac je nepromjenljivi niz £lanova. lanovi u n-tercu su bilo koji objekti, istih ili razli£itih tipova. N-
terac se denira nabrajanjem objekata odvojenih zarezima (,). Zadnjem £lanu u nizu takodjer se moºe
dodati zarez. N-terac sa samo jednim £lanom mora imati zarez na kraju, jer ina£e gubi tip n-terca.
Prazan n-terac je ozna£en s praznim parom zagrada. £lanovi se mogu grupirati, pa nastaju ugnjeºdeni
n-terci.
(100, 200, 300) # N-terac s tri clana

(3.14,) # N-terac sa samo jednim clanom
( ) # Prazan n-terac
Za generiranje n-terca, osim nabrajanjem, mogu¢e je pozvati i ugraenu funkciju 'tuple()'. Ako je
x neki niz, onda tuple(x) vra¢a n-terac s £lanovima jednakima £lanovima niza x.
>>> x='abrakadabra'
>>> tuple(x)
('a', 'b', 'r', 'a', 'k', 'a', 'd', 'a', 'b', 'r', 'a')
>>> y='sezame'
>>> (x,y)
('abrakadabra', 'sezame')
2.2.3 Lista
Lista, listina ili popis je promjenljiv poredani niz £lanova objekata. £lanovi u listi su bilo kakvi objekti
razli£itih tipova. Lista se denira nabrajanjem £lanova odijeljenih zarezima (,) i smje²tenih unutar
uglatih zagrada ([ ]). Dopu²teno je iza zadnjeg £lana liste, ostaviti jo² jedan zarez. Prazna lista se
ozna£ava praznim parom uglatih zagrada. Evo nekih primjera:
18 Tipovi podataka
[42, 3.14, 'zdravo' ] # Lista s tri £lana

[123] # Lista s jednim £lanom
['a', [-45j, 'b'], 4.5] # ugnjeºdena lista s tri £lana
[ ] # Prazna lista
Na sli£an na£in, kao i s generiranjem n-teraca, mogu¢e je pozvati prikladnu funkciju 'list()' za generiranje
listi. Na primjer:
>>> a='ovo'
>>> b='je'
>>> c='lista'
>>> d=[a,b,c] # tvorba liste nabrajanjem £lanova
>>> print d
['ovo', 'je', 'lista']
>>> list(d) # tvorba liste pozivom funkcije
['ovo', 'je', 'lista']
>>> list(a) # tvorba liste pozivom funkcije
['o', 'v', 'o']
>>> type(d)
<type 'list'>
>>> type(a)
<type 'str'>
Treba primjetiti kako se tvorba listi preko list() funkcije uvijek realizira nad pripadnim tipom objekta.
2.3 Temeljne operacije i metode s nizovima

Dohva¢anje elementa bilo kojeg niza (stringa, n-terca, liste) postiºe se indeksiranjem. Dio niza, odlomak
ili kri²ka (engl. slice ) dobiva se sintaksom 'i:j' gdje je 'i' po£etni indeks, a 'j' zavr²ni indeks kri²ke
(tablica 2.4). Duºina niza dobiva se pozivom funkcije len(), a maksimalni i minimalni £lan niza s
funkcijama max(), odnosno min().
Tablica 2.4: Operacije i metode nad svim nizovima
£lan Opis
s[i] Vra¢a element i u nizu s
s[i:j] Vra¢a kri²ku - niz elemenata od i-tog do j-tog indeksa
len(s) Vra¢a broj elemenata u s
min(s) Vra¢a minimalni elemenat iz s
max(s) Vra¢a maksimalni elemenat iz s
Promjenljivi nizovi (liste) imaju mogu mijenjati £lanove ili kri²ke £lanova odjednom, kao i brisati
£lanove i skupine £lanova.
>>> a=(1,3,5,7,9)
>>> print a[0], a[3]
1 7
>>> b='ovo je string'
>>> print b[9],b[0],b[-1]
r o g
>>> c=[7,'marko',-5,'kompleksni']
>>> print c[3],c[1]
kompleksni marko
2.3. Temeljne operacije i metode s nizovima 19
>>> print len(a),len(b),len(c)

5 13 4
>>> print max(a), max(b), max(c)
9 v marko
>>> print min(a), min(b), min(c)
1 -5
>>> print a[1:3],b[7:12],c[0:2]
(3, 5) strin [7, 'marko']
Treba primjetiti kako se dohva¢anje £lanova preko indeksa u kri²kama ostvaruje od po£etnog indeksa
do kona£nog, ali koji se pritom isklju£uje, ne uzima u obzir. Negativan indeks pak dohva¢a £lanove od
kraja niza. Tako je '-1' indeks za zadnji £lan, '-2' za predzadnji i tako dalje.
Budu¢i da se u kategoriji nizova samo liste mogu mijenjati direktno, postoje pridruºbe £lanovima
liste i funkcije brisanja £lanova (tablica 2.5). Obje operacije mogu se izvesti nad pojedina£nim i skupnim
£lanovima liste.
Tablica 2.5: Pridruºba i brisanje
£lan Opis
s[i] = v Pridruºba £lanu na i-tom mjestu
s[i:j] = t Pridruºba skupini £lanova
del s[i] Brisanje £lana
del s[i:j] Brisanje skupine £lanova
Evo kratkog primjera:
>>> lista=['tko zna','bilje','²iroko mu','polje']

>>> lista[1]='bolje'
>>> lista
['tko zna', 'bolje', '²iroko mu', 'polje']
>>> lista[1:3]=[',zna!']
>>> lista
['tko zna', ',zna!', 'polje']
>>> del lista[-1]
>>> lista
['tko zna', ',zna!']
2.3.1 Ugraene metode string-ova

Budu¢i da svaki objekt ima £lanove (varijable) i metode (funkcije), korisno ih je skupno prikazati
(tablica 2.6), te isprobati ugraeno. Nabrojene metode nalaze se u modulu 'string', pa u primjerima
prije njihove uporabe treba pozvati naredbu 'from string import *'
Tablica 2.6: String metode
Metoda Opis
s.capitalize() Pretvara svako slovo od s u veliko slovo.
s.center(width) Centrira string u polju duljine width.
20 Tipovi podataka
Metoda Opis
s.count(sub[,start
Broji pojavljivanja podstringa sub u stringu s.
[,end]])
s.encode([encoding
Vra¢a kodiranu ina£icu stringa.
[,errors]])
s.endswith(suffix
Provjerava kraj stringa za sux.
[,start[,end ]])
s.expandtabs([tabsize]) Pro²iruje tabulatore praznim mjestima.
Pronalazi prvo pojavljivanje zadanog
s.find(sub[,start[,end]])
podstringa sub.
Pronalazi prvo pojavljivanje zadanog
s.index(sub[,start[,end]]) podstringa sub uz podizanje izuzetka, ako ga
nema.
s.isalnum() Provjerava jesu li svi znakovi alfanumeri£ki.
s.isalpha() Provjerava jesu li svi znakovi alfabetski.
s.isdigit() Provjerava jesu li svi znakovi znamenke.
Provjerava jesu li svi znakovi pisani malim
s.islower()
slovima.
s.isspace() Provjerava jesu li svi znakovi praznine.
Provjerava jeli string pisan kao naslov (prvo
s.istitle()
slovo svake rije£i napisano velikim slovom).
Provjerava jesu li svi znakovi pisani velikim
s.isupper()
slovima.
Povezuje stringove u listi t koriste¢i s kao
s.join(t )
mea².
s.ljust(width ) Lijevo poravnanje s u stringu duljine width.
s.lower() Vra¢a s pretvoren u string s malim slovima.
s.lstrip() Odstranjuje prazna mjesta ispred stringa.
s.replace(old , new
Zamjenjuje podstring old sa new.
[,maxreplace ])
s.rfind(sub[,start[,end]]) Nalazi zadnji pojavak podstringa sub.
Nalazi zadnji pojavak podstringa sub ili javlja
s.rindex(sub[,start[,end]])
izuzetak
s.rjust(width) Desno poravnanje s u stringu duljine width.
s.rstrip() Odstranjuje prazna mjesta iza stringa.
Dijeli string koriste¢i sep kao mea².
s.split([sep[,maxsplit]]) maxsplit je nave¢i broj dijeljenja koji ¢e se
izvr²iti.
Dijeli string u listu linija. Ako je keepends
s.splitlines([keepends]) jednak 1, £uvaju se kontrolni znakovi novih
redaka.
s.startswith(prefix
Provjerava da li string zapo£inje s prefix-om
[,start [,end ]])
Odstranjuje prazna mjesta i ispred i iza
s.strip()
stringa.
2.3. Temeljne operacije i metode s nizovima 21
Metoda Opis
Vra¢a velika slova za string malih slova i
s.swapcase()
obratno.
s.title() Vra¢a verziju stringa kao naslova.
s.translate(table Mijenja string koriste¢i transformacijsku
[,deletechars ]) tablicu znakova.
s.upper() Vra¢a string pretvoren u velika slova.
Primjer 2.1 String je nepromjenljivi objekt, pa se njegova promjena mogu¢a tek stvaranjem novog
stringa. treba primjetiti kako se aritmeti£ki znak '+' koristi za povezivanje stringova, dok '1:' ozna£uje
sve znakove nakon prvog.
, ,
>>> s1 = " Moj san "
>>> s2 = ' Tv ' + s1 [1:]
>>> print s2 Tvoj san
>>>
Primjer 2.2 Modul 'string' sadrºi mnogo funkcija. Funkcija 'nd' pronalazi podstring u zadanom
stringu. Vra¢a poziciju naenog podstringa
, ,
>>> import string
>>> riba = " zubatac "
>>> index = string . find ( riba , " t " )
>>> print index 4
>>>
>>> string . find ( " abrakadabra " , " ra " )
>>> string . find ( " abrakadabra " , " ra " ,4)
>>> 2
9
2.3.2 Ugraene metode listi

Na sli£an na£in, s pomo¢u tablice 2.7 mogu se u primjerima provjeriti ugraene metode koje olak²avaju
rad s listama.
Tablica 2.7: Metode liste
Metoda Opis
li.append(x) Dodaje novi element x na kraj liste li.
li.extend(t) Dodaje novu listu t na kraj liste li.
li.count(x) Broji pojavke od x u listi li.
li.index(x) Vra¢a najmanji i za koji je s[i] == x .
li.insert(i,x) Ume¢e x na indeksu i .
22 Tipovi podataka
Metoda Opis
Vra¢a element i i bri²e ga iz liste. Ako se i
li.pop([i])
izostavi, onda se vra¢a zadnji element.
li.remove(x) Traºi x i bri²e ga iz liste li.
li.reverse()) Reverzira (obr¢e) £lanove liste li na mjestu.
Sortira (slaºe) £lanove liste li na mjestu.
li.sort([cmpfunc ])
cmpfunc() je funkcija za usporedbu.
Primjer 2.3 Matrica je lista listi.
, ,
>>> matrica = [[1 , 2 , 3] , [2 , 3 , 1]]
>>> matrica [1] [2 , 3 , 1]
>>> matrica [0][2] 3
2.4 Rje£nik
Preslikavanje (engl. mapping ) je skup objekata indeksiranih s pomo¢u gotovo slobodnih vrijednosti
koje se zovu klju£evi (engl. keys ). Tako nastali objekti su promjenljivi, a za razliku od nizova, nisu
poredani.
Python nudi jednu vrstu preslikavanja, rje£nik (engl. dictionary ). Knjiºni£ki i ekstenzijski moduli
pruºaju jo² vrsta preslikavanja, a druge moºe na£initi korisnik sâm. Klju£evi u rje£niku mogu biti
razli£itih tipova, ali moraju biti jednozna£ni (engl. hashable ). Vrijednosti u rje£niku su takoer objekti
i to mogu biti razli£itih tipova. £lan u rje£niku je par kju£/vrijednost (engl. key/value ). O rje£niku se
moºe razmi²ljati kao o asocijativnom polju.
Eksplicitno stvaranje rje£nika provodi se nizom parova klju£:vrijednost odvojenih zarezima, koji se
smje²taju unutar viti£astih zagrada. Dopu²ten je i zarez nakon zadnjeg £lana. Ako se klju£ pojavljuje
vi²e od jednom u rje£niku, samo se jedan od £lanova s tim klju£em sprema, jer klju£ mora biti jedincat.
Drugim rije£ima, rje£nici ne dozvoljavaju duplikate klju£eva. Prazan se rje£nik ozna£uje parom praznih
viti£astih zagrada. Evo nekih rje£nika:
{'x':42, 'y':3.14, 'z':7} # Rjecnik s tri clana i string kljucevima

{1: 2, 3:4} # Rjecnik s dva clana i cjelobrojnim kljucevima
{ } # Prazan rjecnik
Tvorbu rje£nika mogu¢e je izvesti i s pomo¢u ugraene funkcije dict(). Na primjer:
>>> dict([['a',12],['b',54]])
{'a': 12, 'b': 54}
>>> dict(a='zagreb', d='ogulin', e='Osijek')
{'a': 'zagreb', 'e': 'Osijek', 'd': 'ogulin'}
>>> dict([[12,'akumulator'],['baterija',4.5]])
{'baterija': 4.5, 12: 'akumulator'}
dict( ) bez argumenata stvara i vra¢a prazan rje£nik. Ako se klju£ pojavljuje vi²e nego jednom u
popisu (argumentima funkcije dict), samo ¢e se posljednji £lan s tim kju£em zadrºati u rezultiraju¢em
rje£niku.
2.4.1 Ugraene metode rje£nika

Na sli£an na£in, s pomo¢u tablice 2.8 mogu se u primjerima provjeriti ugraene metode koje olak²avaju
rad s rje£nicima.
2.5. Skup 23
Tablica 2.8: Metode i operacije tipova preslikavanja (rje£nika)
£lan/metoda Opis
di[k] Vra¢a £lan od di s klju£em k .
di[k] = x Postavlja di[k] na x.
del di[k] Bri²e di[k]iz di .
di.clear() Bri²e sve £lanove iz di.
di.copy() Vra¢a kopiju od di.
di.has-key(k) Vra¢a 1 ako di ima klju£ k , a 0 ina£e.
di.items() Vra¢a listu od (key ,value) parova.
di.keys()) Vra¢a listu od vrijednosti klju£eva.
di.update(b) Dodaje sve objekte iz rje£nika b u di .
di.values() Vra¢a listu svih vrijednosti spremljenih u di .
di.get(k [,v]) Vra¢a di[k] ako nae; ina£e vra¢a v .
Vra¢a di[k] ako nae; vra¢a v i postavlja
di.setdefault(k[, v])
di[k]=v .
Vra¢a slu£ajne (key ,value) parove kao
di.popitem()
n-terce iz di.
2.5 Skup
Od Python ver. 2.4, postoji ugraeni tip (iako takoer postoji i modul s imenom 'sets') s dvije varijante
- obi£an i zamrznuti skup. Skup je neporedan niz jedincatih (neponavljaju¢ih) elemenata. Elementi
moraju biti jednozna£ni, engl. hashable. Zamrznuti skupovi su jednozna£ni, pa mogu biti elementi
drugih skupova, dok obi£ni skupovi to ne mogu biti.
Tablica 2.9: Glavne operacije skupova
Operacija Rezultat
[koristi se za ugraene tipove] tvorba obi£nih
set/frozenset
ili zamrznutih skupova iz iterabilnog niza, npr.
([iterabilno=None])
set([5,2,7]), set("zdravo")
[koristi se za set modul] tvorba obi£nih ili
Set/ImmutableSet
nepromjenljivih skupova iz iterabilnog niza,
([iterabilno=None])
npr. Set([5,2,7])
len(s kardinalni broj skupa s
Istinito ako element elem pripada / ne pripada
elem in s / not in s
skupu s
for elem ins: process
Iterira na elementima skupa s
elem...
s1.issubset(s2) s1 u s2
Istinito ako je svaki element u
s1.issuperset(s2) s2 u s1
Istinito ako je svaki element u
s.add(elem) Dodaje element elem u skup s
Bri²e element elem u skupu s. Podiºe
s.remove(elem))
KeyError iznimku ako se element ne pronae
24 Tipovi podataka
Operacija Rezultat
Bri²e sve elemente iz skupa s (ne vrijedi za
s.clear()
nepromjenljive skupove!)
s1.intersection(s2) ili Vra¢a novi skup s elementima zajedni£kim u
s1&s2 s1 i s2
Vra¢a novi skup s elementima koji su i u s1 i
s1.union(s2) ili s1|s2
u s2.
s1.symmetric_difference(s2) Vra¢a novi skup s elementima koji su ili u
ili sl∧s2 s1,ili u s2, ali ne na oba mjesta
s.copy() Vra¢a kopiju skupa s
Dodaje sve vrijednosti iz iterabilnog niza u
s.update(iterabilni niz
skup s
POGLAVLJE 3
Izrazi, operatori i operacije
3.1 Varijable
Python pristupa podacima s pomo¢u referenci. Jedna takva referenca je varijabla, tj. imenovani prostor
u memoriji koji £uva adresu nekog objekta ili literala. Referenca takoer postoji i na atribut (vrijednost)
nekog objekta. Varijabla ili druga vrsta reference nemaju svoj vlastiti tip, za razliku od podatka na
kojeg pokazuju, kojeg referenciraju tj. £iju adresu pohranjuju. Budu¢i da je adresa jedinstvena u
smislu broja okteta, svaka referenca moºe povezati objekte razli£itih tipova, ²to zna£i da je dinami£na,
da se moºe mijenjati prilikom izvr²enja programa. U jednom trenutku varijabla moºe pokazivati na
cjelobrojni podatak, a ve¢ u sljede¢em na realni, kompleksni ili neki sloºeni tip.
U Pythonu nema deklaracija. Postojanje varijable ovisi o naredbi koja povezuje (eng. binding )
varijablu i podatak; drugim rije£ima, naredbi koja imenuje neki objekt, bilo kojeg tipa. Mogu¢e je
odvezati (eng. unbinding ) varijablu resetiranjem njenog imena, tako da vi²e ne sadrºi referencu na taj
objekt. Naredba del odvezuje reference.
Povezivanje reference koja je ve¢ povezana poznato je kao re-povezivanje (eng. rebinding ). Re-
povezivanje ili odvezivanje reference nema nikakv u£inak na objekt s koji je referenca bila povezana,
osim ²to objekt nestaje ako vi²e ne postoji nikakva referenca koja se na njega odnosi. Odvezani objekti
sami ¢e nestati iz memorije. Za to se brine poseban Python modul, ugraen u interpreter. Takvo
automatsko £i²¢enje objekata bez referenci zove se sakupljanje sme¢a (engl. garbage collecting).
Varijabla se moºe imenovati bilo kojim identikatorom, osim onih 30 koji su rezervirani kao Python
klju£ne rije£i. Pritom identikator ima i neka svoja pravila: ne smije imati zabranjene simbole u sebi,
ne smije po£injati brojem i sl. Varijabla moºe biti globalna ili lokalna. Globalna varijabla je dohvatljiva
s vi²e razina, a lokalna uglavnom u funkciji u kojoj se koristi.
3.2 Naredbe pridruºivanja

Naredbe pridruºivanja mogu biti obi£ne ili pro²irene. Obi£no pridruºivanje varijabli (npr. name=value)
je na£in stvaranja nove varijable ili re-povezivanja postoje¢e varijable na novu vrijednost (tj. promjena
vrijednosti). Obi£na pridruºba na atribut objekta (npr. obj.attr=value) je zahtjev objektu obj da
stvori ili re-poveºe atribut attr. Obi£na pridruºba za £lan u nekom nizu ili preslikavanju (listi ili
rje£niku) (npr. obj[key] = value) je zahtjev spremniku obj da stvori ili re-poveºe £lan s indeksom
key. Takva pridruºba uklju£uje indeksiranje niza.
Pro²irena pridruºba (npr. name+=value) ne stvara nove reference, nego samo re-povezuje varija-
blu. Postoje¢i objekt re-povezuje sebe ili jedan od svojih atributa ili £lanovas novom vrijedno²¢u.
Taj se zahtjev uspje²no izvr²ava ili se podiºe iznimka, kojom se javlja neka vrsta pogre²ke. Iznimka
25
26 Izrazi, operatori i operacije
(engl. exception ) je na£in na koji Python rje²ava pogre²ke bilo kojeg tipa. Ako se na primjer, re-
povezivanjem varijable s aritmeti£kim sadrºajem dogodi dijeljenje s nulom, Python ¢e podi¢i iznimku
ZeroDivisionError. Pythen dakako, ima ugraene naredbe za dohva¢anje i obrade iznimki.
3.2.1 Obi£na pridruºba

Naredba obi£ne pridruºbe u svom najjednostavnijem obliku ima sintaksu:
cilj = izraz
Cilj ili odredi²te (engl. target ) je poznat kao lijeve strana pridruºbe, a izraz (engl. expression ) je
desna strana. Izraz moºe biti obi£na varijabla ili vi²e varijabli povezanih operatorima, poziv funkcije ili
mno²tvo drugih kombinacija s meusobno povezanim objektima. Kad se naredba pridruºbe izvr²ava,
Python izra£unava izraz desne strane, te povezuje vrijednost izraza s ciljem na lijevoj strani. Ovo
povezivanje ne ovisi o tipu izra£unate vrijednosti desne strane, jer se pridruºba ionako dogaa na
razini referenca, adresa objekata, a ne njihova sadrºaja. Cilj moºe biti varijabla /identikator, atribut,
indeksirani £lan niza ili kri²ka slicing ) .
(engl.
Detalji povezivanja ovise o vrsti ili tipu cilja:
• Identikator je ime varijable: pridruºba na identikator povezuje sadrºaj varijable s tim imenom,
upisom adrese pod ime identikatora.
• Referenca atributa ima sintaksu obj.name. Pritom je obj identikator koji ozna£ava objekt, a
name atributivno ime objekta. Pridruºba na referencu atributa traºi da objekt obj poveºe svoj
atribut zvan name s izra£unatom ili pozvanom vrijedno²¢u desne strane.
• Indeksiranje ima sintaksu obj[expr]. Pritom je obj objekt, a expr je izraz koji indeksira mjesto
u nizu. Objekt moºe biti bilo kojeg tipa. Pridruºba na indeksiranje traºi da spremnik obj poveºe
svoj £lan koji je izabran pomo¢u vrijednosti expr, takoer poznate i kao indeksni klju£ £lana s
izra£unatom ili pozvanom vrijedno²¢u desne strane.
• Kri²ka (eng. slicing ) ima sintaksu obj[start:stop] ili obj[start:stop:korak]. Pritom je

Obj objekt, a start, stop i korak su izrazi koji koji indeksiraju dio niza objekata. (Dopu-
²teno je izostavljanje £lanova, pa je obj[:stop:] sintaksno ispravna kri²ka, ekvivalentna s
obj[None:stop:None]). Pridruºba traºi od niza objekata obj da se poveºu ili odveºu neki od
njegovih £lanova.
U jednostavnoj pridruºbi moºe biti vi²e ciljeva i znakova jednakosti (=). Na primjer:
a = b = c = 0
povezuje varijable a, b, i c s vrijednosti 0. Svaki cilj se povezuje s jednim objektom koji vra¢a izraz,
isto kao kad bi se nekoliko jednostavnih naredbi izvr²avale jedna za drugom.
Cilj u jednostavnoj pridruºbi moºe imati dvije ili vi²e referenci odvojenih zarezima, proizvoljno
ograenih lu£nim ili kutnim zagradama. Na primjer:
a, b, c = x
Ovo zahtijeva da x bude niz od tri £lana, te povezuje a s prvim £lanom, b s drugim, te c s tre¢im.
Ova vrsta pridruºbe zove se raspakiravaju¢a pridruºba i pritom izraz s desne strane mora biti niz s
to£nim brojem £lanova koliko ima i referenci u cilju, jer se ina£e podigne iznimka. Svaka referenca u
cilju je jednozna£no povezana s odgovaraju¢im £lanom u nizu. Raspakiravaju¢a pridruºba takoer moºe
izmjenjivati reference. Na primjer:
a, b = b, a
3.2. Naredbe pridruºivanja 27
Ovaj izraz re-povezuje a da se pridruºi na ono ²to je u b bilo povezano, i obratno.
Primjer 3.1 Program ra£una n-ti Fibonnaccijev broj za une²eni prirodni broj n.
,
% ovdje dolazi izvorni kod Matlab programa
n = input ( " Inesite prirodni broj n : " )
pret , tren =1 ,1 # asociranje vrijednosti varijablama prethodnik , trenutni

for i in range (0 ,n -1): # i element niza 0 ,1 ,... , n -1
tren , pret = pret + tren , tren # pridruzivanje vrijednosti varijablama
,print " \ n %d - ti Fibonnaccijev broj je % d " %( n , tren )

% ovdje dolazi rjeÜenje koje program daje
4
2
9
3.2.2 Pro²irena pridruºba

Pro²irena pridruºba razlikuje se od obi£ne pridruºbe u tomu, ²to se umjesto znaka jednakosti (=)
izmeu cilja i izraza s desne strane koristipro²ireni operator, tj. binarni operator nakon kojeg slijedi =.
Operatori pro²irene pridruºbe su: + =,− =, ∗ =, / =, // =, % =, ∗∗ =, | =, >>=, <<=, & = i ∧ =.
Pro²irena pridruºba (tablica 3.1) moºe imati samo jedan cilj na lijevoj strani, tj. pro²irena pridruºba
ne podrºava vi²e ciljeva.
Tablica 3.1: Pro²irena pridruºba
Operacija Ekvivalentno sa
x+ = y x=x+y
x− = y x=x−y
x∗ = y x=x∗y
x/ = y x = x/y
x∗∗=y x = x ∗ ∗y
x% = y x = x%y
x& = y x = x&y
x| = y x = x|y
x∧ = y x=x∧y
x >>= y x = x >> y
x <<= y x = x << y
3.2.3 Naredba del

Unato£ svome imenu, naredba del ne bri²e objekte, nego odvezuje njihove reference. Brisanje objekta
je implicitna posljedica sa sakupljanjem sme¢a, kad ne postoji vi²e nijedna referenca na taj objekt.
U Pythonu (sli£no kao u Java programskom jeziku) postoji ugraeni sakuplja£ sme¢a (engl. garbage
collector ) koji oslobaa memorijski prostor zauzet objektima koji se ne referenciraju. To se dogaa na
sistemskoj razini, cikli£ki, tijekom izvoenja programa. Naredba del sastoji se od klju£ne rije£i del,
nakon koje slijedi jedna ili vi²e ciljnih referenci objekata odvojenih zarezima (,). Svaki cilj moºe biti
varijabla, referenca atributa, indeksiranje ili kri²ka, ba² kao za naredbe pridruºbe, te mora biti povezan
u vrijeme izvr²avanja naredbe del. Ako je cilj del-a identikator, naredba del izvodi odvezivanje
varijable, tj. bri²e adresu koju je identikator imao. Dok god je identikator povezan s objektom, takvo
odvezivanje je dopu²teno: kad god se eksplicitno zahtijeva, onda se i izvr²i. U drugim slu£ajevima,
naredba del specicira zahtjev objektu da odveºe neke (ili sve) svoje atribute ili £lanove. Objekt
moºe odbiti odvezati neke (ili sve) atribute ili £lanove, podiºu¢i iznimku ako se poku²ava nedopu²teno
odvezivanje. Odvezivanje (ili brisanje) kri²ke obi£no ima jednak u£inak kao pridruºba praznog niza toj
kri²ki.
3.2.4 Bool -ove vrijednosti

Poslije Pythona ver. 2.3 postoji eksplicitna verzija Bool -ove (engl. boolean ) vrijednosti za Python. Bool -
ove vrijednosti True i False postaju tip (podklasa od int). U ranijim Python verzijama ozna£avale
su se s '1 ' i '0'. Svaka podat£ana vrijednost u Pythonu ima vrijednost istine: istinito ili laºno, ovisi
o tomu je li ta vrijednost razli£ita ili jednaka nuli. U tipu string nuli odgovara prazan string "", kod
n-terca prazan n-terac (), kod rje£nika prazan rje£nik {} i sl. Python takoer ima nekoliko ugraenih
funkcija koje vra¢aju Bool -ove vrijednosti kao rezultate.
Na£injene promjene u novim verzijama Pythona bile su prakti£ne, jer je lak²e govoriti o funkcijama
i izrazima koje " vra¢anje True ili False " nego govoriti o izrazima razli£itim ili jednakim nuli. Ove
promjene takoer omogu¢uju pisanje £i²¢eg kôda, npr. kada se ºeli vratiti vrijednost istine pi²e se
return True, umjesto neprikladnog return 1).
3.3 Operatori i operacije

Izraz je dio programskog kôda koji Python interpreter moºe izvr²iti kako bi proizveo neku vrijednost.
Najjednostavniji izrazi su literali i identikatori (varijable). Sloºeniji izrazi grade se tako da se jednos-
tavni izrazi povezuju operatorima. Tablica 3.2 opisuje operatore po prioritetima, od vi²ih prema niºima.
Operatori koji su zajedno imaju jednak prioritet. Stupac A ispisuje asocijativnost (djelovanje s obzirom
na stranu) operatora, koja moºe biti L (s lijeva na desno), D (s desna na lijevo) ili NA (neasocijativna).
Na primjer, operator '<' nije asocijativan, jer bi x <y zamjenom mjesta identikatora (y < x) dao
sasvim suprotan rezultat.
Tablica 3.2: Prioritet operatora u izrazima
Operator Opis A
'izraz,...' String pretvorba NA
key:izraz,... Stvaranje rje£nika NA
[izraz,...] Stvaranje liste NA
Stvaranje n-terca ili
(izrazr,...) NA
jednostavne zagrade
f(izraz,...) Poziv funkcije L
x[index1:index2] Kri²ka (slicing) L
x[index] Indeksiranje (indexing) L
x.attr Referenca atributa L
x**y Eksponent (x na y potenciju) D
x Bitwise NE (NOT) NA
+x, -x Unarni plus ili minus NA
Mnoºenje, dijeljenje, dijeljenje
x*y, x/y, x//y, x%y L
na cijeli broj, ostatak
3.3. Operatori i operacije 29
Operator Opis A
x+y, x-y Zbajanje, oduzimanje L
xy, xy Lijevi pomak, desni pomak L
x&y Bitwise I (AND) L
x∧y Bitwise eksluzivni ILI (XOR) L
x|y Bitwise ILI (OR) L
x < y, x <= y, x > y, x >=
Usporedbe NA
y, x <> y, x! = y, x == y
x is y, x is not y Provjera identiteta NA
x in y, x not in y Provjera £lanstva NA
not x Bool-ov NE (NOT) NA
x and y Bool-ov I (AND) L
x or y Bool-ov ILI (OR) L
Anonimna jednostavna
lambda arg,...: izraz NA
funkcija
Operatori usporedbe mogu se nizati, £ime se implicira logi£na I (and) funkcija. Na primjer:
a < b <= c < d
ima isto zna£enje kao:
a < b and b <= c and c < d
Oblik prvog niza je mnogo £itljiviji, a provjerava svaki podizraz samo jednom.
Primjer 3.2 Program provjerava ispravnost Boolovih tvrdnji.

,
print " \ n === Boolova algebra === "

uvjet1 = True
uvjet2 = False
print " ----------- AND - - - - - - - - - -- - - "

print uvjet1 , " and " , uvjet1 , " = " , uvjet1 and uvjet1
print uvjet1 , " and " , uvjet2 ," = " , uvjet1 and uvjet2
print " \n - - - - - - - - - - OR - - - - - - - - - -- - - - "

print uvjet1 , " or " , uvjet1 , " = " , uvjet1 or uvjet1
print uvjet1 , " or " , uvjet2 ," = " , uvjet1 or uvjet2
,print " -----------------------------"

4
2
9
3.3.1 Numeri£ke i aritmeti£ke operacije

Python nudi uobi£ajene numeri£ke operacije, kako se vidi u tablici 3.3. Svi su brojevi samo£itaju¢i
(engl. readonly ) objekti, pa bilo koja numeri£ka operacija na brojnom objektu, uvijek proizvodi novi
brojni objekt. Objekt kompleksnog broja z takoer ima samo£itaju¢e (atribute z.real i z.imag.
Poku²aj repovezivanja ovih atributa na kompleksnom objektu podiºe iznimku. Treba primjetiti da +
ili - znak nekog broja, kao i isti znakovi koji pridruºuju realni literal imaginarnom, kako bi se na£inio
kompleksan broj, nisu dijelovi sintakse literala. Iz tog razloga se na primjer, -2 ** 2 izra£unava kao
-4, jer potenciranje ima vi²i prioritet od znaka minusa, pa se cijeli izraz prevodi kao -(2 ** 2), a ne
kao (-2) ** 2.
Tablica 3.3: Numeri£ke operacije
Operacija Opis
x+y Zbrajanje
x−y Oduzimanje
x∗y Mnoºenje
x/y Dijeljenje
x ∗ ∗y Potenciranje (x ∧ y)
x%y Modulo funkcija (x mod y )
−x Unarni minus
+x Unarni plus
Ugraena divmod funkcija uzima dva argumenta i vra¢a par £iji su £lanovi kvocijent i ostatak, ²to je
jednostavnije nego koristiti operator // za cjelobrojno dijeljenje i % za ostatak (tablica 3.4). Ugraena
pow(a,b) funkcija vra¢a isti rezultat kao i a**b. Poziv funkcije pow() s tri argumenta, pow(a,b,c)
vra¢a isti rezultat kao i (a**b)%c, ali brºe.
Tablica 3.4: Ugraene aritmeti£ke funkcije
Funkcija Opis
abs(x) Apsolutna vrijednost
divmod(x,y) Vra¢a (int(x / y ), x % y )
pow(x,y [,modulo]) Vra¢a (x ∗ ∗y)x%modulo
Zaokruºuje na najbliºi vi²ekratnik od 10−n
round(x,[n])
(samo za za realne brojeve)
3.3.2 Prisilna i eksplicitna pretvorba

Arithmeti£ke operacije i usporedbe mogu se primijeniti izmeu bilo koja dva broja. Ako se tipovi ope-
ranada razlikuju, primjenjuje se prisila : Python prepravlja operande tako da one manjeg tipa pretvara
u ve¢i. Poredani od najmanjeg do najve¢eg, tipovi brojeva su sljede¢i: cijeli brojevi, duga£ki cijeli
brojevi, decimalni (realni, s pomi£nim zarezom) brojevi i kompleksni brojevi.
Eksplicitna pretvorba moºe se primijeniti tako da se numeri£ki argument preda ºeljenoj ugraenoj
funkciji: int, long, float te complex. U tom slu£aju int i long ¢e odbaciti decimalni dio svog
argumenta i zadrºati samo cijeli, npr. int (9.8) je 9. Konverzija pak kompleksnog broja na bilo koji
drugi tip broja, odbacuje imaginarni dio. Za tvorbu kompleksnog broja mogu¢e je pozvati ugraenu
funkciju complex s dva argumenta, koji predstavljaju realni i imaginarni dio.
Int i long takoer se mogu pozvati s dva argumenta: prvi je niz znakova za pretvorbu, a
Funkcije
drugi baza (radix), tj. cijeli broj izmeu 2 i 36 kao baza za pretvorbu (npr. int('1101',2) vra¢a 13,
vrijedost '1101' u bazi 2).
3.4. Operacije na nizovima 31
3.3.3 Usporedba
Svi objekti, uklju£uju¢i brojeve, mogu se usporeivati s obzirom na jednakost (==) i nejednakost (!=).
Usporedbe koje zahtijevaju poredak (<, <=, >, >=) mogu se koristiti izmeu bilo koja dva broja osim
kompleksnih. Svi takvi operatori vra¢aju Bool-ove vrijednosti (True ili False). Operatori usporedbe
(tzv. odnosni operatori ) prikazani su u tablici 3.5.
Tablica 3.5: Operatori usporedbe
Operator Opis
x < y Manje nego
x > y Ve¢e nego
x == y Jednako
x != y Nije jednako (isto kao <>)
x >= y Ve¢e nego ili jednako
x <= y Manje nego ili jednako
3.3.4 Operacije na bitovima cijelih brojeva

Cijeli brojevi i duga£ki cijeli brojevi mogu se promatrati kao nizovi bitova i koristiti u operacijama
s bitovima (engl. bitwise operation) prikazanima u Tablici 3.6. Operatori na bitovima imaju niºi
prioritet nego arithmeti£ki operatori. Pozitivni cijeli brojevi pro²ireni su neograni£enim nizom bitova
'0' nalijevo. Negativni cijeli brojevi predstavljeni su dvojnim komplementom, te pro²ireni neograni£enim
nizom bitova '1' nalijevo.
Tablica 3.6: Operacije na bitovima cijelih brojeva
Operacija Opis
x y Lijevi pomak (shift)
x y Desni pomak (shift)
x & y Bitwise I (and)
x | y Bitwise ILI (or)
x∧y Bitwise EX-ILI (xor - exclusive or)
∼x Bitwise negacija
Osim pomaka (ulijevo i udesno) na bitovima se mogu izvr²avati i logi£ke funkcije (I, ILI, NOT i
EX-ILI).
3.4 Operacije na nizovima

Python podrºava nekoliko operacija koje se mogu primijeniti na slijedne tipove (nizove ili sekvence),
koji uklju£uju nizove znakova ( stringove ), popise ili liste ( engl. list ) engl. tuple ).
i n-terce ( Nizovi
su spremnici s £lanovima koji se dohva¢aju indeksiranjem pojedina£nog £lana ili skupom £lanova, tzv.
kri²kama. Nizovi istog tipa nadovezuju se jedan na drugog s pomo¢u operatora +. Isto tako mogu¢e je
mnoºiti bilo koji niz S s cijelim brojem n s pomo¢u operatora *. Rezultat S*n ili n*S je povezivanje n
kopija od S. Ako je n nula ili manje od nule, razultat je prazan niz istog tipa kao S.
U nastavku se promatraju liste, ali ista zapaºanja vrijede i za stringove i n-terce. Jedina razlika je
²to se, za razliku od listi, n-terci i stringovi ne mogu mijenjati.
Operator in u x in S provjerava je li objekt x jednak bilo kojem £lanu u nizu S. Ako jest, vra¢a
True, a False ako nije. Sli£no tomu, x not in S operator je isto kao not(x in S).
N-ti £lan niza S ozna£uje se ili dohva¢a indeksiranjem S[n]. Indeksiranje u Pythonu po£inje od
nule (prvi £lan u S je S[0]). Ako S ima L £lanova, indeksn smije biti 0,1,.., sve do L-1 uklju£no, ali
ne i vi²e. Indeks n moºe takoer biti -1, -2,..., sve do -L (isklju£no), ali ne i manji. Negativni n
ozna£ava iste £lanove u S kao ²to £ini L+n. Drugim rije£ima, S[-1] je posljednji element od S, S[-2] je
pretposljednji, itd. Na primjer:
x = [1,2,3,4]
x[1] # 2
x[-1] # 4
Kori²tenje indeksa ve¢eg ili jednakog duljini niza L ili manjeg od -L, podiºe (izaziva) iznimku.
Pridruºba £lanu niza s nepostoje¢im indeksom ima isti u£inak.
3.4.1 Kri²ka (eng. slicing ) niza

Podniz S moºe se ozna£iti s pomo¢u kri²ke, kori²tenjem sintakse S[i:j], gdje su i i j cijeli brojevi.
S[i:j] je podniz S od i-tog £lana do j-tog £lana, ali ne uklju£uju¢i j-ti £lan. Treba primjetiti kako u
Pythonu svi dosezi uklju£uju donju, a isklju£uju gornju granicu. Kri²ka moºe biti prazan podniz ako je
j manje od i ili ako je i ve¢e ili jednako L, duljini niza S. Ako je j jednako nuli, i se moºe izostaviti, a
ako se ide do konca niza (L) onda se i j smije izostaviti. Cijeli niz S moºe se dakle indeksirati sa S[:].
Bilo koji ili oba indeksa smiju biti manji od nule. Negativni indeks ozna£uje mjesto u nizu s obzirom
na kraj niza. Evo nekih primjera:
x = [1, 2, 3, 4]
x[1:3] # [2, 3] - ne zaboraviti da prvi £lan niza ima indeks jednak 0
x[1:] # [2, 3, 4]
x[:2] # [1, 2]
Kri²ka takoer moºe koristiti pro²irenu sintaksu S[i,j,k], gdje je k - korak indeksa.
Liste mogu mijenjati svoje £lanove pridruºbom izraza indeksiranom £lanu. Na primjer:
x = [1, 2, 3, 4]
x[1] = 42 # x je sada [1, 42, 3, 4]
Drugi na£in promjene objekata liste li je kori²tenjem kri²ke od likao cilja (lijeva strana) uz naredbu
pridruºbe desne strane. Desna strana pritom takoer mora biti lista. Kri²ka s lijeve strane i lista s
desne mogu biti bilo koje duljine, ²to zna£i da pridruºivanje kri²ke moºe dodavati £lanove liste ili ih
brisati. Na primjer:
x = [1, 2, 3, 4]
x[1:3] = [22, 23, 44] # x je sada [1, 22, 33, 44, 4]
x[1:4] = [2, 3] # x se vratio na [1, 2, 3, 4]
Evo nekih vaºnih posebnih slu£ajeva:
• Koriste¢i praznu listu [ ] kao izraz s desne strane, bri²e se ciljna kri²ka iz liste li s lijeve strane.
Drugim rije£ima, li[i:j] = [ ] ima isti u£inak kao i del li[i:j].
• Koriste¢i praznu kri²ku liste li kao cilj s lijeve strane pridruºbe ubacuju se £lanovi liste s desne
strane na primjerenu poziciju u li. Drugim rije£ima, li[i:i] = ['a','b'] ubacuje £lanove 'a'
i 'b' nakon £lana i u listi li.
• Koriste¢i kri²ku koja pokriva cijeli objekt liste li[:], kao cilj s lijeve strane, potpuno se zamjenjuje
sadrºaj liste li.
£lan ili dio (kri²ka) liste moºe se izbrisati naredbom del. Na primjer:
x = [1, 2, 3, 4, 5]
del x[1] # x je sada [1, 3, 4, 5]
del x[1:3] # x je sada [1, 5]
3.5. Naredba Print 33
3.4.2 Stacionarne operacije na listi i rje£niku
Za liste su denirane stacionarne ( in-line ) verzije operatora + i *, koji se koriste u pro²irenim naredbama
pridruºbe. Pro²irena naredba pridruºbe li +=li_1 ima u£inak dodavanja £lana iz liste li_1 na kraj
liste li, dok li *= n ima u£inak dodavanja n broja kopija liste li na kraj li.
Metoda popitem() moºe se koristiti za destruktivnu iteraciju rje£nika, tj. iterativnim dohva¢anjem
£lana bri²e se njegov klju£ i vrijednost u rje£niku. Pritom i item() i popitem() vra¢aju rje£ni£ke £lanove
kao parove klju£/vrijednost, ali kori²tenje funkcije popitem() upotrebljava manju koli£inu memorije.
U²tede na kori²tenju memorije £ine tu metodu korisnom za petlju po dugom rje£niku.
U Pythonu 2.2 i kasnije, izravno iteriranje na rje£niku postiºe se iterkeys() ili iteritems() me-
todama koji traºe skromnu koli£inu memorije i ne uni²tavaju rje£nik po kojemu se iteracija obavlja.
3.5 Naredba Print
Naredba za ispis ozna£ava se s klju£nom rije£i print nakon koje slijedi niti jedan ili vi²e izraza odvojenih
zarezima. Print je prakti£an i jednostavan na£in ispisivanja vrijednosti u tekstovnom obliku. Print
ispisuje na zaslon ra£unala svaki izraz x kao niz znakova ²to je isto kao kad bi se prethodno pozvala
funkcija str(x) koja bi ekslicitno tip podatka, npr. broja pretvorila u string. Print implicitno izbacuje
razmak izmeu izraza, i takoer implicitno uklju£uje novi red (\n) nakon posljednjeg izraza, osim u
slu£aju kad iza posljednjeg izraza slijedi zarez. Evo nekih primjera naredbe print:
slovo = 'c'
print "daj mi ", slovo, "..." # ispisuje: daj mi c ...
odgovor = 100
print "Odgovor je:", odgovor # ispisuje: Odgovor je:100
Odredi²te izlaza naredbe print je datoteka ili objekt sli£an datoteci koji ima vrijednost stdout
atributa u sys modulu. Obi£no je stdout pridruºen zaslonu ra£unala, ali se isto tako moºe pridruºiti
drugom objektu ili izlaznoj napravi. Format ispisa moºe se preciznije kontrolirati uporabom operatora
% ili drugim tehnikama obradbe nizova znakova.
Takoer je mogu¢e koristiti write ili writelines metode datote£nih objekata. U Python ver. 3.0
nadalje, print naredba postaje funkcija print() s pripadnim argumentima za ispis.
Primjer 3.3 Primjena PRINT naredbe s formatiranjem.

,
print " Hello world "

x = " Hello World "
print " Vrijednost x je " , x
print " Visestruke linije : Vrijednost \ n od x \ n je " , x
# formatiranje ispisa
i = 123
j = 99
y = 123.45678912345
print " Vrijednosti su " , i ,j , y

print " ########## Print naredba s razlicitim formatiranjem ############## "
print " d - cijeli broj : % d " % ( i )
print " d - broj klizeceg zareza : % f " % ( y )
print " f - broj klizeceg zareza konacnog formata : %6.2 f " % ( y )
print " f - broj klizeceg zareza konacnog formata : %6.1 f " % ( y )
print " g - realni broj u eksponencijalnom zapisu : % g " % (y )
print " g - realni broj u eksp . zapisu u konacnom formatu %6.2 g " % ( y )
print " s - Vrijednost mog stringa je % s " % ( x )
print " int s 4 znaka razmaka : %4 d %4 d " % (i , j )
print " int s 4 znaka razmaka : %4 d %4 d " % (j , i )
# print naredba automatski ukljucuje silazak u novi red

# dodatkom zareza ( ,) ispustamo silazak u novi red
print " d - an integer : %d " % ( i ) ,

print " f - a floating point number : % f " % ( y )
# razlicite primjene escape znakova
print r " Raw string s \ n i \ t u nj "

,print " String s \ n i \ t u nj "
4
2
9
POGLAVLJE 4
Programsko upravljanje
Programsko upravljanje tokom izvoenja je redoslijed po kojem se programski kôd izvr²ava. Ovo uprav-
ljanje u Python programima, kao i u drugim programskim jezicima, temelji se na uvjetnim naredbama,
petljama i pozivima funkcija.
4.1 Naredba if
esto se neka naredba ili niz (blok) naredbi treba izvr²iti samo u slu£aju ako je neki uvjet zadovoljen.
Ponekad je to izvr²avanje ovisno o nekoliko meusobno povezanih uvjeta. Pythonova kombinirana
naredba if, koja koristi pro²irenja elif ili else zaklju£ak, sluºi za takvo uvjetno izvr²avanje naredbi.
Sintaksa izgleda ovako:
if uvjet(i):
naredba(e)
elif uvjet(i):
naredba(e)
elif uvjet(i):
naredba(e)
...
else uvjet(i):
naredba(e)
gdje uvjet(i) predstavlja jedan ili vi²e uvjetnih izraza povezanih odnosnim (relacijskim) operatorima.
Pro²irenja naredbe 'if ' s 'elif ' i 'else' su dopu²tene u slu£aju ispitivanja vi²e razli£itih uvjeta.
'Elif' je kratica od 'else-if ', ²to zna£i 'ina£e-ako', £ime se prvo ispitivanje uvjeta pro²iruje na idu¢e.
Ako niti jedan od uvjeta nije zadovoljen, onda se izvode naredbe iza 'else' dijela, ako on postoji.
Treba primjetiti kako, za razliku od nekih jezika, Python nema naredbu switch, pa se moraju
koristiti if, elif ili else za sve uvjetne obrade. Evo tipi£ne naredbe if:
if x < 0: print "x je negativan"

elif x % 2: print "x je pozitivan i neparan"
else: print "x je paran i nije ne-negativan"
Kada u 'ako' ili 'ina£e' odlomku ima vi²e naredbi (tj. programsko grananje se odnosi na £itav blok
naredbi), naredbe se pi²u na zasebnim linijama koje su uvu£ene, pomaknute udesno od linije po£etka.
Blok naredbi zavr²ava kada se pozicioniranje linije vrati na ono od po£etka odlomka (ili jo² vi²e ulijevo
od toga). Kada postoji samo jedna jednostavna naredba, kao u gornjem primjeru, onda se ona pi²e na
35
36 Programsko upravljanje
istoj naredbenoj liniji neposredno iza dvoto£ja (':') kojim se zavr²ava jedan ili vi²e uvjetnih ispitivanja.
Dakako, mogu¢e je isto napisati i u idu¢em retku, ali se onda mora koristiti uvlaka. Mnogi koji rade u
Pythonu smatraju stil odvojenih linija £itljivijim od onog u drugim programskim jezicima:
if x < 0
print "x je negativan"
elif x % 2:
print "x je pozitivan i neparan"
else:
print "x is paran i ne-negativan"
Za uvjet u if ili elif odlomku moºe se koristiti bilo koji Python-ov izraz. Pritom se vrijednost
izraza promatra u Bool-ovom kontekstu, gdje se svaka vrijednost uzima kao istinita, ili neistinita. Svaki
broj koji nije nula ili niz znakova koji nije prazan, isto kao i n-terac, lista ili rje£nik, izra£unava se
kao istinito (True). Nula (bilo kojeg brojevnog tipa), None i prazni stringovi, n-terci, liste i rje£nici,
izra£unavaju se kao neistina (False). Kada se pak ºeli ispitati vrijednost x-a u Bool-ovom kontekstu,
preporu£uje se sljede¢i stil kodiranja:
if x:
To je naj£i²¢i i ' naj_Python -skiji' oblik. To je elegantnije i ljep²e nego koristiti konstrukcije kao:
if x is True:
if x == True:
if bool(x) :
ili sli£no.
Postoji osnovna razlika izmeu izjave da izraz " vra¢a True " (²to zna£i da izraz vra¢a vrijednost
kao Bool -ov rezultat) i izjave da se izraz "izra£unava kao istinit " (²to zna£i da izraz vra¢a bilo kakav
rezultat koji je istinit, razli£it od nule ili praznog, u Bool -ovom kontekstu). Kad se ispituje neki izraz u
upravlja£koj naredbi, onda se razmi²lja o ovom drugom uvjetu, a ne prvom. Ako se izraz za if odlomak
izra£una kao istinit, naredbe koje slijede if odlomak ¢e se izvr²iti i cijela naredba if zavr²ava. Ako
se izraz za if odlomak izra£una kao neistinit, onda se izvr²avaju izrazi za idu¢e elif odlomke, ako su
njihovi uvjeti ispunjeni. Za prvu elseif klauzulu za koju je uvjet istinit, izvr²avaju se sve narede koje
je slijede i £itava naredba if time zavr²ava. U protivnom, ako niti jedan elif odlomak nije izvr²en, jer
uvjeti nisu bili zadovoljeni, onda se izvr²avaju naredbe odlomka else, dakako, ako on postoji.
4.2 Naredba while

Naredba while u Pythonu izvr²ava naredbu ili blok naredbi niti jedan, jedan ili vi²e puta, ovisno o
ispunjenju upravljanog uvjetnog izraza. Ovo je sintaksa za naredbu while:
while izraz:
naredba(e)
While naredba takoer moºe uklju£ivati klauzulu else i naredbe break.

Tipi£na uporaba naredbe while:
count = 0
while x > 0:
x = x // 2 # cjelobrojno dijeljenje
count += 1
print "Aproksimacija log2 je", count
4.3. Naredba for 37
Prvo se izra£una izraz poznat kao uvjet petlje (eng. loop condition ). Ako uvjet nije istinit ( false ),
naredba while zavr²ava i niti jedna od naredbi u tijelu petlje se ne izvr²ava. Ako je pak uvjet petlje
zadovoljen, naredba ili naredbe od kojih se sastoji tijela petlje se izvr²avaju. Kada tijelo petlje zavr²i s
izvr²avanjem, uvjet se ponovno izra£unava, da se vidi treba li se izvr²iti nova iteracija. Ovaj se proces
nastavlja sve dok uvjet petlje ne postane neistinit, nakon £ega while naredba zavr²ava. Tijelo petlje
treba sadrºavati kôd koji ¢e u nekom trenutku u£initi petljin uvjet laºnim, ili petlja nikada ne¢e zavr²iti,
osim ako se ne podigne iznimka ili tijelo petlje ne izvr²i naredbu break. Petlja koja je napisana u tijelu
funkcije takoer zavr²ava ako se naredba return izvr²i unutar tijela petlje, jer u tom slu£aju cijela
funkcija zavr²ava.
4.3 Naredba for

Naredba for u Pythonu ostvaruje takoer iterativno izvr²avanje naredbe ili bloka naredbi, a upravlja
se preko iteracijskog izraza. Sintaksa za naredbu for je:
for cilj in nizu:

naredba(e)
Treba primjetiti da je klju£na rije£ in dio sintakse naredbe for. Ona nije povezana s operatorom
in koji se koristi pri ispitivanju £lanova u nizovima. Naredba for takoer moºe uklju£ivati i odlomak
else i naredbu break.
Tipi£na primjer uporabe naredbe for je:
for znak in "dobar dan":

print "slovo: ", znak, "..."
²to ¢e kao rezultat dati:
slovo: d ...
slovo: o ...
slovo: b ...
slovo: a ...
slovo: r ...
slovo: ...
slovo: d ...
slovo: a ...
slovo: n ...
Iteracijski niz u ovom slu£aju je string, pa varijabla znak u svakom prolazu, iteraciji, poprima vrijed-
nost pojedinog £lana tog niza, u ovom slu£aju pojedina£nog slova. U ovom primjeru izvr²ava se samo
jedna naredba, naredba print, koja ispisuje sadrºaj upravlja£ke varijable s pripadnim formatiranjem
('slovo:' ispred i '...' iza sadrºaja).
Iteracijski niz moºe biti bilo koji Pythonov izraz koji se moºe iskoristiti kao argument ugraenoj
funkciji iter, koja vra¢a iteratorski objekt. Cilj pridruºbe iteracijske varijable je obi£no identikator
koji imenuje varijablu petlje, a naredba for slijedno re-povezuje ovu varijablu na svaki £lan po redu
unutar iteratora. Naredba ili naredbe od kojih se sastoji tijelo petlje izvr²avaju se jedna po jedna
za svaki £lan unutar iteratora (osim ako petlja zavr²i uslijed podizanja iznimke ili izvr²enja naredbe
break ili return). Cilj s vi²e identikatora je takoer dopu²ten, kao kad se radi o pridruºbi prilikom
raspakiravanja. U tom slu£aju, iteratorovi £lanovi moraju biti nizovi, svaki iste duljine jednake broju
identikatora unutar cilja. Na primjer, ako je d rje£nik, ovo je uobi£ajeni na£in dohva¢anja £lana u
rje£niku d:
for key, value in d.items():
# dohvatiti samo istinite (pune) kljuceve i vrijednosti
if not key or not value: del d[key]
Metoda items() vra¢a popis parova klju£/vrijednost, pa stoga for petlja koristi dva identikatora
u cilju da se svaki £lan razpakira u par klju£/vrijednost. Ako iterator sadrºi promjenljiv objekt unutar
samoga sebe, onda se taj objekt ne smije mijenjati dok se for petlja obavlja. Na primjer, predhodni
primjer ne moºe koristiti iteritems() items. Naime, iteritems() vra¢a iterator £iji je
umjesto
sadrºani objekt d, pa tijelo petlje ne moºe mijenjati d (sa del d[key]). S druge strane, items() vra¢a
listu, tako da d nije sadrºani objekt, pa tijelo petlje moºe mijenjati d.
Upravlja£ka varijabla moºe se repovezati u tijelu petlje, ali se ponovno repovezuje na slijede¢i £lan
u iteratoru sa sljede¢om iteracijom petlje. Tijelo petlje uop¢e se ne izvr²ava ako iterator ne oslobaa
nikakve £lanove. U tom slu£aju, upravlja£ka varijabla se ne povezuje ili odvezuje na niti jedan na£in
pomo¢u naredbe for. Meutim, ako iterator oslobaa barem jedan £lan, kad se naredba petlje zavr²i,
upravlja£ka varijabla ostaje povezana na posljednju vrijednost na koju ju je naredba petlje povezala.
Zato je sljede¢i kôd ispravan, dok god neki-niz nije prazan.
for x in neki-niz:
obradi(x)
print "Posljednji obradjeni £lan je: ", x
4.4 Iteratori
Metode items(), keys() i values() vra¢aju njihove rezultantne liste bilo kojim redoslijedom. Ako
se pozove vi²e od jedne od ovih metoda bez bilo kakve izmjene na rje£niku, redoslijed rezultata je
identi£an za sve. Metode iteritems(), iterkeys()i itervalues(), koje su uvedene u Pythonu od
ina£ice 2.2, vra¢aju iteratore ekvivalentne tim listama. Iterator zauzima manje memorije od liste, ali
nije dozvoljena promjena rje£nika dok se iterira na jednom od njegovih iteratora. Iteriranje na listi
vra¢enoj sa items(), keys() ili values() dolazi bez takvih restrikcija. Iteriranje direktno na rje£niku
D je isto kao iteriranje na D.iterkeys().
Tablica 4.1: Metode rje£ni£kog objekta
Metoda Opis
Vra¢a iterator za sve £lanove (key/value
D.iteritems( )
parove) u D
D.iterkeys( ) Vra¢a iterator za sve klju£eve u D
D.itervalues( ) Vra¢a iterator za sve vrijednosti u D
Iterator je bilo koji objekt i takav da se moºe pozivati sa i.next() bez argumenata. Naredba
i.next() vra¢a sljede¢i £lan iteratora i ili, kada iterator i vi²e nema £lanova, podiºeStopIteration
iznimku. Ve¢ina je iteratora izgraena eksplicitnim ili implicitnim pozivima ugraene funkcije iter.
Naredba for implicitno poziva iter da bi dobila iterator. Sljede¢a naredba:
for x in clanovi:
naredba(e)
je ekvivalentna s:
_temporary_iterator = iter(clanovi)
while True:
try: x = _temporary_iterator.next ( )
except StopIteration: break
naredba(e)
4.5. Funkcije range i xrange 39
Ako iter(clanovi) vra¢a iterator i tako da naredba i.next nikada ne podigne StopIterationiznimku
(beskona£an iterator), petljafor x in clanovi: nikada ne zavr²ava (osim kad naredbe u tijelu petlje
sadrºavaju prikladne break ili return naredbe ili iznimke). iter(clanovi) poziva posebnu metodu
c._iter_() da se dobije i vrati iterator na clanovi.
Zahvaljuju¢i iteratorima, naredba for se moºe koristiti na spremniku (kontejneru) koji nije niz
znakova, poput rje£nika, sve dok god je kontejner iterabilan (tj. denira _iter_ posebnu metodu tako
da funkcija iter moºe prihvatiti kontejner kao argument i vratiti iterator na taj kontejner). Ugraene
funkcije koje su prije zahtjevale argumentni niz sad prihva¢aju bilo koji iterabilni objekt.
4.5 Funkcije range i xrange

Vrlo £est slu£aj u programiranju je ponavljanje petlje preko niza cijelih brojeva. Za tu svrhu Python
pruºa ugraene funkcije range i xrange koje generiraju i vra¢aju nizove cjelih brojeva.
Najjednostavniji na£in da se zavrti petlja od n puta u Pythonu je:
for i in xrange(n):
naredba(e)
range(x) vra¢a popis ili listu £iji £lanovi su sljedni cijeli brojevi od 0 (uklju£eno) do x (isklju£eno).
Funkcija range(x,y) vra¢a popis £iji £lanovi su su sljedni cijeli brojevi od x (uklju£eno) do y (isklju-
£eno). Ako je x ve¢i ili jednak y, onda je rezultat prazna lista. Funkcija range(x,y,step) vra¢a popis
cijelih brojeva od x (uklju£eno) do y (isklju£eno), tako da je razlika izmeu svaka dva susjedna £lana u
popisu step. Ako je korak (eng. step ) manji od 0, range odbrojava od x do y. Funkcija range vra¢a
prazan popis kada je x ve¢i ili jednak y, a korak je ve¢i od 0, ili kada je x manji ili jednak y i korak je
manji od 0. Ako je korak jednak 0, onda range podiºe iznimku. Dok range vra¢a standardni objekt
liste koja se moºe koristiti za bilo koju svrhu, xrange vra¢a objekt za posebne svrhe, posebno nami-
jenjen kori²tenju u iteracijama kao naredba for pokazana ranije. Xrange uzima manje memorije od
range-a za ovu speci£nu namjenu. Stavljaju¢i na stranu potro²nju memorije, range se moºe koristiti
u iste svrhe kao i xrange.
4.6 Saºete liste

esta svrha for petlje je provjeravanje svakog £lana unutar niza i tvorba nove liste dodaju¢i rezultate
izraza izra£unatog na jednom ili svim £lanovima koji se provjeravaju. Oblik izraza, zvan saºeta lista
(eng. list comprehension ) omogu¢uje to£no i neposredno izvr²avanje ove zada¢e. Kako je saºeta lista
izraz (a ne blok naredbi), moºe se ga koristiti izravno (npr. kao stvarni argument u funkciji poziva,
zatim u naredbi return ili kao podizraz za neki drugi izraz). Saºeta lista ima sljede¢u sintaksu:
[izraz for cilj in iter-clanovi lc-odlomci]
gdje su cilj i iter-clanovi identi£ni kao i u obi£noj for naredbi. Izraz se moºe ograditi i okruglim,
oblim zagradama, pa ¢e u tom slu£aju predstavljati n-terac, a ne listu. lc-odlomci je niz od nula ili
vi²e odlomaka, od kojih je svaki sli£an obliku:
for cilj in iter-clanovi

if izraz
Izraz unutar svake if klauzule ima istu sintaksu kao izraz u obi£noj if naredbi.
Saºeta lista je ekvivalentna petlji for koja gradi istu listu ponavljaju¢im pozivima append metode
rezultantne liste. Na primjer:
result1 = [x+1 for x in neki_niz]

jednak je kao sljede¢a for petlja:
result2 = []
for x in neki_niz
result2.append (x+1)
Saºeta lista koji koristi if odlomak izgleda ovako:
result3 = [x+1 for x in neki_niz if x<100]
a to je identi£no for petlji koja sadrºi naredbu if:
result4 = []
for x in prva-lista:
for y in druga lista:
result6.append (x+y)
Kao ²to ovi primjeri pokazuju, redoslijed naredbi for i if u saºetoj listi jednak je kao u ekvivalentnoj
petlji, ali u saºetoj listi gnjeºdenje operacija ostaje implicitno.
4.7 Naredba break

Upotreba naredbe break dopu²ta se jedino unutar tijela petlje. Kada se break izvr²i, petlja zavr²ava.
Ako je petlja smje²tena unutar drugih petlja, breakzavr²ava jedino petlju koja je smje²tena najdalje
unutra. U prakti£nom kori²tenju, break naredba je obi£no unutar nekog odlomka u naredbi unutar tijela
petlje, tako da se izvr²ava uvjetno. Jedno uobi£ajeno kori²tenje naredbe break je u implementaciji
petlje koja odlu£uje ho¢e li se izvr²avati samo u sredini svake iteracije:
while True: # ova petlja ne bi nikad prirodno zavr²ila

x = get_next( )
y = preprocesses (x)
if not keep_looping (x, y): break
process (x, y)
POGLAVLJE 5
Iznimke
Pi²u¢i program, korisnik (programer) moºe na£initi tri vrste pogre²aka: logi£ke pogre²ke, sintakti£ke
pogre²ke, te pogre²ke u radu (eng. run-time errors )nkoje se pojavljuju tijekom izvoenja programa.
Logi£ka pogre²ka poput neispravnog algoritma, uzrokuje neto£ne rezultate, ali ne sprije£ava izvoenje
programa. Ovakve se pogre²ke te²ko mogu uo£iti.
Sintakti£ka pogre²ka kr²i jedno od Pythonovih gramati£kih pravila i sprije£ava izvoenje programa.
Ove je pogre²ke lako popraviti.
Pogre²ka u radu je pogre²ka kod izvr²enja programa koja se dogaa dok je program u nekoj operaciji.
Neki £esti uzroci takvih pogre²aka u radu su neprimjereni ulazni podaci, arithmeti£ke pogre²ke,
neispravne vrste objekata, nizovi indeksa izvan dometa, nepostoje¢i klju£evi rje£nika, nepravilno
ispisana imena atributa, neinicijalizirane varijable, te problemi vezani uz operacijski sustav.
Iako to ne pomaºe u slu£aju logi£kih pogre²aka, Python podiºe iznimku (engl. exception ) pri otkri-
vanju sintakti£kih pogre²aka ili pogre²aka tijekom izvoenja programa. Interpreter zaustavlja program
te ispisuje dijagnosti£ku poruku o pogre²ci, zvanu " traceback ", koja ukazuje na vrstu iznimke te po-
kazuje pribliºno mjesto pogre²ke. Sintaksne pogre²ke su naj£e²¢e pogre²ke u pisanju programa, a na
njih upozorava Python prilikom izvoenja programa oznakom strijelice na mjestu na kojem se pogre²ka
javlja. To mjesto ne mora doista biti ono na kojem se pogre²ka nalazi, nego je obi£no ono na kojem se
prvi put pogre²ka manifestira. To£no lociranje pogre²aka nije jednostavno.
>>> while True print Pozdrav svima'

File "<stdin>", line 1, in ?
while True print 'Pozdrav svima'
^
SyntaxError: invalid syntax
Kada je program sintaksno dobro napisan, postoji mogu¢nost da se pogre²ke jave prilikom izvoenja
programa. Iznimka je na£in na koji Python dohva¢a i pogre²ke tog tipa.
5.1 Vrste iznimki

Python organizira iznimke po hijerarhijskom stablu. Tablica 5.1 ispisuje i opisuje sve ugraene iznimke.
Sve vrste iznimki su Python klase, objekti. Na vrhu stabla iznimki je Exception, iz kojega su izve-
dene sve druge ugraene iznimke. Exception je roditelj ili temelj dvaju nasljednika: SystemExit i
41
42 Iznimke
StandardError. Funkcija sys.exit() generira iznimku SystemExit koja se moºe dohvatiti kod ekspli-
citnog zatvaranja programa. (SystemExit je iznimka ali ne i pogre²ka).
StandardError je roditelj svih
drugih iznimki. Ovakav hijerarhijski ustroj omogu¢uje otkrivanje i obradu skupnih, a ne samo indivi-
dualnih iznimki. Na primjer, ako postoji skupina iznimki koje obrauju matemati£ke izra£une, onda se
moºe prvo dohvatiti samo ArithmeticError iznimka, a ne i sva njezina djeca (FloatingPointError,
OverflowError i ZeroDivisionError) pojedina£no, uz uvjet da se ºeli na isti na£in raditi sa svim
iznimkama.
Tablica 5.1: Ugraene iznimke
Iznimka Opis
Exception Korijen svih iznimki
Podiºe se sa sys.exit() funkcijom. Ako se ne
obrauje ova iznimka, onda Python interpreter
zavr²ava program bez ispisa putanje zavr²etka
SystemExit (engl. traceback ). Ako se pozove sys.exit(),
Python prevodi poziv u iznimku i izvodi
potporu iznimci (eng. exception handler ) koji
se nalazi u finally odlomku od try naredbe.
Osnova svih ugraenih iznimki osim
StandardError
SystemExit.
Roditelj za iznimke koje Python podiºe za
ArithmeticError
razli£ite aritmeti£ke pogre²ke.
Podiºe se za pogre²ke u operacijama s
FloatingPointError
pomi£nom decimalnom to£kom.
Podiºe se kad je rezultat aritmeti£ke operacije
prevelik da bi se mogao prikazati. Ova
OverflowError iznimka ne moºe se pojaviti za duge cijele
brojeve (eng. long integers ). U njihovom
slu£aju Python podiºe MemoryError.
Podiºe se kad je drugi argument obi£nog ili
ZeroDivisionError
modularnog dijeljenja jednak nuli.
AssertionError Podiºe se kad je pogre²ka u assert naredbi.
Podiºe se kad je atributna referenca ili
pridruºba pogre²na. Ako objekt ne podrºava
AttributeError
atributnu referencu ili pridruºbu, onda Python
podiºe TypeError iznimku.
Roditelj za iznimke koje se pojavljuju izvan
EnvironmentError
Python-a.
Podiºe se kad je ulazno/izlazna operacija (kao
²to je print naredba, open() funkcijski poziv
ili metoda u radu s datotekom) pogre²na, na
IOError
primjer, za U/I razloge: "file not found"
(datoteka nije pronaena) ili "disk full"
(disk je pun).
5.1. Vrste iznimki 43
Iznimka Opis
Podiºe se kad se pojavi pogre²ka povezana s
operacijskim sustavom (izvan Python-a).
OSError Obi£no se ovoj iznimci pridruºuje numeri£ki
kôd pogre²ke, kao ²to je u os modulu iznimka
os.error.
Podiºe se kad se pojavi pogre²ka povezana s
WindowsError
Windows -operacijskim sustavom.
Podiºe se kad input() ili raw_input() otkrije
konac datoteke (EOF) bez £itanja ikakvog
EOFError podatka. (treba primjetiti da le-objekt
read() i readline() metoda vra¢a prazan
EOF.)
string kad se otkrije
Podiºe se kad import grije²i na¢i modul ili kad
ImportError
from-import grije²i na¢i ime.
Podiºe se kad korisnik pritisne tipku prekida
interrupt key
( koja je obi£no Ctrl-C ili Del ).
Python redovito provjerava takve prekide
KeyboardInterrupt tijekom izvoenja programa. Python takoe
podiºe ovu iznimku ako korisnik utipka prekid
za vrijeme input() ili raw_input() naredbe
koja £eka korisnikov unos.
Roditelj za iznimke koje Python podiºe kada
LookupError je indeks rje£ni£kog klju£a ili indeks niza
(stringa, liste ili n-terca) nevaljao.
Podiºe se kad je indeks niza izvan dosega. Ako
IndexError indeks nije cijeli broj, onda Python podiºe
TypeError iznimku.
Podiºe se kad Python ne moºe na¢i rje£ni£ki
KeyError
klju£.
Podiºe se kad operacija prelazi raspoloºivu
memoriju, ali program se jo² moºe spasiti
MemoryError brisanjem nekih obekata. Interpreter ne moºe
uvijek uspje²no ispraviti ovu pogre²ku, pa
podiºe iznimku i ispisuje slijed.
Podiºe se kad Python ne moºe prona¢i lokalno
NameError ili globalno ime. Argument iznimke je string
koji ozna£uje izgubljeno ime.
Podiºe se kad se referencira lokalna varijabla u
UnboundLocalError funkciji ili metodi, ali ne postoji vrijednost
pridruºena toj varijabli.
Podiºe se kada Python otkrije generi£ku
pogre²ku koja ne pripada niti jednoj drugoj
RuntimeError kategoriji. Argument iznimke je string koji
pokazuje ²to je neispravno. Python rijetko
podiºe ovu sveobuhvatnu iznimku.
44 Iznimke
Iznimka Opis
Podiºe se kad se pozove metoda koja se jo² nije
na£inila. Apstraktna metoda u korisnikovoj
NotImplementedError temeljnoj klasi moºe takoer podignuti ovu
iznimku, ako se od izvedene klase zahtijeva da
prebri²e ili prepuni (engl. override ) metodu.
Podiºe se kad Python interpreter otkrije
sintaksnu pogre²ku u interaktivnom ili
skriptnom na£inu rada. Ova iznimka se moºe
SyntaxError
pojaviti u import ili exec naredbi, te u
eval() ili input() pozivima funkcija, kad se
incijalno £ita skripta ili se £ita standardni ulaz.
Podiºe se kad se koristi -tt opcija u
naredbenoj liniji sa programom koji
TabError
nekonzistentno koristi tabulatore i prazna
mjesta.
Podiºe se kad program prekida Pythonova
IndentationError pravila uvla£enja (engl. indentation) izvornog
programskog teksta.
Podiºe se kad Python interpreter otkrije
nutarnju pogre²ku koja nije toliko ozbiljna da
zaustavi izvr²avanje interpretera. Argument
SystemError
iznimke je string koji pokazuje gdje je do²lo do
pogre²ke, na razini sistemskih (najniºih)
operacija.
Podiºe se kad se ugraena operacija ili
funkcija primjeni na objekt neprikladnog tipa.
TypeError
Argument iznimke je string koji pokazuje
detalje o nepodudaranju tipova podataka.
Podiºe se kad se ugraenoj operaciji ili
funkcija proslijedi argument koji ima ispravan
ValueError tip, ali ne i ispravnu vrijednost. To su slu£aji
koji se ne mogu opisati preciznijom iznimkom,
kakva je na primjer IndexError.
Podiºe se kad se pojavi pogre²ka u Unicode
UnicodeError
kodiranju ili dekodiranju.
Evo nekih primjera £estih pogre²aka u programu koji podiºu iznimke:
>>> 10 * (1/0)
Traceback (most recent call last):
ZeroDivisionError: integer division or modulo by zero
>>> 4 + spam*3
NameError: name 'spam' is not defined
>>> '2' + 2
TypeError: cannot concatenate 'str' and 'int' objects
Posljednja linija poruke o pogre²ki govori ²to se dogodilo. Budu¢i da postoji vi²e vrsta iznimaka,
njihov tip se nalazi ispisan u poruci (npr. ZeroDivisionError, NameError and TypeError). Svaka Python
5.2. Rad s iznimkama 45
ugraena iznimka podiºu true pri pojavi pogre²ke njenog tipa. Ostatak ispisane linije poruke pruºa
detaljniji opis pogre²ke (TypeError), a dio prije imena iznimke govori o kontekstu u kojem se pogre²ka
dogodila. Taj kontekst je u obliku slijeda (Traceback) obavijesti, od posljednjeg mjesta, rekurzivno
prema po£etku mogu¢e pogre²ke.
5.2 Rad s iznimkama

U Pythonu je mogu¢e pisati programe koji ¢e raditi (dohva¢ati i obraivati) promatrane iznimke, ²to
se vidi na sljede¢em primjeru:
>>> while True:

... try:
... x = int(raw_input("Unesite broj: "))
... break
... except ValueError:
... print "Oops! To nije dobar broj. Probajte ponovo..."
Pri tome Try radi po sljede¢em na£elu:
• ako se tokom izvr²avanja ne pojavi iznimka, except linija se preska£e i try zavr²ava
• ako se iznimka pojavi tijekom izvr²avanja try-a, i ako odgovara iznimci navedenoj u except liniji,
onda se ona izvr²ava
• ako se iznimka pojavi, a ne odgovara except liniji, provjeravaju se druge iznimke u try izrazu.
Ako njih nema, program zavr²ava i pokazuje poruku koja je gore navedena.
Pri tomu try moºe imati vi²e od jedne except linije (uvjeta), koji dohva¢aju neke druge iznimke.
Pri tome se najvi²e izvr²ava jedna od njih, i to samo za iznimke navedene u tom djelu except linije, ali
ne za druge. Except linija moºe imati vi²e iznimki, deniranih unutar n-terca, npr:
... except (RuntimeError, TypeError, NameError):

... pass
Try...except izraz moºe sadrºavati naredbu else koja se izvr²ava ako u try bloku nije dohva¢ena
niti jedna iznimka.
for arg in sys.argv[1:]:

try:
f = open(arg, 'r')
except IOError:
print 'cannot open', arg
else:
print arg, 'has', len(f.readlines()), 'lines'
f.close()
Taj se na£in koristi umjesto pisanja dodatnih linija u try-u, jer se tako izbjegava mogu¢nost upo-
rabe iznimke koja nije navedena u try bloku. Iznimke mogu imati pridruºene vrijednosti, argumente,
koji ovise o tipu iznimke. Except izraz moºe denirati varijablu nakon imena iznimke, koja je s ins-
tancom iznimke vezana s argumentima u instance.args. Umjesto kori²tenja instance.args dobro je
proslijediti jedinstveni argument iznimke i vezati ga s atributom poruke.
>>> try:
... raise Exception('miki', 'riki')
... except Exception, inst:
... print type(inst) # instance iznimke
46 Iznimke
... print inst.args # argumenti pohranjeni u .args

... print inst # __str__ dozvoljava ispis args
... x, y = inst # __getitem__ dozvoljava da se args otpakiraju
... print 'x =', x
... print 'y =', y
<type 'instance'>
('miki', 'riki')
('miki', 'riki')
x = miki
y = riki
Ako iznimka ima argument, on se ispisuje kao zadnji dio poruke o pogre²ci('detail'). Programi za
rad s iznimkama mogu raditi i s funkcijama, koje se unutar njih pozivaju.
>>> def nemoguce_dijeljenje():

... x = 1/0
...
>>> try:
... nemoguce_dijeljenje()
... except ZeroDivisionError, detail:
... print 'Run time pogreska u dijeljenju:', detail
...
Ovo je Run time pogreska u dijeljenju: integer division or modulo by zero.
5.3 Obradba iznimki

Kada Python podigne iznimku, ona se mora dohvatiti (uhvatiti) i obraditi, ina£e ¢e Python nasilno
zavr²iti izvoenje programa. Obradba iznimki prisiljava programera na razmi²ljanje o tome ²to moºe
po¢i krivo unutar programa i ²to se moºe u£initi u vezi toga. Nije prakti£no (i skoro je nemogu¢e) imati
na umu sve ²to moºe po¢i krivo. Umjesto toga treba traºiti stanja koja se (govore¢i op¢enito) mogu
ponovno vratiti, koriste¢i korekcijski blok kôda, koji se zove 'obrada iznimke' (engl. exception handler ).
Taj kôd moºe automatski popraviti stanje bez korisni£ke interakcije, upitati korisnika za dodatne ili
prihvatljive podatke za popravak problema, ili u nekim okolnostima zatvoriti program sa sys.exit().
(Dakako, cijeli je smisao iznimki u tome da se takve fatalne situacije izbjegnu). Pythonova naredba
try detektira i obrauje iznimke. Ona je vi²eslojna naredba kao if ili while, te slijedi pravila uvlake.
Try takoer mijenja uobi£ajeno upravljanje tijeka programa. (Upravljanje tokom programa je izvr²ni
niz naredbi koje £ine program).
try:
try_block
except ex:
except_block
Python pokre¢e kôd u bloku try dok ga ne zavr²i uspje²no ili se pojavi iznimka. Ako zavr²i uspje²no,
Python preska£e blok except, te se izvr²enje nastavlja na naredbi koja slijedi iza njega. Ako se pojavi
iznimka, Python preska£e ostatak naredbi bloka try i ispituje vrijednost ex u odlomku except kako bi
se ustanovilo je li vrsta podignute iznimke odgovara vrsti koja je opisana sa ex.
Ako iznimka odgovara ex, Python pokre¢e blok except, te se upravljanje tokom programa prebacuje
na naredbu koja slijedi blok except. Ako iznimka ne odgovara ex, iznimka se pro²iruje na bilo koje
uklju£ene try naredbe, koje bi mogle imati odlomak except u kojem bi se iznimka mogla obraditi. Ako
ni jedna od obliºnjih except klauzula ne obrauje podignutu iznimku, onda Python zatvara program te
ispisuje poruku o pogre²ci.
5.3. Obradba iznimki 47
5.3.1 Ignoriranje iznimke

Za ignoriranje iznimke koristi se naredba pass unutar odlomka except.
try:
try_block
except ex:
pass
pa ako se dogodi iznimka, Python je ignorira i upravljanje tokom programa prelazi na prvu naredbu
nakon pass naredbe.
5.3.2 Pronalaºenje argumenta iznimke

Kada se dogod iznimka, ona moºe imati i pridruºenu vrijednost takoer poznatu i kao argument iznimke.
Vrijednost i tip argumenta ovise o tipu iznimke. Kod ve¢ine iznimki, argument je n-terac sastavljen od
jednog string £lana koji upu¢uje na uzrok pogre²ke. Kod pogre²aka operacijskog sustava tipa IOError,
argument sadrºi i dodatne atribute, kao ²to su broj pogre²ke ili ime datoteke. U tom slu£aju moºe
se koristiti funkcija dir() da bi se ispisao popis atributnih argumenta. Za pronalaºenje vrijednosti
argumenta, treba se specicirati varijabla nakon imena iznimke u odlomku except.
try:
try_block
except ex, target:
except_block
pa ako se dogodi iznimka, Python ¢e pridruºiti argument iznimke varijabli target.
5.3.3 Obradba svih iznimki

Da bi se obuhvatilo sve iznimke, treba se specicirati odlomak except bez imena iznimke ili argumenta.
Odlomak except koji na ovaj na£in obuhva¢a sve iznimke je op¢enito slabo rje²enje, jer obuhva¢a sve
iznimke, a ne samo one koje su bitne, a osim toga, moºe prikriti stvarne pogre²ke korisni£kog programa.
try:
try_block
except:
except_block
gdje except_block prihva¢a i obrauje sve iznimke.
5.3.4 Pokretanje programskog koda bez prisustva iznimke

Mogu¢e je takoer dodati odlomak uz else naredbu povezanu s odlomkom try kako bi se pokrenuo
niz naredbi u slu£aju da odlomak try ne uzrokuje iznimku. Pritom odlomak nakon else mora slijediti
posljednji odlomak except (ako ih ima vi²e).
try:
try_block
except [...]:
except_block
else:
else_block
Python pokre¢e else_block jedino u slu£aju kad try_block ne uzrokuje iznimku.

48 Iznimke
5.3.5 Obradba vi²e iznimki

Mogu¢e je koristiti jedan except odlomak da bi se obuhvatilo vi²e tipova iznimki ili se moºe koristiti
vi²e except odlomaka kojima se obrauju pojedine iznimke.
try:
try_block
except (ex1, ex2, ...) [, target]:
except_block
Odlomak except obuhva¢a bilo koju od popisanih iznimki (ex1, ex2, ...) te pokre¢e isti except_block
za sve njih. Target je dopustiva varijabla koja uzima argument iznimke.
5.3.6 Pokretanje obaveznog kôda za £i²¢enje

Naredba try-finally moºe se koristiti za pokretanje programskog kôda bez obzira je li Python podigao
iznimku ili nije. Za razliku od odlomka except , odlomak finally ne dohva¢a iznimke, nego denira
akcije £i²¢enja koje se moraju obaviti u svakom slu£aju, bez obzira na postojanje pogre²ke. Odlomci
finally i except ne mogu se pojaviti zajedno u istom try odlomku. Programeri obi£no postave
naredbutry-finally unutar naredbe try-except kako bi obradili iznimke koje su podignute u naredbi
try-finally. Isto tako, odlomak else ne moºe se dodati uz naredbu try-finally.
try:
try_block
finally:
finally_block
Python pokre¢e kôd unutar finally_block-a nakon ²to ga pokrene u try_block-u. Python ¢e
pokrenuti finally_block bez obzira kako se try_block izvr²i: bilo normalno, bilo putem iznimke
ili putem naredbe tipa break ili return. Ako se iznimka dogodi unutar try_block-a, Python ¢e
presko£iti ostatak try_block-a, te pokrenuti finally_block, a onda ponovno podignuti iznimku kako
bi se dohvatila naredbom try-except vi²e razine.
5.3.7 Eksplicitno podizanje iznimke

Naredba raise se moºe upotrijebiti da bi se podigla ºeljena iznimka. Za eksplicitno podizanje iznimke
treba utipkati:
raise ex
ili
raise ex, arg
ili
raise ex, (arg1, arg2,...)
Argument iznimke moºe biti jedna vrijednost, argument ili n-terac vrijednosti (arg1, arg2, ...).
Ako je izostavljen, onda je pretpostavljena vrijednost argumenta None.
5.4. Korisni£ki denirane iznimke 49
5.4 Korisni£ki denirane iznimke

U Pythonu je mogu¢e stvarati korisni£ke iznimke tako da se deniraju nove klase iznimaka. Takve
iznimke bi trebale direktno ili indirektno dolaziti iz klase ugraenih iznimaka, na primjer:
>>> class MojBad(Exception):

... def __init__(self, value):
... self.value = value
... def __str__(self):
... return repr(self.value)
...
>>> try:
... raise MojBad(2*2)
... except MojBad, e:
... print 'Moja se iznimka dogodila, value:', e.value
...
Moja se iznimka dogodila, value: 4
5.4.1 Tvorba iznimki

Iznimke mogu biti stringovi, klase ili instance objekata. Iznimke u obliku stringova su zastarjele, iako ih
Python jo² uvijek podrºava zbog kompatibilnosti. Korisni£ki denirane iznimke mogu se stvoriti koris-
te¢i naredbu class. Preporu£uje se kao temeljnu klasu uzeti Pythonovu korijensku iznimku Exception.
S korisni£ki deniranim iznimkama radi se na isti na£in kao i s ugraenim iznimkama. Uz except i
else, postoji i na£in da se denira iznimka koja ¢e se uvijek ispisati na kraju programa, bez obzira dali
je ba² nju program traºio ili neku drugu. To je finally clause i denira se kao:
>>> def dijeli(x, y):

... try:
... rez = x / y
... except ZeroDivisionError:
... print "Djeljenje s nulom!"
... else:
... print "Rezultat je", rez
... finally:
... print "Ispisujem zadnju iznimku"
...
>>> dijeli(2, 1)
result is 2
Ispisujem zadnju iznimku
>>> dijeli(2, 0)
division by zero!
>>> dijeli("2", "1")
File "<stdin>", line 3, in divide
TypeError: unsupported operand type(s) for /: 'str' and 'str'
Kao ²to se vidi na primjeru, finally clause se ispisuje pri svakoj operaciji sa funkcijom djeli().
TypeError pozvan kod dijeljenja dva stringa (dijeli("2","1")) nije pozivan od strane iznimaka,te
je stoga ponovo pozvan nakon ²to se zadnja iznimka izvr²ila. Sve iznimke se mogu pozvati naredbom
raise exception[,value], gdje value daje detalje o iznimci koja je pozvana.
50 Iznimke
5.4.2 Dijagnosti£ko pridruºivanje

Pridruºivanje (eng. assertion ) je alat za ispravljanje pogre²aka koji se koristi za ispis dijagnosti£kih
podataka dok program radi. Python naredba assert sadrºi bool -ov izraz koji ozna£ava pogre²ku, ako
je false (neistina). Izraz je uvijek jednak jedinici, ako je istinit u trenutku kad se provjerava. Ako
je izraz izra£unat kao neistina (false), onda Python podiºe AssertionError iznimku, koja se moºe
dohvatiti i obraditi kao bilo koja druga iznimka. Sintaksa je:
assert expr [,arg]

expr je izraz koji se provjerava, a moºe biti true ili false. Ako je expr jednak false, onda Python
podiºeAssertionError iznimku s dopu²tenim argumentom arg. Ako je pak izraz expr jednak true,
onda assert ne poduzima ni²ta.
POGLAVLJE 6
Funkcije
Ve¢ina naredbi tipi£nog Python programa organizirana je preko funkcija. Funkcija je skupina naredbi
koje se izvr²avaju po pozivu. Python pruºa mnogo ugraenih funkcija i dopu²ta programerima de-
niranje vlastitih funkcija. Zahtjev za izvr²enje funkcije zove se funkcijski poziv (engl. function call ).
Kad se funkcija pozove, moºe primiti argumente koji speciciraju vrstu podataka s kojima funkcija
radi (obrauje ih). U Pythonu funkcija uvijek vra¢a rezultantnu vrijednost, koja moºe biti None ili
vrijednost koja predstavlja rezultat nekog izra£una, izvr²enog u tijelu funkcije. U Pythonu su funkcije
objekti, pa se sa njima upravlja isto kao i s drugim objektima. Tako se neka funkcija moºe proslijediti
kao argument u pozivu neke druge funkcije. Sli£no tomu, funkcija moºe vratiti drugu funkciju kao re-
zultat obradbe, izvr²enja svog programskog kôda. Kao i svaki drugi objekt, funkcija moºe biti povezana
s nekom varijablom, nekim £lanom unutar niza (polja, liste) ili atributom objekta. Funkcije takoer
mogu biti klju£evi u rje£niku.
6.1 Naredba 'def'

Funkcija se denira s pomo¢u klju£ne rije£i def. Def je naredba sa sljede¢om sintaksom:
def funkcijsko_ime(parametri):
naredba(e)
funkcijsko_ime je identikator. To je varijabla koja se povezuje (ili re-povezuje) s funkcijskim

objektom prilikom izvr²enja naredbe def. parameteri je dopu²tena, slobodna lista identikatora, koji
se zovu formalni parametri ili samoparametri, a koji se koriste kod poziva funkcija za pridruºivanje
stvarnim vrijednostima koji se navode kao argumenti. U najjednostavnijem slu£aju, funkcija nema ni-
kakvih formalnih parametara, ²to zna£i da kod poziva funkcija ne uzima nikakve argumente. U ovom
slu£aju, denicija funkcije ima prazne zagrade koje slijede iza imena funkcije tj. funkcijsko_ime().
Ako funkcija prihva¢a argumente, onda parametri sadrºe jedan ili vi²e identkatora, odvojenih zarezima.
U ovom slu£aju, svaki poziv fukcije pridruºuje stvarne vrijednosti, argumente, s parametrima specici-
ranima u deniciji funkcije. Parametri su lokalne varijable funkcije, te svaki poziv funkcije povezuje te
varijable s odgovaraju¢im stvarnim vrijednostima koje pozivatelj navodi kao argumente. Niz naredbi
koji nije prazan, poznatiji kao tijelo funkcije (engl. function body ), ne izvr²ava se kada i naredba def.
Ono se izvr²ava kasnije, svaki put kada se funkcija poziva. Tijelo funkcije moºe imati jednu ili vi²e
ponavljanja return naredbe, ali moºe postojati i bez nje. Evo primjera jednostavne funkcije koja vra¢a
dvostruku vrijednost od one koju primi:
def double(x):
return x*2
51
52 Funkcije
6.2 Parametri
Formalni parametri koji su jednostavni identikatori navedeni u deniciji funkcije predstavljaju obve-
zatne parametre, ²to zna£i da svaki poziv funkcije mora pruºiti i odgovaraju¢u vrijednost - ( argument )
za svaki parametar. Nakon niza ili liste parametara odvojenih zarezima s niti jednim ili s vi²e (obveznih)
parametara moºe slijediti jedan ili vi²e slobodnih parametara koji imaju sljede¢u sintaksu:
identifikator=izraz
Naredba def ra£una, ocjenjuje izraz, te sprema referencu vrijednosti koju izraz vra¢a, koja se zove
pretpostavljena vrijednost (eng. default value ). Kad poziv funkcije nema argument koji odgovara
takvom slobodnom parametru, onda se identikator argumenta povezuje s tom pretpostavljenom, ili
izra£unatom, vrijednosti.
Treba primjetiti da se isti objekt, pretpostavljena vrijednost, povezuje sa slobodnim parametrom
kad god u pozivu funkcije nema pridruºenog argumenta. Ovo dakako, moºe biti nezgodno, ako je
pretpostavljena vrijednost promjenljivi objekt, a tijelo funkcije mijenja taj parametar. Na primjer:
def f(x, y=[ ]):

y.append(x)
return y
print f(23) # ispisuje se: [23]
prinf f(42) # ispisuje se: [23,42]
Druga naredba print ispisuje [23,42] zato jer prvi poziv funkcije f mijenja vrijednost y, koja je
prije bila prazna lista [], a onda dodavanjem 23 poprima tu novu (a pretpostavljenu) vrijednost, pa
novi poziv uzima zadnje stanje argumenta. Ako je potrebno povezati y s novim objektom liste svaki
put kada se f poziva s jednim argumentom, koristi se sljede¢e:
def f(x, y=None):

if y is None: y = [ ]
y.append(x)
return y
print f(23) # ispisuje se: [23]
prinf f(42) # ispisuje se: [42]
Na kraju formalnih parametara u deniciji funkcije, dopu²teno je koristiti jedan ili oba posebna
oblika: *identifikator1 i **iidentifikator2. Ako su obadva na raspolaganju, onaj s dvije zvjezdice
mora do¢i zadnji. Parametar *identifikator1 omogu¢uje da poziv funkcije moºe osigurati dodatne
pozicijske argumente, dok **identifikator2 omogu¢uje da poziv funkcije moºe osigurati dodatne
argumente s imenom. Na taj na£in rje²avaju se pozivi funkcija s promjenljivim, varijabilnim brojem
argumenata. Svaki poziv funkcije povezuje identifikator1 s n-tercem £iji su £lanovi dodatni pozicijski
argumenti (ili praznim n-tercem, ako ih nema). Identifikator2 povezuje se s rje£nikom £iji su £lanovi
imena i vrijednosti dodatnih argumenata koji se imenuju (ili praznim rje£nikom, ako ih nema). Evo
kako se pi²e funkcija koja prihva¢a bilo koji broj argumenata i vra¢a njihov zbroj:
def zbroj(*broj):
rez = 0
for x in broj: rez += x
return rez
print zbroj(23,42) # ispisuje se: 65

print zbroj(23,42,15) # ispisuje se: 80
Oblik ** dopu²ta konstrukciju rje£nika s klju£evima stringa u obliku koji se lak²e £ita nego stan-
dardna rje£ni£ka sintaksa:
6.3. Atributi funkcijskih objekata 53
def vbr_rj(**kwds): return kwds
print vbr_rj(a=23, b=42) # ispisuje se: {'a':23, 'b':42}
Treba primjetiti da se tijelo funkcije vbr_rj sastoji od samo jedne jednostavne naredbe, tako da se
moºe staviti u istu liniju kao i naredba def. Dakako, bilo bi jednako to£no (i moºda £itljivije) ako bi se
funkcija vbr_rj ispisala koriste¢i dvije linije umjesto jedne:
def vbr_rj(**kwds):
return kwds
Moºe se takoer denirati rje£nik £iji su klju£evi i vrijednosti funkcije, a onda na£initi rje£nik
dvosmjernim:
inverse = {sin:asin, cos:acos, tan:atan, log:exp}

for f in inverse.keys( ): inverse[inverse[f]] = f
Na taj na£in za odreenu funkciju moºe se brzo na¢i inverzna funkcija. injenica da su funkcije
objekti u Pythonu, £esto se izraºava rije£ima da su funkcije objekti prve klase.
6.3 Atributi funkcijskih objekata

Naredba def denira atribute i tijelo objekta funkcije. Atribut func_name, kojem se moºe pristupiti i kao
__name__, je samo£itaju¢i (engl. read-only ) atribut (pa poku²aj njegovog mijenjanja podiºe iznimku)
koji se odnosi na identikator kori²ten kao ime funkcije u naredbi def. Atribut func_defaults, koji
se moºe ponovno povezati ili re-povezati, odnosi se na n-terac pretpostavljenih vrijednosti za slobodne
parametre (ili prazan n-terac, ako funkcija nema slobodnih parametara). Jo² jedan funkcijski atribut je
dokumentacijski string (engl. documentation string ), takoer poznat kao docstring. Docstring atribut
funkcije moºe se koristiti kao func_doc ili __doc__. Ako je prva naredba u tijelu funkcije string literal,
compiler povezuje taj niz sa docstring atributom funkcije. Docstring se £esto proteºu preko nekoliko
zi£kih linija, te se stoga obi£no ozna£uju kao string literali unutar trostrukih navodnika. Na primjer:
def zbroj(*brojevi):
'''Prihvati bilo koji broj numeri£kih argumenata i vrati njihov zbroj
Argumenti su n-terac ili lista od jednog ili vi²e brojeva. Izlaz je njihov zbroj. '''
rez = 0
for broj in brojevi: rez += broj
return rez
Dokumentacijski nizovi vaºan su sadrºaj svakoga Python kôda. Njihova je uloga sli£na komentarima
u bilo kojem programskom jeziku, ali im je iskoristivost ²ira, jer su dostupni pri procesu pokretanja pro-
grama (engl. runtime ). Programerska okruºenja i drugi alati mogu koristiti docstring -ove funkcijskih,
klasnih i modularnih objekata da podsjete programera kako koristiti te objekte. To zna£i da djeluju
kao pomo¢ (engl. help ) programa. Da bi sedocstring u£inio ²to korisnijim, trebalo bi po²tovati nekoliko
jednostavnih dogovora. Prva linija docstringa trebala bi biti saºeti opis svrhe funkcije, a po£injala
bi s velikim slovom i zavr²avala to£kom. Unutar nje se ne bi trebalo spominjati ime funkcije, osim
ako ime nije rije£ iz prirodnog, govornog jezika pa dolazi kao dio opisa operacije te funkcije. Ako je
docstring protegnut preko vi²e linija, druga linija trebala bi biti prazna, a sljede¢e linije bi trebale for-
mirati jedan ili vi²e odlomaka, odvojenih praznim linijama, koji opisuju o£ekivane argumente funkcije,
potrebne uvjete, izlazne (povratne) vrijednosti, te mogu¢e nuspojave. Daljnja obja²njenja, knjiºevne
reference, te primjeri kori²tenja (koji se mogu provjeriti sa doctest) mogu po slobodnom izboru slijediti
iza, prema zavr²etku docstring -a. Uz ove predenirane atribute, funkcijskom objektu mogu se dodati
i drugi atributi. Da bi se stvorio atribut objekta funkcije, prikladna atributna vrijednost se nakon
54 Funkcije
izvr²enja naredbe def povezuje s odgovaraju¢im referencama. Na primjer, funkcija moºe brojati koliko
je puta pozivana:
def counter( ):
counter.count += 1
return counter.count
counter.count = 0
Iako ogu¢nost pridruºivanja atributa s funkcijom moºe ponekad biti od koristi njena primjena nije
£esta. Mnogo £e²¢e, kada se trebaju povezati neki podaci i programski kôd zajedno, koriste se objektno-
orijentirani mehanizmi.
6.4 Naredba 'return'

Naredba return u Pythonu dopu²ta se jedino unutar tijela funkcije, a iza nje moºe slijediti neki izraz.
Kada se return izvr²i, funkcija zavr²ava i dobiva se povratna vrijednost izraza. Funkcija vra¢a vrijed-
nost None ako zavr²ava dolaskom do konca svog funkcijskog tijela ili izvr²enjem naredbe return bez
pridruºenog izraza. Stvar je stila programskog pisanja da se naredba return ne pi²e na kraju tijela
funkcije, ako ona nema izraz koji se vra¢a programskom kôdu koji funkciju poziva. Isto tako, ako neke
return naredbe u funkciji imaju izraz koji vra¢aju pozivatelju, onda bi ga i sve ostale return naredbe
trebale imati. Naredba return None moºe se pisati ako se eksplicitno ºeli zadrºati stil takvog pisa-
nja. Iako Python ne prisiljava na stilske konvencije, njihovo po²tivanje na£init ¢e na² kôd jasnijim i
£itljivijim.
6.5 Poziv funkcije

Poziv funkciji je izraz sa sljede¢om sintaksom:
funkcijsko_ime(argumenti)
funkcijsko_ime moºe biti bilo kakva referenca na objekt funkcije, ²to je naj£e²¢e samo ime doti£ne
argumenti u najjednostavnijem slu£aju niz
funkcije. Zagrade ozna£uju operaciju poziva funkcijie, dok su
od nula ili vi²e izraza odvojenih zarezima, koji daju, prenose, vrijednosti odgovaraju¢im parametrima
denirane funkcije. Kada se funkcija poziva , parametri poziva funkcije povezuju se s funkcijskim
argumentima, tijelo funkcije se izvr²ava sa stvarnim vrijenostima argumenata, a funkcija nakon izvr²enja
na koncu vra¢a pozivatelju neku vrijednost izraza.
6.5.1 Prijenos argumenata

U tradicionalnim terminima izraºeno, sve operacije preno²enja argumenata u Pythonu su putem vri-
jednosti (engl. by value ). Na primjer, ako se varijabla prenosi kao argument, Python prenosi funkciji
objekt (vrijednost) koju varijabla pokazuje, a ne samu varijablu (adresu koju sadrºi). Na taj na£in
funkcija ne moºe re-povezati, tj. mijenjati sadrºaj varijable, nego samo kopiju vrijednosti. Ali, ako
se kao argument prenosi promjenljivi objekt, funkcija moºe zahtjevati izmjene na objektu, jer Python
prenosi sam objekt (njegovu adresu), a ne njegovu kopiju. Re-povezivanje varijable i promjena objekta
su dva potpuno razli£ita koncepta u Pythonu. Na primjer:
def f(x, y):

x = 23
y.append(42)
a = 77
b = [99]
6.5. Poziv funkcije 55
f(a, b)
print a, b # ispisuje se: 77 [99, 42]
Naredba print pokazuje da je a jo² uvijek povezano sa 77, iako se kao parametar x proslijedila u
funkciju f(x,y). Re-povezivanje funkcijskog parametra x na 23 nema efekta s obzirom na poziv funkcije
f, jer je x lokalna varijabla funkcije.
Meutim, naredba print takoer pokazuje da je b sad povezano s [99,42]. Objekt b je jo² uvijek
povezan s istim objektom liste kao i prije poziva, ali se taj objekt mijenjao, jer se unutar funkcije f
pridodao 42 na taj objekt liste. U oba slu£aja, f nije izmijenio poveznice pozivatelja, niti f moºe
izmijeniti broj 77, jer su brojevi nepromjenljivi. Ali, f moºe izmijeniti objekt liste, jer su objekti liste
promjenljivi. U ovom primjeru, f mijenja objekt liste koji pozivatelj prenosi na f kao drugi argument
pozivaju¢i append metodu objekta.
6.5.2 Vrste argumenata

Upravo opisani argumenti zovu se pozicijski argumenti. Svakom pozicijskom argumentu pridruºuje se
vrijednost parametra koji mu odgovara po poziciji (redoslijedu) u deniciji funkcije. U pozivu funkcije
s nula ili vi²e pozicijskih argumenata mogu slijediti jedan ili vi²e imenovanih argumenata sa sljede¢om
sintaksom:
identifikator=izraz
identifikator mora biti jedno od imena formalnih parametara koja se koriste u def naredbi
funkcije. izraz daje vrijednost formalnom parametru.
Poziv funkcije mora pruºiti, putem pozicijskih i/ili imenovanih argumenata, to£no jednu vrijednost
za svaki obvezatni parametar, te nula ili jednu vrijednost za svaki slobodno izabrani parametar. Na
primjer:
def divide(divisor, dividend): return dividend // divisor
print divide(12,94) # ispisuje se: 7

print divide(dividend=94, divisor=12) # ispisuje se: 7
O£evidno je da su ova dva poziva za dijeljenje ekvivalentna. Imenovani argumenti £esto se pi²u u
svrhu £itljivosti, kada se £itljivost i razumljivost napisanog kôda moºe pove¢ati identikacijom uloge i
upravljanjem redoslijeda argumenata. Treba primjetiti, kako kod poziva imenovanih arguemanta nije
bitan redoslijed njihova pisanja. e²ta uporaba imenovanih argumenata je u svrhu povezivanja izabranih
parametara s posebnim vrijednostima, dok drugi slobodni parametri uzimaju svoje pretpostavljene
vrijednosti:
def f(middle, begin='init', end='finis'): return begin+middle+end

print f('tini', end='') # ispisuje se: inittini
Zahvaljuju¢i imenovanom argumentu end= pozivatelj moºe specicirati vrijednost, u ovom slu£aju
to je prazan string' ' za funkcijski (tre¢i) parametar end, te jo² uvijek dopustiti funkcijskom (drugom)
parametru begin, kori²tenje njegove pretpostavljne vrijednosti, stringu 'init'. Na kraju argumenata u
pozivu funkciji, po izboru se moºe koristiti bilo koji (ili oba) posebna oblika *niz i **rj. Ako su oba
prisutna, onaj sa dvije zvjezdice mora do¢i na zadnjem mjestu.
Parametar *niz prenosi £lanove niz kao pozicijske argumente funkcije (poslije obi£nih pozicijskih
argumenata, ako ih ima). Pritom niz moºe biti bilo kakav niz ili iterator.
S druge pak strane, **rj prenosi £lanove rj kao imenovane argumente funkcije, gdje rj mora
biti rje£nik £iji su svi klju£evi stringovi. Klju£ svakog £lana je ime parametra, a vrijednost tog £lana
je vrijednost argumenta. Ponekad je potrebno prenijeti argument oblika *niz ili **rj kad formalni
parametri koriste sli£ne oblike. Na primjer, koriste¢i funkciju zbroj() moºe se ispisati zbroj svih
vrijednosti u rije£niku d. Ovo se postiºe vrlo jednostavno sa *niz oblikom:
56 Funkcije
def zbroj(*br):
rez = 0
for x in br: rez += x
return rez
print zbroj(*d.values( ))
Dakako, argumenti oblika *niz ili **rj mogu se prenositi i kad se poziva funkcija koja ne koristi
sli£ne oblike u svojim formalnim parametrima.
6.5.3 Prostor imena

Formalni parametri funkcije zajedno s bilo kakvim varijable koje su povezane (pridruºbom ili nekom
drugom povezuju¢om naredbom) u funkcijskom tijelu, tvore lokalni prostor imena funkcije (eng. local
namespace ), takoer poznat i kao lokalni doseg (eng. local scope ). Svaka od ovih varijabli zove se lokalna
varijabla funkcije. Varijable koje nisu lokalne zovu se globalne varijable. Ako lokalna varijabla unutar
funkcije ima isto ime kao i globalna varijabla, kada god se to ime spomene u tijelu funkcije, koristi
se lokalna, a ne globalna varijabla. Za ovakav pristup kaºe se da lokalna varijabla sakriva globalnu
varijablu istog imena kroz cijelo tijelo funkcije.
6.5.4 Naredba 'global'

Kako je prethodno opisano, bilo koja varijabla koja je povezana unutar tijela funkcije je lokalna varijabla
funkcije. Ako pak funkcija treba re-povezati neke od svojih globalnih varijabli, prva naredba funkcije
mora biti:
global identifikatori
gdje su identifikatori jedan ili vi²e identikatora odvojenih zarezima. Identikatori popisani u
global naredbi odnose se na globalne varijable koje funkcija treba re-povezati. Na primjer, _count se
moºe ubaciti u funkciju koriste¢i klju£nu rije£ global i globalnu varijablu, kako slijedi:
_count = 0
def counter( ):
global _count
_count += 1
return _count
Bez global naredbe, funkcija counter() UnboundLocalError iznimku, jer bi _count bio
bi podigla
neinicijalizirana (nepovezana) lokalna varijabla. Takoer, iako naredba global omogu¢uje ovakvu vrstu
programiranja, to ipak nije niti elegantno niti preporu£ljivo. Naredba global nije potrebna ako tijelo
funkcije jednostavno koristi globalnu varijablu, uklju£uju¢i mijenjanje objekta povezanog na varijablu,
dakako ako je objekt promjenljiv. Naredba global treba se koristiti samo onda kada tijelo funkcije
re-povezuje globalnu varijablu. Stvar je stila, a i preporuke, da se naredba global ne koristi osim kad
je to apsolutno nuºno.
6.6 Ugnjeºene funkcije

Naredba def unutar tijela funkcije denira ugnjeºenu funkciju (eng. nested function ), a funkcija £ije
tijelo uklju£uje def je poznata kao vanjska funkcija (eng. outer function ) s obzirom na ugnjeºenu.
Kôd unutar tijela ugnjeºene funkcije moºe pristupiti (ali ne i re-povezati) lokalne varijable vanjske
funkcije, takoer poznate i kao slobodne varijable ugnjeºene funkcije.
Najjednostavniji na£in da se dopusti ugnjeºenoj funkciji pristup vanjskim vrijednostima nije osla-
njati se na ugnjeºene dosege varijabli ili upotreba global naredbe, nego prijenos vanjskih vrijednosti
6.6. Ugnjeºene funkcije 57
preko funkcijskih parametara/argumenata ugnjeºdene funkcije. Vrijednost argumenta moºe se povezati

kada se ugnjeºena funkcija denira s pretpostavljenom vrijednosti za izabrani argument. Na primjer:
def postotak_1(a, b, c):

def pc(x, ukupno=a+b+c): return (x*100.0) / ukupno
print "Postotci su: ", pc(a), pc(b), pc(c)
Isti program s upotrebom ugnjeºenih dosega izgledao bi ovako:
def postotak_2(a, b, c):

def pc(x): return (x*100.0) / (a+b+c)
print "Postotci su: ", pc(a), pc(b), pc(c)
U ovom slu£aju, postotak_1 ima malu prednost: izra£un a+b+c dogaa se samo jednom, dok kod
postotak_2 nutarnja funkcija pc ponavlja izra£un tri puta. Meutim, ako vanjska funkcija re-povezuje
svoje lokalne varijable izmeu poziva ugnjeºene funkcije, ponavljanje izra£una bi mogla biti i prednost.
To zna£i da se preporu£uje znanje oba pristupa, te izbor najprikladnijeg u danoj situaciji.
Ugnjeºena funkcija koja pristupa vrijednostima s vanjskih lokalnih varijabla poznata kao je za-
tvorena funkcija ili closure. Sljede¢i primjer pokazuje kako izgraditi closure bez ugnjeºenih dosega
(koriste¢i pretpostavljenu vrijednost):
def make_adder_1(augend):
def add(addend, _augend=augend): return addend+_augend
return add
Ista funkcija kori²tenjem ugnjeºenih dosega izgleda ovako:
def make_adder_2(augend):
def add(addend): return addend+augend
return add
Closures su iznimke u op¢em pravilu, jer su objektno-orjentirani mehanizmi najbolji na£in pove-
zivanja podataka i kôda zajedno. Kada se trebaju konstruirati pozivni objekti, s nekim parametrima
u vremenu konstrukcije objekta, closures mogu biti ekasnije i jednostavnije od klasa. Na primjer,
rezultat make_adder_1(7) je funkcija koja prihva¢a jedan argument i dodaje 7 na taj argument (re-
zultat make_adder_2(7) se pona²a na isti na£in). Closure je "tvornica" za bilo kojeg £lana obitelji
funkcija koji se razlikuju po nekim parametrima, te moºe pomo¢i u izbjegavanju dvostrukog pisanja
programskog kôda.
POGLAVLJE 7
Python - objektni jezik
Python je programski jezik temeljen na objektima. Za razliku od nekih drugih, takoer objektno-
orijentiranih, jezika, Python ne uvjetuje kori²tenje isklju£ivo objektno-orijentirane paradigme. Pyt-
hon takoer podrºava proceduralno (strukturalno) programiranje s modulima i funkcijama, tako da je
mogu¢e izabrati najprikladniju paradigmu programiranja za svaki dio programa. Op¢enito, objektno-
orijentirana paradigma najbolja je kada se ºele skupiti podaci i funkcije u prakti£ne pakete. Isto tako
moºe biti korisna kada se ºele koristiti neki od Pythonovih objektno-orijentiranih mehanizama, kao npr.
naslijeivanje. Proceduralna paradigma, koja je bazirana na modulima i funkcijama, obi£no je jed-
nostavnija i prikladnija u slu£ajima kada nikakve prednosti objektno-orijentiranog programiranja nisu
potrebne. Novi stil objektnog modela postaje standard u novim verzijama Pythona, pa se preporu£uje
koristiti ga za programiranje.
7.1 Klase i instance

Klasa ili razred je Python objekt s nekoliko zna£ajki:
• Objekt klase moºe se pozivati kao da je funkcija. Poziv stvara novi objekt, poznat kao instanca
klase, za koju se zna kojoj klasi pripada.
• Klasa ima po volji imenovane atribute koji se mogu povezivati i referirati.
• Vrijednosti atributa klase mogu biti podat£ani objekti ili funkcijski objekti.
• Atributi klase koji su povezani na funkcije poznati su kao metode klase.

• Metoda moºe imati posebno ime denirano od Pythona s dvije podcrte ('__') ispred i iza imena.
Python upotrebljava takve posebne metode za neke operacije koje se izvr²avaju na instancama
klase.
• Klasa moºe podatke i metode naslijediti od drugih klasa, pa potraga nekog atributa koji nije
unutar same klase prenosi se na druge objekte, roditelje klase.
• Instanca klase je Python objekt s po volji imenovanim atributima koji se mogu povezivati i
referirati.
• Python klase su objekti, pa se s njima postupa kao i s drugim objektima. Tako se klasa moºe
prenijeti kao argument u pozivu funkcij, a funkcija moºe vratiti klasu kao rezultat poziva. Klasa,
kao i bilo koji drugi objekt, moºe biti povezana na varijablu (lokalnu lili globalnu), £lan niza ili
atribut objekta. Klase takoer mogu biti i klju£evi u rije£niku.
59
60 Python - objektni jezik
7.2 Naredba 'class'

Naredba class je naj£e²¢i na£in stvaranja objekta klase, i to s ovakvom sintaksom:
class ime\_klase[(klase\_roditelji)]:
naredba(e)
String ime_klase je identikator. To je varijabla koja postaje povezana (ili re-povezana) s objektom
klase nakon ²to naredba class zavr²i s izvr²avanjem. klase_roditelji je po volji zarezima odvojen
niz izraza (obi£no stringovnih identikatora) £ije su vrijednosti objekti klasa. Ove su klase poznate
pod razli£itim imenima u razli£itim jezicima - govori se o baznim klasama, superklasama ili roditeljima
klase koja se stvara. Za klasu koja se stvara kaºe se da 'nasljeuje oblik', 'po£inje od', 'produºava se'
ili 'podklasira' od svoje bazne, roditeljske klase. Ova klasa takoer je poznata kao izravna podklasa ili
potomak C1 podklasa od C2, a
svojih baznih klasa. Podklasna veza izmeu klasa je prijelazna: ako je
C2 podklasa od C3, onda je C1 podklasa od C3. Ugraena funkcija issubclass(C1,C2) prihva¢a dva
argumenta koji su objekti klase: vra¢a True ako je C1 podklasa od C2; u suprotnom vra¢a False. Svaka
klasa je zapravo podklasa od same sebe, tako da issubclass(C, C) vra¢a True za bilo koju klasu C.
Sintaksa naredbe class ima malu, nezgodnu razliku od sintakse naredbe def. U naredbidef, zagrade
su obvezatne izmeu imena funkcije i dvoto£ke. Da se denira funkcija bez formalnih parametara, mora
se koristiti naredba kao:
def ime( ):
naredba(e)
U naredbi class zagrade su obvezatne ako klasa ima jednu li vi²e roditeljskih klasa, ali su zabranjene
ako ih klasa nema. Tako se za denaciju klase bez roditeljskih klasa mora koristiti naredba ovakve
sintakse:
class ime:
naredba(e)
Niz naredbi koji nije prazan, a koji slijedi naredbu class poznat je kao tijelo klase. Tijelo klase
izvr²ava se odmah, kao dio procesa izvr²enja naredbe class. Dok se tijelo ne izvr²i, novi objekt klase
ne postoji i identikatorime nije jo² povezan (ili re-povezan). Kona£no, valja primijetiti da naredba
class ne stvara nove instance klase, nego denira skup atributa koji se dijele izmeu svih instanci koje
se iz klase stvore.
7.3 Tijelo klase

Tijelo klase je mjesto gdje se speciciraju atributi klase ; ovi atributi mogu biti podat£ani ili funkcijski
objekti.
7.3.1 Atributi klasnog objekta

Atribut objekta klase obi£no se denira povezivanjem neke vrijednosti (npr. literala) na identikator
unutar tijela klase. Na primjer:
class C1:
x = 23
print C1.x # ispisuje se: 23
Objekt klase C1 ima atribut s imenom x, povezan na vrijednost cjelobrojnog literala 23, a C1.x se
odnosi, referencira na taj atribut. Mogu¢e je takoer povezati ili odvezati atribute klase izvan tijela
klase. Na primjer:
7.3. Tijelo klase 61
class C2:
pass
C2.x = 23
print C2.x # ispisuje se: 23
Ipak, program je £itljiviji ako se poveºu, tj. stvore, atributi klase s naredbama unutar tijela klase.
Bilo koji atributi klase implicitno se dijele svim instancama klase kad se te instance stvore. Naredba
class implicitno denira neke vlastite, posebne atribute klase. Atribut __name__ je ime klase,
stringovni identikator kori²ten u naredbiclass. Atribut __bases__ je n-terac objekata klase koji su
dani kao roditeljske klase u naredbi class (ili prazan n-terac, ako nema zadanih roditeljskih, baznih
klasa). Na primjer, za ve¢ stvorenu klasu C1 vrijedi:
print C1.__name__, C1.__bases__ # ispisuje se: C1, ( )
Klasa takoer ima atribut __dict__, ²to je rje£ni£ki objekt kojeg klasa koristi za potporu (popis)
svih svojih ostalih atributa. Za svaki objekt klase C, bilo koji objekt x i za bilo kakav identikator S
(osim__name__, __bases__ i __dict__) vrijedi:
C.S=x je ekvivalentan s C.__dict__['S']=x.
Na primjer, za poznatu klasu C1:
C1.y = 45
C1.__dict__['z'] = 67
print C1.x, C1.y, C1.z # ispisuje se: 23, 45, 67
Pritom nema razlike izmeu atributa klase koji su stvoreni unutar tijela klase, izvan tijela klase
zadavanjem atributa ili izvan tijela klase eksplicitnim povezivanjem sa C.__dict__.
U naredbama koje su izravno u tijelu klase, reference na atribute klase moraju koristiti puno, a ne
jednostavno ime kvantikatora. Na primjer:
class C3:
x = 23
def f1(self):
print C3.x # mora se koristiti C3.x, a ne samo x
Treba primijetiti da reference atributa (npr. izraz kao C.S) imaju bogatiju semantiku nego jednos-
tavno povezivanje atributa.
7.3.2 Denicija funkcije unutar tijela klase

Ve¢ina tijela klasa uklju£uju naredbu def, jer su funkcije (u ovom kontekstu se zovu metode ) vaºni
atributi za objekte klase. Uz to, metoda denirana unutar tijela klase uvijek ima obvezatan prvi
parametar, koji se dogovorno imenuje kao self, a odnosi se na instancu u kojoj se metoda poziva.
Parametar self igra posebnu ulogu u pozivima metode. Evo primjera klase koja uklju£uje deniciju
metode:
class C4:
def pozdrav(self):
print "Zdravo"
Klasa moºe denirati takoer nekoliko posebnih metoda (metoda sa imenima koja imaju dvije
podcrte ispred i iza imena), a koje se odnose na posebne operacije.
7.3.3 Varijable speci£ne za klasu

Kada naredba u tijelu klase (ili u metodi unutar tijela) koristi identikator koji po£inje s dvije podcrte
(ali ne zavr²ava podcrtama) - __ident, Python compiler implicitno mijenja identikator u _classname__ident,
gdje je classname ime klase. Ovo dopu²ta klasi kori²tenje privatnih imena za atribute, metode, glo-
balne varijable i druge svrhe, bez rizika njihovog slu£ajnog dupliciranja negdje drugdje. Dogovorno, svi
identikatori koji po£inju jednom podcrtom takoer se namijenjeni kao privatni, za doseg koji ih pove-
zuje, bez obzira je li doseg unutar klase ili nije. Python compiler ne prisiljava dogovore oko privatnosti
varijabli i metoda, to je ostavljeno programerima u Pythonu.
7.3.4 Dokumentacijski string

Ako je prva naredba u tijelu klase literal niza znakova (string), onda compiler povezuje taj niz znakova
kao atribut dokumentacijskog stringa za tu klasu. Ovaj se atribut zove __doc__ te je poznat kao
dokumentiranje klase. Ima isto svojstvo kao ve¢ opisan po£etni komentar ili pomo¢ (engl. help ) u
deniciji funkcije.
7.4 Instanca klase

Neka je zadana klasa ZiroRacun ovako:
class ZiroRacun:
"Jednostavna klasa"
tip_racuna = "Ziro"
def _ _init_ _(self,ime,racun):
"Inicijalizacije nove klase"
self.osoba = name
self.novac = racun
def polog(self,iznos):
"Dodaje iznosu na ra£unu"
self.novac = self.novac + iznos
def povuci(self,iznos):
"Oduzima od iznosa na ra£unu"
self.novac = self.novac - iznos
def provjeri(self):
"Vraca iznos na racunu"
return self.novac
Instance klase stvaraju se pozivom class objekta. Tada se istodobno stvara nova instanca i poziva
__init__() metoda te klase (ako je u njoj denirana). Na primjer:
# Neka se klasa zove ZiroRacun

a = ZiroRacun("Mario", 1000.00)
# Stvara instancu 'a' i poziva ZiroRacun.__init__(a,"Mario", 1000.00)
b = ZiroRacun("Bill", 100000000000L)
# Stvara instancu 'b' i poziva ZiroRacun.__init__(b,"Bill", 100000000000L)
Jednom na£injeni, atributi i metode novo nastale instance dohvatljivi su kori²tenjem ' to£ka ' (.)
operatora:
a.polog(100.00) # Poziva ZiroRacun.deposit(a,100.00)

b.povuci(sys.maxint) # Poziva ZiroRacun.povuci(b,sys.maxint)
i = a.ime # Dohvaca a.ime
print a.tip_racuna # Ispisuje tip_racuna
7.4. Instanca klase 63
Interno, svaka instanca se stvara koriste¢i rje£nik koji je dohvatljiv kao instanca __dict__ atributa.
Ovaj rje£nik sadrºi informaciju koja je jedinstvena za svaku instancu. Na primjer:
>>> print a.__dict__

{'novac': 1000.0, 'osoba': 'Mario'}
>>> print b.__dict__
{'novac': 100000000000L, 'osoba': 'Bill'}
Kad god se atributi instance promijene, ove promjene nastaju u njihovom lokalnom rje£niku instance.
Unutar metoda deniranih u klasi, atributi se mijenjaju kroz pridruºbu self varijabli. Meutim, novi
atributi mogu se dodati nekoj instanci u bilo kojem trenutku, kao na primjer:
a.jmbg = 123456 # dodaje atribut 'jmbg' u a.__dict__
Iako se pridruºba atributima uvjek provodi na lokalnom rje£niku neke instance, pristup atributu
ponekad je vrlo sloºen. Kad god se pristupa atributu, Python interpreter (compiler) prvo pretraºuje
rje£nik instance. Ako ne nae traºeno, onda se pretraºuje rje£nik objekta klase koja se koristila za
stvaranje instance. Ako ni to nije urodilo plodom, onda se provodi pretraºivanje roditeljskih klasa (ako
ih klasa ima). Ako i to propadne, kona£ni poku²aj traºenja atributa je pozivom __getattr__() metode
te klase (ako je denirana). Na koncu, ako ni to ne uspije, onda se podiºe AttributeError iznimka.
Kako je pokazano, da bi se stvorila instanca klase, treba se (poput poziva funkcije) pozvati objekt
klase. Svaki poziv vra¢a novi objekt instance te klase:jedna_instanca = C5(). Ugraena funkcija
isinstance(Obj,C) s objektom klase kao argumentom C vra¢a True ako je objekt Obj instanca klase
C ili bilo koje podklase od C. U protivnom isinstance vra¢a False.
7.4.1 __init__
Kada klasa ima ili nasljeuje metodu __init__, poziv objektu klase implicitno izvr²ava __init__ na
novoj instanci kako bi se obavila inicijalizacija koja je potrebna instanci. Argumenti koji se predaju
putem poziva moraju odgovarati formalnim parametrima __init__ metode. Na primjer, u sljede¢oj
klasi:
class C6:
def __init__(self,n):
self.x = n
Evo kako stvoriti jednu instancu klase C6:
jedna_instanca = C6(42)
Kako je pokazano u C6 klasi, metoda __init__ obi£no sadrºi naredbe koje povezuju atribute ins-
tance. Metoda __init__ ne smije vra¢ati nikakvu vrijednost osim vrijednosti None, jer svaka druga
vra¢ena vrijednost uzrokuje TypeError iznimku. Glavna svrha __init__ je povezivanje, tj. stvaranje
atributa novostvorene instance. Atributi instance takoer se mogu povezivati ili re-povezivati i izvan
__init__ metode. Programski kod bit ¢e £itljiviji ako se svi atributi klasne instance inicijalno poveºu
naredbama u metodi __init__.
7.4.2 Atributi objekta instance

Jednom kada se stvori instanca, moºe se pristupiti njenim atributima (podacima i metodama) koriste¢i
to£ka ' (.)
' operator. Na primjer:
i4=C4();
i4.pozdrav( ) # ispisuje se: Zdravo
print jedna_instanca.x # ispisuje se: 42
Objektu instance moºe se dodati neki atribut povezivanjem neke vrijednosti na referencu atributa.
Na primjer:
class C7: pass

z = C7( )
z.x = 23
print z.x # ispisuje se: 23
Objekt instance z sada ima atribut koji se zove x, 23, i z.x se odnosi na taj
povezan na vrijednost
atribut. To povezivanje atributa omogu¢uje takoer posebna metoda __setattr__. Stvaranje instance
implicitno denira dva atributa instance. Za svaku instancu z, z.__class__ je klasa objekta kojemu
z pripada, a z.__dict__ je rje£nik koji z koristi za £uvanje svih svojih ostalih atributa. Na primjer, za
instancu z koja je upravo stvorena:
print z.__class__.__name__, z.__dict__ # ispisuje se: C7, {'x':23}
Oba ova atributa mogu se re-povezati (ali ne odvezati), iako je ovo rijetko nuºno. Za bilo koji objekt
instance z, bilo koji objekt x, i bilo koji identikator S (osim __class__ i __dict__), z.S=x je
ekvivalentan s z.__dict__['S']=x (osim ako __setattr__ posebna metoda presretne poku²aj povezi-
vanja). Na primjer, za poznatu stvarenu instancu z:
z.y = 45
z.__dict__['z'] = 67
print z.x, z.y, z.z # ispisuje: 23, 45, 67
Nema razlike u atributima instance stvorenima s funkcijom __init__, zadavanjem preko atributa
ili po eksplicitnom povezivanju sa z.__dict__.
7.4.3 Tvorni£ka funkcija

Postoji potreba stvaranja instance razli£itih klasa ovisno o nekim uvjetima ili izbjegavanje stvaranja
nove instance ako je postoje¢a jo² uvijek dostupna. Te bi se potrebe mogle rije²iti tako da __init__
vrati speci£an objekt, ali to nije mogu¢e jer Python podiºe iznimku kad __init__ vrati bilo koju
vrijednost osim None. Najbolji na£in implementacije eksibilnog stvaranja objekata je koriste¢i obi£nu
funkciju, a ne pozivanjem objekta klase izravno. Funkcija koja se koristi u ovu svrhu zove se tvorni£ka
funkcija.
Pozivanje tvorni£ke funkcije je eksibilno rje²enje, jer takva funkcija moºe vra¢ati postoje¢u instancu
koja se moºe ponovno koristiti ili stvoriti novu instancu pozivanjem odgovaraju¢e klase. Recimo da
postoje dvije sli£ne klase (Posebna i obicna) i da se treba generirati jedna od njih, ovisno o argumentu.
Sljede¢a tvorni£ka funkcija Prikladna to omogu¢uje:
class Posebna:
def metoda(self): print "posebna"
class Obicna:
def metoda(self): print "obicna"
def Prikladna(obicnaje=1):
if obicnaje: return Obicna( )
else: return Posebna( )
i1 = Prikladna(obicnaje=0)
i1.metoda( ) # ispisuje se: "posebna", kako je traºeno
7.5. Nasljeivanje 65
7.4.4 Brojanje referenci i brisanje instance

Sve instance imaju brojilo referenci. Ako brojilo referenci postane jednako nuli, instanca se bri²e. Iako
postoji vi²e na£ina kako izbrisati referencu, program naj£e²¢e koristi del naredbu za brisanje reference
na objekt. Ako brisanje neke refernce u£ini da se brojilo referenci objekta smanji na nulu, program ¢e
pozvati __del__() metodu. Python-ov 'skuplja£ sme¢a' bri²e iz memorije sve instance koje su ostale
bez referenci i na taj na£in oslobaa memorijski prostor drugim objektima.
7.5 Nasljeivanje
Nasljeivanje je mehanizam stvaranja novih klasa koje specijaliziraju ili mijenjaju pona²anje postoje¢e
klase. Originalna klasa zove se temeljna, roditeljska klasa (bazna, eng. base class ) ili nadklasa, super-
klasa (engl. superclass ). Nova klasa se zove izvedena klasa ili podklasa (eng. subclass ). Kada se klasa
stvara putem nasljeivanja, ona nasljeuje atribute denirane u njenim roditeljskim klasama. Meutim,
izvedena klasa moºe redenirati bilo koji od ovih atributa i dodati nove vlastite atribute. Nasljeivanje
se specicira s listom imena roditeljskih klasa koje se odvajaju zarezom u class naredbi. Na primjer:
class A:
varA = 42
def method1(self):
print "Class A : method1"
class B:
varB = 37
def method1(self):
print "Class B : method1"
def method2(self):
print "Class B : method2"
class C(A,B): # Nasljeuje se od A i B

varC = 3.3
def method3(self):
print "Class C : method3"
class D: pass
class E(C,D): pass
Ako se traºi atribut deniran u temeljnoj klasi, onda se koristi algoritam u dubinu (eng. depth-rst
search ) za pretraºivanje i to u temeljnim klasama kako su navedene u poretku prilikom denicije klase.
Na primjer, u klasi E u prethodnom primjeru, temeljne klase se pretraºuju redoslijedom C , A, B, D. U
slu£aju da vi²estruke temeljne klase deniraju isti simbol, uzet ¢e se prvi simbol kojeg procs traºenja
nae. Na primjer:
c = C() # Create a 'C'

c.method3() # Invoke C.method3(c)
c.method1() # Invoke A.method1(c)
c.varB # Access B.varB
Ako izvedena klasa denira atribut s istim imenom kao atribut u temeljnoj klasi, onda ¢e instance
od izvedene klase koristiti atribute izvedene, a ne roditeljske klase. Ako se ipak ºeli koristiti originalni
atribut, onda se mora napisati puno ime do tog atributa, tj. ime_roditeljske_klase.atribut, kao
na primjer:
class D(A):
def method1(self):
print "Class D : method1"
A.method1(self) # poziva roditeljsku metodu
Jedna posljedica ove £injenice nalazi se u inicijalizaciji klasnih instanci. Kad se instanca stvara, onda
se ne poziva metoda __init__() roditeljskih klasa. To zna£i, da je u izvedenoj klasi nuºno na£initi
ispravnu inicijalizaciju roditeljske klase, ako je to potrebno. Na primjer:
class D(A):
def __init__(self, args1):
# Inicijalizacija roditeljske klase
A.__init__(self)
# Initialize myself
...
Sli£ni koraci mogu takoer biti nuºni kad se deniraju akcije £i²¢enja (brisanja objekata) u __del__()
metodi. Kada se koristi referenca atributa C.ime na objekt klase, i 'ime' nije klju£ u C.__dict__,
potraga se implicitno proslijeuje na svaki objekt klase koji je u C.__bases__, po redoslijedu navoenja.
C-ove roditeljske klase mogu imati i vlastite roditeljske klase. U ovom slu£aju, potraga rekurzivno
prosljeuje navi²e, po drvetu naslijea, zaustavljaju¢i se kada je 'ime' naeno. Potraga je po dubini,
²to zna£i da pregledava pretke svake roditeljske klase od C prije pregleda sljede¢e roditeljske klase od
C. Slijedi primjer:
class Roditeljska_1:
def neka_metoda(self): print "Roditeljska_1"
class Roditeljska_2(Roditeljska_1): pass
class Base3:
def neka_metoda(self): print "Roditeljska_3"
class Izvedena(Roditeljska_2, Roditeljska_3): pass
inst1 = Izvedena( )
inst1.neka_metoda( ) # ispisuje se: "Roditeljska_1"
U ovom slu£aju potraga za metodom zapo£inje u klasi Izvedena. Ako tamo nije pronaena, potraga
se nastavlja na Roditeljska_2. Ako ni tamo atribut nije naen, potraga ide na pretka Roditeljska_2,
tj. na Roditeljska_1, gdje je atribut napokon naen. Tako se pretraga zaustavlja na toj to£ki i nikada
ne uzima u obzir Roditeljska_3, gdje bi se taj atribut takoer na²ao.
7.5.1 Premo²¢uju¢i atributi

Potraga za atributom, kako je obja²njeno, ide navi²e po drvetu naslijea (prema precima), te se za-
ustavlja kada je atribut pronaen. Potoma£ke klase pregledavaju se prije predaka, ²to zna£i da kada
podklasa denira atribut s istim imenom kao i onaj na superklasi, pretraga nalazi deniciju na podklasi
i tu se zaustavlja. Ovo je poznato kao premo²¢ivanje (engl. overriding ) denicije u superklasi koje
obavlja podklasa:
class B:
a = 23
b = 45
def f(self): print "metoda f u klasi B"
def g(self): print "metoda g u klasi B"
class C(B):
b = 67
7.5. Nasljeivanje 67
c = 89
d = 123
def g(self): print "metoda g u klasi C"
def h(self): print "metoda h u klasi C"
U ovom kodu, klasa C premo²¢uje atribute big od njene superklase B.
7.5.2 Posluºivanje metoda superklase

Kada podklasa C premosti metodu f svoje superklase B, tijelo C.f £esto ºeli predati neki dio svoje
operacije implementaciji metode superklase. Ovo se moºe napraviti koriste¢i nepovezanu metodu, kako
slijedi:
class Gornja:
def pozdrav(self, ime): print "Zdravo ", ime
class Donja(Gornja):
def pozdrav(self, ime):
print "Dobro do²li",
Gornja.pozdrav(self, ime)
x = Donja( )
x.pozdrav('Miki')
Predaja superklasi, u tijelu Donja.pozdrav, koristi nepovezanu metodu dobivenu referencom atri-
buta Gornja.pozdrav na superklasi, i zato prenosi sve atribute normalno, uklju£uju¢i self. Predaja
ili posluºivanje implementaciji superklase je glavna korist nepovezanih metoda.
7.5.3 Vi²eobli£je
Vi²eobli£je ili polimorzam, (eng. polymorphism ) ili dinami£ko povezivanje potpuno se otkriva kroz
proces traºenja nekog atributa, prethodno opisano u nasljeivanju objekata. Kad god se metodi pristupa
sa obj.method(), prvo se metoda locira traºenjem __dict__ atributa instance, pa instancine klasne
denicije, pa roditeljskih klasa. To traºenje uvijek ide u tom redoslijedu. Prvi uspje²ni pronalazak
koristi se kao traºena metoda.
7.5.4 Skrivanje informacije (engl. information hiding)

Pretpostavlja se da su svi atributi javni (engl. public ). To zna£i da su svi atributi klasne instance
dohvatljivi bez ikakvog ograni£enja. To takoer povla£i da sve ²to je denirano u temeljnoj, roditeljskoj
klasi nasljeuje se i dohvatljivo je u izvedenoj klasi. Takvo pona²anje je £esto nepoºeljno u objektu
orjentiranim primjenama, jer to otkriva nutarnju strukturu objekta i moºe voditi koniktima prostora
imena izmeu objekata deniranih u izvedenoj klasi i onih deniranih u roditeljskoj klasi. Da bi se
rije²io ovaj probleem, uvedeno je da sva imena u klasi koja po£inju s dvostrukom donjom crtom (__) ,
kao ²to je __Moj, pretvara se u oblik _Classname __Moj. To pruºa rje²enje za klasu da ona ima privatne
atribute, budu¢i da privatna imena u izvedenoj klasi ne¢e kolidirati s imenima u temeljnoj klasi jer su
imena klasa nuºno razli£ita, a dolaze ispred imena atributa. Na primjer:
class A:
def __init__(self):
self.__X = 3 # Pretvara se u self._A__X
class B(A):
def __init__(self):
A.__init__(self)
self.__X = 37 # Pretvara se u self._B__X
Iako ovakva shema daje iluziju sakrivanja podataka, ne postoji stvarni mehanizam da bi se sprije£io
pristup " privatnim " atributima neke klase. To zna£i da, ako su poznati klasa i njen atribut, onda se
oni mogu dohvatiti s gore opisanim punim imenom iz bilo koje instance.
7.5.5 Operatorsko punjenje

Korisni£ki objekti mogu se pro²iriti s novim operatorima, dodaju¢i posebne metode da zajedno rade sa
svim Python-ovim ugraenim operatorima. Na primjer, sljede¢a klasa nadopunja kompleksne brojeve sa
standardnim matemati£kim operatorima i prisilnim tipovima kako bi se ostvarilo mije²anje kompleksnih
brojeva s cijelim i realnim brojevima.
class Complex:
def __init__(self,real,imag=0):
self.real = float(real)
self.imag = float(imag)
def __repr__(self):
return "Complex(%s,%s)" % (self.real, self.imag)
def __str__(self):
return "(%g+%gj)" % (self.real, self.imag)
# self + other
def __add__(self,drugi):
return Complex(self.real + drugi.real, self.imag + drugi.imag)
# self - other
def __sub__(self,drugi):
return Complex(self.real - drugi.real, self.imag - drugi.imag)
# -self
def __neg__(self):
return Complex(-self.real, -self.imag)
# drugi + self
def __radd__(self,drugi):
return Complex.__add__(drugi,self)
# other - self
def __rsub__(self,drugi):
return Complex.__sub__(drugi,self)
# Prisilno pretvori ostale numeri£ke tipove u kompleksni
def __coerce__(self, drugi):
if isinstance(drugi, Complex):
return self,drugi
try: # Provjeriti ako se moºe pretvoriti u float
return self, Complex(float(drugi))
except ValueError:
pass
U ovom primjeru, postoji nekoliko zanimljivih detalja:
1. Prvo, normalno pona²anje od __repr__() je stvaranje stringa koji ¢e se izvr²iti kako bi se ponovno
na£inio objekt. U ovom slu£aju stvara se string oblika "Complex(r,i)". U drugom slu£aju, metoda
__str__() stvara string koji je namijenjen za lijepi formatirani izlaz (to je string koji ¢e se ispisati
s pomo¢u print naredbe).
2. Drugo, da bi se radilo s operatorima u kojima se kompleksni brojevi pojavljuju i na lijevoj i na

desnoj strani operatora, moraju se koristiti __op__() i __rop__() metode.
7.6. Testovi pripadnosti klasa i tipova 69
3. Kona£no, __coerce__ metoda koristi se u dohva¢anju operacija koje uklju£uju mije²ane tipove
podataka. U ovom slu£aju, drugi numeri£ki tipovi pretvaraju se u kompleksne brojeve tako da se
mogu koristiti u metodama kompleksne aritmetike.
7.6 Testovi pripadnosti klasa i tipova

Trenuta£no, postoji odijeljenost izmeu tipova i klasa. To konkretno zna£i, da se ugraeni tipovi poput
lista i rje£nika ne mogu specijalizirati nasljeivanjem, jer ono za njih ne postoji. Isto tako niti klase ne
mogu denirati nove tipove. Ustvari, sve klasne denicije imaju tip ClassType, dok sve klasne instance
imaju tip InstanceType. Zbog toga je izraz
type(a) == type(b)
istinit, za bilo koja dva objekta koja su instance klase (£ak i ako su stvorena iz razli£itih klasa).
Provjera pripadnosti klasi provodi se upotrebom ugraene funkcije isinstance(obj,cname). Ova
funkcija vra¢a istinu, ako objekt obj pripada klasi cname cname. Na
ili bilo kojoj klasi izvedenoj iz
primjer:
class A: pass
class B(A): pass
class C: pass
a = A() # Instanca od 'A'

b = B() # Instanca od 'B'
c = C() # Instanca od 'C'
print isinstance(a,A) # Vra¢a True

print isinstance(b,A) # Vra¢a True, B je izveden iz A
print isinstance(b,C) # Vra¢a False, C nije izveden iz A
Sli£no, ugraena funkcija issubclass(A ,B ) vra¢a istinu ako je A podklasa klase B. Na primjer:
issubclass(B,A) # Vra¢a True

issubclass(C,A) # Vra¢a False
Funkcija isinstance() moºe se koristiti za izvr²avanje provjere tipa s obzirom na bilo koji ugraeni
tip:
import types
isinstance(3, types.IntType) # Vra¢a True
isinstance(3, types.FloatType) # Vra¢a False
Ovo je preporu£en na£in provjere tipa meu ugraenim tipovima, jer ¢e razlika izmeu tipova i klasa
moºda i²£eznuti u budu¢im ina£icama Python-a.
POGLAVLJE 8
Moduli i paketi
Podaci (varijable), funkcije, klase i objekti skupljaju se u module. Vi²e modula zajedno £ini paket.
Moduli i paketi predstavljaju Python knjiºnicu (engl. library ).
8.1 Modul
U modul je mogu¢e uklju£iti bilo koju valjanu datoteku s Python kôdom, te pozvati ga s naredbom
import. Na primjer, neka je sljede¢i kôd spremljen u datoteku 'primjer.py':
# datoteka: primjer.py
a = 37 # Varijabla
def A: # Funkcija
print "Ja sam u A"
class K: # Klasa
def B(self):
print "Ja sam u K.B"
b = K() # Tvorba instance
Pozvati u memoriju ovakav kôd kao modul, postiºe se naredbom import primjer. Prvi put kad se
import koristi da se modul u£ita u memoriju, dogaaju se tri stvari:
1. Modul stvara novi prostor imena koji sluºi svim objektima deniranim u pripadnoj izvornoj
datoteci. Ovaj prostor imena dohva¢a se ako funkcije i metode denirane unutar modula koriste
naredbu global.
2. Modul izvr²ava kôd koji je sadrºan unutar novonastalog prostora imena.
3. Modul izvr²ava ime unutar pozivatelja, koje se odnosi na prostor imena modula. Ovo ime podu-
dara se s imenom modula.
import primjer # U£itava u memoriju i izvodi modul 'primjer'

print primjer.a # Dohva¢a izvodi neki £lan (varijablu) modula 'primjer'
primjer.A() # Dohva¢a i izvodi funkciju iz modula
c = primjer.K() # Dohva¢a i izvodi klasu iz modula, tvorba objekta
...
U£itavanje, uvoz (eng. import ) vi²estrukih modula izvodi se tako da se iza naredbe import dopi²u
imena modula, odijeljena zarezom, na primjer ovako:
71
72 Moduli i paketi
import socket, os, regex
Moduli se mogu u£itati ( importirati ) koriste¢i alternativna imena, i to upotrebom poveznice as. Na
primjer:
import os as sustav
import socket as mreza, thread as nit
sustav.chdir("..")
mreza.gethostname()
Naredba from koristi se za speci£ne denicije unutar modula s trenuta£nim prostoru imena. Ova
naredba predstavlja pro²irenje naredbe import gdje se uz novo stvoreni prostora imena, stvara i refe-
renca na jedan ili vi²e objekata deniranih untar modula:
from socket import gethostname

# Stavlja gethostname u trenuta£ni prostor imena
print gethostname() # Koristi se bez imena modula

socket.gethostname() # Pogre²ka imena (NameError: socket)
Naredba from takoer prihva¢a zarezom odvojena imena objekata. Zvjezdica (engl. asterisk , *) je
sveobuhvatni (engl. wildcard ) znak koji se koristi za u£itanje svih denicija u modulu, osim onih koje
po£inju s podvu£enom crtom (_). Na primjer:
from socket import gethostname, socket

from socket import * # Puni sve definicije u trenuta£ni prostor imena
Moduli se mogu preciznije upravljati skupom imena koji se u£ita s from module import * definiranjem
liste __all__. Na primjer:
# module: primjer.py
__all__ = [ 'K', 'primjer' ] # To su sva ona imena koja ¢e se uvu¢i sa *
Nadalje, poveznica as moºe se koristiti za promjenu imena objekata koji se u£itaju s naredbom
from. Na primjer:
from socket import gethostname as ime_hosta

h = ime_hosta()
Naredba import moºe se pojaviti na bilo kojem mjestu u programu. Meutim, kôd u svakom
modulu izvodi se samo jednom, bez obzira kako £esto se naredba import izvr²ava. Idu¢e import
naredbe jednostavno stvaraju referencu na prostor imena modula koji je stvoren s po£etnom import
naredbom. U varijabli sys.modules moºe se na¢i rje£nik koji sadrºi imena svih trenuta£no napunjenih
modula. On preslikavaa imena modula na njihove objekte. Sadrºaj rje£nika se koristi za odreivanje je
li import napunio svjeºu kopiju modula ili se isti modul poziva drugi put.
Naredba from module import * moºe se koristiti samo na vrhu modula. Drugim rije£ima, nije
dopu²teno koristiti ovaj oblik import naredbe unutar tijela funkcije, zbog njegove interakcije s pra-
vilima funkcijskog dosega (engl. scoping rules ). Svaki modul denira variablu __name__ koja sadrºi
ime modula. Programi mogu ispitivati ovu varijablu i pritom odrediti modul u kojem se programske
naredbe izvr²avaju. Najvi²i (tzv. __main__. Programi zadani
top-level) modul interpretera zove se
__main__ modula. Ponekad
na naredbenoj liniji ili une²eni interaktivno, uvijek se izvode unutar tog
program moºe promijeniti ovo pona²anje, ovisno o tomu je li uvu£en iz modula ili je izveden u __main__
okoli²u. To se moºe posti¢i na ovaj na£in:
8.1. Modul 73
# provjera je li se vrti kao program

if __name__ == '__main__':
# Da
Naredbe
else:
# ne, uvucen je kao modul
Naredbe
8.1.1 Traºenje modula

Kad se moduli u£itavaju, interpreter traºi listu imenika, foldera u sys.path. Tipi£na vrijednost
sys.path moºe izgledati ovako:
['', '/usr/local/lib/python2.5',
'/usr/local/lib/python2.5/lib-tk',
'/usr/local/lib/python2.5/lib-dynload',
'/usr/local/lib/python2.5/site-packages']
Prazan string odnosi se na trenuta£ni imenik, folder. Novi imenici dodaju se u put traºenja vrlo
jednostavno - dodavanjem £lana (stringa puta) u ovu listu.
8.1.2 U£itavanje modula i compilacija

Do sada su moduli prikazani kao datoteke koje sadrºe Python kôd. Meutim, moduli u£itani s naredbom
import mogu pripadati nekoj od £etiri op¢e kategorije:
• Programi pisani u Pythonu (.py datoteke)
• C ili C++ pro²irenja koja su compilirana u zajedni£kim (shared) knjiºnicama ili DLL-ovima.
• Paketi koji sadrºe skupove modula
• Ugraeni moduli pisane u C-u i povezani s Python interpreterom
Kad se na primjer, traºi modul primjer, interpreter pretraºuje svaki od direktorija u sys.path za
sljede¢e datoteke (navedene po redoslijedu pretraºivanja):
1. Imenik ili folder primjer koji je deniran u paketu
2. primjer.so, primjermodule.so, primjermodule.sl, ili primjermodule.dll (compilirana pro-

²irenja)
3. primjer.pyo (samo ako je -O ili -OO opcija kori²tena)
4. primjer.pyc
5. primjer.py
Za .py datoteke, kad se modul prvi put u£ita, on se prevede, compilira u meukôd (eng. bytecode )
i zapisuje na disk u datoteku s pro²irenjem .pyc. U idu¢im u£itanjima, interpreter puni ovaj prireeni
meukôd, osim ako ne doe do promjene originalne .py datoteke (pa se .pyc datoteka mora regenerirati.
Datoteke koje zavr²avaju na .pyo koriste se u svezi s interpreterskom -O opcijom. Ove datoteke sadrºe
meukôd s izba£enim brojevima linija i drugim informacijama potrebnim za traºenje pogre²aka (eng.
debugging ). Kao rezultat toga, kôd je ne²to manji i dopu²ta interpretoru ne²to brºe izvoenje. U slu£aju
-OO opcije svi dokumentacijski stringovi se takoer izbacuju iz datoteka. Ovo brisanje dokumentacijskih
stringova pojavljuje se samo kad se .pyo datoteke stvaraju, a ne kad se pune. Ako niti jedna od ovih
74 Moduli i paketi
datoteka ne postoji u niti jednom imeniku (folderu) u sys.path, onda interpreter provjerava da li ime
odgovara imenu nekog ugraenog modula. Ako ni ono ne postoji, onda se podiºe ImportError iznimka.
Compilacija datoteka u .pyc i .pyo datoteke dogaa se samo u sprezi s naredbom import. Programi
izvedeni preko naredbene linije ili preko standardnog ulaza ne proizvode takve datoteke. Naredba
import u traºenju datoteka razlikuje mala i velika slova u njihovom imenu. Kod operacijskih sustava
koji ne podrºavaju tu razliku, potrebno je o tomu voditi ra£una.
8.1.3 Ponovno punjenje modula

Ugraena funkcija reload() koristi se za ponovno punjenje i izvr²avanje kôda sadrºanog unutar modula
koji je prethodno u£itan s naredbom import. Ona prima objekt modula kao pojedina£ni argument. Na
primjer:
import primjer
... neki kôd ...
reload(primjer) # Ponovno puni modul 'primjer'
Sve operacije uklju£ene u modul ¢e se nakon izvoenja naredbe reload() izvesti iz novo u£itanog
kôda. Meutim, reload() ne¢e retroaktivno obnoviti objekte koji su nastali iz starog modula. To zna£i
da je mogu¢e istodobno postojanje referenci na objekte i u staroj i u novoj verziji modula. Nadalje,
compilirane ekstenzije pisane u C ili C++ ne mogu se ponovono puniti naredbom reload(). Kao
op¢e pravilo, treba izbjegavati ponovno punjenje modula, osim za vrijeme razvitka programa i traºenja
pogre²ki u njemu.
8.2 Paketi
Paketi dopu²taju da se vi²e modula skupi zajedno pod jednim zajedni£kim imenom. Ova tehnika
pomaºe u razlu£ivanju sukoba u prostoru imena modula koji se koriste u razli£itim primjenama. Paket
se denira stvaranjem imenika, foldera (engl. directory, folder ) s istim imenom kao paket i stvaranjem
__init__.py datoteke u tom imeniku. Mogu¢e je nakon toga dodavati druge izvorne datoteke (tekstovne
datoteke s Python kôdom), compilirana pro²irenja ili podpakete u istom imeniku. Na primjer, paket se
moºe ovako organizirati:
Graphics/
__init__.py
Primitive/
__init__.py
linije.py
ispuna.py
tekstovi.py
...
Graph2d/
__init__.py
plot2d.py
...
Graph3d/
__init__.py
plot3d.py
...
Formati/
__init__.py
gif.py
png.py
8.2. Paketi 75
tiff.py
jpeg.py
Naredba import koristi se za punjenje modula iz paketa na nekoliko na£ina:
import Graphics.Primitive.ispuna
Ovo u£itava podmodul Graphics.Primitive.ispuna. Sadrºaj tog modula mora se eksplicitno
imenovati, kao na primjer: Graphics.Primitive.ispune.crtaj(img,x,y,color).
Drugi na£in:
from Graphics.Primitive import ispuna
u£itava podmodul ispuna i £ini ga raspoloºivim i bez paketnog preksa, na primjer: ispuna.crtaj(img,x,y,color).
Tre¢i na£in:
from Graphics.Primitive.ispuna import crtaj
Ova naredba u£itava podmodul ispuna i £ini crtaj funkciju direktno primjenljivom, primjerice:
crtaj(img,x,y,color). Kad god se neki dio paketa u£ita, importira, kôd u datoteci __init__.py se
tad izvr²i. U najmanjem slu£aju ova datoteka moºe biti i prazna, ali takoer moºe sadrºavati kôd kojim
se izvode inicijalizacije koje su speci£ne za paket. __init__.py za vrijeme
Sve naene datoteke u
u£itavanja, automatski se izvr²avaju. Tako ¢e naredba import Graphics.Primitive.ispuna izvr²iti
__init__.py datoteke i u Graphics imeniku i u Primitive imeniku.
Jedan poseban problem s paketima je obradba ovakve naredbe:
from Graphics.Primitive import *
eljeni cilj ove naredbe je u£itati sve module pridruºene u paketu s trenuta£nim prostorom imena.
Meutim, s obzirom da dogovori oko imena datoteka (pogotovo u smislu razlikovanja velikih i malih
slova) variraju od sustava do sustava, Python ne moºe to£no odrediti koje module to£no treba uklju£iti.
Kao rezultat, ova naredba samo u£itava sve reference koje su denirane u __init__.py datoteci u
Primitive imeniku. Ovo se pona²anje moºe promijeniti deniranjem liste __all__ koja sadrºi sva
imena modula pridruºena s paketom.
Takva lista treba biti denirana unutar paketa u __init__.py datoteci, kao na primjer:
# Graphics/Primitive/__init__.py
__all__ = ["linije", "tekstovi", "ispuna",...]
Ako korisnik pokrene naredbu from Graphics.Primitive import * onda se svi navedeni podmo-
duli u£itaju, kako se i o£ekuje. U£itavanje samo imena paketa ne¢e automatski u£itati sve podmodule
koji se nalaze u paketu. Na primjer, sljede¢i kôd ne¢e raditi:
import Graphics
Graphics.Primitive.fill.floodfill(img,x,y,color) # Pogre²no!
Meutim, budu¢i da importGraphics naredba izvr²ava __init__.py datoteku u Graphics imeniku,

mogu¢e ju je promijeniti tako da se automatski u£itaju svi podmoduli:
# Graphics/__init__.py
import Primitive, Graph2d, Graph3d
# Graphics/Primitive/__init__.py
import linije, tekstovi, ispuna ...
76 Moduli i paketi
Na ovaj na£in importGraphics naredba u£itava sve podmodule i £ini ih raspoloºivima za pozive ko-
riste¢i njihova potpuna imena. Moduli koji su sadrºani unutar istog imenika (foldera) paketa, mogu refe-
Graphics.Primitive.ispuna
rencirati jedan drugog bez navoenja punog imena paketa. Na primjer, modul
moºe u£itati Graphics.Primitive.linije modul jednostavno koriste¢i naredbu import linije. Me-
utim, ako je modul smje²ten u drugom imeniku, onda se mora koristiti puno ime paketa. Na primjer,
akoplot2d iz modula Graphics.Graph2d traºi upotrebu linije iz modula Graphics.Primitive, mora
se koristiti puna staza imena:from Graphics.Primitive import linije. Ako je potrebno, modul
moºe ispitati svoju __name__ varijablu kako bi na²ao potpunu stazu svog imena. Na primjer, sljede¢i
kôd u£itava modul iz sestrinskog podpaketa znaju¢i samo ime tog podpaketa (a ne i najvi²e ime s vrha
paketa):
# Graphics/Graph2d/plot2d.py
# Odreuje ime paketa, gdje je smje²ten moj paket
import string
base_package = string.join(string.split(__name__,'.')[:-2],'.')
# Import the ../Primitive/ispuna.py module

exec "from %s.Primitive import ispuna" % (base_package,)
Kona£no, kad Python u£itava paket, on denira posebnu varjablu__path__ koja sadrºi listu imenika
__path__ je posebna ina£ica sys.path
koji se pretraºuju, kad se se traºe paketni podmoduli. (Varijabla
varijable.) __path__ je dohvatljiv za kôd sadrºan u datoteci __init__.py i inicijalno sadrºi jedan £lan
s imenom foldera (imenika) paketa. Ako je potrebno, paket moºe dodati dodatne imenike u __path__
listu da bi se promijenila staza koja se koristi u traºenju podmodula.
POGLAVLJE 9
Ulaz i izlaz
Pod pojmom ulaz/izlaza razmatraju se mogu¢i argumenti naredbene linije, varijable okoline, rad s
datotekama, naredba (ili funkcija) 'print', te o£uvanje programskih objekta.
9.1 itanje naredbene linije i varijable okoli²a

Kad interpreter zapo£ne s radom, argumenti naredbene linije spremaju se u listu sys.argv. Prvi ele-
ment liste je ime programa koji se pokre¢e. Idu¢i elementi su mogu¢i argumenti unes²eni na naredbenoj
liniji iza imena programa koji se izvodi. Sljede¢i program pokazuje kako pristupiti takvim argumentima
naredbene linije:
# printopt.py
# Print all of the command-line options
import sys
for i in range(len(sys.argv)):
print "sys.argv[%d] = %s" % (i, sys.argv[i])
Izvoenjem programa dobije se sljede¢e:
% python printopt.py foo bar -p

sys.argv[0] = printopt.py
sys.argv[1] = foo
sys.argv[2] = bar
sys.argv[3] = -p
%
Varijable okoli²a dohva¢aju se u rje£niku os.environ. Na primjer:
import os
path = os.environ["PATH"]
user = os.environ["USER"]
editor = os.environ["EDITOR"]
... etc ...
Promjena varijabli okoli²a provodi se postavljanjem os.environ varijable. Druga je mogu¢nost
pozivom funkcije os.putenv() function. Na primjer:
os.environ["FOO"] = "BAR"
os.putenv("FOO","BAR")
77
78 Ulaz i izlaz
9.2 Datoteke
Ugraena funkcija open(name [,mode ]) otvara i stvara datoteke, kao ²to sljedi:
f = open('foo') # Otvara 'foo' za citanje

f = open('foo','w') # Otvara za pisanje
Na£ini otvaranja datoteke (engl. le ) su 'r' za £itanje (eng. read ), 'w' za pisanje (engl. write), ili 'a'
za dodavanje sadrºaja u ve¢ postoje¢u datoteku (eng. append ). Binarni podatci spremaju se u datoteku
s oznakom 'b', pa vrijedi 'rb' kao na£in £itanja binarnih podataka, a 'wb' kao na£in spremanja inarnih
podataka. To je opcionalno u UNIX-u, ali nuºno na Windows-ima, gdje se treba uklju£iti kako bi se
postigla prenosivost s jednog sustava na drugi. Uz to, datoteka se moºe otvoriti za aºuriranje (eng.
update) koriste¢i znak (+) character, pa vrijedi 'r+' ili 'w+'. U slu£aju otvaranja datoteke za aºuriranje,
mogu¢e je izvr²iti i ulaz i izlaz podataka, dok god svaka izlazna operacija sprema iz memorije (engl.
flush) svoje podatke u datoteku, prije bilo koje ulazne operacije. Ako je datoteka otvorena sa 'w+'
onda se na po£etku njena duljina pretvara u nulu (bri²e se sadrºaj). open() vra¢a objekt datoteke (eng.
file object) koji podrºava methode prikazane u tablici 9.1:
Tablica 9.1: Metode s datotekama
Metode Opis
f.read([n]) £ita najvi²e n okteta (engl. bytes )
£ita jednu ulaznu liniju do najvi²e n znakova.
f.readline([n])
Ako se n iizostavi, onda £ita cijelu liniju.
f.readlines() £ita sve linije i vra¢a listu.
Returns an opaque sequence object where
f.xreadlines()
each iteration reads a new line from the le.
f.write(s) Upisuje u datoteku string s .
f.writelines(l ) Upisuje u datoteku sve stringove iz liste l .
f.close() Zatvara datoteku.
Vra¢a trenuta£no kazalo (brojilo znakova)
f.tell()
datoteke.
f.seek(offset [, where ]) Traºi novu poziciju u datoteci.
f.isatty() Vra¢a 1 ako je f interactivni terminal.
Sprema (eng. ushes ) izlazni mem. bufer u
f.flush()
datoteku.
f.truncate([size]) Skra¢uje datoteku na najvi²e size okteta.
f.fileno() Vra¢a cjelobrojni identikator datoteke.
f.readinto(buffer,nbytes U£itava nbytes podataka iz memorijskog buer
) objekta.
Metoda read() vra¢a £itavu datoteku kao jedan string, osim ako je zadan jedan proizvoljan para-
metar length kojim se odreºuje maksimalna duljina u£itanih okteta. Metoda readline() vr¢a sljede¢u
liniju ulaza, uklju£uju¢i i znak zavr²etka linije (eng. newline terminator ); metoda readlines() vra¢a
sve ulazne linije kao listu stringova. Metoda readline() dodatno prhva¢a makismalnu duljinu linije n.
Ako je linija duºa od n okteta, frunkcija vra¢a samo n u£itanih okteta. Ostatak podataka na liniji se ne
bri²e, ve¢ se u£itava u idu¢im £itanjima. Obje metode: readline() i readlines() ovise o operacijskom
sustavu te obrauju na razli£ite na£ine zavr²etke linija (na primjer, '
n' u odnosu na '
r
n'). Metoda xreadlines()vra¢a poseban objekt koji omogu¢uje u£itavanje linija datoteke ite-
racijskim postupkom, umjesto cjelokupnog u£itavanja linija odjednom u memoriju, kao ²to to radi
readlines() metoda. Na primjer:
9.3. Standardni ulaz, izlaz i pogre²ka (engl. Input, Output, Error) 79
for line in f.xreadlines():

# Naciniti nesto s linijom
...
Metoda write() upisuje string u datoteku, a metoda writelines()upisuje listu stringova u da-
toteku. U svim ovim slu£ajima, string moºe sadrºavati binarne podatke, uklju£uju¢i umetnute null
znakove. Metoda seek()koristi se za direktan pristup nekom mjestu u datoteci, deniranom zadanim
offset parametrom, koji se nadovezuje na vrijednost parametra where. Ako je where jednak 0 (²to
je pretpostavljena vrijednost), seek() pretpostavlja da je vrijednost offset relativna s obzirom na
po£etak datoteke; ako je vrijednost parametra where jednaka 1, pozicija se ra£una relativno s obzirom
na trenuta£nu poziciju, a ako je jednaka 2, pomak se ra£una od kraja datoteke. Metoda fileno() vra¢a
cjelobrojno kazalo datoteke i ponekad se koristi u ulazno/izlaznim operacijama niske razine u stanovitim
knjiºni£kim modulima. Na strojevima koji podrºavaju velike datoteke (ve¢e od 2 GB) metode seek()i
tell() koriste duge cijele brojeve ( long integers ). Objekti datoteke ima takoer atribute prikazane u
sljede¢oj tablici 9.2:
Tablica 9.2: Atributi datoteka
Atributi Opis
Boolova vrijednost koja pokazuje stanje
f.closed datoteke:0 ako je datoteka otvorena, a 1 ako je
zatvorena.
f.mode Ulazno/izlazni mod (I/O) za datoteku.
Ime datoteke, ako je otvorena s open(). Ina£e,
f.name atribut predstavlja string koji pokazuje izvorni
kod datoteke.
Boolova vrijednost koja pokazuje da li se
f.softspace praznina treba ispisivati ispred druge
vrijednosti kad se koristi print naredba.
9.3 Standardni ulaz, izlaz i pogre²ka (engl. Input, Output, Error)

Python interpreter raspolaºe s tri standardna objekta datoteka, poznata kao standard input, standard
output i standard error, koji se nalaze u sys modulu i pozivaju sa sys.stdin, sys.stdout i sys.stderr. Stdin
je objekt datoteke, koji odgovara tijeku (engl. stream ) ulaznih znakova koji dolaze od interpretera.
Stdout je objekt datoteke koja prima izlaz kojeg proizvodi naredba print. Stderr je datoteka koja
prima poruke o pogre²kama. Naj£e²¢e je stdin preslikan tj. odgovara korisni£koj tipkovnici, dok su
stdout i stderr preslikavaju na ispis na zaslon ra£unala. Metode opisane u prethodnom odlomku, mogu
se korisititi i za izvoenje sirovog ulaza/izlaza (eng. I/O ) u komunikaciji s korisnikom. Na primjer,
sljede¢a funkcija £ita ulaznu liniju sa standardnog ulaza:
def gets():
text = ""
while 1:
c = sys.stdin.read(1)
text = text + c
if c == '\n': break
return text
Alternativno, ugraena funkcija raw_input(prompt) moºe £itati liniju teksta sa standardnog ulaza
stdin :
s = raw_input("type something : ")
print "You typed '%s'" % (s,)
80 Ulaz i izlaz
Kona£no, nasilni prekid preko tipkovnice (naj£e²¢e generiran sa Ctrl+C) rezultira u KeyboardInterrupt
izuzetku koji se moºe dohvatiti koriste¢i potporu izuzetaka (eng. exception handler ). Ako je potrebno
vrijednosti odsys.stdout, sys.stdin i sys.stderr mogu se zamijeniti s ostalim objektima dato-
teke. U tom slu£aju naredba print i funkcije raw_input koriste nove vrijednosti. Originalne vrijed-
nosti od sys.stdout, sys.stdin i sys.stderr na po£etku rada interpretera su takoer dohvatljive
u sys.__stdout__, sys.__stdin__ i sys.__stderr__. Dobro je primjetiti da se u nekim slu£ajima
sys.stdin, sys.stdout i sys.stderr mogu promijeniti od strane integriranog razvojnog okruºenja (eng. inte-
grated development environment - IDE ). Na primjer, kad se Python izvod pod Idle-om, onda se sys.stdin
zamjenjuje s objektom koji se pona²a kao datoteka, iako je on stvarno objekt razvojnog okruºenja. U
ovom slu£aju, stanovite metode niske razine kao ²to su read() i seek() ne mogu se izvoditi.
9.4 Naredba print

Naredba print daje izlaz u datoteku koja se pridruºena objektu sys.stdout. Ta naredba prihva¢a listu
zarezima odvojenih objekata, kao na primjer:
print "Vrijednosti varijabli su: ", x, y, z
Za svaki se objekt poziva funkcija str() kako bi proizvela string na izlazu.. Ovi izlazni stringovi se
onda povezuju i meusobno odjeljuju prazninama, kako bi se proizveo kona£ni izlazni string. Izlaz se
zaklju£uje znakom za novi red, osim u slu£aju kad se print naredba zavr²ava zarezom. U tom slu£aju,
ispisuje se samo dodatna praznina na koncu stringa, ali ne i novi red. Na primjer:
print "Vrijednosti varijabli su: ", x, y, z, w

# ispisuje isti tekst, koriste¢i dvije print naredbe
print " Vrijednosti varijabli su: ", x, y, # Ne ispisuje novi redak
print z, w
Upotrebom string formatiraju¢eg operatora (%) dobiva se formatirani izlaz. Na primjer:
print "Vrijednosti su: %d %7.5f %s" % (x,y,z) # Formatirani UL/IZL (I/O)
Mogu¢e je promijeniti odredi²te print naredbe dodaju¢i specijalni file modifikator, gdje je file
datoteka objekta u koju korisnik pi²e. Na primjer:
f = open("izlaz","w")
print >>f, "Ovdje Python!"
...
f.close()
Kombinacijom formatiranog ulaz/izlaza stringova s trostrukim navodnicima i rje£nika, dobiva se

snaºna pomo¢ u pisanju kompjutorski generiranih tekstova, kakva su, na primjer, cirkularna pisma.
Obi£no se u takvim pismima trebaju op¢a imena, adrese i neki brojni iznosi zamijeniti stvarnima, kao
na primjer ovdje :
Dragi gosp. Miki,

Molim Vas vratite mi moj bicikl ili mi platite 150 Eura.
S po²tovanjem,
Python Mlai
Da bi se to na£inilo, prvo se formira string s trostrukim navodnicima koji sadrºi tekst, a onda rje£nik,
koji sadrºi stvarne vrijednosti varijabli:
9.5. Otpornost 81
form = """\
Dragi %(ime)s,
Molim Vas vratite mi moj %(vlasnistvo)s ili mi platite $%(iznos)0.2f Eura.
S po²tovanjem,
Python Mlai
"""
print form % { 'ime': 'gosp. Miki',
'vlasnistvo': 'bicikl',
'iznos': 150,
}
Za ovakve obrasce koji imaju puno linija i £lanova koji se trebaju zamijeniti, puno je jasnije napisati
jednu print naredbu s popisom £lanova u rje£niku, nego svaki tekst pisati pojedina£no.
9.5 Otpornost
£esto je potrebno spremiti objekt u datoteku i poslije ga iz datoteke pro£itati. Jedan na£in je da se na£ini
niz funkcija za spremanje objekta u datoteku i isto tako funkcije za £itanje. Tu mogu nastati razli£iti
pristupi, ovisno o sklonostima i razmi²ljanju programera. Jedan ugraeni pristup ovom problemu je
serijalizacija objekta koja se postiºe upotrebom pickle i shelve modula. Modul pickle serijalizira
objekt u tok okteta (eng. stream of bytes ) koje se mogu zapisati u datoteku. Na primjer, sljede¢i kôd
zapisuje objekt u datoteku:
import pickle
object = someObject()
f = open(filename,'w')
pickle.dump(object, f) # Sprema objekt
Ponovno obnavljanje objekta postiºe se sljede£im kôdom:
import pickle
f = open(filename,'r')
object = pickle.load(f) # Obnavlja objekt
Modul shelve je sli£an, ali objekte sprema u bazu podataka sli£nu rje£niku:
import shelve
object = someObject()
dbase = shelve.open(filename) # Otvara bazu
dbase['key'] = object # Sprema objekt u bazu
...
object = dbase['key'] # Vra¢a objekt iz baze
dbase.close() # Zatvara bazu
U oba slu£aja, samo se serijalizirani objekti mogu spremiti u datoteku. Ve¢ina Python objekata
se moºe serijalizirati, ali objekti posebne vrste, kao ²to su na primjer datoteke, ne mogu se spremati i
obnavljati na ovaj na£in.
Literatura
[1] Wesley J. Chun, Core Python Programming, Prentice-Hall, Inc., 2001.

[2] Alex Martelli, Python in a Nutshell, O'Reilly, 2003.
[3] David M Beazley , Python Essential Reference, New Riders Publishing , 2001.
[4] Rashi Gupta, Making Use of Python, Wiley Publishing, Inc., 2002.
[5] Allen B. Downey; Jerey Elkner; Chris Meyers, How to Think Like a Computer Scientist,
Green Tea Press, 2005.
[6] David Ascher; Alex Martelli; Ravenscroft, Python Cookbook, O'Reilly, 2005.
[7] Magnus Lie Hetland, Beginning Python: From Novice to Professional, Apress, 2005.
[8] Dave Brueck; Stephen Tanner, Python 2.1 Bible, Hungry Minds, 2001.
[9] Chris Vehily, Python: Visual QuickStart Guide, Peachpit Press, 2001.
[10] Brad Dayley, Python Phrasebook: Essential Code and Commands, Sams, 2006.
83

Essert Python PDF

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Essert Python PDF

Uploaded by

Copyright:

Available Formats

Mario Essert

Sveu£ili²ta Josipa Jurja Strossmayera

3 Izrazi, operatori i operacije 25

7 Python - objektni jezik 59

1.1 Jezi£ne zna£ajke

Jezik visoke razine

Sintaksa jezika je jednostavna i o£evidna. Uvlake zamjenjuju posebne znakove za deniranje

Napredne zna£ajke jezika

1.2 Izvoenje Python programa

ili pod Linux-om:

>>> print 'Znam zbrojiti: 1+2 =', 1+2

Umetnuti (embeded) kôd

1.3 Na² prvi Python program

• identitet - adresa u memoriji gdje je objekt spremljen

• vrijednost - sadrºaj memorijskog prostora spremljenog objekta

• metodu - programski kôd koji se primjenjuje na vrijenosti(ma) objekta

2347 # Cjelobrojni literal

[ 63, 'faks', 8.6 ] # Listina, lista ili popis (engl. list)

Tablica 2.1: Ugraeni (built-in) tipovi u Python programskom jeziku

Kategorija tipa Ime tipa podatka Opis

>>> x=[1, 3, 9, 16] # lista s £etiri podatka

>>> print 'id(a)=',id(a),' id(b)=',id(b) # ne pokazuju isto!

>>> print 'gruba aproksimacija pi = ', 22./7

Programske naredbe Pythona temelje se na pridruºivanju (objekata referencama), upravljanju tije-

Tablica 2.2: Python klju£ne rije£i

1, 23, 3493 # Decimalni cijeli brojevi

1L, 23L, 99999333493L # Duga£ki decimalni cijeli brojevi

>>> print sys.maxint # za uobicajeni stroj najveci cijeli broj je

0., 1.0, .2, 3., 4e0, 5.e0, 6.0e0

Pythonova decimalna vrijednost odgovara uobi£ajena 53 bita preciznosti na modernim ra£unalima.

1j, 1.j, 1.0j, 1e0j, 1.e0j, 1.0e0j

2.2.1 Stringovi - nizovi alfanumeri£kih znakova

'Ovo je string literal'

' jel\' me netko trazio?' # eksplicitni navodnik u stringu

"""A ovo je jedan duuugi string

Tablica 2.3: 'Escape' znakovi

Niz Zna£enje ASCII/ISO kod

Niz Zna£enje ASCII/ISO kod

>>> a=u'str\xf6m gr\xfcn'

>>> print 'koliko' 'je' 'tu' 'stringov' u'\xe4' '?'

(100, 200, 300) # N-terac s tri clana

[42, 3.14, 'zdravo' ] # Lista s tri £lana

2.3 Temeljne operacije i metode s nizovima

Tablica 2.4: Operacije i metode nad svim nizovima

>>> print len(a),len(b),len(c)

Tablica 2.5: Pridruºba i brisanje

Evo kratkog primjera:

>>> lista=['tko zna','bilje','²iroko mu','polje']

2.3.1 Ugraene metode string-ova

Tablica 2.6: String metode

2.3.2 Ugraene metode listi

Tablica 2.7: Metode liste

Primjer 2.3 Matrica je lista listi.

{'x':42, 'y':3.14, 'z':7} # Rjecnik s tri clana i string kljucevima

2.4.1 Ugraene metode rje£nika

Tablica 2.8: Metode i operacije tipova preslikavanja (rje£nika)

Tablica 2.9: Glavne operacije skupova

3.2 Naredbe pridruºivanja

3.2.1 Obi£na pridruºba

• Kri²ka (eng. slicing ) ima sintaksu obj[start:stop] ili obj[start:stop:korak]. Pritom je

Ovaj izraz re-povezuje a da se pridruºi na ono ²to je u b bilo povezano, i obratno.

n = input ( " Inesite prirodni broj n : " )

pret , tren =1 ,1 # asociranje vrijednosti varijablama prethodnik , trenutni

Sintaksa jezika je jednostavna i o£evidna. Uvlake zamjenjuju posebne znakove za deniranje

1.2 Izvoenje Python programa

Tablica 2.1: Ugraeni (built-in) tipovi u Python programskom jeziku

2.3.1 Ugraene metode string-ova

2.3.2 Ugraene metode listi

2.4.1 Ugraene metode rje£nika

Tablica 3.4: Ugraene aritmeti£ke funkcije

While naredba takoer moºe uklju£ivati klauzulu else i naredbe break.

Tablica 5.1: Ugraene iznimke

gdje except_block prihva¢a i obrauje sve iznimke.