Python----函数命名空间,函数的嵌套

# 03，动态参数 *args，**kwargs
# # 用户传入到函数中的实参数量不定时，或者是为了以后拓展，
# # 此时要用到动态参数*args，**kwargs(万能参数。)
# # *args接收的是所有的位置参数。
# # **kwargs接收的是所有的关键字参数。
# # 位置参数，*args，默认参数, **kwargs
# 04，名称空间，作用域，作用域链，加载顺序等。
# 05，函数的嵌套。
# 06，global，nonlocal。

#动态传参:

# def func1(a,b,c):
#     pass
# # func1(1,2,3)
# func1(1,2,3,4,5,6,6)
# print()
# 用户传入到函数中的实参数量不定时，或者是为了以后拓展，
# 此时要用到动态参数*args，**kwargs(万能参数。)
# *args接收的是所有的位置参数。
# **kwargs接收的是所有的关键字参数。


#位置参数,默认参数
# def func2(a,b,sex='男'):
#     print(a)
#     print(b)
#     print(sex)
# func2(1,2,'女')

#位置参数,*args,默认参数
# def func2(a,b,*args,sex='男'):
#     print(a)
#     print(b)
#     print(args)
#     print(sex)
# func2(1,2,5,6,7,8,'f',sex='女')

# 位置参数，*args，默认参数, **kwargs
# def func2(a,b,*args,sex='男',age=20,**kwargs):
#     print(a)
#     print(b)
#     print(args)
#     print(sex)
#     print(age)
#     print(kwargs)
# func2(1,2,4,6,7,5,67,x=5,y=78,name='xiaoming')

# def suml(*args):
#     ret=0
#     for i in args:
#         ret+=i
#     return ret
# print(suml(1,2,3,))
# # *的魔性用法
def func3(*args,**kwargs):#在函数定义时，*是集合
    # print(args)
    # return kwargs
    pass

l1 = [1, 2, 3]
l2 = [11, 21, 32]
dic={'name':'alex','age':'1000'}
print(func3(*l1,*l2,**dic))#函时数中没有return时，打印时会出现None
                             # l1,l2，**dic 在外部转化
                             # 在函数调用时，*是打散


#名称空间,加载顺序

#当程序运行时，代码从上至下一次读取，遇到变量与值，
# 他会在内存中开辟一个空间，存放变量与值的内存地址的对应关系。
#这样存储变量与值得对应关系的空间叫做名称空间(命名空间)。
#当解释器遇到函数时，他会将函数名存储在内存中，但是对于函数体莫不关心。
#当函数执行时，他会通过函数名找到函数体，然后将函数体里面的变量等对应关系存放在一个
# 临时开辟的空间中，随着函数的结束，临时的空间关闭，这样的空间叫做临时名称空间。

#内置名称空间：
# len() print() input() list
'''
名称空间：
    内置名称空间
    全局名称空间
    局部名称空间
加载顺序：内置名称空间  ---> 全局名称空间（程序运行时） ---->局部名称空间(函数执行时)
作用域：
    全局作用域：内置名称空间 全局名称空间
    局部作用域：局部名称空间
取值顺序(单项):局部名称空间(函数执行时) ---> 全局名称空间 ---> 内置名称空间
L local
E eclose
G global
B Built-in
'''

# name = '老男孩'
# def func1():
#     sum = 555
#     print(sum)
# func1()
# sum = 666
# print(sum)

# sum = 666  # global
# def func1():
#     sum = 555  # eclose
#     print(sum)
#     def inner():
#         pass
#         sum = 111   # local
#         print(sum)
#     inner()
# print(sum)
# func1()
#函数的嵌套
# print(111)   # 1
# def func1():
#     name = 'alex'
#     print(name)  # 2
#     def inner():
#         a = 2
#         print(a)  # 3
#     inner()
# func1()


# print(111)
# def func1():
#     name = 'alex'
#     print(name)
#     def inner():
#         a = 2
#         print(a)
#     inner()
# print(333)
# func1()

# print(111)
# def func1():
#     name = 'alex'
#     print(name)
#     def inner():
#         a = 2
#         print(a)
#     print(444)
#     inner()
#     print(555)
# func1()

# 111  'alex'  444  2  555

# def func1():
#     a = 666
#     print(666)
# def func2():
#     name = 'taibai'
#     print(name)
#     func1()
# print(333)
# func2()
# print(555)

# 333 'taibai' 666  555

# global  nonlocal

# def func1():
#     name = 'alex'
#     print(name)
#     return name
# ret = func1()
# print(ret)

# def func1():
#     global name
#     name = 'alex'
# func1()
# print(name)
# name = '老男孩'
# def func1():
#     global name
#     name = 'alex'
# func1()
# print(name)
# 在全局名称空间里得到局部名称空间的变量
# 1，return
# 2，global
    # 1,在局部作用域中声明一个全局变量。
    # 2，在局部作用域中，更改一个全局变量。
    # 补充：
        # 对于可变的数据类型，函数中如果对其进行操作，改变全局不用引用global.
# l1 = [1, 2, 3]
# def func1():
#     l1.append(666)
# func1()
# print(l1)

# nonlocal
#1,不能改变一个全局变量。
# 在局部作用域中，对父级作用域（或者更外层作用域非全局作用域）的变量进行引用和修改，
# 并且引用的哪层，从那层及以下此变量全部发生改变。

name = "老男孩"
def func1():
    name = 'alex'
    print(name)  # 1, alex
    def inner():
        nonlocal name
        name = '老男孩'
        print(name)  # 2 老男孩
    inner()
    print(name)  # 3，alex 老男孩
func1()