函数返回值及函数作用域

函数返回值

#return语句之后可以执行吗？
def showplus(x):
    print(x)
    return x+1
    print('~~~~~~~~~~') #return之后会执行吗？

在这里插入图片描述

# 多条return语句都会执行吗
def showplus(x):
    print(x)
    return x+1
    return x+2

在这里插入图片描述

# 下例多个return可以执行吗
def guess(x):
    if x<3:
        return "x>3"
    else:
        return "<=3"
print(guess(10))

在这里插入图片描述

#### 下面函数执行的结果是什么
def fn(x):
    for i in range(x):
        if i >3:
            return 1
    else:
        print("{} is not greater than 3".format(x))
print(fn(5))
print(fn(3))

在这里插入图片描述
总结：

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

def showvalues():
    return 1,3,5

在这里插入图片描述

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

函数作用域

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

def foo():
    x=100

在这里插入图片描述
上例中X不可以访问到，会抛出异常（NameError:name ‘y’ is not defined）,原因在于函数是一个封装，它会开辟一个作用域，X变量被限制在这个作用域中，所以在函数外部X变量不可见
每一个函数都会开辟一个作用域

作用域分类

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

# 局部变量
def fn1():
    x=1  #局部作用域，X为局部变量，使用范围在fn1中
    
def fn2():
    print(x) #x能打印吗？可见吗？

在这里插入图片描述

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

在这里插入图片描述

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

函数嵌套

def outer():
    def inner():
        print("inter")
    print("outer")
    inner()

在这里插入图片描述
内部函数inner不能在外部直接使用，会抛出NameError异常，因为它在函数外不可见
inner不过就是一个标识符，就是一个函数outer内部定义的变量而已

嵌套结构的作用域

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

在这里插入图片描述

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

在这里插入图片描述
从执行的结果来看：

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

一个赋值语句的问题

函数1:正常执行，函数外部的变量在函数内部可见

x=5
def foo():
    print(x)
foo()

在这里插入图片描述

函数2

x=5
def foo():
    y=x+1
    #x+=1
    print(x)
foo()

在这里插入图片描述

x=5
def foo():
    y=x+1
    x+=1
    print(x)
foo()

在这里插入图片描述
函数2为什么报错？
原因分析：

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的定义

如果全局作用域中没有x定义

情形1

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

在这里插入图片描述

情形2

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

在这里插入图片描述
使用global关键字定义的变量，虽然在foo函数中声明,但是这将告诉当前foo函数作用域，这个x变量将使用外部全局作用域中的x
即使是在foo中有写x=10,也不会在foo这个局部作用域中定义局部变量了
使用了global,foo中的x不再是局部变量了，它是全局变量x

总结

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

global使用原则

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

闭包

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

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

在这里插入图片描述
代码分析：

在第七行foo=counter()，这一行代表执行counter函数并返回inc对应的函数对象，注意这个函数对象并不释放
第四行 c[0]+=1，并不会报错，c已经在counter函数中定义过了，而且inc中的使用方式是为c的元素修改值，不是重新定义c变量
第9行中定义了一个c=100，相当于counter外部的全局变量，但是counter中定义了局部变量所以inc中不是用c=100

nonlocal语句

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

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

在这里插入图片描述

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

在这里插入图片描述
c是外层函数的局部变量，被内部函数引用
内部函数使用nonlocal关键字声明c变量在上级作用域而非本地作用域中定义
代码中内层函数引用外层局部作用域中的自由变量，形成闭包

a=100
def counter():
    nonlocal a
    a+=1
    print(a)
    count=0
    def inc():
        nonlocal count
        count+=1
        return count
    return inc
foo=counter()
foo()
foo()

在这里插入图片描述
上例是错误的，nonlocal声明变量a不在当前作用域，但是往外就是全局作用域

默认值的作用域

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

在这里插入图片描述

def foo(xyz=[]):
    xyz.append(1)
    print(xyz)
foo()
foo()
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__)
foo()
print(id(foo),foo.__defaults__)
foo()
print(id(foo),foo.__defaults__)

在这里插入图片描述
函数地址并没有变，就是说foo这个函数对象的没有变过，调用它，它的属性__defaults__中使用元组保存默认值，xyz默认值是引用地址，引用类型的元素变动，并不是元组的变化。

# 非引用类型缺省值
def foo(xyz,m=123,n='abc'):
    m=456
    n='def'
    print(xyz)
print(foo.__defaults__)
foo('damiao')
print(foo.__defaults__)

在这里插入图片描述
属性__defaults__中使用元组保存所有位置参数默认值，它不会因为在函数体内改变了局部变量（形参）的值而发生变化

#keyword-only参数的缺省值
def foo(xyz,m=123,*,n='abc',t=[1,2]):
    m=456
    n='def'
    t.append(300)
    print(xyz,m,n,t)
print(foo.__defaults__,foo.__kwdefaults__)
foo('damiao')
print(foo.__defaults__,foo.__kwdefaults__)

在这里插入图片描述
属性__defaults__中使用元组保存所有位置参数默认值
属性__kwdefaults__中使用字典保存所有keyword-only参数的默认值

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

在这里插入图片描述

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

在这里插入图片描述
+和+=的区别：

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

变量名解析原则LEGB

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

函数的销毁

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