Python ima podatkovni tip list
. Jaz to prevedem v
seznam, eni imajo raje tabela, ker se vede malo
podobno kot array v kakšnem drugem jeziku.
Zapremo ga v oglate oklepaje. Vsebuje lahko elemente poljubnih
tipov, lahko tudi mešanico tipov, npr. ["Ana", 74, True]
.
Ampak tega ponavadi ne počnemo. Za različne tipe ponavadi uporabljamo
terke (glej spodaj).
Gre lahko čez več vrstic, če pustimo odprt oklepaj. Zamik v drugi in nadaljnjih vrsticah je načelno poljuben, vendar se splača lepo poravnavati.
= [74, 82, 58,
teze 66, 61, 84]
= [
imena "Ana",
"Berta",
"Cilka",
]
prazen
je zelo slabo ime za seznam. Če kdo napiše
prazen = []
, grem stavit, da ta seznam ne bo vedno
prazen. Tudi seznam
je slabo ime za seznam.Terka (tuple
) je podobna seznamu, samo da jo zapremo v
navadne oklepaje, t = (1, 2, 3).
t = 1, 2, 3
. Tega
ponavadi ne počnemo.(42)
temveč
(42, )
. Če napišemo samo (42)
, je to samo 42 v
oklepaju.()
čisto lepa prazna terka.Funkcija len(s)
vrne dolžino s
.
s
je lahko karkoli, kar ima dolžino, npr. niz, seznam,
terka, množica, slovar.
To je ena najboljših stvari v Pythonu (Kotlin jo delno imitira, JavaScript pa je tu še ful bolj kul).
Levo od enačaja je lahko več spremenljivk, če je desno od njega kaj, kar ima natančno toliko elementov. Če bi imeli
= ("Ana", 65, "Ž")
student = [2, 3, 5]
prastevila = "abcdef" crke
lahko pišemo
= student
ime, teza, spol = prastevila
prvo, drugo, tretje = crke a, b, c, d, e, f
Seveda lahko tudi
= ("Ana", 65, "Ž") ime, teza, spol
vendar je to čudno, in celo
= "Ana", 65, "Ž" ime, teza, spol
saj terk ni potrebno zapirati v oklepaje, vendar je to nečitljivo.
Pač pa je zanimivo
= 1
x = 2
y = y, x x, y
x
2
y
1
Prirejanje x, y = y, x
je v bistvu isto kot
x, y = (y, x)
, vendar to vedno pišemo brez oklepajev, ker
je vsakemu jasno, da s tem menjamo vrednosti dveh spremenljivk. (Torej:
sintakse x, y = y, x
si niso izmislili za zamenjavo
vrednosti spremenljivk, temveč je to slučajni stranski učinek tega, da
terk ni potrebno zapirati v oklepaje in da lahko terke razpakiramo.)
Število imen levo od enačaja mora biti enako številu elementov stvari na desni. Lahko pa dodamo še spremenljivko, v katero gre višek. Označimo jo z zvezdico.
*ostala = [2, 3, 5, 7, 11, 13] prvo, drugo,
prvo
2
drugo
3
ostala
[5, 7, 11, 13]
Lahko celo
*ostala, zadnje = [2, 3, 5, 7, 11, 13] prvo, drugo,
ostala
[5, 7, 11]
Zvezdica nima zveze s kazalci, temveč prihaja iz drugega vica. To vlogo je prvič dobila ob klicih funkcij, ampak to bomo videli drugič.
Razpakiranje v elemente uporabljamo tudi zato, da navidez dosežemo,
da lahko funkcija vrača več stvari. Funkcija
splitext(fname)
, ki prejme ime datoteke ter vrne osnovni
del in končnico, bi lahko bila definirana tako:
def splitext(fname):
= fname.rfind(".")
dot_idx = fname[:dot_idx]
base = fname[dot_idx:]
ext return base, ext
in bi jo klicali z
= splitext("en_film.avi") osnova, koncnica
V resnici return
vrača return (base, ext)
,
samo da tu ne pišemo oklepajev, ob klicu pa to razpakiramo nazaj. Tako
sploh ni videti, da delamo s terkami, ampak je videti, kot da vračamo in
dobimo dve stvari. Se pravi, v počasnem posnetku se zgodi to:
def splitext(fname):
= fname.rfind(".")
dot_idx = fname[:dot_idx]
base = fname[dot_idx:]
ext = (base, ext)
t return t
in
= splitext("en_film.avi")
ime_konc = ime_konc[0]
osnova = ime_konc[1] koncnica
C-jevska zanka for
je samo bolj kompaktno zapisan
while
. Zanka
for(zacetek; pogoj; korak) { nekaj }
je isto kot
zacetek; while (pogoj) { nekaj; korak }
. C ima torej
dvakrat isto zanko.
Pythonova zanka for
pa je drugačna od
while
. Je taka kot zanke, ki se ponekod
for each
ali kaj podobnega. Zanka for
gre
vedno čez neko zbirko stvari, recimo čez seznam, terko, niz, množico,
slovar, vrstice datoteke, generator...
= ["Ana", "Berta", "Cilka", "Dani", "Ema"]
imena for ime in imena:
print(ime)
Ana
Berta
Cilka
Dani
Ema
Prosim, ne pišite
for i in range(len(imena)):
= imena[i]
ime print(ime)
for
Navadite se tako:
= [("Ana", 65), ("Berta", 80), ("Cilka", 78)]
studenti for ime, teza in studenti:
...
in celo
= [("Ana", (65, 175)), ("Berta", (80, 180)), ("Cilka", (78, 160))]
studenti for ime, (teza, visina) in studenti:
...
ne pa
for i in range(len(studenti)):
= studenti[i][0]
ime = studenti[i][1][0]
teza = studenti[i][1][1] visina
Ker očitno.
V obeh zankah, for
in while
lahko
uporabljamo break
in continue
.
Zanki v Pythonu lahko sledi else
. Kar zapišemo vanj, se
izvede, če zanka ni bila prekinjena z break
.
for x in stevila:
if x % 2 == 1:
print("Prvo liho število v seznamu je", x)
break
else:
print("Seznam ne vsebuje nobenega lihega števila")
Pozor: else
je poravnan s for
, ker se
nanaša na zanko, in ne z if
, kar bi bilo očitno narobe.
Če imamo
= ["Ana", "Berta", "Cilka", "Dani", "Ema"]
imena = [72, 80, 68, 72, 67] teze
ne pišemo
for i in range(len(imena)):
print(imena[i], teze[i])
temveč
for ime, teza in zip(imena, teze):
print(ime, teza)
Ana 74
Berta 82
Cilka 58
Dani 66
Ema 61
zip
vrne približno tole:
>>> zip(imena, teze)
[('Ana', 72), ('Berta', 80), ('Cilka', 68), ('Dani', 72), ('Ema', 67)]
Tako je bilo pred različico 3. V različici 3 vrne nekaj malo drugačnega, vendar se vede (skoraj) enako.
Funkciji zip
lahko damo poljubno število seznamov in
drugih stvari.
for ime, teza, crka, stevilka in zip(imena, teze, "abcdef", (1, 2, 3, 4, 5)):
...
Če argumenti nimajo enakega števila elementov, se zip
ustavi, ko je konec najkrajšega.
Pogosta rabe zanke for
v C-ish jezikih je
for(i = 0; i < 10; i++)
. V Pythonu je to
for i in range(10)
. Lahko si predstavljamo, da
range
vrne seznam števil. V Pythonu 2.7 bi to bilo tako
>>> range(5)
0, 1, 2, 3, 4]
[>>> range(7, 12)
7, 8, 9, 10, 11]
[>>> range(10, 25, 4)
10, 14, 18, 22]
[>>> range(20, 10, -2)
20, 18, 16, 14, 12] [
Spodnja meja je vključena, zgornja ni, zato da
range(a, b)
vrne b - a
elementov in zato
da
>>> range(5, 8) + range(8, 10)
5, 6, 7, 8, 9] [
Od Pythona 3 naprej, range
ne vrača seznamov, vendar vse
deluje zelo podobno, kot da bi jih. Kaj vrača, izvemo čez par
tednov.
Tole je namerno proti koncu, zato da se čimbolj navadite uporabljati
for
tako, kot je v Pythonu in podobnih jezikih treba.
imena
['Ana', 'Berta', 'Cilka', 'Dani', 'Ema']
0] imena[
'Ana'
1] imena[
'Berta'
Pogosto potrebujemo zadnji element. Ali predzadnjega. Ne pišemo
imena[len(imena) - 1]
ali
imena[len(imena) - 2]
temveč:
-1] imena[
'Ema'
-2] imena[
'Dani'
S s[i:j]
dobimo elemente seznama s
od
i
-tega do j
-tega. Z i
-tim, a brez
j
-tega. Torej j - i
elementov. Enako deluje
tudi s terkami in nizi (Python nima nobenih substr
in
podobnih funkcij).
= "Benjamin" s
2:5] s[
'nja'
Če izpustimo spodnjo mejo, gre od začetka, tako da lahko
s[:i]
preberemo kar "prvih i elementov".
3] s[:
'Ben'
Če izpustimo zgornjo mejo, gre do konca. V bistvu s[i:]
pomeni "brez prvih i".
3:] s[
'jamin'
Zdaj pa še negativni indeksi: s[:-i]
pomeni vse do
i-tega z desne, se pravi "brez zadnjih i".
-3] s[:
'Benja'
In s[-i:]
je potem "zadnjih i elementov".
-3:] s[
'min'
Jasno delajo tudi kombinacije.
1:-1] s[
'enjami'
In še korak.
1:10:2] s[
'ejmn'
In celo
-1] s[::
'nimajneB'
s[:]
vrne vse elemente od prvega do zadnjega, torej
kopijo. To je uporabno predvsem za sezname. Terke in nizi so
nespremenljivi, torej jih nima smisla kopirati.
Če je s
nek seznam, bomo z zip(s, s[1:])
dobili pare zaporednih elementov. Recimo, da nas zanima, ali števila v
nekem seznamu naraščajo.
= [2, 5, 8, 6, 10, 11, 15]
s
= True
narascajo for prej, potem in zip(s, s[1:]):
if potem <= prej:
= False narascajo
Še bolj pa mi je pravzaprav všeč
for prej, potem in zip(s, s[1:]):
if potem <= prej:
= False
narascajo break
else:
= True narascajo
imena
['Ana', 'Berta', 'Cilka', 'Dani', 'Ema']
2] = "Cecilija"
imena[-1] = "Emilija"
imena[ imena
['Ana', 'Berta', 'Cecilija', 'Dani', 'Emilija']
1:3] = ["Benjamin", "Boštjan", "Brane", "Cene"]
imena[ imena
['Ana',
'Benjamin',
'Boštjan',
'Brane',
'Cene',
'Brane',
'Cene',
'Dani',
'Emilija']
5:] = []
imena[ imena
['Ana', 'Benjamin', 'Cene', 'Brane', 'Cene']
Vse to je možno početi le s seznami, ne pa tudi z nizi in terkami, saj so nespremenljivi.
Glede seštevanja se seznami in terke vedejo enako kot nizi: operator
+
stakne dva seznama oz. terki.
"Ana" + "marija"
'Anamarija'
5, 7, 2] + [1, 8, 3] [
[5, 7, 2, 1, 8, 3]
S seštevanjem si pomagamo tudi, če želimo spremeniti element terke ali niza.
= "Be_jamin"
s = s[:2] + "n" + s[3:]
s s
'Benjamin'
Tudi množenje seznamov se vede enako kot množenje nizov.
"Ana" * 3
'AnaAnaAna'
5, 7, 2] * 3 [
[5, 7, 2, 5, 7, 2, 5, 7, 2]
Z operatorjem in
(in not in
) preverimo, ali
seznam vsebuje (in ne vsebuje) določenega elementa.
5 in [5, 7, 2]
True
5 not in [5, 7, 2]
False
Za nize operator in
preverja, ali vsebujejo podniz.
"min" in "Benjamin"
True
"min" not in "Benjamin"
False
imena
['Ana', 'Benjamin', 'Cene', 'Brane', 'Cene']
"Franz")
imena.append( imena
['Ana', 'Benjamin', 'Cene', 'Brane', 'Cene', 'Franz']