python——闭包、装饰器

深碍√TFBOYSˉ_ 2021-12-21 05:47 312阅读 0赞

# 1. 看一个闭包的实际例子： #

def line_conf(a, b):
        def line(x):
            return a*x + b
        return line
    
    line1 = line_conf(1, 1)
    line2 = line_conf(4, 5)
    print(line1(5))
    print(line2(5))

这个例子中，函数line与变量a,b构成闭包。在创建闭包的时候，我们通过line\_conf的参数a,b说明了这两个变量的取值，这样，我们就确定了函数的最终形式(y = x + 1和y = 4x + 5)。我们只需要变换参数a,b，就可以获得不同的直线表达函数。由此，我们可以看到，闭包也具有提高代码可复用性的作用。  
如果没有闭包，我们需要每次创建直线函数的时候同时说明a,b,x。这样，我们就需要更多的参数传递，也减少了代码的可移植性。  
注意点:  
由于闭包引用了外部函数的局部变量，则外部函数的局部变量没有及时释放，消耗内存

# 2. 修改外部函数中的变量 #

python3的方法

def counter(start=0):
        def incr():
            nonlocal start
            start += 1
            return start
        return incr
    
    c1 = counter(5)
    print(c1())
    print(c1())
    
    c2 = counter(50)
    print(c2())
    print(c2())
    
    print(c1())
    print(c1())
    
    print(c2())
    print(c2())

# 3. 装饰器(decorator)功能 #

1.  引入日志
2.  函数执行时间统计
3.  执行函数前预备处理
4.  执行函数后清理功能
5.  权限校验等场景
6.  缓存  
    总结：在不改变源代码的情况下，增加新的功能（新的代码）。

# 4. 装饰器示例 #

### 例1:无参数的函数 ###

from time import ctime, sleep
    
    def timefun(func):
        def wrapped_func():
            print("%s called at %s" % (func.__name__, ctime()))
            func()
        return wrapped_func
    
    @timefun
    def foo():
        print("I am foo")
    
    foo()
    sleep(2)
    foo()

上面代码理解装饰器执行行为可理解成

foo = timefun(foo)
    # foo先作为参数赋值给func后,foo接收指向timefun返回的wrapped_func
    foo()
    # 调用foo(),即等价调用wrapped_func()
    # 内部函数wrapped_func被引用，所以外部函数的func变量(自由变量)并没有释放
    # func里保存的是原foo函数对象

# 例2:被装饰的函数有参数 #

from time import ctime, sleep
    
    def timefun(func):
        def wrapped_func(a, b):
            print("%s called at %s" % (func.__name__, ctime()))
            print(a, b)
            func(a, b)
        return wrapped_func
    
    @timefun
    def foo(a, b):
        print(a+b)
    
    foo(3,5)
    sleep(2)
    foo(2,4)

# 例3:被装饰的函数有不定长参数 #

from time import ctime, sleep
    
    def timefun(func):
        def wrapped_func(*args, **kwargs):
            print("%s called at %s"%(func.__name__, ctime()))
            func(*args, **kwargs)
        return wrapped_func
    
    @timefun
    def foo(a, b, c):
        print(a+b+c)
    
    foo(3,5,7)
    sleep(2)
    foo(2,4,9)

# 例4:装饰器中的return #

执行结果:

foo called at Fri Nov  4 21:55:35 2016
    I am foo
    foo called at Fri Nov  4 21:55:37 2016
    I am foo
    getInfo called at Fri Nov  4 21:55:37 2016
    None

如果修改装饰器为return func()，则运行结果：

foo called at Fri Nov  4 21:55:57 2016
    I am foo
    foo called at Fri Nov  4 21:55:59 2016
    I am foo
    getInfo called at Fri Nov  4 21:55:59 2016
    ----hahah---

### 总结： ###

一般情况下为了让装饰器更通用，可以有return

# 例5:装饰器带参数,在原有装饰器的基础上，设置外部变量 #

#decorator2.py
    
    from time import ctime, sleep
    
    def timefun_arg(pre="hello"):
        def timefun(func):
            def wrapped_func():
                print("%s called at %s %s" % (func.__name__, ctime(), pre))
                return func()
            return wrapped_func
        return timefun
    
    # 下面的装饰过程
    # 1. 调用timefun_arg("itcast")
    # 2. 将步骤1得到的返回值，即time_fun返回， 然后time_fun(foo)
    # 3. 将time_fun(foo)的结果返回，即wrapped_func
    # 4. 让foo = wrapped_fun，即foo现在指向wrapped_func
    @timefun_arg("itcast")
    def foo():
        print("I am foo")
    
    @timefun_arg("python")
    def too():
        print("I am too")
    
    foo()
    sleep(2)
    foo()
    
    too()
    sleep(2)
    too()

可以理解为`foo()==timefun_arg("itcast")(foo)()`

# 例6：类装饰器（扩展） #

装饰器函数其实是这样一个接口约束，它必须接受一个callable对象作为参数，然后返回一个callable对象。在Python中一般callable对象都是函数，但也有例外。只要某个对象重写了 **call**() 方法，那么这个对象就是callable的。

class Test():
        def __call__(self):
            print('call me!')
    
    t = Test()
    t()  # call me

类装饰器demo

class Test(object):
        def __init__(self, func):
            print("---初始化---")
            print("func name is %s"%func.__name__)
            self.__func = func
        def __call__(self):
            print("---装饰器中的功能---")
            self.__func()
    #说明：
    #1. 当用Test来装作装饰器对test函数进行装饰的时候，首先会创建Test的实例对象
    # 并且会把test这个函数名当做参数传递到__init__方法中
    # 即在__init__方法中的属性__func指向了test指向的函数
    #
    #2. test指向了用Test创建出来的实例对象
    #
    #3. 当在使用test()进行调用时，就相当于让这个对象()，因此会调用这个对象的__call__方法
    #
    #4. 为了能够在__call__方法中调用原来test指向的函数体，所以在__init__方法中就需要一个实例属性来保存这个函数体的引用
    # 所以才有了self.__func = func这句代码，从而在调用__call__方法中能够调用到test之前的函数体
    @Test
    def test():
        print("----test---")
    test()
    showpy()#如果把这句话注释，重新运行程序，依然会看到"--初始化--"

运行结果如下：

---初始化---
    func name is test
    ---装饰器中的功能---
    ----test---