python之动态参数 *args,**kwargs和命名空间
一、函数的动态参数 *args,**kwargs, 形参的顺序
1、你的函数，为了拓展，对于传入的实参数量应该是不固定，
所以就需要用到万能参数，动态参数，*args, **kwargs
1，*args 将所有实参的位置参数聚合到一个元组，并将这个元组赋值给args
(起作用的是* 并不是args,但是约定俗成动态接收实参的所有位置参数就用args)
def sum1(*args): print(args) sum1(1,2,['hello']) #是一个元组(1, 2, ['hello'])
2，**kwargs 将所有实参的关键字参数聚合到一个字典，并将这个字典赋值给kwargs
(起作用的是** 并不是kwargs,但是约定俗成动态接收实参的所有关键字参数就用kwargs)
def fun(*args,**kwargs): print(args) print(kwargs) fun(1,2,['a','b'],name='xiaobai',age=18) # 结果： # (1, 2, ['a', 'b']) #位置参数，元组 # {'name': 'xiaobai', 'age': 18} #关键字参数，字典
2、*的用法
在函数的定义时，*位置参数，**关键字参数--->聚合。
在函数的调用(执行)时，*位置参数，**关键字参数--->打散。
实参--->*位置参数--->把位置参数打散成最小的元素，然后一个个添加到args里组成一个元组
l1 = [1,2,3] l2 = [111,22,33,'xiaobai'] #如果要将l1,l2通过函数整合到一起 # 方法一(实参不用*)： def func1(*args): return args[0] + args[1] print(func1(l1,l2)) #[1, 2, 3, 111, 22, 33, 'xiaobai'] # 方法二(实参用*)： def func1(*args): return args print(func1(*l1,*l2)) #(1, 2, 3, 111, 22, 33, 'xiaobai')
实参--->**关键字参数--->把关键字参数打散成最小的元素，然后一个个添加到kwargs里组成一个字典
def func1(**kwargs): print(kwargs) #func1(name='xiaobai',age=18,job=None,hobby='girl') func1(**{'name':'xiaobai','age':18},**{'job':None,'hobby':'girl'}) # 结果： # {'name': 'xiaobai', 'age': 18, 'job': None, 'hobby': 'girl'}
3、形参的顺序(a--->b，代表的顺序是写参数时，要先写a再写b)
位置参数--->默认参数
def func(a,b,sex='男'): print(sex) func(100,200)
位置参数--->*args--->默认参数
def func(a,b,*args,sex='男'): print(a,b) print(args) print(sex) func(100,200,1,2,34,5,'女',6) # 结果： # 100 200 #a,b # (1, 2, 34, 5,'女',6) #args # 男 #默认参数
位置参数--->*args--->默认参数--->**kwargs
def func(a,b,*args,sex='男',**kwargs): print(a,b) print(args) print(sex) print(kwargs) func(100,200,1,2,34,5,6,sex='女',name='xiaobai',age=1000) func(100,200,1,2,34,5,6,name='xiaobai',age=1000,sex='女') # 两个的结果都是： # 100 200 #a,b # (1, 2, 34, 5, 6) #args # 女 #默认参数修改后的值 # {'name': 'xiaobai', 'age': 1000} #kwargs # 若是形参这样写： def func(a,b,*args,**kwargs,sex='男'): print(a,b) print(args) print(sex) print(kwargs) func(100,200,1,2,34,5,6,name='xiaobai',age=1000,sex='女') # 结果：会报错，默认参数一定要写在kwargs前面
二、命名空间，临时命名空间，作用域，取值顺序，加载顺序等
'''
我们首先回忆一下Python代码运行的时候遇到函数是怎么做的，从Python解释器开始执行之后，就在内存中开辟里一个空间，每当遇到一个变量的时候，
就把变量名和值之间对应的关系记录下来，但是当遇到函数定义的时候，解释器只是象征性的将函数名读入内存，表示知道这个函数存在了，至于函数内部的变量和逻辑，解释器根本不关心。
等执行到函数调用的时候，Python解释器会再开辟一块内存来储存这个函数里面的内容，这个时候，才关注函数里面有哪些变量，而函数中的变量会储存在新开辟出来的内存中，
函数中的变量只能在函数内部使用，因为随着函数执行完毕，这块内存中的所有内容也会被清空。
我们给这个‘存放名字与值的关系’的空间起了一个名字-------命名空间。
代码在运行开始，创建的存储“变量名与值的关系”的空间叫做全局命名空间；
在函数的运行中开辟的临时的空间叫做局部命名空间。
'''
1、python中，命名空间分三种：
1，全局命名空间
2，局部命名空间（临时）
3，内置命名空间
*内置命名空间中存放了python解释器为我们提供的名字：input,print,str,list,tuple...它们都是我们熟悉的，拿过来就可以用的方法。
2、作用域：
1，全局作用域：全局命名空间 内置命名空间
2，局部作用域：局部命名空间（临时）
3、取值顺序： 就近原则(LEGB)
局部命名空间 ----> 全局命名空间 ----->内置命名空间 单向 从小到大范围
也就是说：
在局部调用时取值顺序是：局部命名空间->全局命名空间->内置命名空间
在全局调用时取值顺序是：全局命名空间->内置命名空间
len = 6 #设置全局变量 而且len也在内置命名空间中
def func1():
len = 3 #设置局部变量
return len
print(func1()) #返回的len值是局部命名空间的值：3
4、加载顺序
内置命名空间(程序运行前加载) ----> 全局命名空间(程序运行中：从上到下加载) --- > 局部命名空间(当函数调用的时候)
三、global，nonlocal
1、在局部命名空间 可以引用全局命名空间的变量，但是不能改变它的值。
count = 1
def func1():
print(count)
func1() #引用全局命名空间的变量，结果为：1
count = 1
def func1():
count += 1
print(count)
func1() #会报错，因为在局部命名空间中不能直接修改全局命名空间的变量
#如果你在局部名称空间对一个变量进行修改，那么解释器会认为你的这个变量在局部中已经定义了，
#但是对于上面的例题，局部中没有定义，所以就会报错。
2、global：
1，在局部命名空间声明一个全局变量。
2，在局部作用域想要对全局作用域的全局变量进行修改时，需要用到global(限于字符串，数字)。
例子：
def fun(): global a #声明了一个全局变量a。 a = 3 fun() #调用函数后，就生成了全局变量a，不会因为函数的结束而释放掉。 print(a) # 3 count = 1 #全局变量count def fun(): global count #在局部作用域想要对全局作用域的全局变量进行修改时，用global声明。 count += 1 fun() print(count) # 2
ps：对于在全局命名空间的可变数据类型（list，dict，set）可以直接引用并修改不用通过global。
但是函数内部(局部命名空间)的可变数据类型在没有global的声明下，全局命名空间也是不可以调用的。
li = [1, 2, 3] # 全局命名空间的可变数据类型 dic = {'name': 'sb'} def change(): li.append('hello') # 在局部命名空间直接引用并修改 dic['age'] = 18 change() print(li) # [1, 2, 3, 'hello'] print(dic) # {'name': 'sb', 'age': 18} def fun(): l1 = [1, 2, 3] # 局部名称空间的可变数据类型 fun() l1.append(4) print(l1) # 报错，name 'l1' is not defined def fun(): global l1 # 局部名称空间用global声明可变数据类型 l1 l1 = [1, 2, 3] fun() l1.append(4) print(l1) # [1, 2, 3, 4]
3、nonlocal
1，此变量声明的变量不能是全局变量，它不能修改全局变量。
2，子函数对父函数的变量进行修改。(在局部作用域中，对父级作用域（或者更外层作用域非全局作用域）的变量进行引用和修改，并且引用的是哪一层，就从那一层及以下此变量全部发生改变。)
例子：
def func1(): count = 666 def inner(): print(count) def func2(): nonlocal count #这里如果不声明nonlocal，那么可以引用父函数的conut值，但是不能修改否则就会报错 count += 1 print('func2',count) func2() print('inner',count) inner() print('func1',count) func1() # 666 func2 667 inner 667 func1 667
四、函数的嵌套
1、函数的嵌套定义
def f1(): print("in f1") def f2(): print("in f2") f2() f1() #in f1 #in f2 def f1(): def f2(): def f3(): print("in f3") print("in f2") f3() print("in f1") f2() f1() #in f1 #in f2 #in f3
2、函数的嵌套调用
def max1(x,y): m = x if x>y else y return m def max2(a,b,c,d): res1 = max1(a,b) res2 = max1(res1,c) res3 = max1(res2,d) return res3 print(max2(23,-7,31,11)) # 31
