Wie gebe ich zusätzliche Argumente, um eine Python-decorator?

Habe ich eine decorator wie folgt Aussehen.

def myDecorator(test_func):
    return callSomeWrapper(test_func)
def callSomeWrapper(test_func):
    return test_func
@myDecorator
def someFunc():
    print 'hello'

Möchte ich zur Verbesserung dieser Dekorator zu akzeptieren, ein anderes argument, wie unten

def myDecorator(test_func,logIt):
    if logIt:
        print "Calling Function: " + test_func.__name__
    return callSomeWrapper(test_func)
@myDecorator(False)
def someFunc():
    print 'Hello'

Aber dieser code gibt den Fehler,

TypeError: myDecorator() takes exactly 2 arguments (1 given)

Warum wird die Funktion nicht automatisch weitergeleitet? Wie kann ich explizit übergeben Sie der Funktion, die an den Dekorator-Funktion?

balki: bitte vermeiden Sie die Verwendung von boolean als argument, es ist kein gd Ansatz und reduzieren-code readliability
es ist ein boolean-flag, also ein boolean-Wert ist der richtige Ansatz.
was ist "gd"? Ist es "gut"?

InformationsquelleAutor balki | 2012-04-16

130

Da Sie den Aufruf des Dekorateurs, wie eine Funktion, zu der es zurückkehren muss eine weitere Funktion, die die eigentliche decorator:
```
def my_decorator(param):
    def actual_decorator(func):
        print("Decorating function {}, with parameter {}".format(func.__name__, param))
        return function_wrapper(func)  # assume we defined a wrapper somewhere
    return actual_decorator
```
Der äußeren Funktion gegeben werden keine Argumente übergeben Sie ausdrücklich, und sollte die Rückkehr der inneren Funktion. Die innere Funktion übergeben werden, die Funktion zu schmücken, und die geänderte Funktion.

In der Regel will man das decorator zu ändern, das Verhalten der Funktion durch das einwickeln von es in einem wrapper-Funktion. Hier ist ein Beispiel, das Optional fügt Protokollierung, wenn die Funktion aufgerufen wird:
```
def log_decorator(log_enabled):
    def actual_decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            if log_enabled:
                print("Calling Function: " + func.__name__)
            return func(*args, **kwargs)
        return wrapper
    return actual_decorator
```
Den functools.wraps Aufruf kopiert Dinge wie den Namen und den docstring der wrapper-Funktion, machen es ähnlich wie die ursprüngliche Funktion.

Beispiel:
```
>>> @log_decorator(True)
... def f(x):
...     return x+1
...
>>> f(4)
Calling Function: f
5
```
Und mit functools.wraps ist ratsam-es behält den ursprünglichen Namen, den docstring, etc. der umschlossene Funktion.
Danke, ich habe dies nur Hinzugefügt, um das zweite Beispiel.
Also im Grunde Dekorateur dauert immer nur ein argument, nämlich die Funktion. Aber der Dekorateur kann ein Rückgabewert einer Funktion kann Argumente annehmen. Ist das richtig?
Ja, das ist richtig. Was verwirrt die Dinge ist, dass viele Menschen sich auch an den äußeren Funktion (myDecorator hier) ein Dekorateur. Dies ist bequemer für einen Benutzer, der Dekorateur, kann aber verwirrend sein, wenn Sie versuchen, eine zu schreiben.

InformationsquelleAutor interjay
38

Nur um eine andere Sicht: die syntax
```
@expr
def func(...): #stuff
```
entspricht
```
def func(...): #stuff
func = expr(func)
```
Insbesondere expr werden können, was Sie wollen, solange es wertet ein callable. In insbesondere insbesondere expr kann ein decorator factory: Sie geben es einige Parameter, und es gibt Ihnen ein Dekorateur. Also vielleicht einen besseren Weg zu verstehen, Ihre situation so ist, wie
```
dec = decorator_factory(*args)
@dec
def func(...):
```
kann dann gekürzt werden
```
@decorator_factory(*args)
def func(...):
```
Natürlich, da es sieht wie decorator_factory ist ein Dekorateur, Menschen neigen dazu, es zu benennen, zu reflektieren. Das kann verwirrend sein, wenn Sie versuchen, Folgen die Ebenen der Dereferenzierung.

InformationsquelleAutor Katriel

Möchte nur hinzufügen einige nützliche trick, dass wird es ermöglichen, Dekorateur Argumente optional. Es wird auch alows, um die Wiederverwendung von decorator und verringern Schachteln

import functools

def myDecorator(test_func=None,logIt=None):
    if not test_func:
        return functools.partial(myDecorator, logIt=logIt)
    @functools.wraps(test_func)
    def f(*args, **kwargs):
        if logIt==1:
            print 'Logging level 1 for {}'.format(test_func.__name__)
        if logIt==2:
            print 'Logging level 2 for {}'.format(test_func.__name__)
        return test_func(*args, **kwargs)
    return f

#new decorator 
myDecorator_2 = myDecorator(logIt=2)

@myDecorator(logIt=2)
def pow2(i):
    return i**2

@myDecorator
def pow3(i):
    return i**3

@myDecorator_2
def pow4(i):
    return i**4

print pow2(2)
print pow3(2)
print pow4(2)

InformationsquelleAutor Alexey Smirnov

Nur eine andere Art zu tun, Dekorateure.
Ich finde diese Art am einfachsten zu wickeln meinem Kopf herum.

class NiceDecorator:
    def __init__(self, param_foo='a', param_bar='b'):
        self.param_foo = param_foo
        self.param_bar = param_bar

    def __call__(self, func):
        def my_logic(*args, **kwargs):
            # whatever logic your decorator is supposed to implement goes in here
            print('pre action baz')
            print(self.param_bar)
            # including the call to the decorated function (if you want to do that)
            result = func(*args, **kwargs)
            print('post action beep')
            return result

        return my_logic

# usage example from here on
@NiceDecorator(param_bar='baaar')
def example():
    print('example yay')


example()

InformationsquelleAutor Robert Fey

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.