4  Osnove Pythona

Objavljeno

28. avgust 2026

4.1 Namen poglavja

To poglavje uvede osnovne gradnike jezika Python, ki jih bomo uporabljali skozi celotno knjigo. Cilj ni le spoznati sintakso, temveč razviti občutek za to, kako program razbije nalogo na manjše korake: shrani vrednosti, preveri pogoje, ponavlja postopke in zapakira rešitve v funkcije.

V nadaljevanju se bomo osredotočili na več povezanih sklopov:

  • podatkovne tipe in spremenljivke,
  • logične izraze in pogojne stavke,
  • zanke while in for,
  • funkcije in vračanje rezultatov,
  • uvažanje knjižnic,
  • osnovni in oblikovani izpis.

4.2 Vrednosti, tipi in spremenljivke

Programi delajo z vrednostmi. Te so lahko števila, besedilo ali logične vrednosti. V Pythonu so najpogostejši osnovni tipi:

  • int za cela števila,
  • float za realna števila,
  • str za niz znakov,
  • bool za logični vrednosti True in False.

Tip vrednosti preverimo s funkcijo type().

print(10, type(10))
print(10.1, type(10.1))
print("Pozdrav", type("Pozdrav"))
print(True, type(True))
10 <class 'int'>
10.1 <class 'float'>
Pozdrav <class 'str'>
True <class 'bool'>

Poleg osnovnih tipov Python pozna tudi sestavljene podatkovne tipe, v katerih hranimo več vrednosti. Med najpogostejšimi so:

  • list za urejen in spremenljiv seznam vrednosti, na primer [1, 2, 3],
  • tuple za urejeno in nespremenljivo zaporedje, na primer (1, 2),
  • dict za pare ključ–vrednost, na primer {"ime": "Ana", "starost": 21},
  • set za množico enoličnih vrednosti, na primer {1, 2, 3}.

Podrobneje jih bomo uporabljali pri nadaljnjih primerih. Tudi njihov tip lahko preverimo s funkcijo type().

print(type([1, 2, 3]))
print(type({"ime": "Ana"}))
print(type({1, 2, 3}))
<class 'list'>
<class 'dict'>
<class 'set'>

4.2.1 Podatki o celoštevilskem in realnem tipu

Modul sys vsebuje podatke o notranji predstavitvi števil. Objekt sys.int_info opiše izvedbene lastnosti tipa int:

import sys

sys.int_info
sys.int_info(bits_per_digit=30, sizeof_digit=4, default_max_str_digits=4300, str_digits_check_threshold=640)

Pythonova cela števila nimajo vnaprej določene največje vrednosti, saj se lahko po potrebi razširijo na več pomnilnika. sys.int_info zato ne podaja najmanjšega in največjega celega števila, temveč podatke o njegovi notranji predstavitvi.

Objekt sys.float_info vsebuje lastnosti tipa float, med drugim največjo in najmanjšo pozitivno normalizirano vrednost ter približno decimalno natančnost:

sys.float_info
sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)

Tip float ima omejen obseg in natančnost. Zato nekaterih decimalnih števil ni mogoče predstaviti povsem natančno, pri zelo velikih ali zelo majhnih vrednostih pa lahko dosežemo meje predstavitve.

Spremenljivka je ime, s katerim vrednost shranimo za poznejšo uporabo. Prirejanje zapisujemo z operatorjem =.

ime = "Ana"
starost = 21
povprecje = 8.7

print(ime)
print(starost)
print(povprecje)
Ana
21
8.7

Pri poimenovanju spremenljivk se dobro obnese nekaj preprostih pravil:

  • ime naj bo razlagalno in naj pove, kaj podatek predstavlja,
  • uporabimo male črke in podčrtaje, na primer temperatura_zraka,
  • ime se ne sme začeti s številko,
  • izognemo se rezerviranim besedam, kot so if, for, while ali return.

Python razlikuje med malimi in velikimi črkami. Imena ime, Ime in IME zato označujejo tri različne spremenljivke:

ime = "Ana"
Ime = "Boris"

print(ime)
print(Ime)
Ana
Boris

Zaradi preglednosti spremenljivk praviloma ne razlikujemo samo z velikostjo črk. Sledimo dogovoru snake_case, pri katerem večbesedna imena pišemo z malimi črkami in podčrtaji, na primer povprecna_temperatura.

4.2.2 Rezervirane besede

Rezervirane besede imajo v Pythonovi skladnji poseben pomen, zato jih ne smemo uporabiti kot imena spremenljivk, funkcij ali razredov. Aktualni seznam dobimo iz standardnega modula keyword:

import keyword

print(", ".join(keyword.kwlist))
False, None, True, and, as, assert, async, await, break, class, continue, def, del, elif, else, except, finally, for, from, global, if, import, in, is, lambda, nonlocal, not, or, pass, raise, return, try, while, with, yield

Python pozna tudi mehke rezervirane besede, ki imajo poseben pomen samo v določenem skladenjskem kontekstu:

print(", ".join(keyword.softkwlist))
_, case, match, type

Če nismo prepričani, ali je izbrano ime rezervirano, ga lahko preverimo programsko:

print(keyword.iskeyword("for"))
print(keyword.iskeyword("temperatura"))
True
False

4.3 Aritmetične operacije in vrstni red izvajanja

Nad številskimi tipi lahko izvajamo običajne aritmetične operacije:

Operator Pomen Primer
+ seštevanje 11 + 3.1
- odštevanje 5 - 19
* množenje 8.5 * 4
/ deljenje 11 / 2
// celo deljenje 11 // 2
% ostanek pri deljenju 8 % 3
** potenciranje 2 ** 5

Python sledi običajnemu vrstnemu redu računanja: najprej oklepaji, nato potence, potem množenje in deljenje, nazadnje seštevanje in odštevanje.

2 * (3 - 1)
(1 + 1) ** (5 - 2)
6 + 4 / 2
6 + 4 * 2
14

4.3.1 Združevanje in pretvarjanje tipov

Pri nizih znakov operator + pomeni lepljenje besedila:

pozdrav = "Hoj"
stevilka = 10

print(pozdrav + " ti")
print(pozdrav + str(stevilka))
Hoj ti
Hoj10

Zadnji primer pokaže pomembno pravilo: različne tipe pogosto pretvarjamo z int(), float() in str().

int("42")
float(42)
str(3.14)
'3.14'

Pri računanju s celim in realnim številom Python pretvorbo opravi samodejno. Rezultat izraza 1 + 1.2 je zato tipa float:

rezultat = 1 + 1.2
print(rezultat, type(rezultat))
2.2 <class 'float'>

Takšna samodejna pretvorba ni mogoča med poljubnimi tipi. Seštevanje števila in niza sproži napako TypeError:

1 + "1"
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[14], line 1
----> 1 1 + "1"

TypeError: unsupported operand type(s) for +: 'int' and 'str'

Enako velja, če poskusimo niz neposredno združiti s številom:

"Hoj" + 10
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[15], line 1
----> 1 "Hoj" + 10

TypeError: can only concatenate str (not "int") to str

V prvem primeru moramo niz pretvoriti v število, v drugem pa število v niz:

print(1 + int("1"))
print("Hoj" + str(10))
2
Hoj10

Pretvorba realnega števila v celo število decimalni del odreže proti ničli; vrednosti ne zaokroži:

print(int(42.1))
print(int(-42.9))
42
-42

Če želimo matematično zaokroževanje, uporabimo round() ali ustrezno funkcijo iz modula math.

4.4 Vnos in izpis

Za delo v terminalu ali v preprostem interaktivnem programu najpogosteje uporabljamo input() in print().

ime = input("Kako ti je ime? ")
print("Živjo,", ime)

Pomembno je vedeti, da input() vedno vrne niz znakov. Če želimo število, ga moramo pretvoriti:

vnos = input("Vpiši temperaturo: ")
temperatura = float(vnos)
print("Temperatura je", temperatura)

Pri izpisu je koristno vedeti še to, da funkcija print() ni uporabna samo za hiter prikaz vrednosti, ampak tudi za oblikovana sporočila. To pride prav pri razlagi rezultatov, poročanju o vmesnih korakih in iskanju napak v kodi.

4.4.1 Oblikovan izpis

V Pythonu poznamo več načinov oblikovanja nizov:

  • starejši zapis z operatorjem %,
  • metodo .format(),
  • sodobni zapis z f-nizi.

Najpogosteje je danes najbolj berljiv prav zapis z f-nizi.

ime = "Ana"
starost = 21

print("%s je stara %d let" % (ime, starost))
print("{} je stara {} let".format(ime, starost))
print(f"{ime} je stara {starost} let")
Ana je stara 21 let
Ana je stara 21 let
Ana je stara 21 let

Prednost f-nizov je, da lahko vanje neposredno vključimo tudi izraze:

temperatura = 12.34567
print(f"Temperatura: {temperatura:.2f} °C")
Temperatura: 12.35 °C

Oznaka :.2f pomeni, da želimo število izpisati kot realno vrednost z dvema decimalnima mestoma. Tak način izpisa je zelo uporaben v znanstvenem računanju in pri pripravi preglednic rezultatov.

4.5 Uvažanje knjižnic

Pomemben del dela v Pythonu je uporaba že pripravljenih knjižnic. Za to uporabljamo ukaz import.

Najosnovnejši primer je uvoz celotnega modula:

import math

print(math.pi)
print(math.floor(3.15))
3.141592653589793
3

Pri takem zapisu do funkcij in konstant dostopamo prek imena modula, na primer math.pi. To je pregleden način, ker hitro vidimo, od kod neka funkcija prihaja.

Včasih uvozimo le izbrani del modula:

from math import pi

print(pi)
3.141592653589793

Možen je tudi uvoz z vzdevkom oziroma aliasom:

import math as m

print(m.e)
2.718281828459045

To je posebej pogosto pri knjižnicah, ki jih bomo veliko uporabljali pozneje:

import numpy as np

print(np.inf)
inf

Tak zapis je v znanstvenem Pythonu standarden. Na splošno se je smiselno izogniti ukazu from modul import *, ker hitro skrije, od kod posamezna imena prihajajo, in zmanjša preglednost kode.

4.6 Logični izrazi in pogojni stavki

Logični izraz ima dve možni vrednosti: True ali False. Najpogosteje jih dobimo s primerjavami:

Operator Pomen
== je enako
!= ni enako
> je večje
< je manjše
>= je večje ali enako
<= je manjše ali enako

Več pogojev lahko povezujemo z logičnimi operatorji and, or in not.

x = 5
print(x > 0 and x < 10)
print(x == 5 or x == 7)
print(not x < 0)
True
True
True

Na logičnih izrazih temeljijo pogojni stavki. Najosnovnejši je if.

x = 5

if x > 0:
    print("x je pozitiven")
x je pozitiven

Osnovna zgradba pogojnega stavka if

Če želimo določiti tudi alternativo, uporabimo else.

x = 3

if x % 2 == 0:
    print("x je sodo")
else:
    print("x je liho")
x je liho

Pogojni stavek if z vejo else

Pri več možnostih uporabimo verižni pogojni stavek if - elif - else.

ocena = 8

if ocena >= 9:
    print("odlično")
elif ocena >= 7:
    print("prav dobro")
elif ocena >= 6:
    print("zadostno")
else:
    print("nezadostno")
prav dobro

Pogojni stavki so posebej uporabni pri preverjanju uporabniškega vnosa. Če pričakujemo napako pri pretvorbi tipov, jo lahko prestrežemo z try in except.

vnos = input("Hitrost vozila? ")

try:
    hitrost = int(vnos)
    print("Hitrost:", hitrost)
except ValueError:
    print(vnos, "ni celo število")

4.7 Ponavljanje z zankami

Veliko nalog zahteva ponavljanje. Python ima za to dve osrednji strukturi: while in for.

4.7.1 Zanka while

Zanka while se izvaja, dokler je njen pogoj resničen.

n = 5

while n > 0:
    print(n)
    n = n - 1

print("Start!")
5
4
3
2
1
Start!

Pri takih zankah moramo paziti, da se pogoj sčasoma spremeni, sicer nastane neskončna zanka.

Včasih konca ne poznamo vnaprej in uporabimo break, da zanko prekinemo od znotraj:

while True:
    vnos = input("> ")
    if vnos == "konec":
        break
    print(vnos)

Ukaz continue pa preskoči preostanek trenutne iteracije in skoči na začetek naslednje.

4.7.2 Zanka for

Zanko for uporabimo, ko gremo prek končnega nabora vrednosti, na primer seznama ali zaporedja.

prijatelji = ["Ana", "Brane", "Cene", "Darinka"]

for prijatelj in prijatelji:
    print("Srečno", prijatelj)
Srečno Ana
Srečno Brane
Srečno Cene
Srečno Darinka

Tipična zgradba zanke for

To je zelo pogost vzorec pri analizi podatkov: gremo prek vseh elementov in sproti računamo rezultat. Tako lahko preštejemo elemente ali izračunamo vsoto:

stevila = [13, 4, 21, 5, 44, 35]

koliko = 0
for stevilo in stevila:
    koliko += 1

vsota = 0
for stevilo in stevila:
    vsota += stevilo

Na enak način lahko poiščemo največjo ali najmanjšo vrednost.

stevila = [13, 4, 21, 5, 44, 35]
najvecje = None

for stevilo in stevila:
    if najvecje is None or stevilo > najvecje:
        najvecje = stevilo

print(najvecje)
44

V praksi velja pomembno pravilo: ko za pogosto opravilo že obstaja vgrajena funkcija, jo je navadno bolje uporabiti kot lastno zanko. Za zgornje primere so to len(), sum(), min() in max().

4.8 Funkcije

Funkcija je poimenovan kos programa, ki ga lahko pokličemo večkrat. Tako zmanjšamo podvajanje kode in naredimo program preglednejši.

Preprosta funkcija brez argumentov:

def pozdrav():
    print("Pozdrav iz funkcije.")

Funkcijo moramo najprej definirati, nato jo lahko pokličemo

Funkcije pogosto potrebujejo argumente.

def print_dvakrat(kaj):
    print(kaj)
    print(kaj)

Ko funkcijo pokličemo, se podana vrednost priredi parametru:

print_dvakrat("Python")
print_dvakrat(10)
Python
Python
10
10

Mnogo funkcij nekaj izračuna in rezultat vrne z ukazom return.

def sestej(a, b):
    sestevek = a + b
    return sestevek

rezultat = sestej(3, 5)
print(rezultat)
8

To je ključna razlika med funkcijami, ki nekaj le izpišejo, in funkcijami, ki vrnejo vrednost za nadaljnjo uporabo. Pri analizi podatkov praviloma želimo čim več dela organizirati v funkcije, ki vračajo rezultate.

Še nekoliko daljši primer je funkcija, ki preveri, ali je število praštevilo:

def prastevilo(stevilo):
    for i in range(2, stevilo):
        if stevilo % i == 0:
            return False
    return True

Klici funkcij lahko vodijo v več zaporednih korakov izvajanja

Vidimo dva pomembna vzorca:

  • funkcija lahko vsebuje zanke in pogojne stavke,
  • funkcija se konča takoj, ko naleti na return.

4.9 Zakaj so te osnove pomembne

Teme iz tega poglavja bomo uporabljali skoraj v vsaki nadaljnji kodi:

  • pri pandas bomo delali s spremenljivkami, tipi in pogoji,
  • pri obdelavi tabel bomo pogosto iterirali ali raje izbirali vgrajene funkcije,
  • pri skoraj vseh nadaljnjih poglavjih bomo morali pravilno uvoziti knjižnice in razumljivo izpisati rezultate,
  • pri geoprostorskih postopkih bomo ponavljajoče korake zapakirali v funkcije.

Dobro razumevanje teh gradnikov je zato pomembnejše od pomnjenja vseh podrobnosti sintakse. Veliko bolj koristno je, da ob branju kode hitro prepoznamo, kaj je spremenljivka, kaj pogoj, kaj zanka in kaj funkcija.

4.10 Nadaljevanje

Naslednji korak je spremljevalna beležnica z vajami, kjer te osnove uporabimo na kratkih nalogah in mini projektu pretvarjanja temperatur med Celzijevo in Fahrenheitovo lestvico.

Za nadaljnje poglavje o NumPy je posebej pomembno, da iz tega poglavja dobro razumemo tri stvari:

  • kako delajo spremenljivke in tipi,
  • kako zapišemo pogoj ali ponavljanje,
  • kako preprost postopek zapakiramo v funkcijo.

V NumPyju se bo način razmišljanja nekoliko premaknil: namesto obdelave enega elementa naenkrat bomo vedno pogosteje računali nad celotnimi polji hkrati.