Paralleelne muutujatele väärtusete omistamine¶
Meeldetuletuseks, omistusoperaator = omitab väärtusi samaaegselt mitmele muutujale järgmiselt:
a, b, c = 1, 2, 3 # Võrdne arv muutujaid ja väärtusi.
print(a, b, c)
1 2 3
Omistusoperaator = pakib lahti iteraatortoega andmetüüpide objekte:
a, b, c = (1, 2, 3) # Proovi listiga, hulgaga, jne.
print(a, b, c)
1 2 3
my_dict = {'üks': 1, 'kaks': 2, 'kolm': 3}
a, b, c = my_dict # Proovi ka sõnastiku meetodeid items ja values.
print(a, b, c)
üks kaks kolm
Meie jaoks uus käitumine. Python toetab nii vasakul kui ka paremal pool omistusoperaatorit oleva iteraatortorga objekti lahtipakkimist.
[a, b, c] = 1, 2, 3 # Mõlemapoolne lahtipakkimine toetatud.
print(a, b, c)
1 2 3
(a, b, c) = [1, 2, 3] # Mõlemapoolne lahtipakkimine toetatud.
print(a, b, c)
1 2 3
a, b, c = range(3) # Vahemik range on iteraatortoega.
print(a, b, c)
0 1 2
a, b, c = 'ABC'
print(a, b, c)
A B C
Lahtipakkimise ja kokkupakkimise operaatorid * ja **¶
Kasutame selleks, et laiendada operaatorite = ja in kasutusega seotud võimalusi. Allpool näeme ka selle operaatori rakendust funktsioonide argumentide sulgudes.
Operaator *¶
Operaator * on iseenda pöördoperaator. Operaatoriga saame väärtusi ka kokku pakkida lisaks lahtipakkimisele:
*a, = 1, 2 # Kokkupakkimine, ühe elemendiga ennik (singleton tuple syntax).
a
[1, 2]
a = [1, 2, 3] # Proovi ka teisi andmetüüpe.
print(*a) # Lahtipakkimine.
print(*[4, 5]) # Lahtipakkimine.
1 2 3 4 5
a, *b = 1, 2, 3 # Kokkupakkimine muutujasse b.
print(a, b)
1 [2, 3]
*a, b = 1, 2, 3 # Kokkupakkimine muutujasse a.
print(a, b)
[1, 2] 3
*a, b, c = 1, 2, 3
print(a, b, c)
[1] 2 3
*r, = range(10) # Vahemiku kokkupakkimine muutujasse r.
r
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[*'Python'] # Lahtipakkimine loendisse.
['P', 'y', 't', 'h', 'o', 'n']
{*'Python'} # Lahtipakkimine hulka.
{'P', 'h', 'n', 'o', 't', 'y'}
Kasutamise näiteid:
seq = [1, 2, 3, 4, 5]
esimene, *sisu, viimane = seq
sisu # Esimene ja viimane element eemaldatud.
[2, 3, 4]
a, b, *_ = 1, 2, 0, 0, 0, 0 # Muutujanimega _ vihjame, et ei soovi seda edaspidi kasutada.
print(a, b)
_
1 2
[0, 0, 0, 0]
def powers(num):
return num, num**2, num**3
*_, cube = powers(2)
cube # Oleme ainult kuubist huvitatud.
8
for esimene, *muud in [(1, 2, 3), (4, 5, 6, 7)]:
print("Esimene:", esimene)
print("Muud:", muud)
Esimene: 1 Muud: [2, 3] Esimene: 4 Muud: [5, 6, 7]
Jadade defineerimine:
my_tuple = (1, 2)
my_list = [True, False, None]
my_set = {1, 2}
my_str = "12"
[*my_set, *my_list, *my_tuple, *range(3), *my_str] # Vt. ka all.
[1, 2, True, False, None, 1, 2, 0, 1, 2, '1', '2']
Sama tulemus kasutades loendite konkatenatsiooni:
list(my_set) + my_list + list(my_tuple) + list(range(1, 4)) + list(my_str) # Palju tülikam.
[1, 2, True, False, None, 1, 2, 1, 2, 3, '1', '2']
def my_sum(a, b, c):
return a + b + c
lst = [1, 2, 3]
my_sum(*lst) # Lahtipakkimine ja funktsiooni rakendamine.
6
Operaator **¶
Operaator ** on sõnastike lahtipakkimise operaator. Allpoole kasutame seda ka funktsioonide argumentide sulgudes.
d1 = dict(a = 1, b = 2)
d2 = {'c2': 3, 'd': 4}
d3 = {5: 'Python', 6: 'Juulius'}
{**d1, **d2, **d3} # Defineerib uue sõnaraamatu.
{'a': 1, 'b': 2, 'c2': 3, 'd': 4, 5: 'Python', 6: 'Juulius'}
d1 = dict(a = 1, b = 2)
d2 = {'a': 4, 'd': 5} # Võtmesõna a kordub.
{**d1, **d2}
{'a': 4, 'b': 2, 'd': 5}
Pane tähele, luues uut sõnaraamtut kirjutas Pythoni interpretaator eelmises koodirakus võtmesõnale a vastava esmalt määratud väärtuse 1 üle väärtusega 4 kuna hulk salvestab ainult unikaalseid objekte. Nagu ikka, koodi interpreteeritakse ülevalt alla ja vasakult paremale.
Funktsiooni argumentide tüübid ning lahti- ja kokkupakkimise operatorid * ja **¶
Pythoni funktsioonides eristame nelja tüüpi argumente:
- Tavalised argumendid, positsionaalsed argumendid (nii nagu me mõistame neid tuginedes eelnevatele loengutele) — (standard arguments, positional arguments)
*argsargumendid, etteteadmata arv positsionaalseid argumente, meelevaldne arv positsionaalseid argumente — (non-keyworded, positional, variable-length arguments)- Nimelised või võtmesõnaga argumendid, vaikimisiväärtustega argumendid (mitte-positsionaalsed)
**kwargsargumendid ehk nimelised või võtmesõnaga argumendid, etteteadmata arv vaikimisiväärtustega argumendid — (keyworded, non-positional, variable-length arguments)
Etteteadmata arv positsionaalseid argumente, *args¶
Mõnikord me ei tea mitu argumenti väästust me soovime funktsioonile edasi anda. Kõik mis allpool järgneb kehtib nii blokis def kui ka anonüümses funktsioonis, mida defineeriti kasutades lausendit lambda.
def my_sum(*args): # Meelevaldne arv argumente.
print(type(args)) # Operaator * pakkis argumendid ennikusse.
summa = 0
for i in args: # Itereerin üle enniku.
summa += i
return summa
my_sum(1, 2, 3) # Proovi erinev arv argumente.
<class 'tuple'>
6
my_sum() # NB! Argumente võid ka mitte sisestada.
<class 'tuple'>
0
def my_sum(*args):
return sum(args) # Sisseehitatud funktsioon sum itereerib üle iteraatortoega enniku.
my_sum(1, 2, 3)
6
Erinevat tüüpi argumendid sisestame järgmises järjekorras. Esmalt sisesta teadaolev arv positsionaalsed arguendid ja alles siis teadmata arv argumente kasutades operaatorit * kujul *args:
def func(a, b, *args): # Järjekord on oluline.
print(a)
print(b)
print(args)
func(1, 2, 3, 4)
1 2 (3, 4)
Vaikimisiväärtustega argumendid¶
Argumendile saame omistada vaikimisiväärtusi positsionaalselt ja/või viidata neile nimepidi mitte-positsionaalselt (non-positional), ainult siis kui neile ei järgne teist tüüpi argumendid. Pea meeles, et vaikimisiväärtustega argumendid järgnevad positsionaalsetele argumentidele ja *args tüüpi argumentidele funktsiooni või protseduuri argumendi sulgudes.
def test(a, b=12, c=13): # Järjekord on oluline.
print(a)
print(b)
print(c)
test(11, 5) # Vaikimisi väärtusi pole kohustuslik siin edastada.
11 5 13
def test(a=2, b=12, c=13):
print(a)
print(b)
print(c)
test()
2 12 13
def test(a=2, b=12, c=13):
print(a)
print(b)
print(c)
# Viitan nimepidi, mitte-positsionaalselt:
test(b=7, a=6) # Väärtuste muutmine ja ülekirjutamine ei sõltu siin asukohast.
6 7 13
def test(a, b, c):
print(a)
print(b)
print(c)
# Viitan nimepidi, mitte-positsionaalselt:
test(c=13, b=7, a=6) # Väärtuste edastamine ei sõltu siin asukohast.
6 7 13
f = lambda x, y=12: x + y
f(2)
14
def func(a, *args, x=55, y, z): # NB! y ja z on võtmesõnaga argumenid millele pole siin vaikimisiväärtusi omistatud.
print(a)
print(args)
print('x =', x)
print('y =', y)
print('z =', z)
func(1, 2, 3 ,4, 5, 6, 7, y=33, z=44) # Peame vaikimisiväärtused siin edastama.
1 (2, 3, 4, 5, 6, 7) x = 55 y = 33 z = 44
Vaikimisiväärtusega argumendid on meile juba tuttavad. Vaikimisiväärtusega argumendi kasutamine sisseehitatud funktsioonis print:
print('Python', end='\n') # Muutujanime end vaikimisiväärtus on reavahetus.
Python
Positsionaalsed ja vaikumisi väärtustega argumendid, lubatud süntaksi kuju¶
Lisaks eelmainitud sünkaksinöidetele kehtib ka järgmine kirjapilt.
Allolevas näites:
xjayon positsionaalsed argumendid.zjawsaavad olla kas positsionaalsed või vaikimisiväärtustega argumendid, kusjuures vaikimisiväärtustega argumendid peavad järgnema positsionaalsetele.ajabon vaikimisiväärtustega argumendid.
def f(x, y, /, z, w, *, a, b): # Erinevat tüüpi argumendid on eristatud kasutades / ja *.
print(x, y, z, w, a, b)
f(1, 2, z=3, w=4, a=5, b=6) # Erinevad tüübid: järjekord oluline.
f(1, 2, 3, w=4, a=5, b=6)
f(1, 2, 3, 4, b=5, a=66) # Nimega argumentide puhul pole järjekord on oluline.
1 2 3 4 5 6 1 2 3 4 5 6 1 2 3 4 66 5
Etteteadmata arv võtmesõnaga vaikimisiväärtustega argumente, **kwargs¶
def test(**kwargs): # Meelevaldne arv argumente.
print(type(kwargs)) # Operaator * pakis argumendid sõnaraamatusse.
print(kwargs)
test(a=77, b=66, c1=77, c2=88, c3=12)
<class 'dict'>
{'a': 77, 'b': 66, 'c1': 77, 'c2': 88, 'c3': 12}
test() # NB! Argumente võid ka mitte sisestada.
<class 'dict'>
{}
def myFunc(**kwargs):
for key, value in kwargs.items(): # **kwargs argument on sõnastik.
print(f"{key} --> {value}")
myFunc(key1='Python', key2='Snake')
key1 --> Python key2 --> Snake
def myFunc(**kwargs):
for key, value in kwargs.items():
print(f"{key} --> {value}")
items = {'key1':'Python', 'key2':'snake'}
myFunc(**items) # pakin lahti, et funk. saaks kokku pakkida
key1 --> Python key2 --> snake
Argumentide segakasutus¶
Järjekord on oluline. Funktsiooni ja protseduuri argumendi sulgudes kasutame erinevat tüüpi argumente järgmises järjekorras:
- Tavalised positsionaalsed argumendid.
- Vaikimisiväärtustega argumendid (nende väärtusi saab alati ülekirjutada positsionaalselt).
- Meelevaldne arv positsionaalsed argumendid,
*args-tüüpi argumendid. - Vaikimisiväärtustega argumendid (nende väärtusi saab alati ülekirjutada viidates neile nimepidi).
- Meelevaldne arv mittepositsionaalsed võtmesõnaga argumendid,
**kwargs-tüüpi argumendid.
def test(x, y, z=3, *args, **kwargs): # Vaikimisiväärtustega argument z pole kohustuslik.
print(x)
print(y)
print(z) # Käitub rohkem nagu positsionaalne argument.
print(args)
print(kwargs)
test(1, 2, 33, 44, 44, a=444, b=555) # Argument z positsionaalne ülekirjutamine. Argumendi z väärtust pole võimalik mitte sisestada.
1
2
33
(44, 44)
{'a': 444, 'b': 555}
Saab vajadusel ka nii:
def test(x, y, *args, z=3, **kwargs):
print(x)
print(y)
print(args)
print(z)
print(kwargs),
test(1, 2, 33, 44, z=33, a=444, b=555) # Argument z ülekirjutamine. Argumendile z peab viitama nimepidi.
print()
test(1, 2, 33, 44, 33, a=444, b=555) # Argument z jäeti rahule.
1
2
(33, 44)
33
{'a': 444, 'b': 555}
1
2
(33, 44, 33)
3
{'a': 444, 'b': 555}
def test(x, y, z1=2, *args, z2=3, **kwargs):
print(x)
print(y)
print(z1)
print(args)
print(z2)
print(kwargs),
test(1, 2, 33, 44, z2=33, a=444, b=555) # Argument z1 positsionaalne ülekirjutamine. Argumendile z2 peab viitama nimepidi.
print()
test(1, 2, 33, 44, 33, a=444, b=555) # Argument z2 jäeti rahule.
1
2
33
(44,)
33
{'a': 444, 'b': 555}
1
2
33
(44, 33)
3
{'a': 444, 'b': 555}
f = lambda x, y=2, *args, **kwargs: x*(sum(args)) # Algoritm ei kasuta argumenti y ja **kwargs argumente.
f(2, 2, 1, 1) # **kwargs argumente ei kasutanudki. Argument y jäi samaks.
4
Muutujate skoop¶
Skoop tähistab programmis mingit kehtivuspiirkonda (või mõjupiirkonda), milles on muutujad seotud kindlate väärtustega. Pythonis eristatakse nelja skoopi mis on loetletud Joonisel 1. Pythonis kehtib nn. LEGB reegel. See reegel kirjeldab millises järjekorras ja millisest skoobist (nimeruumist) otsitakse lähtekoodis kasutatud muutujate väärtusi, vt. Joonis 1 ja 2.
 |
|---|
| Joonis 1: Akronüümi LEGB tähendus ja nn. LEGB reegel visualiseeritult. |
Lokaalne skoop, funktsioonid ja lausendid global ning nonlocal¶
Pythonis on funktsiooni sees loodud muutujad lokaalsed, need on nähtavad ainult funktsiooni seest. Asudes funktsiooni blokkis, alustab Pythoni interpretaator muutujate väärtuste otsimist lokaalsest skoobist, siis kapseldatud või pesastatud skoobist, siis globaalsest skoobist ja lõpuks sisseehitatud objektide nimeruumi skoobist, vt. Joonis 1 ja 2. Erinevate skoopide tähedus selgub uurides allolevaid näiteid. Pythonis on ainult üks blokk mis loob lokaliseeriva ja kapseldava skoobi, milleks on def blokk.
 |
|---|
| Joonis 2: LEGB reegel visualiseeritult. |
Lokaalne ja globaalne skoop
x = 'Globaalne x' # Globaalne skoop.
def test():
y = 'Lokaalne y' # Bloki seest vaadates on see lokaalne skoop.
print(y)
test()
print(x)
print(y) # Ei näe funktsioonibloki sisse, funktsioon kaitseb enda muutujaid.
Lokaalne y Globaalne x
--------------------------------------------------------------------------- NameError Traceback (most recent call last) Cell In[45], line 9 7 test() 8 print(x) ----> 9 print(y) NameError: name 'y' is not defined
x = 'Globaalne x'
def test():
y = 'Lokaalne y'
print(y, '<- Funktsiooni sees.')
print(x, '<- Funktsiooni sees.') # LEGB järjekord: L -> K (puudub) -> G.
test()
print(x)
Lokaalne y <- Funktsiooni sees. Globaalne x <- Funktsiooni sees. Globaalne x
x = 'Globaalne x'
def test():
x = 'Lokaalne x' # Ei kirjuta globaalset üle.
print(x)
test()
print(x) # Funktsioon test ei kirjutanud x-i üle.
Lokaalne x Globaalne x
Kui tahame funksiooni seest globaalset muutujat üle kirjutada ehk annda funktsiooni lokaalsele skoobil juurdepääsu globaalsele, muudame lokaalse muutuja globaalseks kasutades lausendit global.
x = 'Globaalne x'
def test():
global x
x = 'Lokaalne x' # Kirjutab globaalse muutuja üle.
print(x)
test()
print(x)
Lokaalne x Lokaalne x
Või kui soovime defineerida uut globaalset muutuja lokaalses skoobis ehk def bloki sees.
def test():
global x # Globaalne muutuja.
x = 'Lokaalselt loodud x' # Defineerime muutuja ja omistame väärtuse.
print(x)
test()
print(x) # Näeb lokaalses skoobis loodud globaalset muutujat x.
Lokaalselt loodud x Lokaalselt loodud x
def test(z): # Argument z on lokaalse skoobi muutuja.
print(z)
test('Lokaalne z')
print(z) # Ei näe lokaalsesse skoopi.
Lokaalne z
--------------------------------------------------------------------------- NameError Traceback (most recent call last) Cell In[50], line 5 2 print(z) 4 test('Lokaalne z') ----> 5 print(z) NameError: name 'z' is not defined
Kapseldav ja kapseldatud või pesastatud skoop
Pythonis on kapseldav skoop defineeritud def blokiga. Muutujatele väärtuste otsimine käib endiselt LEGB reegli järgi, kusjuures kapseldavaid skoope saab olla rohkem kui üks, vt. Joonis 1 ja 2, vrd. Joonis 3.
 |
|---|
| Joonis 3: LEGB reegel juhul kui esineb vähemalt kaks lokaalset skoopi ja rohkem kui üks kapseldav skoop. |
x = "globaalne x"
def valisem():
def valine():
def sise():
print('sise --->', x) # L -> E -> E -> G
sise()
print('valine -->', x) # L -> E -> G
valine()
print('valisem -->', x) # L -> G
valisem()
sise ---> globaalne x valine --> globaalne x valisem --> globaalne x
def valine(): # Kapseldav skoop, kapseldab ühte lokaalset skoopi.
x = 'Kapseldav x'
def sise(): # Lokaalne skoop.
x = 'Lokaalne x'
print(x)
sise()
print(x)
valine()
Lokaalne x Kapseldav x
def valine():
x = 'Kapseldav x'
def sise():
print(x) # LEGB järjekord: L -> K.
sise()
print(x)
valine()
Kapseldav x Kapseldav x
def valine():
def sise():
z = 'Lokaalne z'
print(z) # LEGB järjekord: L.
sise()
print(z) # LEGB: Ei näe kapseldatud funktsiooni skoopi.
valine()
Lokaalne z
--------------------------------------------------------------------------- NameError Traceback (most recent call last) Cell In[54], line 8 5 sise() 6 print(z) # LEGB: Ei näe kapseldatud funktsiooni skoopi. ----> 8 valine() Cell In[54], line 6, in valine() 4 print(z) # LEGB järjekord: L. 5 sise() ----> 6 print(z) NameError: name 'z' is not defined
Kui soovime lokaalses skoobis juurdepääsu kapseldava skoobi muutujale kasutame lausendit nonlocal
def valine():
x = 'Kapseldav x'
def sise():
nonlocal x # Kapseldava skoobi muutuja.
x = 'Lokaalne x' # Kirjutab kapseldava muutuja üle.
print(x)
sise()
print(x)
valine()
Lokaalne x Lokaalne x
Kaks astet kapseldavaid skoope. Pesastatud funktsioonid.
def valisem():
x = 'Kapseldav kapseldav x'
def valine():
def sise():
nonlocal x # Kapseldava skoobi muutuja.
x = 'Lokaalne x'
print('sise --->', x)
nonlocal x # Kapseldava kapseldava skoobi muutuja.
x = 'Kapseldav x'
sise()
print('valine -->', x)
valine()
print('valisem -->', x)
valisem()
sise ---> Lokaalne x valine --> Lokaalne x valisem --> Lokaalne x
Märkus 1: Lausendite global ja nonlocal kasutamine pole soovituslik. Kui sa kipud neid tihti kasutama siis suure tõenäosusega teed midagi valesti.
Märkus 2: Globaalseid muutujaid ei ole soovituslik kasutada funktsiooni see. Kasuta funktsiooni argumente.
Sisseehitatud objektide nimeruumi skoop (Built-ins scope)¶
Sisseehitatud objektide nimeruum skoop on spetsiaalne Pythoni skoop, mis luuakse või laaditakse alati, kui käivitate programmi. See skoop sisaldab Pythoni sisseehitatud objektide nimesid ja muid nimesid, nagu näiteks: lausendid, funktsioonid, erisused ja muud Pythoni sisseehitatud atribuudid. Nimed selles skoobis on laitavad kõikjalt koodis. Näiteks funktsioon print on Pythoni sisseehitatud funktsioon ja seetõttu kuulub sisseehitatud objektide nimeruum skoopi.
import builtins # Lausendist impordist räägime tulevastes loengutes lähemalt.
#dir(builtins) # Vaata iseseisvalt mida nimeruum sisaldab.
Ettevaatust: Kuna Pythonis on võimalik selle nimeruumide nimesid üle kirjutada siis...
min([1, 2]) # Funktsioon min on builtins skoobis.
1
def min(*args): # Samuti funktsioon min mis on globaalses skoobis.
print('Juulius Tipikas.')
min([1, 2]) # LEGB reegel: Leib funktsiooni min globaalsest skoobist enne built-ins skoopi.
Juulius Tipikas.
Mitu lokaalset skoopi¶
Üks lokaalne skoop ei saa leida või kasutada teise lokaalse skoobi muutujaid. Lokaalsed skoobid pole üksteisele nähtavad:
def skoop1():
muutuja = 'Python'
skoop2()
print(muutuja)
def skoop2():
muutuja = 'Juulius' # Ei kirjutata üle.
skoop1()
Python
Muutuja skoop ja tingimuslaused¶
if-blokis loodud muutujad on globaalses skoobis. Kuid pea meeles, kui if-bloki tingimus mille all muutuja on defineeritud ei teostu siis ei ole see muutuja ega selle väärtus globaalsest skoobist leitavad:
if False:
invisible = 'Python'
else:
visible = 'Juulius'
print(visible)
print(invisible)
Juulius
--------------------------------------------------------------------------- NameError Traceback (most recent call last) Cell In[61], line 7 4 visible = 'Juulius' 6 print(visible) ----> 7 print(invisible) NameError: name 'invisible' is not defined
for-in avaldis (list comprehension)¶
for-in avaldis on generaatorite, iteraatorite, iteraatortoega objektide ja määratud iteratsiooniblokkide filter kujul:
[<avaldis või algoritm> for <element> in <iteraatortoega obj.>]
Avaldise abil loome loendeid ja filtreeritud loendeid kasutades ainult ühte rida koodi. Alustame meile teadaolevate võtetega ja siis uurime neile vastavaid üherealisi avaldisi.
ruudud = [] # Tühi järjend.
for i in range(5):
ruudud.append(i ** 2) # Meetod append on loendi meetod.
ruudud
[0, 1, 4, 9, 16]
Nüüd kasutades for-in avaldist:
[i ** 2 for i in range(5)]
[0, 1, 4, 9, 16]
lst = [i for i in range(5)]
print(lst)
ruudud = [i ** 2 for i in lst] # Loend lst on iteraatortoega objekt.
print(ruudud)
[0, 1, 2, 3, 4] [0, 1, 4, 9, 16]
Pesastatud for-in avaldis (nested list comprehension)¶
lst = []
for x in [1, 2, 3]: # Pesastav tsükkel.
for y in [5, 5]: # Pesastatud tsükkel.
lst.append(x * y)
lst
[5, 5, 10, 10, 15, 15]
Nüüd kasutades for-in avaldist:
[x * y for x in [1, 2, 3] for y in [5, 5]]
[5, 5, 10, 10, 15, 15]
Hulga avaldis (set comprehension)¶
Sarnaselt loendile saame defineerida ka hulkasid.
{i for i in range(4)} # NB! Loogelised sulud.
{0, 1, 2, 3}
{i for i in [1, 2, 3, 4, 4]} # Ainult unikaalsed listi elemendid.
{1, 2, 3, 4}
ruudud = {i ** 2 for i in range(4)}
ruudud
{0, 1, 4, 9}
{i for i in 'Python'} # Hulk pole järjestatud.
{'P', 'h', 'n', 'o', 't', 'y'}
Sõnastiku avaldis (dictionary comprehension)¶
Väikese lisatööga saame ka sõnastikke defineerida.
{i: i ** 2 for i in range(3)}
{0: 0, 1: 1, 2: 4}
ruudud = {f'Key{i}': i ** 2 for i in range(3)}
print(type(ruudud))
print(ruudud)
<class 'dict'>
{'Key0': 0, 'Key1': 1, 'Key2': 4}
NB! Korteeži avaldist pole olemas kuna see defineerib objekti mida selles loengus ei käsitleta (Järgmise nädala loengus räägime generaatoritest ja nende abil loodud iteraatoritest).
for-in-if avaldis - filtreeritud iteraatortoega objektid, iteraatorid ja määratud iteratsiooni blokid (conditional comprehensions)¶
Teatud liikmete välja filtreerimiseks lisame eelnevate avaldiste lõppu if klausli. Filtreeritud listi süntaks on järgmine:
uus_list = [<avaldis> for <element> in <iteraatortoega obj.> if <tingimus>]
Joonis 4 kujutab eelmainitud filtreerimisprotsessi voodiagrammi.
 |
|---|
Joonis 4: for-in-if avaldise või sarnase jadade filtri voodiagramm. |
Nii nagu eespool, alustame meile teadaolevate võtetega ning siis võrdleme neile vastavaid üherealisi avaldisi.
num_less_ten = []
num = [1, 2, 55, 3]
for i in num:
if i < 10:
num_less_ten.append(i)
num_less_ten
[1, 2, 3]
vowels = []
lause = 'Juulius'
for i in lause:
if i in 'aeiouõäöü':
vowels.append(i)
vowels
['u', 'u', 'i', 'u']
Ekvivalentsed kujud kasutades for-in-if avaldist.
num_less_ten = [i for i in num if i < 10]
num_less_ten
[1, 2, 3]
vowels = [i for i in lause if i in 'aeiouõäöü']
vowels
['u', 'u', 'i', 'u']
Muid näiteid:
[i for i in range(10) if i % 3 == 0] # Kolmega jaguvad arvud.
[0, 3, 6, 9]
numbers = [1, 2, 2, 55, 3, 4]
set_less_ten = {i for i in numbers if i < 10} # Tulemus: Filtreeritud hulk.
set_less_ten # Hulk.
{1, 2, 3, 4}
numb = [1, 2, 55, 3, 4]
{i: i for i in numb if i < 10} # Tulemus: filtreeritud sõnastik.
{1: 1, 2: 2, 3: 3, 4: 4}
Muud segaavaldised¶
if-else valikuavaldis ja for-in avaldis¶
Eespool tutvustatud for-in avaldises saab, näiteks, kasutada Loengus 4 tutvustatud if-else valikuavaldist. Tavaline for-in avaldis on kujul:
[<avaldis> for <element> in <iteraator, iteraatortoega obj.>]
Asenda eelmisel real olev <avaldis> if-else valikuavaldisega:
[<avaldis 1> if <tingimus> else <avaldis 2> for <element> in <iteraator, iteraatortoega obj.>]
See avaldis on ekvivalentne järgmise for tsükliga kujul:
tulemus = []
for <element> in <iteraator, iteraatortoega obj.>:
if <tingimus>:
tulemus.append(<avaldis 1>)
else:
tulemus.append(<avaldis 2>)
Sarnaselt saab ka luua hulga ja sõnaraamatut segaavaldisi mis väljastavad tulemused hulka või sõnaraamatusse.
if-else valikuavaldis ja for-in-if avaldis¶
Eespool tutvustatud for-in-if avaldises saab ka kasutada Loengus 4 tutvustatud if-else valikuavaldist. Tavaline for-in-if avaldis on kujul:
[<avaldis> for <element> in <iteraator, iteraatortoega obj.> if <tingimus>]
Asenda eelmisel real olev <avaldis> if-else valikuavaldisega:
[<avaldis 1> if <tingimus 2> else <avaldis 2> for <element> in <iteraator, iteraatortoega obj.> if <tingimus 1>]
See avaldis on ekvivalentne järgmise for tsükliga kujul:
tulemus = []
for <element> in <iteraator, iteraatortoega obj.>:
if <tingimus 1>:
if <tingimus 2>:
tulemus.append(<avaldis 1>)
else:
tulemus.append(<avaldis 2>)
Sarnaselt saab ka luua hulga ja sõnaraamatut segaavaldisi mis väljastavad tulemused hulka või sõnaraamatusse.
Näide: Filtreeri loend a: Juhul kui loendi arv on suurem või võrdne $50$-ga liida sellele $1$, juhul kui arv on väiksem kui $50$ liida sellele $5$.
a = [22, 45, 50, 98, 69]
[x + 1 if x >= 50 else x + 5 for x in a]
[27, 50, 51, 99, 70]
Ekvivalentne kuju kasutades for tsüklit:
b = []
for x in a:
if x >= 50:
b.append(x + 1)
else:
b.append(x + 5)
print(b)
[27, 50, 51, 99, 70]
Näide: Filtreeri loend a: 1) Elimineeri paaritud arvud. 2) Juhul kui leitud paaris arv on suurem või võrdne $50$-ga liida sellele $1$, juhul kui paaris arv on väiksem kui $50$ liida sellele $5$.
a = [22, 13, 45, 50, 98, 69]
[x + 1 if x >= 50 else x + 5 for x in a if x % 2 == 0]
[27, 51, 99]
Ekvivalentne kuju kasutades for tsüklit:
b = []
for x in a:
if x % 2 == 0:
if x >= 50:
b.append(x + 1)
else:
b.append(x + 5)
print(b)
[27, 51, 99]