Unos, obrada i ispis podataka
=============================
Računar kao sistem sposoban za izvršavanje proračuna i pohranu rezultata proračuna zahtijeva podatke na osnovu kojih će obavljati zadate operacije. Ti podaci predstavljaju temelj izračuna koje računar vrši u okviru različitih programa, te su često podložni raznim obradama, analizama i transformacijama prije nego što rezultati budu dostupni korisnicima ili drugim sistemima. Na taj način svaki računar, bez obzira na vrstu ili kompleksnost zadatka, funkcioniše kroz tri ključna segmenta u radu sa podacima:
1. unos podataka,
2. obrada podataka,
3. ispis podataka.
Većina programa sadrži ove tri osnovne komponente. Podaci se prvo unose, što omogućava računaru pristup tim podacima koji su potrebni za izvođenje proračuna ili analiza. Nakon unosa slijedi proces obrade, koji predstavlja centralni i često najkompleksniji dio svakog programa. U ovom segmentu izvršava se niz operacija nad podacima, prilagođenih specifičnom zadatku, poput transformacija, kalkulacija ili filtriranja. Posljednji korak u radu programa obuhvata ispis rezultata, gdje se korisnicima ili drugim sistemima prikazuju informacije proizvedene tokom obrade podataka. Ovi koraci čine osnovne faze rada svakog programskog rješenja, od najjednostavnijih aplikacija do kompleksnih softverskih sistema.
Iako se obrada podataka često percipira kao najkreativniji i najizazovniji dio programiranja, segmenti unosa i ispisa podataka također zahtijevaju pažnju i planiranje. Način na koji se podaci unose može značajno uticati na tačnost i efikasnost obrade, dok način prikazivanja rezultata određuje koliko će korisnik ili sistem moći razumjeti i koristiti te podatke. Zbog toga su tehnike unosa i ispisa, iako obično standardizovane i manje fleksibilne u pogledu kreativnosti, ključne za cjelokupnu funkcionalnost i korisnost programa.
Ovakav strukturirani pristup omogućava organizaciju programa u tri jasne cjeline koje međusobno funkcionišu kao integrisana cjelina, obezbjeđujući da svi podaci budu pravilno prikupljeni, obrađeni i predstavljeni.
Sljedeći listing prikazuje jednostavan Python program koji obuhvata tri ključna dijela: unos, obradu i ispis podataka.
```python=
grad = input("U kojem gradu živite: ")
poruka = "Pozdrav za " + grad + "!"
print(poruka)
```
<pre style="background-color: #1e1e1e; color: white; padding: 20px;">
> U kojem gradu živite: Sarajevo
Pozdrav za Sarajevo!
</pre>
U prvoj liniji programa vrši se unos podataka. Ova linija može uključivati zahtjev korisniku da unese informaciju koja se preuzima i priprema za daljnji rad. Ova početna faza usmjerava program prema ispunjenju svog cilja, jer prikupljeni ulazni podatak postaje polazna osnova za sve naredne operacije.
Druga linija obuhvata obradu podataka, u kojoj se ulazni podatak obrađuje prema specifičnoj logici programa. U ovom primjeru, ta obrada se sastoji od proširivanja unesenog podatka dodatnim tekstom, stvarajući novi podatak. Na taj način se ukazuje na jedan od osnovnih principa programiranja – transformaciju podataka – koja omogućava programima da generišu rezultate koji su korisni i informativni.
Konačno, treća linija služi za ispis rezultata. Ova linija šalje obrađeni podatak nazad korisniku. Iako jednostavna, ova linija jasno ilustruje kako ispis omogućava da podaci koje je program obradio postanu dostupni vanjskom okruženju, korisnicima ili drugim sistemima.
Ova trodijelna struktura, predstavljena u samo tri linije koda, oslikava klasičan sekvencijalni tok programa, gdje se instrukcije izvršavaju redom, jedna za drugom, čime se gradi jednostavan, linearan put od unosa, preko obrade, do ispisa podataka.
Iako program sadrži samo tri linije, njegove instrukcije su složene i sadrže nekoliko osnovnih mehanizama koji zahtijevaju dodatnu analizu. Kao programski jezik visokog nivoa, Python omogućava pojednostavljeno pisanje koda, ali svaki red uključuje više osnovnih instrukcija koje računar mora obraditi kako bi ispunio traženi zadatak. Stoga je važno dodatno analizirati svaki korak, razumjeti kako se ti mehanizmi ostvaruju unutar programa i kako Python, kao jezik visokog nivoa, prepoznaje i interpretira ove instrukcije.
U nastavku prvo se analizira komanda za prikaz podataka. Ovaj pristup odabran je jer se status i ispravno funkcionisanje programa najbolje prate kroz prikazivanje trenutnih vrijednosti koje računar obrađuje. Ispis pruža neposredan uvid u stanje i rezultate obrade, što omogućava lakše razumijevanje i praćenje toka programa. Nakon što se razjasne mehanizmi ispisa, slijedit će analiza unosa informacija te postupci njihove obrade i transformacije.
:::info
Savremeni korisnici računara većinom su navikli na grafičke interfejse (eng. Graphical User Interface - GUI), koji omogućavaju intuitivnu interakciju s aplikacijama kroz vizualne elemente kao što su prozori, ikone i dugmad. Početnici u programiranju često očekuju da će odmah započeti s izradom interaktivnih aplikacija sa sličnim grafičkim mogućnostima, tj. aplikacijama koje prikazuju slike, video sadržaje ili rade s internet stranicama. S obzirom na to, rad sa čistim tekstom i unosom preko terminala može djelovati skromno ili čak pomalo razočaravajuće u poređenju s vizualno bogatim grafičkim interfejsima. Međutim, tekstualni unos i ispis pružaju osnove koje omogućavaju stabilnu bazu za razumijevanje ključnih programskih koncepata.
Terminal predstavlja jednostavno, ali izuzetno korisno okruženje za unos i ispis podataka. Kroz njega korisnici unose naredbe i podatke putem tastature, dok računar prikazuje rezultate obrade u vidu teksta na ekranu. Iako danas možda djeluje kao zastarjela tehnologija, terminal je i dalje neizostavan alat, posebno za programere i sistemske administratore, zbog svog direktnog pristupa resursima sistema. Historijski gledano, terminali su bili prvi način interakcije s računarima i omogućavali su potpunu kontrolu nad operativnim sistemom i aplikacijama.
Rad sa složenijim podacima, poput slika, videa ili internet sadržaja, zaista pruža atraktivnije mogućnosti za korisničke aplikacije, ali zahtijeva dodatne programerske tehnike i mehanizme koji povećavaju kompleksnost razvoja. Da bi se uspješno obradili ovakvi podaci, neophodno je poznavati naprednije strukture i alate koji nadograđuju osnovne koncepte programiranja. Obrada tekstualnih podataka putem terminala, s druge strane, omogućava programerima da se u početnim fazama fokusiraju na razumijevanje suštinskih elemenata jezika, kao što su unos i ispis podataka, strukture kontrole toka i osnovne algoritamske operacije.
Tekstualna interakcija putem terminala predstavlja efikasan i koristan pristup za učenje ključnih aspekata programiranja. Kroz rad sa tekstom, korisnici mogu usvojiti osnovne vještine koje čine temelj većine aplikacija, dok se složeniji rad s multimedijom i grafikom može nadovezati kasnije, kada su usvojeni osnovni principi.
:::
## Ispis podataka
Python koristi jednostavan i intuitivan način za prikaz podataka putem funkcije `print()`, koja se praktično koristi kao jedina opcija za ispis. Zahvaljujući svojoj fleksibilnosti i univerzalnosti, ova funkcija pokriva većinu potreba programa, bez potrebe za dodatnim komandama.[^druge_komande_za_ispis]
[^druge_komande_za_ispis]: Postoje i druge mogućnosti ispisa, poput `sys.stdout.write()`, ali one se vrlo rijetko koriste i primjenjuju isključivo u specifičnim situacijama gdje je potrebna detaljnija kontrola nad izlaznim tokom.
:::info
Funkcije predstavljaju posebne vrste komandi koje omogućavaju izvršavanje specifičnih zadataka u programu. Iako će se funkcije detaljnije analizirati u narednim poglavljima, trenutno se mogu tretirati kao bilo koja druga komanda koja daje instrukciju računaru. Ono što funkcije izdvaja je njihov prepoznatljiv oblik — **uvijek se pišu s parom zagrada nakon imena funkcije**. Na primjer, u slučaju funkcije `print()`, zagrade su obavezne i označavaju izvršavanje te komande. Ova sintaksa pomaže u razlikovanju funkcija od drugih elemenata koda, omogućavajući programeru lakše prepoznavanje i korištenje funkcija unutar programa.
:::
U kodu ispod ilustrovana je upotreba funkcije `print()`
```python=
print()
```
<pre style="background-color: #1e1e1e; color: white; padding: 20px;">
</pre>
Na prvi pogled, čini se da je došlo do greške, jer se ne prikazuje nikakav tekst na ekranu. Međutim, komanda `print()` daje instrukciju računaru da pređe u novi red. Iako se rezultat možda ne primijeti odmah, razlika postaje jasna kada se izlaz uporedi s programom koji ne sadrži poziv funkcije `print()`.
<pre style="background-color: #1e1e1e; color: white; padding: 20px;">
</pre>
U ovom slučaju, na terminalu se ništa ne ispisuje, te ostaje potpuno prazan. Ipak, efekat funkcije `print()` može se primijetiti kada se komanda ponovi više puta. Na primjer, ako se računaru pet puta zada instrukcija `print()`, rezultat će biti pet praznih redova koji formiraju razmak na ekranu:
```python=
print()
print()
print()
print()
print()
```
<pre style="background-color: #1e1e1e; color: white; padding: 20px;">
</pre>
### Ispisivanje jednog podatka
Ispisivanje praznih redova na ekranu ponekad može biti korisno, ali osnovna svrha funkcije `print()` je prikaz podataka koji nisu prazni redovi. U ovom slučaju, podatak koji se želi prikazati šalje se funkciji `print()` unutar zagrada.
```python=
print(5)
print(2.1)
```
<pre style="background-color: #1e1e1e; color: white; padding: 20px;">
5
2.1
</pre>
Funkcija `print()` u primjeru iznad ispisuje brojeve. Međutim, kada se ispisuje riječ ili rečenica, može doći do greške. Na primjer, sljedeći program neće raditi:
```python=
print(programiranje)
```
<pre style="background-color: #1e1e1e; color: #FF4C4C; padding: 20px;">
NameError: name 'programiranje' is not defined
</pre>
Greška se javlja jer Python ne prepoznaje riječ programiranje. Da bi se ispisao tekstualni sadržaj, mora biti stavljen unutar navodnika. Korigovan primjer:
```python=
print("programiranje")
```
<pre style="background-color: #1e1e1e; color: white; padding: 20px;">
programiranje
</pre>
Već je spomenuto da funkcija `print()` prelazi u novi red kada se koristi bez ikakvih podataka:
```python=
print()
print("Ovo je ispisano poslije praznog reda.")
```
<pre style="background-color: #1e1e1e; color: white; padding: 20px;">
Ovo je ispisano poslije praznog reda.
</pre>
Kada `print()` funkcija ima podatak, prvo ga ispiše, a zatim prelazi u novi red. Na taj način, može se smatrati da funkcija `print()` sa podatkom obavlja dva zadatka: ispisuje sadržaj i prelazi u novi red.
```python=
print("Prva linija")
print("Druga linija")
```
<pre style="background-color: #1e1e1e; color: white; padding: 20px;">
Prva linija
Druga linija
</pre>
### Kontrola prelaska u novi red
U nekim situacijama, potrebno je prikazati više podataka u istom redu, bez automatskog prelaska u novi red. Ovo se može postići korištenjem parametra `end`, koji određuje šta će se dodati na kraju ispisa[^parametar].
[^parametar]: Pojam parametra će dodatno biti razmatran u poglavlju o funkcijama.
```python=
print("Python", end="")
print("programiranje", end="")
print(100, end="")
print(200)
```
<pre style="background-color: #1e1e1e; color: white; padding: 20px;">
Pythonprogramiranje100200
</pre>
Kada se koristi prazan tekst za `end`, ispisuje se sadržaj bez prelaska u novi red, pa su sve riječi i brojevi prikazani spojeno. Međutim, nakon ispisa posljednje vrijednosti `200`, dolazi do automatskog prelaska u novi red, jer parametar `end` više nije naveden. Svaka naredna funkcija `print()` izvršila bi ispis u tom novom redu.
Kod ispisa teksta, razmak se može dodati na dva načina: na kraju samog teksta i korištenjem parametra `end`.
```python=
print("Python ", end="")
print("programiranje")
```
<pre style="background-color: #1e1e1e; color: white; padding: 20px;">
Python programiranje
</pre>
U primjeru iznad razmak je dodan direktno nakon riječi `Python`, prije zatvaranja navodnika.
```python=
print("Python", end=" ")
print("programiranje")
```
Razmak je ovdje dodan korištenjem parametra `end`, koji se koristi za dodavanje sadržaja na kraju ispisa. Kada se ispisuju brojevi, razmak se može dodati jedino na ovaj način, jer nije moguće dodati razmak unutar same vrijednosti broja:
```python=
print(100, end=" ")
print(200)
```
<pre style="background-color: #1e1e1e; color: white; padding: 20px;">
100 200
</pre>
### Ispis više podataka
Funkcija `print()` može prikazati više podataka odjednom, kada se podaci navedu unutar zagrade, odvojeni zarezima. Na ovaj način, moguće je ispisati riječi, brojeve i druge podatke jednom komandom. Podaci će biti prikazani na istoj liniji, a **između njih će automatski biti dodan razmak**.
```python=
print("Broj:", 42, "Tekst:", "Python")
```
<pre style="background-color: #1e1e1e; color: white; padding: 20px;">
Broj: 42 Tekst: Python
</pre>
U ovom primjeru, funkcija `print()` dodaje razmake između svih navedenih podataka, tako da nije potrebno ručno dodavati razmake unutar tekstova.
### Kontrola ispisa više podataka
Podrazumijevani razmak između podataka može se mijenjati. Funkcija `print()` omogućava prilagođavanje načina na koji se podaci prikazuju korištenjem posebnog separatora. Umjesto dodavanja automatskog razmaka, može se koristiti bilo koji znak, skup znakova ili čak prazan tekst.
```python=
print("Broj:", 42, "Tekst:", "Python", sep=" | ")
```
<pre style="background-color: #1e1e1e; color: white; padding: 20px;">
Broj: | 42 | Tekst: | Python
</pre>
U ovom primjeru, koristi se skup znakova `" | "` (razmak, uspravna crta, razmak), kao razdjelnik između podataka. Umjesto razmaka, između svake informacije se dodaje `" - "`, što omogućava prikaz u prilagođenom formatu.
Ako se želi prikazati podatke bez ikakvog razmaka, može se koristiti prazan tekst kao razdjelnik:
```python=
print("Verzija", 3, ".", 10, sep="")
```
<pre style="background-color: #1e1e1e; color: white; padding: 20px;">
Verzija3.10
</pre>
### Kombinovanje `sep` i `end`
Funkcija `print()` omogućava kontrolu formata ispisa korištenjem opcija za razdvajanje podataka (`sep`) i završetak ispisa (`end`). Kombinovanjem ovih opcija moguće je preciznije oblikovati ispis, što može biti korisno kada se prikazuju složeniji nizovi podataka.
```python=
print("Lista namirnica:", end=" ")
print("Hljeb", "Mlijeko", "Jaja", sep=", ", end=".")
```
<pre style="background-color: #1e1e1e; color: white; padding: 20px;">
Lista namirnica: Hljeb, Mlijeko, Jaja.
</pre>
Ovdje se koristi zarez kao razdjelnik između namirnica, dok završetak ispisa uključuje tačku, čime se završava rečenica. Kombinovanje opcija sep i end omogućava prikaz liste u čitljivom formatu bez dodatnog koda.
Ispis podataka u Pythonu nije samo prikaz sadržaja, već i prilika za jasno oblikovanje informacija. Korištenjem osnovnih mogućnosti funkcije `print()`, uz prilagođavanja pomoću `sep` i `end`, jednostavno se kreiraju fleksibilni prikazi koji odgovaraju različitim potrebama programa. Ova prilagodljivost doprinosi boljoj prezentaciji podataka, čineći ih lakšim za razumijevanje i analizu, bez uvođenja dodatne složenosti.
### F-stringovi
Za potrebe formatiranja ispisa, Python nudi fleksibilan i intuitivan način rada s tekstom koristeći **f-string**. Ovaj pristup omogućava umetanje podataka direktno u string, čineći kod čitljivijim i jednostavnijim za održavanje. F-stringovi su korisni za prikazivanje varijabli unutar teksta, formatiranje decimalnih brojeva i druge specifične prilagodbe ispisa.
F-string se kreira dodavanjem slova `f` ispred stringa unutar navodnika. Varijable ili izrazi koje treba prikazati u tekstu stavljaju se unutar vitičastih zagrada `{}`.
```python=
proizvod = "Laptop"
cijena = 1200.50
print(f"Proizvod: {proizvod}, Cijena: {cijena} KM")
```
<pre style="background-color: #1e1e1e; color: white; padding: 20px;">
Proizvod: Laptop, Cijena: 1200.5 KM
</pre>
U prikazanom primjeru, varijable `proizvod` i `cijena` automatski se zamjenjuju svojim vrijednostima unutar vitičastih zagrada `{}`. Kada se program izvrši, Python interpretira string kao f-string zbog prefiksa `f`, pronalazi varijable unutar zagrada i zamjenjuje ih njihovim vrijednostima.
Prednost f-stringova je mogućnost umetanja izraza, a ne samo varijabli. Ovo znači da se direktno unutar zagrada mogu izvoditi računske operacije, pozivi funkcija ili logičke provjere[^kasnije], čime se dodatno povećava fleksibilnost i moć ovog alata.
[^kasnije]: Funkcije i logičke provjere su obrađene naknadno u tekstu.
```python=
a = 5
b = 3
print(f"Rezultat sabiranja {a} + {b} je {a + b}.")
```
<pre style="background-color: #1e1e1e; color: white; padding: 20px;">
Rezultat sabiranja 5 + 3 je 8.
</pre>
Još jedna korisna osobina f-stringova je mogućnost prikazivanja imena varijable zajedno s njenom vrijednošću, koristeći sintaksu f"{varijabla=}". Ovaj oblik formatiranja posebno je koristan za jasno prikazivanje naziva varijable uz njen rezultat.
```python=
a = 10
b = 20
rezultat = a + b
print(f"{rezultat=}")
```
<pre style="background-color: #1e1e1e; color: white; padding: 20px;">
rezultat=30
</pre>
U ovom primjeru, Python automatski prikazuje ime varijable (`rezultat`) i njenu vrijednost (`30`), što olakšava analizu i praćenje rezultata tokom izvršavanja programa. Ova funkcionalnost je posebno korisna kada se radi s više varijabli i njihovih međurezultata, jer eliminiše potrebu za ručnim zapisivanjem njihovih imena u ispisu.
#### Formatiranje decimalnih brojeva
F-stringovi omogućavaju precizno kontrolisanje broja decimalnih mjesta pomoću specijalnih oznaka unutar vitičastih zagrada. Ovo je korisno za prikazivanje rezultata s potrebnim nivoom preciznosti, kao što su finansijski izračuni, naučne simulacije ili prikaz podataka u tehničkim izvještajima.
Korištenjem posebne sintakse unutar vitičastih zagrada `{}`, moguće je precizno definisati kako će se decimalni broj prikazati. Na primjer:
```python=
broj = 3.14159265359
print(f"Pi zaokružen na dvije decimale: {broj:.2f}")
```
<pre style="background-color: #1e1e1e; color: white; padding: 20px;">
Pi zaokružen na dvije decimale: 3.14
</pre>
Ovdje se broj `3.14159265359` prikazuje s tačno dvije decimale, što se postiže zahvaljujući specifičnoj oznaci `:.2f`. Ključne komponente ove sintakse su:
* `:` označava početak formata za broj.
* `.2` definiše broj decimalnih mjesta - u ovom slučaju, dvije decimale.
* `f` označava format s pomičnim zarezom (floating-point), koji prikazuje broj u standardnom decimalnom obliku.
Python koristi standardno pravilo za zaokruživanje prilikom smanjenja broja decimalnih mjesta. Ako je cifra iza granice zaokruživanja jednaka `5` ili veća, broj se povećava za jednu jedinicu. Ako je manja od `5`, dodatne cifre se jednostavno odbacuju.
```python=
broj1 = 2.4567
broj2 = 2.4532
print(f"{broj1:.2f}")
print(f"{broj2:.2f}")
```
<pre style="background-color: #1e1e1e; color: white; padding: 20px;">
2.46
2.45
</pre>
U ovom primjeru, broj `2.4567` se zaokružuje na `2.46`, dok broj `2.4532` postaje 2.45.
#### Ostale primjene f-stringova
Osim umetanja podataka i formatiranja decimalnih brojeva, f-stringovi pružaju širok spektar opcija za prilagođavanje ispisa. Mogu se koristiti za poravnavanje teksta, prikaz brojeva u različitim formatima, uključujući heksadecimalni i binarni, ili za rad s naučnim zapisima. Ove funkcionalnosti čine ih svestranim alatom za generisanje precizno oblikovanog izlaza.
<table>
<thead>
<tr>
<th>Primjena</th>
<th>Primjer koda</th>
<th>Rezultat</th>
</tr>
</thead>
<tbody>
<tr>
<td>Umetanje izraza</td>
<td><code>f"{5 + 3}"</code></td>
<td><code>8</code></td>
</tr>
<tr>
<td>Prikaz u heksadecimalnom obliku</td>
<td><code>f"{255:#x}"</code></td>
<td><code>0xff</code></td>
</tr>
<tr>
<td>Prikaz u binarnom obliku</td>
<td><code>f"{10:#b}"</code></td>
<td><code>0b1010</code></td>
</tr>
<tr>
<td>Prikaz s popunom znakovima</td>
<td><code>f"{42:05}"</code></td>
<td><code>00042</code></td>
</tr>
<tr>
<td>Poravnanje ulijevo</td>
<td><code>f"{'tekst':<10}"</code></td>
<td><code>'tekst '</code></td>
</tr>
<tr>
<td>Poravnanje udesno</td>
<td><code>f"{'tekst':>10}"</code></td>
<td><code>' tekst'</code></td>
</tr>
<tr>
<td>Centriranje</td>
<td><code>f"{'tekst':^10}"</code></td>
<td><code>' tekst '</code></td>
</tr>
<tr>
<td>Naučni zapis</td>
<td><code>f"{0.00123:.2e}"</code></td>
<td><code>1.23e-03</code></td>
</tr>
<tr>
<td>Prikaz procentualne vrijednosti</td>
<td><code>f"{0.75:.1%}"</code></td>
<td><code>75.0%</code></td>
</tr>
</tbody>
</table>
Korištenje prikazanih opcija omogućava oblikovanje rezultata na način koji odgovara specifičnim potrebama aplikacije, bilo da je riječ o vizualnom poboljšanju, standardizaciji formata ili tehničkoj prezentaciji. Ova fleksibilnost čini f-stringove idealnim izborom za kreiranje estetski i funkcionalno optimizovanog ispisa.
## Obrada podataka
Nakon što je prikazan način na koji se podaci mogu ispisati, sljedeći korak je razumjeti kako se ti podaci mogu obraditi prije prikaza. Obrada podataka podrazumijeva izvođenje različitih **operacija** koje omogućavaju manipulaciju podacima, pripremajući ih za konačni ispis. Na ovaj način se postavlja osnova za razumijevanje kako se podaci koriste unutar programa, što je ključni element svakog programskog rješenja.
Razmatrajući pojam operacije, može se započeti s primjerom osnovne matematičke operacije sabiranja. Za očekivati je da računar može sabrati dva broja. Međutim, pokretanjem narednog programa terminal ostaje prazan, iako nema prijavljene greške.
```python=
2+2
```
<pre style="background-color: #1e1e1e; color: white; padding: 20px;">
</pre>
Nasuprot tome, pokretanjem narednog programa prikazuje se greška.
```python=
2 + x
```
<pre style="background-color: #1e1e1e; color: #FF4C4C; padding: 20px;">
NameError: name 'x' is not defined
</pre>
Ova greška ukazuje na to da računar ne prepoznaje znak `x`, što znači da, kada ne razumije operaciju, prijavljuje grešku. U prvom primjeru (`2 + 2`), greška nije prijavljena, što znači da je računanje ipak uspješno izvedeno.
Razlog zašto rezultat nije prikazan leži u tome što računar nije dobio jasnu instrukciju da prikaže izračunatu vrijednost. Operacija je izvedena, ali bez dodatne naredbe za ispis, rezultat ostaje skriven i poznat samo računaru. Kada se operacija `2 + 2` stavi unutar funkcije `print()`, tačan rezultat se ispisuje na terminalu:
```python=
print(2 + 2)
```
<pre style="background-color: #1e1e1e; color: white; padding: 20px;">
4
</pre>
U ovom slučaju, jednom naredbom su izvršena tri zadatka: najprije se izračunava zbir, zatim se rezultat prikazuje, a na kraju se prelazi u novi red.
### Pohrana podatka
U primjeru izvršavanja operacije `2 + 2`, rezultat je uspješno izračunat, ali nije bilo jasne naredbe za njegov prikaz niti za njegovo čuvanje. Prikaz rezultata putem funkcije `print()` učinio je podatak vidljivim, ali to je bila samo privremena akcija, nakon koje je izračunati rezultat opet izgubljen. U prvom poglavlju naglašeno je da jedna od dvije osnovne aktivnosti koje računar obavlja jeste čuvanje rezultata proračuna. Kako bi se ti rezultati zadržali i bili dostupni za daljnju obradu, potrebno je uvesti mehanizam za pohranu podataka u memoriji računara.
:::info
U jezicima niskog nivoa, poput asemblera, postoji instrukcija koja računaru direktno daje tačnu poziciju u memoriji na koju treba pohraniti podatak. Ove memorijske pozicije nazivaju se adrese i predstavljene su brojevima koji se obično zapisuju u heksadecimalnom formatu, zbog lakše čitljivosti. Primjer jedne takve instrukcije je:
```assembly
MOV [0x7FFF], AX
```
Ova naredba pohranjuje vrijednost iz registra AX na memorijsku adresu 0x7FFF. U ovakvom pristupu, programer ima potpunu kontrolu nad radom sa memorijom, ali to često zahtijeva i precizno praćenje adresa, što može biti složeno i sklono greškama.
:::
U jezicima niskog nivoa, programeri su morali pažljivo upravljati memorijskim adresama, vodeći računa o tačnim pozicijama na koje pohranjuju podatke. U jezicima visokog nivoa, poput Pythona, ovaj proces je znatno pojednostavljen. Umjesto praćenja memorijskih adresa, programeri mogu kreirati **naziv** koji se koristi kao *referenca*, tj. *oznaka* za pohranjeni podatak. Na taj način, rad sa memorijom postaje intuitivniji i lakši, jer se podaci smještaju i koriste putem imena, a ne putem numeričkih adresa u memoriji.
Pythonov kod koji kreira naziv za podatak prikazan je u prvoj liniji narednog pograma.
```python=
moj_naziv = 4
print(moj_naziv)
```
<pre style="background-color: #1e1e1e; color: white; padding: 20px;">
4
</pre>
Primjer iznad uvodi nekoliko važnih pojmova koji su ključni za rad sa podacima u Pythonu.
#### Operator dodjele
**Operator dodjele**, predstavljen simbolom jednako `=`, koristi se za povezivanje naziva s podatkom. Ako podatak s desne strane još ne postoji u memoriji, Python ga prvo kreira, a zatim povezuje s nazivom s lijeve strane. Na taj način, operator dodjele omogućava rad s podacima kroz nazive umjesto direktnog upravljanja memorijom.
Simbol `=` u programiranju nema isto značenje kao u matematici. U matematičkim izrazima, znak jednakosti označava da su vrijednosti s obje strane jednake. Međutim, u Pythonu, operator dodjele (`=`) ne poredi vrijednosti, već povezuje naziv s podatkom.
Operator dodjele zahtijeva strogo poštovanje redoslijeda: naziv uvijek mora biti s lijeve strane, dok se podatak nalazi s desne strane. Pisanje izraza obrnutim redoslijedom, poput `4 = moj_naziv`, rezultira greškom.
#### Identifikator
Identifikator je naziv koji se koristi za označavanje elemenata u programu, poput podataka, funkcija ili drugih komponenti. U primjeru `moj_naziv = 4`, identifikator je `moj_naziv`.
Identifikatori omogućavaju programerima da imenuju elemente programa na način koji je razumljiv, smislen i lako pamtljiv. Ovo ne samo da čini rad s programima čitljivijim i organizovanijim, već i smanjuje mogućnost grešaka, jer programer ne mora direktno upravljati memorijskim adresama ili složenim sistemskim oznakama.
:::info
U Pythonu, identifikator mora poštovati određena pravila kako bi bio ispravan. Identifikator mora početi slovom (`a` - `z`, `A` - `Z`) ili donjom crtom (`_`). Nakon početnog znaka može sadržavati slova, brojeve (`0`-`9`) ili donje crte. Identifikator ne smije sadržavati razmake, specijalne znakove poput `@`, `#`, `$`, niti smije početi brojem. Python također ima rezervisane riječi (poput `if`, `for`, `while`) koje se ne mogu koristiti kao identifikatori.
Identifikatori trebaju biti smisleni. Iako Python dopušta korištenje proizvoljnih naziva poput `a`, `b`, ili `x1`, preporučuje se korištenje naziva koji jasno opisuju svrhu podatka. Smisleni identifikatori olakšavaju razumijevanje koda, kako autoru programa, tako i drugima koji ga budu čitali ili mijenjali.
Primjeri ispravnih i pogrešnih naziva prikazani su u tabeli:
| **Ispravni nazivi** | **Pogrešni nazivi** | **Razlog** |
|----------------------|---------------------------|---------------------------------|
| `ime` | `2ime` | Počinje brojem |
| `_cijena` | `cijena$` | Sadrži nedozvoljeni znak |
| `broj1` | `broj 1` | Sadrži prazno mjesto |
| `prosjek_ocjena` | `for` | Rezervisana riječ |
| `max_broj` | `broj!` | Nedozvoljeni znak `!` |
| `ocjena_student` | `ocjena-student` | Sadrži nedozvoljeni znak `-` |
| `prvi_rezultat` | `1_rezultat` | Počinje brojem |
:::
#### Varijabla
:::success
Varijabla je naziv povezan s podatkom u memoriji, koji omogućava pristup i rad s tim podatkom. [^objekti]
:::
[^objekti]: U Pythonu, varijabla ne čuva podatak direktno, već referencira objekat u memoriji. Ovo je tehnička implementacija koja nije ključna za osnovno razumijevanje koncepta varijabli.
Varijabla se sastoji od identifikatora i podatka na koji taj naziv ukazuje. Identifikator je ključna komponenta varijable i služi kao oznaka koja omogućava rad s podatkom bez potrebe za direktnim upravljanjem memorijom.
Varijabla se kreira korištenjem *operatora dodjele* (`=`), koji povezuje identifikator s podatkom pohranjenim u memoriji. Na taj način varijabla omogućava čuvanje, pristup i manipulaciju podacima tokom izvršavanja programa.
Varijable su ključni alat za rad s podacima u Pythonu. Umjesto direktnog upravljanja memorijskim adresama, programer koristi nazive za rad s podacima, što povećava čitljivost koda i pojednostavljuje rad s kompleksnim informacijama.
```python=
moj_naziv = 4
print(moj_naziv)
print(moj_naziv + 2)
print(moj_naziv * 3)
```
<pre style="background-color: #1e1e1e; color: white; padding: 20px;">
4
6
12
</pre>
U primjeru, varijabla `moj_naziv` pokazuje na vrijednost `4`, koja je pohranjena u memoriji. Operator dodjele povezuje identifikator `moj_naziv` s podatkom `4`, omogućavajući programu da koristi ovaj naziv za pristup vrijednosti. Prva komanda `print()` ispisuje vrijednost na koju varijabla ukazuje, dok naredne dvije komande `print()` prikazuju kako se ista vrijednost može koristiti u različitim matematičkim operacijama. Ovaj primjer ilustruje kako podatak ostaje sačuvan i može se upotrijebiti više puta tokom izvršavanja programa.
:::info
Naziv *varijabla* dolazi od pojma *varirati* ili *mijenjati*. Varijable omogućavaju da se tokom trajanja programa mijenja podatak na koji varijabla pokazuje, pri čemu nova veza zamjenjuje prethodnu.
:::
```python=
x = 10
print(x)
x = x + 5
print(x)
```
<pre style="background-color: #1e1e1e; color: white; padding: 20px;">
10
15
</pre>
:::info
U ovom primjeru, varijabla x prvo pokazuje na vrijednost `10`, a zatim se preusmjerava na novu vrijednost `15`. Ova sposobnost varijabli da mijenjaju podatak na koji pokazuju čini ih ključnim elementom u programiranju.
:::
```mermaid
flowchart LR
%% Subgraph Prvi dio %%
subgraph Prvi_dio [x = 10]
direction LR
A[x] --> B["10"]
end
%% Subgraph Drugi dio %%
subgraph Drugi_dio [x = 15]
direction LR
B2["10"]
A2[x] --> C["15"]
end
Prvi_dio ---> Drugi_dio
linkStyle 2 stroke-width:0,opacity:0;
```
:::success
Sažetak pojmova:
| **Pojam** | **Definicija** | **Primjer u Pythonu** |
|-----------|----------------|-----------------------|
| **Operator dodjele** | Simbol (`=`) koji povezuje identifikator s podatkom. | `=` u `x = 42` |
| **Identifikator** | Naziv koji se koristi za označavanje elementa u programu. | `x` u `x = 42` |
| **Varijabla** | Identifikator koji pokazuje na podatak pohranjen u memoriji. | `x` sa vezom na podatak `42` |
:::
### Tipovi podataka
Podaci koje program obrađuje ne samo da se pohranjuju, već se često mijenjaju, kombinuju ili koriste u različitim operacijama. Način na koji se podaci obrađuju zavisi od njihove vrste, jer različite vrste podataka zahtijevaju različite mehanizme za rad.
Na primjer, komanda `+` koristi se za obradu podataka, ali njen rezultat zavisi od vrste podataka koje obrađuje. Ako program obrađuje brojeve `2` i `2`, komanda `+` se tumači kao sabiranje i daje rezultat `4`. Međutim, kada se obrada vrši nad tekstualnim podacima `"2"` i `"2"` (gdje `"2"` predstavlja tekst, a ne broj), komanda `+` ima sasvim drugo značenje — spajanje teksta, što rezultira sa `"22"`.
Primjer prikazuje oba slučaja:
```python=
print(2 + 2)
print("2" + "2")
```
<pre style="background-color: #1e1e1e; color: white; padding: 20px;">
4
22
</pre>
Operacija spajanja teksta nije ograničena samo na brojeve predstavljene kao tekst. Na primjer, spoj dva različita tekstualna podatka može izgledati ovako:
```python=
print("program" + "iranje")
```
<pre style="background-color: #1e1e1e; color: white; padding: 20px;">
programiranje
</pre>
Različite vrste podataka ponašaju se na različite načine prilikom obrade, pa čak i ista komanda može imati različita značenja u zavisnosti od vrste podataka s kojima radi. Ovo pokazuje važnost razumijevanja vrste podataka i načina na koji oni utiču na rezultate obrade.
:::success
**Tip podataka** definiše skup **vrijednosti** koje podatak može imati i skup **operacija** koje se mogu izvoditi nad tim vrijednostima.
:::
Tip podataka određuje kako računar interpretira sadržaj memorije i koje operacije su nad tim sadržajem dozvoljene. Na primjer, određeni tipovi podataka omogućavaju matematičke operacije, dok drugi podržavaju manipulaciju tekstualnim informacijama. Različiti tipovi imaju različita pravila, koja osiguravaju ispravan rad programa i sprječavaju neželjene greške.
Python koristi različite tipove podataka, među kojima su:
| **Tip** | **Engleski naziv** [^skr] | **Opis** |
|----------|---------------------------|----------|
| `int` | Integer | Predstavlja cijele brojeve, pozitivne i negativne, uključujući nulu. |
| `float` | Floating Point Number | Predstavlja brojeve s decimalnim dijelom, koristeći format s pomičnim zarezom. |
| `str` | String | Predstavlja niz znakova, obično korišten za tekstualne podatke. |
| `bool` | Boolean | Predstavlja logičke vrijednosti, koje mogu biti `True` ili `False`. |
[^skr]: U koloni su navedene engleske riječi čijim skraćivanjem su nastali nazivi tipova
Ovi osnovni tipovi predstavljaju temelj velikog broja programa i koriste se vrlo često. Razumijevanje tipova podataka predstavlja osnovu za programiranje, jer svaki program, bez obzira na svoju složenost, uključuje operacije nad podacima.
Za diskusiju o tipovima podataka potrebno je prvo upoznati pojmove *doslovne vrijednosti* i *izraza*, koji čine osnovu rada s podacima u programima. Doslovne vrijednosti su neizostavan koncept u svakom programu i pružaju temelj za definisanje tipova podataka. Razumijevanje izraza omogućava uvid u način na koji se podaci kombinuju i obrađuju unutar programa.
#### Doslovna vrijednost
:::success
Kada se u programu direktno navode podaci, oni se nazivaju doslovne vrijednosti.
:::
Za razliku od podataka koji dolaze iz vanjskih izvora, poput unosa korisnika, doslovne vrijednosti se unose direktno u kod i koriste u svom osnovnom obliku.
Vrijednosti koje program koristi ne moraju uvijek biti doslovne. One mogu dolaziti i iz varijabli, koje omogućavaju čuvanje podataka i njihovu upotrebu na različitim mjestima u programu. Kada vrijednost dolazi iz varijable, ona nije doslovna vrijednost, već je povezana s nazivom varijable koja na nju ukazuje.
```python=
a = 5
b = "Python"
c = a + 3
d = b + " programiranje"
print(c)
print(d)
```
<pre style="background-color: #1e1e1e; color: white; padding: 20px;">
8
Python programiranje
</pre>
U ovom primjeru, `5`, `"Python"`, `3` i `" programiranje"` su doslovne vrijednosti jer su direktno navedene u kodu. S druge strane, `a`, `b`, `c` i `d` su varijable. Rezultati operacija `a + 3` i `b` + `" programiranje"` također nisu doslovne vrijednosti, već nastaju obradom podataka na koje varijable pokazuju.
#### Izraz
:::success
Izraz je kombinacija doslovnih vrijednosti, varijabli i operacija koju Python obrađuje kako bi dobio određeni rezultat.
:::
Bez obzira na složenost, svaki izraz ima ključnu osobinu, a to je da njegovo računanje uvijek daje **vrijednost** koju program može dalje koristiti. Na taj način, izrazi predstavljaju osnovni mehanizam za obradu podataka i generisanje rezultata unutar programa. Primjeri jednostavnih izraza uključuju `10 + 5` ili `x - 2`. U prvom slučaju rezultat izraza je broj `15`, dok u drugom rezultujuća vrijednost zavisi od trenutne vrijednosti varijable `x`.
Python **automatski izračunava svaki izraz** čim na njega naiđe tokom izvršavanja programa. Ovo znači da se izraz ne samo obrađuje, već se odmah zamjenjuje njegovom izračunatom vrijednošću[^izvorni], čime rezultat postaje dostupan za daljnju upotrebu. Ovaj proces se odvija bez potrebe za dodatnim intervencijama programera tj. Python prepoznaje svaki izraz kao uputstvo koje treba odmah riješiti.
[^izvorni]: Zamjena izraza njegovom vrijednošću nije fizička promjena samog programa, već način na koji računar obrađuje i koristi podatke tokom izvršavanja. Izraz se računa, a rezultat postaje dostupan za naredne operacije i odluke programa, dok sam zapis izraza ostaje nepromijenjen.
Na primjer:
```python=
x = 8
y = 3
z = x * y + 2
print(z)
```
<pre style="background-color: #1e1e1e; color: white; padding: 20px;">
26
</pre>
Kada Python naiđe na izraz `x * y + 2`, postupa na sljedeći način:
1. Prvo zamjenjuje varijable `x` i `y` njihovim vrijednostima, pa izraz postaje `8 * 3 + 2`.
2. Zatim računa proizvod `8 * 3`, što daje `24`.
3. Dodaje doslovnu vrijednost `2` rezultatu, što daje konačni rezultat `26`.
Nakon što se izraz izračuna, Python ga zamjenjuje rezultatom `26`, pa varijabla `z` sada sadrži tu vrijednost. Funkcija `print()` koristi ovu izračunatu vrijednost za prikaz.
Izrazi su nezaobilazan element svakog programskog jezika, jer omogućavaju dinamičko računanje vrijednosti koje zavise od trenutnih podataka. Bez obzira na to da li se koriste za matematičke proračune, logička poređenja ili rad s tekstualnim podacima, izrazi uvijek dovode do jasnog i konkretno definisanog rezultata.
Prilikom obrade podataka, od ključne je važnosti razumjeti individualne tipove podataka, jer svaki tip definiše skup vrijednosti koje podatak može imati i operacije koje su dozvoljene nad tim vrijednostima. Različiti tipovi podataka omogućavaju programima da rade s brojevima, tekstom, logičkim vrijednostima i drugim vrstama informacija, pri čemu svaki tip ima specifične osobine i pravila.
#### Tip `int`
Tip podataka int koristi se za predstavljanje cijelih brojeva, uključujući pozitivne, negativne vrijednosti i nulu. Ovaj tip podataka je osnovni element programa kada su u pitanju podaci koji ne sadrže decimalni dio. Cijeli brojevi koriste se za modeliranje kvantitativnih vrijednosti koje su nedjeljive, kao što su godine, brojevi predmeta ili rezultati brojanja.
Python podržava rad s cijelim brojevima koji mogu biti veoma veliki ili veoma mali, bez ograničavanja njihove veličine. Jedini faktor koji utiče na najveći broj s kojim se može raditi jeste raspoloživa memorija računara. Ovo je značajna prednost Pythona u poređenju s nekim drugim programskim jezicima koji ograničavaju veličinu cijelih brojeva.
>[!Note] Veličina cijelih brojeva
Na primjer, u jeziku C++ tip podataka `int` obično ima fiksnu veličinu od 4 bajta, što znači da može predstaviti samo brojeve u rasponu od $-2,147,483,648$ do $2,147,483,647$. Ako se pokušaju koristiti brojevi izvan ovog raspona, doći će do greške ili neočekivanih rezultata zbog tzv. *overflow*-a.
>
>U Pythonu, takvih ograničenja nema. Cijeli brojevi mogu biti proizvoljno veliki, čime se omogućava rad sa brojevima poput $123456789123456789123456789$. Ova fleksibilnost čini Python pogodnim za zadatke koji zahtijevaju precizne proračune ili rad s velikim brojevima, poput kriptografije, simulacija ili finansijskih aplikacija.
Za rad s cijelim brojevima Python nudi niz operatora koji omogućavaju izvođenje uobičajenih aritmetičkih operacija. Binarni operatori uključuju `+` za sabiranje, `-` za oduzimanje, `*` za množenje, `//` za cijelobrojno dijeljenje, `%` za računanje ostatka i `**` za stepenovanje. Ovi operatori uzimaju dva operanda tipa `int` i najčešće proizvode rezultat koji je također tipa `int`. Osim binarnih, Python podržava i unarne operatore, poput `+` i `-`, koji određuju predznak broja. Na primjer, unarni operator `-` koristi se za prikaz negativne vrijednosti broja.
Sljedeća tabela za tip `int` prikazuje primjere uobičajenih doslovnih vrijednosti, te podržane operacije i operatore koji se koriste za te operacije.
<table>
<tr>
<td><strong>Vrijednosti</strong></td>
<td style="text-align: center;">cijeli brojevi</td>
</tr>
<tr>
<td><strong>Tipične doslovne vrijednosti</strong></td>
<td style="text-align: center;"><code>1234</code>, <code>99</code>, <code>0</code>, <code>1000000</code> <code>0b110</code> <code>0xA4</code></td>
</tr>
<tr>
<td><strong>Operacije</strong></td>
<td style="text-align: center;">predznak, sabiranje, oduzimanje, množenje, cijelobrojno dijeljenje, ostatak pri dijeljenju, stepenovanje</td>
</tr>
<tr>
<td><strong>Operatori</strong></td>
<td style="text-align: center;"><code>+</code>, <code>-</code>, <code>*</code>, <code>//</code>, <code>%</code>, <code>**</code></td>
</tr>
</table>
<!--
| | |
|-----------------------------|:---------------------------------------------:|
| **Vrijednosti** | Cijeli brojevi (`int`) |
| **Tipične doslovne vrijednosti** | `1234`, `99`, `0`, `1000000` |
| **Operacije** | Predznak, sabiranje, oduzimanje, množenje, cijelobrojno dijeljenje, ostatak pri dijeljenju, potenciranje |
| **Operatori** | `+`, `-`, `*`, `//`, `%`, `**` |
-->
Sljedeća tabela prikazuje izraze tipa `int`, njihove vrijednosti i komentare koji pojašnjavaju operacije i rezultate.
| **Izraz** | **Vrijednost** | **Komentar** |
|-------------------|---------------------|---------------------------------------|
| `42` | `42` | doslovna vrijednost |
| `+42` | `42` | pozitivan predznak |
| `-42` | `-42` | negativan predznak |
| `7 + 4` | `11` | sabiranje |
| `10 - 6` | `4` | oduzimanje |
| `8 * 2` | `16` | množenje |
| `7 // 3` | `2` | zaokruživanje naniže |
| `-7 // 3` | `-3` | zaokruživanje naniže |
| `9 % 4` | `1` | ostatak pri dijeljenju |
| `3 ** 4` | `81` | stepenovanje |
| `10 // 0` | greška pri izvršavanju | dijeljenje s nulom |
| `4 * 3 + 2` | `14` | `*` ima prednost |
| `10 + 8 // 3` | `12` | `//` ima prioritet |
| `6 - 2 - 3` | `1` | lijeva asocijativnost |
| `(6 - 2) - 3` | `1` | bolji stil |
| `6 - (2 - 3)` | `7` | nedvosmislen izraz |
| `3 ** 3 ** 2` | `19683` | desna asocijativnost |
| `2 ** 200` | `160 ... 376` | proizvoljno veliki broj |
:::warning
**Cjelobrojno dijeljenje i zaokruživanje naniže**
U Pythonu, operator `//` vrši cjelobrojno dijeljenje, pri čemu rezultat predstavlja najveći cijeli broj koji nije veći od stvarnog rezultata dijeljenja. Ova osobina poznata je kao zaokruživanje naniže (eng. flooring).
Za pozitivne brojeve, rezultat cjelobrojnog dijeljenja odgovara standardnom dijeljenju gdje se odbacuje decimalni dio. Na primjer, `7 // 3` daje `2`, jer je `2` najveći cijeli broj manji ili jednak rezultatu `2.333...`.
Kod negativnih brojeva, rezultat se uvijek zaokružuje naniže prema negativnoj beskonačnosti, što znači da može biti manji od očekivanog. Na primjer, `-7 // 3` daje `-3`, jer je `-3` manji od stvarnog rezultata `-2.333...`.
:::
U nastavku je program koji demonstrira upotrebu operacija nad cijelim brojevima.
```python=
a, b = 10, 3
print("Sabiranje:", a, "+", b, "=", a + b)
print("Oduzimanje:", a, "-", b, "=", a - b)
print("Množenje:", a, "*", b, "=", a * b)
print("Cjelobrojno dijeljenje:", a, "//", b, "=", a // b)
print("Ostatak pri dijeljenju:", a, "%", b, "=", a % b)
print("Stepenovanje:", a, "**", b, "=", a ** b)
print("Kombinovani izraz:", a, "*", b, "-", b, "**", 2, "+",
"(", a, "%", b, ")", "=", a * b - b ** 2 + (a % b))
print("Asocijativnost (lijeva):", a, "-", b, "-", 2, "=", a - b - 2)
print("Grupisanje lijevo:", "(", a, "-", b, ")", "-", 2, "=", (a - b) - 2)
print("Grupisanje desno:", a, "- (", b, "-", 2, ")", "=", a - (b - 2))
print("Veliki broj (2 ** 100):", 2, "**", 100, "=", 2 ** 100)
```
<pre style="background-color: #1e1e1e; color: white; padding: 20px;">
Sabiranje: 10 + 3 = 13
Oduzimanje: 10 - 3 = 7
Množenje: 10 * 3 = 30
Cjelobrojno dijeljenje: 10 // 3 = 3
Ostatak pri dijeljenju: 10 % 3 = 1
Stepenovanje: 10 ** 3 = 1000
Kombinovani izraz: 10 * 3 - 3 ** 2 + ( 10 % 3 ) = 22
Asocijativnost (lijeva): 10 - 3 - 2 = 5
Grupisanje lijevo: ( 10 - 3 ) - 2 = 5
Grupisanje desno: 10 - ( 3 - 2 ) = 9
Veliki broj (2 ** 100): 2 ** 100 = 1267650600228229401496703205376
</pre>
:::info
Cijeli brojevi u Pythonu mogu se zapisivati i u **binarnoj** i u **heksadecimalnoj** formi, što je korisno u situacijama kada se radi s podacima poput mrežnih adresa i boja.
* Binarni zapis koristi prefiks `0b` ili `0B`, nakon kojeg slijede cifre `0` i `1`. Na primjer, dekadni broj `10` može se zapisati kao `0b1010`.
* Heksadecimalni zapis koristi prefiks `0x` ili `0X`, nakon kojeg slijede cifre `0`-`9` i slova `A`-`F` (za vrijednosti $10$ - $15$). Na primjer, dekadni broj `255` se može zapisati kao `0xFF`.
Ovi zapisi se automatski interpretiraju kao cijeli brojevi (`int`), pa je moguće vršiti iste operacije kao s brojevima u dekadnom obliku.
```python=
binarni_broj = 0b1010
print("Binarni broj:", binarni_broj)
heksadecimalni_broj = 0xFF
print("Heksadecimalni broj:", heksadecimalni_broj)
rezultat = binarni_broj + heksadecimalni_broj
print("Rezultat sabiranja:", rezultat)
```
<pre style="background-color: #1e1e1e; color: white; padding: 20px;">
Binarni broj: 10
Heksadecimalni broj: 255
Rezultat sabiranja: 265
</pre>
:::
#### Tip `float`
Tip `float` koristi se za predstavljanje brojeva koji uključuju decimalni dio, poput `3.14` ili `0.001`. Ovaj tip omogućava rad s vrijednostima koje nisu cijele, čime se pruža fleksibilnost u mnogim proračunima.
>[!Note] Naziv *float*
Naziv *float* dolazi od engleske riječi *floating-point*, što označava način na koji se realni brojevi predstavljaju u računaru. U ovom sistemu, decimalni zarez (ili *tačka*) može se *pomjerati*, čime se omogućava rad s vrlo velikim i vrlo malim brojevima kroz naučnu notaciju.
>
>Naziv *float* odnosi se upravo na ovu sposobnost decimalne tačke da *pluta*, tj. da se prilagođava vrijednosti broja i omogućava njegovo efikasno skladištenje i obradu.
Za razliku od cijelih brojeva (`int`), koji su precizni, `float` brojevi predstavljaju približne vrijednosti realnih brojeva. Iako matematički realni brojevi mogu imati beskonačnu preciznost, računari rade s ograničenim skupom vrijednosti zbog tehničkih ograničenja memorije i načina na koji se brojevi predstavljaju. Ova ograničenja ponekad mogu dovesti do malih grešaka u proračunima ili zaokruživanjima. Uprkos tome, `float` brojevi su dovoljno tačni za većinu praktičnih primjena i omogućavaju izvođenje složenih operacija s razlomcima i decimalnim vrijednostima.
:::warning
Naredni program prikazuje kako može doći do greške u preciznosti prilikom rada sa `float` brojevima:
```python=
rezultat1 = 6 * (1 / 3)
rezultat2 = (1 / 3) + (1 / 3) + (1 / 3) + (1 / 3) + (1 / 3) + (1 / 3)
print("Mnozenje:", rezultat1)
print("Sabiranje:", rezultat2)
```
<pre style="background-color: #1e1e1e; color: white; padding: 20px;">
Mnozenje: 2.0
Sabiranje: 1.9999999999999998
</pre>
U ovom primjeru, množenje `6 * (1 / 3)` daje tačan rezultat `2.0`. Međutim, prilikom šest pojedinačnih sabiranja $\frac{1}{3}$ dolazi do akumulacije greške zaokruživanja, pa rezultat postaje `1.9999999999999998`. [^preciznost]
:::
[^preciznost]: U situacijama gdje je potrebna apsolutna preciznost, umjesto `float` brojeva može se koristiti modul `decimal` za rad s brojevima uz tačno definisanu preciznost ili modul `fractions` za rad s racionalnim brojevima.
Za rad sa `float` brojevima Python nudi niz operatora, poput `+` za sabiranje, `-` za oduzimanje, `*` za množenje, `/` za standardno dijeljenje, `**` za stepenovanje i `%` za računanje ostatka (iako ostatak nije uvijek intuitivan kod `float` brojeva).
Sljedeća tabela za tip `float` prikazuje primjere uobičajenih doslovnih vrijednosti, te podržane operacije i operatore koji se koriste za te operacije.
<table>
<tr>
<td><strong>Vrijednosti</strong></td>
<td style="text-align: center;">realni brojevi</td>
</tr>
<tr>
<td><strong>Tipične doslovne vrijednosti</strong></td>
<td style="text-align: center;"><code>3.14</code>, <code>0.001</code>, <code>-273.15</code>, <code>4.0</code>, <code>1.0e6</code></td>
</tr>
<tr>
<td><strong>Operacije</strong></td>
<td style="text-align: center;">sabiranje, oduzimanje, množenje, dijeljenje, stepenovanje, ostatak</td>
</tr>
<tr>
<td><strong>Operatori</strong></td>
<td style="text-align: center;"><code>+</code>, <code>-</code>, <code>*</code>, <code>/</code>, <code>%</code>, <code>**</code></td>
</tr>
</table>
Sljedeća tabela prikazuje izraze tipa float, njihove vrijednosti i komentare koji pojašnjavaju operacije i rezultate.
| **Izraz** | **Vrijednost** | **Komentar** |
|------------------|---------------------|---------------------------------------|
| `3.14` | `3.14` | doslovna vrijednost |
| `-3.14` | `-3.14` | negativan predznak |
| `1.5 + 2.3` | `3.8` | sabiranje |
| `10.0 - 3.5` | `6.5` | oduzimanje |
| `4.2 * 2.0` | `8.4` | množenje |
| `9.0 / 4.0` | `2.25` | dijeljenje |
| `5.5 % 2.0` | `1.5` | ostatak pri dijeljenju |
| `2.0 ** 3.0` | `8.0` | stepenovanje |
U nastavku je Python program koji demonstrira upotrebu operatora nad realnim brojevima:
```python=
a, b = 7.5, 2.5
print("Sabiranje:", a, "+", b, "=", a + b)
print("Oduzimanje:", a, "-", b, "=", a - b)
print("Množenje:", a, "*", b, "=", a * b)
print("Dijeljenje:", a, "/", b, "=", a / b)
print("Ostatak pri dijeljenju:", a, "%", b, "=", a % b)
print("Stepenovanje:", a, "**", b, "=", a ** b)
```
<pre style="background-color: #1e1e1e; color: white; padding: 20px;">
Sabiranje: 7.5 + 2.5 = 10.0
Oduzimanje: 7.5 - 2.5 = 5.0
Množenje: 7.5 * 2.5 = 18.75
Dijeljenje: 7.5 / 2.5 = 3.0
Ostatak pri dijeljenju: 7.5 % 2.5 = 0.0
Stepenovanje: 7.5 ** 2.5 = 154.04696929832798
</pre>
:::info
Za realne brojeve u Pythonu dostupni su dodatni formati za prikaz, uključujući eksponencijalni zapis. Broj poput `1.0e6` interpretira se kao $1.0 \cdot 10^6$, tj. $1000000.0$. Ovo omogućava rad s veoma velikim ili malim brojevima na čitljiv način.
:::
#### Tip `str`
Tip podataka `str` koristi se za predstavljanje tekstualnih podataka. Stringovi su nizovi znakova, poput slova, brojeva, razmaka ili specijalnih simbola, koji se koriste za pohranu i manipulaciju tekstualnih informacija. Oni su osnovni tip podataka u Pythonu i igraju ključnu ulogu u aplikacijama gdje se radi s imenima, opisima, porukama ili bilo kojim drugim oblikom tekstualnog sadržaja.
>[!Note] Naziv *string*
Naziv *string* dolazi iz engleske riječi koja znači *niz* ili *vrpca*. U kontekstu programiranja, string označava niz znakova koji su poredani u određenom redoslijedu. Svaki znak u stringu ima svoju poziciju, što omogućava pristup i manipulaciju pojedinačnim dijelovima teksta.
>
>Ovaj koncept preuzet je iz ranih dana informatike, kada su se tekstualni podaci tretirali kao nizovi simbola, često predstavljeni ASCII kodovima. U modernim programskim jezicima, poput Pythona, stringovi su unaprijeđeni da podržavaju širok spektar znakova, uključujući razne jezike i simbole, zahvaljujući standardu Unicode.
U Pythonu se stringovi zapisuju unutar apostrofa (`'`) ili navodnika (`"`). Na primjer, 'Python' i "Programiranje" su validni stringovi. Ova fleksibilnost omogućava lako zapisivanje različitih formata teksta.
:::info
**Rad sa navodnicima, specijalnim znakovima i višelinijskim stringovima**
Stringovi u Pythonu pružaju veliku fleksibilnost u zapisivanju teksta, uključujući situacije kada se u tekstu pojavljuju navodnici ili specijalni znakovi.
Ako tekst sadrži apostrof (`'`), može se koristiti navodnik (`"`) za obuhvatanje stringa. Na primjer:
```python
"Necu ic' kuci."
```
Slično, kada tekst sadrži navodnike, apostrof može obuhvatiti string:
```python
'Rekao je: "Danas ucimo Python."'
```
U situacijama kada su potrebni i navodnici i apostrofi unutar stringa, koristi se **escape znak** (`\`) kako bi se označilo da znak pripada sadržaju stringa, a ne označava njegov kraj [^escape]. Na primjer:
[^escape]: Izraz escape znak ustalio se u IT terminologiji i najčešće se koristi bez prevođenja, jer je prepoznatljiv i univerzalan u različitim jezicima i kontekstima. Smislen prevod bio bi *znak za izbjegavanje*, jer naglašava njegovu svrhu u izbjegavanju konflikata između specijalnih znakova i njihove uloge unutar stringova.
```python
print("Rekao je: \"Necu ic' kuci.\"")
```
<pre style="background-color: #1e1e1e; color: white; padding: 20px;">
Rekao je: "Necu ic' kuci."
</pre>
Escape znakovi omogućavaju unos i drugih specijalnih karaktera poput prelaska u novi red (`"\n"`) i dodavanje tabulatora[^tabulator] (`"\t"`).
[^tabulator]: Tabulator označava specijalni razmak koji se koristi za poravnanje teksta ili podataka, a generiše se pritiskom na tipku `Tab` na tastaturi.
```python=
print("Prva linija\nDruga linija")
```
<pre style="background-color: #1e1e1e; color: white; padding: 20px;">
Prva linija
Druga linija
</pre>
```python=
print("A\tB")
```
<pre style="background-color: #1e1e1e; color: white; padding: 20px;">
A B
</pre>
Znak `\` ima posebno značenje u stringovima, pa se za prikaz samog znaka koristi dvostruki zapis `\\`:
```python=
print("Putanja do fajla je C:\\Users\\Korisnik.")
```
<pre style="background-color: #1e1e1e; color: white; padding: 20px;">
Putanja do fajla je C:\Users\Korisnik.
</pre>
Python omogućava unos stringova preko više redova koristeći trostruke navodnike (`'''` ili `"""`). Ovo je korisno za veće tekstove:
```python=
print("""Ovo je primjer
višelinijskog stringa
koji zauzima više redova.""")
```
<pre style="background-color: #1e1e1e; color: white; padding: 20px;">
Ovo je primjer
višelinijskog stringa
koji zauzima više redova.
</pre>
Višelinijski stringovi olakšavaju rad s formatiranim tekstovima bez potrebe za korištenjem `\n` za novi red
:::
Operator `+` omogućava spajanje (konkatenaciju) stringova, čime se više dijelova teksta kombinuje u jedan. Na primjer, izraz `'Python' + 'programiranje'` daje rezultat `'Pythonprogramiranje'`. Ako se doda razmak između riječi, poput `'Python' + ' ' + 'programiranje'`, rezultat postaje `'Python programiranje'`. Ova operacija je korisna za kreiranje dinamičkih poruka ili formatiranje informacija.
Stringovi podržavaju mnoge dodatne operacije koje se mogu koristiti za pretraživanje, dijeljenje, modifikaciju i analizu teksta. Ove naprednije operacije detaljno će se razmatrati u posebnom poglavlju nakon što se upoznaju koncepti vezani za module i sekvence, koji pružaju širu osnovu za rad sa stringovima.
Sljedeća tabela prikazuje osnovne karakteristike stringova, uključujući tipične doslovne vrijednosti, operacije i operatore koji se koriste za rad s tekstualnim podacima.
<table>
<tr>
<td><strong>Vrijednosti</strong></td>
<td style="text-align: center;">stringovi (tekstualni podaci)</td>
</tr>
<tr>
<td><strong>Tipične doslovne vrijednosti</strong></td>
<td style="text-align: center;">
<code>'tekst'</code>,
<code>"tekst"</code>,
<code>'"tekst unutar navodnika"'</code>,
<code>"'tekst unutar jednostrukih'"</code>,
<code>''</code>,
<code>' '</code>
</td>
</tr>
<tr>
<td><strong>Operacije</strong></td>
<td style="text-align: center;">spajanje (konkatenacija)</td>
</tr>
<tr>
<td><strong>Operatori</strong></td>
<td style="text-align: center;"><code>+</code></td>
</tr>
</table>
Sljedeća tabela prikazuje izraze koji koriste tip str, njihove vrijednosti i kratke komentare o rezultatima.
| **Izraz** | **Vrijednost** | **Komentar** |
|--------------------------|----------------------|---------------------------------------|
| `'Python'` | `'Python'` | doslovna vrijednost |
| `''` | `''` | prazan string |
| `' ' + 'Python'` | `' Python'` | spajanje stringa s razmakom |
| `'Hello' + 'World'` | `'HelloWorld'` | spajanje stringova |
| `'Broj: ' + '42'` | `'Broj: 42'` | dodavanje prefiksa stringu |
| `'Broj: ' + 42` | greška pri izvršavanju | spajanje stringa i broja |
:::info
**Prazan string**
Prazan string je string koji ne sadrži niti jedan znak i zapisuje se kao `''` ili `""`. S druge strane, string s razmakom `" "` sadrži jedan znak razmaka (` `) i razlikuje se od praznog stringa. Iako izgledaju slično, ova dva stringa imaju potpuno različite primjene.
U Pythonu, razlika između praznog stringa i stringa s razmakom može biti presudna u mnogim situacijama, poput provjere korisničkog unosa, obrade podataka ili manipulacije tekstualnim nizovima.
Primjena praznog stringa i stringa s razmakom postat će jasnija u narednim poglavljima, posebno kada se budu obrađivali algoritmi za rad s tekstom i provjere uslova u programima.
:::
U nastavku je primjera programa koji koristi stringove za kreiranje rasporeda sati u danu:
```python=
sat1 = "08:00"
sat2 = sat1 + " - 09:00"
sat3 = sat2 + " | " + "09:00 - 10:00"
sat4 = sat3 + " | " + "10:00 - 11:00"
sat5 = sat4 + " | " + "11:00 - 12:00"
print("Raspored sati:")
print(sat5)
```
<pre style="background-color: #1e1e1e; color: white; padding: 20px;">
Raspored sati:
08:00 - 09:00 | 09:00 - 10:00 | 10:00 - 11:00 | 11:00 - 12:00
</pre>
#### Tip `bool`
Tip podataka bool koristi se za predstavljanje logičkih vrijednosti koje mogu biti `True` (tačno) i `False` (netačno). Ove dvije vrijednosti igraju ključnu ulogu u logičkim operacijama i procjenama, jer omogućavaju programima da donose odluke na osnovu stanja podataka.
>[!Note] Naziv *bool*
>Naziv *bool* dolazi od imena britanskog matematičara i logičara **Georgea Boolea** (1815–1864), koji je postavio temelje moderne logike i binarnog sistema. Boole je razvio matematički pristup logici koji koristi samo dvije vrijednosti: istinito i lažno. Ovaj sistem, poznat kao **Booleova algebra**, postao je osnova za rad digitalnih računara, jer se svi podaci i operacije u računarima svode na nizove vrijednosti `True` i `False`. Tip podataka `bool` u programiranju nosi njegovo ime kao priznanje za doprinos računarstvu i matematici.
Ove vrijednosti nisu samo alat za procjenu istinitosti već čine temelj za dizajn i rad računarskih sistema. Cijeli digitalni svijet, uključujući osnovne strukture softvera i hardvera, zasnovan je na binarnom principu koji koristi samo dvije vrijednosti – tačno i netačno.
Kako logičke vrijednosti i operacije imaju ključnu ulogu u donošenju odluka unutar programa, detaljnija obrada ovog tipa nalazi se u sekciji koja se bavi strukturama odlučivanja.
### Promjena tipa podataka
Podaci u Pythonu ponekad zahtijevaju prilagođavanje ili konverziju iz jednog tipa u drugi kako bi bili pogodni za obradu. Ova prilagodba naziva se *promjena tipa podataka* i može biti ključna u slučajevima kada se operacije nad podacima mogu izvršiti samo ako su podaci odgovarajućeg tipa.
Na primjer, sabiranje broja i stringa rezultira greškom, jer Python ne zna kako kombinovati dva različita tipa podataka:
```python=
rezultat = 5 + "5"
```
<pre style="background-color: #1e1e1e; color: #FF4C4C; padding: 20px;">TypeError: unsupported operand type(s) for +: 'int' and 'str'</pre>
Ponekad se podaci mogu uspješno pretvoriti iz jednog tipa u drugi, ali postoje i situacije gdje to nije moguće, što izaziva grešku. Na primjer, broj `5` može se pretvoriti u string `"5"`, ali tekst `"Python"` ne može postati broj.
Promjena tipa podataka može se odvijati na dva načina:
* Implicitna promjena tipa: Python automatski prilagođava tip podataka kada je to potrebno i moguće.
* Eksplicitna promjena tipa: Programer koristi ugrađene funkcije kako bi precizno definisao promjenu tipa.
#### Implicitna promjena tipa podataka
Python ima sposobnost da automatski, bez eksplicitnih uputstava, promijeni tip podataka kada je to potrebno za izvršavanje operacija. Ova osobina naziva se **implicitna promjena tipa** i omogućava nesmetano izvođenje operacija koje uključuju različite tipove podataka.
Na primjer, kada se cijeli broj (`int`) koristi zajedno s realnim brojem (`float`) u matematičkoj operaciji, Python automatski pretvara cijeli broj u realni broj kako bi očuvao preciznost rezultata:
```python=
a = 5
b = 2.0
rezultat = a + b
print(rezultat)
```
<pre style="background-color: #1e1e1e; color: white; padding: 20px;">
7.0
</pre>
U ovom primjeru, cijeli broj `5` automatski je konvertovan u realni broj `5.0` prije sabiranja, jer je rezultat operacije `float`. Ova konverzija ne zahtijeva intervenciju programera i često je neprimjetna, ali osigurava tačnost rezultata.
Jedan od praktičnih primjera implicitne promjene tipa je prilikom rada s funkcijom `print()`. Ova funkcija automatski konvertuje vrijednosti različitih tipova (`int`, `float`, `bool`) u string (`str`) kako bi ih prikazala kao tekst. Na primjer:
```python=
broj = 42
tekst = "Broj je:"
print(tekst, broj)
```
<pre style="background-color: #1e1e1e; color: white; padding: 20px;">
Broj je: 42
</pre>
U ovom primjeru, broj `42` automatski je konvertovan u string `"42"` kako bi se mogao prikazati zajedno s drugim tekstom. Važno je napomenuti da se ova promjena tipa događa samo tokom ispisa i ne mijenja originalni tip podatka.
#### Eksplicitna promjena tipa podataka
U situacijama kada Python ne može automatski prilagoditi tip podataka ili kada je potrebna specifična konverzija, koristi se **eksplicitna promjena tipa**. Ovaj pristup omogućava preciznu kontrolu nad načinom na koji se podaci transformišu, koristeći dostupne komande.
| **Funkcija** | **Opis** |
|--------------|--------------------------------------------------------------------------------|
| `int()` | Pretvara podatak u cijeli broj (`int`). Ako je ulazni podatak tipa `float`, odbacuje se decimalni dio. Ako je podatak tipa `str`, mora sadržavati samo cifre. |
| `float()` | Pretvara podatak u realni broj (`float`). Može obraditi string koji sadrži decimalnu tačku. |
| `str()` | Pretvara podatak u string (`str`). Koristi se za pripremu podataka za tekstualni prikaz. |
| `bool()` | Pretvara podatak u logičku vrijednost (`True` ili `False`). Broj `0`, broj `0.0` i prazan string daju rezultat `False`. Sve ostale vrijednosti ovih tipova daju rezultat `True`. |
```python=
print(int(3.14))
print(int("42"))
print(float(5))
print(float("3.14"))
broj = 42
tekst = "Broj je: " + str(broj)
print(tekst)
print(bool(0))
print(bool(1))
print(bool(""))
print(bool("Python"))
```
<pre style="background-color: #1e1e1e; color: white; padding: 20px;">
3
42
5.0
3.14
Broj je: 42
False
True
False
True
</pre>
Promjena tipa podataka omogućava fleksibilniju obradu informacija, čineći programe svestranijim. Implicitna i eksplicitna promjena tipa često se kombinuju u složenijim programima kako bi se osigurala tačnost i efikasnost operacija.
:::warning
##### Potencijalni problemi implicitne konverzije
Implicitna konverzija tipova u Pythonu korisna je jer omogućava nesmetan rad s podacima različitih tipova u specifičnim situacijama, poput kombinacije cijelih i realnih brojeva. Međutim, oslanjanje na implicitnu konverziju tipova može biti **rizično** u nekim programskim jezicima ili kompleksnim sistemima.
Nedostaci implicitne konverzije uključuju:
1. Nejasnoća u radu programa: Implicitna konverzija može izazvati zabunu kod programera jer ponašanje programa postaje manje očigledno. Na primjer, automatska promjena tipa može dati rezultate koji nisu odmah intuitivni.
3. Loša praksa za održavanje koda: Implicitna konverzija može otežati razumijevanje i održavanje koda, jer drugi programeri moraju znati pravila konverzije za svaki jezik i kontekst.
4. Greške pri kombinaciji tipova: U nekim jezicima, poput **JavaScript-a**, implicitna konverzija može uzrokovati neočekivane rezultate. U primjeru ispod JavaScript automatski pretvara broj u string u prvoj liniji, dok u drugoj pretvara string u broj. Ovo ponašanje može izazvati greške ili konfuziju u složenim programima.
```javascript
console.log(5 + "5"); // Rezultat: "55"
console.log("5" - 1); // Rezultat: 4
```
Implicitna konverzija korisna je u jednostavnim situacijama, ali može postati problematična u složenijim programima. Python-ov fokus na eksplicitnost doprinosi sigurnosti i čitljivosti koda, dok jezici poput JavaScripta mogu ponuditi veću fleksibilnost uz rizik od neočekivanih rezultata. **Preporučuje se korištenje eksplicitne konverzije tipova** kada je to moguće, kako bi se izbjegli nesporazumi i greške u programima.
:::
## Unos ulaznih podataka
Obrada podataka, kao centralni dio svakog programa, zasniva se na informacijama koje program koristi za izvršavanje svojih operacija. Ove informacije dolaze iz dva osnovna izvora: mogu biti unaprijed definisane unutar programa (doslovne vrijednosti) ili unesene od strane korisnika tokom njegovog rada. Unos ulaznih podataka omogućava korisnicima da direktno utiču na rad programa pružanjem informacija koje se obrađuju u realnom vremenu.
:::info
### Uloge programera i korisnika
Programi se gotovo uvijek pišu s ciljem da ih koristi neko drugi – **krajnji korisnik**. Ovaj korisnik može biti pojedinac, grupa ili čak drugi program, zavisno od namjene aplikacije. Iako programi mogu biti kreirani i za ličnu upotrebu programera, takvi slučajevi su rijetki u svijetu razvoja softvera. Fokus većine programskih rješenja je olakšavanje zadataka, rješavanje problema ili pružanje korisnog alata drugim osobama.
Međutim, u procesu učenja programiranja stvari su nešto drugačije. Tokom učenja potrebno je napisati mnogo kraćih programa koji često neće imati prave korisnike osim samog autora. Uprkos tome, ovi programi služe kao temelj za sticanje iskustva, razumijevanje koncepata i razvijanje vještina koje će kasnije omogućiti izgradnju aplikacija za širu publiku.
Programeri u fazi testiranja i razvoja vlastitog koda postaju i njegovi korisnici. Pri svakom pokretanju programa, unošenju podataka ili provjeri rezultata, autor preuzima ulogu korisnika kako bi analizirao ponašanje svog koda. Ova dualna uloga programera kao kreatora i korisnika zahtijeva sposobnost brzog prebacivanja između perspektive autora i korisnika – jedno je pisati funkcionalnosti, a drugo testirati ih i ocjenjivati.
Shvatanje ovih različitih uloga važno je jer razvija osjećaj odgovornosti prema kvaliteti koda. Programer koji se stavi u ulogu krajnjeg korisnika bolje razumije važnost intuitivnog dizajna, jasnih uputa i pouzdanog ponašanja aplikacije.
:::
S obzirom na to da programi predstavljeni u ovom tekstu komuniciraju s korisnikom isključivo putem terminala, Python nudi jedan način za preuzimanje podataka, i to pomoću komande `input()`.
### Funkcija `input()`
Unos podataka u Pythonu realizuje se pomoću funkcije `input()`. Da bi se razumjelo njeno osnovno ponašanje, može se posmatrati program koji se sastoji od samo jednog poziva funkcije.
```python=
input()
```
<pre style="background-color: #1e1e1e; color: white; padding: 20px;">
</pre>
<pre style="background-color: #1e1e1e; color: white; padding: 20px;">
Python <kbd>⏎ Enter</kbd>
</pre>
Pokretanjem ovog programa, terminal ostaje prazan, što može ostaviti dojam da je program završio. Međutim, program je i dalje aktivan i čeka unos s tastature. Tokom unosa teksta, uneseni sadržaj se pojavljuje na terminalu, a pritiskom na tipku <kbd>⏎ Enter</kbd> program se završava.
Ovdje se funkcija `input()` koristi za prihvatanje podataka, ali bez dodatnih koraka podaci se niti pohranjuju niti obrađuju. Ova situacija podsjeća na raniji primjer s izrazom `2 + 2`, gdje je rezultat operacije izračunat, ali nije prikazan. Na sličan način, funkcija `input()` prihvata tekstualni unos, ali ga bez dodatnih instrukcija zanemaruje i program se završava.
### Pohranjivanje unosa u varijablu
Da bi podaci unijeti putem funkcije `input()` bili dostupni za daljnju upotrebu, potrebno ih je pohraniti u varijablu. Na ovaj način unos postaje trajno dostupan tokom izvršavanja programa.
```python=
unos = input()
print("Uneseno je:", unos)
```
<pre style="background-color: #1e1e1e; color: white; padding: 20px;">
Python <kbd>⏎ Enter</kbd>
Uneseno je: Python
</pre>
Ovaj program omogućava prihvatanje unosa, njegovo pohranjivanje u varijablu `unos` i naknadno prikazivanje. Kada se, na primjer, unese tekst `"Python"`, na terminalu će se pojaviti rezultat:
`Uneseno je: Python`.
:::info
Iako se na prvi pogled čini kao sitnica, ovaj program sada zavisi od unosa korisnika. Svaki novi unos vodi do drugačijeg rezultata. Naravno, rezultat je poznat, očekivan i predvidiv jer se tačno zna šta program radi – preuzima unos i ponovo ga prikazuje. Međutim, ovim se pravi važan korak ka izgradnji dinamičnih programa koji ne funkcionišu samo s unaprijed definisanim vrijednostima, već prilagođavaju svoje ponašanje u zavisnosti od korisničkog unosa. Ovo je osnova interaktivnosti u programiranju.
:::
### Prosljeđivanje poruke korisniku
Program bez jasne upute može biti neintuitivan. Korisnik može biti zbunjen zbog praznog terminala i nejasnoće o tome šta se očekuje. Da bi se riješio ovaj problem, funkciji `input()` se može proslijediti tekst, koji se prikazuje na terminalu prije unosa.
```python=
unos = input("Molimo unesite neki tekst: ")
print("Uneseno je:", unos)
```
<pre style="background-color: #1e1e1e; color: white; padding: 20px;">
Molimo unesite neki tekst: Python programiranje! <kbd>⏎ Enter</kbd>
Python programiranje!
</pre>
:::warning
Ovdje je važno obratiti pažnju na razmak nakon dvotačke u tekstu upita. Ukoliko razmak nije uključen, uneseni tekst bi bio spojen s dvotačkom, što može izgledati neuredno i neprirodno.
```python=
unos = input("Molimo unesite neki tekst:")
```
<pre style="background-color: #1e1e1e; color: white; padding: 20px;">
Molimo unesite neki tekst:Python programiranje! <kbd>⏎ Enter</kbd>
Python programiranje! </pre>
Funkcija `input()` ne dodaje automatski razmak nakon ispisanog teksta, pa je potrebno ručno osigurati pravilan razmak unutar samog stringa. Ovo se razlikuje od ponašanja funkcije `print()`, koja automatski dodaje razmak između elemenata koje ispisuje. Ranije je objašnjeno da `print()` omogućava prilagođavanje razmaka pomoću svojih parametara poput `sep` i `end`, dok `input()` zahtijeva pažnju prilikom formulisanja teksta upita kako bi rezultat bio estetski korektan.
Još jedna bitna razlika između funkcija `input()` i `print()` jeste u broju podataka koje mogu obraditi. Funkcija `input()` prihvata samo jedan tekstualni podatak, koji koristi kao upit za unos korisnika. Nasuprot tome, funkcija `print()` može istovremeno prikazati više podataka odvojenih zarezima, što je čini fleksibilnijom za prikaz složenijih poruka. Ova razlika odražava različite namjene ovih funkcija, a to je da se `print()` koristi za prikazivanje informacija, dok `input()` omogućava unos jednog podatka od strane korisnika.
:::
### Rezultat funkcije `input()` uvijek je string
Funkcija `input()` omogućava unos podataka s tastature, ali bez obzira na to šta korisnik unese – cijeli broj, decimalni broj, riječ ili čak prazan unos – rezultat funkcije uvijek je string. Ovo ponašanje omogućava funkciji da prihvati širok spektar podataka, ali zahtijeva dodatne korake kada je potrebno raditi s podacima poput brojeva.
Ako se nakon pokretanja narednog programa unese broj `42`, program ispisuje `Uneseno je: 42`.
```python=
unos = input("Unesite broj: ")
print("Uneseno je:", unos)
```
<pre style="background-color: #1e1e1e; color: white; padding: 20px;">
Unesite broj: 42 <kbd>⏎ Enter</kbd>
Uneseno je: 42
</pre>
Međutim, pokušaj sabiranja unesenog podatka s brojem izaziva problem.
```python=
unos = input("Unesite broj: ")
rezultat = unos + 2
print("Rezultat je:", rezultat)
```
<pre style="background-color: #1e1e1e; color: white; padding: 20px;">
Unesite broj: 42 <kbd>⏎ Enter</kbd>
<span style="color: #FF4C4C">TypeError: can only concatenate str (not "int") to str</span>
</pre>
Ova greška ukazuje na to da funkcija `input()` vraća string, pa se pokušava izvršiti operacija koja nije dozvoljena, a to je sabiranje stringa i broja.
:::success
Rezultat funkcije `input()` uvijek je string!
:::
Da bi se rezultat funkcije `input()` koristio kao broj, potrebno je izvršiti eksplicitnu konverziju u odgovarajući tip, poput cijelog broja (`int`) ili realnog broja (`float`). Na primjer:
```python=
unos = input("Unesite broj: ")
broj = int(unos)
rezultat = broj + 2
print("Rezultat je:", rezultat)
```
<pre style="background-color: #1e1e1e; color: white; padding: 20px;">
Unesite broj: 42 <kbd>⏎ Enter</kbd>
Rezultat je: 44
</pre>
Sada, unos broja `42` daje očekivani rezultat: `Rezultat je: 44`.
Rezultat funkcije `input()` uvijek je string, ali u nekim situacijama nema potrebe za čuvanjem originalnog podatka u obliku stringa. Ako je unos zamišljen isključivo kao broj ili neka druga specifična vrsta podatka, moguće je odmah izvršiti konverziju u željeni tip. Ovo se postiže tako što se funkcija `input()` direktno umetne u funkciju za konverziju.
Primjer takvog pristupa je:
```python=
broj = int(input("Unesite cijeli broj: "))
print("Uneseni broj uvećan za 2 je:", broj + 2)
```
<pre style="background-color: #1e1e1e; color: white; padding: 20px;">
Unesite cijeli broj: 42 <kbd>⏎ Enter</kbd>
Uneseni broj uvećan za 2 je: 44
</pre>
U ovom slučaju, funkcija `input()` prihvata unos korisnika, ali njen rezultat se odmah prosljeđuje funkciji `int()`, koja vrši konverziju stringa u cijeli broj. Na ovaj način, varijabla `broj` sadrži već konvertovani podatak i spremna je za upotrebu u aritmetičkim operacijama.
Sličan princip može se primijeniti i za druge vrste podataka, poput realnih brojeva:
```python=
decimalni_broj = float(input("Unesite decimalni broj: "))
print("Uneseni broj podijeljen s 2 je:", decimalni_broj / 2)
```
<pre style="background-color: #1e1e1e; color: white; padding: 20px;">
Unesite decimalni broj: 15 <kbd>⏎ Enter</kbd>
Uneseni broj podijeljen s 2 je: 7.5
</pre>
:::warning
Direktna konverzija unosa, gdje se funkcija `input()` odmah prosljeđuje funkciji poput `int()` ili `float()`, može pojednostaviti kod jer eliminiše potrebu za čuvanjem stringa i naknadnom konverzijom. Međutim, ovaj pristup nosi rizik. Ako korisnik unese nevažeći podatak, poput teksta umjesto broja, program će se prekinuti s greškom.
Ova metoda je korisna kada je unos korisnika predvidiv i jasno definisan, ali za situacije gdje su greške vjerovatne, preporučuje se korištenje validacije podataka. Validacija omogućava provjeru ispravnosti unosa prije nego što se izvrši konverzija, čime se osigurava pouzdan rad programa.
:::
Unos podataka predstavlja ključnu komponentu interaktivnih programa, omogućavajući korisnicima da direktno utiču na izvršavanje i rezultate. Kroz funkciju input(), Python pruža fleksibilan način za prikupljanje unosa, ali zahtijeva razumijevanje njenih ograničenja, poput činjenice da uvijek vraća string. Korištenjem varijabli, eksplicitne konverzije i jasnih uputa, unos se može efikasno integrisati u programe, pružajući osnovu za izgradnju dinamičnih aplikacija prilagođenih korisničkim potrebama.
## Komentari
Komentari su tekst unutar koda koje Python ignoriše prilikom izvršavanja programa. Njihova svrha je pružanje dodatnih informacija ili objašnjenja koja olakšavaju razumijevanje koda programerima, bez uticaja na sam tok programa. Komentari su ključni za pisanje čitljivog koda, što je posebno važno prilokom rada u timu ili kada se kod ponovo čita nakon duže pauze.
### Kreiranje komentara
U Pythonu se komentari zapisuju korištenjem znaka `#`. Sve što se nalazi nakon ovog znaka do kraja linije smatra se komentarom i Python neće razmatrati.
Primjer jednostavnog komentara:
```python=
# Ova linija pozdravlja korisnika
print("Dobrodošli u Python!") # Pozdravna poruka
```
U ovom primjeru, prva linija je čitav komentar, dok je na drugoj liniji komentar dodan nakon koda.
### Višelinijski komentari
Iako Python nema poseban sintaksni znak za višelinijske komentare, više pojedinačnih komentara može se koristiti za objašnjavanje složenijih dijelova programa.
```python=
# Ovaj program izračunava površinu pravougaonika
# Potrebno je unijeti dužinu i širinu
# Rezultat se ispisuje na ekranu
duzina = 10
sirina = 5
povrsina = duzina * sirina
print("Površina je:", povrsina)
```
Za duže napomene ili objašnjenja može se koristiti i sintaksa trostrukih navodnika (`'''` ili `"""`). Međutim, treba napomenuti da Pythonu ovo predstavlja višelinijske strinogve koji se evaluiraju, ali se ne čuvaju ako nisu pridružene nekoj varijabli.
```python=
"""
Ovaj program izračunava površinu pravougaonika
Potrebno je unijeti dužinu i širinu
Rezultat se ispisuje na ekranu
"""
duzina = 10
sirina = 5
povrsina = duzina * sirina
print("Površina je:", povrsina)
```
Korištenje trostrukih navodnika može biti korisno za dokumentovanje koda, ali nije prava zamjena za komentare, jer Python ove stringove obrađuje kao dio koda. Za prave komentare preporučuje se upotreba znaka `#`.
:::info
Mnogi programski jezici pružaju poseban sintaksni znak za označavanje višelinijskih komentara. Na primjer, u jezicima **C++**, **Java** i **JavaScript** višelinijski komentari ubacuju se između `/*` i `*/`.
```javascript
/* Ovo je višelinijski komentar
koji može obuhvatiti više redova teksta
i koristi se za objašnjenje složenijih dijelova programa. */
```
Python, s druge strane, ne nudi ovu mogućnost kao dio jezika. Međutim, većina alata za razvoj softvera (IDE-ova) koji podržavaju Python nudi praktične prečice na tastaturi za brzo komentarisanje više linija koda.
Na primjer, u popularnim alatima poput **PyCharm**-a i **VS Code**-a, označeni dio koda može se komentarisati koristeći kombinaciju <kbd>Ctrl</kbd> + <kbd>/</kbd> na tastaturi. Ova kratica automatski dodaje znak `#` ispred svake linije u selektovanom dijelu teksta.
:::
### Privremeno isključivanje koda
Osim za objašnjavanje, komentari se često koriste za privremeno stavljanje dijelova koda van funkcije, što je korisno prilikom otklanjanja grešaka ili testiranja. Na taj način određeni kod se ne izvršava, dok ostatak programa ostaje funkcionalan:
```python=
print("Ova poruka se prikazuje")
# print("Ova poruka je privremeno isključena")
print("Program se nastavlja")
```
U ovom primjeru, druga linija koda neće se izvršiti jer je pretvorena u komentar. Ovo je često korištena praksa prilikom testiranja i otkrivanja grešaka.
:::info
#### Šta je *debugging*?
Debugging, ili otklanjanje grešaka, predstavlja proces pronalaženja i ispravljanja grešaka (bugova) u programu. Greške su neizbježan dio programiranja i mogu se pojaviti iz raznih razloga poput tipografskih grešaka, nepravilne logike, neočekivanih ulaznih podataka i problema u integraciji s drugim sistemima. Cilj debugginga je razumjeti zašto program ne radi kako se očekuje, otkriti uzrok problema i korigovati kod tako da funkcioniše ispravno.
Porijeklo izraza *debugging* veže se za rane dane računarskih sistema. Legenda kaže da su inženjeri na Harvardu, 1947. godine, otkrili grešku u Mark II računaru uzrokovanu pravom bubom (eng. bug) koja se zaglavila unutar mašine. Nakon uklanjanja bube, proces identifikacije i otklanjanja grešaka počeo se nazivati "debugging". Iako je izraz *bug* za greške u mehaničkim sistemima postojao i ranije, ovaj događaj dodatno je popularizovao termin, koji je ostao u upotrebi i do danas.
*Debugging* obično uključuje nekoliko metoda. Najjednostavniji način je korištenje ispisa (`print()` funkcija) za provjeru vrijednosti varijabli. Ovo omogućava uvid u stanje programa tokom njegovog rada i pomaže u identifikaciji mjesta gdje se nalaze greške. U složenijim scenarijima koriste se specijalizovani alati za *debugging* koji omogućavaju praćenje izvršavanja programa liniju po liniju, pregled stanja varijabli u stvarnom vremenu i postavljanje tačaka prekida (eng. breakpoints) kako bi se pauziralo izvršavanje u važnim dijelovima koda.
Komentari također igraju važnu ulogu u *debuggingu*. Privremeno isključivanje dijelova koda pomoću komentara pomaže u izolaciji problematičnih dijelova programa i olakšava otkrivanje uzroka greške. Korisna tehnika za praćenje ponašanja programa tokom rada je i logovanje, koje podrazumijeva zapisivanje ključnih događaja ili vrijednosti tokom izvršavanja programa, omogućavajući detaljnu analizu grešaka, čak i nakon što se one dogode.
*Debugging* nije samo tehnička vještina već i proces logičkog razmišljanja i detaljne analize. Razvijanjem ove sposobnosti programeri bolje razumiju svoje greške, ali i dublje principe funkcionisanja softvera.
:::
### Pisanje dobrih komentara
Dobri komentari su kratki, jasni i pomažu u razumijevanju koda. Praksa pisanja komentara može značajno poboljšati čitljivost i održavanje koda. Međutim, treba izbjegavati prekomjerno komentarisanje ili pisanje komentara koji samo ponavljaju ono što sam kod već jasno opisuje.
:::warning
Primjer lošeg komentara:
```python=
a = 10 # Dodjeljuje 10 varijabli a
```
:::
Primjer dobrog komentara:
```python=
a = 10 # Postavlja početnu vrijednost za varijablu a
```
Komentari su alat koji doprinosi razumljivosti, održavanju i efikasnom otklanjanju grešaka u kodu. Pravilnom upotrebom komentara programerima se omogućava bolja komunikacija i lakši rad, dok privremeno isključivanje koda pomoću komentara predstavlja praktičnu tehniku za testiranje i debagovanje.
## Sažetak
U ovom poglavlju objašnjena je temeljna struktura većine programa: unos, obrada i ispis podataka. Istaknuto je da računar, bez obzira na složenost zadatka, u suštini prima podatke, vrši nad njima određene operacije i zatim prikazuje rezultate. Kao primjer, prikazan je jednostavan Python program koji podatke unosi preko tastature, zatim vrši jednostavnu obradu i na kraju rezultat vraća korisniku kroz prikaz na ekranu. Razmotreno je i zašto je rad sa tekstualnim unosom i ispisom kroz terminal, iako djeluje skromno u odnosu na grafičke interfejse, izuzetno koristan za razumijevanje osnovnih principa programiranja.
Dodatno je detaljno objašnjena funkcija `print()`, koja služi za ispis podataka, te funkcija `input()` koja omogućava preuzimanje podataka od korisnika. Istaknuto je da `print()` može prilagođavati format ispisa (kroz `sep` i `end` parametre, kao i *f-stringove* za fleksibilno formatiranje), dok `input()` uvijek vraća tekst (string) koji je po potrebi potrebno konvertovati u broj ili neki drugi tip. U ovom poglavlju naglasak je stavljen i na razumijevanje tipova podataka (`int`, `float`, `str` i `bool`) i važnost njihove ispravne primjene i konverzije. Time se gradi osnova za rad s različitim vrstama informacija, bilo da su to brojevi, tekst ili logičke vrijednosti.
Na kraju, obrađen je koncept komentara kao alata za dodavanje objašnjenja unutar koda, čime se povećava čitljivost i održivost programa. Kroz primjere je pokazano kako komentari pomažu u razumijevanju strukture programa, pronalaženju i ispravljanju grešaka, te privremenom isključivanju određenih dijelova koda. Time su postavljeni temelji za daljnji rad na složenijim i interaktivnijim programima, gdje će se principi unosa, obrade, ispisa i komentarisanja koristiti u kombinaciji s drugim programskim konceptima.
Sign in with Wallet
Connect another wallet