Loeng 2: Omistusoperaator, muutuja, sõne indekseerimine, sõne meetodid, sõne vorming, f-string, r-string, list, korteez, hulk, kujutus, lausend del.¶

Viimati uuendatud 7.09.2024.

Koodinäited¶

Omistusoperaator = ja muutujad¶

Muutuja on nimega varustatud koht arvuti mälus väärtuste salvestamiseks. 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. Muutujale saab valida nime meelevaldselt (PEP 8 soovitus: väikeste tähtedega, inglise keeles, mittelühendatud, sõnad eralda kasutades _).

In [1]:
muutuja = 'Python'
muutuja
Out[1]:
'Python'
In [2]:
x = 55
y = 88
x + y
Out[2]:
143
In [3]:
z = x + y
z
Out[3]:
143
In [4]:
minu_muutuja = 'Python' + ' on madu.'
print(minu_muutuja)

Python on madu.

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

In [5]:
a, b, c = 5, 6, 7
print(a)
print(b)
print(c)

5
6
7
In [6]:
a, b = b, a
print(a)
print(b)

6
5

Sõne indekseerimine (string indexing)¶

Sõne ehk tekst on üks Pythoni sisseehitatud andmetüüpidest. Sõne sümbolid (tähed) on indekseeritud. Indekseerimine algab 0-st. Sümbolitele viitamiseks kasutame kandilisi sulge.

P y t h o n
0 1 2 3 4 5
-6 -5 -4 -3 -2 -1
In [7]:
'Python'[2]
Out[7]:
't'
In [8]:
'Python'[-4]
Out[8]:
't'

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

In [9]:
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
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:

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

Juulius Tipikas on maskott.

Sõne on muutumatu (immutable) andmetüüp, loodud sõne sümboleid pole võimalik muuta:

In [11]:
muut = 'Python'
muut[0] = 'R'

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[11], 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:

In [12]:
'R' + muut[1:]
Out[12]:
'Rython'

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

Kaldkriips (escape tag) \ lubab sisestada sümboleid.

Spetsiaalse tähendusega süblolid:

Sümbol Tähendus
\n uus rida
\t taane (tabulatsioon)
\r rea algusesse
\\ kaldkriips
In [13]:
print('Python\'Python')  # Vt. eelmine nädal.

Python'Python
In [14]:
print('Juuliuse \nisa on \n\tarst ja ema on\nnahkhiir.')

Juuliuse 
isa on 
	arst ja ema on
nahkhiir.

Sõne meetodid¶

Sõnele (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 programmeerimist Pythonis, leia jooniselt objekti meetodid.

No description has been provided for this image
Joonis 1. Programmeerimine Pythonis.

Meetodit rakendame kasutades .. Olemasolevate meetodite järelevaatamiseks vajuta Tab, meetodi dokumentatsiooni ja abiinfo lugemiseks vajuta Shift + Tab. Meetodi nime autocompliitimiseks vajuta Tab.

In [15]:
"Juulius Tipikas on hingaja.".count('u')
Out[15]:
3
In [16]:
a = "Juulius Tipikas on hingaja."
a.count("p")
Out[16]:
1
In [17]:
a.upper()
Out[17]:
'JUULIUS TIPIKAS ON HINGAJA.'
In [18]:
a.lower()
Out[18]:
'juulius tipikas on hingaja.'
In [19]:
a.split()
Out[19]:
['Juulius', 'Tipikas', 'on', 'hingaja.']
In [20]:
a.replace('Juulius', 'Juulia')
Out[20]:
'Juulia Tipikas on hingaja.'
In [21]:
b = 'kool'
b.capitalize()
Out[21]:
'Kool'
In [22]:
a.index('Tip')
Out[22]:
8

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

In [23]:
#dir(a)  # Interpretreeri iseseisvalt.

Sõne vormindamine (string formatting), muutujad, format meetod¶

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

In [24]:
nimi = 'Juulius'
tiitel = 'tudeng'
e = 'Nimi on {} ja ta on {} ning ta omab {:.3f} eurot.'.format(nimi, tiitel, 2.18836)
print(e)

Nimi on Juulius ja ta on tudeng ning ta omab 2.188 eurot.
In [25]:
e = 'Nimi on {1} ja ta on {0} ning ta omab {2:.3e} eurot.'.format(nimi, tiitel, 2.18836)
print(e)

Nimi on tudeng ja ta on Juulius ning ta omab 2.188e+00 eurot.
In [26]:
e = 'Nimi on {} ja ta on {:*^10} ning ta omab {:.3g} eurot.'.format(nimi, tiitel, 2.188364*3.234)
print(e)

Nimi on Juulius ja ta on **tudeng** ning ta omab 7.08 eurot.
In [27]:
e = 'Nimi on {1} ja ta on {0:*>10} ning ta omab {2:.3g} eurot.'.format(nimi, tiitel, 2.188364*3.234)
print(e)

Nimi on tudeng ja ta on ***Juulius ning ta omab 7.08 eurot.
In [28]:
e = 'Nimi on {1} ja ta on {0:>10} ning ta omab {2:.3g} eurot.'.format(nimi, tiitel, 2.188364*3.234)
print(e)

Nimi on tudeng ja ta on    Juulius ning ta omab 7.08 eurot.
In [29]:
e = 'Nimi on {nimi} ja ta on {tiitel}.'.format(nimi='Juulius', tiitel='sepp')
print(e)

Nimi on Juulius ja ta on sepp.
In [30]:
e = 'Nimi on {tiitel} ja ta on {nimi}.'.format(nimi='Juulius', tiitel='sepp')
print(e)

Nimi on sepp ja ta on Juulius.
In [31]:
points = 19
total = 22
suhe = points/total
print(suhe)
'Vastus: {:.2%}'.format(suhe)

0.8636363636363636
Out[31]:
'Vastus: 86.36%'

f-strings (fast string), r-strings (raw string)¶

Ülalmanitud toiminguid saab teostada mugavamalt ja kiiremini.

In [32]:
nimi = 'Juulius'
tiitel = 'tudeng'
a = f'Nimi on {nimi} ja ta on {tiitel} ning ta omab {2.188} eurot.'  # Ilma f ei tööta.
print(a)

Nimi on Juulius ja ta on tudeng ning ta omab 2.188 eurot.
In [33]:
print(f'''Nimi on {nimi}
ja ta on {tiitel}.''')

Nimi on Juulius
ja ta on tudeng.

r-string ignoreerib sõnes olevate escape tagide tähendusi:

In [34]:
b = r"C:\Home\Documents\#\n"
print(b)

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

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

Valik andmehulki ehk mitme väärtusega sisseehitatud andmetüüpe:¶

Allolevatel andmetüüpide objektidel on sarnaselt sõnele olemas meetodid . Uuri iseseisvalt mis meetodid eksisteerivad ja kuidas need töötavad.

Loend, järjend või list (list)¶

Tihti on vaja omistada muutujale mitu väärtust korraga või on meil soov salvestatada mitu väärtust taaskasutamise eesmärgil. Andmetüübid mis toetavad sellist võimalust on järgmised: list, korteez, hulk ja sõnaraamat. Listi elemendid eraldatakse komaga ja need paigutatakse kandiliste sulgude sisse.

In [36]:
lst = [1, 2, 3, 4, 'stop']  # NB! Ära nim. listi 'list'-ks.
lst
Out[36]:
[1, 2, 3, 4, 'stop']
In [37]:
lst[:3]
Out[37]:
[1, 2, 3]

Lausendit del kasutame loendi ja muude andmetüübi objektide kustutamiseks. See lausend lubab kustutada ka listi elemendi või mitu elemeti korraga.

In [38]:
del lst[:3]
lst
Out[38]:
[4, 'stop']
In [39]:
del lst
lst

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

NameError: name 'lst' is not defined

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

In [40]:
lst = []  # Tühi list
lst.append(1)  # Lisan sellele numbri 1.
lst
Out[40]:
[1]

Korteez või ennik (tuple)¶

Korteez on muutumatu (immutable) andmetüüp st., et defineeritud korteezi elemete ei saa muuta ega kustutada nii nagu seda saab teha listis. Korteezi elemendid paigutatakse sulgude sisse:

In [41]:
tpl = (1, 2, 3, 'stop')  # Ära kasuta nime 'tuple'.
tpl
Out[41]:
(1, 2, 3, 'stop')

NB!: Ühe elemendiga korteezi defineerimine:

In [42]:
tpl = (22, )
tpl
Out[42]:
(22,)
In [43]:
tpl = 23,
tpl
Out[43]:
(23,)

Tühja korteezi on võimalik defineerida järgmiselt.

In [44]:
tpl = ()
tpl
Out[44]:
()

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.

In [45]:
tpl = 1, 2, 3
tpl
Out[45]:
(1, 2, 3)
In [46]:
tpl = 1,
tpl
Out[46]:
(1,)

Hulk (set)¶

Hulk on järjestamata unikaalseid elemente sisaldav andmetüüp. Hulga elementideks saavad olla ainult muutumatud (immutable) objektid. Hulka pole võimalik pesastada hulga sisse, vt. eelmine lause. Unikaalsus tähendab, et korduvad liikmed ignoreeritakse. Hulga elemedid paigutame loogelistesse sulgudesse:

In [47]:
st = {1, 22, 3, 4, 4, 'stop'}  # Ära kasuta nime 'set'.
st
Out[47]:
{1, 22, 3, 4, 'stop'}

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

In [48]:
st[1]

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

TypeError: 'set' object is not subscriptable

Tühja hulga defineerime järgmiselt (vt. vr. järgmine lõik). Hulgal on meetodid add ja update mille abil saame sellele objekte lisada.

In [49]:
st2 = set()  # set on sisseehitatuud funktsioon.
st2.add(1)
st2
Out[49]:
{1}

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.

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

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

{'key1': 'value1', 'key2': 'value2'}
value1
In [51]:
dic2 = dict(key1='value1', key2='value2')  # dict on sisseehitatud funktsioon.
print(dic2)
print(dic2['key1'])

{'key1': 'value1', 'key2': 'value2'}
value1
In [52]:
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:

In [53]:
car = {
    "brand": "Ford",
    "model": "Mustang",
    "year": 1964
}

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

{'brand': 'Ford', 'model': 'Mustang', 'year': 1964}
Mustang
In [54]:
dic2 = {1:'value1', 2:'value2', 3:'value3'}
print(dic2)
print(dic2[1])

{1: 'value1', 2: 'value2', 3: 'value3'}
value1
In [55]:
dic3 = {1:66, 5:77, 3:88}
print(dic3)
print(dic3[5])

{1: 66, 5: 77, 3: 88}
77
In [56]:
dic5 = {(0, 1):'value1', (1, 1):'value2'}
print(dic5)
print(dic5[(0, 1)])  # Korteez on muutumatu.

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

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

In [57]:
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.

In [58]:
dic6 = {}
dic6.update({'key':'value'})  # Lisame uue paari.
dic6.update(car)  # Lisame terve kujutuse.
dic6
Out[58]:
{'key': 'value',
 'brand': 'Ford',
 'model': 'Mustang',
 'year': 1964,
 'color': 'red'}

Omistusoperaator ja mitme elemendiga andmetüübid¶

Operaator = oskab liste, korteeze, hulki ja sõnaraamatuid lahti pakkida. Teiste sõnadega operaator = näeb eelmainitud andmetüüpide sisse või nende sisu.

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

55 66 77
In [60]:
tup = (55, 66, 77)
v1, v2, v3 = tup
print(v1, v2, v3)

55 66 77
In [61]:
st = {556, 266, 177}  # Elemendid järjestamata.
v1, v2, v3 = st
print(v1, v2, v3)

177 266 556
In [62]:
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 võtmed ja väärtused.
print(kv1, kv2)

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

















☻   ☻   ☻