函数的返回值，作用域以及函数名的应用

1 、返回值 return

"""
自定义函数的返回值,return 可以把值返回到函数的调用处
(1) return + 六大标准数据类型 , 还有类和对象,函数
    如果不定义return , 默认返回的是None
(2) 在执行完return之后,立刻终止函数,后面的代码不执行
"""
def func():
    for i in range(3):
        if i == 2:
            return 1
        print(i)
res = func()
print(res)
​
# 模拟简单的计算器 + - * /
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

　　

2、作用域

"""
局部变量 : 在函数内部定义的变量(局部命名空间)
全局变量 : 在函数外部定义的或者使用global在函数内部定义(全局命名空间)
​
作用域: 作用的范围
局部变量作用域: 在函数的内部
全局变量作用域: 横跨整个文件
​
生命周期:
内置变量 > 全局变量 > 局部变量
"""

　　

2.1 局部变量

def func():
    # 定义局部变量
    a = 5
    # 获取局部变量
    print(a)
    # 修改局部变量
    a = 10
    print(a)
func()

　　

2.1.1 nonlocal 在函数内部修改变量(LEGB原则)

# 注意点:nonlocal只能修改局部变量
def outer():
    a = 100
    def inner():
        a = 500
        def smaller():
            nonlocal a 
            a = 400
            print(a)              # 400
        smaller()
        print(a)                  # 400     nonlocal 修改了 inner函数下的 a
    inner()
    print(a)                      # 500     没有做修改
outer()

　　

2.1.2 不使用nonlocal 修改局部变量

def func():
   lst = [1,2,3,4]
   def inner():
      lst[-1] = 10               #  lst = [1,2,3,10]  自己没有会去上一层找
   inner()
   print(lst)
func()
​
# 注意点
def func():
   lst = [1,2,3,4]
   def inner():
      lst[-1] = 10  
      lst = [1,2,3]               #  报错  自己有需要先定义再修改         
   inner()
   print(lst)
func()

　　

2.2 全局变量

# 定义全局变量
b = 10
# 获取全局变量
print(b)
# 修改全局变量
b = 20
​
def func():
    # 可以在函数内部获取全局变量
    print(b)
func()

　　

2.2.1 global在函数内部创建全局变量

def func():
    global c
    c = 200
func()
print(c)

　　

2.2.2 global在函数内部修改全局变量

n = 100
def func():
    global n
    n = 200
func()
print(n)              # n = 200

　　

2.2.3 global小总结

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

　　

3、函数名的使用

3.1 函数名作变量

def func()
    print("func函数")
a = func
a()
​
del a                 # 销毁
func()                # 继续执行

　　

3.2 函数名作为容器类型的元素

def func1()
    print("我是func1")
def func2()
    print("我是func2")
def func3()
    print("我是func3")
lst = [func1,func2,func3]
for i in lst:
    i()                       # 执行函数

　　

3.3 函数名作为参数

def func1()
    print("我是func1")
​
def func(arg):
    arg()
    
func(func1)

　　

3.4 函数名作为返回值

def func():
    pass
    return arg
res = func()
res()

　　

4 、LEGB 原则

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

　　

5、locals()与glocal()

# locals 获取当前作用域中所有变量
​
"""
locals 如果在全局,调用locals之后,获取的是打印之前的所有变量,返回字典,全局空间作用域
locals 如果在局部,调用locals之后,获取的是调用之前的所有变量,返回字典,局部空间作用域
"""
# 例子1
def func():
    ff = 123
a = 1
b = 2
res = locals()
c = 3
print(res)
d = 4
​
# 例子2
a1 = 10
def func():
    a = 1 
    b = 2
    res = locals()
    c = 3
    print(res)
    d = 4
a2 = 20
func()
a3 = 30
​
# globals 只获取全局空间中所有变量
"""
globals 如果在全局,调用globals之后,获取的是打印之前的所有变量,返回字典,全局空间作用域
globals 如果在局部,调用globals之后,获取的是调用之前的所有变量,返回字典,全局空间作用域
"""
# 例子1
def func():
    ff = 123
a = 1
b = 2
res = globals()
c = 3
print(res)
d = 4
​
# 例子2
a1 = 10
def func():
    a = 1 
    b = 2
    res = globals()
    c = 3
    print(res)
    d = 4
a2 = 20
func()  # globals
a3 = 30
​
# globals 动态批量创建全局变量
# 1.用字符串定义全局变量
dic = globals()
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()
"""
"a%d" % (1) => a1
"a%d" % (2) => a2
"a%d" % (3) => a3
"a%d" % (4) => a4
"a%d" % (5) => a5
"""