Uvod u

Python

Adnan Mehremić, MA, dipl. ing. el.

KULTURNI CENTAR KRALJ FAHD
Sadržaj

Sadržaj .................................................................................................................................................... 2
Predgovor ................................................................................................................................................ 4
Kratak pregled......................................................................................................................................... 5
Python verzije i radno okruženje ............................................................................................................ 6
1. Uvod u programiranje ..................................................................................................................... 7
1.1. Dijagram toka.......................................................................................................................... 7
1.2. Pseudo kod .............................................................................................................................. 9
2. Ulazno izlazne funkcije................................................................................................................. 10
2.1. Funkcija print() ..................................................................................................................... 10
2.2. Funkcija input() ..................................................................................................................... 13
Primjeri ................................................................................................................................................. 15
3. Elementi programskog jezika Python ........................................................................................... 16
3.1. Promjenljive/varijable ........................................................................................................... 16
3.2. Brojevi................................................................................................................................... 18
3.2.1. Cijeli brojevi ................................................................................................................. 18
3.2.2. Brojevi u pokretnom zarezu .......................................................................................... 21
3.2.3. Stringovi ............................................................................................................................ 21
Primjeri ................................................................................................................................................. 30
4. Strukture podataka ........................................................................................................................ 31
4.1. Liste....................................................................................................................................... 31
4.2. Uređeni parovi (n-torke) ....................................................................................................... 36
4.3. Rječnici ................................................................................................................................. 39
5. Upravljanje tokom programa ........................................................................................................ 44
5.1. Komentari ............................................................................................................................. 44
5.2. Poređenjem naredbama if, elif i else ..................................................................................... 45
5.3. Ponavljanje pomoću while naredbe ...................................................................................... 50
5.4. Ponavljanje pomoću for naredbe........................................................................................... 52
5.5. Poseban način za definisanje struktura podataka .................................................................. 56
5.6. Funkcije................................................................................................................................. 60
Primjeri ................................................................................................................................................. 67
6. Moduli i paketi .............................................................................................................................. 73
6.1. Rad sa modulima i paketima ................................................................................................. 73
7. Objekti i klase ............................................................................................................................... 78
7.1. Šta su objekti? ....................................................................................................................... 78
7.2. Definisanje klase ................................................................................................................... 78
7.2.1. Nasljeđivanje..................................................................................................................... 81
7.2.2. Premostiti metodu ............................................................................................................. 82
7.2.3. Dodavanje metoda............................................................................................................. 84
7.2.4. Pomoć od nadklase uz super ............................................................................................. 85
7.2.5. Argument self.................................................................................................................... 87
7.2.6. Pronalazak i podešavanje vrijednosti atributa ................................................................... 87
Primjeri ................................................................................................................................................. 90
8. Podaci moraju negdje otići............................................................................................................ 92
8.1. Ulazno – izlazne operacije sa fajlovima ............................................................................... 92
8.2. Pisanje tekstualnih fajlova koristeći write() .......................................................................... 93
8.3. Čitanje tekstualnog fajla putem read(), readline() ili readlines() ......................................... 93
8.4. Zatvorite fajlove automatski koristeći with........................................................................... 95
Zaključak .............................................................................................................................................. 96
Zadaci za samostalan rad ...................................................................................................................... 97
Predgovor

Ovaj priručnik će vas uvesti u programski jezik Pyhon. Namjenjen je osobama koji tek ulaze u
svijet programiranja, ali također može biti dobar početak osobama koje su već pisale neke
programske kodove u nekom drugom programskom jeziku.
Prema mnogim studijama učenje programskoga jezika Python je izrazito jednostavno,
ponajviše zahvaljujući tome što ima jednostavnu sintaksu 1. Jedan od razloga zašto se danas sve
više programira u Pythonu je jednostavna sintaksa.
Priručnik se sastoji od nekoliko poglavlja. Na kraju svakog poglavlja nalaze se vježbe koje će
polaznici raditi samostalno ili zajedno s predavačem. U ovom priručniku polaznici će naučiti
osnovne koncepte programiranja u programskom jeziku Python.
Tako naučeni osnovni koncepti na kursu Python primjenjivi su i na većinu ostalih programskih
jezika, čime se polaznicima omogućava da nakon završenog kursa s lakoćom savladavaju i
ostale programske jezike.
Naučeni osnovni koncepti omogućavaju lakše snalaženje prilikom nadograđivanja vlastitog
znanja nakon kursa uz pomoć web pretraživača i ostale literature.
Python je interpreterski programski jezik. Interpreterski programski jezici su jezici kod kojih
se izvorni kod izvršava direktno uz pomoć interpretera, tj. kod ovakvih tipova programskih
jezika nema potrebe za kompajliranjem prije izvršavanja, tj. prevođenjem u izvršni oblik.
Programi pisani u programskom jeziku Python su kraći, a i za njihovo pisanje utrošak vremena
je puno manji. Python programerima dopušta nekoliko stilova pisanja programa: strukturno,
objektno orijentisano i aspektno orijentisano programiranje.
U ovom priručniku obrađeno je strukturno programiranje. Kod strukturnog programiranja
glavni je naglasak za kontrolu programa na korištenju struktura poput funkcija, metoda, odluka,
petlji. Ovakav način programiranja omogućava programerima da se program razlomi na manje
logičke dijelove,tj. u funkcije te se tako povećava modularnost programskog koda koji je
moguće višekratno iskoristiti. Ovakav pristup idealan je za kraće logičke programe, ali kod
velikih projekata nije dovoljno učinkovit i nakon nekog vremena programerima je sve teže
razvijati nove komponente,tj. funkcionalnosti.
Kako je Python interpreterski tip jezika, programi pisani u njemu se za posljedicu sporije
izvršavaju za razliku od programa koji su pisani u programskim jezicima C, C++, Java itd.

1
U programiranju se sintaksa odnosi na pravila koja određuju ispravan kombinirani slijed simbola koji se mogu
upotrijebiti za oblikovanje ispravno strukturiranog programa koristeći zadani programski jezik. Programeri
komuniciraju s računarima pomoću pravilno strukturirane sintakse, semantike i gramatike programskog jezika.

4
Izradu programskog koda moguće je podijeliti na nekoliko koraka:
• shvatiti problem koji je potrebno riješiti,
• rastaviti problem na manje dijelove (module),
• prepoznati koji su programski elementi potrebni za rješavanje problema,
• povezati programske elemente u smislen algoritam,
• napisati program u odabranom programskom jeziku,
• testirati program, pronaći ivične slučajeve te popraviti eventualne greške.

Kratak pregled

Poglavlje 1
Programi su kao upustva za rad neke sofisticirane mašine. Neki pravi Python programi pružaju
malu demonstraciju izgleda jezika, njegovih mogućnosti i upotrebe u praksi. Kro ovo poglavlje
ćemo da se upoznamo sa tokom programa kao i sa pisanjem pseudo koda kao i sa osnovnim
ulazno izlaznim funkcijama
Poglavlje 2
U ovom poglavlju su prikazani najosnovniji tipovi podataka u Python jeziku: logički tip, cijeli
brojevi, brojevi u pokretnom zarezu i tekstualni stringovi. Također ćemo naučiti i neke osnovne
matematičke operacije i operacije sa tekstom.
Poglavlje 3
Napredujemo ka strukturama podataka višeg nivoa ugrađivanim u Python: liste, n-torke i
rječnici. Njih možemo korisitit kao što bismo koristili i Lego kocke kako bismo napravili
kompleksnije strukture. Naučit ćemo kako da se kroz njih krećemo koristeći iteratore i
napredne načine stvaranja lista.
Poglavlje 4
U ovom poglavlju, strukture podataka iz prethodnih podataka ćemo prožeti strukturama koda
radi poređenja, odabira ili ponavljanja. Vidjet ćemo kako se kod pakuje u funkcije i kako se
izuzecima izlazi na kraj sa greškama.
Poglavlje 5 i 6
U ovom poglavlju, prikazano je kako se prelazi na veće strukture koda: module, pakete i
programe. Vidjet ćemo gdje se smještaju kod i podaci, unosit ćemo i izvoziti podatke, rukovati
opcijama itd.
Poglavlje 7
Ukoliko imate iskustva sa objektno orijentisanim programiranjem u drugim jezicima, Python
će nam biti malo opušteniji. U poglavlju 6 je objašnjeno kako se koriste objekti i klase.

5
Poglavlje 8
Podaci moraju negdje otići. U ovom poglavlju, upoznat ćemo se sa osnovnim operacijama nad
fajlovima, kao što su pisanje i čitanje u i iz fajla.

Python verzije i radno okruženje

Računarski jezici se vremenom mijenjaju kako programeri dodaju mogućnosti i popravljaju

greške. Primjeri u ovoj knjizi su pisani i testirani na Python verziji 3.11. Verzija 3.11 je
objavljena dok je ova knjiga pisana. Zadnju verziju Pythona možete skinuti na sljedećoj
stranici: https://www.python.org/downloads/
Ukoliko želite da znate šta je i kada dodato u Python, pogledajte novu web stranicu
https://docs.python.org/3/whatsnew/. Ona je priručnik tehničke prirode i malo je teža ukoliko
tek krećemo sa Python-om, ali može biti od koristi u budućnosti ukoliko budemo morali da
pravimo programe tako da rade sa računarima sa različitim Python verzijama

Za radno okruženje smo koristili Visual Studio Code 1.75 (https://code.visualstudio.com/) i

ekstenziju Jupyter za Visual Studio Code.

6
 1. Uvod u programiranje

Po završetku ovog poglavlja polaznik će moći:

• objasniti kako dijagram toka prikazuje algoritam,
• nacrtati dijagram toka za jednostavan algoritam,
• tumačiti pseudo-kod,
• napisati pseudo-kod za jednostavan algoritam,
• pripremiti radno okruženje za rad s programskim jezikom Python,
• koristiti funkcije print() i input().

1.1. Dijagram toka

Dijagram toka je grafički prikaz algoritma. Dijagram toka sastoji se od niza elemenata koji su
međusobno povezani strelicama čiji smjer diktira smjer realizacije programa. Dijagrami toka
pomažu programerima u vizualizaciji algoritma, ali i za bolje shvatanje problema kojeg
rješavaju.
Najčešće korišteni elementi su:

Slika 1: Najčešće korišteni elementi u dijagramu toka

7
Primjer 1:
Program učitava dvije vrijednosti (učitane vrijednosti spremaju se u varijable). Od veće
vrijednosti oduzima se manja učitana vrijednost. Tako dobijeni rezultat koji se ispisuje uvijek
je veći ili jednak nuli (>= 0).
Varijable su dijelovi programa koji se koriste kako bi se spremile učitane vrijednosti.
Vrijednosti se nekoj varijabli pridružuju pomoću matematičkog operatora jednako tj. "=". Ime
varijable u koju želimo spremiti neku vrijednost uvijek se nalazi s lijeve strane znaka "=" dok
se s desne strane nalazi vrijednost koju želimo spremiti u varijablu.
Obrazloženje rješenja: priloženi dijagram toka prikazuje algoritam koji učitava dva broja,
učitani brojevi spremaju se u varijable a i b. Nakon učitavanja vrijednosti slijedi odluka o tome
je li vrijednost varijable a manja od vrijednosti varijable b. Ako je uslov provjere istinit, tada
se u varijablu x sprema rezultat oduzimanja b–a, dok se u suprotnom primjeru u varijablu x
sprema rezultat oduzimanja a–b. Nakon izvršenog oduzimanja rezultat spremljen u varijablu x
ispisuje se na ekran.

Rješenje:
Priloženi algoritam radi matematičku operaciju oduzimanja čiji rezultat nikada neće biti
negativan, već će uvijek biti x >= 0

Opisivanje algoritma dijagramom toka je prikladno za kraće/lakše algoritme te za početnike

kako bi lakše vizualizirali problem koji rješavaju.

8
 1.2. Pseudo kod

Kako su dijagrami toka prilikom opisivanja složenih algoritama izrazito nepregledni, bolja
zamjena za njih je pseudokod. Pseudokod koristi termine govornog jezika i on je puno
prikladniji za opis složenijih algoritama. Prilikom opisa nekog algoritma pseudokod u svom
sadržaju koristi izraze kojima se ljudi svakodnevno koriste. Na autoru pseudokoda je da odluči
koliko će detaljno ići riječima opisivati neki algoritam. Pseudokod mora biti napisan općenito
tako da se ne vide detalji implementacije koji su zavisni o nekom konkretnom programskom
jeziku, na primjer Pythonu. Kod pseudokoda za pridruživanje vrijednosti varijablama koristi
se oznaka ":=" i ostale standardne matematičke operacije. U nastavku je prikazan pseudokod
čija je logika identična logici algoritma prikazanog u prethodnom dijelu.

Slika 2: Pseudo kod

9
 2. Ulazno izlazne funkcije

Po završetku ovog poglavlja, polaznik će moći koristiti funkcije:

• print( )
• input( )

Svaki računarski program treba komunicirati s okolinom (bilo da su to drugi programi ili
interakcija s čovjekom). Za ostvarenje komunikacije s okolinom koriste se ulazno izlazne
funkcije. Izlazne funkcije (na primjer, funkcija print()) omogućavaju ispis podataka na ekran,
dok ulazne funkcije (na primjer, funkcija input()) omogućavaju unos podataka preko tastature
u sâm program.
U ovom poglavlju obrađuju se gore spomenute funkcije: print() i input().

2.1. Funkcija print()

Kao što je već spomenuto, funkcija print() omogućava ispis informacija odnosno podataka na
ekran. Funkciju print() moguće jekoristiti na nekoliko različitih načina. U ovom poglavlju kao
i u sljedećim poglavljima će bit opisani i pokazani najčešće korišteni načini. Na sljedećoj slici
(screanshoot iz VisualStudio Code) ćemo prikazati funkciju print sa tekstom “Hello world!”.

Nakon što smo završili sa upisom: print(“Hello world!”) potrebno je pokrenuti/izvršiti

upisanu naredbu, tako što kliknemo na trokutić koji se nalazi na početku našeg dijela za
kodiranje (zaokruženo crvenim krugom na slici ispod).

10
U pisanju koda moramo voditi računa i o razmacima na početku linije. Ukoliko stavimo jedan
razmak prije riječi print, u našem primjeru, editor će nam javiti da nismo ispravno napisali –
upozorenje na grešku: je sa crvenim “valovima”, kao što možemo vidjeti na slici ispod.

Dovoljno je da izbrišemo razmak, odnosno riječ print pomjerimo krajnje lijevo, tj. na početak
linije.

U slučaju da napišemo nekoliko print funkcija, jednu ispod druge, dobijamo ispis svake od te
print funkcije u novom redu.

Razlog zbog kojeg se ispis za svaku print funkciju ispisuje u novom redu je zbog argumenta 2
end koji je po defaultu novi red. Kada smo već spomenuli argumente bitno je spomenuti da
funkcija print() može primiti nekoliko argumenata. Tri najčešće korištena argumenta koja
funkcija print prima, tj. parametri funkcije print() su sljedeći:
• *objects – prvi argument, tj. argumenti (jer ih može biti više) u pozivu funkcije print()
su vrijednosti (varijable 3) koje se žele ispisati. Broj varijabli koje se predaju funkciji
print() na ispis je proizvoljan. Predani argumenti konvertiraju se u tip podataka string
na način kao što to radi funkcija str() 4 te se ispisuju. Konvertiranje u tip podataka string
radi se automatski. Ako je proslijeđeno više argumenata (vrijednosti) kod poziva
funkcije print(), oni se međusobno odvajaju vrijednošću parametra sep i završavaju
vrijednošću parametra end.

2
Argumente ćemo detaljnije obraditi u poglavlju funkcije.
3
Varijable ćemo detaljnije obraditi u narednom poglavlju
4
Tipove podataka kao funkciju str() ćemo obraditi u narednom poglavlju

11
 • sep=' ' – ovaj parametar označava znak kojim su vrijednosti koje se ispisuju međusobno
odvojene. Ako ovaj argument nije zadan u funkciji print(), tada on poprima
predefiniranu vrijednost, tj. razmak ' '.

• end='\n' – ovaj parametar označava znak koji se ispisuje na kraju izvršavanja pojedine
print() funkcije. Ako ovaj argument nije zadan u funkciji print(), tada on poprima
predefiniranu vrijednost, tj. znak '\n'. Znak '\n' predstavlja novi redak. Što bi značilo da
nakon što se sve vrijednosti ispišu, ispisuje se i znak za novi red.

Prametri sep i end mogu biti izostavljeni iz poziva funkcije print(). U tom slučaju oni poprimaju
predefinirane vrijednosti. Predefinirane vrijednosti funkcije print() za parametre sep i end su
razmak, tj. ' ' i novi red, tj. '\n'. Ako se funkciji print() ne proslijedi niti jedna vrijednost, funkcija
print() će ispisati samo vrijednost argumenta end, a kako nema proslijeđenih argumenata 5 to je
predefinirana vrijednost '\n', tj. novi red. Kao što smo mogli vidjeti u prethodnom primjeru sa
tri print funkcije jedne ispod druge.
Ukoliko želimo da naš parametar end, ima neku drugu vrijednost, dovoljno je to u pozivu
funkcije print, navesti parametar end i dodijeliti mu vrijednost koju mi želimo pod
navodnicima. U ovom slučaju je to prazan prostor.

U gornjem primjeru, prvo se izvršava prva funkcija print, pomoću koje se ispisuje Hello world!,
međutim u ovoj prvoj print funkciji smo argument end postavili na prazan prostor, što znači
da će nakon što se izvrši prva funkcija print, sljedeći print će se ispisati u tom istom redu sa
razmakom od jednog praznog mjesta (kao što možemo vidjeti da se ispisalo Hello world!
Python). Međutim, druga funkcija print u sebi nema proslijeđen argument za promjenu
parametra end, i kod te funkcije je predefinisana vrijednost novi red. Pa nakon što se je druga
funkcija print ispisala Python, prešlo se u novi red i nakon toga treća funkcija ispisala ono što
smo joj zadali, a to je u našem slučaju Programming.

U slučaju da sva tri teksta iz prethodnih print funkcija stavimo u jednu print funkciju odvajajući
sa zarezom “,” jedan od drugog, ispis takve print funkcije bio bio kao što je prikazano na
primjeru ispod.

5
Razlika između argumenata i parametara će biti objašnjena u poglavlju funkcije.

12
Zbog čega je ovakav ispis? Razlog ovakvog ispisa je zbog drugog parametra sep koja ima
predefinisanu vrijednost – prazno mjesto, upravo zbog toga imamo ispis ove tri odvojene riječi
međuosobno odvojene praznim mjestom.
U slučaju da želimo da razmak bude drugačiji, potrebno je proslijediti drugu vrijednost za
parametar sep. Ukoliko proslijedmo vrijednost “---“, ispis te funkcije će biti kao što je
prikazano na sljedećem primjeru.

U ovom slučaju razmak između proslijeđenih riječi/tekstova će biti “---“ umjesto praznog
mjesta, jer smo u našoj funkciji print naznačili da želimo da sep bude “---“.

2.2. Funkcija input()

Gotovo je nemoguće zamisliti program koji obrađuje neku radnju, a da je za tu obradu

nepotrebna interakcija u smislu dohvaćanja dodatnih podataka. Podaci koje program dohvaća
mogu dolaziti iz raznih izvora, na primjer, iz baze podataka, dohvaćanje podataka s Interneta,
s tastature itd.
Funkcija koja omogućava prihvatanje unosa podataka sa tastature je funkcija input().
Funkcija input() radi na način tako da čita s tastature znakove sve do trenutka dok se ne pritisne
tipka "Enter". Nakon pritiska tipke "Enter" čitanje se završava te funkcija konvertira pročitane
podatke u tip podataka string te tako učitane znakove vraća preko povratne vrijednosti funkcije.

U donjem primjeru pozvana je funkcija input() koja je učitala niz znakova koji je unesen
preko tastature. Nakon što se učitavanje završilo funkcija input() vraća učitani niz znakova te
se taj niz znakova sprema u varijablu 6 pod imenom tekst. U sljedećoj liniji funkcija print()
ispisuje proslijeđenu varijablu – tekst.

6
Varijable ćemo obraditi u narednom poglavlju. Za sada varijablu shvatiti kao kutiju u kojoj se čuva vrijednost
koja joj se dodijeli iza znaka jednakosti.

13
Nakon što smo unijeli tekst pomoću input funkcije i završavanjem unosa sa tipkom Enter,
funkcija print, sljedeća linija koda se izvršava, i u našem slučaju ispisuje na ekran vrijednost
koja je “spremljena” u varijabli tekst.

14
Primjeri

Primjer 1
Napišite program koji se sastoji od pet varijabli sa dodjeljenim proizvoljnim vrijednostima. Sa
jednim pozivom funkcije print(), potrebno je ispisati na ekran svih pet vrijednosti.

Primjer 2
Napišite program koji se sastoji od dvije varijable. Vrijednosti tih varijabli učitajte preko
tastature te ih ispišite na zaslon ekrana. Prilikom upisivanja vrijednosti u varijable obavijestite
korisnika da mora unijeti neku vrijednost, npr. "Unesite prvi niz znakova: ".

15
 3. Elementi programskog jezika Python

Ovo poglavlje ćemo početi sa osvrtom na najosnovnije tipove podataka u Pythonu:

• Bulov tip (koji ima vrijednosti True ili False)
• Cijeli broj (cijeli brojevi poput 19 ili 100000)
• Broj u pokretnom zarezu (brojevi sa decimalnim zarezom poput 3.14159)
• Stringovi (nizovi tekstualnih karaktera)
Oni su na neki način, kao atomi. U ovom poglavlju ćemo ih koristiti ponaosob. Dok ćemo u
poglavlju 4 pokazati kako se kombinuju u veće “molekule”.
Za svaki tip postoje pravila korištenja kojima se zasebno bavi računar.. Također, ćemo uvesti
promjenljive/varijable (imena koja označavaju konkretne podatke).

3.1. Promjenljive/varijable

U Pythonu, sve – Bulov izraz, cijeli brojevi, brojevi u pokrentom zarezu, stringovi, čak i velike
strukture podataka, funkcije, i programi – implementirani su kao objekat. Ovo jeziku daje
dosljednost (i korisne mogućnosti) koje nedostaju drugim jezicima.
Objekat možemo posmatrati poput plastične kutije koja sadrži podatke.
Objekat ima tip, naprimjer, Bulov izraz ili cijeli broj, koji određuje šta sa
tim podatkom možemo raditi. Jedna kutija iz svakodnevog života na kojoj
piše “Čaše” bi nam ukazivala na određene stvari (da je osjetljiva i da je ne
bacamo na pod). Slično je i u Pythonu, gdje ukoliko objekat ima tip int,
znate da ga možete sabirati sad drugim tipom int.

Tip također, određuje i da li se vrijednost koju sadrži kutija može ili ne može mijenjati.
Zamislite nepromjenjivi objekat kao zatvorenu kutiju sa čistim prozorom: možete da vidite
vrijednost, ali ne možete da je mijenjate. Istom analogijom, promjenjiv objekat je kao otvorena
kutija: ne samo da možete da vidite vrijednost unutra, već također možete i da je promijenite;
međutim ne možete da mijenjate tip. Jer je Python strogo tipiziran jezik – što znači da se tip
podataka ne može mijenjat, dok se vrijednost može.

16
Programski jezici nam omogućavaju da definišemo promjenjive (varijable). Ovo su imena koja
su povezana sa vrijednostima u memoriji računara. U Pythonu, koristi se znak „=“ 7 kako bi se
vrijednost dodijelila promjenljivoj.
Slijedi Python kôd koji se sastoji od dva reda koji dodjeljuje vrijednost cijelog broja 10
promjenljivoj koju smo nazvali „a“, i zatim ispisuje vrijednost koju trenutno sadrži
promjenljiva (varijabla) „a“.

Sada je vrijeme da istaknemo ključnu činjenicu kada su u pitanju promjenljive

u Pythonu: promjenljive su samo imena. Dodjeljivanjem se ne kopira
vrijednost; samo se ime povezuje sa objektom koji sadrži podatak.

Imena promjenljivih (varijabli) mogu da sadrže samo sljedeće karaktere:

• mala slova (od a do z)
• velika slova (od A do Z)
• cifre (od 0 do 9)
• donju crtu (_)
Imena ne mogu počinjati cifrom. Također, prilikom kreiranja imena varijabli, potrebno je dobro
razmisliti o najboljem imenu za neku varijablu, jer ako programer pametno odabere ime, to će
mu omogućiti lakše pisanje programskoga kôda, a posljedično i lakše snalaženje u
programskom kôdu. Posebno, ako će taj isti kôd ići čitati, na primjer, par sedmica nakon što je
programski kôd napisan.
Primjer: ako je potrebno u varijablu spremiti trenutnu godinu, tada je tu varijablu pametnije
nazvati trenutnaGodina, a ne trenutniMjesec.
Još jedno pravilo prilikom davanja imena varijablama je da ne smijemo koristiti neku od
Python rezervisanih riječi, kao što su:

7
Iako smo svi u osnovnoj školi naučili da matematički znak = znači jednako, u programskim jezicima to ne
predstavlja znak jednakosti. Razlog tome je što standardne tastature nemaju dovoljno logičkih alternativa kao što
je strelica na lijevo, a = ne djeluje previše konfuzno. Također, u računarskim jezicima koristi se dodjeljivanje
mnogo češće od testiranja jednakosti.

17
 3.2. Brojevi

Python ima tri osnovna tipa brojeva:

• cijeli brojevi - int
• decimalni brojevi - float
• kompleksni brojevi.
Kao dodatak tu se može uvrstiti i boolean tip podataka koji je podskup cijelih brojeva (boolean
tip podataka može poprimiti vrijednosti 0 ili 1, tj. True ili False). Preciznost decimalnih brojeva
izravno je vezana za računar na kojem se program izvršava, tj. ako isti program izvršavamo na
2 različita tipa računara postoji mogućnost da će preciznost decimalnoga dijela broja biti
različita.
Kompleksne brojeve u ovom priručniku nećemo obrađivati, ali je dobro znati da Python
podržava i takav tip podataka.

3.2.1. Cijeli brojevi

Python ima ugrađenu podršku za cijele brojeve (brojevi kao što su: 5, 10, 10000) - integer. Za
bilo koji niz cifara u Pythonu se predpostavlja da je to cjelobrojna konstanta. Niz cifara

18
predstavlja pozitivan cijeli broj. U slučaju da želimo negativan broj, potrebno je prije cifara
staviti znak – (minus).

Kombinacije brojeve možemo računati jednostavnim matematičkim znakovima operacija.

Python podržava nekoliko unaprijed definisanih aritmetičkih operatora za rad s brojevima. U
nastavku je prikazana tabela u kojoj se nalazi popis aritmetičkih operatora koji se mogu
koristiti.

Znak Opis Primjer Rezultat

+ sabiranje 5+8 13
- oduzimanje 90 - 10 90
* množenje 4*3 12
/ dijeljenje 7/2 3.5
// cjelobrojno dijeljenje 7 // 2 3
% modul (ostatak dijeljenja) 7%3 1
** stepenovanje 3 ** 4 81

Također, uz gore navedene aritmetičke operatore u programskim jezicima, pa tako i u Pythonu,

postoji skraćena verzija operatora pridruživanja. U nastavku je prikazana tabela.

Operator Primjer Osnovni oblik Rezultat

a=10; b=5
+= a += b a=a+b a = 15
-= a -= b a=a–b a=5
*= a *= b a=a*b a = 50
/= a /= b a=a/b a=2
%= a %= b a=a%b a=0
**= a **= b a = a ** b a =10000
//= a //= b a = a // b a=2
= a=b a=b a=5

Kao što se može vidjeti iz gornje tabele, skraćeni operatori omogućavaju kraći zapis jedne te
iste stvari koja se u svim slučajevima može odraditi s osnovnim aritmetičkim operatorima.
Uzmimo za primjer operator "+=", ako je varijablu a, potrebno uvećati za vrijednost varijable
b, sa skraćenim aritmetičkim operatorom to bi se zapisalo kao a+=b. To je identičan izraz kao
a=a+b, zapisan na drugačiji način. Pomoću ovih operatora programer može pojednostaviti
izgled programskog koda.

19
Ukoliko želimo da provjerimo kojeg je tipa određena varijabla, dovoljno je da pozovemo
funkciju type nad tom varijablom.

Riječ „class“ označava klasu, a klasa je definicija jednog objekta; u poglavlju Klase ćemo
pokriti detaljnije. U Pythonu „klasa“ i „tip“ znače uglavnom istu stvar.

Konverzija tipova
Da bi jedan Python tip podataka pretvorili u cijeli broj, potrebno je koristiti funkciju int().
Ovime će se zadržati cijeli broj, a odbacit će se dio iza zareza (u slučaju da pretvaramo broj sa
pokretnim zarezom u cijeli broj).

Najjednostavniji Python tip podataka je Bulov izraz, koji ima samo vrijednosti True i False.
Kada se prebacuju u cijeli broj, on predstavlja vrijednost 1 i 0.

Prebacivanjem broja u pokretnom zarezu u cijeli broj, odsjeca se sve što se nalazi nakon
decimalnog zareza

Zanimljivo je što možemo konvertovati tekstualni string (više o stringovima u narednom dijelu)
koji sadrži samo cifre, eventualno sa znakovima + ili -::

20
 3.2.2. Brojevi u pokretnom zarezu

Brojevi u pokrentom zarezu (u Pythonu poznati kao floats) imaju decimalni zarez. Ovim
brojevima se rukuje slično kao i sa cijelim brojevima: možemo koristiit znakove operacija (-,
+, *, /, //, **, %).
Da bi ostale tipove podataka konvertovali u brojeve u pokretnom zarezu, koristmo funkciju
float()

Kao i ranije, Bulov izraz se ponaša kao mali cijeli broj:

Konvertovanje cijelog broja u broj u pokrentom zarezu, pretvaramo ga u ponosnog vlasnika

decimalnog zareza:

Također, možemo konvertovati i string koji sadrži karaktere koji bi bili validan broj u
pokretnom zarezu (cifre, znakove, decimalne zareze) u realan broj:

3.2.3. Stringovi

Neprogrameri često pomisle kako programeri moraju biti dobri u matematici jer rade sa
brojevima. Zapravo, većina programera radi sa stringovima teksta više nego sa brojevima.
Logično (i kreativno) razmišljanje je najčešće bitnije od matematičkih vještina.
Stringovi su naš prvi primjer Python niza. U ovom slučaju oni su niz karaktera.
Za razliku od ostalih programskih jezika, stringovi u Python-u su nepromjenjivi. Ne možemo
promijeniti string, ali možemo kopirati dijelove stringa u drugi string i dobiti isti efekat.

21
Kreiranje stringova
String se pravi ako što se krakteri zagrade navodnicima, ili sa jednim ili sa dva apostrofa, kao
što je prikazano na primjeru ispod:

Interaktini prevodilac 8 stringove ispisuje sa navodnicima sa jednim apostrofom, ali ih Python

tretira sve jednako.
Postavlja se pitanje, zašto imamo potrebu za dvije vrste navodnika? Osnovna svrha je da
možemo praviti stringove koji u sebi sadrže karaktere koji se navode. Možemo imati obične
navodnike unutar stringova navedenih duplim navodnicima, ili duple navodnike unutar
stringova sa navodnicima sa jednim apostrofom.

Moguće je koristiti i tri navodnika (' ' ') ili tri dupla navodnika ( " " "):

8
Interaktivni prevodilac je računarski program koji čita programski kod te ga prevodi u ciljani (najčešće
mašinski) jezik.

22
Međutim, trostruki navodnici nisu naročito korisni za kratke stringove kao što su ovi. Njihova
najčešća upotreba jeste prilikom kreiranja stringova od više redova, kao što je prikazano na
sljedećem primjeru filozofije Pythona 9:

Ovdje je bitno napomenuti da postoji razlika između izlaza funkcije print() i automatskog
ispisivana koje radi interaktivni prevodilac. Funkcija print() „skida“ navodnike sa stringova i
ispisuje njihov sadržaj i namjenjena je izlazu u formatu za „ljudsko“ čitanje. Čime dobijamo
prostor između svake stvari koja se ispiše kao i novi red na kraju. Dok interaktivni prevodilac
ispisuje string sa običnim navodnicima i posebnim karakterima kao što je „\n“ 10.
Na kraju, postoji i prazan string, koji nema nikakve karaktere ali je i dalje savršeno validan.
Možemo napraviti prazan string pomoću bilo kojih od prethodno pomenutih navodnika.

9
Filozofiju Pythona dobijamo ukoliko pokrenemo „import this“
10
„\n“ specijani karakter koji predstavlja prelazak u novi red za funkciju print()

23
Postavlja se pitanje zašto bi nam bio potreban prazan string? Ponekada nam je potrebno da
napravimo string od drugih stringova, i u tom slučaju je potrebno da krenemo sa praznim listom
papira.

Konvertovanje podataka pomoću funkcije str()

Možemo konvertovati ostale Python tipove podataka u stringove korištenjem funkcije str():

Python koristi str() funkciju interno kada pozovete print() funkciju sa objektima koji nisu
stringovi.

24
Posebno značenje karaktera uz znak „\“
Python nam omogućava da promijenimo značenje nekih karaktera unutar stringa kako bismo
postigli efekat koji bi u suprotnom bilo teško izraziti. Savljajući znak obrute kose crte (\) ispred
karaktera, dajemo mu posebno značenje. Najčešći primjer je „\n“, koji znači početak novog
reda. Ovim, možemo napraviti stringove od više redova stringom koji ima samo jedan red.

Spajanje znakom +
Možemo spajati fiksne stringove ili promjenljive tipa string u Pythonu, korištenjem znaka +
kao što je prikazano na primjeru ispod:

Također, možemo spajati fiksne stringove međusobno tako što ćemo ih jednostavno staviti
jedan za drugim:

Python ne daje prostor prilikom spajanja stringova, tako da smo u prethodnom primjeru morali
da eksplicitno unesemo razmake (nakon riječi „Volimo“, možemo primjetiti razmak između
slova 'o' i dvostrukih navodnika).

Multipliciranje uz znak *
Možemo koristiti znak * za multipliciranje stringa.

25
Izdvajanje karaktera (pristupanje karakterima) uz []
Da bismo dobili jedan karakter iz stringa, potrebno je odrediti njegovu udaljenost od početka
unutar uglastih zagrada nakon imena stringa. Prva (sa krajnje lijeve strane) udaljenost je 0,
sljedeći je 1 i tako dalje. Posljednja udaljenost (sa krajnje desne strane) može se definisati sa -
1, nalijevo su: -2, -3, i tako dalje.

Ukoliko navedemo udaljenost koja je dužine stringa ili duža (napomena: udaljenosti idu od 0
do dužine stringa -1), dobit ćemo izuzetak (grešku).
Indeksi rade isto kao i ostali tipovi nizova (liste i uređeni parovi), koji će biti obrađeni u
narednom poglavlju.
Pošto su stringovi nepromjenjivi, ne možemo umetati karakter direktno u njega ili mijenjati
karakter na određenom indeksu, umjesto toga možemo koristiti funkciju replace(), što ćemo
obraditi u jednoj od sljedećih stranica.

Odsječak niza uz [start: end: step]

Ukoliko želimo da izvučemo neki dio stringa (podstring) – to možemo uraditi korištenjem
odsječka. Odsječak se definiše pomoću uglastih zagrada, početne udaljenosti (start), krajnje
(end) i opcione veličine koraka (step). Nešto od navedenog se može i izostaviti. Odsječak će
podrazumjevati i karaktere od početne udaljenosti do one prije kraja.
• [ : ] - izvlači cijeli niz od početka do kraja,
• [početak : ] - određuje od udaljenosti početka do kraja,
• [ : kraj] - određuje od početka do krajnje udaljenosti minus 1,
• [početak : kraj] - ukazuje od početnog do krajnjeg udaljenosti minus 1,
• [početak : kraj : korak] - izvlači iz početnog do krajnjeg udaljenosti minus 1, preskačući
karakter za korak.

Kao i ranije , udaljenosti idu od: 0,1 i tako dalje od početka pa nadesno, i: -1,-2, i tako dalje sa
desno na lijevo. Ukoliko ne odredimo početak, odsječak koristi 0 (kao početak), a ukoliko ne
odredimo kraj, koristi -1.

26
Pronađimo dužinu stringa uz len()
Za sada smo koristili posebne znakove kao što je + da bismo manipulisali sa stringovima.
Međutim, tih posebnih znakova nema mnogo. Python ima nekoliko ugrađenih funkcija (buil-
in functions) : imenovanih dijelova koda koji izvršavaju određene operacije.
Konkretno, funkcija len() broji karaktere u stringu.

Funkciju len(), možemo koristiti i sa ostalim nizovnim tipovima, također, kao što je objašnjeno
u narednom poglavlju.

Podjela stringa uz split()

Za razliku od funkcije len(), neke funkcije su specifične za stringove. Da bi smo upotrijebili
string funkciju, potrebno je navesti ime stringa, tačku, ime funkcije i sve argumente koji su toj
funkciji potrebni: string.funkcija(argumenti). O čemu će biti više riječi u dijelu poglavlju
Funkcije.
Ukoliko želimo string podijeliti na listu manjih stringova zasnovanih na nekom separatoru,
onda koristimo funkciju split(). Liste ćemo posebno obraditi u sljedećem poglavlju. Liste
predstavljaju niz vrijednosti, odvojenih zarezima i okruženim uglastim zagradama.

U prethodnom primjeru string je nazvan „recenica“, nad kojim smo pozvali funkciju split()
koja po defaultu kao separator koristi prazan razmak, novi red, tab itd. Ukoliko želimo neki
drugi separator, potrebno je navesti prilikom pozivanja funkcije split(). Kao što možemo vidjeti
na sljedećem primjeru, gdje smo kao separator naveli zarez ',' u funkciji split().

27
Zamjena uz replace()
Za jednostavnu zamjenu podstringovima koristimo funkciju replace(). Ovoj funkciji je
potrebno proslijediti string koji treba zamijeniti i string sa kojim treba zamijeniti, kao i
opcionalni parametar 11 broj koliko starih stringova treba zamijeniti. Ukoliko izostavimo ovaj
posljedni parametar, u tom slučaju budu zamjenjeni svi podstringovi sa novim stringom.

U slučaju da želimo samo jedan da zamijenimo, onda navedemo kao treći parametar broj koliko
podstringova želimo da zamijenimo.

U slučaju kada znamo tačan broj podstringova koji želimo da promijenimo, replace() je dobar
izbor. Međutim treba biti oprezan sa ovom funkcijom, jer može se desiti da nam zamijeni i
karaktere koje nismo predvidjeli da nam trebaju biti zamijenjeni (ovo može biti problem kada
želimo da mijenjamo manji broj karaktera, tipa jedno slova sa drugim).
U nastavku su prikazani operatori za rad sa nizovima znakova.
Operator Opis Rezultat
a=“abc“, b=“def“
+ Spajanje a+b = abcdef

* Ponavljanje a*2 = abcabc

(multipliciranje)
[] Dohvaćanje vrijednosti a[0] = a
na određenom indeksu
[:] Vraća dio niza omeđen a[0:2] = ab
indeksima
in Provjerava nalazili se 'c' in a => True
dati znak u nizu
not in Provjerava da li se dati 'H' not in a => True
znak NE nalazi u nizu

11
Opcionalni parametar možemo a i ne moramo navesti, ako ga ne navedemo on poprima defaultnu vrijednost.

28
U nastavku slijedi popis još nekoliko najčešće korištenih funkcija i metoda za rad sa nizovima
znakova. U tabeli ispod rezultat će biti prikazan nakon što pripadajuća funkcija(metoda) se
izvrši nad nizom znakova:
niz_znakova = ''hello WORLD''
Naziv funcije (metode) Opis Rezultat
capitalize() U datom nizu prvo početno Hello world
slovo stavlja u veliko slova, a
sva ostala slova u mala.
len() Vraća dužinu niza znakova 11

lower() Pretvara cijeli niz znakova u Hello world

mala slova
upper() Pretvara cijeli niz znakova u HELLO WORLD
velika slova
title() Sve riječi počinju velikim Hello World
slovom, a ostatak riječi
napisan je malim slovima.
lstrip() Uklanja sve praznine sa lijeve -
strane niza.
rstrip() Uklanja sve praznine sa desne -
strane niza.
strip() Uklanja sve praznine sa desne -
i lijeve strane niza.
str() Prima objekat i vraća niz -
znakova

29
Primjeri

Primjer 1
Napisati kod gdje dvjema varijablama dodjeljujemo proizvoljne vrijednosti, a zatim računamo
njihovu: sumu, razliku, produkt, kolicnik kao i ostatak djeljenja.

Primjer 2
Napisati kod koji će za dati niz znakova smjestiti u novu varijablu prvih 6 znakova tog datog
stringa:

30
 4. Strukture podataka

U poglavlju 3 smo počeli sa osnovnim tipovima podataka u Python-u: Bulov izraz, cijeli
brojevi, brojevi u pokretnom zarezu i stringovi. Ako bi smo ih posmatrali kao atome, onda su
strukture podataka u ovom poglavlju kao molekuli. Odnosno, sve osnovne tipove
kombinujemo na kompleksnije načine. Što se koristi svakodnevno kod programera. Dobar dio
programiranja se sastoji od sjeckanja i „lijepljenja“ podataka u specifične formate, a alat za
sjeckanje i lijepljenje ćemo upznati u ovom poglavlju.

4.1. Liste

Većina računarskih jezika može da predstavlja niz stavki koji su poredani prema svojim
pozicijama izraženim u cijelim brojevima: prvi, drugi, i tako dalje do kraja liste. Već smo
vidjeli stringove koje predstavljaju niz karaktera.
Python ima još dvije strukture nizova: uređene parove (engl. tuple) i liste. Oni sadrže nula ili
više elemenata. Za razliku od stringova, ovdje elementi mogu biti različitih tipova. Zapravo,
svaki element može biti bilo koji Python objekat. Ovo nam omogućava da pravimo strukture
onoliko duboke i kompleksne koliko želimo.
Postavlja se pitanje, zašto Python sadrži liste i uređene parove? Uređeni parovi su
nepromjenljivi; to znači kada uređenom paru dodijelimo element, oni su „uzidani“ i ne mogu
se mijenjati. Međutim, liste su promjenljive, što znači da možemo ubacivati i brisati elemente
po želji i potrebi.

Liste su dobre za vođenje računa o stvarima prema njihovom redu, naročito onda kada se red i
sadržaj mogu mijenjati. Za razliku od strngova, liste su promjenljive. Što znači da elemente
liste možemo mijenjati, dodavati nove elemente, te brisati ili prebacivati postojeće elemente u
neku drugu listu. Također, bitno je spomenuti da se ista vrijednost u listama može naći više
puta.

Kreiranje liste uz [ ] ili list()

Lista se pravi sa nula ili više elemenata, razdvojenih zarezima unutar uglastih zagrada.

Također, možemo napraviti praznu listu uz funkciju list():

31
Lista radni_dani je jedina koja zapravo koristi redoslijed liste 12. Dok lista kombinovana_lista
pokazuje da vrijednosti elemenata unutar liste ne moraju biti istog tipa podataka.

Konvertovanje ostalih tipova podataka u liste uz list()

Python funkcija list() konvertuje ostale tipove podataka u liste. U sljedećem primjeru se string
prebacuje u listu stringova od jednog karaktera:

U prethodnom poglavlju smo mogli vidjeti kako korištenjem funkcije split() kao rezultat
dobijamo listu.

Pristupanje elementima koristeći [udaljenost]

Kao i sa stringovima, možemo uzeti jednu vrijednost iz liste koristeći njegnu udaljenost 13 od
početka liste (index):

12
U slučaju da želimo pratiti jedinstvene vrijednosti u kojima nam nije bitan redoslijed, Python skup može biti
bolji izbor od liste. O skupovima će biti riječ malo kasnije u ovom poglavlju.
13
Udaljenost (indeks) mora biti validna za tu listu – inače ćemo odbiti izuzetak (grešku).

32
Isti slučaj kao i sa stringovima, indeksi se broje unazad od kraja; -1, -2, -3, itd:

Liste sa listama
Liste mogu sadržavati elemente različitih tipova, uključujući i druge liste, kao što je ilustrovano
na primjeru ispod:

Dakle, kako sedmica, lista sa listama izgleda?

Pogledajmo prvi element u njoj:

Prvi element je lista: zapravo, to je radni_dani koji smo odredili prilikom pavljenja liste
sedmica. Na taj način možete pristupati bilo kom drugom elementu.
33
To je drugi element, koji smo odredili, neradni_dani. Ukoliko želimo prvi element iz iz
prethodne liste neradni_dani, koja se nalazi u listi sedmica, onda je potrebno koristiti dva
indeksa:

[1] se odnosi na listu koja je drugi element u listi sedmica, dok se [0] odnosi na prve element
u unutrašnjoj listi.

Izmjena elemenata pomoću [udaljenosti/indeksa]

Baš kao što možemo dobiti vrijednosti liste jednog elementa preko njene udaljenosti (indeksa),
možemo je i promijeniti:

Napomena: lista udaljenosti (indeks) mora biti validan za tu listu.

Karakter u stringu ne možemo mijenjati na ovaj način, jer su stringovi nepromjenjivi. Liste su
promjenjive. Dakle, možemo mijenjati broj elemenata koje jedna lista sadrži, kao i same
elemente unutar liste.

34
Dodavanje elementa na kraj pomoću funkcije append()
Tradicionalni način dodavanja elemenata u listu je da se pomoću funkcije append() elementi
dodaju jedan po jedan na kraj liste. U prethodnom primjeru, programski_jezici, nakon kreiranja
liste, sjetili smo se da smo zaboravili dodati još jedan programski jezik: Ruby, ali nećemo imati
problema jer je lista promjenljiva i možemo ga dodati naknadno:

Brisanje elementa korištenjem remove()

U slučaju da želimo neki element da uklonimo iz liste, potrebno je upotrijebiti remove() kako
bismo obrisli element prema vrijednosti. Zbogom C#:

Testiranje vrijednosti uz in
Pythonski način da provjerimo postojanje određene vrijednosti unutar jedne liste je da
upotrijebimo in:

35
Pronalazak dužine liste uz len()
len() vraća broj elemenata u listi:

4.2. Uređeni parovi (n-torke)

Slično kao i liste, uređeni parovi/n-torke (engl. tuple) su nizovi proizvoljnih elemenata. Za
razliku od listi, n-torke su nepromjenljive, što znači da nakon definisanja n-torke ne možemo
mijenjati, dodavati ili brisati elemente. Dakle, n-torka je slična konstantnoj listi.

Kreiranje n-torke pomoću ()

Sintaksa za pravljenje n-torke je donekle nedoslijedna, kao što ćemo vidjeti kroz sljedeće
primjere.
Ukoliko počnemo od pravljenjem prazne n-torke korištenjem ():

Međutim, da bismo napravili n-torku sa jednim ili više elemenata, potrebno je upisati zarez
poslije svakog elementa. To se radi i za čak n-torke od jednog elementa:

36
Ukoliko imamo jedan ili više elemenata, u tom slučaju je potrebno nakon svakog osim
posljednjeg elementa staviti zarez:

Python stavlja i zagrada kada prikazuje jedan uređeni par. One nam nisu nisu neophodne - ono
što zapravo određuje jedan uređeni par jesu zarezi koje stavljamo između elemenata – međutim
korištenjem zagrada nećemo dobiti grešku. Možemo ih koristiti kako bismo ogradili
vrijednosti, što uređeni par čini lakše vidljivim:

Ono što nam uređeni parovi omogućavaju jeste dodjeljivanje vrijednosti više promjenljivih
odjednom 14:

Također, jedna od primjena uređenog para jeste za razmjenu vrijednosti u jednoj naredbi bez
korištenja privremene promjenljive:

14
Ovo se ponekad zove otpakivanjem uređenog para.

37
Funkcija za konverziju drugih tipova u uređeni par je tuple():

Uređeni parovi naspram lista

Često možemo koristiti uređene parove (n-torke) umjesto lista, međutim one imaju mnogo
manje funcija u odnosu na liste, jer se uređene liste, nakon pravljenja ne mogu modifikovati.
Postavlja se onda pitanje, zašto ne koristiti liste umjesto uređenih parova (n-torki):
• uređene liste zauzimaju manje prostora u memoriji,
• elemente uređene liste ne možemo poremetiti greškom,
• uređene liste možemo koristiti kao ključeve za rječnike (sljedeći odjeljak; 4.3.),
• argumenti funkcija prolaze kao n-torke (više o tome u dijelu „Funkcije“).

Istina je da se u svakodnevnom programiranju više koriste liste i rječnici od uređenih parova,

ali nije na odmet da znamo da postoje i uređene parovi (n-torke) u Pythonu.

38
 4.3. Rječnici

Rječnik je sličan listi, ali redoslijed elemenata nije bitan i one nisu izabrane prema udaljenosti
(indeksima) kao na primjer 0, 1,...,-1, itd. Umjesto toga, potrebno je odrediti jedinstveni ključ
(keys) koji će se pripisati svakoj vrijednosti. Ovaj ključ je vrlo često string, ali on zapravo može
biti bilo koji od nepromjenljivih u Pythonu: Bulov izraz, broj u pokretnom zarezu, string, n-
torka, cijeli broj itd. Rječnici su promjenljivi, što znači da možemo dodavati, brisati i mijenjati
vrijednosti ključeva.
Ukoliko ste već radili sa drugim programskim jezicima koji podržavaju samo liste ili nizove,
vjerujem da će vam se svidjeti rječnici 15.

Pravljenje rječnika uz pomoć { }

Da bismo napravili rječnik, potrebno je da u sljedećem formatu: vitičaste zagrade {} unutar
kojih su odvojeni parovi ključ:vrijednost.

Najjednostavniji rječnik je prazan, koji uopšte ne sadrži niti ključeve niti vrijednosti:

Ukoliko želimo da kreiramo rječnik sa nekim ključevima i vrijednostima, možemo to uraditi

na sljedeći način:

U ovom primjeru, ključevi su: mob1, mob2, mob3, a vrijednosti su: iPhone, Samsung, Xiaomi.
I kao što smo mogli vidjeti, unošenjem imena rječnika mobiteli, interaktivni prevodilac će
ispisati njegove ključeve i vrijednosti.

15
U drugim jezicima, rječnici se mogu nazivati asocijativni nizovi, heševi ili hešmape. U Pythonu, rječnik se
često označava sa dict (skraćeno od engl. dictionary)

39
Konvertovanje uz dict()
Možemo upotrijebiti funkciju dict() kako bismo nizove sa dvije vrijednosti konvertovali u
rječnik. Gdje se prvi element u svakom nizu koristi kao ključ, a drugi kao vrijednost.
Najprije, evo malog primjera gdje se koristi lista bodovi (lista sa listama od dva elementa):

Dodavanje ili izmjena elementa zavisno od [ključa]

Dodavanje jednog elementa u rječnik je lahko. Samo je potrebno odrediti jedan element u
zavisnosti od njegovog ključa i dodijeliti mu vrijednost. Ukoliko ključ već postoji u rječniku,
postojeću vrijednost zamjenjuje nova. Međutim, ukoliko ne postoji taj ključ, onda se dodaje u
rječnik sa svojim vrijednošću – za razliku od lista, ne moramo brinuti o tome da li će nam
Python reći da je došlo do greške u toku dodjele zbog indeksa koji je van opsega.
Napravimo rječnik većine grupe Monty Python 16, koristeći njihova prezimena kao ključeve, a
imena kao vrijednosti:

16
Televizijska serija po kojoj je ovaj programski jezik i dobio ime.

40
Nakon što smo kreirali prethodni rječnik, sjetili smo se da nam nedostaje jedan član Terry
Gilliam. Njega ćemo lahko dodati, na sljedeći način:

Na ovaj jednostavan način smo dodali novi

par ključ:vrijednost u naš već postojeći
rječnik.
Napomena: ključevi rječnika moraju biti
jedinstveni. Zato smo za ključeve rječnika
koristili prezimena, a ne imena – jer dvojica
članova Monty Python imaju isto ime Terry.
U slučaju da koristimo isti ključ više puta,
posljednja vrijednost ostaje u rječniku.

Provjeravanje određenog ključa uz pomoć in

Ukoliko želimo da saznamo da li u rječniku postoji određeni ključ, potrebno je upotrijebiti in.
Definisanjem novog rječnika pythons, ali ovaj put izostavljajući jedno ili dva imena:

Hajde sada da vidimo koga tu ima:

Opet smo zaboravili Terry Gilliama.

41
Nađimo element koji ima odgovarajući [ključ]
Ovo je najčešći način upotrebe rječnika. Odredimo rječnik i ključ kako bismo dobili
odgovarajuću vrijednost.

Ukoliko ključ nije prisutan u rječniku, dobit ćemo izuzetak:

Postoje dva načina da se ovo izbjegne. Prvi je

da provjerimo da li ključ postoji koristeći in.
A drugi je korištenjem funkcije get() u
formatu: pythons.get('Tom') – i koliko postoji
dobit ćemo njegovu vrijednost. Međutim,
ukoliko ne postoji, dobit ćemo None (što se u
interaktivnom prevodiocu ne prikazuje ništa)

Pristupanjem svim ključevima koristeći keys()

Ukoliko želimo da dobijemo sve ključeve u rječniku, tada koristimo funkciju keys(). Sada
ćemo koristiti drugačiji primjer rječnika za sljedeći primjer:

Vidimo da nam vraća dict_keys(), što predstavlja iterator. Ovoje zgodno kod velikih rječnika
jer ne troši vrijeme i memoriju za pravljenje i skladištenje liste koju možda nećemo koristiti.
Ali često zapravo i želimo listu, što možemo dobiti ukoliko nad ovim semafor.keys() pozovemo
list().

42
Naći sve vrijednosti koristeći values()
Da bismo dobili sve vrijednosti u rječniku, potrebno je upotrijebiti values():

Naći sve parove ključ-vrijednost koristeći items()

Kada želimo naći sve parove ključ:vrijednost iz rječnika, potrebno je upotrijebiti items()
funkciju:
Vidimo da se svaki ključ i
vrijednost vraćaju kao uređeni
par. Npr: ('zeleno', 'prođi').

43
 5. Upravljanje tokom programa

Kroz prethodna poglavlja, vidjeli smo mnoge primjere podataka ali sa njima nismo skoro ništa
radili. U većem dijelu primjera koda, korišten je interaktivni prevodilac i primjeri su bili kratki.
U ovom poglavlju ćemo vidjeti kako se pored podataka struktuira Python kod.
Mnogi računarski jezici koriste vitičaste zagrade {} ili ključne riječi poput begin i end kako bi
se obilježili blokovi koda. U tim jezicima, trebalo je biti dosljedno pri uvlačenju teksta kako bi
program bio čitljivi za nas kao i za druge koji taj kod čitaju. Postoje čak i alati (ekstenzije)
pomoću kojih se lnije našeg koda mogu lijepo urediti.
Kada je osmišljavao jezik koji će postati Python, Guido van Rossum je odlučio da je
samouvlačenje teksta dovoljno za definisanje strukture programa, i izbjegao je unošenje otlikih
zagrada. Python je neobičan po načinu korištenja uvlačenja za definisanje strukutre programa.
To je jedna od prvih odlika koje novi programeri primjete, a može biti neobično i onima koji
već imaju iskustvo sa ostalim jezicima. Na kraju, nakon određenog perioda korištenja Pythona,
to nam postane prirodno i prestanemo i da primjećujemo. Čak se i naviknemo na to da smo
produktivniji sa manje unijetog teksta.

5.1. Komentari

Komentari su opisi koji pomažu programerima da bolje razumiju namjeru i funkcionalnost

programa. Komentar je dio teksta u našem programu koji interaktivni prevodilac ignoriše.
Korištenje komentara u programima čini naš kod razumljivijim, program čini čitljivijim što
nam pomaže da se prisjetimo zašto su napisani određeni blokovi koda.
Osim toga, komentari se također mogu koristiti za ignoriranje nekog koda tijekom testiranja
drugih blokova koda. Ovo nudi jednostavan način da se spriječi izvršavanje nekih redova ili
napiše brzi pseudo-kôd za program.
U Pythonu koristimo simbol # (engl. hash), za pisanje komentara u jednom redu, sve od tog
mjesta pa do kraja trenutnog reda je komentar. Što možemo vidjeti na sljedećim primjerima.

Python nema koemtare od više redova. Svaki red komentara ili njegov dio u kodu moramo
započeti znakom #.

44
Međutim, ukoliko se nalazi u tekstualnom stringu, taraba(#) jednostavno znači znak #:

5.2. Poređenjem naredbama if, elif i else

Do sada smo u knjizi uglavnom govorili o strukturama podataka. Sada, najzad pravimo naš
prvi korak u strukturu koda kojima se podaci provlače kroz programe. Naš prvi primjer je
sljedeći mali Python program koji provjerava vrijednost Bulove promjenljive prisustvo i
ispisuje adekvatan komentar:

Redovi if i else u Pythonu su naredbe kojima se provjerava da li je uslov (u ovom slučaju,

vrijednost promjenljive prisustvo) True. Kao što smo naučili, print() je Python ugrađena
funkcija kojom se vrši ispis na ekran.
Svaki print() red je ispod svog testa uvučen. U ovom slučaju smo koristili četiri slovna mjesta
za uvlačenje svakog pododjeljka (bloka koda). Mada, možemo uvlačiti koliko god želimo, ali
Python očekuje da budemo dosljedni unutar istog odjeljka – tj. redovi moraju biti uvučeni u
istoj količini od lijeve strane. Preporučeni stil, PEP-8 17, znači da koristite četiri slovna mjesta.
Ovdje smo uradili nekoliko stvari, koje ćemo objasniti detaljnije kroz ovo poglavlje:
• Dodijelili smo Bulovu vrijednost True promjenljivoj pod imenom prisustvo
• Izveli smo uslovno poređenje koristeći naredbe if i else, i pokrenuli različit kod u
zavisnosti od vrijednosti promjenljive prisustvo
• Pozvali smo funkciju print() kako bismo ispisali neki tekst

17
PEP 8 – Style Guide for Python Code

45
Kao što smo rekli, naredba if pripada kontroli toka za odluke. U najjednostavnijem obliku ova
struktura se sastoji od jedne ili više naredbi koje rade neku radnju.
Kao što smo mogli iz prethodnog primjera primjetiti, sintaksa if iskaza je:

if uslov:
naredbe

Objašnjenje prethodnog pseudo-koda:

Ako je uslov zadovoljen, izvršava se tijelo odluke (naredbe), međutim ako izraz nije
zadovoljen, tijelo odluke (naredbe) se neće izvršiti. Sintaksa zahtjeva da se napiše ključna riječ
if, nakon toga logički izraz (logički izraz uvijek na kraju završi u True ili False vrijednosti).
Ključne riječi su riječi koje su unaprijed rezervisane od strane korištenog programskog jezika,
u ovom slučaju od strane Pythona. Iza ključnih riječi običnu dolaze naredbe. Svaki programski
jezik ima skup ključnih riječi i te riječi ne mogu se koristiti kao imena varijabli. Nakon logičkog
izraza potrebno je staviti dvotačku koja interpreteru označava da slijedi tijelo odluke (naredbe).

Naredbom if moguće je napraviti puno stvari, međutim kako bi se programerima što više
olakšao posao, uvedena je i else naredba, koja zajedno sa if naredbom čini if-else odluku. Kod
ovakvog tipa odluke, uvijek će biti izvršen jedan dio. Ako je uslov zadovoljen, izvršit će se
tijelo if odluke, u suprotnom će se izvršiti tijelo else odluke.

Sintaksa if-else iskaza je:

if uslov:
naredbe1
else:
naredbe2

Ukoliko ima više od dvije mogućnosti koje treba testirati , u tom slučaju potrebno je korisiti if,
elif (skraćeno od else if ) i else:

46
U prethodnom primjeru, testirali smo znak jednakost znakom operacije ==. Znakovi za
operacije poređenja u Pythonu su:

Operator Opis Primjer Rezultat Rezultat

a=5; b=10 a=5; b=5
== Jednakost a == b False True

!= Nejednakost a != b True False

> Veće od a>b False False

< Manje od a<b True False

>= Veće ili jednako a >= b False True

<= Manje ili a <= b True True

jednako

Kao što možemo vidjeti iz prethodne tabele, ovim operacijama se vraća Bulova vrijednost:
True ili False.
Napomena: dva znaka jednakosti (==) se koriste za ispitivanje jednakosti, dok jedan znak
jednakosti (=) znači da promjenljivoj dodjeljujemo neku vrijednost.
Ukoliko je neophodno da izvršimo više poređenja istovremeno (za kreiranje složenijih izraza),
u tom slučaju možemo koristiti logičke operatore: and, or, not.
U nastavku su prikazane tabele stanja logičkih operatora:

47
Tabela stanja operatora I (and):
A B A and B
False False False
True False False
False True False
True True True

Možemo primjetiti da operator and daje razultat True samo u jednom slučaju, a to je kada oba
operatora imaju istu vrijednost True.

Tabela stanja operatora ILI (or):

A B A or B
False False False
True False True
False True True
True True True

Operator or daje rezultat True u slučaju da barem jedan od operanada ima vrijednost True, tj.
operator or daje vrijednost False samo u slučaju kada svi operandi imaju vrijednost False.

Tabela stanja operatora NE (not):

A not A
False True
True False

Operator not, daje invertnu vrijednost.

Kao što smo prethodno rekli, kod složenijih logičkih izraza, moguće je istovremeno
kombinovati više vrsta operacija: aritmetička operacija, operatori poređenja kao i logičke
operacije. Da bi lakše zapamtili redoslijed izvođenja operacija, redoslijed istih je prikazan u
tabeli ispod:
Redoslijed Operacija
1. Aritmetička operacija
2. Operatori usporedbe
3. Logička operacija

48
Šta je istinito?

Šta se dešava ukoliko element koji provjeravamo nije Bulov izraz? Šta Python podrazumjeva
kao True i False?
Neistinita vrijednost (false) ne mora izričito biti False. Na primjer, sve ove vrijednosti se
tretiraju kao False
boolean False
bull None
zero integer 0
zero float 0.0
empty string ''
empty list []

Sve ostalo se uzima kao True. Python programi koriste ovu definiciju istinitosti (ili u ovom
slučaju neistinitosti) kako bi se provjerilo ima li praznih strukutra podataka kao i False uslova:

49
 5.3. Ponavljanje pomoću while naredbe

Ispitivanje pomoću: if, elif, else, ide od vrha prema dnu. Međutim, ponekad moramo nešto
uraditi više puta. Što znači da nam je potrebna petlja, a najjednostavniji mehanizam petlje u
Pythonu je while petlja.

U ovom primjeru, prvo smo promjenljivoj brojac

dodijelili vrijednost 1. Petlja while poredi vrijednost od
brojaca sa 5 i nastavlja ukoliko je vrijednost brojaca
manja od 5. Unutar petlje, izvršava se naredba print
gdje smo ispisali vrijednost brojaca i onda uvećali
njegovu vrijednost za jedan. Nakon toga vraćamo se na
vrh petlje, i ponovo se poredi vrijednost brojaca sa 5.
Vrijednost brojaca je sada 2, te se sadržaj while petlje
opet izvršava, a brojac se uvećava na 3.

Ovo se nastavlja se dok vrjednost brojaca sa 5 se ne uveća na 6 pri dnu petlje. U tom koraku,
brojac <= 5 je False i while petlja se završava, a izvršavanje programa prelazi na sljedeće linije
koda nakon while petlje.
Iz prethodnog možemo zaključiti da se while petlja prije izvršavanja programskog bloka koda
koji joj pripada, ispituje da li je uslov istinit ili ne. Ako je uslov istinit (True) tada će se izvršiti
tijelo petlje, dok u suprotnom tijelo petlje se preskače i izvršava se programski kod napisan
nakon (ispod) petlje.
Vidjeli smo da se sintaksa while petlje sastoji od ključne riječi while, gdje nakon toga slijedi
logički izraz te dvotačka koja interpreteru označava da nakon nje slijedi tijelo petlje:
Sintaksa while petlje je:

while uslov:
naredbe

Prekidanje sa break
Ukoliko želimo da ponavljamo naredbe dok se nešto ne desi, ali nismo sigurni u kom trenutku
bi se to moglo dogoditi, u tom slučaju koristimo beskonačnu petlju i naredbu break.
U ovom primjeru ćemo od korisnika tražiti da preko tastature unosi neki string (niz karaktera)
a nakon toga ispisuje velikim slovima. Izlazimo iz petlje kada se uense red koji sadrži samo
slovo q:

50
U prethodnom primjeru smo unijeli „python“ da bi se unutar while petlje primjenila metoda
capitalize() koja prvi karakter (slovo) pretvara u veliko slovo, a u sljedećoj iteraciji smo unijeli
„q“ i nakon toga je petlja prekinuta pomoću break naredbe.

Preskakanje pomoć continue

Ponekad ne želimo da zaustavimo ponavljanje već samo da pređemo na sljedeće ponavljanje
ukoliko neki uslov nije ispunjen. U sljedećem primjeru ćemo prikazati unos brojeva i računanje
njihovih kvadrata za neparne brojeve. Ukoliko unesemo paran broj, preskačemo i ne račnamo
njegov kvadrat, nego tražimo ponovo unos.

U prethodnom primjeru smo unosili brojeve od 1-10, i možemo primjetiti kako smo kao izlaz
dobili samo kvadrate onih brojeva koji su neparni, što smo i željeli.

Provjera prekida uz else

Ukoliko se while petlja zaustavila normalno (bz pozivanja break), kontrola prelazi na opciono
else 18. Možemo ovo koristiti kada smo while petlju kodirali tako da nešto provjerava i prekine
čim to i pronađe. Ukoliko bi se while petlja završila, a objekat nije pronađen pokrenulo bi se
else:

18
Upotreba else može se činiti nelogičnom, ali posmatrajmo to kao ispitivanje da li je došlo do prekida.

51
 U ovom primjeru smo prolazili kroz
niz brojevi. I za svaki element tog
niza, provjeravali da li je paran, u
slučaju da je paran element,
prekidali bi while petlju pomoću
naredbe break. U slučaju da nije
pronađen niti jedan paran broj u
našem nizu, break se ne bi izvršio i
prešlo bi se na else izvan while
petlje.

5.4. Ponavljanje pomoću for naredbe

U Pythonu se često koriste iteratori 19, i to sa dobrim razlogom. Oni nam omogućavaju da se
krećemo kroz strukture podataka, a da ni ne moramo znati koliko su velike niti kako se
implementiraju.
Možemo pregledati podatke koji se prave u „hodu“, čime omogućavamo obradu tokova
podataka koji inače ne bi svi odjednom stali u memoriju računara.

Ovo je jedan od načina da prođemo kroz listu (pomoću while petlje)

19
Iteratori su objekti koji definiraju niz omogućavanjem dohvaćanja sljedećeg elementa iz niza.

52
Međutim, postoji više „pajtonski“ način za to:

Liste poput dani su jedni od Python objekata kroz koje se može prolaziti, zajedno sa
stringovima, n-torkama, rječnicima i ostalim elementima. Prolaženjem kroz n-torke ili liste
stvara se element po element. Prolaženjem kroz stringove stvara se jedan po jedan karakter,
kao što je prikazano na primjeru ispod:

Prolaženjem kroz rječnik (ili njegove keys()) vraćaju se ključevi. U primjeru ispod, ključevi su:

53
Da bismo prolazili kroz vrijednosit umjesto ključeva, možemo koristiti funkciju values():

U slučaju da nam treba i ključ i vrijednost u formatu uređenog para, možemo koristiti funkciju
items():

Prekid pomoću break

Komanda break u for petlji, prekida njeno izvršavanje isto kao u while petlji.

Preskakanje uz continue
Korištenjem komande continue u for petlji preskače na sljedeće ponavljanje petlje, isto kao i u
while petlji.

Provjera prekida pomoću else

Slično kao i sa while, for ima jedno opciono else sa kojim se provjerava da li je for izvršeno
normalno.
Ovo se koristi kada želimo potvrditi da li se prethodna for petlja izvršila u potpunosti, umjesto
da bude stopirana ranije komandom break. Petlja for u sljedećem primjeru ispisuje ime sira i
prekida se ukoliko se u prodavnici sira (listi) pronađe bilo kakav sir:

54
Isto kao i sa while, upotreba komande else uz for može se činiit nelogično. Više ima smisla
ukoliko na for posmatramokao da ono traga za nečim, i da se else poziva ukoliko se to ne
pronađe.

Generisanje liste brojeva uz range()

Funkcija range() vraća tok brojeva unutar određenog opsega, bez potrebe da najprije kreirate i
skladištite velike strukture podatakao kao što su n-torke ili liste. Ovo nam omogućava da
kreiramo ogromne opsege bez toga da iskoristimo svu memoriju našeg računara i krahiramo
naš program.
Funkciju range() koristimo slično kao i isječke: range(start, stop, korak). Ukoliko izostavimo
start, opseg počinje od 0. Jedina neophodna vrijednost je stop; kao i sa isječcima, posljednja
vrijednost koja se kreira bit će odmah pred stop. Automatska vrijednost koraka je 1, a možemo
ići i unazada sa –1.
Funkcija range() vraća objekat kroz koji se može prolaziti, taok da treba da kroz vrijednosti
prolazimo uz pomoć for i in.

U slučaju da želimo napraviti opseg od 2 pa naniže ka 0:

55
U slučaju da želimo kreirati parne brojeve od 0-10 i staviti ih u listu, možemo to uraditi pomoću
sljedeće linije koda:

5.5. Poseban način za definisanje struktura podataka

U Pythonu postoji poseban način da napravimo strukturu podataka od jednog ili više iteratora.
Oni omogućavaju da kombinujemo petlje i uslovne testove sa manje opširnom sintaksom.
Definisanje na ovaj način, ponekad znači da smo na većem nivou od početničkog poznavanja
Pythona. Drugim riječima, to je više pajtonski način.

Definisanje liste
Možemo napraviti listu cijelih brojeva od 1 do 5, sa jednim po jednim elementom, na sljedeći
način:

Ili, možemo upotrijebiti iterator i range() funkciju:

56
Ili, smo mogli jednostavno iskopirati(dodijeliti) izlaz funkcije range() direktno u listu:

Svi ovi pristupi predstavljaju validan Python kod i dovest će do istog rezultata. Međutim,
postoji više pajtonski način za definisanje listi koji u svom najednostavnijem obliku izgleda:
[izraz for elemen in iterator]

U prvom redu, potrebno je prva promjenljiva broj da proizvede vrijednosti za listu: odnosno,
da rezultat petlje stavi u lista_brojeva. Druga promjenljiva broj je dio for petlje. Da bismo
vidjeli da je prva promjenljiva broj dio izraza, isprobajmo sljedeću varijantu:

57
Ovaj način definisanja liste, pokreće petlju unutar uglastih zagrada. Ovaj primjer nije zaista
jednostavniji od prethodnog primjera, ali ima još. Na ovaj način, lista može sadržavati i uslovni
izraz, koji bi izgledao ovako:
[izraz for elemen in iterator if uslov]

Ukoliko želimo napraviti novu listu neparnih brojeva između 1 i 10 (napomena: broj %2 True
za neparne brojeve, a False za parne):

Što bi na neki standardni način izgledalo ovako (vidimo da smo 4 linije koda smjestili u jednu):

58
Definisanje rječnika
Rječnici također mogu da se definišu pomoću for petlje. Najjednostavniji oblik je:
{izraz_ključa : izraz_vrijednosti for izraz in interator}

Prolazimo kroz svako od sedam slova u stringu 'letters' i brojimo koliko puta se koje slovo
pojavljuje. Gdje su ključevi riječnika svako slovo pojedinačno a vrijednosti je broj ponavljanja
svakog tog slova u stringu.

59
 5.6. Funkcije

Do sada su svi naši primjeri Python koda bili mali dijelovi koda. Potreban nam je neki način
organizovanja većeg koda u dijelove kojima se može rukovati. U ovom dijelu ćemo vidjeti
kako to možemo sami praviti(definisati) funkcije.
Funkcije su korisne za razbijanje velikih programa na manje delove, što programe čini
čitljivijim i lakšim za održavanja. Funkcije su takođe korisne kada moramo da ponavljate isti
kod u raznim delovima našeg programa. Kod koji se ponavlja možemo staviti unutar funkcije
i pozivati ga kada god je potrebno da izvršavate naredbe iz tog koda. Funkcije možemo koristiti
i za kreiranje svojih pomoćnih programa, matematičkih funkcija itd.
Funkcija može primiti (uzeti) bilo koji broj i tip parametara za unošenje i vratiti bilo koji broj
i tip u rezultujućem izlazu.
Sa funkcijom možemo uraditi dvije stvari:
• definisati je
• pozvati je

Da bismo definisali Python funkciju, potrebno je navesti ključnu riječ def , ime funkcije,
zagrade oko svih parametara koji se unose u funkciju, i na kraju, dvotačku (:). Imena funkcija
imaju ista pravila kao i imena promjenljivih (moraju počinjati slovom ili donjom crtom _, i
sadržavati samo slova i brojeve i _).
Idemo korak po korak, i prvo definišemo i pozovemo funkciju koja nema parametara. Evo
najjednostanije Python funkcije:

Čak i za funkciju bez parametara poput ove, i dalje nam trebaju zagrade i dvotačka u njenoj
definiciji. Sljedeći red treba biti uvučen, baš kao što smo uvlačili i kod if naredbe. Python
zahtjeva da pass naredba prikaže da ova funkcija ništa ne radi. To je isto kao i da kaže: Ova
strana je namjerno ostavljena prazna.
Ovu funkciju ukoliko želimo pozvati, to radimo na način da unesemo ime te funkcije i zagrade.
I radi baš ono što joj i samo ime kaže 20, ništa.

20
Konevencija je da se imena funkcija i varijabli daju tako da ime opisuje šta ta funkcija radi ili varijabla sadrži.

60
Hajde da sada definišemo i pozovemo drugu funkciju koja nema parametara, ali ispisuje jednu
riječ:
Kada smo pozvali funkciju „ucimo_programiranje“,
Python je pokrenuo kod unutar definicije same
funkcije. U ovom slučaju, je pozvana funkcija
print(„Python“) – i kao izlaz smo dobili samo riječ
Python.

Hajde da isprobamo funkciju koja nema parametara, ali vraća vrijednost:

Ovu funkciju možemo pozvati i ispitati vrijednosti koju je vratila koristeći if:

Upravo smo napravili jedan veliki iskorak. Kombinacija funkcija sa testovima kao što su if i
petljama poput while nam omogućava da radimo stvari koje ranije nismo mogli uraditi.

Sada je već vrijeme da između zagrada nešto stavimo. Hajde da definišemo funkciju echo() sa
jednim parametrom pod imenom anything. Ona koristi return naredbu za vraćanje vrijednosti
od anything nazad odakle je pozvana dva puta, sa razmakom između.

Hajde sada da pozovemo funkciju echo sa proslijeđenim stringom 'programiranje'

61
Vrijednost koju proslijedimo u funkciju kada je pozivamo poznate su pod imenom argumenti.
Kada pozivamo funkciju sa argumentima, vrijednost tih argumenata se kopiraju u njihove
odgovarajuće parametre unutar funkcije.
U prethodnom primjeru, funkcija echo()pozvana je stringom argumentom 'programiranje'.
Ova vrijednost je prekopirana unutar funkije echo() u parametar anything i zatim vraćena kao
vrijednost kada se funkcija pozove.
Ovi primjeri funkcija su prilično jednostavni. Hajde da napišemo funkciju koja uzima izlaz
argumenta i sa njime radi nešto konkretno.

U prethodnom primjeru definisali smo funkciju koja računa kvadrat proslijeđenog broja.

Ova funkcija radi sljedeće:

• dodjeljuje vrijednost 5 internom parametru 'broj' u funkciji
• računa kvadrat tog broja
• vraća vrijednost kvadrata (integer vrijednost)
Ono što smo dodatno mogli uraditi je da vrijednost nakon pozivanja funkcije dodijelimo nekoj
varijabli, u ovom slučaju varijabli kv_br

I dobijamo sljedeće:

62
Funkcija može uzimati bilo koji argument (uključujući i nulu) bilo kog tipa. Može vratiti bilo
koji broj vrijednosti (uključujući nulu). Ukoliko funkcija izričito ne vrati return, pozivalac
dobija rezultat None.

Pozicioni argumenti
Python rukuje argumentima funkcije na način koji je neobično fleksibilan, u poređenju sa
mnogim jezicima. Najčešći tipovi argumenata su pozicioni argumenti, čije vrijednosti kopiraju
po redu u njihove odgovarajuće parametre.
Sljedeća funkcija pravi rječnik od svojih pozicionih argumenata za unošenje i vraća ga:

Iako su vrlo česti, mana pozicionih argumenata je to što moramo pamtiti značenje svake
pozicije. Ako bismo zaboravili, i pozvali menu() u malo drugačijem redoslijedu, obrok bi bio
drugačiji:

63
Imenovani argumenti
Kako bi izbjegli konfuziju sa pozicionim arguentima, možemo odrediti argumente prema
imenima njihovih odgovarajućih parametara, čak i u drugačijem redoslijedu od njihovih
definicija u funkciji:

Možemo kombinovati pozicione argumente i imenovane argumente. Hajde da prvo odredimo

predjelo, a zatim dezert i glavno jelo:

Ukoliko pozovemo funkciju i sa pozicionim argumentima i imenovanim argumentima,

pozicioni argumenti treba da dođu na prvo mjesto.

Podrazumjevane vrijednosti parametra

Možemo odrediti podrazumjevanu vrijednost za parametre. Podrazumjevana vrijednost se
koristi onda kada pozivalac ne dostavlja odgovarajući argument. Ova mogućnost je zapravo
vrlo korisna. Ukoliko upotrijebimo prethodni primjer:

Sada, pokušajmo da pozovemo menu() bez argumenta dezert:

Međutim, ukoliko proslijedimo argument, on se onda koristi umjesto podrazumjevane

vrijednosti 21:

21
Podrazumjevana vrijednost argumenta se raćuna kada se funkcija određuje (definiše), ne kada se pokreće
(poziva).

64
Prostori imena i opseg
Ime se može odnositi na različite stvari, u zavisnosti od toga gdje se koristi. Python programi
imaju različite prostore imena – odjeljke unutar kojih je određeno ime jedinstveno i
nepovezano sa istim imenom u ostalim prostorima za imena.
Svaka funkcija definiše sopstvene prostore imena. Ukoliko definišete promjenljivu pod
imenom suma u glavnom programu i drugu promjenljivu suma u funkcij, one se neće odnositi
na iste stvari.

Razlog ovakvog ispisa, je taj što je promjenljiva suma koja se nalazi unutar funkcija vidljiva
(raspolaže se sa njom) samo unutar funkcije.

Upravljanje greškama uz try i except

„Nemoj pokušavati. Uradi to ili nemoj uraditi.“ – Joda

U nekim jezicima, greške ukazuju na posebne povratne vrijednosti funkcija. Python koristi
izuzetke: kod koji se izvršava kada dođe do greške.
Već smo ih vidjeli, kao na primjer, pri pristupanju listi ili n-torci sa udaljenostima (indeksima)
kojje su van opsega, ili u rječniku sa nepostojećim ključem. Kada pokrenemo kod koji može
da zakaže pod nekim okolnostima, također su vam potrebni odgovarajući izuzeci kako bi
presreli ove potencijalne greške.
Treba obezbijediti upravljanje izuzecima gdje god je moguće da se pojavi izuzetak kako bi
korisnik znao šta se dešava. Možda nećete moći da ispravite problem, ali barem možemo da
pribilježimo okolnosti i isključimo program kako treba. Ukoliko dođe do izuzetaka u nekim
funkcijama i tu se on ne detektuje, taj izuzetak isplivava sve dok ga odgovarajući rukovodioc
izuzecima ne detektuje u funkciji koja je pozvala. Ukoliko ne obezbijedimo sopstvene
rukovaoce izuzecima, Python ispisuje poruku o grešci i informacije o mjestu gdje je došlo do
greške i zatim se program obustavlja, kao što je prikazanao na sljedećem dijelu koda:

65
Umjesto da to prepustimo slučaju, koristimo try da obavijemo kod i except da obezbijedimo
upravljanje greškama:

Prvo se pokreće kod unutar bloka try. Ukoliko ima greške, dolazi do izuzetka i pokreće se kod
unutar bloka except. Ukoliko nema greške, blok except se preskače.
Određivanje običnog except bez argumenata, kao što smo to uradili ovdje, obuhvata sve tipove
izuzetaka. Ukoliko se desi više od jednog tipa izuzetka, najbolje je dostaviti zasebnog
rukovodioca za svaki izuzetak. Mada, možemo koristiti i obični except da obuhvatimo sve
izuzetke, ali ćemo ga najvjerovatnije imati u uopštenom formatu („Došlo je do neke greške“).

66
Primjeri

Primjer 1
Na osnovu unesenog broja, ispisati da li je taj broj paran ili neparan.

Primjer 2
Na osnovu unesenog broja, ispisati da li je taj broj pozitivan, negativan ili nula.

67
Primjer 3
Napisati program koji provjerava da li je lista prazna ili nije. Ukoliko nije prazna, ispisati od
koliko elemenata se sastoji.

Primjer 4
Napisati program koji provjerava da li određeni broj nalazi u listi. Broj koji se provjerava se
traži od korisnika da unese
A lista je zadata:
lista = [1, 34, 5, 19, 99, 102, 15]

Primjer 5
Napisati program koji traži od korisnika unos brojeva sve dok suma tih brojeva ne bude
manja od 20. I na kraju ispisati sumu unesenih brojeva.

68
Primjer 6
Napisati program koji traži od korisnika unos brojeva sve dok uneseni broj ne bude neparan. U
slučaju unosa neparnog broja treba se ispisati poruka „Unijeli ste neparan broj“ i završiti
program. A u slučaju unosa parnog broja da ispiše "Unijeli ste broj: broj".

Primjer 7
Napisati program koji traži od korisnika za autentifikaciju dužine passworda. Uvjet za
minimalan broj karaktera je 8. Ako korisnik unese manje od 8 karaktera, traži se ponovan unos
passworda. Ako korisnik unese više i jednako od 8 karaktera, program se završava i ispisuje
unijeti password.

69
Primjer 8
Napisati program koji traži od korisnika unos brojeva koji će se dodavati u praznu listu. Kada
korisnik unese „q“ prekida se unos brojeva i ispisuje se lista sa dodatim elementima.

Primjer 9
Napisati funkciju koja provjerava da li je upisan broj pozitivan ili negativan.

70
Primjer 10
Napišite funkciju koja će izračunati prosjek brojeva u listi. Funkcija bi trebala primiti jedan
argument (lista brojeva) i vratiti prosjek.

Primjer 11
Napišite funkciju koja će spojiti dva stringa u jedan. Funkcija bi trebala primiti dva argumenta
(prvi_string i drugi_string) i vratiti spojeni string.

Primjer 12
Napisati program kojim se od korisnika traži unos elemenata u prazne liste. Nakon što korisnik
unese 'q' prestaje se sa unosom elemenata u listu i završava se program te ispisuje tu listu
elementa.

71
Primjer 13
Napisati program koji pronalazi broj nula (elemenata sa vrijednošću 0) i ispisuje koliko ima
takvih elemenata u datoj listi.

72
 6. Moduli i paketi

Moduli i paketi omogućavaju lakši i brži razvoj programskog koda, a u konačnici i programa.
Napisano je puno modula tj. paketa za Python koji ubrzavaju razvoj programskog koda
jednostavnim pozivanjem unaprijed napisanih funkcija, razreda, konstanti. Moduli tj. paketi su
organizirani u smislene cjeline radi što lakšeg snalaženja, ne samo prilikom korištenja već i
radi što lakšeg traženja po dokumentaciji.

Module i pakete koji dolaze sa standardnom instalacijom Pythona nazivamo standardnom

bibliotekom.

Ponekad su programerima potrebne funkcionalnosti koje ne dolaze s modulima tj. paketima iz

standardne biblioteke. Za takve funkcionalnosti potrebno je poslužiti se Internetom i potražiti
odgovarajuće pakete te ih instalirati na računar na kojem će se program izvršavati. U nastavku
obrađeni su samo moduli koji dolaze sa standardnom instalacijom Pythona.

Potrebno je razlikovati module i pakete. Moduli su elementi programskog koda unutar kojih je
implementirana neka specifična funkcionalnost. Uzmimo za primjer nekoliko modula koji
dolaze sa standardnom bibliotekom: math, cmath, random, datetime. Paketi su cjeline koje
uključuju druge module i oni omogućavaju njihovo hijerarhijsko grupisanje. Uzmimo za
primjer paket koji dolazi sa standardnom bibliotekom, paket urllib, koji u sebi sadrži nekoliko
modula:

• urllib.request
• urllib.error
• urllib.parse
• urllib.robotparser

6.1. Rad sa modulima i paketima

Funkcije, konstante i razrede koji se nalaze unutar nekog modula, moguće je koristiti na dva
načina:

• najavljivanjem korištenja
• uključivanjem u program

73
Najavljivanje korištenja

Najavljivanje korištenja modula ostvaruje se pomoću ključne riječi import.

Sintaksa:

import <modul>

U gornjem primjeru prikazan je način korištenja naredbe import. Kod ovakvog načina korištenja
naredbe import najavljuje se korištenje svih funkcija, razreda i konstanti (u daljnjem tekstu spominjat
će se samo funkcije, međutim podrazumijeva se da se u nekom modulu mogu nalaziti i razredi i
konstante) iz nekog modula.
Ako se korištenje funkcija samo najavi kao u gornjem primjeru, tada u svakom dijelu programa u kojem
želimo iskoristiti funkciju iz najavljenog modula mora pisati ime modula i ime funkcije odvojene
tačkom. Sintaksa ovakvog načina korištenja najavljenih funkcija je:

modul.funkcija()

Uključivanje u program

Ako se želi izbjeći gornja sintaksa i koristiti samo ime funkcije kao poziv, a ne da se ispred
imena funkcije piše ime modula u kojem se funkcija nalazi, tada je potrebno željene funkcije
uključiti u program. Uključivanje funkcija u program radi se korištenjem ključnih riječi from i
import. Sintaksa takvog načina korištenja funkcija jest:

from <modul> import <funkcija1>, <funkcija2>

Ključna riječ from govori koji modul će se koristiti, dok ključna riječ import govori koje sve
funkcije iz modula će se uključiti u naš program. Kod ovakvog načina uključivanja funkcija u
program, prilikom korištenja uključenih funkcija, za razliku od prijašnjeg primjera, više nije
potrebno pisati u kojem modulu se nalazi korištena funkcija.

74
U gornjem primjeru prikazana je sintaksa korištenja funkcija tako da se one uključuju u
programski kod. U program su uključene samo one funkcije koje će se koristiti u programskom
kodu, a to su sin() i cos(). Primijetimo da prilikom poziva funkcija više nije potrebno ispred
funkcije pisati ime modula u kojem se ta funkcija nalazi.

Ako se prilikom korištenja (poziva) funkcija iz modula ne želi pisati iz kojeg modula dolazi
funkcija, a ne želi se ni kod uključivanja modula raditi popis svih funkcija koje će se koristiti,
to se može napraviti tako da u program uključimo sve funkcije iz nekog modula.

from math import *

Problem koji se može pojaviti prilikom ovakvog načina korištenja modula jest to da se prilikom
uključenja više različitih modula može dogoditi kolizija ako se u dva i više modula nalazi isto
ime funkcije.

Primjer organizacije projekta

Kada pišete projekat u Pythonu, dobra organizacija foldera je ključna za održavanje čitljivosti,
organizovanosti i jednostavnosti upravljanja kodom.

Postoji nekoliko različitih pristupa organizaciji foldera u Pythonu, ali jedan od najčešćih je
takozvani "modularni pristup". Ovaj pristup podrazumjeva organizaciju koda u module
(fajlove), koji se zatim grupišu u direktorijume (foldere) prema funkcionalnosti.

Evo jedne moguće strukture foldera koja bi mogla biti korisna za srednje do velike projekte:

75
projekat/

├── README.md

├── setup.py

├── requirements.txt

├── docs/

│ ├── index.md

│ ├── installation.md

│ ├── usage.md

│ └── ...

├── tests/

│ ├── test_module1.py

│ ├── test_module2.py

│ └── ...

├── src/

│ ├── __init__.py

│ ├── module1/

│ │ ├── __init__.py

│ │ ├── module1.py

│ │ └── ...

│ ├── module2/

│ │ ├── __init__.py

│ │ ├── module2.py

│ │ └── ...

│ └── ...

└── data/

├── raw/

├── processed/

└── ...

76
U ovom primjeru, README.md sadrži opšte informacije o projektu, setup.py je Python skripta
koji se koristi za instalaciju projekta, a requirements.txt sadrži spisak Python biblioteka koje
su potrebne za pokretanje projekta.

docs/ direktorijum sadrži dokumentaciju projekta, koja može biti organizovana po potrebi.
tests/ direktorijum sadrži testove za projekat.

src/ direktorijum je najvažniji i sadrži sve module koje ste napisali za vaš projekat. Svaki modul
se nalazi u svom sopstvenom folderu, a __init__.py fajl označava da je folder Python paket. U
ovom primjeru postoje module1/ i module2/, ali u praksi bi se ovo moglo proširiti na bilo koliko
modula.

data/ direktorijum je namjenjen za sve podatke koje projekt koristi. U ovom primjeru postoje
raw/ i processed/ direktorijumi, ali u praksi bi se ovde mogli nalaziti bilo koji podaci koji su
potrebni za vaš projekat.

Ovo je samo jedan primjer strukture foldera, a vi možete prilagoditi ovaj template prema svojim
potrebama i specifičnostima vašeg projekta. Važno je samo da se držite jedne organizovane i
konzistentne strukture kako biste olakšali upravljanje i održavanje vašeg koda.

77
 7. Objekti i klase

Sve do sada, vidjeli smo strukture podataka poput stringova i rječnika, i strukture koda kao
što su funkcije i moduli. U ovom poglavlju napravit ćemo nove strukture podataka: objekte.

7.1. Šta su objekti?

Kao što smo spomenuli u poglavlju 2, sve u Python-u, od brojeva pa do modula, je objekat.
Međutim, Python većinu mašinerije iza objekta skriva posebnom sintaksom. Možemo ukucati
num = 7, kako bismo napravili objekat cjelobrojnog tipa sa vrijednošću 7, i napraviti ga tako
da num pokazuje na njega. Jedini put kada moramo pogledati u objekat jeste kada želimo da
osmislimo ili uredimo ponašanje već postojećih objekata. Kako se rade, vidjet ćemo u ovom
poglavlju.
Objekat sadrži i podatke (promjenljive, pod imenom atributi) i kod (funkcije, pod imenom
metode). On predstavlja jedinstveno instancu nečeg konkretnog. Na primjer, cjelobrojni
objekat sa vrijednošću 7 je objekat koji omogućava metode kao što su sabiranje ili množenje.
Ovo znači da postoji klasa Integer u Pythonu kojoj pripadaj cjelobrojna vrijednost 7, 8 itd.
Stringovi poput 'pas' i 'mačka', su također objekti u Pythonu i imaju metode za stringove koje
smo do sada već vidjeli, poput replace().
Kada stvaramo nove objekte koje niko prije nije napravio, moramo napraviti klasu koja ukazuje
na njihov sadržaj.
Objekte možemo posmatrati kao imenice, a na metode kao njihove glagole. Objekat predstavlja
nešto indvidualno, a metode definišu kakvu interakciju ono ima sa ostalim stvarima.
Za razliku od modula, možemo imati istovremeno različite objekte iste klase, svaki sa svojim
različitim vrijednostima za svoje atribute Oni su kao super-struktura podataka, sa ubačenim
kodom.

7.2. Definisanje klase

U poglavlju 2, objekat smo uporedili sa kutijom. Klasa je kao kalup kojim se ta kutija pravi.
Na primjer, String je ugrađena Python klasa koja stvara string objekte kao što su 'mačka', 'pas'.
Python ima još dosta drugih ugrađenih klasa za stvaranje drugih tipova podataka, među kojima
su i lite, rječnici itd. Da bismo napravili sopstveni objekat po mjeri, u Python-u, prvo moramo
definisati klasu koristeći class kao ključnu riječ.
Hajde da prođemo kroz jedan jednostavan primjer:
Predpostavimo da želimo da definišemo objekte tako da predstavljaju informacije o ljudima.
Svaki objekat će predstavljati po jednu osobu. Prvo treba da definišemo klasu pod imenom

78
Osoba kao kalup. U primjerima koji slijede, isprobat ćemo više od jedne verzije ove klase kako
budemo napredovali od jednostavnijih klasa do onih koje zapravo rade nešto korisno.
Naš prvi pokušaj je najjednostavnija moguća klasa – prazna:

Isto kao i sa funkcijama, trebalo je da kažemo pass kako bismo ukazali na to da je ova klasa
prazna. Ova definicija je minimum za pravljenje objekta. Objekat se iz klase pravi pozivanjem
imena klase kao da je funkcija:

U ovom slučaju, Osoba() stvara indvidualni objekat iz Osoba klase i dodjeljuje mu ime neko.
Međutim, naša Osoba klasa je bila prazna, tako da objekat neko- koji smo od njenapravili samo
postoji tu i nište ne može drugo da radi. Nikada zapravo ne bismo definisali takvu klasu, pa je
ovo samo ilustrativan primjer čisto da bismo napredovali do sljedećeg primjera.
Hajde ponovo da pokušamo, ali da ovaj put u to uključimo i posebnu Python metodu za
inicijalizaciju objekta __init__:

Ovo ćemo vidjeti u pravim definicijama Python klasa.

__init__() je posebno Python ime za metodu koja individualni objekat pokreće iz definicije
klase. Argument self određuje da ono pokazuje sam indvidualni objekat.
Kada definišemo __init__() u definiciji klase, njegov prvi parametar bi trebalo da bude self.
Premada self, nije rezervisanariječ u Python-u, često se koristi. Niko ko bi kasnije mogao čitati
vaš kod (uključujući i nas same) neće kasnije morati da pogađa šta smo mislili kada smo
upotrijebili self.
Međutim, čak ni drugom Osoba(), definicijom, nije stvoren nikakav objekat koji će zapravo
nešto konkretno da radi. Treća sreća, pa ćemo pokušati da vidimo kako se stvara jednostavan
objekat u Python-u, s tim da ćemo ovaj put dodati parametar ime metodi za inicijalizaiciju:

79
Sada možemo napraviti objekat iz Osoba klase prosljeđivanjem stringa za parametar ime:

Evo šta ova linija koda radi:

• Pretražuje definiciju klase Osoba
• Stvara novi objekat u memoriji
• Poziva metodu __init__, proslijeđujući ovaj novostvoreni objekat kao self, a drugi
argument ('Guido van Rossum') kao ime
• Skladišti vrijednost imena (ime) objekta
• Vraća novi objekat
• Dodjeljuje ime osoba1 za objekat
Ovaj novi objekat je kao i svaki drugi objekat u Python-u. Možemo ga koristiti kao element
liste, n-torke ili rječnika. Možemo ga proslijediti funkciji kao argument ili ga vratiti kao
rezultat.
A šta je sa vrijednošću ime koju smo proslijedili unutra? Sačuvana je sa objekotm kao atribut.
Možemo je čitati i pisati direktno:

Zapamtimo, unutar definicije klase Osoba, možemo pristupiti atributu ime kao self.ime, kada
pravimo konkretan objekat na primjer osoba1, navođenjem osoba1.ime

80
 7.2.1. Nasljeđivanje

Kada pokušavamo da riješimo neki problem sa kodom, često ćemo naći klasu koja već pravi
objekte koji rade skoro baš to što vam treba. Šta možemo da uradimo? Mogli bi smo
modifikovati ovu staru klasu, ali ćemo je dalje zakomplikovati pa možemo pokvariti nešto što
je radilo 22.
Naravno, mogli bismo napraviti i novu klasu, kopiranjem dijelova stare i spajanjem sa novim
kodom. Ali, ovo znači da imamo više koda koji treba održavati, a u slučaju izmjena novi i stari
kod mogu postati nekompatibilni jer su sada na različitim mjestima.
Rješenje je u nasljeđivanju: stvaranje nove klase od postojeće, ali sa nekim dodacima ili
izmjenama. To je jedan sjajan način recikliranja koda. Kada se sluđimo nasljeđivanjem, nova
klasa može automatski koristiti sav kod iz stare klase, ali bez toga da te dijelove iz nje
kopiramo.
Definišemo samo ono što je potrebno dodati ili izmijeniti u novoj klasi, i time se premosti
ponašanje stare klase. Izvorna klasa se naziva nadklasa, superklasa, ili osnovna klasa je
podređena klasa, podklasa ili izvedena klasa. Ovi termini se koriste naizmjenično u objektno-
orijentisanom programiranju.
Stoga, hajde da nešto naslijedimo. Definisat ćemo praznu klasu pod imenom Auto. Zatim,
definisat ćemo podklasu klase Auto pod imenom Tesla. Podklasu definišemo korištenjem iste
ključne riječi class, ali sa imenom nadklase u zagradama (class Tesla(Auto)) kao što je
prikazano ispod:

Zatim, napravimo objekat od svake klase:

Podklasa je specijalizacija nadklase; u objektno-orijentisanom žargonu, Tesla je Auto. Objekat

pod imenom auto2 je instanca klase Tesla, ali također naslijeđuje i sve što može i Auto. Mada
u ovom slučaju, Auto i Tesla su korisni koliko i čistač palube na podmornici, tako da hajde da
napravimo novu definiciju klase koja zapravo radi nešto:

22
Nepisano programersko pravilo: „Ako radi – ne diraj.“

81
Ukoliko, napravimo jedan objekat od svake klase i pozovemo metodu prikaz():

Tesla je naslijedio prikaz() metodu iz klase Auto, a da nismo ništa naročito uradili sa klasom
Tesla. Zapravo, Tesla tvrdi da jeste Auto, što može dovesti do krize identiteta. Hajde da vidimo
šta možemo uraditi povodom toga.

7.2.2. Premostiti metodu

Kao što smo upravo vidjeli, nova klasa u početku nasljeđuje sve iz svoje nadklase. Kako
budemo napredovali, vidjet ćemo kako da zamijenimo ili premostimo nadređenu metodu. Tesla
bi vjerovatno na neki način trebalo da bude drugačiji od Auto; u suprotnom, koja je poenta
definisanja nove klase? Hajde da promijenimo način na koji metoda prikaz() radi za Teslu:

82
Ukoliko napravimo objekte ovih klasa:

U ovim primjerima, premostili smo metodu prikaz(). Možemo premostiti svaku metodu, među
njima je i __init__(). Evo još jednog primjera koji koristi našu raniju klasu Osoba. Hajde da
napravimo dvije podklase koje predstavljaju doktora i advokata:

U ovim klasama, metoda za inicijalizaciju __init__() uzima iste argumente kao i nadklasa
Osoba ali skladišti vrijednosti ime posebno u svakom objektu.

83
 7.2.3. Dodavanje metoda

Podklasa može također i dodadati metodu koja se ne nalazi u nadklasi. Vratit ćemo se na klase
Auto i Tesla, i definisat ćemo nove metoda potrebno_punjenje() samo za klasu Tesla:

Hajde da sada napravimo jedanobjekat iz klase Auto i Tesla:

Objekat iz klase Tesla, auto2 može reagovati na poziv metode; potrebno_punjenje()

84
Ali, generički objekat (auto1) klase Auto, to ne može:

Sada Tesla, može da radi nešto što Auto ne može, pa prepoznatljivost Tesle može da dođe do
izražaja.

7.2.4. Pomoć od nadklase uz super

Vidjeli smo kako podklasa može da dodaje ili premosti metodu od svoje nadklase. Šta ako
bismo željeli da pozovemo tu nadređenu metodu? To možemo uz pomoć funkcije super().
Definisat ćemo novu klasu pod imenom EmailOsobe koja predstavlja osobu (Osoba)- sa
adresom elektronske pošte. Prvo, naša definicija Osobe:

Primjetit ćemo da __init__() poziv u sljedećoj podklasi ima dodatan parametar email:

85
Kada definišemo jednu __init__() metodu za našu klasu, mi zamjenjujemo __init__() metodu
njene nadklase, i ona se više ne poziva automatski. Rezultat je to da je moramo pozvati
ekplicitino. Evo šta se dešava:
• Metoda super() dobija definiciju nadklase, Osoba
• Metoda __init__() poziva Osoba.__init__() metodu. Vodi računa o proslijeđivanju
self argumenta nadklasi, tako da samo treba joj treba dati opcione argumente. U
našem slučaju, jedini drugi argument koji Osoba() obuhvata je ime.
• Red self.email = email, je novi kod koji čini EmailOsoba drugačijimm od Osoba.

Idemo da napravimo objekte iz ovih klasa:

Trebalo bi sada da možemo da pristupamo i atributu ime i email:

Postavlja se pitanje, zašto nismo našu novu klasu definisali kao što slijedi:

Mogli smo to uraditi, ali bismo time prekršili upotrebu nasljeđivanja. Upotrijebili smo metodu
super() da učini da Osoba radi svoj posao, isto kao što bi i običan objekat Osoba radio. Postoji
još jedna korist: ukoliko se definicija Osoba promijeni u buudćnosti, korištenjem super() ćemo
obezbijediti da svi atributi i metode koje EmailOsoba naslijeđuje od Osoba odražavaju tu
promjenu.
Koristimo super() onda kada podklasa radi nešto na svoj način ali joj i dalje treba nešto od
nadklase.

86
 7.2.5. Argument self

Najčešća kritika Python-a (pored uvlačenja teksta) jeste potreba za korištenjem self kao prvog
argumenta za metode instance (ovakve metode koje smo vidjeli u prethodnim primjerima).
Python koristi argument self da nađe prave atribute i metode objekta. Pokazat ćemo kroz
primjer, kako još možemo pozvati metodu objekta, kao i ono što Python radi iza kulisa:

Evo šta Python zapravo čini ispod haube:

• Pretražuje klasu Auto objekta auto
• Proslijeđuje objekat metodi prikaz() klase Auto kao parametar self

Čisto zabave radi, možemo pokrenuti ovo i na sljedeći način i radit će kao i normalna
sintaksa:

Međutim, nikada nema razloga za korištenjem dužeg stila.

7.2.6. Pronalazak i podešavanje vrijednosti atributa

Neki objektno-orijentisani programski jezici podržavaju privatne atribute objekta kojima se ne

može pristupiti direktno spolja; programeri često moraju pisati metode za dobijanje i
postavljanje vrijednosti ako bi čitali i pisali vrijednosti takvih atributa.
Python-u ne trebaju ovakve metode, jer su svi atrivuti i metode javni, a od nas se očekuje
ispravno ponašanje. Ukoiko nam se ideja o direktnom pristupanju atributima ne dopada,
možemo naravno pisati metode za dobijanje i postavljanje vrijednosti. Ali, pazimo da budemo
pajtonski nastrojeni – koristimo osobine.
U sljedećem primjeru, definisat ćemo klasu Pas sa jednim atributom pod imenom
skriveno_ime. Ne želimo da iko drugi pristupa ovom atributu direktno, tako da ćemo definisati
dvije metode: za nalaženje (get_ime()) i za podešavanje (set_ime()). Dodali smo još i print()
naredbu svakoj metodi da bi pokazali kako se ona poziva.

87
Nove metode se ponašaju kao normalni pretraživači (getter) i podešivači (setter) sve do
posljednjeg reda; on definiše ove dvije metode kao osobine atributa ime. Prvi argument za
property() je metoda pretraživač, a druga podešivač. Sada kada ukazujemo na ime (ime) bilo
kojeg Pas objekta, time se zapravo poziva get_ime() metoda da bi vratila to ime:

I dalje možemo pozvati get_ime() metodu direktno, kao normalnu pretraživačku metodu:

Kada ime atributu dodijeljujemo neku vrijednost, set_ime() metoda će biti pozvana:

88
I dalje možemo pozvati metodu set_ime() direktno:

89
Primjeri

Primjer 1
Napraviti klasu Stan sa atributima: lokacija, kvadratura, cijena uz metodu promjena cijene i
poreza na nekretninu od 3%, kao i metodu prikaz koja ce sve navedeno isprintati.

90
Primjer 2
Napraviti klasu sa dva atributa stranicom a i b za računanje obima i površine pravougaonika.
Imamo dvije metode: getPovrsina i getOpseg.

Primjer 3
Napraviti klasu KursPython, koja će imati dva atributa, student i bodovi. Funkcije koje klasa
treba da ima je da na osnovu bodova ispiše da li je taj student položio ili nije položio završni
test. Položio ako ima >=70 bodova.

91
 8. Podaci moraju negdje otići

Aktivan program skladišti podatke u RAM memoriji. RAM memorija je vrlo brza, ali je skupa
i zahtjeva stalan dotok energije; ukoliko nestane struje, svi podaci u memoriji se gube. Diskovi
su sporiji od RAM memorije, ali imaju veći kapacitet, manje koštaju, i zadržavaju podatke i
nakon što se izgubi dotok električne energije. Upravo zbog toga, uložena je ogromna količina
truda u računarske sisteme kako bi se došlo do najboljih kompromisa između skladištenja
podataka na disku i u RAM memoriji. Kao programerima, potrebna nam je trajnost:
skladištenje i vraćanje podataka korištenjem trajnih medija kao što su diskovi (HDD/SSD).
U ovom poglavlju govori se o različitim vrstama skladišta podataka, gdje je svaka
optimizovana u različite svrhe.

8.1. Ulazno – izlazne operacije sa fajlovima

Najjednostavniji oblik trajnog zapisa podataka je obični fajl. To je samo lista bajtova pod
nazivom fajla. Iz fajla s eučitava u memoriju, a iz memorije upisuje u fajl. Python ove zadatake
poprilično pojednostavljuje.
Prije učitavanja i ispisivanja fajla, moramo ga otvoriti:

fileobj = open(filename, mode)

Evo kratkog objašnjenja segementa ovog poziva:

• fileobj je objekat fajla kojeg vraća open()
• filename je string ime fajla
• mode je string koji ukazuje na tip fajla i ono što njime želimo da radimo

Prvo slovo u mode ukazuje na operaciju:

• r – znači čitati
• w – znači pisati, ukoliko fajl ne postoji, pravi se. A ukoliko postoji prepisuje se
• x – znači pisati, ali samo ukoliko fajl već ne postoji
• a – znači dodati (napisati nakon kraja) ukoliko fajl postoji.

Drugo slovo u mode ukazuje na tip fajla:

• t (ili ništa) - znači teksutalni fajl
• b - znači binarni fajl
Nakon otvaranja fajla, pozivamo funkciju za čitanje ili pisanje podataka; one će biti prikazana
u primjerima koji slijede.

92
Hajde da napravimo jedan fajl od Python stringa u programu i zatim ga ponovo pročitamo u
tekstu.

8.2. Pisanje tekstualnih fajlova koristeći write()

Kao izvorni podatak koristit ćemo jedan citat Meše Selimovića:

Sljedećim kodom, cijeli citat se ispisuje u fajlu „Mesa“ u jednom pozivu:

Funkcija write() vraća broj napisanih bajtova. Ne dodaje nikakve razmake ili nove redove, kao
što to radi funkcija print().

8.3. Čitanje tekstualnog fajla putem read(), readline() ili readlines()

Možemo pozvati funkciju read() bez argumenata kako bismo iščitali cijeli fajl odjednom, kao
što je prikazano u primjeru koji slijedi. Treba biti oprezan kada to radimo sa velikim fajlovima;
fajl od gigabajta će zauzeti gigabajt memorije.

Također možemo čitati fajl red po red, koristeći readline(). U sljedećem primjeru dodat ćemo
svaki red stringu citat kako bismo napravili iznova orginal:

93
Za tekstualni fajl, čak i prazan red ima dužinu kao jedan red (novi red), i ocjenjuje se kao True.
Kada se fajl pročita, readline() (kao i read()) također vraća prazan string, koji se također
ocjenjuje kao False.
Najlakši način da pročitate tekstualni fajle jeste korištenjem iteratora. Ovime se vraća jedan po
jedan red. Slično je prethodnom primjeru, ali sa manje koda:

Svi prethodni primjeri na kraju izgrade citat od jednog stringa. Funkcija readlines() poziva red
po red, i vraća listu stringova od jednog reda:

94
 8.4. Zatvorite fajlove automatski koristeći with

Ukoliko smo zaboravili da zatvorimo fajl koji smo otvorili, Python će ga zatvoriti kada više ne
bude bio pozivan. To znači da će se ukoliko otvorimo fajl u funkciji i ne zatvorimo ga
eksplicitno, on zatvoriti automatski sa završetkom funkcije. Ali možda smo otvorili fajl u
funkciji koja dugo radi ili u glavnom dijelu programa. Fajl bi trebalo zatvoriti kako bi se na
silu izvršila ostala ispisivanja.
Python ima rukovodioca kontekstom kako bi sređivao stvari kao što su otvoreni fajlovi. Služit
ćemo se oblikom:

with izraz as promjenljiva:

To je to. Nakon što se blok koda rukovodiocu kontekstom (u ovom slučaju, jedan red) izvrši
(normalno ili sa greškom), fajl se automatski zatvara.

95
Zaključak

Uspješno smo završili naš putovanje kroz osnove Pythona. Počevši od print funkcije, najjednostavnijeg
načina za ispis informacija na ekran, prešli smo dugu stazu učenja koja je uključivala razumijevanje
varijabli, tipova podataka, kontrolnih struktura, funkcija, modula, i na kraju klasa i rada s datotekama.
Dok smo se kretali kroz različite teme, vaša su se znanja i vještine gradila. Svaka nova tema proširila
je vašu sposobnost korištenja Pythona za rješavanje problema i realizaciju ideja. Sada možete napisati
svoje programe, strukturirati kod, raditi s podacima, upravljati datotekama i implementirati osnovne
koncepte objektno orijentiranog programiranja.
Međutim, vaše putovanje u svijetu Pythona tek je započelo. Python je iznimno moćan jezik s brojnim
bibliotekama i okvirima koji se koriste u različitim industrijskim sektorima, uključujući web razvoj,
mašinsko učenje, analizu podataka razvoj igara, automatizaciju i još mnogo toga. Bez obzira na vaše
interese, sigurno ćete pronaći način kako upotrijebiti Python da bi se vaše ideje ostvarile.
Također, ne zaboravite da je programiranje vještina koja se stalno razvija. Dok nastavljate učiti,
pokušajte redovito vježbati i izazivati sebe s novim projektima. Također, budite otvoreni za učenje iz
svojih grešaka i nemojte se bojati pitati za pomoć. Python ima veliku i prijateljsku zajednicu koja je
uvijek spremna pomoći.
Za kraj, želim vam čestitati na vašoj posvećenosti i trudu. Naučili ste mnogo i postigli značajan
napredak. Nastavite s istraživanjem, učenjem i stvaranjem. Sretno na vašem daljnjem putovanju s
Pythonom!

96
Zadaci za samostalan rad

Zadatak 1
Napisati program koji prolazi kroz listu brojeva i ispisuje samo parne brojeve.
lista = [1, 2, 3, 5, 7, 18, 20, 99, 100]

Zadatak 2
Za prethodno zadatu listu, napisati kod koji će napraviti dvije nove liste sa parnim i neparnim
brojevima. Tako da u listi za parne brojeve ćemo ubaciti sve one parne brojeve iz zadate liste,
a u listu neparnih brojeva, sve one neparne brojeve iz zadate liste.

Zadatak 3
Za zadatu listu brojeva, ispisati onaj element koji ima najmanju vrijednost.
lista = [13, 44, 3, 56, 9, 98, 99, 66, 11, 7]

Zadatak 4
Napišite funkciju koja će provjeriti je li dana riječ palindrom. Funkcija bi trebala primiti jedan
argument (riječ koja se provjerava) i vratiti "Da" ako je riječ palindrom ili "Ne" ako nije.

Zadatak 5
Napišite funkciju koja će izračunati prosjek brojeva u listi. Funkcija bi trebala primiti jedan
argument (lista brojeva) i vratiti prosjek.

Zadatak 6
Napišite funkciju koja će izračunati faktorijel broja. Funkcija bi trebala primiti jedan argument
(broj) i vratiti njegov faktorijel.

Zadatak 7
Napišite funkciju koja će filtrirati sve neparne brojeve iz liste. Funkcija bi trebala primiti jedan
argument (lista) i vratiti novu listu koja sadrži samo neparne brojeve.

Zadatak 8

97
Napisati kod koji tražiti od korisnika da unese neki broj a zatim računa sumu parnih brojeva
do tog broja kao i sumu neparnih brojeva do unesenog broja. A nakon toga razliku sume
neparnih od sume parnih brojeva. Treba da ispiše sve, u slj. formatu:
Suma parnih brojeva je: ____
Suma neparnih brojeva je: ____
Razlika prethodne dvije sume je: ___

Zadatak 9
Niz koji je zadat treba ispisati sve one članove čija je vrednost manja od njihovog rednog
broja (indeksa) u nizu.
niz = [12, 15, 88, 74 , 45, 5, 1, 4, 19, 0, 6, 0, 11]

Vrijednost elementa 1 je manja od indeksa 6 na kojem se nalazi.

Vrijednost elementa 4 je manja od indeksa 7 na kojem se nalazi.
Vrijednost elementa 0 je manja od indeksa 9 na kojem se nalazi.

Zadatak 10
Napisati kod koji provjerava da li u nizu ima više pozitivnih ili negativnih brojeva.
niz = [1,-3, 14, 55, -9, -22, 66, 90, 18, 99, -11]

Zadatak 11
Napisati kod koji će naći index najmanjeg elementa sljećeg niza:
niz = [22,34,12,11,99,109,33,19,9,92,3,19]

Zadatak 12
Napišite funkciju pretrazi_po_vrijednosti(rjecnik, vrijednost) koja će pretražiti rječnik po
vrijednostima i vratiti listu ključeva čije vrijednosti odgovaraju traženoj vrijednosti.
osobe = {"Mujo": 25, "Haso": 30, "Fata": 27, "Hajra": 25}

Zadatak 13

98
Napišite funkciju ukloni_duplikate(rjecnik) koja će ukloniti sve duplikate iz rječnika, tj. sve
ključeve koji imaju istu vrijednost kao neki drugi ključ. Funkcija treba vratiti novi rječnik bez
duplikata.

Zadatak 14
Napisati funkciju koja provjerava da li se određeni element narađi u tuplu tuplsa:
Ako se nalazi da vrati True, a ako se ne nalazi da vrati False.
(('Red', 'White', 'Blue'), ('Green', 'Pink', 'Purple'), ('Orange', 'Yellow', 'Lime'))

Zadatak 15
Napišite Python funkciju koja računa zbroj svih elemenata svakog tuplea pohranjenog unutar
liste tuplova.
Izvorna lista tuplova:
[(1, 2), (2, 3), (3, 4)]
Zbroj svih elemenata svakog tuplea pohranjenog unutar navedene liste tuplova:
[3, 5, 7]

Izvorna lista tuplova:

[(1, 2, 6), (2, 3, -6), (3, 4), (2, 2, 2, 2)]
Zbroj svih elemenata svakog tuplea pohranjenog unutar navedene liste tuplova:
[9, -1, 7, 8]

Zadatak 16
Napisati funkciju koja iz postojeće liste kreira novu listu bez duplikata:
lst = [1, 2, 2, 3, 3, 3, 4, 5, 5]
Output: [1, 2, 3, 4, 5]

Zadatak 17
Napišite funkciju koja prima riječi i vraća dužinu najduže riječi u rečenici i tu riječ kao tuple.

Zadatak 18

99
Napisati kod koji u odnosu na unesenog broja ispisuje sljedeći ispis (uneseni broj = broj redova)
1
12
123
1234
12345

Zadatak 19
Napisati funkcija koja prima tri argumenta, a, b i c, i vraća njihovu sumu, ali s uvjetom da se
jedna od vrijednosti ne pojavljuje dva puta. Ako se to dogodi, jedna od njih se neće računati u
zbroju. Primjerice, ako je vrijednost a jednaka vrijednosti b, a zbroju a + b + c će se dodati
samo vrijednost c.
sum_without_duplicates(1, 2, 3) # Output: 6
sum_without_duplicates(2, 2, 3) # Output: 3
sum_without_duplicates(3, 3, 3) # Output: 0
sum_without_duplicates(1, 1, 2) # Output: 2

Zadatak 20
Napišite klasu "Student" u Pythonu. Klasa treba imati sljedeće atribute:
Ime
Godina studija
Prosjek ocjena

Klasa treba imati sljedeće metode:

Metoda promijeni_godinu koja će promijeniti godinu studija studenta.
Metoda prikazi_studenta koja će ispisati ime studenta, godinu studija i prosjek ocjena.

Zadatak 21
Napraviti klasu Imenik koja će primati argumente: ime, broj, naj_broj. Gdje će argument
naj_broj po defaultu biti False. Metode: set_name(), get_name(), set_number(), get_number(),
set_naj_broj(), cijena_poziva(). Cijena treba da prima jedan parametar, dužinu poziva. U
slučaju da je naj_broj = True, tada je cijena poziva 0.25KM/min, u slučaju da nije naj broj: tada
je cijena poziva 0.5 KM/min.

100
101