python_programski jezik napredni
DESCRIPTION
Programiranje u pytonu napredi opisTRANSCRIPT
P Y T H O N U R A C U N A R S K O M I N Ž E N J E R S T V U
stefan ivic , bojan crnkovic , jerko škific i marko cavrak
Numericke metode, priprema, obrada i vizualizacija podataka
14. sijecnja 2015. – v0.1
Stefan Ivic, Bojan Crnkovic, Jerko Škific i Marko Cavrak: Python u racunar-skom inženjerstvu, Numericke metode, priprema, obrada i vizualizacija po-dataka, c© 14. sijecnja 2015.
S A D R Ž A J
I osnove pythona 1
1 uvod 3
1.1 Instalacija . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.1.1 Instalacija na Linux platformi . . . . . . . . . . . . . . . . . . . . 3
1.1.2 Instalacija na Windows platformi . . . . . . . . . . . . . . . . . . 3
1.2 Dodatni paketi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.2.1 Dodatni paketi na Linux platformi . . . . . . . . . . . . . . . . . . 4
1.2.2 Dodatni paketi na Windows platformi . . . . . . . . . . . . . . . . 4
1.2.3 Instalacija pomocu upravitelja paketa . . . . . . . . . . . . . . . . . 4
1.3 Editori i razvojna okruženja . . . . . . . . . . . . . . . . . . . . . . . 5
1.3.1 Spyder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.3.2 PyDev . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.3.3 Kate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2 python ljuska i .py skripte 7
2.1 Pokretanje Pythona . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.2 Python ljuska kao kalukulator . . . . . . . . . . . . . . . . . . . . . . 7
2.3 Python skripte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.3.1 Upotreba posebnih znakova . . . . . . . . . . . . . . . . . . . . 8
2.4 Moduli . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
3 tipovi podataka 11
3.1 Brojevi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
3.2 String . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
3.3 Liste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
3.4 Tuple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
3.5 Dictionary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
3.6 Skupovi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
4 operatori 19
4.1 Aritmeticki operatori . . . . . . . . . . . . . . . . . . . . . . . . . . 19
4.2 Relacijski operatori ili operatori usporedivanja) . . . . . . . . . . . . . . 19
4.3 Operatori dodjeljivanja . . . . . . . . . . . . . . . . . . . . . . . . . 20
4.4 Logicki operatori . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
4.5 Clanski operatori . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
4.6 Operatori identiteta . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
5 osnovne naredbe za unos i ispis podataka 23
5.1 print . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
5.2 raw_input . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
5.3 input . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
6 uvjetna grananja 25
6.1 if . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
6.2 else . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
6.3 elif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
7 petlje 29
7.1 for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
7.2 while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
7.3 break . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
7.4 continue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
7.5 Paraleleno iteriranje . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
7.6 Numeriranje liste . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
iii
iv sadržaj
8 funkcije 35
8.1 Definiranje i pozivanje funkcija . . . . . . . . . . . . . . . . . . . . . . 35
8.2 Vracanje vrijednosti iz funkcije . . . . . . . . . . . . . . . . . . . . . . 36
8.3 Argumenti sa zadanim vrijednostima . . . . . . . . . . . . . . . . . . . 37
8.4 Keyword i non-keyword argumenti . . . . . . . . . . . . . . . . . . . . 37
8.5 Ugnježdena definicija funkcije . . . . . . . . . . . . . . . . . . . . . . 39
8.6 Anonimne funkcije . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
8.7 Rekurzivne funkcije . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
9 objektno-orijentirano programiranje 43
9.1 Objektno-orijentirano programiranje . . . . . . . . . . . . . . . . . . . 43
9.2 Klase . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
9.3 Atributi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
9.3.1 Globalni atributi . . . . . . . . . . . . . . . . . . . . . . . . . 44
9.3.2 Objektni atributi . . . . . . . . . . . . . . . . . . . . . . . . . 45
9.4 Metode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
9.5 Preopterecivanje . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
9.5.1 Preopterecivanje funkcija . . . . . . . . . . . . . . . . . . . . . . 48
9.5.2 Preopterecivanje operatora . . . . . . . . . . . . . . . . . . . . . 49
9.6 Nasljedivanje . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
10 oblikovanje stringova 55
10.1 Oblikovanje sa operatorom % . . . . . . . . . . . . . . . . . . . . . . 55
10.2 Oblikovanje sa metodom format . . . . . . . . . . . . . . . . . . . . . 57
11 rad sa datotekama 59
11.1 Otvaranje i zatvaranje datoteka . . . . . . . . . . . . . . . . . . . . . . 59
11.2 Pisanje u datoteke . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
11.3 Citanje iz datoteka . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
11.4 Pozicioniranje u datoteci . . . . . . . . . . . . . . . . . . . . . . . . . 61
11.5 Preimenovanje, kopiranje i brisanje datoteka . . . . . . . . . . . . . . . 62
11.6 Arhiviranje . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
12 python standard library 63
12.1 Informacije o platformi i operacijskom sustavu . . . . . . . . . . . . . . 63
12.2 Matematicke funkcije . . . . . . . . . . . . . . . . . . . . . . . . . . 63
12.3 Datum i vrijeme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
12.4 Vrijeme izvršavanja . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
13 greške u python kodu 67
13.1 Tipovi grešaka . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
13.2 Manipulacija greškama - Exception handling . . . . . . . . . . . . . . . . 68
13.3 Ispravljanje grešaka - DeBugging . . . . . . . . . . . . . . . . . . . . . 69
II numpy 71
14 zadavanje polja u numpy-u 73
14.1 array . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
14.2 arange . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
14.3 linspace . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
14.4 zeros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
14.5 ones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
14.6 eye . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
14.7 diag . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
14.8 meshgrid . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
15 informacije o polju i indeksiranje 79
15.1 Informacije o polju . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
15.2 Indeksiranje polja . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
16 manipulacije sa numpy poljima 81
sadržaj v
16.1 Manipulacije sa dimenzijama polja . . . . . . . . . . . . . . . . . . . . 81
16.2 Transponiranje . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
16.3 Dodavanje i brisanje elemenata polja . . . . . . . . . . . . . . . . . . . 82
17 ucitavanje i spremanje numpy polja 83
17.1 Ucitavanje iz tekstualnih datoteka . . . . . . . . . . . . . . . . . . . . 83
17.2 Spremanje u tekstualne datoteke . . . . . . . . . . . . . . . . . . . . . 84
18 matricni racun 85
18.1 Rješavanje sustava linearnih jednadžbi . . . . . . . . . . . . . . . . . . 85
19 rad sa polinomima 87
19.1 poly1d . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
III priprema , obrada i vizualizacija podataka 89
20 osnovni 2d grafovi 91
20.1 Linijski grafovi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
20.2 Naprednija kontrola linijskih grafova . . . . . . . . . . . . . . . . . . . 94
20.2.1 Boje . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
20.2.2 Markeri . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
20.3 Svojstva prozora, prostora crtanja i osi . . . . . . . . . . . . . . . . . . 96
20.4 Spremanje grafova . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
20.5 Podgrafovi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
20.6 Polarni grafovi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
20.7 tips and tricks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
21 složeniji 2d grafovi 105
21.1 Izolinije . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
21.1.1 Mapa boja . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
21.1.2 Detaljnije podešavanje grafa izolinija . . . . . . . . . . . . . . . . . 106
21.1.3 Primjer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
22 izrada animacija 109
IV numericke metode 111
23 rješavanje nelinearnih jednadžbi 113
23.1 Metoda bisekcije . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
23.2 Newton-Raphsonova metoda . . . . . . . . . . . . . . . . . . . . . . . 115
23.3 Metoda sekante . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
23.4 Brentova metoda . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
23.5 Zadaci . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
24 interpolacije 119
24.1 1D interpolacija . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
24.2 2D i N-D interpolacija . . . . . . . . . . . . . . . . . . . . . . . . . . 120
25 regresije 123
25.1 Metoda najmanjih kvadrata . . . . . . . . . . . . . . . . . . . . . . . 123
25.2 Linearna regresija . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
25.3 Zadaci . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
26 rješavanje sustava linearnih jednadžbi 127
26.1 Metoda Gaussove eliminacije . . . . . . . . . . . . . . . . . . . . . . . 127
26.2 LU dekompozicija . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
27 numericko integriranje 131
27.1 Trapezna formula . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131
27.2 Simpsonove formule . . . . . . . . . . . . . . . . . . . . . . . . . . . 133
27.3 Naprednije metode . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
27.4 Zadaci . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
vi sadržaj
V rješavanje modela temeljenih na odj i pdj 137
28 numericke metode za rješavanje obicnih diferencijalnih jed-nadžbi 139
28.1 Obicne diferencijalne jednadžbe 1. reda . . . . . . . . . . . . . . . . . . 139
28.1.1 Eulerova metoda . . . . . . . . . . . . . . . . . . . . . . . . . 139
28.1.2 Runge-Kutta metode . . . . . . . . . . . . . . . . . . . . . . . 139
28.1.3 Rješavanje pomocu scipy-a . . . . . . . . . . . . . . . . . . . . . 139
28.2 Sustavi obicnih diferencijalnih jednadžbi 1. reda . . . . . . . . . . . . . . 140
28.3 Obicne diferencijalne jednadžbe višeg reda . . . . . . . . . . . . . . . . 140
29 pocetni problemi 141
29.1 Modeliranje otvorenog vodotoka . . . . . . . . . . . . . . . . . . . . . 141
29.1.1 Stacionarno strujanje . . . . . . . . . . . . . . . . . . . . . . . 142
29.1.2 Maningova formula . . . . . . . . . . . . . . . . . . . . . . . . 143
29.1.3 Uniformno strujanje i normalna dubina . . . . . . . . . . . . . . . . 144
29.1.4 Kriticna dubina . . . . . . . . . . . . . . . . . . . . . . . . . . 145
29.1.5 Hidraulicki skok . . . . . . . . . . . . . . . . . . . . . . . . . 146
29.1.6 Numericko rješavanje . . . . . . . . . . . . . . . . . . . . . . . 147
30 rubni problemi 151
30.1 Savijanje grede . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151
30.2 Stacionarno provodenje topline u štapu . . . . . . . . . . . . . . . . . . 153
31 klasifikacija parcijalnih diferencijalnih jednadžbi 155
32 elipticke parcijalne diferencijalne jednadžbe 157
32.1 Progib ploce . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157
33 metoda linija 161
VI optimizacijske metode 165
34 definicija optimizacijskog problema 167
34.1 Optimizacijske varijable . . . . . . . . . . . . . . . . . . . . . . . . . 167
34.2 Ciljevi optimizacije i funkcija cilja . . . . . . . . . . . . . . . . . . . . 168
34.3 Ogranicenja . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168
35 linearno programiranje 169
35.1 Definicija LP problema . . . . . . . . . . . . . . . . . . . . . . . . . . 169
35.2 Simpleks metoda . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170
35.3 Rješavanje LP problema pomocu modula PuLP . . . . . . . . . . . . . . 170
35.4 Prakticni primjeri LP problema . . . . . . . . . . . . . . . . . . . . . . 170
35.4.1 Teretni zrakoplov . . . . . . . . . . . . . . . . . . . . . . . . . 171
36 nelder-mead metoda 175
36.1 Algoritam . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175
36.2 Nelder-Mead metoda za optimizaciju funkcije dviju varijabli . . . . . . . . 176
37 simulirano kaljenje 181
37.1 Algoritam . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181
37.2 Primjer simuliranog kaljenja pomocu modula inspyred . . . . . . . . . . 181
38 optimizacija rojem cestica 185
38.1 Razvoj metode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185
38.2 Korištenje PSO metode pomocu modula inspyred . . . . . . . . . . . . . 186
39 geneticki algoritmi 189
39.1 Evolucijski algoritmi . . . . . . . . . . . . . . . . . . . . . . . . . . . 189
39.2 Korištenje DEAP modula . . . . . . . . . . . . . . . . . . . . . . . . 190
VII dodaci 197
a korisne naredbe u linux operativnom sustavu 199
a.1 Kreiranje videa iz skupa slika . . . . . . . . . . . . . . . . . . . . . . 199
a.2 Pracenje promjena tekstualnih datoteka . . . . . . . . . . . . . . . . . . 199
sadržaj vii
b bibliografija 201
P O P I S S L I K A
Slika 1.1 Spyder razvojno okruženje . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
Slika 1.2 Kate tekstualni editor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
Slika 6.1 Dijagram toka if naredbe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
Slika 6.2 if-else dijagram toka . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
Slika 6.3 Dijagram toka za složeni uvjet grananja . . . . . . . . . . . . . . . . . . . . . . . 28
Slika 7.1 Dijagram toka while petlje . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
Slika 7.2 Dijagram toka while petlje sa else blokom . . . . . . . . . . . . . . . . . . . . . 31
Slika 7.3 Dijagram toka while petlje sa continue naredbom . . . . . . . . . . . . . . . . . 31
Slika 19.1 Graf polinoma iz primjera 19.1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
Slika 20.1 Matplotlib elementi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
Slika 20.2 Prozor sa grafom napravljen izvodenjem izvrnog koda 20.1 . . . . . . . . . . . 92
Slika 20.3 Graf napravljen izvodenjem izvornog koda 20.2 . . . . . . . . . . . . . . . . . . 94
Slika 20.4 Graf napravljen izvodenjem izvornog koda 20.3 . . . . . . . . . . . . . . . . . . 96
Slika 20.5 Izmijenjene granice grafa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
Slika 20.6 Custom ticks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
Slika 20.7 Custom ticks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
Slika 20.8 Spines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
Slika 20.9 Formatiranje oznaka na osima . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
Slika 20.10 Prikaz legende na grafu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
Slika 20.11 Podgrafovi nastali izvršavanjem izvornog koda 20.5 . . . . . . . . . . . . . . . 102
Slika 20.12 Graf u polarnom koordinatnom sustavu . . . . . . . . . . . . . . . . . . . . . . 103
Slika 21.1 Predefinirane mape boja u matplotlibu . . . . . . . . . . . . . . . . . . . . . . . 106
Slika 21.2 Graf napravljen izvodenjem izvornog koda 21.1 . . . . . . . . . . . . . . . . . . 108
Slika 23.1 Skica metode biskecije . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
Slika 23.2 Newton-Raphsonova metoda . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
Slika 24.1 Primjer razlicitih 1D interpolacija . . . . . . . . . . . . . . . . . . . . . . . . . . 120
Slika 24.2 Primjer 2D interpolacije . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
Slika 25.1 Regresijski pravac dobiven izvornim kodom 25.1 . . . . . . . . . . . . . . . . . 124
Slika 27.1 Trapezi na cjelom intervalu [a,b] i na tri podintervala. . . . . . . . . . . . . . . 131
Slika 27.2 Racunanje površine ispod krivulje pomocu trapeza (Izvorni kod 27.1) . . . . . 133
Slika 28.1 Vizualizacija rješenja iz izvornog koda 28.1. . . . . . . . . . . . . . . . . . . . . 140
Slika 29.1 Skica poprecnog presjeka otvorenog vodotoka . . . . . . . . . . . . . . . . . . . 141
Slika 29.2 Energetske linije u strujanju fluida otvorenim vodotokom . . . . . . . . . . . . 141
Slika 29.3 Pravokutni poprecni presjek kanala . . . . . . . . . . . . . . . . . . . . . . . . . 144
Slika 29.4 Trapezni poprecni presjek kanala . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
Slika 29.5 M-krivulje vodnog lica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
Slika 29.6 S-krivulje vodnog lica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
Slika 29.7 Numericko rješenje strujanja u otvorenom kanalu pravokutnog presjeka . . . . 149
Slika 30.1 Savijanje grede . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151
Slika 30.2 Rubni uvjeti za razlicite oslonce grede . . . . . . . . . . . . . . . . . . . . . . . . 152
Slika 30.3 Progib elasticne linije grede . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
Slika 32.1 Ploca . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157
Slika 33.1 Diskretizacija . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161
Slika 36.1 Tocke refleksije, ekspanzije, kontrakcije i redukcije kod Nelder-Mead metodeoptimizacije za funkciju dvije varijable. Tocke refleksije, ekspanzije ili kontrak-cije mjenjaju najgoru tocku simpleksa, dok tocke redukcije mjenjaju dvije na-gore tocke simpleksa. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 176
Slika 36.2 Izgled simpleksa u 5 iteraciji (za izvorni kod 36.1). . . . . . . . . . . . . . . . . 179
Slika 37.1 Konvergencija optimizacije pomocu simuliranog kaljenja . . . . . . . . . . . . . 183
Slika 38.1 Ponašanje jedinki u Reynoldsovom modelu. Odvajanje, usmjeravanje i kohezija. . 185
Slika 38.2 Utjecaj gnjezda na jedinke jata. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 186
Slika 39.1 Konvergencija optimizacije genetickim algoritmom (Izvorni kod 39.1) . . . . . 195
viii
P O P I S TA B L I C A
Tablica 3.1 Primjeri oznacavanja brojeva . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
Tablica 4.1 Aritmeticki operatori . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
Tablica 4.2 Relacijski operatori . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
Tablica 4.3 Operatori dodjeljivanja . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
Tablica 4.4 Logicki operatori . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
Tablica 5.1 printf formatiranje . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
Tablica 10.1 Opcije konverzije . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
Tablica 10.2 Definiranje tipova podataka . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
Tablica 12.1 Opis nekih funkcija math modula . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
Tablica 12.2 Opis nekih funkcija cmath modula . . . . . . . . . . . . . . . . . . . . . . . . . . 63
Tablica 20.1 Vrste linija . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
Tablica 20.2 Simboli boja . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
Tablica 20.3 Vrste markera . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
Tablica 20.4 Pozicija legende . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
Tablica 29.1 Vrijednosti Manningovog koeficijenta za razlicite izvedbe kanala. . . . . . . . . 143
ix
P O P I S I Z V O R N O G K O D A
Izvorni kod 2.1 Podrška za posebne znakove u Python skriptama . . . . . . . . . . . . . . . . . 8
Izvorni kod 2.2 Korištenje objekata modula . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
Izvorni kod 3.1 Dodavanje i brisanje elemenata liste . . . . . . . . . . . . . . . . . . . . . . . . . 16
Izvorni kod 4.1 Primjer kombiniranje operatora dodjeljivanja, operatora usporedivanja i logic-kih operatora . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
Izvorni kod 5.1 Razliciti primjeri ispisa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
Izvorni kod 6.1 Jednostavan primjer upotrebe if naredbe . . . . . . . . . . . . . . . . . . . . . . 25
Izvorni kod 6.2 Pisanje složenijeg uvjetovanog grananja . . . . . . . . . . . . . . . . . . . . . . . 26
Izvorni kod 6.3 Primjer upotrebe else naredbe . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
Izvorni kod 6.4 Primjer kombinacije naredbi if, elif i else . . . . . . . . . . . . . . . . . . . . 27
Izvorni kod 7.1 Upotreba for naredbe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
Izvorni kod 7.2 Naredba for s listom stringova . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
Izvorni kod 7.3 Naredba for i stirng . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
Izvorni kod 7.4 Naredba for s listom stringova . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
Izvorni kod 7.5 Upotreba while naredbe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
Izvorni kod 7.6 Upotreba else naredbe u petlji . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
Izvorni kod 7.7 Upotreba break naredbe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
Izvorni kod 7.8 Upotreba continue naredbe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
Izvorni kod 7.9 Upotreba zip naredbe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
Izvorni kod 7.10 Upotreba zip naredbe sa više lista. . . . . . . . . . . . . . . . . . . . . . . . . . . 32
Izvorni kod 7.11 Numeriranje elemenata liste pomocu enumerate. . . . . . . . . . . . . . . . . . 33
Izvorni kod 8.1 Definicija i pozivanje jednostavne funkcije . . . . . . . . . . . . . . . . . . . . . 35
Izvorni kod 8.2 Definicija funkcije koja prima argument . . . . . . . . . . . . . . . . . . . . . . . 36
Izvorni kod 8.3 Definicija funkcije koja prima više argumenata i vraca vrijednost . . . . . . . . 36
Izvorni kod 8.4 Funkcija koja vraca razlicite tipove . . . . . . . . . . . . . . . . . . . . . . . . . . 36
Izvorni kod 8.5 Funkcija koja vraca više vrijednosti korsiteci tuple . . . . . . . . . . . . . . . . 37
Izvorni kod 8.6 Funkcija sa zadanim argumentom . . . . . . . . . . . . . . . . . . . . . . . . . . 37
Izvorni kod 8.7 Funkcija sa *args i **kwargs argumentima . . . . . . . . . . . . . . . . . . . . . 38
Izvorni kod 8.8 *args i **kwargs argumenti prilikom poziva funkcije . . . . . . . . . . . . . . . 38
Izvorni kod 8.9 Primjer anonimne funkcije u ugnježdenoj definiciji . . . . . . . . . . . . . . . . 40
Izvorni kod 9.1 Definicija klase . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
Izvorni kod 9.2 Primjer definicije klasnih (globalnih) atributa . . . . . . . . . . . . . . . . . . . . 44
Izvorni kod 9.3 Primjer definicije objektnog atributa . . . . . . . . . . . . . . . . . . . . . . . . . 45
Izvorni kod 9.4 Inicijalizacija objekta . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
Izvorni kod 9.5 Definicija metode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
Izvorni kod 9.6 Preopterecivanje funkcije print . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
Izvorni kod 9.7 Preopterecivanje funkcije print . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
Izvorni kod 9.8 Preopterecivanje funkcije print . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
Izvorni kod 9.9 Naslijedivanje . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
Izvorni kod 9.10 Naslijedivanje override __init__metode . . . . . . . . . . . . . . . . . . . . . . . 52
Izvorni kod 10.1 Primjer formatiranja numerickih podataka sa tupleom i dictionaryjem . . . . . 55
Izvorni kod 10.2 Primjer formatiranja numerickih podataka sa tupleom i dictionaryjem . . . . . 56
Izvorni kod 10.3 Primjer formatiranja numerickih podataka za ispis u stupcima . . . . . . . . . 56
Izvorni kod 11.1 Primjer kreiranja tekstualne datoteke . . . . . . . . . . . . . . . . . . . . . . . . 59
gfx/RadSaDatotekama/info.txt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
gfx/RadSaDatotekama/test.txt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
Izvorni kod 11.2 Citanje sadržaja tekstualne datoteke . . . . . . . . . . . . . . . . . . . . . . . . . 61
Izvorni kod 11.3 Pristupanje sadržaju datoteke preko iteriranja po file objektu . . . . . . . . . 61
gfx/RadSaDatotekama/test.txt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
Izvorni kod 11.4 Dohvacanje trenutne pozicije u datoteci . . . . . . . . . . . . . . . . . . . . . . . 61
Izvorni kod 11.5 Kopiranje, micanje i preimenovanje datoteka . . . . . . . . . . . . . . . . . . . . 62
Izvorni kod 12.1 Primjer mjerenja vremena izvršavanje algoritma . . . . . . . . . . . . . . . . . . 64
Izvorni kod 12.2 Primjer upotrebe Timer klase za mjerenje vremena izvodenja funkcije . . . . . 65
Izvorni kod 13.1 Upotreba dbg modula . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
Izvorni kod 14.1 Spremanje elemenata dijagonale matrice u vektor . . . . . . . . . . . . . . . . . 76
Izvorni kod 15.1 Osnovne informacije o NumPy polju . . . . . . . . . . . . . . . . . . . . . . . . 79
Izvorni kod 15.2 Manipulacije sa poljima pomocu indeksa . . . . . . . . . . . . . . . . . . . . . . 80
Izvorni kod 16.1 Mijenjanje dimenzija polja . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
Izvorni kod 16.2 Mijenjanje dimenzija polja . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
Izvorni kod 16.3 Transponiranje matrica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
Izvorni kod 17.1 Sadržaj datoteke data.txt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
Izvorni kod 17.2 Ucitavanje iz tekstualne datoteke . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
Izvorni kod 18.1 Rješavanje sustava linearnih jednadžbi . . . . . . . . . . . . . . . . . . . . . . . 85
Izvorni kod 19.1 Zadavanje polinoma kao poly1d objekta . . . . . . . . . . . . . . . . . . . . . . 87
Izvorni kod 20.1 Jednostavan graf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
Izvorni kod 20.2 Kontrola linija i markera . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
Izvorni kod 20.3 Naprednija kontrola linija i markera . . . . . . . . . . . . . . . . . . . . . . . . . 95
Izvorni kod 20.4 Prikaz legende na grafu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
Izvorni kod 20.5 Primjer crtanja podgrafova . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
Izvorni kod 20.6 Primjer crtanja grafa u polarnom koordinatnom sustavu . . . . . . . . . . . . . 102
Izvorni kod 21.1 Primjer vizualizacije izolinija . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
Izvorni kod 22.1 Jednostavan primjer animacije . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
Izvorni kod 23.1 Primjer pronalaženja nultocke funkcije metodom biskecije . . . . . . . . . . . . 114
Izvorni kod 23.2 Primjer pronalaženja nultocke funkcije metodom tangente . . . . . . . . . . . . 116
Izvorni kod 24.1 Primjer razlicitih 1D interpolacija . . . . . . . . . . . . . . . . . . . . . . . . . . 119
x
Popis izvornog koda xi
Izvorni kod 24.2 Primjer linearne i kubicne 2D interpolacije . . . . . . . . . . . . . . . . . . . . . 120
Izvorni kod 25.1 Primjer linearne regresije . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
gfx/RjesavanjeSustavaLinJed/A.txt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
gfx/RjesavanjeSustavaLinJed/B.txt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
Izvorni kod 26.1 Primjer naivne Gaussove eliminacije . . . . . . . . . . . . . . . . . . . . . . . . . 128
Izvorni kod 26.2 Primjer LU dekompozicije . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
Izvorni kod 27.1 Primjer racunanja odredenog inegrala pomocu trapezne formule . . . . . . . . 132
Izvorni kod 27.2 Upotreba Simpsonove 1/3 formule . . . . . . . . . . . . . . . . . . . . . . . . . 134
Izvorni kod 27.3 Numericko integriranje pomocu quad funkcije . . . . . . . . . . . . . . . . . . . 135
Izvorni kod 28.1 Primjer rješavanja obicnih diferencijalnih jednadžbi 1. reda. . . . . . . . . . . . 139
Izvorni kod 29.1 Strujanje u pravokutnom kanalu . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
Izvorni kod 30.1 Rješavanje elasticne linije savijanja . . . . . . . . . . . . . . . . . . . . . . . . . . 152
Izvorni kod 32.1 Rješavanje problema progiba ploce pomocu metode konacnih razlika . . . . . 158
Izvorni kod 33.1 Primjer rješavanje provodenja topline kroz štap pomocu metode linija . . . . . 162
Izvorni kod 35.1 Primjer rješavanja LP problema pomocu modula PuLP . . . . . . . . . . . . . . 170
Izvorni kod 35.2 Rješavanje problema transportnog zrakoplova . . . . . . . . . . . . . . . . . . . 172
Izvorni kod 36.1 Primjer 2D optimizacije Nelder-Mead metodom . . . . . . . . . . . . . . . . . . 177
Izvorni kod 37.1 Primjer simuliranog kaljenja pomocu modula inspyred . . . . . . . . . . . . . . 181
Izvorni kod 38.1 Particle Swarm Optimization na primjeru Rastrigin funkcije . . . . . . . . . . . 186
Izvorni kod 39.1 Optimizacija Rastrigin funkcije pomocu DEAP modula . . . . . . . . . . . . . . 190
I N D E K S
%, 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, 47–49, 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 jednadžbe, 157
else, 26, 30
encode, 14
endswith, 13
enumerate, 33
error, 68
Euler-Bernoullijeva jednadžba, 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
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
xii
INDEKS xiii
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 jednadžbe, 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 jednadžbi, 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
ugnježdena definicija funkcije, 39
uniformno strujanje, 141, 144
unique, 82
upper, 14
vektor slobodnih clanova, 85
Vrijeme izvršavanja, 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
A C R O N Y M S
DRY Don’t Repeat Yourself
API Application Programming Interface
UML Unified Modeling Language
xiv
Dio I
O S N O V E P Y T H O N A
Python je skriptni programski jezik opce namjene.
1U V O D
Zašto Python? Postoje mnogi razlozi zašto odabrati Python kao inženjerskialat
? 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 izvršavanje koda na gotovo svimplatformama i arhitekturama
? Ugradiv u kodove pisane u drugim programskim jezicima
? Proširiv sa drugim programskim jezicima
? Objektno orjentiran
? Uredna i elegantna sintaksa
? Stabilan
? Bogatstvo dostupnih paketa i biblioteka
? Specijelizirani paketi za numeriku, statistiku, obradu podataka i vizu-alizacije
? Otvoreni besplatni kod koji održava velika zajednica programera iznanstvenika
1.1 instalacija
1.1.1 Instalacija na Linux platformi
Gotovo sve Linux distribucije sadže Python pakete u osnovnim repozitori-jima, ali i vcina distribucija ima inicijalno instaliran Python.
Na openSUSE distribuciji, Python se može instalirati jednostavnom nared-bom:sudo zypper in python
Nakon instalacije Pythona, možemo provjeriti koja je putanja python izvršnedatotekeuser@machine:~> type python
python is /usr/bin/python
1.1.2 Instalacija na Windows platformi
Za instalaciju Pythona na Windows platformi potrebno je preuzeti instalacij-sku datoteku sa http://www.python.org. Nakon preuzimanja, pokretanjem insta-lacijske datoteke zapocinje isntalacijki program koji omogucuje uredivanjepostavki Python instalacije.
Uobicajena je instalacija Pythona zajedno sa dodatnim paketima, na Win-dows platformi, preko neke od dostupnih Python distribucija (vidi poglavlje1.2.2.1).
3
4 uvod
1.2 dodatni paketi
Velika snaga Pythona je dostupnost velikog broja paketa raznih namjena. Zainženjerske potrebe, potrebni su dodatni paketi koji omogucavaju matricniracun, numericke metode, statisticku obradu podataka, vizualizacije, izraduanimacija i druge specijalizirane mogucnosti.
Osnovni paketi, koji ce biti korišteni 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 Pythonpaketima. Najpoznatiji su easy_install, koji dolazi sa vecinom Python dis-tribucija te pip. pip se može 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 Dodatni paketi na Windows platformi
1.2.2.1 Python distribucije
Python distribucije su objedinjane instalacije pythona, raznih dodatnih pa-keta te cesto i tekstualnih editora ili razvoijnih okruženja. Distribucije suvecinom ciljane za Windows platformu zbog neprakticne višestruke instala-cije 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, osvježavanjeili deinstalaciju raznih Python paketa. Iako upravitelji paketa nisu dio Pyt-hona, cesto 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 okruženja 5
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 okruženja
Python koristi pokrece kod iz obicnih tekstualnih datoteka koje je moguceuredivati u mnogim tekstualnim editorima.
Razvojna okruženja (eng. Integrated Development Environment, IDE), osimšto omogucavaju uredivanje koda, sadrže niza alata za lakši i brži razvoj kaošto su jednostavno pokretanje koda iz IDE-a, debug-iranje koda, pracenjeispisa i dr.
1.3.1 Spyder
Spyder (http://code.google.com/p/spyderlib/) je interaktivno razvojno okruženje zaPython namjenjeno za znastvenu i inženjersku primjenu. Spyder je dostupanza vecinu platformi.
Slika 1.1: Spyder razvojno okruženje
1.3.2 PyDev
PyDev (http://pydev.org/) je dodatak za Eclipse (http://www.eclipse.org/) razvojnosucelje koji nudi mogucnosti za rad sa Pythonom.
6 uvod
1.3.3 Kate
Kate (http://kate-editor.org/) je mocan tekstualni editor, iako radi i na Windowsplatformi, primarno je namjenjen za Linux platformu.
Na openSUSE-u, Kate se može instalirati naredbom:
user@machine:~> sudo zypper in kate
Slika 1.2: Kate tekstualni editor
2P Y T H O N L J U S K A I . P Y S K R I P T E
Python je interpretirani jezik, a jednostavni Python izrazi mogu se izvoditiu interaktivnom programskom okruženju pod nazivom ljuska.
2.1 pokretanje pythona
Najjednostavniji nacin za otvaranje Python ljuske (eng. shell) na Windowsplatformi je pokrenuti IDLE, dok je ne Linux platformi dovoljno pokrenutiPython naredbu u terminalu/konzoli. Nakon pokretanja Pythona prikazujuse osnovne informacije o Pythonu (verzija) te tzv. prompt koji je simboliziransa 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 izvršava unešene naredbe nakon pritiska na tipkuEnter (Return). Najjednostavniji Python izrazi su matematicke operacije po-mocu kojih možemo koristiti Python ljusku kao kalkulator. Izracun te ispisrezultata matematickih izrazi dešava se u novom retku terminala ili IDLE-a:
>>> 1+1
2
>>>
Matematicke operacije, naravno, možemo medusobno kombinirati i pri tomekoristiti zagrade za definiranja redoslijeda operacija. Oprez! Prilikom
dijeljenja cijelihbrojeva rezultat jecijeli broj! Koddecimalnih brojevaobavezno koristitidecimalnu tocku.
>>> 1/5
0
>>> 1./5.
0.2
>>> 1./(5.+2)
0.14285714285714285
>>>
Ljuska može 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 sadrže Pythonkod. Izvršavanje .py skripte, zapravo, se pokrece linija po linija kao da se jeunosi u Python ljusku. Ovo je ocita prednost, pogotovo prilikom pokretanjaviše od nekoliko naredbi.
Datoteke sa ekstenzijom .py, osim kao skripte, koriste se i za definiranjevlastitih modula što je detaljnije opisano u poglavlju 2.4.
7
8 python ljuska i .py skripte
Osnovni nacin pokretanja python skripte je pokretanje Pythona sa specifi-ciranim .py fajlom:
user@machine:~$ python imeskripte.py
Python ce se pokrenuti i izvršiti kod zapisan u skripti.Nakon završetkaizvodenja skriptepomocu python
skripta.py Pythonse gasi!
Ako je prva linija skripte:
1 #!/usr/bin/python
tada se na Unix sustavima može izvršavati u terminalu. Za pokretanje skripteu terminalu nužno je da skripta koristi Unix oznaku za kraj reda te da imadozvole za izvršavanje:
user@machine:~$ chmod +x imeskripte.py
Ako je .py datoteka izvršna, tada se može direktno izvršavati:
user@machine:~$ ./imeskripte.py
Na Windows sustavima datoteke s ekstenzijom *.py su kod intalacije Pyt-hona pridružene programu python.exe. Python skripta se pokrece dvostru-kim lijevim klikom miša na skriptu.
2.3.1 Upotreba posebnih znakova
Da bi se koristilo posebne znakove (npr. slova sa kvacicama ili simboli) ustringovima, potrebno je u prvoj ili drugoj liniji skripte upisati poseban ko-mentar:
# -*- coding: utf-8 -*-
Izvorni kod 2.1: Podrška za posebne znakove u Python skriptama
1 #!/usr/bin/python
2 # -*- coding: utf-8 -*-
3
4 print ’Sada možemo koristi slova sa kvacicama!’
5 print ’Ali i razne simbole kao što su & $’
2.4 moduli
Modul je Python objekt, definiran u odredenoj datoteci, koji sadrži defini-cije varijabli, funkcija i klasa. Obicno su varijable, funkcije i klase odredenogmodula specijalizirane namjene, pa se module može interpretirati kao gru-piranje koda i najcešce je taj kod slicne namjene.
Npr. modul math (obraden u poglavlju 12.2) sadrži varijable pi i e kojepredstavljaju matematicke konstante te niz matematickih funkcija kao štosu sqrt, log, pow, exp, sin, cos itd.
Da bi se objekti odredenog modula mogli koristiti u kodu, potrebno jeucitati (importirati) modul ili ucitati odredeni objekt iz modula.
Ucitavanje modula vrši se pomocu naredbe import cija je osnovna sin-taksa
import module_name
gdje je module_name ime modula.Nakon što je modul ucitan, može 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 može se ucitati više modula na slijedeci nacin:
2.4 moduli 9
import module1, modul2, modul3
Ucitanom modulu se može dodijeliti novo ime. To se može napraviti po-mocu kljucne rijeci as:
import module_name as new_name
nakon cega se modul može koristiti pomocu novog imena.Moduli cesto sadržavaju velik broj objekata, a njihovim ucitavanjem bes-
potrebno se troše memorijski i procesorski resursi. Kako bi se izbjeglo ucita-vanje cijelog modula, moguce je iz odredenog modula ucitati samo odredeneobjekte:
from module_name import object_name
Ako se direktno ucita objekte iz modula, tada ih se koristiti samo prekoimena objekta. Kao i sam modul, moguce je ucitati objekt nekog modulapod 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: Korištenje objekata modula
1 #!/usr/bin/python
2
3 # importiraj sys modula
4 import sys
5 print sys.platform # ispisi platformu (operaticni sustav)
6 print sys.version # ispisi verziju Pythona
7
8 # importiraj modul math kao m
9 import math as m
10 print m.pi # ispisi vrijednost broja pi
11 print m.sin(m.pi/2.0) # ispisi vrijednost sinusa kuta pi/2
12
13 # iz modula datetime importiraj objekt date
14 from datetime import date
15 print date.today() # ispisi danasnji datum
16
17 # iz modula random importiraj funkciju random kao nasumicni
18 from random import random as nasumicni
19 print nasumicni() # ispisi nasumicni broj
20
21 # Importiraj sve objekte iz modula string
22 from string import *23 print uppercase # ispis svih velikih slova
24 print lowercase # ispis svih velikih slova
25 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
3T I P O V I P O D ATA K A
Varijable se ne moraju explicitno deklarirati. Naime, deklaracija se dešavaprilikom pridruživanja vrijednosti varijabli. Odnosno, varijable se pridru-žuju memorijskim lokacijama na kojima je zapisana vrijednost. Znak jedna-kosti = se koristi za pridruživanje vrijednosti varijablama. Na primjer:
1 #!/usr/bin/python
2
3 brojac = 100 # Integer
4 duljina = 1000.0 # Float
5 ime = ’Hrvoje’ # String
6
7 print brojac
8 print duljina
9 print ime
Ovdje su 100, 1000.0 i Hrvoje vrijednosti pridružene varijablama brojac,duljina i ime. Program ce producirati sljedeci rezultat:
100
1000.0
Hrvoje
Moguce je pridružiti jednu vrijednost u više varijabli. Tada sve varijablegledaju na istu memorijsku lokaciju. Odnosno:
1 #!/usr/bin/python
2 a = b = c = 1
3 c = 5
4 print a
što rezultira
1
Varijable a, b ic gledaju na istu lokaciju u memoriji u kojoj piše 1. Brojevi suimutable varijable odnosno nepromjenjive pa kada promijenimo c=5 Pythonpreusmjerava varijablu c na novu lokaciju u memoriji na kojoj piše broj 5,a varijable a, b i dalje gledaju na isto mjesto kao i prije. Takoder je mogucepridružiti više vrijednosti u više varijabli.
1 #!/usr/bin/python
2 a, b, c = 1, 2, ’Hrvoje’
Varijablama a i b se pridružuju memorijske lokacije na kojima su zapisanevrijednosi 1 i 2, dok je varijabli c pridružena memorijska lokacija na kojoj jezapisana 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
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name ’b’ is not defined
>>> print c
2
Python podržava pet osnovnih tipova podataka;
? Numbers
? String
? List
? Tuple
? Dictionary
Tip podataka odredene varijable može 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 vrijed-nosti rezultira novim alociranim objektom. Numericki tip podatka se kreirapridruživanjem vrijednosti varijabli. Odnosno
1 #!/usr/bin/python
2 var1 = 1
3 var2 = 10
Takoder je moguce pobrisati referencu na numericki objekt koristeci del
naredbu. Sintaksa izgleda ovako:
del var1[,var2[,var3[....,varN]]]]
Primjer:
1 #!/usr/bin/python
2 del var
3 del var_a, var_b
Python podržava cetiri numericka tipa
? int
? long
? float
? complex
Nekoliko primjera oznacavanja numerickih podataka ja prikazana u Tablici3.1.
Moguce je koristiti i malo slovo L za oznaku long, iako se takvo oznaca-vanje ne preporuca zbog velike slicnosti sa brojem 1.
3.2 string 13
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
Tablica 3.1: Primjeri oznacavanja brojeva
3.2 string
Iako je mogucedefinirati string sajednostrukim idvostrukimnavodnicima,preporuka je da sekoriste jednostrukinavodnici.
Stringovi su definirani kao slijed znakova izmedu navodnika, jednostrukih(apostrofi) ili dvostrukih. Jednom zadane stringove je nemoguce mijenjati jersu stringovi, u Pythonu, nepromjenjivi (imutable) tip podatka. Niz funkcijakoje rade promjene nad string varijabama zapravo kreiraju kopije izvornestring varijable.
Dijelove stringova (znakove ili niz znakova - string) je moguce dohvatitioperatorima [] i [:] sa indeksima koji pocinju od 0 na pocetku stringa svedo -1 na kraju.
Znak plus (+) oznacava spajanje (concatenation), a asterisk (∗) je operatorponavljanja. Odnosno:
1 #!/usr/bin/python
2
3 str = ’Hello World!’ # zadavanje sa jednostrukim navodnicima
4 ime = "Rudi" # zadavanje sa dvostrukim navodnicima
5
6 print str, ime # print cijelog stringa
7 print str[0] # print prvog znaka u stringu
8 print str[2:5] # print od treceg do petog znaka
9 print str[2:] # print znakova od treceg do zadnjeg
10 print str * 2 # print stringa dva puta
11 print str + ’TEST’ # print concatenated string
Što ce rezultirati
Hello World! Rudi
H
llo
llo World!
Hello World!Hello World!
Hello World!TEST
Nad stringovima je moguce izvoditi niz specijaliziranih operacija pomocufunkcija koje su dostupne za varijable tipa string.
Funkcije za pretraživanje 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])
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 liste
Lista sadrži podatke odvojene zarezima i omedene uglatim zagradama. Iakoje slicna listama u C jeziku, podaci python liste mogu biti razlicitog tipa.Kao i kod stringova, pristupanje vrijednostima u listi je moguce pomocuoperatora [ ] i [ : ] sa indeksima koji pocinju od 0 na pocetku stringa svedo -1 na kraju. Znak plus (+) se koristi za operator spajanja (concatenation)stirngova, a asterisk (∗) je operator ponavljanjaIako lista može biti
heterogena(sadržavati razlicite
tipove podataka),preporuka je koristiti
listu kao spremnikhomogenih podataka.
Za heterogenepodatke se preporucatuple (poglavlje 3.4)
1 #!/usr/bin/python
2
3 list = [ ’abcd’, 786 , 2.23, ’hrvoje’, 70.2 ]
4 tinylist = [123, ’hrvoje’]
5
6 print list # print cijele liste
7 print list[0] # print prvog elementa liste
8 print list[1:3] # print od drugog do treceg elementa liste
9 print list[2:] # print od treceg do zadnjeg elementa
10 print tinylist * 2 # print liste dva puta
11 print list + tinylist # print concatenated lists
Što ce rezultirati
3.3 liste 15
[’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 cesto se koristi naredba len za provjeru brojaelemenata liste, naredbom insert se umece novi element u listu te naredbadel kojom se brišu pojedini elementi iz liste.
1 #/user/bin/python
2
3 list = [2,3,4,5]
4 print(len(list)) #broj elemnata u listi
5 print list
6 list.insert(0,1) #umetanje elementa 1 u listu na prvu poziciju
7 print list
8 del list[-1] #brisnje zadnjeg elementa iz liste
9 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 štoje cesto potrebno kod korištenja for petlje (poglavlje 7.1). Sintaksa naredberange je
range(stop),
range(start, stop),
range(start, stop, step),
gdje je start prvi element, stop je gornja granica i step je korak aritmetic-kog niza.
1 #/user/bin/python
2
3 list=range(7) # aritmeticki niz 0,..,6
4 print list
5 list = range(2,7) # aritmeticki niz 2,..,6
6 print list
7 list = range(0,7,2) # aritmeticki niz s korakom 2
8 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 pozicijui a extend proširuje postojecu listu sa listom L.
Naredbe za brisanje elemenata iz liste su:
remove(x)
pop(i)
del L[index]
remove briše prvi element koji ima vrijednost x a pop briše element na pozi-ciji i. Naredba del L[index] briše 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
16 tipovi podataka
vrijednost x, count prebrojava sve elemente koji su jednaki x, sort sortiraelemente liste a reverse rasporeduje elemente u obrnutom redosljedu odinicijalnog.index(x)
count(x)
sort()
reverse()
Izvorni kod 3.1: Dodavanje i brisanje elemenata liste
1 ljudi = [’Marko’, ’Mirela’, ’Luka’]
2 nadljudi = [’Chuck’,’Arnold’,’Steven’,’Silvester’]
3
4 ljudi.append(’Igor’)
5 print ljudi
6 nadljudi.insert(1,’Anita’)
7 print ljudi
8 nadljudi.extend(ljudi)
9 print nadljudi
10
11 nadljudi.pop(1)
12 print nadljudi
13 nadljudi.remove(’Igor’)
14 print nadljudi
15 del nadljudi[4:]
16 print nadljudi
17
18 print ljudi.index(’Marko’)
19 ljudi.append(’Marko’)
20 print ljudi.count(’Marko’)
21
22 nadljudi.sort()
23 print nadljudi
24 nadljudi.reverse()
25 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 zarezomi za razliku od listi omeden zagradama (). Python dopušta fleksibilnostizostavljanja zagrada prilikom definiranja tuplea.
Postoji mnogo slicnosti sa listama, ali i nekoliko temeljnih razlika:
? pristupanje elementima liste i tuplea vrši se na identican nacin (prekoindeksa)
? i list i tuple su iterabilni
? lista može mijenjati broj elemenata i vrijednosti elemenata, dok tuplene može
3.5 dictionary 17
? nad tupleom se ne mogu provoditi operacije koje mjenjaju sam tuple(sort, remove i sl.)
1 #!/usr/bin/python
2
3 tuple = ( ’abcd’, 786 , 2.23, ’hrvoje’, 70.2 )
4 tinytuple = (123, ’hrvoje’)
5
6 print tuple # print liste
7 print tuple[0] # prints prvog elementa liste
8 print tuple[1:3] # print od drugog do treceg elementa liste
9 print tuple[2:] # print od treceg do zadnjeg elementa
10 print tinytuple * 2 # print liste dva puta
11 print tuple + tinytuple # print liste nastale spajanjem dvije liste
12
13 istotuple = 2, True, ’teskt’ # Zadavanje tuplea bez zagrada
14 print istotuple
Što ce 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 ce producirati grešku u liniji 5, jer smo pokušali promijenitivrijednost u tupleu
1 #!/usr/bin/python
2
3 tuple = ( ’abcd’, 786 , 2.23, ’hrvoje’, 70.2 )
4 list = [ ’abcd’, 786 , 2.23, ’hrvoje’, 70.2 ]
5 tuple[2] = 1000 # greska
6 list[2] = 1000 # ok
Tuple se vrlo cesto koristi za višestruko dodjeljivanje:
>>> a, b, c = 3, 10, ’neki tekst’
>>> print a
3
>>> print b
10
>>> print c
neki tekst
što se cesto koristi prilikom vracanja više vrijednosti iz funkcije (poglavlje8.2)
3.5 dictionary
Dictionary možemo smatrati jednostavnim pridruživanjem odnosno presli-kavanjem svih elemenata jednog skupa elementima drugog skupa.
1 #!/usr/bin/python
2
3 dict =
4 dict[’jedan’] = ’Ovo je jedan’
5 dict[2] = ’Ovo je dva’
6
7 tinydict = ’ime’: ’hrvoje’,’code’:6734, ’odjel’: ’admin’
8
9 print dict[’jedan’] # print vrijednosti ’jedan’
10 print dict[2] # print vrijednosti za 2
11 print tinydict # print cijelog dictionary
18 tipovi podataka
12 print tinydict.keys() # print svih kljuceva
13 print tinydict.values() # print svih vrijednosti
Što ce 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’])
4O P E R AT O R I
Operatori su osnovni dio Pythona i omogucuju operacije na varijablama(operandima). Najcešce se povezuju sa algebarskim matematickim operaci-jama, medutim operatori mogu biti i “ne matematicke” naravi.
Python operatore možemo 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 aritmeticki operatori
Aritmeticki operatori omogucuju osnovne matematicke operacije na broje-vima. Rezultat aritmetickog operatora je uvijek broj tj. varijabla tipa float
ili int, ovisno o tipovima operanada. Bitno je napomenuti da je tip rezultataaritmetickih operacija uvijek višeg tipa operanada.
Operator Opis Primjer za x=9.0 i y=2.0
+ Zbrajanje x+y daje 11
- Oduzimanje x-y daje 7
* Množenje 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 usporeðivanja)
Relacijski operatori omogucavaju usporedivanje vrrijednosti varijabli. Rezul-tat relacijskih operatora je varijabla tipa bool i može poprimiti vrijednosti(True ili False).
19
20 operatori
Operator Opis Primjer za x=9.0 i y=2.0
== 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 služi za dodjeljivanje vrijednosti varijabli. Postoje,proširenja kojima se može kombinirati aritmeticke operatore i operator do-djeljivanja.
Operator Opis Primjer za x=9.0 i y=2.0
= Dodjeljivanje x=y dodjeljuje vrijednost 2.0varijabli x
+= Zbrajanje i dodjeljivanje x+=y je isto što i x=x+y, x po-prima vrijednost 11.0
-= Oduzimanje i dodjeljiva-nje
x-=y je isto što i x=x-y, x po-prima vrijednost 7.0
*= Množenje i dodjeljivanje x*=y je isto što i x=x*y, x po-prima vrijednost 18.0
/= Dijeljenje i dodjeljivanje x/=y je isto što i x=x/y, x po-prima vrijednost 4.5
%= Ostatak dijeljenja i dodje-ljivanje
x%=y je isto što i x=x%y, x po-prima vrijednost 1.0
//= Cjelobrojno dijeljenje i do-djeljivanje
x//=y je isto što i x=x//y, xpoprima vrijednost 4.0
**= Potenciranje i dodjeljiva-nje
x**=y je isto što i x=x**y, xpoprima vrijednost 81.0
Tablica 4.3: Operatori dodjeljivanja
4.4 logicki 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 operatorlogicko ne. Rezultat logickih operatora je uvijek bool varijabla.
Izvorni kod 4.1: Primjer kombiniranje operatora dodjeljivanja, operatora usporedivanja i logic-kih operatora
1 #! /usr/bin/python
2
3 a = 10
4 b = 1
4.5 clanski operatori 21
a b 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
5 c = 15
6
7 d = a < b
8 print d
9
10 e = a > b and c > b
11 print e
12
13 f = a > c or not b > c
14 print f
False
True
True
4.5 clanski operatori
Clanski opratori služe za odredivanje pripadnosti odredenoj listi. Osnovniclanski operator je operator in, i može se proširiti sa logickim operatoromnot te rvot oprator not in. Rezultat clanskih opratora je bool varijabla kojadaje saznanje da li zadani element pripada listi ili ne pripada list.
>>> a = [1, 2, 3, 8, 6]
>>> 2 in a
True
>>> 3 not in a
False
>>> 5 not in a
True
4.6 operatori identiteta
Operatori identita usporeduju da li su Python objekti zapisani na istommjestu u memoriji. Postoji operator is i is not koji usporeduju id Pythonobjekta. id Python objekta se može 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
5O 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 naredbeprint. Osnovna sintaksa za ispisivanje je
print variable
gdje je variable ima varijable ciju vrijednost se želi ispisati.Moguce je ispisivati vrijednosti više varijabli:
print variable1, variable2
Naprednije mogucnosti ispisa moguce je kontrolirati pomocu ubacivanjavrijednosti varijabli u string pomocu printf formata. Simbolom % i pripada-jucim znakom za tip podatka može se u stringu odreduju pozicije na kojese želi ubaciti vrijednosti varijabli, a nakon stringa i simbola % slijede imenasamih 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 najma-nje 10 znakova
Tablica 5.1: printf formatiranje
Više o oblikovanju stringova pomocu operatora % opisano je u poglavlju10.1.
Izvorni kod 5.1: Razliciti primjeri ispisa
1 print ’Ispisi ovo na ekranu!’
2 print ’Ispisi’ + ’ jos’ + ’ ovo.’
3
4 a=12
5 type(a)
6 print a
7 print ’a=’, a
8 print ’a=’ + str(12)
9 print ’Ovo je a:%d’ % (a)
10 print ’Ovo je a:%.2d’ % (a)
11
12 b=15.365982
13 type(b)
14 print ’Ovo je b:’,b
15 print ’Ovo je b:’+str(b)
23
24 osnovne naredbe za unos i ispis podataka
16 print ’Ovo je b:%f’ % (b)
17 print ’Ovo je b:%.2f’ % (b)
18 print ’Ovo je b:%10.3f’ % (b)
19
20 print ’ovo je a: %d a ovo je b: %f’ % (a,b)
21
22 print ’a = broj_a, b = broj_b’.format(broj_a = a, broj_b = b)
23 print ’a = broj_a, b = broj_b:.2f’.format(broj_a = a, broj_b = b)
24 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 unošenje vrijednosti tipa str (string).
>>> a = raw_input()
moj prvi unos
>>> print a
moj prvi unos
>>> print type(a)
<type ’str’>
Dodatno, funkcija raw_input može primiti poruku, u obliku stringa, kojase ispisuje na ekarn prilikom unosa.
>>> ime = raw_input(’Unesite svoje ime: ’)
Unesite svoje ime: Ivo
>>> print ime
Ivo
5.3 input
6U V J E T N A G R A N A N J A
Odredene naredbe ili djelove koda moguce je izvršavati ili preskociti ovisnoo vrijednosti postavljenog logickog uvjeta.
6.1 if
Logičkiuvjet
NaredbeAko je uvjetzadovoljen
Ako uvijet nije zadovoljen
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 izvršavanje naredbe command (ili više naredbi) natemelju logickog uvjeta condition. Zadane naredbe ce se izvršiti samo akoje logicki uvijet zadovoljen.
Izvorni kod 6.1: Jednostavan primjer upotrebe if naredbe
1 #!/usr/bin/python
2
3 a = input("a: ")
4 if a < 0: a = -a
5 print a
Pokretanjem Izvornog koda 6.1 i utipkavanjem pozitivnog broja ispiše seutipkani broj:user@machine:~> python if_01.py
a: 5
5
Medutim, utipkavanjem negativnog broja zadovoljava se postavljeni logickiuvjet i izvrši se operacija a = -a te se potom ispiše pozitivna vrijednostutipkanog broja:user@machine:~> python if_01.py
a: -11
11
U slucaju kad postoji više naredbi uvjetovanih istim logickim uvjetom,naredbe možemo objediniti pod jednim uvjetom te ih odvojiti sa tocka-zarezom (;). Ako su uvjetovane naredbe kompleksne ili ih ima više, naredbepišemo u uvucenim recima nakon if naredbe. Sve uvucene naredbe do pr-vog retka koji je poravnat sa if naredbom su uvjetovane.
25
26 uvjetna grananja
Izvorni kod 6.2: Pisanje složenijeg uvjetovanog grananja
1 #!/usr/bin/python
2
3 a = 0
4 b = input("b: ")
5 c = input("c: ")
6
7 if b < 0: a = 1; b = -b
8 print a, b
9
10 if c < b:
11 a = 2
12 b = c - b
13 c = c +1
14 a = b + c
15 print a, b, c
user@machine:~> python if_02.py
b: -6
c: 4
1 6
3 -2 5
6.2 else
Ova naredba omogucuje složeniji oblik grananja od naredbe if. Naredbaima dvije grane koje se mogu izvršiti u ovisnosti o uvjetu. Svaka grana/mo-gucnost omogucuje izvršavanje pripadajucih naredbi (Slika 6.2).
Logičkiuvjet
Naredbe B
Ako je uvjetzadovoljen
Ako uvijet nije zadovoljen
Naredbe A
Slika 6.2: if-else dijagram toka
else naredba koristi se u paru sa if i služi za grananje u slucaju da uvjetnije zadovoljen.
Sintaksa naredbe je:
if condition : command1
else: command2
Izvorni kod 6.3: Primjer upotrebe else naredbe
1 #!/usr/bin/python
2
3 a = input("a: ")
4 b = input("b: ")
5
6 if a < b:
7 b = a
6.3 elif 27
8 a = 0
9 else:
10 a = b
11 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) služinaredba elif. Iako se sa ugnježdenim grananjem može 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 korištenjaif-elif-else grananja uvijek izvrši samo jedan set uvjetovanih naredbi.
Iz same definicije dodatnog uvjetnog grananja, naredba elif uvijek do-lazi u kombinaciji sa naredbom if, te se upotrebljava u sljedecoj osnovnojsintaksi
if condition1 : command1
elif condition2 : command2
Kao ni u slucaju upotrebe else naredbe dodatno grananje se mora napi-sati u novom retku. Uobicajeno je da se naredbe koje slijede nakon uvjetapišu u novom uvucenom retku.
Proširena upotreba ukljucuje kombinaciju više elif naredbi:
if condition1 : command1
elif condition2 : command2
elif condition3 : command3
Grananje se može napraviti i kombinacijom sve tri navedene naredbe:
if condition1 : command1
elif condition2 : command2
else : command2
U Izvornom kodu 6.4 napisan je jednostavan primjer grananja koristecinavedene naredbe.
Izvorni kod 6.4: Primjer kombinacije naredbi if, elif i else
1 #!/usr/bin/python
2
3 a = input("a: ")
4
5 if a < 0:
6 print ’a je negativan’
7 elif a > 0:
8 print ’a je pozitivan’
9 else:
10 print ’a je nula’
28 uvjetna grananja
Logičkiuvjet A
Naredbe B
Ako je uvjetzadovoljen
Ako uvijet nije zadovoljen
Naredbe A
Logičkiuvjet B
Ako je uvjetzadovoljen
Naredbe C
Ako uvijet nije zadovoljen
Logičkiuvjet C
Ako je uvjetzadovoljen
Naredbe D
Ako uvijet nije zadovoljen
Slika 6.3: Dijagram toka za složeni uvjet grananja
Unosom pozitivnog broja izvršava se naredba koja je uvjetovana uvjetompod elif naredbom:
user@machine:~> python if_elif_else_01.py
a: 33
a je pozitivan
7P E T L J E
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 izvršavaju se jednom za svaki element iz niza list.Objekt iter je iterator koji pokazuje na elemente niza list. Za razliku odjezika C, C++ iter se ne briše nakon što for naredba završi.
Izvorni kod 7.1: Upotreba for naredbe
1 #!/usr/bin/python
2 for num in range(2, 5):
3 print(num)
4
5 print(num)
2
3
4
4
Izvorni kod 7.2: Naredba for s listom stringova
1 #!/usr/bin/python
2 text=[’ide’,’patka’,’preko’,’save’]
3 for r in text:
4 print(r)
ide
patka
preko
save
Izvorni kod 7.3: Naredba for i stirng
1 #!/usr/bin/python
2 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 može se doci korištenjem naredbi len i
range (poglavlje ??) kao što se može vidjeti na primjeru Izvornog koda 7.4:
Izvorni kod 7.4: Naredba for s listom stringova
1 #!/usr/bin/python
2 text=[’ide’,’patka’,’preko’,’save’]
3 for i in range(len(text)):
4 print i, text[i]
29
30 petlje
0 ide
1 patka
2 preko
3 save
7.2 while
Osnovne sintaksa naredbe while jewhile conditon : commands
Naredbe commands izvršavaju se dokle god je uvjet condition istinit.
Logičkiuvjet
Ako je uvjetzadovoljen
Ako uvijet nije zadovoljen
Naredbe
Slika 7.1: Dijagram toka while petlje
Izvorni kod 7.5: Upotreba while naredbe
1 #!/usr/bin/python
2 i=0
3 while i*i<=9:
4 print i
5 i=i+1
0
1
2
7.3 break
Proširena 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, izvršit ce se naredbe commands2.Naredbe specificirane u else bloku izvode se kad se petlja završi zbog
nezadovoljavanja uvjeta sprecificiranog za while petlju ali ne i u slucajuzavršavanje tj. prekida petlje zbog break naredbe (Slika 7.2).
Izvorni kod 7.6: Upotreba else naredbe u petlji
1 #!/usr/bin/python
2 for num in range(3):
3 print(num)
4 else:print(’Kraj’)
7.4 continue 31
Logičkiuvjet
Ako je uvjetzadovoljen
Ako uvijet nije zadovoljen
Naredbe
Break
"else" naredbe
Slika 7.2: Dijagram toka while petlje sa else blokom
0
1
2
Kraj
Naredbom break se završava for ili while naredba. Na primjeru Izvornogkoda 7.7 može se vidjeti da se nakon break naredbe ne izvrši dio koda nakonelse naredbe.
Izvorni kod 7.7: Upotreba break naredbe
1 #!/usr/bin/python
2 i=0
3 while i*i<=9:
4 print i
5 i=i+1
6 if i==2 : break
7 else : print(’Kraj’)
0
1
7.4 continue
Naredbom continue se preskace izvršavnje sljedecih naredbi u tijelu for iliwhile naredbe (Slika 7.3).
Logičkiuvjet
Ako je uvjetzadovoljen
Ako uvijet nije zadovoljen
NaredbeNaredbe
continue
Slika 7.3: Dijagram toka while petlje sa continue naredbom
32 petlje
Izvorni kod 7.8: Upotreba continue naredbe
1 #!/usr/bin/python
2 for num in range(2, 5):
3 if num==3:continue
4 print(num)
2
4
7.5 paraleleno iteriranje
Naredbom zip moguce je elemente više listi pohraniti u jednu listu kojasadrži tupleove pripadajucih elemenata. Takva mogucnost restrukturiranjapodataka vrlo je korisna kod potrebe za istovremenim iteriranjem kroz višelisti (Izvorni kod 7.9).
Izvorni kod 7.9: Upotreba zip naredbe
1 #!/usr/bin/python
2 # -*- coding: utf-8 -*-
3
4 imena = [’Vlatko’, ’Ivana’, ’Darko’, ’Igor’]
5 prezimena = [’Hoorvat’, ’Bali’, ’Copljar’, ’Worry’]
6
7 osobe = zip(imena, prezimena)
8 print osobe
9
10 for o in osobe:
11 print o
12
13 for i, p in osobe:
14 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 sadrže jednak broj elemenata, formira se lista jednakeduljine 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 može biti i više od dva a rezultat je analogankorištenju funkcije zip sa dva argumenta (Izvorni kod 7.10).
Izvorni kod 7.10: Upotreba zip naredbe sa više lista.
1 #!/usr/bin/python
2 # -*- coding: utf-8 -*-
3
4 imena = [’Vlatko’, ’Ivana’, ’Darko’, ’Igor’]
5 prezimena = [’Hoorvat’, ’Bali’, ’Copljar’, ’Worry’]
6 visine = [1.79, 1.86, 2.10, 2.03]
7
8 for i, p, v in zip(imena, prezimena, visine):
9 print ’%s %s (%.2f m)’ % (i, p, v)
7.6 numeriranje liste 33
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 kre-ira iterabilni enumerate objekt koja sadrži tuplove elemenata izvorne liste tenjihve indekse. Dodatno, enumerate može primiti argument koji ukazuje odkojeg broj pocinje numeracija.
Izvorni kod 7.11: Numeriranje elemenata liste pomocu enumerate.
1 #!/usr/bin/python
2 # -*- coding: utf-8 -*-
3
4 X = [12.3, 18.6, 2.1, 12.3]
5
6 print ’Iteriranje pomocu enumerate:’
7 for x in enumerate(X):
8 print x
9
10 print ’Kreni od 0:’
11 for i, x in enumerate(X):
12 print ’a[%d]: %f’ % (i, x)
13
14 print ’Kreni od 1:’
15 for i, x in enumerate(X, 1):
16 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
8F U N K C I J E
Funkcije su grupirani dio koda koji izvodi odredeni zadatak. Prednosti upo-trebe funkcija su:
? Smanjenje ponavljanja istog koda
? Povecavanje modularnosti koda - rašclanjivanje složenog koda na jed-nostavnije djelove
? Povecanje citkosti koda.
Rad sa funkcijama u Pythonu omogucuje veliku fleksibilnost. Funkcijemogu biti dodijeljene varijablama, spremljene u listama i prosljedivane kaoargumenti 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 sintaksakoja omogucuje definiranje funkcije je:
def functionname():
commands
gdje je functionname odabrano ime funkcije a commnds je naredba ili više na-redbi koje funkcija izvršava. Prethodno definiranu funkciju možemo izvršiti Poziv funkcije uvijek
mora biti nakondefinicije funkcije. Nemože se pozvatifunkcija kojaprethodno nijedefinirana.
pozivom te funkcije. Funkcija se poziva pomocu imena funkcije nakon kojegslijede zagrade.
Izvorni kod 8.1: Definicija i pozivanje jednostavne funkcije
1 #!/usr/bin/python
2
3 def pozdrav():
4 print ’Pozdrav!’
5
6 pozdrav()
Pozdrav!
Funkciju je moguce proširiti na nacin da prima jedan ili više argumenata.Argumenti se definiraju pomocu imena argumenata razdvojenih zarezom uzagradama nakon imena funkcije:
def functionname(arg1, arg2, ... , argn):
commands
Funkcija sa argumentima se poziva tako da se u zagradama nakon imenafunkcije upišu vrijednosti argumenata. Argumenti se u pozivu funkcije raz-dvajaju zarezom kao i prilikom definicije funkcije.
35
36 funkcije
Izvorni kod 8.2: Definicija funkcije koja prima argument
1 #!/usr/bin/python
2
3 def pozdrav( ime ):
4 print ’Pozdrav’, ime, ’!’
5
6 def zbroji( a, b ):
7 c = a + b
8 print a, ’+’, b, ’=’, c
9
10 pozdrav(’Marko’)
11 zbroji(2, 5)
Pozdrav Marko !
2 + 5 = 7
8.2 vracanje vrijednosti iz funkcije
Funkcija može vratiti vrijednost nakon poziva funkcije. Vrijednost koju funk-cija vraca doslovno zamjenjuje funkciju u kontekstu u kojem je ona pozvana,a tip vracenog podatka može biti bilo koji Python objekt. Vracanje vrijed-nosti se definira naredbom return nakon koje se zaustavlja izvršavanje funk-cije:
def functionname(arg1, arg2, ... , argn):
commands
return value
Izvorni kod 8.3: Definicija funkcije koja prima više argumenata i vraca vrijednost
1 #!/usr/bin/python
2
3 def zbroji(a, b):
4 c = a + b
5 return c
6
7 x = zbroji(2, 6)
8 y = zbroji(x, -5)
9
10 print x, y
8 3
Funkcija može sadržavati više return naredbi (obicno u razlicitim uvjet-nim grananjima) i svaka može vratiti razlicit tip podatka (Izvorni kod 8.4).
Izvorni kod 8.4: Funkcija koja vraca razlicite tipove
1 #!/usr/bin/python
2
3 def luda_funkcija(a, b):
4 if(a > b):
5 return a + b
6 else:
7 return ’malo teksta’
8
9 x = luda_funkcija(6, 2)
10 y = luda_funkcija(x, 10)
11
12 print x, y
8 malo teksta
8.3 argumenti sa zadanim vrijednostima 37
Vrlo cesto, javlja se potreba da funkcija vraca više vrijednosti. To se možeostvariti vracanjem tuplea.
Izvorni kod 8.5: Funkcija koja vraca više vrijednosti korsiteci tuple
1 #!/usr/bin/python
2
3 def f(a, b):
4 z = a + b
5 r = a - b
6 return z, r
7
8 x = f(6.0, 2.0)
9 print x
10
11 c, d = f(6.0, 2.0)
12 print c
13 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. Argu-menti sa zadanim vrijednostima mooraju biti definirani nakon argumenatabez zadanih vrijednosti.def functionname(arg1=val1, arg2=val2, ... , argn=valn):
commands
return value
Prilikom poziva funkcije, moguce je funkciju pozvati bez zadanih argu-menata.
Izvorni kod 8.6: Funkcija sa zadanim argumentom
1 #!/usr/bin/python
2
3 def f(a, b=0.0):
4 if(a > b):
5 return a - b
6 else:
7 return b
8
9 a = f(6.0, 2.0)
10 b = f(20.0)
11 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 može pozivati na nacin da se, pomocu keyword argumenata,tocno specificiraju argumenti. Keyword argumenti su oni argumenti kojise, pri pozivu funkcije, zadaju imenom i vrijednošcu, za razliku od non-keyword argumenata koji se zadaju samo kao vrijednost. Redosljed zadava-nja keyword argumenata može biti proizvoljan dok kod kombinacije non-keyword i keyword argumenata prvo moraju biti specificirani non-keywordargumenti.
38 funkcije
1 # Definiranje funkcije
2 def f(x, a, b):
3 return x*(a+b)
4
5 # Poziv funkcije sa keyword argumentima
6 f(x=10, b=0, a=8)
7
8 # Poziv funkcije sa mjesovitim keyword i non-keyword argumentima
9 f(10, b=0, a=8)
Posebna sintaksa definiranja funkcije pomocu * i ** omogucuje korište-nje varijabilnog broja argumenata funkcije. Argument definiran sa jendomzvjezdicom, uobicajeno *args, obuhvaca sve non-keyword argumente u je-dan tuple. Upotrebom dvostruke zvijezdice **kwargs omogucuje pohranusvih keyword argumenata u dictionary gdje su kljucevi imena argumenata avrijednosti argumenata su pohranjene u vrijednosti pod pripadajucim klju-cem.
Izvorni kod 8.7: Funkcija sa *args i **kwargs argumentima
1 #!/usr/bin/python
2 # -*- coding: utf-8 -*-
3
4 def funkcija(*args, **kwargs):
5 print ’non-keyword argumenti:’, args
6 print ’keyword argumenti:’, kwargs
7
8 for key, value in kwargs.iteritems():
9 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 = TruePrilikom korištenja
oba operatora za“raspakiravanje”
argumenata (* i **)važno je poštivati
redoslijed. I koddefinicije funkcije ikod poziva funkcije
prvo se koristenon-keyword
argumenti a ondakeyword argumenti.
Osim prilikom definicije funkcije, sintaksa *args i **kwargs može se ko-ristiti i pri pozivu funkcije. Zvijezdicom * se tuple vrijednosti “raspakiraju”u argumente funkcije. Analogno, keyword argumente definirane u dicti-onaryu može se proslijediti funkciji pomocu dvije zvijezdice **. U izvornomkodu 8.8 prikazano je korištenje *args i **kwargs prilikom poziva funkcije.
Izvorni kod 8.8: *args i **kwargs argumenti prilikom poziva funkcije
1 #!/usr/bin/python
2 # -*- coding: utf-8 -*-
3
4 def funkcija(a, b, c, d, e):
5 print ’argumenti:’
6 print ’ a:’, a
7 print ’ b:’, b
8 print ’ c:’, c
9 print ’ d:’, d
10 print ’ e:’, e
11
12 a = (1, 2, 3, 4, 5)
13 funkcija(*a)
14
15 kwa = ’d’:1, ’c’:2, ’a’:3, ’e’:4, ’b’:5
16 funkcija(**kwa)
17
18 a = (5, 4)
19 kwa = ’e’:1, ’d’:2, ’c’:3
8.5 ugnježdena definicija funkcije 39
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 ugnježdena definicija funkcije
Ugnježdeno definiranje funkcije (eng. closure ili nested function definition)omogucuje definiciju funkcije u funkciji. Ugnježdena definicija funkcije jemoguca u Pythonu jer su funkcije objekti te ih je moguce prosljedivati kaoargumente drugim funkcijama te vracati kao rezultat funkcije. Ugnježdenodefinirane funkcije mogu se pokazati korisne jer unutarnja funkcija možekoristiti objekte definirane u vanjskoj:
>>> def vanjska(vanjski_argument):
... def unutarnja(unutarnji_argument):
... return vanjski_argument * unutarnji_argument
... return unutarnja
...
>>> f = vanjska(5)
>>> f(3)
15
>>> f(4)
20
8.6 anonimne funkcije
Lambda funkcije su funkcije bez imena tj. anonimne funkcije. Najcešce sekoriste za definiranje vrlo jednostavnih i kratkih funkcija. Definiranje ano-nimne funkcije se vrši korištenjem kljucne rijeci lambda:
lambda argumenti: izraz
Upotrebu jednostavne funkcije koja vraca apsolutnu razliku dva broja
1 def diff(a, b):
2 return abs(a - b)
3
4 print diff(7, 11)
4
može se zamjeniti lambda funkcijom:
1 >>> print (lambda a, b: abs(a - b))(7, 11)
2 4
40 funkcije
Anonimne funkcije se cesto pokriste kao argumenti drugih funkcija kojeocekuju objekt tipa funkcija kao argument.sorted funkcija ocekuje argument key kao funkciju, koja je vecini sluca-
jeva veoma jednostavna funkcija i obicno se koristi anonimna funkcija da seizbjegne posebno definiranje funkcije. U sljedecem primjeru napravljeno jesortiranje liste tupleova po drugim clanovima 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 ugnježdenim definici-jama funkcijama.
Izvorni kod 8.9: Primjer anonimne funkcije u ugnježdenoj definiciji
1 def poruka(ime):
2 return lambda poruka: ime + ’: ’ + poruka
3
4 p = poruka(’Mario’)
5 print p(’Bok!’)
6 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 iterativnipostupak kao sukcesivno povecavanje indeksa, tj. brojcanika koji sudjeluje uoperaciji koja u konacnici daje finalni rezultat. Primjer je suma uzastopnihbrojeva od 1 do 100.
1 suma = 0
2 for index in range(1,101):
3 suma = suma + index
4
5 print suma
Znaci suma se postepeno povecava dok se ne iscrpi lista, tj. sekvenca in-deksa definirana pozivom na range naredbu.
index = 1
suma = 0 + 1
index = 2
suma = 1 + 2
index = 3
suma = 3 + 3
index = 4
suma = 6 + 4
i tako dalje dok index ne postane 100. Drugim rijecima postepeno se navarijablu nadodaju brojevi.
Takoder je moguce zapisati isti postupak prema koracima kako je vršenosumiranje
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 = sumaindex−1 + index
8.7 rekurzivne funkcije 41
. Tako zapisani izraz daje naslutiti kako je slijedeca suma zapisana kao sumaiz prethodnog koraka na koju se nadodaje vrijednost index iz trenutnogkoraka iterativne petlje. Ovakav zapis u biti je obrnuti zapis od prirodnogsukcesivnog 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) + 1Mogucnost zapisafunkcije u obliku kojipoziva istu funkcijunazivamo rekurzija,a takvu funkcijurekurzivnafunkcija.
Tipicna rekurzivna funkcija vrši poziv sama na sebe.Primjer je funkcija rsuma :
1 def rsuma(x):
2 return rsuma(x)
No, kao što vidite ova funkcija vraca poziv na samu sebe koja vraca pozivna samu sebe koja vraca poziv na samu sebe i tako u beskonacnost. Ovakodefinirana rekurzivna funkcija nema kraja, a program ulazi u beskonacnu pet-lju (eng. infinite loop). A gdje je greška? Kako bi sprijecili ovakvo ponašanjepotrebno je uvesti uvjet prekida. To je granicna vrijednost nakon koje funkcijaviše nece vratiti sebe vec neku vrijednost. Ako se sada vratimo na sumubrojeva onda bi rekurzivna funkcija sume trebala izgledati ovako:
1 def rsuma(n):
2 return rsuma(n - 1) + n
No oznaka prekida je suma(0)=0, tj. kada u 100-tom pozivu funkcije rsumabude primila za argument 0 potrebno je zaustaviti daljnje pozive rsumafunkcije. To cemo postici testiranjem vrijednosti n
1 def rsuma(n):
2 if n = 0:
3 return 0
4 else:
5 return rsuma(n - 1) + n
Na taj nacin omogucili smo oznaku kraja rekurzivnim pozivima funkcije.Slijedi nekoliko primjera: Rekurzivni zapis
unosi konciznost ieleganciju uprogramski kod.
Primjer 1. Proracun faktorijela broja n.Faktorijel broja n je jednak :
n! = 1 ∗ 2 ∗ 3 ∗ 4 ∗ ... ∗nIma rekurzivni zapis
n! = (n− 1)! ∗n
1 def factoriel(n):
2 if n = 0:
3 return 1
4 else:
5 return factoriel(n - 1) * n
Primjer 2. Potenciranje broja x eksponentom n.Potenciranje takoder je iterativni proces koji može biti zapisan rekurzivno
na slijedeci nacin
xn = xn−1 ∗ xPrimjerice kub je jednak umnošku broja i kvadrata broja,
x3 = x2 ∗ x
42 funkcije
1 def potencija(x,n):
2 if n = 0:
3 return 1
4 else:
5 return potencija(x, n - 1) * x
Primjer 3. Korisnicki unos i formiranje listeUnose se brojevi koji se dodaju na listu dok se ne unese ’0’.
1 def rloop():
2 x = int(raw_input(’Unesi broj ili 0 za kraj’))
3
4 if x:
5 return [x]+rloop()
6 else:
7 return []
Dok su prethodni primjeri ovisili o smanjivanju broja n do oznake kraja, uovom primjeru funkcija se poziva tako da ažurira listu novim vrijednostima.
Za zakljucak, potrebno je napomenuti da je rekurzivnu funkciju mogucenapraviti za svaki poziv petlje, no da li je nužno sve petlje pretvoriti u re-kurzivne funkcije To ostaje na procijeni programeru koji mora odvagnutikolicinu elegancije, hijerarhije, strukturiranosti te preglednosti koda.
9O B J E K T N O - O R I J E N T I R A N O P R O G R A M I R A N J E
9.1 objektno-orijentirano programiranje
Python je inicijalno zamišljen kao objektno orijentirani programski jezik.Pojam objekt je kljuc za razumijevanje objektno-orijentiranog pristupa pro-
gramiranju. Objekt je kompozicija stanja (atributi, varijable) i ponašanja (me-tode, funkcije). Stanja jednog objekta cine njegovi atributi (npr. objekt auto-mobil može imati atribute promjer kotaca, snaga motora, trenutni prijenosniomjer) koji su u programu utjelovljeni kao varijable koje poprimaju odre-dene vrijednosti (stanja). Ponašanje ili aktivnosti odredenog objekta utjelov-ljene su u programu u obliku funkcija koje izvršavaju odredene radnje važneza objekt ili korisnike koji koriste objekte (npr. metode koje može izvršitiautomobil su kocenje, ubrzavanje, mijenjanje brzine, skretanje). Tako defi-nirani objekti omogucuju proširenje postojece funkcionalnosti programskogjezika i time programeru olakšavaju pisanje programa. Cesto ih se možesusresti prilikom izrade aplikacija sa grafickim suceljem ili bilo kojoj dru-goj aplikaciji ciji korisnici moraju stvarati objekte, mijenjati njihova stanja ikoristiti metode kako bi definirali ponašanje ili uzrokovali neku aktivnostvezanu uz objekt. Najlakše ce biti to shvatiti na slijedecem primjeru.
Primjer: "Aplikacija za pisanje teksta" omogucava korisniku slijedece funk-cionalnosti:
? izradu novog dokumenta - (u programskom kodu dokument je objekt)
? mijenjanje sadržaja dokumenta (sadržaj je jedan od atributa objekta)
? mijenjanje naziva dokumenta (sadržaj je jedan od atributa objekta)
? zapis sadržaja dokumenta u datoteku (Save, Save As funkcije kao me-tode objekta dokumenta)
? otvaranje dokumenta iz datoteke (Open funkcija kao metoda objektadokumenta)
? lijevo, centralno, podjednako i desno poravnanje teksta u sadržaju(Funkcije Left,Center,Right,Justify kao metode objekta dokumenta)
? itd.
Pored ovih stanja i ponašanja jednog dokumenta kao objekta lako bistemogli poznavajuci MS Word ili neku drugu aplikaciju za uredivanje i editi-ranje teksta osmisliti ili se sjetiti još neke od mnogih stanja i ponašanja kojeMS Word posjeduje.
Aplikacija poput ove takoder mora omoguciti i izradu ili ucitavanje ne-koliko objekata kako bismo mogli usporedivati ili kopirati njihov sadržaj ilirecimo spojiti više dokumenata u jedan. Da bi to omogucila aplikacija moraposjedovati nacin kako da omoguci istovremenu pojavu više dokumenata.Što to znaci u programu tocno. Dokument je opisan kao objekt u program-skom kodu. Više dokumenata time cini više objekta gdje svaki može imatisadržaj, naziv kao svoje atribute te metode Open ,Save, Left, itd. kao pona-šanja koja aplikacija omogucuje pojedinom dokumentu tj. objektu.
43
44 objektno-orijentirano programiranje
Time dolazimo do problema što svi izradeni dokumenti imaju varijablekao stanja i funkcije kao metode koje su jednake za sve dokumente/objekte.Kako bi aplikacija svim dokumentima omogucila tako nešto, mora u apli-kaciji postojati zapis koji definira kako ce se ponašati svaki pojedini objektdokumenta te koje ce funkcionalnosti svakom dokumentu aplikacija omo-guciti.
Taj zapis u objektno-orijentiranim programskim jezicima nazivamo Kla-som, a svaki poziv na izradu novog objekta instanciranje. Time je svakiobjekt definiran kao jedna instanca klase.
9.2 klase
Klase predstavljaju definiciju svih atributa i metoda koje ce instance te klasepoprimiti. 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 #!/usr/bin/python
2 # -*- coding: utf-8 -*-
3
4 class Dokument:
5 """
6 Klasa Dokument omogucuje instanciranje objekata Dokument
7 """
>>> 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 defini-cije klase te nacin instanciranja dva objekta d1 i d2. Printanjem u konzoliobjekata d1 i d2 moguce je vidjeti da su oba objekta instance te da je svakazasebno referencirana u memoriji na drugo adresno mjesto.
9.3 atributi
Atributi omogucuju dodjeljivanje stanja objekata. Njihova definicija nalazise 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 definirajuse odmah poslije definicije klase. To su globalne varijable koje vrijede za sveobjekte instancirane iz te klase. Npr.
Izvorni kod 9.2: Primjer definicije klasnih (globalnih) atributa
9.3 atributi 45
1 #!/usr/bin/python
2 # -*- coding: utf-8 -*-
3
4 class Dokument:
5 """
6 Klasa Dokument omogucuje instanciranje objekata Dokument
7 """
8
9 ime=’Dokument1’
10 sadrzaj=’Ovo je prva linija u dokumentu’
11
12 d1=Dokument()
13 d2=Dokument()
>>> d1.ime
’Dokument1’
>>> d2.ime
’Dokument1’
>>> Dokument.ime
’Dokument1’
Atribut ’ime’ je stoga dostupan svim objektima kao i samoj klasi Doku-ment. Potrebno je napomenuti da je moguce doci do pogreške ako objektnastoji mijenjati vrijednost klasnom atributu. Naime, takvim cinom nije iz-mijenjena vrijednost klasnom atributu vec je izraden novi atribut istogaimena, a koji pripada objektu.
>>> d2.ime
’Dokument1’
>>> d2.ime=’Doc’
>>> Dokument.ime
’Dokument1’
Svrha postojanja globalnih atributa je u tome da omoguce identifikacijuobjekata instanciranih iz jedne klase. Slijedeci primjeri primjene dati su naklasi Parkirališta:
? identifikacijski broj objekta (npr. Parking01,Parking02,...)
? lista objekata (npr. [obj1,obj2,obj3])
? kumulativne sume (npr. ukupan broj automobila parkiranih na svimparkiralištima)
9.3.2 Objektni atributi
Objektni atributi cine atribute definirane u klasi unutar posebne metodekoja se zove __init__. Ova metoda pripada u kategoriju ’magicnih metoda
klase’ jer omogucuju napredne mogucnosti. Inicijalizacija je u drugim pro-gramskim jezicima prisutna pod nazivom konstruktor. Ona ima za cilj omo-guciti definiciju atributa koji ce poprimati stanja definirana prilikom stvara-nja objekta. Npr.
Izvorni kod 9.3: Primjer definicije objektnog atributa
1 #!/usr/bin/python
2 # -*- coding: utf-8 -*-
3
4 class Dokument:
5 """
6 Klasa Dokument omogucuje instanciranje objekata Dokument
7 """
8 def __init__(self):
46 objektno-orijentirano programiranje
9 self.ime=’’
10 self.sadrzaj=’’
11
12 d1=Dokument()
13 d2=Dokument()
14
15 d1.ime=’Prica01’
16 d1.sadrzaj=’Bio jednom jedan val.’
17
18 d2.ime=’ListaSerija’
19 d2.sadrzaj=’Lud, zbunjen, normalan.\n’
20 d2.sadrzaj+=’Sila\n’
Metoda __init__omogucuje, takoder, prihvat argumenata predanih Klasiprilikom formiranja objekta. To cinimo tako da u argument listu metode__init__predamo vrijednosti koje želimo da pojedini atributi tog objekta po-prime. Npr.
Izvorni kod 9.4: Inicijalizacija objekta
1 #!/usr/bin/python
2 # -*- coding: utf-8 -*-
3
4 class Dokument:
5 """
6 Klasa Dokument omogucuje instanciranje objekata Dokument
7 """
8 def __init__(self,name=’Dokument’,content=’’):
9 self.ime=name
10 self.sadrzaj=content
11
12
13 d1=Dokument(’Esej’,’Prva recenica’)
14 d2=Dokument(’Blog01’)
15 d3=Dokument()
Do ovog koraka vec sve uvidjeli da se pozivi atributa unutar metode__init__vrše pomocu specificne rijeci self. No, to cemo obraditi u sljedecempoglavlju Metode.
9.4 metode
Metode su funkcije koje koristimo da u klasi definiramo promjenu stanjaatributa, izvršimo neke aktivnosti ili obavimo neke druge radnje vezane uzodredeni objekt. Svaka metoda mora biti definirana kao funkcija i posje-dovati minimalno jedan argument, a to je self kao opis objekta za kojegase izvršava metoda. Slijedeci primjer definira metodu Info koja omogucujeprintanje naziva i sadržaja objekta koji ju je pozvao.
Obratite pažnju na korišteni globalni atribut DokumentList kao listu obje-kata koja se puni prilikom inicijalizacije.
Izvorni kod 9.5: Definicija metode
1 #!/usr/bin/python
2 # -*- coding: utf-8 -*-
3
4 class Dokument:
5 """
6 Klasa Dokument omogucuje instanciranje objekata Dokument
7 """
8
9 DokumentList=[]
10
9.5 preopterecivanje 47
11 def __init__(self,name=’Dokument’,content=’’):
12 self.ime=name
13 self.sadrzaj=content
14 Dokument.DokumentList.append(self)
15
16 def Info(self):
17 print ’Ime dokumenta:’,self.ime
18 print ’Sadrzaj:\n’,self.sadrzaj
19
20 d1=Dokument(’Esej’,’Prva recenica’)
21 d2=Dokument(’Blog01’)
22 d3=Dokument()
23
24 for d in Dokument.DokumentList:
25 d.Info()
26 print ’\n’
Self prvi put dobiva znacaj kao prvi clan argument liste metode __init__(def__init__(self,arg1,arg2,...)). Unutar same metode svaki od atributa koji se ko-riste mora biti zapisan uz pomoc ’self.’ prefiksa.
Možemo to gledati na drugaciji nacin. Zamislite da je klasa modul kojiima svoje pod-funkcije (metode). Svaka od tih pod-funkcija ima mogucnostmijenjati atribute nekom objektu. To je ostvarivo samo ako pod-funkcijamože pristupiti objektu i njegovim atributima.
Upravo to cinimo predajuci self metodi __init__. Predajemo objekt u oblikurijeci self, te nakon toga vrijednosti koje želimo dodijeliti atributima. No ustvarnosti Python dozvoljava pozivanje funkcija bez davanja sebe kao prvogclana argument liste.
Na slijedecem primjeru usporedujemo dva istovjetna poziva metode gdjeje prva na nacin da objekt poziva metodu, a druga da Klasnoj metodi pre-damo objekt kao prvi clan argument liste te nakon njega sve ostale argu-mente.
>>> 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 jednos-tavniji 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 preop-terecivanja funkcija i operatora kako bi i objektima omogucili istu funkci-onalnost kao i klasicnim varijablama poput int, float, bool, string, list, itd.Takva osobina cesto je i nužnost kako bi operatore mogli dovoditi u odre-dene odnose i operacije ili nad objektima izvršiti radnje poput printanja.
Cesto se za evaluaciju ili grananje služimo operatorima usporedbe (>,>=,<,<=,==) te logickim operatorima and i or. Istu funkcionalnost moguce je posticii usporedbom dvaju objekata gdje se objekti pritom usporeduju na nacinda im se tocno odredi što i kako se usporeduje (npr. dvije košare voca Ko-sara01 i Kosara02 su objekti ciji sastav cini raznovrsno voce gdje svako imasvoju težinu i moguce je u svakom slucaju utvrditi ukupnu težinu košare tepristupiti usporedbi dvaju košarica).
48 objektno-orijentirano programiranje
Nadalje, objekti mogu biti tako osmišljeni da je od znacaja primjena os-novnih numerickih operatora (+,-,*,/,itd.) kako bi se kreirali novi objekti saizmjenjenim atributima na temelju numerickih operatora (npr. ako su onedvije kosare iz prethodnog zadatka bile pune i u njih vise ne stane onda jemoguce u novu kosaru dodati sastojke iz prethodne dvije pune kosare).
Sva preopterecenja u Pythonu predefinirana su u obliku specijalnih me-toda koje svaka klasa može implementirati. Specijalne metode imaju nazivomeden sa dvije donje crte ispred i iza naziva (npr. __str__ili __gt__)
9.5.1 Preopterecivanje funkcija
Izvorni kod 9.6: Preopterecivanje funkcije print
1 # -*- coding: utf-8 -*-
2 """
3 Created on Sat Jun 1 13:35:55 2013
4 """
5
6 from math import sqrt
7
8 class Point:
9
10 def __init__(self,x,y):
11 self.x=x
12 self.y=y
13
14 def R(self): # funkcija koja vraca radij vektor tocke, tj. udaljenost od
ishodista
15 return sqrt(self.x**2 + self.y**2)
16
17 # Preoptereceni operatori usporedbe tocka s obzirom na udaljenost od ishodista
18 def __lt__(self,other): # less then
19 return self.R() < other.R()
20 def __le__(self,other): # less or equal
21 return self.R() <= other.R()
22 def __gt__(self,other): # greather then
23 return self.R() > other.R()
24 def __ge__(self,other): # greater or equal
25 return self.R() >= other.R()
26
27 p1=Point(2,1)
28 p2=Point(1,2)
29 p3=Point(3,0)
30
31 print p1>p2
32 print p1>=p2
33 print p1<=p2
34 print p1<p3
35 print 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 funk-ciju __str__koja vraca string koji ce biti printan prilikom printanja objekta.
print PTS1
print PTS2
9.5 preopterecivanje 49
Potrebno je napomenuti da nije moguce preopteretiti korisnicki definiranefunkcije tj. sve one koje nemaju svoju specijalnu funkciju.9.5.2 Preopterecivanje operatora
Preopterecivanje operatora omoguceno je u Pythonu korištenjem specijalnihmetoda slijedecih imena Operatori usporedbe
? __gt__ - Vece od - ’>’
? __ge__ - Vece ili jednako od - ’>=’
? __lt__ - Manje od - ’<’
? __le__ - Manje ili jednako od - ’<=’
? __eq__ - Jednako - ’==’
Izvorni kod 9.7: Preopterecivanje funkcije print
1 # -*- coding: utf-8 -*-
2 """
3 Created on Sat Jun 1 13:35:55 2013
4 """
5
6 from math import sqrt
7
8 class RVector:
9
10 def __init__(self,x,y):
11 self.x=x # atribut x koordinata
12 self.y=y # atribut y koordinata
13
14 def R(self): # metoda koja vraca duljinu radij vektora, tj. udaljenost od
ishodista
15 return sqrt(self.x**2 + self.y**2)
16
17 # Preoptereceni operatori usporedbe radij vektora s obzirom na udaljenost od
ishodista
18 def __lt__(self,other): # less then
19 return self.R() < other.R()
20 def __le__(self,other): # less or equal
21 return self.R() <= other.R()
22 def __gt__(self,other): # greather then
23 return self.R() > other.R()
24 def __ge__(self,other): # greater or equal
25 return self.R() >= other.R()
26 def __eq__(self,other): # greater or equal
27 return self.R() == other.R()
28
29 p1=RVector(2,1)
30 p2=RVector(1,2)
31 p3=RVector(3,0)
32
33 print p1>p2
34 print p1>=p2
35 print p1<=p2
36 print p3<p2
37 print p1==p2
False
True
True
False
True
50 objektno-orijentirano programiranje
Aritmeticki operatori
? __add__ - zbrajanje - ’+’
? __sub__ - oduzimanje - ’-’
? __mul__ - množenje - ’*’
? __div__ - djeljenje - ’/’
Izvorni kod 9.8: Preopterecivanje funkcije print
1 # -*- coding: utf-8 -*-
2
3 class Table:
4
5 def __init__(self,a=1.0,b=1.0):
6 self.a = a
7 self.b = b
8 self.Area = self.a * self.b # atribut povrsine stola
9
10 def __str__(self):
11 return ’Table = %4.1f x %4.1f \n Area = %6.2f’ % (self.a,self.b,self.Area)
12
13 def Rotate(self): # rotira stranice a i b
14 tmpA=self.a
15 tmpB=self.b
16
17 self.a=tmpB
18 self.b=tmpA
19
20 print ’Stol zarotiran!’
21
22 # Preoptereceni aritmeticki operatori
23
24 def __add__(self,other): # zbraja dva stola
25 self.a = self.a + other.a # dužinu drugog pridodajemo dužini prvog
26 self.Area = self.Area + other.Area # površinu drugog dodajemo povrsini
prvog
27 self.b = self.Area / self.a # izracunavamo novu prosjecnu širinu
28 print ’Stolovi spojeni!’
29 def __sub__(self,other): # oduzima dva stola
30 if self.Area > other.Area:
31 if self.a > other.a:
32 if self.b > other.b:
33 self.Area -= other.Area # oduzima površinu drugoga
34 self.a -= other.a # oduzima dužinu drugoga
35 self.b = float(self.Area)/self.a # izracunava novu širinu
36 print ’Stolovi oduzeti!’
37 else:
38 print ’Sirina b je duža kod drugog stola.’
39 else:
40 print ’Duzina a je duza kod drugog stola.’
41 else:
42 print ’Povrsina drugog je veca od prvog stola.’
43
44 t1=Table(10,20)
45 t2=Table(20,40)
46 print t1
47 print t2
48 t1-t2
49 t2-t1
50 t1+t2
51 t1.Rotate()
52 t1-t2
53 print t1
54 print t2
9.6 nasljeðivanje 51
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 prepuštamovama da ih istražite ako smatrate potrebnim.
9.6 nasljeðivanje
Objekti koje je moguce susresti u stvarnom životu najcešce su kategoriziraniu neke grupacije ili klastere, ili su dio neke hijerarhijske strukture. Rijetkoda je neki objekt jedinstven u svoj svojoj unutrašnjosti. Covjek jede, životinjajede, a i biljke jedu tj. izvršavaju jednu od svojih najvažnijih funkcija. Biciklje kopneno vozilo, kao i automobil, dok je avion ili balon na vruci zrakzracno vozilo, a podmornica ili brod pomorsko vozilo. Sva ova prometalasu vozila. Na taj nacin slijedi hijerarhija koja definira pripadnost pojedinihobjekata. Postoje i rekurzivne hijerarhijske veze poput obiteljskih stabala ilisvake strukture koja za svoj rezultat ima potomstvo novih objekata.
Nasljedivanje je u pravilu proces kojim od viših hijerarhijskih razina iligrupacija poprimamo neke osobine ili funkcije.
Objektno-orjentirano programiranje omogucuje naslijedivanje atributa imetoda iz nadredenih klasa. Deklaracija klase koja posjeduje nadklasu dataje u slijedecoj liniji koda:
class Sudoku(Igra):
Klasa Sudoku naslijeduje metode od svoje nadklase Igra koja se cestozove i bazna (osnovna) klasa. Kao što je Igra nadklasa klasi Sudoku tako jeSudoku klasi Igra podklasa.
U slijedecem primjeru dana je nadklasa Road koja inicijalizira naziv cestename i duljinu ceste length te definira sadržaj metode Info() koja služi zaispis vrijednosti atributa svakog instanciranog objekta bilo podklase Hig-hway, MainRoad, LoaclRoad ili osnovne nadklase Road.
Naslijedivanje ima još jednu prednost koja se ocituje u sistematizaciji iz-vornog koda. Kada ne bi imali nadklasu, svaka od podklasa trebala bi samainicijalizirati svoje atribute kao i definirati svoju funkciju Info(). Na taj nacinizvorni kod bi bio predugacak, nejasan i necitljiv.
Izvorni kod 9.9: Naslijedivanje
1 # -*- coding: utf-8 -*-
2 """
52 objektno-orijentirano programiranje
3 Created on Sat Jun 1 20:07:45 2013
4 """
5 class Road:
6 def __init__(self,name,length):
7 self.name=name
8 self.length=length
9 def Info(self):
10 print "Road definition"
11 print "Ime:\t %15s" % self.name
12 print "Length:\t %15s" % self.length
13 class Highway(Road):
14 pass # Bez lokalnih definicija
15 class MainRoad(Road):
16 pass # Bez lokalnih definicija
17 class LocalRoad(Road):
18 pass # Bez lokalnih definicija
19
20 h1=Highway(’A1’,1000)
21 m1=MainRoad(’E54’,540)
22 l1=LocalRoad(’S16’,125)
23 h1.Info()
24 m1.Info()
25 l1.Info()
Road definition
Ime: A1
Length: 1000
Road definition
Ime: E54
Length: 540
Road definition
Ime: S16
Length: 125
U situaciji kada pojedina podklasa ipak zahtjeva prilikom inicijalizacije de-finirati neki vlastiti atribut tada definicija __init__unutar podklase predefi-nira (override) __init__metodu nadklase. U tom slucaju je potrebno pozvatiinicijalizacijsku metodu nadklase unutar inicijalizacijske metode podklase.
Izvorni kod 9.10: Naslijedivanje override __init__metode
1 # -*- coding: utf-8 -*-
2 """
3 Created on Sat Jun 1 20:07:45 2013
4 """
5 class Road:
6 def __init__(self,name,length):
7 self.name=name
8 self.length=length
9
10 def Info(self):
11 print "Road definition"
12 print "Ime:\t %15s" % self.name
13 print "Length:\t %15s" % self.length
14
15 class Highway(Road):
16 def __init__(self,name,length): # override __init__ nadklase
17 Road.__init__(self,name,length) # invokacija __init__ metode nadklase
18 self.type=’highway’
19 self.toll=50 # Kn/100km
20 class MainRoad(Road):
21 def __init__(self,name,length): # override __init__ nadklase
22 Road.__init__(self,name,length) # invokacija __init__ metode nadklase
23 self.type=’mainroad’
24 class LocalRoad(Road):
25 def __init__(self,name,length): # override __init__ nadklase
26 Road.__init__(self,name,length) # invokacija __init__ metode nadklase
9.6 nasljeðivanje 53
27 self.type=’localroad’
28
29 h1=Highway(’A1’,1000)
30 m1=MainRoad(’E54’,540)
31 l1=LocalRoad(’S16’,125)
32
33 print h1.toll
50
Pored jednostavnih naslijedivanja moguca su i višestruka naslijedivanjaiz više nadklasa i definiraju se na slijedeci nacin:
class Smartphone(Mobile_device,Computer):
10O 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 vri-jednosti unutar stringa na posebno oznacena mjesta. Mjesta na koja trebaubaciti odredenu vrijednost u stringu oznacavaju se znakom % i posebnimoznakama koje detaljnije definiraju formatiranje ubacene vrijednosti. Nakonstringa i operatora % (Nije isto što i oznaka u samom stringu) u tupleu ilidictionaryju 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 kojase ubacuje u string,
? konverzijske opcije (neobavezno),
? minimalni broj rezerviranih znakova (neobavezno),
? preciznost (neobavezno), oznacava broj decimalnih mjesta koje se pri-kazuju i piše se nakon znaka ..
? tip konverzije.Upotrebom kljucevamapiranja zadavanjeargumenata udictionaryju ne morabiti u istomredosljedu kao ipozicije ubacivanja usamom stringu. Naovaj se nacinargumenti moguupotrijebiti više puta,bez potrebe da ih sevišestruko putazapisuje unutardictionaryja.
Ako se koristi kljuc mapiranja onda vrijednosti treba zadati u dictionaryjudok se inace zadaju u tupleu.
Konverzijske opcije se definiraju pomocu znakova opisanih u tablici 10.1.
Simbol Opis
’0’ 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 deci-malnog i cijelog broja u string. Primjer obuhvaca primjenu tupleova bezkljuca mapiranja te na istom primjeru primjenu dictionaryja sa kljucevimamapiranja.
Izvorni kod 10.1: Primjer formatiranja numerickih podataka sa tupleom i dictionaryjem
>>> s = ’a = %.2f, b = %d’ % (12.365, 18)
>>> print s
a = 12.37, b = 18
>>> s = ’a = %(a).2f, b = %(b)d’ % ’a’: 12.365, ’b’: 18
>>> print s
a = 12.37, b = 18
>>> s = ’a = %(a).2f, a = %(a)+.1f’ % ’a’: 12.365
>>> print s
a = 12.37, a = +12.4
55
56 oblikovanje stringova
Simbol Tip
’d’ Cijeli broj
’o’ Oktalni broj
’x’ Heksadecimalni broj
’e’ Decimalni broj u eksponencijanom obliku
’f’ Decimalni broj
’c’ Tekstualni znak
’s’ String
’%’ Nema konverzije argumenta, rezultat sadrži znak ’%’
Tablica 10.2: Definiranje tipova podataka
Razlicite primjene konverzijskih opcija prikazane su u izvornom kodu10.2.
Izvorni kod 10.2: Primjer formatiranja numerickih podataka sa tupleom i dictionaryjem
>>> print ’x = [%5.2f, %5.2f]’ % (11.14, 7.88)
x = [11.14, 7.88]
>>> print ’x = [%f, %f]’ % (11.14, 7.88)
x = [11.140000, 7.880000]
>>> print ’x = [%10f, %10f]’ % (11.14, 7.88)
x = [ 11.140000, 7.880000]
>>> print ’x = [%010f, %010f]’ % (11.14, 7.88)
x = [011.140000, 007.880000]
>>> print ’x = [%+10f, %+10f]’ % (11.14, 7.88)
x = [+11.140000, +7.880000]
>>> print ’x = [%-+10f, %-+10f]’ % (11.14, 7.88)
x = [+11.140000, +7.880000 ]
>>> print ’x = [%-+10.2f, %-+10.2f]’ % (11.14, 7.88)
x = [+11.14 , +7.88 ]
>>> print ’x = [%+10.2f, %+10.2f]’ % (11.14, 7.88)
x = [ +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 for i in range(len(l)):
6 s = ’%03d %4.1f %6.1f %5.2f %+6.3f’ % \
7 (i+1, l[i], l[i]**2.0, sqrt(l[i]), sin(l[i]))
8 print s
001 1.0 1.0 1.00 +0.841
002 2.0 4.0 1.41 +0.909
003 3.0 9.0 1.73 +0.141
004 4.0 16.0 2.00 -0.757
005 5.0 25.0 2.24 -0.959
006 6.0 36.0 2.45 -0.279
007 7.0 49.0 2.65 +0.657
008 8.0 64.0 2.83 +0.989
009 9.0 81.0 3.00 +0.412
010 10.0 100.0 3.16 -0.544
10.2 oblikovanje sa metodom format 57
10.2 oblikovanje sa metodom format
Svi string objekti sadže metodu format koja omogucuje napredno formati-ranje i kontrolu stringova.
11R A D S A D AT O T E K A M A
11.1 otvaranje i zatvaranje datoteka
Osnovna manipulacija sa sadržajem datoteka u Pythonu je omogucena kori-štenjem file objekta.
Python ima ugradenu funkciju open za otvaranje postojecih ili stvaranjenovih datoteka na disku. Funkcija open vraca file objekt, koji sadrži metodei atribute za pristup i manipulaciju informacija i sadržaja otvorene datoteke.
Sintaksa otvaranja datoteka je:f = open(ime\_datoteke, vrsta\_pristupa, buffering)
gdje je ime_datoteke sting koji sadrži relativnu ili apsolutnu putanju da-toteke, vrsta_pristupa je string koji sadrži mod pristupa, buffering jeinteger koji oznacava velicinu medupohrane. Argumenti vrsta_pristupa
i buffering nisu obavezni. f je novonastali file objekt kreiran pozivomfunkcije open. Pocetna pozicija
unutar datotekerazlikuje se ovisno oopciji ’r’, ’w’(pocetak datoteke) ili’a’ (kraj datoteke).
Mod pristupa se definira kao string koji sadrži znakove:
? ’r’, ’w’ ili ’a’ kojima se definira da li ce se vršiti citanje (read), pisanje(write) ili dodavanje (append)
? ’b’ oznacava binarni oblik datoteke. Ako nije specificiran onda je oblikdatoteke takstualni (’t’).
? ’+’ omogucuje istodobno citanje i pisanje (ili dodavanje) datoteke.
Nakon obavljanja željenih manipulacija, koje su objašnjene u narednimpoglavljima, datoteku je potrebno zatvoriti. Za zatvaranje datoteke koristise 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 writelinesklase file.write metoda prima string varijablu koju zapisuje u prethodno otvorenu
datoteku u modu za pisanje (’w’) ili dodavanje (’a’). Ovu naredbu može seponavljati kako bi se dodalo još teksta u datoteku.f.write(tekst)
Izvorni kod 11.1: Primjer kreiranja tekstualne datoteke
1 #!/usr/bin/python
2 # -*- coding: utf-8 -*-
3
4 datoteka = open(’info.txt’, ’w’)
5
6 datoteka.write(’Tehnicki fakultet’)
7 datoteka.write(’, Rijeka’)
8 datoteka.write(’\nVukovarska 58’)
9
10 datoteka.close()
59
60 rad sa datotekama
Tehnicki fakultet, Rijeka
Vukovarska 58
Funkcija writelines zapisuje listu stringova u datoteku. Postignuti efektje isti kao da se pozove write za svaki element liste.Iako njeno ime na to
upucuje,writelines ne
zapisuje svakielement liste u novi
redak!
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 citanje datoteke potrebno je željenu datoteku otvoriti u modu za citanje(’r’). Osnovni nacin za procitati sadržaj odredene datoteke je preko funk-cija:
? read koja vraca sadržaj datoteke (od trenutne pozicije) željene velicineu obliku stringa,
? readline koja vraca sadržaj trenutne linije u obliku stringa,
? readlines koja vraca listu stringova koji predstavljaju pojedine linijedatoteke
Sintaks metode read je:
f.read(size)
gdje je size velicina sadržaja koji treba procitati. Za binarnu datoteku size
oznacava broj bitova a za tekstualnu broj znakova. Ukoliko je size negativanili nije zadan, cita se cijeli sadržaj datoteke.Kod citanja datoteka
vrlo cesto je bitnatrenutna pozicija u
samoj datoteci što jeobjašnjeno u
poglavlju 11.4
f.readline(size)
Metoda readline cita jednu liniju u datoteci i to od trenutne pozicije dokraja lnije (do znaka ’
n’). Argument size definira maksimalnu velicinu procitanih podataka. Zaprazne lnije metoda vraca string koji sadrži znak za novu liniju ’
n’. Kad je trenutna pozicija na kraju datoteke, metoda vraca prazan string.
f.readlines(size)
readlines vraca sadržaj datoteke kao listu linija. size ima jednak ucinakkao i na dvije prethodno objašnjene metode.
Za potrebe primjera, zadana je datoteka test.txt sljedeceg sadržaja:
123456789
ABCDEFGHIJKLMNOPQRSTUVWXYZ
3. linija
4. linija
zadnja!
U izvornom kodu 11.2 dani su primjeri upotrebe navedenih funkcija zacitanje sadržaja datoteke.
11.4 pozicioniranje u datoteci 61
Izvorni kod 11.2: Citanje sadržaja tekstualne datoteke
1 data = open(’test.txt’, ’r’)
2 print data.read(5)
3 print data.readline()
4 print data.readline(6)
5 print data.readlines()
6 data.close()
12345
6789
ABCDEF
[’GHIJKLMNOPQRSTUVWXYZ\n’, ’3. linija\n’, ’4. linija\n’, ’zadnja!’]
Osim pomocu navedenih funkcija, postoji još jedan nacin pristupanju lini-jama neke tekstualne datotetke, a to je iterirajuci kroz file objekt kao što jeprikazano u izvornom kodu 11.3.
Izvorni kod 11.3: Pristupanje sadržaju datoteke preko iteriranja po file objektu
1 data = open(’test.txt’, ’r’)
2 s = ’’
3 for line in data:
4 s += line
5 print s
6 data.close()
123456789
ABCDEFGHIJKLMNOPQRSTUVWXYZ
3. linija
4. linija
zadnja!
11.4 pozicioniranje u datoteci
Trenutnu poziciju u datoteci može se saznati preko metode tell:
f.tell()
Metoda tell daje broj bitova (znakova) trenutne pozicije od pocetka da-toteke (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 anegativan u nazad. Argumentom from se definira od kuda ce se pomakracunati (0 za pocetak datoteke, 1 za trenutni položaj i 2 za kraj datoteke).
Izvorni kod 11.4: Dohvacanje trenutne pozicije u datoteci
1 data = open(’test.txt’, ’r’)
2 print data.readline()
3 print ’pozicija:’,data.tell()
4 print data.read(3)
5 print ’pozicija:’,data.tell()
6 data.seek(6,1)
7 print data.read(3)
8 data.seek(-3,1)
9 print data.read(5)
10 data.seek(0,0)
11 print data.read(5)
62 rad sa datotekama
12 data.seek(-5,2)
13 print data.read(5)
14 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 # simply
2 import os
3 os.rename(’a.txt’,’b.kml’)
4
5 # or
6 import shutil
7 shutil.move(’a.txt’, ’b.kml’)
8
9
10 # or if you want to copy..
11 import shutil
12 shutil.copy(’a.txt’, ’b.kml’)
11.6 arhiviranje
1 from shutil import make_archive
2 import os
3 archive_name = os.path.expanduser(os.path.join(’~’, ’myarchive’))
4 root_dir = os.path.expanduser(os.path.join(’~’, ’.ssh’))
5 make_archive(archive_name, ’gztar’, root_dir)
6 ’/Users/tarek/myarchive.tar.gz’
12P Y T H O N S TA N D A R D L I B R A RY
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 matematicke funkcije
Python modul math sadrži standardne matematicke funkcije za realne bro-jeve koje su definirane C standrdom, s kojima se najcešce susrecemo prili-kom 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 #!/usr/bin/python
2 from math import log,e,fsum
3 print log(e)
4 print fsum([1,2,3])
1.
6.
Python modul cmath sadrži standardne matematicke funkcija nad poljemkompleksnih 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 from cmath import sqrt
2 sqrt(1.+2.j)
(1.272019649514069+0.7861513777574233j)
63
64 python standard library
Python modul decimal omogucuje racunanje i pravilno zaokruživanje re-alnih brojeva u aritmetici s proizvoljnim brojem decimalnih mjesta.
Primjer upotrebe nekih funkcija math modula:
1 #!/usr/bin/python
2 from decimal import *3 getcontext().prec = 6
4 print Decimal(1) / Decimal(3)
5 getcontext().prec =30
6 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 izvršavanja
Ucinkovitost odredenog algoritma, djela izvornog koda ili pak cijelog izvor-nog koda vrlo je bitan faktor ukupne kvalitete racunalnog programa. Ucin-kovitost odredenog izvornog koda se, prije svega, može mjeriti vremenomizvodenja tog koda.
Treba imati na umu da vrijeme izvodenja ovisi o hardverskim resursimaracunala pa su stoga rezultati razliciti ovisn o racunalu na kojem se testi-ranje vrši. Vrijeme izvršavanja ovisi i o trenutnom opterecenju hardverskihresursa (operativni sustav, sistemski servisi i pokrenute aplikacije), pa ce, umanjoj mjeri, testiranja na istom racunalu biti razlicita.
Vrlo elegantan nacin za mjerenje vremena izvršavanja odredenog djelakoda 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 izvršavanja,
ali razlicito funkcionira na Linux (Unix) i MS Windows platformama:time.clock() ilitime.time() se
mogu pozivati višeputa te na taj nacin
mjeriti vrijemeizvršavanja višedjelova izvornog
koda.
? na Linux platofrmi, time.clock() daje utrošeno procesorsko vrijeme,tj. koliko je sekundi procesor bio opterecen,
? na MS Windows platformi, time.clock() daje “ukupno” utrošeno vri-jeme koje obuhvaca vrijeme racunanja (procesor) ali i utrošeno vrijemena citanje datoteka (disk) ili npr. utoršeno vrijeme na uspostavljanjekonekcije preko nekog mrežnog protokola.
Kod mjerenja izvršavanja koda koji radi sa citanje ili pisanjem datoteka ilikoji vrši komunikaciju preko mrežnih protokola, rezultati ce biti ovisni i oplatformi na kojoj se kod izvršava.
Izvorni kod 12.1: Primjer mjerenja vremena izvršavanje algoritma
1 #!/usr/bin/python
2 # -*- coding: utf-8 -*-
3
4 import time
5
6 # dohvati vrijeme pocetka
7 start_c = time.clock()
8 start_t = time.time()
12.4 vrijeme izvršavanja 65
9 print ’Start clock: %.5f’ % start_c
10 print ’Start time: %.5f’ % start_t
11
12
13 # Algoritam
14 a = 0.0
15 for i in range(1000):
16 for j in range(i):
17 a = a + (i - j)**0.3
18
19 # dohvati vrijeme završetka
20 stop_c = time.clock()
21 stop_t = time.time()
22 print ’Stop clock: %.5f’ % stop_c
23 print ’Stop time: %.5f’ % stop_t
24
25 print ’Rezultat: %.2f’ % a
26 print ’Vrijeme izvrsavanja (clock): %.3f ms’ % (stop_c - start_c)
27 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 sadrži klasu Timer koja omogucuje mjerenje vre-mena izvršavanja Python izraza.
Izvorni kod 12.2: Primjer upotrebe Timer klase za mjerenje vremena izvodenja funkcije
1 #!/usr/bin/python
2 # -*- coding: utf-8 -*-
3
4 import timeit
5 from math import sqrt
6
7 # Algoritam
8 def f(x):
9 s = 0.0
10 for i in range(x):
11 s = s * sqrt(s+x)
12
13 t = timeit.Timer(stmt=’f(500)’, setup=’from __main__ import f’)
14
15 r1 = t.timeit(number=1000)
16 print ’Potrebno vrijeme za 1000 poziva funkcije f(500): %.5f’ % r1
17
18 r5 = t.repeat(number=1000, repeat=5)
19 print ’\nPonavljanje testa (5 puta):’
20 for r in r5:
21 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 f(500): 0.05900
Potrebno vrijeme za 1000 poziva funkcije f(500): 0.05927
Potrebno vrijeme za 1000 poziva funkcije f(500): 0.05888
Potrebno vrijeme za 1000 poziva funkcije f(500): 0.05953
Potrebno vrijeme za 1000 poziva funkcije f(500): 0.05925
13G R E Š K E U P Y T H O N K O D U
13.1 tipovi grešaka
Vecina programskih jezika posjeduje odredene usluge prema korisniku kojeomogucuju identificiranje i manipulaciju grešaka u pisanom izvornom kodute davaju korisna objašnjenja vezana uz izvor greške ili nacin kako ih uklo-niti. Python slijedi takvu logiku i omogucuje prijavljivanje dva tipa grešaka:
? Sintaksne greške Syntax Error i
? Iznimke (eng. Exceptions)
Obje greške utvrduju se iskljucivo tijekom izvodenja tj. interpretiranjakoda: sintaksne greške na pocetku izvodenja koda, a iznimke za svaki iz-vršeni red koda. Nakon što Python identificira prvu grešku na koju naideprogram stane sa izvršavanjem i objavi poruku slijedeceg izgleda
>>> print c
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name ’c’ is not defined
Traceback obavještava korisnika o tome gdje je greška pronadena i daje opisgreške pomocu sintaksne greške ili iznimke (eng. exception) koja objašnjavarazlog prekida izvršavanja programa. U navedenom primjeru NameError jeiznimka koja opisuje grešku pri pozivu imena ’c’.
Sintaksne greške testiraju svaku liniju koda netom prije izvodenja cijelogprograma i utvrduju svaku nepravilnost u sintaksi programskog jezika. Npr.
1 j=1
2
3 if j<2:
4 print ’Help’
5 else:
6 if True
7 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 jeuvjet if naredbe takav da vraca True, medutim program svejedno vraca gre-šku prilikom provere sintakse (’nedostaje dvotocka iza True’)
No, iznimke ce program objaviti samo ako naide na njih.Primjer kada naide na grešku (pogrešno upisana varijabla ’i’, trebalo je
’j’):
1 j=1
2
3 if j<2:
4 print ’Help’
5 print i
67
68 greške u python kodu
Help
Traceback (most recent call last):
File "/home/mcavrak/.spyder2/.temp.py", line 6, in <module>
print i
NameError: name ’i’ is not defined
Primjer kada ne naide na grešku:
1 j=1
2
3 if j<2:
4 print ’Help’
5 else:
6 print i
Help
Najcešce iznimke koje susrecemo su:
? ZeroDivisionError
pokušaj operacije djeljenja sa nulom
>>> 10 * (1/0)
Traceback (most recent call last):
File "<stdin>", line 1, in ?
ZeroDivisionError: integer division or modulo by zero
? NameError
pokušaj operacije sa varijablom cije ime (name) nije u popisu imena(namespace)
>>> 4 + i*3
Traceback (most recent call last):
File "<stdin>", line 1, in ?
NameError: name ’i’ is not defined
? TypeError
Pokušaj izvršavanja operacije na krivom tipu podataka
>>> ’2’ + 2
Traceback (most recent call last):
File "<stdin>", line 1, in ?
TypeError: cannot concatenate ’str’ and ’int’ objects
Postoji još mnogo iznimaka te ih je moguce pronaci na http://docs.python.org/
2/library/exceptions.html#bltin-exceptions.No, iznimkama možemo manipulirati, tj. moguce je ugraditi u kod iden-
tifikaciju greške te djelovanje sukladno tome. O tome više u slijedecem po-glavlju.
13.2 manipulacija greškama - exception handling
Iznimkama možemo manipulirati, tj. možemo prihvatiti informaciju o greškite djelovati u skladu sa njom ili granati kod tako da nastavi sa izvršavanjemunatoc greški. Razmotrimo primjer kada korisnik unosi brojeve na konzolipomocu raw_input naredbe.
1 var=raw_input(’Unesi broj:’)
2 a=int(var)
3 print a
Python vraca iznimku ValueError jer nije u stanju pretvoriti preuzetistring u cjelobrojnu vrijednost.
13.3 ispravljanje grešaka - debugging 69
Unesi broj:z
Traceback (most recent call last):
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 grešku i prihvatili iznimku poslužiti cemo se sa try- except formulacijom:
1 var = raw_input(’Unesi broj:’)
2
3 try:
4 a = int(var)
5 print ’SUCCESS’
6 except ValueError:
7 print ’Nije unešen broj!’
8 print ’Broj postavljen na defaultnu vrijednost 0.’
9 a = 0
10
11 print a
U ovom kodu izvršen je prihvat iznimke na nacin da je:
? unešena kljucna rijec try cije se tijelo prvo izvršava
? ako program ne naide na iznimku tada program preskace dio tijelakoji pripada except sekciji i nastavlja sa kodom (’print a’).
? ako program naide na iznimku u try sekciji koda tada se zaustavlja namjestu gdje je našao grešku, ne nastavlja dalje sa preostalim djelomkoda (’print SUCCESS’) vec skace na except sekciju koja odgovara iz-nimki koju je uhvatio (u ovom slucaju ValueError) te potom nastavljasa kodom (’print a’)
? ukoliko program ne naide na vrstu iznimke opisanu u except sekcijitada izbaci grešku u obliku neuhvacene iznimke (eng. unhandled excep-tion)
Pored ovog osnovnog koncepta primjene prihvata iznimaka, moguce jepodici iznimku prema korisnickoj želji te izraditi korisnicki definirane iz-nimke. Ove funkcionalnosti nadilaze osnove i citatelj je slobodan potražitiviše informacija na http://docs.python.org/2/tutorial/errors.html.
13.3 ispravljanje grešaka - debugging
Python ima modul pdb („Python DeBugger") koji pomaže kod otkrivanja iispravljanja grešaka u kodu skripte. Ako ne koristite neki specijalizirani edi-tor unutar nekog razvojnog okruženja tada je potrebno pozvati pdb modulna pocetku skripte:
1 import pdb
Na nekom kljucnom mjestu u kodu na kojem se želite zaustaviti moratestaviti naredbu:
1 pdb.set_trace()
na primjeru 13.1 može se vidjeti upotreba pdb modula.Ako koristite editor Spyder tada nije nužno pozvati pdb modul. Dovoljno
je postaviti prekide u kodu dvostrukim lijevim klikom na lijevoj strani do-kumenta i pokrenuti skriptu u Debug nacinu rada.
(Pdb)
70 greške u python kodu
Unutar pdb modula moguce je kontrolirati izvršavanje koda, a najcešce sekoriste naredbe:
? n (next) izvršava se sljedeca naredba u skripti,
? c (continue) izvrešava se ostatak skripte do sljedeceg prekida,
? s (step into) pdb ulazi u podprogram ili funkciju,
? r (return) slicno kao naredba c, ali pdb izvršava ostatak podprogramaili funkcije do izlaza iz podprograma,
? p var (print) pdb istpis stanja varijable var
? ENTER pdb izvršava zadnju naredbu koja mu je poslana,
? q (quit) zaustavlja izvršavanje skripte.
Izvorni kod 13.1: Upotreba dbg modula
1 #!/usr/bin/python
2 import pdb
3
4 pdb.set_trace()
5 a=0
6 b=1
7 c=2
8 pdb.set_trace()
9 a=b+c
10 pdb.set_trace()
11 a=b-c
12 print ’kraj’
Dio II
N U M P Y
14Z 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. UNumPy-u, dimenzije se nazivaju axes a broj dimenzija rank.
Elementi polja su indeksirani pozitivnim cijelim brojevima.NumPy polja se mogu zadavati na više nacina. Bazicno, zadavanje polja
se može podjeliti na rucni unos pomocu naredbe array te na automatskogeneriranje polja. NumPy polja mogu se automatski generirati pomocu nekeod naredbi za generiranje polja.
14.1 array
Naredba array omogucava kreiranje NumPy polja iz obicnih Python listiili tuple-ova. Prilikom kreiranja polja pomocu array naredbe, u argumentfunkcije upisuju se elementi matrice i to na nacin da svaka dimnezija za-pocinje otvornemo uglatom zagradom ([) i završava zatvorenom uglatomzagradom (]) dok su elementi razdvojeni zarezom.
Najjednostavnija sintaksa naredbe array je:array(object)
Ako je argument naredbe array tuple, onda pojedina dimenzija zapocinjei završava sa zagradama. Pri tome treba paziti da je argumnet naredbe array
samo jedan tuple (cijeli tuple mora biti u jednim zagradama). Moguce jekombinirati 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 za-
dan, elementi polja ce preuzeti minimalni tip potreban za pohranu poda-taka iz objekta object. Ovaj argument se može 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 može
biti pohranjeno na tri nacina:
? ’C’ - elementi polja ce biti poredani u memoriji na nacin da zadnjiindeks varira najbrže (C-povezani poredak)
? ’F’ - elementi polja ce biti poredani u memoriji na nacin da prvi in-deks varira najbrže (Fortran-povezani poredak)
73
74 zadavanje polja u numpy-u
? ’A’ - elementi polja nece imati definiran poredak u memoriji (C-povezaniporedak, Fortran-povezani poredak ili cak 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 ce biti povecan na nacina da ce jedinice biti dodane u shape polja.
14.2 arange
Naredba arange omogucuje kreiranje jednodimenzionalnog polja koje sa-drži aritmeticki niz definiran sa prvim clanom, zadnjim clanom te korakom.
Sintaksa naredbe je
arange(start, stop, step, type)
gdje je start pocetak niza, stop kraj niza, step korak niza a type je tippodataka sadržanih u nizu.Oprez! Prilikom
korištenjane-cjelobrojnih
koraka niza rezultatnaredbe array možebiti nekonzistentan.
U takvimslucajevima bolje je
koristiti naredbulinspace (14.3).
Svi argumennti naredbe arange osim stop su neobavezni i ukoliko nisuuneseni 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 arit-metickog niza) samo što se umjesto koraka niza zadaje broj clanova 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, endpointje opcija ukljucivanja zadnjeg elementa a retstep je opcija vracanja korište-nog 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 75
0.30612245, 0.32653061, 0.34693878, 0.36734694, 0.3877551 ,
0.40816327, 0.42857143, 0.44897959, 0.46938776, 0.48979592,
0.51020408, 0.53061224, 0.55102041, 0.57142857, 0.59183673,
0.6122449 , 0.63265306, 0.65306122, 0.67346939, 0.69387755,
0.71428571, 0.73469388, 0.75510204, 0.7755102 , 0.79591837,
0.81632653, 0.83673469, 0.85714286, 0.87755102, 0.89795918,
0.91836735, 0.93877551, 0.95918367, 0.97959184, 1. ])
>>> step
0.02040816326530612
14.4 zeros
Naredba zeros omogucava generiranje polja koje sadrži nule. Osnovna sin-taksa naredbe zeros je
zeros(shape)
gdje je shape lista koja sadrži velicine dimenzija.Osim velicine dimnezija, postoje i dodatni neobavezni argumenti za defi-
niranje tipa podataka te nacina spremanja polja u memoriju:
zeros(shape, dtype=float, order=’C’)Naredbazeros_like imadodatne argumentedtype i order.dtype omogucujenametanje tipapodataka zagenerirano polje, aako nije specificiranonda generirano poljenasljeduje tippodataka odargumenta a. orderomogucujemijenjanje rasporedaspremanja polja umemoriju.
Za generiranje polja nula može poslužiti i naredba zeros_like koja ge-nerira polje nula istih dimenzija kao neko postojece polje. Sintaksa naredbeje:
zeros_like(a)
gdje je a matrica cije dimenzije treba preuzeti.
>>> from numpy import *>>> 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 ones
Za generiranje matrice zadanih dimenzija koja sadrži jedinice koristi se na-redba ones. Sintaksa naredbe je vrlo ista kao i kod naredbe zeros:
ones(shape, dtype=float, order=’C’)Naredba ones_like
ima dodatneargumente dtype iorder kojifunkcionirajujednako kao što jeopisano za naredbuzeros_like.
Za kreiranje matrice, koja sadrži jedinice istih dimenzija kao neka posto-jeca matrice, koristi se ones_like naredba:
ones_like(a)
gdje je a matrica cije dimenzije treba preuzeti.
>>> from numpy import *>>> a = ones([2,4])
>>> print a
[[ 1. 1. 1. 1.]
[ 1. 1. 1. 1.]]
>>> b = ones([3, 2],dtype=int)
>>> print b
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 (sadrži jedinice na dijago-nali a ostalo su nule) moguce je sa naredbom eye. Potpuna sintaksa naredbeNaredba eye
omogucujegeneriranje iskljucivo
dvodimenzionalnihjedinicnih matrica.
eye je:
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 anegativna na dijagonale ispod glavne dijagonale) dok je dtype tip podatakageneriranog polja.
>>> from numpy import *>>> 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 važni u proracunu i javlja se potrebada ih se spremi u zasebnu varijablu. Naredba diag omogucuje upravo to:generira vektor koji sadrži elemenate dijagonale zadane matrice.
Sintaksa naredbe je vrlo jednostavna. Funkcija diag obavezno prima, kaoargument, matricu iz koje se želi preuzeti dijagonala. Dodatni argument,k, specificira položaj (indeks) dijagonale: 0 je glavna dijagonala, pozitivnavrijednost se odnosi na dijagonale iznad a negativna na dijagonale ispodglavne dijagonale.
diag(v, k=0)
Izvorni kod 14.1: Spremanje elemenata dijagonale matrice u vektor
1 from numpy import *2 M1 = array([[1, 2, 3],[4, 5, 6],[7, 8, 9]])
3 v1 = diag(M1)
4 v2 = diag(M1,1)
14.8 meshgrid 77
5
6 print M1
7 print v1
8 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 služi za generiranje matrice koordinata na temelju vek-tora 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 mreži 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]])
15I N F O R M A C I J E O P O L J U I I N D E K S I R A N J E
15.1 informacije o polju
Svako NumPy polje ima definiran broj dimenzija, koji se lako može provje-riti pomocu ndim atributa polja.
ndarray.ndim
ili pomocu naredbe ndim
ndim(ndarray)
gdje je ndarray numpy polje.Za svaku dimenziju, polje ima rezerviran odreden broj elemenata polja.
Broj elemenata po dimenzijma polja cini niz koji se može dobiti preko atri-buta shape
ndarray.shape
ili preko naredbe shape
shape(ndarray)
gdje je ndarray numpy polje.Ukupan broj elemenata u polju se odreduje naredbom size
size(ndarray)
ili atributom numpy polja
ndarray.size
gdje je ndarray numpy polje.
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 print M1.ndim
6 print ndim(M1)
7 print M1.shape
8 print shape(M1)
9 print M1.size
10 print size(M1)
2
2
(2, 3)
(2, 3)
6
6
15.2 indeksiranje polja
Pristupanje elementima Numpy polja vrši se pomocu indeksa na slican na-cin kao i sa listama. Indeks oznacuje poziciju elementa polja i to pomocucijelog broja pocevši od nule. Kod jednodimenzionalnih polja (vektori), vri-jednostima 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, štoznaci da je indeks zadnjeg elementa jednak ukupnom broju elemenata vek-tora umanjenom za jedan. Svaki indeks koji je jedank ili veci broju elemenatavektora je indeks nepostojeceg elementa vektora i korištenje tog indeksa ceprouzrociti grešku.>>> 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]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: index out of boundsIndeksi u jednom
paru uglatih zagrada(npr. M[2,4]) su
zapravo tuple, pa sepristupanju
odredenom elementamože vršiti i preko
tuplea indeksa (poz= (3, 1); print
M[poz]).
Indeksiranje višedimenzionalnih polja je analogno jednodimenzionalnimpoljima, za svaku dimenziju se koristi po jedan indeks. Elementima polja semože pristupati sa indeksima svake dimenzije upisanim u uglate zagrade ilisa 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 M = np.array([[ 1, 2, 3, 4, 5],
6 [ 6, 7, 8, 9, 10],
7 [11, 12, 13, 14, 15],
8 [16, 17, 18, 19, 20],
9 [21, 22, 23, 24, 25]])
10
11 print M[2, 4] # ispiši element na poziciji 2,4
12 poz = (3, 2) # definiraj poziciju 3,2
13 print M[poz] # ispiši element na poziciji poz
14
15 print M[1:-1,1:-1] # ispiši dio polja bez prvih i zadnjih redaka i stupaca
16 print M[:,::-1] # ispiši polje sa obrnutim redoslijedom stupaca
17 print M[::2] # Ispiši svaki drugi redak polja
15
18
[[ 7 8 9]
[12 13 14]
[17 18 19]]
[[ 5 4 3 2 1]
[10 9 8 7 6]
[15 14 13 12 11]
[20 19 18 17 16]
[25 24 23 22 21]]
[[ 1 2 3 4 5]
[11 12 13 14 15]
[21 22 23 24 25]]
16M A N I P U L A C I J E S A N U M P Y P O L J I M A
16.1 manipulacije sa dimenzijama polja
Elementi NumPy polja odredenih dimenzija, mogu se presložiti u NumPypolje drukcijih dimenzija. Preslagivanje polja na druge dimenzije vrši sepomocu naredbe reshape:
reshape(a, newshape, order=’C’)
gdje je a izvorno polje, newshape vektor novih dimenzija a order je nacinspremanja polja u matricu.
Uvijet za reshape je da broj elemenata polja ostane isti tj. umnožak velicinadimenzija mora biti konstantan. Ukoliko se, kod
poziva naredbereshape, velicinajedna od dimenzijane specificira, tada seona automatskiracuna na temeljuostalih velicinadimenzija i ukupnogbroja elemenatainicijalne matrice.
Specificni slucaj mijenjanja dimenzija polja je kada inicijalno polje želimotransformirati u jednodimenzionalno polje tj. vektor. Iako je to moguce na-praviti sa naredbom reshape, postoji specijelizirana naredba ravel za tran-sformaciju n-dimnezionalnih polja u jednodimenzionalna polja. Sintaksa na-redba je vrlo slicna kao i za reshape osim što nije potrebno specificirativektor velicina dimenzija jer je rezultat uvijek jednodimenzionalno polje.
ravel(a, order=’C’)
Za pretvorbu matrice u vektor koristi se i naredba flatten. Razlika je štoje 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 M1 = arange(0, 20)
4 print M1
5
6 M2 = reshape(M1, [4, 5])
7 print M2
8 M3 = reshape(M2, [2, -1])
9 print M3
10
11 print ravel(M2)
12 print M3.flatten()
[ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19]
[[ 0 1 2 3 4]
[ 5 6 7 8 9]
[10 11 12 13 14]
[15 16 17 18 19]]
[[ 0 1 2 3 4 5 6 7 8 9]
[10 11 12 13 14 15 16 17 18 19]]
[ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19]
[ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19]
Brisanje jedinicnih dimenzija matrice, koje vrlo cesto znaju biti suvišne,može se napraviti funkcijom squeeze.
Izvorni kod 16.2: Mijenjanje dimenzija polja
1 from numpy import *
81
82 manipulacije sa numpy poljima
2
3 M1 = arange(0, 20)
4
5 M2 = reshape(M1, [4, 1, 1, 5])
6 print M2.shape
7
8 M3 = squeeze(M2)
9 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 M1 = array([
4 [1, 0, 3, 4],
5 [2, 2, 7 ,8],
6 [6, 8, 3, 0],
7 [9, 8, 2, 1]])
8
9 M2 = M1.T
10 print M2
11
12 M3 = transpose(M1)
13 print M3
[[1 2 6 9]
[0 2 8 8]
[3 7 3 2]
[4 8 0 1]]
[[1 2 6 9]
[0 2 8 8]
[3 7 3 2]
[4 8 0 1]]
16.3 dodavanje i brisanje elemenata polja
17U C 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
Vrlo se cesto dešava da se rezultati raznih proracuna ili mjerenja spremaju utekstualne datoteke. Takve datoteke, svaka zapisana u svom formatu cestose ucitavaju u Python za daljnju obradu, vizualizaciju ili provjeru. Numpypruža gotove funkcije za automatizirano ucitavanja tablicnih podataka uNumPy polja.
Jednako bitno je i mogucnost spremanja podataka iz NumPy polja u tek-stualne datoteke.
Osim tekstualnih datoteka, ucitavanje i spremanje NumPy polja moguceje i sa binarnim datotekama.
17.1 ucitavanje iz tekstualnih datoteka
Ucitavanje numerickih vrijednosti iz tekstualnih datoteka u numpy poljavrši se sa naredbom loadtxt. Podrazumijeva se da su brojevi u tekstualnojdatoteci 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 po-cetnih redaka te odabir stupaca za ucitavanje i dr.
Sintaksa naredbe sa najcešce korištenim argumentima je: Zadana vrijednostargumentadelimiter je Nonešto znaci da se redakdijeli na temeljurazmaka(podrazumijeva itabulatore) i višeuzastopnih razmakasmatra kao jedanrazmak.
loadtxt(fname, comments, delimiter, skiprows, usecols)
gdje je fname ime datoteke iz koje se ucitavaju podaci, comments je simbolkojim zapocinju pasivni retci (komentari), delimiter je simbol(i) kojim surazdvojene vrijednosti u retcima, skiprows je broj pocetnih redaka koji sepreskacu prilikom ucitavanja a usecols je lista indeksa stupaca koji se ucita-vaju.
Izvorni kod 17.1: Sadržaj datoteke data.txt
1 Tehnicki fakultet
2 Zavod za mehaniku fluida i racunarko inženjerstvo
3
4
5 1 8.14 28.72 -0.12 126.04 5
6 2 8.37 26.79 -0.47 130.96 9
7 3 4.41 26.55 -0.44 125.82 2
8 4 6.74 22.48 -0.55 133.24 0
9 5 5.30 24.30 -0.70 137.91 9
10 * ovo je komentar
11 6 6.11 22.14 -0.87 102.43 7
12 7 2.10 25.96 -0.90 137.88 2
13 *8 7.40 24.40 -0.03 122.03 1
14 9 0.07 22.04 -0.73 143.81 2
15 10 8.45 23.07 -0.47 137.48 0
16 11 2.91 22.07 -0.07 116.26 6
17 12 9.14 20.70 -0.10 132.36 9
18 13 7.62 23.83 -0.51 111.39 1
Izvorni kod 17.2: Ucitavanje iz tekstualne datoteke
1 # -*- coding: utf-8 -*-
2
3 from numpy import *
83
84 ucitavanje i spremanje numpy polja
4
5 M = loadtxt(’data.txt’, skiprows=4, comments=’*’, usecols=(1, 3, 5))
6 print M
[[ 8.14 -0.12 5. ]
[ 8.37 -0.47 9. ]
[ 4.41 -0.44 2. ]
[ 6.74 -0.55 0. ]
[ 5.3 -0.7 9. ]
[ 6.11 -0.87 7. ]
[ 2.1 -0.9 2. ]
[ 0.07 -0.73 2. ]
[ 8.45 -0.47 0. ]
[ 2.91 -0.07 6. ]
[ 9.14 -0.1 9. ]
[ 7.62 -0.51 1. ]]
Naprednije mogucnosti pri ucitavanju NumPy polja iz tekstualnih dato-teka pruža 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 tekstu-alne datoteke.
savetxt(fname, X, fmt, delimiter, newline, header, footer, comments)
18M AT R I C N I R A C U N
18.1 rješavanje sustava linearnih jednadžbi
Za rješavanje sustava linearnih jednadžbi
A · x = b (18.1)
koristi se NumPy naredba solve:
solve(a, b)
gdje je a matrica sustava a b vektor slobodnih clanova.
Izvorni kod 18.1: Rješavanje sustava linearnih jednadžbi
1 from numpy import *2
3 A = array([
4 [ 1.0, 3.0, 6.0],
5 [-2.0, 0.0, 3.0],
6 [ 8.0, -2.0, 0.0]
7 ])
8 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
19R A D S A P O L I N O M I M A
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 na-
cina. 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 može dobiti sa
p.r
p.roots
Evaluacija polinoma p u danoj tocki a može se vršiti kao
p.(a)
gdje a može biti broj ili ndarray.
Izvorni kod 19.1: Zadavanje polinoma kao poly1d objekta
1 # -*- coding: utf-8 -*-
2 """
3 Created on Sat Nov 29 22:21:54 2014
4
5 @author: stefan
6 """
7
8 import numpy as np
9 import matplotlib.pyplot as plt
10
11 # Zadavanje polinoma preko koeficijenata
12 p1 = np.poly1d([ 1., -8.3, 1.7, 5.6])
13 print ’p1:’
14 print p1
15
16 # Zadavanje polinoma preko korijena
17 p2 = np.poly1d([-3, -1.02, 6.75], True)
18 print ’\np2:’
19 print p2
20
21 # Koeficijenti polinoma
22 print ’\nKoeficijetni:’
23 print p1.c
24 print p2.coeffs
25
26 # Korijeni polinoma
27 x01 = p1.r
28 x02 = p2.roots
29 print ’\nKorijeni:’
30 print x01
87
88 rad sa polinomima
31 print x02
32
33 x = np.linspace(-6, 10, 200)
34 y1 = p1(x)
35 y2 = p2(x)
36
37 plt.plot(x, y1, c = ’r’, label = ’p1’)
38 plt.plot(x, y2, c = ’b’, label = ’p2’)
39 plt.plot(x01, np.zeros_like(x01), ’ro’, label = ’Korijeni p1’)
40 plt.plot(x02, np.zeros_like(x02), ’bo’, label = ’Korijeni p2’)
41 plt.grid()
42 plt.legend(loc = ’best’)
43 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 5.6]
[ 1. -2.73 -24.075 -20.655]
Korijeni:
[ 8. 1. -0.7]
[ 6.75 -3. -1.02]
6 4 2 0 2 4 6 8 10600
400
200
0
200
400
600
p1p2Korijeni p1Korijeni p2
Slika 19.1: Graf polinoma iz primjera 19.1
Dio III
P R I P R E M A , O B R A D A I V I Z U A L I Z A C I J AP O D ATA K A
20O S N O V N I 2 D G R A F O V I
Terminologija:
? Figure = prozor
? Axes = prostor crtanja
? Axis = osi
Prozor
Prostor crtanja Prostor crtanja
Os y
Os x
Os y
Os x
Slika 20.1: Matplotlib elementi
20.1 linijski grafovi
Osnovna naredba u matplotlibu je plot i služi za crtanje grafova pomoculinija ili tocaka. Osnovna sintaksa naredbe je
plot(y)
plot(x, y)
gdje su x i y vektori koordinata tocaka koje želimo vizualizirati. U slucaju davektor x koordinata nije zadan, koristi se uniformni vektor [0, 1, 2, ...,
n] gdje je n broj clanova vektora y. U slucaju da su zadani i vektor x i vektory, tada oni moraju imati isti broj clanova.
Više uzastopnih plot naredbi ce nacrtati više linija na istom grafu. Na-redba plot ne prikazuje graf, graf se iscrtava na ekranu pozivom funkcijeshow.
Izvorni kod 20.1 kreira dva linijska grafa koristeci naredbu plot a potom,naredbom show, graf prikaže na ekranu (Slika 20.2)
Izvorni kod 20.1: Jednostavan graf
1 from pylab import *2 from numpy import *3
4 plot([3, 6, 3, 2, 4])
5
91
92 osnovni 2d grafovi
6 x = linspace(0, 4, 100)
7 y = 5*cos(x)/(1 + x**2)
8 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 imarkera pomocu znakova. Znakovi za definiranje vrste linije, boje linije tevrste markera kombiniraju se u stringu koji se prosljeduje funkciji plot.Simboli za definiranje vrste linije, boje linije i vrste markera prikazani suu tablicama 20.1, 20.2 i 20.3. Simboli se mogu kombinirati u proizvoljnomredoslijedu. Ako je izostavljen simbol za boju, primjenjuje se zadana vrijed-nost boje. Markeri se ne prikazuju izostavljanjem simobla za vrstu markera.Izostavljanjem simbola za vrstu linije, ako je zadana vrsta markera linija sene 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 93
Simbol Boja
’b’ Plava
’r’ Crvena
’g’ Zelena
’c’ Cijan
’m’ Magenta
’y’ Žuta
’k’ Crna
’w’ Bijela
Tablica 20.2: Simboli boja
Detaljnije i fleksibilnije definiranje boja opisano je u poglavlju (20.2.1).
Simbol Vrsta markera
’.’ Tockasti
’,’ Piksel
’o’ Kružni
’v’ Trokutasti prema dolje
’ˆ’ Trokutasti prema gore
’<’ Trokutasti prema lijevo
’>’ Trokutasti prema desno
’s’ Kvadratni
’p’ Peterokutni
’*’ Zvijezdasti
’h’ Šesterokutni 1
’H’ Šesterokutni 2
’+’ Plus
’x’ Križic
’D’ Romb
’d’ Tanki romb
’|’ Vertikalna linija
’_’ Horizontalna linija
Tablica 20.3: Vrste markera
U izvornom kodu 20.2 upotrebljene su razlicite varijante linija, markera iboja (Slika 20.3).
Izvorni kod 20.2: Kontrola linija i markera
1 from pylab import *2 from numpy import *3
4 plot([1, 6, 3, 2, 4], ’r--o’)
5 plot([3, 2, 1, 3, 1], ’g-.D’)
6 plot([2, 3, 5, 6, 2],’r-.x’)
7 plot([5, 4, 2, 4, 5],’ks:’)
8
9 show()
94 osnovni 2d grafovi
0.0 0.5 1.0 1.5 2.0 2.5 3.0 3.5 4.01
2
3
4
5
6
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 sadodatnim parametrima naredbe plot.
20.2.1 Boje
Argumentom color (ili skraceno c) moguce je preciznije definirati boju li-nije:
plot(x, y, color = gray_string)
plot(x, y, color = hex_string)
plot(x, y, color = rgb_tuple)
plot(x, y, color = 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 sadrži HTML naziv boje (npr. color=’Cyan’,color=’Crimson’)
20.2.2 Markeri
Izgled markera se može detaljnije specificirati pomocu više parametara na-redbe plot:
20.2 naprednija kontrola linijskih grafova 95
? 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 licamarkera,
? markerevery za definiranje koliko tocaka ce biti prikazane (npr. svakapeta).
1 plot(x, y, markeredgecolor = ’r’, # Boja ruba markera - crvena
2 markeredgewidth = 2, # Debljina ruba
3 markerfacecolor = ’b’, # Boja lica - plava
4 markerfacecoloralt = ’g’, # Izmjenjujuca boja lica - zelena
5 markersize = 4, # Velicina markera
6 markerevery = 5) # Crtaj svaki peti marker
Argumentom label omogucuje se oznaka tj. opis krivulje, koji se prika-zuje u legendi grafa.
U izvornom kodu 20.3 upotrebljene su razlicite varijante linija, markera iboja (Slika 20.4).
Izvorni kod 20.3: Naprednija kontrola linija i markera
1 from pylab import *2 from numpy import *3
4 X = np.linspace(-np.pi, np.pi, 256,endpoint=True)
5 C,S = np.cos(X), np.sin(X)
6 X2=[-3, -2, -0.5, 1.2, 2.8]
7 Y2=[0.3, 0.9, 0.5, 0.1, 0.62]
8 plot(X, C, color="blue", linewidth=2.5, linestyle="-")
9 plot(X, S, color="red", linewidth=2.5, linestyle="-")
10 plot(X2, Y2, color="green", linestyle="-", marker="o", markersize=10)
11 show()
96 osnovni 2d grafovi
4 3 2 1 0 1 2 3 41.0
0.5
0.0
0.5
1.0
Slika 20.4: Graf napravljen izvodenjem izvornog koda 20.3
20.3 svojstva prozora , prostora crtanja i osi
Stvaranje prvogprozora nije nužno.Naredbe za crtanjegrafova (npr. plot)
same ce kreiratiprozora ako vec ne
postoji.
Novi prozor se stvara pomocu funkcije figure, koja vraca handle na prozora po potrebi može primati dodatne argumente
figure()
fig1 = figure()
fig1 = figure(figsize = (12, 10), dpi = 300)
Dva argumenta koji se najcešce koriste su figsize i dpi. figsize primatuple koji specificira širinu i visinu prozora u incima a pomocu argumentadpi (dots per inch) regulira se rezolucija koja je posebno bitna kod spremanjagrafova u raster format ili pri spremanju animacija u video format.
Naredbama xlabel i ylabel moguce je dodati naslove osi. Sintaksa objenaredbe je identicna:
xlabel(’Opis x osi’)
ylabel(’Opis y osi’)
Naredbama xlim i ylim odreduju se granice intervala koji se prikazuje naprostoru crtanja. Sintaksa naredbe je:
xlim( (xmin, xmax) )
xlim( xmin, xmax )
Dodaju li se izvornom kodu 20.3 sljedece linije,
1 xlim(X.min()*1.1, X.max()*1.1)
2 ylim(C.min()*1.1, C.max()*1.1)
moguce je dobiti sljedeci rezultat:
20.3 svojstva prozora , prostora crtanja i osi 97
3 2 1 0 1 2 3
1.0
0.5
0.0
0.5
1.0
Slika 20.5: Izmijenjene granice grafa
1 xlim(0, 5) # Donja i gornja granica
2 ylim(ymax=1) # Samo gornja granica
3 ylim(ymin=-1) # Samo donja granica
Moguce je promijeniti i ticks. U slucaju da je potrebno i izvornom kodu20.3 prikazati vrijednosti od x os od −π do π s korakom od π/2 i y os od -1od 1 s korakom od 1, potrebno je dodati sljedece linije:
1 xticks( [-np.pi, -np.pi/2, 0, np.pi/2, np.pi])
2 yticks([-1, 0, +1])
Rezultat je prikazan na sljedecoj slici.
98 osnovni 2d grafovi
3.142 1.571 0.000 1.571 3.142
1
0
1
Slika 20.6: Custom ticks
Još je potrebno promijeniti oznake na osima:
1 xticks([-np.pi, -np.pi/2, 0, np.pi/2, np.pi],
2 [r’$-\pi$’, r’$-\pi/2$’, r’$0$’, r’$+\pi/2$’, r’$+\pi$’])
3 yticks([-1, 0, +1],
4 [r’$-1$’, r’$0$’, r’$+1$’])
što rezultira sljedecim grafom:
−π −π/2 0 +π/2 +π
−1
0
+1
Slika 20.7: Custom ticks
U nekim situacijama je korisno pomaknuti osi:
20.3 svojstva prozora , prostora crtanja i osi 99
1 ax = gca()
2 ax.spines[’right’].set_color(’none’)
3 ax.spines[’top’].set_color(’none’)
4 ax.xaxis.set_ticks_position(’bottom’)
5 ax.spines[’bottom’].set_position((’data’,0))
6 ax.yaxis.set_ticks_position(’left’)
7 ax.spines[’left’].set_position((’data’,0))
−π −π/2 0 +π/2 +π
−1
0
+1
Slika 20.8: Spines
Oznake na osima su prekrivene linijama s(Slika 20.8) te ih je potrebno uciniticitljivijima:
1 for label in ax.get_xticklabels() + ax.get_yticklabels():
2 label.set_fontsize(16)
3 label.set_bbox(dict(facecolor=’white’, edgecolor=’None’, alpha=0.65))
100 osnovni 2d grafovi
−π −π/2 0 +π/2 +π
−1
0
+1
Slika 20.9: Formatiranje oznaka na osima
Ukljucivanje i iskljucivanje mreže pomocnih linija na prostoru crtanja vršise naredbom grid.
grid(b=None, which=’major’, axis=’both’, **kwargs)
b je argument kojim se kontrolira da li se iskljucuje ili ukljucuje mreža po-mocnih linija i može poprimiti vrijednosti true ili false ali i ’on’ ili ’off’(kao i MATLAB). which može biti ’major’, ’minor’ ili ’both’ i služi za kon-trolu glavne ili sporedne mreže pomocnih linija. Argumentom axis konto-rilra se za koje ce osi biti postavljena mreža pomocnih linija. Vrijednosti zaaxis mogu biti ’both’, ’x’ ili ’y’.grid može primati dodatne argumente za detaljniju kontrolu mreže po-
mocnih linija:
1 grid(color=’k’, linestyle=’:’, linewidth=0.2)
Dodavanje naslova na prostor crtanja vrši se naredbom title:
title(’Text naslova’)
Prikazivanje legende na na prostoru crtanja vrši se pomocu naredbe legenduz prethodno definirane opise krivulja (label).
legend()
Ako u prethodno nacrtanim grafovima nije specificiran label, legenduse može napraviti i pomocu handleova na plotove. U tom slucaju, funkcijalegend 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 pro-zoru. Vrijednosti koje se daju argumentu loc mogu biti cijeli brojevi ili strin-govi koji specificiraju poziciju legende na prozoru (Tablica 20.4).
20.4 spremanje grafova 101
Pozicija Broj String
Gore desno 1 ’upper right’
Gore lijevo 2 ’upper left’
Dolje lijevo 3 ’lower left’
Dolje desno 4 ’lower right’
Desno 5 ’right’
Na sredini lijevo 6 ’center left’
Na sredini desno 7 ’center right’
Dolje u sredini 8 ’lower center’
Gore u sredini 9 ’upper center’
U sredini 10 ’center’
Tablica 20.4: Pozicija legende
Izvorni kod 20.4: Prikaz legende na grafu
1 from pylab import *2 from numpy import *3
4 x = linspace(0, 10, 100)
5 y1 = sin(x)
6 y2 = cos(x)
7
8 figure(1, [8, 2])
9 plot(x, y1, label=’sinus’)
10 plot(x, y2, label=’kosinus’)
11 legend(loc=’upper center’) # Postavlja legendu gore na sredinu
12 show()
0 2 4 6 8 101.0
0.5
0.0
0.5
1.0
sinuskosinus
Slika 20.10: Prikaz legende na grafu
20.4 spremanje grafova
20.5 podgrafovi
Podgrafovi omogucavaju postavljanje grafova u mrežu grafova. Potrebno jespecificirati broj redaka i stupaca.
Izvorni kod 20.5: Primjer crtanja podgrafova
1 from pylab import *2 from numpy import *3 def myticks():
4 xticks([-np.pi, -np.pi/2, 0, np.pi/2, np.pi],
5 [r’$-\pi$’, r’$-\pi/2$’, r’$0$’, r’$+\pi/2$’, r’$+\pi$’])
6 yticks([-1, 0, +1],
7 [r’$-1$’, r’$0$’, r’$+1$’])
102 osnovni 2d grafovi
8
9 X = np.linspace(-np.pi, np.pi, 256,endpoint=True)
10 C,S = np.cos(X), np.sin(X)
11
12 figure(1)
13 subplot(211)
14 plot(X, C, color="blue", linewidth=2.5, linestyle="-")
15 myticks()
16 subplot(212)
17 plot(X, S, color="red", linewidth=2.5, linestyle="-")
18 myticks()
19
20 show()
−π −π/2 0 +π/2 +π−1
0
+1
−π −π/2 0 +π/2 +π−1
0
+1
Slika 20.11: Podgrafovi nastali izvršavanjem izvornog koda 20.5
Podgrafovi se iscrtavaju u slici (figure) koja se sastoji od dva grafa. Na-redba subplot definira broj redaka, broj stupaca i broj grafa, koji mora bitibroj 1 < fignum < numrows ∗numcols. Varijable ne moraju biti odvojenezarezom ako vrijedi numrows ∗ numcols < 10. Odnosno, subplot(211) jeekvivalentan izrazu subplot(2,1,1).
20.6 polarni grafovi
Izvorni kod 20.6: Primjer crtanja grafa u polarnom koordinatnom sustavu
1 from pylab import *2 from numpy import *3
4 fig = figure(figsize=[8,8])
5 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 r = arange(0,1,0.001)
10 theta = 2*2*pi*r
20.7 tips and tricks 103
11
12 ax.plot(theta,r, lw=2)
13 grid(True)
14 show()
0°
45°
90°
135°
180°
225°
270°
315°
0.2
0.4
0.6
0.8
1.0
Slika 20.12: Graf u polarnom koordinatnom sustavu
20.7 tips and tricks
Use matplotlib’s calls that won’t block:Using draw():
1 from matplotlib import plot, draw, show
2 plot([1,2,3])
3 draw()
4 print ’continue computation’
5
6 # at the end call show to ensure window won’t close.
7 show()
Using interactive mode:
1 from matplotlib import plot, ion, show
2 ion() # enables interactive mode
3 plot([1,2,3]) # result shows immediatelly (implicit draw())
4
5 print ’continue computation’
6
7 # at the end call show to ensure window won’t close.
8 show()
21S L O Ž E N I J I 2 D G R A F O V I
21.1 izolinije
Prilikom vizualizacije ovisnosti funkcije (ili podataka) o dvije varijable (2D)cesto se koriste izolinije. Izolinije su krivulje koje povezuju tocke iste (ska-larne) vrijednosti.
Izolinija je skup rješenja jednadžbe
f(x,y) = ci (21.1)
gdje je ci konstanta za koju se odreduje izolinija. Ako za dani ci postoji rje-šenje jednadžbe (21.1), to rješenje predstavlja jednu ili više krivulja u ravninix− y. Za više parametara c = (c1, c2, ..., cn) dobiva se familija krivulja kojesluže za 2D vizualizaciju funkcija dvije varijable.
Matplotlib nudi mogucnost naprednog uredivanja i kontrolabilnost izoli-nijskih grafova. Funkcija contour služi za crtanje izolinija a countourf zabojanje površina izmedu izolinija.matplotlib.pyplot.contour
matplotlib.pyplot.contourf
Obje navedene funkcije imaju identicnu osnovnu sintaksu, a razlikuju seu svega nekoliko argumenta koji su specificni za stiliziranje linija odnsnobojanje ploha.
U najjednostavnijoj varijanti, funkcije primaju jedan argumenti i to ma-tricu Z na temelju cijih vrijednosti se crtaju izolinije i plohe. Razmaci izmeduredaka i stupaca su jednaki 1 a broj izolinija se odreduje automatski.matplotlib.pyplot.contour(Z)
matplotlib.pyplot.contourf(Z)
Broj nivo linija se može specificirati cijelim brojem n ili se mogu odreditiželjene vrijednosti pomocu vektora V za koje ce se crtati izolinije.matplotlib.pyplot.contour(Z, n)
matplotlib.pyplot.contourf(Z, n)
matplotlib.pyplot.contour(Z, V)
matplotlib.pyplot.contourf(Z, V)
Razmaci izmedu stupaca i redaka mogu se zadati pomocu matrica X i Y: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 sadrže x i y kordinate pripadajucih elemenata u matrici Z te svetri matrice moraju biti istog oblika/dimenzija. Za jednostavljeno kreiranjetakvih 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 inter-vala [0, 1] pretvara u RGBA (Red, Green, Blue, Alpha) specifikaciju boje kojomse definira udio crvene, zelene i plave boje te prozirnost.
105
106 složeniji 2d grafovi
Mapiranje boja se odvija u dva koraka: podaci koje treba vizualizirati suprvo 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 sadrži unaprijed definirane mape boja koje se nalaze u matplo-tlib.pyplot.cm modulu (Slika 21.1).
Accent Blues
BrBG BuGn
BuPu CMRmap
Dark2 GnBu
Greens Greys
OrRd Oranges
PRGn Paired
Pastel1 Pastel2
PiYG PuBu
PuBuGn PuOr
PuRd Purples
RdBu RdGy
RdPu RdYlBu
RdYlGn Reds
Set1 Set2
Set3 Spectral
YlGn YlGnBu
YlOrBr YlOrRd
afmhot autumn
binary bone
brg bwr
cool coolwarm
copper cubehelix
flag gist_earth
gist_gray gist_heat
gist_ncar gist_rainbow
gist_stern gist_yarg
gnuplot gnuplot2
gray hot
hsv jet
nipy_spectral ocean
pink prism
rainbow seismic
spectral spring
summer 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 mapeboja.
21.1.2 Detaljnije podešavanje grafa izolinija
Podešavanje boja u grafovima izolinija moguce je se keyword argumentomcolors u contour i contourf funkcijama. U funkciji contour boje se aplici-raju na izolinije a u funkciji contourf boje se apliciraju na površine izmeduizolinija.
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 površine iz-medu izolinija.
21.1 izolinije 107
? colors = [’r’, ’g’, ’b’], postavlja se lista (ili tuple) boja. Boje izliste se ponavljaju, ako ima više izolinija nego specificiranih boja.
Pojedinu boju ili boju u listi se može zadavati na više nacina, kao što jeopisano u poglavlju (20.2.1).
Kada u istom prostoru crtanja postoji više grafova, bolja vidljivost svihgrafova se postiže prozirnošcu. Prozirnost izolinija ili površina izmedu njihpostavlja se pomocu keyword argumenta alpha. alpha može primiti deci-malni broj sa intervala [0, 1] gdje je 0 potpuno prozirno (nevidljivo) a 1 jepotpuno neprozirna boja.
21.1.3 Primjer
Izvorni kod 21.1: Primjer vizualizacije izolinija
1 # -*- coding: utf-8 -*-
2 import numpy as np
3 import matplotlib.pyplot as pl
4
5 # Definiranje funckije
6 def f(x,y):
7 return (1 - np.sin(x) - np.sin(y)**3) * np.exp(-np.cos(x) -np.sin(y)**2)
8
9 # Gustoca vizualizacijskih tocaka (po svakoj dimenziji)
10 n = 256
11
12 # Diskretizacija
13 x = np.linspace(-4, 0, n)
14 y = np.linspace(-3, 1, n)
15 X,Y = np.meshgrid(x, y)
16
17 # Ukljucivanje mreže pomocnih linija
18 pl.grid()
19
20 # Crtanje površina izmedu izolinija
21 # 8 - broj izolinija, alpha - prozirnost, cmap - kolormapa
22 Cf = pl.contourf(X, Y, f(X, Y), 8, alpha=.75, cmap=pl.cm.jet)
23
24 # Crtanje izolinija
25 # colors - boja linija, linewidth - debljina linija
26 Cl = pl.contour(X, Y, f(X, Y), 8, colors=’black’, linewidth=.5)
27
28 # Dodavanje oznaka na izolinije
29 pl.clabel(Cl, inline=1, fontsize=10)
30
31 pl.show()
108 složeniji 2d grafovi
4.0 3.5 3.0 2.5 2.0 1.5 1.0 0.5 0.03.0
2.5
2.0
1.5
1.0
0.5
0.0
0.5
1.0
0.000
0.500
0.500
1.0
00
1.000
1.50
0
2.0002.5
00
2.500
3.000
3.00
0
3.500
Slika 21.2: Graf napravljen izvodenjem izvornog koda 21.1
22I Z R A D A A N I M A C I J A
Izvorni kod 22.1: Jednostavan primjer animacije
1 # -*- coding: utf-8 -*-
2 """
3 Nelder-Mead metoda
4 """
5
6 import numpy as np
7 import matplotlib.pyplot as plt
8 from matplotlib import animation
9
10 fig = plt.figure()
11 linija, = plt.plot([], [], ’-o’)
12 plt.xlim([0, 10])
13 plt.ylim([-1, 1])
14
15
16 def init():
17 linija, = plt.plot([], [], ’-o’)
18
19 return linija
20
21 def draw_frame(it):
22
23 xline = np.linspace(0.0,10.0,50)
24 yline = np.sin(xline + it/10.0)/(1.0 +xline**2.0)
25 linija.set_data(xline, yline)
26
27 return linija
28
29 Writer = animation.writers[’ffmpeg’]
30 writer = Writer(fps=5, metadata=dict(artist=’sim.riteh.hr’), bitrate=3600)
31
32 anim = animation.FuncAnimation(fig, draw_frame, init_func=init,
33 frames=500, interval=2, repeat=False)
34
35 anim.save(’nelder-mead.avi’, writer=writer)
36 plt.show()
109
Dio IV
N U M E R I C K E M E T O D E
23R 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 rješavnje nelinearnih jednadžbi (eng. root finding)je odrediti nultocku neprekidne realne funkcije f : R → R to jest riješitijednadžbu
f(x) = 0. (23.1)
Moguce je da funkcija f ima više realnih nultocaka i da su neke višestruke.Takoder, funkcija f možda uopce nema realnih nultocaka.
Ako za neprekidnu funkciju vrijedi
f(a) f(b) 6 0
tada funkcija na intervalu [a,b] mijenja predznak pa postoji barem jednanultocka na odabranom intervalu. Ako je poznato da je funkcija i monotonana intervalu [a,b] tada je nultocka jedinstvena.
Osnovni korak numerickih metoda je separirati jedan korijen ξ jednadžbe(23.1). Nakon što smo izolirali jedno rješenje, nekom odabranom numeric-kom metodom formiramo niz aproksimacija xi → ξ. Numericku metoduzaustavljamo kada je zadovoljen zadani kriterij tocnosti
|ξ− xi| < ε.
Postoji više numerickih metoda za rješavanje nelinearnih funkcija, a neko-liko najznacajnijih ce biti obradeno u ovom poglavlju. Numericke metode serazlikuju po stabilnosti, nacinu primjene i brzini konvergencije (red konver-gencije).
Definicija 23.1Neka niz (xi), dobiven nekom iterativnom metodom, konvergira prema ξ Akopostoje dvije pozitivne konstante C, r takve da vrijedi
limi→∞ |ξ− xi+1|
|ξ− xi|r6 C
tada kažemo da metoda ima red konvergencije r.
S obzirom na red konvergencije r, iterativna numericka metoda konver-gira:
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 rješavnju jednadžbe f(x) = 0 na intervalu[xl, xd] koristeci ogradivanje (eng. bracketing) Da bi se metoda mogla primje-niti, funkcija f(x) mora biti neprekidna te mora vrijediti f(xl) · f(xd) 6 0.
113
114 rješavanje nelinearnih jednadžbi
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 korakuracuna vrijednost funkcije na polovici intervala.
xs =xl + xd2
Na temelju vrijednosti funkcije u rubnim tockama te u centralnoj tocki,odreduje se novi, dvostruko uži, interval. Ako je f(xl) · f(xs) < 0 tada jex0 ∈ [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,tada je pronaden traženi korijen funkcije.
x
f(x)
xl
xd
f(x)
Slika 23.1: Skica metode biskecije
Metoda biskecije, ako su navedeni uvjeti zadovoljeni, ce sigurno konvergi-rati u jedan od korijena funkcije f(x) na intervalu [xl, xd]. Apsolutna greškase prepolavlja u svakom koraku iteracije pa metoda konvegira linearno, štoje, 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 traži korijenfunkcije.optimize.bisect
poziva_zeros._bisect,
koja jeimplementirana u
C-u.
Dodatni argumenti omogucuju kontrolu i pregled konvergencije:
args=()
xtol=1e-12
rtol=4.4408920985006262e-16
maxiter=100
full_output=False
disp=True
gdje je xtol apsolutna tolerancija, rtol relativna tolerancija, maxiter maksi-malni broj iteracija, full_output omogucuje dohvacanje dodatnih informa-cija o konvergenciji i disp omogucuje podizanje RuntimeError u slucaju dametoda ne konvergira.
Izvorni kod 23.1: Primjer pronalaženja nultocke funkcije metodom biskecije
1 #!/usr/bin/python
2 import scipy.optimize as optimize
3 from numpy import cos
4
5 def f(x):
23.2 newton-raphsonova metoda 115
6 return cos(x)**2 + 6 - x
7
8 # 0<=cos(x)**2<=1, so the root has to be near x=7
9 x0, S = optimize.bisect(f,6,8,full_output=True)
10 print x0
11 print S.iterations
12 print S.function_calls
6.77609231632
41
43
23.2 newton-raphsonova metoda
Za razliku od nelinearne funkcije, traženje nultocke linearne funkcije je bitnolakši zadatak. Osnovna ideja Newton-Raphsonove metode je lokalna aprok-simacija nelinearne funkcije f(x) najboljom linearnom aproksimacijom. Akoje poznata derivacija funkcije f(x) tada je u blizini x1 moguce funkciju f(x)aproksimirati tangentom
f(x) ≈ T(x) = f(x1) + f ′(x1)(x− x1).
x1 je pocetna aproksimacija nultocke, a x0− f(x1)/f ′(x1) (nultocka tangenteT(x)) bi trebala biti bolja aproksimacija nultocke. Niz aproksimacija
xi+1 = xi −f(xi)
f ′(xi)(23.2)
bi trebao konvergirati nultocki funkcije f(x). . Za ovu iterativnu metodu po- Newthon-Raphsonova metodaje poznata i kaoNewtonova metodaili metoda tangente
trebno je zadati dobru pocetnu aproksimaciju nultocke i derivaciju funkcije(Slika 23.2).
x
y
x1
f(x)
x2x3 x4
Slika 23.2: Newton-Raphsonova metoda
Osnovna sintaksa:
newton(func, x0, fprime)
gdje je func funkcija, x0 pocetna aproksimacija nultocke i fprime prva deri-vacija funkcije (zadaje se kao funkcija). Dodatni argumenti omogucuju kon-trolu i konvergencije:
args=()
tol=1e-12
maxiter=100
fprime2=None
116 rješavanje nelinearnih jednadžbi
gdje je tol apsolutna tolerancija, maxiter maksimalni broj iteracija i fprime2je druga derivacija funkcije koja omogucuje ubrzanje konvergencije.
Izvorni kod 23.2: Primjer pronalaženja nultocke funkcije metodom tangente
1 from scipy import optimize
2
3 def fun(t):
4 return t**2-2
5 def fprim(t):
6 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 bržaod metode bisekcije, ali je bisekcija stabilnija i robusnija. Iz jednadžbe (23.2)može se zakljuciti da ce Newton-Raphsonova metoda biti nestabilna kadaje f ′(x) ≈ 0 odnosno kada je tangenta skoro horizontalna. Takoder, f ′(x) umnogim slucajevima nije poznata ili je vrlo zahtjevna za racunanje.
23.3 metoda sekante
Kada derivacija funkcije nije poznata tada je moguce modificirati metodutangente na nacin da se funkcija f(x) aproksimira nekom sekantom kojadobro aproksimira tangentu. U tom slucaju moraju se zadati dvije pocetneaproksimacije nultocke funkcije, ali derivacija funkcije nije potrebna jer jemoguce aproksimirati derivaciju:
f(x) ≈ S(x) = f(x2) +f(x2) − f(x1)
x2 − x1(x− x2).
Odnosno moguce je formirati niz aproksimacija
xi+1 = xi −f(xi)(xi − xi−1)
f(xi) − f(xi−1). (23.3)
Osnovna sintaksa:
newton(func, x0)
gdje je func funkcija, a x0 pocetna aproksimacija.Metoda sekante je nešto sporija od metode tangenete, ali je ipak znatno
brža od bisekcije. Kažemo da sekanta konvergira superlinearno. Takoder,metoda sekante postaje nestabilna u slucaju kada je sekanta skoro horizon-talna.
23.4 brentova metoda
Osnovna sintaksa:
brent(func, a, b)
23.5 zadaci 117
23.5 zadaci
Zadatak 23.1 Lopta (sfera) je uronjena u vodu i postiže stanje ravnoteže.
Volumen uronjenog dijela lopte iznosi
V(H) =
∫H0πr(h)2dh
V(H) =
∫H0R2 − (h− R)2dh =
∫H02Rh− h2dh
V(H) = RH2 −H3
3
Uzgon koji daje uronjeni dio lopte iznosi
U(H) = V(H) · ρ · g
U stanju ravnoteže, uzgon je jednak težini lopte.
U(H) = m · g
RH2 −H3
3= m · g
Lopta mase m = 0.4kg i promjera R = 0.22m stavljena je u vodu gustoceρ = 1024kg/m3. Koliko ce lopta biti uronjena (u stanju ravnoteže)?
24I N T E R P O L A C I J E
Cesto se javlja potreba da na temelju nepotpunih ili rijetkih podataka trebaprocjeniti odnosno izracunati vrijednosti u željenim tockama. Interpolacija jemetoda konstrukcije novi tocaka unutar raspona diskretnog skupa poznatihtocaka podataka.
Interpolacije možemo klasificirati s obzirom na :
? broj dimenzija danog interpolacijskog problema,
? interpolacijsku funkciju (linearna, spline itd.),
? na strukturu zadanih diskretnih podataka (zadani na mreži tocaka ilina 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. Di-menzija y-a duž koje se vrši interpolacija treba biti iste dužine kao i x. kindmože biti ’linear’, ’nearest’, ’zero’, ’slinear’, ’quadratic’, ’cubic’ili cijeli broj koji specificira red spline inerpolacije. Parametar axis odredujedimenziju y-a duž koje se vrši interpolacija. Pozivanja interpolacije izvanintervala zadanih tocaka može se kontrolirati parametrima bounds_error ifill_value. bounds_error odreduje da li se podiže error u slucaju pokušajainterpolacije van granica a fill_value definira vrijednost koju interpolacijau tom slucaju vraca.
Izvorni kod 24.1: Primjer razlicitih 1D interpolacija
1 from numpy.random import *2 from scipy import interpolate
3 from pylab import *4
5 X = linspace(0., 10., 6)
6 Y = array([1.6, 4., 3.4, 1.6, 1.8, 1.2])
7
8 x = linspace(0., 10., 101)
9
10 f1 = interpolate.interp1d(X, Y, kind=’linear’)
11 y1 = f1(x)
12
13 f2 = interpolate.interp1d(X, Y, kind=2)
14 y2 = f2(x)
15
16 f3 = interpolate.interp1d(X, Y, kind=3)
17 y3 = f3(x)
18
19 figure(1, figsize=[8, 3])
20 plot(X, Y, ’o’)
21 plot(x, y1, label=’linearna’)
22 plot(x, y2, label=’spline 2. reda’)
23 plot(x, y3, label=’spline 3. reda’)
24 subplots_adjust(bottom=0.1,top=0.95,left=0.05,right=0.98)
119
120 interpolacije
25 legend()
26 show()
0 2 4 6 8 101.0
1.5
2.0
2.5
3.0
3.5
4.0
4.5
linearnaspline 2. redaspline 3. reda
Slika 24.1: Primjer razlicitih 1D interpolacija
24.2 2d i n-d interpolacija
U slucaju dvo-dimenzionalne (ili više) interpolacije, moguce je interpolacij-ski problem postaviti na diskretnim podacima zadanim na mreži tocaka ilinepravilno razbacanim tockama (scatterd).
Za interpolaciju vrijednosti zadanih na N-D nestrukturiranim tockamakoristi se funkcija griddata:Parametar values
može biti 2D polje,pa se na istim
zadanim tockamamože zadati više
velicina koje se moguinterpolirati preko
jednog pozivainterpolacijske
funkcije.
griddata(points, values, xi, method, fill_value)
gdje je points numpy polje koje sadrži koordinate zadanih diskretnih po-dataka. Oblik polja points je (broj_tocaka, broj_dimenzija). Pripadajucevrijednosti zadaju se preko numpy polja values. xi je polje tocaka za koje jepotrebno interpolirati zadane podatke.
method specificira metodu interpolacije i podržane su sljedece metode:
? nearest
? linear
? cubic
Parametrom fill_value definira se vrijednost koju vraca interpolacijskafunkcija za tocke izvan podrucja zadanih podataka.
Interpolacija na podacima zadanim na pravilnoj mreži tocaka se vrši po-mocu klase interp2d.
interp2d(x, y, z, kind, copy, bounds_error, fill_value)
U izvornom kodu 24.2 rješen je problem intepolacije dvo-dimenzionalnogpolja zadanog vrijednostima u 25 tocaka (uniformna mreža 5x5). Zadanetocke te rješenje linearne i kubicne interpolacije prikazani su na slici 24.2na kojo jse jasno vidi razlika u glatkoci linearne i kubicne interpolacijskefunkcije.
Izvorni kod 24.2: Primjer linearne i kubicne 2D interpolacije
1 from numpy.random import *2 from scipy import interpolate
3 from pylab import *4 from mpl_toolkits.mplot3d import Axes3D
5
24.2 2d i n-d interpolacija 121
6 X = linspace(0., 2., 5)
7 Y = linspace(0., 4., 5)
8 Z = array([
9 [1.3, 1.4, 1.1, 1.0, 0.8],
10 [1.6, 1.1, 1.2, 1.3, 1.5],
11 [1.2, 1.5, 1.6, 1.5, 1.6],
12 [1.2, 1.4, 1.5, 1.4, 1.3],
13 [1.3, 1.2, 1.1, 1.1, 1.2]
14 ])
15
16 XX, YY = np.meshgrid(X, Y)
17
18 f1 = interpolate.interp2d(X, Y, Z, kind=’linear’)
19 f2 = interpolate.interp2d(X, Y, Z, kind=’cubic’)
20
21 x = linspace(0., 2., 51)
22 y = linspace(0., 4., 31)
23 xx, yy = meshgrid(x, y)
24
25 z1 = f1(x, y)
26 z2 = f2(x, y)
27
28 fig = plt.figure(figsize=[8, 3])
29
30 subplot(1, 3, 1)
31 scatter(XX, YY, c=Z, marker = ’s’, s = 100, cmap = cm.Purples)
32 xlim(0, 2)
33 ylim(0, 4)
34
35 subplot(1, 3, 2)
36 CS = plt.contourf(xx, yy, z1, cmap = cm.Purples)
37 xlim(0, 2)
38 ylim(0, 4)
39
40 subplot(1, 3, 3)
41 CS = plt.contourf(xx, yy, z2, cmap = cm.Purples)
42 xlim(0, 2)
43 ylim(0, 4)
44
45 subplots_adjust(bottom=0.3,top=0.95,left=0.05,right=0.95)
46 cax = fig.add_axes([0.05, 0.1, 0.9, 0.1])
47 fig.colorbar(CS, cax=cax, orientation=’horizontal’)
48
49 show()
0.0 0.5 1.0 1.5 2.00.0
0.5
1.0
1.52.0
2.5
3.0
3.5
4.0
0.0 0.5 1.0 1.5 2.00.0
0.5
1.0
1.52.0
2.5
3.0
3.5
4.0
0.0 0.5 1.0 1.5 2.00.0
0.5
1.0
1.52.0
2.5
3.0
3.5
4.0
0.75 0.90 1.05 1.20 1.35 1.50 1.65
Slika 24.2: Primjer 2D interpolacije
25R E G R E S I J E
U inženjerskoj praksi, prilikom odredivanja relativno jednostavne veze iz-medu dvije velicine cesto se nailazi na veliki broj podataka koji zapravopredefiniraju tu vezu. Takvi podaci su, najcešce, dobiveni eksperimentom imjerenjima.
U takvim slucajevima potrebno je odrediti sve parametre modela (funk-cije) da se što tocnije i preciznije opišu podaci.
Primjer
Poznat je zakon koji povezuje silu istezanja opruge F i promjenu duljineopruge ∆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 # -*- coding: utf-8 -*-
2 """
3 Linearna regresija
4 """
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
9 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 k = np.polyfit(X,Y,1)
12 print ’Regresijski pravac: y=%.3fx%+.3f’ % (k[0], k[1])
13
14 xr = np.linspace(np.min(X), np.max(X), 100)
15 yr = xr*k[0] + k[1]
16
17 plot(X, Y, ’ro’, label=u’Tocke’)
18 plot(xr, yr, ’b-’, lw=2, label=u’Regresijski pravac’)
19
20 legend(loc=2)
21 grid()
22 show()
Regresijski pravac: y=10.846x-2.035
0.5 1.0 1.5 2.0 2.5 3.0 3.5 4.00
10
20
30
40
50
To keRegresijski pravac
Slika 25.1: Regresijski pravac dobiven izvornim kodom 25.1
25.3 zadaci
Zadatak 25.1 U laboratoriju se koristi skupi termometar T2 cije je mjerenjepouzdano i znatno jeftiniji i robusniji termometar T1 cije mjerenje trebamo ko-rigirati u odnosu na termometar T1. Pretpostavlja se da je veza izmedu T1 iT2 linearna. U tablici su dana mjerenja istog objekta u isto vrijeme s termome-trima 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 35C kolika bi temperatura bila na termometruT2? Ako termometru T1 pokazuje 12C kolika bi temperatura bila na termome-tru T2?
25.3 zadaci 125
Zadatak 25.2 Vrijednost gravitacijskog ubranje Zemlje g se minjenja s vi-sinom, odnosno udaljenošcu od zemljine površine h, kako je dano u tablici.Izracunaj vrijednost gravitacijskog ubrzanja na visini h = 126 km, koristecikvadratnu regresiju.
h[km] 0.1 20.0 40 60 80 100 120 140
g[ms2
]9.81 9.7486 9.6789 9.6728 9.5681 9.5091 9.4506 9.3926
26R 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 jednadžbi
a11 · x1 + a12 · x2 + . . . + a1n · xn = b1
a21 · x1 + a22 · x2 + . . . + a2n · xn = b2...
......
...
am1 · x1 + an2 · x2 + . . . + ann · xn = bn
(26.1)
se može zapisati matricnoa11 a21 . . . a1n
a12 a22 . . . a2n...
.... . .
...
an2 an2 . . . ann
·x1
x2...
xn
=
b1
b2...
bn
(26.2)
odnsono
A · x = b (26.3)
Matrica A se naziva matrica sustava, x je vektor nepozanica a b je vektorslobodnih clanova.
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?
Rješenje
Neka je d broj djece a o broj odraslih. Ukupan broj ljudi na sajmu jed + o = 341. Novac zaraden od ulaznica: 5 · d + 20 · o = 4810. Dvijenavedene linearne jednadžbe tvore sustav:[
1 1
5 20
]·
[d
o
]=
[341
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 clanova zapisan u datoteci B.txt:
-0.5
2.3
0.8
3.1
127
128 rješavanje sustava linearnih jednadžbi
Izvorni kod 26.1: Primjer naivne Gaussove eliminacije
1 # -*- coding: utf-8 -*-
2 """
3 GAUSSOVA ELIMINACIJA
4 """
5
6 from numpy import *7 from scipy.optimize import *8
9 A = loadtxt(’A.txt’)
10 B = loadtxt(’B.txt’)
11
12 n = len(B)
13
14 # Naivna eliminacija
15 for k in range(0,n):
16 for i in range(k+1,n):
17 faktor = A[i,k]/A[k,k]
18 for j in range(k+1,n):
19 A[i,j] = A[i,j] - faktor*A[k,j]
20 B[i] = B[i] - faktor*B[k]
21
22 # Supstitucija unatrag
23 X = empty(shape(B))
24 for i in range(n-1,-1,-1):
25 suma = 0
26 for j in range(i+1,n):
27 suma = suma + A[i,j]*X[j]
28 X[i] = (B[i]-suma)/A[i,i]
29
30 print X
31
32 # Scipy rjesenje
33 A = loadtxt(’A.txt’)
34 B = loadtxt(’B.txt’)
35 print linalg.solve(A,B)
Izvodenje izvornog koda 26.1 vidimo da su oba ispisana rješenja (Ga-ussova eliminacija i numpy funkcija linalg.solve) identicna:[-0.19367432 0.07619065 0.03675057 0.39036472]
[-0.19367432 0.07619065 0.03675057 0.39036472]
26.2 lu dekompozicija
Primjer LU dekompozicije u izvornom kodu 26.2 koristi datoteke A.txt iB.txt iz prethodnog poglavlja (26.1).
Izvorni kod 26.2: Primjer LU dekompozicije
1 # -*- coding: utf-8 -*-
2 """
3 LU DEKOMPOZICIJA
4 """
5
6 from numpy import *7
8 A = loadtxt(’A.txt’)
9 B = loadtxt(’B.txt’)
10
11 n = len(B)
12
13 # LU dekompozicija
14
15 L = zeros([n,n])
26.2 lu dekompozicija 129
16 U = zeros([n,n])
17
18 for k in range(0,n):
19 for i in range(k,n):
20 suma = 0
21 for m in range(0,k):
22 suma = suma + L[i,m]*U[m,k]
23 L[i,k] = A[i,k] - suma
24 for j in range(k+1,n):
25 suma = 0
26 for m in range(0,k):
27 suma = suma + L[k,m]*U[m,j]
28 U[k,j] = (A[k,j]-suma)/L[k,k]
29
30 for i in range(0,n):
31 U[i,i] = 1
32
33 # rjesavanje sustava
34
35 C = empty(shape(B))
36 X = empty(shape(B))
37
38 for i in range(0,n):
39 suma = 0
40 for j in range(0,i):
41 suma = suma + L[i,j]*C[j]
42 C[i] = (B[i]-suma)/L[i,i]
43
44 for i in range(n-1,-1,-1):
45 suma = 0
46 for j in range(i+1,n):
47 suma = suma + U[i,j]*X[j]
48 X[i] = C[i] - suma
49
50 print X
51
52 # Scipy rjesenje
53 print linalg.solve(A,B)
[-0.19367432 0.07619065 0.03675057 0.39036472]
[-0.19367432 0.07619065 0.03675057 0.39036472]
27N U M E R I C K O I N T E G R I R A N J E
Numerickim integriranjem rješava se odredeni integral funkcije f(x) na in-tervalu [a,b]
I =
∫baf(x)dx (27.1)
27.1 trapezna formula
Najjednostavniji nacin za aproksimiranje odredenog integrala je izracun po-vršine ispod najjednostavnije aproksimacijske krivulje - pravca. Pravac jedefiniran pocetnom i krajnjom tockom intervala inegrala te zatvara povr-šinu sa x-osi oblika trapeza. Izracun površine ispod pravca temelji se natrapeznoj formuli tj. izracunu površine trapeza:∫b
af(x)dx ≈ (b− a)
[f(a) + f(b)
2
]. (27.2)
Svojstvo odredenog integrala je da ga možemo rastaviti na konacni brojdjelova, te je tada odredeni integral nad pocetnim intervalom jednak zbrojuintegrala na djelovima tog integrala:
b∫a
f(x)dx =
c∫a
f(x)dx+
b∫c
f(x)dx. (27.3)
Uzevši u obzir rastavljanje odredenog integrala (27.3), trapeznu formulu(27.2) može se koristiti po djelovima intervala [a,b]:∫b
af(x)dx ≈ 1
2
N∑k=1
(xk+1 − xk) (f(xk+1) + f(xk)) (27.4)
gdje je N broj podintervala za koje vrijedi a < x1 < x2 < · · · < xN−1 <
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 može pojednostaviti:∫b
af(x)dx ≈ h
2
N∑k=1
(f(xk+1) + f(xk)) (27.5)
gdje je h širina podintervala.Modul numpy.integrate sadrži funkciju trapz za numericku integraciju
pomocu trapezne formule.
131
132 numericko integriranje
scipy.integrate.trapz(y, x=None, dx=1.0)
Funkcija prima set (vektor) vrijednosti podintegralne funkcije u tockama dis-kretiziranog 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 širinupodintervala. Ukoliko je funkciji trapz proslijeden samo vektor y, pretpos-tavlja se da je rijec o uniformnoj diskretizaciji sa širinom podintervala 1.
U izvornom kodu 27.1 rješen je odreden integral na uniformno diskreti-ziranom intervalu implementacijom trapezne formule (27.5) te korištenjemfunkcije trapz sa vektorom diskretizirane varijable integracije i sa širinompodintervala.
Izvorni kod 27.1: Primjer racunanja odredenog inegrala pomocu trapezne formule
1 # -*- coding: utf-8 -*-
2
3 import numpy as np
4 import matplotlib.pyplot as plt
5
6 def f(x):
7 return -25.0*x +200.0*x**2 +400.0*x**4 -500.0*x**5
8
9 # Granice integrala
10 # granice (a,b)=(0.0,1.0)
11 a, b = 0.0, 1.0
12
13 # Broj podintervala
14 n = 10
15
16 # Osiguravanje ispravnih tipova varijabli
17 a, b, n = float(a), float(b), int (n)
18
19 # Sirina intervala
20 h = (b-a)/n
21
22 # Diskretizacija, racunanje x-a i y-a za svaku tocku
23 X = np.linspace(a,b,n+1)
24 Y = f(X)
25
26 # Rucno rjesavanje odredenog integrala pomocu trapezne formule
27 I = 0.
28 for i in range(n):
29 I += 0.5*h*(Y[i]+Y[i+1])
30
31 print ’Rjesenje 1: %f’ % I
32
33 # Rjesavanje pomocu numpy.trapz funkcije
34 print ’Rjesenje 2: %f’ %np.trapz(Y, X) # pomocu vektora X
35 print ’Rjesenje 3: %f’ %np.trapz(Y, dx=h) # pomocu razmaka dx
36
37 # Crtanje
38 plt.figure(figsize=(8,5))
39 Xplt = np.linspace(min(X), max(X), 1000)
40 plt.plot(Xplt,f(Xplt), lw=2)
41 plt.plot(X, Y, ’ro’)
42 for i in range(n+1):
43 plt.plot([X[i], X[i]], [0.0, Y[i]], ’k--’)
44 plt.fill_between(X,f(X),color=’DarkSeaGreen’)
45 plt.show()
Rjesenje 1: 50.419500
Rjesenje 2: 50.419500
Rjesenje 3: 50.419500
27.2 simpsonove formule 133
0.0 0.2 0.4 0.6 0.8 1.020
0
20
40
60
80
100
120
Slika 27.2: Racunanje površine ispod krivulje pomocu trapeza (Izvorni kod 27.1)
27.2 simpsonove formule
Simpsonova pravila (ili Simpsonove formule) koriste kvadratni ili kubni po-linom za aproksimaciju funkcije prilikom numericke integracije. Zbog nemo-gucnosti odredivanja aproksimacijkog polinoma na jendom intervalu (dvijetocke), Simpsonove formule se korsite obuhvacajuci dva podinervala (zaaproksimaciju kvadratnim polinomom) ili na tri podintervala (za aproksi-maciju kubnim polinomom). Simposonova 1/3
formula je definiranana parovimapodintervala, štouvjetuje da za njenokorištenje podrucjeodredenog integrala[a,b] treba podjelitina paran brojpodintervala.
Za aproksimaciju kvadratnim polinomom na intervalu [xi, xi+2] vrijedi:∫xi+2xi
f(x)dx =h
3(f(xi) + 4f(xi+1) + f(xi+2)) (27.6)
gdje je x uniformno diskretiziran (xi+2 − xi+1 = xi+1 − xi = h).Izraz (27.6) cesto se naziva Simpsonova 1/3 formula a dobiven je integraci-
jom kvadratnog polinoma koji prolazi kroz tocke (xi, f(xi)), (xi+1, f(xi+1)),(xi+2, f(xi+2)).
Višestrukom primjenom na sve parove uniformno diskretiziranih podin-tervala na [a,b] dobiva se∫b
af(x)dx =
1
3h
f(x0) + 4 n−1∑i=1,3
f(xi) + 2
n−2∑i=2,4
f(xi) + f(xn)
(27.7)
poznato kao kompozitno Simpsonovo pravilo.Kompozitno pravilo se može zapisati i pomocu vektorskog produkta:∫b
af(x)dx =
h
3(cT f) (27.8)
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 više tocaka za
njegovo definiranje. Za aproksimacijom polinomom 3 stupnja potrebne sucetri tocke tj. 3 intervala. Integriranjem polinoma dobiva se izraz za aprok-simaciju odredenog integrala:∫xi+3
xi
f(x)dx =3
8h(f(xi) + 3f(xi+1) + 3f(xi+2) + f(xi+3)) (27.9)
134 numericko integriranje
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 može koristit za poznate vrijednosti podintegralne funk-cije y u tockama x ili za razmak dx uniformne diskretizacije. Argumentomeven odreduje se nacin na koji se racuna odredeni integral nad parnim bro-jem tocaka (neparni broj podintervala):
? even = ’first’, prvi podinterval se racuna pomocu trapezne formule
? even = ’last’, zadnji podinterval se racuna pomocu trapezne for-mule
? even = ’avg’, rezultat integracije je prosjecna vrijednost integrala iz-racunatih sa opcijom even = ’first’ i even = ’last’.
U izvornom kodu 27.2 dan je primjer racunanja odredenog integrala po-mocu Simpsonove 1/3 formule.
Izvorni kod 27.2: Upotreba Simpsonove 1/3 formule
1 # -*- coding: utf-8 -*-
2 """
3 SIMPSONOVA 1/3 FORMULA
4 """
5
6 from numpy import *7 from scipy.integrate import *8
9 # Podintegralna funkcija
10 def f(x):
11 return 20.0*sqrt(x) - 0.2*x**2 - 2.0*sin(x)
12
13 # Granice odredenog integrala
14 a, b = 0.0, 10.0
15
16 # Broj podintervala
17 n = 40
18
19 h = (b-a)/n
20 X = linspace(a,b,n+1)
21 Y = f(X)
22
23 INT = 0.0
24 for i in range(0, n - 1, 2):
25 INT = INT + (1.0/3.0)*h*(Y[i] + 4*Y[i+1] + Y[i+2])
26
27 # "Rucno" rješenje
28 print INT
29
30 # Scipy rjesenje
31 print simps(Y,X)
351.089170175
351.089170175
27.3 naprednije metode
Scipy nudi funkciju quad koja koristi napredniju adaptivnu metodu za nu-mericku integraciju.quad se zansiva na
QUADPACK-u -Fortran biblioteci za
numerickuintegraciju
jednodimenzionalnihfunkcija.
Osnovna upotreba funkcije quad zahtjeva podintegralnu funkciju f te gra-nice odredenog integrala a i b.
27.4 zadaci 135
scipy.integrate.quad(f, a, b)
U izvornom kodu 27.3 rješen je isti odredeni integral kao i u 27.2.
Izvorni kod 27.3: Numericko integriranje pomocu quad funkcije
1 # -*- coding: utf-8 -*-
2
3 from numpy import *4 from scipy.integrate import *5
6 # Podintegralna funkcija
7 def f(x):
8 return 20.0*sqrt(x) - 0.2*x**2 - 2.0*sin(x)
9
10 # Rješavanje odredenog integrala na intervalu [0, 10]
11 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 površina 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 plju-ska svake minute zabilježen je protok oborinske vode.
Vrijeme [min] Protok [l/s] Vrijeme [min] Protok [l/s]
0 0.0 8 10.6
1 0.0 9 11.2
2 2.8 10 10.0
3 4.2 11 9.5
4 6.9 12 4.3
5 10.1 13 1.8
6 10.5 14 0.2
7 11.0 15 0.0
Ako vrijedi
V =
∫T0Q(t)dt
koliki je ukupni volumen vode koja je ušla u spremnik?
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 IP D J
28N U M E R I C K E M E T O D E Z A R J E Š AVA N J E O B I C N I HD I F E R E N C I J A L N I H J E D N A D Ž B I
28.1 obicne diferencijalne jednadžbe 1 . reda
y ′ =dy
dx= f(x,y) (28.1)
y(x0) = y0 (28.2)
28.1.1 Eulerova metoda
Eulerova metoda služi za numericko rješavanje diferencijalne jednadžbe pr-vog reda (28.1) sa zadanim pocetnim uvjetom (28.2) a temelji se na aprok-simaciji funkcije y(x) pomocu prvog clana Taylorovog reda u okolini tockex:
y(x+∆x) ≈ y(x) + y ′(x)∆x (28.3)
gdje je ∆x konacni odmak od x.
28.1.2 Runge-Kutta metode
28.1.3 Rješavanje pomocu scipy-a
Rješavanje obicnih diferencijalnih jednadžbi moguce je korištenjem odeint
funkcije iz modula scipy. Iako funkcija odeint ima znatno širu primjenu,u ovom poglavlju ce se opisati samo primjena na obicne diferencijalne jed-nadžbe prvog reda.
Osnovna sintaksa odeint funkcije je:
scipy.integrate.odeint(f, y0, x)Pri upotrebi odeintmetode ocekuje se daje funkcija f
definirana kaof(y,x), što jeneuobicajenredoslijedargumenata te cestomože dovesti dopogreške.
gdje je f funkcija kojom je definiran diferencijalna jednadžba (28.1), y0 jepocetni uvjet a x je vektor koji predstavlja diskretiziran interval varijable x.Pocetni uvjet y0 vrijedi u pocetnoj vrijednosti vektora x.
Primjer rješavanje obicne diferencijalne jednadžbe 1. reda dan je u izvor-nom kodu 28.1.
Izvorni kod 28.1: Primjer rješavanja obicnih diferencijalnih jednadžbi 1. reda.
1 # -*- coding: utf-8 -*-
2
3 import numpy as np
4 import matplotlib.pyplot as plt
5 import scipy.integrate as intgr
6
7 # ODJ dy/dx = f(y,x)
8 def f(y, x):
9 return -y + np.sin(x)*np.cos(y)
10
11 # Pocetni uvjet
139
140 numericke metode za rješavanje obicnih diferencijalnih jednadžbi
12 x0 = 0.
13 y0 = 20.
14
15 # Krajnja tocka intervala
16 xf = 10
17
18 # Diskretizacija
19 X = np.linspace(x0, xf, 200)
20
21 # Rješavanje ODJ
22 Y = intgr.odeint(f, y0, X)
23
24 # Vizualizacija
25 plt.plot(X, Y, ’r’, lw = 2)
26 plt.xlabel(’x’)
27 plt.ylabel(’y(x)’)
28 plt.grid()
29 plt.show()
0 2 4 6 8 10x
5
0
5
10
15
20
y(x
)
Slika 28.1: Vizualizacija rješenja iz izvornog koda 28.1.
28.2 sustavi obicnih diferencijalnih jednadžbi 1 . reda
28.3 obicne diferencijalne jednadžbe višeg reda
29P O C E T N I P R O B L E M I
29.1 modeliranje otvorenog vodotoka
Promatrajmo strujanje fluida u otvorenom vodotoku[3, 13] (eng. open channelflow). Poprecni presjeci kanala mogu biti razliciti npr. pravokutni, trapezni isl., dok se kod prirodnih vodotoka pojavljuju poprecni presjeci nepravilnihoblika. 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 - površina 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 može napraviti prema razlicitim kriterijima. Akose brzina strujanja ne mijenja u ovisnosti o vremenu, onda je strujanje sta-cionarno, u suprotnom se radi o nestacionarnom strujanju. Nadalje, ako sebrzina strujanja ne mijenja s obzirom na udaljenost u kanalu (od neke refe-rentne tocke) onda je strujanje uniformno, a inace se radi o neuniformnomstrujanju.
vodno lice
idealan fluid
referentna ravnina
enegetska linija
Slika 29.2: Energetske linije u strujanju fluida otvorenim vodotokom
141
142 pocetni problemi
Pretpostavke:
? kut Φ je mali
? strujanje je izrazito jednodimenzionalno
? tlak je iskljucivo hidrostatski
Opcenito se strujanje u kanalu opisuje sustavom parcijalnih diferencijal-nih jednadžbi, koje proizlaze iz zakona ocuvanja mase i zakona ocuvanjakolicine gibanja. Ako pretpostavimo da se radi o prizmaticnom kanalu, mo-žemo ih zapisati u obliku:
∂A
∂t+∂Q
∂x= 0 (29.1)
∂v
∂t+ g
∂
∂x
(y+
v2
2g
)= g(S0 − Sf) (29.2)
y je dubina vode, v brzina, a Q protok, pri cemu vrijedi relacija v =Q
A.
Sf je pad energetske linijedH
dx, definiran Manningovom formulom (koja je
prikazana u nastavku). Uvedimo oznaku
dH
dx= −Sf (29.3)
S S0 smo oznacili nagib dna kanala, tj. S0 = −dz
dx= −tan(Φ).
29.1.1 Stacionarno strujanje
Nadalje, ukoliko promatramo stacionarno strujanje fluida, ocito je da zbog
neovisnosti varijabli o vremenu tj. 0
∂A
∂t= 0 i
∂v
∂t= 0, iz prve jednadžbe
sustava (29.1) slijedi:
Q = konst. (29.4)
odnosno iz druge jednanžbe
dz
dx+dy
dx+d
dx
(v2
2g
)= Sf (29.5)
Zapravo se ova jednadžbe može dobiti i ako krenemo od poznate namBernoullijeve jednažbe
z+p
ρg+v2
2g= H (29.6)
prema kojoj je ukupna energija konstantna duž strujnice. Vrijednost energet-ske linije oznacimo s H. Uvažavanjem jednakosti p = ρgy , slijedi z+ y+v2
2g= H, odnosno deriviranjem po x dobijemo diferencijalnu jednadžbu za
dubinu vode y = y(x):
dz
dx+dy
dx+d
dx
(Q2
2gA2
)=dH
dx(29.7)
29.1 modeliranje otvorenog vodotoka 143
Vrsta kanala Manningov koeficijent
Betonski kanal 0.015
Prirodni kanali (glina) 0.030
Rijecni tokovi 0.030 - 0.070
Tablica 29.1: Vrijednosti Manningovog koeficijenta za razlicite izvedbe kanala.
Nadalje, kod stacionarnog toka (Q = konst.) u prizmaticnom kanalu vri-jedi
d
dx
(Q2
2gA2
)=Q2
2g
d
dx
(1
A2
)=Q2
2g
d
dy
(1
A2
)dy
dx
= −Q2
gA3dA
dy
dy
dx
= −Q2B
gA3dy
dx
(29.8)
Kod druge smo jednakosti uvažili cinjenicu da je kanal prizmatican, štoznaci da se poprecni profili ne mijenjaju s obzirom na udaljenost x u kanalu,
dok zadnja jednakost slijedi izdA
dy= B. Pad energetske linije
dH
dx= −Sf
definiran je Manningovom formulom, pomocu koje se modeliraju gubicinastali zbog trenja
29.1.2 Maningova formula
Manningova formula, još poznata kao Gauckler–Manningova formula ili Ga-uckler–Manning–Stricklerova formula, je empirijska jednadžba za strujanjeu otovrenim kanalima ili strujanja sa slobodnom površinom pod utjecajemgravitacije. Definirana je kao:
Sf =Q2n2
R4/3)A2
(29.9)
gdje je n Manningov koeficijent trenja, R =A
Pje hidraulicki radijus, a P
perimetar.
dy
dx=S0 − Sf
1−BQ2
gA3
(29.10)
Zadatak: Za pocetniuvjet y(x0) = y0odrediti dubinu vodey(x) izdiferencijalnejednadžbe (29.10).
Opazimo da jednadžba (29.10) vrijedi zaBQ2
gA36= 1
(29.10) je diferencijalna jednadžba prvog reda oblika
dy
dx= f(x,y(x))
za koju analiticko rješenje znamo odrediti samo u nekim posebnim sluca-jevima, za razliku od numerickog rješenja koje znamo odrediti u podrucjuu kojem je diferencijalna jednadžba dobro definirana. Da bi problem bio upotpunosti modeliran potrebno je zadati i pocetne uvjete.
144 pocetni problemi
29.1.3 Uniformno strujanje i normalna dubina
Kao što smo vec spomenuli, kod uniformnog strujanja su brzina i dubina
vode konstantne velicine pa iz jednadžbe (29.10), zbogdy
dx= 0, slijedi:
S0 = Sf (29.11)
Iz Manningove formule (29.9) potom proizlazi da kod uniformnog toka vri-jedi:
Q =1
nAR2/3S
1/20 (29.12)
Na osnovu te jednadžbe može se odrediti dubina vode kod uniformnogtoka, tzv. normalna dubina koju cemo oznaciti yn.
29.1.3.1 Prizmaticni kanal s pravokutnim poprecnim presjekom
B - širina kanala
A(y) = B · y⇒ dA
dy= B (29.13)
P(y) = B+ 2y (29.14)
Slika 29.3: Pravokutni poprecni presjek kanala
Kod zadavanja podataka, obicno su nam poznate velicine: Q, n, S0, B.Normalnu dubinu potom možemo odrediti iz sljedeceg izraza:
Q =1
nAR2/3S
1/20
=1
nByn
(Byn
B+ 2yn
)2/3S1/20
(29.15)
koristeci neku od numerickih metoda
29.1.3.2 Trapezni kanal
B0 - širina kanala Z - nagib bocnih stranica kanala (tangens kuta nagibabocnih stranica kanala)
A(y) = (B0 + yZ) · y⇒dA
dy= B0 + 2yZ (29.16)
P(y) = B0 + 2y√1+Z2 (29.17)
29.1 modeliranje otvorenog vodotoka 145
Slika 29.4: Trapezni poprecni presjek kanala
Zadatak 29.1 Odrediti normalnu dubinu vode yn u trapeznom kanalu, s boc-nim nagibom Z = 2, te širinom dna B0 = 10m. Nagib dna kanala je konstan-
tan i jednak S0 = −dz
dx= 0.001 (1m po km duljine) a Manningov koeficijent
n = 0.013.
Rješenje
Dubinu vode oznacimo s y. Iz slicnosti trokuta slijedi 1 : z = y : x, pa jex = zy. Površina omocenog presjeka trapeza je A = (B0 + zy)y. Opsegomocenog presjeka trapeza je P = B0 + 2y
√1+ z2. Hidraulicki radijus
je
R =A
P=
(B0 + zy)y
B0 + 2y√1+ z2
.
Normalnu dubinu vode potom odredujemo iz jednadžbe (29.12), kojanakon uvrštavanja dobivenih izraza i i sredivanja poprimi oblik
nQ
S0−
[(B0 + zyn)yn]5/3[
B0 + 2yn√1+ z2
]2/3 = 0
Nakon uvrštavanja poznatih vrijednosti dobijemo
F(yn) = 12.33(10+ 4.47yn)2/3 − ((10+ 2yn)yn)5/3 = 0
Nul tocka funkcije F(y) predstavlja rješenje gornje jednadžbe. Može seodrediti pomocu neke od numerickih metoda npr. bisekcijom ili Newto-novom metodom. Rješenje je
yn = 1.09m
29.1.4 Kriticna dubina
Nadalje, definirajmo kriticnu dubinu yc. To je dubina kod koje je Froudovbroj jednak 1, tj.
Fr =v
√gyc
= 1 (29.18)
Opazimo da je u slucaju kriticne dubine nazivnik u diferencijalnoj jednadžbi(29.10) jednak 0 te da diferencijalna jednadžba u toj tocki ne vrijedi. Kriticnudubinu možemo izraziti iz (29.18) te dobijemo
yc =3
√Q2
gA2=
3
√q2
g(29.19)
146 pocetni problemi
gdje je q =Q
A. Karakteristika kriticne dubine je da je to dubina kod koje je
specificna energijafluida 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 < conda govorimo o podkriticnom toku, za v = c je tok kritican, dok je zav > c tok nadkritican. Uocimo da kod podkriticnog toka vrijedi v− c < 0 , av+ 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, dokdruga putuje nizvodno brzinom v+ c. Za razliku od toga, kod nadkriticnogtoka 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 datok uzvodno od promatrane lokacije uopce ’ne zna’ što se dogada nizvodno.
29.1.5 Hidraulicki skok
Hidraulicki skok (jump) se pojavljuje kod prijelaza strujanja iz nadkriticnogu pdkriticno. U tocki u kojoj je Froudov broj jednak 1 dogodi se hidraulickiskok. Kod hidraulickog skoka dolazi do gubitka energije (zbog turbulencije)i do naglog skoka u vodnom licu. Kako gubitak energije na skoku nije una-prijed poznat, jednadžbu ocuvanja energije ne možemo primijeniti direktno.Uocimo takoder da u tocki skoka diferencijalna jednadžba (29.10) ne vrijedijer je nazivnik desne strane jednak nula.
U nastavku cemo promatrati rješenja jednadžbe (29.10) uz postavljeni po-cetni uvjet y(x0) = y0, tj. poznatu dubinu vode u nekoj tocki. Kako ana-liticka rješenja jednadžbe nisu poznata, osim u nekim posebnim slucaje-vima, za rješavanje cemo koristiti numericke metode. Prisjetimo se, da sustandardne numericke metode za rješavanje diferencijalne jednadžbe prvogreda: Eulerova metoda, poboljšana Eulerova metoda i razlicite Runge-Kuttametode. Koju cemo od spomenutih metoda odabrati ovisi o tocnosti kojuželimo postici. Pritom treba svakako voditi racuna i o stabilnosti pojedinihmetoda.
Rješenja postavljenog pocetnog problema mogu biti razlicitog oblika, uzavisnosti o pocetnom uvjetu, nagibu kanala i trenju u kanalu. Promatraticemo razlicite slucajeve u tzv. kanalima s blagim nagibom (mild slope). Ta-kav je nagib okarakteriziran uvjetom
yc < yn (29.20)
U tom se slucaju linija kriticne dubine nalazi ispod linije normalne dubine.Tim je dvjema linijama podrucje strujanja podijeljeno u tri zone (vidi sliku3.). Oblik rješenja, dakle vodno lice, ovisi o pocetnom uvjetu. Tražena serješenja odreduju iz diferencijalne jednadžbe (29.10), koja se za promatranipravokutni prizmaticni kanal može zapisati u obliku:
dy
dx= S0
1+
(yn
y
)10/31−
(yc
y
)3 (29.21)
U ovisnosti o zoni u kojoj se nalazi pocetni uvjet, dakle pocetna dubina ovisisami oblik rješenja. Znacajno je naglasiti da dubina vode, odnosno rješenjene može prijeci diferencijalne jednadžbe iz jedne u drugu zonu – dakle, ako
29.1 modeliranje otvorenog vodotoka 147
je pocetni uvjet u zoni 1, vodno lice ostati ce u zoni 1. Pripadajuca se krivuljanaziva M1 krivulja.
Razlikujemo M1, M2 i M3 krivulje (Slika 29.5). Vrijedi:
? za yc < yn < y0 rješenje je M1-krivulja
? za yc < y0 < yn rješenje je M2-krivulja
? za y0 < yc < yn rješenje je M3-krivulja
U tockama u kojima se dogodi prijelaz iz jedne u drugu zonu, rješenjezapravo ne zadovoljava diferencijalnu jednadžbu (to su slucajevi u kojimaje nazivnik u diferencijalnoj jednadžbi jednak 0, dakle tocke u kojima sedostigne 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 ka-nala ciji se nagib poveca; strujanje prije prijelaza u nadkriticno imaoblik M2-krivulje;
? M3-krivulja – prijelaz iz nadkriticnog u podkriticno strujanje npr. stru-janje ispod zapornice; dio krivulje prije prijelaza u podkriticni tok imaoblik M3-krivulje.
Na slican se nacin rješenja mogu dobiti i za vece nagibe kanala (steep slope)– kada je yc > yn. U tom slucaju rješenja imaju oblik tzv. S-krivulja (Slika29.6).
Slika 29.5: M-krivulje vodnog lica Slika 29.6: S-krivulje vodnog lica
29.1.6 Numericko rješavanje
Izvorni kod 29.1: Strujanje u pravokutnom kanalu
1 # -*- coding: utf-8 -*-
2 """
148 pocetni problemi
3 pravokutni kanal
4 transkriticno strujanje
5 rješavanje ODJ
6 """
7
8 from numpy import *9 from scipy.optimize import *
10 from scipy.integrate import *11 from matplotlib.pyplot import *12
13 g = 9.81
14
15 # ulazni podaci o kanalu
16 B = 15.0
17 S0 = 0.001
18 n = 0.012
19
20 Q = 10.0
21
22 yc = ((Q/B)**2/g)**(1.0/3.0)
23 print(’yc = ’+str(yc))
24
25 # osnovne velicine
26 A = lambda y: B*y
27 P = lambda y: B+2*y
28 R = lambda y: A(y)/P(y)
29 Sf = lambda y: (n*Q/(R(y)**(2.0/3.0)*A(y)))**2
30
31 yn = fsolve((lambda y: Sf(y)-S0),yc)
32 print(’yn = ’+str(yn[0]))
33
34 # racunanje razine vode
35 x0 = 0.0
36 y0 = 0.42
37 x1 = 30.0
38
39 X = linspace(x0,x1,100)
40
41 dydx = lambda y,x: (S0-Sf(y))/(1.0-B*Q**2/(A(y)**3*g))
42 Y = odeint(dydx,y0,X)
43
44 #dydx_2 = lambda y,x: S0*(1.0-(yn/y)**(10.0/3.0))/(1.0-(yc/y)**3)
45 #Y_2 = odeint(dydx_2,y0,X)
46
47 #crtanje
48 figure(1, [8, 3])
49 Ydno = -(X-x0)*S0
50 plot(X,Y[:,0]+Ydno)
51 plot(X,Ydno)
52 #plot(X,Y_2[:,0]-(X-x0)*S0);
53 legend((’razina vode’,’dno’),loc=’best’);
54 subplots_adjust(bottom=0.08,top=0.95,left=0.05,right=0.98)
55 show()
29.1 modeliranje otvorenog vodotoka 149
0 5 10 15 20 25 300.1
0.0
0.1
0.2
0.3
0.4
0.5
razina vodedno
Slika 29.7: Numericko rješenje strujanja u otvorenom kanalu pravokutnog presjeka
30R U B N I P R O B L E M I
Uvod, opcenito o rubnim problemima
30.1 savijanje grede
Za rješavanje ovog primjer korišten je rješavac bvp1lg. Prije instalacije mo-dula bvp1lg potrebno je instalirati pakete koje on koristi:sudo zypper in python-numpy-devel fparser-devel \
libatlas3 libatlas3-devel lapack-devel
nakon cega se može instalirati i sam modul:sudo pip install scikits.bvp1lg
bvp1lg zahtjevaFortran compiler!
q(x)
u(x)
E, I
Slika 30.1: Savijanje grede
Veza izmedu progiba elasticne linije i postavljenog opterecenja opisana jeEuler-Bernoullijevom jednadžbom (Diferencijalna jednadžba elasticne linije):
EI · d2 ud x2
= −M(x) (30.1)
ili prošireno
d2
d x2
(EI · d2 u
d x2
)= q(x) (30.2)
gdje je E Youngov modul, I osni moment tromosti poprecnog presjeka, u jeprogib grede, M je moment savijanja, q je kontinuirano poprecno opterece-nje, a x je os nedeformirane grede.
Ako je E · I konstantno duž grede, jednadžba (30.2) se pojednostavljuje:
E · I · d4 ud x4
= q(x) (30.3)
Pomocu supstitucija:
w1(x) = u(x)
w2(x) =dud x
w3(x) =d2 ud x2
w4(x) =d3 ud x3
(30.4)
151
152 rubni problemi
obicnu diferencijalnu jednadžbu 4. reda (30.3) može se zapisati kao sustav 4
obicne diferencijalne jednadžbe 1. reda.
dw1d x
= w2(x)
dw2d x
= w3(x)
dw3d x
= w4(x)
dw4d x
=1
EIq(x)
(30.5)
Za sustav (30.5) potrebno je postaviti 4 rubna uvjeta kako bi se moglo do-biti rješenje savijanja grede. Rubni uvjeti koje je moguce postaviti na krajevegrede (Slika 30.2):
? Rubni uvjet progiba u|xbc = ubc. U tocki xbc postavlja se vrijednostprogiba ubc.
? Rubni uvjet nagiba dudx
∣∣∣xbc
= vbc. U tocki xbc postavlja se vrijednost
nagiba vbc.
? Rubni uvjet momenta d2udx2
∣∣∣xbc
=Mbc. U tocki xbc postavlja se vrijed-
nost momenta Mbc.
? Rubni uvjet poprecne sile d3udx3
∣∣∣xbc
= Qbc. U tocki xbc postavlja se
vrijednost poprecne sile Qbc.
Slika 30.2: Rubni uvjeti za razlicite oslonce grede
U izvornom kodu 30.1 prikazan je primjer rješavanja savijanja grede ko-risteci bvp1lg paket koji je specijaliziran rješavac za rubne probleme. U da-nom primjeru korišteni su sljedeci rubni uvjeti: lijevi rub je uklješten (nemaprogiba ni rotacije/nagiba) dok na desnom rubu zglob (nema pomaka nimomenta). Greda je opterecenja konstantnim kontinuiranim opterecenjemduž cijele dužine.
Izvorni kod 30.1: Rješavanje elasticne linije savijanja
1 from pylab import *2 import scikits.bvp1lg as bvp
3
4 # Definiranje problema
5 EI = 1.0 # Youngov modul i moment otpora
6 L = 1.0 # Duzina grede
7 # Opterecenja
8 qq=-1.0
9
30.2 stacionarno provoðenje topline u štapu 153
10 # Kontinuirana sila, poprecna sila i moment savijanja
11 def q(x): return qq
12
13 degrees = [1, 1, 1, 1]
14
15 # Sustav diferencijalnih jednadzbi
16 def function(x , y):
17 u, du, d2u, d3u = y
18 return ([ du,
19 d2u,
20 d3u,
21 q(x)/EI])
22
23 # Rubni uvjeti
24 boundary_points = [0.0, 0.0, L, L]
25 def boundary_conditions(y):
26 u, du, d2u, d3u = y
27 return [u[0], du[1], u[2], d2u[3]]
28
29 tol = [1e-15, 1e-15, 1e-15, 1e-15]
30
31 # Rjesavanje rubnog problema
32 solution = bvp.colnew.solve(
33 boundary_points, degrees, function, boundary_conditions,
34 is_linear=False, tolerances=tol,
35 vectorized=False, maximum_mesh_size=10000)
36
37 # Vizualizacija rjesenja
38 figure(1, figsize=(8, 3))
39 x = solution.mesh
40 plot(x, solution(x)[:,0], ’b-’, linewidth=2)
41 xlabel(’x’)
42 ylabel(’y’)
43 grid()
44 subplots_adjust(bottom=0.15,top=0.95,left=0.13,right=0.98)
45 savefig(’greda.pdf’)
46 show()
Rješenje dobiveno izvornim kodom 30.1 je prikazano na slici 30.3.
0.0 0.2 0.4 0.6 0.8 1.0x
0.006
0.005
0.004
0.003
0.002
0.001
0.000
y
Slika 30.3: Progib elasticne linije grede
30.2 stacionarno provoðenje topline u štapu
31K 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 HJ E D N A D Ž B I
Za danu funkciju u = u(x,y) se parcijalne derivacije definiraju s
∂u
∂x(x,y) = lim
∆x→0
u(x+∆x,y) − u(x,y)∆x
(31.1)
i
∂u
∂y(x,y) = lim
∆y→0
u(x,y+∆y) − u(x,y)∆y
(31.2)
Parcijalna diferencijalna jednadžba je jednadžba koja sadrži parcijalne deri-vacije nepoznate funkcije dviju ili više nezavisnih varijabli.
Opceniti oblik linearne PDJ drugog reda s konstantnim koeficijentima je
A∂2u
∂x2+B
∂2u
∂x∂y+C
∂2u
∂y2+D (31.3)
Tip jednadžbe (31.3) odreden je predznakom izraza B−4AC. Parcijalnadiferencijalna jednadžba (31.3) je
? elipticka za B2 − 4AC < 0
? parabolicka za B2 − 4AC = 0
? hiperbolicka za B2 − 4AC > 0
Zbog veoma raširene pojave jednadžbi ovakvog tipa u matematickom mo-deliranju fizikalnih pojava, a time i u inženjerstvu, upoznat cemo neke odnumerickih metoda koje se koriste pri rješavanju jednadžbi oblika (31.3).Numericke se metode bitno razlikuju u zavisnosti o tipu jednadžbe.
155
32E L I P T I C 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
Tpicni predstavnici PDJ eliptickog tipa su:Laplaceova jednadžba
∆u =∂2u
∂x2+∂2u
∂y2= 0 (32.1)
Poissonova jednadžba
∆u =∂2u
∂x2+∂2u
∂y2= f(x,y) (32.2)
Kvaziharmonicka PDJ
∂
∂x
(kx ·
∂u
∂x
)+∂
∂y
(ky ·
∂u
∂y
)= f(x,y) (32.3)
32.1 progib ploce
x
z
yn
q
Slika 32.1: Ploca
Promatramo plocu jednostavno poduprtu na rubovima, s površinskim op-terecenjem q (Slika 32.1). Progib tako slobodno oslonjene ploce u smjeru zmože se odrediti iz PDJ eliptickog tipa
∂4z
∂x4+ 2
∂4z
∂x2∂y2+∂4z
∂y4=q
D(32.4)
koja vrijedi u unutarnjim tockama podrucja Ω, te rubnih uvjeta
z|∂Ω = 0 (32.5)
i
∂2z
∂n2
∣∣∣∣∂Ω
= 0 (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
158 elipticke parcijalne diferencijalne jednadžbe
Ako se definira nova varijabla
u = ∆z =∂2z
∂x2+∂2z
∂y2(32.8)
jednadžba (32.4) može se zapisati u obliku
∂2u
∂x2+∂2u
∂y2=q
D(32.9)
pa se problem (32.4) svodi na rješavanje dviju Poissonovih jednadžbi (32.8)i (32.9).
Iz rubnih uvjeta (32.5) i (32.6) odreduju se rubni uvjeti koji pripadajudobivnenim jednadžbama 2. reda:
u|∂Ω = 0 (32.10)
i
z|∂Ω = 0 (32.11)
Naravno, prvo se rješava jednadžba (32.9) a onda se dobiveno rješenjekoristi za rješavanje jednadžbe (32.8).
Izvorni kod 32.1: Rješavanje problema progiba ploce pomocu metode konacnih razlika
1 # -*- coding: utf-8 -*-
2 """
3 progib ploce
4 rješavanje PDJ
5 konacne razlike
6 """
7
8 from numpy import *9 from scipy.linalg import *
10 from matplotlib.pyplot import *11 from mpl_toolkits.mplot3d import Axes3D
12
13 # ulazni podaci
14 q = 10000.0 # [N/m^2]
15 d = 0.01 # [m]
16 L = 2.0 # [m]
17 E = 2.0*10**11 # modul elasticnosti
18 pbr = 0.3 # Poissonov broj
19
20 D = E*d**3/(12.0*(1.0-pbr**2)) # fleksna krutost
21
22 nm = 50 # broj tocaka po dimenziji
23
24 h = L/(nm-1) # udaljenost od tocke do tocke
25 n = (nm-2)
26
27 # izgradnja matrice sustava i vektora d.s.
28 Adblok = zeros([n,n]) + diag(-4*ones(n)) + \
29 diag(ones(n-1),k=1) + diag(ones(n-1),k=-1)
30 A=empty([0,0])
31 for i in range(n):
32 A = block_diag(A, Adblok)
33 A = A + diag(ones([n**2-n]),k=n) + diag(ones([n**2-n]),k=-n)
34 b = h**2*q/D*ones(n**2)
35
36 # rješavanje
37 u = solve(A,b)
38 z = solve(A,u*h**2)
32.1 progib ploce 159
39
40 # pakiranje rezultata
41 z = reshape(z,[n,n]) # ili: z = z.reshape([n,n])
42 Z = zeros([nm,nm])
43 Z[1:(nm-1),1:(nm-1)] = -z
44
45 # prikaz
46 pcolor(Z)
47 colorbar()
48
49 # 3d
50 l = linspace(0,L,nm)
51 X, Y = meshgrid(l,l)
52 figure().gca(projection=’3d’).plot_surface(X,Y,Z, \
53 rstride=1, cstride=1, cmap=cm.coolwarm, linewidth=0)
54
55 show()
33M E T O D A L I N I J A
Metoda linija je opca tehnika za rješavanje parcijalnih diferencijalnih jed-nadžbi (PDE) koje obicno koriste konacne razlike za odnose prostornih de-rivacija i obicne diferencijalne jednadžbe za vremensku derivaciju.
Za ilustraciju i detaljnije pojašnjenje ove metode koristit ce se primjenametode na problem nestacionarnog progrijavanja štapa. Parcijalna diferen-cijalna jednadžvba koja opisuje promjenu temperature duž osi štapa i uvremenu je:
∂T
∂t= D
∂2T
∂x2(33.1)
Lijevi rub je izoliran i u toj tocki vrijedi Neumannov rubni uvjet:
∂T
∂x
∣∣∣∣0
= 0 (33.2)
Na desnom rubu zadana je konstantna temperatura i vrijedi Dirichleovrubni uvjet:
T |L = 0 (33.3)
.Osnovna ideja metode linija je da se parcijalnu diferencijalnu jednadžbu
(33.1) svede na sustav obicnih diferencijalnih jednadžbi.
ii-1 i+1
x=0 x=L
"ghost" point
Δx
i=ni=1
Slika 33.1: Diskretizacija
Diskretizacijom prostorne koordinate (Slika 33.1) te aproksimacijom ko-nacnim razlikama, vrijedi:
∂2T
∂x2(x) =
T(x+∆x) − 2T(x) + T(x−∆x)
∆x2(33.4)
Jednadžba (33.4) vrijedi za svaku unutarnju diskretizacijsku tocku i ovisnaje o susjednim tockama:
∂Ti∂t
= DTi+1 − 2Ti + Ti−1
∆x2(33.5)
Na lijevom rubu, iz (33.2) vrijedi:
T1 = T0 (33.6)
161
162 metoda linija
pa se može korigirati jednadžbu za prvu tocku:
∂T1∂t
= DT2 − 2T1 + T0
∆x2= D
T2 − T1
∆x2(33.7)
Desni rub se ne mjenja u vremenu, pa u krajnjoj tocki vrijedi:
∂Tn
∂t= 0 (33.8)
Jednadžbe (33.4), (33.7) i (33.8) tvore sustav obicnih diferencijalnih jed-nadžbi koje se može rješiti prikladinim rješavacem.
Izvorni kod 33.1: Primjer rješavanje provodenja topline kroz štap pomocu metode linija
1 #!/usr/bin/python
2 # -*- coding: utf-8 -*-
3
4 from scipy import *5 from scipy.integrate import *6 from matplotlib.pyplot import *7 from matplotlib.animation import *8
9 nx = 50
10 x = linspace(0, 1, nx)
11 A = diag(ones(nx)*(-2.0), k=0) + \
12 diag(ones(nx-1)*1.0, k=1) + \
13 diag(ones(nx-1)*1.0, k=-1)
14
15 """
16 Resetiraj jednadžbu za prvu i zadnju tocku
17 """
18 A[0,:] = 0
19 A[-1,:] = 0
20
21 """
22 Prva tocka: izolacija dT0/dx = 0 ==> T_-1 = T_0
23 dT0/dt = k*(T_1 - 2*T_0 +T_-1)/dx^2
24 = k*(T_1 - T_0)/dx^2
25 """
26 A[0,0] = -1
27 A[0,1] = 1
28
29 """
30 Zadnja tocka: fiksna temperatura dT/dt = 0
31 """
32 A[-1,-1] = 0
33
34
35 dx=0.1;
36 k=0.01;
37 nt = 11
38 t = linspace(0.0, 100., nt)
39
40 T0 = sin(x*pi)
41 print shape(dot(A,T0))
42
43 """
44 Postavi sustav ODJ
45 """
46 def dT_dt(T, t):
47 dT = (k/dx**2.0)*dot(A,T)
48 return dT
49
50 """
51 Rješi sustav ODJ
52 """
metoda linija 163
53 rez = odeint(dT_dt, T0, t)
54
55 """
56 Crtanje i animacija rješenja
57 """
58 fig1 = figure()
59 lineGeom, = plot([], [], ’r-’, lw=2)
60 titl = title(’’)
61
62 def update_line(i):
63 lineGeom.set_data(x, rez[i,:])
64 titl.set_text(’t=%f’ % t[i])
65 #fig1.savefig(’img_%03d.png’ % i)
66 return
67
68 anim = FuncAnimation(fig1, update_line, nt, interval=1000, repeat_delay=0)
69 show()
Dio VI
O P T I M I Z A C I J S K E M E T O D E
34D E F I N I C I J A O P T I M I Z A C I J S K O G P R O B L E M A
Optimizacijski problem se može postaviti kao pronalaženje vektora x∗ =
(x∗1, x∗2, ..., x∗n) 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 rješenja optimizacijskog problema. Ω je prostor pretraživanja.Izraz (34.1) pretpostavlja da je rijec o minimizacijskom problemu. U slu-
caju maksimizacije, problem se definira kao
f(x∗) > f(x), ∀x ∈ Ω (34.2)
34.1 optimizacijske varijable
Optimizacijske varijable (eng. optimization variables, design variables, designparameters, decision variables) su varijable cije vrijednosti treba odrediti a dazadovoljavaju ciljeve i ogranicenja optimizacijskog problema.
Zbog jednostavnosti zapisa, cesto se koristi vektor optimizacijskih varija-bli (eng. design vector):
x = (x1, x2, ..., xn) (34.3)
gdje je n broj optimizacijskih varijabli.Domena pretraživanja ili prostor pretraživanja odreduje moguce vrijed-
nosti optimizacijskih varijabli; a odreden je s obzirom na tip varijabli (konti-nuirane ili diskretne) te s obzirom na propisane granice varijabli.
Prostor pretraživanja
Za optimizaciju sa kontinuiranim neomedenim varijablama vrijedi
x ∈ Rn (34.4)
Uvodenjem omedenosti, prostor pretraživanja sužava se na Ω
x ∈ Ω ⊂ Rn (34.5)
Omedenost (bound) kontinuiranih optimizacijskih varijabli je postavljanjegranica varijabli tj. definiranje dopuštenog intervala varijabli. Za svaku kon-tinuiranu varijablu xi može se postaviti donja granica (lower bound) xmini tegornja granica (upper bound) xmaxi i onda vrijedi:
xi ∈[xmini , xmaxi
], ∀i = 1, . . . ,n (34.6)
Uvodenjem diskretnih varijabli, najcešce indeksiranih pomocu cijelih iliprirodnih brojeva, prostor pretraživanja 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 nakonacnom 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, mo-
žemo klasificirati na:
? kontinuirane
? diskretne
? mješovite
a s obizirom na omedenost na:
? omedene (bounded) i
? neomedene (unbounded).
34.2 ciljevi optimizacije i funkcija cilja
f(x) (34.10)
34.3 ogranicenja
35L I N E A R N O P R O G R A M I R A N J E
Linearno programiranje je matematicka metoda pronalaska optimuma line-arne funkcije više varijabli poštujuci ogranicenja zadana linearnim nejedna-kostima i jednakostima.
Linearno programiranje je razvijeno kao disciplina u 1940-ima, u pocetkumotivirano zbog potrebe za rješavanje složenih problema planiranja u rat-nim 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 odprvih prakticnih upotreba imao je ruski matematicar Kantorovic ([5]) u po-kušaju poboljšanja ekonomskih planiranja 1939. godine u SSSR-u.
35.1 definicija lp problema
Problem linearnog programiranje može se razluciti na funkciju cilja te naogranicenja.
Funkcija cilja je linerna jednadžba n varijabli (x1, x2, ..., xn) definirana ko-eficijetima c1, c2, ..., cn.
f(x1, x2, ..., xn) =n∑i=1
ci · xi (35.1)
Jednadžba (35.1) može 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 koefi-cijenata linearne jednadžbe. Vektor x ∈ Ω ⊂ Rn predstavlja optimizacijskevarijable za koje se traži optimalno rješenje x∗ za koje vrijedi
f(x∗) 6 f(x), ∀x ∈ Ω (35.3)
Ogranicenja problema se mogu zadati kao sustav linearnih nejednadžbi: Nejednadžbe se moguzadavati sa razlicitimoperatorimausporedivanja (> i6), a mjenjanjeoperatora se možepostici množenjemcijele nejednandžbesa -1.
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 nejednadžbi (35.6) se može jednostavnije zapisati vektor-
ski
A · x > b (35.4)
169
170 linearno programiranje
Osim ogranicenja zadanih nejednakostima, ogranicenja se mogu zadati ilineanrim jednadžbama
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.Ogranicenja zadanjednakostima mogu
se zadavati i kaodvije identicnenejednakosti sa
suprotnim znakomnejednakosti (npr.x1+x2 > 0 i
x1+x2 6 0 je istošto i x1+x2 = 0)
U vektorskom zapisu sustav linearnih jednadžbi (35.6) glasi
D · x = E (35.5)
35.2 simpleks metoda
George Dantzig je 1947. godine, zajedno sa suradnicima iz americkog ratnogzrakoplovstva razvio simpleks metodu [15, 16].
35.3 rješavanje lp problema pomocu modula pulp
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 rješavanja LP problema pomocu modula PuLP
1 # -*- coding: utf-8 -*-
2
3 from pulp import *4
5 # Varijable
6 x = LpVariable("x", 0, 3)
7 y = LpVariable("y", 0, 1)
8
9 # LP problem
10 prob = LpProblem("myProblem", LpMinimize)
11
12 # Cilj
13 prob += -4*x + y
14
15 # Ogranicenja
16 prob += x + y <= 2
17 prob += x == y
18
19 # Rjesavanje
20 status = prob.solve()
21
22 # Ispis
23 print LpStatus[status]
24 print value(x)
25 print value(y)
35.4 prakticni primjeri lp problema
35.4 prakticni primjeri lp problema 171
35.4.1 Teretni zrakoplov
Zadatak 35.1 Teretni zrakoplov ima tri odjeljka za teret: prednji, centralni istražnji odjeljak. Odjeljci zrakoplova imaju ogranicenja s obzirom na masu ivolumen tereta koji mogu prihvatiti.
Odjeljak Dopuštena masa tereta [t] Skladišni prostor [m3]
Prednji 10 68
Centralni16 87
Stražnji 8 53
Masa tereta rasporedenog po odjeljcima mora biti proporcionalna dopuštenojmasi tereta za te odjeljke kako bi se zadržao balans zrakoplova.
Za transport zrakoplovom su dostupne cetri vrste tereta, koji svaki ima spe-cificiranu masu, obujam i profit.
Teret Masa [t] Obujam [m3/t] Zarada [AC]
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 pojedi-nog tereta treba ukrcati te kako ih distribuirati u odjeljke zrakoplova kako bi semaksimizirao ukupan profit leta.
Rješenje
Potrebno je odrediti mase svakog od cetri vrste tereta koje treba ukrcatiu svaki od tri odjeljaka. Neka je xij masa tereta i koji se ukrcava uodjeljak j.
x = (x11, x12, x13, x21, x22, x23, x31, x32, x33, x41, x42, x43)
U zrakoplov se ne može ukrcati više tereta nego što ga ima na raspo-laganju. To vrijedi za svaku od cetri vrste tereta.
x11 + x12 + x13 6 18
x21 + x22 + x23 6 15
x31 + x32 + x33 6 23
x41 + x42 + x43 6 12
Dopuštena ukupna masa tereta u svakom odjeljku ne smije biti pre-koracena.
x11 + x21 + x31 + x41 6 10
x12 + x22 + x32 + x42 6 16
x13 + x23 + x33 + x43 6 8
172 linearno programiranje
Prostorni (volumni) kapaciteti odjeljaka odreduje kolicine tereta kojise 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 + x4110
=
x12 + x22 + x32 + x4216
=
x13 + x23 + x33 + x438
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
(35.6)
Izvorni kod 35.2: Rješavanje problema transportnog zrakoplova
1 # -*- coding: utf-8 -*-
2
3 from pulp import *4
5 # Varijable
6 x11 = LpVariable("x11", 0)
7 x12 = LpVariable("x12", 0)
8 x13 = LpVariable("x13", 0)
9
10 x21 = LpVariable("x21", 0)
11 x22 = LpVariable("x22", 0)
12 x23 = LpVariable("x23", 0)
13
14 x31 = LpVariable("x31", 0)
15 x32 = LpVariable("x32", 0)
16 x33 = LpVariable("x33", 0)
17
18 x41 = LpVariable("x41", 0)
19 x42 = LpVariable("x42", 0)
20 x43 = LpVariable("x43", 0)
21
22 # LP problem
23 prob = LpProblem("Plane Cargo", LpMaximize)
24
25 # Cilj
26 prob += (x11 + x12 + x13)*310 + (x21 + x22 + x23)*380 + \
27 (x31 + x32 + x33)*350 + (x41 + x42 + x43)*285
28
29 # Ogranicenja
30 prob += x11 + x12 + x13 <= 18
31 prob += x21 + x22 + x23 <= 15
32 prob += x31 + x32 + x33 <= 23
33 prob += x41 + x42 + x43 <= 12
34
35.4 prakticni primjeri lp problema 173
35 prob += x11 + x21 + x31 + x41 <= 10
36 prob += x12 + x22 + x32 + x42 <= 16
37 prob += x13 + x23 + x33 + x43 <= 8
38
39 prob += 4.80*x11 + 6.50*x21 + 5.80*x31 + 3.90*x41 <= 68
40 prob += 4.80*x12 + 6.50*x22 + 5.80*x32 + 3.90*x42 <= 87
41 prob += 4.80*x13 + 6.50*x23 + 5.80*x33 + 3.90*x43 <= 53
42
43 prob += (x11 + x21 + x31 + x41)/10 == (x12 + x22 + x32 + x42)/16
44 prob += (x12 + x22 + x32 + x42)/16 == (x13 + x23 + x33 + x43)/8
45
46 # Rjesavanje
47 status = prob.solve()
48
49 # Ispis rjesenja
50 print ’Status:’, LpStatus[status]
51
52 for v in prob.variables():
53 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
36N E L D E R - M E A D M E T O D A
Nelder-Mead metoda, poznata kao Downhill simplex metoda ili Amoebametoda. Nelder-Mead metoda je tehnika za minimizaciju funkcije cilja uvišedimenzionalnom prostoru. Osnovnu ideju metode su osmislili John Nel-der i Roger Mead 1965. godine [8].
Pregled metode Metoda koristi koncept simpleksa, što je specijalni po-litop od n tocaka u n dimenzija. Politop je geometrijski oblik sa ravnimstranicama koji ekzistira u bilo kojem broju dimenzija. Poligon je politopu dvije dimenzije. Primjeri simpleksa su dužina na pravcu (1D), trokut uravnini (2D), tetraedron u prosotru (3D) itd. Metoda se zasniva na traže-nju uzorka koji usporeduje vrijednosti funkcije u svim tockama simpleksa.Najgora tocka se odbacuje i uvodi se nova tocka koja sa ostalima cini novisimpleks. Nalaženje nove toce simpleksa u svakoj iteraciji može uzrokovatiširenje ili smanjivanje raspona simpleksa. Smanjivanje simpleksa dovodi dokonvergencije (svih tocaka simpleksa) ka optimumu.
36.1 algoritam
Algoritam Nelder-Mead metode je unificiran za bilo koji broj optimizacijskihvarijabli.
1. Odredi n tocaka pocetnog simpleksax1, 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 težište svih tocaka osim najgore Pod najgoromtockom sepodrazumijeva tockau kojoj je vrijednostfunkcije najveca (kodproblemaminimizacije).
x0 =
n∑i=1
xi
n
? Izracunaj tocku refleksije i funkciju cilja u tocki refleksijexr = x0 +α(x0 − xn+1)
? Ako je funkcija cilja u tocki refleksije nije bolja od najbolje tockesimpleksa a bolja je od druge najgore tocke simpleksa Pod najboljom
tockom sepodrazumijeva tockau kojoj je vrijednostfunkcije najmanja(kod problemaminimizacije).
f(x1) 6 f(xr) 6 f(xn)onda:
– nova tocka simpleksa je tocka refleksije xr i mjenja najgorutocku xn+1
– idi na korak 1
5. EkspanzijaAko je tocka refleksije najboljaf(xr) < f(x1)
onda:
175
176 nelder-mead metoda
? izracunaj tocku ekspanzije i funkciju cilja u tocki ekspanzijexe = x0 + γ(x0 − xn+1)
? Ako je tocka ekspanzije bolja od tocke refleksijef(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. Kontrakcijaf(xr) > f(xn) Izracunaj tocku kontrakcije i funkciju cilja u tocki kon-trakcijexc = xn+1 + ρ(x0 − xn+1)
Ako je tocka kontrakcije bolja od najgore tockef(xc) < f(x(n+ 1))
onda
? nova tocka simpleksa postaje tocka kontrakcije xc? idi na korak 1
7. RedukcijaZa 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. Stan-dardno korištene vrijendosti su α = 1, γ = 2, ρ = 1/2 i σ = 1/2.
36.2 nelder-mead metoda za optimizaciju funkcije dviju va-rijabli
Slika 36.1: Tocke refleksije, ekspanzije, kontrakcije i redukcije kod Nelder-Mead metode optimi-zacije za funkciju dvije varijable. Tocke refleksije, ekspanzije ili kontrakcije mjenjajunajgoru tocku simpleksa, dok tocke redukcije mjenjaju dvije nagore tocke simpleksa.
36.2 nelder-mead metoda za optimizaciju funkcije dviju varijabli 177
Simpleks koji se koristi kod Nelder-Mead metode optimizacije funkcijedviju varijabli jest trokut (Slika 36.1). Za svaki korak iteracije izracunava senovi simpleks ondnosno trokut na nacin da se mjenja najgora tocka starogtrokuta, odnosno dvije najgore tocke u slucaju redukcije.
Izvornom kodu 36.1 vizualizira svaki korak metode na primjeru rješava-nje 2D funkcije cilja.
Izvorni kod 36.1: Primjer 2D optimizacije Nelder-Mead metodom
1 # -*- coding: utf-8 -*-
2 """
3 Nelder-Mead metoda
4 """
5
6 import numpy as np
7 import matplotlib.pyplot as plt
8 from matplotlib import animation
9
10 def f(x):
11 return np.sin(x[0]/20.0)/(x[0]**2.0/1000.0 + 1)*np.cos(x[1]/50.0)
12 #return x[0]**2.0 + x[1]**2.0
13
14
15 X,Y = np.meshgrid(np.arange(-60,60,2), np.arange(-60,60,2))
16 Z = np.sin(X/20.0)/(X**2.0/1000.0 + 1)*np.cos(Y/50.0)
17
18 fig = plt.figure()
19 contour_plot = plt.contourf(X, Y, Z, 150, # [-1, -0.1, 0, 0.1],
20 #alpha=0.5,
21 #cmap=plt.cm.bone,
22 #origin=origin
23 )
24
25
26 # Postavke metode
27 alpha = 1.0
28 beta = 0.5
29 gamma = 2.0
30 delta = 0.5
31 maxiter = 15
32 eps = 0.0001
33
34 # Pocetne tocke
35 A0 = [-50, 50]
36 B0 = [-50, -50]
37 C0 = [50, 50]
38
39 A0.append(f(A0))
40 B0.append(f(B0))
41 C0.append(f(C0))
42
43 # Formiranje trokuta pomocu matrice
44 T = [A0, B0, C0]
45 xline = [A0[0], B0[0], C0[0], A0[0]]
46 yline = [A0[1], B0[1], C0[1], A0[1]]
47 simpleks, = plt.plot(xline, yline, ’k-o’)
48
49 def init():
50 xline = [A0[0], B0[0], C0[0], A0[0]]
51 yline = [A0[1], B0[1], C0[1], A0[1]]
52 simpleks, = plt.plot(xline, yline, ’-o’)
53
54 return simpleks
55
56 # Glavna petlja metode
57 def iteration(it):
178 nelder-mead metoda
58 Ts = sorted(T, key=lambda point: point[2])
59
60 B = np.array(Ts[0])
61 S = np.array(Ts[1])
62 W = np.array(Ts[2])
63
64 M = (B + S) / 2.0
65
66 # Refleksija
67 R = M + alpha * (M - W)
68 R[2] = f(R)
69
70 if R[2] >= B[2] and R[2] < S[2]:
71 W = np.copy(R)
72
73 elif R[2] < B[2]:
74 # Ekspanzija
75 E = M + gamma * (R - M)
76 E[2] = f(E)
77
78 if E[2] < R[2]:
79 W = np.copy(E)
80 else:
81 W = np.copy(R)
82
83 elif R[2] >= S[2]:
84
85 if R[2]< W[2]:
86 # Kontrakcija vanjska
87 C = M + beta*(W-M)
88 C[2] = f(C)
89
90 if C[2] <= R[2]:
91 W = np.copy(C)
92 else:
93 # Shrink
94 W = B + delta * (W - B)
95 W[2] = f(W)
96
97 S = B + delta * (S - B)
98 S[2] = f(S)
99
100 else:
101 # Kontrakcija unutarnja
102 C = M - beta * (W - M)
103 C[2] = f(C)
104
105 if C[2] < W[2]:
106 W = np.copy(C)
107 else:
108 # Shrink
109 W = B + delta * (W - B)
110 W[2] = f(W)
111
112 S = B + delta * (S - B)
113 S[2] = f(S)
114
115 T[0] = B
116 T[1] = S
117 T[2] = W
118
119 xline = [B[0], S[0], W[0], B[0]]
120 yline = [B[1], S[1], W[1], B[1]]
121 simpleks.set_data(xline, yline)
122
123 #plt.savefig(’iteration%02d.pdf’ % it)
124 return simpleks
36.2 nelder-mead metoda za optimizaciju funkcije dviju varijabli 179
125
126 Writer = animation.writers[’ffmpeg’]
127 writer = Writer(fps=2, metadata=dict(artist=’Stefan’), bitrate=3600)
128
129 anim = animation.FuncAnimation(fig, iteration, #init_func=init,
130 frames=maxiter, interval=2, repeat=False)
131
132 anim.save(’nelder-mead.avi’, writer=writer)
133 plt.show()
134
135 Ts = sorted(T, key=lambda point: point[2])
136 print Ts[0]
137 print Ts[1]
138 print Ts[2]
[ -2.08786964e+01 4.72068787e-03 -6.01976050e-01]
[ -2.08750000e+01 -2.99504027e-03 -6.01976025e-01]
[ -2.08756335e+01 8.40537250e-03 -6.01976024e-01]
60 40 20 0 20 4060
40
20
0
20
40
Slika 36.2: Izgled simpleksa u 5 iteraciji (za izvorni kod 36.1).
37S I M U L I R A N O K A L J E N J E
Simulirano kaljenje je stohasticka optimizacijska metoda namjenjena rješa-vanju problema globalne optimizacije. 1983. godine su Kirkpatrick, Gelatt iVecchi [7], te Cerny 1985. [2] godine su osmislili i postavili osnovnu idejumetode.
Metoda emulira proces kaljenja celika gdje se zagrijano tijelo polako hladii mijenja svoju strukturu te u konacnom ohladenom stanju doseže konfigu-raciju 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 − fi4. Odredi vjerojatnost prihvacanja novog stanja (xi+1)
p(T) =
1 ako je ∆f < 0
e−∆fTi ako je ∆f > 0
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 blizinistare. Vecina algoritama simuliranog kaljenja automatski reducira ∆x tije-kom samog procesa optimizacije kako bi se u pocetku pokrivalo što vecepodrucje (global search) a kasnije osigurala što brža konvergencija (local se-arch).
Funkcija α(T) je funkcija hladenja i najcešce se kostiti α(T) = r · T gdje je0 < r < 1.
37.2 primjer simuliranog kaljenja pomocu modula inspyred
Izvorni kod 37.1: Primjer simuliranog kaljenja pomocu modula inspyred
1 # -*- coding: utf-8 -*-
2 """
3 Simulirano kaljenje
4 """
5
6 from random import Random
181
182 simulirano kaljenje
7 from time import time
8 import inspyred
9 from numpy import *10 from matplotlib.pyplot import *11
12 F=[]
13
14 def f(X):
15 fit = 10.0 * len(X)
16 for x in X:
17 fit += (x**2.0 - 10.0*cos(2.0*pi*x))
18 return float(fit)
19
20 def generate(random, args):
21 size = args.get(’num_inputs’, 10)
22 return [random.uniform(-5.12, 5.12) for i in range(size)]
23
24 def evaluate(candidates, args):
25 fitness = []
26 for cs in candidates:
27 fitness.append(f(cs))
28 return fitness
29
30 def observe(population, num_generations, num_evaluations, args):
31 best = min(population)
32 #print ’%10d > %.4e’ % (num_generations, best.fitness)
33 F.append(best.fitness)
34
35 prng = Random()
36 prng.seed(time())
37
38 ea = inspyred.ec.SA(prng)
39 ea.terminator = inspyred.ec.terminators.evaluation_termination
40 ea.observer = observe
41 final_pop = ea.evolve(evaluator = evaluate,
42 generator = generate,
43 maximize = False,
44 bounder = inspyred.ec.Bounder(-5.12, 5.12),
45 max_evaluations = 3000,
46 temperature = 1000.0,
47 cooling_rate = 0.5)
48
49 best = min(final_pop)
50 print(’Najbolje rjesenje: \n0’.format(str(best)))
51
52 plot(F)
53 xlabel(’iteracije’)
54 xlabel(’f’)
55 grid()
56 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
37.2 primjer simuliranog kaljenja pomocu modula inspyred 183
0 500 1000 1500 2000 2500 3000f
0
50
100
150
200
Slika 37.1: Konvergencija optimizacije pomocu simuliranog kaljenja
38O P T I M I Z A C I J A R O J E M C E S T I C A
38.1 razvoj metode
Optimizacija rojem cestica (Particle Swarm Optimization, PSO) je stohastickaoptimizacijska metoda temeljena na idejama opaženim na kretanju jata irojeva.
Reynolds[11] je 1987. godine predložio model ponašanja jata, prema ko-jem se svaki clan jata ponaša prema slijedecim pravilima:
? Držanje razmaka - svaki clan jata se pokušava udaljiti od susjednihako su mu oni preblizu,
? Prilagodavanje smjera - svaki clan jata giba se u usrednjenom smjerukretanja svojih susjeda,
? Kohezija - svaki clan jata ostaje blizu svojih susjeda tj. ostaje u jatu.
Kennedy i Eberhart[6] su dodali ’gnijezdo’ u pojednostavljenu simulacijutemeljenu na Reynoldsovom modelu. Simulacija je obuhvacala sljedece utje-caje gnijezda na jedinke jata:
? gnijezdo privlaci svaku jedinku,
? Svaka jedinka pamti gdje je bila najbliža gnijezdu.
? Svaka jedinka razmijenjuje informacije sa susjedima o lokaciji najbližojgnijezdu.
Nakon dovoljno vremena provodenja simulacije, sve su jedinke došle do’legla’.
Postavlja se pitanje što se dešava sa sustavom ako se gnjezdo giba premanepoznatoj funkciji? Da li ce jedinke stici do gnjezda?
vt+1i = vti +φ1Ut1(pbti − xti) +φ2Ut2(gbt − xti) (38.1)
xt+1i = xti + vt+1i (38.2)
Shi i Eberhart[12] uvode inerciju cestice koja je kontrolirana preko faktorainercije wt.
vt+1i = wtvti +φ1Ut1(pbti − xti) +φ2Ut2(gbt − xti) (38.3)
Slika 38.1: Ponašanje jedinki u Reynoldsovom modelu. Odvajanje, usmjeravanje i kohezija.
185
186 optimizacija rojem cestica
Slika 38.2: Utjecaj gnjezda na jedinke jata.
U osnovnom obliku, faktor inercije je konstantan u vremenu wt = w. U slu-caju w > 1, brzine cestica rastu u vremenu (cestice ubrzavaju) a formacijaroja divergira. Usporavanje cestica i smanjivanje brzine do nule postiže se saw < 1. Veci faktor inercije omogucava lakše globalno pretraživanje, sa pove-canjem rasapa cestica, dok manji w omogucuje bolje lokalno pretraživanjei bržu konvergenciju. Odabir faktora inercije treba temeljiti na karkateristi-kama funkcije cilja i svodi se na balansiranje širine pretraživanja i brzinekonvergencije.
Prema [14]
w >c1 + c22
− 1 (38.4)
garantira konvergenciju putanja cestica, a prema [1] preporuceni faktor iner-cije je w = 0.73.
38.2 korištenje pso metode pomocu modula inspyred
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 from random import Random
3 from time import time
4 from math import cos, pi
5 import inspyred
6
7 # Random generiranje
8 def generate_rastrigin(random, args):
9 size = args.get(’num_inputs’, 10)
10 return [random.uniform(-5.12, 5.12) for i in range(size)]
11
12 # Evaluacija (funkcija cilja)
13 def evaluate_rastrigin(candidates, args):
14 fitness = []
15 for cs in candidates:
16 fit = 10 * len(cs) + sum([((x - 1)**2 - 10 * cos(2 * pi * (x - 1))) for x
in cs])
17 fitness.append(fit)
18 return fitness
19
20
21 rand = Random()
22 rand.seed(int(time()))
23 pso = inspyred.swarm.PSO(rand)
24 pso.terminator = inspyred.ec.terminators.evaluation_termination
38.2 korištenje pso metode pomocu modula inspyred 187
25
26 final_pop = pso.evolve(generator=generate_rastrigin,
27 evaluator=evaluate_rastrigin,
28 pop_size=100,
29 maximize=False,
30 bounder=inspyred.ec.Bounder(-5.12, 5.12),
31 max_evaluations=20000,
32 mutation_rate=0.25,
33 num_inputs=5)
34
35 # Sort and print the best individual, who will be at index 0.
36 final_pop.sort(reverse=True)
37 print(final_pop[0])
39G E N E T I C K I A L G O R I T M I
Geneticki algoritam (GA) je adaptivni heuristicni algoritam traženja baziranna evolucijskim idejama prirodne selekcije i genetike. Kao takav predstav-lja inteligentno iskorištavanje nasumicnog traženja za rješavanje optimizacij-skih problema.
39.1 evolucijski algoritmi
50-ih i 60-ih godina 20. stoljeda nekoliko znanstvenika na podrucju racunar-stva nezavisno su proucavali evolucijske sustave sa idejom da se evolucijakoristi kao optimizacijski alat za inženjerske probleme. Ideja u svim timsustavima bila je da populacija kandidacijskih rješenja evoluira ka optimal-nom rješenju zadanog problema, koristeci operatore inspirirane prirodnomgenetskom varijacijom i prirodnom selekcijom.
Profesor John Holland, na sveucilištu u Michiganu, došao na ideju ge-netskog algoritma, koju je razvijao 60-ih i 70-ih godina zajedno sa svojimstudentima i kolegama. Hollandov cilj nije bilo dizajniranje algoritma za rje-šavanje specificnih problema, vec proucavanje fenomena adaptacije kakav sepojavljuje u prirodi, te razviti nacine kako mehanizme prirodne adaptacijeprimjeniti u racunalnim sustavima. 1975 Holland je prvi koristio naziv „ge-netski algoritam“ u knjizi „Adaptation in Natural and Artificial Systems“.John Henry Holland smatra se ocem genetskih algoritama. 1989 David Gol-dberg sa sveucilišta u Illinoisu primijenio je Hollandovu ideju na razlicitainženjerska podrucja. Goldberg: „Three billion years of evolution can’t bewrong. It’s the most powerful algorithm there is.“.
Današnji moderni genetski algoritam svrstava se u evolucijske algoritme,koji sadržavaju široki spektar mehanizama koji oponašaju procese prirodneevolucije, gdje je glavni koncept opstanak najjaceg. Današnji najkorištenijievolucijski 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 po-našanja u evoluciji (phenotypic evolution).
? Evolucijske strategije su usmjerene prema modeliranju strategije para-metara koji kontroliraju varijaciju u evoluciji, cesto nazivano „Evolu-cija evolucije“.
? Diferencijalna evolucija, koja je slicna genetskim algoritmima ali razli-kuje se po korištenim mehanizmima reprodukcije.
? Kulturalna evolucija, modelira evoluciju kulture populacije i kako kul-tura utjece na genetsku i fenotipnu evoluciju jedinki.
? Koevolucija, namjerno „glupe“ jedinke evoluiraju kroz kooperaciju, ilikroz nadmetanje jedne sa drugom, a pritom stjecu potrebne karakte-ristike kako bi preživjele.
189
190 geneticki algoritmi
39.2 korištenje deap modula
DEAP je Python modul za evolucijsko racunanje. [9, 4] Namjenjen je razvojunovih algoritama te brzo i lako testiranje novih ideja. Osim mogucnosti iz-rade vlastitih algoritma, DEAP nudi gotove algoritme:
? Geneticki algoritam (GA)
? Geneticko programiranje (GP)
? Evolucijske strategije (ES)
? Optimizacija rojem cestica (PSO) (vidi poglavlje 38)
Osim podrške za evolucijske metode, DEAP pruža mogucnost detaljnog ifleksibilnog 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 # -*- coding: utf-8 -*-
2 """
3 Created on Wed Dec 18 15:15:56 2013
4
5 @author: stefan
6 """
7
8 import random
9
10 from deap import base
11 from deap import creator
12 from deap import tools
13 from deap import algorithms
14 import matplotlib.pyplot as plt
15 import numpy as np
16
17 DIMS = 10
18 LB = -100.0*np.ones(DIMS)
19 UB = 100*np.ones(DIMS)
20
21 # Funkcija cilja
22 # Rosenbrock funkcija
23 def evaluate(x):
24 x = np.array(x)
25 s = sum(100.0*(x[1:]-x[:-1]**2.0)**2.0 + (1-x[:-1])**2.0)
26 return s,
27
28 # Definicija funkcije korekcije
29 # Korigira gornju i donju granicu varijabli
30 def checkBounds(lb, ub):
31 def decorator(func):
32 def wrapper(*args, **kargs):
33 offspring = func(*args, **kargs)
34 for child in offspring:
35 for i in xrange(len(child)):
36 if child[i] > ub[i]:
37 child[i] = ub[i]
38 elif child[i] < lb[i]:
39 child[i] = lb[i]
40 return offspring
41 return wrapper
42 return decorator
43
39.2 korištenje deap modula 191
44 # Kreiranje minimizacijskog problema
45 creator.create("FitnessMax", base.Fitness, weights=(-1.0,))
46 # Definicija jedinki
47 creator.create("Individual", list, fitness=creator.FitnessMax)
48
49 toolbox = base.Toolbox()
50
51 # Registracija optimizacijske varijable
52 toolbox.register("attr_float", random.uniform, -100.0, 100.0)
53 # Registriracija jedinke
54 toolbox.register("individual", tools.initRepeat, creator.Individual, toolbox.
attr_float, DIMS)
55 # Registracija populacije
56 toolbox.register("population", tools.initRepeat, list, toolbox.individual)
57
58
59 # Registracija funkcije cilja
60 toolbox.register("evaluate", evaluate)
61 # Registracija operatora križanja
62 toolbox.register("mate", tools.cxTwoPoints)
63 # Registracija korekcije poslije križanja
64 toolbox.decorate("mate", checkBounds(LB, UB))
65 # Resgistracija mutacije
66 toolbox.register("mutate", tools.mutGaussian, mu=0, sigma=1, indpb=0.1)
67 # Registracija korekcije poslije mutacije
68 toolbox.decorate("mutate", checkBounds(LB, UB))
69 # Registracija metode selekcije
70 toolbox.register("select", tools.selTournament, tournsize=3)
71
72 # Kreiranje populacije jedinki
73 pop = toolbox.population(n=250)
74 # Definiraj pamcenje jedne najbolje jedinke
75 hof = tools.HallOfFame(1)
76
77 # Statisticko pracenje algoritma
78 stats = tools.Statistics(lambda ind: ind.fitness.values)
79 stats.register("avg", tools.mean)
80 stats.register("std", tools.std)
81 stats.register("min", min)
82 stats.register("max", max)
83
84 # Pokretanje algoritma
85 algorithms.eaSimple(pop, toolbox, cxpb=0.75, mutpb=0.8, ngen=200, stats=stats,
86 halloffame=hof, verbose=True)
87
88 # Ispis najbolje jedinke
89 print hof
90
91 # Crtanje grafa konvergencije
92 fig = plt.figure()
93 ax = fig.add_subplot(1,1,1)
94 ax.set_yscale(’log’)
95 plt.plot(stats.data[’min’][0], ’-g’, label = ’min’)
96 plt.plot(stats.data[’avg’][0], ’-b’, label = ’avg’)
97 plt.plot(stats.data[’max’][0], ’-r’, label = ’max’)
98 plt.grid()
99 plt.legend()
100 plt.show()
gen evals std max avg min
0 250 [8.138e+09] [4.366e+10] [1.676e+10] [9.85e+08]
1 241 [5.711e+09] [2.543e+10] [1.055e+10] [6.183e+08]
2 240 [3.454e+09] [1.832e+10] [6.01e+09] [6.183e+08]
3 238 [1.913e+09] [1.194e+10] [3.19e+09] [3.502e+08]
4 237 [9.443e+08] [4.473e+09] [1.735e+09] [2.265e+08]
5 235 [5.374e+08] [3.477e+09] [1.015e+09] [1.64e+08]
6 239 [2.739e+08] [1.794e+09] [6.411e+08] [1.211e+08]
192 geneticki algoritmi
7 237 [1.672e+08] [9.866e+08] [4.233e+08] [1.249e+08]
8 238 [9.335e+07] [6.107e+08] [3.006e+08] [9.78e+07]
9 234 [6.907e+07] [4.452e+08] [2.184e+08] [8.422e+07]
10 244 [4.674e+07] [3.436e+08] [1.652e+08] [4.803e+07]
11 234 [3.899e+07] [2.573e+08] [1.259e+08] [4.305e+07]
12 236 [3.2e+07] [2.203e+08] [9.343e+07] [3.412e+07]
13 241 [1.952e+07] [1.377e+08] [6.896e+07] [2.664e+07]
14 238 [1.461e+07] [1.085e+08] [5.295e+07] [1.134e+07]
15 243 [1.133e+07] [8.049e+07] [4.122e+07] [1.115e+07]
16 230 [8.692e+06] [5.624e+07] [3.121e+07] [8.309e+06]
17 235 [7.148e+06] [5.685e+07] [2.289e+07] [5.22e+06]
18 239 [5.664e+06] [3.561e+07] [1.715e+07] [5.233e+06]
19 235 [4.503e+06] [2.791e+07] [1.25e+07] [4.354e+06]
20 235 [2.689e+06] [2.033e+07] [8.937e+06] [4.219e+06]
21 233 [1.738e+06] [1.318e+07] [6.871e+06] [3.476e+06]
22 234 [9.617e+05] [9.931e+06] [5.427e+06] [3.49e+06]
23 236 [6.41e+05] [7.87e+06] [4.707e+06] [3.324e+06]
24 241 [5.806e+05] [5.958e+06] [4.204e+06] [2.497e+06]
25 235 [6.607e+05] [6.073e+06] [3.807e+06] [1.906e+06]
26 238 [5.783e+05] [5.22e+06] [3.303e+06] [1.797e+06]
27 236 [5.321e+05] [5.234e+06] [2.786e+06] [1.639e+06]
28 234 [4.515e+05] [3.899e+06] [2.35e+06] [1.186e+06]
29 234 [3.543e+05] [3.36e+06] [1.991e+06] [8.656e+05]
30 237 [2.97e+05] [2.796e+06] [1.738e+06] [8.762e+05]
31 242 [2.645e+05] [2.49e+06] [1.509e+06] [7.125e+05]
32 234 [2.519e+05] [2.296e+06] [1.293e+06] [6.843e+05]
33 234 [2.091e+05] [1.684e+06] [1.108e+06] [6.358e+05]
34 237 [1.942e+05] [1.68e+06] [9.355e+05] [4.7e+05]
35 242 [1.551e+05] [1.439e+06] [8.028e+05] [4.176e+05]
36 237 [1.357e+05] [1.268e+06] [6.795e+05] [3.876e+05]
37 235 [1.102e+05] [8.952e+05] [5.743e+05] [3.197e+05]
38 241 [9.698e+04] [8.459e+05] [4.92e+05] [2.626e+05]
39 244 [7.705e+04] [7.722e+05] [4.153e+05] [2.147e+05]
40 234 [7.128e+04] [6.02e+05] [3.643e+05] [1.835e+05]
41 246 [6.495e+04] [5.171e+05] [3.15e+05] [1.489e+05]
42 235 [5.698e+04] [4.734e+05] [2.66e+05] [1.359e+05]
43 238 [5.898e+04] [6.019e+05] [2.248e+05] [1.102e+05]
44 239 [3.92e+04] [3.411e+05] [1.868e+05] [1.063e+05]
45 239 [3.232e+04] [3.309e+05] [1.6e+05] [8.606e+04]
46 234 [2.677e+04] [2.427e+05] [1.392e+05] [6.186e+04]
47 232 [2.274e+04] [2.095e+05] [1.215e+05] [6.204e+04]
48 241 [2.193e+04] [1.912e+05] [1.061e+05] [5.615e+04]
49 237 [1.737e+04] [1.565e+05] [9.149e+04] [4.468e+04]
50 238 [1.688e+04] [1.627e+05] [7.915e+04] [4.597e+04]
51 242 [1.307e+04] [1.44e+05] [6.853e+04] [4.181e+04]
52 229 [1.245e+04] [1.222e+05] [6.11e+04] [3.93e+04]
53 239 [1.075e+04] [1.124e+05] [5.482e+04] [3.562e+04]
54 239 [8887] [1.352e+05] [4.914e+04] [3.23e+04]
55 225 [7171] [7.923e+04] [4.539e+04] [3.234e+04]
56 233 [7837] [1.011e+05] [4.241e+04] [3.092e+04]
57 230 [6770] [9.115e+04] [3.89e+04] [2.606e+04]
58 242 [4400] [5.14e+04] [3.55e+04] [2.345e+04]
59 238 [5340] [6.22e+04] [3.342e+04] [2.177e+04]
60 233 [7401] [8.657e+04] [3.168e+04] [2.028e+04]
61 240 [5802] [6.033e+04] [2.803e+04] [1.973e+04]
62 240 [6684] [8.118e+04] [2.584e+04] [1.533e+04]
63 231 [5612] [7.537e+04] [2.368e+04] [1.533e+04]
64 240 [5351] [5.62e+04] [2.216e+04] [1.386e+04]
65 236 [3744] [4.749e+04] [2.02e+04] [1.244e+04]
66 241 [4260] [5.345e+04] [1.885e+04] [1.27e+04]
67 240 [3062] [3.483e+04] [1.725e+04] [1.239e+04]
68 233 [2475] [2.889e+04] [1.555e+04] [1.041e+04]
69 238 [3295] [4.651e+04] [1.477e+04] [1.041e+04]
70 236 [2922] [3.337e+04] [1.401e+04] [8998]
71 230 [2645] [3.777e+04] [1.323e+04] [8433]
72 242 [3215] [4.977e+04] [1.244e+04] [7378]
73 236 [2562] [3.043e+04] [1.152e+04] [6977]
39.2 korištenje deap modula 193
74 237 [2283] [2.74e+04] [1.072e+04] [6996]
75 238 [2489] [2.563e+04] [1.008e+04] [4771]
76 239 [2032] [2.137e+04] [9035] [4002]
77 238 [1637] [1.356e+04] [8000] [3826]
78 239 [2292] [1.971e+04] [7353] [3792]
79 235 [2040] [2.641e+04] [6200] [3739]
80 234 [3623] [3.688e+04] [5974] [2730]
81 241 [1986] [1.705e+04] [4968] [2022]
82 240 [2757] [2.914e+04] [4753] [1755]
83 238 [1986] [1.912e+04] [4180] [1001]
84 242 [2064] [1.878e+04] [3743] [1017]
85 237 [1369] [1.267e+04] [3069] [804.6]
86 244 [3604] [4.884e+04] [3013] [908.5]
87 241 [2782] [3.149e+04] [2625] [856]
88 238 [1717] [1.656e+04] [2124] [686.6]
89 243 [1238] [1.472e+04] [1745] [715]
90 230 [2571] [2.544e+04] [1894] [436.2]
91 244 [4126] [5.141e+04] [1922] [315.4]
92 239 [1784] [1.27e+04] [1471] [275.5]
93 241 [3300] [4.286e+04] [1414] [132.2]
94 243 [2112] [2.661e+04] [1246] [90.83]
95 234 [1190] [9698] [956.8] [81.2]
96 239 [1216] [9830] [816.8] [76.04]
97 235 [1446] [1.128e+04] [736.9] [81.2]
98 239 [1419] [1.155e+04] [638.8] [31.3]
99 237 [2335] [3.506e+04] [636] [29.87]
100 233 [1694] [1.367e+04] [808.3] [29.93]
101 239 [2725] [3.562e+04] [677] [24.3]
102 238 [904.7] [6506] [439.6] [33.82]
103 230 [1020] [7747] [422.4] [24.77]
104 239 [1850] [1.988e+04] [643.3] [12.46]
105 238 [1275] [1.218e+04] [459.7] [10.9]
106 243 [1501] [1.328e+04] [563.6] [10.9]
107 239 [1411] [1.284e+04] [524.7] [10.9]
108 240 [588.3] [4070] [288.2] [10.2]
109 238 [1348] [1.315e+04] [445.2] [10.2]
110 238 [1954] [1.643e+04] [634.8] [10.95]
111 241 [876.8] [7940] [345.1] [8.495]
112 236 [1800] [2.136e+04] [537.7] [8.495]
113 237 [1454] [1.53e+04] [538.4] [8.495]
114 236 [1755] [1.268e+04] [584.9] [8.495]
115 241 [1623] [1.681e+04] [521.7] [7.986]
116 236 [1154] [1.077e+04] [427.5] [9.09]
117 232 [1236] [1.046e+04] [507.4] [7.984]
118 235 [1733] [1.446e+04] [531.4] [7.984]
119 236 [964.4] [1.038e+04] [334.3] [7.829]
120 239 [886] [6653] [316.1] [7.829]
121 240 [855.8] [4878] [351.3] [7.829]
122 238 [958.2] [9124] [341.1] [7.829]
123 235 [1769] [1.818e+04] [526.3] [7.829]
124 238 [1070] [1.007e+04] [330.1] [8.119]
125 240 [629.2] [5382] [263.6] [8.119]
126 241 [1230] [1.394e+04] [365.8] [8.379]
127 241 [1356] [1.548e+04] [423.5] [6.521]
128 232 [1345] [1.174e+04] [428.2] [6.521]
129 239 [1718] [1.816e+04] [501] [6.521]
130 245 [884.6] [8338] [339.4] [6.435]
131 236 [2529] [3.469e+04] [522.1] [7.612]
132 238 [991.9] [7635] [363.4] [5.994]
133 241 [1205] [1.271e+04] [371.4] [5.602]
134 243 [1302] [1.004e+04] [451.9] [5.486]
135 235 [931.8] [7436] [376] [4.942]
136 242 [2047] [2.631e+04] [584.8] [4.822]
137 237 [1823] [1.76e+04] [605.4] [4.942]
138 231 [1165] [1.159e+04] [393.9] [4.946]
139 240 [1321] [1.059e+04] [510.3] [5.019]
140 238 [1145] [1.02e+04] [418] [4.946]
194 geneticki 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,))]
39.2 korištenje deap modula 195
0 50 100 150 200100
101
102
103
104
105
106
107
108
109
1010
1011
minavgmax
Slika 39.1: Konvergencija optimizacije genetickim algoritmom (Izvorni kod 39.1)
Dio VII
D O D A C I
AK 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 Jun 11 17:21 slika_000.png
-rw-r--r-- 1 stefan users 120415 Jun 11 17:24 slika_001.png
-rw-r--r-- 1 stefan users 116858 Jun 11 17:26 slika_002.png
-rw-r--r-- 1 stefan users 113018 Jun 11 17:29 slika_003.png
-rw-r--r-- 1 stefan users 114172 Jun 11 11:10 slika_004.png
-rw-r--r-- 1 stefan users 114172 Jun 11 11:21 slika_005.png
-rw-r--r-- 1 stefan users 114172 Jun 11 11:32 slika_006.png
-rw-r--r-- 1 stefan users 111188 Jun 11 11:43 slika_007.png
-rw-r--r-- 1 stefan users 110868 Jun 11 11:54 slika_008.png
-rw-r--r-- 1 stefan users 110868 Jun 11 12:05 slika_009.png
-rw-r--r-- 1 stefan users 110868 Jun 11 12:16 slika_010.png
-rw-r--r-- 1 stefan users 110868 Jun 11 12:27 slika_011.png
-rw-r--r-- 1 stefan users 113035 Jun 11 12:38 slika_012.png
stefan@fuji:~> ffmpeg -r 5 -i slika_%03d.png \
> -c:v libx264 -r 30 -pix_fmt yuv420p video.mp4
Detaljnije objašnjenje svih argumenata naredbe:
? -r 5 oznacava ulazni frame rate tj. koliko ce ulaznih slika biti u sekundividea.
? -i slika_%03d.png definicija imena ulaznih datoteka/slika.
? -c:v libx264 definiranje video codeca.
? -pix_fmt yuv420p korištenje YÚV420p formata pixela prilikom pre-tvorbe slika.
? -r 30 oznacava izlazni frame rate tj. frame rate videa.
?
omogucuje nastavak pisanja naredbe u sljedecoj liniji.
a.2 pracenje promjena tekstualnih datoteka
Cesto se prilikom izvodenja numerickih proracuna ili simulacija važne infor-macije o tijeku i napredku proracuna bilježe u tekstualne datoteke. Za lakšelokalno i posebice udaljeno pracenje promjene tekstualne datoteke putemterminala koristi se naredba tail.
Primjer dinamickog pracenja tekstualne datoteke:
tail -f log.txt
Primjer dinamickog pracenja prvih 100 znakova u novim linijama tekstu-alne datoteke:
tail -f log.txt | cut -b 1-100
199
BB I B L I O G R A F I J A
[1] Daniel Bratton and James Kennedy. Defining a standard for particle swarm optimization. In SwarmIntelligence Symposium, 2007. SIS 2007. IEEE, pages 120–127. IEEE, 2007.
[2] Vladimír Cerny. Thermodynamical approach to the traveling salesman problem: An efficient simula-tion algorithm. Journal of optimization theory and applications, 45(1):41–51, 1985.
[3] M.H. Chaudry. Open-channel flow. Springer Science+Business Media, 2008.
[4] Félix-Antoine Fortin, François-Michel De Rainville, Marc-André Gardner, Marc Parizeau, and ChristianGagné. Deap: Evolutionary algorithms made easy. Journal of Machine Learning Research, 13:2171–2175,2012.
[5] L. V. Kantorovic. Mathematical methods of organizing and planning prodution. Management Science, 6:363–422, 1960. (in Russian 1939).
[6] J. Kennedy and R. Eberhart. Particle swarm optimization. In Neural Networks, 1995. Proceedings., IEEEInternational Conference on, volume 4, pages 1942–1948. IEEE, 1995.
[7] Scott Kirkpatrick, D. Gelatt Jr., and Mario P Vecchi. Optimization by simmulated annealing. science,220(4598):671–680, 1983.
[8] J. A. Nelder and R. Mead. A simplex method for function minimization. Computer Journal, 7:308–313,1965.
[9] De Rainville, Félix-Antoine Fortin, Marc-André Gardner, Marc Parizeau, Christian Gagné, et al. Deap:A python framework for evolutionary algorithms. In Proceedings of the fourteenth international conferenceon Genetic and evolutionary computation conference companion, pages 85–92. 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 Com-puter Graphics, volume 21, pages 25–34. 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, pages69–73. 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, Universityof Pretoria, Pretoria, 2001.
[15] M. K. Wood and G. B. Dantzig. Programming of Interdependent Activities. I. General Discussion.Econometrica, 17:193–199, 1949.
[16] M. K. Wood and G. B. Dantzig. Programming of Interdependent Activities. I. Mathematical Model.Econometrica, 17:200–211, 1949.
201
colophon
This work is licensed under a Creative Commons Attribution-ShareAlike3.0 Unported License.
http://creativecommons.org/licenses/by-sa/3.0/
This document was typeset using the typographical look-and-feel classicthesisdeveloped by André Miede. The style was inspired by Robert Bringhurst’sseminal book on typography “The Elements of Typographic Style”. classicthesisis available for both LATEX and LYX:
http://code.google.com/p/classicthesis/
Final Version as of 14. sijecnja 2015. (classicthesis v0.1).