decorar decoradores: tratar de conseguir mi cabeza alrededor de la comprensión de que

Question

Estoy tratando de entender la decoración decoradores, y quería probar el siguiente:

Digamos que tengo dos decoradores y aplicarlos a la función hola:

def wrap(f): 
    def wrapper(): 
     return " ".join(f()) 
    return wrapper 


def upper(f): 
    def uppercase(*args, **kargs): 
     a,b = f(*args, **kargs) 
     return a.upper(), b.upper() 
    return uppercase 

@wrap 
@upper 
def hello(): 
    return "hello","world" 

print hello() 

entonces tengo que empezar a añadir otros decoradores para otras funciones, pero en general el decorador envoltura se "envuelva todos ellos"

def lower(f): 
    def lowercase(*args, **kargs): 
     a,b = f(*args, **kargs) 
     return a.lower(), b.lower() 
    return lowercase 

@wrap 
@lower 
def byebye(): 
    return "bye", "bye" 

Ahora, ¿cómo puedo escribir un decorador, con la bruja que puedo decorar mis decoradores inferior y superior:

@wrap 
def lower(): 
    ... 

@wrap 
def upper(): 
    ... 

para lograr el mismo resultado que el anterior sólo haciendo:

@upper 
def hello(): 
    ... 

@lower 
def byebye(): 
    ... 

Answer 1

Aquí es una solución genérica (y un poco complicado) para la decoración de decoradores con decoradores (¡Sí!).

# A second-order decorator 
def decdec(inner_dec): 
    def ddmain(outer_dec): 
     def decwrapper(f): 
      wrapped = inner_dec(outer_dec(f)) 
      def fwrapper(*args, **kwargs): 
       return wrapped(*args, **kwargs) 
      return fwrapper 
     return decwrapper 
    return ddmain 

def wrap(f): 
    def wrapper(): 
     return " ".join(f()) 
    return wrapper 


# Decorate upper (a decorator) with wrap (another decorator) 
@decdec(wrap) 
def upper(f): 
    def uppercase(*args, **kargs): 
     a,b = f(*args, **kargs) 
     return a.upper(), b.upper() 
    return uppercase 

@upper 
def hello(): 
    return "hello","world" 

print hello() 

Answer 2

def upper(f): 
    @wrap 
    def uppercase(*args, **kargs): 
     a,b = f(*args, **kargs) 
     return a.upper(), b.upper() 
    return uppercase 

---

Un decorador en Python

@foo 
def bar(...): ... 

es j UST equivalente a

def bar(...): ... 
bar = foo(bar) 

Usted desea conseguir el efecto de

@wrap 
@upper 
def hello(): .... 

es decir

hello = wrap(upper(hello)) 

por lo que el wrap se recurrirá a ellas el valor retorno de upper:

def upper_with_wrap(f): 
    def uppercase(...): ... 
    return wrap(uppercase) 

que también es equivalente a aplicar el decorador en esa función:

def upper_with_wrap(f): 
    @wrap 
    def uppercase(...): ... 
    #^equivalent to 'uppercase = wrap(uppercase)' 
    return uppercase