Python Skripta PDF

UNARSKOM INENJERSTVU
PYTHON U RAC
bojan crnkovi c,
jerko kifi c i marko cavrak
stefan ivi c,
Numericke metode, priprema, obrada i vizualizacija podataka

14. sijecnja 2015. v0.1

Stefan Ivic, Bojan Crnkovic, Jerko kific i Marko Cavrak:
Python u racunarskom inenjerstvu, Numericke metode, priprema, obrada i vizualizacija poc 14. sijecnja 2015.
dataka,
SADRAJ
I
1
osnove pythona
uvod
1.1
1.2
1.3
1.2.2
Dodatni paketi na Windows platformi
1.2.3
Instalacija pomocu upravitelja paketa
2.2
2.3
2.4
3.2
3.3
3.4
3.5
3.6
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
. . . . . . . . .
Python ljuska kao kalukulator . . . .
Python skripte . . . . . . . . . . .
2.3.1
Upotreba posebnih znakova . .
Moduli . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
. . . . . . . . . . . . .
Relacijski operatori ili operatori usporedivanja)

.
Operatori dodjeljivanja . . . . . . . . . . . .
Logicki operatori . . . . . . . . . . . . . . .
Clanski
operatori . . . . . . . . . . . . . . .
Operatori identiteta . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
String . .
Liste . .
Tuple . .
.
.
.
.
Dictionary .
Skupovi . . .
Brojevi
.
.
.
.
.
.
.
.
.
.
4.2
4.3
4.4
4.5
4.6
5.2
5.3
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
6.2
6.3
7.2
7.3
7.4
7.5
7.6
. . . . .
while . . . .
break . . . .
continue . .
4
4
4
5
5
5
6
7
7
7
8
8
12
13
14
16
17
18
19
19
20
20
21
21
23
24
24
25
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
else . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
elif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
if
25
26
27
29
.
.
.
.
Paraleleno iteriranje .
Numeriranje liste . .
for
23
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
raw_input . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
input . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
print
petlje
7.1
19
Aritmeticki operatori
uvjetna grananja
6.1
11
.
.
.
.
.
.
osnovne naredbe za unos i ispis podataka

5.1
Pokretanje Pythona
operatori
4.1
.
.
.
.
.
.
.
.
.
.
.
tipovi podataka
3.1
.
.
.
.
.
.
.
.
.
.
.
python ljuska i .py skripte

2.1
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Spyder . . . . . . .
PyDev . . . . . . .
Kate . . . . . . . .
Editori i razvojna okruenja
1.3.3
.
.
.
.
.
.
.
.
.
.
1.3.2
. . . . . . . . . . . . . . .
1.1.1
Instalacija na Linux platformi . . .
1.1.2
Instalacija na Windows platformi .
Dodatni paketi . . . . . . . . . . . .
1.2.1
Dodatni paketi na Linux platformi .
Instalacija
1.3.1
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
29
30
30
31
32
33
iii
iv
sadraj
funkcije
8.1
8.2
8.3
8.4
8.5
8.6
8.7
35
. . . . .
Vracanje vrijednosti iz funkcije . . . . .
Argumenti sa zadanim vrijednostima . .
Keyword i non-keyword argumenti . . .
Ugnjedena definicija funkcije . . . . .
Anonimne funkcije . . . . . . . . . .
Rekurzivne funkcije . . . . . . . . . .
Definiranje i pozivanje funkcija
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
objektno-orijentirano programiranje
9.4
9.5
9.6
39
40
43
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
9.5.1
Preopterecivanje funkcija
.
9.5.2
Preopterecivanje operatora .
Nasljedivanje
. . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
10 oblikovanje stringova
10.1
.
.
.
.
11.5 Preimenovanje, kopiranje i brisanje datoteka .
11.6 Arhiviranje . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
12.2 Matematicke funkcije . . . . . . . . . . . . .
12.3 Datum i vrijeme . . . . . . . . . . . . . . . .
12.4 Vrijeme izvravanja . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Otvaranje i zatvaranje datoteka
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
12 python standard library

12.1
44
44
45
46
47
48
49
51
57
59
.
11.2 Pisanje u datoteke . . . . . . .
11.3 Citanje
iz datoteka . . . . . . .
11.4 Pozicioniranje u datoteci . . . .
11.1
44
55
Oblikovanje sa operatorom %
11 rad sa datotekama
59
59
60
61
62
62
63
Informacije o platformi i operacijskom sustavu
13 greke u python kodu
63
63
64
64
67
. . . . . . . . . . . . . . . . . . . . . . . . . . . . .
13.2 Manipulacija grekama - Exception handling . . . . . . . . . . . . . . . .
13.3 Ispravljanje greaka - DeBugging . . . . . . . . . . . . . . . . . . . . .
67
numpy
71
13.1
II
39
55
9.3
. . . . . . . . . .
Atributi . . . . . . . . .
9.3.1
Globalni atributi .
9.3.2
Objektni atributi .
Metode . . . . . . . . .
Preopterecivanje . . . . .
.
.
.
.
.
.
.
.
.
.
37
. . . . . . . . . . . . . . . . . . . . . .
10.2 Oblikovanje sa metodom format . . . . . . . . . . . . . . . . . . . . .
Klase
.
.
.
.
.
.
.
.
.
.
37
43
Objektno-orijentirano programiranje
9.2
.
.
.
.
.
.
.
.
.
.
36
.
.
.
.
.
.
.
.
.
.
9.1
.
.
.
.
.
.
.
.
.
.
35
Tipovi greaka
14 zadavanje polja u numpy-u

14.1
14.2
14.3
14.4
14.5
14.6
14.7
14.8
. .
.
linspace .
zeros . .
ones . .
eye . . .
diag . .
.
.
.
.
.
.
.
meshgrid .
array
arange
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
69
73
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
15 informacije o polju i indeksiranje
. . . . . . . . . . . . . . . . . . . . . . . . . . .
15.2 Indeksiranje polja . . . . . . . . . . . . . . . . . . . . . . . . . . . .
15.1
68
Informacije o polju
16 manipulacije sa numpy poljima
73
74
74
75
75
76
76
77
79
79
79
81
sadraj
. . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . .
16.3 Dodavanje i brisanje elemenata polja . . . . . . . . . . . . . . . . . . .
16.1
Manipulacije sa dimenzijama polja
81
16.2
Transponiranje
82
17 u citavanje
i spremanje numpy polja
83
. . . . . . . . . . . . . . . . . . . .
17.2 Spremanje u tekstualne datoteke . . . . . . . . . . . . . . . . . . . . .
17.1
Ucitavanje iz tekstualnih datoteka
18 matri cni
ra cun
18.1
. . . . . . . . . . . . . . . . . .
Rjeavanje sustava linearnih jednadbi
III
poly1d
priprema, obrada i vizualizacija podataka

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
. . . . . . . . . . . . . . . . . .
Mapa boja . . . . . . . . . . . . .
Detaljnije podeavanje grafa izolinija . .
Primjer . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Svojstva prozora, prostora crtanja i osi

Spremanje grafova
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
21 sloeniji 2d grafovi
21.1
Izolinije
21.1.1
21.1.2
21.1.3
23.2
23.4
23.5
. . . . . .
Newton-Raphsonova metoda .
Metoda sekante . . . . . . .
Brentova metoda . . . . . .
Zadaci . . . . . . . . . . .
Metoda bisekcije
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
94
96
101
101
102
103
105
105
106
107
113
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
24 interpolacije
113
115
116
116
117
119
. . . . . . . . . . . . . . . . . . . . . . . . . . . . .
24.2 2D i N-D interpolacija . . . . . . . . . . . . . . . . . . . . . . . . . .
24.1
94
111
23 rjeavanje nelinearnih jednadbi
23.3
94
109
numeri cke
metode
23.1
91
105
22 izrada animacija
IV
87
89
.
.
.
.
.
.
.
.
.
Linijski grafovi
.
20.5 Podgrafovi . . . .
20.6 Polarni grafovi . .
20.7 tips and tricks . . .
20.4
85
91
. . . . . . . . . . .
20.2 Naprednija kontrola linijskih grafova .
20.2.1
Boje . . . . . . . . . . . .
20.2.2
Markeri . . . . . . . . . . .
20.3
84
87
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
20 osnovni 2d grafovi
20.1
83
85
19 rad sa polinomima
19.1
82
1D interpolacija
25 regresije
119
120
123
. . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . .
25.3 Zadaci . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
25.1
Metoda najmanjih kvadrata
123
25.2
Linearna regresija
123
26 rjeavanje sustava linearnih jednadbi
127
. . . . . . . . . . . . . . . . . . . . . . .
26.2 LU dekompozicija . . . . . . . . . . . . . . . . . . . . . . . . . . . .
26.1
Metoda Gaussove eliminacije
27 numeri cko
integriranje
. .
.
27.3 Naprednije metode .
27.4 Zadaci . . . . . . .
27.1
Trapezna formula
27.2
Simpsonove formule
.
.
.
.
.
.
.
.
124
127
128
131
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
131
133
134
135
vi
sadraj
rjeavanje modela temeljenih na odj i pdj
137
28 numeri cke
metode za rjeavanje obi cnih
diferencijalnih jednadbi
.
28.1.1
.
28.1.2
.
28.1.3
.
28.2 Sustavi obicnih diferencijalnih jednadbi 1. reda .
28.3 Obicne diferencijalne jednadbe vieg reda . . .
.
Eulerova metoda . . . . . . . .
Runge-Kutta metode . . . . . .
Rjeavanje pomocu scipy-a . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
141
. . . . . . . . . . . . . . . . . . . . . . . . . . . . .
30.2 Stacionarno provodenje

topline u tapu . . . . . . . . . . . . . . . . . .
151
Obicne diferencijalne jednadbe 1. reda
.
.
.
.
.
.
.
.
.
.
.
.
29 po cetni
problemi
29.1
. . . . . . .
Stacionarno strujanje . . . . . . . . .
Maningova formula . . . . . . . . . .
Uniformno strujanje i normalna dubina . .
Kriticna dubina . . . . . . . . . . . .
Hidraulicki skok . . . . . . . . . . .
Numericko rjeavanje . . . . . . . . .
Modeliranje otvorenog vodotoka

29.1.1
29.1.2
29.1.3
29.1.4
29.1.5
29.1.6
30.1
Progib ploce
. . . . . . . . . . . . .
35.2 Simpleks metoda . . . . . . . . . . . . . . .
35.3 Rjeavanje LP problema pomocu modula PuLP .
35.4 Prakticni primjeri LP problema . . . . . . . . .
35.4.1
Teretni zrakoplov . . . . . . . . . . . .
Definicija LP problema
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
36.2 Nelder-Mead metoda za optimizaciju funkcije dviju varijabli . . . . . . . .
Algoritam
37 simulirano kaljenje
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
37.2 Primjer simuliranog kaljenja pomocu modula inspyred . . . . . . . . . .
Algoritam
38 optimizacija rojem cestica
. . . . . . . . . . . . . . . . . . . . . . . . . . . . .
38.2 Koritenje PSO metode pomocu modula inspyred . . . . . . . . . . . . .
Razvoj metode
39 geneti cki
algoritmi
. . . . . . . . . . . . . . . . . . . . . . . . . . .
39.2 Koritenje DEAP modula . . . . . . . . . . . . . . . . . . . . . . . .
VII
a
Evolucijski algoritmi
dodaci
korisne naredbe u linux operativnom sustavu
a.1
a.2
144
145
146
147
. . . . . . . . . . . . . . . . . . . . . .
Pracenje promjena tekstualnih datoteka . . . . . . . . . . . . . . . . . .
Kreiranje videa iz skupa slika
153
157
167
168
168
169
.
.
.
.
.
36 nelder-mead metoda
39.1
143
167
Optimizacijske varijable
35 linearno programiranje
38.1
142
165
. . . . . . . . . . . . . . . . . . . . . . . . .
34.2 Ciljevi optimizacije i funkcija cilja . . . . . . . . . . . . . . . . . . . .
34.3 Ogranicenja . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
37.1
140
161
34 definicija optimizacijskog problema
36.1
139
140
157
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
optimizacijske metode
35.1
139
155
33 metoda linija
34.1
139
151
Savijanje grede
31 klasifikacija parcijalnih diferencijalnih jednadbi
32 elipti cke
parcijalne diferencijalne jednadbe
32.1
139
141
.
.
.
.
.
.
.
30 rubni problemi
VI
139
.
.
.
.
.
.
28.1
169
170
170
170
171
175
175
176
181
181
181
185
185
186
189
189
190
197
199
199
199
sadraj
bibliografija
201
vii
POPIS SLIKA
Slika 1.1
Slika 1.2
Slika 6.1
Slika 6.2
Slika 6.3
Slika 7.1
Slika 7.2
Slika 7.3
Slika 19.1
Slika 20.1
Slika 20.2
Slika 20.3
Slika 20.4
Slika 20.5
Slika 20.6
Slika 20.7
Slika 20.8
Slika 20.9
Slika 20.10
Slika 20.11
Slika 20.12
Slika 21.1
Slika 21.2
Slika 23.1
Slika 23.2
Slika 24.1
Slika 24.2
Slika 25.1
Slika 27.1
Slika 27.2
Slika 28.1
Slika 29.1
Slika 29.2
Slika 29.3
Slika 29.4
Slika 29.5
Slika 29.6
Slika 29.7
Slika 30.1
Slika 30.2
Slika 30.3
Slika 32.1
Slika 33.1
Slika 36.1
Slika 36.2
Slika 37.1
Slika 38.1
Slika 38.2
Slika 39.1
viii
Spyder razvojno okruenje . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Kate tekstualni editor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Dijagram toka if naredbe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
if-else dijagram toka . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Dijagram toka za sloeni uvjet grananja . . . . . . . . . . . . . . . . . . . . . . .
Dijagram toka while petlje . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Dijagram toka while petlje sa else blokom . . . . . . . . . . . . . . . . . . . . .
Dijagram toka while petlje sa continue naredbom . . . . . . . . . . . . . . . . .
Graf polinoma iz primjera 19.1 . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Matplotlib elementi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Prozor sa grafom napravljen izvodenjem

izvrnog koda 20.1 . . . . . . . . . . .
Graf napravljen izvodenjem

izvornog koda 20.2 . . . . . . . . . . . . . . . . . .

izvornog koda 20.3 . . . . . . . . . . . . . . . . . .
Izmijenjene granice grafa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Custom ticks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Custom ticks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Spines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Formatiranje oznaka na osima . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Prikaz legende na grafu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Podgrafovi nastali izvravanjem izvornog koda 20.5 . . . . . . . . . . . . . . .
Graf u polarnom koordinatnom sustavu . . . . . . . . . . . . . . . . . . . . . .
Predefinirane mape boja u matplotlibu . . . . . . . . . . . . . . . . . . . . . . .

izvornog koda 21.1 . . . . . . . . . . . . . . . . . .
Skica metode biskecije . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Newton-Raphsonova metoda . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Primjer razlicitih 1D interpolacija . . . . . . . . . . . . . . . . . . . . . . . . . .
Primjer 2D interpolacije . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Regresijski pravac dobiven izvornim kodom 25.1 . . . . . . . . . . . . . . . . .
Trapezi na cjelom intervalu [a, b] i na tri podintervala. . . . . . . . . . . . . . .
Racunanje povrine ispod krivulje pomocu trapeza (Izvorni kod 27.1) . . . . .
Vizualizacija rjeenja iz izvornog koda 28.1. . . . . . . . . . . . . . . . . . . . .
Skica poprecnog presjeka otvorenog vodotoka . . . . . . . . . . . . . . . . . . .
Energetske linije u strujanju fluida otvorenim vodotokom . . . . . . . . . . . .
Pravokutni poprecni presjek kanala . . . . . . . . . . . . . . . . . . . . . . . . .
Trapezni poprecni presjek kanala . . . . . . . . . . . . . . . . . . . . . . . . . . .
M-krivulje vodnog lica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
S-krivulje vodnog lica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Numericko rjeenje strujanja u otvorenom kanalu pravokutnog presjeka . . . .
Savijanje grede . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Rubni uvjeti za razlicite oslonce grede . . . . . . . . . . . . . . . . . . . . . . . .
Progib elasticne linije grede . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Ploca . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Diskretizacija . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Tocke refleksije, ekspanzije, kontrakcije i redukcije kod Nelder-Mead metode
optimizacije za funkciju dvije varijable. Tocke refleksije, ekspanzije ili kontrakcije mjenjaju najgoru tocku simpleksa, dok tocke redukcije mjenjaju dvije nagore tocke simpleksa. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Izgled simpleksa u 5 iteraciji (za izvorni kod 36.1). . . . . . . . . . . . . . . . .
Konvergencija optimizacije pomocu simuliranog kaljenja . . . . . . . . . . . . .
Ponaanje jedinki u Reynoldsovom modelu. Odvajanje, usmjeravanje i kohezija. .
Utjecaj gnjezda na jedinke jata. . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Konvergencija optimizacije genetickim algoritmom (Izvorni kod 39.1) . . . . .
5
6
25
26
28
30
31
31
88
91
92
94
96
97
98
98
99
100
101
102
103
106
108
114
115
120
121
124
131
133
140
141
141
144
145
147
147
149
151
152
153
157
161
176
179
183
185
186
195
P O P I S TA B L I C A
Tablica 3.1
Tablica 4.1
Tablica 4.2
Tablica 4.3
Tablica 4.4
Tablica 5.1
Tablica 10.1
Tablica 10.2
Tablica 12.1
Tablica 12.2
Tablica 20.1
Tablica 20.2
Tablica 20.3
Tablica 20.4
Tablica 29.1
Primjeri oznacavanja brojeva . . . . . . . . . . . . . . . . . . . . .

Aritmeticki operatori . . . . . . . . . . . . . . . . . . . . . . . . . .
Relacijski operatori . . . . . . . . . . . . . . . . . . . . . . . . . . .
Operatori dodjeljivanja . . . . . . . . . . . . . . . . . . . . . . . . .
Logicki operatori . . . . . . . . . . . . . . . . . . . . . . . . . . . .
printf formatiranje . . . . . . . . . . . . . . . . . . . . . . . . . . .
Opcije konverzije . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Definiranje tipova podataka . . . . . . . . . . . . . . . . . . . . . .
Opis nekih funkcija math modula . . . . . . . . . . . . . . . . . . .
Opis nekih funkcija cmath modula . . . . . . . . . . . . . . . . . .
Vrste linija . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Simboli boja . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Vrste markera . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Pozicija legende . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Vrijednosti Manningovog koeficijenta za razlicite izvedbe kanala.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
13
.
19
.
20
.
20
.
21
.
23
.
55
.
56
.
63
. 63
.
92
.
93
.
93
. 101
. 143
ix
POPIS IZVORNOG KODA
Izvorni kod 2.1

Izvorni kod 2.2
Izvorni kod 3.1
Izvorni kod 4.1
Podrka za posebne znakove u Python skriptama . . . . . . . . . . . . . . . . .

Koritenje objekata modula . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Dodavanje i brisanje elemenata liste . . . . . . . . . . . . . . . . . . . . . . . . .
Primjer kombiniranje operatora dodjeljivanja, operatora usporedivanja

i logickih operatora . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Izvorni kod 5.1
Razliciti primjeri ispisa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Izvorni kod 6.1
Jednostavan primjer upotrebe if naredbe . . . . . . . . . . . . . . . . . . . . . .
Izvorni kod 6.2
Pisanje sloenijeg uvjetovanog grananja . . . . . . . . . . . . . . . . . . . . . . .
Izvorni kod 6.3
Primjer upotrebe else naredbe . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Izvorni kod 6.4
Primjer kombinacije naredbi if, elif i else . . . . . . . . . . . . . . . . . . . .
Izvorni kod 7.1
Upotreba for naredbe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Izvorni kod 7.2
Naredba for s listom stringova . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Izvorni kod 7.3
Naredba for i stirng . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Izvorni kod 7.4
Naredba for s listom stringova . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Izvorni kod 7.5
Upotreba while naredbe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Izvorni kod 7.6
Upotreba else naredbe u petlji . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Izvorni kod 7.7
Upotreba break naredbe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Izvorni kod 7.8
Upotreba continue naredbe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Izvorni kod 7.9
Upotreba zip naredbe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Izvorni kod 7.10
Upotreba zip naredbe sa vie lista. . . . . . . . . . . . . . . . . . . . . . . . . . .
Izvorni kod 7.11
Numeriranje elemenata liste pomocu enumerate. . . . . . . . . . . . . . . . . .
Izvorni kod 8.1
Definicija i pozivanje jednostavne funkcije . . . . . . . . . . . . . . . . . . . . .
Izvorni kod 8.2
Definicija funkcije koja prima argument . . . . . . . . . . . . . . . . . . . . . . .
Izvorni kod 8.3
Definicija funkcije koja prima vie argumenata i vraca vrijednost . . . . . . . .
Izvorni kod 8.4
Funkcija koja vraca razlicite tipove . . . . . . . . . . . . . . . . . . . . . . . . . .
Izvorni kod 8.5
Funkcija koja vraca vie vrijednosti korsiteci tuple . . . . . . . . . . . . . . . .
Izvorni kod 8.6
Funkcija sa zadanim argumentom . . . . . . . . . . . . . . . . . . . . . . . . . .
Izvorni kod 8.7
Funkcija sa *args i **kwargs argumentima . . . . . . . . . . . . . . . . . . . . .
Izvorni kod 8.8
*args i **kwargs argumenti prilikom poziva funkcije . . . . . . . . . . . . . . .
Izvorni kod 8.9
Primjer anonimne funkcije u ugnjedenoj definiciji . . . . . . . . . . . . . . . .
Izvorni kod 9.1
Definicija klase . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Izvorni kod 9.2
Primjer definicije klasnih (globalnih) atributa . . . . . . . . . . . . . . . . . . . .
Izvorni kod 9.3
Primjer definicije objektnog atributa . . . . . . . . . . . . . . . . . . . . . . . . .
Izvorni kod 9.4
Inicijalizacija objekta . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Izvorni kod 9.5
Definicija metode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Izvorni kod 9.6
Preopterecivanje funkcije print . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Izvorni kod 9.7
Izvorni kod 9.8
Izvorni kod 9.9

Naslijedivanje
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Izvorni kod 9.10

Naslijedivanje
override __init__metode . . . . . . . . . . . . . . . . . . . . . . .
Izvorni kod 10.1
Primjer formatiranja numerickih podataka sa tupleom i dictionaryjem . . . . .
Izvorni kod 10.2
Primjer formatiranja numerickih podataka sa tupleom i dictionaryjem . . . . .
Izvorni kod 10.3
Primjer formatiranja numerickih podataka za ispis u stupcima . . . . . . . . .
Izvorni kod 11.1
Primjer kreiranja tekstualne datoteke . . . . . . . . . . . . . . . . . . . . . . . .
gfx/RadSaDatotekama/info.txt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
gfx/RadSaDatotekama/test.txt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Izvorni kod 11.2

Citanje
sadraja tekstualne datoteke . . . . . . . . . . . . . . . . . . . . . . . . .
Izvorni kod 11.3
Pristupanje sadraju datoteke preko iteriranja po file objektu . . . . . . . . .
gfx/RadSaDatotekama/test.txt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Izvorni kod 11.4
Dohvacanje trenutne pozicije u datoteci . . . . . . . . . . . . . . . . . . . . . . .
Izvorni kod 11.5
Kopiranje, micanje i preimenovanje datoteka . . . . . . . . . . . . . . . . . . . .
Izvorni kod 12.1
Primjer mjerenja vremena izvravanje algoritma . . . . . . . . . . . . . . . . . .
Izvorni kod 12.2

Primjer upotrebe Timer klase za mjerenje vremena izvodenja
funkcije . . . . .
Izvorni kod 13.1
Upotreba dbg modula . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Izvorni kod 14.1
Spremanje elemenata dijagonale matrice u vektor . . . . . . . . . . . . . . . . .
Izvorni kod 15.1
Osnovne informacije o NumPy polju . . . . . . . . . . . . . . . . . . . . . . . .
Izvorni kod 15.2
Manipulacije sa poljima pomocu indeksa . . . . . . . . . . . . . . . . . . . . . .
Izvorni kod 16.1
Mijenjanje dimenzija polja . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Izvorni kod 16.2
Mijenjanje dimenzija polja . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Izvorni kod 16.3
Transponiranje matrica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Izvorni kod 17.1
Sadraj datoteke data.txt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Izvorni kod 17.2
Ucitavanje iz tekstualne datoteke . . . . . . . . . . . . . . . . . . . . . . . . . . .
Izvorni kod 18.1
Rjeavanje sustava linearnih jednadbi . . . . . . . . . . . . . . . . . . . . . . .
Izvorni kod 19.1
Zadavanje polinoma kao poly1d objekta . . . . . . . . . . . . . . . . . . . . . .
Izvorni kod 20.1
Jednostavan graf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Izvorni kod 20.2
Kontrola linija i markera . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Izvorni kod 20.3
Naprednija kontrola linija i markera . . . . . . . . . . . . . . . . . . . . . . . . .
Izvorni kod 20.4
Prikaz legende na grafu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Izvorni kod 20.5
Primjer crtanja podgrafova . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Izvorni kod 20.6
Primjer crtanja grafa u polarnom koordinatnom sustavu . . . . . . . . . . . . .
Izvorni kod 21.1
Primjer vizualizacije izolinija . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Izvorni kod 22.1
Jednostavan primjer animacije . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Izvorni kod 23.1
Primjer pronalaenja nultocke funkcije metodom biskecije . . . . . . . . . . . .
Izvorni kod 23.2
Primjer pronalaenja nultocke funkcije metodom tangente . . . . . . . . . . . .
Izvorni kod 24.1
Primjer razlicitih 1D interpolacija . . . . . . . . . . . . . . . . . . . . . . . . . .
8
9
16
20
23
25
26
26
27
29
29
29
29
30
30
31
32
32
32
33
35
36
36
36
37
37
38
38
40
44
44
45
46
46
48
49
50
51
52
55
56
56
59
60
60
61
61
61
61
62
64
65
70
76
79
80
81
81
82
83
83
85
87
91
93
95
101
101
102
107
109
114
116
119
Popis izvornog koda
Izvorni kod 24.2

Primjer linearne i kubicne 2D interpolacije . . . . . . . . . . . . . . . .
Izvorni kod 25.1
Primjer linearne regresije . . . . . . . . . . . . . . . . . . . . . . . . . .
gfx/RjesavanjeSustavaLinJed/A.txt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
gfx/RjesavanjeSustavaLinJed/B.txt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Izvorni kod 26.1
Primjer naivne Gaussove eliminacije . . . . . . . . . . . . . . . . . . . .
Izvorni kod 26.2
Primjer LU dekompozicije . . . . . . . . . . . . . . . . . . . . . . . . . .
Izvorni kod 27.1

Primjer racunanja odredenog
inegrala pomocu trapezne formule . . .
Izvorni kod 27.2
Upotreba Simpsonove 1/3 formule . . . . . . . . . . . . . . . . . . . .
Izvorni kod 27.3
Numericko integriranje pomocu quad funkcije . . . . . . . . . . . . . .
Izvorni kod 28.1
Primjer rjeavanja obicnih diferencijalnih jednadbi 1. reda. . . . . . .
Izvorni kod 29.1
Strujanje u pravokutnom kanalu . . . . . . . . . . . . . . . . . . . . . .
Izvorni kod 30.1
Rjeavanje elasticne linije savijanja . . . . . . . . . . . . . . . . . . . . .
Izvorni kod 32.1
Rjeavanje problema progiba ploce pomocu metode konacnih razlika
Izvorni kod 33.1

Primjer rjeavanje provodenja
topline kroz tap pomocu metode linija
Izvorni kod 35.1
Primjer rjeavanja LP problema pomocu modula PuLP . . . . . . . . .
Izvorni kod 35.2
Rjeavanje problema transportnog zrakoplova . . . . . . . . . . . . . .
Izvorni kod 36.1
Primjer 2D optimizacije Nelder-Mead metodom . . . . . . . . . . . . .
Izvorni kod 37.1
Primjer simuliranog kaljenja pomocu modula inspyred . . . . . . . . .
Izvorni kod 38.1
Particle Swarm Optimization na primjeru Rastrigin funkcije . . . . . .
Izvorni kod 39.1
Optimizacija Rastrigin funkcije pomocu DEAP modula . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
120
123
127
127
128
128
132
134
135
139
147
152
158
162
170
172
177
181
186
190
xi
INDEKS
%, 55
alpha, 107
Amoeba, 175
and, 20
anonimne funkcije, 39
append, 15, 82
arange, 74
aritmeticki operatori, 19
array, 73
as, 9
atributi, 44
bisect, 113
bisekcija, 113
break, 30
brent, 116
Brentova metoda, 116
bvp1lg, 152
capitalize, 14
center, 14
class, 44, 4749, 51
clock, 64
close, 59
closure, 39
cmath, 63
coding, 8
color, 94
colormap, 105
continue, 31
contour, 105
contourf, 105
copy, 62
count, 13, 15
datoteke, 59
DEAP, 190
debug, 67, 69
decimal, 64
decode, 14
def, 35
del, 11, 15
delete, 82
diag, 76
dpi, 96
draw, 103
easy_install, 4
elasticna linija, 151
elif, 27
Elipticke parcijalne diferencijalne jednadbe, 157
else, 26, 30
encode, 14
endswith, 13
enumerate, 33
error, 68
Euler-Bernoullijeva jednadba, 151
Eulerova metoda, 139
evolucijski algoritmi, 189
exception, 68
expandtabs, 13
extend, 15
eye, 76
ffmpeg, 199
figsize, 96
figure, 96
file, 59
find, 13
flatten, 81
for, 29
xii
format, 57
from, 9
funkcije, 35
GA, 189
geneticki algoritmi, 189
genfromtxt, 84
globalni atributi, 44
grid, 100
griddata, 120
hidraulicki skok, 146
id, 21
if, 25
import, 8
in, 21
indeksi, 79
index, 13, 15
input, 24
insert, 15, 82
inspyred, 186
integriranje, 131
interp1d, 119
interp2d, 120
interpolacija, 119
is, 21
is not, 21
isalnum, 14
isalpha, 14
isdigit, 14
islower, 14
isspace, 14
istitle, 14
isupper, 14
izolinije, 105
join, 14
Kate, 6
label, 95
lambda, 39
lambda funkcije, 39
legend, 100
legenda, 100
len, 15
linearno programiranje, 169
linspace, 74
list, 14
ljust, 14
loadtxt, 83
logicki operatori, 20
lower, 14
lstrip, 14
LU dekompozicija, 128
M krivulje, 147
Manningov koeficijent trenja, 143
Manningova formula, 142, 143
mapa boja, 105
marker, 94
markeredgecolor, 94
markeredgewidth, 94
markerevery, 94
markerfacecolor, 94
markerfacecoloralt, 94
markersize, 94
math, 63
matrica sustava, 85
meshgrid, 77, 105
metoda Gaussove eliminacije, 127
metoda linija, 161
metoda sekante, 116
INDEKS
metoda tangente, 115

metode, 46
modul, 8
move, 62
naslov, 100
ndarray, 73
ndim, 79
Nelder-Mead metoda, 175
nestacionarno strujanje, 141
neuniformno strujanje, 141
newton, 115
Newton-Raphsonova metoda, 115
Newtonova metoda, 115
normalna dubina, 144
not, 20
not in, 21
objektni atributi, 45
objektno orijentirano programiranje, 43
odeint, 139
ones, 75
ones_like, 75
open, 59
open channel flow, 141
operatori dodjeljivanja, 20
or, 20
otvoreni vodotok, 141
Parcijalne diferencijalne jednadbe, 155
Particle Swarm Optimization, 185
partition, 14
pdb, 67, 69
perimetar, 141
pip, 4
plot, 91
polinomi, 87
poly1d, 87
pop, 15
print, 23
printf, 23
prozirnost, 107
PSO, 185
PuLP, 170
PyDev, 5
quad, 134
range, 15
ravel, 81
raw_input, 24
read, 60
readline, 60
readlines, 60
regresija, 123
rekurzija, 40
rekurzivne funkcije, 40
relacijski operatori, 19
remove, 15
rename, 62
replace, 13
reshape, 81
resize, 82
return, 36
reverse, 15
rfind, 13
rindex, 13
rjust, 14
rpartition, 14
rsplit, 14
rstrip, 14
Runge-Kutta metode, 139

S krivulje, 147
savetxt, 84
secant, 116
seek, 61
set, 18
setuptools, 4
shape, 79
show, 91
shutil, 62
simboli, 8
simps, 134
Simpsonova pravila, 133
Simpsonove formule, 133
simulated annealing, 181
simulirano kaljenje, 181
size, 79
skupovi, 18
solve, 85
sort, 15
spines, 98
spline interpolacija, 119
split, 14
splitlines, 14
Spyder, 5
squeeze, 81
stacionarno strujanje, 141, 142
startswith, 13
str, 13
string, 13
strip, 14
subplot, 101
sustav linearnih jednadbi, 127
swapcase, 14
tail, 199
tell, 61
time, 64
Timer, 65
title, 14, 100
translate, 13
trapezna formula, 131
trapz, 131
trim_zeros, 82
type, 12
ugnjedena definicija funkcije, 39
uniformno strujanje, 141, 144
unique, 82
upper, 14
vektor slobodnih c lanova, 85
Vrijeme izvravanja, 64
while, 30
write, 59
writelines, 59
xlabel, 96
xlim, 96
xticks, 97
ylabel, 96
ylim, 96
yticks, 97
zeros, 75
zeros_like, 75
zfill, 14
zip, 32
xiii
ACRONYMS
DRY
Dont Repeat Yourself
API
Application Programming Interface
UML
Unified Modeling Language
xiv
Dio I
OSNOVE PYTHONA
Python je skriptni programski jezik opce namjene.
UVOD
Zato Python? Postoje mnogi razlozi zato odabrati Python kao inenjerski
alat
? Odlican za pocetnike a istodobno mocan za strucnjake
? Skalabilan, pogodan za velike projekte, kao i one male
? Omogucuje brz razvoj
? Cross-platform, omogucuje razvoj i izvravanje koda na gotovo svim
platformama i arhitekturama
? Ugradiv u kodove pisane u drugim programskim jezicima
? Proiriv sa drugim programskim jezicima
? Objektno orjentiran
? Uredna i elegantna sintaksa
? Stabilan
? Bogatstvo dostupnih paketa i biblioteka
? Specijelizirani paketi za numeriku, statistiku, obradu podataka i vizualizacije
? Otvoreni besplatni kod koji odrava velika zajednica programera i
znanstvenika
1.1
1.1.1
instalacija
Instalacija na Linux platformi
Gotovo sve Linux distribucije sade Python pakete u osnovnim repozitorijima, ali i vcina distribucija ima inicijalno instaliran Python.
Na openSUSE distribuciji, Python se moe instalirati jednostavnom naredbom:
sudo zypper in python
Nakon instalacije Pythona, moemo provjeriti koja je putanja python izvrne

datoteke
user@machine:~> type python
python is /usr/bin/python
1.1.2
Instalacija na Windows platformi
Za instalaciju Pythona na Windows platformi potrebno je preuzeti instalacijsku datoteku sa http://www.python.org. Nakon preuzimanja, pokretanjem insta
lacijske datoteke zapocinje isntalacijki program koji omogucuje uredivanje
postavki Python instalacije.
Uobicajena je instalacija Pythona zajedno sa dodatnim paketima, na Windows platformi, preko neke od dostupnih Python distribucija (vidi poglavlje
1.2.2.1).
uvod
1.2
dodatni paketi
Velika snaga Pythona je dostupnost velikog broja paketa raznih namjena. Za

inenjerske potrebe, potrebni su dodatni paketi koji omogucavaju matricni
racun, numericke metode, statisticku obradu podataka, vizualizacije, izradu
animacija i druge specijalizirane mogucnosti.
Osnovni paketi, koji c e biti koriteni u ovoj skripti, su:
? Numpy (http://www.numpy.org/),
? SciPy (http://www.scipy.org),
? matplotlib (http://matplotlib.org/) i
? IPython (http://ipython.org/).
Za instalaciju dodatnih python paketa postoje alati za upravljanje Python
paketima. Najpoznatiji su easy_install, koji dolazi sa vecinom Python distribucija te pip. pip se moe instalirati pomocu easy_install-a:
user@machine:~> sudo easy_install pip
1.2.1
Dodatni paketi na Linux platformi
Za instalaciju dodatnih paketa na openSUSE distribuciji pokrenite naredbu:

user@machine:~> sudo zypper in python-numpy python-scipy \\
python-matplotlib IPython
1.2.2
1.2.2.1
Dodatni paketi na Windows platformi

Python distribucije
Python distribucije su objedinjane instalacije pythona, raznih dodatnih paketa te c esto i tekstualnih editora ili razvoijnih okruenja. Distribucije su
vecinom ciljane za Windows platformu zbog neprakticne viestruke instalacije svakog pojedinog softwarea.
Neke od najpopularnijih Python distribucija su:
? pythonxy (http://code.google.com/p/pythonxy/)
? ActivePython (http://www.activestate.com/activepython)
? Entought Python (http://www.enthought.com/python/)
? winpython (http://code.google.com/p/winpython/)
? PortablePython (http://portablepython.com/)
1.2.3
Instalacija pomocu upravitelja paketa
Python upravitelji paketa omogucuju jednostavno instalaciju, osvjeavanje

ili deinstalaciju raznih Python paketa. Iako upravitelji paketa nisu dio Pythona, c esto bar jedan upravitelj dolazi sa osnovnom instalacijom Pythona.
Valja izdvojiti dva upravitelja python paketa:
? setuptools https://pypi.python.org/pypi/setuptools
? pip https://pypi.python.org/pypi/pip
1.3 editori i razvojna okruenja
Primjer instalacije paketa pomocu upravitelja setuptools sa naredbom easy_install:

user@machine:~> sudo easy_install ime_paketa
Primjer instalacije paketa sa naredbom pip:

user@machine:~> sudo pip install ime_paketa
1.3
editori i razvojna okruenja
Python koristi pokrece kod iz obicnih tekstualnih datoteka koje je moguce
uredivati
u mnogim tekstualnim editorima.
Razvojna okruenja (eng. Integrated Development Environment, IDE), osim
to omogucavaju uredivanje
koda, sadre niza alata za laki i bri razvoj kao
to su jednostavno pokretanje koda iz IDE-a, debug-iranje koda, pracenje
ispisa i dr.
1.3.1
Spyder
Spyder (http://code.google.com/p/spyderlib/) je interaktivno razvojno okruenje za

Python namjenjeno za znastvenu i inenjersku primjenu. Spyder je dostupan
za vecinu platformi.
Slika 1.1: Spyder razvojno okruenje
1.3.2
PyDev
PyDev (http://pydev.org/) je dodatak za Eclipse (http://www.eclipse.org/) razvojno

sucelje koji nudi mogucnosti za rad sa Pythonom.
uvod
1.3.3
Kate
Kate (http://kate-editor.org/) je mocan tekstualni editor, iako radi i na Windows

platformi, primarno je namjenjen za Linux platformu.
Na openSUSE-u, Kate se moe instalirati naredbom:
user@machine:~> sudo zypper in kate
Slika 1.2: Kate tekstualni editor
PYTHON LJUSKA I .PY SKRIPTE
Python je interpretirani jezik, a jednostavni Python izrazi mogu se izvoditi

u interaktivnom programskom okruenju pod nazivom ljuska.
2.1
pokretanje pythona
Najjednostavniji nacin za otvaranje Python ljuske (eng. shell) na Windows

platformi je pokrenuti IDLE, dok je ne Linux platformi dovoljno pokrenuti
Python naredbu u terminalu/konzoli. Nakon pokretanja Pythona prikazuju
se osnovne informacije o Pythonu (verzija) te tzv. prompt koji je simboliziran
sa tri strelice u desno (> > >).
user@machine:~> python
Python 2.7.3 (default, Apr 14 2012, 08:58:41) [GCC] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>>
2.2
python ljuska kao kalukulator
Python ljuska odmah izvrava uneene naredbe nakon pritiska na tipku

Enter (Return). Najjednostavniji Python izrazi su matematicke operacije pomocu kojih moemo koristiti Python ljusku kao kalkulator. Izracun te ispis
rezultata matematickih izrazi deava se u novom retku terminala ili IDLE-a:
>>> 1+1
2
>>>
Matematicke operacije, naravno, moemo medusobno

kombinirati i pri tome
koristiti zagrade za definiranja redoslijeda operacija.
>>> 1/5
0
>>> 1./5.
0.2
>>> 1./(5.+2)
0.14285714285714285
>>>
Ljuska moe raditi i bazicne operacije sa tekstom tj. nizovima znakova (string).
>>> "Kratki " + "probni " + "tekst."
Kratki probni tekst.
>>>
2.3
python skripte
Python skripte su tekstualne datoteke s ekstenzijom *.py koje sadre Python

kod. Izvravanje .py skripte, zapravo, se pokrece linija po linija kao da se je
unosi u Python ljusku. Ovo je ocita prednost, pogotovo prilikom pokretanja
vie od nekoliko naredbi.
Datoteke sa ekstenzijom .py, osim kao skripte, koriste se i za definiranje
vlastitih modula to je detaljnije opisano u poglavlju 2.4.
Oprez! Prilikom
dijeljenja cijelih
brojeva rezultat je
cijeli broj! Kod
decimalnih brojeva
obavezno koristiti
decimalnu tocku.
python ljuska i .py skripte
Osnovni nacin pokretanja python skripte je pokretanje Pythona sa specificiranim .py fajlom:
user@machine:~$ python imeskripte.py
Nakon zavretka
izvodenja
skripte
pomocu python
skripta.py Python
se gasi!
Python c e se pokrenuti i izvriti kod zapisan u skripti.

Ako je prva linija skripte:
1
#!/usr/bin/python
tada se na Unix sustavima moe izvravati u terminalu. Za pokretanje skripte

u terminalu nuno je da skripta koristi Unix oznaku za kraj reda te da ima
dozvole za izvravanje:
user@machine:~$ chmod +x imeskripte.py
Ako je .py datoteka izvrna, tada se moe direktno izvravati:

user@machine:~$ ./imeskripte.py
Na Windows sustavima datoteke s ekstenzijom *.py su kod intalacije Pythona pridruene programu python.exe. Python skripta se pokrece dvostrukim lijevim klikom mia na skriptu.
2.3.1
Upotreba posebnih znakova
Da bi se koristilo posebne znakove (npr. slova sa kvacicama ili simboli) u

stringovima, potrebno je u prvoj ili drugoj liniji skripte upisati poseban komentar:
# -*- coding: utf-8 -*-
Izvorni kod 2.1: Podrka za posebne znakove u Python skriptama

1
2
#!/usr/bin/python
# -*- coding: utf-8 -*-
3
4
5
print Sada moemo koristi slova sa kva

cicama!
print Ali i razne simbole kao to su & $
2.4
moduli
Modul je Python objekt, definiran u odredenoj

datoteci, koji sadri defini
cije varijabli, funkcija i klasa. Obicno su varijable, funkcije i klase odredenog
modula specijalizirane namjene, pa se module moe interpretirati kao grupiranje koda i najcece je taj kod slicne namjene.
u poglavlju 12.2) sadri varijable pi i e koje
Npr. modul math (obraden
predstavljaju matematicke konstante te niz matematickih funkcija kao to
su sqrt, log, pow, exp, sin, cos itd.
Da bi se objekti odredenog
modula mogli koristiti u kodu, potrebno je
ucitati (importirati) modul ili ucitati odredeni

objekt iz modula.
Ucitavanje modula vri se pomocu naredbe import c ija je osnovna sintaksa
import module_name
gdje je module_name ime modula.

Nakon to je modul ucitan, moe se koristiti objekte modula (varijable,
funkcija i klase) tako da se unese ime modula, tocka te ime objekta koji se
eli koristiti.
Jednom naredbom import moe se ucitati vie modula na slijedeci nacin:
2.4 moduli
import module1, modul2, modul3
Ucitanom modulu se moe dodijeliti novo ime. To se moe napraviti pomocu kljucne rijeci as:
import module_name as new_name
nakon c ega se modul moe koristiti pomocu novog imena.

Moduli c esto sadravaju velik broj objekata, a njihovim ucitavanjem bespotrebno se troe memorijski i procesorski resursi. Kako bi se izbjeglo ucita
vanje cijelog modula, moguce je iz odredenog

modula ucitati samo odredene
objekte:
from module_name import object_name
Ako se direktno ucita objekte iz modula, tada ih se koristiti samo preko

imena objekta. Kao i sam modul, moguce je ucitati objekt nekog modula
pod novim imenom:
from module_name import object_name as object_new_name
Za ucitavanje svih objekata odredenog

modula koristi se:
from module_name import *
Izvorni kod 2.2: Koritenje objekata modula

1
#!/usr/bin/python
2
3
4
5
6
# importiraj sys modula

import sys
print sys.platform
# ispisi platformu (operaticni sustav)
print sys.version
# ispisi verziju Pythona
7
8
9
10
11
# importiraj modul math kao m

import math as m
print m.pi
# ispisi vrijednost broja pi
print m.sin(m.pi/2.0) # ispisi vrijednost sinusa kuta pi/2
12
13
14
15
# iz modula datetime importiraj objekt date

from datetime import date
print date.today()
# ispisi danasnji datum
16
17
18
19
# iz modula random importiraj funkciju random kao nasumicni

from random import random as nasumicni
print nasumicni()
# ispisi nasumicni broj
20
21
22
23
24
25
# Importiraj sve objekte iz modula string

from string import *
print uppercase # ispis svih velikih slova
print lowercase # ispis svih velikih slova
print digits
# ispis svih znamenaka
linux2
2.7.3 (default, Apr 14 2012, 08:58:41) [GCC]
3.14159265359
1.0
2013-03-05
0.952486831091
ABCDEFGHIJKLMNOPQRSTUVWXYZ
abcdefghijklmnopqrstuvwxyz
0123456789
T I P O V I P O D ATA K A
Varijable se ne moraju explicitno deklarirati. Naime, deklaracija se deava

prilikom pridruivanja vrijednosti varijabli. Odnosno, varijable se pridruuju memorijskim lokacijama na kojima je zapisana vrijednost. Znak jednakosti = se koristi za pridruivanje vrijednosti varijablama. Na primjer:
1
#!/usr/bin/python
2
3
4
5
brojac
duljina
ime
= 100
# Integer
= 1000.0
# Float
= Hrvoje # String
6
7
8
9
print brojac
print duljina
print ime
Ovdje su 100, 1000.0 i Hrvoje vrijednosti pridruene varijablama brojac,

duljina i ime. Program c e producirati sljedeci rezultat:
100
1000.0
Hrvoje
Moguce je pridruiti jednu vrijednost u vie varijabli. Tada sve varijable

gledaju na istu memorijsku lokaciju. Odnosno:
1
2
3
4
#!/usr/bin/python
a = b = c = 1
c = 5
print a
to rezultira
1
Varijable a, b ic gledaju na istu lokaciju u memoriji u kojoj pie 1. Brojevi su

imutable varijable odnosno nepromjenjive pa kada promijenimo c=5 Python
preusmjerava varijablu c na novu lokaciju u memoriji na kojoj pie broj 5,
je moguce
a varijable a, b i dalje gledaju na isto mjesto kao i prije. Takoder
pridruiti vie vrijednosti u vie varijabli.
1
2
#!/usr/bin/python
a, b, c = 1, 2, Hrvoje
Varijablama a i b se pridruuju memorijske lokacije na kojima su zapisane

vrijednosi 1 i 2, dok je varijabli c pridruena memorijska lokacija na kojoj je
zapisana vrijednost Hrvoje.
Varijable te njihov memorijski prostor moguce je pobrisati naredbom del.
>>> a = 10
>>> print a
10
>>> del a
>>> print a
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name a is not defined
>>> b = c = 2
>>> print b, c
2 2
>>> del b
11
12
tipovi podataka
>>> print b, c
NameError: name b is not defined
>>> print c
2
Python podrava pet osnovnih tipova podataka;

? Numbers
? String
? List
? Tuple
? Dictionary
Tip podataka odredene

varijable moe se dobiti naredbom type:
>>> a=10
>>> b=11.2
>>> c=Rijeka
>>> type(a), type(b), type(c)
(<type int>, <type float>, <type str>)
3.1
brojevi
To su nepromjenjivi(immutable) tipovi podataka, odnosno promjena vrijednosti rezultira novim alociranim objektom. Numericki tip podatka se kreira
pridruivanjem vrijednosti varijabli. Odnosno
1
2
3
#!/usr/bin/python
var1 = 1
var2 = 10
je moguce pobrisati referencu na numericki objekt koristeci del

Takoder
naredbu. Sintaksa izgleda ovako:
del var1[,var2[,var3[....,varN]]]]
Primjer:
1
2
3
#!/usr/bin/python
del var
del var_a, var_b
Python podrava c etiri numericka tipa

? int
? long
? float
? complex
Nekoliko primjera oznacavanja numerickih podataka ja prikazana u Tablici
3.1.
Moguce je koristiti i malo slovo L za oznaku long, iako se takvo oznacavanje ne preporuca zbog velike slicnosti sa brojem 1.
3.2 string
int
long
float
complex
10
51924361L
0.0
3.14j
100
-0x19323L
15.20
45.j
-783
0122L
-21.9
9.322e-36j
-0490
0xDEFABCECBDAECBFBAEl
-90.
.876j
-0x260
535633629843L
-32.54e100
.6545+0J
0x69
-052318172735L
70.2-E12
4.53e-7j
13
Tablica 3.1: Primjeri oznacavanja brojeva
3.2
string
navodnika, jednostrukih
Stringovi su definirani kao slijed znakova izmedu
(apostrofi) ili dvostrukih. Jednom zadane stringove je nemoguce mijenjati jer
su stringovi, u Pythonu, nepromjenjivi (imutable) tip podatka. Niz funkcija
koje rade promjene nad string varijabama zapravo kreiraju kopije izvorne
string varijable.
Dijelove stringova (znakove ili niz znakova - string) je moguce dohvatiti
operatorima [] i [:] sa indeksima koji pocinju od 0 na pocetku stringa sve
do -1 na kraju.
Znak plus (+) oznacava spajanje (concatenation), a asterisk () je operator
ponavljanja. Odnosno:
1
#!/usr/bin/python
2
3
4
str = Hello World!

ime = "Rudi"
# zadavanje sa jednostrukim navodnicima

# zadavanje sa dvostrukim navodnicima
print
print
print
print
print
print
#
#
#
#
#
#
5
6
7
8
9
10
11
str, ime
str[0]
str[2:5]
str[2:]
str * 2
str + TEST
print
print
print
print
print
print
cijelog stringa
prvog znaka u stringu
od treceg do petog znaka
znakova od treceg do zadnjeg
stringa dva puta
concatenated string
to c e rezultirati
Hello World! Rudi
H
llo
llo World!
Hello World!Hello World!
Hello World!TEST
Nad stringovima je moguce izvoditi niz specijaliziranih operacija pomocu

funkcija koje su dostupne za varijable tipa string.
Funkcije za pretraivanje stringova:
count(sub[, start[, end]])
endswith(suffix[, start[, end]])
find(sub[, start[, end]])
index(sub[, start[, end]])
rfind(sub [,start [,end]])
rindex(sub[, start[, end]])
startswith(prefix[, start[, end]])
Funkcije za mjenjanje znakova:

expandtabs([tabsize])
replace(old, new[, count])
translate(table[, deletechars])
Iako je moguce
definirati string sa
jednostrukim i
dvostrukim
navodnicima,
preporuka je da se
koriste jednostruki
navodnici.
14
tipovi podataka
Funkcije za provjeru vrste znakova:

isalnum()
isalpha()
isdigit()
isspace()
Funkcije za rad sa velikim i malim slovima:

capitalize()
islower()
istitle()
isupper()
lower()
swapcase()
title()
upper()
Funkcije za poravnanje teksta:

center(width[, fillchar]
ljust(width[, fillchar])
rjust(width[, fillchar])
zfill(width)
Funkcije za spajanje i razdvajanje stringova:

join(seq)
partition(sep)
rpartition(sep)
split([sep [,maxsplit]])
splitlines([keepends])
rsplit([sep [,maxsplit]])
Funkcije za brisanje pocetnih i krajnjih znakova:

lstrip([chars])
rstrip([chars])
strip([chars])
Funkcije za encoding stringova:

decode([encoding[, errors]])
encode([encoding[,errors]])
3.3
Iako lista moe biti

heterogena
(sadravati razlicite
tipove podataka),
preporuka je koristiti
listu kao spremnik
homogenih podataka.
Za heterogene
podatke se preporuca
tuple (poglavlje 3.4)
liste
Lista sadri podatke odvojene zarezima i omedene

uglatim zagradama. Iako
je slicna listama u C jeziku, podaci python liste mogu biti razlicitog tipa.
Kao i kod stringova, pristupanje vrijednostima u listi je moguce pomocu
operatora [ ] i [ : ] sa indeksima koji pocinju od 0 na pocetku stringa sve
do -1 na kraju. Znak plus (+) se koristi za operator spajanja (concatenation)
stirngova, a asterisk () je operator ponavljanja
1
#!/usr/bin/python
2
3
4
list = [ abcd, 786 , 2.23, hrvoje, 70.2 ]

tinylist = [123, hrvoje]
5
6
7
8
9
10
11
print
print
print
print
print
print
list
#
list[0]
#
list[1:3]
#
list[2:]
#
tinylist * 2 #
list + tinylist
to c e rezultirati
print cijele liste

print prvog elementa liste
print od drugog do treceg elementa liste
print od treceg do zadnjeg elementa
print liste dva puta
# print concatenated lists
3.3 liste
[abcd, 786, 2.23, hrvoje, 70.2]

abcd
[786, 2.23]
[2.23, hrvoje, 70.2]
[123, hrvoje, 123, hrvoje]
[abcd, 786, 2.23, hrvoje, 70.2, 123, hrvoje]
Za manipulaciju listama c esto se koristi naredba len za provjeru broja

elemenata liste, naredbom insert se umece novi element u listu te naredba
del kojom se briu pojedini elementi iz liste.
1
#/user/bin/python
2
3
4
5
6
7
8
9
list = [2,3,4,5]
print(len(list)) #broj elemnata u listi
print list
list.insert(0,1) #umetanje elementa 1 u listu na prvu poziciju
print list
del list[-1] #brisnje zadnjeg elementa iz liste
print list
4
[2, 3, 4, 5]
[1, 2, 3, 4, 5]
[1, 2, 3, 4]
Naredbom range moguce je stvoriti listu brojeva u aritmetickom nizu to

je c esto potrebno kod koritenja for petlje (poglavlje 7.1). Sintaksa naredbe
range je
range(stop),
range(start, stop),
range(start, stop, step),
gdje je start prvi element, stop je gornja granica i step je korak aritmetickog niza.
1
#/user/bin/python
2
3
4
5
6
7
8
list=range(7) # aritmeticki niz 0,..,6

print list
list = range(2,7) # aritmeticki niz 2,..,6
print list
list = range(0,7,2) # aritmeticki niz s korakom 2
print list
[0, 1, 2, 3, 4, 5, 6]
[2, 3, 4, 5, 6]
[0, 2, 4, 6]
Naredbe za dodavanje elemenata u listu su:

append(x)
insert(i, x)
extend(L)
append dodaje element x na kraj liste, insert ubacuje element x na poziciju

i a extend proiruje postojecu listu sa listom L.
Naredbe za brisanje elemenata iz liste su:

remove(x)
pop(i)
del L[index]
remove brie prvi element koji ima vrijednost x a pop brie element na poziciji i. Naredba del L[index] brie element list L na indeksu index.
Osim funkcija za brisanje i dodavanje elemenata, Python liste imaju jo
ugradenih
prakticnih funkcija. index vraca indeks prvog elementa koji ima
15
16
tipovi podataka
vrijednost x, count prebrojava sve elemente koji su jednaki x, sort sortira
elemente liste a reverse rasporeduje

elemente u obrnutom redosljedu od
inicijalnog.
index(x)
count(x)
sort()
reverse()
Izvorni kod 3.1: Dodavanje i brisanje elemenata liste

1
2
ljudi = [Marko, Mirela, Luka]

nadljudi = [Chuck,Arnold,Steven,Silvester]
3
4
5
6
7
8
9
ljudi.append(Igor)
print ljudi
nadljudi.insert(1,Anita)
print ljudi
nadljudi.extend(ljudi)
print nadljudi
10
11
12
13
14
15
16
nadljudi.pop(1)
print nadljudi
nadljudi.remove(Igor)
print nadljudi
del nadljudi[4:]
print nadljudi
17
18
19
20
print ljudi.index(Marko)
ljudi.append(Marko)
print ljudi.count(Marko)
21
22
23
24
25
nadljudi.sort()
print nadljudi
nadljudi.reverse()
print nadljudi
[Marko, Mirela, Luka, Igor]
[Marko, Mirela, Luka, Igor]
[Chuck, Anita, Arnold, Steven, Silvester, Marko, Mirela,
Luka, Igor]
[Chuck, Arnold, Steven, Silvester, Marko, Mirela, Luka,
Igor]
[Chuck, Arnold, Steven, Silvester, Marko, Mirela, Luka]
[Chuck, Arnold, Steven, Silvester]
0
2
[Arnold, Chuck, Silvester, Steven]
[Steven, Silvester, Chuck, Arnold]
3.4
tuple
Tuple je tip podatke slican listi. Sastoji se od vrijednosti odvojenih zarezom
i za razliku od listi omeden

zagradama (). Python doputa fleksibilnost
izostavljanja zagrada prilikom definiranja tuplea.
Postoji mnogo slicnosti sa listama, ali i nekoliko temeljnih razlika:
? pristupanje elementima liste i tuplea vri se na identican nacin (preko
indeksa)
? i list i tuple su iterabilni
? lista moe mijenjati broj elemenata i vrijednosti elemenata, dok tuple
ne moe
3.5 dictionary
? nad tupleom se ne mogu provoditi operacije koje mjenjaju sam tuple

(sort, remove i sl.)
1
#!/usr/bin/python
2
3
4
tuple = ( abcd, 786 , 2.23, hrvoje, 70.2

tinytuple = (123, hrvoje)
5
6
7
8
9
10
11
print
print
print
print
print
print
tuple
tuple[0]
tuple[1:3]
tuple[2:]
tinytuple * 2
tuple + tinytuple
#
#
#
#
#
#
print liste
prints prvog elementa liste
print od drugog do treceg elementa liste
print od treceg do zadnjeg elementa
print liste dva puta
print liste nastale spajanjem dvije liste
12
13
14
istotuple = 2, True, teskt

print istotuple
# Zadavanje tuplea bez zagrada
to c e rezultirati
(abcd, 786, 2.23, hrvoje, 70.200000000000003)
abcd
(786, 2.23)
(2.23, hrvoje, 70.200000000000003)
(123, hrvoje, 123, hrvoje)
(abcd, 786, 2.23, hrvoje, 70.200000000000003, 123, hrvoje)
(2, True, teskt)
Sljedeci kod c e producirati greku u liniji 5, jer smo pokuali promijeniti

vrijednost u tupleu
1
#!/usr/bin/python
2
3
4
5
6
tuple = ( abcd, 786 , 2.23, hrvoje, 70.2 )

list = [ abcd, 786 , 2.23, hrvoje, 70.2 ]
tuple[2] = 1000
# greska
list[2] = 1000
# ok
Tuple se vrlo c esto koristi za viestruko dodjeljivanje:

>>> a, b, c = 3, 10, neki tekst
>>> print a
3
>>> print b
10
>>> print c
neki tekst
to se c esto koristi prilikom vracanja vie vrijednosti iz funkcije (poglavlje

8.2)
3.5
dictionary
Dictionary moemo smatrati jednostavnim pridruivanjem odnosno preslikavanjem svih elemenata jednog skupa elementima drugog skupa.
1
#!/usr/bin/python
2
3
4
5
dict = {}
dict[jedan] = Ovo je jedan
dict[2]
= Ovo je dva
6
7
tinydict = {ime: hrvoje,code:6734, odjel: admin}
8
9
10
11
print dict[jedan]
print dict[2]
print tinydict
# print vrijednosti jedan

# print vrijednosti za 2
# print cijelog dictionary
17
18
tipovi podataka
12
13
print tinydict.keys()
# print svih kljuceva
print tinydict.values() # print svih vrijednosti
to c e rezultirati
Ovo je jedan
Ovo je dva
{odjel: admin, code: 6734, ime: hrvoje}
[odjel, code, ime]
[admin, 6734, hrvoje]
Objekti tipa dict nemaju poredane elemente.

3.6
skupovi
>>> basket = [apple, orange, apple, pear, orange, banana]

>>> fruit = set(basket)
# create a set without duplicates
>>> fruit
set([orange, pear, apple, banana])
>>> orange in fruit
# fast membership testing
True
>>> crabgrass in fruit
False
>>> # Demonstrate set operations on unique letters from two words
...
>>> a = set(abracadabra)
>>> b = set(alacazam)
>>> a
# unique letters in a
set([a, r, b, c, d])
>>> a - b
# letters in a but not in b
set([r, d, b])
>>> a | b
# letters in either a or b
set([a, c, r, d, b, m, z, l])
>>> a & b
# letters in both a and b
set([a, c])
>>> a ^ b
# letters in a or b but not both
set([r, d, b, m, z, l])
O P E R AT O R I
Operatori su osnovni dio Pythona i omogucuju operacije na varijablama

(operandima). Najcece se povezuju sa algebarskim matematickim operaci
jama, medutim
operatori mogu biti i ne matematicke naravi.
Python operatore moemo podjeliti prema namjeni:
? Aritmeticki operatori
? Relacijski operatori ili operatori usporedivanja

? Operatori dodjeljivanja
? Logicki operatori
? Bitovni operatori
? Clanski
operatori
? Operatori identiteta
ili s obzirom na broj operanada:
? Unarni operatori (jedan operand)
? Binarni operatori (dva operanada)
4.1
aritmeti cki
operatori
Aritmeticki operatori omogucuju osnovne matematicke operacije na brojevima. Rezultat aritmetickog operatora je uvijek broj tj. varijabla tipa float
ili int, ovisno o tipovima operanada. Bitno je napomenuti da je tip rezultata
aritmetickih operacija uvijek vieg tipa operanada.
Operator
Opis
Primjer za x=9.0 i y=2.0
Zbrajanje
x+y daje 11
Oduzimanje
x-y daje 7
Mnoenje
x*y daje 18
Dijeljenje
x/y daje 4.5
Ostatak dijeljenja
x%y daje 1
//
Cjelobrojno dijeljenje
x//y daje 4
**
Potenciranje
x**y daje 81
Tablica 4.1: Aritmeticki operatori
4.2
relacijski operatori ili operatori usporeivanja)
Relacijski operatori omogucavaju usporedivanje

vrrijednosti varijabli. Rezultat relacijskih operatora je varijabla tipa bool i moe poprimiti vrijednosti
(True ili False).
19
20
operatori
Operator
Opis
==
Jednakost
x==y daje False
!=
Nejednakost, razlicitost
x!=y daje True
<>
Nejednakost, razlicitost
x<>y daje True
>
Vece
x>y daje True
>=
Vece ili jednako
x>=y daje True
<
Manje
x<y daje False
<=
Manje ili jednako
x<=y daje False
Tablica 4.2: Relacijski operatori
4.3
operatori dodjeljivanja
Operator dodjeljivanja slui za dodjeljivanje vrijednosti varijabli. Postoje,

proirenja kojima se moe kombinirati aritmeticke operatore i operator dodjeljivanja.
Operator
Opis
Dodjeljivanje
x=y dodjeljuje vrijednost 2.0

varijabli x
+=
Zbrajanje i dodjeljivanje
x+=y je isto to i x=x+y, x poprima vrijednost 11.0
-=
Oduzimanje i dodjeljivanje
x-=y je isto to i x=x-y, x poprima vrijednost 7.0
*=
Mnoenje i dodjeljivanje
x*=y je isto to i x=x*y, x poprima vrijednost 18.0
/=
Dijeljenje i dodjeljivanje
x/=y je isto to i x=x/y, x poprima vrijednost 4.5
%=
Ostatak dijeljenja i dodjeljivanje
x%=y je isto to i x=x%y, x poprima vrijednost 1.0
//=
Cjelobrojno dijeljenje i dodjeljivanje
x//=y je isto to i x=x//y, x

poprima vrijednost 4.0
**=
Potenciranje i dodjeljivanje
x**=y je isto to i x=x**y, x

poprima vrijednost 81.0
Tablica 4.3: Operatori dodjeljivanja
4.4
logi cki
operatori
Logicki operatori and, or i not omogucavaju operacije na bool varijablama.

and i or su binarni operatori logicko i i logicko ili dok je not unarni operator
logicko ne. Rezultat logickih operatora je uvijek bool varijabla.
Izvorni kod 4.1: Primjer kombiniranje operatora dodjeljivanja, operatora usporedivanja

i logickih operatora
1
#! /usr/bin/python
2
3
4
a = 10
b = 1

4.5 clanski
operatori
a and b
a or b
not b
True
True
True
True
False
True
False
False
True
True
False
True
False
True
False
False
False
False
Tablica 4.4: Logicki operatori
c = 15
6
7
8
d = a < b
print d
9
10
11
e = a > b and c > b

print e
12
13
14
f = a > c or not b > c

print f
False
True
True
4.5
clanski
operatori
Clanski
opratori slue za odredivanje
pripadnosti odredenoj
listi. Osnovni
c lanski operator je operator in, i moe se proiriti sa logickim operatorom
not te rvot oprator not in. Rezultat c lanskih opratora je bool varijabla koja
daje saznanje da li zadani element pripada listi ili ne pripada list.
>>> a
>>> 2
True
>>> 3
False
>>> 5
True
= [1, 2, 3, 8, 6]
in a
4.6
operatori identiteta
not in a
not in a
Operatori identita usporeduju

da li su Python objekti zapisani na istom
mjestu u memoriji. Postoji operator is i is not koji usporeduju

id Python
objekta. id Python objekta se moe dohvatiti naredbom id.
>>> a=[1, 2, 3]
>>> b=[1, 2, 3]
>>> id(a)
139967012502704
>>> id(b)
139967012502848
>>> a is b
False
>>> b=a
>>> id(b)
139967012502704
>>> a is b
21
O S N O V N E N A R E D B E Z A U N O S I I S P I S P O D ATA K A
5.1
print
Iz Python koda moguce je ispisivati poruke u konzolu pomocu naredbe

print. Osnovna sintaksa za ispisivanje je
print variable
gdje je variable ima varijable c iju vrijednost se eli ispisati.

Moguce je ispisivati vrijednosti vie varijabli:
print variable1, variable2
Naprednije mogucnosti ispisa moguce je kontrolirati pomocu ubacivanja

vrijednosti varijabli u string pomocu printf formata. Simbolom % i pripada
jucim znakom za tip podatka moe se u stringu odreduju
pozicije na koje
se eli ubaciti vrijednosti varijabli, a nakon stringa i simbola % slijede imena
samih varijabli.
>>> var_a=7
>>> var_b=13.54592
>>> var_str = a iznosi %d, b iznosi %f % (var_a, var_b)
>>> print var_str
a iznosi 7, b iznosi 13.545920
Primjer
Opis
%s
String
%d
Cijeli broj
%f
Decimalni broj
%.2f
Decimalni broj sa dvije decimale
%10.3d
Decimalni broj sa dvije decimale i rezerviranih najmanje 10 znakova

Tablica 5.1: printf formatiranje
Vie o oblikovanju stringova pomocu operatora % opisano je u poglavlju

10.1.
Izvorni kod 5.1: Razliciti primjeri ispisa
1
2
print Ispisi ovo na ekranu!

print Ispisi + jos + ovo.
3
4
5
6
7
8
9
10
a=12
type(a)
print a
print a=, a
print a= + str(12)
print Ovo je a:%d % (a)
print Ovo je a:%.2d % (a)
11
12
13
14
15
b=15.365982
type(b)
print Ovo je b:,b
print Ovo je b:+str(b)
23
24
osnovne naredbe za unos i ispis podataka
16
17
18
print Ovo je b:%f % (b)

print Ovo je b:%.2f % (b)
print Ovo je b:%10.3f % (b)
19
20
print ovo je a: %d a ovo je b: %f % (a,b)
21
22
23
24
print a = {broj_a}, b = {broj_b}.format(broj_a = a, broj_b = b)

print a = {broj_a}, b = {broj_b:.2f}.format(broj_a = a, broj_b = b)
print a = {broj_a:8d}, b = {broj_b:8.2f}.format(broj_a = a, broj_b = b)
Ispisi ovo na ekranu!
Ispisi jos ovo.
12
a= 12
a=12
Ovo je a:12
Ovo je a:12
Ovo je b: 15.365982
Ovo je b:15.365982
Ovo je b:15.365982
Ovo je b:15.37
Ovo je b:
15.366
ovo je a: 12 a ovo je b: 15.365982
a = 12, b = 15.365982
a = 12, b = 15.37
a =
12, b =
15.37
5.2
raw_input
Funkcija raw_input omogucuje unoenje vrijednosti tipa str (string).

>>> a = raw_input()
moj prvi unos
>>> print a
moj prvi unos
>>> print type(a)
<type str>
Dodatno, funkcija raw_input moe primiti poruku, u obliku stringa, koja

se ispisuje na ekarn prilikom unosa.
>>> ime = raw_input(Unesite svoje ime: )
Unesite svoje ime: Ivo
>>> print ime
Ivo
5.3
input
UVJETNA GRANANJA
Odredene
naredbe ili djelove koda moguce je izvravati ili preskociti ovisno
o vrijednosti postavljenog logickog uvjeta.
6.1
if
Ako uvijet
nije zadovoljen
Logiki
uvjet
Ako je uvjet
zadovoljen
Naredbe
Slika 6.1: Dijagram toka if naredbe
Slika 6.1 prikazuje jednostavno grananje u programskom kodu.

Osnovna sintaksa if naredbe je
if condition : command
Navedeni izraz uvjetuje izvravanje naredbe command (ili vie naredbi) na

temelju logickog uvjeta condition. Zadane naredbe c e se izvriti samo ako
je logicki uvijet zadovoljen.
Izvorni kod 6.1: Jednostavan primjer upotrebe if naredbe
1
#!/usr/bin/python
2
3
4
5
a = input("a: ")
if a < 0: a = -a
print a
Pokretanjem Izvornog koda 6.1 i utipkavanjem pozitivnog broja ispie se

utipkani broj:
user@machine:~> python if_01.py
a: 5
5
Medutim,
utipkavanjem negativnog broja zadovoljava se postavljeni logicki
uvjet i izvri se operacija a = -a te se potom ispie pozitivna vrijednost
utipkanog broja:
a: -11
11
U slucaju kad postoji vie naredbi uvjetovanih istim logickim uvjetom,

naredbe moemo objediniti pod jednim uvjetom te ih odvojiti sa tockazarezom (;). Ako su uvjetovane naredbe kompleksne ili ih ima vie, naredbe
piemo u uvucenim recima nakon if naredbe. Sve uvucene naredbe do prvog retka koji je poravnat sa if naredbom su uvjetovane.
25
26
uvjetna grananja
Izvorni kod 6.2: Pisanje sloenijeg uvjetovanog grananja

1
#!/usr/bin/python
2
3
4
5
a = 0
b = input("b: ")
c = input("c: ")
6
7
8
if b < 0: a = 1; b = -b
print a, b
9
10
11
12
13
14
15
if c < b:
a = 2
b = c - b
c = c +1
a = b + c
print a, b, c
b: -6
c: 4
1 6
3 -2 5
6.2
else
Ova naredba omogucuje sloeniji oblik grananja od naredbe if. Naredba

ima dvije grane koje se mogu izvriti u ovisnosti o uvjetu. Svaka grana/mogucnost omogucuje izvravanje pripadajucih naredbi (Slika 6.2).
Ako je uvjet
zadovoljen
Naredbe A
Logiki
uvjet
Ako uvijet
nije zadovoljen
Naredbe B
Slika 6.2: if-else dijagram toka
else naredba koristi se u paru sa if i slui za grananje u slucaju da uvjet

nije zadovoljen.
Sintaksa naredbe je:
if condition : command1
else: command2
Izvorni kod 6.3: Primjer upotrebe else naredbe

1
#!/usr/bin/python
2
3
4
a = input("a: ")
b = input("b: ")
5
6
7
if a < b:
b = a
6.3 elif
8
9
10
11
a = 0
else:
a = b
b = 0
12
13
print a, b
user@machine:~> python if_else_01.py
a: 1
b: 8
0 1
user@machine:~> python if_else_01.py
a: 5
b: 3
3 0
6.3
elif
Za dodatna grananja uvjetovana novim logickim uvjetima (Slika 6.3) slui

naredba elif. Iako se sa ugnjedenim grananjem moe postici isti rezultat,
elif omogucuje jednostavnije i preglednije grananje algoritma.
Naredba elif omogucuje grananje u alogritmu samo ako prethodni uvjeti
(if ili elif) nisu zadovoljeni. Treba napomenuti da se u slucaju koritenja
if-elif-else grananja uvijek izvri samo jedan set uvjetovanih naredbi.
Iz same definicije dodatnog uvjetnog grananja, naredba elif uvijek dolazi u kombinaciji sa naredbom if, te se upotrebljava u sljedecoj osnovnoj
sintaksi
if condition1 : command1
elif condition2 : command2
Kao ni u slucaju upotrebe else naredbe dodatno grananje se mora napisati u novom retku. Uobicajeno je da se naredbe koje slijede nakon uvjeta
piu u novom uvucenom retku.
Proirena upotreba ukljucuje kombinaciju vie elif naredbi:
Grananje se moe napraviti i kombinacijom sve tri navedene naredbe:

else : command2
U Izvornom kodu 6.4 napisan je jednostavan primjer grananja koristeci

navedene naredbe.
Izvorni kod 6.4: Primjer kombinacije naredbi if, elif i else
1
#!/usr/bin/python
2
3
a = input("a: ")
4
5
6
7
8
9
10
if a < 0:
print a je negativan
elif a > 0:
print a je pozitivan
else:
print a je nula
27
28
uvjetna grananja
Logiki
uvjet A
Ako je uvjet
zadovoljen
Naredbe A
Ako uvijet
nije zadovoljen
Logiki
uvjet B
Ako je uvjet
zadovoljen
Naredbe B
Ako uvijet
nije zadovoljen
Logiki
uvjet C
Ako je uvjet
zadovoljen
Naredbe C
Ako uvijet
nije zadovoljen
Naredbe D
Slika 6.3: Dijagram toka za sloeni uvjet grananja
Unosom pozitivnog broja izvrava se naredba koja je uvjetovana uvjetom

pod elif naredbom:
user@machine:~> python if_elif_else_01.py
a: 33
a je pozitivan
PETLJE
7.1
for
Naredba for koristi se za iteriranje elemenata u nekom iterabilnom objektu

(lista, tuple, string itd.). Njezina osnovna sintaksa je
for iter in list : commands
Naredbe commands izvravaju se jednom za svaki element iz niza list.

Objekt iter je iterator koji pokazuje na elemente niza list. Za razliku od
jezika C, C++ iter se ne brie nakon to for naredba zavri.
Izvorni kod 7.1: Upotreba for naredbe
1
2
3
#!/usr/bin/python
for num in range(2, 5):
print(num)
4
5
print(num)
2
3
4
4
Izvorni kod 7.2: Naredba for s listom stringova

1
2
3
4
#!/usr/bin/python
text=[ide,patka,preko,save]
for r in text:
print(r)
ide
patka
preko
save
Izvorni kod 7.3: Naredba for i stirng

1
2
#!/usr/bin/python
for c in patka: print(c)
p
a
t
k
a
Izvorni kodovi 7.2 i 7.3 prikazuju upotrebu stringova u for naredbi.

Do indeksa elemenata u nizu moe se doci koritenjem naredbi len i
range (poglavlje ??) kao to se moe vidjeti na primjeru Izvornog koda 7.4:
Izvorni kod 7.4: Naredba for s listom stringova
1
2
3
4
#!/usr/bin/python
text=[ide,patka,preko,save]
for i in range(len(text)):
print i, text[i]
29
30
petlje
0
1
2
3
ide
patka
preko
save
7.2
while
Osnovne sintaksa naredbe while je

while conditon : commands
Naredbe commands izvravaju se dokle god je uvjet condition istinit.

Naredbe
Ako je uvjet
zadovoljen
Logiki
uvjet
Ako uvijet
nije zadovoljen
Slika 7.1: Dijagram toka while petlje
Izvorni kod 7.5: Upotreba while naredbe

1
2
3
4
5
#!/usr/bin/python
i=0
while i*i<=9:
print i
i=i+1
0
1
2
7.3
break
Proirena sintaksa for ili while naredbe ukljucuje i naredbu else:

for iter in list : commands1
else : comands2
while condition : commands1
else : comands2
Nakon to se iscrpe svi elemnti niza list ili nakon to uvjet condition
postane neistinit, izvrit c e se naredbe commands2.
Naredbe specificirane u else bloku izvode se kad se petlja zavri zbog
nezadovoljavanja uvjeta sprecificiranog za while petlju ali ne i u slucaju
zavravanje tj. prekida petlje zbog break naredbe (Slika 7.2).
Izvorni kod 7.6: Upotreba else naredbe u petlji
1
2
3
4
#!/usr/bin/python
for num in range(3):
print(num)
else:print(Kraj)
7.4 continue
Break
Naredbe
Ako je uvjet
zadovoljen
Logiki
uvjet
"else" naredbe
Ako uvijet
nije zadovoljen
Slika 7.2: Dijagram toka while petlje sa else blokom
0
1
2
Kraj
Naredbom break se zavrava for ili while naredba. Na primjeru Izvornog

koda 7.7 moe se vidjeti da se nakon break naredbe ne izvri dio koda nakon
else naredbe.
Izvorni kod 7.7: Upotreba break naredbe
1
2
3
4
5
6
7
#!/usr/bin/python
i=0
while i*i<=9:
print i
i=i+1
if i==2 : break
else : print(Kraj)
0
1
7.4
continue
Naredbom continue se preskace izvravnje sljedecih naredbi u tijelu for ili

while naredbe (Slika 7.3).
Naredbe
Naredbe
Ako je uvjet
zadovoljen
continue
Logiki
uvjet
Ako uvijet
nije zadovoljen
Slika 7.3: Dijagram toka while petlje sa continue naredbom
31
32
petlje
Izvorni kod 7.8: Upotreba continue naredbe

1
2
3
4
#!/usr/bin/python
for num in range(2, 5):
if num==3:continue
print(num)
2
4
7.5
paraleleno iteriranje
Naredbom zip moguce je elemente vie listi pohraniti u jednu listu koja
sadri tupleove pripadajucih elemenata. Takva mogucnost restrukturiranja
podataka vrlo je korisna kod potrebe za istovremenim iteriranjem kroz vie
listi (Izvorni kod 7.9).
Izvorni kod 7.9: Upotreba zip naredbe
1
2
#!/usr/bin/python
# -*- coding: utf-8 -*-
3
4
5
imena = [Vlatko, Ivana, Darko, Igor]

prezimena = [Hoorvat, Bali, Copljar, Worry]
6
7
8
osobe = zip(imena, prezimena)

print osobe
9
10
11
for o in osobe:
print o
12
13
14
for i, p in osobe:
print i, p
[(Vlatko, Hoorvat), (Ivana, Bali), (Darko, Copljar), (Igor, Worry)]
(Vlatko, Hoorvat)
(Ivana, Bali)
(Darko, Copljar)
(Igor, Worry)
Vlatko Hoorvat
Ivana Bali
Darko Copljar
Igor Worry
Ukoliko liste ne sadre jednak broj elemenata, formira se lista jednake

duljine kao i najkraca lista dana kao argument u ttt naredbi.
>>> a = [1, 2, 3, 4, 5]
>>> b = [a, b, c]
>>> print zip(a, b)
[(1, a), (2, b), (3, c)]
Broj argumenta funkcije zip moe biti i vie od dva a rezultat je analogan
koritenju funkcije zip sa dva argumenta (Izvorni kod 7.10).
Izvorni kod 7.10: Upotreba zip naredbe sa vie lista.
1
2
#!/usr/bin/python
# -*- coding: utf-8 -*-
3
4
5
6
imena = [Vlatko, Ivana, Darko, Igor]

prezimena = [Hoorvat, Bali, Copljar, Worry]
visine = [1.79, 1.86, 2.10, 2.03]
7
8
9
for i, p, v in zip(imena, prezimena, visine):

print %s %s (%.2f m) % (i, p, v)
7.6 numeriranje liste
Vlatko Hoorvat (1.79 m)

Ivana Bali (1.86 m)
Darko Copljar (2.10 m)
Igor Worry (2.03 m)
7.6
numeriranje liste
Funkcija enumerate omogucuje numeraciju elemenata liste na nacin da kreira iterabilni enumerate objekt koja sadri tuplove elemenata izvorne liste te
njihve indekse. Dodatno, enumerate moe primiti argument koji ukazuje od
kojeg broj pocinje numeracija.
Izvorni kod 7.11: Numeriranje elemenata liste pomocu enumerate.
1
2
#!/usr/bin/python
# -*- coding: utf-8 -*-
3
4
X = [12.3, 18.6, 2.1, 12.3]
5
6
7
8
print Iteriranje pomocu enumerate:

for x in enumerate(X):
print x
9
10
11
12
print Kreni od 0:
for i, x in enumerate(X):
print a[%d]: %f % (i, x)
13
14
15
16
print Kreni od 1:
for i, x in enumerate(X, 1):
print a[%d]: %f % (i, x)
Iteriranje pomocu enumerate:
(0, 12.3)
(1, 18.6)
(2, 2.1)
(3, 12.3)
Kreni od 0:
a[0]: 12.300000
a[1]: 18.600000
a[2]: 2.100000
a[3]: 12.300000
Kreni od 1:
a[1]: 12.300000
a[2]: 18.600000
a[3]: 2.100000
a[4]: 12.300000
33
FUNKCIJE
Funkcije su grupirani dio koda koji izvodi odredeni

zadatak. Prednosti upotrebe funkcija su:
? Smanjenje ponavljanja istog koda
? Povecavanje modularnosti koda - raclanjivanje sloenog koda na jednostavnije djelove
? Povecanje c itkosti koda.
Rad sa funkcijama u Pythonu omogucuje veliku fleksibilnost. Funkcije
mogu biti dodijeljene varijablama, spremljene u listama i prosljedivane

kao
argumenti drugim funkcijama.
Razlikujemo dva osnovna tipa Python funkcija:
? Ugradene
funkcije su funkcije koje su dio Python programskog jezika
? Funkcije definirane od strane korisnika.
8.1
definiranje i pozivanje funkcija
Kljucna rijec def omogucuje definiranje funkije. Najjednostavnija sintaksa

koja omogucuje definiranje funkcije je:
def functionname():
commands
gdje je functionname odabrano ime funkcije a commnds je naredba ili vie naredbi koje funkcija izvrava. Prethodno definiranu funkciju moemo izvriti
pozivom te funkcije. Funkcija se poziva pomocu imena funkcije nakon kojeg
slijede zagrade.
Izvorni kod 8.1: Definicija i pozivanje jednostavne funkcije
1
#!/usr/bin/python
2
3
4
def pozdrav():
print Pozdrav!
5
6
pozdrav()
Pozdrav!
Funkciju je moguce proiriti na nacin da prima jedan ili vie argumenata.

Argumenti se definiraju pomocu imena argumenata razdvojenih zarezom u
zagradama nakon imena funkcije:
def functionname(arg1, arg2, ... , argn):
commands
Funkcija sa argumentima se poziva tako da se u zagradama nakon imena

funkcije upiu vrijednosti argumenata. Argumenti se u pozivu funkcije razdvajaju zarezom kao i prilikom definicije funkcije.
35
Poziv funkcije uvijek

mora biti nakon
definicije funkcije. Ne
moe se pozvati
funkcija koja
prethodno nije
definirana.
36
funkcije
Izvorni kod 8.2: Definicija funkcije koja prima argument

1
#!/usr/bin/python
2
3
4
def pozdrav( ime ):

print Pozdrav, ime, !
5
6
7
8
def zbroji( a, b ):
c = a + b
print a, +, b, =, c
9
10
11
pozdrav(Marko)
zbroji(2, 5)
Pozdrav Marko !
2 + 5 = 7
8.2
vra canje
vrijednosti iz funkcije
Funkcija moe vratiti vrijednost nakon poziva funkcije. Vrijednost koju funkcija vraca doslovno zamjenjuje funkciju u kontekstu u kojem je ona pozvana,
a tip vracenog podatka moe biti bilo koji Python objekt. Vracanje vrijednosti se definira naredbom return nakon koje se zaustavlja izvravanje funkcije:
def functionname(arg1, arg2, ... , argn):
commands
return value
Izvorni kod 8.3: Definicija funkcije koja prima vie argumenata i vraca vrijednost
1
#!/usr/bin/python
2
3
4
5
def zbroji(a, b):

c = a + b
return c
6
7
8
x = zbroji(2, 6)
y = zbroji(x, -5)
9
10
print x, y
8 3
Funkcija moe sadravati vie return naredbi (obicno u razlicitim uvjetnim grananjima) i svaka moe vratiti razlicit tip podatka (Izvorni kod 8.4).
Izvorni kod 8.4: Funkcija koja vraca razlicite tipove
1
#!/usr/bin/python
2
3
4
5
6
7
def luda_funkcija(a, b):

if(a > b):
return a + b
else:
return malo teksta
8
9
10
x = luda_funkcija(6, 2)
y = luda_funkcija(x, 10)
11
12
print x, y
8 malo teksta
8.3 argumenti sa zadanim vrijednostima
Vrlo c esto, javlja se potreba da funkcija vraca vie vrijednosti. To se moe

ostvariti vracanjem tuplea.
Izvorni kod 8.5: Funkcija koja vraca vie vrijednosti korsiteci tuple
1
#!/usr/bin/python
2
3
4
5
6
def f(a, b):

z = a + b
r = a - b
return z, r
7
8
9
x = f(6.0, 2.0)
print x
10
11
12
13
c, d = f(6.0, 2.0)
print c
print d
(8.0, 4.0)
8.0
4.0
8.3
argumenti sa zadanim vrijednostima
Funkcije mogu biti dfinirane i sa zadanim vrijednostima argumenata. Argumenti sa zadanim vrijednostima mooraju biti definirani nakon argumenata
bez zadanih vrijednosti.
def functionname(arg1=val1, arg2=val2, ... , argn=valn):
commands
return value
Prilikom poziva funkcije, moguce je funkciju pozvati bez zadanih argumenata.

Izvorni kod 8.6: Funkcija sa zadanim argumentom
1
#!/usr/bin/python
2
3
4
5
6
7
def f(a, b=0.0):

if(a > b):
return a - b
else:
return b
8
9
10
11
a = f(6.0, 2.0)
b = f(20.0)
c = f(-3.0)
12
13
print a, b, c
4.0 20.0 0.0
8.4
keyword i non-keyword argumenti
Funkciju se moe pozivati na nacin da se, pomocu keyword argumenata,

tocno specificiraju argumenti. Keyword argumenti su oni argumenti koji
se, pri pozivu funkcije, zadaju imenom i vrijednocu, za razliku od nonkeyword argumenata koji se zadaju samo kao vrijednost. Redosljed zadavanja keyword argumenata moe biti proizvoljan dok kod kombinacije nonkeyword i keyword argumenata prvo moraju biti specificirani non-keyword
argumenti.
37
38
funkcije
1
2
3
# Definiranje funkcije
def f(x, a, b):
return x*(a+b)
4
5
6
# Poziv funkcije sa keyword argumentima

f(x=10, b=0, a=8)
7
8
9
# Poziv funkcije sa mjesovitim keyword i non-keyword argumentima

f(10, b=0, a=8)
Posebna sintaksa definiranja funkcije pomocu * i ** omogucuje koritenje varijabilnog broja argumenata funkcije. Argument definiran sa jendom
zvjezdicom, uobicajeno *args, obuhvaca sve non-keyword argumente u jedan tuple. Upotrebom dvostruke zvijezdice **kwargs omogucuje pohranu
svih keyword argumenata u dictionary gdje su kljucevi imena argumenata a
vrijednosti argumenata su pohranjene u vrijednosti pod pripadajucim kljuc em.
Izvorni kod 8.7: Funkcija sa *args i **kwargs argumentima
1
2
#!/usr/bin/python
# -*- coding: utf-8 -*-
3
4
5
6
def funkcija(*args, **kwargs):

print non-keyword argumenti:, args
print keyword argumenti:, kwargs
7
8
9
for key, value in kwargs.iteritems():

print "%s = %s" % (key, value)
10
11
funkcija(10, bla bla, a=3, b=True, c=(0,0))

non-keyword argumenti: (10, bla bla)
keyword argumenti: {a: 3, c: (0, 0), b: True}
a = 3
c = (0, 0)
b = True
Prilikom koritenja
oba operatora za
raspakiravanje
argumenata (* i **)
vano je potivati
redoslijed. I kod
definicije funkcije i
kod poziva funkcije
prvo se koriste
non-keyword
argumenti a ond
akeyword argumenti.
Osim prilikom definicije funkcije, sintaksa *args i **kwargs moe se koristiti i pri pozivu funkcije. Zvijezdicom * se tuple vrijednosti raspakiraju
u argumente funkcije. Analogno, keyword argumente definirane u dictionaryu moe se proslijediti funkciji pomocu dvije zvijezdice **. U izvornom
kodu 8.8 prikazano je koritenje *args i **kwargs prilikom poziva funkcije.
Izvorni kod 8.8: *args i **kwargs argumenti prilikom poziva funkcije
1
2
#!/usr/bin/python
# -*- coding: utf-8 -*-
3
4
5
6
7
8
9
10
def funkcija(a, b, c, d, e):

print argumenti:
print a:, a
print b:, b
print c:, c
print d:, d
print e:, e
11
12
13
a = (1, 2, 3, 4, 5)
funkcija(*a)
14
15
16
kwa = {d:1, c:2, a:3, e:4, b:5}

funkcija(**kwa)
17
18
19
a = (5, 4)
kwa = {e:1, d:2, c:3}
8.5 ugnjedena definicija funkcije
20
funkcija(*a, **kwa)
argumenti:
a: 1
b: 2
c: 3
d: 4
e: 5
argumenti:
a: 3
b: 5
c: 2
d: 1
e: 4
argumenti:
a: 5
b: 4
c: 3
d: 2
e: 1
8.5
ugnjedena definicija funkcije
Ugnjedeno definiranje funkcije (eng. closure ili nested function definition)

omogucuje definiciju funkcije u funkciji. Ugnjedena definicija funkcije je
moguca u Pythonu jer su funkcije objekti te ih je moguce prosljedivati

kao
argumente drugim funkcijama te vracati kao rezultat funkcije. Ugnjedeno
definirane funkcije mogu se pokazati korisne jer unutarnja funkcija moe
koristiti objekte definirane u vanjskoj:
>>>
...
...
...
...
>>>
>>>
15
>>>
20
8.6
def vanjska(vanjski_argument):
def unutarnja(unutarnji_argument):
return vanjski_argument * unutarnji_argument
return unutarnja
f = vanjska(5)
f(3)
f(4)
anonimne funkcije
Lambda funkcije su funkcije bez imena tj. anonimne funkcije. Najcece se

koriste za definiranje vrlo jednostavnih i kratkih funkcija. Definiranje anonimne funkcije se vri koritenjem kljucne rijeci lambda:
lambda argumenti: izraz
Upotrebu jednostavne funkcije koja vraca apsolutnu razliku dva broja

1
2
def diff(a, b):

return abs(a - b)
3
4
print diff(7, 11)

4
moe se zamjeniti lambda funkcijom:

1
2
>>> print (lambda a, b: abs(a - b))(7, 11)

4
39
40
funkcije
Anonimne funkcije se c esto pokriste kao argumenti drugih funkcija koje

ocekuju objekt tipa funkcija kao argument.
sorted funkcija ocekuje argument key kao funkciju, koja je vecini slucajeva veoma jednostavna funkcija i obicno se koristi anonimna funkcija da se
izbjegne posebno definiranje funkcije. U sljedecem primjeru napravljeno je
sortiranje liste tupleova po drugim c lanovima tupleova:
>>> sorted([(5, 5), (13, 2), (11, 6), (7, 4)], key=lambda a: a[1])
[(13, 2), (7, 4), (5, 5), (11, 6)]
Jo jedan primjer upotrebe anonimnih funkcija je u ugnjedenim definicijama funkcijama.

Izvorni kod 8.9: Primjer anonimne funkcije u ugnjedenoj definiciji
1
2
def poruka(ime):
return lambda poruka: ime + : + poruka
3
4
5
6
p = poruka(Mario)
print p(Bok!)
print p(Kako ste?)
Mario: Bok!
Mario: Kako ste?
8.7
rekurzivne funkcije
Do sada smo se vec susreli sa petljama i nacinom kako funkcionira iterativni

postupak kao sukcesivno povecavanje indeksa, tj. brojcanika koji sudjeluje u
operaciji koja u konacnici daje finalni rezultat. Primjer je suma uzastopnih
brojeva od 1 do 100.
1
2
3
suma = 0
for index in range(1,101):
suma = suma + index
4
5
print suma
Znaci suma se postepeno povecava dok se ne iscrpi lista, tj. sekvenca indeksa definirana pozivom na range naredbu.
index = 1
suma =
index = 2
suma =
index = 3
suma =
index = 4
suma =
0 + 1
1 + 2
3 + 3
6 + 4
i tako dalje dok index ne postane 100. Drugim rijecima postepeno se na

varijablu nadodaju brojevi.
Takoder je moguce zapisati isti postupak prema koracima kako je vreno
sumiranje
suma = (0)
index = 1 : suma = ((0) + 1)
index = 2 : suma = (((0) + 1) + 2)
index = 3 : suma = ((((0) + 1) + 2) + 3)
itd.
Kada bi indeksirali parcijalne sume tada bi dobili slijedeci izraz

sumaindex = sumaindex1 + index
8.7 rekurzivne funkcije
41
. Tako zapisani izraz daje naslutiti kako je slijedeca suma zapisana kao suma
iz prethodnog koraka na koju se nadodaje vrijednost index iz trenutnog
koraka iterativne petlje. Ovakav zapis u biti je obrnuti zapis od prirodnog
sukcesivnog povecavanja indeksa:
suma(100) = suma(99) + 100, gdje je
suma(99) = suma(98) + 99, gdje je
suma(98) = suma(97) + 98, i tako dalje sve do
.
.
.
suma(1) = suma(0) + 1
Tipicna rekurzivna funkcija vri poziv sama na sebe.

Primjer je funkcija rsuma :
1
2
def rsuma(x):
return rsuma(x)
No, kao to vidite ova funkcija vraca poziv na samu sebe koja vraca poziv
na samu sebe koja vraca poziv na samu sebe i tako u beskonacnost. Ovako
definirana rekurzivna funkcija nema kraja, a program ulazi u beskonacnu petlju (eng. infinite loop). A gdje je greka? Kako bi sprijecili ovakvo ponaanje
potrebno je uvesti uvjet prekida. To je granicna vrijednost nakon koje funkcija
vie nece vratiti sebe vec neku vrijednost. Ako se sada vratimo na sumu
brojeva onda bi rekurzivna funkcija sume trebala izgledati ovako:
1
2
Mogucnost zapisa
funkcije u obliku koji
poziva istu funkciju
nazivamo rekurzija,
a takvu funkciju
rekurzivna
funkcija.
def rsuma(n):
return rsuma(n - 1) + n
No oznaka prekida je suma(0)=0, tj. kada u 100-tom pozivu funkcije rsuma

bude primila za argument 0 potrebno je zaustaviti daljnje pozive rsuma
funkcije. To c emo postici testiranjem vrijednosti n
1
2
3
4
5
def rsuma(n):
if n = 0:
return 0
else:
return rsuma(n - 1) + n
Na taj nacin omogucili smo oznaku kraja rekurzivnim pozivima funkcije.

Slijedi nekoliko primjera:
Primjer 1. Proracun faktorijela broja n.
Faktorijel broja n je jednak :
n! = 1 2 3 4 ... n
Ima rekurzivni zapis
n! = (n 1)! n
1
2
3
4
5
def factoriel(n):
if n = 0:
return 1
else:
return factoriel(n - 1) * n
Primjer 2. Potenciranje broja x eksponentom n.

je iterativni proces koji moe biti zapisan rekurzivno
Potenciranje takoder
na slijedeci nacin
xn = xn1 x
Primjerice kub je jednak umnoku broja i kvadrata broja,
x3 = x2 x
Rekurzivni zapis
unosi konciznost i
eleganciju u
programski kod.
42
funkcije
1
2
3
4
5
def potencija(x,n):
if n = 0:
return 1
else:
return potencija(x, n - 1) * x
Primjer 3. Korisnicki unos i formiranje liste

Unose se brojevi koji se dodaju na listu dok se ne unese 0.
1
2
def rloop():
x = int(raw_input(Unesi broj ili 0 za kraj))
3
4
if x:
return [x]+rloop()
5
6
7
else:
return []
Dok su prethodni primjeri ovisili o smanjivanju broja n do oznake kraja, u

ovom primjeru funkcija se poziva tako da aurira listu novim vrijednostima.
Za zakljucak, potrebno je napomenuti da je rekurzivnu funkciju moguce
napraviti za svaki poziv petlje, no da li je nuno sve petlje pretvoriti u rekurzivne funkcije To ostaje na procijeni programeru koji mora odvagnuti
kolicinu elegancije, hijerarhije, strukturiranosti te preglednosti koda.
OBJEKTNO-ORIJENTIRANO PROGRAMIRANJE
9.1
Python je inicijalno zamiljen kao objektno orijentirani programski jezik.

Pojam objekt je kljuc za razumijevanje objektno-orijentiranog pristupa programiranju. Objekt je kompozicija stanja (atributi, varijable) i ponaanja (metode, funkcije). Stanja jednog objekta c ine njegovi atributi (npr. objekt automobil moe imati atribute promjer kotaca, snaga motora, trenutni prijenosni
omjer) koji su u programu utjelovljeni kao varijable koje poprimaju odre
dene
vrijednosti (stanja). Ponaanje ili aktivnosti odredenog
objekta utjelov
ljene su u programu u obliku funkcija koje izvravaju odredene
radnje vane
za objekt ili korisnike koji koriste objekte (npr. metode koje moe izvriti
automobil su kocenje, ubrzavanje, mijenjanje brzine, skretanje). Tako definirani objekti omogucuju proirenje postojece funkcionalnosti programskog
jezika i time programeru olakavaju pisanje programa. Cesto

ih se moe
susresti prilikom izrade aplikacija sa grafickim suceljem ili bilo kojoj drugoj aplikaciji c iji korisnici moraju stvarati objekte, mijenjati njihova stanja i
koristiti metode kako bi definirali ponaanje ili uzrokovali neku aktivnost
vezanu uz objekt. Najlake c e biti to shvatiti na slijedecem primjeru.
Primjer: "Aplikacija za pisanje teksta" omogucava korisniku slijedece funkcionalnosti:
? izradu novog dokumenta - (u programskom kodu dokument je objekt)
? mijenjanje sadraja dokumenta (sadraj je jedan od atributa objekta)
? mijenjanje naziva dokumenta (sadraj je jedan od atributa objekta)
? zapis sadraja dokumenta u datoteku (Save, Save As funkcije kao metode objekta dokumenta)
? otvaranje dokumenta iz datoteke (Open funkcija kao metoda objekta
dokumenta)
? lijevo, centralno, podjednako i desno poravnanje teksta u sadraju
(Funkcije Left,Center,Right,Justify kao metode objekta dokumenta)
? itd.
Pored ovih stanja i ponaanja jednog dokumenta kao objekta lako biste
mogli poznavajuci MS Word ili neku drugu aplikaciju za uredivanje

i editiranje teksta osmisliti ili se sjetiti jo neke od mnogih stanja i ponaanja koje
MS Word posjeduje.
mora omoguciti i izradu ili ucitavanje neAplikacija poput ove takoder
koliko objekata kako bismo mogli usporedivati

ili kopirati njihov sadraj ili
recimo spojiti vie dokumenata u jedan. Da bi to omogucila aplikacija mora
posjedovati nacin kako da omoguci istovremenu pojavu vie dokumenata.
to to znaci u programu tocno. Dokument je opisan kao objekt u programskom kodu. Vie dokumenata time c ini vie objekta gdje svaki moe imati
sadraj, naziv kao svoje atribute te metode Open ,Save, Left, itd. kao ponaanja koja aplikacija omogucuje pojedinom dokumentu tj. objektu.
43
44
Time dolazimo do problema to svi izradeni

dokumenti imaju varijable
kao stanja i funkcije kao metode koje su jednake za sve dokumente/objekte.
Kako bi aplikacija svim dokumentima omogucila tako neto, mora u aplikaciji postojati zapis koji definira kako c e se ponaati svaki pojedini objekt
dokumenta te koje c e funkcionalnosti svakom dokumentu aplikacija omoguciti.
Taj zapis u objektno-orijentiranim programskim jezicima nazivamo Klasom, a svaki poziv na izradu novog objekta instanciranje. Time je svaki
objekt definiran kao jedna instanca klase.
9.2
klase
Klase predstavljaju definiciju svih atributa i metoda koje c e instance te klase

poprimiti. Za definiranje klase, tj. opisa objekta, koristi se izraz
class ime_klase():
nakon kojeg slijede definicije atributa i metoda.

Izvorni kod 9.1: Definicija klase
1
2
#!/usr/bin/python
# -*- coding: utf-8 -*-
3
4
5
6
7
class Dokument:
"""
Klasa Dokument omogucuje instanciranje objekata Dokument
"""
>>> d1 = Dokument()
>>> d2 = Dokument()
>>> d1
<__main__.Dokument instance at 0x7f050f2c0098>
>>> d2
<__main__.Dokument instance at 0x7f05000287e8>
>>>
Prikazani izvorni kod i output iz Python konzole pokazuju nacin definicije klase te nacin instanciranja dva objekta d1 i d2. Printanjem u konzoli
objekata d1 i d2 moguce je vidjeti da su oba objekta instance te da je svaka
zasebno referencirana u memoriji na drugo adresno mjesto.
9.3
atributi
Atributi omogucuju dodjeljivanje stanja objekata. Njihova definicija nalazi

se unutar klase i vrijedi za sve objekte instancirane iz klase.
Postoje dvije vrste atributa
? Klasni (globalni) atributi
? Objektni (lokalni) atributi
9.3.1
Globalni atributi
Atributi koji pripadaju svim objektima zovu se klasni atributi, i definiraju

se odmah poslije definicije klase. To su globalne varijable koje vrijede za sve
objekte instancirane iz te klase. Npr.
Izvorni kod 9.2: Primjer definicije klasnih (globalnih) atributa
9.3 atributi
1
2
#!/usr/bin/python
# -*- coding: utf-8 -*-
3
4
5
6
7
class Dokument:
"""
Klasa Dokument omogu
cuje instanciranje objekata Dokument
"""
8
9
10
ime=Dokument1
sadrzaj=Ovo je prva linija u dokumentu
11
12
13
d1=Dokument()
d2=Dokument()
>>> d1.ime
Dokument1
>>> d2.ime
Dokument1
>>> Dokument.ime
Dokument1
Atribut ime je stoga dostupan svim objektima kao i samoj klasi Dokument. Potrebno je napomenuti da je moguce doci do pogreke ako objekt
nastoji mijenjati vrijednost klasnom atributu. Naime, takvim c inom nije iz
mijenjena vrijednost klasnom atributu vec je izraden
novi atribut istoga
imena, a koji pripada objektu.
>>> d2.ime
Dokument1
>>> d2.ime=Doc
>>> Dokument.ime
Dokument1
Svrha postojanja globalnih atributa je u tome da omoguce identifikaciju

objekata instanciranih iz jedne klase. Slijedeci primjeri primjene dati su na
klasi Parkiralita:
? identifikacijski broj objekta (npr. Parking01,Parking02,...)
? lista objekata (npr. [obj1,obj2,obj3])
? kumulativne sume (npr. ukupan broj automobila parkiranih na svim
parkiralitima)
9.3.2
Objektni atributi
Objektni atributi c ine atribute definirane u klasi unutar posebne metode

koja se zove __init__. Ova metoda pripada u kategoriju magi
cnih metoda
klase jer omogucuju napredne mogucnosti. Inicijalizacija je u drugim programskim jezicima prisutna pod nazivom konstruktor. Ona ima za cilj omoguciti definiciju atributa koji c e poprimati stanja definirana prilikom stvaranja objekta. Npr.
Izvorni kod 9.3: Primjer definicije objektnog atributa
1
2
#!/usr/bin/python
# -*- coding: utf-8 -*-
3
4
5
6
7
8
class Dokument:
"""
"""
def __init__(self):
45
46
self.ime=
self.sadrzaj=
9
10
11
12
13
d1=Dokument()
d2=Dokument()
14
15
16
d1.ime=Prica01
d1.sadrzaj=Bio jednom jedan val.
17
18
19
20
d2.ime=ListaSerija
d2.sadrzaj=Lud, zbunjen, normalan.\n
d2.sadrzaj+=Sila\n
prihvat argumenata predanih Klasi

Metoda __init__omogucuje, takoder,
prilikom formiranja objekta. To c inimo tako da u argument listu metode
__init__predamo vrijednosti koje elimo da pojedini atributi tog objekta poprime. Npr.
Izvorni kod 9.4: Inicijalizacija objekta
1
2
#!/usr/bin/python
# -*- coding: utf-8 -*-
3
4
5
6
7
8
9
10
class Dokument:
"""
"""
def __init__(self,name=Dokument,content=):
self.ime=name
self.sadrzaj=content
11
12
13
14
15
d1=Dokument(Esej,Prva recenica)
d2=Dokument(Blog01)
d3=Dokument()
Do ovog koraka vec sve uvidjeli da se pozivi atributa unutar metode

__init__vre pomocu specificne rijeci self. No, to c emo obraditi u sljedecem
poglavlju Metode.
9.4
metode
Metode su funkcije koje koristimo da u klasi definiramo promjenu stanja

atributa, izvrimo neke aktivnosti ili obavimo neke druge radnje vezane uz
odredeni
objekt. Svaka metoda mora biti definirana kao funkcija i posjedovati minimalno jedan argument, a to je self kao opis objekta za kojega
se izvrava metoda. Slijedeci primjer definira metodu Info koja omogucuje
printanje naziva i sadraja objekta koji ju je pozvao.
Obratite panju na koriteni globalni atribut DokumentList kao listu objekata koja se puni prilikom inicijalizacije.
Izvorni kod 9.5: Definicija metode
1
2
#!/usr/bin/python
# -*- coding: utf-8 -*-
3
4
5
6
7
class Dokument:
"""
Klasa Dokument omogucuje instanciranje objekata Dokument
"""
8
9
10
DokumentList=[]
9.5 preopterecivanje
11
12
13
14
def __init__(self,name=Dokument,content=):
self.ime=name
self.sadrzaj=content
Dokument.DokumentList.append(self)
15
16
17
18
def Info(self):
print Ime dokumenta:,self.ime
print Sadrzaj:\n,self.sadrzaj
19
20
21
22
d1=Dokument(Esej,Prva recenica)
d2=Dokument(Blog01)
d3=Dokument()
23
24
25
26
for d in Dokument.DokumentList:
d.Info()
print \n
Self prvi put dobiva znacaj kao prvi c lan argument liste metode __init__(def
__init__(self,arg1,arg2,...)). Unutar same metode svaki od atributa koji se koriste mora biti zapisan uz pomoc self. prefiksa.
Moemo to gledati na drugaciji nacin. Zamislite da je klasa modul koji
ima svoje pod-funkcije (metode). Svaka od tih pod-funkcija ima mogucnost
mijenjati atribute nekom objektu. To je ostvarivo samo ako pod-funkcija
moe pristupiti objektu i njegovim atributima.
Upravo to c inimo predajuci self metodi __init__. Predajemo objekt u obliku
rijeci self, te nakon toga vrijednosti koje elimo dodijeliti atributima. No u
stvarnosti Python dozvoljava pozivanje funkcija bez davanja sebe kao prvog
c lana argument liste.
Na slijedecem primjeru usporedujemo

dva istovjetna poziva metode gdje
je prva na nacin da objekt poziva metodu, a druga da Klasnoj metodi predamo objekt kao prvi c lan argument liste te nakon njega sve ostale argumente.
>>> d1.Info()
Ime dokumenta: Esej
Sadrzaj:
Prva recenica
>>> Dokument.Info(d1)
Ime dokumenta: Esej
Sadrzaj:
Prva recenica
Znaci d1.Info() je isto to i Dokument.Info(d1). Prvi omogucava jednostavniji poziv metode dok drugi ukazuje nacin kako Python ustvari radi, tj.
predaje metodi objekt koji u deklaraciji metode stoji kao self.
9.5
preopterecivanje
Jedna od osobina objektno-orjentiranog programiranja je mogucnost preopterecivanja funkcija i operatora kako bi i objektima omogucili istu funkcionalnost kao i klasicnim varijablama poput int, float, bool, string, list, itd.
Takva osobina c esto je i nunost kako bi operatore mogli dovoditi u odre
dene
odnose i operacije ili nad objektima izvriti radnje poput printanja.
Cesto
se za evaluaciju ili grananje sluimo operatorima usporedbe (>,>=,<,<=,
==) te logickim operatorima and i or. Istu funkcionalnost moguce je postici
i usporedbom dvaju objekata gdje se objekti pritom usporeduju

na nacin
da im se tocno odredi to i kako se usporeduje

(npr. dvije koare voca Kosara01 i Kosara02 su objekti c iji sastav c ini raznovrsno voce gdje svako ima
svoju teinu i moguce je u svakom slucaju utvrditi ukupnu teinu koare te
pristupiti usporedbi dvaju koarica).
47
48
Nadalje, objekti mogu biti tako osmiljeni da je od znacaja primjena osnovnih numerickih operatora (+,-,*,/,itd.) kako bi se kreirali novi objekti sa
izmjenjenim atributima na temelju numerickih operatora (npr. ako su one
dvije kosare iz prethodnog zadatka bile pune i u njih vise ne stane onda je
moguce u novu kosaru dodati sastojke iz prethodne dvije pune kosare).
Sva preopterecenja u Pythonu predefinirana su u obliku specijalnih metoda koje svaka klasa moe implementirati. Specijalne metode imaju naziv
sa dvije donje crte ispred i iza naziva (npr. __str__ili __gt__)
omeden
9.5.1
Preopterecivanje funkcija
Izvorni kod 9.6: Preopterecivanje funkcije print

1
2
3
4
# -*- coding: utf-8 -*"""

Created on Sat Jun 1 13:35:55 2013
"""
5
6
from math import sqrt
7
8
class Point:
9
10
11
12
def __init__(self,x,y):
self.x=x
self.y=y
13
14
15
def R(self): # funkcija koja vraca radij vektor tocke, tj. udaljenost od
ishodista
return sqrt(self.x**2 + self.y**2)
16
17
18
19
20
21
22
23
24
25
# Preoptereceni operatori usporedbe tocka s obzirom na udaljenost od ishodista

def __lt__(self,other): # less then
return self.R() < other.R()
def __le__(self,other): # less or equal
return self.R() <= other.R()
def __gt__(self,other): # greather then
return self.R() > other.R()
def __ge__(self,other): # greater or equal
return self.R() >= other.R()
26
27
28
29
p1=Point(2,1)
p2=Point(1,2)
p3=Point(3,0)
30
31
32
33
34
35
print
print
print
print
print
p1>p2
p1>=p2
p1<=p2
p1<p3
p1==p2
Opis objekta klase CPoints

Ukupan broj tocaka:
2
Opis objekta klase CPoints
Ukupan broj tocaka:
4
U ovom primjeru naredba print je preopterecena koristeci specijalnu funkciju __str__koja vraca string koji c e biti printan prilikom printanja objekta.
p r i n t PTS1
p r i n t PTS2
9.5 preopterecivanje
Potrebno je napomenuti da nije moguce preopteretiti korisnicki definirane

funkcije tj. sve one koje nemaju svoju specijalnu funkciju.
9.5.2 Preopterecivanje operatora
Preopterecivanje operatora omoguceno je u Pythonu koritenjem specijalnih
metoda slijedecih imena Operatori usporedbe
? __gt__ - Vece od - >
? __ge__ - Vece ili jednako od - >=
? __lt__ - Manje od - <
? __le__ - Manje ili jednako od - <=
? __eq__ - Jednako - ==
1
2
3
4
# -*- coding: utf-8 -*"""

"""
5
6
7
8
class RVector:
9
10
11
12
def __init__(self,x,y):
self.x=x # atribut x koordinata
self.y=y # atribut y koordinata
13
14
15
def R(self): # metoda koja vraca duljinu radij vektora, tj. udaljenost od
ishodista
return sqrt(self.x**2 + self.y**2)
16
17
18
19
20
21
22
23
24
25
26
27
# Preoptereceni operatori usporedbe radij vektora s obzirom na udaljenost od

ishodista
def __lt__(self,other): # less then
return self.R() < other.R()
def __le__(self,other): # less or equal
return self.R() <= other.R()
def __gt__(self,other): # greather then
return self.R() > other.R()
def __ge__(self,other): # greater or equal
return self.R() >= other.R()
def __eq__(self,other): # greater or equal
return self.R() == other.R()
28
29
30
31
p1=RVector(2,1)
p2=RVector(1,2)
p3=RVector(3,0)
32
33
34
35
36
37
print
print
print
print
print
False
True
True
False
True
p1>p2
p1>=p2
p1<=p2
p3<p2
p1==p2
49
50
Aritmeticki operatori
? __add__ - zbrajanje - +
? __sub__ - oduzimanje - -
? __mul__ - mnoenje - *
? __div__ - djeljenje - /
1
# -*- coding: utf-8 -*-
2
3
class Table:
4
5
6
7
8
def __init__(self,a=1.0,b=1.0):
self.a = a
self.b = b
self.Area = self.a * self.b # atribut povrsine stola
9
10
11
def __str__(self):
return Table = %4.1f x %4.1f \n Area = %6.2f % (self.a,self.b,self.Area)
12
13
14
15
def Rotate(self): # rotira stranice a i b

tmpA=self.a
tmpB=self.b
16
17
18
self.a=tmpB
self.b=tmpA
19
20
print Stol zarotiran!
21
22
# Preoptereceni aritmeti
cki operatori
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
def __add__(self,other): # zbraja dva stola

self.a = self.a + other.a # duinu drugog pridodajemo duini prvog
self.Area = self.Area + other.Area # povrinu drugog dodajemo povrsini
prvog
self.b = self.Area / self.a # izra
cunavamo novu prosje
cnu irinu
print Stolovi spojeni!
def __sub__(self,other): # oduzima dva stola
if self.Area > other.Area:
if self.a > other.a:
if self.b > other.b:
self.Area -= other.Area # oduzima povrinu drugoga
self.a -= other.a # oduzima duinu drugoga
self.b = float(self.Area)/self.a # izra
cunava novu irinu
print Stolovi oduzeti!
else:
print Sirina b je dua kod drugog stola.
else:
print Duzina a je duza kod drugog stola.
else:
print Povrsina drugog je veca od prvog stola.
43
44
45
46
47
48
49
50
51
52
53
54
t1=Table(10,20)
t2=Table(20,40)
print t1
print t2
t1-t2
t2-t1
t1+t2
t1.Rotate()
t1-t2
print t1
print t2
9.6 nasljeivanje
Table = 10.0 x 20.0

Area = 200.00
Table = 20.0 x 40.0
Area = 800.00
Povrsina drugog je veca od prvog stola.
Stolovi oduzeti!
Stolovi spojeni!
Stol zarotiran!
Sirina b je duza kod drugog stola.
Table = 40.0 x 20.0
Area = 800.00
Table = 10.0 x 60.0
Area = 600.00
Postoji jo mnogo specijalnih metoda, ali njihovo izucavanje preputamo

vama da ih istraite ako smatrate potrebnim.
9.6
nasljeivanje
Objekti koje je moguce susresti u stvarnom ivotu najcece su kategorizirani

u neke grupacije ili klastere, ili su dio neke hijerarhijske strukture. Rijetko
da je neki objekt jedinstven u svoj svojoj unutranjosti. Covjek

jede, ivotinja
jede, a i biljke jedu tj. izvravaju jednu od svojih najvanijih funkcija. Bicikl
je kopneno vozilo, kao i automobil, dok je avion ili balon na vruci zrak
zracno vozilo, a podmornica ili brod pomorsko vozilo. Sva ova prometala
su vozila. Na taj nacin slijedi hijerarhija koja definira pripadnost pojedinih
objekata. Postoje i rekurzivne hijerarhijske veze poput obiteljskih stabala ili
svake strukture koja za svoj rezultat ima potomstvo novih objekata.
Nasljedivanje
je u pravilu proces kojim od viih hijerarhijskih razina ili
grupacija poprimamo neke osobine ili funkcije.
Objektno-orjentirano programiranje omogucuje naslijedivanje

atributa i
metoda iz nadredenih
klasa. Deklaracija klase koja posjeduje nadklasu data
je u slijedecoj liniji koda:
class Sudoku(Igra):
Klasa Sudoku naslijeduje

metode od svoje nadklase Igra koja se c esto
zove i bazna (osnovna) klasa. Kao to je Igra nadklasa klasi Sudoku tako je
Sudoku klasi Igra podklasa.
U slijedecem primjeru dana je nadklasa Road koja inicijalizira naziv ceste
name i duljinu ceste length te definira sadraj metode Info() koja slui za
ispis vrijednosti atributa svakog instanciranog objekta bilo podklase Highway, MainRoad, LoaclRoad ili osnovne nadklase Road.
Naslijedivanje
ima jo jednu prednost koja se ocituje u sistematizaciji izvornog koda. Kada ne bi imali nadklasu, svaka od podklasa trebala bi sama
inicijalizirati svoje atribute kao i definirati svoju funkciju Info(). Na taj nacin
izvorni kod bi bio predugacak, nejasan i necitljiv.
Izvorni kod 9.9: Naslijedivanje

1
2
# -*- coding: utf-8 -*"""
51
52
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

"""
class Road:
def __init__(self,name,length):
self.name=name
self.length=length
def Info(self):
print "Road definition"
print "Ime:\t %15s" % self.name
print "Length:\t %15s" % self.length
class Highway(Road):
pass # Bez lokalnih definicija
class MainRoad(Road):
class LocalRoad(Road):
19
20
21
22
23
24
25
h1=Highway(A1,1000)
m1=MainRoad(E54,540)
l1=LocalRoad(S16,125)
h1.Info()
m1.Info()
l1.Info()
Road definition
Ime:
Length:
Road definition
Ime:
Length:
Road definition
Ime:
Length:
A1
1000
E54
540
S16
125
U situaciji kada pojedina podklasa ipak zahtjeva prilikom inicijalizacije definirati neki vlastiti atribut tada definicija __init__unutar podklase predefinira (override) __init__metodu nadklase. U tom slucaju je potrebno pozvati
inicijalizacijsku metodu nadklase unutar inicijalizacijske metode podklase.
Izvorni kod 9.10: Naslijedivanje

override __init__metode
1
2
3
4
5
6
7
8
# -*- coding: utf-8 -*"""

"""
class Road:
def __init__(self,name,length):
self.name=name
self.length=length
9
10
11
12
13
def Info(self):
print "Road definition"
print "Ime:\t %15s" % self.name
print "Length:\t %15s" % self.length
14
15
16
17
18
19
20
21
22
23
24
25
26
class Highway(Road):
def __init__(self,name,length): # override __init__ nadklase
Road.__init__(self,name,length) # invokacija __init__ metode nadklase
self.type=highway
self.toll=50 # Kn/100km
class MainRoad(Road):
self.type=mainroad
class LocalRoad(Road):
9.6 nasljeivanje
self.type=localroad
27
28
29
30
31
h1=Highway(A1,1000)
m1=MainRoad(E54,540)
l1=LocalRoad(S16,125)
32
33
print h1.toll
50
Pored jednostavnih naslijedivanja

moguca su i viestruka naslijedivanja
iz vie nadklasa i definiraju se na slijedeci nacin:
class Smartphone(Mobile_device,Computer):
53
10
O B L I K O VA N J E S T R I N G O VA
10.1
oblikovanje sa operatorom %
String objekti imaju ugradeni

operator (%) koji omogucava ubacivanje vrijednosti unutar stringa na posebno oznacena mjesta. Mjesta na koja treba
ubaciti odredenu
vrijednost u stringu oznacavaju se znakom % i posebnim
oznakama koje detaljnije definiraju formatiranje ubacene vrijednosti. Nakon
stringa i operatora % (Nije isto to i oznaka u samom stringu) u tupleu ili
dictionaryju se zadaju vrijenosti ili varijable koje treba umetnuti u string.
Izraz koji definira format ubacene vrijednosti sastoji se od:
? znak % koji oznacava pocetak izraza za definiranje formata,
? kljuc mapiranja (neobavezno) koji definira ime (kljuc) vrijednosti koja
se ubacuje u string,
? konverzijske opcije (neobavezno),
? minimalni broj rezerviranih znakova (neobavezno),
? preciznost (neobavezno), oznacava broj decimalnih mjesta koje se prikazuju i pie se nakon znaka ..
? tip konverzije.
Ako se koristi kljuc mapiranja onda vrijednosti treba zadati u dictionaryju
dok se inace zadaju u tupleu.
Konverzijske opcije se definiraju pomocu znakova opisanih u tablici 10.1.
Simbol
Opis
Prazne znakove popunjuje sa nulama
Poravnanje u lijevo
Nezauzete znakove popunjuje razmacima
Uvijek postavlja predznak (+ ili -)

Tablica 10.1: Opcije konverzije
Pomocu operatora % u string je moguce ubaciti razne numericke (i string)

formate koji se definiraju pomocu simobla danih u tablici 10.2.
Primjer u izvornom kodu 10.1 prikazuje ubacivanje i formatiranje decimalnog i cijelog broja u string. Primjer obuhvaca primjenu tupleova bez
kljuca mapiranja te na istom primjeru primjenu dictionaryja sa kljucevima
mapiranja.
Izvorni kod 10.1: Primjer formatiranja numerickih podataka sa tupleom i dictionaryjem
>>>
>>>
a =
>>>
>>>
a =
>>>
>>>
a =
s = a =
print s
12.37, b
s = a =
print s
12.37, b
s = a =
print s
12.37, a
%.2f, b = %d % (12.365, 18)

= 18
%(a).2f, b = %(b)d % {a: 12.365, b: 18}
= 18
%(a).2f, a = %(a)+.1f % {a: 12.365}
= +12.4
55
Upotrebom kljuceva
mapiranja zadavanje
argumenata u
dictionaryju ne mora
biti u istom
redosljedu kao i
pozicije ubacivanja u
samom stringu. Na
ovaj se nacin
argumenti mogu
upotrijebiti vie puta,
bez potrebe da ih se
viestruko puta
zapisuje unutar
dictionaryja.
56
oblikovanje stringova
Simbol
Tip
Cijeli broj
Oktalni broj
Heksadecimalni broj
Decimalni broj u eksponencijanom obliku
Decimalni broj
Tekstualni znak
String
Nema konverzije argumenta, rezultat sadri znak %

Tablica 10.2: Definiranje tipova podataka
Razlicite primjene konverzijskih opcija prikazane su u izvornom kodu

10.2.
Izvorni kod 10.2: Primjer formatiranja numerickih podataka sa tupleom i dictionaryjem
>>>
x =
>>>
x =
>>>
x =
>>>
x =
>>>
x =
>>>
x =
>>>
x =
>>>
x =
print x = [%5.2f, %5.2f] % (11.14, 7.88)

[11.14, 7.88]
print x = [%f, %f] % (11.14, 7.88)
[11.140000, 7.880000]
print x = [%10f, %10f] % (11.14, 7.88)
[ 11.140000,
7.880000]
print x = [%010f, %010f] % (11.14, 7.88)
[011.140000, 007.880000]
print x = [%+10f, %+10f] % (11.14, 7.88)
[+11.140000, +7.880000]
print x = [%-+10f, %-+10f] % (11.14, 7.88)
[+11.140000, +7.880000 ]
print x = [%-+10.2f, %-+10.2f] % (11.14, 7.88)
[+11.14
, +7.88
]
print x = [%+10.2f, %+10.2f] % (11.14, 7.88)
[
+11.14,
+7.88]
Izvorni kod 10.3: Primjer formatiranja numerickih podataka za ispis u stupcima

1
from math import sqrt, sin
2
3
l = range(1, 11)
4
5
6
7
8
for i in range(len(l)):
s = %03d %4.1f %6.1f %5.2f %+6.3f % \
(i+1, l[i], l[i]**2.0, sqrt(l[i]), sin(l[i]))
print s
001 1.0
002 2.0
003 3.0
004 4.0
005 5.0
006 6.0
007 7.0
008 8.0
009 9.0
010 10.0
1.0
4.0
9.0
16.0
25.0
36.0
49.0
64.0
81.0
100.0
1.00
1.41
1.73
2.00
2.24
2.45
2.65
2.83
3.00
3.16
+0.841
+0.909
+0.141
-0.757
-0.959
-0.279
+0.657
+0.989
+0.412
-0.544
10.2 oblikovanje sa metodom format
10.2
oblikovanje sa metodom format
Svi string objekti sade metodu format koja omogucuje napredno formatiranje i kontrolu stringova.
57
11
R A D S A D AT O T E K A M A
11.1
otvaranje i zatvaranje datoteka
Osnovna manipulacija sa sadrajem datoteka u Pythonu je omogucena koritenjem file objekta.
Python ima ugradenu

funkciju open za otvaranje postojecih ili stvaranje
novih datoteka na disku. Funkcija open vraca file objekt, koji sadri metode
i atribute za pristup i manipulaciju informacija i sadraja otvorene datoteke.
Sintaksa otvaranja datoteka je:
f = open(ime\_datoteke, vrsta\_pristupa, buffering)
gdje je ime_datoteke sting koji sadri relativnu ili apsolutnu putanju datoteke, vrsta_pristupa je string koji sadri mod pristupa, buffering je
integer koji oznacava velicinu medupohrane.

Argumenti vrsta_pristupa
i buffering nisu obavezni. f je novonastali file objekt kreiran pozivom
funkcije open.
Mod pristupa se definira kao string koji sadri znakove:
? r, w ili a kojima se definira da li c e se vriti c itanje (read), pisanje
(write) ili dodavanje (append)
? b oznacava binarni oblik datoteke. Ako nije specificiran onda je oblik
datoteke takstualni (t).
? + omogucuje istodobno c itanje i pisanje (ili dodavanje) datoteke.
Nakon obavljanja eljenih manipulacija, koje su objanjene u narednim
poglavljima, datoteku je potrebno zatvoriti. Za zatvaranje datoteke koristi
se close metoda koju ima svaki file objekt:
f.close()
Nakon zatvaranja nisu moguce nikakve operacije na datoteci.

11.2
pisanje u datoteke
Za zapisivanje informacija u datoteku koriste se metode write i writelines

klase file.
write metoda prima string varijablu koju zapisuje u prethodno otvorenu
datoteku u modu za pisanje (w) ili dodavanje (a). Ovu naredbu moe se
ponavljati kako bi se dodalo jo teksta u datoteku.
f.write(tekst)
Izvorni kod 11.1: Primjer kreiranja tekstualne datoteke

1
2
#!/usr/bin/python
# -*- coding: utf-8 -*-
3
4
datoteka = open(info.txt, w)
5
6
7
8
datoteka.write(Tehni
cki fakultet)
datoteka.write(, Rijeka)
datoteka.write(\nVukovarska 58)
9
10
datoteka.close()
59
Pocetna pozicija
unutar datoteke
razlikuje se ovisno o
opciji r, w
(pocetak datoteke) ili
a (kraj datoteke).
60
rad sa datotekama
Tehni
cki fakultet, Rijeka
Vukovarska 58
Iako njeno ime na to

upucuje,
writelines ne
zapisuje svaki
element liste u novi
redak!
Funkcija writelines zapisuje listu stringova u datoteku. Postignuti efekt

je isti kao da se pozove write za svaki element liste.
f.writelines(lista_stringova)
l = [malo, , teksta]
f.writelines(l)
# isto to i
for s in l:
f.write(s)
11.3
citanje
iz datoteka
Za c itanje datoteke potrebno je eljenu datoteku otvoriti u modu za c itanje
(r). Osnovni nacin za procitati sadraj odredene

datoteke je preko funkcija:
? read koja vraca sadraj datoteke (od trenutne pozicije) eljene velicine
u obliku stringa,
? readline koja vraca sadraj trenutne linije u obliku stringa,
? readlines koja vraca listu stringova koji predstavljaju pojedine linije
datoteke
Sintaks metode read je:
f.read(size)
Kod c itanja datoteka

vrlo c esto je bitna
trenutna pozicija u
samoj datoteci to je
objanjeno u
poglavlju 11.4
gdje je size velicina sadraja koji treba procitati. Za binarnu datoteku size
oznacava broj bitova a za tekstualnu broj znakova. Ukoliko je size negativan
ili nije zadan, c ita se cijeli sadraj datoteke.
f.readline(size)
Metoda readline c ita jednu liniju u datoteci i to od trenutne pozicije do

kraja lnije (do znaka
n). Argument size definira maksimalnu velicinu procitanih podataka. Za
prazne lnije metoda vraca string koji sadri znak za novu liniju
n. Kad je trenutna pozicija na kraju datoteke, metoda vraca prazan string.
f.readlines(size)
readlines vraca sadraj datoteke kao listu linija. size ima jednak ucinak
kao i na dvije prethodno objanjene metode.

Za potrebe primjera, zadana je datoteka test.txt sljedeceg sadraja:
123456789
3. linija
4. linija
zadnja!
U izvornom kodu 11.2 dani su primjeri upotrebe navedenih funkcija za

c itanje sadraja datoteke.
11.4 pozicioniranje u datoteci
Izvorni kod 11.2: Citanje

sadraja tekstualne datoteke
1
2
3
4
5
6
data = open(test.txt, r)
print data.read(5)
print data.readline()
print data.readline(6)
print data.readlines()
data.close()
12345
6789
ABCDEF
[GHIJKLMNOPQRSTUVWXYZ\n, 3. linija\n, 4. linija\n, zadnja!]
Osim pomocu navedenih funkcija, postoji jo jedan nacin pristupanju linijama neke tekstualne datotetke, a to je iterirajuci kroz file objekt kao to je
prikazano u izvornom kodu 11.3.
Izvorni kod 11.3: Pristupanje sadraju datoteke preko iteriranja po file objektu
1
2
3
4
5
6
s =
for line in data:
s += line
print s
data.close()
123456789
3. linija
4. linija
zadnja!
11.4
pozicioniranje u datoteci
Trenutnu poziciju u datoteci moe se saznati preko metode tell:

f.tell()
Metoda tell daje broj bitova (znakova) trenutne pozicije od pocetka datoteke (Izvorni kod 11.4).
seek momogucuje micanje trenutne pozicije u datoteci. Sintaksa metode
je:
f.seek(offset, from)
offset je broj koim definiramo pomak pozicije. Pozitivan je u naprijed a

negativan u nazad. Argumentom from se definira od kuda c e se pomak
racunati (0 za pocetak datoteke, 1 za trenutni poloaj i 2 za kraj datoteke).

Izvorni kod 11.4: Dohvacanje trenutne pozicije u datoteci
1
2
3
4
5
6
7
8
9
10
11
print data.readline()
print pozicija:,data.tell()
print data.read(3)
print pozicija:,data.tell()
data.seek(6,1)
print data.read(3)
data.seek(-3,1)
print data.read(5)
data.seek(0,0)
print data.read(5)
61
62
rad sa datotekama
12
13
14
data.seek(-5,2)
print data.read(5)
data.close()
123456789
pozicija: 10
ABC
pozicija: 13
JKL
JKLMN
12345
dnja!
11.5
preimenovanje, kopiranje i brisanje datoteka
http://docs.python.org/2/library/shutil.html
Izvorni kod 11.5: Kopiranje, micanje i preimenovanje datoteka

1
2
3
# simply
import os
os.rename(a.txt,b.kml)
4
5
6
7
# or
import shutil
shutil.move(a.txt, b.kml)
8
9
10
11
12
# or if you want to copy..

import shutil
shutil.copy(a.txt, b.kml)
11.6
1
2
3
4
5
6
arhiviranje
from shutil import make_archive

import os
archive_name = os.path.expanduser(os.path.join(~, myarchive))
root_dir = os.path.expanduser(os.path.join(~, .ssh))
make_archive(archive_name, gztar, root_dir)
/Users/tarek/myarchive.tar.gz
12
P Y T H O N S TA N D A R D L I B R A R Y
http://docs.python.org/2/library/index.html
12.1
informacije o platformi i operacijskom sustavu
http://www.pythonforbeginners.com/systems-programming/how-to-use-the-platform-module-in-python/
12.2
matemati cke
funkcije
Python modul math sadri standardne matematicke funkcije za realne brojeve koje su definirane C standrdom, s kojima se najcece susrecemo prilikom pisanja nekog programa.
Funkcija
Opis
math.fabs(x)
Funkcija vraca apsolutnu vrijednost realnog broja x.
math.fsum(niz)
Funkcija vraca sumu elemenata nekog niza brojeva.
math.isnan(x)
Funkcija vraca True ako je x tipa NaN.
math.exp(x)
Exponencijalna funkcija ex .
math.log(x, b)
Funkcija logb (x) odnosno ln(x) ako se ne zada b.
math.cos(x)
Funkcija vraca kosinus kuta x zadanog u radijanima.
math.acos(x)
Inverz funkcije kosinus.
math.e
Matematicka konstanta e=2.718281828459045...

Tablica 12.1: Opis nekih funkcija math modula
Primjer upotrebe nekih funkcija math modula:

1
2
3
4
#!/usr/bin/python
from math import log,e,fsum
print log(e)
print fsum([1,2,3])
1.
6.
Python modul cmath sadri standardne matematicke funkcija nad poljem

kompleksnih brojeva. Argumenti funkcija mogu biti tipa float ili complex.
Funkcija
Opis
cmath.polar(x)Funkcija vraca polranu (r,) reprezentaciju kompleksnog broja x.

cmath.sqrt(x) Funkcija vraca korijen kompleksnog broja
Tablica 12.2: Opis nekih funkcija cmath modula
Primjer upotrebe nekih funkcija cmath modula:

1
2
from cmath import sqrt

sqrt(1.+2.j)
(1.272019649514069+0.7861513777574233j)
63
64
python standard library
Python modul decimal omogucuje racunanje i pravilno zaokruivanje realnih brojeva u aritmetici s proizvoljnim brojem decimalnih mjesta.
Primjer upotrebe nekih funkcija math modula:
1
2
3
4
5
6
#!/usr/bin/python
from decimal import *
getcontext().prec = 6
print Decimal(1) / Decimal(3)
getcontext().prec =30
print Decimal(1) / Decimal(3)
0.333333
0.333333333333333333333333333333
12.3
datum i vrijeme
http://www.tutorialspoint.com/python/python_date_time.htm
12.4
vrijeme izvravanja
Ucinkovitost odredenog
algoritma, djela izvornog koda ili pak cijelog izvornog koda vrlo je bitan faktor ukupne kvalitete racunalnog programa. Ucin
kovitost odredenog
izvornog koda se, prije svega, moe mjeriti vremenom
izvodenja
tog koda.
Treba imati na umu da vrijeme izvodenja

ovisi o hardverskim resursima
racunala pa su stoga rezultati razliciti ovisn o racunalu na kojem se testiranje vri. Vrijeme izvravanja ovisi i o trenutnom opterecenju hardverskih
resursa (operativni sustav, sistemski servisi i pokrenute aplikacije), pa c e, u
manjoj mjeri, testiranja na istom racunalu biti razlicita.
Vrlo elegantan nacin za mjerenje vremena izvravanja odredenog

djela
koda je upotrebom funkcija clock i time iz modula time.
time funkcija daje trenutno vrijeme u sekundama od 00:00 1. sijecnja 1970.
godine.
Funkcija clock je preciznija i primjerenija mjerenju vremena izvravanja,
ali razlicito funkcionira na Linux (Unix) i MS Windows platformama:
time.clock() ili
time.time() se
? na Linux platofrmi, time.clock() daje utroeno procesorsko vrijeme,

tj. koliko je sekundi procesor bio opterecen,
mogu pozivati vie

puta te na taj nacin
mjeriti vrijeme
izvravanja vie
djelova izvornog
koda.
? na MS Windows platformi, time.clock() daje ukupno utroeno vrijeme koje obuhvaca vrijeme racunanja (procesor) ali i utroeno vrijeme
na c itanje datoteka (disk) ili npr. utoreno vrijeme na uspostavljanje
konekcije preko nekog mrenog protokola.
Kod mjerenja izvravanja koda koji radi sa c itanje ili pisanjem datoteka ili
koji vri komunikaciju preko mrenih protokola, rezultati c e biti ovisni i o
platformi na kojoj se kod izvrava.
Izvorni kod 12.1: Primjer mjerenja vremena izvravanje algoritma
1
2
#!/usr/bin/python
# -*- coding: utf-8 -*-
3
4
import time
5
6
7
8
# dohvati vrijeme po
cetka
start_c = time.clock()
start_t = time.time()
12.4 vrijeme izvravanja
9
10
print Start clock: %.5f % start_c

print Start time: %.5f % start_t
11
12
13
14
15
16
17
# Algoritam
a = 0.0
for i in range(1000):
for j in range(i):
a = a + (i - j)**0.3
18
19
20
21
22
23
# dohvati vrijeme zavretka

stop_c = time.clock()
stop_t = time.time()
print Stop clock: %.5f % stop_c
print Stop time: %.5f % stop_t
24
25
26
27
print Rezultat: %.2f % a

print Vrijeme izvrsavanja (clock): %.3f ms % (stop_c - start_c)
print Vrijeme izvrsavanja (time): %.3f ms % (stop_t - start_t)
Start clock: 0.01000
Start time: 1373797428.12780
Stop clock: 0.12000
Stop time: 1373797428.23620
Rezultat: 2656321.74
Vrijeme izvrsavanja (clock): 0.110 ms
Vrijeme izvrsavanja (time): 0.109 ms
Python Standard Library sadri klasu Timer koja omogucuje mjerenje vremena izvravanja Python izraza.
Izvorni kod 12.2: Primjer upotrebe Timer klase za mjerenje vremena izvodenja
funkcije
1
2
#!/usr/bin/python
# -*- coding: utf-8 -*-
3
4
5
import timeit
6
7
8
9
10
11
# Algoritam
def f(x):
s = 0.0
for i in range(x):
s = s * sqrt(s+x)
12
13
t = timeit.Timer(stmt=f(500), setup=from __main__ import f)
14
15
16
r1 = t.timeit(number=1000)
print Potrebno vrijeme za 1000 poziva funkcije f(500): %.5f % r1
17
18
19
20
21
r5 = t.repeat(number=1000, repeat=5)
print \nPonavljanje testa (5 puta):
for r in r5:
print Potrebno vrijeme za 1000 poziva funkcije f(500): %.5f % r
Potrebno vrijeme za 1000 poziva funkcije f(500): 0.05833
Ponavljanje testa (5 puta):
Potrebno vrijeme za 1000 poziva
funkcije
funkcije
funkcije
funkcije
funkcije
f(500):
f(500):
f(500):
f(500):
f(500):
0.05900
0.05927
0.05888
0.05953
0.05925
65
13
GREKE U PYTHON KODU
13.1
tipovi greaka
Vecina programskih jezika posjeduje odredene

usluge prema korisniku koje
omogucuju identificiranje i manipulaciju greaka u pisanom izvornom kodu
te davaju korisna objanjenja vezana uz izvor greke ili nacin kako ih ukloniti. Python slijedi takvu logiku i omogucuje prijavljivanje dva tipa greaka:
? Sintaksne greke Syntax Error i
? Iznimke (eng. Exceptions)
Obje greke utvrduju

se iskljucivo tijekom izvodenja
tj. interpretiranja
koda: sintaksne greke na pocetku izvodenja

koda, a iznimke za svaki iz
vreni red koda. Nakon to Python identificira prvu greku na koju naide
program stane sa izvravanjem i objavi poruku slijedeceg izgleda
>>> print c
NameError: name c is not defined
Traceback obavjetava korisnika o tome gdje je greka pronadena

i daje opis
greke pomocu sintaksne greke ili iznimke (eng. exception) koja objanjava
razlog prekida izvravanja programa. U navedenom primjeru NameError je
iznimka koja opisuje greku pri pozivu imena c.
Sintaksne greke testiraju svaku liniju koda netom prije izvodenja

cijelog
programa i utvrduju
svaku nepravilnost u sintaksi programskog jezika. Npr.
1
j=1
2
3
4
5
6
7
if j<2:
print Help
else:
if True
print Help2
File "/home/mcavrak/.spyder2/.temp.py", line 7
if True
^
SyntaxError: invalid syntax
prilikom izvodenja
ovog koda program nikada niti nece uci u else jer je
uvjet if naredbe takav da vraca True, medutim

program svejedno vraca greku prilikom provere sintakse (nedostaje dvoto
cka iza True)
na njih.
No, iznimke c e program objaviti samo ako naide
na greku (pogreno upisana varijabla i, trebalo je
Primjer kada naide
j):
1
j=1
2
3
4
5
if j<2:
print Help
print i
67
68
greke u python kodu
Help
File "/home/mcavrak/.spyder2/.temp.py", line 6, in <module>
print i
NameError: name i is not defined
na greku:
Primjer kada ne naide
1
j=1
2
3
4
5
6
if j<2:
print Help
else:
print i
Help
Najcece iznimke koje susrecemo su:

? ZeroDivisionError
pokuaj operacije djeljenja sa nulom
>>> 10 * (1/0)
File "<stdin>", line 1, in ?
ZeroDivisionError: integer division or modulo by zero
? NameError
pokuaj operacije sa varijablom c ije ime (name) nije u popisu imena
(namespace)
>>> 4 + i*3
NameError: name i is not defined
? TypeError
Pokuaj izvravanja operacije na krivom tipu podataka
>>> 2 + 2
TypeError: cannot concatenate str and int objects
Postoji jo mnogo iznimaka te ih je moguce pronaci na http://docs.python.org/

.
No, iznimkama moemo manipulirati, tj. moguce je ugraditi u kod identifikaciju greke te djelovanje sukladno tome. O tome vie u slijedecem poglavlju.
2/library/exceptions.html#bltin-exceptions
13.2
manipulacija grekama - exception handling
Iznimkama moemo manipulirati, tj. moemo prihvatiti informaciju o greki

te djelovati u skladu sa njom ili granati kod tako da nastavi sa izvravanjem
unatoc greki. Razmotrimo primjer kada korisnik unosi brojeve na konzoli
pomocu raw_input naredbe.
1
2
3
var=raw_input(Unesi broj:)
a=int(var)
print a
Python vraca iznimku ValueError jer nije u stanju pretvoriti preuzeti

string u cjelobrojnu vrijednost.
13.3 ispravljanje greaka - debugging
Unesi broj:z
File "/home/flood/untitled0.py", line 9, in <module>
a=int(var)
ValueError: invalid literal for int() with base 10: z
Kako bi izbjegli takvu greku i prihvatili iznimku posluiti c emo se sa try

- except formulacijom:
1
var = raw_input(Unesi broj:)
2
3
4
5
6
7
8
9
try:
a = int(var)
print SUCCESS
except ValueError:
print Nije uneen broj!
print Broj postavljen na defaultnu vrijednost 0.
a = 0
10
11
print a
U ovom kodu izvren je prihvat iznimke na nacin da je:

? uneena kljucna rijec try c ije se tijelo prvo izvrava
na iznimku tada program preskace dio tijela
? ako program ne naide
koji pripada except sekciji i nastavlja sa kodom (print a).
na iznimku u try sekciji koda tada se zaustavlja na
? ako program naide
mjestu gdje je naao greku, ne nastavlja dalje sa preostalim djelom
koda (print SUCCESS) vec skace na except sekciju koja odgovara iznimki koju je uhvatio (u ovom slucaju ValueError) te potom nastavlja
sa kodom (print a)
na vrstu iznimke opisanu u except sekciji
? ukoliko program ne naide
tada izbaci greku u obliku neuhvacene iznimke (eng. unhandled exception)
Pored ovog osnovnog koncepta primjene prihvata iznimaka, moguce je
podici iznimku prema korisnickoj elji te izraditi korisnicki definirane iznimke. Ove funkcionalnosti nadilaze osnove i c itatelj je slobodan potraiti
vie informacija na http://docs.python.org/2/tutorial/errors.html.
13.3
ispravljanje greaka - debugging
Python ima modul pdb (Python DeBugger") koji pomae kod otkrivanja i
ispravljanja greaka u kodu skripte. Ako ne koristite neki specijalizirani editor unutar nekog razvojnog okruenja tada je potrebno pozvati pdb modul
na pocetku skripte:
1
import pdb
Na nekom kljucnom mjestu u kodu na kojem se elite zaustaviti morate

staviti naredbu:
1
pdb.set_trace()
na primjeru 13.1 moe se vidjeti upotreba pdb modula.

Ako koristite editor Spyder tada nije nuno pozvati pdb modul. Dovoljno
je postaviti prekide u kodu dvostrukim lijevim klikom na lijevoj strani dokumenta i pokrenuti skriptu u Debug nacinu rada.
(Pdb)
69
70
greke u python kodu
Unutar pdb modula moguce je kontrolirati izvravanje koda, a najcece se

koriste naredbe:
? n (next) izvrava se sljedeca naredba u skripti,
? c (continue) izvreava se ostatak skripte do sljedeceg prekida,
? s (step into) pdb ulazi u podprogram ili funkciju,
? r (return) slicno kao naredba c, ali pdb izvrava ostatak podprograma
ili funkcije do izlaza iz podprograma,
? p var (print) pdb istpis stanja varijable var
? ENTER pdb izvrava zadnju naredbu koja mu je poslana,
? q (quit) zaustavlja izvravanje skripte.
Izvorni kod 13.1: Upotreba dbg modula
1
2
#!/usr/bin/python
import pdb
3
4
5
6
7
8
9
10
11
12
pdb.set_trace()
a=0
b=1
c=2
pdb.set_trace()
a=b+c
pdb.set_trace()
a=b-c
print kraj
Dio II
NUMPY
14
Z A D AVA N J E P O L J A U N U M P Y- U
Bazni objekt u NumPy-u, ndarray, je homogeno multidimenzionalno polje.

Homogenost polja podrazumijeva da su svi podaci u polju istog tipa. U
NumPy-u, dimenzije se nazivaju axes a broj dimenzija rank.
Elementi polja su indeksirani pozitivnim cijelim brojevima.
NumPy polja se mogu zadavati na vie nacina. Bazicno, zadavanje polja
se moe podjeliti na rucni unos pomocu naredbe array te na automatsko
generiranje polja. NumPy polja mogu se automatski generirati pomocu neke
od naredbi za generiranje polja.
14.1
array
Naredba array omogucava kreiranje NumPy polja iz obicnih Python listi

ili tuple-ova. Prilikom kreiranja polja pomocu array naredbe, u argument
funkcije upisuju se elementi matrice i to na nacin da svaka dimnezija zapocinje otvornemo uglatom zagradom ([) i zavrava zatvorenom uglatom
zagradom (]) dok su elementi razdvojeni zarezom.
Najjednostavnija sintaksa naredbe array je:
array(object)
Ako je argument naredbe array tuple, onda pojedina dimenzija zapocinje

i zavrava sa zagradama. Pri tome treba paziti da je argumnet naredbe array
samo jedan tuple (cijeli tuple mora biti u jednim zagradama). Moguce je
kombinirati Python liste i tuple-ove prilikom zadavanja matrice.
>>> from numpy import *
>>> M1 = array([[1, 2, 3],[4, 5, 6]])
>>> M1
array([[1, 2, 3],
[4, 5, 6]])
>>> M2 = array( ( (6,7,8), (9,10,11) ) )
>>> M2
array([[ 6, 7, 8],
[ 9, 10, 11]])
>>> M3 = array( ( [6,7,8], (9,10,11) ) )
>>> M3
array([[ 6, 7, 8],
[ 9, 10, 11]])
Dodatni, neobavezni argumenti naredbe array su:

dtype - eljeni tip podataka za elemente polja. Ako argument nije zadan, elementi polja c e preuzeti minimalni tip potreban za pohranu podataka iz objekta object. Ovaj argument se moe koristiti samo za povecati
(eng. upcast) tip zadanog objekta. Za smanjiti (eng. downcast) tip koristiti
.astype(t) naredbu.
copy - bool varijabla (True ili False) koja odreduje

da li se objekt kopira.
order - odreduje
nacin na koji se polje pohranjuje u memoriji. Polje moe
biti pohranjeno na tri nacina:
? C - elementi polja c e biti poredani u memoriji na nacin da zadnji
indeks varira najbre (C-povezani poredak)
? F - elementi polja c e biti poredani u memoriji na nacin da prvi indeks varira najbre (Fortran-povezani poredak)
73
74
zadavanje polja u numpy-u
? A - elementi polja nece imati definiran poredak u memoriji (C-povezani

poredak, Fortran-povezani poredak ili c ak nepovezani poredak)
subok : bool, optional If True, then sub-classes will be passed-through,
otherwise the returned array will be forced to be a base-class array (default).
ndmin - minimalni broj dimenzija generiranog polja. Prema potrebi, broj
dimenzija c e biti povecan na nacina da c e jedinice biti dodane u shape polja.
14.2
arange
Naredba arange omogucuje kreiranje jednodimenzionalnog polja koje sadri aritmeticki niz definiran sa prvim c lanom, zadnjim c lanom te korakom.
Sintaksa naredbe je
arange(start, stop, step, type)
Oprez! Prilikom
koritenja
ne-cjelobrojnih
koraka niza rezultat
naredbe array moe
biti nekonzistentan.
U takvim
slucajevima bolje je
koristiti naredbu
linspace (14.3).
gdje je start pocetak niza, stop kraj niza, step korak niza a type je tip
podataka sadranih u nizu.
Svi argumennti naredbe arange osim stop su neobavezni i ukoliko nisu
uneseni imaju zadane vrijednosti:
? start ima zadanu vrijednost 0
? step ima zadanu vrijednost 1 te zahtijeva i zadavanje argumenta start
? type ako nije zadan, postavlja se tipa na temelju ostalih argumenata.
>>> M1 = arange(10, 30, 3)
>>> M1
array([10, 13, 16, 19, 22, 25, 28])
>>> M2 = arange(-2, 3)
>>> M2
array([-2, -1, 0, 1, 2])
>>> M3 = arange(5)
>>> M3
array([0, 1, 2, 3, 4])
14.3
linspace
Naredba linspace ima slicnu namjenu kao i naredba arange (kreiranje aritmetickog niza) samo to se umjesto koraka niza zadaje broj c lanova niza.
I sintaksa naredbe je vrlo slicna naredbi arange:
linspace(start, stop, num=50, endpoint=True, retstep=False)
gdje je start pocetak niza, stop kraj niza, num broj elemenata niza, endpoint
je opcija ukljucivanja zadnjeg elementa a retstep je opcija vracanja koritenog koraka niza.
>>> M1=linspace(0,10,21)
>>> M1
array([ 0. ,
0.5,
1. ,
1.5,
2. ,
2.5,
3. ,
3.5,
4. ,
4.5,
5. ,
5.5,
6. ,
6.5,
7. ,
7.5,
8. ,
8.5,
9. ,
9.5, 10. ])
>>> M2 = linspace(0, 5, 10, endpoint=False)
>>> M2
array([ 0. , 0.5, 1. , 1.5, 2. , 2.5, 3. , 3.5, 4. , 4.5])
>>> M3, step = linspace(0, 1, retstep=True)
>>> M3
array([ 0.
, 0.02040816, 0.04081633, 0.06122449, 0.08163265,
0.10204082, 0.12244898, 0.14285714, 0.16326531, 0.18367347,
0.20408163, 0.2244898 , 0.24489796, 0.26530612, 0.28571429,
14.4 zeros
0.30612245,
0.40816327,
0.51020408,
0.6122449 ,
0.71428571,
0.81632653,
0.91836735,
>>> step
0.02040816326530612
14.4
0.32653061,
0.42857143,
0.53061224,
0.63265306,
0.73469388,
0.83673469,
0.93877551,
0.34693878,
0.44897959,
0.55102041,
0.65306122,
0.75510204,
0.85714286,
0.95918367,
0.36734694,
0.46938776,
0.57142857,
0.67346939,
0.7755102 ,
0.87755102,
0.97959184,
75
0.3877551 ,
0.48979592,
0.59183673,
0.69387755,
0.79591837,
0.89795918,
1.
])
zeros
Naredba zeros omogucava generiranje polja koje sadri nule. Osnovna sintaksa naredbe zeros je
zeros(shape)
gdje je shape lista koja sadri velicine dimenzija.

Osim velicine dimnezija, postoje i dodatni neobavezni argumenti za definiranje tipa podataka te nacina spremanja polja u memoriju:
zeros(shape, dtype=float, order=C)
Za generiranje polja nula moe posluiti i naredba zeros_like koja generira polje nula istih dimenzija kao neko postojece polje. Sintaksa naredbe
je:
zeros_like(a)
gdje je a matrica c ije dimenzije treba preuzeti.

>>> a = zeros([3, 5])
>>> print a
[[ 0. 0. 0. 0. 0.]
[ 0. 0. 0. 0. 0.]
[ 0. 0. 0. 0. 0.]]
>>> b = array([2, 5, 6, 0])
>>> print b
[2 5 6 0]
>>> c = zeros_like(b)
>>> print c
[0 0 0 0]
14.5
Naredba
zeros_like ima
dodatne argumente
dtype i order.
dtype omogucuje
nametanje tipa
podataka za
generirano polje, a
ako nije specificiran
onda generirano polje
nasljeduje
tip
podataka od
argumenta a. order
omogucuje
mijenjanje rasporeda
spremanja polja u
memoriju.
ones
Za generiranje matrice zadanih dimenzija koja sadri jedinice koristi se naredba ones. Sintaksa naredbe je vrlo ista kao i kod naredbe zeros:
ones(shape, dtype=float, order=C)
Za kreiranje matrice, koja sadri jedinice istih dimenzija kao neka postojeca matrice, koristi se ones_like naredba:
ones_like(a)
gdje je a matrica c ije dimenzije treba preuzeti.

>>> a = ones([2,4])
>>> print a
[[ 1. 1. 1. 1.]
[ 1. 1. 1. 1.]]
>>> b = ones([3, 2],dtype=int)
>>> print b
Naredba ones_like
ima dodatne
argumente dtype i
order koji
funkcioniraju
jednako kao to je
opisano za naredbu
zeros_like.
76
zadavanje polja u numpy-u
[[1 1]
[1 1]
[1 1]]
>>> c = array([5, 8])
>>> d = ones_like(c)
>>> print d
[1 1]
14.6
eye
Generiranje dvodimenzionalne jedinicne matrice (sadri jedinice na dijagonali a ostalo su nule) moguce je sa naredbom eye. Potpuna sintaksa naredbe
eye je:
Naredba eye
omogucuje
generiranje iskljucivo
dvodimenzionalnih
jedinicnih matrica.
eye(N, M=None, k=0, dtype=<type float>)
gdje je N broj redaka generiranog polja, M broj stupaca generiranog polja

(ako nije zadano, broj stupaca je jednak broju redaka), k indeks dijagonale
(0 je glavna dijagonala, pozitivna vrijednost se odnosi na dijagonale iznad a
negativna na dijagonale ispod glavne dijagonale) dok je dtype tip podataka
generiranog polja.
>>> a = eye(4)
>>> print a
[[ 1. 0. 0. 0.]
[ 0. 1. 0. 0.]
[ 0. 0. 1. 0.]
[ 0. 0. 0. 1.]]
>>> b = eye(5, 3)
>>> print b
[[ 1. 0. 0.]
[ 0. 1. 0.]
[ 0. 0. 1.]
[ 0. 0. 0.]
[ 0. 0. 0.]]
>>> c = eye(3, 5, 1)
>>> print c
[[ 0. 1. 0. 0. 0.]
[ 0. 0. 1. 0. 0.]
[ 0. 0. 0. 1. 0.]]
14.7
diag
Cesto
su brojevi na dijagonali matrice vani u proracunu i javlja se potreba
da ih se spremi u zasebnu varijablu. Naredba diag omogucuje upravo to:
generira vektor koji sadri elemenate dijagonale zadane matrice.
Sintaksa naredbe je vrlo jednostavna. Funkcija diag obavezno prima, kao
argument, matricu iz koje se eli preuzeti dijagonala. Dodatni argument,
k, specificira poloaj (indeks) dijagonale: 0 je glavna dijagonala, pozitivna
vrijednost se odnosi na dijagonale iznad a negativna na dijagonale ispod
glavne dijagonale.
diag(v, k=0)
Izvorni kod 14.1: Spremanje elemenata dijagonale matrice u vektor

1
2
3
4
from
M1 =
v1 =
v2 =
numpy import *
array([[1, 2, 3],[4, 5, 6],[7, 8, 9]])
diag(M1)
diag(M1,1)
14.8 meshgrid
5
6
7
8
print M1
print v1
print v2
user@machine:~> python diag01.py
[[1 2 3]
[4 5 6]
[7 8 9]]
[1 5 9]
[2 6]
14.8
meshgrid
Naredba meshgrid slui za generiranje matrice koordinata na temelju vektora koordinata.

>>> import numpy as np
>>> x = np.linspace(0, 5, 6)
>>> y = np.linspace(10, 50, 5)
>>> X, Y = np.meshgrid(x, y)
>>> print x
[ 0. 1. 2. 3. 4. 5.]
>>> print y
[ 10. 20. 30. 40. 50.]
>>> print X
[[ 0. 1. 2. 3. 4. 5.]
[ 0. 1. 2. 3. 4. 5.]
[ 0. 1. 2. 3. 4. 5.]
[ 0. 1. 2. 3. 4. 5.]
[ 0. 1. 2. 3. 4. 5.]]
>>> print Y
[[ 10. 10. 10. 10. 10. 10.]
[ 20. 20. 20. 20. 20. 20.]
[ 30. 30. 30. 30. 30. 30.]
[ 40. 40. 40. 40. 40. 40.]
[ 50. 50. 50. 50. 50. 50.]]
meshgrid je vrlo korisna kod evaluacije funkcija na mrei tocaka:

>>> import numpy
>>> x = numpy.linspace(0, 3, 4)
>>> y = numpy.linspace(0, 5, 6)
>>> xx, yy = numpy.meshgrid(x, y, sparse=True)
>>> z = numpy.cos(xx + yy**2) - numpy.sin(xx**2 - yy)
>>> z
array([[ 1.
, -0.30116868, 0.34065566, -1.40211098],
[ 1.38177329, -0.41614684, -1.1311125 , -1.64300187],
[ 0.25565381, 1.12513317, 0.05087286, 0.09691566],
[-0.77001025, 0.0702259 , -0.83704529, 1.12326946],
[-1.71446198, -0.13404333, 0.66031671, 1.94762889],
[ 0.03227854, -0.10988317, 0.54933218, -0.20580337]])
77
15
INFORMACIJE O POLJU I INDEKSIRANJE
15.1
informacije o polju
Svako NumPy polje ima definiran broj dimenzija, koji se lako moe provjeriti pomocu ndim atributa polja.
ndarray.ndim
ili pomocu naredbe ndim

ndim(ndarray)
gdje je ndarray numpy polje.

broj elemenata polja.
Za svaku dimenziju, polje ima rezerviran odreden
Broj elemenata po dimenzijma polja c ini niz koji se moe dobiti preko atributa shape
ndarray.shape
ili preko naredbe shape

shape(ndarray)
Ukupan broj elemenata u polju se odreduje

naredbom size
size(ndarray)
ili atributom numpy polja

ndarray.size

Izvorni kod 15.1: Osnovne informacije o NumPy polju
1
from numpy import *
2
3
M1 = array([[1, 2, 3], [4, 5, 6]])
4
5
6
7
8
9
10
print
print
print
print
print
print
M1.ndim
ndim(M1)
M1.shape
shape(M1)
M1.size
size(M1)
2
2
(2, 3)
(2, 3)
6
6
15.2
indeksiranje polja
Pristupanje elementima Numpy polja vri se pomocu indeksa na slican nac in kao i sa listama. Indeks oznacuje poziciju elementa polja i to pomocu
cijelog broja pocevi od nule. Kod jednodimenzionalnih polja (vektori), vrijednostima se pristupa preko jednog indeksa upisanog u uglate zagrade.
79
80
informacije o polju i indeksiranje
Svaki sljedeci element vektora ima indeks za jedan veci od prethodnog, to

znaci da je indeks zadnjeg elementa jednak ukupnom broju elemenata vektora umanjenom za jedan. Svaki indeks koji je jedank ili veci broju elemenata
vektora je indeks nepostojeceg elementa vektora i koritenje tog indeksa c e
prouzrociti greku.
>>> import numpy as np
>>> V = np.array([6.0, 2.2, 3.0, 5.8, 5.4, 0.8])
>>> n = np.size(V)
>>> print n
6
>>> indeksi = range(n)
>>> print indeksi
[0, 1, 2, 3, 4, 5]
>>> for i in indeksi:
...
print V[i]
...
6.0
2.2
3.0
5.8
5.4
0.8
>>> print V[6]
IndexError: index out of bounds
Indeksi u jednom
paru uglatih zagrada
(npr. M[2,4]) su
zapravo tuple, pa se
pristupanju
odredenom
elementa
moe vriti i preko
tuplea indeksa (poz
= (3, 1); print
M[poz]).
Indeksiranje viedimenzionalnih polja je analogno jednodimenzionalnim

poljima, za svaku dimenziju se koristi po jedan indeks. Elementima polja se
moe pristupati sa indeksima svake dimenzije upisanim u uglate zagrade ili
sa indeksima upisanim u jedne uglate zagrade a razmaknutim sa zarezima.
Izvorni kod 15.2: Manipulacije sa poljima pomocu indeksa
1
# -*- coding: utf-8 -*-
2
3
import numpy as np
4
5
6
7
8
9
M = np.array([[ 1, 2, 3, 4,
[ 6, 7, 8, 9,
[11, 12, 13, 14,
[16, 17, 18, 19,
[21, 22, 23, 24,
5],
10],
15],
20],
25]])
10
11
12
13
print M[2, 4]
poz = (3, 2)
print M[poz]
# ispii element na poziciji 2,4

# definiraj poziciju 3,2
# ispii element na poziciji poz
print M[1:-1,1:-1]
print M[:,::-1]
print M[::2]
# ispii dio polja bez prvih i zadnjih redaka i stupaca

# ispii polje sa obrnutim redoslijedom stupaca
# Ispii svaki drugi redak polja
14
15
16
17
15
18
[[ 7
[12
[17
[[ 5
[10
[15
[20
[25
[[ 1
[11
[21
8
13
18
4
9
14
19
24
2
12
22
9]
14]
19]]
3 2
8 7
13 12
18 17
23 22
3 4
13 14
23 24
1]
6]
11]
16]
21]]
5]
15]
25]]
16
MANIPULACIJE SA NUMPY POLJIMA
16.1
manipulacije sa dimenzijama polja
Elementi NumPy polja odredenih

dimenzija, mogu se presloiti u NumPy
polje drukcijih dimenzija. Preslagivanje polja na druge dimenzije vri se
pomocu naredbe reshape:
reshape(a, newshape, order=C)
gdje je a izvorno polje, newshape vektor novih dimenzija a order je nacin

spremanja polja u matricu.
Uvijet za reshape je da broj elemenata polja ostane isti tj. umnoak velicina
dimenzija mora biti konstantan.
Specificni slucaj mijenjanja dimenzija polja je kada inicijalno polje elimo
transformirati u jednodimenzionalno polje tj. vektor. Iako je to moguce napraviti sa naredbom reshape, postoji specijelizirana naredba ravel za transformaciju n-dimnezionalnih polja u jednodimenzionalna polja. Sintaksa naredba je vrlo slicna kao i za reshape osim to nije potrebno specificirati
vektor velicina dimenzija jer je rezultat uvijek jednodimenzionalno polje.
ravel(a, order=C)
Za pretvorbu matrice u vektor koristi se i naredba flatten. Razlika je to

je ovo funkcija ndarray objekta i uvijek kreira kopiju polja.
flatten(order=C)
Izvorni kod 16.1: Mijenjanje dimenzija polja

1
from numpy import *
2
3
4
M1 = arange(0, 20)
print M1
5
6
7
8
9
M2 = reshape(M1, [4, 5])

print M2
M3 = reshape(M2, [2, -1])
print M3
10
11
12
print ravel(M2)
print M3.flatten()
[ 0
[[ 0
[ 5
[10
[15
[[ 0
[10
[ 0
[ 0
1
1
6
11
16
1
11
1
1
2
2
7
12
17
2
12
2
2
3
3
8
13
18
3
13
3
3
4 5
4]
9]
14]
19]]
4 5
14 15
4 5
4 5
9 10 11 12 13 14 15 16 17 18 19]
6 7 8 9]
16 17 18 19]]
6 7 8 9 10 11 12 13 14 15 16 17 18 19]
6 7 8 9 10 11 12 13 14 15 16 17 18 19]
Brisanje jedinicnih dimenzija matrice, koje vrlo c esto znaju biti suvine,
moe se napraviti funkcijom squeeze.
Izvorni kod 16.2: Mijenjanje dimenzija polja
1
from numpy import *
81
Ukoliko se, kod

poziva naredbe
reshape, velicina
jedna od dimenzija
ne specificira, tada se
ona automatski
racuna na temelju
ostalih velicina
dimenzija i ukupnog
broja elemenata
inicijalne matrice.
82
manipulacije sa numpy poljima
2
3
M1 = arange(0, 20)
4
5
6
M2 = reshape(M1, [4, 1, 1, 5])

print M2.shape
7
8
9
M3 = squeeze(M2)
print M3.shape
(4, 1, 1, 5)
(4, 5)
16.2
transponiranje
Transponiranje matrica moguce je izvesti na dva nacina:

? funkcijom transpose
? atributom T
Izvorni kod 16.3: Transponiranje matrica
1
from numpy import *
2
3
4
5
6
7
M1 = array([
[1, 0, 3, 4],
[2, 2, 7 ,8],
[6, 8, 3, 0],
[9, 8, 2, 1]])
8
9
10
M2 = M1.T
print M2
11
12
13
M3 = transpose(M1)
print M3
[[1
[0
[3
[4
[[1
[0
[3
[4
2
2
7
8
2
2
7
8
16.3
6
8
3
0
6
8
3
0
9]
8]
2]
1]]
9]
8]
2]
1]]
dodavanje i brisanje elemenata polja
17
I TAVA N J E I S P R E M A N J E N U M P Y P O L J A
UC
Vrlo se c esto deava da se rezultati raznih proracuna ili mjerenja spremaju u

tekstualne datoteke. Takve datoteke, svaka zapisana u svom formatu c esto
se ucitavaju u Python za daljnju obradu, vizualizaciju ili provjeru. Numpy
prua gotove funkcije za automatizirano ucitavanja tablicnih podataka u
NumPy polja.
Jednako bitno je i mogucnost spremanja podataka iz NumPy polja u tekstualne datoteke.
Osim tekstualnih datoteka, ucitavanje i spremanje NumPy polja moguce
je i sa binarnim datotekama.
17.1
u citavanje
iz tekstualnih datoteka
Ucitavanje numerickih vrijednosti iz tekstualnih datoteka u numpy polja

vri se sa naredbom loadtxt. Podrazumijeva se da su brojevi u tekstualnoj
datoteci zapisani u retcima koji svi imaju jednak broj zapisanih vrijednosti.
Arumenti naredbe loadtxt omogucuju detaljnije odredivanje

ucitavanja tek
stualne datoteke pomocu razdvojnika, komentara, odredivanja
pasivnih poc etnih redaka te odabir stupaca za ucitavanje i dr.
Sintaksa naredbe sa najcece koritenim argumentima je:
loadtxt(fname, comments, delimiter, skiprows, usecols)
gdje je fname ime datoteke iz koje se ucitavaju podaci, comments je simbol

kojim zapocinju pasivni retci (komentari), delimiter je simbol(i) kojim su
razdvojene vrijednosti u retcima, skiprows je broj pocetnih redaka koji se
preskacu prilikom ucitavanja a usecols je lista indeksa stupaca koji se ucitavaju.
Izvorni kod 17.1: Sadraj datoteke data.txt
1
2
Tehni
cki fakultet
Zavod za mehaniku fluida i ra
cunarko inenjerstvo
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
1
2
3
4
5
8.14
28.72
8.37
26.79
4.41
26.55
6.74
22.48
5.30
24.30
* ovo je komentar
6
6.11
22.14
7
2.10
25.96
7.40
24.40
*8
9
0.07
22.04
10 8.45
23.07
11 2.91
22.07
12 9.14
20.70
13 7.62
23.83
-0.12
-0.47
-0.44
-0.55
-0.70
126.04
130.96
125.82
133.24
137.91
5
9
2
0
9
-0.87
-0.90
-0.03
-0.73
-0.47
-0.07
-0.10
-0.51
102.43
137.88
122.03
143.81
137.48
116.26
132.36
111.39
7
2
1
2
0
6
9
1
Izvorni kod 17.2: Ucitavanje iz tekstualne datoteke

1
# -*- coding: utf-8 -*-
2
3
from numpy import *
83
Zadana vrijednost
argumenta
delimiter je None
to znaci da se redak
dijeli na temelju
razmaka
(podrazumijeva i
tabulatore) i vie
uzastopnih razmaka
smatra kao jedan
razmak.

u citavanje
i spremanje numpy polja
84
4
5
6
M = loadtxt(data.txt, skiprows=4, comments=*, usecols=(1, 3, 5))

print M
[[
[
[
[
[
[
[
[
[
[
[
[
8.14
8.37
4.41
6.74
5.3
6.11
2.1
0.07
8.45
2.91
9.14
7.62
-0.12
-0.47
-0.44
-0.55
-0.7
-0.87
-0.9
-0.73
-0.47
-0.07
-0.1
-0.51
5.
9.
2.
0.
9.
7.
2.
2.
0.
6.
9.
1.
]
]
]
]
]
]
]
]
]
]
]
]]
Naprednije mogucnosti pri ucitavanju NumPy polja iz tekstualnih datoteka prua naredba genfromtxt.
http://penandpants.com/2012/03/09/reading-text-tables-with-python/
17.2
spremanje u tekstualne datoteke
Naredba savetxt omogucuje jednostavno spremanje NumPy polja u tekstualne datoteke.

savetxt(fname, X, fmt, delimiter, newline, header, footer, comments)
18
NI RAC
UN
M AT R I C
18.1
rjeavanje sustava linearnih jednadbi
Za rjeavanje sustava linearnih jednadbi

Ax = b
(18.1)
koristi se NumPy naredba solve:

solve(a, b)
gdje je a matrica sustava a b vektor slobodnih c lanova.

Izvorni kod 18.1: Rjeavanje sustava linearnih jednadbi
1
from numpy import *
2
3
4
5
6
7
8
A = array([
[ 1.0, 3.0, 6.0],
[-2.0, 0.0, 3.0],
[ 8.0, -2.0, 0.0]
])
b = array([2.0, 6.0, 0.0])
9
10
x = linalg.solve(A, b)
11
12
print x
[-0.58823529 -2.35294118
1.60784314]
85
19
RAD SA POLINOMIMA
19.1
poly1d
Za prakticno i jednostavno baratanje polinomima predvidena

je klasa poly1d
koja omogucuje osnovne operacije i radnje sa polinomima.
Definirnaje instance polinoma pomoc poly1d klase moguce je na dva nac ina. Zadavanjem koeficijenata polinoma:
poly1d(koeficijenti)
ili zadavanjem korijena polinoma:

poly1d(korijeni, True)
Za dobivanje liste koeficijenata polinoma:

p.c
p.coeffs
dok se lista korijena polinoma moe dobiti sa

p.r
p.roots
Evaluacija polinoma p u danoj tocki a moe se vriti kao

p.(a)
gdje a moe biti broj ili ndarray.

Izvorni kod 19.1: Zadavanje polinoma kao poly1d objekta
1
2
3
# -*- coding: utf-8 -*"""

Created on Sat Nov 29 22:21:54 2014
4
5
6
@author: stefan
"""
7
8
9
import numpy as np
import matplotlib.pyplot as plt
10
11
12
13
14
# Zadavanje polinoma preko koeficijenata

p1 = np.poly1d([ 1., -8.3, 1.7, 5.6])
print p1:
print p1
15
16
17
18
19
# Zadavanje polinoma preko korijena

p2 = np.poly1d([-3, -1.02, 6.75], True)
print \np2:
print p2
20
21
22
23
24
# Koeficijenti polinoma
print \nKoeficijetni:
print p1.c
print p2.coeffs
25
26
27
28
29
30
# Korijeni polinoma
x01 = p1.r
x02 = p2.roots
print \nKorijeni:
print x01
87
88
rad sa polinomima
31
print x02
32
33
34
35
x = np.linspace(-6, 10, 200)

y1 = p1(x)
y2 = p2(x)
36
37
38
39
40
41
42
43
plt.plot(x, y1, c = r, label = p1)

plt.plot(x, y2, c = b, label = p2)
plt.plot(x01, np.zeros_like(x01), ro, label = Korijeni p1)
plt.plot(x02, np.zeros_like(x02), bo, label = Korijeni p2)
plt.grid()
plt.legend(loc = best)
plt.show()
p1:
3
2
1 x - 8.3 x + 1.7 x + 5.6
p2:
3
2
1 x - 2.73 x - 24.07 x - 20.66
Koeficijetni:
[ 1. -8.3 1.7
[ 1.
-2.73
5.6]
-24.075 -20.655]
Korijeni:
[ 8.
1. -0.7]
[ 6.75 -3.
-1.02]
600
p1
p2
Korijeni p1
Korijeni p2
400
200
0
200
400
600
Slika 19.1: Graf polinoma iz primjera 19.1
10
Dio III
PRIPREMA, OBRADA I VIZUALIZACIJA
P O D ATA K A
20
OSNOVNI 2D GRAFOVI
Terminologija:
? Figure = prozor
? Axes = prostor crtanja
? Axis = osi
Prozor
Prostor crtanja
Prostor crtanja
Os y
Os y
Os x
Os x
Slika 20.1: Matplotlib elementi
20.1
linijski grafovi
Osnovna naredba u matplotlibu je plot i slui za crtanje grafova pomocu

linija ili tocaka. Osnovna sintaksa naredbe je
plot(y)
plot(x, y)
gdje su x i y vektori koordinata tocaka koje elimo vizualizirati. U slucaju da

vektor x koordinata nije zadan, koristi se uniformni vektor [0, 1, 2, ...,
n] gdje je n broj c lanova vektora y. U slucaju da su zadani i vektor x i vektor
y, tada oni moraju imati isti broj c lanova.
Vie uzastopnih plot naredbi c e nacrtati vie linija na istom grafu. Naredba plot ne prikazuje graf, graf se iscrtava na ekranu pozivom funkcije
show.
Izvorni kod 20.1 kreira dva linijska grafa koristeci naredbu plot a potom,
naredbom show, graf prikae na ekranu (Slika 20.2)
Izvorni kod 20.1: Jednostavan graf
1
2
from pylab import *

from numpy import *
3
4
plot([3, 6, 3, 2, 4])
91
92
osnovni 2d grafovi
6
7
8
x = linspace(0, 4, 100)
y = 5*cos(x)/(1 + x**2)
plot(x, y)
9
10
show()
Slika 20.2: Prozor sa grafom napravljen izvodenjem

izvrnog koda 20.1
Dodatni argument naredbe plot omogucuje definiranje izgleda linije i

markera pomocu znakova. Znakovi za definiranje vrste linije, boje linije te
vrste markera kombiniraju se u stringu koji se prosljeduje

funkciji plot.
Simboli za definiranje vrste linije, boje linije i vrste markera prikazani su
u tablicama 20.1, 20.2 i 20.3. Simboli se mogu kombinirati u proizvoljnom
redoslijedu. Ako je izostavljen simbol za boju, primjenjuje se zadana vrijednost boje. Markeri se ne prikazuju izostavljanjem simobla za vrstu markera.
Izostavljanjem simbola za vrstu linije, ako je zadana vrsta markera linija se
ne prikazuje a puna linija se iscrtava u slucaju da vrsta markera nije zadana.
Simbol
Vrsta linije
Puna linija
Crtkana linija
-.
Crta-tocka
Tockasta linija
Tablica 20.1: Vrste linija
20.1 linijski grafovi
Simbol
Boja
Plava
Crvena
Zelena
Cijan
Magenta
uta
Crna
Bijela
Tablica 20.2: Simboli boja
Detaljnije i fleksibilnije definiranje boja opisano je u poglavlju (20.2.1).

Simbol
Vrsta markera
Tockasti
Piksel
Kruni
Trokutasti prema dolje
Trokutasti prema gore
<
Trokutasti prema lijevo
>
Trokutasti prema desno
Kvadratni
Peterokutni
Zvijezdasti
esterokutni 1
esterokutni 2
Plus
Kriic
Romb
Tanki romb
Vertikalna linija
Horizontalna linija
Tablica 20.3: Vrste markera
U izvornom kodu 20.2 upotrebljene su razlicite varijante linija, markera i

boja (Slika 20.3).
Izvorni kod 20.2: Kontrola linija i markera
1
2
from pylab import *

from numpy import *
3
4
5
6
7
plot([1,
plot([3,
plot([2,
plot([5,
8
9
show()
6,
2,
3,
4,
3,
1,
5,
2,
2,
3,
6,
4,
4], r--o)
1], g-.D)
2],r-.x)
5],ks:)
93
94
osnovni 2d grafovi
6
5
4
3
2
10.0
0.5
1.0
1.5
2.0
2.5
3.0
3.5
4.0
Slika 20.3: Graf napravljen izvodenjem

izvornog koda 20.2
20.2
naprednija kontrola linijskih grafova
Bolju kontrolu izgleda linijskih grafova u matplotlibu moguce je ostvariti sa

dodatnim parametrima naredbe plot.
20.2.1
Boje
Argumentom color (ili skraceno c) moguce je preciznije definirati boju linije:

plot(x,
plot(x,
plot(x,
plot(x,
y,
y,
y,
y,
color
color
color
color
=
=
=
=
gray_string)
hex_string)
rgb_tuple)
html_string)
gdje je
? gray_string string koji specificira nijansu sive boje kao udio bijele
(npr. color = 0.72)
? hex_string string koji specificira heksidecimalni zapis RGB boje (npr.
color = #FF8C00)
? rgb_tuple tuple kojim se specificiraju udjeli crvene, zelemne i plave
(RGB) boje (npr. color = (0.1, 0.5, 0.3))
? html_string string koji sadri HTML naziv boje (npr. color=Cyan,
color=Crimson)
20.2.2
Markeri
Izgled markera se moe detaljnije specificirati pomocu vie parametara naredbe plot:
20.2 naprednija kontrola linijskih grafova
? marker za definiranje vrste tj. oblika markera,

? markersize ili ms za definiranje velicine markera,
? markeredgecolor ili mec za definiranje boje ruba markera,
? markeredgewidth ili mew za definiranje debljine ruba markera,
? markerfacecolor ili mfc za definiranje boje lica markera
? markerfacecoloralt ili mfcalt za definiranje izmjenjujuce boje lica
markera,
? markerevery za definiranje koliko tocaka c e biti prikazane (npr. svaka
peta).
1
2
3
4
5
6
plot(x, y, markeredgecolor = r,
markeredgewidth = 2,
markerfacecolor = b,
markerfacecoloralt = g,
markersize = 4,
markerevery = 5)
#
#
#
#
#
#
Boja ruba markera - crvena

Debljina ruba
Boja lica - plava
Izmjenjuju
ca boja lica - zelena
Velicina markera
Crtaj svaki peti marker
Argumentom label omogucuje se oznaka tj. opis krivulje, koji se prikazuje u legendi grafa.
U izvornom kodu 20.3 upotrebljene su razlicite varijante linija, markera i
boja (Slika 20.4).
Izvorni kod 20.3: Naprednija kontrola linija i markera
1
2
from pylab import *

from numpy import *
3
4
5
6
7
8
9
10
11
X = np.linspace(-np.pi, np.pi, 256,endpoint=True)

C,S = np.cos(X), np.sin(X)
X2=[-3, -2, -0.5, 1.2, 2.8]
Y2=[0.3, 0.9, 0.5, 0.1, 0.62]
plot(X, C, color="blue", linewidth=2.5, linestyle="-")
plot(X, S, color="red", linewidth=2.5, linestyle="-")
plot(X2, Y2, color="green", linestyle="-", marker="o", markersize=10)
show()
95
96
osnovni 2d grafovi
1.0
0.5
0.0
0.5
1.0 4

izvornog koda 20.3
20.3
Stvaranje prvog
prozora nije nuno.
Naredbe za crtanje
grafova (npr. plot)
same c e kreirati
prozora ako vec ne
postoji.
svojstva prozora, prostora crtanja i osi
Novi prozor se stvara pomocu funkcije figure, koja vraca handle na prozor
a po potrebi moe primati dodatne argumente
figure()
fig1 = figure()
fig1 = figure(figsize = (12, 10), dpi = 300)
Dva argumenta koji se najcece koriste su figsize i dpi. figsize prima

tuple koji specificira irinu i visinu prozora u incima a pomocu argumenta
dpi (dots per inch) regulira se rezolucija koja je posebno bitna kod spremanja
grafova u raster format ili pri spremanju animacija u video format.
Naredbama xlabel i ylabel moguce je dodati naslove osi. Sintaksa obje
naredbe je identicna:
xlabel(Opis x osi)
ylabel(Opis y osi)
Naredbama xlim i ylim odreduju

se granice intervala koji se prikazuje na
prostoru crtanja. Sintaksa naredbe je:
xlim( (xmin, xmax) )
xlim( xmin, xmax )
Dodaju li se izvornom kodu 20.3 sljedece linije,

1
2
xlim(X.min()*1.1, X.max()*1.1)
ylim(C.min()*1.1, C.max()*1.1)
moguce je dobiti sljedeci rezultat:
20.3 svojstva prozora, prostora crtanja i osi
1.0
0.5
0.0
0.5
1.0
3
Slika 20.5: Izmijenjene granice grafa
1
2
3
xlim(0, 5)
# Donja i gornja granica
ylim(ymax=1) # Samo gornja granica
ylim(ymin=-1) # Samo donja granica
Moguce je promijeniti i ticks. U slucaju da je potrebno i izvornom kodu

20.3 prikazati vrijednosti od x os od do s korakom od /2 i y os od -1
od 1 s korakom od 1, potrebno je dodati sljedece linije:
1
2
xticks( [-np.pi, -np.pi/2, 0, np.pi/2, np.pi])

yticks([-1, 0, +1])
Rezultat je prikazan na sljedecoj slici.
97
98
osnovni 2d grafovi
1
3.142
1.571
0.000
1.571
3.142
Slika 20.6: Custom ticks
Jo je potrebno promijeniti oznake na osima:

1
2
3
4
xticks([-np.pi, -np.pi/2, 0, np.pi/2, np.pi],

[r$-\pi$, r$-\pi/2$, r$0$, r$+\pi/2$, r$+\pi$])
yticks([-1, 0, +1],
[r$-1$, r$0$, r$+1$])
to rezultira sljedecim grafom:
+1
/2
Slika 20.7: Custom ticks
U nekim situacijama je korisno pomaknuti osi:
+ /2
20.3 svojstva prozora, prostora crtanja i osi
1
2
3
4
5
6
7
ax = gca()
ax.spines[right].set_color(none)
ax.spines[top].set_color(none)
ax.xaxis.set_ticks_position(bottom)
ax.spines[bottom].set_position((data,0))
ax.yaxis.set_ticks_position(left)
ax.spines[left].set_position((data,0))
+1
/2
+ /2
Slika 20.8: Spines
Oznake na osima su prekrivene linijama s(Slika 20.8) te ih je potrebno uciniti

c itljivijima:
1
2
3
for label in ax.get_xticklabels() + ax.get_yticklabels():

label.set_fontsize(16)
label.set_bbox(dict(facecolor=white, edgecolor=None, alpha=0.65))
99
100
osnovni 2d grafovi
+1
/2
00
+ /2
Slika 20.9: Formatiranje oznaka na osima
Ukljucivanje i iskljucivanje mree pomocnih linija na prostoru crtanja vri

se naredbom grid.
grid(b=None, which=major, axis=both, **kwargs)
b je argument kojim se kontrolira da li se iskljucuje ili ukljucuje mrea pomocnih linija i moe poprimiti vrijednosti true ili false ali i on ili off
(kao i MATLAB). which moe biti major, minor ili both i slui za kontrolu glavne ili sporedne mree pomocnih linija. Argumentom axis kontorilra se za koje c e osi biti postavljena mrea pomocnih linija. Vrijednosti za
axis mogu biti both, x ili y.
grid moe primati dodatne argumente za detaljniju kontrolu mree pomocnih linija:
1
grid(color=k, linestyle=:, linewidth=0.2)
Dodavanje naslova na prostor crtanja vri se naredbom title:

title(Text naslova)
Prikazivanje legende na na prostoru crtanja vri se pomocu naredbe legend

uz prethodno definirane opise krivulja (label).
legend()
Ako u prethodno nacrtanim grafovima nije specificiran label, legendu

se moe napraviti i pomocu handleova na plotove. U tom slucaju, funkcija
legend prima listu handleova i listu pripadajucih opisa.
plt1, = plot([1,2,3])
plt2, = plot([3,2,1])
legend([plt2, plt1], ["line 2", "line 1"])
Dodatnim keyword argumentom loc odreduje

se pozicija legende na prozoru. Vrijednosti koje se daju argumentu loc mogu biti cijeli brojevi ili stringovi koji specificiraju poziciju legende na prozoru (Tablica 20.4).
20.4 spremanje grafova
Pozicija
Broj
String
Gore desno
upper right
Gore lijevo
upper left
Dolje lijevo
lower left
Dolje desno
lower right
Desno
right
Na sredini lijevo
center left
Na sredini desno
center right
Dolje u sredini
lower center
Gore u sredini
upper center
U sredini
10
center
Tablica 20.4: Pozicija legende
Izvorni kod 20.4: Prikaz legende na grafu

1
2
from pylab import *

from numpy import *
3
4
5
6
x = linspace(0, 10, 100)

y1 = sin(x)
y2 = cos(x)
7
8
9
10
11
12
figure(1, [8, 2])

plot(x, y1, label=sinus)
plot(x, y2, label=kosinus)
legend(loc=upper center) # Postavlja legendu gore na sredinu
show()
1.0
0.5
0.0
0.5
1.00
sinus
kosinus
10
Slika 20.10: Prikaz legende na grafu
20.4
spremanje grafova
20.5
podgrafovi
Podgrafovi omogucavaju postavljanje grafova u mreu grafova. Potrebno je

specificirati broj redaka i stupaca.
Izvorni kod 20.5: Primjer crtanja podgrafova
1
2
3
4
5
6
7
from pylab import *

from numpy import *
def myticks():
xticks([-np.pi, -np.pi/2, 0, np.pi/2, np.pi],
[r$-\pi$, r$-\pi/2$, r$0$, r$+\pi/2$, r$+\pi$])
yticks([-1, 0, +1],
[r$-1$, r$0$, r$+1$])
101
102
osnovni 2d grafovi
8
9
10
X = np.linspace(-np.pi, np.pi, 256,endpoint=True)

C,S = np.cos(X), np.sin(X)
11
12
13
14
15
16
17
18
figure(1)
subplot(211)
plot(X, C, color="blue", linewidth=2.5, linestyle="-")
myticks()
subplot(212)
plot(X, S, color="red", linewidth=2.5, linestyle="-")
myticks()
19
20
show()
+1
/2
+ /2
/2
+ /2
+1
Slika 20.11: Podgrafovi nastali izvravanjem izvornog koda 20.5
Podgrafovi se iscrtavaju u slici (figure) koja se sastoji od dva grafa. Naredba subplot definira broj redaka, broj stupaca i broj grafa, koji mora biti
broj 1 < fignum < numrows numcols. Varijable ne moraju biti odvojene
zarezom ako vrijedi numrows numcols < 10. Odnosno, subplot(211) je
ekvivalentan izrazu subplot(2,1,1).
20.6
polarni grafovi
Izvorni kod 20.6: Primjer crtanja grafa u polarnom koordinatnom sustavu

1
2
from pylab import *

from numpy import *
3
4
5
fig = figure(figsize=[8,8])
ax = fig.add_subplot(111, polar=True)
6
7
subplots_adjust(bottom=0.1,top=0.9,left=0.1,right=0.9)
8
9
10
r = arange(0,1,0.001)
theta = 2*2*pi*r
20.7 tips and tricks
11
12
13
14
ax.plot(theta,r, lw=2)
grid(True)
show()
90
135
45
0.2
180
0.4
0.6
225
Slika 20.12: Graf u polarnom koordinatnom sustavu
tips and tricks
Use matplotlibs calls that wont block:

Using draw():
1
2
3
4
from matplotlib import plot, draw, show

plot([1,2,3])
draw()
print continue computation
5
6
7
# at the end call show to ensure window wont close.

show()
Using interactive mode:

1
2
3
from matplotlib import plot, ion, show

ion() # enables interactive mode
plot([1,2,3]) # result shows immediatelly (implicit draw())
4
5
print continue computation
6
7
8
# at the end call show to ensure window wont close.

show()
1.0
315
270
20.7
0.8
103
21
SLOENIJI 2D GRAFOVI
21.1
izolinije
Prilikom vizualizacije ovisnosti funkcije (ili podataka) o dvije varijable (2D)

c esto se koriste izolinije. Izolinije su krivulje koje povezuju tocke iste (skalarne) vrijednosti.
Izolinija je skup rjeenja jednadbe
f(x, y) = ci
(21.1)
gdje je ci konstanta za koju se odreduje

izolinija. Ako za dani ci postoji rjeenje jednadbe (21.1), to rjeenje predstavlja jednu ili vie krivulja u ravnini
x y. Za vie parametara c = (c1 , c2 , ..., cn ) dobiva se familija krivulja koje
slue za 2D vizualizaciju funkcija dvije varijable.
Matplotlib nudi mogucnost naprednog uredivanja

i kontrolabilnost izolinijskih grafova. Funkcija contour slui za crtanje izolinija a countourf za
izolinija.
bojanje povrina izmedu
matplotlib.pyplot.contour
matplotlib.pyplot.contourf
Obje navedene funkcije imaju identicnu osnovnu sintaksu, a razlikuju se

u svega nekoliko argumenta koji su specificni za stiliziranje linija odnsno
bojanje ploha.
U najjednostavnijoj varijanti, funkcije primaju jedan argumenti i to ma
tricu Z na temelju c ijih vrijednosti se crtaju izolinije i plohe. Razmaci izmedu
redaka i stupaca su jednaki 1 a broj izolinija se odreduje

automatski.
matplotlib.pyplot.contour(Z)
matplotlib.pyplot.contourf(Z)
Broj nivo linija se moe specificirati cijelim brojem n ili se mogu odrediti
eljene vrijednosti pomocu vektora V za koje c e se crtati izolinije.
matplotlib.pyplot.contour(Z, n)
matplotlib.pyplot.contourf(Z, n)
matplotlib.pyplot.contour(Z, V)
matplotlib.pyplot.contourf(Z, V)
stupaca i redaka mogu se zadati pomocu matrica X i Y:

Razmaci izmedu
matplotlib.pyplot.contour(X, Y, Z)
matplotlib.pyplot.contour(X, Y, Z, n)
matplotlib.pyplot.contourf(X, Y, Z, n)
matplotlib.pyplot.contour(X, Y, Z, V)
matplotlib.pyplot.contourf(X, Y, Z, V)
Matrice X i Y sadre x i y kordinate pripadajucih elemenata u matrici Z te sve

tri matrice moraju biti istog oblika/dimenzija. Za jednostavljeno kreiranje
takvih matrica na temelju vektora koordinata koristi se funkcija meshgrid
(vidi poglavlje 14.8).
21.1.1
Mapa boja
Mapa boja (eng. colormap) je nacin na koji se numericka vrijednost sa intervala [0, 1] pretvara u RGBA (Red, Green, Blue, Alpha) specifikaciju boje kojom
se definira udio crvene, zelene i plave boje te prozirnost.
105
106
sloeniji 2d grafovi
Mapiranje boja se odvija u dva koraka: podaci koje treba vizualizirati su

prvo mapirani na interval [0, 1] koristeci klasu matplotlib.colors.Normalize
ili neku od njenih podklasa; onda se broj sa intervala [0, 1] mapira u odre
denu
boju koristeci mapu boja.
Matplotlib sadri unaprijed definirane mape boja koje se nalaze u matplotlib.pyplot.cm modulu (Slika 21.1).
Accent
BrBG
BuPu
Dark2
Greens
OrRd
PRGn
Pastel1
PiYG
PuBuGn
PuRd
RdBu
RdPu
RdYlGn
Set1
Set3
YlGn
YlOrBr
afmhot
binary
brg
cool
copper
flag
gist_gray
gist_ncar
gist_stern
gnuplot
gray
hsv
nipy_spectral
pink
rainbow
spectral
summer
Blues
BuGn
CMRmap
GnBu
Greys
Oranges
Paired
Pastel2
PuBu
PuOr
Purples
RdGy
RdYlBu
Reds
Set2
Spectral
YlGnBu
YlOrRd
autumn
bone
bwr
coolwarm
cubehelix
gist_earth
gist_heat
gist_rainbow
gist_yarg
gnuplot2
hot
jet
ocean
prism
seismic
spring
terrain
Slika 21.1: Predefinirane mape boja u matplotlibu
Mapa boja se postavlja pomocu keyword argumenta cmap:

matplotlib.pyplot.contour(X, Y, Z, cmap=matplotlib.pyplot.cm.hot)
Osim predefiniranih mapa boja, mogu se koristiti i rucno definirane mape

boja.
21.1.2
Detaljnije podeavanje grafa izolinija
Podeavanje boja u grafovima izolinija moguce je se keyword argumentom

colors u contour i contourf funkcijama. U funkciji contour boje se aplici
raju na izolinije a u funkciji contourf boje se apliciraju na povrine izmedu
izolinija.
Tri su osnovna nacina zadavanja boje:
? colors = None, boje se preuzimaju iz postavljene mape boja (vidi 21.1.1)
? colors = r, postavlja se jedna boja za sve izolinije ili povrine iz izolinija.
medu
21.1 izolinije
? colors = [r, g, b], postavlja se lista (ili tuple) boja. Boje iz

liste se ponavljaju, ako ima vie izolinija nego specificiranih boja.
Pojedinu boju ili boju u listi se moe zadavati na vie nacina, kao to je
opisano u poglavlju (20.2.1).
Kada u istom prostoru crtanja postoji vie grafova, bolja vidljivost svih
njih
grafova se postie prozirnocu. Prozirnost izolinija ili povrina izmedu
postavlja se pomocu keyword argumenta alpha. alpha moe primiti decimalni broj sa intervala [0, 1] gdje je 0 potpuno prozirno (nevidljivo) a 1 je
potpuno neprozirna boja.
21.1.3
Primjer
Izvorni kod 21.1: Primjer vizualizacije izolinija

1
2
3
# -*- coding: utf-8 -*import numpy as np

import matplotlib.pyplot as pl
4
5
6
7
# Definiranje funckije
def f(x,y):
return (1 - np.sin(x) - np.sin(y)**3) * np.exp(-np.cos(x) -np.sin(y)**2)
8
9
10
# Gusto
ca vizualizacijskih to
caka (po svakoj dimenziji)
n = 256
11
12
13
14
15
# Diskretizacija
x = np.linspace(-4, 0, n)
y = np.linspace(-3, 1, n)
X,Y = np.meshgrid(x, y)
16
17
18
# Uklju
civanje mree pomo
cnih linija
pl.grid()
19
20
21
22
# Crtanje povrina izme

du izolinija
# 8 - broj izolinija, alpha - prozirnost, cmap - kolormapa
Cf = pl.contourf(X, Y, f(X, Y), 8, alpha=.75, cmap=pl.cm.jet)
23
24
25
26
# Crtanje izolinija
# colors - boja linija, linewidth - debljina linija
Cl = pl.contour(X, Y, f(X, Y), 8, colors=black, linewidth=.5)
27
28
29
# Dodavanje oznaka na izolinije

pl.clabel(Cl, inline=1, fontsize=10)
30
31
pl.show()
107
sloeniji 2d grafovi
0
0.50
0.0
3.500
00
0
2.50
0.5
1.5
00
0.5
0.00
3.0
1.0
1.0
1.5
2.0
00
3.5
3.0
2.5
2.0
1.5
1.0
3.0
0.50
00
3.0
4.0
00
1.0
2.0
1.000
2.5
2.50
108
0.5

izvornog koda 21.1
0.0
22
IZRADA ANIMACIJA
Izvorni kod 22.1: Jednostavan primjer animacije

1
2
3
4
# -*- coding: utf-8 -*"""

Nelder-Mead metoda
"""
5
6
7
8
import numpy as np
from matplotlib import animation
9
10
11
12
13
fig = plt.figure()
linija, = plt.plot([], [], -o)
plt.xlim([0, 10])
plt.ylim([-1, 1])
14
15
16
17
def init():
linija, = plt.plot([], [], -o)
18
19
return linija
20
21
def draw_frame(it):
22
23
24
25
xline = np.linspace(0.0,10.0,50)
yline = np.sin(xline + it/10.0)/(1.0 +xline**2.0)
linija.set_data(xline, yline)
26
27
return linija
28
29
30
Writer = animation.writers[ffmpeg]
writer = Writer(fps=5, metadata=dict(artist=sim.riteh.hr), bitrate=3600)
31
32
33
anim = animation.FuncAnimation(fig, draw_frame, init_func=init,

frames=500, interval=2, repeat=False)
34
35
36
anim.save(nelder-mead.avi, writer=writer)
plt.show()
109
Dio IV
KE METODE
NUMERIC
23
R J E AVA N J E N E L I N E A R N I H J E D N A D B I
Cilj numerickih metoda za rjeavnje nelinearnih jednadbi (eng. root finding)

je odrediti nultocku neprekidne realne funkcije f : R R to jest rijeiti
jednadbu
f(x) = 0.
(23.1)
Moguce je da funkcija f ima vie realnih nultocaka i da su neke viestruke.

funkcija f moda uopce nema realnih nultocaka.
Takoder,
Ako za neprekidnu funkciju vrijedi
f(a) f(b) 6 0
tada funkcija na intervalu [a, b] mijenja predznak pa postoji barem jedna
nultocka na odabranom intervalu. Ako je poznato da je funkcija i monotona
na intervalu [a, b] tada je nultocka jedinstvena.
Osnovni korak numerickih metoda je separirati jedan korijen jednadbe
(23.1). Nakon to smo izolirali jedno rjeenje, nekom odabranom numerickom metodom formiramo niz aproksimacija xi . Numericku metodu
zaustavljamo kada je zadovoljen zadani kriterij tocnosti
| xi | < .
Postoji vie numerickih metoda za rjeavanje nelinearnih funkcija, a neko
liko najznacajnijih c e biti obradeno
u ovom poglavlju. Numericke metode se
razlikuju po stabilnosti, nacinu primjene i brzini konvergencije (red konvergencije).
Definicija 23.1
Neka niz (xi ), dobiven nekom iterativnom metodom, konvergira prema Ako
postoje dvije pozitivne konstante C, r takve da vrijedi
| xi+1 |
6C
i | xi |r
lim
tada kaemo da metoda ima red konvergencije r.

S obzirom na red konvergencije r, iterativna numericka metoda konvergira:
1. linearno ako je r = 1,
2. superlinearno ako je 1 < r < 2,
3. kvadraticno ako je r = 2,
4. kubicno ako je r = 2.
23.1
metoda bisekcije
Metoda bisekcije namjenjena je rjeavnju jednadbe f(x) = 0 na intervalu
[xl , xd ] koristeci ogradivanje

(eng. bracketing) Da bi se metoda mogla primjeniti, funkcija f(x) mora biti neprekidna te mora vrijediti f(xl ) f(xd ) 6 0.
113
114
rjeavanje nelinearnih jednadbi
Zbog navedenih uvjeta, funkcija f(x) ima bar jedan korijen x0 na intervalu
[xl , xd ].
Biskecija je jedna od metoda ogradivanja,

u kojoj se u svakom koraku
racuna vrijednost funkcije na polovici intervala.
xs =
xl + xd
2
Na temelju vrijednosti funkcije u rubnim tockama te u centralnoj tocki,
odreduje
se novi, dvostruko ui, interval. Ako je f(xl ) f(xs ) < 0 tada je
x0 [xl , xs ], a ako je f(xs ) f(xd ) < 0 tada je x0 [xs , xd ].
Prepolavljanje se iterativno ponavlja (Slika 23.1). U slucaju da je f(xs ) = 0,
traeni korijen funkcije.
tada je pronaden
f(x)
xd
xl
x
f(x)
Slika 23.1: Skica metode biskecije
Metoda biskecije, ako su navedeni uvjeti zadovoljeni, c e sigurno konvergirati u jedan od korijena funkcije f(x) na intervalu [xl , xd ]. Apsolutna greka
se prepolavlja u svakom koraku iteracije pa metoda konvegira linearno, to
je, u odnosu na druge metode, relativno sporo.
Osnovna sintaksa:
bisect(f, a, b)
gdje je f funkcija, a a i b su granice intervala na kojem se trai korijen

funkcije.
Dodatni argumenti omogucuju kontrolu i pregled konvergencije:
optimize.bisect
poziva
_zeros._bisect,
args=()
xtol=1e-12
rtol=4.4408920985006262e-16
maxiter=100
full_output=False
disp=True
koja je
implementirana u
C-u.
gdje je xtol apsolutna tolerancija, rtol relativna tolerancija, maxiter maksimalni broj iteracija, full_output omogucuje dohvacanje dodatnih informacija o konvergenciji i disp omogucuje podizanje RuntimeError u slucaju da
metoda ne konvergira.
Izvorni kod 23.1: Primjer pronalaenja nultocke funkcije metodom biskecije
1
2
3
#!/usr/bin/python
import scipy.optimize as optimize
from numpy import cos
4
5
def f(x):
23.2 newton-raphsonova metoda
115
return cos(x)**2 + 6 - x
7
8
9
10
11
12
# 0<=cos(x)**2<=1, so the root has to be near x=7

x0, S = optimize.bisect(f,6,8,full_output=True)
print x0
print S.iterations
print S.function_calls
6.77609231632
41
43
23.2
newton-raphsonova metoda
Za razliku od nelinearne funkcije, traenje nultocke linearne funkcije je bitno

laki zadatak. Osnovna ideja Newton-Raphsonove metode je lokalna aproksimacija nelinearne funkcije f(x) najboljom linearnom aproksimacijom. Ako
je poznata derivacija funkcije f(x) tada je u blizini x1 moguce funkciju f(x)
aproksimirati tangentom
f(x) T (x) = f(x1 ) + f 0 (x1 )(x x1 ).
x1 je pocetna aproksimacija nultocke, a x0 f(x1 )/f 0 (x1 ) (nultocka tangente
T (x)) bi trebala biti bolja aproksimacija nultocke. Niz aproksimacija
xi+1 = xi
f(xi )
f 0 (xi )
(23.2)
bi trebao konvergirati nultocki funkcije f(x). . Za ovu iterativnu metodu potrebno je zadati dobru pocetnu aproksimaciju nultocke i derivaciju funkcije
(Slika 23.2).
f(x)
x3
x4 x2
x1
Slika 23.2: Newton-Raphsonova metoda
Osnovna sintaksa:
newton(func, x0, fprime)
gdje je func funkcija, x0 pocetna aproksimacija nultocke i fprime prva derivacija funkcije (zadaje se kao funkcija). Dodatni argumenti omogucuju kontrolu i konvergencije:
args=()
tol=1e-12
maxiter=100
fprime2=None
NewthonRaphsonova metoda
je poznata i kao
Newtonova metoda
ili metoda tangente
116
rjeavanje nelinearnih jednadbi
gdje je tol apsolutna tolerancija, maxiter maksimalni broj iteracija i fprime2

je druga derivacija funkcije koja omogucuje ubrzanje konvergencije.
Izvorni kod 23.2: Primjer pronalaenja nultocke funkcije metodom tangente
1
from scipy import optimize
2
3
4
5
6
def fun(t):
return t**2-2
def fprim(t):
return 2*t
7
8
print optimize.newton(fun, 1., fprim,
tol=1.e-5)
1.41421356237
Newton-Raphsonova metoda konvergira kvadraticno pa je znatno je bra

od metode bisekcije, ali je bisekcija stabilnija i robusnija. Iz jednadbe (23.2)
moe se zakljuciti da c e Newton-Raphsonova metoda biti nestabilna kada
f 0 (x) u
je f 0 (x) 0 odnosno kada je tangenta skoro horizontalna. Takoder,
mnogim slucajevima nije poznata ili je vrlo zahtjevna za racunanje.
23.3
metoda sekante
Kada derivacija funkcije nije poznata tada je moguce modificirati metodu

tangente na nacin da se funkcija f(x) aproksimira nekom sekantom koja
dobro aproksimira tangentu. U tom slucaju moraju se zadati dvije pocetne
aproksimacije nultocke funkcije, ali derivacija funkcije nije potrebna jer je
moguce aproksimirati derivaciju:
f(x) S(x) = f(x2 ) +
f(x2 ) f(x1 )
(x x2 ).
x2 x1
Odnosno moguce je formirati niz aproksimacija

xi+1 = xi
f(xi )(xi xi1 )

.
f(xi ) f(xi1 )
(23.3)
Osnovna sintaksa:
newton(func, x0)
gdje je func funkcija, a x0 pocetna aproksimacija.

Metoda sekante je neto sporija od metode tangenete, ali je ipak znatno
bra od bisekcije. Kaemo da sekanta konvergira superlinearno. Takoder,

metoda sekante postaje nestabilna u slucaju kada je sekanta skoro horizontalna.
23.4
brentova metoda
Osnovna sintaksa:
brent(func, a, b)
23.5 zadaci
23.5
zadaci
Zadatak 23.1 Lopta (sfera) je uronjena u vodu i postie stanje ravnotee.
Volumen uronjenog dijela lopte iznosi

ZH
V(H) =
r(h)2 dh
ZH
V(H) =
R2 (h R)2 dh =
ZH
2Rh h2 dh
H3
3
Uzgon koji daje uronjeni dio lopte iznosi
V(H) = RH2
U(H) = V(H) g
U stanju ravnotee, uzgon je jednak teini lopte.
U(H) = m g
H3
= mg
3
Lopta mase m = 0.4kg i promjera R = 0.22m stavljena je u vodu gustoce
= 1024kg/m3 . Koliko c e lopta biti uronjena (u stanju ravnotee)?
RH2
117
24
INTERPOLACIJE
Cesto
se javlja potreba da na temelju nepotpunih ili rijetkih podataka treba
procjeniti odnosno izracunati vrijednosti u eljenim tockama. Interpolacija je
metoda konstrukcije novi tocaka unutar raspona diskretnog skupa poznatih
tocaka podataka.
Interpolacije moemo klasificirati s obzirom na :
? broj dimenzija danog interpolacijskog problema,
? interpolacijsku funkciju (linearna, spline itd.),
? na strukturu zadanih diskretnih podataka (zadani na mrei tocaka ili
na nepravilno razbacanim tockama (scatterd))
24.1
1d interpolacija
Klasa interp1d u modulu scipy.interpolate omogucuje 1D interpolaciju.

interp1d(x, y, kind, axis, copy, bounds_error, fill_value)
gdje je x 1D monotono rastuce polje polje a y n-dimenzionalno polje. Dimenzija y-a du koje se vri interpolacija treba biti iste duine kao i x. kind
moe biti linear, nearest, zero, slinear, quadratic, cubic
ili cijeli broj koji specificira red spline inerpolacije. Parametar axis odreduje
dimenziju y-a du koje se vri interpolacija. Pozivanja interpolacije izvan
intervala zadanih tocaka moe se kontrolirati parametrima bounds_error i
fill_value. bounds_error odreduje

da li se podie error u slucaju pokuaja
interpolacije van granica a fill_value definira vrijednost koju interpolacija
u tom slucaju vraca.
Izvorni kod 24.1: Primjer razlicitih 1D interpolacija
1
2
3
from numpy.random import *

from scipy import interpolate
from pylab import *
4
5
6
X = linspace(0., 10., 6)
Y = array([1.6, 4., 3.4, 1.6, 1.8, 1.2])
7
8
x = linspace(0., 10., 101)
9
10
11
f1 = interpolate.interp1d(X, Y, kind=linear)
y1 = f1(x)
12
13
14
f2 = interpolate.interp1d(X, Y, kind=2)
y2 = f2(x)
15
16
17
f3 = interpolate.interp1d(X, Y, kind=3)
y3 = f3(x)
18
19
20
21
22
23
24
figure(1, figsize=[8, 3])

plot(X, Y, o)
plot(x, y1, label=linearna)
plot(x, y2, label=spline 2. reda)
plot(x, y3, label=spline 3. reda)
119
120
interpolacije
25
26
legend()
show()
4.5
4.0
3.5
3.0
2.5
2.0
1.5
1.00
linearna
spline 2. reda
spline 3. reda
10
Slika 24.1: Primjer razlicitih 1D interpolacija
24.2
2d i n-d interpolacija
U slucaju dvo-dimenzionalne (ili vie) interpolacije, moguce je interpolacijski problem postaviti na diskretnim podacima zadanim na mrei tocaka ili
nepravilno razbacanim tockama (scatterd).
Za interpolaciju vrijednosti zadanih na N-D nestrukturiranim tockama
koristi se funkcija griddata:
Parametar values
moe biti 2D polje,
pa se na istim
zadanim tockama
moe zadati vie
velicina koje se mogu
interpolirati preko
jednog poziva
interpolacijske
funkcije.
griddata(points, values, xi, method, fill_value)
gdje je points numpy polje koje sadri koordinate zadanih diskretnih podataka. Oblik polja points je (broj_tocaka, broj_dimenzija). Pripadajuce
vrijednosti zadaju se preko numpy polja values. xi je polje tocaka za koje je
potrebno interpolirati zadane podatke.
method specificira metodu interpolacije i podrane su sljedece metode:
? nearest
? linear
? cubic
Parametrom fill_value definira se vrijednost koju vraca interpolacijska
funkcija za tocke izvan podrucja zadanih podataka.
Interpolacija na podacima zadanim na pravilnoj mrei tocaka se vri pomocu klase interp2d.
interp2d(x, y, z, kind, copy, bounds_error, fill_value)
U izvornom kodu 24.2 rjeen je problem intepolacije dvo-dimenzionalnog

polja zadanog vrijednostima u 25 tocaka (uniformna mrea 5x5). Zadane
tocke te rjeenje linearne i kubicne interpolacije prikazani su na slici 24.2
na kojo jse jasno vidi razlika u glatkoci linearne i kubicne interpolacijske
funkcije.
Izvorni kod 24.2: Primjer linearne i kubicne 2D interpolacije
1
2
3
4
5
from
from
from
from
numpy.random import *
scipy import interpolate
pylab import *
mpl_toolkits.mplot3d import Axes3D
24.2 2d i n-d interpolacija
6
7
8
9
10
11
12
13
14
X = linspace(0., 2., 5)
Y = linspace(0., 4., 5)
Z = array([
[1.3, 1.4, 1.1, 1.0,
[1.6, 1.1, 1.2, 1.3,
[1.2, 1.5, 1.6, 1.5,
[1.2, 1.4, 1.5, 1.4,
[1.3, 1.2, 1.1, 1.1,
])
0.8],
1.5],
1.6],
1.3],
1.2]
15
16
XX, YY = np.meshgrid(X, Y)
17
18
19
f1 = interpolate.interp2d(X, Y, Z, kind=linear)
f2 = interpolate.interp2d(X, Y, Z, kind=cubic)
20
21
22
23
x = linspace(0., 2., 51)

y = linspace(0., 4., 31)
xx, yy = meshgrid(x, y)
24
25
26
z1 = f1(x, y)
z2 = f2(x, y)
27
28
fig = plt.figure(figsize=[8, 3])
29
30
31
32
33
subplot(1, 3, 1)
scatter(XX, YY, c=Z, marker = s, s = 100, cmap = cm.Purples)
xlim(0, 2)
ylim(0, 4)
34
35
36
37
38
subplot(1, 3, 2)
CS = plt.contourf(xx, yy, z1, cmap = cm.Purples)
xlim(0, 2)
ylim(0, 4)
39
40
41
42
43
subplot(1, 3, 3)
CS = plt.contourf(xx, yy, z2, cmap = cm.Purples)
xlim(0, 2)
ylim(0, 4)
44
45
46
47
cax = fig.add_axes([0.05, 0.1, 0.9, 0.1])
fig.colorbar(CS, cax=cax, orientation=horizontal)
48
49
show()
4.0
4.0
4.0
3.5
3.5
3.5
3.0
3.0
3.0
2.5
2.5
2.5
2.0
2.0
2.0
1.5
1.5
1.5
1.0
1.0
1.0
0.5
0.5
0.5
0.00.0 0.5 1.0 1.5 2.00.00.0 0.5 1.0 1.5 2.00.00.0 0.5 1.0 1.5 2.0
0.75
0.90
1.05
1.20
1.35
Slika 24.2: Primjer 2D interpolacije
1.50
1.65
121
25
REGRESIJE
U inenjerskoj praksi, prilikom odredivanja

relativno jednostavne veze iz dvije velicine c esto se nailazi na veliki broj podataka koji zapravo
medu
predefiniraju tu vezu. Takvi podaci su, najcece, dobiveni eksperimentom i
mjerenjima.
U takvim slucajevima potrebno je odrediti sve parametre modela (funkcije) da se to tocnije i preciznije opiu podaci.
Primjer
Poznat je zakon koji povezuje silu istezanja opruge F i promjenu duljine
opruge l:
F = k l
gdje je k konstanta opruge.
Potrebno je odrediti nepoznatu konstante k na osnovu jednostavnog
mjerenja sile i promjene duljine opruge.
Nizom mjerenja dobiveni su sljedeci podaci:
F [N]
7.0
11.0
12.0
16.0
18.0
20.0
21.0
24.0
l[mm]
3.0
6.5
7.0
7.5
8.5
10.5
11.0
12.5
25.1
metoda najmanjih kvadrata
25.2
linearna regresija
Izvorni kod 25.1: Primjer linearne regresije

1
2
3
4
# -*- coding: utf-8 -*"""

Linearna regresija
"""
5
6
from pylab import *
7
8
X = [1.0, 0.6, 1.065, 1.5, 1.72, 2.06, 2.84, 3.1, 3.15, 3.26, 3.55, 3.61, 4.0]
123
124
regresije
Y = [10.0, 10.6, 11.5, 10.8, 11.0, 20.6, 20.8, 30.1, 32.7, 33.4, 38.0, 37.0, 48.2]
10
11
12
k = np.polyfit(X,Y,1)
print Regresijski pravac: y=%.3fx%+.3f % (k[0], k[1])
13
14
15
xr = np.linspace(np.min(X), np.max(X), 100)

yr = xr*k[0] + k[1]
16
17
18
plot(X, Y, ro, label=uTo

cke)
plot(xr, yr, b-, lw=2, label=uRegresijski pravac)
19
20
21
22
legend(loc=2)
grid()
show()
Regresijski pravac: y=10.846x-2.035
50
To ke
Regresijski pravac
40
30
20
10
0
0.5
1.0
1.5
2.0
2.5
3.0
3.5
4.0
Slika 25.1: Regresijski pravac dobiven izvornim kodom 25.1
25.3
zadaci
Zadatak 25.1 U laboratoriju se koristi skupi termometar T2 c ije je mjerenje

pouzdano i znatno jeftiniji i robusniji termometar T1 c ije mjerenje trebamo ko T1 i
rigirati u odnosu na termometar T1. Pretpostavlja se da je veza izmedu
T2 linearna. U tablici su dana mjerenja istog objekta u isto vrijeme s termometrima T1 i T2.
T1
[ C]
19.1
22.9
31.5
42.2
50.2
T2
[ C]
18.5
22.2
30.6
41.1
49.1
Ako termometru T1 pokazuje 35 C kolika bi temperatura bila na termometru

T2? Ako termometru T1 pokazuje 12 C kolika bi temperatura bila na termometru T2?
25.3 zadaci
Zadatak 25.2 Vrijednost gravitacijskog ubranje Zemlje g se minjenja s visinom, odnosno udaljenocu od zemljine povrine h, kako je dano u tablici.
Izracunaj vrijednost gravitacijskog ubrzanja na visini h = 126 km, koristeci
kvadratnu regresiju.
h[km]
h i
g sm2
0.1
20.0
40
60
80
100
120
140
9.81
9.7486
9.6789
9.6728
9.5681
9.5091
9.4506
9.3926
125
26
R J E AVA N J E S U S TAVA L I N E A R N I H J E D N A D B I
Sustav linearnih jednadbi

a11 x1
a12 x2
+ ...
a1n xn
b1
a21 x1
..
.
a22 x2
..
.
+ ...
a2n xn
..
.
b2
..
.
am1 x1
+ an2 x2
+ ...
+ ann xn
se moe zapisati matricno

b
x
a11 a21 . . . a1n
1 1
a
12 a22 . . . a2n x2 b2
=
.
..
.. .. ..
..
..
.
. . .
.
bn
xn
an2 an2 . . . ann
(26.1)
= bn
(26.2)
odnsono
Ax = b
(26.3)
Matrica A se naziva matrica sustava, x je vektor nepozanica a b je vektor

slobodnih c lanova.
Primjer
Ulaznice za sajam se prodaju po cjeni od 5 kn za djecu i 20 kn za odrasle.
Na sajmu je bilo ukupno 341 osoba i od ulaznica je zaradeno

4810 kn.
Koliko je bilo odraslih a koliko djece na sajmu?
Rjeenje
Neka je d broj djece a o broj odraslih. Ukupan broj ljudi na sajmu je
od ulaznica: 5 d + 20 o = 4810. Dvije
d + o = 341. Novac zaraden
navedene linearne jednadbe tvore sustav:
#
"
# " # "
341
1 1
d
=
5 20
o
4810
26.1
metoda gaussove eliminacije
Matrica sustava zapisana u datoteci A.txt:

12 2 3 4
1 22 1 2
0 2 7 1
1 2 0.5 8
Vektor slobodnih c lanova zapisan u datoteci B.txt:

-0.5
2.3
0.8
3.1
127
128
rjeavanje sustava linearnih jednadbi
Izvorni kod 26.1: Primjer naivne Gaussove eliminacije

1
2
3
4
# -*- coding: utf-8 -*"""

GAUSSOVA ELIMINACIJA
"""
5
6
7
from numpy import *

from scipy.optimize import *
8
9
10
A = loadtxt(A.txt)
B = loadtxt(B.txt)
11
12
n = len(B)
13
14
15
16
17
18
19
20
# Naivna eliminacija
for k in range(0,n):
for i in range(k+1,n):
faktor = A[i,k]/A[k,k]
for j in range(k+1,n):
A[i,j] = A[i,j] - faktor*A[k,j]
B[i] = B[i] - faktor*B[k]
21
22
23
24
25
26
27
28
# Supstitucija unatrag
X = empty(shape(B))
for i in range(n-1,-1,-1):
suma = 0
for j in range(i+1,n):
suma = suma + A[i,j]*X[j]
X[i] = (B[i]-suma)/A[i,i]
29
30
print X
31
32
33
34
35
# Scipy rjesenje
A = loadtxt(A.txt)
B = loadtxt(B.txt)
print linalg.solve(A,B)
Izvodenje
izvornog koda 26.1 vidimo da su oba ispisana rjeenja (Gaussova eliminacija i numpy funkcija linalg.solve) identicna:
[-0.19367432
[-0.19367432
26.2
0.07619065
0.07619065
0.03675057
0.03675057
0.39036472]
0.39036472]
lu dekompozicija
Primjer LU dekompozicije u izvornom kodu 26.2 koristi datoteke A.txt i

B.txt iz prethodnog poglavlja (26.1).
Izvorni kod 26.2: Primjer LU dekompozicije
1
2
3
4
# -*- coding: utf-8 -*"""

LU DEKOMPOZICIJA
"""
5
6
from numpy import *
7
8
9
A = loadtxt(A.txt)
B = loadtxt(B.txt)
10
11
n = len(B)
12
13
# LU dekompozicija
14
15
L = zeros([n,n])
26.2 lu dekompozicija
16
U = zeros([n,n])
17
18
19
20
21
22
23
24
25
26
27
28
for k in range(0,n):
for i in range(k,n):
suma = 0
for m in range(0,k):
suma = suma + L[i,m]*U[m,k]
L[i,k] = A[i,k] - suma
for j in range(k+1,n):
suma = 0
for m in range(0,k):
suma = suma + L[k,m]*U[m,j]
U[k,j] = (A[k,j]-suma)/L[k,k]
29
30
31
for i in range(0,n):
U[i,i] = 1
32
33
# rjesavanje sustava
34
35
36
C = empty(shape(B))
X = empty(shape(B))
37
38
39
40
41
42
for i in range(0,n):
suma = 0
for j in range(0,i):
suma = suma + L[i,j]*C[j]
C[i] = (B[i]-suma)/L[i,i]
43
44
45
46
47
48
for i in range(n-1,-1,-1):
suma = 0
for j in range(i+1,n):
suma = suma + U[i,j]*X[j]
X[i] = C[i] - suma
49
50
print X
51
52
53
# Scipy rjesenje
print linalg.solve(A,B)
[-0.19367432
[-0.19367432
0.07619065
0.07619065
0.03675057
0.03675057
0.39036472]
0.39036472]
129
27
KO INTEGRIRANJE
NUMERIC
Numerickim integriranjem rjeava se odredeni

integral funkcije f(x) na intervalu [a, b]
Zb
f(x)dx
(27.1)
I=
a
27.1
trapezna formula
Najjednostavniji nacin za aproksimiranje odredenog

integrala je izracun povrine ispod najjednostavnije aproksimacijske krivulje - pravca. Pravac je
definiran pocetnom i krajnjom tockom intervala inegrala te zatvara povrinu sa x-osi oblika trapeza. Izracun povrine ispod pravca temelji se na
trapeznoj formuli tj. izracunu povrine trapeza:

Zb
f(a) + f(b)
f(x) dx (b a)
.
(27.2)
2
a
Svojstvo odredenog
integrala je da ga moemo rastaviti na konacni broj
djelova, te je tada odredeni

integral nad pocetnim intervalom jednak zbroju
integrala na djelovima tog integrala:
Zc
Zb
f(x)dx =
a
Zb
f(x)dx + f(x)dx.
(27.3)
Uzevi u obzir rastavljanje odredenog

integrala (27.3), trapeznu formulu
(27.2) moe se koristiti po djelovima intervala [a, b]:
Zb
f(x) dx
a
N
1X
(xk+1 xk ) (f(xk+1 ) + f(xk ))
2
(27.4)
k=1
gdje je N broj podintervala za koje vrijedi a < x1 < x2 < < xN1 <
xN < b .
Slika 27.1: Trapezi na cjelom intervalu [a, b] i na tri podintervala.
Za unifomnu podjelu intervala [a, b], gdje su svi podintervali jednako

iroki, trapezna formula (27.4) se moe pojednostaviti:
Zb
f(x) dx
a
N
hX
(f(xk+1 ) + f(xk ))
2
(27.5)
k=1
gdje je h irina podintervala.

Modul numpy.integrate sadri funkciju trapz za numericku integraciju
pomocu trapezne formule.
131

numeri cko
integriranje
132
scipy.integrate.trapz(y, x=None, dx=1.0)
Funkcija prima set (vektor) vrijednosti podintegralne funkcije u tockama diskretiziranog intervala [a, b]. Za neuniformnu diskretizaciju intervala [a, b]
potrebno je funkciji proslijediti vrijednosti diskretizirane varijable integracije
(vektor x-eva) a za uniformnu diskretizaciju dovoljno je specificirati irinu
samo vektor y, pretpospodintervala. Ukoliko je funkciji trapz proslijeden
tavlja se da je rijec o uniformnoj diskretizaciji sa irinom podintervala 1.
integral na uniformno diskretiU izvornom kodu 27.1 rjeen je odreden
ziranom intervalu implementacijom trapezne formule (27.5) te koritenjem
funkcije trapz sa vektorom diskretizirane varijable integracije i sa irinom
podintervala.
Izvorni kod 27.1: Primjer racunanja odredenog

inegrala pomocu trapezne formule
1
# -*- coding: utf-8 -*-
2
3
4
import numpy as np
5
6
7
def f(x):
return -25.0*x +200.0*x**2 +400.0*x**4 -500.0*x**5
8
9
10
11
# Granice integrala
# granice (a,b)=(0.0,1.0)
a, b = 0.0, 1.0
12
13
14
# Broj podintervala
n = 10
15
16
17
# Osiguravanje ispravnih tipova varijabli

a, b, n = float(a), float(b), int (n)
18
19
20
# Sirina intervala
h = (b-a)/n
21
22
23
24
# Diskretizacija, racunanje x-a i y-a za svaku tocku

X = np.linspace(a,b,n+1)
Y = f(X)
25
26
27
28
29
# Rucno rjesavanje odre

denog integrala pomocu trapezne formule
I = 0.
for i in range(n):
I += 0.5*h*(Y[i]+Y[i+1])
30
31
print Rjesenje 1: %f % I
32
33
34
35
# Rjesavanje pomo
cu numpy.trapz funkcije
print Rjesenje 2: %f %np.trapz(Y, X)
# pomocu vektora X
print Rjesenje 3: %f %np.trapz(Y, dx=h) # pomocu razmaka dx
36
37
38
39
40
41
42
43
44
45
# Crtanje
plt.figure(figsize=(8,5))
Xplt = np.linspace(min(X), max(X), 1000)
plt.plot(Xplt,f(Xplt), lw=2)
plt.plot(X, Y, ro)
for i in range(n+1):
plt.plot([X[i], X[i]], [0.0, Y[i]], k--)
plt.fill_between(X,f(X),color=DarkSeaGreen)
plt.show()
Rjesenje 1: 50.419500
Rjesenje 2: 50.419500
Rjesenje 3: 50.419500
27.2 simpsonove formule
133
120
100
80
60
40
20
0
20
0.0
0.2
0.4
0.6
0.8
1.0
Slika 27.2: Racunanje povrine ispod krivulje pomocu trapeza (Izvorni kod 27.1)
27.2
simpsonove formule
Simpsonova pravila (ili Simpsonove formule) koriste kvadratni ili kubni polinom za aproksimaciju funkcije prilikom numericke integracije. Zbog nemo
gucnosti odredivanja
aproksimacijkog polinoma na jendom intervalu (dvije
tocke), Simpsonove formule se korsite obuhvacajuci dva podinervala (za
aproksimaciju kvadratnim polinomom) ili na tri podintervala (za aproksimaciju kubnim polinomom).
Za aproksimaciju kvadratnim polinomom na intervalu [xi , xi+2 ] vrijedi:
Z xi+2
h
f(x)dx = (f(xi ) + 4f(xi+1 ) + f(xi+2 ))
(27.6)
3
xi
gdje je x uniformno diskretiziran (xi+2 xi+1 = xi+1 xi = h).
Izraz (27.6) c esto se naziva Simpsonova 1/3 formula a dobiven je integracijom kvadratnog polinoma koji prolazi kroz tocke (xi , f(xi )), (xi+1 , f(xi+1 )),
(xi+2 , f(xi+2 )).
Viestrukom primjenom na sve parove uniformno diskretiziranih podintervala na [a, b] dobiva se
Zb
n2
n1
X
X
1
f(x)dx = h f(x0 ) + 4
f(xi ) + 2
f(xi ) + f(xn )
(27.7)
3
a
i=1,3
i=2,4
poznato kao kompozitno Simpsonovo pravilo.

Kompozitno pravilo se moe zapisati i pomocu vektorskog produkta:
Zb
h
f(x)dx = (cT f)
(27.8)
3
a
gdje je c = [1 4 2 4 2 ... 2 4 1]T i f = [f1 f2 f3 ... fn ]T .
Povecanjem stupnja aproksimacijkog polinoma potrebno je vie tocaka za
njegovo definiranje. Za aproksimacijom polinomom 3 stupnja potrebne su
c etri tocke tj. 3 intervala. Integriranjem polinoma dobiva se izraz za aprok
simaciju odredenog
integrala:
Z xi+3
3
f(x)dx = h(f(xi ) + 3f(xi+1 ) + 3f(xi+2 ) + f(xi+3 ))
(27.9)
8
xi
Simposonova 1/3
formula je definirana
na parovima
podintervala, to
uvjetuje da za njeno
koritenje podrucje
odredenog
integrala
[a, b] treba podjeliti
na paran broj
podintervala.

numeri cko
integriranje
134
koji se naziva Simpsonova 3/8 formula.

Scipy ima implementiranu Simpsonovu 1/3 formulu u funkciji simps:
scipy.integrate.simps(y, x=None, dx=1, even=avg)
Funkciju simps se moe koristit za poznate vrijednosti podintegralne funkcije y u tockama x ili za razmak dx uniformne diskretizacije. Argumentom
even odreduje
se nacin na koji se racuna odredeni
integral nad parnim brojem tocaka (neparni broj podintervala):
? even = first, prvi podinterval se racuna pomocu trapezne formule
? even = last, zadnji podinterval se racuna pomocu trapezne formule
? even = avg, rezultat integracije je prosjecna vrijednost integrala izracunatih sa opcijom even = first i even = last.
U izvornom kodu 27.2 dan je primjer racunanja odredenog

integrala pomocu Simpsonove 1/3 formule.
Izvorni kod 27.2: Upotreba Simpsonove 1/3 formule
1
2
3
4
# -*- coding: utf-8 -*"""

SIMPSONOVA 1/3 FORMULA
"""
5
6
7
from numpy import *

from scipy.integrate import *
8
9
10
11
# Podintegralna funkcija
def f(x):
return 20.0*sqrt(x) - 0.2*x**2 - 2.0*sin(x)
12
13
14
# Granice odred
enog integrala
a, b = 0.0, 10.0
15
16
17
# Broj podintervala
n = 40
18
19
20
21
h = (b-a)/n
X = linspace(a,b,n+1)
Y = f(X)
22
23
24
25
INT = 0.0
for i in range(0, n - 1, 2):
INT = INT + (1.0/3.0)*h*(Y[i] + 4*Y[i+1] + Y[i+2])
26
27
28
# "Ru
cno" rjeenje
print INT
29
30
31
# Scipy rjesenje
print simps(Y,X)
351.089170175
351.089170175
27.3
quad se zansiva na
QUADPACK-u Fortran biblioteci za

numericku
integraciju
jednodimenzionalnih
funkcija.
naprednije metode
Scipy nudi funkciju quad koja koristi napredniju adaptivnu metodu za numericku integraciju.
Osnovna upotreba funkcije quad zahtjeva podintegralnu funkciju f te gra
nice odredenog
integrala a i b.
27.4 zadaci
scipy.integrate.quad(f, a, b)
U izvornom kodu 27.3 rjeen je isti odredeni

integral kao i u 27.2.
Izvorni kod 27.3: Numericko integriranje pomocu quad funkcije
1
# -*- coding: utf-8 -*-
2
3
4
from numpy import *

from scipy.integrate import *
5
6
7
8
# Podintegralna funkcija
def f(x):
return 20.0*sqrt(x) - 0.2*x**2 - 2.0*sin(x)
9
10
11
# Rjeavanje odre
denog integrala na intervalu [0, 10]
rj, gr = quad(f, 0, 10)
12
13
print rj
351.292211631
27.4
zadaci
Zadatak 27.1 Lim je izrezan u obliku tita koji je omeden:

? parabolom y = x2
? parabolom y = 2 0.1x2
Kolika je povrina izrezanog lima?
Zadatak 27.2 Oborinske vode sa krova zgrade odlaze u spremnik (cisterna).
Na ulazu u spremnik postavljen je mjerac protoka. Tijekom 15 minutnog pljuska svake minute zabiljeen je protok oborinske vode.
Vrijeme [min]
Protok [l/s]
Vrijeme [min]
Protok [l/s]
0.0
10.6
0.0
11.2
2.8
10
10.0
4.2
11
9.5
6.9
12
4.3
10.1
13
1.8
10.5
14
0.2
11.0
15
0.0
Ako vrijedi
ZT
Q(t)dt
V=
0
koliki je ukupni volumen vode koja je ula u spremnik?
135
Dio V
R J E AVA N J E M O D E L A T E M E L J E N I H N A O D J I
PDJ
28
K E M E T O D E Z A R J E AVA N J E O B I C
NIH
NUMERIC
DIFERENCIJALNIH JEDNADBI
obi cne
diferencijalne jednadbe 1. reda
28.1
y0 =
dy
= f(x, y)
dx
y(x0 ) = y0
28.1.1
(28.1)
(28.2)
Eulerova metoda
Eulerova metoda slui za numericko rjeavanje diferencijalne jednadbe prvog reda (28.1) sa zadanim pocetnim uvjetom (28.2) a temelji se na aproksimaciji funkcije y(x) pomocu prvog c lana Taylorovog reda u okolini tocke
x:
y(x + x) y(x) + y 0 (x) x
(28.3)
gdje je x konacni odmak od x.

28.1.2
Runge-Kutta metode
28.1.3
Rjeavanje pomocu scipy-a
Rjeavanje obicnih diferencijalnih jednadbi moguce je koritenjem odeint

funkcije iz modula scipy. Iako funkcija odeint ima znatno iru primjenu,
u ovom poglavlju c e se opisati samo primjena na obicne diferencijalne jednadbe prvog reda.
Osnovna sintaksa odeint funkcije je:
scipy.integrate.odeint(f, y0, x)
gdje je f funkcija kojom je definiran diferencijalna jednadba (28.1), y0 je

pocetni uvjet a x je vektor koji predstavlja diskretiziran interval varijable x.
Pocetni uvjet y0 vrijedi u pocetnoj vrijednosti vektora x.
Primjer rjeavanje obicne diferencijalne jednadbe 1. reda dan je u izvornom kodu 28.1.
Izvorni kod 28.1: Primjer rjeavanja obicnih diferencijalnih jednadbi 1. reda.
1
# -*- coding: utf-8 -*-
2
3
4
5
import numpy as np
import scipy.integrate as intgr
6
7
8
9
# ODJ dy/dx = f(y,x)

def f(y, x):
return -y + np.sin(x)*np.cos(y)
10
11
# Po
cetni uvjet
139
Pri upotrebi odeint

metode ocekuje se da
je funkcija f
definirana kao
f(y,x), to je
neuobicajen
redoslijed
argumenata te c esto
moe dovesti do
pogreke.
numeri cke
metode za rjeavanje obi cnih
diferencijalnih jednadbi
140
12
13
x0 = 0.
y0 = 20.
14
15
16
# Krajnja to
cka intervala
xf = 10
17
18
19
# Diskretizacija
X = np.linspace(x0, xf, 200)
20
21
22
# Rjeavanje ODJ
Y = intgr.odeint(f, y0, X)
23
25
26
27
28
29
# Vizualizacija
plt.plot(X, Y, r, lw = 2)
plt.xlabel(x)
plt.ylabel(y(x))
plt.grid()
plt.show()
20
15
10
y(x)
24
5
0
5
0
10
Slika 28.1: Vizualizacija rjeenja iz izvornog koda 28.1.
28.2
sustavi obi cnih

diferencijalnih jednadbi 1. reda
28.3
obi cne
diferencijalne jednadbe vieg reda
29
ETNI PROBLEMI
POC
29.1
modeliranje otvorenog vodotoka
Promatrajmo strujanje fluida u otvorenom vodotoku[3, 13] (eng. open channel

flow). Poprecni presjeci kanala mogu biti razliciti npr. pravokutni, trapezni i
sl., dok se kod prirodnih vodotoka pojavljuju poprecni presjeci nepravilnih
oblika. Ukoliko je poprecni presjek kanala jednak na proizvoljnom presjeku,
te je nagib dna jednak u bilo kojoj tocki, govorimo o prizmaticnom kanalu.
Slika 29.1: Skica poprecnog presjeka otvorenog vodotoka
Na poprecnom presjeku kanala definiramo sljedece velicine:

? A - povrina omocenog presjeka kanala (A = A(x, y)
? P - perimetar odnosno opseg omocenog presjeka (P = P(x, y))
? R - hidraulicki radijus (R =
A
)
P
Klasifikacija strujanja se moe napraviti prema razlicitim kriterijima. Ako

se brzina strujanja ne mijenja u ovisnosti o vremenu, onda je strujanje stacionarno, u suprotnom se radi o nestacionarnom strujanju. Nadalje, ako se
brzina strujanja ne mijenja s obzirom na udaljenost u kanalu (od neke referentne tocke) onda je strujanje uniformno, a inace se radi o neuniformnom
strujanju.
idealan fluid
enegetska linija
vodno lice
referentna ravnina
Slika 29.2: Energetske linije u strujanju fluida otvorenim vodotokom
141
142
po cetni
problemi
Pretpostavke:
? kut je mali
? strujanje je izrazito jednodimenzionalno
? tlak je iskljucivo hidrostatski
Opcenito se strujanje u kanalu opisuje sustavom parcijalnih diferencijalnih jednadbi, koje proizlaze iz zakona ocuvanja mase i zakona ocuvanja
kolicine gibanja. Ako pretpostavimo da se radi o prizmaticnom kanalu, moemo ih zapisati u obliku:
A Q
+
=0
t
x
v
+g
t
x
(29.1)

v2
y+
= g(S0 Sf )
2g
(29.2)
Q
y je dubina vode, v brzina, a Q protok, pri c emu vrijedi relacija v = .
A
dH
Sf je pad energetske linije
, definiran Manningovom formulom (koja je
dx
prikazana u nastavku). Uvedimo oznaku
dH
= Sf
dx
S S0 smo oznacili nagib dna kanala, tj. S0 =
29.1.1
(29.3)
dz
= tan().
dx
Stacionarno strujanje
Nadalje, ukoliko promatramo stacionarno strujanje fluida, ocito je da zbog

v
A
= 0i
= 0, iz prve jednadbe
neovisnosti varijabli o vremenu tj. 0
t
t
sustava (29.1) slijedi:
Q = konst.
odnosno iz druge jednanbe

dz dy
d v2
+
+
= Sf
dx dx dx 2g
(29.4)
(29.5)
Zapravo se ova jednadbe moe dobiti i ako krenemo od poznate nam

Bernoullijeve jednabe
z+
p
v2
+
=H
g 2g
(29.6)
prema kojoj je ukupna energija konstantna du strujnice. Vrijednost energetske linije oznacimo s H. Uvaavanjem jednakosti p = gy , slijedi z + y +
v2
= H, odnosno deriviranjem po x dobijemo diferencijalnu jednadbu za
2g
dubinu vode y = y(x):
2
dz dy
d
Q
dH
+
+
=
(29.7)
dx dx dx 2gA2
dx
29.1 modeliranje otvorenog vodotoka
Vrsta kanala
Manningov koeficijent
Betonski kanal
0.015
Prirodni kanali (glina)
0.030
Rijecni tokovi
0.030 - 0.070
143
Tablica 29.1: Vrijednosti Manningovog koeficijenta za razlicite izvedbe kanala.
Nadalje, kod stacionarnog toka (Q = konst.) u prizmaticnom kanalu vrijedi

2

Q
Q2 d
1
d
=
dx 2gA2
2g dx A2

Q2 d
1
dy
=
2g dy A2 dx
(29.8)
Q2 dA dy
= 3
gA dy dx
Q2 B dy
=
gA3 dx
Kod druge smo jednakosti uvaili c injenicu da je kanal prizmatican, to
znaci da se poprecni profili ne mijenjaju s obzirom na udaljenost x u kanalu,
dH
dA
= B. Pad energetske linije
= Sf
dok zadnja jednakost slijedi iz
dy
dx
definiran je Manningovom formulom, pomocu koje se modeliraju gubici
nastali zbog trenja
29.1.2
Maningova formula
Manningova formula, jo poznata kao GaucklerManningova formula ili GaucklerManningStricklerova formula, je empirijska jednadba za strujanje
u otovrenim kanalima ili strujanja sa slobodnom povrinom pod utjecajem
gravitacije. Definirana je kao:
Sf =
Q2 n2
2
R4/3)A
(29.9)
A
gdje je n Manningov koeficijent trenja, R =
je hidraulicki radijus, a P
P
perimetar.
dy
S Sf
= 0
dx
BQ2
1
gA3
(29.10)
BQ2
Opazimo da jednadba (29.10) vrijedi za
6= 1
gA3
(29.10) je diferencijalna jednadba prvog reda oblika
dy
= f(x, y(x))
dx
za koju analiticko rjeenje znamo odrediti samo u nekim posebnim slucajevima, za razliku od numerickog rjeenja koje znamo odrediti u podrucju
u kojem je diferencijalna jednadba dobro definirana. Da bi problem bio u
potpunosti modeliran potrebno je zadati i pocetne uvjete.
Zadatak: Za pocetni
uvjet y(x0 ) = y0
odrediti dubinu vode
y(x) iz
diferencijalne
jednadbe (29.10).
144
po cetni
problemi
Uniformno strujanje i normalna dubina
29.1.3
Kao to smo vec spomenuli, kod uniformnog strujanja su brzina i dubina

dy
= 0, slijedi:
vode konstantne velicine pa iz jednadbe (29.10), zbog
dx
(29.11)
S0 = Sf
Iz Manningove formule (29.9) potom proizlazi da kod uniformnog toka vrijedi:

Q=
1
1/2
AR2/3 S0
n
(29.12)
Na osnovu te jednadbe moe se odrediti dubina vode kod uniformnog

toka, tzv. normalna dubina koju c emo oznaciti yn .
29.1.3.1
Prizmaticni kanal s pravokutnim poprecnim presjekom
B - irina kanala
A(y) = B y
dA
=B
dy
(29.13)
(29.14)
P(y) = B + 2y
Slika 29.3: Pravokutni poprecni presjek kanala
Kod zadavanja podataka, obicno su nam poznate velicine: Q, n, S0 , B.

Normalnu dubinu potom moemo odrediti iz sljedeceg izraza:
1
1/2
Q = AR2/3 S0
n

2/3
1
Byn
1/2
S0
= Byn
n
B + 2yn
(29.15)
koristeci neku od numerickih metoda

29.1.3.2
Trapezni kanal
B0 - irina kanala Z - nagib bocnih stranica kanala (tangens kuta nagiba

bocnih stranica kanala)
A(y) = (B0 + yZ) y
P(y) = B0 + 2y
1 + Z2
dA
= B0 + 2yZ
dy
(29.16)
(29.17)
Slika 29.4: Trapezni poprecni presjek kanala
Zadatak 29.1 Odrediti normalnu dubinu vode yn u trapeznom kanalu, s bocnim nagibom Z = 2, te irinom dna B0 = 10m. Nagib dna kanala je konstandz
tan i jednak S0 =
= 0.001 (1m po km duljine) a Manningov koeficijent
dx
n = 0.013.
Rjeenje
Dubinu vode oznacimo s y. Iz slicnosti trokuta slijedi 1 : z = y : x, pa je
x = zy. Povrina omocenog presjeka trapeza
je A = (B0 + zy)y. Opseg
omocenog presjeka trapeza je P = B0 + 2y 1 + z2 . Hidraulicki radijus
je
R=
A
(B0 + zy)y
.
=
P
B0 + 2y 1 + z2
Normalnu dubinu vode potom odredujemo

iz jednadbe (29.12), koja
nakon uvrtavanja dobivenih izraza i i sredivanja

poprimi oblik
[(B0 + zyn ) yn ]5/3
nQ
h
i2/3 = 0
S0
2
B0 + 2yn 1 + z
Nakon uvrtavanja poznatih vrijednosti dobijemo
F(yn ) = 12.33(10 + 4.47yn )2/3 ((10 + 2yn )yn )5/3 = 0
Nul tocka funkcije F(y) predstavlja rjeenje gornje jednadbe. Moe se
odrediti pomocu neke od numerickih metoda npr. bisekcijom ili Newtonovom metodom. Rjeenje je
yn = 1.09m
29.1.4
Kriticna dubina
Nadalje, definirajmo kriticnu dubinu yc . To je dubina kod koje je Froudov

broj jednak 1, tj.
v
Fr =
=1
gyc
(29.18)
Opazimo da je u slucaju kriticne dubine nazivnik u diferencijalnoj jednadbi

(29.10) jednak 0 te da diferencijalna jednadba u toj tocki ne vrijedi. Kriticnu
dubinu moemo izraziti iz (29.18) te dobijemo
s
s
2
2
3 q
3 Q
yc =
=
(29.19)
2
g
gA
145
146
po cetni
problemi
Q
. Karakteristika kriticne dubine je da je to dubina kod koje je
A
specificna energija
fluida minimalna.
Vrijednost c = gy nazivamo brzina irenja poremecaja. To je zapravo

relativna brzina irenja vala u odnosu na medij unutar kojeg taj val putuje.
Apsolutne brzine irenja vala su zapravo jednake v c i v + c. Ako je v < c
onda govorimo o podkriticnom toku, za v = c je tok kritican, dok je za
v > c tok nadkritican. Uocimo da kod podkriticnog toka vrijedi v c < 0 , a
v + c > 0 to znaci da se jedan kraj vala putuje uzvodno, a drugi nizvodno.
Kod kriticnog je toka v c = 0 , pa je jedna strana vala stacionarna, dok
druga putuje nizvodno brzinom v + c. Za razliku od toga, kod nadkriticnog
toka se obje strane vala gibaju nizvodno, jer je v c > 0 i v + c > 0. Dakle,
kod nadkriticnog toka poremecaj putuje iskljucivo nizvodno, to znaci da
nizvodno.
tok uzvodno od promatrane lokacije uopce ne zna to se dogada
gdje je q =
29.1.5
Hidraulicki skok
Hidraulicki skok (jump) se pojavljuje kod prijelaza strujanja iz nadkriticnog

u pdkriticno. U tocki u kojoj je Froudov broj jednak 1 dogodi se hidraulicki
skok. Kod hidraulickog skoka dolazi do gubitka energije (zbog turbulencije)
i do naglog skoka u vodnom licu. Kako gubitak energije na skoku nije unaprijed poznat, jednadbu ocuvanja energije ne moemo primijeniti direktno.
da u tocki skoka diferencijalna jednadba (29.10) ne vrijedi
Uocimo takoder
jer je nazivnik desne strane jednak nula.
U nastavku c emo promatrati rjeenja jednadbe (29.10) uz postavljeni poc etni uvjet y(x0 ) = y0 , tj. poznatu dubinu vode u nekoj tocki. Kako analiticka rjeenja jednadbe nisu poznata, osim u nekim posebnim slucajevima, za rjeavanje c emo koristiti numericke metode. Prisjetimo se, da su
standardne numericke metode za rjeavanje diferencijalne jednadbe prvog
reda: Eulerova metoda, poboljana Eulerova metoda i razlicite Runge-Kutta
metode. Koju c emo od spomenutih metoda odabrati ovisi o tocnosti koju
elimo postici. Pritom treba svakako voditi racuna i o stabilnosti pojedinih
metoda.
Rjeenja postavljenog pocetnog problema mogu biti razlicitog oblika, u
zavisnosti o pocetnom uvjetu, nagibu kanala i trenju u kanalu. Promatrati
c emo razlicite slucajeve u tzv. kanalima s blagim nagibom (mild slope). Takav je nagib okarakteriziran uvjetom
(29.20)
yc < yn
U tom se slucaju linija kriticne dubine nalazi ispod linije normalne dubine.
Tim je dvjema linijama podrucje strujanja podijeljeno u tri zone (vidi sliku
3.). Oblik rjeenja, dakle vodno lice, ovisi o pocetnom uvjetu. Traena se
rjeenja odreduju
iz diferencijalne jednadbe (29.10), koja se za promatrani
pravokutni prizmaticni kanal moe zapisati u obliku:

yn 10/3
1+
dy
y
= S0
3
dx
yc
1
y

(29.21)
U ovisnosti o zoni u kojoj se nalazi pocetni uvjet, dakle pocetna dubina ovisi
sami oblik rjeenja. Znacajno je naglasiti da dubina vode, odnosno rjeenje
ne moe prijeci diferencijalne jednadbe iz jedne u drugu zonu dakle, ako
je pocetni uvjet u zoni 1, vodno lice ostati c e u zoni 1. Pripadajuca se krivulja

naziva M1 krivulja.
Razlikujemo M1, M2 i M3 krivulje (Slika 29.5). Vrijedi:
? za yc < yn < y0 rjeenje je M1-krivulja
? za yc < y0 < yn rjeenje je M2-krivulja
? za y0 < yc < yn rjeenje je M3-krivulja
U tockama u kojima se dogodi prijelaz iz jedne u drugu zonu, rjeenje
zapravo ne zadovoljava diferencijalnu jednadbu (to su slucajevi u kojima
je nazivnik u diferencijalnoj jednadbi jednak 0, dakle tocke u kojima se
dostigne kritican tok).
Primjeri u kojima se pojavljuju promatrane krivulje:
? M1-krivulja podkriticno strujanje (Fr<1) - utok u jezero;
? M2-krivulja prijelaz iz podkriticnog u nadkriticno strujanje kod kanala c iji se nagib poveca; strujanje prije prijelaza u nadkriticno ima
oblik M2-krivulje;
? M3-krivulja prijelaz iz nadkriticnog u podkriticno strujanje npr. strujanje ispod zapornice; dio krivulje prije prijelaza u podkriticni tok ima
oblik M3-krivulje.
Na slican se nacin rjeenja mogu dobiti i za vece nagibe kanala (steep slope)
kada je yc > yn . U tom slucaju rjeenja imaju oblik tzv. S-krivulja (Slika
29.6).
Slika 29.5: M-krivulje vodnog lica
29.1.6
Slika 29.6: S-krivulje vodnog lica
Numericko rjeavanje
Izvorni kod 29.1: Strujanje u pravokutnom kanalu

1
2
# -*- coding: utf-8 -*"""
147

po cetni
problemi
148
3
4
5
6
pravokutni kanal
transkriti
cno strujanje
rjeavanje ODJ
"""
7
8
9
10
11
from
from
from
from
numpy import *
scipy.optimize import *
scipy.integrate import *
matplotlib.pyplot import *
12
13
g = 9.81
14
15
16
17
18
# ulazni podaci o kanalu

B = 15.0
S0 = 0.001
n = 0.012
19
20
Q = 10.0
21
22
23
yc = ((Q/B)**2/g)**(1.0/3.0)
print(yc = +str(yc))
24
25
26
27
28
29
# osnovne veli
cine
A = lambda y: B*y
P = lambda y: B+2*y
R = lambda y: A(y)/P(y)
Sf = lambda y: (n*Q/(R(y)**(2.0/3.0)*A(y)))**2
30
31
32
yn = fsolve((lambda y: Sf(y)-S0),yc)
print(yn = +str(yn[0]))
33
34
35
36
37
# ra
cunanje razine vode
x0 = 0.0
y0 = 0.42
x1 = 30.0
38
39
X = linspace(x0,x1,100)
40
41
42
dydx = lambda y,x: (S0-Sf(y))/(1.0-B*Q**2/(A(y)**3*g))

Y = odeint(dydx,y0,X)
43
44
45
#dydx_2 = lambda y,x: S0*(1.0-(yn/y)**(10.0/3.0))/(1.0-(yc/y)**3)

#Y_2 = odeint(dydx_2,y0,X)
46
47
48
49
50
51
52
53
54
55
#crtanje
figure(1, [8, 3])
Ydno = -(X-x0)*S0
plot(X,Y[:,0]+Ydno)
plot(X,Ydno)
#plot(X,Y_2[:,0]-(X-x0)*S0);
legend((razina vode,dno),loc=best);
show()
0.5
0.4
0.3
razina vode
dno
0.2
0.1
0.0
0.10
10
15
20
25
Slika 29.7: Numericko rjeenje strujanja u otvorenom kanalu pravokutnog presjeka
30
149
30
RUBNI PROBLEMI
Uvod, opcenito o rubnim problemima

30.1
savijanje grede
Za rjeavanje ovog primjer koriten je rjeavac bvp1lg. Prije instalacije modula bvp1lg potrebno je instalirati pakete koje on koristi:
sudo zypper in python-numpy-devel fparser-devel \
libatlas3 libatlas3-devel lapack-devel
nakon c ega se moe instalirati i sam modul:

sudo pip install scikits.bvp1lg
bvp1lg zahtjeva
Fortran compiler!
q(x)
u(x)
E, I
Slika 30.1: Savijanje grede
progiba elasticne linije i postavljenog opterecenja opisana je

Veza izmedu
Euler-Bernoullijevom jednadbom (Diferencijalna jednadba elasticne linije):
EI
d2 u
= M(x)
d x2
(30.1)
ili proireno
d2
d x2
d2 u
EI
d x2
!
= q(x)
(30.2)
gdje je E Youngov modul, I osni moment tromosti poprecnog presjeka, u je

progib grede, M je moment savijanja, q je kontinuirano poprecno opterecenje, a x je os nedeformirane grede.
Ako je E I konstantno du grede, jednadba (30.2) se pojednostavljuje:
EI
d4 u
= q(x)
d x4
(30.3)
Pomocu supstitucija:
w1 (x) = u(x)
du
dx
d2 u
w3 (x) =
d x2
d3 u
w4 (x) =
d x3
w2 (x) =
(30.4)
151
152
rubni problemi
obicnu diferencijalnu jednadbu 4. reda (30.3) moe se zapisati kao sustav 4

obicne diferencijalne jednadbe 1. reda.
d w1
dx
d w2
dx
d w3
dx
d w4
dx
= w2 (x)
= w3 (x)
(30.5)
= w4 (x)
=
1
q(x)
EI
Za sustav (30.5) potrebno je postaviti 4 rubna uvjeta kako bi se moglo dobiti rjeenje savijanja grede. Rubni uvjeti koje je moguce postaviti na krajeve
grede (Slika 30.2):
? Rubni uvjet progiba u|xbc = ubc . U tocki xbc postavlja se vrijednost
progiba ubc .

= vbc . U tocki xbc postavlja se vrijednost
? Rubni uvjet nagiba dd u
x
xbc
nagiba vbc .
? Rubni uvjet momenta
d2 u

d x2 x
nost momenta Mbc .

? Rubni uvjet poprecne sile
= Mbc . U tocki xbc postavlja se vrijedbc
d3 u

d x3 x
vrijednost poprecne sile Qbc .
= Qbc . U tocki xbc postavlja se

bc
Slika 30.2: Rubni uvjeti za razlicite oslonce grede
U izvornom kodu 30.1 prikazan je primjer rjeavanja savijanja grede koristeci bvp1lg paket koji je specijaliziran rjeavac za rubne probleme. U danom primjeru koriteni su sljedeci rubni uvjeti: lijevi rub je ukljeten (nema
progiba ni rotacije/nagiba) dok na desnom rubu zglob (nema pomaka ni
momenta). Greda je opterecenja konstantnim kontinuiranim opterecenjem
du cijele duine.
Izvorni kod 30.1: Rjeavanje elasticne linije savijanja
1
2
from pylab import *

import scikits.bvp1lg as bvp
3
4
5
6
7
8
9
# Definiranje problema
EI = 1.0 # Youngov modul i moment otpora
L = 1.0 # Duzina grede
# Opterecenja
qq=-1.0
30.2 stacionarno provoenje topline u tapu
10
11
# Kontinuirana sila, poprecna sila i moment savijanja

def q(x): return qq
12
13
degrees = [1, 1, 1, 1]
14
15
16
17
18
19
20
21
# Sustav diferencijalnih jednadzbi

def function(x , y):
u, du, d2u, d3u = y
return ([ du,
d2u,
d3u,
q(x)/EI])
22
23
24
25
26
27
# Rubni uvjeti
boundary_points = [0.0, 0.0, L, L]
def boundary_conditions(y):
u, du, d2u, d3u = y
return [u[0], du[1], u[2], d2u[3]]
28
29
tol = [1e-15, 1e-15, 1e-15, 1e-15]
30
31
32
33
34
35
# Rjesavanje rubnog problema

solution = bvp.colnew.solve(
boundary_points, degrees, function, boundary_conditions,
is_linear=False, tolerances=tol,
vectorized=False, maximum_mesh_size=10000)
36
38
39
40
41
42
43
44
45
46
# Vizualizacija rjesenja
figure(1, figsize=(8, 3))
x = solution.mesh
plot(x, solution(x)[:,0], b-, linewidth=2)
xlabel(x)
ylabel(y)
grid()
savefig(greda.pdf)
show()
Rjeenje dobiveno izvornim kodom 30.1 je prikazano na slici 30.3.
37
0.000
0.001
0.002
0.003
0.004
0.005
0.0060.0
0.2
0.4
0.6
Slika 30.3: Progib elasticne linije grede
30.2
stacionarno provoenje topline u tapu
0.8
1.0
153
31
K L A S I F I K A C I J A PA R C I J A L N I H D I F E R E N C I J A L N I H
JEDNADBI
Za danu funkciju u = u(x, y) se parcijalne derivacije definiraju s

u
u(x + x, y) u(x, y)
(x, y) = lim
x
x
x0
(31.1)
u(x, y + y) u(x, y)
u
(x, y) = lim
y
y
y0
(31.2)
Parcijalna diferencijalna jednadba je jednadba koja sadri parcijalne derivacije nepoznate funkcije dviju ili vie nezavisnih varijabli.
Opceniti oblik linearne PDJ drugog reda s konstantnim koeficijentima je
A
2 u
2 u
2 u
+C 2 +D
+B
2
xy
x
y
(31.3)
je predznakom izraza B 4AC. Parcijalna

Tip jednadbe (31.3) odreden
diferencijalna jednadba (31.3) je
? elipticka za B2 4AC < 0
? parabolicka za B2 4AC = 0
? hiperbolicka za B2 4AC > 0
Zbog veoma rairene pojave jednadbi ovakvog tipa u matematickom modeliranju fizikalnih pojava, a time i u inenjerstvu, upoznat c emo neke od
numerickih metoda koje se koriste pri rjeavanju jednadbi oblika (31.3).
Numericke se metode bitno razlikuju u zavisnosti o tipu jednadbe.
155
K E PA R C I J A L N E D I F E R E N C I J A L N E J E D N A D B E
ELIPTIC
Tpicni predstavnici PDJ eliptickog tipa su:

Laplaceova jednadba
u =
2 u 2 u
+ 2 =0
x2
y
(32.1)
Poissonova jednadba
u =
2 u 2 u
+ 2 = f(x, y)
x2
y
Kvaziharmonicka PDJ

u
kx
+
ky
= f(x, y)
x
x
y
y
(32.2)
(32.3)
progib plo ce
32.1
q
x
y
z
Slika 32.1: Ploca
Promatramo plocu jednostavno poduprtu na rubovima, s povrinskim opterecenjem q (Slika 32.1). Progib tako slobodno oslonjene ploce u smjeru z
moe se odrediti iz PDJ eliptickog tipa
4 z
4 z
4 z
q
+
2
+
=
D
x4
x2 y2 y4
(32.4)
koja vrijedi u unutarnjim tockama podrucja , te rubnih uvjeta

z| = 0
(32.5)

2 z
=0
n2
(32.6)
Parametar D definiran je s
D=
Et3
2(1 2 )
(32.7)
gdje je E Youngov modul, t debljina ploce a Poissonov broj.
157
32

elipti cke
parcijalne diferencijalne jednadbe
158
Ako se definira nova varijabla

u = z =
2 z 2 z
+
x2 y2
(32.8)
jednadba (32.4) moe se zapisati u obliku

q
2 u 2 u
+ 2 =
D
x2
y
(32.9)
pa se problem (32.4) svodi na rjeavanje dviju Poissonovih jednadbi (32.8)

i (32.9).
Iz rubnih uvjeta (32.5) i (32.6) odreduju

se rubni uvjeti koji pripadaju
dobivnenim jednadbama 2. reda:
u| = 0
(32.10)
z| = 0
(32.11)
Naravno, prvo se rjeava jednadba (32.9) a onda se dobiveno rjeenje

koristi za rjeavanje jednadbe (32.8).
Izvorni kod 32.1: Rjeavanje problema progiba ploce pomocu metode konacnih razlika
1
2
3
4
5
6
# -*- coding: utf-8 -*"""

progib plo
ce
rjeavanje PDJ
kona
cne razlike
"""
7
8
9
10
11
from
from
from
from
numpy import *
scipy.linalg import *
mpl_toolkits.mplot3d import Axes3D
12
13
14
15
16
17
18
# ulazni podaci
q = 10000.0 # [N/m^2]
d = 0.01
# [m]
L = 2.0
# [m]
E = 2.0*10**11 # modul elasti
cnosti
pbr = 0.3
# Poissonov broj
19
20
D = E*d**3/(12.0*(1.0-pbr**2))
# fleksna krutost
21
22
nm = 50
# broj to
caka po dimenziji
23
24
25
h = L/(nm-1)
n = (nm-2)
# udaljenost od tocke do tocke
26
27
28
29
30
31
32
33
34
# izgradnja matrice sustava i vektora d.s.

Adblok = zeros([n,n]) + diag(-4*ones(n)) + \
diag(ones(n-1),k=1) + diag(ones(n-1),k=-1)
A=empty([0,0])
for i in range(n):
A = block_diag(A, Adblok)
A = A + diag(ones([n**2-n]),k=n) + diag(ones([n**2-n]),k=-n)
b = h**2*q/D*ones(n**2)
35
36
37
38
# rjeavanje
u = solve(A,b)
z = solve(A,u*h**2)

32.1 progib plo ce
39
40
41
42
43
# pakiranje rezultata
z = reshape(z,[n,n])
# ili: z = z.reshape([n,n])
Z = zeros([nm,nm])
Z[1:(nm-1),1:(nm-1)] = -z
44
45
46
47
# prikaz
pcolor(Z)
colorbar()
48
49
50
51
52
53
# 3d
l = linspace(0,L,nm)
X, Y = meshgrid(l,l)
figure().gca(projection=3d).plot_surface(X,Y,Z, \
rstride=1, cstride=1, cmap=cm.coolwarm, linewidth=0)
54
55
show()
159
33
METODA LINIJA
Metoda linija je opca tehnika za rjeavanje parcijalnih diferencijalnih jednadbi (PDE) koje obicno koriste konacne razlike za odnose prostornih derivacija i obicne diferencijalne jednadbe za vremensku derivaciju.
Za ilustraciju i detaljnije pojanjenje ove metode koristit c e se primjena
metode na problem nestacionarnog progrijavanja tapa. Parcijalna diferencijalna jednadvba koja opisuje promjenu temperature du osi tapa i u
vremenu je:
2 T
T
=D 2
t
x
(33.1)
Lijevi rub je izoliran i u toj tocki vrijedi Neumannov rubni uvjet:

T
=0
x 0
(33.2)
Na desnom rubu zadana je konstantna temperatura i vrijedi Dirichleov

rubni uvjet:
T |L = 0
(33.3)
.
Osnovna ideja metode linija je da se parcijalnu diferencijalnu jednadbu
(33.1) svede na sustav obicnih diferencijalnih jednadbi.
"ghost" point
i=1
i-1
i=n
i+1
x
x=0
x=L
Slika 33.1: Diskretizacija
Diskretizacijom prostorne koordinate (Slika 33.1) te aproksimacijom konacnim razlikama, vrijedi:

2 T
T (x + x) 2T (x) + T (x x)
(x) =
x2
x2
(33.4)
Jednadba (33.4) vrijedi za svaku unutarnju diskretizacijsku tocku i ovisna

je o susjednim tockama:
T
2Ti + Ti1
Ti
= D i+1
t
x2
(33.5)
Na lijevom rubu, iz (33.2) vrijedi:

T1 = T0
(33.6)
161
162
metoda linija
pa se moe korigirati jednadbu za prvu tocku:

T1
T 2T1 + T0
T T
=D 2
=D 2 21
2
t
x
x
(33.7)
Desni rub se ne mjenja u vremenu, pa u krajnjoj tocki vrijedi:

Tn
=0
t
(33.8)
Jednadbe (33.4), (33.7) i (33.8) tvore sustav obicnih diferencijalnih jednadbi koje se moe rjeiti prikladinim rjeavacem.
Izvorni kod 33.1: Primjer rjeavanje provodenja

topline kroz tap pomocu metode linija
1
2
#!/usr/bin/python
# -*- coding: utf-8 -*-
3
4
5
6
7
from
from
from
from
scipy import *
scipy.integrate import *
matplotlib.animation import *
8
9
10
11
12
13
nx = 50
x = linspace(0, 1, nx)
A = diag(ones(nx)*(-2.0), k=0) + \
diag(ones(nx-1)*1.0, k=1) + \
diag(ones(nx-1)*1.0, k=-1)
14
15
16
17
18
19
"""
Resetiraj jednadbu za prvu i zadnju to
cku
"""
A[0,:] = 0
A[-1,:] = 0
20
21
22
23
24
25
26
27
"""
Prva to
cka: izolacija dT0/dx = 0 ==> T_-1 = T_0
dT0/dt = k*(T_1 - 2*T_0 +T_-1)/dx^2
= k*(T_1 - T_0)/dx^2
"""
A[0,0] = -1
A[0,1] = 1
28
29
30
31
32
"""
Zadnja to
cka: fiksna temperatura dT/dt = 0
"""
A[-1,-1] = 0
33
34
35
36
37
38
dx=0.1;
k=0.01;
nt = 11
t = linspace(0.0, 100., nt)
39
40
41
T0 = sin(x*pi)
print shape(dot(A,T0))
42
43
44
45
46
47
48
"""
Postavi sustav ODJ
"""
def dT_dt(T, t):
dT = (k/dx**2.0)*dot(A,T)
return dT
49
50
51
52
"""
Rjei sustav ODJ
"""
metoda linija
53
rez = odeint(dT_dt, T0, t)
54
55
56
57
58
59
60
"""
Crtanje i animacija rjeenja
"""
fig1 = figure()
lineGeom, = plot([], [], r-, lw=2)
titl = title()
61
62
63
64
65
66
def update_line(i):
lineGeom.set_data(x, rez[i,:])
titl.set_text(t=%f % t[i])
#fig1.savefig(img_%03d.png % i)
return
67
68
69
anim = FuncAnimation(fig1, update_line, nt, interval=1000, repeat_delay=0)

show()
163
Dio VI
OPTIMIZACIJSKE METODE
34
DEFINICIJA OPTIMIZACIJSKOG PROBLEMA

Optimizacijski problem se moe postaviti kao pronalaenje vektora x =
(x1 , x2 , ..., xn ) za koji vrijedi
f(x ) 6 f(x), x
(34.1)
gdje je f funkcija cilja, x = (x1 , x2 , ..., xn ) vekor optimizacijskih varijabli a x

vektor rjeenja optimizacijskog problema. je prostor pretraivanja.
Izraz (34.1) pretpostavlja da je rijec o minimizacijskom problemu. U sluc aju maksimizacije, problem se definira kao
f(x ) > f(x), x
34.1
(34.2)
optimizacijske varijable
Optimizacijske varijable (eng. optimization variables, design variables, design

parameters, decision variables) su varijable c ije vrijednosti treba odrediti a da
zadovoljavaju ciljeve i ogranicenja optimizacijskog problema.
Zbog jednostavnosti zapisa, c esto se koristi vektor optimizacijskih varijabli (eng. design vector):
x = (x1 , x2 , ..., xn )
(34.3)
gdje je n broj optimizacijskih varijabli.
Domena pretraivanja ili prostor pretraivanja odreduje

moguce vrijed je s obzirom na tip varijabli (kontinosti optimizacijskih varijabli; a odreden
nuirane ili diskretne) te s obzirom na propisane granice varijabli.
Prostor pretraivanja
Za optimizaciju sa kontinuiranim neomedenim

varijablama vrijedi
x Rn
(34.4)
Uvodenjem
omedenosti,
prostor pretraivanja suava se na
x Rn
(34.5)
Omedenost
(bound) kontinuiranih optimizacijskih varijabli je postavljanje
granica varijabli tj. definiranje doputenog intervala varijabli. Za svaku kontinuiranu varijablu xi moe se postaviti donja granica (lower bound) xmin
te
i
gornja granica (upper bound) xmax
i
onda
vrijedi:
i
i
h
xi xmin
, xmax
, i = 1, . . . , n
(34.6)
i
i
Uvodenjem
diskretnih varijabli, najcece indeksiranih pomocu cijelih ili
prirodnih brojeva, prostor pretraivanja se definira na skupu cijelih brojeva
x Zn
(34.7)
ili na skupu prirodnih brojeva

x Nn
(34.8)
167
168
definicija optimizacijskog problema
U relanim primjenama, diskretne varijable su gotovo uvijek definirane na

konacnom skupu brojeva
xi {i = 1, 2, . . . , ki } , i = 1, . . . , n
(34.9)
gdje je ki broj mogucih vrijednsoti diskretne varijable xi .

Optimizacijske probleme, s obzirom na tip optimizacijskih varijabli, moemo klasificirati na:
? kontinuirane
? diskretne
? mjeovite
a s obizirom na omedenost
na:
? omedene
(bounded) i
? neomedene
(unbounded).
34.2
ciljevi optimizacije i funkcija cilja

f(x)
34.3
ograni cenja
(34.10)
35
LINEARNO PROGRAMIRANJE
Linearno programiranje je matematicka metoda pronalaska optimuma linearne funkcije vie varijabli potujuci ogranicenja zadana linearnim nejednakostima i jednakostima.
Linearno programiranje je razvijeno kao disciplina u 1940-ima, u pocetku
motivirano zbog potrebe za rjeavanje sloenih problema planiranja u ratnim operacijama. Njegov razvoj ubrzano raste u poslijeratnom razdoblju,
kad mnoge industrije pronalaze korisne primjene linearnog programiranja.
Iako je problem linearnog programiranja formulirao jo Furier, jedna od
prvih prakticnih upotreba imao je ruski matematicar Kantorovic ([5]) u pokuaju poboljanja ekonomskih planiranja 1939. godine u SSSR-u.
35.1
definicija lp problema
Problem linearnog programiranje moe se razluciti na funkciju cilja te na

ogranicenja.
Funkcija cilja je linerna jednadba n varijabli (x1 , x2 , ..., xn ) definirana koeficijetima c1 , c2 , ..., cn .
f(x1 , x2 , ..., xn ) =
n
X
ci xi
(35.1)
i=1
Jednadba (35.1) moe se zapisati u vektorskom obliku:

f(x) = c x
(35.2)
gdje je x = (x1 , x2 , ..., xn ) vekor varijabli a c = (c1 , c2 , ..., cn ) vektor koeficijenata linearne jednadbe. Vektor x Rn predstavlja optimizacijske
varijable za koje se trai optimalno rjeenje x za koje vrijedi
f(x ) 6 f(x), x
(35.3)
Ogranicenja problema se mogu zadati kao sustav linearnih nejednadbi:

a11 x1 + a12 x2 + . . . + a1n xn
> b1
a21 x1 + a22 x2 + . . . + a2n xn

..
.
> b2
..
.
am1 x1 + am2 x2 + . . . + amn xn
> bm
gdje je m broj ogranicenja.

Sustav linearnih nejednadbi (35.6) se moe jednostavnije zapisati vektorski
Ax > b
(35.4)
169
Nejednadbe se mogu
zadavati sa razlicitim
operatorima
usporedivanja
(> i
6), a mjenjanje
operatora se moe
postici mnoenjem
cijele nejednandbe
sa -1.
170
linearno programiranje
Osim ogranicenja zadanih nejednakostima, ogranicenja se mogu zadati i

lineanrim jednadbama
d11 x1 + d12 x2 + . . . + d1n xn
= e1
d21 x1 + d22 x2 + . . . + d2n xn

..
.
= e2
..
.
dp1 x1 + dp2 x2 + . . . + dpn xn
= ep
gdje je p broj ogranicenja.

U vektorskom zapisu sustav linearnih jednadbi (35.6) glasi
Ogranicenja zadan
jednakostima mogu
se zadavati i kao
dvije identicne
nejednakosti sa
suprotnim znakom
nejednakosti (npr.
x1 + x2 > 0 i
x1 + x2 6 0 je isto
to i x1 + x2 = 0)
Dx = E
35.2
(35.5)
simpleks metoda
George Dantzig je 1947. godine, zajedno sa suradnicima iz americkog ratnog

zrakoplovstva razvio simpleks metodu [15, 16].
35.3
modula pulp
rjeavanje lp problema pomo cu
http://code.google.com/p/pulp-or/
Kako instaliraty PuLP:

user@machine:~>sudo pip install pulp
user@machine:~>sudo zypper in glpk
Izvorni kod 35.1: Primjer rjeavanja LP problema pomocu modula PuLP

1
# -*- coding: utf-8 -*-
2
3
from pulp import *
4
5
6
7
# Varijable
x = LpVariable("x", 0, 3)
y = LpVariable("y", 0, 1)
8
9
10
# LP problem
prob = LpProblem("myProblem", LpMinimize)
11
12
13
# Cilj
prob += -4*x + y
14
15
16
17
# Ogranicenja
prob += x + y <= 2
prob += x == y
18
19
20
# Rjesavanje
status = prob.solve()
21
22
23
24
25
# Ispis
print LpStatus[status]
print value(x)
print value(y)
35.4
prakti cni
primjeri lp problema

35.4 prakti cni
35.4.1
Teretni zrakoplov
Zadatak 35.1 Teretni zrakoplov ima tri odjeljka za teret: prednji, centralni i
stranji odjeljak. Odjeljci zrakoplova imaju ogranicenja s obzirom na masu i
volumen tereta koji mogu prihvatiti.
Odjeljak Doputena masa tereta [t]
Skladini prostor [m3 ]
Prednji 10
68
Centralni16
87
Stranji 8
53
Masa tereta rasporedenog

po odjeljcima mora biti proporcionalna doputenoj
masi tereta za te odjeljke kako bi se zadrao balans zrakoplova.
Za transport zrakoplovom su dostupne c etri vrste tereta, koji svaki ima specificiranu masu, obujam i profit.
Teret
Masa [t]
Obujam [m3 /t]
Zarada [A
C]
C1
18
4.80
310
C2
15
6.50
380
C3
23
5.80
350
C4
12
3.90
285
Bilo koja kolicina tereta je prihvatljiva. Cilj je pronaci koliko svakog pojedinog tereta treba ukrcati te kako ih distribuirati u odjeljke zrakoplova kako bi se
maksimizirao ukupan profit leta.
Rjeenje
Potrebno je odrediti mase svakog od c etri vrste tereta koje treba ukrcati
u svaki od tri odjeljaka. Neka je xij masa tereta i koji se ukrcava u
odjeljak j.
x = (x11 , x12 , x13 , x21 , x22 , x23 , x31 , x32 , x33 , x41 , x42 , x43 )
U zrakoplov se ne moe ukrcati vie tereta nego to ga ima na raspolaganju. To vrijedi za svaku od c etri vrste tereta.
x11 + x12 + x13 6 18
x21 + x22 + x23 6 15
x31 + x32 + x33 6 23
x41 + x42 + x43 6 12
Doputena ukupna masa tereta u svakom odjeljku ne smije biti prekoracena.
x11 + x21 + x31 + x41 6 10
x12 + x22 + x32 + x42 6 16
x13 + x23 + x33 + x43 6
171
172
linearno programiranje
Prostorni (volumni) kapaciteti odjeljaka odreduje

kolicine tereta koji
se mogu ukrcati.
4.80x11 + 6.50x21 + 5.80x31 + 3.90x41 6 68
4.80x12 + 6.50x22 + 5.80x32 + 3.90x42 6 87
4.80x13 + 6.50x23 + 5.80x33 + 3.90x43 6 53
Da bi se zadovoljio balans masa po odjeljcima i stabilnost zrakoplova,
mase u odjeljcima moraju biti proporcionalne.
x11 + x21 + x31 + x41
=
10
x12 + x22 + x32 + x42
=
16
x13 + x23 + x33 + x43
8
Potrebno je maksimizirati ukupno profit ostvaren prijevozom tereta.
f(x) =
(x11 + x12 + x13 ) 310 +
(x21 + x22 + x23 ) 380 +
(x31 + x32 + x33 ) 350 +
(x41 + x42 + x43 ) 285
Izvorni kod 35.2: Rjeavanje problema transportnog zrakoplova
1
# -*- coding: utf-8 -*-
2
3
from pulp import *
4
5
6
7
8
# Varijable
x11 = LpVariable("x11", 0)
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# LP problem
prob = LpProblem("Plane Cargo", LpMaximize)
24
25
26
27
# Cilj
prob += (x11 + x12 + x13)*310 + (x21 + x22 + x23)*380 + \
(x31 + x32 + x33)*350 + (x41 + x42 + x43)*285
28
29
30
31
32
33
34
# Ogranicenja
prob += x11 +
prob += x21 +
prob += x31 +
prob += x41 +
x12
x22
x32
x42
+
+
+
+
x13
x23
x33
x43
<=
<=
<=
<=
18
15
23
12
(35.6)

35.4 prakti cni
35
36
37
prob += x11 + x21 + x31 + x41 <= 10

prob += x12 + x22 + x32 + x42 <= 16
prob += x13 + x23 + x33 + x43 <= 8
38
39
40
41
prob += 4.80*x11 + 6.50*x21 + 5.80*x31 + 3.90*x41 <= 68

prob += 4.80*x12 + 6.50*x22 + 5.80*x32 + 3.90*x42 <= 87
prob += 4.80*x13 + 6.50*x23 + 5.80*x33 + 3.90*x43 <= 53
42
43
44
prob += (x11 + x21 + x31 + x41)/10 == (x12 + x22 + x32 + x42)/16

prob += (x12 + x22 + x32 + x42)/16 == (x13 + x23 + x33 + x43)/8
45
46
47
# Rjesavanje
status = prob.solve()
48
49
50
# Ispis rjesenja
print Status:, LpStatus[status]
51
52
53
for v in prob.variables():
print v.name, "=", v.varValue
54
55
print "Total profit = ", value(prob.objective)

Status: Optimal
x11 = 0.0
x12 = 0.0
x13 = 0.0
x21 = 7.0
x22 = 0.0
x23 = 8.0
x31 = 3.0
x32 = 12.947368
x33 = 0.0
x41 = 0.0
x42 = 3.0526316
x43 = 0.0
Total profit = 12151.578806
173
36
NELDER-MEAD METODA
Nelder-Mead metoda, poznata kao Downhill simplex metoda ili Amoeba

metoda. Nelder-Mead metoda je tehnika za minimizaciju funkcije cilja u
viedimenzionalnom prostoru. Osnovnu ideju metode su osmislili John Nelder i Roger Mead 1965. godine [8].
Pregled metode Metoda koristi koncept simpleksa, to je specijalni politop od n tocaka u n dimenzija. Politop je geometrijski oblik sa ravnim
stranicama koji ekzistira u bilo kojem broju dimenzija. Poligon je politop
u dvije dimenzije. Primjeri simpleksa su duina na pravcu (1D), trokut u
ravnini (2D), tetraedron u prosotru (3D) itd. Metoda se zasniva na trae
nju uzorka koji usporeduje
vrijednosti funkcije u svim tockama simpleksa.
Najgora tocka se odbacuje i uvodi se nova tocka koja sa ostalima c ini novi
simpleks. Nalaenje nove toce simpleksa u svakoj iteraciji moe uzrokovati
irenje ili smanjivanje raspona simpleksa. Smanjivanje simpleksa dovodi do
konvergencije (svih tocaka simpleksa) ka optimumu.
36.1
algoritam
Algoritam Nelder-Mead metode je unificiran za bilo koji broj optimizacijskih

varijabli.
1. Odredi n tocaka pocetnog simpleksa
x1 , x2 , ..., xn+1
2. Izracunaj vrijednost funkcije cilja za sve tocke simpleksa
3. Sortiraj tocke simpleksa prema vrijednosti funkcije cilja u tockama:
f(x1 ) 6 f(x2 ) 6 ... 6 f(xn+1 )
4. Refleksija
? Izracunaj teite svih tocaka osim najgore
n
P
xi
x0 = i=1
n
? Izracunaj tocku refleksije i funkciju cilja u tocki refleksije
xr = x0 + (x0 xn+1 )
Pod najgorom
tockom se
podrazumijeva tocka
u kojoj je vrijednost
funkcije najveca (kod
problema
minimizacije).
? Ako je funkcija cilja u tocki refleksije nije bolja od najbolje tocke

simpleksa a bolja je od druge najgore tocke simpleksa
f(x1 ) 6 f(xr ) 6 f(xn )
onda:
nova tocka simpleksa je tocka refleksije xr i mjenja najgoru
tocku xn+1
idi na korak 1
5. Ekspanzija
Ako je tocka refleksije najbolja
f(xr ) < f(x1 )
onda:
175
Pod najboljom
tockom se
podrazumijeva tocka
u kojoj je vrijednost
funkcije najmanja
(kod problema
minimizacije).
176
nelder-mead metoda
? izracunaj tocku ekspanzije i funkciju cilja u tocki ekspanzije

xe = x0 + (x0 xn+1 )
? Ako je tocka ekspanzije bolja od tocke refleksije
f(xe ) < f(xr )
onda
nova tocka simpleksa postaje tocka ekspanzije xe
idi na korak 1
inace
nova tocka simpleksa postaje tocka refleksije xr
idi na korak 1
6. Kontrakcija
f(xr ) > f(xn ) Izracunaj tocku kontrakcije i funkciju cilja u tocki kontrakcije
xc = xn+1 + (x0 xn+1 )
Ako je tocka kontrakcije bolja od najgore tocke
f(xc ) < f(x( n + 1))
onda
? nova tocka simpleksa postaje tocka kontrakcije xc
? idi na korak 1
7. Redukcija
Za sve tocke osim najbolje izracunaj nove:
xi = x1 + (xi x1 ) za i = 2, ..., n + 1
Idi na korak 1
, , i su koeficijenti refleksije, ekspanzije, kontrakcije i redukcije. Standardno koritene vrijendosti su = 1, = 2, = 1/2 i = 1/2.
36.2
nelder-mead metoda za optimizaciju funkcije dviju varijabli
Slika 36.1: Tocke refleksije, ekspanzije, kontrakcije i redukcije kod Nelder-Mead metode optimizacije za funkciju dvije varijable. Tocke refleksije, ekspanzije ili kontrakcije mjenjaju
najgoru tocku simpleksa, dok tocke redukcije mjenjaju dvije nagore tocke simpleksa.
36.2 nelder-mead metoda za optimizaciju funkcije dviju varijabli
Simpleks koji se koristi kod Nelder-Mead metode optimizacije funkcije

dviju varijabli jest trokut (Slika 36.1). Za svaki korak iteracije izracunava se
novi simpleks ondnosno trokut na nacin da se mjenja najgora tocka starog
trokuta, odnosno dvije najgore tocke u slucaju redukcije.
Izvornom kodu 36.1 vizualizira svaki korak metode na primjeru rjeavanje 2D funkcije cilja.
Izvorni kod 36.1: Primjer 2D optimizacije Nelder-Mead metodom
1
2
3
4
# -*- coding: utf-8 -*"""

Nelder-Mead metoda
"""
5
6
7
8
import numpy as np
from matplotlib import animation
9
10
11
12
def f(x):
return np.sin(x[0]/20.0)/(x[0]**2.0/1000.0 + 1)*np.cos(x[1]/50.0)
#return x[0]**2.0 + x[1]**2.0
13
14
15
16
X,Y = np.meshgrid(np.arange(-60,60,2), np.arange(-60,60,2))

Z = np.sin(X/20.0)/(X**2.0/1000.0 + 1)*np.cos(Y/50.0)
17
18
19
20
21
22
23
fig = plt.figure()
contour_plot = plt.contourf(X, Y, Z, 150, # [-1, -0.1, 0, 0.1],
#alpha=0.5,
#cmap=plt.cm.bone,
#origin=origin
)
24
25
26
27
28
29
30
31
32
# Postavke metode
alpha = 1.0
beta = 0.5
gamma = 2.0
delta = 0.5
maxiter = 15
eps = 0.0001
33
34
35
36
37
# Po
cetne to
cke
A0 = [-50, 50]
B0 = [-50, -50]
C0 = [50, 50]
38
39
40
41
A0.append(f(A0))
B0.append(f(B0))
C0.append(f(C0))
42
43
44
45
46
47
# Formiranje trokuta pomo

cu matrice
T = [A0, B0, C0]
xline = [A0[0], B0[0], C0[0], A0[0]]
yline = [A0[1], B0[1], C0[1], A0[1]]
simpleks, = plt.plot(xline, yline, k-o)
48
49
50
51
52
def init():
xline = [A0[0], B0[0], C0[0], A0[0]]
yline = [A0[1], B0[1], C0[1], A0[1]]
simpleks, = plt.plot(xline, yline, -o)
53
54
return simpleks
55
56
57
# Glavna petlja metode

def iteration(it):
177
178
nelder-mead metoda
58
Ts = sorted(T, key=lambda point: point[2])
59
60
61
62
B = np.array(Ts[0])
S = np.array(Ts[1])
W = np.array(Ts[2])
63
64
M = (B + S) / 2.0
65
66
67
68
# Refleksija
R = M + alpha * (M - W)
R[2] = f(R)
69
70
71
if R[2] >= B[2] and R[2] < S[2]:

W = np.copy(R)
72
73
74
75
76
elif R[2] < B[2]:

# Ekspanzija
E = M + gamma * (R - M)
E[2] = f(E)
77
78
79
80
81
if E[2] < R[2]:

W = np.copy(E)
else:
W = np.copy(R)
82
83
elif R[2] >= S[2]:
84
85
86
87
88
if R[2]< W[2]:
# Kontrakcija vanjska
C = M + beta*(W-M)
C[2] = f(C)
89
90
91
92
93
94
95
if C[2] <= R[2]:

W = np.copy(C)
else:
# Shrink
W = B + delta * (W - B)
W[2] = f(W)
96
S = B + delta * (S - B)
S[2] = f(S)
97
98
99
100
101
102
103
else:
# Kontrakcija unutarnja
C = M - beta * (W - M)
C[2] = f(C)
104
105
106
107
108
109
110
if C[2] < W[2]:

W = np.copy(C)
else:
# Shrink
W = B + delta * (W - B)
W[2] = f(W)
111
S = B + delta * (S - B)
S[2] = f(S)
112
113
114
115
116
117
T[0] = B
T[1] = S
T[2] = W
118
119
120
121
xline = [B[0], S[0], W[0], B[0]]

yline = [B[1], S[1], W[1], B[1]]
simpleks.set_data(xline, yline)
122
123
124
#plt.savefig(iteration%02d.pdf % it)
return simpleks
36.2 nelder-mead metoda za optimizaciju funkcije dviju varijabli
125
126
127
Writer = animation.writers[ffmpeg]
writer = Writer(fps=2, metadata=dict(artist=Stefan), bitrate=3600)
128
129
130
anim = animation.FuncAnimation(fig, iteration, #init_func=init,

frames=maxiter, interval=2, repeat=False)
131
132
133
anim.save(nelder-mead.avi, writer=writer)
plt.show()
134
135
136
137
138
Ts = sorted(T, key=lambda point: point[2])

print Ts[0]
print Ts[1]
print Ts[2]
[ -2.08786964e+01
[ -2.08750000e+01
[ -2.08756335e+01
4.72068787e-03
-2.99504027e-03
8.40537250e-03
-6.01976050e-01]
-6.01976025e-01]
-6.01976024e-01]
40
20
0
20
40
60
60
40
20
20
40
Slika 36.2: Izgled simpleksa u 5 iteraciji (za izvorni kod 36.1).
179
37
SIMULIRANO KALJENJE
Simulirano kaljenje je stohasticka optimizacijska metoda namjenjena rjeavanju problema globalne optimizacije. 1983. godine su Kirkpatrick, Gelatt i
Vecchi [7], te Cern

y` 1985. [2] godine su osmislili i postavili osnovnu ideju
metode.
Metoda emulira proces kaljenja c elika gdje se zagrijano tijelo polako hladi
i mijenja svoju strukturu te u konacnom ohladenom

stanju dosee konfiguraciju minimalne energije.
37.1
algoritam
? Postavi pocetnu temperaturu T0 za (i = 1)

? Generiraj nasumicno pocetno stanje x0
? Evaluiraj stanje f0 = f(x0 )
? Ponavljaj dok se na zadovolji kriterij zaustavljanja :
1. Generiraj novo stanje xi+1 = xi + x
2. Evaluiraj stanje fi+1 = f(xi+1 )
3. Izracunaj razliku energije f = fi+1 fi
4. Odredi vjerojatnost prihvacanja novog stanja (xi+1 )
1
ako je f < 0
p(T ) =
f
Ti
ako je f > 0
e
5. (Ne)prihvacanje novog stanja
6. Proces hladenja
Ti+1 = (Ti )
7. Sljedeca iteracija i = i + 1
x je nasumicni vektor pomaka kojim dobivamo novu tocku u blizini
stare. Vecina algoritama simuliranog kaljenja automatski reducira x tijekom samog procesa optimizacije kako bi se u pocetku pokrivalo to vece
podrucje (global search) a kasnije osigurala to bra konvergencija (local search).
Funkcija (T ) je funkcija hladenja

i najcece se kostiti (T ) = r T gdje je
0 < r < 1.
37.2
modula inspyred
primjer simuliranog kaljenja pomo cu
Izvorni kod 37.1: Primjer simuliranog kaljenja pomocu modula inspyred

1
2
3
4
# -*- coding: utf-8 -*"""

Simulirano kaljenje
"""
5
6
from random import Random
181
182
simulirano kaljenje
7
8
9
10
from time import time

import inspyred
from numpy import *
from matplotlib.pyplot import *
11
12
F=[]
13
14
15
16
17
18
def f(X):
fit = 10.0 * len(X)
for x in X:
fit += (x**2.0 - 10.0*cos(2.0*pi*x))
return float(fit)
19
20
21
22
def generate(random, args):

size = args.get(num_inputs, 10)
return [random.uniform(-5.12, 5.12) for i in range(size)]
23
24
25
26
27
28
def evaluate(candidates, args):

fitness = []
for cs in candidates:
fitness.append(f(cs))
return fitness
29
30
31
32
33
def observe(population, num_generations, num_evaluations, args):

best = min(population)
#print %10d > %.4e % (num_generations, best.fitness)
F.append(best.fitness)
34
35
36
prng = Random()
prng.seed(time())
37
38
39
40
41
42
43
44
45
46
47
ea = inspyred.ec.SA(prng)
ea.terminator = inspyred.ec.terminators.evaluation_termination
ea.observer = observe
final_pop = ea.evolve(evaluator = evaluate,
generator = generate,
maximize = False,
bounder = inspyred.ec.Bounder(-5.12, 5.12),
max_evaluations = 3000,
temperature = 1000.0,
cooling_rate = 0.5)
48
49
50
best = min(final_pop)
print(Najbolje rjesenje: \n{0}.format(str(best)))
51
52
53
54
55
56
plot(F)
xlabel(iteracije)
xlabel(f)
grid()
show()
Najbolje rjesenje:
[-0.007675196458353489, -0.004919287254415098, -0.013702756782375067,
0.007230016365494668, 0.0016173493554606094, -0.02186560269034206,
-0.04488667414508021, 0.008940404646539009, -0.006383384005716428,
0.0035534794190288585] : 0.58284052168
modula inspyred
37.2 primjer simuliranog kaljenja pomo cu
200
150
100
50
0
0
500
1000
1500
f
2000
2500
Slika 37.1: Konvergencija optimizacije pomocu simuliranog kaljenja
3000
183
38
ESTICA
OPTIMIZACIJA ROJEM C
38.1
razvoj metode
Optimizacija rojem c estica (Particle Swarm Optimization, PSO) je stohasticka

optimizacijska metoda temeljena na idejama opaenim na kretanju jata i
rojeva.
Reynolds[11] je 1987. godine predloio model ponaanja jata, prema kojem se svaki c lan jata ponaa prema slijedecim pravilima:
? Dranje razmaka - svaki c lan jata se pokuava udaljiti od susjednih
ako su mu oni preblizu,
? Prilagodavanje
smjera - svaki c lan jata giba se u usrednjenom smjeru
kretanja svojih susjeda,
? Kohezija - svaki c lan jata ostaje blizu svojih susjeda tj. ostaje u jatu.
Kennedy i Eberhart[6] su dodali gnijezdo u pojednostavljenu simulaciju
temeljenu na Reynoldsovom modelu. Simulacija je obuhvacala sljedece utjecaje gnijezda na jedinke jata:
? gnijezdo privlaci svaku jedinku,
? Svaka jedinka pamti gdje je bila najblia gnijezdu.
? Svaka jedinka razmijenjuje informacije sa susjedima o lokaciji najblioj
gnijezdu.
Nakon dovoljno vremena provodenja

simulacije, sve su jedinke dole do
legla.
Postavlja se pitanje to se deava sa sustavom ako se gnjezdo giba prema
nepoznatoj funkciji? Da li c e jedinke stici do gnjezda?
vt+1
= vti + 1 Ut1 (pbti xti ) + 2 Ut2 (gbt xti )
i
(38.1)
xt+1
= xti + vt+1
i
i
(38.2)
Shi i Eberhart[12] uvode inerciju c estice koja je kontrolirana preko faktora

inercije wt .
vt+1
= wt vti + 1 Ut1 (pbti xti ) + 2 Ut2 (gbt xti )
i
(38.3)
Slika 38.1: Ponaanje jedinki u Reynoldsovom modelu. Odvajanje, usmjeravanje i kohezija.
185

optimizacija rojem cestica
186
Slika 38.2: Utjecaj gnjezda na jedinke jata.
U osnovnom obliku, faktor inercije je konstantan u vremenu wt = w. U sluc aju w > 1, brzine c estica rastu u vremenu (cestice ubrzavaju) a formacija
roja divergira. Usporavanje c estica i smanjivanje brzine do nule postie se sa
w < 1. Veci faktor inercije omogucava lake globalno pretraivanje, sa povec anjem rasapa c estica, dok manji w omogucuje bolje lokalno pretraivanje
i bru konvergenciju. Odabir faktora inercije treba temeljiti na karkateristikama funkcije cilja i svodi se na balansiranje irine pretraivanja i brzine
konvergencije.
Prema [14]
w>
c1 + c2
1
2
(38.4)
garantira konvergenciju putanja c estica, a prema [1] preporuceni faktor inercije je w = 0.73.
38.2
modula inspyred
koritenje pso metode pomo cu
Kako instaliraty inspyred: http://inspyred.github.com/index.html

user@machine:~>sudo pip install inspyred
Izvorni kod 38.1: Particle Swarm Optimization na primjeru Rastrigin funkcije

1
2
3
4
5
from random import Random

from time import time
from math import cos, pi
import inspyred
6
7
8
9
10
# Random generiranje
def generate_rastrigin(random, args):
size = args.get(num_inputs, 10)
return [random.uniform(-5.12, 5.12) for i in range(size)]
11
12
13
14
15
16
17
18
# Evaluacija (funkcija cilja)

def evaluate_rastrigin(candidates, args):
fitness = []
for cs in candidates:
fit = 10 * len(cs) + sum([((x - 1)**2 - 10 * cos(2 * pi * (x - 1))) for x
in cs])
fitness.append(fit)
return fitness
19
20
21
22
23
24
rand = Random()
rand.seed(int(time()))
pso = inspyred.swarm.PSO(rand)
pso.terminator = inspyred.ec.terminators.evaluation_termination
modula inspyred
38.2 koritenje pso metode pomo cu
25
26
27
28
29
30
31
32
33
final_pop = pso.evolve(generator=generate_rastrigin,
evaluator=evaluate_rastrigin,
pop_size=100,
maximize=False,
bounder=inspyred.ec.Bounder(-5.12, 5.12),
max_evaluations=20000,
mutation_rate=0.25,
num_inputs=5)
34
35
36
37
# Sort and print the best individual, who will be at index 0.

final_pop.sort(reverse=True)
print(final_pop[0])
187
39
KI ALGORITMI
GENETIC
Geneticki algoritam (GA) je adaptivni heuristicni algoritam traenja baziran

na evolucijskim idejama prirodne selekcije i genetike. Kao takav predstavlja inteligentno iskoritavanje nasumicnog traenja za rjeavanje optimizacijskih problema.
39.1
evolucijski algoritmi
50-ih i 60-ih godina 20. stoljeda nekoliko znanstvenika na podrucju racunarstva nezavisno su proucavali evolucijske sustave sa idejom da se evolucija
koristi kao optimizacijski alat za inenjerske probleme. Ideja u svim tim
sustavima bila je da populacija kandidacijskih rjeenja evoluira ka optimalnom rjeenju zadanog problema, koristeci operatore inspirirane prirodnom
genetskom varijacijom i prirodnom selekcijom.
Profesor John Holland, na sveucilitu u Michiganu, doao na ideju genetskog algoritma, koju je razvijao 60-ih i 70-ih godina zajedno sa svojim
studentima i kolegama. Hollandov cilj nije bilo dizajniranje algoritma za rjeavanje specificnih problema, vec proucavanje fenomena adaptacije kakav se
pojavljuje u prirodi, te razviti nacine kako mehanizme prirodne adaptacije
primjeniti u racunalnim sustavima. 1975 Holland je prvi koristio naziv genetski algoritam u knjizi Adaptation in Natural and Artificial Systems.
John Henry Holland smatra se ocem genetskih algoritama. 1989 David Goldberg sa sveucilita u Illinoisu primijenio je Hollandovu ideju na razlicita
inenjerska podrucja. Goldberg: Three billion years of evolution cant be
wrong. Its the most powerful algorithm there is..
Dananji moderni genetski algoritam svrstava se u evolucijske algoritme,
koji sadravaju iroki spektar mehanizama koji oponaaju procese prirodne
evolucije, gdje je glavni koncept opstanak najjaceg. Dananji najkoriteniji
evolucijski algoritmi su:
? Genetski algoritmi koji modeliraju genetsku evoluciju
? Genetsko programiranje koje je bazirano na genetskim algoritmima,
ali jedinke su programi (struktura hijerarhijskog stabla).
? Evolucijsko programiranje je izvedeno iz simuliranja adaptivnog ponaanja u evoluciji (phenotypic evolution).
? Evolucijske strategije su usmjerene prema modeliranju strategije parametara koji kontroliraju varijaciju u evoluciji, c esto nazivano Evolucija evolucije.
? Diferencijalna evolucija, koja je slicna genetskim algoritmima ali razlikuje se po koritenim mehanizmima reprodukcije.
? Kulturalna evolucija, modelira evoluciju kulture populacije i kako kultura utjece na genetsku i fenotipnu evoluciju jedinki.
? Koevolucija, namjerno glupe jedinke evoluiraju kroz kooperaciju, ili
kroz nadmetanje jedne sa drugom, a pritom stjecu potrebne karakteristike kako bi preivjele.
189

geneti cki
algoritmi
190
39.2
koritenje deap modula
DEAP je Python modul za evolucijsko racunanje. [9, 4] Namjenjen je razvoju

novih algoritama te brzo i lako testiranje novih ideja. Osim mogucnosti izrade vlastitih algoritma, DEAP nudi gotove algoritme:
? Geneticki algoritam (GA)
? Geneticko programiranje (GP)
? Evolucijske strategije (ES)
? Optimizacija rojem c estica (PSO) (vidi poglavlje 38)
Osim podrke za evolucijske metode, DEAP prua mogucnost detaljnog i
fleksibilnog statistickog pracenja i testiranja optimizacijskih procesa.
Kako instaliraty DEAP: http://code.google.com/p/deap/
user@machine:~>sudo pip install deap
Izvorni kod 39.1: Optimizacija Rastrigin funkcije pomocu DEAP modula

1
2
3
# -*- coding: utf-8 -*"""

Created on Wed Dec 18 15:15:56 2013
4
5
6
@author: stefan
"""
7
8
import random
9
10
11
12
13
14
15
from deap import base

from deap import creator
from deap import tools
from deap import algorithms
import numpy as np
16
17
18
19
DIMS = 10
LB = -100.0*np.ones(DIMS)
UB = 100*np.ones(DIMS)
20
21
22
23
24
25
26
# Funkcija cilja
# Rosenbrock funkcija
def evaluate(x):
x = np.array(x)
s = sum(100.0*(x[1:]-x[:-1]**2.0)**2.0 + (1-x[:-1])**2.0)
return s,
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
# Definicija funkcije korekcije

# Korigira gornju i donju granicu varijabli
def checkBounds(lb, ub):
def decorator(func):
def wrapper(*args, **kargs):
offspring = func(*args, **kargs)
for child in offspring:
for i in xrange(len(child)):
if child[i] > ub[i]:
child[i] = ub[i]
elif child[i] < lb[i]:
child[i] = lb[i]
return offspring
return wrapper
return decorator
39.2 koritenje deap modula
44
45
46
47
# Kreiranje minimizacijskog problema

creator.create("FitnessMax", base.Fitness, weights=(-1.0,))
# Definicija jedinki
creator.create("Individual", list, fitness=creator.FitnessMax)
48
49
toolbox = base.Toolbox()
50
51
52
53
54
55
56
# Registracija optimizacijske varijable

toolbox.register("attr_float", random.uniform, -100.0, 100.0)
# Registriracija jedinke
toolbox.register("individual", tools.initRepeat, creator.Individual, toolbox.
attr_float, DIMS)
# Registracija populacije
toolbox.register("population", tools.initRepeat, list, toolbox.individual)
57
58
59
60
61
62
63
64
65
66
67
68
69
70
# Registracija funkcije cilja

toolbox.register("evaluate", evaluate)
# Registracija operatora krianja
toolbox.register("mate", tools.cxTwoPoints)
# Registracija korekcije poslije krianja
toolbox.decorate("mate", checkBounds(LB, UB))
# Resgistracija mutacije
toolbox.register("mutate", tools.mutGaussian, mu=0, sigma=1, indpb=0.1)
# Registracija korekcije poslije mutacije
toolbox.decorate("mutate", checkBounds(LB, UB))
# Registracija metode selekcije
toolbox.register("select", tools.selTournament, tournsize=3)
71
72
73
74
75
# Kreiranje populacije jedinki

pop = toolbox.population(n=250)
# Definiraj pam
cenje jedne najbolje jedinke
hof = tools.HallOfFame(1)
76
77
78
79
80
81
82
# Statisti
cko pra
cenje algoritma
stats = tools.Statistics(lambda ind: ind.fitness.values)
stats.register("avg", tools.mean)
stats.register("std", tools.std)
stats.register("min", min)
stats.register("max", max)
83
84
85
86
# Pokretanje algoritma
algorithms.eaSimple(pop, toolbox, cxpb=0.75, mutpb=0.8, ngen=200, stats=stats,
halloffame=hof, verbose=True)
87
88
89
# Ispis najbolje jedinke

print hof
90
91
92
93
94
95
96
97
98
99
100
# Crtanje grafa konvergencije

fig = plt.figure()
ax = fig.add_subplot(1,1,1)
ax.set_yscale(log)
plt.plot(stats.data[min][0], -g, label = min)
plt.plot(stats.data[avg][0], -b, label = avg)
plt.plot(stats.data[max][0], -r, label = max)
plt.grid()
plt.legend()
plt.show()
gen
0
1
2
3
4
5
6
evals
250
241
240
238
237
235
239
std
max
avg
[8.138e+09] [4.366e+10]
[5.711e+09] [2.543e+10]
[3.454e+09] [1.832e+10]
[1.913e+09] [1.194e+10]
[9.443e+08] [4.473e+09]
[5.374e+08] [3.477e+09]
[2.739e+08] [1.794e+09]
min
[1.676e+10] [9.85e+08]
[1.055e+10] [6.183e+08]
[6.01e+09] [6.183e+08]
[3.19e+09] [3.502e+08]
[1.735e+09] [2.265e+08]
[1.015e+09] [1.64e+08]
[6.411e+08] [1.211e+08]
191
192
geneti cki
algoritmi
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
237
238
234
244
234
236
241
238
243
230
235
239
235
235
233
234
236
241
235
238
236
234
234
237
242
234
234
237
242
237
235
241
244
234
246
235
238
239
239
234
232
241
237
238
242
229
239
239
225
233
230
242
238
233
240
240
231
240
236
241
240
233
238
236
230
242
236
[1.672e+08] [9.866e+08] [4.233e+08] [1.249e+08]

[9.335e+07] [6.107e+08] [3.006e+08] [9.78e+07]
[6.907e+07] [4.452e+08] [2.184e+08] [8.422e+07]
[4.674e+07] [3.436e+08] [1.652e+08] [4.803e+07]
[3.899e+07] [2.573e+08] [1.259e+08] [4.305e+07]
[3.2e+07] [2.203e+08] [9.343e+07] [3.412e+07]
[1.952e+07] [1.377e+08] [6.896e+07] [2.664e+07]
[1.461e+07] [1.085e+08] [5.295e+07] [1.134e+07]
[1.133e+07] [8.049e+07] [4.122e+07] [1.115e+07]
[8.692e+06] [5.624e+07] [3.121e+07] [8.309e+06]
[7.148e+06] [5.685e+07] [2.289e+07] [5.22e+06]
[5.664e+06] [3.561e+07] [1.715e+07] [5.233e+06]
[4.503e+06] [2.791e+07] [1.25e+07] [4.354e+06]
[2.689e+06] [2.033e+07] [8.937e+06] [4.219e+06]
[1.738e+06] [1.318e+07] [6.871e+06] [3.476e+06]
[9.617e+05] [9.931e+06] [5.427e+06] [3.49e+06]
[6.41e+05] [7.87e+06] [4.707e+06] [3.324e+06]
[5.806e+05] [5.958e+06] [4.204e+06] [2.497e+06]
[6.607e+05] [6.073e+06] [3.807e+06] [1.906e+06]
[5.783e+05] [5.22e+06] [3.303e+06] [1.797e+06]
[5.321e+05] [5.234e+06] [2.786e+06] [1.639e+06]
[4.515e+05] [3.899e+06] [2.35e+06] [1.186e+06]
[3.543e+05] [3.36e+06] [1.991e+06] [8.656e+05]
[2.97e+05] [2.796e+06] [1.738e+06] [8.762e+05]
[2.645e+05] [2.49e+06] [1.509e+06] [7.125e+05]
[2.519e+05] [2.296e+06] [1.293e+06] [6.843e+05]
[2.091e+05] [1.684e+06] [1.108e+06] [6.358e+05]
[1.942e+05] [1.68e+06] [9.355e+05] [4.7e+05]
[1.551e+05] [1.439e+06] [8.028e+05] [4.176e+05]
[1.357e+05] [1.268e+06] [6.795e+05] [3.876e+05]
[1.102e+05] [8.952e+05] [5.743e+05] [3.197e+05]
[9.698e+04] [8.459e+05] [4.92e+05] [2.626e+05]
[7.705e+04] [7.722e+05] [4.153e+05] [2.147e+05]
[7.128e+04] [6.02e+05] [3.643e+05] [1.835e+05]
[6.495e+04] [5.171e+05] [3.15e+05] [1.489e+05]
[5.698e+04] [4.734e+05] [2.66e+05] [1.359e+05]
[5.898e+04] [6.019e+05] [2.248e+05] [1.102e+05]
[3.92e+04] [3.411e+05] [1.868e+05] [1.063e+05]
[3.232e+04] [3.309e+05] [1.6e+05] [8.606e+04]
[2.677e+04] [2.427e+05] [1.392e+05] [6.186e+04]
[2.274e+04] [2.095e+05] [1.215e+05] [6.204e+04]
[2.193e+04] [1.912e+05] [1.061e+05] [5.615e+04]
[1.737e+04] [1.565e+05] [9.149e+04] [4.468e+04]
[1.688e+04] [1.627e+05] [7.915e+04] [4.597e+04]
[1.307e+04] [1.44e+05] [6.853e+04] [4.181e+04]
[1.245e+04] [1.222e+05] [6.11e+04] [3.93e+04]
[1.075e+04] [1.124e+05] [5.482e+04] [3.562e+04]
[8887]
[1.352e+05] [4.914e+04] [3.23e+04]
[7171]
[7.923e+04] [4.539e+04] [3.234e+04]
[7837]
[1.011e+05] [4.241e+04] [3.092e+04]
[6770]
[9.115e+04] [3.89e+04] [2.606e+04]
[4400]
[5.14e+04] [3.55e+04] [2.345e+04]
[5340]
[6.22e+04] [3.342e+04] [2.177e+04]
[7401]
[8.657e+04] [3.168e+04] [2.028e+04]
[5802]
[6.033e+04] [2.803e+04] [1.973e+04]
[6684]
[8.118e+04] [2.584e+04] [1.533e+04]
[5612]
[7.537e+04] [2.368e+04] [1.533e+04]
[5351]
[5.62e+04] [2.216e+04] [1.386e+04]
[3744]
[4.749e+04] [2.02e+04] [1.244e+04]
[4260]
[5.345e+04] [1.885e+04] [1.27e+04]
[3062]
[3.483e+04] [1.725e+04] [1.239e+04]
[2475]
[2.889e+04] [1.555e+04] [1.041e+04]
[3295]
[4.651e+04] [1.477e+04] [1.041e+04]
[2922]
[3.337e+04] [1.401e+04] [8998]
[2645]
[3.777e+04] [1.323e+04] [8433]
[3215]
[4.977e+04] [1.244e+04] [7378]
[2562]
[3.043e+04] [1.152e+04] [6977]
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
237
238
239
238
239
235
234
241
240
238
242
237
244
241
238
243
230
244
239
241
243
234
239
235
239
237
233
239
238
230
239
238
243
239
240
238
238
241
236
237
236
241
236
232
235
236
239
240
238
235
238
240
241
241
232
239
245
236
238
241
243
235
242
237
231
240
238
[2283]
[2489]
[2032]
[1637]
[2292]
[2040]
[3623]
[1986]
[2757]
[1986]
[2064]
[1369]
[3604]
[2782]
[1717]
[1238]
[2571]
[4126]
[1784]
[3300]
[2112]
[1190]
[1216]
[1446]
[1419]
[2335]
[1694]
[2725]
[904.7]
[1020]
[1850]
[1275]
[1501]
[1411]
[588.3]
[1348]
[1954]
[876.8]
[1800]
[1454]
[1755]
[1623]
[1154]
[1236]
[1733]
[964.4]
[886]
[855.8]
[958.2]
[1769]
[1070]
[629.2]
[1230]
[1356]
[1345]
[1718]
[884.6]
[2529]
[991.9]
[1205]
[1302]
[931.8]
[2047]
[1823]
[1165]
[1321]
[1145]
[2.74e+04] [1.072e+04] [6996]

[2.563e+04] [1.008e+04] [4771]
[2.137e+04] [9035]
[4002]
[1.356e+04] [8000]
[3826]
[1.971e+04] [7353]
[3792]
[2.641e+04] [6200]
[3739]
[3.688e+04] [5974]
[2730]
[1.705e+04] [4968]
[2022]
[2.914e+04] [4753]
[1755]
[1.912e+04] [4180]
[1001]
[1.878e+04] [3743]
[1017]
[1.267e+04] [3069]
[804.6]
[4.884e+04] [3013]
[908.5]
[3.149e+04] [2625]
[856]
[1.656e+04] [2124]
[686.6]
[1.472e+04] [1745]
[715]
[2.544e+04] [1894]
[436.2]
[5.141e+04] [1922]
[315.4]
[1.27e+04] [1471]
[275.5]
[4.286e+04] [1414]
[132.2]
[2.661e+04] [1246]
[90.83]
[9698]
[956.8] [81.2]
[9830]
[816.8] [76.04]
[1.128e+04] [736.9] [81.2]
[1.155e+04] [638.8] [31.3]
[3.506e+04] [636]
[29.87]
[1.367e+04] [808.3] [29.93]
[3.562e+04] [677]
[24.3]
[6506]
[439.6] [33.82]
[7747]
[422.4] [24.77]
[1.988e+04] [643.3] [12.46]
[1.218e+04] [459.7] [10.9]
[1.328e+04] [563.6] [10.9]
[1.284e+04] [524.7] [10.9]
[4070]
[288.2] [10.2]
[1.315e+04] [445.2] [10.2]
[1.643e+04] [634.8] [10.95]
[7940]
[345.1] [8.495]
[2.136e+04] [537.7] [8.495]
[1.53e+04] [538.4] [8.495]
[1.268e+04] [584.9] [8.495]
[1.681e+04] [521.7] [7.986]
[1.077e+04] [427.5] [9.09]
[1.046e+04] [507.4] [7.984]
[1.446e+04] [531.4] [7.984]
[1.038e+04] [334.3] [7.829]
[6653]
[316.1] [7.829]
[4878]
[351.3] [7.829]
[9124]
[341.1] [7.829]
[1.818e+04] [526.3] [7.829]
[1.007e+04] [330.1] [8.119]
[5382]
[263.6] [8.119]
[1.394e+04] [365.8] [8.379]
[1.548e+04] [423.5] [6.521]
[1.174e+04] [428.2] [6.521]
[1.816e+04] [501]
[6.521]
[8338]
[339.4] [6.435]
[3.469e+04] [522.1] [7.612]
[7635]
[363.4] [5.994]
[1.271e+04] [371.4] [5.602]
[1.004e+04] [451.9] [5.486]
[7436]
[376]
[4.942]
[2.631e+04] [584.8] [4.822]
[1.76e+04] [605.4] [4.942]
[1.159e+04] [393.9] [4.946]
[1.059e+04] [510.3] [5.019]
[1.02e+04] [418]
[4.946]
193
194
geneti cki
algoritmi
141
243
[1129]
[1.223e+04] [339.6] [4.498]
142
233
[1841]
[1.926e+04] [503.9] [4.498]
143
227
[2081]
[2.256e+04] [440.2] [4.498]
144
237
[1637]
[1.377e+04] [463.4] [4.812]
145
227
[822.9] [5511]
[331.5] [4.812]
146
241
[1353]
[1.136e+04] [456.5] [4.511]
147
241
[2742]
[4.17e+04] [552.9] [4.359]
148
239
[1607]
[1.535e+04] [511.9] [4.501]
149
240
[1390]
[2.069e+04] [288.1] [4.207]
150
236
[2938]
[4.022e+04] [644.6] [4.207]
151
235
[1182]
[8947]
[463.4] [4.325]
152
240
[1623]
[2.288e+04] [419.3] [4.137]
153
235
[1488]
[1.018e+04] [488.9] [4.137]
154
237
[1428]
[1.126e+04] [406.1] [4.173]
155
238
[1028]
[1.098e+04] [407.9] [4.173]
156
242
[1936]
[2.189e+04] [512.9] [4.173]
157
239
[1401]
[1.565e+04] [482.9] [4.349]
158
231
[1646]
[1.815e+04] [470.4] [4.173]
159
240
[1213]
[1.234e+04] [380.1] [4.173]
160
237
[2538]
[2.251e+04] [663.3] [4.12]
161
238
[1553]
[1.415e+04] [555.3] [4.12]
162
242
[958.1] [6383]
[399.8] [4.12]
163
238
[2865]
[4.117e+04] [588.5] [4.12]
164
239
[1653]
[2.155e+04] [407.9] [4.12]
165
238
[1852]
[2.361e+04] [475.2] [4.149]
166
235
[1891]
[1.527e+04] [607.9] [4.12]
167
236
[3473]
[5.273e+04] [625]
[3.956]
168
239
[1542]
[1.697e+04] [463]
[3.956]
169
239
[807.2] [6581]
[350.1] [3.934]
170
241
[1412]
[1.861e+04] [425.3] [3.89]
171
231
[1155]
[9384]
[384.7] [3.771]
172
238
[1163]
[1.102e+04] [399.2] [3.771]
173
235
[1219]
[1.679e+04] [298.3] [3.705]
174
238
[1162]
[1.117e+04] [374.7] [3.705]
175
236
[1362]
[1.645e+04] [381.5] [3.546]
176
237
[1214]
[1.07e+04] [409.8] [3.546]
177
236
[1791]
[1.927e+04] [552.3] [3.488]
178
239
[848.6] [5107]
[369.8] [3.488]
179
237
[830.2] [4992]
[382]
[3.488]
180
243
[2064]
[2.391e+04] [454.4] [3.488]
181
236
[1035]
[9859]
[340.8] [3.488]
182
239
[1009]
[7094]
[379.3] [3.488]
183
238
[2095]
[2.451e+04] [513]
[3.418]
184
241
[1196]
[1.205e+04] [422.7] [3.418]
185
232
[1858]
[1.774e+04] [531.3] [3.48]
186
243
[1039]
[7818]
[369.3] [3.48]
187
241
[2927]
[3.483e+04] [681.6] [3.48]
188
239
[1053]
[1.037e+04] [337.1] [3.48]
189
237
[1260]
[1.353e+04] [440.2] [3.352]
190
233
[1493]
[1.131e+04] [541.1] [3.352]
191
238
[1221]
[1.254e+04] [363]
[3.352]
192
239
[1183]
[1.012e+04] [402]
[3.352]
193
237
[661.4] [6206]
[207.8] [3.352]
194
229
[973.4] [1.098e+04] [311.9] [3.352]
195
239
[819.5] [8727]
[309.5] [3.352]
196
241
[1426]
[1.023e+04] [544]
[3.352]
197
231
[1554]
[1.574e+04] [460.7] [3.299]
198
230
[871.4] [7335]
[357]
[3.299]
199
230
[1274]
[1.564e+04] [360.9] [3.337]
200
237
[1132]
[1.33e+04] [335.3] [3.299]
[[0.9766898231038279, 0.9607527096530896, 0.9065456124364575, 0.7944737905585467,
0.6248374250078815, 0.4065051529287608, 0.1803529539435661, 0.042390694202784074,
0.020730481699758788, -0.0009199868286795705]]
[deap.creator.FitnessMax((3.2990264400893148,))]
1011
min
avg
max
1010
109
108
107
106
105
104
103
102
101
100 0
50
100
150
200
Slika 39.1: Konvergencija optimizacije genetickim algoritmom (Izvorni kod 39.1)
195
Dio VII
DODACI
K O R I S N E N A R E D B E U L I N U X O P E R AT I V N O M S U S TAV U
a.1
kreiranje videa iz skupa slika
ffmpeg (http://www.ffmpeg.org/)
Primjer kreiranja video datoteke iz skupa slika koristeci alat ffmpeg.
stefan@fuji:~> ls -la
-rw-r--r-- 1 stefan users
116833
120415
116858
113018
114172
114172
114172
111188
110868
110868
110868
110868
113035
Jun
Jun
Jun
Jun
Jun
Jun
Jun
Jun
Jun
Jun
Jun
Jun
Jun
11
11
11
11
11
11
11
11
11
11
11
11
11
17:21
17:24
17:26
17:29
11:10
11:21
11:32
11:43
11:54
12:05
12:16
12:27
12:38
slika_000.png
slika_001.png
slika_002.png
slika_003.png
slika_004.png
slika_005.png
slika_006.png
slika_007.png
slika_008.png
slika_009.png
slika_010.png
slika_011.png
slika_012.png
stefan@fuji:~> ffmpeg -r 5 -i slika_%03d.png \

> -c:v libx264 -r 30 -pix_fmt yuv420p video.mp4
Detaljnije objanjenje svih argumenata naredbe:

? -r 5 oznacava ulazni frame rate tj. koliko c e ulaznih slika biti u sekundi
videa.
? -i slika_%03d.png definicija imena ulaznih datoteka/slika.
? -c:v libx264 definiranje video codeca.
? -pix_fmt yuv420p koritenje YV420p formata pixela prilikom pretvorbe slika.
? -r 30 oznacava izlazni frame rate tj. frame rate videa.
?
omogucuje nastavak pisanja naredbe u sljedecoj liniji.
a.2
pra cenje
promjena tekstualnih datoteka
Cesto
se prilikom izvodenja
numerickih proracuna ili simulacija vane informacije o tijeku i napredku proracuna biljee u tekstualne datoteke. Za lake
lokalno i posebice udaljeno pracenje promjene tekstualne datoteke putem
terminala koristi se naredba tail.
Primjer dinamickog pracenja tekstualne datoteke:
tail -f log.txt
Primjer dinamickog pracenja prvih 100 znakova u novim linijama tekstualne datoteke:
tail -f log.txt | cut -b 1-100
199
BIBLIOGRAFIJA
[1] Daniel Bratton and James Kennedy. Defining a standard for particle swarm optimization. In Swarm
Intelligence Symposium, 2007. SIS 2007. IEEE, pages 120127. IEEE, 2007.
[2] Vladimr Cern

y.
` Thermodynamical approach to the traveling salesman problem: An efficient simulation algorithm. Journal of optimization theory and applications, 45(1):4151, 1985.
[3] M.H. Chaudry. Open-channel flow. Springer Science+Business Media, 2008.
[4] Flix-Antoine Fortin, Franois-Michel De Rainville, Marc-Andr Gardner, Marc Parizeau, and Christian
Gagn. Deap: Evolutionary algorithms made easy. Journal of Machine Learning Research, 13:21712175,
2012.
[5] L. V. Kantorovic. Mathematical methods of organizing and planning prodution. Management Science, 6:
363422, 1960. (in Russian 1939).
[6] J. Kennedy and R. Eberhart. Particle swarm optimization. In Neural Networks, 1995. Proceedings., IEEE
International Conference on, volume 4, pages 19421948. IEEE, 1995.
[7] Scott Kirkpatrick, D. Gelatt Jr., and Mario P Vecchi. Optimization by simmulated annealing. science,
220(4598):671680, 1983.
[8] J. A. Nelder and R. Mead. A simplex method for function minimization. Computer Journal, 7:308313,
1965.
[9] De Rainville, Flix-Antoine Fortin, Marc-Andr Gardner, Marc Parizeau, Christian Gagn, et al. Deap:
A python framework for evolutionary algorithms. In Proceedings of the fourteenth international conference
on Genetic and evolutionary computation conference companion, pages 8592. ACM, 2012.
[10] S.S. Rao and S.S. Rao. Engineering Optimization: Theory and Practice. Wiley, 2009. ISBN 9780470183526.
[11] C.W. Reynolds. Flocks, herds and schools: A distributed behavioral model. In ACM SIGGRAPH Computer Graphics, volume 21, pages 2534. ACM, 1987.
[12] Y. Shi and R. Eberhart. A modified particle swarm optimizer. In Evolutionary Computation Proceedings,
1998. IEEE World Congress on Computational Intelligence., The 1998 IEEE International Conference on, pages
6973. IEEE, 1998.
[13] R. Szymkiewicz. Numerical modeling in open channel hydraulics (Water science & technology library).
Recherche, 67:02, 2010.
[14] F van den Bergh. An Analysis of Particle Swarm Optimizers., Submitted Ph. D. PhD thesis, thesis, University
of Pretoria, Pretoria, 2001.
[15] M. K. Wood and G. B. Dantzig. Programming of Interdependent Activities. I. General Discussion.
Econometrica, 17:193199, 1949.
[16] M. K. Wood and G. B. Dantzig. Programming of Interdependent Activities. I. Mathematical Model.
Econometrica, 17:200211, 1949.
201
colophon
This work is licensed under a Creative Commons Attribution-ShareAlike
3.0 Unported License.
http://creativecommons.org/licenses/by-sa/3.0/
This document was typeset using the typographical look-and-feel classicthesis

developed by Andr Miede. The style was inspired by Robert Bringhursts
seminal book on typography The Elements of Typographic Style. classicthesis
is available for both LATEX and LYX:
http://code.google.com/p/classicthesis/
Final Version as of 14. sijecnja 2015. (classicthesis v0.1).

Python Skripta 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

Python Skripta PDF

Uploaded by

Copyright:

Available Formats

UNARSKOM INENJERSTVU

Numericke metode, priprema, obrada i vizualizacija podataka

Dodatni paketi na Windows platformi

Instalacija pomocu upravitelja paketa

Relacijski operatori ili operatori usporedivanja)

osnovne naredbe za unos i ispis podataka

python ljuska i .py skripte

Editori i razvojna okruenja

Definiranje i pozivanje funkcija

Otvaranje i zatvaranje datoteka

12 python standard library

Informacije o platformi i operacijskom sustavu

13 greke u python kodu

14 zadavanje polja u numpy-u

15 informacije o polju i indeksiranje

16 manipulacije sa numpy poljima

Manipulacije sa dimenzijama polja

Ucitavanje iz tekstualnih datoteka

Rjeavanje sustava linearnih jednadbi

priprema, obrada i vizualizacija podataka

Svojstva prozora, prostora crtanja i osi

23 rjeavanje nelinearnih jednadbi

Metoda najmanjih kvadrata

26 rjeavanje sustava linearnih jednadbi

Metoda Gaussove eliminacije

rjeavanje modela temeljenih na odj i pdj

30.2 Stacionarno provodenje

Obicne diferencijalne jednadbe 1. reda

Modeliranje otvorenog vodotoka

38 optimizacija rojem cestica

34 definicija optimizacijskog problema

31 klasifikacija parcijalnih diferencijalnih jednadbi

Spyder razvojno okruenje . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Prozor sa grafom napravljen izvodenjem

Graf napravljen izvodenjem

Graf napravljen izvodenjem

Graf napravljen izvodenjem

Primjeri oznacavanja brojeva . . . . . . . . . . . . . . . . . . . . .

POPIS IZVORNOG KODA

Izvorni kod 2.1

Podrka za posebne znakove u Python skriptama . . . . . . . . . . . . . . . . .

Primjer kombiniranje operatora dodjeljivanja, operatora usporedivanja

Izvorni kod 9.9

Izvorni kod 9.10

Izvorni kod 11.2

Izvorni kod 12.2

Popis izvornog koda

Izvorni kod 24.2

Izvorni kod 27.1

Izvorni kod 33.1

metoda tangente, 115

Runge-Kutta metode, 139

Dont Repeat Yourself

Application Programming Interface

Unified Modeling Language

Nakon instalacije Pythona, moemo provjeriti koja je putanja python izvrne

Instalacija na Windows platformi

Velika snaga Pythona je dostupnost velikog broja paketa raznih namjena. Za

Dodatni paketi na Linux platformi

Za instalaciju dodatnih paketa na openSUSE distribuciji pokrenite naredbu:

Dodatni paketi na Windows platformi

Instalacija pomocu upravitelja paketa

Python upravitelji paketa omogucuju jednostavno instalaciju, osvjeavanje