Moodulid ja skoop¶

Ametlik terminoloogia: skoop¶

Funktsiooni sisemuse ja välismaailma tähistamiseks on tegelikult olemas spetsiaalsed terminid – lokaalne skoop (ingl local scope) ja globaalne skoop (ingl global scope). Lokaalne skoop tähistab seda piirkonda programmi tekstis, mis jääb mingi konkreetse funktsiooni definitsiooni sisse. Iga funktsiooni definitsioon moodustab omaette lokaalse skoobi. Kõik, mis jääb funktsioonide definitsioonidest väljapoole, on globaalne skoop (see väide on pisut lihtsustatud, aga praeguseks siiski piisavalt täpne).

Kui räägitakse mingist konkreetsest muutujast, siis võidakse ka öelda, et „sellel muutujal on <lokaalne või globaalne> skoop“ (see tähendab sama, mis „see muutuja on <lokaalne või globaalne>“).

Nimeruumid¶

Mingi funktsiooni sees kasutusele võetud (st. lokaalsete) muutujate kogumit nimetatakse selle funktsiooni lokaalseks nimeruumiks (local namespace). Kõigist mingi skripti e mooduli globaalsest muutujatest moodustub vastava mooduli globaalne nimeruum (global namespace). Kõige tähtsamad Pythoni funktsioonid (nt len, str, sum) on koondatud omaette nimeruumi, mida nimetatakse sisseehitatud nimeruumiks (builtin namespace).

Nimeruumide abil haldab Python muutujaid ja nende väärtusi programmi jooksutamise ajal. Nimeruumi võib kujutada ette kaheveerulise tabelina, mis seab mingi muutuja nime vastavusse mingi väärtusega. Näitena toome ühe lihtsa programmi ja sellele vastava globaalse nimeruumi nagu see näeks välja programmi lõppu jõudes:

x = 3
sõna = "tere"
x += 1

Nimeruumide kasutamine¶

Sisseehitatud nimeruum luuakse Pythoni interpretaatori käivitamisel ja see püsib Pythoni mälus kuni interpretaatori sulgemiseni.

Skripti/mooduli globaalne nimeruum luuakse skripti käivitamisel/mooduli laadimisel (st. esmakordsel importimisel) ja see püsib mälus (tavaliselt) kuni programmi sulgemiseni. Konktreetse skripti/mooduli käivitamise/laadimise alguses on tema nimeruum tühi. Uued kirjed tekivad ja olemasolevate kirjete väärtused muutuvad omistamislausete käivitamisel. Funktsioon globals() annab selle nimeruumi sisu tavalise Pythoni sõnastikuna.

Funktsiooni nimeruum luuakse igal funktsiooni väljakutsel uuesti ja see kustutatakse, kui funktsioon lõpetab. Funktsiooni käivitamisel täidetakse nimeruum juba ette funktsioonis defineeritud muutujate nimedega, v.a need nimed, mis on mainitud võtmesõna global järel. Väärtuste lahtrid jäetaks esialgu tühjaks. Funktsiooni täitmise käigus lokaalsesse nimeruumi enam uusi kirjeid ei teki, omistamislaused muudavad ainult olemasolevate kirjete väärtuse veergu (kui omistatakse globaalsetesse muutujatesse, siis muudetakse vastava mooduli globaalset nimeruumi). Funktsioon locals() annab selle nimeruumi sisu sõnastikuna.

Mingis avaldises esineva muutuja väärtustamiseks kasutab Python järgnevat skeemi:

1. kui avaldis asub funktsiooni kehas ja kui funktsiooni lokaalses nimeruumis leidub otsitav nimi, siis kasutatakse vastavat väärtust;
2. vastasel juhul otsitakse väärtust kõigepealt mooduli globaalsest nimeruumist;
3. kui globaalses nimeruumis vastet ei leidu, siis otsitakse sisseehitatud nimeruumist;
4. kui ka sisseehitatud nimeruumis vastet ei leidu, siis antakse veateade (NameError).

Moodul kui väärtus/objekt¶

Tuleb välja, et import-lause tekitab programmi uue muutuja, mille väärtuseks on samanimelises programmifailis sisalduvate funktsioonidefinitsioonide (ja teiste definitsioonide) kogum. Kuna sõna moodul kasutatakse ka programmifaili tähistamiseks, siis on tavaks import lausega tekitatud väärtust nimetada mooduli objektiks.

Nagu teame, on igal Pythoni väärtusel/objektil mingi tüüp, mis määrab ära, mida sellega teha saab. Uurime järele, mis on mooduli objekti tüüp:

>>> import math
>>> type(math)
<class 'module'>

Saime teada, et tegemist on tüübiga module. Arve saab liita ja korrutada, sõnesid saab teisendada suurtähtedeks jne. Mida saab teha module tüüpi objektiga?

Nagu mainitud, on moodul mingite definitsioonide kogum, seega võib arvata, et moodulilt saab küsida mingit definitsiooni. Nii see on – mingi moodulis sisalduva definitsiooni kasutamiseks tuleb kirjutada moodulit tähistava muutuja nimi, punkt ja definitsiooni nimi. Seega, kui oled mõnes oma programmis kasutanud avaldist math.pi, siis meie uue terminoloogia järgi võid öelda, et küsisid mooduli objektilt math defintsiooni pi väärtust.

Kuidas jääb aga avaldisega math.sqrt(4.0)? See avaldis on veid keerulisem, sest siin on kasutatud funktsiooni definitsiooni, aga pi oli lihtsalt mingi arv. Tuleb välja, et me võime selle avaldise veel osadeks võtta:

>>> import math

>>> math.sqrt
<built-in function sqrt>

>>> type(math.sqrt)
<class 'builtin_function_or_method'>

Nagu näha, õnnestus meil küsida definitsiooni sqrt väärtus ilma argumenti mainimata. Nii nagu mooduli objekti puhul, on tegemist väärtusega, mida ei ole lihtne ekraanil näidata, sellepärast näitabki käsurida ainult lühikest kirjeldust. Oluline on see, et nii kirjeldus kui ka väärtuse tüübi küsimine kinnitavad, et definitsiooni sisu on funktsioon (nimetatakse ka funktsiooni objekt).

Siiani oled harjunud funktsiooni mainima ainult koos argumendiga. Samas, kui järele mõelda, siis on täiesti loomulik, et iga funktsioon on ka ise, konkreetsetest argumentidest sõltumatult olemas.

Nagu juba tavaks saanud, küsime ka funktsioonitüüpi väärtuse puhul – mida sellega teha saab? Vastust oled juba eelnevates peatükkides kohanud – funktsiooni saab välja kutsuda e käivitada, kirjutades tema järele sulud ja sinna sisse 0 või rohkem argumenti. Seejuures pole oluline, kust ja kuidas me selle funktsioonitüüpi väärtuse saime. Selle demonstreerimiseks on järgnevas näites küsitud math mooduli käest mõned funktsioonid ja tehtud nendega kõikvõimalikke trikke:

>>> import math

>>> # salvestame uude muutujasse
>>> funktsioon = math.sqrt
>>> funktsioon(4.0)
2.0

>>> # alamavaldiste ümber võib panna sulge, järelikult peaks järgnev töötama
>>> (math.sqrt)(4.0)
2.0

>>> # proovime salvestada funktsiooni objektid järjendisse
>>> järjend = [math.sqrt, math.sin, math.cos]
>>> järjend[0]
<built-in function sqrt>
>>> järjend[0](4.0)
2.0
>>> järjend[1](0.5)
0.479425538604203
>>> järjend[2](0.5)
0.8775825618903728

Tänu Pythoni sellisele lähenemisele funktsioonidele saamegi väga lihtsalt öelda, mida mooduli objektiga saab teha – sellelt saab nime järgi küsida mingit väärtust (mis peab olema eelnevalt moodulis defineeritud). See, kas antud väärtus on mingi lihtne objekt (sõne või täisarv) või midagi keerulisemat (nt funktsioon), ning kuidas seda väärtust kasutada, on juba küsija mure.

from math import sin, cos
...

import math
sin = math.sin
cos = math.cos
del math # del eemaldab näidatud (s.o import lause poolt tekitatud) muutuja
...

Isetehtud moodulid¶

Pythoni installeerimisel tuleb kaasa suur hulk nn standardmoodule, mis paigutatakse kindlatesse kaustadesse, kust import-lause nad üles leiab. Neile lisaks on aga väga lihtne luua ka oma mooduleid – tegelikult saab igat skripti, mida siiani oled kirjutanud, kasutada Pythoni moodulina.

Kui tahad ühte oma moodulitest kasutada teises skriptis, siis on kõige kindlam, kui salvestad mõlemad failid samasse kausta. Salvesta järgnev näide faili nimega demomoodul.py:

eriline_arv = 42

def korruta(x):
    return x * eriline_arv

def tervita():
    print("Tervitused demomoodulist")

Samasse kausta salvesta (suvalise nimega) ka järgnev skript ja käivita see:

import demomoodul # mooduli nimeks saab failinimi ilma laiendita

print(demomoodul.eriline_arv)
print(demomoodul.korruta(2))
demomoodul.tervita()

Nendes skriptides, mida kavatsed kasutada moodulina (st importida mõnes teises skriptis) võiks sisalduda ainult definitsioonid. Nagu näitest näha, on Pythonis kaks viisi definitsioonide kirjutamiseks – uute funktsioonide defineerimiseks kasutatakse def konstruktsiooni ja lihtsamate definitsioonide jaoks võrdusmärki.

Mooduli sisu uurimine¶

Nagu öeldud, saab mooduli objektilt küsida mingile nimele vastavat väärtust. Kas see kirjeldus meenutab sulle ühte teist Pythoni andmetüüpi? Loodetavasti mäletad, et ka Pythoni sõnastikus sai mingi võtme järgi küsida sellega seotud väärtust. Moodulit võib tegelikult vaadelda justkui teatud kitsendustega sõnastikku – võti antakse punktiga, mitte kantsulgudes, ja võti peab alati olema mingi nimi.

Erinev on ka moodulis sisalduvate nimede loetlemine – selleks tuleb kasutada funktsiooni dir:

>>> import math
>>> dir(math)
['__doc__', '__name__', '__package__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2',
 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp',
 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'hypot',
 'isfinite', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'modf',
 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'trunc']