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 sumprint(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 = 3func1() 结果： 空

2，他会在内存中开辟一个空间，存放变量与值的内存地址的对应关系。

3，这样存储变量与值得对应关系的空间叫做名称空间(命名空间)。

4，当解释器遇到函数时，他会将函数名存储在内存中，但是对于函数体莫不关心。

5，当函数执行时，他会通过函数名找到函数体，然后将函数体里面的变量等对应关系存放在一个

临时开辟的空间中，随着函数的结束，临时的空间关闭，这样的空间叫做临时名称空间。

名称空间：

内置名称空间

全局名称空间

局部名称空间

加载顺序：内置名称空间 ---> 全局名称空间（程序运行时） ---->局部名称空间(函数执行时)

作用域：

全局作用域：内置名称空间 全局名称空间

局部作用域：局部名称空间

取值顺序(单项):局部名称空间(函数执行时) ---> 全局名称空间 ---> 内置名称空间

L local

E eclose

G global

B Built-in

sum = 666name = '老男孩'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)   # 1def 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