Zapiski
Lastnosti
Najprej nekoliko nesmiselen primer.
class A:
def stevilka(self):
return 42
Priznam, ta je eden bolj nesmiselnih. Vse, kar lahko naredimo s tem razredom, je
>>> a = A()
>>> a.stevilka()
42
Kaj pa tole?
class A:
@property
def stevilka(self):
return 42
Tudi pred metode lahko postavljamo dekoratorje. Dekorator @property spremeni funkcijo v getter za lastnosti oz., no, atribute. Z drugimi besedami, s tem stevilka postane (vsaj, kakor je videti od zunaj) atribut.
>>> a = A()
>>> a.stevilka
42
Razlika med tem atributom in pravim atributom je v tem, da se ta računa, medtem ko pravi atribut "obstaja".
O mehanizmu, kako to deluje, se ne bomo pogovarjali. Le toliko povejmo: dekoratorji ne vračajo nujno funkcij in tale vrača nekaj drugega ... Več v dokumentaciji Pythona.
Na predavanjih iz Programiranja 1 smo menda napisali razred Vector.
Napišimo razred Vector s konstruktorjem, ki mu damo komponente (poljubno dimenzionalnega) vektorja.
class Vector:
def __init__(self, *v):
self.values = v
Dajmo tem vektorjem dolžino.
class Vector:
def __init__(self, *v):
self.values = v
@property
def length(self):
from math import sqrt
return sqrt(sum(x ** 2 for x in self.values))
Poskusimo.
>>> v = Vector(3, 4)
>>> v.length
5.0
Zdaj je videti kot da ima Vector tudi atribut length. V resnici pa ga vsakič sproti izračuna.
Nekateri pravijo, da bi morali biti vsi atributi dostopni le prek getterjev, prave vrednosti pa bi morale biti privatne. Tako razmišljujoči programerji bi Vector sprogramirali tako, da bi preimenovali values v _values, medtem ko bi values "ponudili" kot lastnost.
Podčrtaj na začetku imena Pythonu ne pomeni nič posebnega, nam, programerjem, pa pove, da se sme tega atributa dotikati le razred Vector, tisti, ki uporabljajo ta razred, pa ne. Torej:
class Vector:
def __init__(self, *v):
self._values = v
@property
def length(self):
from math import sqrt
return sqrt(sum(x ** 2 for x in self.values))
@property
def values(self):
return self._values
Navzven se ni spremenilo nič.
>>> v = Vector(3, 4)
>>> v.values
(3, 4)
>>> v.length
5.0
V ozadju pa je values zdaj lastnost in ne atribut. (Prevodi so zoprna reč. V angleščini govorijo o property in attribute. V slovenščini je oboje lastnost, zato puščam besedo attribute praktično neprevedeno.)
Pravzaprav ni čisto res, da se ni nič spremenilo. Če je values samo lastnost, je ne moremo nastavljati.
>>> v.values = (5, 6)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: can't set attribute
Seveda bi lahko rekli v._values = (5, 6), vendar tega ne smemo (čeprav deluje). Ker je tak pač dogovor glede imen, ki se začnejo s podčrtajem.
Tole ima določene prednosti. Recimo, da bi pogosto zahtevali dolžino vektorja. Namesto, da jo računamo vsakič posebej, jo lahko izračunamo enkrat za vselej in shranimo. Morda že kar v konstruktorju.
class Vector:
def __init__(self, *v):
from math import sqrt
self._values = v
self._length = sqrt(sum(x ** 2 for x in self.values))
@property
def values(self):
return self._values
@property
def length(self):
return self._length
Tole sicer ni bistveno drugače kot
class Vector:
def __init__(self, *v):
self._values = v
self.length = sqrt(sum(x ** 2 for x in self.values))
@property
def values(self):
return self._values
vendar počakajmo. Različica, po kateri je length lastnost, bo še koristna.
Lepota tega je, da bo dolžina vedno pravilna, saj nihče ne more spremeniti values. (Lahko bi spremenil le _values in posledično tudi values, vendar tega ne sme.)
Kaj pa, če želimo omogočiti spreminjanje values? V tem primeru potrebujemo setter. Getterje in setterje lahko določimo na različne načine. Tule se učimo le enega in skladno z njim se naš program nadaljuje takole
class Vector:
def __init__(self, *v):
self._values = v
self._length = sqrt(sum(x ** 2 for x in self.values))
@property
def values(self):
return self._values
@values.setter
def values(self, new_values):
self._values = new_values
self._length = sqrt(sum(x ** 2 for x in self.values))
@property
def length(self):
return self._length
Uporabimo nek hecen dekorator @values.setter, s katero okrasimo metodo, ki sprejema argument self (kot vse metode) in novo vrednost lastnosti, ki jo nastavljamo. Metoda mora nato narediti vse, kar je potrebno narediti,
ko nastavljamo to lastnost. Tule, konkretno, spremeni _values na novo vrednost, istočasno pa še ažurira self._length.
Lastne setterje lahko uporabljamo tudi sami. Tako lahko skrajšamo konstruktor.
class Vector:
def __init__(self, *v):
self.values = v
@property
def values(self):
return self._values
@values.setter
def values(self, new_values):
self._values = new_values
self._length = sqrt(sum(x ** 2 for x in self.values))
@property
def length(self):
return self._length
Ker smo v konstruktorje spremenili self._values = v v self.values = v, bo prirejanje poklicalo setter, ta pa bo poskrbel še za _length.
In zdaj še zadnji korak. Kaj pa, če določenega vektorja ne bo nihče vprašal po dolžini? Nekatere druge pa bodo stalno spraševali po dolžini?
class Vector:
def __init__(self, *v):
self.values = v
@property
def values(self):
return self._values
@values.setter
def values(self, new_values):
self._values = new_values
self._length = None
@property
def length(self):
if self._length is None:
self._length = sqrt(sum(x ** 2 for x in self.values))
return self._length
Setter za values zdaj nastavi _length na None, češ, dolžine pa še ne poznamo. Getter za length preveri, ali je dolžina že izračunana. Če ni (self._length is None), jo izračuna. Na koncu jo vrne - ne glede na to, ali je izračunana že od prej ali pravkar. Kasnejši klici length bodo vračali dolžino, ne da bi jo računali. Če kdo slučajno spremeni values na kako drugo vrednost, pa _length ponovno postavimo na None. Ko bo kasneje spet kdo poklical length, bomo dolžino tako izračunali na novo. Če ne bo nihče spraševal po dolžini, pa je pač ne bomo.