例子
def func(a,b,c,d,e,f,g):
pass
print(func(a, b , c, d, e, f, g))
如果再加30个参数呢？，在后面继续添加？有没有万能的参数，可以代表一切参数呢？
*args 动态参数，万能参数
args接收的就是实参对应的所有位置参数，并将其放在元组中，它不会接收关键字参数
例子
def func(*args):
pass
func(1,2,3,4,5,6,7,8,9)执行没有报错
def func1(*args):
print(args)
func1(1,2,3,4,5,6,7,8,9)执行结果是一个元组
(1, 2, 3, 4, 5, 6, 7, 8, 9)
形参对应顺序
错误的示例
def func(*args,a,b,c,d,e='sex'):
print(args)
print(a)
print(b)
print(c)
print(d)
func(1,2,3,4,5)执行报错
TypeError: func() missing 4 required keyword-only arguments: 'a', 'b', 'c', and 'd'
因为*args接收了所有实参，所以缺少了a,b,c,d
形参对应顺序
#位置参数，*args,默认参数
正确的示例
def func(a,b,c,d,*args,e='男'):
print(a)
print(b)
print(c)
print(d)
print(args)
print(e)
func(1,2,3,4,10,9,8,7,e='女')执行结果
*args参数，可以不传，默认为空()
示例
def func(a,b,c,d,*args,e='男'):
print(a)
print(b)
print(c)
print(d)
print(args)
print(e)
func(1,2,3,4,e='女')执行结果
*args名字可以随便更改，args只是一个变量而已，但是约定默认使用的就是*args，建议不要更改
**kwargs
示例代码
def func(a,b,c,**kwargs):
print(kwargs)
func(1,2,3,r=4,s=5)执行结果
**kwargs只接收关键字参数
**kwargs动态传参，他将所有的关键字参数放到一个字典中，返回的结果是一个字典，从前往后找
示例
def func(a,b,c,**kwargs):
print(kwargs)
func(1,2,3,r=4,b1=5,c1=6,d=7)执行结果为
{'d': 7, 'c1': 6, 'r': 4, 'b1': 5}
**kwargs动态传参，他将所有的关键字参数（非位置对应的）放到一个字典中
示例
def func(a,b,c,**kwargs):
print(kwargs)
func(1,2,r=4,b1=5,c1=6,c=7)执行结果
{'c1': 6, 'b1': 5, 'r': 4}
**kwargs动态传参，他将所有的关键字参数(无意义的)放到一个字典中
上面示例中的c参数，是有意义的
最终顺序：位置参数，*args,默认参数，**kwargs
例子：
def func(a,b,c,d,*args,e='男',**kwargs):
print(a)
print(b)
print(c)
print(d)
print(args)
print(e)
print(kwargs)
func(1,2,3,4,5,6,7,v=3,m=7,h=9,e='女')执行结果
一般情况下，用这种方式就可以了
def func(*args,**kwargs):
pass
func()查看python源码
*魔法运用
例子
def func(*args):
print(args)
l1 = [1,2,30]
l2 = [1,2,33,21,45,66]
func(*l1)
func(*l1,*l2)执行结果
在函数的调用时，*代表打散
例子2
def func(*args):
print(args)
l1 = [1,2,30]
l2 = [1,2,33,21,45,66]
tu = (1,2,3)
func(*l1,*l2,*tu)执行结果
(1, 2, 30, 1, 2, 33, 21, 45, 66, 1, 2, 3)
*就相当于迭代添加
在函数的调用时，*可迭代对象，代表打散(list,tuple,str,dict(键))
比如用到要传多个列表时，需要用到魔法运用
def func(*args):
print(args)
func(1,2,3,10,20,80)执行结果
(1, 2, 3, 10, 20, 80)
在函数的调用执行时，*可迭代对象，代表打散
在函数定义时，*args代表的是聚合
将字典的键值对，添加到函数中
def func(**kwargs):
print(kwargs)
dic1 = {'name1':'sam','age1':16}
dic2 = {'name2':'tom','age2':20}
func(**dic1,**dic2)执行结果
{'age1': 16, 'age2': 20, 'name1': 'sam', 'name2': 'tom'}
**kwargs只限于字典
在函数的调用执行时，
*可迭代对象，代表打散(list,tuple,str,dict(键))将元素一一添加到args
**字典，代表打散，将所有键值对放到一个kwargs字典里
在函数定义时，*args,**kwargs代表的是聚合
def func(*args,**kwargs):
print(args)
print(kwargs)
dic1 = {'name1':'sam','age1':18}
dic2 = {'name2':'tom','age2':20}
func(*[1,2,3,4],*'abcdef',**dic1,**dic2)执行结果
(1, 2, 3, 4, 'a', 'b', 'c', 'd', 'e', 'f') #打散
{'name1': 'sam', 'age1': 18, 'name2': 'tom', 'age2': 20} #聚合
我们首先回忆一下Python代码运行的时候遇到函数是怎么做的，从Python解释器开始执行之后，就在内存中开辟里一个空间，每当遇到一个变量的时候，就把变量名和值之间对应的关系记录下来，但是当遇到函数定义的时候，解释器只是象征性的将函数名读如内存，表示知道这个函数存在了，至于函数内部的变量和逻辑，解释器根本不关心。
等执行到函数调用的时候，Python解释器会再开辟一块内存来储存这个函数里面的内容，这个时候，才关注函数里面有哪些变量，而函数中的变量回储存在新开辟出来的内存中，函数中的变量只能在函数内部使用，并且会随着函数执行完毕，这块内存中的所有内容也会被清空。
我们给这个‘存放名字与值的关系’的空间起了一个名字-------命名空间。
代码在运行伊始，创建的存储“变量名与值的关系”的空间叫做全局命名空间；
在函数的运行中开辟的临时的空间叫做局部命名空间。
命名空间和作用域
命名空间一共分为三种
全局命名空间
局部命名空间
内置命名空间
内置命名空间中存放了python解释器为我们提供的名字:input,print,str,list,tuple...它们都是我们熟悉的，拿过来就可以用的方法
三种命名空间之间的加载和取值顺序
加载顺序：内置命名空间(程序运行前加载)-->全局命名空间(程序运行中：从上到下加载)-->局部命名空间(程序运行中：调用时才加载)
例子
def my_len(argv):
return 666
print(len([12,3]))执行结果，因为函数没有被调用，所以直接打印len里面列表的长度
2
取值顺序：
在局部调用：局部命名空间-->全局命名空间-->内置命名空间
在全局调用：全局命名空间-->内置命名空间
综上所述，在找寻变量时，从小范围，一层一层到大范围去寻找
例子
name = '张三'
def func():
name = 'sam'
print(name)
func()执行结果,程序运行中，从上到下加载，name的值被局部命名空间里的值覆盖了
sam
例子2
a = 2
print(a)
def func():
age = 11
print(age)
func()执行结果
2
11
例子3
print(111)
def func1():
print(333)
def func2():
print(444)
def func3():
print(555)
func2()
func1()
print(222)执行结果，从上往下执行，首先打印111，中间遇到了几个函数，只是暂存到内存中，并不执行，后面调用func1，从而打印333，下面的几个函数没有调用，所以不执行，最后打印222
111
333
222
例子4
print(111)
def func1():
print(333)
func2()
print(666)
def func2():
print(444)
def func3():
print(555)
func1()
print(222)执行结果，先手打印111，遇到func1-3函数暂存到内存中，遇到调用func1函数，打印出333，然后调用func2，打印444，这里注意，要等func2执行完成后，才会执行func1后面剩余的print(666),最后打印222
111
333
444
666
222
例子5
def f1():
def f2():
def f3():
print("in f3")
print("in f2")
f3()
print("in f1")
f2()
f1()执行结果，调用f1,先打印'in f1'在调用f2,打印'in f2'在调用f3,打印'in f3'
in f1
in f2
in f3
作用域
作用域就是作用范围，按照生效范围可以分为全局作用域和局部作用域
全局作用域：包含内置名称空间，全局名称空间，在整个文件的任意位置都能被引用，全局有效
局部作用域：局部名称空间，只能在局部范围内生效
globals和locals方法
globals：全局名称空间：所有变量
locals：局部名称空间：所有变量
例子
a = 2
b = 3
def func1():
c = 5
d = 6
print(globals()) #全局变量放在一个字典中
print(locals()) #局部变量(函数里的c,d)放在一个字典中
func1()执行结果
例子2
a = 3
b = 5
def func1():
c = 6
d = 8
e = 10
print(globals()) #全局变量放在一个字典中
return locals() #局部变量(函数里的c,d,e)放在一个字典中
print(func1())如果逻辑比较多，可以使用return locals() 查看函数所有局部变量，返回字典类型
global关键字，nonlocal关键字
global:
1 声明一个全局变量
2 在局部作用域想要对全局作用域的全局变量进行修改时，需要用到global(限字符串，数字)
例子1
def func1():
global name
name = '你好'
print(name)
func1()
print(name)执行结果，在局部空间内，声明一个全局变量
你好
你好
例子2
name = '哈哈'
def func1():
global name
name = '你好'
func1()
print(name)执行结果,因为函数func1里面声明使用全局变量name,对name的值进行了修改，所以最后打印的值是函数里面name的值
你好
例子3
def func1():
global a
a = 5
func1()
a = 4
print(a)执行结果，代码从上至下执行，最后a=4把a的值覆盖了
4
对可变数据类型(list,dict,set)可以直接引用不用通过global
例子
li = [1,2,3]
dic = {'a':'b'}
def change():
li.append('a')
dic['q'] = 'g'
print(dic)
print(li)
change()
print(li)
print(dic)执行结果，很明显，这里没有使用global声明，也可以直接添加
{'q': 'g', 'a': 'b'}
[1, 2, 3, 'a']
[1, 2, 3, 'a']
{'q': 'g', 'a': 'b'}
nonlocal
1 不能修改全局变量
2 在局部作用域中，对父级作用域(或者更外层作用域非全局作用域)的变量进行引用和修改，并且引用到哪层，从那层及父级或以下此变量全部发生改变。
错误例子
a = 4
def func1():
nonlocal a
a = 5
func1()
print(a)执行报错
SyntaxError: no binding for nonlocal 'a' found
例子
def func1():
b = 6
def func2():
nonlocal b #
b = 666
print(b)
func2()
func1()执行输出
666
例子2
def add_b():
b = 42
def do_global():
b = 10
print(b)
def dd_nonlocal():
nonlocal b
b = b + 20
print(b)
dd_nonlocal()
print(b)
do_global()
print(b)
add_b()执行结果
10
30
30
42
