Essert Python PDF

Mario Essert
Digitalni udbenik
Python
- osnove -
Odjel za matematiku
Sveuilita Josipa Jurja Strossmayera

Osijek, 2007.
Sadraj
Sadraj 3
1 Python interpreter 7
1.1 Jezine znaajke . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 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 alfanumerikih 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 Rjenik . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.4.1 Ugraene metode rjenika . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.5 Skup . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
3 Izrazi, operatori i operacije 25

3.1 Varijable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
3.2 Naredbe pridruivanja . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
3.2.1 Obina pridruba . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
3.2.2 Proirena pridruba . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
3.2.3 Naredba del . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
3.2.4 Bool -ove vrijednosti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
3.3 Operatori i operacije . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
3.3.1 Numerike i aritmetike 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 Krika (eng. slicing ) niza . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
3.4.2 Stacionarne operacije na listi i rjeniku . . . . . . . . . . . . . . . . . . . . . . . 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 Saete 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 Pronalaenje argumenta iznimke . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
5.3.3 Obradba svih iznimki . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
5.3.4 Pokretanje programskog koda bez prisustva iznimke . . . . . . . . . . . . . . . . 47
5.3.5 Obradba vie iznimki . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
5.3.6 Pokretanje obaveznog kda za ienje . . . . . . . . . . . . . . . . . . . . . . . . 48
5.3.7 Eksplicitno podizanje iznimke . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
5.4 Korisniki denirane iznimke . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
5.4.1 Tvorba iznimki . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
5.4.2 Dijagnostiko pridruivanje . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 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 Ugnjeene 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 specine 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 Tvornika funkcija . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
7.4.4 Brojanje referenci i brisanje instance . . . . . . . . . . . . . . . . . . . . . . . . . 65
7.5 Nasljeivanje . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
7.5.1 Premoujui atributi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
7.5.2 Posluivanje metoda superklase . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
7.5.3 Vieoblije . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 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 Traenje modula . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
8.1.2 Uitavanje 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 okolia . . . . . . . . . . . . . . . . . . . . . . . . . . 77
9.2 Datoteke . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
9.3 Standardni ulaz, izlaz i pogreka (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 znaajke u programiranju, ve na optimalan nain ujedinjuje sve najbolje ideje i
naela rada drugih programskih jezika. On je jednostavan i snaan istodobno. Vie nego drugi jezici on
omoguuje programeru vie razmiljanja o problemu nego o jeziku. U neku ruku moemo 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 znai da nudi jednostavnost i lako koritenje skriptnih jezika
(poput Matlab -a), uz napredne programske alate koji se tipino 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 Jezine znaajke

Interpretacija meukda
Python kd sprema se u tekst datoteke koje zavravaju na .py. Program kompilira kd u
niz bytecode-ova koji se spremaju u .pyc datoteke koje su prenosive na bilo koje platforme
gdje se mogu izvoditi interpretacijom tog meukda. Na slian nain izvrava se Java kd -
interpretacijom meukda. Brzina izvoenja Python kda istog je reda veliine kao u Javi ili
Perlu. ANSI C i raspoloiv za cijeli niz strojeva i operacijskih sustava
Python je napisan u
ukljuujui 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 rjenici.
Interaktivnost
Python se moe izvoditi u razliitim okruenjima. Za razvitak programa najlaki je interak-
tivni nain rada u kojem se programski kd pie naredbu za naredbom. Ne postoji razlika u
razvojnom i izvedbenom (engl. runtime ) okoliu: u prvom se izvodi naredba za naredbom ,
a u drugom odjednom itava skripta.
ista sintaksa
7
8 Python interpreter
Sintaksa jezika je jednostavna i oevidna. Uvlake zamjenjuju posebne znakove za deniranje

blokova kda, pa je napisani program vrlo pregledan i jednostavan za itanje.
Napredne znaajke jezika

Python nudi sve znaajke oekivane u modernom programskom jeziku: objektu orijentirano
programiranje s viestrukim nasljeivanjem, dohvaanje izuzetaka ili iznimki (engl. excep-
tion ), redeniranje standardnih operatora, pretpostavljene argumente, prostore imena (engl.
namespaces), module i pakete.
Proirivost
Python je pisan u modularnoj C arhitekturi. Zato se moe lako proirivati novi znaajkama
ili API-ima. (engl. application programming interface ).
Bogate knjinice programa
Pythonova knjinica (engl. library ), koja ukljuuje standardnu instalaciju, ukljuuje 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 saeti index
mnogih Python projekata i razliitih drugih knjinica.
Potpora
Python ima veliku entuzijastiku zajednicu korisnika koja se svake godine udvostruuje.
1.2 Izvoenje Python programa

Python kd moe se izvoditi na vie naina:
Interaktivni rad
To je najei nain rada kod pisanja novih programa, a zapoinje pozivom python u Li-
nux -u, odnosno dvostrukim klikom na ikonicu u Windows okruenju. U MS-DOS okruenju,
Python se poziva isto kao u Unix -u/Linux -u, jedino je sistemski znak (engl. prompt ) dru-
gaiji. 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 zavra s ENTER tipkom (ili Return tipkom). Zatim Python izvodi tu naredbu, ispisuje
rezultat i ponovo ispisuje prompt oekujui novu naredbu:
>>> print 'Znam zbrojiti: 1+2 =', 1+2

Znam zbrojiti: 1+2 = 3
>>>
1.3. Na prvi Python program 9
Na ovaj nain Python se moe koristiti kao jednostavan, ali i vrlo sloen kalkulator.
U sluaju naredbi koje pretpostavljaju daljnje naredbe u nastavku, npr. naredbe petlje (for,
while, ...), Python interpreter ispisuje '...' i automatski ini uvlaku za nove naredbe. U
Windows okruenju postoji vie grakih rjeenja 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 rjeenja od IDLE-a su PythonWin, PyScripter i novija, koja korisniku daju puno
grakih rjeenja za jednostavnu Python upotrebu kako u interaktivnom tako i u skriptnom
radu.
Skriptni rad
Programi se spremaju u skripte s pomou obinog text editora ili Python orjentiranog gra-
kog okruenja, a onda se kao Unix /Linux ili Windows skripte pozivaju iz sistemske linije.
Ako smo na primjer gornju naredbu (ili vie 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 kd skripte
bio isti onaj utipkan u interaktivnom radu.
Umetnuti (embeded) kd
Iako se ee unutar Pythona mogu pozivati funkcije iz drugih programa (npr. C -a za sluaj
programskog ubrzanja), mogue je Python kd u obliku izvornih tekst naredbi izvoditi i
unutar programa pisanog u drugom programskom jeziku, koristei 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 poetku promotri jedan primjer Python programa, kako bi se uoila svojstva i nain pisanja
programskog kda.
,
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 uvlai (engl. import ) iz modula random funkciju randint() s kojom e se
generirati sluajan cijeli broj. Varijabla 'gotovo' postavlja se u Bool-ovo stanje neistine (engl. False ),
a varijabla 'korak' inicijalizira se sa 0. Znak ';' slui za odvajanje naredbi pisanih na istoj liniji. U
varijablu 'broj' sprema se sluajni 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 zamiljeni 'broj' bude jednak, od korisnika izabranoj, vrijednosti varijable 'x'. U
sluaju da to nije ispunjeno, program 'pomae' korisniku savjetom da pogaa navie ili nanie. Pritom
se varijabla 'korak' svaki put poveava 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 poetka i konca bloka naredbi (kao to su to
vitiaste zagrade u C -jeziku ili begin-end u Pascal -u), nego se to ostvaruje uvlakama. Na taj nain
korisnik je prisiljen pisati strukturirani kod, lagan za itanje. Sve upravljae naredbe (if, while, else
i sl.) zavravaju sa znakom dvotoke (':'). Treba takoer uoiti 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 uitava niz znakova ( string ) koji korisnik upie, a druga samo ispisuje
string i/ili sadraj varijabli. Mogue je takoer i formatiranje izlaza (zadnja print naredba).
POGLAVLJE 2
Tipovi podataka
Raunalni program je algoritam zadan programskim naredbama koje se izvravaju nad nekom vrstom ili
tipom podataka. Sve podatane vrijednosti u Pythonu predstavljene su objektima,
(binarno spremljenih)
pa se za Python s pravom kae: "Sve je objekt ". Svaki objekt moe imati najvie etiri svojstva:
identitet - adresa u memoriji gdje je objekt spremljen
tip - veliina memorijskog prostora kojeg objekt zauzima i na kojem se stanovite metode (obrade)
mogu tj. smiju obavljati
vrijednost - sadraj memorijskog prostora spremljenog objekta
metodu - programski kd koji se primjenjuje na vrijenosti(ma) objekta
Identitet i tip objekta su nepromjenljive veliine i deniraju se stvaranjem, generiranjem, objekta. Svaki
objekt moe imati jednu ili vie vrijednosti, te jednu ili vie metoda. Neki objekti dolaze se Python
interpreterom, zovemo ih ugraeni objekti (engl. built-in objects ), a druge stvara sm korisnik preko
Python klasa. Vrijednosti objekta esto se zovu atributi. Dohvaanje 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 moe mijenjati bez stvaranja novog objekta istog tipa zovu se nepromjenljivi (engl.
immutable ) objekti. Promjena vrijednosti objekta obino se dogaa pridruivanjem razliitih literala
ili djelovanjem metode na vrijednost objekta. Literal oznauje 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 alfanumerikih znakova za brojeve i stringove, Python koristi i posebne simbole i to kao meae
ili graninike (npr. za poetak i zavretak string literala koristi simbole jednostrukih, dvostrukih ili
trostrukih navodnika) ili kao simbole aritmetiko-logikih i odnosnih (relacijskih) operatora. Simbol '#'
koristi se za poetak komentara i ne obrauje se od strane Python interpretera: sve napisano u linije
iza njega, udesno, interpreter nee obraivati. Meai slue i kod denicije sloenih tipova, od kojih se
najee koriste:
[ 63, 'faks', 8.6 ] # Listina, lista ili popis (engl. list)

( 450, 320, '600' ) # n-terac (engl. tuple)
{ 'a':72, 'b':1.4 } # rjenik (engl. dictionary)
11
12 Tipovi podataka
Tipovi objekata mogu se sloiti 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 Vraeno iz xrange()
BufferType Vraeno iz buer()
Preslikavanje DictType Rjenik
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 Korisnika funkcija
InstanceType Instanca klase, objekt
MethodType Ograniena metoda
UnboundMethodType Neograniena metoda
Nutarnji tipovi CodeType Byte-compilirani kd
FrameType Izvedbeni okvir
TracebackType Sloaj slijeda izuzetaka
SliceType Tip krike (odlomka)
EllipsisType Proireni 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 sloenih tipova (npr. liste, stringa ili rjenika) esto
se jo zovu lanovi (engl. items ).
Identitet ili adresna referenca objekta sprema se u memorijsku lokaciju koja se zove varijabla. Varija-
bla moe pokazivati na spremljeni literal, na isti nain kao i na objekt koji ima vie vrijednosti(sadraja
memorijske lokacije) i/ili vie metoda. Svaka varijabla sa svojim sadrajem moe postojati samostalno,
a moe biti i ugraena u neki objekt. Dohvaanje varijable, tj. njezinog sadraja iz objekta postie se
sa obj.x, gdje je obj ime objekta, a x je ime varijable.
Jedna ili vie Python programskih naredbi moe se spremiti u funkciju. Razlikuju se ugraene (engl.
built-in ) i korisnike funkcije. Funkcije, zajedno s podacima, grupiraju se u klase. Funkcije denirane
unutar klasa, zovu se metode. Od klase moe nastati jedan ili vie objekata.
Korisnike funkcije denira korisnik, a ugraene dolaze s Python interpreterom. Dakako, i funkcija je
objekt. Ona se moe postojati samostalno, a moe biti ugraena unutar onekog drugog objekta. Metoda
Tipovi podataka 13
se iz klase/objekta dohvaa 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 moe imati ulazne
argumente i vraati izlazne vrijednosti.
Na primjer, provjera tipa nekog objekta ostvaruje se pozivom ugraene funkcije type():
>>> type("Zanimljivi Python svijet!") # string literal
<type 'str'>
>>> type(512) # numeriki 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 uitava s pomou naredbe 'import'.
import sys # ucitava se modul sistemskih funkcija
Pojedinani podatak ili funkcija iz modula dohvaa se naredbom 'from ... import ... ' :
from math import sin, cos # uitavaju se samo sin() i cos() funkcije
Dohvaanje vrijednosti podatka preko atributa objekta postie se sintaksom 'objekt.atribut'.
Objekt moe imati vie atributa. U sluaju da je atribut neka funkcija, odgovarajua sintaksa je
'objekt.atribut()'.
>>>import math
>>> print math.pi, math.sin(2.3)
3.14159265359 0.745705212177
Dohvaanje vrijednosti podatka preko lanova, esto se naziva indeksiranje i odnosi se samo na
strukturirane tipove podataka (liste, stringove i sl.). Indeksacija poinje s nultim (0) indeksom.
>>> x=[1, 3, 9, 16] # lista s etiri podatka

>>> print x[3] # dohvaanje treeg podatka
16
Vrijednost reference (njena adresa u memoriji) moe se doznati pozivom funkcije id(). Pridrui-
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 # pridruba 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 izrau-
natog izraza ispisuje se na zaslon raunala koritenjem naredbe ili funkcije print:
>>> print 'gruba aproksimacija pi = ', 22./7

gruba aproksimacija pi = 3.14285714286
Programske naredbe Pythona temelje se na pridruivanju (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 kljunih rijei Python-a (tablica 2.2), jer su one pridruene osnovnim Python naredbama.
Tablica 2.2: Python kljune rijei

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 podravaju cijele brojeve (obine i dugake), brojeve s pominim
zarezom (realne brojeve) i kompleksne brojeve. Objekti brojeva u Pythonu su nepromjenljivi ( immu-
table ) objekti, to znai da bilo kakva aritmetika 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 razliita od nule. Oktetni literal je odreen s poetnom
0 iza koje ide niz oktetnih znamenki (0 do 7). Na slian nain heksadecimalni literal koristi poetni 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 moe moe se dodati slovo 'L' ili 'l' kako bi se oznaio dugaki cijeli
broj ( long integer ). Na primjer:
2.2. Nizovi 15
1L, 23L, 99999333493L # Dugaki decimalni cijeli brojevi

01L, 027L, 01351033136165L # Dugaki oktetni cijeli brojevi
0x1L, 0x17L, 0x17486CBC75L # Dugaki heksadec. cijeli brojevi
Razlika izmeu dugakog i obinog cijelog broja je u tome to dugaki cijeli broj nema predodreenu
numeriku granicu; moe biti toliko dug koliko raunalo ima memorije. Obian cijeli broj uzima nekoliko
okteta memorije i ima minimalnu i maksimalnu vrijednost koju diktira arhitektura stroja. sys.maxinit
je najvei dostupni obian cijeli broj, dok je sys.maxinit-1 najvei 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 pominim zarezom) predstavljen je nizom decimalnih znamenki koje ukljuuju
decimalni zarez, tj. toku (.), exponent ( e ili E, te + ili - iza, s jednom ili vie znamenki na kraju), ili
oboje. Vodei znak decimalnog literala ne smije biti e ili E, a moe biti bilo koja znamenka ili toka
(.). Na primjer:
0., 1.0, .2, 3., 4e0, 5.e0, 6.0e0
Pythonova decimalna vrijednost odgovara uobiajena 53 bita preciznosti na modernim raunalima.

Kompleksni broj sastavljen je od dviju decimalnih vrijednosti, jedne za realni, a druge za imaginarni
dio. Mogue je pristupiti dijelovima kompleksnog objekta z kao samo-itajuim "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 oznauje kvadratni korijen od -1, to je uobiajena oznaka imaginarnog
dijela u elektrotehnikoj praksi (neke druge discipline koriste znak 'i' u tu svrhu, ali Python je izabrao
ba znak j).
Treba primijetiti da brojevni literali ne ukljuuju predznak: ako postoji + ili - ispred broja, onda
su to posebni operatori.
x=input('Upiite prvi prirodni broj: ') y=input('Upiite 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 dohvaaju ne-negativnim
cijelim brojevima. Python prua tri ugraene (engl. built-in ) vrste nizova za stringove (obine i Uni-
code), n-terace, i liste. Knjiniki i ekstenzijski moduli pruaju druge vrste nizova, a korisnik takoer
moe sam napisati svoje. Nizovi se mogu obraivati na vie naina.
2.2.1 Stringovi - nizovi alfanumerikih znakova

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

"Ovo je novi string literal"
Dvije razliite vrste navodnika imaju identinu 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 vie 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 sauvani novi redovi, pa se njihovi kontrolni
znakovi ne trebaju dodavati u niz. Nije doputena 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 Znaenje 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 Znaenje 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 ukljuuje
sve znakove iz gotovo svih svjetskih jezika. Unicode literalni string ima istu sintaksu kao obini literalni
string uz dodatak znaka 'u' ili 'U' koji se pie odmah ispred poetnog 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
strm grn
Vie 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 razliitih tipova. N-
terac se denira nabrajanjem objekata odvojenih zarezima (,). Zadnjem lanu u nizu takodjer se moe
dodati zarez. N-terac sa samo jednim lanom mora imati zarez na kraju, jer inae gubi tip n-terca.
Prazan n-terac je oznaen s praznim parom zagrada. lanovi se mogu grupirati, pa nastaju ugnjedeni
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, mogue je pozvati i ugraenu funkciju 'tuple()'. Ako je
x neki niz, onda tuple(x) vraa 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
razliitih tipova. Lista se denira nabrajanjem lanova odijeljenih zarezima (,) i smjetenih unutar
uglatih zagrada ([ ]). Doputeno je iza zadnjeg lana liste, ostaviti jo jedan zarez. Prazna lista se
oznaava 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] # ugnjedena lista s tri lana
[ ] # Prazna lista
Na slian nain, kao i s generiranjem n-teraca, mogue 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

Dohvaanje elementa bilo kojeg niza (stringa, n-terca, liste) postie se indeksiranjem. Dio niza, odlomak
ili krika (engl. slice ) dobiva se sintaksom 'i:j' gdje je 'i' poetni indeks, a 'j' zavrni indeks krike
(tablica 2.4). Duina 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] Vraa element i u nizu s
s[i:j] Vraa kriku - niz elemenata od i-tog do j-tog indeksa
len(s) Vraa broj elemenata u s
min(s) Vraa minimalni elemenat iz s
max(s) Vraa maksimalni elemenat iz s
Promjenljivi nizovi (liste) imaju mogu mijenjati lanove ili krike 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 dohvaanje lanova preko indeksa u krikama ostvaruje od poetnog indeksa
do konanog, ali koji se pritom iskljuuje, ne uzima u obzir. Negativan indeks pak dohvaa lanove od
kraja niza. Tako je '-1' indeks za zadnji lan, '-2' za predzadnji i tako dalje.
Budui da se u kategoriji nizova samo liste mogu mijenjati direktno, postoje pridrube lanovima
liste i funkcije brisanja lanova (tablica 2.5). Obje operacije mogu se izvesti nad pojedinanim i skupnim
lanovima liste.
Tablica 2.5: Pridruba i brisanje
lan Opis
s[i] = v Pridruba lanu na i-tom mjestu
s[i:j] = t Pridruba 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

Budui 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
Vraa kodiranu inaicu stringa.
[,errors]])
s.endswith(suffix
Provjerava kraj stringa za sux.
[,start[,end ]])
s.expandtabs([tabsize]) Proiruje 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 alfanumeriki.
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 rijei napisano velikim slovom).
Provjerava jesu li svi znakovi pisani velikim
s.isupper()
slovima.
Povezuje stringove u listi t koristei s kao
s.join(t )
mea.
s.ljust(width ) Lijevo poravnanje s u stringu duljine width.
s.lower() Vraa 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 koristei sep kao mea.
s.split([sep[,maxsplit]]) maxsplit je navei broj dijeljenja koji e se
izvriti.
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 zapoinje 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
Vraa velika slova za string malih slova i
s.swapcase()
obratno.
s.title() Vraa verziju stringa kao naslova.
s.translate(table Mijenja string koristei transformacijsku
[,deletechars ]) tablicu znakova.
s.upper() Vraa string pretvoren u velika slova.
Primjer 2.1 String je nepromjenljivi objekt, pa se njegova promjena mogua tek stvaranjem novog
stringa. treba primjetiti kako se aritmetiki znak '+' koristi za povezivanje stringova, dok '1:' oznauje
sve znakove nakon prvog.
, ,
>>> s1 = " Moj san "
>>> s2 = ' Tv ' + s1 [1:]
>>> print s2 Tvoj san
>>>
Primjer 2.2 Modul 'string' sadri mnogo funkcija. Funkcija 'nd' pronalazi podstring u zadanom
stringu. Vraa 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 slian nain, s pomou tablice 2.7 mogu se u primjerima provjeriti ugraene metode koje olakavaju
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) Vraa najmanji i za koji je s[i] == x .
li.insert(i,x) Umee x na indeksu i .
22 Tipovi podataka
Metoda Opis
Vraa element i i brie ga iz liste. Ako se i
li.pop([i])
izostavi, onda se vraa zadnji element.
li.remove(x) Trai x i brie ga iz liste li.
li.reverse()) Reverzira (obre) lanove liste li na mjestu.
Sortira (slae) 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 Rjenik
Preslikavanje (engl. mapping ) je skup objekata indeksiranih s pomou gotovo slobodnih vrijednosti
koje se zovu kljuevi (engl. keys ). Tako nastali objekti su promjenljivi, a za razliku od nizova, nisu
poredani.
Python nudi jednu vrstu preslikavanja, rjenik (engl. dictionary ). Knjiniki i ekstenzijski moduli
pruaju jo vrsta preslikavanja, a druge moe nainiti korisnik sm. Kljuevi u rjeniku mogu biti
razliitih tipova, ali moraju biti jednoznani (engl. hashable ). Vrijednosti u rjeniku su takoer objekti
i to mogu biti razliitih tipova. lan u rjeniku je par kju/vrijednost (engl. key/value ). O rjeniku se
moe razmiljati kao o asocijativnom polju.
Eksplicitno stvaranje rjenika provodi se nizom parova klju:vrijednost odvojenih zarezima, koji se
smjetaju unutar vitiastih zagrada. Doputen je i zarez nakon zadnjeg lana. Ako se klju pojavljuje
vie od jednom u rjeniku, samo se jedan od lanova s tim kljuem sprema, jer klju mora biti jedincat.
Drugim rijeima, rjenici ne dozvoljavaju duplikate kljueva. Prazan se rjenik oznauje parom praznih
vitiastih zagrada. Evo nekih rjenika:
{'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 rjenika mogue je izvesti i s pomou 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 vraa prazan rjenik. Ako se klju pojavljuje vie nego jednom u
popisu (argumentima funkcije dict), samo e se posljednji lan s tim kjuem zadrati u rezultirajuem
rjeniku.
2.4.1 Ugraene metode rjenika

Na slian nain, s pomou tablice 2.8 mogu se u primjerima provjeriti ugraene metode koje olakavaju
rad s rjenicima.
2.5. Skup 23
Tablica 2.8: Metode i operacije tipova preslikavanja (rjenika)
lan/metoda Opis
di[k] Vraa lan od di s kljuem k .
di[k] = x Postavlja di[k] na x.
del di[k] Brie di[k]iz di .
di.clear() Brie sve lanove iz di.
di.copy() Vraa kopiju od di.
di.has-key(k) Vraa 1 ako di ima klju k , a 0 inae.
di.items() Vraa listu od (key ,value) parova.
di.keys()) Vraa listu od vrijednosti kljueva.
di.update(b) Dodaje sve objekte iz rjenika b u di .
di.values() Vraa listu svih vrijednosti spremljenih u di .
di.get(k [,v]) Vraa di[k] ako nae; inae vraa v .
Vraa di[k] ako nae; vraa v i postavlja
di.setdefault(k[, v])
di[k]=v .
Vraa sluajne (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
- obian i zamrznuti skup. Skup je neporedan niz jedincatih (neponavljajuih) elemenata. Elementi
moraju biti jednoznani, engl. hashable. Zamrznuti skupovi su jednoznani, pa mogu biti elementi
drugih skupova, dok obini skupovi to ne mogu biti.
Tablica 2.9: Glavne operacije skupova
Operacija Rezultat
[koristi se za ugraene tipove] tvorba obinih
set/frozenset
ili zamrznutih skupova iz iterabilnog niza, npr.
([iterabilno=None])
set([5,2,7]), set("zdravo")
[koristi se za set modul] tvorba obinih 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
Brie element elem u skupu s. Podie
s.remove(elem))
KeyError iznimku ako se element ne pronae
24 Tipovi podataka
Operacija Rezultat
Brie sve elemente iz skupa s (ne vrijedi za
s.clear()
nepromjenljive skupove!)
s1.intersection(s2) ili Vraa novi skup s elementima zajednikim u
s1&s2 s1 i s2
Vraa novi skup s elementima koji su i u s1 i
s1.union(s2) ili s1|s2
u s2.
s1.symmetric_difference(s2) Vraa novi skup s elementima koji su ili u
ili sls2 s1,ili u s2, ali ne na oba mjesta
s.copy() Vraa 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 pomou 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. Budui da je adresa jedinstvena u
smislu broja okteta, svaka referenca moe povezati objekte razliitih tipova, to znai da je dinamina,
da se moe mijenjati prilikom izvrenja programa. U jednom trenutku varijabla moe pokazivati na
cjelobrojni podatak, a ve u sljedeem na realni, kompleksni ili neki sloeni tip.
U Pythonu nema deklaracija. Postojanje varijable ovisi o naredbi koja povezuje (eng. binding )
varijablu i podatak; drugim rijeima, naredbi koja imenuje neki objekt, bilo kojeg tipa. Mogue je
odvezati (eng. unbinding ) varijablu resetiranjem njenog imena, tako da vie ne sadri 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 uinak na objekt s koji je referenca bila povezana,
osim to objekt nestaje ako vie 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 ienje objekata bez referenci zove se sakupljanje smea (engl. garbage collecting).
Varijabla se moe imenovati bilo kojim identikatorom, osim onih 30 koji su rezervirani kao Python
kljune rijei. Pritom identikator ima i neka svoja pravila: ne smije imati zabranjene simbole u sebi,
ne smije poinjati brojem i sl. Varijabla moe biti globalna ili lokalna. Globalna varijabla je dohvatljiva
s vie razina, a lokalna uglavnom u funkciji u kojoj se koristi.
3.2 Naredbe pridruivanja

Naredbe pridruivanja mogu biti obine ili proirene. Obino pridruivanje varijabli (npr. name=value)
je nain stvaranja nove varijable ili re-povezivanja postojee varijable na novu vrijednost (tj. promjena
vrijednosti). Obina pridruba na atribut objekta (npr. obj.attr=value) je zahtjev objektu obj da
stvori ili re-povee atribut attr. Obina pridruba za lan u nekom nizu ili preslikavanju (listi ili
rjeniku) (npr. obj[key] = value) je zahtjev spremniku obj da stvori ili re-povee lan s indeksom
key. Takva pridruba ukljuuje indeksiranje niza.
Proirena pridruba (npr. name+=value) ne stvara nove reference, nego samo re-povezuje varija-
blu. Postojei objekt re-povezuje sebe ili jedan od svojih atributa ili lanovas novom vrijednou.
Taj se zahtjev uspjeno izvrava ili se podie iznimka, kojom se javlja neka vrsta pogreke. Iznimka
25
26 Izrazi, operatori i operacije
(engl. exception ) je nain na koji Python rjeava pogreke bilo kojeg tipa. Ako se na primjer, re-
povezivanjem varijable s aritmetikim sadrajem dogodi dijeljenje s nulom, Python e podii iznimku
ZeroDivisionError. Pythen dakako, ima ugraene naredbe za dohvaanje i obrade iznimki.
3.2.1 Obina pridruba

Naredba obine pridrube u svom najjednostavnijem obliku ima sintaksu:
cilj = izraz
Cilj ili odredite (engl. target ) je poznat kao lijeve strana pridrube, a izraz (engl. expression ) je
desna strana. Izraz moe biti obina varijabla ili vie varijabli povezanih operatorima, poziv funkcije ili
mnotvo drugih kombinacija s meusobno povezanim objektima. Kad se naredba pridrube izvrava,
Python izraunava izraz desne strane, te povezuje vrijednost izraza s ciljem na lijevoj strani. Ovo
povezivanje ne ovisi o tipu izraunate vrijednosti desne strane, jer se pridruba ionako dogaa na
razini referenca, adresa objekata, a ne njihova sadraja. Cilj moe biti varijabla /identikator, atribut,
indeksirani lan niza ili krika slicing ) .
(engl.
Detalji povezivanja ovise o vrsti ili tipu cilja:
Identikator je ime varijable: pridruba na identikator povezuje sadraj varijable s tim imenom,
upisom adrese pod ime identikatora.
Referenca atributa ima sintaksu obj.name. Pritom je obj identikator koji oznaava objekt, a
name atributivno ime objekta. Pridruba na referencu atributa trai da objekt obj povee svoj
atribut zvan name s izraunatom ili pozvanom vrijednou desne strane.
Indeksiranje ima sintaksu obj[expr]. Pritom je obj objekt, a expr je izraz koji indeksira mjesto
u nizu. Objekt moe biti bilo kojeg tipa. Pridruba na indeksiranje trai da spremnik obj povee
svoj lan koji je izabran pomou vrijednosti expr, takoer poznate i kao indeksni klju lana s
izraunatom ili pozvanom vrijednou desne strane.
Krika (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 krika, ekvivalentna s
obj[None:stop:None]). Pridruba trai od niza objekata obj da se poveu ili odveu neki od
njegovih lanova.
U jednostavnoj pridrubi moe biti vie 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 vraa izraz,
isto kao kad bi se nekoliko jednostavnih naredbi izvravale jedna za drugom.
Cilj u jednostavnoj pridrubi moe imati dvije ili vie referenci odvojenih zarezima, proizvoljno
ograenih lunim 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 treim.
Ova vrsta pridrube zove se raspakiravajua pridruba i pritom izraz s desne strane mora biti niz s
tonim brojem lanova koliko ima i referenci u cilju, jer se inae podigne iznimka. Svaka referenca u
cilju je jednoznano povezana s odgovarajuim lanom u nizu. Raspakiravajua pridruba takoer moe
izmjenjivati reference. Na primjer:
a, b = b, a
3.2. Naredbe pridruivanja 27
Ovaj izraz re-povezuje a da se pridrui na ono to je u b bilo povezano, i obratno.
Primjer 3.1 Program rauna n-ti Fibonnaccijev broj za uneeni 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 rjeenje koje program daje
4
2
9
3.2.2 Proirena pridruba

Proirena pridruba razlikuje se od obine pridrube u tomu, to se umjesto znaka jednakosti (=)
izmeu cilja i izraza s desne strane koristiproireni operator, tj. binarni operator nakon kojeg slijedi =.
Operatori proirene pridrube su: + =, =, =, / =, // =, % =, =, | =, >>=, <<=, & = i =.
Proirena pridruba (tablica 3.1) moe imati samo jedan cilj na lijevoj strani, tj. proirena pridruba
ne podrava vie ciljeva.
Tablica 3.1: Proirena pridruba
Operacija Ekvivalentno sa
x+ = y x=x+y
x = y x=xy
x = y x=xy
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=xy
x >>= y x = x >> y
x <<= y x = x << y
3.2.3 Naredba del

Unato svome imenu, naredba del ne brie objekte, nego odvezuje njihove reference. Brisanje objekta
je implicitna posljedica sa sakupljanjem smea, kad ne postoji vie nijedna referenca na taj objekt.
U Pythonu (slino kao u Java programskom jeziku) postoji ugraeni sakuplja smea (engl. garbage
collector ) koji oslobaa memorijski prostor zauzet objektima koji se ne referenciraju. To se dogaa na
sistemskoj razini, cikliki, tijekom izvoenja programa. Naredba del sastoji se od kljune rijei del,
nakon koje slijedi jedna ili vie ciljnih referenci objekata odvojenih zarezima (,). Svaki cilj moe biti
varijabla, referenca atributa, indeksiranje ili krika, ba kao za naredbe pridrube, te mora biti povezan
u vrijeme izvravanja naredbe del. Ako je cilj del-a identikator, naredba del izvodi odvezivanje
varijable, tj. brie adresu koju je identikator imao. Dok god je identikator povezan s objektom, takvo
odvezivanje je doputeno: kad god se eksplicitno zahtijeva, onda se i izvri. U drugim sluajevima,
naredba del specicira zahtjev objektu da odvee neke (ili sve) svoje atribute ili lanove. Objekt
moe odbiti odvezati neke (ili sve) atribute ili lanove, podiui iznimku ako se pokuava nedoputeno
odvezivanje. Odvezivanje (ili brisanje) krike obino ima jednak uinak kao pridruba praznog niza toj
kriki.
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 oznaavale
su se s '1 ' i '0'. Svaka podatana vrijednost u Pythonu ima vrijednost istine: istinito ili lano, ovisi
o tomu je li ta vrijednost razliita ili jednaka nuli. U tipu string nuli odgovara prazan string "", kod
n-terca prazan n-terac (), kod rjenika prazan rjenik {} i sl. Python takoer ima nekoliko ugraenih
funkcija koje vraaju Bool -ove vrijednosti kao rezultate.
Nainjene promjene u novim verzijama Pythona bile su praktine, jer je lake govoriti o funkcijama
i izrazima koje " vraanje True ili False " nego govoriti o izrazima razliitim ili jednakim nuli. Ove
promjene takoer omoguuju pisanje ieg kda, npr. kada se eli vratiti vrijednost istine pie se
return True, umjesto neprikladnog return 1).
3.3 Operatori i operacije

Izraz je dio programskog kda koji Python interpreter moe izvriti kako bi proizveo neku vrijednost.
Najjednostavniji izrazi su literali i identikatori (varijable). Sloeniji izrazi grade se tako da se jednos-
tavni izrazi povezuju operatorima. Tablica 3.2 opisuje operatore po prioritetima, od viih prema niima.
Operatori koji su zajedno imaju jednak prioritet. Stupac A ispisuje asocijativnost (djelovanje s obzirom
na stranu) operatora, koja moe 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 rjenika NA
[izraz,...] Stvaranje liste NA
Stvaranje n-terca ili
(izrazr,...) NA
jednostavne zagrade
f(izraz,...) Poziv funkcije L
x[index1:index2] Krika (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
Mnoenje, 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
xy 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 logina I (and) funkcija. Na primjer:
a < b <= c < d
ima isto znaenje 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 Numerike i aritmetike operacije

Python nudi uobiajene numerike operacije, kako se vidi u tablici 3.3. Svi su brojevi samoitajui
(engl. readonly ) objekti, pa bilo koja numerika operacija na brojnom objektu, uvijek proizvodi novi
brojni objekt. Objekt kompleksnog broja z takoer ima samoitajue (atribute z.real i z.imag.
Pokuaj repovezivanja ovih atributa na kompleksnom objektu podie iznimku. Treba primjetiti da +
ili - znak nekog broja, kao i isti znakovi koji pridruuju realni literal imaginarnom, kako bi se nainio
kompleksan broj, nisu dijelovi sintakse literala. Iz tog razloga se na primjer, -2 ** 2 izraunava kao
-4, jer potenciranje ima vii prioritet od znaka minusa, pa se cijeli izraz prevodi kao -(2 ** 2), a ne
kao (-2) ** 2.
Tablica 3.3: Numerike operacije
Operacija Opis
x+y Zbrajanje
xy Oduzimanje
xy Mnoenje
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 vraa 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 vraa isti rezultat kao i a**b. Poziv funkcije pow() s tri argumenta, pow(a,b,c)
vraa isti rezultat kao i (a**b)%c, ali bre.
Tablica 3.4: Ugraene aritmetike funkcije
Funkcija Opis
abs(x) Apsolutna vrijednost
divmod(x,y) Vraa (int(x / y ), x % y )
pow(x,y [,modulo]) Vraa (x y)x%modulo
Zaokruuje na najblii viekratnik od 10n
round(x,[n])
(samo za za realne brojeve)
3.3.2 Prisilna i eksplicitna pretvorba

Arithmetike 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 vei. Poredani od najmanjeg do najveeg, tipovi brojeva su sljedei: cijeli brojevi, dugaki cijeli
brojevi, decimalni (realni, s pominim zarezom) brojevi i kompleksni brojevi.
Eksplicitna pretvorba moe se primijeniti tako da se numeriki argument preda eljenoj ugraenoj
funkciji: int, long, float te complex. U tom sluaju int i long e odbaciti decimalni dio svog
argumenta i zadrati 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 mogue 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) vraa 13,
vrijedost '1101' u bazi 2).
3.4. Operacije na nizovima 31
3.3.3 Usporedba
Svi objekti, ukljuujui 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 vraaju 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 Vee nego
x == y Jednako
x != y Nije jednako (isto kao <>)
x >= y Vee nego ili jednako
x <= y Manje nego ili jednako
3.3.4 Operacije na bitovima cijelih brojeva

Cijeli brojevi i dugaki 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 nii
prioritet nego arithmetiki operatori. Pozitivni cijeli brojevi proireni su neogranienim nizom bitova
'0' nalijevo. Negativni cijeli brojevi predstavljeni su dvojnim komplementom, te proireni neogranienim
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)
xy Bitwise EX-ILI (xor - exclusive or)
x Bitwise negacija
Osim pomaka (ulijevo i udesno) na bitovima se mogu izvravati i logike funkcije (I, ILI, NOT i
EX-ILI).
3.4 Operacije na nizovima

Python podrava nekoliko operacija koje se mogu primijeniti na slijedne tipove (nizove ili sekvence),
koji ukljuuju nizove znakova ( stringove ), popise ili liste ( engl. list ) engl. tuple ).
i n-terce ( Nizovi
su spremnici s lanovima koji se dohvaaju indeksiranjem pojedinanog lana ili skupom lanova, tzv.
krikama. Nizovi istog tipa nadovezuju se jedan na drugog s pomou operatora +. Isto tako mogue je
mnoiti bilo koji niz S s cijelim brojem n s pomou 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 zapaanja 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, vraa
True, a False ako nije. Slino tomu, x not in S operator je isto kao not(x in S).
N-ti lan niza S oznauje se ili dohvaa indeksiranjem S[n]. Indeksiranje u Pythonu poinje od
nule (prvi lan u S je S[0]). Ako S ima L lanova, indeksn smije biti 0,1,.., sve do L-1 ukljuno, ali
ne i vie. Indeks n moe takoer biti -1, -2,..., sve do -L (iskljuno), ali ne i manji. Negativni n
oznaava iste lanove u S kao to ini L+n. Drugim rijeima, 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
Koritenje indeksa veeg ili jednakog duljini niza L ili manjeg od -L, podie (izaziva) iznimku.
Pridruba lanu niza s nepostojeim indeksom ima isti uinak.
3.4.1 Krika (eng. slicing ) niza

Podniz S moe se oznaiti s pomou krike, koritenjem 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 ukljuujui j-ti lan. Treba primjetiti kako u
Pythonu svi dosezi ukljuuju donju, a iskljuuju gornju granicu. Krika moe biti prazan podniz ako je
j manje od i ili ako je i vee ili jednako L, duljini niza S. Ako je j jednako nuli, i se moe izostaviti, a
ako se ide do konca niza (L) onda se i j smije izostaviti. Cijeli niz S moe se dakle indeksirati sa S[:].
Bilo koji ili oba indeksa smiju biti manji od nule. Negativni indeks oznauje 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]
Krika takoer moe koristiti proirenu sintaksu S[i,j,k], gdje je k - korak indeksa.
Liste mogu mijenjati svoje lanove pridrubom izraza indeksiranom lanu. Na primjer:
x = [1, 2, 3, 4]
x[1] = 42 # x je sada [1, 42, 3, 4]
Drugi nain promjene objekata liste li je koritenjem krike od likao cilja (lijeva strana) uz naredbu
pridrube desne strane. Desna strana pritom takoer mora biti lista. Krika s lijeve strane i lista s
desne mogu biti bilo koje duljine, to znai da pridruivanje krike moe 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 vanih posebnih sluajeva:
Koristei praznu listu [ ] kao izraz s desne strane, brie se ciljna krika iz liste li s lijeve strane.
Drugim rijeima, li[i:j] = [ ] ima isti uinak kao i del li[i:j].
Koristei praznu kriku liste li kao cilj s lijeve strane pridrube ubacuju se lanovi liste s desne
strane na primjerenu poziciju u li. Drugim rijeima, li[i:i] = ['a','b'] ubacuje lanove 'a'
i 'b' nakon lana i u listi li.
Koristei kriku koja pokriva cijeli objekt liste li[:], kao cilj s lijeve strane, potpuno se zamjenjuje
sadraj liste li.
lan ili dio (krika) liste moe 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 rjeniku
Za liste su denirane stacionarne ( in-line ) verzije operatora + i *, koji se koriste u proirenim naredbama
pridrube. Proirena naredba pridrube li +=li_1 ima uinak dodavanja lana iz liste li_1 na kraj
liste li, dok li *= n ima uinak dodavanja n broja kopija liste li na kraj li.
Metoda popitem() moe se koristiti za destruktivnu iteraciju rjenika, tj. iterativnim dohvaanjem
lana brie se njegov klju i vrijednost u rjeniku. Pritom i item() i popitem() vraaju rjenike lanove
kao parove klju/vrijednost, ali koritenje funkcije popitem() upotrebljava manju koliinu memorije.
Utede na koritenju memorije ine tu metodu korisnom za petlju po dugom rjeniku.
U Pythonu 2.2 i kasnije, izravno iteriranje na rjeniku postie se iterkeys() ili iteritems() me-
todama koji trae skromnu koliinu memorije i ne unitavaju rjenik po kojemu se iteracija obavlja.
3.5 Naredba Print
Naredba za ispis oznaava se s kljunom rijei print nakon koje slijedi niti jedan ili vie izraza odvojenih
zarezima. Print je praktian i jednostavan nain ispisivanja vrijednosti u tekstovnom obliku. Print
ispisuje na zaslon raunala 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 ukljuuje novi red (\n) nakon posljednjeg izraza, osim u
sluaju 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
Odredite izlaza naredbe print je datoteka ili objekt slian datoteci koji ima vrijednost stdout
atributa u sys modulu. Obino je stdout pridruen zaslonu raunala, ali se isto tako moe pridruiti
drugom objektu ili izlaznoj napravi. Format ispisa moe se preciznije kontrolirati uporabom operatora
% ili drugim tehnikama obradbe nizova znakova.
Takoer je mogue koristiti write ili writelines metode datotenih 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 kd izvrava. 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 izvriti samo u sluaju ako je neki uvjet zadovoljen.
Ponekad je to izvravanje ovisno o nekoliko meusobno povezanih uvjeta. Pythonova kombinirana
naredba if, koja koristi proirenja elif ili else zakljuak, slui za takvo uvjetno izvravanje 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 vie uvjetnih izraza povezanih odnosnim (relacijskim) operatorima.
Proirenja naredbe 'if ' s 'elif ' i 'else' su doputene u sluaju ispitivanja vie razliitih uvjeta.
'Elif' je kratica od 'else-if ', to znai 'inae-ako', ime se prvo ispitivanje uvjeta proiruje na idue.
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 tipine 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 'inae' odlomku ima vie naredbi (tj. programsko grananje se odnosi na itav blok
naredbi), naredbe se piu na zasebnim linijama koje su uvuene, pomaknute udesno od linije poetka.
Blok naredbi zavrava kada se pozicioniranje linije vrati na ono od poetka odlomka (ili jo vie ulijevo
od toga). Kada postoji samo jedna jednostavna naredba, kao u gornjem primjeru, onda se ona pie na
35
36 Programsko upravljanje
istoj naredbenoj liniji neposredno iza dvotoja (':') kojim se zavrava jedan ili vie uvjetnih ispitivanja.
Dakako, mogue je isto napisati i u iduem 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 moe 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 rjenik, izraunava se
kao istinito (True). Nula (bilo kojeg brojevnog tipa), None i prazni stringovi, n-terci, liste i rjenici,
izraunavaju se kao neistina (False). Kada se pak eli ispitati vrijednost x-a u Bool-ovom kontekstu,
preporuuje se sljedei stil kodiranja:
if x:
To je najii i ' naj_Python -skiji' oblik. To je elegantnije i ljepe nego koristiti konstrukcije kao:
if x is True:
if x == True:
if bool(x) :
ili slino.
Postoji osnovna razlika izmeu izjave da izraz " vraa True " (to znai da izraz vraa vrijednost
kao Bool -ov rezultat) i izjave da se izraz "izraunava kao istinit " (to znai da izraz vraa bilo kakav
rezultat koji je istinit, razliit od nule ili praznog, u Bool -ovom kontekstu). Kad se ispituje neki izraz u
upravljakoj naredbi, onda se razmilja o ovom drugom uvjetu, a ne prvom. Ako se izraz za if odlomak
izrauna kao istinit, naredbe koje slijede if odlomak e se izvriti i cijela naredba if zavrava. Ako
se izraz za if odlomak izrauna kao neistinit, onda se izvravaju izrazi za idue elif odlomke, ako su
njihovi uvjeti ispunjeni. Za prvu elseif klauzulu za koju je uvjet istinit, izvravaju se sve narede koje
je slijede i itava naredba if time zavrava. U protivnom, ako niti jedan elif odlomak nije izvren, jer
uvjeti nisu bili zadovoljeni, onda se izvravaju naredbe odlomka else, dakako, ako on postoji.
4.2 Naredba while

Naredba while u Pythonu izvrava naredbu ili blok naredbi niti jedan, jedan ili vie puta, ovisno o
ispunjenju upravljanog uvjetnog izraza. Ovo je sintaksa za naredbu while:
while izraz:
naredba(e)
While naredba takoer moe ukljuivati klauzulu else i naredbe break.

Tipina 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 izrauna izraz poznat kao uvjet petlje (eng. loop condition ). Ako uvjet nije istinit ( false ),
naredba while zavrava i niti jedna od naredbi u tijelu petlje se ne izvrava. Ako je pak uvjet petlje
zadovoljen, naredba ili naredbe od kojih se sastoji tijela petlje se izvravaju. Kada tijelo petlje zavri s
izvravanjem, uvjet se ponovno izraunava, da se vidi treba li se izvriti nova iteracija. Ovaj se proces
nastavlja sve dok uvjet petlje ne postane neistinit, nakon ega while naredba zavrava. Tijelo petlje
treba sadravati kd koji e u nekom trenutku uiniti petljin uvjet lanim, ili petlja nikada nee zavriti,
osim ako se ne podigne iznimka ili tijelo petlje ne izvri naredbu break. Petlja koja je napisana u tijelu
funkcije takoer zavrava ako se naredba return izvri unutar tijela petlje, jer u tom sluaju cijela
funkcija zavrava.
4.3 Naredba for

Naredba for u Pythonu ostvaruje takoer iterativno izvravanje 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 kljuna rije in dio sintakse naredbe for. Ona nije povezana s operatorom
in koji se koristi pri ispitivanju lanova u nizovima. Naredba for takoer moe ukljuivati i odlomak
else i naredbu break.
Tipina 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 sluaju je string, pa varijabla znak u svakom prolazu, iteraciji, poprima vrijed-
nost pojedinog lana tog niza, u ovom sluaju pojedinanog slova. U ovom primjeru izvrava se samo
jedna naredba, naredba print, koja ispisuje sadraj upravljake varijable s pripadnim formatiranjem
('slovo:' ispred i '...' iza sadraja).
Iteracijski niz moe biti bilo koji Pythonov izraz koji se moe iskoristiti kao argument ugraenoj
funkciji iter, koja vraa iteratorski objekt. Cilj pridrube iteracijske varijable je obino 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 izvravaju se jedna po jedna
za svaki lan unutar iteratora (osim ako petlja zavri uslijed podizanja iznimke ili izvrenja naredbe
break ili return). Cilj s vie identikatora je takoer doputen, kao kad se radi o pridrubi prilikom
raspakiravanja. U tom sluaju, iteratorovi lanovi moraju biti nizovi, svaki iste duljine jednake broju
identikatora unutar cilja. Na primjer, ako je d rjenik, ovo je uobiajeni nain dohvaanja lana u
rjeniku 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() vraa popis parova klju/vrijednost, pa stoga for petlja koristi dva identikatora
u cilju da se svaki lan razpakira u par klju/vrijednost. Ako iterator sadri promjenljiv objekt unutar
samoga sebe, onda se taj objekt ne smije mijenjati dok se for petlja obavlja. Na primjer, predhodni
primjer ne moe koristiti iteritems() items. Naime, iteritems() vraa iterator iji je
umjesto
sadrani objekt d, pa tijelo petlje ne moe mijenjati d (sa del d[key]). S druge strane, items() vraa
listu, tako da d nije sadrani objekt, pa tijelo petlje moe mijenjati d.
Upravljaka varijabla moe se repovezati u tijelu petlje, ali se ponovno repovezuje na slijedei lan
u iteratoru sa sljedeom iteracijom petlje. Tijelo petlje uope se ne izvrava ako iterator ne oslobaa
nikakve lanove. U tom sluaju, upravljaka varijabla se ne povezuje ili odvezuje na niti jedan nain
pomou naredbe for. Meutim, ako iterator oslobaa barem jedan lan, kad se naredba petlje zavri,
upravljaka varijabla ostaje povezana na posljednju vrijednost na koju ju je naredba petlje povezala.
Zato je sljedei kd 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() vraaju njihove rezultantne liste bilo kojim redoslijedom. Ako
se pozove vie od jedne od ovih metoda bez bilo kakve izmjene na rjeniku, redoslijed rezultata je
identian za sve. Metode iteritems(), iterkeys()i itervalues(), koje su uvedene u Pythonu od
inaice 2.2, vraaju iteratore ekvivalentne tim listama. Iterator zauzima manje memorije od liste, ali
nije dozvoljena promjena rjenika dok se iterira na jednom od njegovih iteratora. Iteriranje na listi
vraenoj sa items(), keys() ili values() dolazi bez takvih restrikcija. Iteriranje direktno na rjeniku
D je isto kao iteriranje na D.iterkeys().
Tablica 4.1: Metode rjenikog objekta
Metoda Opis
Vraa iterator za sve lanove (key/value
D.iteritems( )
parove) u D
D.iterkeys( ) Vraa iterator za sve kljueve u D
D.itervalues( ) Vraa iterator za sve vrijednosti u D
Iterator je bilo koji objekt i takav da se moe pozivati sa i.next() bez argumenata. Naredba
i.next() vraa sljedei lan iteratora i ili, kada iterator i vie nema lanova, podieStopIteration
iznimku. Veina je iteratora izgraena eksplicitnim ili implicitnim pozivima ugraene funkcije iter.
Naredba for implicitno poziva iter da bi dobila iterator. Sljedea 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) vraa iterator i tako da naredba i.next nikada ne podigne StopIterationiznimku
(beskonaan iterator), petljafor x in clanovi: nikada ne zavrava (osim kad naredbe u tijelu petlje
sadravaju prikladne break ili return naredbe ili iznimke). iter(clanovi) poziva posebnu metodu
c._iter_() da se dobije i vrati iterator na clanovi.
Zahvaljujui iteratorima, naredba for se moe koristiti na spremniku (kontejneru) koji nije niz
znakova, poput rjenika, sve dok god je kontejner iterabilan (tj. denira _iter_ posebnu metodu tako
da funkcija iter moe prihvatiti kontejner kao argument i vratiti iterator na taj kontejner). Ugraene
funkcije koje su prije zahtjevale argumentni niz sad prihvaaju bilo koji iterabilni objekt.
4.5 Funkcije range i xrange

Vrlo est sluaj u programiranju je ponavljanje petlje preko niza cijelih brojeva. Za tu svrhu Python
prua ugraene funkcije range i xrange koje generiraju i vraaju nizove cjelih brojeva.
Najjednostavniji nain da se zavrti petlja od n puta u Pythonu je:
for i in xrange(n):
naredba(e)
range(x) vraa popis ili listu iji lanovi su sljedni cijeli brojevi od 0 (ukljueno) do x (iskljueno).
Funkcija range(x,y) vraa popis iji lanovi su su sljedni cijeli brojevi od x (ukljueno) do y (isklju-
eno). Ako je x vei ili jednak y, onda je rezultat prazna lista. Funkcija range(x,y,step) vraa popis
cijelih brojeva od x (ukljueno) do y (iskljueno), 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 vraa
prazan popis kada je x vei ili jednak y, a korak je vei od 0, ili kada je x manji ili jednak y i korak je
manji od 0. Ako je korak jednak 0, onda range podie iznimku. Dok range vraa standardni objekt
liste koja se moe koristiti za bilo koju svrhu, xrange vraa objekt za posebne svrhe, posebno nami-
jenjen koritenju u iteracijama kao naredba for pokazana ranije. Xrange uzima manje memorije od
range-a za ovu specinu namjenu. Stavljajui na stranu potronju memorije, range se moe koristiti
u iste svrhe kao i xrange.
4.6 Saete liste

esta svrha for petlje je provjeravanje svakog lana unutar niza i tvorba nove liste dodajui rezultate
izraza izraunatog na jednom ili svim lanovima koji se provjeravaju. Oblik izraza, zvan saeta lista
(eng. list comprehension ) omoguuje tono i neposredno izvravanje ove zadae. Kako je saeta lista
izraz (a ne blok naredbi), moe se ga koristiti izravno (npr. kao stvarni argument u funkciji poziva,
zatim u naredbi return ili kao podizraz za neki drugi izraz). Saeta lista ima sljedeu sintaksu:
[izraz for cilj in iter-clanovi lc-odlomci]
gdje su cilj i iter-clanovi identini kao i u obinoj for naredbi. Izraz se moe ograditi i okruglim,
oblim zagradama, pa e u tom sluaju predstavljati n-terac, a ne listu. lc-odlomci je niz od nula ili
vie odlomaka, od kojih je svaki slian obliku:
for cilj in iter-clanovi

if izraz
Izraz unutar svake if klauzule ima istu sintaksu kao izraz u obinoj if naredbi.
Saeta lista je ekvivalentna petlji for koja gradi istu listu ponavljajuim pozivima append metode
rezultantne liste. Na primjer:
result1 = [x+1 for x in neki_niz]

jednak je kao sljedea for petlja:
result2 = []
for x in neki_niz
result2.append (x+1)
Saeta lista koji koristi if odlomak izgleda ovako:
result3 = [x+1 for x in neki_niz if x<100]
a to je identino for petlji koja sadri 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 saetoj listi jednak je kao u ekvivalentnoj
petlji, ali u saetoj listi gnjedenje operacija ostaje implicitno.
4.7 Naredba break

Upotreba naredbe break doputa se jedino unutar tijela petlje. Kada se break izvri, petlja zavrava.
Ako je petlja smjetena unutar drugih petlja, breakzavrava jedino petlju koja je smjetena najdalje
unutra. U praktinom koritenju, break naredba je obino unutar nekog odlomka u naredbi unutar tijela
petlje, tako da se izvrava uvjetno. Jedno uobiajeno koritenje naredbe break je u implementaciji
petlje koja odluuje hoe li se izvravati samo u sredini svake iteracije:
while True: # ova petlja ne bi nikad prirodno zavrila

x = get_next( )
y = preprocesses (x)
if not keep_looping (x, y): break
process (x, y)
POGLAVLJE 5
Iznimke
Piui program, korisnik (programer) moe nainiti tri vrste pogreaka: logike pogreke, sintaktike
pogreke, te pogreke u radu (eng. run-time errors )nkoje se pojavljuju tijekom izvoenja programa.
Logika pogreka poput neispravnog algoritma, uzrokuje netone rezultate, ali ne sprijeava izvoenje
programa. Ovakve se pogreke teko mogu uoiti.
Sintaktika pogreka kri jedno od Pythonovih gramatikih pravila i sprijeava izvoenje programa.
Ove je pogreke lako popraviti.
Pogreka u radu je pogreka kod izvrenja programa koja se dogaa dok je program u nekoj operaciji.
Neki esti uzroci takvih pogreaka u radu su neprimjereni ulazni podaci, arithmetike pogreke,
neispravne vrste objekata, nizovi indeksa izvan dometa, nepostojei kljuevi rjenika, nepravilno
ispisana imena atributa, neinicijalizirane varijable, te problemi vezani uz operacijski sustav.
Iako to ne pomae u sluaju logikih pogreaka, Python podie iznimku (engl. exception ) pri otkri-
vanju sintaktikih pogreaka ili pogreaka tijekom izvoenja programa. Interpreter zaustavlja program
te ispisuje dijagnostiku poruku o pogreci, zvanu " traceback ", koja ukazuje na vrstu iznimke te po-
kazuje priblino mjesto pogreke. Sintaksne pogreke su najee pogreke u pisanju programa, a na
njih upozorava Python prilikom izvoenja programa oznakom strijelice na mjestu na kojem se pogreka
javlja. To mjesto ne mora doista biti ono na kojem se pogreka nalazi, nego je obino ono na kojem se
prvi put pogreka manifestira. Tono lociranje pogreaka 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 mogunost da se pogreke jave prilikom izvoenja
programa. Iznimka je nain na koji Python dohvaa i pogreke 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 moe dohvatiti kod ekspli-
citnog zatvaranja programa. (SystemExit je iznimka ali ne i pogreka).
StandardError je roditelj svih
drugih iznimki. Ovakav hijerarhijski ustroj omoguuje otkrivanje i obradu skupnih, a ne samo indivi-
dualnih iznimki. Na primjer, ako postoji skupina iznimki koje obrauju matematike izraune, onda se
moe prvo dohvatiti samo ArithmeticError iznimka, a ne i sva njezina djeca (FloatingPointError,
OverflowError i ZeroDivisionError) pojedinano, uz uvjet da se eli na isti nain raditi sa svim
iznimkama.
Tablica 5.1: Ugraene iznimke
Iznimka Opis
Exception Korijen svih iznimki
Podie se sa sys.exit() funkcijom. Ako se ne
obrauje ova iznimka, onda Python interpreter
zavrava program bez ispisa putanje zavretka
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 podie za
ArithmeticError
razliite aritmetike pogreke.
Podie se za pogreke u operacijama s
FloatingPointError
pominom decimalnom tokom.
Podie se kad je rezultat aritmetike operacije
prevelik da bi se mogao prikazati. Ova
OverflowError iznimka ne moe se pojaviti za duge cijele
brojeve (eng. long integers ). U njihovom
sluaju Python podie MemoryError.
Podie se kad je drugi argument obinog ili
ZeroDivisionError
modularnog dijeljenja jednak nuli.
AssertionError Podie se kad je pogreka u assert naredbi.
Podie se kad je atributna referenca ili
pridruba pogrena. Ako objekt ne podrava
AttributeError
atributnu referencu ili pridrubu, onda Python
podie TypeError iznimku.
Roditelj za iznimke koje se pojavljuju izvan
EnvironmentError
Python-a.
Podie se kad je ulazno/izlazna operacija (kao
to je print naredba, open() funkcijski poziv
ili metoda u radu s datotekom) pogrena, 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
Podie se kad se pojavi pogreka povezana s
operacijskim sustavom (izvan Python-a).
OSError Obino se ovoj iznimci pridruuje numeriki
kd pogreke, kao to je u os modulu iznimka
os.error.
Podie se kad se pojavi pogreka povezana s
WindowsError
Windows -operacijskim sustavom.
Podie se kad input() ili raw_input() otkrije
konac datoteke (EOF) bez itanja ikakvog
EOFError podatka. (treba primjetiti da le-objekt
read() i readline() metoda vraa prazan
EOF.)
string kad se otkrije
Podie se kad import grijei nai modul ili kad
ImportError
from-import grijei nai ime.
Podie se kad korisnik pritisne tipku prekida
interrupt key
( koja je obino Ctrl-C ili Del ).
Python redovito provjerava takve prekide
KeyboardInterrupt tijekom izvoenja programa. Python takoe
podie ovu iznimku ako korisnik utipka prekid
za vrijeme input() ili raw_input() naredbe
koja eka korisnikov unos.
Roditelj za iznimke koje Python podie kada
LookupError je indeks rjenikog kljua ili indeks niza
(stringa, liste ili n-terca) nevaljao.
Podie se kad je indeks niza izvan dosega. Ako
IndexError indeks nije cijeli broj, onda Python podie
TypeError iznimku.
Podie se kad Python ne moe nai rjeniki
KeyError
klju.
Podie se kad operacija prelazi raspoloivu
memoriju, ali program se jo moe spasiti
MemoryError brisanjem nekih obekata. Interpreter ne moe
uvijek uspjeno ispraviti ovu pogreku, pa
podie iznimku i ispisuje slijed.
Podie se kad Python ne moe pronai lokalno
NameError ili globalno ime. Argument iznimke je string
koji oznauje izgubljeno ime.
Podie se kad se referencira lokalna varijabla u
UnboundLocalError funkciji ili metodi, ali ne postoji vrijednost
pridruena toj varijabli.
Podie se kada Python otkrije generiku
pogreku koja ne pripada niti jednoj drugoj
RuntimeError kategoriji. Argument iznimke je string koji
pokazuje to je neispravno. Python rijetko
podie ovu sveobuhvatnu iznimku.
44 Iznimke
Iznimka Opis
Podie se kad se pozove metoda koja se jo nije
nainila. Apstraktna metoda u korisnikovoj
NotImplementedError temeljnoj klasi moe takoer podignuti ovu
iznimku, ako se od izvedene klase zahtijeva da
prebrie ili prepuni (engl. override ) metodu.
Podie se kad Python interpreter otkrije
sintaksnu pogreku u interaktivnom ili
skriptnom nainu rada. Ova iznimka se moe
SyntaxError
pojaviti u import ili exec naredbi, te u
eval() ili input() pozivima funkcija, kad se
incijalno ita skripta ili se ita standardni ulaz.
Podie se kad se koristi -tt opcija u
naredbenoj liniji sa programom koji
TabError
nekonzistentno koristi tabulatore i prazna
mjesta.
Podie se kad program prekida Pythonova
IndentationError pravila uvlaenja (engl. indentation) izvornog
programskog teksta.
Podie se kad Python interpreter otkrije
nutarnju pogreku koja nije toliko ozbiljna da
zaustavi izvravanje interpretera. Argument
SystemError
iznimke je string koji pokazuje gdje je dolo do
pogreke, na razini sistemskih (najniih)
operacija.
Podie se kad se ugraena operacija ili
funkcija primjeni na objekt neprikladnog tipa.
TypeError
Argument iznimke je string koji pokazuje
detalje o nepodudaranju tipova podataka.
Podie se kad se ugraenoj operaciji ili
funkcija proslijedi argument koji ima ispravan
ValueError tip, ali ne i ispravnu vrijednost. To su sluaji
koji se ne mogu opisati preciznijom iznimkom,
kakva je na primjer IndexError.
Podie se kad se pojavi pogreka u Unicode
UnicodeError
kodiranju ili dekodiranju.
Evo nekih primjera estih pogreaka u programu koji podiu 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 pogreki govori to se dogodilo. Budui da postoji vie vrsta iznimaka,
njihov tip se nalazi ispisan u poruci (npr. ZeroDivisionError, NameError and TypeError). Svaka Python
5.2. Rad s iznimkama 45
ugraena iznimka podiu true pri pojavi pogreke njenog tipa. Ostatak ispisane linije poruke prua
detaljniji opis pogreke (TypeError), a dio prije imena iznimke govori o kontekstu u kojem se pogreka
dogodila. Taj kontekst je u obliku slijeda (Traceback) obavijesti, od posljednjeg mjesta, rekurzivno
prema poetku mogue pogreke.
5.2 Rad s iznimkama

U Pythonu je mogue pisati programe koji e raditi (dohvaati i obraivati) promatrane iznimke, to
se vidi na sljedeem 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 sljedeem naelu:
ako se tokom izvravanja ne pojavi iznimka, except linija se preskae i try zavrava
ako se iznimka pojavi tijekom izvravanja try-a, i ako odgovara iznimci navedenoj u except liniji,
onda se ona izvrava
ako se iznimka pojavi, a ne odgovara except liniji, provjeravaju se druge iznimke u try izrazu.
Ako njih nema, program zavrava i pokazuje poruku koja je gore navedena.
Pri tomu try moe imati vie od jedne except linije (uvjeta), koji dohvaaju neke druge iznimke.
Pri tome se najvie izvrava jedna od njih, i to samo za iznimke navedene u tom djelu except linije, ali
ne za druge. Except linija moe imati vie iznimki, deniranih unutar n-terca, npr:
... except (RuntimeError, TypeError, NameError):

... pass
Try...except izraz moe sadravati naredbu else koja se izvrava ako u try bloku nije dohvaena
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 nain koristi umjesto pisanja dodatnih linija u try-u, jer se tako izbjegava mogunost upo-
rabe iznimke koja nije navedena u try bloku. Iznimke mogu imati pridruene vrijednosti, argumente,
koji ovise o tipu iznimke. Except izraz moe denirati varijablu nakon imena iznimke, koja je s ins-
tancom iznimke vezana s argumentima u instance.args. Umjesto koritenja 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 pogreci('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, inae e Python nasilno
zavriti izvoenje programa. Obradba iznimki prisiljava programera na razmiljanje o tome to moe
poi krivo unutar programa i to se moe uiniti u vezi toga. Nije praktino (i skoro je nemogue) imati
na umu sve to moe poi krivo. Umjesto toga treba traiti stanja koja se (govorei openito) mogu
ponovno vratiti, koristei korekcijski blok koda, koji se zove 'obrada iznimke' (engl. exception handler ).
Taj kod moe automatski popraviti stanje bez korisnike 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 vieslojna naredba kao if ili while, te slijedi pravila uvlake.
Try takoer mijenja uobiajeno upravljanje tijeka programa. (Upravljanje tokom programa je izvrni
niz naredbi koje ine program).
try:
try_block
except ex:
except_block
Python pokree kod u bloku try dok ga ne zavri uspjeno ili se pojavi iznimka. Ako zavri uspjeno,
Python preskae blok except, te se izvrenje nastavlja na naredbi koja slijedi iza njega. Ako se pojavi
iznimka, Python preskae 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 pokree blok except, te se upravljanje tokom programa prebacuje
na naredbu koja slijedi blok except. Ako iznimka ne odgovara ex, iznimka se proiruje na bilo koje
ukljuene try naredbe, koje bi mogle imati odlomak except u kojem bi se iznimka mogla obraditi. Ako
ni jedna od oblinjih except klauzula ne obrauje podignutu iznimku, onda Python zatvara program te
ispisuje poruku o pogreci.
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 Pronalaenje argumenta iznimke

Kada se dogod iznimka, ona moe imati i pridruenu vrijednost takoer poznatu i kao argument iznimke.
Vrijednost i tip argumenta ovise o tipu iznimke. Kod veine iznimki, argument je n-terac sastavljen od
jednog string lana koji upuuje na uzrok pogreke. Kod pogreaka operacijskog sustava tipa IOError,
argument sadri i dodatne atribute, kao to su broj pogreke ili ime datoteke. U tom sluaju moe
se koristiti funkcija dir() da bi se ispisao popis atributnih argumenta. Za pronalaenje 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 pridruiti 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 nain obuhvaa sve iznimke je openito slabo rjeenje, jer obuhvaa sve
iznimke, a ne samo one koje su bitne, a osim toga, moe prikriti stvarne pogreke korisnikog programa.
try:
try_block
except:
except_block
gdje except_block prihvaa i obrauje sve iznimke.
5.3.4 Pokretanje programskog koda bez prisustva iznimke

Mogue je takoer dodati odlomak uz else naredbu povezanu s odlomkom try kako bi se pokrenuo
niz naredbi u sluaju da odlomak try ne uzrokuje iznimku. Pritom odlomak nakon else mora slijediti
posljednji odlomak except (ako ih ima vie).
try:
try_block
except [...]:
except_block
else:
else_block
Python pokree else_block jedino u sluaju kad try_block ne uzrokuje iznimku.

48 Iznimke
5.3.5 Obradba vie iznimki

Mogue je koristiti jedan except odlomak da bi se obuhvatilo vie tipova iznimki ili se moe koristiti
vie except odlomaka kojima se obrauju pojedine iznimke.
try:
try_block
except (ex1, ex2, ...) [, target]:
except_block
Odlomak except obuhvaa bilo koju od popisanih iznimki (ex1, ex2, ...) te pokree isti except_block
za sve njih. Target je dopustiva varijabla koja uzima argument iznimke.
5.3.6 Pokretanje obaveznog kda za ienje

Naredba try-finally moe se koristiti za pokretanje programskog kda bez obzira je li Python podigao
iznimku ili nije. Za razliku od odlomka except , odlomak finally ne dohvaa iznimke, nego denira
akcije ienja koje se moraju obaviti u svakom sluaju, bez obzira na postojanje pogreke. Odlomci
finally i except ne mogu se pojaviti zajedno u istom try odlomku. Programeri obino postave
naredbutry-finally unutar naredbe try-except kako bi obradili iznimke koje su podignute u naredbi
try-finally. Isto tako, odlomak else ne moe se dodati uz naredbu try-finally.
try:
try_block
finally:
finally_block
Python pokree kd unutar finally_block-a nakon to ga pokrene u try_block-u. Python e

pokrenuti finally_block bez obzira kako se try_block izvri: bilo normalno, bilo putem iznimke
ili putem naredbe tipa break ili return. Ako se iznimka dogodi unutar try_block-a, Python e
preskoiti ostatak try_block-a, te pokrenuti finally_block, a onda ponovno podignuti iznimku kako
bi se dohvatila naredbom try-except vie razine.
5.3.7 Eksplicitno podizanje iznimke

Naredba raise se moe 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 moe biti jedna vrijednost, argument ili n-terac vrijednosti (arg1, arg2, ...).
Ako je izostavljen, onda je pretpostavljena vrijednost argumenta None.
5.4. Korisniki denirane iznimke 49
5.4 Korisniki denirane iznimke

U Pythonu je mogue stvarati korisnike 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 podrava zbog kompatibilnosti. Korisniki denirane iznimke mogu se stvoriti koris-
tei naredbu class. Preporuuje se kao temeljnu klasu uzeti Pythonovu korijensku iznimku Exception.
S korisniki deniranim iznimkama radi se na isti nain kao i s ugraenim iznimkama. Uz except i
else, postoji i nain da se denira iznimka koja e se uvijek ispisati na kraju programa, bez obzira dali
je ba nju program traio 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 izvrila. Sve iznimke se mogu pozvati naredbom
raise exception[,value], gdje value daje detalje o iznimci koja je pozvana.
50 Iznimke
5.4.2 Dijagnostiko pridruivanje

Pridruivanje (eng. assertion ) je alat za ispravljanje pogreaka koji se koristi za ispis dijagnostikih
podataka dok program radi. Python naredba assert sadri bool -ov izraz koji oznaava pogreku, ako
je false (neistina). Izraz je uvijek jednak jedinici, ako je istinit u trenutku kad se provjerava. Ako
je izraz izraunat kao neistina (false), onda Python podie AssertionError iznimku, koja se moe
dohvatiti i obraditi kao bilo koja druga iznimka. Sintaksa je:
assert expr [,arg]

expr je izraz koji se provjerava, a moe biti true ili false. Ako je expr jednak false, onda Python
podieAssertionError iznimku s doputenim argumentom arg. Ako je pak izraz expr jednak true,
onda assert ne poduzima nita.
POGLAVLJE 6
Funkcije
Veina naredbi tipinog Python programa organizirana je preko funkcija. Funkcija je skupina naredbi
koje se izvravaju po pozivu. Python prua mnogo ugraenih funkcija i doputa programerima de-
niranje vlastitih funkcija. Zahtjev za izvrenje funkcije zove se funkcijski poziv (engl. function call ).
Kad se funkcija pozove, moe primiti argumente koji speciciraju vrstu podataka s kojima funkcija
radi (obrauje ih). U Pythonu funkcija uvijek vraa rezultantnu vrijednost, koja moe biti None ili
vrijednost koja predstavlja rezultat nekog izrauna, izvrenog u tijelu funkcije. U Pythonu su funkcije
objekti, pa se sa njima upravlja isto kao i s drugim objektima. Tako se neka funkcija moe proslijediti
kao argument u pozivu neke druge funkcije. Slino tomu, funkcija moe vratiti drugu funkciju kao re-
zultat obradbe, izvrenja svog programskog koda. Kao i svaki drugi objekt, funkcija moe biti povezana
s nekom varijablom, nekim lanom unutar niza (polja, liste) ili atributom objekta. Funkcije takoer
mogu biti kljuevi u rjeniku.
6.1 Naredba 'def'

Funkcija se denira s pomou kljune rijei def. Def je naredba sa sljedeom sintaksom:
def funkcijsko_ime(parametri):
naredba(e)
funkcijsko_ime je identikator. To je varijabla koja se povezuje (ili re-povezuje) s funkcijskim

objektom prilikom izvrenja naredbe def. parameteri je doputena, slobodna lista identikatora, koji
se zovu formalni parametri ili samoparametri, a koji se koriste kod poziva funkcija za pridruivanje
stvarnim vrijednostima koji se navode kao argumenti. U najjednostavnijem sluaju, funkcija nema ni-
kakvih formalnih parametara, to znai da kod poziva funkcija ne uzima nikakve argumente. U ovom
sluaju, denicija funkcije ima prazne zagrade koje slijede iza imena funkcije tj. funkcijsko_ime().
Ako funkcija prihvaa argumente, onda parametri sadre jedan ili vie identkatora, odvojenih zarezima.
U ovom sluaju, svaki poziv fukcije pridruuje stvarne vrijednosti, argumente, s parametrima specici-
ranima u deniciji funkcije. Parametri su lokalne varijable funkcije, te svaki poziv funkcije povezuje te
varijable s odgovarajuim stvarnim vrijednostima koje pozivatelj navodi kao argumente. Niz naredbi
koji nije prazan, poznatiji kao tijelo funkcije (engl. function body ), ne izvrava se kada i naredba def.
Ono se izvrava kasnije, svaki put kada se funkcija poziva. Tijelo funkcije moe imati jednu ili vie
ponavljanja return naredbe, ali moe postojati i bez nje. Evo primjera jednostavne funkcije koja vraa
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 znai da svaki poziv funkcije mora pruiti i odgovarajuu vrijednost - ( argument )
za svaki parametar. Nakon niza ili liste parametara odvojenih zarezima s niti jednim ili s vie (obveznih)
parametara moe slijediti jedan ili vie slobodnih parametara koji imaju sljedeu sintaksu:
identifikator=izraz
Naredba def rauna, ocjenjuje izraz, te sprema referencu vrijednosti koju izraz vraa, 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
izraunatom, vrijednosti.
Treba primjetiti da se isti objekt, pretpostavljena vrijednost, povezuje sa slobodnim parametrom
kad god u pozivu funkcije nema pridruenog argumenta. Ovo dakako, moe 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 sljedee:
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, doputeno je koristiti jedan ili oba posebna
oblika: *identifikator1 i **iidentifikator2. Ako su obadva na raspolaganju, onaj s dvije zvjezdice
mora doi zadnji. Parametar *identifikator1 omoguuje da poziv funkcije moe osigurati dodatne
pozicijske argumente, dok **identifikator2 omoguuje da poziv funkcije moe osigurati dodatne
argumente s imenom. Na taj nain rjeavaju 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 rjenikom iji su lanovi
imena i vrijednosti dodatnih argumenata koji se imenuju (ili praznim rjenikom, ako ih nema). Evo
kako se pie funkcija koja prihvaa bilo koji broj argumenata i vraa 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 ** doputa konstrukciju rjenika s kljuevima stringa u obliku koji se lake ita nego stan-
dardna rjenika 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
moe staviti u istu liniju kao i naredba def. Dakako, bilo bi jednako tono (i moda itljivije) ako bi se
funkcija vbr_rj ispisala koristei dvije linije umjesto jedne:
def vbr_rj(**kwds):
return kwds
Moe se takoer denirati rjenik iji su kljuevi i vrijednosti funkcije, a onda nainiti rjenik
dvosmjernim:
inverse = {sin:asin, cos:acos, tan:atan, log:exp}

for f in inverse.keys( ): inverse[inverse[f]] = f
Na taj nain za odreenu funkciju moe se brzo nai inverzna funkcija. injenica da su funkcije
objekti u Pythonu, esto se izraava rijeima da su funkcije objekti prve klase.
6.3 Atributi funkcijskih objekata

Naredba def denira atribute i tijelo objekta funkcije. Atribut func_name, kojem se moe pristupiti i kao
__name__, je samoitajui (engl. read-only ) atribut (pa pokuaj njegovog mijenjanja podie iznimku)
koji se odnosi na identikator koriten kao ime funkcije u naredbi def. Atribut func_defaults, koji
se moe 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 moe 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 proteu preko nekoliko
zikih linija, te se stoga obino oznauju kao string literali unutar trostrukih navodnika. Na primjer:
def zbroj(*brojevi):
'''Prihvati bilo koji broj numerikih argumenata i vrati njihov zbroj
Argumenti su n-terac ili lista od jednog ili vie brojeva. Izlaz je njihov zbroj. '''
rez = 0
for broj in brojevi: rez += broj
return rez
Dokumentacijski nizovi vaan su sadraj svakoga Python kda. Njihova je uloga slina komentarima
u bilo kojem programskom jeziku, ali im je iskoristivost ira, jer su dostupni pri procesu pokretanja pro-
grama (engl. runtime ). Programerska okruenja i drugi alati mogu koristiti docstring -ove funkcijskih,
klasnih i modularnih objekata da podsjete programera kako koristiti te objekte. To znai da djeluju
kao pomo (engl. help ) programa. Da bi sedocstring uinio to korisnijim, trebalo bi potovati nekoliko
jednostavnih dogovora. Prva linija docstringa trebala bi biti saeti opis svrhe funkcije, a poinjala
bi s velikim slovom i zavravala tokom. 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 vie linija, druga linija trebala bi biti prazna, a sljedee linije bi trebale for-
mirati jedan ili vie odlomaka, odvojenih praznim linijama, koji opisuju oekivane argumente funkcije,
potrebne uvjete, izlazne (povratne) vrijednosti, te mogue nuspojave. Daljnja objanjenja, knjievne
reference, te primjeri koritenja (koji se mogu provjeriti sa doctest) mogu po slobodnom izboru slijediti
iza, prema zavretku 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
izvrenja naredbe def povezuje s odgovarajuim referencama. Na primjer, funkcija moe brojati koliko
je puta pozivana:
def counter( ):
counter.count += 1
return counter.count
counter.count = 0
Iako ogunost pridruivanja atributa s funkcijom moe ponekad biti od koristi njena primjena nije
esta. Mnogo ee, kada se trebaju povezati neki podaci i programski kd zajedno, koriste se objektno-
orijentirani mehanizmi.
6.4 Naredba 'return'

Naredba return u Pythonu doputa se jedino unutar tijela funkcije, a iza nje moe slijediti neki izraz.
Kada se return izvri, funkcija zavrava i dobiva se povratna vrijednost izraza. Funkcija vraa vrijed-
nost None ako zavrava dolaskom do konca svog funkcijskog tijela ili izvrenjem naredbe return bez
pridruenog izraza. Stvar je stila programskog pisanja da se naredba return ne pie na kraju tijela
funkcije, ako ona nema izraz koji se vraa programskom kdu koji funkciju poziva. Isto tako, ako neke
return naredbe u funkciji imaju izraz koji vraaju pozivatelju, onda bi ga i sve ostale return naredbe
trebale imati. Naredba return None moe se pisati ako se eksplicitno eli zadrati stil takvog pisa-
nja. Iako Python ne prisiljava na stilske konvencije, njihovo potivanje nainit e na kd jasnijim i
itljivijim.
6.5 Poziv funkcije

Poziv funkciji je izraz sa sljedeom sintaksom:
funkcijsko_ime(argumenti)
funkcijsko_ime moe biti bilo kakva referenca na objekt funkcije, to je najee samo ime dotine
argumenti u najjednostavnijem sluaju niz
funkcije. Zagrade oznauju operaciju poziva funkcijie, dok su
od nula ili vie izraza odvojenih zarezima, koji daju, prenose, vrijednosti odgovarajuim parametrima
denirane funkcije. Kada se funkcija poziva , parametri poziva funkcije povezuju se s funkcijskim
argumentima, tijelo funkcije se izvrava sa stvarnim vrijenostima argumenata, a funkcija nakon izvrenja
na koncu vraa pozivatelju neku vrijednost izraza.
6.5.1 Prijenos argumenata

U tradicionalnim terminima izraeno, sve operacije prenoenja 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 sadri). Na taj nain
funkcija ne moe re-povezati, tj. mijenjati sadraj varijable, nego samo kopiju vrijednosti. Ali, ako
se kao argument prenosi promjenljivi objekt, funkcija moe zahtjevati izmjene na objektu, jer Python
prenosi sam objekt (njegovu adresu), a ne njegovu kopiju. Re-povezivanje varijable i promjena objekta
su dva potpuno razliita 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 sluaja, f nije izmijenio poveznice pozivatelja, niti f moe
izmijeniti broj 77, jer su brojevi nepromjenljivi. Ali, f moe izmijeniti objekt liste, jer su objekti liste
promjenljivi. U ovom primjeru, f mijenja objekt liste koji pozivatelj prenosi na f kao drugi argument
pozivajui append metodu objekta.
6.5.2 Vrste argumenata

Upravo opisani argumenti zovu se pozicijski argumenti. Svakom pozicijskom argumentu pridruuje se
vrijednost parametra koji mu odgovara po poziciji (redoslijedu) u deniciji funkcije. U pozivu funkcije
s nula ili vie pozicijskih argumenata mogu slijediti jedan ili vie imenovanih argumenata sa sljedeom
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 pruiti, putem pozicijskih i/ili imenovanih argumenata, tono 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
Oevidno je da su ova dva poziva za dijeljenje ekvivalentna. Imenovani argumenti esto se piu u
svrhu itljivosti, kada se itljivost i razumljivost napisanog kda moe poveati identikacijom uloge i
upravljanjem redoslijeda argumenata. Treba primjetiti, kako kod poziva imenovanih arguemanta nije
bitan redoslijed njihova pisanja. eta 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
Zahvaljujui imenovanom argumentu end= pozivatelj moe specicirati vrijednost, u ovom sluaju
to je prazan string' ' za funkcijski (trei) parametar end, te jo uvijek dopustiti funkcijskom (drugom)
parametru begin, koritenje njegove pretpostavljne vrijednosti, stringu 'init'. Na kraju argumenata u
pozivu funkciji, po izboru se moe koristiti bilo koji (ili oba) posebna oblika *niz i **rj. Ako su oba
prisutna, onaj sa dvije zvjezdice mora doi na zadnjem mjestu.
Parametar *niz prenosi lanove niz kao pozicijske argumente funkcije (poslije obinih pozicijskih
argumenata, ako ih ima). Pritom niz moe biti bilo kakav niz ili iterator.
S druge pak strane, **rj prenosi lanove rj kao imenovane argumente funkcije, gdje rj mora
biti rjenik iji su svi kljuevi 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 sline oblike. Na primjer, koristei funkciju zbroj() moe se ispisati zbroj svih
vrijednosti u rijeniku d. Ovo se postie 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
sline oblike u svojim formalnim parametrima.
6.5.3 Prostor imena

Formalni parametri funkcije zajedno s bilo kakvim varijable koje su povezane (pridrubom ili nekom
drugom povezujuom 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 kae 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 vie identikatora odvojenih zarezima. Identikatori popisani u
global naredbi odnose se na globalne varijable koje funkcija treba re-povezati. Na primjer, _count se
moe ubaciti u funkciju koristei kljunu 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 omoguuje ovakvu vrstu
programiranja, to ipak nije niti elegantno niti preporuljivo. Naredba global nije potrebna ako tijelo
funkcije jednostavno koristi globalnu varijablu, ukljuujui 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 nuno.
6.6 Ugnjeene funkcije

Naredba def unutar tijela funkcije denira ugnjeenu funkciju (eng. nested function ), a funkcija ije
tijelo ukljuuje def je poznata kao vanjska funkcija (eng. outer function ) s obzirom na ugnjeenu.
Kd unutar tijela ugnjeene funkcije moe pristupiti (ali ne i re-povezati) lokalne varijable vanjske
funkcije, takoer poznate i kao slobodne varijable ugnjeene funkcije.
Najjednostavniji nain da se dopusti ugnjeenoj funkciji pristup vanjskim vrijednostima nije osla-
njati se na ugnjeene dosege varijabli ili upotreba global naredbe, nego prijenos vanjskih vrijednosti
6.6. Ugnjeene funkcije 57
preko funkcijskih parametara/argumenata ugnjedene funkcije. Vrijednost argumenta moe se povezati

kada se ugnjeena 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 ugnjeenih 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 sluaju, postotak_1 ima malu prednost: izraun a+b+c dogaa se samo jednom, dok kod
postotak_2 nutarnja funkcija pc ponavlja izraun tri puta. Meutim, ako vanjska funkcija re-povezuje
svoje lokalne varijable izmeu poziva ugnjeene funkcije, ponavljanje izrauna bi mogla biti i prednost.
To znai da se preporuuje znanje oba pristupa, te izbor najprikladnijeg u danoj situaciji.
Ugnjeena funkcija koja pristupa vrijednostima s vanjskih lokalnih varijabla poznata kao je za-
tvorena funkcija ili closure. Sljedei primjer pokazuje kako izgraditi closure bez ugnjeenih dosega
(koristei pretpostavljenu vrijednost):
def make_adder_1(augend):
def add(addend, _augend=augend): return addend+_augend
return add
Ista funkcija koritenjem ugnjeenih dosega izgleda ovako:
def make_adder_2(augend):
def add(addend): return addend+augend
return add
Closures su iznimke u opem pravilu, jer su objektno-orjentirani mehanizmi najbolji nain pove-
zivanja podataka i kda 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 prihvaa jedan argument i dodaje 7 na taj argument (re-
zultat make_adder_2(7) se ponaa na isti nain). Closure je "tvornica" za bilo kojeg lana obitelji
funkcija koji se razlikuju po nekim parametrima, te moe pomoi u izbjegavanju dvostrukog pisanja
programskog kda.
POGLAVLJE 7
Python - objektni jezik
Python je programski jezik temeljen na objektima. Za razliku od nekih drugih, takoer objektno-
orijentiranih, jezika, Python ne uvjetuje koritenje iskljuivo objektno-orijentirane paradigme. Pyt-
hon takoer podrava proceduralno (strukturalno) programiranje s modulima i funkcijama, tako da je
mogue izabrati najprikladniju paradigmu programiranja za svaki dio programa. Openito, objektno-
orijentirana paradigma najbolja je kada se ele skupiti podaci i funkcije u praktine pakete. Isto tako
moe biti korisna kada se ele koristiti neki od Pythonovih objektno-orijentiranih mehanizama, kao npr.
naslijeivanje. Proceduralna paradigma, koja je bazirana na modulima i funkcijama, obino je jed-
nostavnija i prikladnija u sluajima kada nikakve prednosti objektno-orijentiranog programiranja nisu
potrebne. Novi stil objektnog modela postaje standard u novim verzijama Pythona, pa se preporuuje
koristiti ga za programiranje.
7.1 Klase i instance

Klasa ili razred je Python objekt s nekoliko znaajki:
Objekt klase moe 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 podatani objekti ili funkcijski objekti.
Atributi klase koji su povezani na funkcije poznati su kao metode klase.

Metoda moe imati posebno ime denirano od Pythona s dvije podcrte ('__') ispred i iza imena.
Python upotrebljava takve posebne metode za neke operacije koje se izvravaju na instancama
klase.
Klasa moe 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 moe
prenijeti kao argument u pozivu funkcij, a funkcija moe vratiti klasu kao rezultat poziva. Klasa,
kao i bilo koji drugi objekt, moe biti povezana na varijablu (lokalnu lili globalnu), lan niza ili
atribut objekta. Klase takoer mogu biti i kljuevi u rijeniku.
59
60 Python - objektni jezik
7.2 Naredba 'class'

Naredba class je najei nain 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 zavri s izvravanjem. klase_roditelji je po volji zarezima odvojen
niz izraza (obino stringovnih identikatora) ije su vrijednosti objekti klasa. Ove su klase poznate
pod razliitim imenima u razliitim jezicima - govori se o baznim klasama, superklasama ili roditeljima
klase koja se stvara. Za klasu koja se stvara kae se da 'nasljeuje oblik', 'poinje od', 'produava 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) prihvaa dva
argumenta koji su objekti klase: vraa True ako je C1 podklasa od C2; u suprotnom vraa False. Svaka
klasa je zapravo podklasa od same sebe, tako da issubclass(C, C) vraa 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 dvotoke. 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 vie 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
izvrava se odmah, kao dio procesa izvrenja naredbe class. Dok se tijelo ne izvri, novi objekt klase
ne postoji i identikatorime nije jo povezan (ili re-povezan). Konano, 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 podatani ili funkcijski
objekti.
7.3.1 Atributi klasnog objekta

Atribut objekta klase obino 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. Mogue 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 poveu, 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 koriten 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 rjeniki 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

Veina tijela klasa ukljuuju naredbu def, jer su funkcije (u ovom kontekstu se zovu metode ) vani
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 ukljuuje deniciju
metode:
class C4:
def pozdrav(self):
print "Zdravo"
Klasa moe 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 specine za klasu

Kada naredba u tijelu klase (ili u metodi unutar tijela) koristi identikator koji poinje s dvije podcrte
(ali ne zavrava podcrtama) - __ident, Python compiler implicitno mijenja identikator u _classname__ident,
gdje je classname ime klase. Ovo doputa klasi koritenje privatnih imena za atribute, metode, glo-
balne varijable i druge svrhe, bez rizika njihovog sluajnog dupliciranja negdje drugdje. Dogovorno, svi
identikatori koji poinju 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 poetni 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 raunu"
self.novac = self.novac + iznos
def povuci(self,iznos):
"Oduzima od iznosa na raunu"
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 nainjeni, atributi i metode novo nastale instance dohvatljivi su koritenjem ' toka ' (.)
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 koristei rjenik koji je dohvatljiv kao instanca __dict__ atributa.
Ovaj rjenik sadri 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 rjeniku instance.
Unutar metoda deniranih u klasi, atributi se mijenjaju kroz pridrubu 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 pridruba atributima uvjek provodi na lokalnom rjeniku neke instance, pristup atributu
ponekad je vrlo sloen. Kad god se pristupa atributu, Python interpreter (compiler) prvo pretrauje
rjenik instance. Ako ne nae traeno, onda se pretrauje rjenik objekta klase koja se koristila za
stvaranje instance. Ako ni to nije urodilo plodom, onda se provodi pretraivanje roditeljskih klasa (ako
ih klasa ima). Ako i to propadne, konani pokuaj traenja atributa je pozivom __getattr__() metode
te klase (ako je denirana). Na koncu, ako ni to ne uspije, onda se podie AttributeError iznimka.
Kako je pokazano, da bi se stvorila instanca klase, treba se (poput poziva funkcije) pozvati objekt
klase. Svaki poziv vraa novi objekt instance te klase:jedna_instanca = C5(). Ugraena funkcija
isinstance(Obj,C) s objektom klase kao argumentom C vraa True ako je objekt Obj instanca klase
C ili bilo koje podklase od C. U protivnom isinstance vraa False.
7.4.1 __init__
Kada klasa ima ili nasljeuje metodu __init__, poziv objektu klase implicitno izvrava __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 sljedeoj
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__ obino sadri naredbe koje povezuju atribute ins-
tance. Metoda __init__ ne smije vraati nikakvu vrijednost osim vrijednosti None, jer svaka druga
vraena 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 poveu
naredbama u metodi __init__.
7.4.2 Atributi objekta instance

Jednom kada se stvori instanca, moe se pristupiti njenim atributima (podacima i metodama) koristei
toka ' (.)
' operator. Na primjer:
i4=C4();
i4.pozdrav( ) # ispisuje se: Zdravo
print jedna_instanca.x # ispisuje se: 42
Objektu instance moe 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 omoguuje 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 rjenik 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 nuno. 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 pokuaj 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 Tvornika funkcija

Postoji potreba stvaranja instance razliitih klasa ovisno o nekim uvjetima ili izbjegavanje stvaranja
nove instance ako je postojea jo uvijek dostupna. Te bi se potrebe mogle rijeiti tako da __init__
vrati specian objekt, ali to nije mogue jer Python podie iznimku kad __init__ vrati bilo koju
vrijednost osim None. Najbolji nain implementacije eksibilnog stvaranja objekata je koristei obinu
funkciju, a ne pozivanjem objekta klase izravno. Funkcija koja se koristi u ovu svrhu zove se tvornika
funkcija.
Pozivanje tvornike funkcije je eksibilno rjeenje, jer takva funkcija moe vraati postojeu instancu
koja se moe ponovno koristiti ili stvoriti novu instancu pozivanjem odgovarajue klase. Recimo da
postoje dvije sline klase (Posebna i obicna) i da se treba generirati jedna od njih, ovisno o argumentu.
Sljedea tvornika funkcija Prikladna to omoguuje:
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 traeno
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 brie. Iako
postoji vie naina kako izbrisati referencu, program najee koristi del naredbu za brisanje reference
na objekt. Ako brisanje neke refernce uini da se brojilo referenci objekta smanji na nulu, program e
pozvati __del__() metodu. Python-ov 'skuplja smea' brie iz memorije sve instance koje su ostale
bez referenci i na taj nain oslobaa memorijski prostor drugim objektima.
7.5 Nasljeivanje
Nasljeivanje je mehanizam stvaranja novih klasa koje specijaliziraju ili mijenjaju ponaanje postojee
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 moe 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 trai atribut deniran u temeljnoj klasi, onda se koristi algoritam u dubinu (eng. depth-rst
search ) za pretraivanje i to u temeljnim klasama kako su navedene u poretku prilikom denicije klase.
Na primjer, u klasi E u prethodnom primjeru, temeljne klase se pretrauju redoslijedom C , A, B, D. U
sluaju da viestruke temeljne klase deniraju isti simbol, uzet e se prvi simbol kojeg procs traenja
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 znai, da je u izvedenoj klasi nuno nainiti
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
...
Slini koraci mogu takoer biti nuni kad se deniraju akcije ienja (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 sluaju, potraga rekurzivno
prosljeuje navie, po drvetu naslijea, zaustavljajui se kada je 'ime' naeno. Potraga je po dubini,
to znai da pregledava pretke svake roditeljske klase od C prije pregleda sljedee 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 sluaju potraga za metodom zapoinje 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 toki i nikada
ne uzima u obzir Roditeljska_3, gdje bi se taj atribut takoer naao.
7.5.1 Premoujui atributi

Potraga za atributom, kako je objanjeno, ide navie po drvetu naslijea (prema precima), te se za-
ustavlja kada je atribut pronaen. Potomake klase pregledavaju se prije predaka, to znai 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 premoivanje (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 premouje atribute big od njene superklase B.
7.5.2 Posluivanje 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 moe napraviti koristei nepovezanu metodu, kako
slijedi:
class Gornja:
def pozdrav(self, ime): print "Zdravo ", ime
class Donja(Gornja):
def pozdrav(self, ime):
print "Dobro doli",
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, ukljuujui self. Predaja
ili posluivanje implementaciji superklase je glavna korist nepovezanih metoda.
7.5.3 Vieoblije
Vieoblije ili polimorzam, (eng. polymorphism ) ili dinamiko povezivanje potpuno se otkriva kroz
proces traenja nekog atributa, prethodno opisano u nasljeivanju objekata. Kad god se metodi pristupa
sa obj.method(), prvo se metoda locira traenjem __dict__ atributa instance, pa instancine klasne
denicije, pa roditeljskih klasa. To traenje uvijek ide u tom redoslijedu. Prvi uspjeni pronalazak
koristi se kao traena metoda.
7.5.4 Skrivanje informacije (engl. information hiding)

Pretpostavlja se da su svi atributi javni (engl. public ). To znai da su svi atributi klasne instance
dohvatljivi bez ikakvog ogranienja. To takoer povlai da sve to je denirano u temeljnoj, roditeljskoj
klasi nasljeuje se i dohvatljivo je u izvedenoj klasi. Takvo ponaanje je esto nepoeljno u objektu
orjentiranim primjenama, jer to otkriva nutarnju strukturu objekta i moe voditi koniktima prostora
imena izmeu objekata deniranih u izvedenoj klasi i onih deniranih u roditeljskoj klasi. Da bi se
rijeio ovaj probleem, uvedeno je da sva imena u klasi koja poinju s dvostrukom donjom crtom (__) ,
kao to je __Moj, pretvara se u oblik _Classname __Moj. To prua rjeenje za klasu da ona ima privatne
atribute, budui da privatna imena u izvedenoj klasi nee kolidirati s imenima u temeljnoj klasi jer su
imena klasa nuno razliita, 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 sprijeio
pristup " privatnim " atributima neke klase. To znai 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

Korisniki objekti mogu se proiriti s novim operatorima, dodajui posebne metode da zajedno rade sa
svim Python-ovim ugraenim operatorima. Na primjer, sljedea klasa nadopunja kompleksne brojeve sa
standardnim matematikim operatorima i prisilnim tipovima kako bi se ostvarilo mijeanje 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 numerike tipove u kompleksni
def __coerce__(self, drugi):
if isinstance(drugi, Complex):
return self,drugi
try: # Provjeriti ako se moe pretvoriti u float
return self, Complex(float(drugi))
except ValueError:
pass
U ovom primjeru, postoji nekoliko zanimljivih detalja:
1. Prvo, normalno ponaanje od __repr__() je stvaranje stringa koji e se izvriti kako bi se ponovno
nainio objekt. U ovom sluaju stvara se string oblika "Complex(r,i)". U drugom sluaju, metoda
__str__() stvara string koji je namijenjen za lijepi formatirani izlaz (to je string koji e se ispisati
s pomou 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. Konano, __coerce__ metoda koristi se u dohvaanju operacija koje ukljuuju mijeane tipove
podataka. U ovom sluaju, drugi numeriki tipovi pretvaraju se u kompleksne brojeve tako da se
mogu koristiti u metodama kompleksne aritmetike.
7.6 Testovi pripadnosti klasa i tipova

Trenutano, postoji odijeljenost izmeu tipova i klasa. To konkretno znai, da se ugraeni tipovi poput
lista i rjenika 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 razliitih klasa).
Provjera pripadnosti klasi provodi se upotrebom ugraene funkcije isinstance(obj,cname). Ova
funkcija vraa 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) # Vraa True

print isinstance(b,A) # Vraa True, B je izveden iz A
print isinstance(b,C) # Vraa False, C nije izveden iz A
Slino, ugraena funkcija issubclass(A ,B ) vraa istinu ako je A podklasa klase B. Na primjer:
issubclass(B,A) # Vraa True

issubclass(C,A) # Vraa False
Funkcija isinstance() moe se koristiti za izvravanje provjere tipa s obzirom na bilo koji ugraeni
tip:
import types
isinstance(3, types.IntType) # Vraa True
isinstance(3, types.FloatType) # Vraa False
Ovo je preporuen nain provjere tipa meu ugraenim tipovima, jer e razlika izmeu tipova i klasa
moda ieznuti u buduim inaicama Python-a.
POGLAVLJE 8
Moduli i paketi
Podaci (varijable), funkcije, klase i objekti skupljaju se u module. Vie modula zajedno ini paket.
Moduli i paketi predstavljaju Python knjinicu (engl. library ).
8.1 Modul
U modul je mogue ukljuiti bilo koju valjanu datoteku s Python kdom, te pozvati ga s naredbom
import. Na primjer, neka je sljedei kd 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 kd kao modul, postie se naredbom import primjer. Prvi put kad se
import koristi da se modul uita u memoriju, dogaaju se tri stvari:
1. Modul stvara novi prostor imena koji slui svim objektima deniranim u pripadnoj izvornoj
datoteci. Ovaj prostor imena dohvaa se ako funkcije i metode denirane unutar modula koriste
naredbu global.
2. Modul izvrava kd koji je sadran unutar novonastalog prostora imena.
3. Modul izvrava ime unutar pozivatelja, koje se odnosi na prostor imena modula. Ovo ime podu-
dara se s imenom modula.
import primjer # Uitava u memoriju i izvodi modul 'primjer'

print primjer.a # Dohvaa izvodi neki lan (varijablu) modula 'primjer'
primjer.A() # Dohvaa i izvodi funkciju iz modula
c = primjer.K() # Dohvaa i izvodi klasu iz modula, tvorba objekta
...
Uitavanje, uvoz (eng. import ) viestrukih modula izvodi se tako da se iza naredbe import dopiu
imena modula, odijeljena zarezom, na primjer ovako:
71
72 Moduli i paketi
import socket, os, regex
Moduli se mogu uitati ( importirati ) koristei 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 specine denicije unutar modula s trenutanim prostoru imena. Ova
naredba predstavlja proirenje naredbe import gdje se uz novo stvoreni prostora imena, stvara i refe-
renca na jedan ili vie objekata deniranih untar modula:
from socket import gethostname

# Stavlja gethostname u trenutani prostor imena
print gethostname() # Koristi se bez imena modula

socket.gethostname() # Pogreka imena (NameError: socket)
Naredba from takoer prihvaa zarezom odvojena imena objekata. Zvjezdica (engl. asterisk , *) je
sveobuhvatni (engl. wildcard ) znak koji se koristi za uitanje svih denicija u modulu, osim onih koje
poinju s podvuenom crtom (_). Na primjer:
from socket import gethostname, socket

from socket import * # Puni sve definicije u trenutani prostor imena
Moduli se mogu preciznije upravljati skupom imena koji se uita s from module import * definiranjem
liste __all__. Na primjer:
# module: primjer.py
__all__ = [ 'K', 'primjer' ] # To su sva ona imena koja e se uvui sa *
Nadalje, poveznica as moe se koristiti za promjenu imena objekata koji se uitaju s naredbom
from. Na primjer:
from socket import gethostname as ime_hosta

h = ime_hosta()
Naredba import moe se pojaviti na bilo kojem mjestu u programu. Meutim, kd u svakom
modulu izvodi se samo jednom, bez obzira kako esto se naredba import izvrava. Idue import
naredbe jednostavno stvaraju referencu na prostor imena modula koji je stvoren s poetnom import
naredbom. U varijabli sys.modules moe se nai rjenik koji sadri imena svih trenutano napunjenih
modula. On preslikavaa imena modula na njihove objekte. Sadraj rjenika se koristi za odreivanje je
li import napunio svjeu kopiju modula ili se isti modul poziva drugi put.
Naredba from module import * moe se koristiti samo na vrhu modula. Drugim rijeima, nije
doputeno 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 sadri
ime modula. Programi mogu ispitivati ovu varijablu i pritom odrediti modul u kojem se programske
naredbe izvravaju. Najvii (tzv. __main__. Programi zadani
top-level) modul interpretera zove se
__main__ modula. Ponekad
na naredbenoj liniji ili uneeni interaktivno, uvijek se izvode unutar tog
program moe promijeniti ovo ponaanje, ovisno o tomu je li uvuen iz modula ili je izveden u __main__
okoliu. To se moe postii na ovaj nain:
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 Traenje modula

Kad se moduli uitavaju, interpreter trai listu imenika, foldera u sys.path. Tipina vrijednost
sys.path moe 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 trenutani imenik, folder. Novi imenici dodaju se u put traenja vrlo
jednostavno - dodavanjem lana (stringa puta) u ovu listu.
8.1.2 Uitavanje modula i compilacija

Do sada su moduli prikazani kao datoteke koje sadre Python kd. Meutim, moduli uitani s naredbom
import mogu pripadati nekoj od etiri ope kategorije:
Programi pisani u Pythonu (.py datoteke)
C ili C++ proirenja koja su compilirana u zajednikim (shared) knjinicama ili DLL-ovima.
Paketi koji sadre skupove modula
Ugraeni moduli pisane u C-u i povezani s Python interpreterom
Kad se na primjer, trai modul primjer, interpreter pretrauje svaki od direktorija u sys.path za
sljedee datoteke (navedene po redoslijedu pretraivanja):
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 koritena)
4. primjer.pyc
5. primjer.py
Za .py datoteke, kad se modul prvi put uita, on se prevede, compilira u meukd (eng. bytecode )
i zapisuje na disk u datoteku s proirenjem .pyc. U iduim uitanjima, interpreter puni ovaj prireeni
meukd, osim ako ne doe do promjene originalne .py datoteke (pa se .pyc datoteka mora regenerirati.
Datoteke koje zavravaju na .pyo koriste se u svezi s interpreterskom -O opcijom. Ove datoteke sadre
meukd s izbaenim brojevima linija i drugim informacijama potrebnim za traenje pogreaka (eng.
debugging ). Kao rezultat toga, kd je neto manji i doputa interpretoru neto bre izvoenje. U sluaju
-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 podie 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 traenju datoteka razlikuje mala i velika slova u njihovom imenu. Kod operacijskih sustava
koji ne podravaju tu razliku, potrebno je o tomu voditi rauna.
8.1.3 Ponovno punjenje modula

Ugraena funkcija reload() koristi se za ponovno punjenje i izvravanje kda sadranog unutar modula
koji je prethodno uitan s naredbom import. Ona prima objekt modula kao pojedinani argument. Na
primjer:
import primjer
... neki kd ...
reload(primjer) # Ponovno puni modul 'primjer'
Sve operacije ukljuene u modul e se nakon izvoenja naredbe reload() izvesti iz novo uitanog
kda. Meutim, reload() nee retroaktivno obnoviti objekte koji su nastali iz starog modula. To znai
da je mogue 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
ope pravilo, treba izbjegavati ponovno punjenje modula, osim za vrijeme razvitka programa i traenja
pogreki u njemu.
8.2 Paketi
Paketi doputaju da se vie modula skupi zajedno pod jednim zajednikim imenom. Ova tehnika
pomae u razluivanju sukoba u prostoru imena modula koji se koriste u razliitim primjenama. Paket
se denira stvaranjem imenika, foldera (engl. directory, folder ) s istim imenom kao paket i stvaranjem
__init__.py datoteke u tom imeniku. Mogue je nakon toga dodavati druge izvorne datoteke (tekstovne
datoteke s Python kdom), compilirana proirenja ili podpakete u istom imeniku. Na primjer, paket se
moe 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 naina:
import Graphics.Primitive.ispuna
Ovo uitava podmodul Graphics.Primitive.ispuna. Sadraj tog modula mora se eksplicitno
imenovati, kao na primjer: Graphics.Primitive.ispune.crtaj(img,x,y,color).
Drugi nain:
from Graphics.Primitive import ispuna
uitava podmodul ispuna i ini ga raspoloivim i bez paketnog preksa, na primjer: ispuna.crtaj(img,x,y,color).
Trei nain:
from Graphics.Primitive.ispuna import crtaj
Ova naredba uitava podmodul ispuna i ini crtaj funkciju direktno primjenljivom, primjerice:
crtaj(img,x,y,color). Kad god se neki dio paketa uita, importira, kd u datoteci __init__.py se
tad izvri. U najmanjem sluaju ova datoteka moe biti i prazna, ali takoer moe sadravati kd kojim
se izvode inicijalizacije koje su specine za paket. __init__.py za vrijeme
Sve naene datoteke u
uitavanja, automatski se izvravaju. Tako e naredba import Graphics.Primitive.ispuna izvriti
__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 uitati sve module pridruene u paketu s trenutanim 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 moe tono odrediti koje module tono treba ukljuiti.
Kao rezultat, ova naredba samo uitava sve reference koje su denirane u __init__.py datoteci u
Primitive imeniku. Ovo se ponaanje moe promijeniti deniranjem liste __all__ koja sadri sva
imena modula pridruena 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 uitaju, kako se i oekuje. Uitavanje samo imena paketa nee automatski uitati sve podmodule
koji se nalaze u paketu. Na primjer, sljedei kd nee raditi:
import Graphics
Graphics.Primitive.fill.floodfill(img,x,y,color) # Pogreno!
Meutim, budui da importGraphics naredba izvrava __init__.py datoteku u Graphics imeniku,

mogue ju je promijeniti tako da se automatski uitaju svi podmoduli:
# Graphics/__init__.py
import Primitive, Graph2d, Graph3d
# Graphics/Primitive/__init__.py
import linije, tekstovi, ispuna ...
76 Moduli i paketi
Na ovaj nain importGraphics naredba uitava sve podmodule i ini ih raspoloivima za pozive ko-
ristei njihova potpuna imena. Moduli koji su sadrani unutar istog imenika (foldera) paketa, mogu refe-
Graphics.Primitive.ispuna
rencirati jedan drugog bez navoenja punog imena paketa. Na primjer, modul
moe uitati Graphics.Primitive.linije modul jednostavno koristei naredbu import linije. Me-
utim, ako je modul smjeten u drugom imeniku, onda se mora koristiti puno ime paketa. Na primjer,
akoplot2d iz modula Graphics.Graph2d trai upotrebu linije iz modula Graphics.Primitive, mora
se koristiti puna staza imena:from Graphics.Primitive import linije. Ako je potrebno, modul
moe ispitati svoju __name__ varijablu kako bi naao potpunu stazu svog imena. Na primjer, sljedei
kd uitava modul iz sestrinskog podpaketa znajui samo ime tog podpaketa (a ne i najvie ime s vrha
paketa):
# Graphics/Graph2d/plot2d.py
# Odreuje ime paketa, gdje je smjeten 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,)
Konano, kad Python uitava paket, on denira posebnu varjablu__path__ koja sadri listu imenika
__path__ je posebna inaica sys.path
koji se pretrauju, kad se se trae paketni podmoduli. (Varijabla
varijable.) __path__ je dohvatljiv za kd sadran u datoteci __init__.py i inicijalno sadri jedan lan
s imenom foldera (imenika) paketa. Ako je potrebno, paket moe dodati dodatne imenike u __path__
listu da bi se promijenila staza koja se koristi u traenju podmodula.
POGLAVLJE 9
Ulaz i izlaz
Pod pojmom ulaz/izlaza razmatraju se mogui argumenti naredbene linije, varijable okoline, rad s
datotekama, naredba (ili funkcija) 'print', te ouvanje programskih objekta.
9.1 itanje naredbene linije i varijable okolia

Kad interpreter zapone s radom, argumenti naredbene linije spremaju se u listu sys.argv. Prvi ele-
ment liste je ime programa koji se pokree. Idui elementi su mogui argumenti uneseni na naredbenoj
liniji iza imena programa koji se izvodi. Sljedei 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 sljedee:
% python printopt.py foo bar -p

sys.argv[0] = printopt.py
sys.argv[1] = foo
sys.argv[2] = bar
sys.argv[3] = -p
%
Varijable okolia dohvaaju se u rjeniku os.environ. Na primjer:
import os
path = os.environ["PATH"]
user = os.environ["USER"]
editor = os.environ["EDITOR"]
... etc ...
Promjena varijabli okolia provodi se postavljanjem os.environ varijable. Druga je mogunost
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
Naini otvaranja datoteke (engl. le ) su 'r' za itanje (eng. read ), 'w' za pisanje (engl. write), ili 'a'
za dodavanje sadraja u ve postojeu datoteku (eng. append ). Binarni podatci spremaju se u datoteku
s oznakom 'b', pa vrijedi 'rb' kao nain itanja binarnih podataka, a 'wb' kao nain spremanja inarnih
podataka. To je opcionalno u UNIX-u, ali nuno na Windows-ima, gdje se treba ukljuiti kako bi se
postigla prenosivost s jednog sustava na drugi. Uz to, datoteka se moe otvoriti za auriranje (eng.
update) koristei znak (+) character, pa vrijedi 'r+' ili 'w+'. U sluaju otvaranja datoteke za auriranje,
mogue je izvriti 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 poetku njena duljina pretvara u nulu (brie se sadraj). open() vraa objekt datoteke (eng.
file object) koji podrava methode prikazane u tablici 9.1:
Tablica 9.1: Metode s datotekama
Metode Opis
f.read([n]) ita najvie n okteta (engl. bytes )
ita jednu ulaznu liniju do najvie n znakova.
f.readline([n])
Ako se n iizostavi, onda ita cijelu liniju.
f.readlines() ita sve linije i vraa 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.
Vraa trenutano kazalo (brojilo znakova)
f.tell()
datoteke.
f.seek(offset [, where ]) Trai novu poziciju u datoteci.
f.isatty() Vraa 1 ako je f interactivni terminal.
Sprema (eng. ushes ) izlazni mem. bufer u
f.flush()
datoteku.
f.truncate([size]) Skrauje datoteku na najvie size okteta.
f.fileno() Vraa cjelobrojni identikator datoteke.
f.readinto(buffer,nbytes Uitava nbytes podataka iz memorijskog buer
) objekta.
Metoda read() vraa itavu datoteku kao jedan string, osim ako je zadan jedan proizvoljan para-
metar length kojim se odreuje maksimalna duljina uitanih okteta. Metoda readline() vra sljedeu
liniju ulaza, ukljuujui i znak zavretka linije (eng. newline terminator ); metoda readlines() vraa
sve ulazne linije kao listu stringova. Metoda readline() dodatno prhvaa makismalnu duljinu linije n.
Ako je linija dua od n okteta, frunkcija vraa samo n uitanih okteta. Ostatak podataka na liniji se ne
brie, ve se uitava u iduim itanjima. Obje metode: readline() i readlines() ovise o operacijskom
sustavu te obrauju na razliite naine zavretke linija (na primjer, '
n' u odnosu na '
r
n'). Metoda xreadlines()vraa poseban objekt koji omoguuje uitavanje linija datoteke ite-
racijskim postupkom, umjesto cjelokupnog uitavanja linija odjednom u memoriju, kao to to radi
readlines() metoda. Na primjer:
9.3. Standardni ulaz, izlaz i pogreka (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 sluajima, string moe sadravati binarne podatke, ukljuujui 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
poetak datoteke; ako je vrijednost parametra where jednaka 1, pozicija se rauna relativno s obzirom
na trenutanu poziciju, a ako je jednaka 2, pomak se rauna od kraja datoteke. Metoda fileno() vraa
cjelobrojno kazalo datoteke i ponekad se koristi u ulazno/izlaznim operacijama niske razine u stanovitim
knjinikim modulima. Na strojevima koji podravaju velike datoteke (vee od 2 GB) metode seek()i
tell() koriste duge cijele brojeve ( long integers ). Objekti datoteke ima takoer atribute prikazane u
sljedeoj 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(). Inae,
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 pogreka (engl. Input, Output, Error)

Python interpreter raspolae 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 pogrekama. Najee je stdin preslikan tj. odgovara korisnikoj tipkovnici, dok su
stdout i stderr preslikavaju na ispis na zaslon raunala. Metode opisane u prethodnom odlomku, mogu
se korisititi i za izvoenje sirovog ulaza/izlaza (eng. I/O ) u komunikaciji s korisnikom. Na primjer,
sljedea 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) moe itati liniju teksta sa standardnog ulaza
stdin :
s = raw_input("type something : ")
print "You typed '%s'" % (s,)
80 Ulaz i izlaz
Konano, nasilni prekid preko tipkovnice (najee generiran sa Ctrl+C) rezultira u KeyboardInterrupt
izuzetku koji se moe dohvatiti koristei 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 sluaju naredba print i funkcije raw_input koriste nove vrijednosti. Originalne vrijed-
nosti od sys.stdout, sys.stdin i sys.stderr na poetku rada interpretera su takoer dohvatljive
u sys.__stdout__, sys.__stdin__ i sys.__stderr__. Dobro je primjetiti da se u nekim sluajima
sys.stdin, sys.stdout i sys.stderr mogu promijeniti od strane integriranog razvojnog okruenja (eng. inte-
grated development environment - IDE ). Na primjer, kad se Python izvod pod Idle-om, onda se sys.stdin
zamjenjuje s objektom koji se ponaa kao datoteka, iako je on stvarno objekt razvojnog okruenja. U
ovom sluaju, 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 pridruena objektu sys.stdout. Ta naredba prihvaa 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 konani izlazni string. Izlaz se
zakljuuje znakom za novi red, osim u sluaju kad se print naredba zavrava zarezom. U tom sluaju,
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, koristei dvije print naredbe
print " Vrijednosti varijabli su: ", x, y, # Ne ispisuje novi redak
print z, w
Upotrebom string formatirajueg operatora (%) dobiva se formatirani izlaz. Na primjer:
print "Vrijednosti su: %d %7.5f %s" % (x,y,z) # Formatirani UL/IZL (I/O)
Mogue je promijeniti odredite print naredbe dodajui specijalni file modifikator, gdje je file
datoteka objekta u koju korisnik pie. Na primjer:
f = open("izlaz","w")
print >>f, "Ovdje Python!"
...
f.close()
Kombinacijom formatiranog ulaz/izlaza stringova s trostrukim navodnicima i rjenika, dobiva se

snana pomo u pisanju kompjutorski generiranih tekstova, kakva su, na primjer, cirkularna pisma.
Obino se u takvim pismima trebaju opa 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 potovanjem,
Python Mlai
Da bi se to nainilo, prvo se formira string s trostrukim navodnicima koji sadri tekst, a onda rjenik,
koji sadri 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 potovanjem,
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 rjeniku, nego svaki tekst pisati pojedinano.
9.5 Otpornost
esto je potrebno spremiti objekt u datoteku i poslije ga iz datoteke proitati. Jedan nain je da se naini
niz funkcija za spremanje objekta u datoteku i isto tako funkcije za itanje. Tu mogu nastati razliiti
pristupi, ovisno o sklonostima i razmiljanju programera. Jedan ugraeni pristup ovom problemu je
serijalizacija objekta koja se postie upotrebom pickle i shelve modula. Modul pickle serijalizira
objekt u tok okteta (eng. stream of bytes ) koje se mogu zapisati u datoteku. Na primjer, sljedei kd
zapisuje objekt u datoteku:
import pickle
object = someObject()
f = open(filename,'w')
pickle.dump(object, f) # Sprema objekt
Ponovno obnavljanje objekta postie se sljedeim kdom:
import pickle
f = open(filename,'r')
object = pickle.load(f) # Obnavlja objekt
Modul shelve je slian, ali objekte sprema u bazu podataka slinu rjeniku:
import shelve
object = someObject()
dbase = shelve.open(filename) # Otvara bazu
dbase['key'] = object # Sprema objekt u bazu
...
object = dbase['key'] # Vraa objekt iz baze
dbase.close() # Zatvara bazu
U oba sluaja, samo se serijalizirani objekti mogu spremiti u datoteku. Veina Python objekata
se moe serijalizirati, ali objekti posebne vrste, kao to su na primjer datoteke, ne mogu se spremati i
obnavljati na ovaj nain.
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

Sveuilita Josipa Jurja Strossmayera

3 Izrazi, operatori i operacije 25

7 Python - objektni jezik 59

1.1 Jezine znaajke

Jezik visoke razine

Sintaksa jezika je jednostavna i oevidna. Uvlake zamjenjuju posebne znakove za deniranje

Napredne znaajke jezika

1.2 Izvoenje Python programa

ili pod Linux-om:

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

1.3 Na prvi Python program

identitet - adresa u memoriji gdje je objekt spremljen

vrijednost - sadraj memorijskog prostora spremljenog objekta

metodu - programski kd koji se primjenjuje na vrijenosti(ma) objekta

2347 # Cjelobrojni literal

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

Tablica 2.1: Ugraeni (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 pridruivanju (objekata referencama), upravljanju tije-

Tablica 2.2: Python kljune rijei

1, 23, 3493 # Decimalni cijeli brojevi

1L, 23L, 99999333493L # Dugaki 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 uobiajena 53 bita preciznosti na modernim raunalima.

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

2.2.1 Stringovi - nizovi alfanumerikih 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 Znaenje ASCII/ISO kod

Niz Znaenje 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: Pridruba i brisanje

Evo kratkog primjera:

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

2.3.1 Ugraene metode string-ova

Tablica 2.6: String metode

2.3.2 Ugraene 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 Ugraene metode rjenika

Tablica 2.8: Metode i operacije tipova preslikavanja (rjenika)

Tablica 2.9: Glavne operacije skupova

3.2 Naredbe pridruivanja

3.2.1 Obina pridruba

Krika (eng. slicing ) ima sintaksu obj[start:stop] ili obj[start:stop:korak]. Pritom je

Ovaj izraz re-povezuje a da se pridrui 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

,print " \ n %d - ti Fibonnaccijev broj je % d " %( n , tren )

Sintaksa jezika je jednostavna i oevidna. Uvlake zamjenjuju posebne znakove za deniranje