函数基础回顾02

1. 1. 1. 1. 函数的传参：形参的第三种参数：万能参数--动态参数(解决参数数目不定的问题)

            def eat(food1,food2,food3):
                 print(f'我请你吃：{food1},{food2},{food3}')
            eat('蒸羊羔','蒸熊掌','蒸鹿尾')
            
            当给函数传入的参数数目不定时，之前的传参方式解决不了问题。
            万能参数，动态参数。 *args
            def eat(food1,food2,food3):
                 print(f'我请你吃：{food1},{food2},{food3}')
             eat('蒸羊羔','蒸熊掌','蒸鹿尾','烧花鸭','烧企鹅')
            
            def eat(*args):     将实参角度：定义一个函数时，* 所有的位置参数聚合到一个元组中。
                print(args)
                print(f'我请你吃：{args}')
            eat('蒸羊羔','蒸熊掌','蒸鹿尾','烧花鸭','烧企鹅')
            
            函数接收不定个数的数字实参，将最终的和返回出去。
            def sum1(*args):
            	print(args)  (100, 2, 67, 3)
            	result = 0
            	for i in args:
                 	result += i
                 return result
             print(sum1(100,2,67,3))
            
            **kwargs
            
            def func(**kwargs):     函数的定义时：**将实参角度所有的关键字参数聚合成了一个字典，给了kwargs.
                 print(kwargs)
            func(name='alex',age=84,hobby='唱跳rap篮球')
            
            *args,**kwargs 万能参数
            def func(*args,**kwargs):
                print(args,kwargs)
            func(1,2,4,'fjdksal',age=84,hobby='唱跳rap篮球')
            
            *的魔性用法： （函数中）
            
            def func(*args,**kwargs):
                print(args)     (1, 2, 3,'太白', 'wusir', '景女神')
                print(kwargs)
            
             l1 = [1, 2, 3]
             l2 = ['太白', 'wusir', '景女神']
             func(l1,l2)
             func(*l1,*l2)     当函数的执行时：*iterable 代表打散。
             func(*[1, 2, 3],*(11,22),*'fdsakl')     当函数的执行时：*iterable 代表打散。
            
             def func(*args,**kwargs):
                 print(args)
                 print(kwargs)
             func(**{'name':"alex"},**{'age': 73,'hobby': '吹'})
            当函数的执行时：**dict 代表打散。
            
            
            函数外：处理剩余元素
            a,b,*c = [1,2,3,4,5]
            a,*c,b, = [1,2,3,4,5]
            a,*c = range(5)
            a,*c,b = (1,2,3,4,5,6)
            print(a,c,b)
            

         2. 函数形参角度，形参的顺序

            *args的位置
            *args不能放在位置参数前面，a,b取不到值
            def func(*args,a,b,sex='man',):
               print(a)
               print(b)
               print(sex)
               print(args)
               print(kwargs)
            func(1,2,4,5,6)
            
            *args如果想要接收到值之前，肯定要改变sex默认参数。
            def func(a,b,sex='man',*args):
            	print(a)
            	print(b)
            	print(sex)
            	print(args)
            	print(kwargs)
            func(1,2,4,5,6)
            
            def func(a,b,*args,sex='man'):
            	print(a)
            	print(b)
            	print(sex)
            	print(args)
            	print(kwargs)
            func(1,2,4,5,6)
            func(1,2,4,5,6,sex='women')
            
            **kwargs
            位置参数,*args,默认参数，**kwargs
            def func(a,b,*args,sex='man',**kwargs,):
            	print(a)
            	print(b)
            	print(sex)
            	print(args)
            	print(kwargs)
            func(1,2,4,5,6,name='太白',age=18)
            
            形参角度第四种传参方式：仅限关键字参数  (了解)
            位置参数,*args,默认参数，仅限关键字参数,**kwargs
            def func(a,b,*args,sex='man',c,**kwargs,):
            	print(a)
            	print(b)
            	print(sex)
            	print(c)
            	print(args)
            	print(kwargs)
            func(1,2,4,5,6,67,c=666,name='太白',age=18,)
            

         3. 从空间角度研究函数

            全局命名空间--> 我们直接在py文件中, 函数外声明的变量都属于全局命名空间

            局部命名空间--> 在函数中声明的变量会放在局部命名空间

            内置命名空间--> 存放python解释器为我们提供的名字, list, tuple, str, int这些都是内置命名空间

            加载顺序：函数直接可以用的比如abs(-1),max(1,3)等等，在启动Python解释器的时候，就已经导入到内存当中供我们使用，所以肯定是先加载内置名称空间，然后就开始从文件的最上面向下一行一行执行，此时如果遇到了初始化变量，就会创建全局名称空间，将这些对应关系存放进去，然后遇到了函数执行时，在内存中临时开辟一个空间，加载函数中的一些变量等等。所以这三个空间的加载顺序为：内置命名空间(程序运行伊始加载)->全局命名空间(程序运行中：从上到下加载)->局部命名空间(程序运行中：调用时才加载。

            取值顺序：取值顺序就是引用一个变量，先从哪一个空间开始引用。这个有一个关键点：从哪个空间开始引用这个变量。（单向不可逆）

            所以空间的取值顺序与加载顺序是相反的，取值顺序满足的就近原则，从小范围到大范围一层一层的逐步引用

         4. 作用域

            作用域就是作用范围, 按照生效范围来看分为全局作用域和局部作用域

            全局作用域: 包含内置命名空间和全局命名空间. 在整个文件的任何位置都可以使用(遵循 从上到下逐⾏执行).

            局部作用域: 在函数内部可以使用.

            作⽤域命名空间:

            1. 全局作用域: 全局命名空间 + 内置命名空间
            2. 局部作⽤域: 局部命名空间

         5. 关键字global，nonlocal

            在函数中对不能直接对全局变量进行修改
            
            报错：UnboundLocalError: local variable 'count' referenced before assignment
            解释器认为：如果你在局部作用域对一个变量进行修改了，你在局部作用域已经定义好这个变量了。
            
            global(剪切):在局部作用域中声明一个全局变量,
            
            ​			可以修改全局变量
            
            nonlocal(复制)可以对父级作用域的变量进行修改，并且在当前作用域创建（复制）一份此变量
            
            ​		不能对全局变量进行操作
            

         6. 默认参数的坑

            def func(a,b=False):
                   print(a)
                   print(b)
               func(1,True)
               当你的默认参数如果是可变的数据类型，你要小心了。
            
               def func(a,l=[]):
                   l.append(a)
                   return l
               print(func(1))     [1,]
               print(func(2))     [1，2]
               print(func(3))     [1，2，3]