Python语言装饰器-专题笔记-职坐标

Python语言装饰器-专题笔记

小标 2018-12-20 来源：阅读 1211 评论 0

摘要：本文主要向大家介绍Python语言装饰器-专题笔记了，通过具体的内容向大家展示，希望对大家学习Python语言有所帮助。

本文主要向大家介绍Python语言装饰器-专题笔记了，通过具体的内容向大家展示，希望对大家学习Python语言有所帮助。

学会装饰器，Python更进阶函数作用域到闭包到装饰器讲解，及闭包和装饰器的运用。[√] 慕课网Meshare_huang老师: python进阶mark函数作用域介绍 Python 的函数作用域，了解函数作用域 LEGB 间关系。主要内容:函数作用域LEGB闭包理解与使用装饰器LEGB: L>E>G>BL: local 函数内部作用域E: enclosing 函数内部与内嵌函数之间(主要是内置函数对我们函数变量的一个引用，称之为闭包)G: global 全局作用域: 我们所定义的全局变量。B: build-in 内置作用域: Python解释器默认导入的一些变量。build-in比如：tuple，list，元组等。知识点： LEGB原则: 首先从函数内部作用域查找，然后去enclosing作用域中去查找,然后依次是全局和内置。例子(使用Python3.4版本 + sublimeText)：passline = 60          #passline 是全局变量（global）def func(val):
    if val >= passline:        print ('pass')    else:        print ('failed')

func(89)运行结果:pass分析：当我们定义一个函数时，会引入一个作用域：L: local.当我们对于func函数进行调用时，val就是我们的一个本地变量。在函数内部并没有定义passline 的值。这个时候回去全局变量找查找。如果全局没有还会继续向上查找B: build-in当总分变为150.我们的passline应该设为90,如果我们不想修改全局的passline,我们可以在函数内部定义新的passline。因为L>G,所以会以我们自己函数内部的local域为准。实现代码:passline = 60          #passline 是全局变量（global）def func(val):
    passline = 90      #这里的passline是函数内部作用域(local)
    if val >= passline:        print ('pass')    else:        print ('failed')

func(89)运行结果：failedPython解释器查找顺序为L-->E-->G-->B,如果已经找到，就不会找更上层。如果我们需要拿到两个分数中的更大值。实现代码:def Max(val1,val2):
    return max(val1,val2)print (Max(90,100))运行结果：100Max函数内部引用了一个内置函数方法max.这个内置方法在Max函数中以及整个文件中都没有定义。这个max存在于我们的build-in.Python解释器在运行时会自动导入内置的方法。比如list,tuple函数内部的函数产生enclosing：实现代码:passline = 60          #passline 是全局变量（global）def func(val):
    passline = 90      #这里的passline是函数内部作用域(local)
    if val >= passline:        print ('pass')    else:        print ('failed')    def in_func():
        print (val)    # 调用方式1
    in_func()    # 调用方式2：将in_func()返回。这样我们就可以在外部调用。func(89)运行结果：failed
89val变量的查找过程:  print (val) 中val的查找过程。in_func()内部并没有定义这个val的值。也就是local作用域中没有这个值.下一步我们就会去enclosing作用域查找。也就是我们的func(val)中引入的有val变量。找到传入的val值89什么是闭包介绍什么是闭包，为什么使用闭包，闭包作用装饰器之闭包1closure：内部函数对enclosig作用域的变量进行引用概念：如果在一个内部函数里，对在外部作用域（但不是在全局作用域）也就是enclosig作用域的变量进行引用，那么内部函数就被认为是闭包（closure）函数实质与属性函数是一个对象函数执行完之后内部变量回收(如果我们中间产生一个变量，这个变量返回那么他不会被回收: 因为他的引用计数还补为0)作为一个对象函数拥有自己的属性(闭包函数的特殊属性)函数返回值正常的调用参考上一章代码。passline = 60          #passline 是全局变量（global）def func(val):
    passline = 90
    if val >= passline:        print ('pass')    else:        print ('failed')    def in_func():
        print (val)
    in_func()
    return in_func # in_func是func内部的一个函数对象。f = func(89) #使用f来接收返回值f() #infunc运行结果：failed
89
89func执行完成之后，他的val值就会消失。但是我们再次调用f()因为infunc的引用计数还没有归零。所以会一直保留。当我们这时候运行f()，val值是哪来的呢？print (f.__closure__)运行结果(,)这里面有一个int object 地址为: 0x00000000052169F8添加一行查看传入func的val的id值(%x 表示使用16进制打印。id()可打印出val的id)def func(val):
    print ('%x'%id(val))mark可以看出value的id值和__closure__中的那个int object的值一样。如果我引用了外部enclosing的值。会将该值保存在函数的属性中。当我们调用f()时并没有去代码中查找。而是去函数的属性(Local域)中查找.可以理解为在in_func定义的时候，函数属性中会添加(val,)这个属性的值是一个元组。是不能变得。总分从100到150涉及到passline的取值问题。passline = 60  #100      def func(val):
    passline = 90 # 150最常用的解决方案是定义两个函数分别处理:实现代码:def func_150(val):
    passline = 90 # 150
    if val >= passline:        print ('pass')    else:        print ('failed')def func_100(val):
    passline = 60 # 150
    if val >= passline:        print ('pass')    else:        print ('failed')
func_100(89)
func_150(89)运行结果：passfailed上面两个函数在处理逻辑上基本一致，如果后期对于打印出来的信息要做修改，就得修改两遍。如要为print添加数值的显示。def func_150(val):
    print ('%d pass' %val)def func_100(val):
    print ('%d pass' %val)所有的改动都得做两遍。（这里想起了c++的模板）进阶版修改:def  set_passline(passline): #passline = 60
    def cmp(val): #cmp 的__closure__属性中加入passline
        if val >= passline:            print ('%x'%id(passline))            print ('pass')        else:            print ('%x'%id(passline))            print ('failed')    return cmp

f_100 = set_passline(60)
f_150 = set_passline(90)print (type(f_100)) # f_100就是一个函数对象。__closure__属性中存放着passlineprint (f_100.__closure__)
f_100(89)print (f_150.__closure__)
f_150(89)mark理解：闭包就是内部函数(cmp)对于外层函数(set_passline)变量(passline)的使用（也就是对enclosing作用域变量的使用），会将我们使用的这个变量(passline)放到我们的__closure__这个属性中。当我们内部函数处理时会直接对于这个属性值进行使用。闭包的作用：封装代码复用装饰器之闭包2上节我们接触到的enclosing域中的变量passline是一个整数，我们可不可以把它换成一个函数对象呢。废话，当然可以。例子：求一组数据的总分和平均分def my_sum(*arg):
    return sum(arg)def my_average(*arg):
    return sum(arg) / len(arg)

print(my_sum(1, 2, 3, 4, 5))
print(my_average(1, 2, 3, 4, 5))运行结果：15
3此时如果我们的my_average需要加上一个对于传入参数不为0的判断。print(my_average())因为传入为空会报除0错误：ZeroDivisionError: integer division or modulo by zero而我们如果想要给my_sum传一个字符串进去。print(my_sum(1,2,3,4,5,'6'))会报错不支持int和str相加:TypeError: unsupported operand type(s) for +: 'int' and 'str'说明我们的函数写的不够健全。我们还需要对于函数的参数进行判断。判断参数有没有长度。也就是不能为空。对于参数的类型进行判断，限制为只是int型普通版实现代码:def my_sum(*arg):
    if len(arg) == 0:        return 0
        for val in arg:            if not isinstance(val, int):                return 0
        return sum(arg)def my_average(*arg):
    if len(arg) == 0:        return 0
        for val in arg:            if not isinstance(val, int):                return 0
    return sum(arg) / len(arg)

print(my_sum(1, 2, 3, 4, 5))
print(my_average(1, 2, 3, 4, 5))
print(my_sum(1, 2, 3, 4, 5, '6'))运行结果：None3None可以看出两部分代码都有重合，我们使用进阶方法，使用闭包方式完成。def my_sum(*arg):
    print ('in mysum arg=', arg)    return sum(arg)def my_average(*arg):
    print ('in my_average arg=', arg)    return sum(arg) / len(arg)def dec(func):
    def in_dec(*arg):  # my_sum -> __closure__
        print ('in dec arg=', arg)        if len(arg) == 0:            return 0
        for val in arg:            if not isinstance(val, int):                return 0
        return func(*arg)    return in_dec# dec() return indec -> my_sum;# mysum = in_dec(*arg);my_sum = dec(my_sum)
my_average = dec(my_average)

print(my_sum(1, 2, 3, 4, 5))
print(my_sum(1, 2, 3, 4, 5, '6'))# print(my_average(1, 2, 3, 4, 5))# print(my_average())运行结果：('in dec arg=', (1, 2, 3, 4, 5))
('in mysum arg=', (1, 2, 3, 4, 5))
15
('in dec arg=', (1, 2, 3, 4, 5, '6'))
0我们把原有的重复的逻辑操作放进了我们的in_dec中。def dec(func):中func是我们传入的一个参数。因此我们调用这个函数时。我们可以指定它做什么此时我们想要让func()对于arg进行处理。所以return func(*arg)函数名可以进行重新赋值：my_sum = dec(my_sum)第一步我们调用的是dec(func),调用之后将my_sum传了进去。因为在in_dec中我们对他进行了使用。所以我们的in_dec就是一个闭包。这个时候my_sum就已经作为in_dec的一个__closure__ 属性被保存。那么在in_dec内部就可以直接使用my_sum第二步my_sum = dec(my_sum)时。my_sum将保存dec()被调用后的返回值也就是in_dec(*arg)对象。具体执行函数：第一步是调用的in_dec函数第二步是调用的func也就是my_sum这里所有参数的处理都是in_dec处理的。所以当第二个直接返回0时，my_sum直接没有被调用。# dec() return indec -> my_sum;# mysum = in_dec(*arg);Python装饰器python装饰器- 装饰器用来装饰函数
- 返回一个函数对象
- 被装饰函数标识符指定返回的函数对象(A被装饰了，再用A接收被装饰后返会的新对象)被装饰的函数去哪了？
- 语法糖 @decomy_sum = dec(my_sum)执行过程：dec(my_sum)将my_sum作为一个参数传给dec函数.dec函数内部有一个内置的函数in_dec内置函数作为返回值重新赋给了my_sum理解：装饰器就是对于闭包的一个使用。Python提供了语法糖@实现代码:def dec(func):
    print "call dec"

    def in_dec(*arg):  # my_sum
        print ('in dec arg=', arg)        if len(arg) == 0:            return 0
        for val in arg:            if not isinstance(val, int):                return 0
        return func(*arg)    return in_dec@decdef my_sum(*arg):
    print ('in mysum arg=', arg)    return sum(arg)运行结果：call dec并没有显式的调用任何方法，但是打印出了call dec因为@dec就相当于my_sum = dec(my_sum)已经进行了调用。此时的my_sum已经是装饰后的函数in_dec了。print (my_sum(1, 2, 3, 4, 5))运行结果：15@dec就相当于my_sum = dec(my_sum)，这是python解释器支持的语法糖。实现代码:def dec(func):
    print "call dec"

    def in_dec(*arg):  # my_sum

        print('in dec arg=', arg)        if len(arg) == 0:            return 0
        for val in arg:            if not isinstance(val, int):                return 0
        return func(*arg)
    print('return in_dec')    return in_dec@decdef my_sum(*arg):  # my_sum = in_dec
    print('in mysum arg=', arg)    return sum(arg)

print(my_sum(1, 2, 3, 4, 5))运行结果：call decreturn in_dec
('in dec arg=', (1, 2, 3, 4, 5))
('in mysum arg=', (1, 2, 3, 4, 5))
15装饰器就是对于我们的函数进行了功能的丰富。内部继续调用具体函数，将新函数返回，并覆盖原函数变量。实质就是对于闭包的使用。my_sum当做enclosing域的变量。被内置函数in_dec所使用。实现代码:def deco(func):
    def in_deco():
        print('in decp')
        func()
    print('call deco')@decodef bar():
    print('in bar')print (type(bar))运行结果：call deco
因为我们在外层函数deco中返回的是None实现代码:def deco(func):
    def in_deco():
        print('in decp')
        func()
    print('call deco')    return in_deco@decodef bar():
    print('in bar')

print(type(bar))
bar()运行结果：call deco
in decpin bar给被装饰函数加上参数：第二个装饰器。@decodef bar(x, y):
    print('in bar', x + y)我们如果给被装饰函数加上了参数。那么也要对要返回的内置函数in_deco加上参数。否则报错：TypeError: bar() takes exactly 2 arguments (0 given)实现代码:def deco(func):
    def in_deco(x, y):
        print('in decp')
        func(x, y)
    print('call deco')    return in_deco@decodef bar(x, y):
    print('in bar', x + y)

print(type(bar))
bar(1, 2)运行结果：call deco
in decp
('in bar', 3)要同时对于in_deco(x, y)和func(x, y)都加上参数。假设我们是Python解释器：我们看到了@deco我们将会调用deco()然后将bar也就是被装饰函数作为参数传入。deco(bar) -> indeco
bar -> in_deco  #(enclosing作用域)变量保存在in_deco的`__closure__`使用。bar() in_deco() 重新调用自己属性中的被装饰函数调用之后deco会返回一个in_deco的函数对象。现在根本没地方选的。只能存在原来的bar中。因此bar已经变成了in_deco而in_deco中调用的func(x,y)是存放在自己的bar.__closure__中了。def deco(func):
    def in_deco(x, y):
        print('%x' % id(func))
        print(in_deco.__closure__)
        print('in deco')
        func(x, y)
    print('call deco')    return in_deco@decodef bar(x, y):
    print('%x' % id(bar))

bar(1, 2)运行结果：call deco
5491ba8
(, )in deco
5491c18可以看出in_deco.__closure__已经将原始bar函数进行了保存。这里就有一个问题了？可以看出里面保存着两个变量。(第一个是一个函数对象func，第二个便是我们的原始bar)分解来说，包含下面3个条件：需要函数嵌套, 就是一个函数里面再写一个函数.外部函数需要返回一个内部函数的引外部函数中有一些局部变量, 并且, 这些局部变量在内部函数中有使用一些概念:1)自由变量: 外部函数中定义的局部变量, 并且在内部函数中被使用闭包: 那个使用了自由变量并被返回的内部函数就称为闭包支持闭包的语言有这样的特性：1)函数是一阶值（First-class value），即函数可以作为另一个函数的返回值或参数，还可以作为一个变量的值2)函数可以嵌套定义，即在一个函数内部可以定义另一个函数#代码示例（点开编辑查看）#coding:utf-8#闭包：实现封装，实现代码复用def set_passline(passline):   #passline = 60
    def cmp(val):             #cmp() -> 闭包
        if val >= passline:
            print('pass')        else:
            print("failed")    return cmp
f_100 = set_passline(60)   #f_100是函数，也即返回的函数cmpf_150 = set_passline(90)
f_100(89)
f_150(89)封装和代码的复用闭包会保留来自外围作用域变量的信息。Python 中函数对象都拥有一个 closure 属性。closure 对象返回一个由 cell 对象组成的元组，cell 对象记录了定义在外围作用域的变量信息。对于那些不是闭包的函数对象来说，closure 属性值为 None函数调用顺序：（）#1、dec函数返回in_dec -> my_sum#2、my_sum = in_dec(*arg)print(my_sum(1,2,3,4,5))print(my_sum(1,2,3,4,5,'6'))打印结果：in_dec(*arg)= (1, 2, 3, 4, 5)
my_sum
15
in_dec(*arg)= (1, 2, 3, 4, 5, '6')
0