python 10 days

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