Ist es möglich, zu ersetzen, eine Funktion/Methode decorator zur Laufzeit? [ python ]

Wenn ich eine Funktion haben :


@aDecorator
def myfunc1():
  # do something here

if __name__ = "__main__":
  # this will call the function and will use the decorator @aDecorator
  myfunc1() 
  # now I want the @aDecorator to be replaced with the decorator @otherDecorator
  # so that when this code executes, the function no longer goes through
  # @aDecorator, but instead through @otherDecorator. How can I do this?
  myfunc1()

Ist es möglich, zu ersetzen, einem Dekorateur bei der Laufzeit?

InformationsquelleAutor Geo | 2009-03-13

Ich weiß nicht, ob es einen Weg gibt, um "ersetzen", "decorator", sobald es angewandt wurde, aber ich denke, dass wahrscheinlich es nicht, weil die Funktion wurde bereits geändert.

Kann man, eh, tragen Sie eine Dekorateurin zur Laufzeit basierend auf einer Bedingung:

#!/usr/bin/env python

class PrintCallInfo:
    def __init__(self,f):
        self.f = f
    def __call__(self,*args,**kwargs):
        print "-->",self.f.__name__,args,kwargs
        r = self.f(*args,**kwargs)
        print "<--",self.f.__name__,"returned: ",r
        return r

# the condition to modify the function...
some_condition=True

def my_decorator(f):
    if (some_condition): # modify the function
        return PrintCallInfo(f)
    else: # leave it as it is
        return f

@my_decorator
def foo():
    print "foo"

@my_decorator
def bar(s):
    print "hello",s
    return s

@my_decorator
def foobar(x=1,y=2):
    print x,y
    return x + y

foo()
bar("world")
foobar(y=5)

InformationsquelleAutor Paolo Tedesco

14

Als Miya erwähnt, können Sie ersetzen Sie den Dekorator mit einer anderen Funktion einem beliebigen Punkt vor der interpreter ruft die Funktion Erklärung. Allerdings, wenn der decorator wird angewendet auf die Funktion, ich glaube nicht, dass es eine Möglichkeit dynamisch ersetzen Sie den Dekorator mit einem anderen. So zum Beispiel:
```
@aDecorator
def myfunc1():
    pass

# Oops! I didn't want that decorator after all!

myfunc1 = bDecorator(myfunc1)
```
Wird nicht funktionieren, weil myfunc1 nicht mehr die Funktion, die Sie ursprünglich definiert; es ist bereits verpackt. Der beste Ansatz ist hier, um manuell anwenden Dekorateure, oldskool-Stil, ich.e:
```
def myfunc1():
    pass

myfunc2 = aDecorator(myfunc1)
myfunc3 = bDecorator(myfunc1)
```
Edit: Oder um es ein wenig klarer,
```
def _tempFunc():
    pass

myfunc1 = aDecorator(_tempFunc)
myfunc1()
myfunc1 = bDecorator(_tempFunc)
myfunc1()
```
- +1: aDecorate( func1 ) und bDecorate( func1 )
InformationsquelleAutor DNS

Hier ist eine tolle Rezept zum Einstieg. Grundsätzlich, die Idee ist, übergeben Sie eine Instanz der Klasse in den Dekorateur. Sie können dann festlegen, dass die Attribute, die auf die Instanz der Klasse (die machen es einem Borg, wenn Sie mögen) und verwenden, um das Verhalten der Dekorator selbst.

Hier ein Beispiel:

class Foo:
    def __init__(self, do_apply):
        self.do_apply = do_apply

def dec(foo):
    def wrap(f):
        def func(*args, **kwargs):
            if foo.do_apply:
                # Do something!
                pass 
            return f(*args, **kwargs)
        return func
    return wrap

foo = Foo(False)
@dec(foo)
def bar(x):
    return x

bar('bar') 
foo.do_apply = True 
# Decorator now active!
bar('baz')

Natürlich können Sie auch enthalten die "Dekorateur Dekorateur" zu bewahren, Signaturen, etc.

InformationsquelleAutor zweiterlinde

Sicher - Sie können die function-Objekt, und tun, was Sie will:

# Bypass a decorator

import types

class decorator_test(object):

    def __init__(self, f):
        self.f = f

    def __call__(self):
        print "In decorator ... entering: ", self.f.__name__
        self.f()
        print "In decorator ... exiting: ", self.f.__name__


@decorator_test
def func1():
    print "inside func1()"

print "\nCalling func1 with decorator..."
func1()

print "\nBypassing decorator..."
for value in func1.__dict__.values():
    if isinstance(value, types.FunctionType) and value.func_name == "func1":
        value.__call__()

Dieser übernimmt die Kontrolle über die erste Dekorator. Stellen Sie sich die Raumausstatter -def aDecorator(f): return lambda *args, **kwargs: "HAHAHAHAHAHAHA". Im Allgemeinen ist dies nicht in der Nähe ein Gültiger Ansatz. Wenn Sie do passieren die Kontrolle der erste Dekorator, dann gibt es Reiniger, mehr idiomatische Möglichkeiten, dies zu tun.

InformationsquelleAutor Freddie

0

Wenn Sie wollen ausdrücklich die änderung der Dekorateur, könnte man genauso gut wählen Sie einen expliziten Ansatz anstelle der Erstellung einer verzierten Funktion:
```
deco1(myfunc1, arg1, arg2)
deco2(myfunc1, arg2, arg3)
```
deco1() und deco2() für die Funktionen, die Ihre Dekorateure bieten und rufen myfunc1() mit den Argumenten.
- Ja, hätte ich eine Funktion, die nimmt eine Funktion als ersten param, meine Funktion als zweites param, gefolgt von den Argumenten, und haben eine ziemlich generische Art und Weise, es zu tun.Ich war interessiert, jedoch, wenn ich ersetzen können, Dekorateur mit meinen eigenen.Ich würde gerne "spielen" mit anderen Klassen, die das Verhalten der
InformationsquelleAutor

-1

Ich weiß, es ist ein Alter thread, aber ich hatte Spaß dabei

def change_deco(name, deco, placeholder='    #'):
with open(name + '.py', 'r') as file:
    lines = file.readlines()
for idx, string in enumerate(lines):
    if placeholder in string and repr(placeholder) not in string:
        lines[idx] = f'    @{deco}\r\n'
exec(''.join(lines))
return locals()[name]

InformationsquelleAutor

-2

Wenn der decorator ist eine Funktion, nur ersetzen.
```
aDecorator = otherDecorator
```
- Aber das wird sich nicht ändern myfunc1().
- Ich habe versucht mit deinem code, die Funktion noch ausgeführt wird, mit der ursprünglichen Dekorateur.
- wow.. wusste nicht, dass das passieren wird.
InformationsquelleAutor miya

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.