4. Funktsioonid [ülesannete katsetused]¶

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 me 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.

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ärgi!

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 me 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.

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, kuna 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 ning 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 võttes 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. 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.

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 importida eraldi
from tkinter import ttk

# 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).