Python 函数返回值、作用域

函数返回值

多条return语句：

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

def showplus(x):
    print(x) 
    return x + 1 
    return x + 2
#执行结果
10
11

#从结果来看 出现第一个return后 下面的就不会执行

def fn(x):
    for i in range(x): 
        if i > 3:
            return i 
        else:
            print("{} is not greater than 3".format(x))
#fn(5) 执行结构是4
#fn(3) 3 is not greater than 3

#可以看出，我们可以通过条件控制语句来控制return

总结：

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

返回多个值：

函数不能同时返回多个值
return[1,3,5] 是指明返回一个列表，是一个列表对象
return 1,3,5 看似返回多个值，隐式的被python封装成了一个元组

可以使用解构来提前

def showlist():
    return 1, 3, 5
x, y, z = showlist()

函数嵌套

def outer():
    def inner(): 
        print("inner")
    print("outer")
    inner() 
outer()
#inner() #报错，inner没定义。说有函数是有作用域的

函数有可见范围，这就是作用域的概念
内部函数不能在外部直接使用，会抛NameError异常，因为它不可见

作用域

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

举例，对比案例1和案例2

#案例1
x=5
def foo():
    print(x)
    
foo()
#有执行结构，复用了全局的变量x
#案例2
x=5
def foo():
    x+=1
    print(x)
    
foo()
#报错，x+=1 既是x= x+1 ,这里x被重新赋值了，所有x = x+1 既这里x是没有值的

全局作用域：

在整个程序运行环境中都可见

局部作用域：

在函数、类等内部可见
局部变量使用范围不能超过其所在的局部作用域

def fn1():
    x = 1 #局部作用域，在fn1内
    
def fn2():
    print(x) #不可见

print(x) #不可见

嵌套结构作用域例子：

#例子1、
def outer1(): #
    o = 65
    def inner():
        print("inner {}".format(o))
        print(chr(o)) 
    print("outer {}".format(o)) 
    inner()
outer1()
#例子2、
def outer2(): #
    o = 65
    def inner():
        o = 97
        print("inner {}".format(o)) 
        print(chr(o))
    print("outer {}".format(o)) 
    inner()
outer2()

从例子中看出：

外层变量作用域在内层作用域可见
内层作用域inner中，如果定义了o=97，相当于当前作用域中重新定义了一个新的变量o,但是这个o并没有覆盖外层作用域outer中的o

x= 6
def foo():
    x += 1
foo()

报错：

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

解决这个问题全局变量global 、nonlocal 来解决

全局变量global

案例

#x= 6
def foo():
    global x
    x = 10 
    x += 1  #不会报错了，
    print(x) #打印11
print(x) #报错，找不到b这个标识符

使用global关键字变量，将foo内的x声明为使用外部的全局作用域中定义的x
但是，x = 10 赋值既定义，在内部作用域为一个外部作用域的变量x赋值，不是在内部作用域定义个新变量，所有x +=1 不会报错，注意：这里x的作用域还是全局的

global总结：

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

global使用原则：

外部作用域变量会内部作用域可见，但也不要在这个内部的局部作用域中直接使用，因为函数的目的就是为了封装，尽量与外界隔离
如果函数需要使用外部全局变量，请使用函数的形参传参解决
一句话：不用global。学习它就是为了深入理解变量作用域

闭包

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

案例：

def counter():
    c = [0]
    def inc():
        c[0] += 1  #会报错吗？
        return c[0]  
    return inc
foo = counter()
print(foo(),foo())  #打印结果？
c = 100 
print(foo()) #打印结果?

代码解析：

不会报错，c已经在counter函数中定义过了，而且inc中的使用方式是为c的元素修改值，而不是重新定义变量
第一个的打印结果是 1， 2
最后一行的打印结果是 3
倒数第二行的c和counter中的c不一样，而inc引用的是自由变量正式counter的变量c
这是python2中实现闭包的方式，python3还可以使用nonlocal关键字

nonlocal关键字

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

例子：

def counter1():
    c = 0
    def inc():
        nonlocal c
        c += 1
        return c
    return inc
foo = counter()
foo()
foo()

c 是外层函数的局部变量，被内部函数引用
内部函数使用nonlocal关键字声明c变量在上级作用域而非本地作用域中定义

默认值作用域

案例

#案例1
def foo(xyz=1):
    print(xyz)
foo() # 打印  1 
foo() # 打印 1
print(xyz) # 报错 NameError 当前作用域没有xyz变量
#案例2
def foo(xyz=[]):
    xyz.append(1)
    print(xyz)
foo() # [1]
foo() # [1,1]

案例2中为什么第二个foo()会打印2个1

因为函数也是对象，python把函数的默认值放在了属性中，这个属性就伴随着这个函数对象整个生命周期
查看foo.__defaults__

运行下面案例

def foo(xyz=[], u='abc', z=123):
    xyz.append(1)
    return xyz 
print(foo(), id(foo)) 
print(foo.__defaults__) 
print(foo(), id(foo)) 
print(foo.__defaults__)

#执行结果
[1] 139927086673704
([1], 'abc', 123)
[1, 1] 139927086673704
([1, 1], 'abc', 123)

总结：

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

运行下面案例：

def foo(w, u='abc', *, z=123, zz=[456]):
    u = 'xyz'
    z = 789 
    zz.append(1) 
    print(w, u, z, zz)
print(foo.__defaults__) 
foo('magedu') 
print(foo.__kwdefaults__)

运行结果
('abc',)
magedu xyz 789 [456, 1]
{'z': 123, 'zz': [456, 1]}

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

按需修改的案例：

例如案例中列表增加的问题，如果我不想让他增加呢？

def foo(xyz=[], u='abc', z=123): 
    xyz = xyz[:] # 影子拷贝 
    xyz.append(1)
    print(xyz)
foo() 
print(foo.__defaults__) 
foo() 
print(foo.__defaults__) 
foo([10]) 
print(foo.__defaults__) 
foo([10,5]) 
print(foo.__defaults__)

函数体内，不改默认值
xyz都是传入参数或者默认值参数的副本，如果就想修改原参数，无能为力

第二种方法：

def foo(xyz=None, u='abc', z=123): 
    if xyz is None:
        xyz = [] 
    xyz.append(1) 
    print(xyz)
foo() 
print(foo.__defaults__) 
foo() 
print(foo.__defaults__) 
foo([10]) 
print(foo.__defaults__) 
foo([10,5]) 
print(foo.__defaults__)

使用不可变类型默认值
如果使用缺省值None就创建一个列表
如果传入一个列表，就地修改这个列表

第一种方法

使用影子拷贝创建一个新的对象，永远不能改变传入的参数

第二种方法

通过值的判断就可以灵活的选择创建或者修改传入对象
这种方法灵活，应用广泛
很多函数定义，都可以看到使用None这个不可变的值作为默认参数，可以说这是一种惯用法

变量名解析原则LEGB

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

函数销毁

全局函数销毁

重新定义同名函数
del语句删除函数对象
程序退出时

def foo(xyz=[], u='abc', z=123):
    xyz.append(1)
    return xyz
print(foo(), id(foo), foo.__defaults__) 
def foo(xyz=[], u='abc', z=123):
    xyz.append(1)
    return xyz
print(foo(), id(foo), foo.__defaults__) 
del foo
print(foo(), id(foo), foo.__defaults__)

局部函数销毁

重新在上级作用域定义同名函数
del语句删除函数名称，函数对象的引用计数减1
上级作用域销毁时

def foo(xyz=[], u='abc', z=123):
    xyz.append(1)
    def inner(a=10):
        pass 
    print(inner)
    def inner(a=100):
        print(xyz) 
    print(inner) 
    return inner
bar = foo()
print(id(foo),id(bar), foo.__defaults__, bar.__defaults__) 
del bar
print(id(foo),id(bar), foo.__defaults__, bar.__defaults__)