Wie kann ich dekorieren Sie eine Instanz-Methode mit einem decorator-Klasse?

Betrachten dieses kleine Beispiel:

import datetime as dt

class Timed(object):
    def __init__(self, f):
        self.func = f

    def __call__(self, *args, **kwargs):
        start = dt.datetime.now()
        ret = self.func(*args, **kwargs)
        time = dt.datetime.now() - start
        ret["time"] = time
        return ret

class Test(object):
    def __init__(self):
        super(Test, self).__init__()

    @Timed
    def decorated(self, *args, **kwargs):
        print(self)
        print(args)
        print(kwargs)
        return dict()

    def call_deco(self):
        self.decorated("Hello", world="World")

if __name__ == "__main__":
    t = Test()
    ret = t.call_deco()

dem Drucke

Hello
()
{'world': 'World'}

Warum ist die self parameter (das sollten die Test obj-Instanz) nicht bestanden, der als erstes argument an die eingerichtete Funktion decorated?

Wenn ich es manuell mache, wie :

def call_deco(self):
    self.decorated(self, "Hello", world="World")

funktioniert es wie erwartet. Aber wenn ich muss im Voraus wissen, ob eine Funktion eingerichtet ist oder nicht, es Niederlagen der ganze Zweck der Dekorateure. Was ist das Muster, hier zu gehen, oder mache ich etwas falsch verstanden?

Eine schnelle google auftaucht: thecodeship.com/patterns/guide-to-python-function-decorators (siehe Abschnitt "Dekorieren Methoden")
Haben Sie gelesen, z.B. stackoverflow.com/q/2365701/3001761, stackoverflow.com/q/15098424/3001761
Du wirst nicht auf diese Art von problem, wenn Sie eine Funktion als Dekorator statt eines callable-Objekts.

InformationsquelleAutor Rafael T | 2015-05-07

37

tl;dr

Dieses problem können Sie beheben, indem Sie die Timed Klasse a Deskriptor und die Rückgabe einer partiell angewandten Funktion von __get__ gilt die Test Objekt als eines der Argumente, wie diese
```
class Timed(object):
    def __init__(self, f):
        self.func = f

    def __call__(self, *args, **kwargs):
        print(self)
        start = dt.datetime.now()
        ret = self.func(*args, **kwargs)
        time = dt.datetime.now() - start
        ret["time"] = time
        return ret

    def __get__(self, instance, owner):
        from functools import partial
        return partial(self.__call__, instance)
```
Das eigentliche problem

Zitieren Python-Dokumentation für Dekorator,
Den Dekorator syntax ist lediglich syntaktischer Zucker, die beiden folgenden Funktionsdefinitionen sind semantisch äquivalent:
```
def f(...):
    ...
f = staticmethod(f)

@staticmethod
def f(...):
    ...
```
So, wenn Sie sagen,
```
@Timed
def decorated(self, *args, **kwargs):
```
ist es eigentlich
```
decorated = Timed(decorated)
```
nur die Funktion ein Objekt übergeben, um die Timed, das Objekt, zu dem es tatsächlich gebunden ist, nicht an, zusammen mit. Also, wenn Sie es aufrufen, wie dies
```
ret = self.func(*args, **kwargs)
```
self.func beziehen sich auf die ungebundene Funktion Objekt und es wird aufgerufen mit Hello wie das erste argument. Das ist, warum self Drucke als Hello.

Wie kann ich dieses Problem beheben?

Da Sie keinen Verweis auf die Test Instanz in der Timed, der einzige Weg, dies zu tun wäre, um zu konvertieren Timed als - Deskriptor-Klasse. Angabe der Unterlagen, Aufruf-Deskriptoren Abschnitt,

Im Allgemeinen ein Deskriptor ist ein Objekt-Attribut mit "Bindungsverhalten", eine, deren Attribut-Zugang wurde nicht durch Methoden, die in der Deskriptor-Protokoll: __get__(), __set__(), und __delete__(). Wenn eine dieser Methoden für ein Objekt definiert sind, es wird gesagt, um einen Deskriptor.

Das Standardverhalten für den Attribut-Zugriff zu erhalten, setzen oder löschen Sie das Attribut von einem Objekt im Wörterbuch. Zum Beispiel a.x hat eine lookup-Kette beginnend mit a.__dict__['x'], dann type(a).__dict__['x'], aus-und Weiterbildung durch die Basis-Klassen von type(a) ohne metaclasses.

Jedoch, wenn der gesuchte Wert ist ein Objekt, das die Definition eines Deskriptor-Methoden, dann Python können das Standardverhalten überschreiben und aufrufen der Deskriptor-Methode anstelle.

Können wir machen Timed einen Deskriptor, indem Sie einfach die Definition einer Methode, wie diese
```
def __get__(self, instance, owner):
    ...
```
Hier self bezieht sich auf die Timed Objekt selbst instance bezieht sich auf das aktuelle Objekt, auf dem der Attribut-lookup geschieht, und owner bezieht sich auf die Klasse entsprechend der instance.

Nun, wenn __call__ aufgerufen wird Timed, die __get__ - Methode aufgerufen wird. Nun, irgendwie müssen wir die ersten argument die Instanz des Test Klasse (noch vor Hello). Wir erstellen also ein anderes partiell angewandte Funktion, deren Erster parameter wird die Test Instanz, wie dies
```
def __get__(self, instance, owner):
    from functools import partial
    return partial(self.__call__, instance)
```
Nun self.__call__ ist eine gebundene Methode (gebunden Timed Instanz) und der zweite parameter partial ist das erste argument für die self.__call__ nennen.

So, all diese effektiv zu übersetzen, wie dies
```
t.call_deco()
self.decorated("Hello", world="World")
```
Nun self.decorated ist eigentlich Timed(decorated) (dies wird bezeichnet als TimedObject von nun an) Objekt. Wenn wir darauf zugreifen, die __get__ Methode definiert ist, wird Sie aufgerufen, und es gibt eine partial Funktion. Können Sie bestätigen, dass, wie dies
```
def call_deco(self):
    print(self.decorated)
    self.decorated("Hello", world="World")
```
drucken würde
```
<functools.partial object at 0x7fecbc59ad60>
...
```
So,
```
self.decorated("Hello", world="World")
```
übersetzt wird, zu
```
Timed.__get__(TimedObject, <Test obj>, Test.__class__)("Hello", world="World")
```
Da kehren wir ein partial Funktion,
```
partial(TimedObject.__call__, <Test obj>)("Hello", world="World"))
```
was ist eigentlich
```
TimedObject.__call__(<Test obj>, 'Hello', world="World")
```
So, <Test obj> wird auch ein Teil der *args, und wenn self.func ist aufgerufen, das erste argument wird sein, die <Test obj>.

Warum eine functool.partial anstelle des integrierten dedizierten types.MethodType ?
Vielen Dank für diese umfassende Antwort - ich werde es Lesen ein paar mal zu grok, aber ich bin zuversichtlich, dass ich werde! Als ich zuerst versucht, die Anwendung dieser, ich Links von der (object) in der definition von meinem decorator - so, ich hatte gerade class Timed: - und ich habe immer noch die OP ' s ursprüngliche Fehler. Könnten Sie mir auf das richtige Konzept zu Lesen, um zu verstehen, warum?
Waren Sie in Python2.7? 2.7 Sie wollen, stellen Sie sicher, jede Klasse erbt von object; diese Vererbung ist standardmäßig in Python ist3. Ich weiß nicht, konkret, warum dies manifestiert sich in einem bug, aber das ist die wahrscheinlich Täter - type(YourClass) sollte type, nicht classobj.
Können Sie bitte erklären, warum def check_authorization(f): def wrapper(*args): print(args[0].url) return f(*args) return wrapper class Client(object): def __init__(self, url): self.url = url @check_authorization def get(self): print('get') hier funktioniert? wäre es nicht auch ungebunden?

InformationsquelleAutor thefourtheye
9

Müssen Sie zunächst verstehen,wie die Funktion zu Methoden und wie self "automagisch" injiziert.

Sobald Sie wissen, dass das "problem" liegt auf der Hand: Sie schmücken die decorated Funktion mit einem Timed Instanz - IOW, Test.decorated ist ein Timed Instanz, nicht eine function Instanz - und Ihr Timed Klasse nicht imitieren die function geben Sie die Implementierung der descriptor Protokoll. Was Sie wollen, sieht wie folgt aus:
```
import types

class Timed(object):
    def __init__(self, f):
        self.func = f

    def __call__(self, *args, **kwargs):
        start = dt.datetime.now()
        ret = self.func(*args, **kwargs)
        time = dt.datetime.now() - start
        ret["time"] = time
        return ret

   def __get__(self, instance, cls):           
       return types.MethodType(self, instance, cls)
```
Danke, das hat geholfen. Man aber beachten Sie, dies funktioniert nicht Python 3, da ungebundene Methoden nicht mehr existieren (MethodType nur zwei Argumente nimmt, und die zweite darf nicht sein, Keiner). Für Python 3 die alternative wäre: return types.MethodType(self, instance) if instance else self.

InformationsquelleAutor bruno desthuilliers

-2

Benutze ich Dekorateure in der folgenden Weise:

def timeit(method):
    def timed(*args, **kw):
        ts = time.time()
        result = method(*args, **kw)
        te = time.time()
        ts = round(ts * 1000)
        te = round(te * 1000)
        print('%r (%r, %r) %2.2f millisec' %
             (method.__name__, args, kw, te - ts))
        return result
    return timed


 class whatever(object):
    @timeit
    def myfunction(self):
         do something

InformationsquelleAutor PyNico

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.