day11:return关键字&全局/局部变量&函数名的使用&函数的嵌套&nonlocal关键字&locals/globals

关键字：return

自定义函数的返回值，return可以把值返回到函数的调用处
        1.return+六大标准数据类型，还有类和对象，函数
        如果不定义return，默认返回的是None
        2.在执行return之后，立刻终止函数，后面的代码不执行

# 1.return的返回类型
def func():
    # return 1
    # return 3.14
    # return "abc"
    # return []
    # return ()
    # return {"a":1}
    pass
res=func()
# 如果不定义return，默认返回的是None
print(res)

# 2.在执行完return 之后，立刻终止函数，后面的代码不执行
def func():
    print(1)
    print(2)
    return 3 # 立刻终止函数，后面的print(4)和print(5)不执行
    print(4)
    print(5)
res =func()
print(res)

def func():
    for i in range(3):
        if i==2:
            return 1
        print(i)
res = func()
print(res) # 0 1 1

# 3.模拟简单的计算器 + - * /
def func(sign,num1,num2):
    if sign=="+":
        res= num1+num2
    elif sign=="-":
        res =num1-num2
    elif sign=="*":
        res = num1*num2
    elif sign=="/":
        if num2 ==0:
            return "除数不能为0，老弟"
        res = num1/num2
    else:
        return "这个本计算器真算不了"
    return res

res = func("+",3,5)
res = func("-",10,20)
res = func("*",10,20)
res = func("/",20,10)
res = func("/",20,0)
res = func("&",20,0)
print(res)

全局变量和局部变量

局部变量：在函数内部定义的变量（局部命名空间）
全局变量：在函数外部定义的或者使用global在函数内部定义（全局命名空间）
作用域：作用的范围

局部变量作用域：在函数的内部
全局变量作用域：横跨整个文件

生命周期：
内置变量>全局变量>局部变量

1.局部变量

# 1.局部变量
def func():
    # 定义局部变量
    a=5
    # 获取局部变量
    print(a)
    # 修改局部变量
    a=10
    print(a)
func()
print(a) # error 不能在全局调用局部变量

2.全局变量

# 2.全局变量
# 定义全局变量
b=10
# 获取全局变量
print(b)
# 修改全局变量
b=20

def func():
    # 可以在函数内部获取全局变量
    print(b)
func()

3.使用global在函数内部创建全局变量

# 3.使用global在函数内部创建全局变量
def func():
    global c
    c=200
func()
print(c)

4.使用global在函数内部修改全局变量

# 4.使用global在函数内部修改全局变量
d=300
def func():
    global d
    d=400
func()
print(d)

5.总结：

可以使用global关键字在函数内部定义一个全局变量
也可以使用global关键字在函数内部修改一个全局变量

函数名的使用

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

def func():
    print("我是func函数")
    return 1

# 1.函数名是个特殊的变量，可以当做变量赋值
a="你好"
print(a)
a=func()
# a()

# 函数可以像变量一样销毁
del a
a()

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

# 2.函数名可以作为容器类型数据的元素
def func1():
    print("我是func1函数")
def func2():
    print("我是func2函数")
def func3():
    print("我是func3函数")

lst=[func1,func2,func3]
for i in lst:
    print(i)
    i() # func1() func2() func3()

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

# 3.函数名可以作为函数的参数
def func3():
    print("我是func3函数")

def func4(f):
    f() # 我是func3函数

func4(func3)

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

# 4.函数名可以作为函数的返回值
def func(f):
    return f
res = func(func2) # f---> func2 -----> res=func2()
res()

5.__doc__ 或者help查看文档

#  __doc__ 或者help查看文档
def func(a):
    """
    功能：xxxx
    参数：a
    返回值：1
    """
    print("xxxx")
    return 1

help(func)
res = func.__doc__
print(res)

输出结果：  功能：xxxx
          参数：a
          返回值：1
            

 函数的嵌套

1.一个简单的例子

def outer():
    def inner():
        print("我是inner函数")
    inner()
outer()
inner() # 调用外部函数时,内部函数不可以再函数外部调用!

1.内部函数可以直接在函数外部调用吗？不行
2.调用外部函数后，内部函数可以在函数外部调用吗？不行
3.内部函数可以在函数内部调用吗？ 可以
4.内部函数在函数内部调用时，是否有先后顺序？有！必须先定义再调用

2.函数嵌套案例

# 外层是outer，内层是inner，最里层是smaller，调用smaller里面的所有代码

def outer():
    def inner():
        def smaller():
            print("我是smaller函数",id)
        smaller()
    inner()
outer()

3.LEGB原则

找寻变量的调用顺序采用LEGB原则，即就近原则
B- Builtin（Python）：python内置模块的命名空间 （内建作用域）
G- Global（module）：函数外部所在的命名空间（全局作用域）
E -Enclosing function locals:外部嵌套函数的作用域（嵌套作用域）
L -Local(function):当前函数内的作用域(局部作用域)
依据就近原则 从下向上 由里向外 依次寻找

nonlocal关键字

nonlocal 遵循LEGB就近找变量原则
        1.找当前空间上一层的局部变量进行修改
        2.如果找不到，会继续向上寻找
        3.最后什么也没有，直接报错

1.找当前空间上一层的局部变量进行修改

# 1.找当前空间上一层的局部变量进行修改
def outer():
    a=100
    def inner():
        nonlocal a
        a=200
        print(a) # 200
    inner()
    print(a) # 200
outer()

2.如果找不到，会继续向上寻找

# 2.如果找不到，会继续向上寻找
def outer():
    a=100
    def inner():
        def smaller():
            nonlocal a
            a=400
            print(a) # 400
        smaller()
        print(a) # 400
    inner()
    print(a) # 400
outer()

3.注意点：nonlocal只能修改局部变量

# 3.注意点：nonlocal只能修改局部变量
a=100
def outer():
    def inner():
        def smaller():
            nonlocal a # nonlocal只能修改局部变量，而本程序中第一行的a是全局变量，nonlocal无法修改
            a=400
            print(a)
        smaller()
        print(a)
    inner()
    print(a) 
outer()

4.不使用nonlocal修改局部变量--->只能适用于列表

# 4.不使用nonlocal修改局部变量
def func():
    lst=[1,2,3,4]
    def inner():
        lst[-1]=10
    inner()
    print(lst)
func()

globals和locals

1.locals 获取当前作用域中所有变量

locals 如果在全局,调用locals之后,获取的是打印之前的所有变量,返回字典,全局空间作用域
locals 如果在局部,调用locals之后,获取的是调用之前的所有变量,返回字典,局部空间作用域

# locals 在全局：获取打印之前的所有变量
def func():
    ff = 123
a = 1
b = 2
res = locals()
c = 3
print(res) # 是一个大字典，里面有很多键值对,a:1 b:2 c:3均可以打印出来（截止到打印之前）
d = 4 # d:4 不会被打印

# locals 在全局
a1 = 10
def func():
    a = 1
    b = 2
    res = locals()
    c = 3
    print(res) # a:1 b:2 会被打印出来 截止到调用local()之前的都会被打印出来
    d = 4
a2 = 20
func()
a3 = 30

2.globals 只获取全局空间中所有变量

globals 如果在全局,调用globals之后,获取的是打印之前的所有变量,返回字典,全局空间作用域
globals 如果在局部,调用globals之后,获取的是调用之前的所有变量,返回字典,全局空间作用域

# global 在全局
def func():
    ff = 123
a = 1
b = 2
res = globals() # a:1 b:2 c:3 截止到打印之前
c = 3
print(res)
d = 4

# global 在局部
a1 = 10
def func():
    a = 1
    b = 2
    res = globals()
    c = 3
    print(res)
    d = 4
a2 = 20
func()  # globals() a1:10 a2:20 截止到调用处
a3 = 30

3.globals 动态批量创建全局变量

# 1.用字符串定义全局变量
dic = globals() # 必须是global定义的字典,普通字典无效
print(dic) # 返回的是系统的字典
# 在全局的字典当中,通过添加键值对,自动创建全局变量
# 对应的键时变量名,对应的值是变量指向的值
dic["name"] = "致和"
print(name) # 致和

# 2.批量定义全局变量
def func():
    dic = globals()
    # 通过在全局系统字典当中,添加键值对,批量创建变量
    for i in range(1,6):
        # "a%d" % (1) => "a1"  "a%d" % (2) => "a2"  
        dic["a%d" % (i)] = i #  1~5 
        
func()