Python函数返回值作用域（闭包）

函数返回值

• 例

1. return语句之后可以执行吗?

def showplus(x):
    print(x)
    return x + 1
    print('-'*30)  # return语句之后会执行吗

showplus(5) # 5，输出结果

# return之后print('-'*30)并没有执行

5 # 输出结果,return之后print('-'*30)并没有执行

2. 多条return语句都会执行吗

def showplus(x):
    print(x)
    return x + 1
    return x + 2

showplus(5) #， 输出结果 


 # return之后return x + 2并没有执行

3. 下例多个return可以执行吗?

def guess(x):
    if x > 3:
        return "> 3"
    else:
        return "<= 3"

print(guess(4)) # >3, 输出结果
print(guess(2)) # <=3,输出结果

4. 观察下例函数执行的结果

def fn(x):
    for i in range(x):
        if i > 3:
            return i
    else:
        print("{} is not greater than 3".format(x))

print(fn(5)) #4 输出结果
print(fn(2)) # 2 is not greater than 3 ；None 输出结果

总结

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

def showvalues():
    return 1, 3, 5

print(showvalues()) #输出结果(1, 3, 5)

• 函数不能同时返回多个值
• return 1, 3, 5看似返回多个值，隐式的被python封装成了一个元祖
• x, ,y, z =showlist() 使用结构提取返回值更为方便

函数作用域

作用域

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

def foo():
	x = 100

print(x) # 可以访问到吗

• 上例中x不可以访问，会抛出异常（NameError:name ‘x’ is not defined）,原因在于函数是一个封装，它会开辟一个作用域，x变量被限制在这个作用域中，所以在函数外部x变量不可见
• 注意：每一个函数都会开辟一个作用域

作用域分类

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

def fn1():
    x = 1 #局部作用域,x为局部变量,使用范围在fn1内

def fn2():
    print(x) # x 能打印吗? 可见吗? 为什么?

print(x) #x能打印吗?可见吗?为什么?

• 全局变量

x = 5 # 全局变量，也在函数外定义
def foo():
    print(x) #可见吗？为什么？
    
foo()

• 一般来讲外部作用域变量在函数内部可见，可以使用
• 反过来，函数内部的局部变量，不能在函数外部看到

函数嵌套

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

def outer():
    def inner():
        print("inner")
    print("outer")
    inner()
    
outer() # 可以调用吗
inner() # 可以调用吗

• 内部函数inner不能在外部直接使用，会抛出NameError异常，因为它在函数外部不可见
• 其实，inner不过就是一个标识符，就是一个函数outer内部定义的变量而已

嵌套结构的作用域

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

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

    inner()
    print("outer {}".format(o))

outer() #输出结果 inner 65  ； outer 65

def outer2():
    o = 65
    def inner():
        o = 97
        print("inner {}".format(o))
        print(chr(0))

    inner()
    print("outer {}".format(o))

outer2() #输出结果 inner 97  ； outer 65

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

一个赋值语句的问题

x = 5
def foo():
	x += 1
foo() #报错如下
# UnboundLocalError: local variable 'x' referenced before assignment

• 原因分析：
  x += 1其实是 x = x+1
  相当于在foo内部定义一个局部变量 x，那么foo内部所有x都是这个局部变量x了
  x = x +1 相当于使用了局部变量x，但是这个x还没有完成赋值，就被右边拿来做加1操作了
• 如果解决这个常见问题？

global语句

x = 5
def foo():
	global x #全局变量
	x +=1
	print(x)
foo()

• 使用global关键字的变量，将foo内的x声明为使用外部的全局作用域中定义的x
• 全局作用域中必须有x的定义
  使用了global，foo中的x不再是局部变量，它是全局变量

总结

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

global使用原则

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

闭包

• 自由变量：未在本地作用域中定义的变量。例如定义在内层函数外的外层函数的作用域中的变量
• 闭包：就是一个概念，出现在嵌套函数中，指的是内层函数引用到了外层函数的自由变量，就形成了闭包。很多语言都有这个概念，最熟悉就是JaveSceipt

def counter():
	c = [0]
	def inc():
		c[0] += 1
		return c[0]
	return inc
foo = counter()
print(foo(), foo())
c = 100
print(foo())

• 代码分析
  第7行会执行counter函数并返回inc对应的函数对象，注意这个函数对象并不释放，因为有foo记着
  第4行不会报错，c已经在counter函数中定义过了。而且inc中的使用方式是为c的元素修改值，而不是重新定义c变量
  第8行打印 1 2
  第10行打印 3
  第9行的c和counter中的不一样，而inc引用的是自变量真是counter中的变量c
• 这就是Python2中实现闭包的方式，Python3还可以使用nonlocal关键字

nonlocal语句

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

def counter():
    count =0
    def inc():
        nonlocal count #声明变量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
foo() #打印 1
print(xyz) #错误传参 xyz是foo函数的本地变量，不可再函数范围外直接调用

def foo (xyz=[]):
    xyz.append(1)
    print(xyz)

foo() #打印 [1]
foo() #打印[1, 1]
print(xyz) #同上

• 第二次调用foo函数打印的是[1, 1]
  因为函数也是对象，每个函数定义被执行后，就生成了一个函数对象和函数名这个标识符关联
  python把函数的默认值放在了函数对象的属性中，这个属性就伴随着这个函数对象的整个生命周期
  通过查看foo._defaults_属性,它是个元祖

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

print(id(foo),foo.__defaults__)	# 打印结果 35535864 ([], 123, 'abc')
foo()							# 打印结果 [1]
print(id(foo),foo.__defaults__)	#打印结果 35535864 ([1], 123, 'abc')
foo()							#打印结果[1, 1]
print(id(foo),foo.__defaults__) #打印结果 35535864 ([1, 1], 123, 'abc')

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

非引用类型缺省值

def foo (xyz, m=123, n='abc'):
    m = 456
    n = 'def'
    print(xyz)

print(foo.__defaults__)	#结果 (123, 'abc')
foo('hello')			#结果 hello
print(foo.__defaults__)	#结果 (123, 'abc')

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

keyword-only参数的缺省值

def foo(xyz, m=123, *,n='abc',t =[1, 2]):
    m = 456
    n = 'def'
    t.append(30)
    print(xyz, m, n, t)

print(foo.__defaults__,foo.__kwdefaults__)	# 结果 (123,) {'n': 'abc', 't': [1, 2]}
foo('hello')								# 结果 hello 456 def [1, 2, 30]
print(foo.__defaults__,foo.__kwdefaults__)	# 结果 {'n': 'abc', 't': [1, 2, 30]}

• 属性__defaults__中使用元祖保存所有位置参数默认值
• 属性__kwdefaults__中使用字典保存所有keyword-only参数的默认值
• +和+=的区别：
  +表示两个列表合并并返回一个全新的列表
  +=表示，就地修改前一个列表，在其后追加一个列表。就是extend方法

变量名解析原则LEGB

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

函数的销毁

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