函数 动态参数， 名称空间 作用域 取值顺序，函数的嵌套

你的函数，在工作当中一般不会写死，要留有余地去拓展，对于传入的实参数量不确定是多少个，万能参数，动态参数： *args     **kwargs

# def sum1(*args,**kwargs):  # 在函数的定义时，在 *位置参数，聚合。
#                    # *args 将所有的实参的位置参数聚合到一个元组，并将这个元组赋值给args
约定成俗 用args   不用 你就很low

# * 的魔性用法
# 在函数的定义时，在 *位置参数，**位置参数聚合。
# 在函数的调用(执行)时，在 *位置参数，**位置参数打散。
# l1 = [1,2,3]
# l2 = [111,22,33,'alex']
# #
# def func1(*args):
#     print(args)
#     return args[0] + args[1]
# print(func1(l1,l2))

# def func1(*args,**kwargs):
#     # print(args)
#     print(kwargs)
# func1(*l1,*l2)
# func1(*(1,2,3),*('alex','sb'))
# func1(*'alex',*'sb')
# func1(1,2,3,'alex','sb')

# 形参的顺序

# 位置参数，*args, 默认参数 **kwargs
# def func(a,b,*args,sex='男',**kwargs,):
#     print(a,b)
#     print(sex)
#     print(args)
#     print(kwargs)
# func(100,200,1,2,34,5,6,sex='nv',name='alex',age=1000)
---------------------------------

我们首先回忆一下Python代码运行的时候遇到函数是怎么做的，从Python解释器开始执行之后，就在内存中开辟里一个空间，每当遇到一个变量的时候，就把变量名和值之间对应的关系记录下来，但是当遇到函数定义的时候，
解释器只是象征性的将函数名读如内存，表示知道这个函数存在了，至于函数内部的变量和逻辑，解释器根本不关心。
等执行到函数调用的时候，Python解释器会再开辟一块内存来储存这个函数里面的内容，这个时候，才关注函数里面有哪些变量，而函数中的变量回储存在新开辟出来的内存中，函数中的变量只能在函数内部使用，
并且会随着函数执行完毕，这块内存中的所有内容也会被清空。
我们给这个‘存放名字与值的关系’的空间起了一个名字-------命名空间。
代码在运行伊始，创建的存储“变量名与值的关系”的空间叫做全局命名空间；
在函数的运行中开辟的临时的空间叫做局部命名空间。

# python中，名称空间分三种：
    # 全局名称空间
    # 局部名称空间（临时）
    # 内置名称空间

# 作用域：
#     全局作用域 全局名称空间 内置名称空间
#     局部作用域 局部名称空间（临时）

# 取值顺序： 就近原则
    # 局部名称空间  ---->  全局名称空间 ----->内置名称空间  单向从小到大范围

-------------------------

加载顺序
    # 内置名称空间 ----> 全局名称空间（当程序执行时） --- > 局部名称空间（当函数调用的时候）
-----------------------------------
global           nonlocal
局部名称空间 ，对全局名称空间的变量可以引用，但是不能改变

# count = 1
# def func1():
#     count = 2
#     print(count)
# func1()
# count = 1
# def func1():
#     # count = 3
#     count = count + 1  # local variable 'count' referenced before assignment
#     print(count)
# func1()

如果你在局部名称空间 对一个变量进行修改，那么解释器会认为你这个变量在局部中已经定义
但是对于上面的例题，局部中没有定义，所以它会报错。

# global
    # 1，在局部名称空间声明一个全局变量。
# def func2():
#     global name
#     name = 'alex'
# func2()
# print(name)
    # 2，在局部名称空间可以对全局变量进行修改。
# count = 1
# def func1():
#     global count
#     count = count + 1
#     print(count)
# func1()
# print(count)

# nonlocal
# def func1():
#     count = 666
#     def func2():
#         print(count)
#     func2()
# func1()


# nonlocal
# 子函数对父函数的变量进行修改。
# 此变量不能是全局变量。

# 在局部作用域中，对父级作用域（或者更外层作用域非全局作用域）的变量进行引用和修改，
# 并且引用的哪层，从那层及以下此变量全部发生改变。
def func1():
    count = 666
    def inner():
        print(count)
        def func2():
            nonlocal count
            count += 1
            print('func2',count)
        func2()
        print('inner',count)
    inner()
    print('func1',count)
func1()
#  666  func2 667  inner 667  func1 667