Python 函数（下）

1.函数名的使用
2.全局变量与局部变量
3.函数的嵌套
4.nonlocal 特指修改局部变量
5.闭包函数
6.匿名函数

---

1.函数名的使用

1.函数名是个特殊的变量，可以当做变量赋值

def func():
    print(1)
# 动态创建
a = func
# 调用函数
a()
# 动态销毁
del a

2.函数名可以作为容器类型数据的元素

def func1():
    print(1)
def func2():
    print(2)
def func3():
    print(3)
lst = [func1,func2.func3]
for i in lst:
    i()

3.函数名可以作为函数的参数

def func1():
    print("func1函数")

def func(func_xingcan):
    func_xingcan()    # func1()

func(func1)  # func1函数

4.函数名可作为函数的返回值

def func(func_xingcan):
    return func_xingcan

res = func(func1)    # res = func1
print(res)
res()    #  func1()

5.doc 定义函数的文档

def func():
    '''
    一些解释内容等...
    '''

# 方法一
res = func.__doc__
print(res)
# 方法二
help(func)

2.全局变量与局部变量

局部变量：定义在函数内部的变量，作用范围仅限定在函数内部，函数外部无法获取。
.
全局变量：定义在函数外部的变量，或者是在函数内部使用global关键字定义的变量，作用范围很跨整个文件。
.
作用域：作用的范围
.
生命周期：内建变量 > 全局变量 > 局部变量(调用函数时,局部变量创建,调用结束时,局部变量被销毁)
.
销毁顺序：局部、全局、内建

## global 的使用
#定义全局变量
def func():
    global a
    a = 10
func()
print(c)

# 修改全局变量
b = 20
def func():
    global b
    b = 30
func()
print(b)

3.函数的嵌套

函数的嵌套遵循 LEGB原则(就近原则)，从下往上，从里向外，一次寻找。

# 基本写法
def outer():
    def inner():
        print(1)
    inner()
outer()

4.nonlocal 特指修改局部变量

nonlocal 采用LEGB原则：
1.nonlocal 主要用来修改当前作用域上一级的局部变量
2.如果上一级空间没有该变量，会继续向上寻找
3.如果找不到，会直接报错

# 基本写法
def func():
    a = 16
    def inner():
        nonlocal a
        a = 61
    inner()
    print(a)
func()

# 不依赖 nonlocal 实现值的修改，必须是列表
def func():
    lst = [1,2,3]
    def inner():
        lst[-1] = 30
    inner()
    print(lst)
func()

5.闭包函数

为了延长局部变量的生命周期，执行脚本结束，再释放局部变量。

闭包函数：内函数使用了外函数的局部变量，外函数把内函数返回出来的过程，交闭包。里面的内函数就是闭包函数。
.
函数的普通参数是局部变量

def outer(val):
    def inner(num):
        return val + num
    return inner

func = outer(10)
res = func(15)
print(res)

6.匿名函数 lambda

用一句话来表达只有返回值的函数

# 语法格式
函数名 = lambda 参数 : 返回值

# 无参数
# 改造
func = lambda : 123
res = func()
print()

# 有参数
func = lambda n : type(n)
print(func("abc"))

# 带判断条件
func = lambda n : 真值 if条件 else 假值

func = lambda n : "偶数" if n % 2 == 0 else "奇数" 
res = func(18)
print(res)