闭包和装饰器

最新推荐文章于 2023-07-03 14:51:12 发布

沟通障碍的游戏废人

最新推荐文章于 2023-07-03 14:51:12 发布

阅读量104

点赞数

本文链接：https://blog.csdn.net/riku22/article/details/97956738

版权

文章目录

闭包
装饰器

闭包

闭是封闭（函数中的函数），包是包含（该内部函数对外部函数作用域而非全局作用域变量的引用）。

内部作用域对外部函数作用域里的变量的引用
函数内的属性，都是有生命周期，都是在函数执行期间
闭包内的闭包函数私有化了变量

def foo():
    print('in foo()')
    def bar():
        print('in bar()')

# 1.直接运行内部函数报错
# bar()

# 2.先运行外部函数，再运行内部函数，依然会报错
# foo()
# bar()

由于作用域的问题，函数内的属性，都是有生命周期的，只有在函数执行期间

只有调用foo()时，内部的print()及bar()才能存活。

把foo的返回值设置成bar

def foo():
    print('in foo()')
    def bar():
        print('in bar()')
    return bar

var = foo()
var()
#输出
in foo()
in bar()

内部函数对外部函数作用域变量的引用

li = [1, 2, 3, 4, 5]


def foo(obj):
    print('foo:', obj)

    def bar():
        obj[0] += 1
        print('bar:', obj)

    return bar


var = foo(li)
var()
#输出
foo: [1, 2, 3, 4, 5]
bar: [2, 2, 3, 4, 5]

装饰器

装饰器存在的意义

不影响原有函数的功能
可以添加新功能

一般常见的，比如拿到第三方的API接口，第三方不允许修改这个接口。这个时候，装饰器就派上用场。

装饰器本身也是一个函数，作用为现有存在的函数，在不改变函数的基础上，增加一些功能进行装饰。

以闭包的形式实现。

在使用装饰器函数时，在被装饰的函数的前一行，使用’@装饰器函数名’的形式来进行装饰。

Demo：

import time


def my_count():
    s = 0
    for i in range(1000001):
        s += i
    print('s:', s)
start = time.time()
my_count()
end = time.time()
print(end-start)
#输出
s: 500000500000
0.17095065116882324

实现了时间的计算，如果函数很多，每个函数都要写就很麻烦。通过另一个函数也可以计算时间

import time


def my_count():
    s = 0
    for i in range(1000001):
        s += i
    print('s:', s)


def count_time(func):
    start = time.time()
    func()
    end = time.time()
    print(end - start)


count_time(my_count)

但仍然修改了函数使用方式。所以使用装饰器。

import time


def count_time(func):
    def wrapper():
        start = time.time()
        func()
        end = time.time()
        print('用时:', end - start)

    return wrapper


@count_time
def my_count():
    s = 0
    for i in range(1000001):
        s += i
    print('s:', s)


my_count()  
#输出
s: 500000500000
用时: 0.17102622985839844

这样实现的好处在于只需要通过’@装饰器函数名’形式的装饰器语法，就可以将’@装饰器函数名’加到要装饰的函数前即可。

这种不改变原有函数功能，对函数进行拓展的形式，就成为’装饰器’,

在执行’@装饰器函数名’时，就是将原函数传递到闭包中，然后原函数的引用指向闭包返装饰过的内部函数的引用。

添加功能而不改变原函数的引用。

装饰器的几种形式

无参无返回值

def setFunc(func):
    def wrapper():
        print('Start')
        func()
        print('End')  

    return wrapper


@setFunc
def show():
    print('show')


print(show())  
#输出
Start
show
End
None

无参有返回值

def setFunc(func):
    def wrapper():
        print('Start')
        return func()
        print('End')   #return后面的不执行

    return wrapper


@setFunc
def show():
    return 'show'


print(show())
#输出
Start
show

有参无返回值

def setFunc(func):
    def wrapper(s):    #参数传递
        print('Start')
        func(s)     
        print('End')  

    return wrapper


@setFunc
def show(s):
    print('Hello %s' % s)


print(show('City College'))
#输出
Start
Hello City College
End
None

有参有返回值

def setFunc(func):
    def wrapper(s):
        print('Start')
        return func(s)

    return wrapper


@setFunc
def show(s):
    return 'Hello %s' % s


print(show('City College'))
#输出
Start
Hello City College

万能装饰器

根据被装饰函数的定义不同，分出了四种形式。

使用万能装饰器可以接收任何形式的函数。

def setFunc(func):
    def wrapper(*args, **kwargs):
        print('Wrapper context.')
        return func(*args, **kwargs)

    return wrapper


@setFunc
def add1(x, y):
    return x + y


@setFunc
def add2():
    print(15)


@setFunc
def add3(x, y):
    print(x + y)


@setFunc
def add4():
    return 100


@setFunc
def demo(a, b, *c, **d):
    print(a)
    print(b)
    print(c)
    print(d)


print(add1(1, 4))
add2()
add3(12, 20)
print(add4())
demo('abc', 1, 'wow', 'riku', AllMight='hero', k='people')
#输出
Wrapper context.
5
Wrapper context.
15
Wrapper context.
32
Wrapper context.
100
Wrapper context.
abc
1
('wow', 'riku')
{'AllMight': 'hero', 'k': 'people'}

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

def setFunc1(func):
    def wrapper1(*args, **kwargs):
        print('Wrapper Context 1 Start.'.center(40, '-'))
        func(*args, **kwargs)
        print('Wrapper Context 1 End.'.center(40, '-'))

    return wrapper1


def setFunc2(func):
    def wrapper2(*args, **kwargs):
        print('Wrapper Context 2 Start.'.center(40, '-'))
        func(*args, **kwargs)
        print('Wrapper Context 2 End.'.center(40, '-'))

    return wrapper2


@setFunc1
@setFunc2
def show(*args, **kwargs):
    print('Show Run.'.center(40,' '))


show()
#从下往上去装饰     （程序语句运行顺序来看）
#从内往外去装饰     （函数的调用来看）
#输出
--------Wrapper Context 1 Start.--------
--------Wrapper Context 2 Start.--------
               Show Run.                
---------Wrapper Context 2 End.---------
---------Wrapper Context 1 End.---------