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'>
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:
while in for,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'>
Modul sys vsebuje podatke o notranji predstavitvi števil. Objekt sys.int_info opiše izvedbene lastnosti tipa int:
import sys
sys.int_infosys.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_infosys.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:
temperatura_zraka,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.
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
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 * 214
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.
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.
V Pythonu poznamo več načinov oblikovanja nizov:
%,.format(),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.
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.
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

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

if z vejo elsePri 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")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.")
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
Vidimo dva pomembna vzorca:
return.Teme iz tega poglavja bomo uporabljali skoraj v vsaki nadaljnji kodi:
pandas bomo delali s spremenljivkami, tipi in pogoji,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.
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:
V NumPyju se bo način razmišljanja nekoliko premaknil: namesto obdelave enega elementa naenkrat bomo vedno pogosteje računali nad celotnimi polji hkrati.