函数的动态参数和作用域

1. 动态参数

位置参数的动态参数: *args

* 在这里表示接收位置参数的动态传参,接收到的是元祖
def chi(*food):          # 可以传入任意的位置参数   food是参数名,*便是动态参数    
　　print("我要吃",food)  # 动态参数接收到的是tuple类型的数据
chi("盖浇饭", "辣条", "面条")
chi('大米饭','小米饭')
chi()    # 可以接收空,接收到的也是元祖

关键字参数的动态参数 : **kwargs

def func(**food):         # **food动态接收关键字参数
    print(food)                # 接收到的是dict类型

func(good_food="盖浇饭", no_good_food="辣条", drink="冰封")

这个函数可以接收所有的参数(无敌的)

def func(*args, **kwargs):
    print(args)
    print(kwargs)
func(1, 2, 5, 6, name="taibai",age=18, sex="不详")

顺序:位置,*args,默认值,**kwargs

在形参上:'*','**',表示聚合,所有的位置参数,*聚合成元祖,**聚合成字典
在实参上:'*','**',表示打散,*打散,迭代传参,**打散字典,以k=v形式进行传参

def func(*args, **kwargs):
    print(args)
    print(kwargs)
lst = ["钢铁侠", "蜘蛛侠", "煎饼侠", "蝙蝠侠"]
func(*lst)     # 实参, 打散, 迭代产生的
func(lst)       #没有打散
dic = {"name":"小猴", "age":26}
func(**dic)     # 把字典打散. 以key=value形式进行传参
func(dic)      # 没有打散



('钢铁侠', '蜘蛛侠', '煎饼侠', '蝙蝠侠')     # 是个元祖,里边装了4个元素
(['钢铁侠', '蜘蛛侠', '煎饼侠', '蝙蝠侠'],)   # 也是个元祖,里边是个列表,但是是1个元素
{'name': '小猴', 'age': 26}    # 就是一个字典
({'name': '小猴', 'age': 26},)    # 是个元祖,装了个字典

定义函数

def 函数名(形参):  1.位置参数, 2, *args, 3.默认值参数, 4. **kwargs
   函数体   
　　return 返回值
函数名(实参)    1. 位置参数. 2.关键字参数. 3. 混合参数,

2. 命名空间和作用域

   命名空间: 存放名字和值的空间
   1. 内置命名空间: python解释器内部运行时存储的:int,str,list,tuple这些名字的空间
   2. 全局命名空间: 在代码运行初始,创建的存储名字和值的空间
   3. 局部命名空间: 在函数内部运行中创建的空间

作用域:
1.全局作用域:内置+全局命名空间,在整个文件的任意位置都可以被引用,全局有效
2.局部作用域:局部命名空间,只在局部范围内生效

globals() 查看全局作用域中的名字
locals() 查看当前作用域中的名字

a = 10
def func():
    a = 20
    print(globals())  # globals() 获取到全局作用域(内置,全局)中的所有名字
    print(locals())  # locals() 查看当前作用域中的所有名字
func()



记住:如果是函数必须是函数调用后,才能查看作用域

三种命名空间之间的加载与取值顺序：

加载顺序：内置命名空间(程序运行前加载)=>全局命名空间(程序运行中：从上到下加载)=>局部命名空间(程序运行中：调用时才加载)

取值顺序：

　　在局部调用：局部命名空间->全局命名空间->内置命名空间

　　在全局调用：全局命名空间->内置命名空间

3.函数的嵌套
降维模式,一层一层去分析

def func1():
    print("呵呵")
    def func2():
        print("哈哈")
    func2()
    print("吼吼")
func1()

def func1():
    print("赵")
    def func2():
        print("钱")
        def func3():
            print("孙")
        print("李")
    def func4():
        print("哈哈")
        func2()
    print("周")
    func2()
func1()

4. global和nonlocal

global: 把全局变量拿到局部来用.

a = 10
def func():
    global a    # 把外面全局中的a 引进来
    a = 30      # 把全局中的a重新赋值成30   外面的a也就变成30了
    print(a)
func()
print(a)


# 30
# 30

nonlocal: 把最近的一层的变量拿过来.不会找全局

def func1():
    a = 10           
    def func2():
        nonlocal a    # 找局部作用域中 离他最近的那个变量引入进来
        a = 20         # 把a重新赋值成20
        print(a)
    func2()
    print(a)
func1()


# 20
# 20

记住:
# global 如果在全局中找不到,会把局部变量升级成全局变量
# nonlocal 如果在局部中找不到,会报错

默写:
    1，形参的接收顺序。
位置参数 => *args => 默认值参数 => **kwargs

    2，什么是命名空间，什么是全局名称空间，什么是局部名称空间，什么是内置名称空间
命名空间:存放名字和值的关系的空间
全局名称空间: 在代码运行初始,(俗称函数外)创建的存储名字和值的空间
局部名称空间: 函数运行中创建的空间
内置名称空间: python解释器内部运行时存储的:int,str,list,tuple这些名字的空间

    3，什么是全局作用域，什么是局部作用域。
全局作用域: 包含内置名称空间、全局名称空间，在整个文件的任意位置都能被引用、全局有效
局部作用域: 局部名称空间，只能在局部范围内生效

    4，名称空间的加载顺序，取值顺序。
加载顺序:内置命名空间(程序运行前加载)=>全局命名空间(程序运行中:从上到下加载)=>局部命名空间(程序运行中:调用时才加载)
调用顺序:
　　     在局部调用：局部命名空间->全局命名空间->内置命名空间
　　     在全局调用：全局命名空间->内置命名空间

    5，解释一下什么是global，什么是nonlocal。
global:    把全局变量拿到局部来用.
nonlocal:  在函数内部中,把最近的一层的变量拿过来.不会找全局