python 10 days
动态参数 *args，**kwargs
用户传入到函数中的实参数量不定时，或者是为了以后拓展，
此时要用到动态参数*args，**kwargs(万能参数。)
*args接收的是所有的位置参数。
**kwargs接收的是所有的关键字参数。
位置参数，*args，默认参数, **kwargs
位置参数：
def fun1(*args,**kwargs):
print(args)
print(**kwargs)
fun1(1,2,3,4)
结果：(1, 2, 3, 4)
关键字参数：
def fun1(*a,**ab):
print(ab)
fun1(x=1,y=2,z=3)
结果：{'x': 1, 'y': 2, 'z': 3}
混合参数：
def fun1(*a,**ab):
print(a)
print(ab)
fun1(1,2,3,x=4,y=5,z=6)
结果：(1, 2, 3)
{'x': 4, 'y': 5, 'z': 6}
加法计算器：
def func1(*args):
sum = 0
for i in args:
sum += i
return sum
print(func1(1,2,3))
结果：6
列表，字典，字符串等对元组的 *args，**kwargs转变
def func3(*args,**abc): print(args) l1 = [1, 2, 3] l2 = [11, 21, 32] l3 = {33,44,55,66} func3(*l3,*l1,*l2)
转变前结果：({33, 66, 44, 55}, [1, 2, 3], [11, 21, 32])
def func3(*args,**abc): print(args) l1 = [1, 2, 3] l2 = [11, 21, 32] l3 = {33,44,55,66} func3(*l3,*l1,*l2) 在func13添加 *
转变后结果：(33, 66, 44, 55, 1, 2, 3, 11, 21, 32)
字典的转变
def func3(*args,**abc): print(abc) dic = {"name": "光头"} dic1 = {"age": 2000} func3(**dic,**dic1)
结果:{'name': '光头', 'age': 2000}
def func1(*args, **kwargs): print(args) func1(1, 2, 3, 4) func1(1, 2, 3, x=4, y=5, z=6)
结果：(1, 2, 3, 4)
(1, 2, 3)
位置参数，默认参数
def func2(a, b, sex='男'): print(a) print(b) print(sex) func2(1, 2, '女')
结果：1
2
女
位置参数，*args，默认参数
def func2(a, b, *args, sex='男'): print(a) print(b) print(args) print(sex) func2(1, 2, 5,6,7,8,9,sex='女')
结果：1
2
(5, 6, 7, 8, 9)
女
位置参数，*args，默认参数，**kwargs
def func2(a, b, *args, sex='男',age=20, **kwargs): print(a) print(b) print(args) print(sex) print(age) print(kwargs) func2(1, 2, 5, 6, 7, 8, 9, x=6, y=5, name='alex')
结果:1
2
(5, 6, 7, 8, 9)
男
20
{'x': 6, 'y': 5, 'name': 'alex'}
位置参数：如下
def func3(*args,**kwargs): # 函数的定义 *用意是聚合。 print(args) # (1,2,3,11,21,32) # *的魔性用法 l1 = [1, 2, 3] l2 = [11, 21, 32] s1 = 'fjskalgf' s2 = 'fjskrrrf' tu1 = (1, 2, 3) tu2 = (11, 22, 33) func3(l1, tu1, tu2)
结果：([1, 2, 3], (1, 2, 3), (11, 22, 33)，)位置参数，是一 一对应
动态参数：* 的魔性用法
def func3(*args,**kwargs): # 函数的定义 *用意是聚合。 print(args) # (1,2,3,11,21,32) l1 = [1, 2, 3] l2 = [11, 21, 32] s1 = 'fjskalgf' s2 = 'fjskrrrf' tu1 = (1, 2, 3) tu2 = (11, 22, 33) func3(*l1, *tu1, *tu2)
结果：(1, 2, 3, 1, 2, 3, 11, 22, 33)动态参数，是多个值放在一起
* 的打散用法：把字典里多个元素打散，重新放在一个字典组合
def func3(**kwargs): # 函数的定义 *用意是聚合。 print(kwargs) dic ={'name': 'alex','sex':'man'} dic1 ={'age': 1000} dic4={"hobby":"光头", "work":"前台"} func3(**dic, **dic1,**dic4)
结果：{'name': 'alex', 'sex': 'man', 'age': 1000, 'hobby': '光头', 'work': '前台'}
def func3(*args,**kwargs):
l = []
for i in args: # ([1, 2, 3], [11, 21, 32])
l.extend(i)
args = tuple(l)
print(args)
# print(kwargs)
l1 = [1, 2, 3]
l2 = [11, 21, 32]
func3(l1,l2)
名称空间，加载顺序等
1，当程序运行时，代码从上至下一次读取，遇到变量与值
def func1(): a = 2 b = 3 func1()
结果： 空
2，他会在内存中开辟一个空间，存放变量与值的内存地址的对应关系。
3，这样存储变量与值得对应关系的空间叫做名称空间(命名空间)。
4，当解释器遇到函数时，他会将函数名存储在内存中，但是对于函数体莫不关心。
5，当函数执行时，他会通过函数名找到函数体，然后将函数体里面的变量等对应关系存放在一个
临时开辟的空间中，随着函数的结束，临时的空间关闭，这样的空间叫做临时名称空间。
名称空间：
内置名称空间
全局名称空间
局部名称空间
加载顺序：内置名称空间 ---> 全局名称空间（程序运行时） ---->局部名称空间(函数执行时)
作用域：
全局作用域：内置名称空间 全局名称空间
局部作用域：局部名称空间
取值顺序(单项):局部名称空间(函数执行时) ---> 全局名称空间 ---> 内置名称空间
L local
E eclose
G global
B Built-in
sum = 666 name = '老男孩' def func1(): # sum = 555 print(sum) func1() sum = 666 （global）
print(sum)
def func1():
sum = 555 # eclose
print(sum)
def inner():
pass
sum = 111 # local
# print(sum)
inner()
函数的嵌套
print(111) # 1 def func1(): name = 'alex' print(name) # 2 def inner(): a = 2 print(a) # 3 inner() func1()
结果： 111
alex
2
print(111) def func1(): name = 'alex' print(name) def inner(): a = 2 print(a) inner() print(333) func1()
结果：111
333
alex
2
print(111) def func1(): name = 'alex' print(name) def inner(): a = 2 print(a) print(444) inner() print(555) func1()
结果：111
alex
444
2
555