【Python】闭包&装饰器

Summary

• 闭包
• 装饰器

最后修改时间：2021/3/4

一.闭包

1.闭包的概念

简单来说就是一个函数定义中引用了函数外定义的变量，并且该函数可以在其定义环境外被执行。

在一个外函数中定义了一个内函数，内函数里运用了外函数的临时变量，并且外函数的返回值是内函数的引用。这样就构成了一个闭包

def func():
    a = 100
    def war():
        print(a)
    return war

可以发现变量a是无法修改的，只能调用

2.形成闭包的条件

1. 必须有外层函数嵌套内层函数
2. 外层函数的返回值是内层函数
3. 内层函数必须引用外层函数的变量（不能是全局变量）

3.闭包和装饰器的区别

闭包和装饰器的区别，可以理解为装饰器是闭包的一种

二.装饰器

1.装饰器概念

针对函数来说，对于已有的函数A，可以新增方法使他变成函数B，但是不能改变A已有的逻辑

简单来说，装饰器可以对一个函数、方法或者类进行加工。在不修改代码原有功能的同时给代码拓展新的功能

举例说明

原本函数funa

def funa():
    print("writing")
    print("working")

funa()

然后给funa新增一个功能cook，但是不能修改funa的内部代码和调用方式

def decorator(func):
    def warp():
        print("cooking")
        func()
    return warp

@decorator
def func():
    print("writing")
    print("working")

func()

这里就使用闭包，构建了一个新的函数，新增了一个功能

@的作用

@decorator
def func():

这个@的作用等同于，给decorator函数传入func参数并返回给func

func = decorator(func)

运行下和有装饰器返回结果是一样的

2.装饰器应用

• 首先定义两个函数，一个是用来计算平方和的一个是用来计算平方差的

# get square sum
def square_sum(a, b):
    return a**2 + b**2

# get square diff
def square_diff(a, b):
    return a**2 - b**2


print(square_sum(3, 4))
print(square_diff(3, 4))

• 现在增加一个功能，打印输入的参数，实现方法可以使用以下方式，改写这个函数

# modify: print input

# get square sum
def square_sum(a, b):
    print("intput:", a, b)
    return a**2 + b**2

# get square diff
def square_diff(a, b):
    print("input", a, b)
    return a**2 - b**2

print(square_sum(3, 4))
print(square_diff(3, 4))

• 现在使用装饰器对这个函数进行修改，不用直接修改函数的代码

def decorator(F):
    def new_F(a, b):
        print("input", a, b)
        return F(a, b)
    return new_F

def test_deco(F):
    def new_F(a,b):
        print("hello",a,b)
        return F(a,b)
    return new_F

# get square sum
@decorator
def square_sum(a, b):
    return a**2 + b**2

# get square diff
@test_deco
def square_diff(a, b):
    return a**2 - b**2

print(square_sum(3, 4))
print(square_diff(3, 4))

这里用闭包的方法，构造一个叫decorator这个函数，用新的函数来装饰

装饰器接收被装饰函数作为参数，返回新的装饰函数

三.装饰带参函数

注意：函数有参数！

1.装饰一个参数的函数

如果被装饰函数有参数，在装饰器这里就需要定义参数来接收

def decorator(func):
    def warp(a,b):
        print("cooking")
        func(a,b)
    return warp

@decorator
def add_num(a,b):
    print(a+b)

add_num(2,5)

2.多个参数参数

如果被装饰的函数都有不同个数的参数传入，这里就需要*args不定参数，或者**kwargs不定键值对

def deco(fun):
    def warp(*args,**kwargs):
        print("begin")
        res = fun(*args,**kwargs)
        return res
    return warp

@deco
def funa(a):
    return a**2

@deco
def funb(a,b):
    return a+b

@deco
def func(a,b,c):
    return a*b*c


print(funa(2))
print(funb(2,3))
print(func(3,4,5))

所以定义装饰器之后最好定义成多个参数的函数

3.使用装饰器计算该函数的运行时间

主要思路为在函数运行前获取当前时间，函数运行后获取当前时间，然后相减

def count_time(func):
    
    def warp(*args, **kwargs):
        # 函数调用之前获取一下当前的实际：start_time
        start_time = time.time()
        # 调用原功能函数
        func(*args, **kwargs)
        # 函数调用之后：再获取一下当前时间 end_time
        end_time = time.time()
        print("running time:{}".format(end_time-start_time))
        
    return warp

四.带参数的装饰器——装饰器有参数

如果装饰器本身需要增加参数，就需要再加一个外部函数，再套一层才可以传参

1.没有加参数时候

def mid(func):
    def warp(a,b):
        print("before")
        res = func(a,b)
        print("after")
        return res
    return warp

@mid
def foo(a,b):
    return a+b

print(foo(2,3))
'''
结果：
before
after
5
'''

这里的实现逻辑是foo(2,3) = mid(foo(2,3)) = mid(warp(2,3))

2.增加一个参数

def outer(outer_arg):
    def mid(func):
        def warp(a,b):
            print("before")
            print("outer: "+outer_arg)
            res = func(a,b)
            print("after")
            return res
        return warp
    return mid

@outer("hello")
def foo(a,b):
    return a+b

print(foo(2,3))

另一个例子

# a new wrapper layer
def pre_str(pre=''):
    # old decorator
    def decorator(F):
        def new_F(a, b):
            print(pre + "input", a, b)
            return F(a, b)
        return new_F
    return decorator


# get square sum
@pre_str('^_^')
def square_sum(a, b):
    return a**2 + b**2

# get square diff
@pre_str('T_T')
def square_diff(a, b):
    return a**2 - b**2

print(square_sum(3, 4))
print(square_diff(3, 4))

3.总结

这里就需要三层嵌套，第一层传入装饰器的参数，第二层传入

五.一个函数被多个装饰器装饰

1.需要的装饰器

• 装饰器count_time：计算运行时间

import time

def count_time(func):

    def warp(*args, **kwargs):
        start_time = time.time()
        func(*args, **kwargs)
        end_time = time.time()
        print("running time:{}".format(end_time-start_time))

    return warp

• 装饰器doc

def doc(func):

    def wrapper(*args, **kwargs):
        print('一个叫doc的装饰器')
        # 调用原功能函数
        func(*args, **kwargs)

    return wrapper

• 运行函数

@count_time
@doc
def funa(a,b):
    print("a+b:",a+b)

funa(3,4)

2.运行先后顺序

@count_time
@doc
def funa(a,b):
    print("a+b:",a+b)

funa(3,4)

这个的实际运行逻辑也就是

funa = count_time(doc(funa))

增加打印

可以增加打印输出来判断对应的

import time

def count_time(func):

    def warp(*args, **kwargs):

        start_time = time.time()
        print("----------count1----------")
        func(*args, **kwargs)
        end_time = time.time()
        print("----------count2----------")
        print("running time:{}".format(end_time-start_time))

    return warp


def doc(func):

    def wrapper(*args, **kwargs):
        print("----------doc1----------")
        print('一个叫doc的装饰器')
        # 调用原功能函数
        func(*args, **kwargs)
        print("----------doc2----------")

    return wrapper


@count_time
@doc
def funa(a,b):
    print("----------funa----------")
    print("a+b:",a+b)

funa(3,4)

运行结果

----------count1----------
----------doc1----------
一个叫doc的装饰器
----------funa----------
a+b: 7
----------doc2----------
----------count2----------
running time:0.0

从结果看是一个很明显的嵌套展示

六.一个类被装饰

构建一个装饰类的装饰器

1.用闭包构建

最常见的用闭包来构建装饰类的，装饰器

def doc(func):
    """
    :param func: 接收被装饰的函数/类
    :return:
    """
    count[func] = 0
    def wrapper(*args, **kwargs):
        # 调用原功能函数
        count[func] += 1
        return func(*args, **kwargs)

    return wrapper

2.自定义可以装饰类的装饰器

使用cls表示没用被实例化的类本身，这里可以用来构建装饰类的装饰器

def class_decorate(cls):
    cls.name = 'musen'
    cls.age = 18
    return cls

3.python中类的内置装饰器

class MyTest:
    @classmethod
    def func(cls):
        print("类方法")

    @staticmethod
    def func01():
        print("静态方法")

    @property
    def name(self):
        print('只读属性')
        return '7890'

classmethod——类方法

classmethod 修饰符对应的函数不需要实例化，不需要 self 参数，但第一个参数需要是表示自身类的cls参数

• 好处：不需要实例化就可以调用

MyTest.func()
# 类方法

staticmethod——静态方法

静态方法不需要self方法，不需要cls方法，就当成使用函数一样。

• 可以类名.属性名or类名.方法名调用

property——把方法当成函数

property函数，可以将方法伪装成属性，在限制函数的私有属性上有用处

m = MyTest()
res = m.name
print(res)

这里的name原本是一个函数，使用property装饰，就可以用属性的方法调用

class Student(object):
    def __init__(self,score):
        self._score = score

    #这个用于伪装
    @property
    def score(self):
        return self._score

    #这个用于设置伪装
    @score.setter
    def score(self,new_value):
        if not isinstance(new_value, int):
            raise ValueError('score must be an integer!')
        if new_value < 0 or new_value > 100:
            raise ValueError('score must between 0 ~ 100!')
        self._score = new_value

七.装饰器类

用类来构建装饰器

1.类装饰器

使用类装饰器可以依靠类内部的__call__方法，在初始化函数中传入函数对象的参数，在__call__函数中实现附加的装饰功能，可以让对象像函数一样去调用

class Foo():
    def __init__(self, func):    # 初始化函数中传入函数对象的参数
        self._func = func
    def __call__(self,*args,**kwargs):    # 定义__call__方法，直接实现装饰功能
        start_time = time.time()
        self._func(*args,**kwargs)
        end_time = time.time()
        print('花费了 %.2f' % (end_time - start_time))

@Foo
def bar():
    print('bar函数的执行时间为：')
    time.sleep(2.5)

bar()
# bar = Foo(bar)

• 在定义初始化函数时候设置自定义变量，这里新增了一个下划线
• 定义call方法时候需要传入参数

2.带参数的类装饰器

如果需要实现的装饰器有参数，那么__init__函数就不能传入被装饰对象，需要传入参数，__call__函数用来实现装饰器功能

class MyClass(object):
    def __init__(self,arg):
        print("传入的参数：{}".format(arg))

    def __call__(self,func):
        def inner(*args,**kwargs):
            res = func(*args,**kwargs)
            print("装饰的功能")
            return res
        return inner

@MyClass("hello")
def demo():
    print("函数demo")

@MyClass("bye")
class Demo():
    def __init__(self):
        print("类demo")

demo()
m = Demo()

八.缓存装饰器lru_cache

实现原理：根据参数缓存每次函数调用结果，对于相同参数的，无需重新函数计算，直接返回之前缓存的返回值

import time
from functools import lru_cache

def Foo(func):
    def inner(*args,**kwargs):
        start_time = time.time()
        res = func(*args,**kwargs)
        end_time = time.time()
        print('花费了 %.2f' % (end_time - start_time))
        return res
    return inner


@Foo
def a(x=3):
    time.sleep(3)
    print(x)
    return x+1

print(a())
print(a())

在没有加上@lru_cache()之前，这个函数会被执行两次，加上装饰器之后，第二次执行相同参数的x=3，就不会执行这个函数，直接返回结果