4. Funktsioonid¶

Funktsioonide kasutamine¶

Toome meeldetuletuseks mõned koodijupid, kus on kasutatud funktsioone nimedega input, int, is_wall, print, sqrt ja sin:

• sisestatud_vanus = input("Sisesta oma vanus: ")
• vanus_arvuna = int(sisestatud_vanus)
• if is_wall(): ...
• print(sqrt(sin(0.5)))

Esimene tähelepanek on see, et funktsiooni kasutamiseks tuleb kirjutada tema nimi ja selle järel sulud. Sulgudes võib olla 0 või rohkem argumenti s.o miski, millega me saame funktsiooni tööd kuidagi mõjutada. Näiteks lauses print("tere") tähistab print funktsiooni, "tere" on tema argument ja kõik see kokku on funktsiooni väljakutse e rakendamine (öeldakse ka aplikatsioon). Argumendid võivad olla mingid konkreetsed väärtused, muutujad või mingid muud avaldised (sh funktsioonide rakendused).

Arvutamine vs tegemine¶

Siiani oli meil kombeks uusi Pythoni konstruktsioone lahterdada avaldiste või lausete hulka. Nüüd tekib küsimus, kas mingi funktsiooni väljakutse (nt sqrt(sin(x)) või print('Tere!')) on avaldis või lause? Tuleb välja, et sellele ei saagi lühidalt vastata.

Mõned funktsioonid (nt sin, sqrt ja int) on olemuselt küllalt sarnased matemaatiliste funktsioonidega, kuna nad võtavad ühe väärtuse, arvutavad natuke ja annavad vastu e tagastavad mingi teise väärtuse (nt avaldisega sqrt(4) anname funktsioonile sqrt argumendiks väärtuse 4 ning funktsioon annab meile vastu väärtuse 2.0). Selliste funktsioonide väljakutsed on oma olemuselt avaldised, mis tähendab, et me võime neid kasutada igal pool, kus avaldised on lubatud, näiteks omistuslauses või mõne teise funktsiooni argumendina. Siia gruppi loeme ka need funktsioonid, mille väljakutse võib anda igal korral erineva väärtuse, näiteks input("Sisesta midagi: ") või Pykkari is_wall(). Kuigi need pole funktsioonid matemaatilises mõttes, kasutatakse ka neid avaldistes.

Teiste funktsioonide väljakutsel (nt print('Tere'), right(90), step()) huvitab meid see, mida nad teevad – me tahame, et midagi juhtuks (nt et ekraanile ilmuks uus tekstijupp või robot liigutaks ennast). Mingit huvitavat tagastusväärtust nad meile ei paku. Selliste funktsioonide väljakutseid loeme lauseteks ja seetõttu esinevad nad programmides omaette real. Funktsioonide defineerimise õppimist alustame just seda tüüpi funktsioonidega.

Meetodid¶

Teises peatükis nägime, et sõnede puhul kirjutati mõne funktsiooni nimi (nt count) sõne ja argumentide vahele, nt:

sõna = "kukununnu"
u_tähtede_arv = sõna.count("u")

Jääb mulje, et mingil põhjusel on üks funktsiooni argumentidest (antud näites sõna) lihtsalt esile tõstetud. Tuleb välja, et Python seda umbes nii ka käsitleb.

Taolisi funktsioone nimetatakse meetoditeks. Lisaks sellele, et meetodite puhul kirjutame esimese argumendi meetodi nime ette, on neil tavaliste funktsioonidega võrreldes veel mõningaid erinevusi, millel me praegu ei peatu. Meetod on väga tähtis mõiste objekt-orienteeritud programmeerimises.

Harjutus. Täidetud ruudud¶

Täienda eespool toodud 3 ruudu joonistamise programmi nii, et kõik 3 ruutu oleksid seest värviga täidetud.

...
begin_fill()
...
# joonista mingi kujund
...
end_fill()
....

from turtle import *

def ruut():
    begin_fill()
    joonistatud_kylgi = 0
    while joonistatud_kylgi < 4:
        forward(30)
        left(90)
        joonistatud_kylgi += 1
    end_fill()

ruut()

up()
forward(100)
left(90)
forward(100)
down()

ruut()

up()
left(90)
forward(200)
down()

ruut()

exitonclick()

from turtle import *

def ruut():
    joonistatud_kylgi = 0
    while joonistatud_kylgi < 4:
        forward(30)
        left(90)
        joonistatud_kylgi += 1

begin_fill()
ruut()
end_fill()

up()
forward(100)
left(90)
forward(100)
down()

begin_fill()
ruut()
end_fill()

up()
left(90)
forward(200)
down()

begin_fill()
ruut()
end_fill()

exitonclick()

Kontrollküsimus: mitu kala?¶

Küllap oled juba märganud, et Python ei soovi programmeerija vabadust piirata, seetõttu on loomulik, et ühes programmis võib defineerida ükskõik kui palju uusi funktsioone ja need võivad ka üksteist kasutada.

Nüüd küsimus: mitu korda kirjutab järgnev programm ekraanile sõna „kala“? NB! Proovi vastata ilma Pythoni abita programmi enda peas läbi mängides! Lõpuks kontrolli oma vastust Pythoni abil.

def fun1():
    print("kala")
    print("kala")

def fun2():
    fun1()
    print("kala")
    fun1()

fun2()
fun2()

def fun1():
    print("fun1 esimene rida")
    print("fun1 teine rida")

def fun2():
    print("fun2 algus")
    fun1()
    print("fun2 keskmine rida")
    fun1()
    print("fun2 lõpp")

print("eksperimendi algus")
fun2()
print("----------------")
fun2()
print("eksperimendi lõpp")

Kontrollküsimus: mitu tärni?¶

Mitu tärni ilmub ekraanile järgmise programmi käivitamisel? Paku vastus ja siis kontrolli.

def fun1():
    print(10 * "*")

def fun2():
    i = 0
    while i < 10:
        fun1()
        i += 1

Harjutus. Pööre vasakule¶

Eelmises peatükis Pykkari käske tutvustades tuli välja, et Pykkaril pole sisseehitatud käsku vasakule pööramiseks. Õnneks oli võimalik saavutada sama efekt 3 korda paremale pöörates.

Proovi nüüd täiendada mõnda eelmises peatükis kirjutatud Pykkari programmi selliselt, et vasakule pööramised näeksid koodis natuke loomulikumad välja.

from pykkar import *

...

def left():
    ...
    ...
    ...


...
left()
...
...
left()
...
...
...

Kontrollküsimus: mis juhtub?¶

Nüüd peaksid sa oskama ennustada, mida teeb järgmine programm:

x = 1

def f():
    y = 2
    print(x)
    print(y)

f()
print(x)
print(y)

1
2
1
Traceback (most recent call last):
  File "C:\Users\Aivar\Desktop\katse.py", line 10, in <module>
    print(y)
NameError: name 'y' is not defined

Funktsioonis jäävad lokaalsed muutujad peale¶

Eespool sai öeldud, et lokaalsetele muutujatele võib nimesid valida ilma teiste funktsioonide või programmi põhiosa pärast muretsemata. Mis juhtub aga siis, kui valida lokaalsele muutujale selline nimi, mis esineb ka mõne globaalse muutuja nimena? Proovime järele!

x = 1

def f():
    x = 2
    print(x)

print(x) # ekraanile kuvatakse 1
f()      # ekraanile kuvatakse 2
print(x) # ekraanile kuvatakse 1

Tuleb välja, et funktsiooni sees defineeritud muutuja x ei mõjuta kuidagi samanimelist globaalset muutujat, tegemist on kahe erineva muutujaga, millel on juhtumisi sama nimi (nagu kahel erineval inimesel võib olla sama nimi).

Selle skeemiga kaasneb paratamatult kitsendus, et me ei saa funktsiooni f sees enam ligi globaalsele x-le, sest lokaalsed muutujad varjavad samanimelisi globaalseid muutujaid.

x = 1

def f():
    print(x)

    if False:
        x = 2

f()

Globaalsete muutujate muutmine funktsiooni sees¶

Kui omistuslause funktsiooni sees tekitab uue lokaalse muutuja, siis kas on üldse võimalik funktsiooni sees olles mõnd globaalset muutujat muuta? On võimalik küll. Selleks tuleb funktsiooni alguses deklareerida, et teatud nime puhul mõtleme antud funktsioonis igal juhul globaalset muutujat, isegi kui sellele muutujale tehakse omistamine.

x = 10

def test():
    global x
    x = 3       # Globaalsele x-le omistatakse uus väärtus.
    print(x)    # Kuvatakse globaalse x-i väärtus.

test()      # Mis peaks nüüd ekraanile ilmuma?
print(x)    # Aga nüüd?

NB! Kuigi teatud juhtudel on selline võimalus kasulik, tuleks funktsioonis globaalsete muutujate muutmist siiski võimalusel vältida. Globaalsed muutujad on funktsiooni jaoks väga võimas kanal, mille abil ülejäänud programmiga infot vahetada, aga selle kanali ülemäärasel kasutamisel võib programmeerija kergesti kaotada järje, kes suhtleb kellega ja mis sõltub millest. Järgmiseks tutvustame ühte palju paremat viisi funktsiooni ja ülejäänud programmi vahel info vahetamiseks.

Harjutus. Parametriseeritud ruut¶

Täiusta eespool defineeritud ruudu joonistamise funktsiooni nii, et ruudu küljepikkuse saab määrata funktsiooni väljakutsel. Kasuta loodud funktsiooni, joonistades mitu erineva suurusega ruutu.

from turtle import *

def ruut(kylg):
    i = 0
    while i < 4:
        forward(kylg)
        left(90)
        i += 1

ruut(100)

# liigume kuskile mujale
up()
forward(200)
down()

# väiksem ruut
ruut(20)

exitonclick()

Parameetrid vs input¶

Parameetritega funktsioon meenutab oma olemuselt programmi, kus on kasutatud input käsku – mõlemal juhul on konkreetsed sisendandmed teadmata. Erinevus on selles, et kui input puhul on teada, et sisendandmed küsitakse kasutajalt, siis parameetrite kasutamisel jäetakse (funktsiooni seisukohast vaadatuna) sisendi saamise viis lahtiseks. Eelnevas näites andsime funktsiooni väljakutsel parameetri väärtuseks sõneliteraali, kuid seal oleks võinud kasutada ka muutujat:

def tere(nimi):
    print("Tere " + nimi)
    print("Kuidas läheb?")

sisestatud_nimi = input("Kuidas on sinu nimi? ")
tere(sisestatud_nimi)

See näide demonstreerib parameetritega funktsioonide universaalsust – vastavalt vajadusele võime taolist funktsiooni kasutada literaali, mõne muutuja (mille väärtus võib olla saadud input-ist) või ka mingi keerulisema avaldisega.

def tere(nimi):
    print("Tere " + nimi)
    print("Kuidas läheb?")

nimi = input("Kuidas on sinu nimi? ")
tere(nimi)

Mitu parameetrit¶

Parameetreid (ja vastavaid argumente) võib olla ka rohkem kui üks. Proovi näiteks järgmist programmi:

def tere(nimi, aeg):
    print("Tere, " + nimi)
    print("Pole sind juba " + str(aeg) + " päeva näinud")

tere("Kalle", 3)

Nagu näed, tuleb funktsiooni väljakutsel argumendid anda samas järjekorras nagu on vastavad parameetrid funktsiooni definitsioonis. Teisisõnu, argumendi positsioon määrab, millisele parameetrile tema väärtus omistatakse.

Harjutus. Värviline ruut¶

Kilpkonna pliiatsi värvi saab muuta funktsiooniga color, andes sellele argumendiks sõne ingliskeelse värvinimega, nt color('red'). Peale seda teeb kilpkonn järgmised jooned nõutud värviga.

Lisa funktsioonile ruut uus parameeter joone värvi määramiseks. Katseta.

def tere(nimi, aeg = "mitu"):
    print("Tere, " + nimi)
    print("Pole sind juba " + str(aeg) + " päeva näinud")

tere("Kalle", 3)
tere("Malle")

def f(a, b, c):
    print(a, b, c)

# järgnevad 2 väljakutset on samaväärsed:
f(1, 2, 3)
f(c=3, a=1, b=2)

def f(a=1, b=2, c=3):
    print(a, b, c)

# järgnevad 2 väljakutset on samaväärsed:
f(1, 22, 3)
f(b=22)

return-lause¶

Funktsiooni tulemuse tagastamiseks on Pythonis eraldi konstruktsioon – return-lause. Demonstreerime selle kasutamist netopalga arvutamise funktsioonis:

def neto(bruto):
    maksuvaba = 180
    if (bruto <= maksuvaba):
        return bruto
    else:
        maksustatav = bruto - maksuvaba
        tulumaksu_määr = 0.2
        maks = maksustatav * tulumaksu_määr
        return bruto - maks

ema_bruto = float(input('Sisesta ema brutopalk: '))
isa_bruto = float(input('Sisesta isa brutopalk: '))
laste_arv = int(input('Sisesta alaealiste laste arv: '))
ühe_lapse_toetus = 50
sissetulek = neto(ema_bruto) + neto(isa_bruto) + laste_arv * ühe_lapse_toetus
print('Pere sissetulek kuus on', sissetulek, 'eurot.')

return-lause käivitamisel arvutab Python näidatud avaldise väärtuse ja saadab selle funktsioonist välja e tagastab sellesse konteksti, kus funktsioon välja kutsuti (antud näites on selleks kontekstiks eelviimase rea liitmistehe).

Vaatame selle idee kinnistamiseks ka ühte lihtsamat näidet – defineerime funktsiooni, mis arvutab ja tagastab ringi pindala, ning seejärel kutsume selle välja omistuslauses:

from math import pi

def ringi_pindala(raadius):
    return pi * raadius**2

r1 = float(input("Sisesta esimese ringi raadius: "))
r2 = float(input("Sisesta teise ringi raadius: "))

pindala1 = ringi_pindala(r1)
pindala2 = ringi_pindala(r2)

if pindala1 > pindala2:
    print("Esimene on suurem")
elif pindala2 > pindala1:
    print("Teine on suurem")
else:
    print("Ringid on võrdse pindalaga")

Eespool jagasime funktsioonid kahte leeri – ühed teevad midagi (neid kasutame me lausetena) ja teised arvutavad midagi (neid kasutame avaldistes). Funktsiooni defineerimise vaatenurgast tuleneb see erinevus justnimelt return-lause kasutamisest – kõikides funktsioonides, mida me soovime avaldistes kasutada, on vaja kasutada return-i.

Harjutus. Sõne dubleerimine¶

Kirjuta funktsioon dubleeri, mis võtab argumendiks sõne ning tagastab selle sõne korratuna nii mitu korda, kui mitu tähte on esialgses sõnes:

>>> dubleeri('xo')
'xoxo'
>>> dubleeri('Tere')
'TereTereTereTere'

Nipp: funktsioonide testimine käsureal¶

Väärtusega funktsioone on mugav testida käsureal. Selleks piisab, kui skriptis on kirjas ainult funktsiooni definitsioon – taolise skripti jooksutamisel küll esialgu midagi ekraanile ei ilmu, aga käsureal on võimalik funktsiooni kasutada. Näiteks kui skripti sisu on selline:

def liida(a ,b):
    return a + b

def korruta(a, b):
    return a * b

siis peale selle Thonnys või IDLE’is käivitamist on võimalik käsureal teha nii:

>>> liida(223, 6)
229
>>> korruta(456, 987)
450072

Harjutus. Puuduv definitsioon¶

Kirjuta võimalikult lühike programm, mille käivitamise järel saaks Pythoni käsureal pidada sellise dialoogi:

>>> fun1(18)
8
>>> fun1(5687)
7
>>> fun1(1)
1
>>> fun1(98)
8
>>> fun1(66)
6
>>> fun1(67)
7
>>> fun2("tere", 4)
'EEEE'
>>> fun2("torpeedo", 1)
'T'
>>> fun2("nina", 3)
'NNN'

>>> 215 % 10
5

>>> s = "tere"
>>> s[0]
't'
>>> s[1]
'e'
>>> s[2]
'r'

return vs print¶

Eelnevalt märkisime, et funktsiooni parameetrid ja input on olemuselt sarnased, kuna mõlemad on seotud sisendi saamisega, kuid parameetrid on paindlikumad, sest täpne sisendi saamise viis jäetakse lahtiseks.

Analoogselt võime võrrelda print ja return käskusid – mõlemad on seotud väljundi andmisega, kuid return on paindlikum, kuna täpne tulemuse kasutamise viis jäetakse lahtiseks.

Uuri kahte järgnevat programmi, kus mõlemas on defineeritud funktsioon ringi pindala arvutamiseks. Mõlemal juhul on meie eesmärgiks arvutada mingi ringi pindala, kuvada tulemus ekraanile ja kirjutada faili.

from math import pi

def ringi_pindala(raadius):
    print("Pindala on", pi * raadius**2)


ringi_pindala(16.5)

# Salvestame tulemuse ka faili ...
# Probleem: kuidas saada tulemust
# ekraanilt kätte?

from math import pi

def ringi_pindala(raadius):
    return pi * raadius**2

x = ringi_pindala(16.5)
print("Pindala on", x)

# salvestame tulemuse ka faili
f.open("tulemus.txt")
f.write("Tulemus: " + str(x))
f.close()

Kui sooviksime arvutuse tulemust näidata ainult ekraanil, siis tehniliselt pole vahet, kas me teeme print-i funktsiooni sees või väljaspool. Erinevus tuleb sisse, kui me soovime tulemust veel kuskil kasutada, näiteks faili koostamisel või mingites järgnevates arvutustes – meie esimeses programmis olev funktsioon siis enam ei sobi. Teises variandis on funktsioon defineeritud üldisemana ja seetõttu saab seda kasutada rohkemates situatsioonides.

Harjutus. Kuu nimed¶

Harjutus. Kahest suurim => kolmest suurim¶

Kõigepealt defineeri funktsioon kahest_suurim, mis tagastab kahest argumendiks antud arvust suurima.

Seejärel küsi programmi põhiosas kasutajalt kolm arvu ning kuva ekraanile neist suurim. Proovi seejuures delegeerida võimalikult palju tööd äsja loodud funktsioonile.

return lõpetab funktsiooni töö¶

Senistes näidetes oli return-lause funktsiooni kehas kõige viimane lause (või siis viimane lause if-lause harus). Tegelikult ei pea return olema tingimata funktsiooni lõpus. Järgnevas absoluutväärtuse arvutamise funktsiooni näites kasutatakse return-i kahes kohas – funktsiooni lõpus ja tingimuslause sees:

def absoluut(x):
    if x < 0:
        return -x

    return x

Kumb neist return-idest siis ikkagi kehtib? Sellele vastamiseks peame teadma, et return-lause käivitamine lõpetab alati funktsiooni töö. Seega, kui kutsume antud funktsiooni välja negatiivse argumendiga, siis käivitub esimene return ja if-lausele järgnevat rida üldse ei vaadatagi. Kui aga if-lause tingimus osutub vääraks, siis if-lause keha ei vaadata ja Python jätkab sellega, mis tuleb peale if-lauset (s.o teine return).

Selline võimalus kasutada return-i funktsiooni keskel ei ole tegelikult eriti oluline – alati saab funktsiooni panna kirja nii, et seal on täpselt üks return-lause ja see paikneb funktsiooni lõpus. Vahel võib mitme return-i kasutamine siiski koodi selgemaks teha.

Funktsioonide veateadete lugemine¶

Esimeses peatükis soovitasime pikkade veateadete puhul keskenduda veateate viimastele ridadele. Kui täitmisaegne viga tekib mingi funktsiooni sees, siis võib ainult viimaste ridade põhjal olla raske vea põhjust tuvastada. Proovi käivitada järgnevat programmi:

def arvuta_kuupalk(aastapalk):
    return aastapalk / 12

aastapalk = input("Palun sisesta aastapalk: ")
print("Kuupalk on", arvuta_kuupalk(aastapalk))

Kui sisestad nõutud palganumbri, siis saad umbes taolise veateate:

Traceback (most recent call last):
  File "C:/harjutused/vigane.py", line 5, in <module>
    print("Kuupalk on", arvuta_kuupalk(aastapalk))
  File "C:/harjutused/vigane.py", line 2, in arvuta_kuupalk
    return aastapalk / 12
TypeError: unsupported operand type(s) for /: 'str' and 'int'

Viimaste ridade järgi võiks järeldada, et probleem on real nr 2, funktsioonis arvuta_kuupalk. Tegelikult oli viga aga selles, et funktsiooni kutsuti välja valet tüüpi argumendiga (peaks olema arv, aga oli sõne). Seega tuleb pöörata tähelepanu ka funktsiooni väljakutse kohale. Meie õnneks on ka väljakutse koht veateates ära näidatud – see on real nr 5. Kui ka väljakutse ise paiknes kuskil funktsioonis, siis on ka tolle funktsiooni väljakutse koht ära näidatud – ülevalt alla liikudes saab veateatest välja lugeda, millises kohas mida välja kutsuti.

Erindite tekitamine¶

Tuleta meelde netopalga arvutamise funktsiooni. Mis juhtub, kui sellele anda argumendiks negatiivne arv? Proovi toodud näiteprogrammi nii, et isa palk on -300 ja ema oma 900. Kas saadud tulemus on mingis mõttes mõistlik?

Ilmselt oled nõus, et neto(-300) ei ole mõistlik, samamoodi nagu int("tere") ei ole mõistlik. Kuna Python annab int("tere") käivitamisel vea ehk tekitab erindi (mida vajadusel saab kinni püüda), siis võiksime ka funktsioonis neto kontrollida kõigepealt parameetri väärtust ja kui see on vigane, siis tekitada erindi:

def neto(bruto):
    if bruto < 0:
        raise Exception("Argument peab olema mittenegatiivne")

    maksuvaba = 144
    if (bruto <= maksuvaba):
        return bruto
    else:
        maksustatav = bruto - maksuvaba
        return maksustatav * 0.79 + maksuvaba

ema_bruto = float(input('Sisesta ema brutopalk: '))
isa_bruto = float(input('Sisesta isa brutopalk: '))
laste_arv = int(input('Sisesta alaealiste laste arv: '))
ühe_lapse_toetus = 20
sissetulek = neto(ema_bruto) + neto(isa_bruto) + laste_arv * ühe_lapse_toetus
print('Pere sissetulek kuus on', sissetulek, 'eurot.')

Ilmselt juba aimasid, et erindi tekitamisega oli seotud lause, mis algas võtmesõnaga raise. Sõna Exception näitab erindi tüüpi. Eri tüüpi erindite kasutamist me siin ei käsitle, seetõttu ütleme praegu, et erindi tekitamise lause peab olema kujul raise Exception(<veateade>).

Katseta muudetud programmi negatiivse palganumbriga – loodetavasti näed nüüd vigase vastuse asemel veateadet. Kui saab valida, kas programm annab vale vastuse või lõpetab veateatega, siis kindlasti peaks eelistama viimast!

Enda erindite püüdmine¶

Ise tekitatud erindeid on võimalik kinni püüda samamoodi nagu Pythonisse sisseehitatud funktsioonide omi:

def neto(bruto):
    if bruto < 0:
        raise Exception("Argument peab olema mittenegatiivne")

    maksuvaba = 144
    if (bruto <= maksuvaba):
        return bruto
    else:
        maksustatav = bruto - maksuvaba
        return maksustatav * 0.79 + maksuvaba

ema_bruto = float(input('Sisesta ema brutopalk: '))
isa_bruto = float(input('Sisesta isa brutopalk: '))
laste_arv = int(input('Sisesta alaealiste laste arv: '))
ühe_lapse_toetus = 20
try:
    ema_neto = neto(ema_bruto)
    isa_neto = neto(isa_neto)
    sissetulek = ema_neto + isa_neto + laste_arv * ühe_lapse_toetus
    print('Pere sissetulek kuus on', sissetulek, 'eurot.')
except:
    print('Mingi jama. Arvatavasti ebaõnnestus ema või isa netopalga arvutamine')
    # "arvatavasti", kuna teoreetiliselt võib ka print-lause erindi tekitada

Antud programmi puhul pole see lahendus tegelikult optimaalne – kasutaja jaoks oleks mugavam, kui juba sisestamise järel kontrollitaks palganumbreid ja vigase sisendi korral küsitaks uuesti.

DRY-printsiip¶

Kogenud programmeerijad mainivad tihti nn DRY-printsiipi – see tuleb ingliskeelsest väljendist „Don’t repeat yourself“, millega tahetakse öelda, et sarnase koodi mitmekordset kirjapanekut tuleks vältida.

Põhiline viis DRY-printsiibi rakendamiseks on uue funktsiooni defineerimine – selle asemel, et sarnast koodi kirjutada erinevatesse kohtadesse, saab selle esitada funktsioonina ning edaspidi piisab selle kasutamiseks vaid funktsiooni nime mainimisest. Kui midagi on vaja muuta, siis tehakse muudatus vaid funktsiooni kehas ja see mõjub igalpool, kus funktsiooni on kasutatud.

Pere sissetuleku programmi muutmine oli hea DRY-printsiibi rakendamise näide. Lisaks tippimise vaeva vähendamisele muutis funktsiooni neto sissetoomine ka programmi uuendamise lihtsamaks ja veakindlamaks – kui netopalga arvutamise reeglid peaks muutuma, siis tuleb muudatus teha vaid ühes kohas. Ilma funktsioonideta peaksime sel juhul üles otsima ja parandama kõik kohad, kus netopalka arvutatakse. Paraku oleks suuremate programmide puhul küllalt tõenäoline, et mõni koht jääb kahe silma vahele.

Üldistamine¶

Kui eri kohtades on vaja sarnast, kuid teatud variatsiooniga koodi (nt ühel juhul arvutame netopalka ema, aga teisel juhul isa brutopalga põhjal), siis tulevad appi parameetrid, mis võimaldavad meil funktsiooni kehas jätta mõned detailid lahtiseks. Teisiti öeldes – funktsiooni parameetrid võimaldavad meil kirjutada üldisema lahenduse, mida saab hiljem konkreetsete argumentidega täpsustada. Netopalga arvutamise funktsioonis saime brutopalga esitada parameetrina, millele antakse väärtus alles konkreetse arvutuse käivitamisel.

Abstraktsioon ja mustad kastid¶

Kolmas oluline põhjus tuleb paremini esile suuremate programmide puhul. Kui me koondame teatud alamülesande lahendamiseks vajalikud laused ühte funktsiooni (alamprogrammi), siis programmi põhiosas piisab selle alamülesande lahendamiseks vaid vastava funktsiooni nime mainimisest. See annab meile võimaluse juba lahendatud alamülesandeid käsitleda abstraktselt ilma muretsemata, kuidas vastavad funktsioonid sisemas töötavad. Teisiti öeldes, programmi põhiosa kallal töötades võime me käsitleda funktsioone kui maagilisi „musti kaste“, eeldades lihtsalt, et nad teevad seda, mida nende nimest võib välja lugeda. Taoline võte võimaldab meil ühele programmi kihile korraga keskendudes luua väga keerulisi programme, millega poleks võimalik toime tulla, kui me peaks kõiki detaile korraga meeles pidama.

Kui DRY-printsiibi juures rõhutasime seda, et funktsioonid aitavad sama koodi kasutada korduvalt, siis abstraktsiooni põhiidee on selles, et me saame hästi valitud nimega funktsiooni edukalt kasutada ilma selle ehituse peale mõtlemata. Seetõttu on uue funktsiooni loomine põhjendatud tihti ka siis, kui seda kasutatakse vaid ühes kohas.

1. Liigu nurka ver 2¶

Eelmises peatükis oli ülesanne, kus Pykkar tuli juhatada maailma kirdenurka. Ilmselt pidid sa selleks kirjutama kaks korda samalaadse tsükli, mis kummalgi korral liigutas Pykkari tema ees oleva seinani. Miks ei võiks Pykkaril olla eraldi käsk, mis paneb ta kõndima kuni seinani?

Lisa oma eelmises peatükis tehtud programmile funktsioon liigu_seinani, mis lisab Pykkarile just sellise uue käsu. Muuda ka programmi põhiosa nii, et see delegeeriks seinani kõndimise sammud äsja loodud funktsioonile.

2. Ristkülik¶

Kirjuta funktsioon ristkylik, mis võtab argumentideks kaks küljepikkust ja joonistab kilpkonnaga neile vastava ristküliku. Seejärel joonista järgnev kujund, delegeerides võimalikult palju tööd äsja loodud funktsioonile:

3. Kahe punkti kaugus¶

Kirjuta funktsioon, mis võtab argumentideks kahe tasandipunkti koordinaadid ja tagastab nende punktide kauguse üksteisest.

Funktsiooni kasutamiseks küsi kasutajalt kolme punkti koordinaadid ja vasta millised kaks neist on üksteisele kõige lähemal.

Vihje

Kuidas arvutada kahe punkti kaugust:

4. Kuupäeva esitamine sõnena¶

Kirjuta funktsioon kuupäev_sõnena, mis võtab argumentideks päeva, kuu ja aasta (arvudena) ning tagastab sõne, mis esitab kuupäeva kujul <päev>. <kuu nimi> <aasta> (nt. 24. veebruar 1918).

Seejärel kirjuta programm, mis küsib kasutajalt arvudena päeva, kuu ja aasta ning kuvab ekraanile vastava kuupäeva sõnena.

5. Kolmnurga pindala¶

Kirjuta funktsioon kolmnurga_pindala_külgede_järgi, mis võtab argumentideks kolmnurga külgede pikkused ning tagastab vastava kolmnurga pindala. Võid eeldada, et argumentideks antud arvud sobivad kolmnurga küljepikkusteks.

Kirjuta veel üks kolmnurga pindala arvutamise funktsioon, kolmnurga_pindala_tippude_järgi, mis võtab argumentideks kolmnurga tippude koordinaadid (kokku 6 argumenti) ja tagastab neile vastava kolmnurga pindala.

Testi oma funktsioone!

6. Hulknurgad¶

Kirjuta funktsioon, mis võtab argumentideks külgede arvu ning küljepikkuse, ning joonistab kilpkonnaga neile vastava regulaarse hulknurga.

Joonista selle funktsiooni abil juhuslikesse ekraani kohtadesse, juhusliku suuruse ja külgede arvuga 30 hulknurka.

7. Puuduv funktsioon¶

Mis funktsiooniga on tegemist?

>>> fun1(-40)
-40.0
>>> fun1(0)
32.0
>>> fun1(22)
71.6
>>> fun1(39)
102.2
>>> fun1(100)
212.0

Kirjuta sellise käsureasessiooniga klappiv funktsioon.

8. Abifunktsioonid arvude küsimiseks¶

Kolmandas peatükis toodi ära üks skeem kasutajalt arvu küsimiseks niikaua, kuni sisestatud teksti tõesti on võimalik arvuks teisendada. Kuna taolist skeemi läheb vaja paljudes programmides (ning mõnes programmis palju kordi), võiks selle pakendada abifunktsiooniks.

Kirjuta funktsioonid input_int ja input_float, mis mõlemad võtavad argumendiks kasutajale esitatava teksti ning tagastavad kasutaja poolt sisestatud arvu, mis on juba teisendatud vastavalt int-iks või float-iks. Vigase sisendi puhul peavad funktsioonid küsimust kordama.

Demonstreeri nende funktsioonide kasutamist.

tkinter ja graafilise kasutajaliidesega programmid¶

Praeguseks tunned Pythonit juba piisavalt, et alustada graafiliste programmide loomisega. Kõik vajalikud funktsioonid selleks asuvad moodulis tkinter (ja selle alammoodulites).

Graafiliste programmide loomisel kasutatakse samu baaskonstruktsioone, mida oled siiani õppinud – avaldised, laused (tingimuslause, tsükkel), funktsioonid. Oluline erinevus on see, et kasutusele võetakse uued, spetsiifilisemad andmetüübid, mis esitavad kasutajaliidese komponente (nupud, sisestuskastid jne). Nendega toimetamine nõuab omajagu tähelepanu ja teadmisi detailide osas – näiteks kuidas paigutada mingit nuppu ekraanil õigesse kohta. Seetõttu tuleb ka arvestada, et graafilised programmid kipuvad olema nende detailide tõttu pikemad kui tekstipõhised programmid.

Nagu ikka, on mõttekas alustada millestki lihtsast. Vaata üle järgnev näiteprogramm ja katseta seda:

# impordi tk vidinad ja konstandid
from tkinter import *
# Pythoni moodulisüsteemi ühe nüansi tõttu tuleb ttk ja messagebox importida eraldi
from tkinter import ttk, messagebox

# loome ühe funktsiooni, mis käivitatakse nupule klõpsamisel
# (funktsiooni sidumine nupuga tehakse allpool)
def tervita():
    tervitus = 'Tere ' + nimi.get()
    messagebox.showinfo(message=tervitus)


# loome akna
raam = Tk()
raam.title("Tervitaja")  # määrame pealkirja
raam.geometry("300x100") # määrame akna suuruse

# loome tekstikasti jaoks sildi
# esimene argument (raam) näitab, et silt asub ülalpool loodud akna sees
silt = ttk.Label(raam, text="Nimi")
silt.place(x=5, y=5) # paigutame etteantud koordinaatidele

# loome tekstikasti
nimi = ttk.Entry(raam)
nimi.place(x=70, y=5, width=150)

# loome nupu ja seome selle ülalpool antud funktsiooniga (command=tervita)
nupp = ttk.Button(raam, text="Tervita!", command=tervita)
nupp.place(x=70, y=40, width=150)

# mainloop jälgib kasutaja tegevusi (nt. hiireklõpse)
# ja kutsub õigel hetkel välja õige funktsiooni (nt. tervita())
raam.mainloop()

Loodetavasti ilmus sinu ekraanile aken, kus oli võimalik sisestada mingi tekst ja vajutada nupule. Peale nupuvajutust pidi ilmuma uus väike aken tervitusega.

Kuigi see programm on suhteliselt lihtne ja lühike, illustreerib ta küllalt hästi graafiliste programmide põhimõtteid.

• Kuskil on olemas funktsioonid ja andmetüübid, mis oskavad ekraanile manada nuppe jms (antud juhul moodulid tkinter ja tkinter.ttk).
• Erinevaid kasutajaliidese komponente (e vidinaid) saab paigutada üksteise sisse (antud näites asuvad raam-i sees silt, nimi ja nupp).
• Vidinate loomisel saab määrata mitmeid erinevaid välimust puudutavaid omadusi (nt ... text="Tervita!" ...).
• Saab ka määrata, millise funktsiooni peab Python käivitama mingi kasutaja tegevuse e sündmuse korral (... command=tervita ...). Sündmustele vastamise funktsioonides võib teha mida iganes – lugeda ja kirjutada faile, tõmmata midagi internetist, muuta teiste vidinate sisu või välimust jne.
• Peale kasutajaliidese paikasättimist pannakse programm kasutaja tegevusi ootama (raam.mainloop()).

Järgmine samm oleks uurida välja, milliseid erinevaid kasutajaliidese komponente tkinter toetab ja kuidas neid kasutada. Kui sul on juba olemas projektiidee, mis vajab graafilist kasutajaliidest, siis tee oma tulevase programmi väljanägemisest lihtne visand ja proovi seda realiseerida tkinter-i abil.

Veel selgitusi, näiteprogramme ja linke lisainformatsioonile leiad õpiku lisast (tkinter).

Soovitame uurida ka järgnevaid linke, mis tutvustavad tkinter-i erinevaid vidinaid (vali lehekülje paremalt servast Show: Python, siis näidatakse näiteid ainult keeles Python).

• http://www.tkdocs.com/tutorial/widgets.html
• http://www.tkdocs.com/tutorial/morewidgets.html

tkinter.Canvas¶

Standardsed kasutajaliidese komponendid (nupud, sisestuskastid jms) on kasulikud ennekõike „asjalike“ programmide juures, aga näiteks mängude juures vajab programmeerija tavaliselt suuremat väljenduvabadust. Appi tuleb üks väga paindlik tkinter-i vidin, mille nimi on Canvas (tõlkes lõuend). Canvase peale saab joonistada kujundeid, laadida pilte, neid pilte ja kujundeid saab liigutada, nendele klõpsamist on võimalik registreerida jne.

Salvesta endale järgnev näiteprogramm. Enne käivitamist salvesta samasse kausta ka fail juku.gif.

from tkinter import *
from random import randint

# mõningad abikonstandid
juku_sammu_pikkus = 50
tahvli_laius = 600
tahvli_kõrgus = 600

# funktsioonid, mis käivitatakse vastavalt kasutaja tegevusele
def hiireklõps_juku_peal(event):
    # liigutan Juku juhuslikku positsiooni
    uus_x = randint(0, tahvli_laius-50)
    uus_y = randint(0, tahvli_kõrgus-50)
    tahvel.coords(juku_id, uus_x, uus_y)

def nool_üles(event):
    tahvel.move(juku_id, 0, -juku_sammu_pikkus)

def nool_alla(event):
    tahvel.move(juku_id, 0, juku_sammu_pikkus)

def nool_vasakule(event):
    tahvel.move(juku_id, -juku_sammu_pikkus, 0)

def nool_paremale(event):
    tahvel.move(juku_id, juku_sammu_pikkus, 0)


# tavaline raami ja tahvli loomine
raam = Tk()
raam.title("Tahvel")
tahvel = Canvas(raam, width=tahvli_laius, height=tahvli_kõrgus, background="white")
tahvel.grid()

# tavaline pildi sisselugemine
juku = PhotoImage(file="juku.gif")

# pildi loomisel jätan meelde pildi id
juku_id = tahvel.create_image(100, 100, image=juku)

# pildi id kaudu seon sellel pildil toimunud klõpsud vastava funktsiooniga
# <1> tähistab vasakut hiireklahvi
tahvel.tag_bind(juku_id, '<1>', hiireklõps_juku_peal)

# seon nooleklahvid vastavate funktsioonidega
raam.bind_all("<Up>",    nool_üles)
raam.bind_all("<Down>",  nool_alla)
raam.bind_all("<Left>",  nool_vasakule)
raam.bind_all("<Right>", nool_paremale)

raam.mainloop()

Käivita programm, vajuta nooleklahve, klõpsa hiirega kriipsujukul.

See näiteprogramm oli siinkohal mõeldud vaid isuäratajana – selleks, et sellest aru saada, loe esmalt lihtsamate Canvase programmide selgitusi õpiku lisast tkinter, jaotusest Tahvel (canvas).