装饰器

# 一、不含参数的装饰器
#装饰无参数函数
def log(func):
    def warrper():
        print("before func() called.")
        ret = func()
        print("after func() called.")
        return ret
    return warrper
# 使用糖装饰now函数
@log
def now():
    print('func() called')

---------------------------------------------------------------------------

#装饰确定参数的函数
def deco(func):
    def warrper(a,b):
        print("before func() called.")
        ret = func(a,b)
        print("after func() called.")
        return ret
    return warrper

@deco
def func(a,b):
    print('func() called')
    return a+b

# 调用函数
print(func(3,5))

----------------------------------------------------------------------------------------

# 2、装饰不确定参数的函数
def log_single(func):
    def wrapper(*args,**dict):
        print("before func() called.")
        return func(*args,**dict)
    return wrapper

#在调用函数前后动态增加功能
def log_double(func):
    def wrapper(*args,**dict):
        print("before func() called.")
        func(*args,**dict)
        print("after func() called.")
        return func
    return wrapper

-----------------------------------------------------------------------------------------

# 二、含参数的装饰器

# 装饰器带参数
def deco(arg):
    def _deco(func):
        def __deco():
            print('call before',arg)
            ret = func()
            print('call after',arg)
            return ret
        return __deco
    return _deco

# 糖装饰
@deco('hello')
def func():
    print('func called')

# 调用
func()

# 执行结果
# call before hello
# func called
# call after hello

---------------------------------------------------------------------------------------

# 装饰器带类参数(类的静态方法)
class Locker:
    def __init__(self):
        print("locker.__init__() should be not called")
    @staticmethod
    def acquire():
        print("locker.acquire() called")
    @staticmethod
    def release():
        print("locker.release() called")

def deco(cls):
    "cls必须实现acquire 和release 的静态方法"
    def _deco(func):
        def __deco():
            print("before called")
            cls.acquire()
            ret = func()
            cls.release()
            return ret
        return __deco
    return _deco
# 糖装饰
@deco(Locker)
def func():
    print("func is called")

# 调用
func()

--------------------------------------------------------------------------------------------

# 装饰器带类参数(类的实例方法)
class Locker:
    def __init__(self):
        print("locker.__init__() should be not called")
    def acquire(self):
        print("locker.acquire() called")
    def release(self):
        print("locker.release() called")

def deco(self):
    "cls必须实现acquire 和release 的静态方法"
    def _deco(func):
        def __deco():
            print("before called")
            self.acquire()
            ret = func()
            self.release()
            return ret
        return __deco
    return _deco
# 糖装饰
l=Locker()
@deco(l)
def func():
    print("func is called")

# 调用
func()

# 执行结果
# locker.__init__() should be not called
# before called
# locker.acquire() called
# func is called
# locker.release() called

--------------------------------------------------------------------------------------------------

# 装饰器带类参数(公共类，一个函数应用多个装饰器)
class mylocker:
    def __init__(self):
        print("mylocker.__init__() called")
    @staticmethod
    def acquire():
        print("mylocker.acquire() called")
    @staticmethod
    def unlock():
        print("mylocker.unlock() called")

class lockerex(mylocker):
    @staticmethod
    def acquire():
        print("lockerex.acquire() called")
    @staticmethod
    def unlock():
        print("lockerex.unlock() called")

# 闭包函数
def deco(cls):
    def _deco(func):
        def __deco():
            cls.acquire()
            ret = func()
            cls.unlock()
            return ret
        return __deco
    return _deco

@deco(mylocker)
@deco(lockerex)
def func():
    print('func called')

# 函数调用
func()

# 执行结果
# mylocker.acquire() called
# lockerex.acquire() called
# func called
# lockerex.unlock() called
# mylocker.unlock() called