Senko’s corner of the Web

U objektno-orjentiranim jezicima korištenje API-ja se često izvodi tako da postoji bazna klasa koja implementira neku funkcionalnost ali sadrži i dummy metode koje u baznoj klasi ne rade ništa nego služe kao hookovi koje podklasa može koristiti da bi se integrirala sa radom bazne klase.

Tipičan primjer ovoga su callbackovi. Ukoliko podklasa želi instalirati callback za neki događaj (npr lijevi klik mišem nad labelom) može overloadati metodu koja se poziva na taj događaj (a koja u baznoj klasi ne radi ništa).
U PyQT-u (sintaksa ide po sjećanju) to izgleda otprilike ovako:

  class MyLabel(QLabel):
    def onKeyPress(self, event):
        ...do something...

Dva problema s ovim su: ukoliko želimo različitu funkcionalnost u keypress eventu za nekoliko objekata, moramo kreirati nekoliko različitih podklasa; a ukoliko netko drugi kreira objekt, ponekad ne možemo odrediti objekt koje klase treba instancirati.

Tipičan pattern za rješavanje potonjeg problema je Factory, odnosno klasa koja opisuje koju klasu želite instancirati. Ali, kako je Python dinamički jezik, imamo i alternativu – monkey-patch.

Monkeypatchiranje je tehnika mijenjanja ponašanja već postojećeg koda prilikom izvršavanja. Stvar je prilično moćna i lako se upucati u nogu, pa se obično ne preporuča ukoliko postoje bolji/elegantniji načini za rješavanje problema. Ali ovdje će nam izvrsno poslužiti da bi modificirali ponašanje već instanciranog objekta.

Mali snippet Python koda s kojim ćemo raditi:

  class Foo(object):
    def foo(self):
      print "foo called"
    def bar(self):
      print "bar called"

  x = Foo()
  x.bar() # ispisati će "bar called"

Ideja nam je overrideati metodu bar da ispiše nešto drugo:

  class Bar(Foo):
    def bar(self):
      print "different bar called"

  x = Bar()
  x.bar() # ispisati će "different bar called"

Zasad nema iznenađenja, ovo je standardni OOP. Ali što ako već imamo definiran ‘x’ kao instancu od Foo? Prva stvar koju možemo napraviti je promjeniti mu klasu:

   x = Foo()
   x.bar() # ispisuje "bar called"
   x.__class__ = Bar  # mijenjamo klasu objektu
   x.bar() # ispisuje "different bar called"

Ako vam ovo djeluje suludo, dobrodošli u dinamičke jezike ;-)

Još uvijek imamo problem sa činjenicom da moramo imati definiciju klase Bar. Ukoliko samo želimo promjeniti jednu metodu, ne da nam se svaki put pisati klasu. U tom slučaju možemo napraviti slijedeće:

def baz(self):
  print "yet another bar"

def add_method(obj, meth):
  obj.__class__ = type('newclassname', (Foo,), { 'bar': meth })

add_method(x, baz)
x.bar() # ispisuje "yet another bar"

Ovdje smo u tijeku izvođenja kreirali novu klasu “baz” koja naslijeđuje klasu Foo a ima jednu metodu zvanu “bar”, i promjenili postojećeg objekta u novkreiranu klasu.

Kao što se vidi, ovime možemo raditi prilično moćne modifikacije već postojećeg koda prilikom samog izvršavanja. Ali ovaj specifičan slučaj možemo rješiti i nešto jednostavnije i elegantnije:

def baz(self):
  print "yet another bar"

def add_method(obj, meth):
  setattr(obj, meth.__name__, lambda *args, **kwargs: meth(obj, *args, **kwargs))

add_method(x, baz)
x.baz() # ispisuje "yet another bar"

Ovaj put nismo morali generirati novu jednokratnu klasu samo da bi dodali metodu, nego smo funkciju dodali kao atribut objekta. Dodanu funkciju Python ne tretira magično kao metodu – da smo je samo dodali kao takvu, Python bi je tretirao kao obični callable atribut i samo je pozvao, pa kao prvi argument ne bi bila proslijeđena referenca na sam objekt. Kako bi se funkcija pozvala sa prvim argumentom objektom, morali smo kreirati closure koji je boundao referencu na objekt i proslijedio je funkciji kao prvi argument (tome služi ona lambda).

Update: Popravio poziv funkcije u zadnjem snippetu iz “x.bar()” u “x.baz()”, thx @nikolaplejic na uočavanju greške. Usput sam pokušao i malo pojasniti zašto je potrebno wrappati metodu i ručno proslijediti referencu na objekt.

Update 2: Ideja u članku je dodati metodu pojedinoj instanci objekta, ne proširiti cijelu klasu. Ukoliko želimo prilikom izvođenja dodati (ili izmjeniti) metode u nekoj klasi (a da to odmah bude vidljivo svim trenutnim i budućim instancama te klase, možemo napraviti slijedeće:

def baz(self):
  print "yet another bar"

x = Foo()
x.bar() # ispisuje "bar called"
Foo.bar = baz
x = Foo()
x.bar() # ispisuje "yet another bar"

U tom slučaju će se python čak pobrinuti oko automatskog bindanja metode instanci i proslijeđivanja reference kao prvog argumenta, i ovakav monkeypatching je relativno čest (iako još uvijek opasan ako se zloupotrebljava :) u Pyhtonu.