Python作用域

BTW

• Python函数使用return语句返回"返回值"
• 所有函数都有返回值，如果没有return语句，饮食调用return None
• return语句并不一定是函数的语句块的最后一条语句
• 一个函数可以存在多个return语句，但是只有一条可以被执行。如果没有一条return语句被执行到，隐式调用return None
• 如果有必要，可以显示调用return None，可以简写为return
• 如果函数执行了return语句，函数就会返回，当前被执行的return语句之后的其他语句就不会被执行了
• 返回值的作用：结束函数调用，返回"返回值"

def showvalues():
    return 1,2,3
showvalues()
(1, 2, 3)
a,b,c = showvalues()  #解构
print(a,b,c)
1 2 3

• return不能返回多个值
• 当return返回多个值时，会将多个值封装成一个元祖
• 被封装成的元祖可以被解构

函数作用域

作用域

一个标识符的课件范围，这就是标识符的作用域，一般常说的变量的作用域

def foo():
    x = 100
    
tpye(x)  
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-35-0ed6a7146749> in <module>
----> 1 tpye(x)

NameError: name 'tpye' is not defined

不可以访问到，原因是函数是一个封装，它会开辟一个作用域，x变量被限制在这个作用域中，所以在函数外部x变量不可见。（每一个函数都会开辟一个作用域）。

作用域分类

• 全局作用域
      在整个程序运行环境中都可见
      全局作用域中的变量称为全局变量
• 局部作用域
      在函数、类等内不可见
      局部作用域中的变量称为局部变量，其使用范围不能超过其所在局部作用域。

def fn1():
    x = 1
def fn2():
    print(x)
    
fn2()
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-39-e87bcb52744c> in <module>
----> 1 fn2()

<ipython-input-38-7fac7d12782b> in fn2()
      2     x = 1
      3 def fn2():
----> 4     print(x)

NameError: name 'x' is not defined
    
=================================================================================
print(x)
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-40-fc17d851ef81> in <module>
----> 1 print(x)

NameError: name 'x' is not defined

函数嵌套

在一个函数定义了另外一个函数

def outer():   #将标识符与函数对象做绑定关系
    def inner():  
        print('inner')
    print('outer')
    inner()
outer()
outer
inner
=====================================================
inner()
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-43-7f0826fa8974> in <module>
      5     inner()
      6 outer()
----> 7 inner()

NameError: name 'inner' is not defined

封装在函数内部的函数封装对外是不可见的及不可调用，outer内部定义的变量对于外部不可知就想货物装在卡车里

函数结构的作用域

对比下面嵌套结构，代码执行的效果：

def outer1():
    o = 65
    def inner():
        print('inner {}'.format(o))
        print(chr(o))
    inner()
    print("outer {}".format(o))

outer1()
inner 65
A
outer 65  
----------------------------------------------------------------
def outer2():
    o = 65
    def inner():
        o = 97
        print("inner {}".format(o))
        print(chr(o))
    inner()
    print('oouter {}'.format(o))

outer2()
inner 97
a
oouter 65

从执行的结果来看：

• 外层变量在内部作用域可见

• 内层作用域inner中，如果定义了o = 97，相当于在当前函数inner作用域中重新定义了一个新的变量o，但是，这个o并不能覆盖掉外部作用于outer2中的变量o，只不过对inner函数来说，其只能可见自己作用域中定义的变量o了

• 赋值语句：

x = 6
def add():
    a = x + 1
    return a
add()
7
==========================================================================
x = 6
def add():
    x += 1
    return a
add()
---------------------------------------------------------------------------
UnboundLocalError                         Traceback (most recent call last)
<ipython-input-48-15ca56e81ced> in <module>
      3     x += 1
      4     return a
----> 5 add()

<ipython-input-48-15ca56e81ced> in add()
      1 x = 6
      2 def add():
----> 3     x += 1
      4     return a
      5 add()

UnboundLocalError: local variable 'x' referenced before assignment

分析为什么a = x+1 和 x += 1：

• x += 1 就是 x = x+1
• 相当于在foo内部定义一个局部变量x，那么foo内部所有x都是这个局部变量x了
• a = x + 1相当于使用了局部变量x，但是这个x还没有完成赋值，就被右边拿来加1操作了

global语句

x = 1
def foo():
    global x
    x += 1
    print(x)
foo()
2

• 使用global关键字的变量，将foo内的x声明为使用外部的额去阿奴作用域中定义的x
• 全局作用域必须有x的定义

def foo():
    global x
    x += 1
    print(x)
foo()
NameError: name 'x' is not defined
============================================================
def foo():
    global x
    x = 10
    x += 1
    print(x)
foo()
11
print(x)
11
==================================================================
x = 10
def foo():
    global x
    x = 6
    x += 1
    print(x)
foo()
7
print
7

使用global关键字定义的变量，虽然在foo函数中声明，但是这个将告诉当前foo函数作用域，这个x变量将使用外部全局作用域中的x。
即使实在foo中又写了x = 10，也不会在foo这个局部作用域中定义局部变量x了。
使用了global，foo中的x不再是局部变量了，它是全局变量

总结：

• x+=1这种是特殊形式产生的错误的原因，先引用后赋值，而python动态语言是赋值才算定义，才能被引用。解决办法，在这条语句前增加x=0之类的赋值语句，或者使用global告诉内部作用域，去全局作用域查找变量定义
• 内部作用域使用x = 10之类的赋值语句会重新定义局部作用域使用的变量x，但是一旦这个作用域使用了global声明x为全局的，那么x = 5 相当于在为全局作用域的变量x赋值

global使用原则

• 外部作用域变量会在内部作用域可见，但也不要在这个内部的局部作用于直接使用，因为函数的目的就是为了封装，尽量与外界隔离
• 如果函数需要使用外部全局变量，请尽量使用函数的形参定义，并在调用传实参解决
• 不能用global

闭包

• 自由变量：未在本地作用域中定义的变量，例如定义在内层函数外的外层函数的作用域中的变量
• 闭包：出现在嵌套函数中，指的是内层函数引用到了外层函数的自由变量，就形成了闭包。javascript也使用了这个概念

nonlocal语句

nonlocal：将变量标记为不在本地作用域定义，而是在上级的某一级局部作用域中定义，但不能是全局作用域中定义

def counter():
    count = 0
    def inc():
        nonlocal count
        count += 1
        return count
    return inc

foo = counter()
print(foo(),foo())
1 2

count是外层函数的局部变量，被内部函数引用
内部函数使用nonlocal关键字声明count变量在上级作用域而非本地作用域中定义。
代码中内层函数引用外部局部作用域中的自由变量，形成闭包。

def foo(xyz=1):
    print(xyz)

foo()
1
-------------------------
print(foo())
1
None
--------------------------

def foo(xyz=[]):
    xyz.append(1)
    print(xyz)
  
foo()
[1]
-------------------------------
foo()
[1,1]
-------------------------------
print(xyz)
NameError: name 'xyz' is not defined
-------------------------------
print(foo())
[1, 1, 1, 1]
None

• 每个函数定义被执行后，就生成了一个函数对象和函数名这个标识符关联
• python把函数的模拟任职放在了函数对象的属性中，这个属性就伴随这个函数对象的整个生命周期
• 查看foo._default_属性，它是个元祖

def foo(xyz=[],m = 123,n = 'abc'):
    xyz.append(1)
    print(xyz)
    
print(id(foo),foo.__defaults__)
140727444481840 ([], 123, 'abc')
-------------------------------------
foo()
[1]
--------------------------------------
print(id(foo),foo.__defaults__)
140727444481840 ([1], 123, 'abc')

函数地址并没有变，就是说foo这个函数对象的没有变过，调用它，它的属性__defaults__中使用元祖默认值，xyz默认值的引用类型，引用类型的元素变动，并不是元祖的变化

def foo(xyz,m = 123,n = 'abc'):
    m = 455
    n = 'A'
    print(xyz)
    
print(foo.__defaults__)
(123, 'abc')
-------------------------
foo('heihei')
heihei
-------------------------
print(foo.__defaults__)
(123, 'abc')

属性__defaults__中使用元祖保存所有位置参数默认值，它不会因为函数体内改变了局部变量（形参）的值而发生改变

def foo(xyz,m = 123,*,n = 'abc',t = [1,2]):
    m = 455
    n = 'A'
    t.append(300)
    print(xyz,m,n,t)
------------------------------------
print(foo.__defaults__,foo.__kwdefaults__)
(123,) {'n': 'abc', 't': [1, 2]}
------------------------------------------
foo('heihei')
heihei 455 A [1, 2, 300]
------------------------------------------
(123,) {'n': 'abc', 't': [1, 2, 300]}

属性__defaults__中使用元祖保存所有位置参数默认值
属性__kwdefaults__中使用字典保存所有keyword-only参数的默认值

def x(a=[]):
    a +=[5]
    
print(x.__defaults__)
([],)
x()
x()
print(x.__defaults__)
([5, 5],)

def x(a=[]):
    a = a + [5]
    
print(x.__defaults__)
([],)
x()
x()
print(x.__defaults__)
([],)

• +表示两个列表合并并返回一个全新的列表
• +=表示，就地修改前一个列表，在其后追加后一个列表，就是extend方法

变量名解析原则LEGB

• local，本地作用域，局部作用域的local命名空间。函数调用时创建，电泳结束消亡
• Enclosing，python2.2时引入了嵌套函数，实现了闭包，这个就是嵌套函数的外部函数的命名空间
• Global，全局作用域，即一个模块的命名空间。模块被import时创建，解释器退出时消亡
• Build-in，内置模块的命名空间，生命周期从python解释器启动时创建到解释器退出时消亡。例如print(open),prin和open都是内置的变量

所以一个名次的查找顺序就是LEGB

函数的销毁

• 定义一个函数就是生成一个函数对象，函数名指向的就是函数对象
• 可以使用del语句删除函数，使其引用计数减1
• 可以使用同名标识符覆盖原有定义，本质上也是使其引用计数减1
• Python程序结束时，所有对象销毁
• 函数也是对象，也不例外，是否销毁，还是看引用计数是否减为0