Python函数的返回值与嵌套函数

1.什么是返回值

• 返回值指的是函数返回的结果；
• return执行完毕后面的语句将不会再执行；

def add(x, y):
    print(x, y)   #输出：10 20
    return x + y   # 返回值， return之后的语句将不会再执行
    print(x)
    print(y)
add(10,20)

• 若是一个函数里面有两个return，前面return执行完毕，后面的return也不会执行；

def add(x, y):
    print(x, y)    # 输出：1 2
    return x + y   # 函数体内，碰到return语句，函数执行完毕，以后的语句将不会再执行
    return x - y   # 不会再次执行
add(1,2)

2.函数的隐式返回和显示返回

• Python函数都有返回值，若是有return语句，是显式返回；
• 若是没有return语句，默认返回None，是隐式返回；

3.函数多值返回

• 若是返回多个值经过逗号分开，会把值进行压缩，封装成一个元组；

def get_data(x,y,z):
    return x + 1, y + 1, z + 1
print(get_data(1,2,3)) # 获得的是一个元组(2, 3, 4)

• 若是返回一个列表，获得的就是一个列表；

def get_data(x,y,z):
    return [x + 1, y + 1, z + 1]
print(get_data(1,2,3))  # 获得的是一个列表[2, 3, 4]

4.什么是嵌套函数

def outer_function():
    # 内部函数
    def inner_function():
        print("inner_function")  # 输出：inner_function
    print("outer_function")      # 输出：outer_function
    # 内部调用
    inner_function()
outer_function()
# 注意：inner_function函数只能在outer_function函数内部调用，没法再outer_function函数外部被调用

• 嵌套函数的内部函数只能在包含它的函数的直接父级调用，也就是只能在包含它的外部函数中调用；
• 嵌套函数层数不宜过深，通常3层之内便可，太深不够直观，容易形成代码混乱；

5.函数做用域

• 做用域指的是，一个标识符的做用范围就是这个标识符的做用域；
• 在函数里面定义的变量（即局部做用域）只能在函数体内部被访问，函数外部不能访问；

def add(x, y):
    z = 100
    print(x, y , z)  #输出:1 2 100
add(1,2)
print(z)  #报错：NameError: name 'z' is not defined

• 在函数外部定义的变量（即全局做用域）能在函数体外部被访问，也能在函数体内部被访问；

z = 100
def add(x, y):
    print(x, y, z)# 输出：1 2 100
add(1, 2)
print(z)  # 输出：100

6.函数的闭包

• 闭包：内部函数引用了外部函数的变量，这就是闭包的定义；
• 若是函数体想访问变量，只能在变量定义以后才能访问；

# 例1
x=5
def add():
    y = x + 1
    print(y)  #输出：6
add()

# 例2
x=5
def add():
    x = x + 1  # 报错：local variable 'x' referenced before assignment
add()

# 报错缘由分析：
# 在例1中，函数内部引用的x为函数外部的x, 所以x的值为5
# 在例2中，函数内部从新定义了x的值，那么整个函数内部都会使用这个内部x，
# 所以在运算x + 1的时候，x尚未完成定义就被引用了，这里的x引用的必定是内部正在定义的 x，不是函数外部的 x=5这个x；


# 例3：
x=5
def add():
    print(x) # 这里的x引用的是x = 1的x，可是执行print(x)时，x尚未被定义，因此报错：local variable 'x' referenced before assignment
    x =  1
add()

• 若是要访问函数体内部的函数，能够先把内部函数的函数名做为外部函数的返回值，把外部函数的引用赋值给变量，再调用变量；

# 例4：
def outer_function():
    x = 100
    def inner_function():
        print(x)        # 内部函数引用了外部函数的自由变量  输出：100
    return inner_function
ret = outer_function()
ret()

7.关键字

• global关键字：能够指定变量为全局变量，可是global关键字会污染全局变量，也就是会覆盖以前全局变量的值，因此最好慎用；

x=1
def add():
    global x  # 使用global关键字，指定x的引用全局的x变量
    x = x + 1
    print(x)  #输出：2
add()

x = 100
def foo():
    global x  # x被声明了全局变量
    x = 10
    x += 1
    print(x)  # x的值为11
foo()
print(x)      # 输出x的值为：11，本来这里应该引用的是全局变量x = 100 的，所以global关键字污染了全局变量 x

• nonlocal关键字：能够申明内部函数的变量引用的是外部函数变量的值（做用域在外部函数），不是全局做用域的值，所以不会污染全局做用域；

def outer_function():
    x = 100
    def inner_function():
        x = x + 1       # 这样会报错，函数内部从新定义了x的值，可是尚未完成定义就被引用了
        print(x)
    return inner_function
ret = outer_function()
ret()


def outer_function():
    x = 1
    def inner_function():
        nonlocal x   # 使用nonlocal关键字声明x 为外层函数的x的值
        x = x + 1    #因此这里使用的x 是外层函数的x
        print(x)   #输出：2
    return inner_function
ret = outer_function()
ret()

8.函数默认值的做用域

• 同一个函数的生命周期相同，函数的默认值会绑定在函数的整个生命周期上，不会由于函数内部对默认值的操做而发生改变；

def add(lst = []):
    lst.append('hello')
    print(lst)
add() # 输出：['hello']
print('id={}'.format(id(add)))   # 函数对象的id值不变，调用的是同一个函数  id=1837000
add() # 输出['hello', 'hello']
print('id={}'.format(id(add)))   # 函数对象的id值不变，调用的是同一个函数  id=1837000

# 查看函数的位置参数的默认值
print(add.__defaults__)    #输出：(['hello', 'hello'],)

# 查看函数的关键字参数的默认值
print(add.__kwdefaults__)  #输出：None

• 可使用浅拷贝copy（简写[:]）来清空默认值，那每次调用函数，默认值都为初始值；

def add(lst = []):
    lst = lst[:]
    lst.append('hello')
    print(lst)
add() # 输出：['hello']
add() # 输出：['hello']

• 也能够经过参数值判断来给默认值从新赋值，那每次调用函数，默认值都为初始值；

def add(lst=None):
    if lst is None:
        lst = []
    lst.append(1)
    print(lst)
    
add()    # 输出：[1]
print(add.__defaults__)  # 输出： (None,)

add([1, 2, 3])    # 输出： [1, 2, 3, 1]
print(add.__defaults__)  # 输出：(None,)

add([4, 5, 6])     # 输出：[4, 5, 6, 1]
print(add.__defaults__)    # 输出：(None,)

9.函数销毁

def add():
    print('add')
del add
add()

• 能够经过 del 函数名 的方式来删除函数，再调用函数时，就会报错不存在；

参考：侠课岛（9xkd.com）Python同窗计划