Loeng 2: Omistusoperaator, muutuja, sõne indekseerimine, sõne meetodid, sõne vorming, f-string, r-string, andemtüübi objekti meetod, list, korteež, hulk, kujutus, lausend del.

Viimati uuendatud 8.09.2025.

---

Koodinäited

1  Omistusoperaator = ja Pythoni (globaalsed) muutujad

1.1  Muutuja defineerimine ja sellele väärtuse omistamine

Muutuja on nimega varustatud koht arvuti mälus andmetüüpide väärtuste salvestamiseks. Muutuja viitab arvuti mälus andmetüübi andmetele/väärtusele. Muutuja kasutamine programmis teeb võimalikuks andmete meeleshoidmise programmi töötamise jooksul. Muutujale saab väärtusena omistada erinevate andmetüüpide andmeid. Muutuja on andmete kohahoidija. Python loob muutuja selle esmasel mainimisel ehk deklareerimisel. Interpretaator loeb ja interpreteerib koodi üldjuhul vasakult paremale ja ülevalt alla.

Muutujale saab valida nime meelevaldselt (PEP 8 soovitus: väikeste tähtedega, inglise keeles, mittelühendatud, sõnad eralda kasutades _).

muutuja = 'Python'
muutuja

'Python'

x = 55
y = 88
x + y

143

z = x + y
z

143

minu_muutuja = 'Python' + ' on madu.'
print(minu_muutuja)

Python on madu.

Python lubab ühes reas omistada väärtusi mitmele muutujale korraga:

a, b, c = 5, 6, 7  # NB! Võrdne arv muutuja nimesid ja väärtusi.
print(a)
print(b)
print(c)

5
6
7

Muutujale saab omistada teise muutuja. Siin omistame kahele muutujale need muutujad endid aga tagurpidises järjekorras:

a, b = b, a
print(a)
print(b)

6
5

1.2  Muutujale teise muutuja omistamisest

Pythonis muutujatega töötades tasub meeles pidada järgmiseid nüansse:

1. Kui muutujad viitavad samale andmetüübi esindajale võib Pythoni interpretaator, mälu kokkuhoiu (ja muudel põhjustel), siduda need muutujad sama mälukoha aadressiga. Allolevas näites on kasutatud täisarvud esindatud ainult üks kord arvuti mälus. Lisaks on siin kasutatud Pythoni sisseehitatud funktsiooni id salvestatud andmete mälukoha aadressi kuvamiseks. Funktsioon id näitab kuhu omistusoperaator viitab arvuti mälus.

a = 13  # Viitab arvule 13 arvuti mälus.
b = 13  # Viitab samale arvule 13 arvuti mälus.

print(a, b)
print(id(a), id(b), id(a) - id(b))  # Sama aadress.

13 13
4342683808 4342683808 0

2. Kui muutuja väärtuseks valida teine muutuja, siis seotakse teine muutuja esimese muutuja andmete mälukohaga.

a = 14
b = a  # Viide andmetele, numbrile 14.

print(a, b)
print(id(a), id(b), id(a) - id(b))  # Sama aadress.

14 14
4342683840 4342683840 0

Märkus: Siin näidatud muutujate käitumine võib tekitada algajas programmeerijas segadust. Kui tekitada olukord kus ühe muutujaga seotud mälus olev andmetüübi väärtus muudetakse (in-place) siis see võib mõjutada sellega seotud muid muutujaid. Selle dokumendi Lõigus 3.1.2 demostreerime kuidas taoline omistusoperaatori käitumine võib tekitada potensiaalseid probleeme.

2  Sõne (string)

Sõne ehk tekst on üks Pythoni sisseehitatud andmetüüpidest, vt. eelmine loeng.

2.1  Sõne indekseerimine (string indexing)

Sõne tähemärgid või sümbolid (tähed) on indekseeritud. Indekseerimine algab 0-st. Indekseerimist saame teostada ka tagant ettepoole kasutades negatiivseid indekseid, nagu on näidatud siin tabelis:

P	y	t	h	o	n
0	1	2	3	4	5
-6	-5	-4	-3	-2	-1

Sümbolitele viitamiseks kasutame kandilisi sulge.

'Python'[2]  # Tähemärk indeksiga 2.

't'

'Python'[-4]

't'

2.2  Sõne lõikumine (string slicing)

Sõnega opereerimine (string slicing), sõne lõikudeks jagamine:

a = "Juulius Tipikas on hingaja."

print(a[:])          # Kõik sümbolid.
print(a[3:])         # Alustame indeksist 3 (3 kaasaarvatud).
print(a[-3:])        # Alustame indeksist -3 (-3 kaasaarvatud).
print(a[:3])         # Kuni indeksini 3 (3 pole kaasaarvatud) .
print(a[1:5])        # Vahemik/lõik, alustame 1ga lõpetame 5ga (5 pole kaasaarvatud).
print(a[5:15:2])     # [algus:lõpp(pole kaasatud):samm]
print(a[-1:-15:-1])  # Tagurpidi sammuga 1.
print(a[::-1])       # Kõik sümbolid, tagurpidi.

Juulius Tipikas on hingaja.
lius Tipikas on hingaja.
ja.
Juu
uuli
u iia
.ajagnih no sa
.ajagnih no sakipiT suiluuJ

Kasutamise näide:

uus_a = a[:19] + 'maskott.'
print(uus_a)

Juulius Tipikas on maskott.

Sõne on muutumatu (immutable) andmetüüp, arvuti mällu salvestatud sõne tähemärke pole võimalik muuta ega kustutada (kustutamine on seletatud selle dokumendi Lõigus 3.1.1). Konkatenatsiooni ehk operaatori + rakendamine sõnedele ei ole olemasolevate tähemärkide muutmine.

muut = 'Python'
muut[0] = 'R'

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[13], line 2
      1 muut = 'Python'
----> 2 muut[0] = 'R'

TypeError: 'str' object does not support item assignment

Kui sul on vaja tähte (või tähti) ikkagist muuta siis võid käituda järgmiselt:

'R' + muut[1:]

'Rython'

2.3  Sõne ja spetsiaalsed sümbolid (escape characters)

Kaldkriips (escape character, escape tag, exit tag) \ lubab sisestada spetsiaalse tähendusega sümboleid mida interpreteeritakse tekstist ja/või Pythoni süntaksist erinevalt. Valik spetsiaalse tähendusega sümbolid:

Sümbol	Tähendus
\n	uus rida
\t	taane (tabulatsioon)
\r	rea algusesse
\\	kaldkriips
\'	ülakoma (kui muud moodi ei saa)

print('Python\'Python')  # Vt. ja vrd. eelmine nädal.

Python'Python

print('Juuliuse \nisa on \n\tarst ja ema on\nnahkhiir.')

Juuliuse 
isa on 
	arst ja ema on
nahkhiir.

2.4  Sõne meetodid

Sõnele ehk tekstile (tähemärkide kogum) kui Pythoni andmetüübi objektile on võimalik rakendada sellega kaasaskäivaid meetodeid. Andmetüübi objekt ja selle meetodid on defineeritud Pythoni klassi abil. Klassi mõistet arutame tulevastes loengutes. Joonis 1 kujutab visuaalselt Pythoni programmi, selle osasid ja programmeerimist Pythonis, leia jooniselt klassid ja objekti meetodid.

Joonis 1. Programmeerimine Pythonis, programm ja selle osad.

Meetodit rakendame kasutades .. Olemasolevate meetodite järele vaatamiseks vajuta Tab peale punkti sisestamist, meetodi dokumentatsiooni ja abiinfo lugemiseks vajuta Shift + Tab. Meetodi nime autocompliitimiseks vajuta selle sisestamisel Tab.

Valik sõne meetodeid ja nenede kasutamine:

"Juulius Tipikas on hingaja.".count('u')

3

a = "Juulius Tipikas on hingaja."
a.count("p")

1

a.upper()

'JUULIUS TIPIKAS ON HINGAJA.'

a.lower()

'juulius tipikas on hingaja.'

a.split()

['Juulius', 'Tipikas', 'on', 'hingaja.']

a.replace('Juulius', 'Juulia')

'Juulia Tipikas on hingaja.'

b = 'kool'
b.capitalize()

'Kool'

a.index('Tip')

8

Kõigi objektiga seotud meetodite konsoolis järelvaatamiseks kasuta sisseehitatud funktsiooni dir.

#dir(a)  # Interpreteeri iseseisvalt, pikk väljund.

2.5  Sõne vormindamine (string formatting)

Lisainfo: https://docs.python.org/3/library/string.html#custom-string-formatting

2.5.1  Sõne meetod format

Meetod format aitab sisestada ja vormindada muutujate väärtusi sõnedesse. Meetod on põhjalikumalt kirjeldatud siin: PEP 3101. Valik näiteid:

nimi = 'Juulius'
tiitel = 'tudeng'
e = '{} on {} ning ta omab {:.3f} eurot.'.format(nimi, tiitel, 2.18836)  # Kolme komakoha täpsusega. 
print(e)

Juulius on tudeng ning ta omab 2.188 eurot.

e = '{1} on {0} ning ta omab {2:.3e} eurot.'.format(nimi, tiitel, 2.18836)
print(e)

tudeng on Juulius ning ta omab 2.188e+00 eurot.

e = '{} on {:*^10} ning ta omab {:.3g} eurot.'.format(nimi, tiitel, 2.188364*3.234)
print(e)

Juulius on **tudeng** ning ta omab 7.08 eurot.

e = '{1} on {0:*>10} ning ta omab {2:.3g} eurot.'.format(nimi, tiitel, 2.188364*3.234)
print(e)

tudeng on ***Juulius ning ta omab 7.08 eurot.

e = '{1} on {0:>10} ning ta omab {2:.3g} eurot.'.format(nimi, tiitel, 2.188364*3.234)
print(e)

tudeng on    Juulius ning ta omab 7.08 eurot.

e = '{nimi} on {tiitel}.'.format(nimi='Juulius', tiitel='sepp')
print(e)

Juulius on sepp.

e = '{tiitel} on {nimi}.'.format(nimi='Juulius', tiitel='sepp')
print(e)

sepp on Juulius.

points = 19
total = 22
suhe = points / total
print(suhe)

'Vastav protsent on {:.2%}'.format(suhe)  # Esitamine protsendina.

0.8636363636363636

'Vastav protsent on 86.36%'

2.5.2  f-string (fast string) ja r-string (raw string)

Ülalmainitud toiminguid saab teostada mugavamalt ja kiiremini kasutades nt. f-stringi:

nimi = 'Juulius'
tiitel = 'tudeng'
a = f'{nimi} on {tiitel} ning ta omab {2.188} eurot.'  # Ilma f ei tööta.
print(a)

Juulius on tudeng ning ta omab 2.188 eurot.

print(f'''{nimi}
on {tiitel}.''')

Juulius
on tudeng.

f-stringi poolt edastatud muutujaid või muid andmeid saab vormidada sarnaselt tavalise sõnega:

e = 1.23456
lause = f'Number on {e:.2f}'  # Kahe komakoha täpsusega.
print(lause)

Number on 1.23

points = 19
total = 22
suhe = points / total
print(suhe)

f'Vastav protsent on {suhe:.2%}'  # Esitamine protsendina.

0.8636363636363636

'Vastav protsent on 86.36%'

r-string ignoreerib sõnes olevate escape tag'de spetsiaalseid tähendusi:

b = r"C:\Home\Documents\#\n"
print(b)

C:\Home\Documents\#\n

a = r"C:\Home\Docum{}ents\#\n".format(' BUG ')
print(a)

C:\Home\Docum BUG ents\#\n

3  Sisseehitatud andmehulgad ehk mitme väärtusega andmetüübid

Tihti on vaja omistada muutujale mitu väärtust korraga või on meil soov salvestada mitu väärtust taaskasutamise eesmärgil. Pythoni andmetüübid mis toetavad sellist võimalust on järgmised: list, korteež, hulk ja sõnaraamat.

Allolevatel andmetüüpide objektidel on sarnaselt sõnele olemas meetodid. Kasutades Pythoni dokumentatsiooni ja abiinfot uuri iseseisvalt mis meetodid neil eksisteerivad ja kuidas need töötavad.

3.1  Loend, järjend ehk list (list)

List on muudetav (mutable) andmetüüp st., selle liikmeid saab muuta neid saab lisada ja/või kustutada peale listi loomist. Listi elemendid, milleks saavad olla kõik muud Pythoni andmetüübid, eraldatakse komaga ja need paigutatakse kandiliste sulgude sisse:

lst = [1, 2, 3, 4, 'stop']  # NB! Ära nimeta listi kunagi 'list'ks.
lst

[1, 2, 3, 4, 'stop']

Listi elemendid on indekseeritud sarnaselt sõnele:

lst[:3]

[1, 2, 3]

3.1.1  Lausend del

Lausend del kustutab kõiki eelnevalt loodud Pythoni objekte ja mitme elemendiga muudetavate (mutable) andmetüüpide objektide elemente. Siin kasutame lausendit del loendi ja/või selle elementide kustutamiseks arvuti mälust. See lausend lubab kustutada ka listi mitut elementi korraga, kasuta lõikudeks jagamise süntaksit:

del lst[:3]  # See rida kustutas andmed.
lst  # Kontrollime mis jäi järele.

[4, 'stop']

del lst
lst  # Sellele muutuja nimele ei vasta midagi.

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In[43], line 2
      1 del lst
----> 2 lst

NameError: name 'lst' is not defined

Tühi list on võimalik defineerida järgmiselt. Listil on meetodid append, insert ja extend mille abil saame sellele objekte lisada.

lst = []  # Tühi list
lst.append(1)  # Lisan listile numbri 1, tagantpoolt.
lst

[1]

3.1.2  Meetod append on nn. in place meetod

Listi meetod append muudab listi arvuti mälus nn. kohapeal (in place). Lõigus 1.2 mainisime, et olukorras kus üks muutuja viitab teisele võib see teatud olukordades tekitada segadust. Püüame seda siin demonstreerida:

a = [2, 3, 4]
b = a  # viide listi objektile mälus
print(b)  # Muutujale b vastab list [2 ,3, 4]
print(id(a), id(b), id(a) - id(b))  # Muutujad a ja b viitavad samale kohale mälus.

a.append(5)  # Muudab listi mälus (in place) seda muutes.

print(a, b)  # Muutuja b viitab endiselt mälus olevale listile.
print(id(a), id(b), id(a) - id(b))  # Muutujad a ja b viitavad samale kohale mälus.

[2, 3, 4]
4635709504 4635709504 0
[2, 3, 4, 5] [2, 3, 4, 5]
4635709504 4635709504 0

Rea 6 kood a.append(5) muudab ainult listi a lisades sellele arvu 5. Miks aga muutus ka listi b sisu, vt. rida 8. See juhtus kuna nii muutuja a kui ka b viitasid samadele andmetele arvuti mälus.

3.2  Korteež või ennik (tuple)

Korteež on muutumatu (immutable) andmetüüp st., et defineeritud korteeži elemete ei saa muuta ega kustutada nii nagu seda saab teha listi elementidega. Korteeži elemendid paigutatakse tavaliste sulgude sisse ja neid eristatakse komaga:

tpl = (1, 2, 3, 'stop')  # Ära kasuta nime 'tuple'.
tpl

(1, 2, 3, 'stop')

Korteež on on järjestatud ja selle elemendid on indekseeritud sarnaselt listile ja sõnele:

tpl[3]

'stop'

NB! Ühe elemendiga korteeži defineerimine:

tpl = (22, )  # Singleton tuple syntax.
tpl

(22,)

tpl = 23,  # Singleton tuple syntax.
tpl

(23,)

Tühi korteež on võimalik defineerida järgmiselt.

tpl = ()
tpl

()

Märkus: Enniku loomisel pole tegelikult sulge vaja. Koodi kirjutamisel püüame sellist kirjapilti vältida (v.a. funktsiooni defineerimisel, peale lausendit return). Tulevastes loengutes laiendame seda teemat.

tpl = 1, 2, 3
tpl

(1, 2, 3)

tpl = 1,  # Singleton tuple syntax.
tpl

(1,)

3.3  Hulk (set)

Hulk on järjestamata unikaalseid elemente sisaldav andmetüüp. Hulk on muudetav (mutable) andmetüüp. Unikaalsus tähendab, et korduvad liikmed ignoreeritakse. Hulga elemendid paigutame loogelistesse sulgudesse ja eristame neid komaga:

st = {1, 'stop', 2, 3, 3}  # Ära kasuta nime 'set'.
st

{1, 2, 3, 'stop'}

Järjestamatus tähendab, et indekseerimist ei teostata ning puuduvad indekseerimisega seotud meetodid.

st[1]

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[54], line 1
----> 1 st[1]

TypeError: 'set' object is not subscriptable

Hulga elementideks saavad olla ainult muutumatute (immutable) andmetüüpide objektid. Hulka pole võimalik pesastada hulga sisse, vt. eelmine lause.

{1, [7, 7], 2, 3, 3}  # List on muudetav andmetüüp.

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[55], line 1
----> 1 {1, [7, 7], 2, 3, 3}

TypeError: unhashable type: 'list'

{1, {7, 7}, 2, 3, 3}  # Hulk on muudetav andmetüüp.

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[56], line 1
----> 1 {1, {7, 7}, 2, 3, 3}

TypeError: unhashable type: 'set'

Tühi hulk defineeritakse järgmiselt (vt. vr. järgmine lõik). Hulgal on meetodid add ja update mille abil saame sellele objekte järjestamata moel lisada.

st2 = set()  # set on sisseehitatud (konstruktor) funktsioon.
st2.add(1)  # Meetod mis lisab elemente, muudab olemasolevat hulka.
st2

{1}

Siit selgub ka põhjus miks hulka pole mõtekas nimetada muutujanimega set. Seda tehes kirjutad sisseehitatud funktsiooni set ümber hulgaks. Kas Pythonis eksisteerivad (konstruktor) funktsiooonid nimedega list ja tuple?

3.4  Kujutus või sõnaraamat (dictionary)

Sõnaraamat on andmetüüp mis sisaldab ja seob võtmesõnu ja neile vastavate väärtuste paare. Võtmesõna abil viitame kindlale väärtusele. Võtmesõna peab olema muutumatu (immutable) objekt. Väärtus saab olla suvaline andmetüüp. Sõnaraamat on muudetav (mutable) andmetüüp.

Sõnaraamatut saab ajaloolistel põhjustel deklareerida süntaktiliselt kolmel erineval viisil:

dic = {'key1':'value1', 'key2':'value2'}  # Ära kasuta nime 'dict'.
print(dic)
print(dic['key1'])  # Viitame võtmesõnaga.

{'key1': 'value1', 'key2': 'value2'}
value1

dic2 = dict(key1='value1', key2='value2')  # dict on sisseehitatud (konstruktor) funktsioon.
print(dic2)
print(dic2['key1'])

{'key1': 'value1', 'key2': 'value2'}
value1

dic3 = dict([('key1', 'value1'), ('key2', 'value2')])  # Listi asemel sobib ka ennik, hulk.
print(dic3)
print(dic3['key1'])

{'key1': 'value1', 'key2': 'value2'}
value1

Kasutamise näiteid:

car = {"brand": "Ford",
       "model": "Mustang",
       "year": 1964
      }

print(car)
print(car['model'])

{'brand': 'Ford', 'model': 'Mustang', 'year': 1964}
Mustang

dic2 = {1:'value1', 2:'value2', 3:'value3'}
print(dic2)
print(dic2[1])

{1: 'value1', 2: 'value2', 3: 'value3'}
value1

dic3 = {1:66, 5:77, 3:88}
print(dic3)
print(dic3[5])

{1: 66, 5: 77, 3: 88}
77

dic5 = {(0, 1):'value1', (1, 1):'value2'}
print(dic5)
print(dic5[(0, 1)])  # Korteež on muutumatu.

{(0, 1): 'value1', (1, 1): 'value2'}
value1

Lisame uue võtmesõna ja väärtuse paari olemasolevale kujutusele car:

car['color'] = 'red'
print(car)

{'brand': 'Ford', 'model': 'Mustang', 'year': 1964, 'color': 'red'}

Tühja kujutuse defineerime järgmiselt. Uusi andmeid saame lisada kasutades meetodit update.

dic6 = {}
dic6.update({'key':'value'})  # Lisame uue paari.
dic6.update(car)  # Lisame terve kujutuse.
dic6

{'key': 'value',
 'brand': 'Ford',
 'model': 'Mustang',
 'year': 1964,
 'color': 'red'}

3.5  Omistusoperaator ja mitme elemendiga andmetüübid

Operaator = oskab liste, korteeže, hulki ja sõnaraamatuid lahti pakkida või nende sisse näha. Teiste sõnadega operaator = näeb eelmainitud andmetüüpide sisse, näeb nende sisu. See võimaldab järgmist käitumist:

lst = [55, 66, 77]
v1, v2, v3 = lst
print(v1, v2, v3)

55 66 77

tup = (55, 66, 77)
v1, v2, v3 = tup
print(v1, v2, v3)

55 66 77

st = {556, 266, 177}  # Hulga elemendid järjestamata.
v1, v2, v3 = st
print(v1, v2, v3)

177 266 556

dic = {1:'value1', 2:'value2'}
k1, k2 = dic           # Võtmesõnad.
v1, v2 = dic.values()  # Meetod tagastab väärtused.
print(k1, v1)
print(k2, v2)

kv1, kv2 = dic.items()  # Meetod tagastab nii võtmed kui ka väärtused.
print(kv1, kv2)

1 value1
2 value2
(1, 'value1') (2, 'value2')

☻   ☻   ☻