一、函数返回值

先看下几个例子：

# return之后可以执行吗？
def showplus(x):
    print(x)
    return x + 1
    print('~~~~end~~~~') # return之后会执行吗？ -- 不会！

showplus(5)

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

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

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

总结：

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

能够一次返回多个值吗？

def showvalues():
    return 1, 3, 5
    
print(showvalues()) # 返回了一个值，是一个三元组；并不是返回三个值

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

二、函数作用域

1、作用域

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

def foo():
    x = 100
    
print(x) # 可以访问地到吗？ -- 不行

上例的 x 不可以访问到，会抛出异常 (NameError: name 'x' is not defined)，原因在于函数是一个封装，它会开辟一个作用域，x变量被限制在这个作用域中，所以在函数外部，x变量不可见。

注意：每一个函数都会开辟一个作用域

2、作用域的分类

2.1 全局作用域

• 在整个程序运行环境中都可见
• 全局作用域中的变量称为全局变量

2.2 局部作用域

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

# 局部变量
def fn1():
    x = 1 # 局部变量
    
def fn2():
    print(x) # 访问不到x
    
print(x) # 访问不到x

# 全局变量
x = 5 # 全局变量
def foo():
    print(x) # 访问的到x

foo()

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

3、函数嵌套

在函数中定义另一个函数：

def outer():
    def inner():
        print("inner")
    print("outer")
    inner()
    
outer()
inner() # NameError: name 'inner' is not defined

内部函数 inner 不能在外部直接使用，会抛出NameError异常，因为他在其他函数外部不可见。

其实，inner 不过就是一个标识符，就是一个函数 outer 内部定义的变量而已。

3.1 嵌套结构的作用域

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

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("outer {}".format(o))
    
outer2()


# 运行结果：

inner 97
a
outer 65

从执行结果可以看出：

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

4、一个赋值语句的问题

思考：

函数1	函数2
x = 5 def foo(): print(x) foo()	x = 5 def foo(): y = x + 1 # 可以运行 x += 1 # UnboundLocalError: local variable 'x' referenced before assignment print(x) foo()
正常执行，函数外部的变量在函数内部可见	执行错误，为什么？难道函数内部又不可见了吗？

原因分析：

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

如何解决这个问题呢？

5、global语句

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

foo()

• 使用global关键字的变量，将foo内的x声明为使用外部全局作用域定义的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() 
print(x) # 可以吗？-- 可以

使用global关键字定义全局变量，虽然在foo函数中声明，但是这将告诉我们当前foo函数作用域，这个x变量将使用外部全局作用域中的x。

即使是在foo中又写了 x = 10，也不会在foo这个局部作用域中定义局部变量x了。

使用了global，foo中的 x 不再是局部变量了，它是全局变量。

5.1 总结

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

5.2 global的使用原则

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

6、闭包

自由变量：未在本地作用域中定义的变量。例如定义在内层函数外的外层函数的作用域中的变量。

闭包：就是一个概念，出现在嵌套函数中，指的是内层函数引用到了外层函数的自由变量，就形成了闭包。很多语言都有这个概念，最熟悉的就是JavaScript。

def counter():
    c = [0]
    def inc():
        c[0] += 1 # 会报错吗？为什么
        return c[0]
    return inc
foo = counter()
print(foo(), foo())  
c = 100
print(foo())

# 思考：
# 第4行会不会报错？
# 第8行打印结果是什么？
# 第10行打印结果是什么？

代码分析：

• 第7行会执行counter函数，返回inc对应的函数对象，注意这个函数对象并不释放，因为有foo记着
• 第4行会报错吗？为什么
  • 不会
  • 因为c已经在counter中定义过了，而且inc中的使用方式为c修改元素值，而不是重新定义c变量，所以inc函数不认为c变量是本地变量，而是引用了外部函数的自由变量c，没有犯[前面讲过的赋值语句引起的错误](# 4、一个赋值语句的问题)
• 第8行打印结果是什么？
  • 打印1 2
• 第10行打印结果是什么？
  • 打印3
  • 第9行的c和counter定义的c不一样，而inc使用的是自由变量正是counter中的变量c

这是python 2中实现闭包的方式，python 3还可以使用nonlocal关键字。

在看下面这段代码，会报错吗？使用global能解决吗？

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

肯定会报错，因为第4行犯了前面讲过的赋值语句引起的错误，使用global能解决：

def counter(): 
    global count #
    count = 0
    def inc():
        global count #
        count += 1
        return count
    return inc
    
foo = counter()
print(foo(), foo())

这是使用全局变量来解决，而不是闭包。

如果要对这个普通变量使用闭包，python 3中提供nonlocal关键字。

7、nonlocal语句

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

def counter():
    count = 0
    def inc():
        nonlocal count # 声明变量count不是本地变量
        count += 1
        return count
    return inc
    
foo = counter()
print(foo(), foo())

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

a = 50
def counter():
    nonlocal a # SyntaxError: no binding for nonlocal 'a' found，上级作用域是全局
    a += 1
    print(a)
    count = 0
    def inc():
        global count
        count += 1 
        return count
    return inc

foo = counter()
foo()
foo()

上例是错误的，nonlocal声明a不在当前作用域，但是往外就是全局作用域了，所以错误。

三、默认值的作用域

def foo(xyz=1):
    print(xyz)
    
foo()  # 1
foo()  # 1
print(xyz)  # NameError: name 'xyz' is not defined

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

为什么第二个函数第6行打印出来是 [1, 1] ？

• 因为函数也是对象，每个函数执行完后，就生成了一个函数对象和函数名这个标识符关联
• python把函数的默认值放在了函数对象的属性中，这个属性就伴着这个函数对象的整个生命周期
• 查看foo.__defaults__ 属性，他是个元组

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

print(id(foo), foo.__defaults__)
foo()
print(id(foo), foo.__defaults__)
foo()
print(id(foo), foo.__defaults__)


# 运行结果
2464804553352 ([],)
[1]
2464804553352 ([1],)
[1, 1]
2464804553352 ([1, 1],)

函数地址没有变，就是说foo这个函数对象没有动过，调用它，它的属性 _defaults_ 中使用元组保存默认值

xyz默认值是引用类型，引用类型的元素变动，并不是元组的变动

非引用类型的默认值：

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

print(id(foo), foo.__defaults__) # 1370273530504 (123, 'abc')
foo('pinginglab')                # pinginglab
print(id(foo), foo.__defaults__) # 1370273530504 (123, 'abc')，和前面一样

属性 _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(id(foo), foo.__defaults__, foo.__kwdefaults__)
foo('pinginglab')
print(id(foo), foo.__defaults__, foo.__kwdefaults__)

属性 _defaults_ 中使用元组保存所有位置参数的默认值

属性 _kwdefaults_ 中使用字典保存所有keyword-only参数的默认值

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


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

只有一句话不同，输出结果却不同？

这是因为 a += [5] 和 a = a + [5] 的区别：

• + 表示两个列表合并并返回一个新的列表
• += 表示就地修改前一个列表，在其后面追加一个列表，就是相当于 a.extend([5])

四、变量名解析原则LEGB

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

所以一个变量的查找顺序就是LEGB。

<img src="https://gitee.com/jackyfmy/resource/raw/master/static/20200416003010.png" style="zoom: 67%;" />

五、函数的销毁

定义一个函数就是生成一个函数对象，函数名指向的就是函数对象。

可以使用del语句删除函数，使其引用计数减一。

可以使用同名标识符覆盖原有定义，本质上也是使其引用计数减一。

python程序结束时，所有对象销毁。

函数也是对象，也不例外，是否销毁，还是看引用计数是否减为0。