python days_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