zoukankan      html  css  js  c++  java
  • python中对变量的作用域LEGB、闭包、装饰器基本理解

    一、作用域

      在Python程序中创建、改变、查找变量名时,都是在一个保存变量名的空间中进行,我们称之为命名空间,也被称之为作用域。python的作用域是静态的,在源代码中变量名被赋值的位置决定了该变量能被访问的范围。即Python变量的作用域由变量所在源代码中的位置决定。

      在Python中并不是所有的语句块中都会产生作用域。只有当变量在Module(模块)、Class(类)、def(函数)中定义的时候,才会有作用域的概念。而在if、for、while等语句中不产生作用域。

      L(local)局部作用域,存在于def内的局部性的作用域,随着函数的定义而产生。

      E(enclosing)嵌套作用域,同L作用域是相对而言,存在函数嵌套时,内部函数的作用域称为L作用域,外部函数称为E作用域。

      G(global)全局作用域,变量在该模块内的作用域,可以简单的理解为单个文件内的范围。

      B(built-in)内置作用域,系统内固定模块里定义的变量,如预定义在builtin 模块内的变量,最高级别的作用域,范围最广,可以理解为当前运行系统的范围。

    举例说明:

    #!/usr/bin/env python3
    # -*- coding: utf-8 -*-
    __author__ = "问道编程"
    __date__ = "2018-06-13 15:40"
    passline = 60   #global var

    def func(val):
        passline = 90   #for func, it's local var;for in_func, it's enclosing var
        if val >= passline:
    print "pass"
    else:
    print "fail"
    def in_func():
    print val
    return in_func

    def Max(val1, val2):
    return max(val1, val2) # max is a built-in fun,函数也可以赋值给变量,所以所有的内置函数的作用域都可视作B

    声明全局变量:

    a = 100
    def foo():
    global a # 引用全局变量a,并认可其修改的值
    a = 200
    print(a)
    foo()
    print(a)
    ---------
    100
    200

    二、闭包

      首先理解下python中的函数,在python中,函数是一个对象(可以通过type函数查看),在内存中占用空间;函数执行完成之后内部的变量会被解释器回收,但是如果某变量被返回,则不会回收,因为引用计数器的值不为0;既然函数也是一个对象,他也拥有自己的属性;对于python函数来说,返回的不一定是变量,也可以是函数。

      由此引出闭包的概念,当存在函数嵌套时(如上例中的func()和in_func()就是嵌套关系),外部函数的返回值为内部函数,且内部函数引用外部函数的变量、参数,并将引用的变量、参数封装在函数中一起作为返回值,其中的内部函数就称为一个闭包。

      形成闭包的必要条件:

    1)必须有一个内嵌函数(函数里定义的函数)——这对应函数之间的嵌套
    2)内嵌函数必须引用一个定义在闭合范围内(外部函数里)的变量——内部函数引用外部变量
    3)外部函数必须返回内嵌函数——必须返回那个内部函数

    三、闭包的使用场景

    第一个例子:

    #!/usr/bin/env python3
    # -*- coding: utf-8 -*-
    __author__ = "问道编程"
    __date__ = "2018-06-13 15:53"

    def funx():
    x=5 # 对于funx,是L作用域,对于funy,是E作用域
    def funy(): # 是一个闭包
    nonlocal x # 绑定到外部的x,只在python3中使用
    x+=1
    return x
    return funy

    a = funx()
    print(a())
    print(a())
    print(a())
    print(x)
    -------------------------
    6
    7
    8
    NameError: name 'x' is not defined

      本来x只是funx()的局部变量,但是形成了闭包之后,它的行为就好像是一个全局变量一样,最后的错误说明x并不是一个全局变量。其实这就是闭包的一个十分浅显的作用,形成闭包之后,闭包变量能够随着闭包函数的调用而实时更新,就好像是一个全局变量那样。

    第二个例子,也是讲闭包用的最多的例子:

    def func_150(val):   # 总分为150时,及格分数为90
    passline = 90
    if val >= passline:
    print "pass"
    else:
    print "fail"

    def func_100(val): # 总分为100时,及格分数为60
    passline = 60
    if val >= passline:
    print "pass"
    else:
    print "fail"

    func_100(89)
    func_150(89)

    使用闭包优化上面的代码:

    def set_passline(passline):
    def cmp(val):
    if val >= passline:
    print "pass"
    else:
    print "fail"
    return cmp

    f_100 = set_passline(60) # f_100调用函数set_passline(),并将60赋值给变量passline,这是f_100等于函数的返回值,也就是函数cmp
    f_150 = set_passline(90)
    f_100(89) # f_100()=cmp(),将89赋值给val,运行cmp()函数,输出结果
    f_150(89)

    第三个例子:

    def my_sum(*arg):
    print('in my_sum,arg=',arg)
    return sum(arg)


    def dec(func):
    def in_dec(*arg):
    print('in 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


    my_sums = dec(my_sum) # 命名为my_sums,是为了和my_sum进行区分,便于理解
    # ①调用dec()函数,将dec的返回值赋值给my_sums,相当于my_sums=in_dec,②将函数my_sum赋值给func,相当于func=my_sum
    result = my_sums(1, 2, 3, 4, 5)
    # ③相当于将(1, 2, 3, 4, 5)赋值给in_dec函数中的arg,调用并执行函数in_dec(),
    # ④in_dec()函数的return返回值是func()函数,将in_dec函数中的arg赋值给func()函数中的arg,也就是赋值给my_sum()中的arg
    # ⑤调用并执行函数my_sum(),将sum(arg)结果返回给变量result
    print(result)
    ------------
    in in_dec,arg= (1, 2, 3, 4, 5)
    in my_sum,arg= (1, 2, 3, 4, 5)
    15
    整个过程可以简单的理解为,先运行dec()函数,其返回值是in_dec函数,再运行in_dec函数,其返回值为func函数,也就是my_sum函数,再运行my_sum函数
    dec() -> in_dec() -> my_sum()

    第四个例子:

    #!/usr/bin/env python3
    # -*- coding: utf-8 -*-
    __author__ = "问道编程"
    __date__ = "2018-06-13 17:08"

    variable = 300

    def test_scopt():
    print(variable) # variable是test_scopt()的局部变量,但是在打印时并没有绑定内存对象。
    variable = 200 # 因为这里,所以variable就变为了局部变量

    test_scopt()
    print(variable)
    ------------
    UnboundLocalError: local variable 'variable' referenced before assignment

      上面的例子会报出错误,因为在执行程序时的预编译能够在test_scopt()中找到局部变量variable(对variable进行了赋值)。在局部作用域找到了变量名,所以不会升级到嵌套作用域去寻找。但是在使用print语句将变量variable打印时,局部变量variable并有没绑定到一个内存对象(没有定义和初始化,即没有赋值)。本质上还是Python调用变量时遵循的LEGB法则和Python解析器的编译原理,决定了这个错误的发生。所以,在调用一个变量之前,需要为该变量赋值(绑定一个内存对象)。
      注意:为什么在这个例子中触发的错误是UnboundLocalError而不是NameError:name ‘variable’ is not defined。因为变量variable不在全局作用域。Python中的模块代码在执行之前,并不会经过预编译,但是模块内的函数体代码在运行前会经过预编译,因此不管变量名的绑定发生在作用域的那个位置,都能被编译器知道。Python虽然是一个静态作用域语言,但变量名查找是动态发生的,直到在程序运行时,才会发现作用域方面的问题

      可以使用global将变量variable声明为全局变量。

     四、装饰器

      概念性的知识,拗口的表述:

    1.装饰器就是对闭包的使用;
    2.装饰器的作用是装饰函数;
    3.装饰器会返回一个函数对象,被装饰的函数接收;
    4.被装饰函数标识符指向返回的函数对象。

      将上面第三个例子用上装饰器:

    def dec(func):
    def in_dec(*arg):
    print('in 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('in dec') # 新增的一行
    return in_dec
    @dec 
    def my_sum(*arg):
    print('in my_sum,arg=',arg)
    return sum(arg)
    print(type(my_sum))

      对概念的实例化:

    1、@dec是一个装饰器,是调用dec()函数形成的装饰器;

    2、被装饰的函数是my_sum(),即调用dec()函数形成装饰器时,dec()函数的参数为my_sum()函数,即:func = my_sum

    3、装饰器的返回值是函数in_dec(),该返回值被函数my_sum()接收,其实是传给被装饰函数(即my_sum()函数)的标识符my_sum,即:my_sum=in_dec

      直接运行该文件,输出:

    --------------
    in dec
    <class 'function'> # 此时的my_sum并非指定义的def my_sum(*arg)函数,而是变成接收了装饰器的返回值,in_dec函数。

      说明只要使用了装饰器,就会调用装饰器里的函数;并且装饰器的返回值:in_dec(),被my_sum接收(如果没有return in_dec,直接运行,则my_sum格式为:<class 'NoneType'>,说明装饰器没有返回值时,会返回None,这一点跟函数一样)。

      接下来,执行语句:

    result = my_sum(1, 2, 3, 4, 5)  
    print(result)
    ------------
    in dec
    <class 'function'>
    in in_dec,arg= (1, 2, 3, 4, 5)
    in my_sum,arg= (1, 2, 3, 4, 5)
    15

      运行过程为(结合第三个例子进行理解):

    1、@dec,调用dec函数,其参数就是被装饰的函数my_sum(),即func=my_sum,执行print('in dec'),返回in_dec函数,被my_sum接收,即:最后会将函数in_dec的运行结果,传给被装饰函数的标识符my_sum;

    2、调用in_dec函数,参数为(1,2,3,4,5),执行print、if、for语句,执行return func(*arg),func=my_sum函数;

    3、调用函数my_sum(),参数为(1,2,3,4,5),执行print语句,执行return sum(*arg),返回最终结果;

    参考文章:

    https://www.cnblogs.com/fireporsche/p/7813961.html

    https://www.cnblogs.com/cotyb/p/5243252.html

  • 相关阅读:
    GJM : Unity的profiler性能分析【转载】
    GJM :Unity UI 之 UGUI 开发
    GJM:笔记记录
    GJM : UGUI 缩放循环拖动展示卡牌效果
    GJM :HTC Vive VRTK.Package 踩坑之路(一)
    GJM :Mono 介绍
    GJM :Unity3D 介绍
    GJM : C# 介绍
    GJM : 通用类型系统(Common Type System CTS)
    GJM :SQL Server中常用的SQL语句
  • 原文地址:https://www.cnblogs.com/wendaobiancheng/p/9179387.html
Copyright © 2011-2022 走看看