python 函数 动态参数 和嵌套

1.动态参数
  是可以接收任意的参数.
一种方式,
    1,位置的动态传参,  写法是:   *参数名
    接收的参数是tuple类型
举个例子:
def yue(*food):
    print(food)
yue("香蕉",'苹果','芒果')
yue("键盘",'鼠标','rng牛批')
yue('北冰洋','脉动','百岁山,')
这样不用一个一个带进去,一个*food 就全部概括了
顺序是:  位置参数,动态参数(*),默认值参数
     2,**参数名   形成一个字典
关键字参数的动态传参,,写法是: **参数名, 例如: **kwarg
利用**来接收动态关键字参数
def func(**kwargs):
    print(kwargs)
func(a=1, b=2, c=3)
func(a=1, b=2)
结果:
{'a': 1, 'b': 2, 'c': 3}
{'a': 1, 'b': 2}
接收的是一个dict 字典

他们最终的顺序是:
位置参数,*args,默认值参数, **kwargs

无敌传参
def func(*args, **kwargs)
这个参数是什么都可以接收,无敌的
*, ** 的作用:
# # 在形参: 聚合
# # 在实参: 打散
命名空间:
  ①全局命名空间 --> 我们直接在py文件中,函数外声明的变量都属于全局命名空间
  ②局部命名空间 --> 在函数中声明的变量会放在局部命名空间
  ③内置命名空间 --> 存放python解释器为我们提供的名字,list,tuple,str,int这些都是内置命名空间

 加载顺序:内置               取值顺序是:局部
         全局                        全局
         局部                        内置
      作用域的问题
1. globals() 获取全局作用域中的内容
2.locals()    获取局部作用域中的内容
a = 10  # 全局
def func(): # 全局
    a = 40  # 局部
    b = 20  # 局部
    def abc():  # 局部
        d = 30 # 是局部
        print("哈哈")
        print(a, b) # 这⾥使⽤的是局部作⽤域
        print(locals())
    abc()

    # print(globals()) # 打印全局作用域中的内容
    # print(locals()) # 打印局部作用域中的内容,locals()打印当前这个函数局部作用与中的内容
func()

函数嵌套:
1.只要遇见了()就是函数的调用,如果没有()就不是函数的调用,
def fun1():
    print(111)

def fun2():
    print(222)
    fun1()

fun2()
print(333)
结果是  222  111  333

def fun2():
    print(222)
    def fun3():
        print(666)
    print(444)
    fun3()
    print(888)

print(33)
fun2()
print(555)
结果是  33  222  444 666 888 555

def func():
    print("哈哈哈")
a = func # 函数可以赋值 .相当于. a和func是一回事儿
func()
a()
结果是   哈哈哈
        哈哈哈


4.
global和nonlocal
global: 寻找全局作用域中的内容
nonlocal: 寻找上一级作用域中的内容, 但不能是全局的#
比如:
a=10
def func():
    global  a      # 这里的a 是全局的
    a=20           #a 被更改了
    print(a)
func()
print(a)
结果是:  20   20

a=10
def func1():
    a=20
    print(a)
    def fun2():
        nonlocal a          #上一级 ,且不能是全局
        a = 30
        print(a)
    fun2()
    print(a)
func1()
print(a)
结果是:  20  30  30  10