python高阶函数闭包装饰器_【Python入门】9.高阶函数之 闭包与装饰器，装饰器究竟是怎么运行的？...

目录

高阶函数

返回函数

闭包

装饰器

• 初步的装饰器

• 完整装饰器的构建

• 带参数的装饰器

高阶函数

====

返回函数

高阶函数除了可以把函数作为参数之外，还能把函数作为返回值返回。

如定义一个函数，在函数内部再定义一个函数，而外面的函数把内部函数作为返回值。def sum(*args):

def sum1():

a = 0

for n in args:

a = a + n        return a    return sum1

我们执行sum( )这个函数>>>f = sum(1, 2, 3)>>>f

.sum1 at 0x00000000021E37B8>

会发现返回的是一个函数sum1，而不是整数1，2，3的求和结果。我们需要调用函数f( )才能求出结果。>>>f()6

需要注意的是，每次调用sum( )，都会返回一个新的函数，即使传入的参数是相同的。>>>f1 = sum(1, 2, 3)>>>f2 = sum(1, 2, 3)>>>f1 == f2

False

闭包

在上面的例子中，我们称sum为外部函数，sum1为内部函数，内部函数可以引用外部函数的参数和局部变量，而当外部函数返回内部函数时，参数和局部变量都保存在返回的函数中，这种程序结构称为闭包。

需要注意的是，返回的函数并没有立刻执行直到被调用，因此在返回函数中最好不要引用任何循环变量或者后续会发生变化的变量，看个例子（以下例子转自廖雪峰的官方网站）。def count():

fs = []    for i in range(1, 4):        def f():

return i*i

fs.append(f)    return fs

f1, f2, f3 = count()

输出结果>>> f1()9>>> f2()9>>> f3()9

结果不是认为中的1，4，9，那是因为返回函数f引用的参数是i，而等到函数执行的时候，i等于3，因此f1，f2，f3的结果都是9。可以再定义一个函数来解决这个问题，但会略显麻烦。def count():

def f(j):

def g():

return j*j        return g

fs = []    for i in range(1, 4):

fs.append(f(i))               # f(i)立刻被执行，因此i的当前值被传入f()，返回的是函数g

return fs

输出结果>>> f1, f2, f3 = count()>>> f1()1>>> f2()4>>> f3()9

装饰器 Decorator

Decorator，在英文上是装饰师的意思。顾名思义，装饰器的作用就是装饰，在函数不需要做任何代码变动的前提下增加额外功能，增加比如插入日志、性能测试、权限校验等场景。实质上，Decorator是一个高阶函数，它传入一个函数，又返回一个函数，形成闭包的结构。下面将用一个简单的例子解释装饰器的工作原理。

首先我们定义两个简单的函数。def Ming():

print('I am Ming.')def Hong():

print('I am Hong.')

在解释之前插入一个小知识点，每个函数都有_name_属性，可以拿到函数的名字，如：>>>f = Ming>>>Ming.__name__Ming>>>f.__name__                   #这里由于函数MIng赋给变量f，所f的__name__属性也是Ming。Ming

再跟随上面的例子，我们希望在执行Ming函数时还能打印出函数的执行日志，于是可这样添加语句。def Ming():

print('Ming is running.')

print('I am Ming.')

运行结果>>>Ming()

Ming is running.

I am Ming.

那如果Hong也要这样打印执行日志呢，如果要每个函数都去修改的话就太麻烦了，于是我们可以先定义一个函数，函数的参数是要执行的函数，内容为先打印出执行日志，再执行需要的函数，像这样：def run(func):

print('%s is running' % func.__name__)

func()    return

def Ming():

print('I am Ming.')    return

运行结果>>>run(Ming)

Ming is running

I am Ming.

>>>run(Hong)

Hong is running

I am Hong.

• 初步的装饰器

但是这样的话，每次都要执行run函数，显得麻烦而且我们本来是执行Ming函数的，这样就破坏了代码的逻辑性。如果用装饰器的话就能简单地解决这些问题了。下面是一个简单的装饰器。def run(func):

def wrapper(*args, **kw):                            #wrapper在英文中是包装纸的意思

print('%s is runing.' % func.__name__)        return func(*args, **kw)    return wrapperdef Ming():

print('I am Ming.')

Ming = run(Ming)

运行一下Ming函数。>>>Ming()

Ming is runing.

I am Ming.

解释一下上面装饰器的运行过程。但我们执行run(Ming)时，返回的是wrapper函数，而根据wrapper函数的定义，它接收任意可变参数和关键字参数，然后执行print，打印出执行日志，然后返回func与其对应的参数，即返回Ming。所以最终的结果相当于打印出了执行日志，然后执行Ming函数。

• 完整装饰器的构建

再者，我们可以借助Python中的@符号，来避免每次定义函数后都要进行函数赋值的操作。在定义新的函数前加入@run即可，@run相当于执行了Ming = run(Ming)语句，像这样：def run(func):

def wrapper(*args, **kw):

print('%s is runing.' % func.__name__)        return func(*args, **kw)    return wrapper@rundef Ming():

print('I am Ming.')>>>Ming()

Ming is runing.

I am Ming.

运行结果与上面一样。

到目前为止，装饰器的建立差不多完成，但还有一个问题：在运行过程中，我们把原函数的信息给替换了，比如Ming的_name_属性。>>>Ming.__name__wrapper

这是因为在执行装饰器run的时候，直接返回的函数是wrapper，那么要解决这个问题只需要将func的函数名赋给wrapper即可，这里Python内置了functools.wraps这个函数，相当于执行了wrapper._name_ = func._name_。在装饰器定义中添加这个@functools.wraps( )，像这样：import functoolsdef run(func):    @functools.wraps(func)

def wrapper(*args, **kw):

print('%s is runing.' % func.__name__)        return func(*args, **kw)    return wrapper@rundef Ming():

print('I am Ming.')

运行一下Ming._name_>>>Ming.__name__Ming

问题解决。这样，上面的一个decorator，装饰器就是完整的装饰器了。

• 带参数的装饰器

当然我们还可以给装饰器加入更大的灵活性，如定义一个带参数的装饰器，这时就需要用三层嵌套的高阶函数了，如下import functoolsdef log(text):

def decorator(func):        @functools.wraps(func)

def wrapper(*args, **kw):

print('%s %s():' % (text, func.__name__))            return func(*args, **kw)        return wrapper    return decorator@run('Executed Successfully.')def Ming():

print('I am Ming.')

运行结果>>>Ming()

Ming is runing. Executed Successfully.

I am Ming.

作者：三贝_

链接：https://www.jianshu.com/p/b5a1502ad8a8