Python的闭包和装饰器

Posted 玄离199

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Python的闭包和装饰器相关的知识,希望对你有一定的参考价值。

闭包

变量作用域

作用域是程序运行时变量可以被引用的范围。

  • 函数内部的变量被称为局部变量,它只能在函数内部中被引用。
  • 定义在代码最外层的变量为全局变量,它可以整个代码中被引用。

在函数内部可以访问全局变量,在函数外部不能访问局部变量。

函数嵌套

把一个函数定义在另外一个函数的内部,就是函数嵌套。外边的函数为外层函数,里边的函数为内层函数。

闭包

在函数嵌套中,内层函数对外层函数的局部变量进行了引用,并且外层函数的返回值是内层函数的引用,就构成了一个闭包。

def outer(a, b):
    a = a
    b = b
    def inside():
        print(a+b)
    return inside


function_inside = outer(10, 20)
function_inside()

运行结果:

30
  • 函数是一个对象,可以作为返回值被返回,也可以作为参数被传递。
  • 函数执行完毕后变量会被回收,但是因为内层函数对外部函数的变量进行了引用,所以即使外层函数执行完毕,变量也不会被回收。
  • 修改外层函数的变量使用nonlocal关键字

    创建一个闭包

  • 闭包函数必须有函数嵌套
  • 内层函数需要引用外层函数中的变量
  • 闭包函数必须返回内层函数的引用

注意点

  1. 闭包就是函数和函数独有的数据 结合在一起,它比类要轻量级,比一般的函数功能更强。

  2. 每次调用外层函数都会创建一个新的闭包对象。

  3. 内层函数没有引用的变量会在外层函数执行结束后销毁。

    装饰器

问题提出

  1. 当电脑的硬盘空间不够用的时候。
  2. 我们能想到的一个办法就是把电脑拆开,再添加一块硬盘。(功能增强)
  3. 但是这样做,不仅麻烦,而且改变了原有的电脑结构。(复杂,改变了原有函数)
  4. 我们不想做改变原有电脑这么复杂的事情,但是又要储存更多东西。
  5. 所以聪明的人就发明了移动硬盘,它可以在不改变原有结构的情况下,又做了功能增强,并且还可以为被多个电脑使用,一台电脑也可以使用多个移动硬盘。(功能增强,方便,不改变原有函数)

而我们需要给函数增加新的功能,又不想改变函数的代码的时候,便用到了 装饰器

python函数

python函数可以被当作参数传递给其他函数。

def say(func):
    func()


def test():
    print("this is a function")


say(test)

运行结果:

this is a function

python的函数可以像变量一样作为返回值返回,被定义在函数内部,而且还可以作为参数被传递。

装饰器

原有函数:

def test():
    print("this is a function")

现在需要给函数增加另外一个功能,限制该函数的调用。

print("use limit")

把功能加入到函数内部

我们可以直接把功能加入到函数内部:

def test():
    print("use limit")
    print("this is a function")


test()

但是如果有函数test1、test2()...也想使用该功能,我们就需要一一修改,这就造成了:

  1. 修改工作量巨大
  2. 造成大量的重复代码
  3. 不利于以后功能的添加

定义一个新的函数

我们可以定义一个新的函数,来完成新增加的功能,把原有函数当作参数传入新函数执行。

def limit(func):
    print("use limit")
    func()


def test():
    print("this is a function")


limit(test)

这样不仅没修改原有的函数,而且增加了新的功能,但是也存在新的问题:

  1. 调用的时候,不是在调用 test 而是调用新函数 limit
  2. 每次使用 test 函数的时候都需要调用 limit ,如果有已存在的调用,将无法使用新加入的功能,会对代码结构造成破环。

使用装饰器

如果想对函数增加新的功能,并且不修改原有函数,且调用方式不做出改变的话,就要使用装饰器。

简单的装饰器实现:

def limit(func):
    def addlimit():
        print("use limit")
        func()
    return addlimit


def test():
    print("this is a function")


test = limit(test)


test()

函数 limit 就是一个装饰器,它把函数 test 当作参数传入,在内层函数中增加功能后,又把内层函数返回,重新赋值给 test 变量。这里使用到了闭包,外层函数负责接收要修饰的函数,返回修饰后的函数,内层函数赋值修饰传入的函数。

装饰器的进阶

@语法糖

装饰器的使用有一种简写方式,就是在函数定义之前使用 @ +装饰器名字:

def limit(func):
    def addlimit():
        print("use limit")
        func()
    return addlimit

@limit  # 相当于test = limit(test)
def test():
    print("this is a function")


test()

@limit 便相当于 test = limit(test)

使用@语法糖 便相当于把定义在后边的函数当作参数传入装饰器。
  • 可以省去最后一步再赋值的操作,使用方便。
  • 可以不修改原有的函数增加新的功能。
  • 不改变函数的调用方式。
  • 可以为多个函数进行装饰。

被装饰函数带有参数

def limit(func):
    def addlimit(a, b):
        print("use limit")
        func(a, b)
    return addlimit


@limit
def test(a, b):
    print("I tell you : %s" % a)
    print("I tell you : %s" % b)


a = "hello"
b = "hi"
test(a, b)

因为装饰器调用的是闭包中的内部函数,所以我们先在内部函数接收参数,再传递给被装饰的函数。这样,参数经过传递便被传递给了原有的 test 函数。

但是,如果其他函数不是两个参数,在使用该装饰器的时候,便会运行错误,为了装饰器的通用性,我们可以用不定长位置参数 *args 和关键字参数 **kwargs

使用不定长参数

def limit(func):
    def addlimit(*args, **kwargs):
        print("use limit")
        func(*args, **kwargs)
    return addlimit


@limit
def test(a, b):
    print("I tell you : %s" % a)
    print("I tell you : %s" % b)


@limit
def test1(a, b, c):
    print("I tell you : %s" % a)
    print("I tell you : %s" % b)
    print("I tell you : %s" % c)


a = "hello"
b = "hi"

test(a, b)
print()
test1(a, b, c = "hello world")

运行结果:

use limit
I tell you : hello
I tell you : hi

use limit
I tell you : hello
I tell you : hi
I tell you : hello world

被装饰函数带有返回值

def limit(func):
    def addlimit():
        print("use limit")
        return func()
    return addlimit


@limit
def test():
    print("this is a function")
    return "I tell you: hello"


print(test())

直接在闭包内部函数返回原函数的调用结果即可。

既有参数又有返回值的通用装饰器

def limit(func):
    def addlimit(*args, **kwargs):
        print("use limit")
        return func(*args, **kwargs)
    return addlimit

三层装饰器

三层装饰器可以在原有装饰器的基础上,设置额外的外部变量。

def limit_arg(arg):
    def limit(func):
        def addlimit():
            print("use limit--%s" % arg)
            func()
        return addlimit
    return limit


@limit_arg("hello")
def test():
    print("this is a function")


test()

运行结果:

use limit--hello
this is a function

test() 相当于:

limit_arg("hello")(test)()

类装饰器

装饰器不仅是一个函数,还可以是一个类。

class Limit(object):
    def __init__(self, func):
        self.func = func

    def __call__(self):
        print("use limit")
        self.func()


@Limit
def test():
    print("this is a function")


test()
  • 魔术方法 __call__ 方法可以让类的实例对象像函数一样被调用。

  • 类装饰器对比函数装饰器具有灵活度大、高内聚、封装性等优点。

多个装饰器

def add_a(func):
    def a():
        return "<a href=‘mxuanli.cn‘>" + func() + "</a>" 
    return a


def add_h1(func):
    def h1():
        return "<h1>" + func() + "</h1>"
    return h1


@add_a
@add_h1
def test():
    return "hello world"


print(test())

运行结果:

<a href=‘mxuanli.cn‘><h1>hello world</h1></a>
  • 多个装饰器的时候,执行顺序是从里到外,会先从最内层的开始执行。

以上是关于Python的闭包和装饰器的主要内容,如果未能解决你的问题,请参考以下文章

python-闭包和装饰器-02-装饰器(decorator)

python-闭包和装饰器-02-装饰器(decorator)

python闭包装饰器

python闭包及装饰器

python闭包和装饰器的理解

Python学习—— 装饰器和函数闭包