python3.6入门到高阶(全栈) day010 函数进阶

今日主要内容
    1. 动态传参
        形参:
            1. 位置参数
            def chi(quality_food,junk_food):
               print("我要吃",quality_food,junk_food)
            chi('大米饭','小米饭')  # 大米饭传给quality_food,小米饭传给junk_food 按位置传
            2. 默认值参数
            3. 动态传参

                1 *args: 动态接收位置参数
                # *表示动态传参. 可以接受所有的位置参数
                # 传参的时候自动的把实参打包成元组 交给形参
                def chi(*food)
                    print('我要吃',food)
                chi('大米饭','小米饭')
                # 多个参数传递进去. 收到的内容是  元组tuple


                2 **kwargs:动态接收关键字参数
                # ** 表示接收关键字的动态传参
                # 接收到的内容放在字典里
                顺序: 位置, *args, 默认值, **kwargs
                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

                *, **:
                    def func(*args, **kwargs): 无敌传参
                        pass
                    *, ** 在形参位置: 聚合
                    def func(*args, **kwargs):
                       print(args, kwargs)
                    func(1,2,"哈哈",3,4,5,a=6,b=7,c=8,d=9, e=18 )
                    # (1, 2, '哈哈', 3, 4, 5) {'a': 6, 'b': 7, 'c': 8, 'd': 9, 'e': 18}

                          在实参位置: 打散
                1    lst = ["火腿肠","方便面","有调料包","被捏碎了", "韭菜", "大白菜"]
                     def chi(*food): #  形参上的* : 动态接收位置参数
                        print(food)

                    # 把列表中的所有食物传递给chi
                    chi(*lst) # 把一个列表或者元组或者字符串.打散成参数. 传递给形参

                2   dic = {"张无忌":"倚天屠龙记", "乔峰":"天龙八部", "郭靖":"射雕"}

                    def da(**kwargs): # 动态传参. 接收关键字参数
                        print(kwargs)
                    # da(张无忌=dic['张无忌'])
                    da(**dic)   # 把字典打散成关键字参数

        实参:
            1. 位置参数
            2. 关键字参数
            3. 混合参数

    2. 名称空间和作用域
        名称空间: 保存名字用的
             变量, 函数, 类

        1. 内置名称空间:python自己, print, input, len
        2. 全局名称空间: 你写的代码从上到下
        3. 局部名称空间: 函数, 类, 方法, 其他模块, 对象

        作用域
            全局作用域
                 内置 + 全局
            局部作用域
                 局部名称空间
            从局部找全局可以. 但是从全局找局部是不可以的

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

    3. 函数的嵌套(难点)
         每一层都会产生独自的名称空间
        # def fun2():
        #     print(222)
        #     def fun3():
        #         print(666)
        #     print(444)
        #     fun3()
        #     print(888)
        # print(33)
        # fun2()
        # print(555)

        # 33 222 444 666 888 555
         
    4. nonlocal global
        global: 在局部引入全局的内容,  可以升华一个变量为全局变量
        nonlocal :  在局部, 引入上一层名称空间中的变量, 如果没有, 继续上一层......

        a = 1
        def fun_1():
            a = 2
            def fun_2():
                nonlocal a
                a = 3
                def fun_3():
                    a = 4
                    print(a)
                print(a)
                fun_3()
                print(a)
            print(a)
            fun_2()
            print(a)
        print(a)
        fun_1()
        print(a)

        # 1234331