python-fullstack-s13-day10-python基础

Posted 2020-11-18 bug-ming

一、动态参数

　　1、当我们需要一个函数接收多个位置参数的时候，但我们又不是确定我们传的这些参数的数量，此时就出现了不定长参数，用 *args表示。

 1 # 没有不定长的参数的情况下，我们给多少个位置参数就必须在实参内传递多少个
 2 # 如果我们传递的参数少了一个的话，程序会报错
 3 def eat(a,b,c):
 4     print(a,b,c)
 5 eat("rice","junk_food","coco")
 6 # eat("rice","junk_food") # TypeError: eat() missing 1 required positional argument: ‘c‘
 7 
 8 # 所以我们定义了一个不定长的参数 *args 他是动态的，你输入的参数是可以改变个数的
 9 # 注意：args是参数，打印的时候是不能带 * 的，并且其接受的是一个元组。
10 def eat(*args):
11     print(args)
12 eat("rice","junk_food")  # (‘rice‘, ‘junk_food‘)

# 当我们有位置参数和动态参数结合的时候，如下
# 其中实参赋值的时候必须满足位置参数的个数数量，不能少于形参中给定的位置参数
def eat(a,b,c,*args):
    print(a,b,c,args)
eat("rice","junk_food","麻辣烫","盖浇饭","beer") # rice junk_food 麻辣烫 (‘盖浇饭‘, ‘beer‘)
eat("rice","junk_food","麻辣烫") # rice junk_food 麻辣烫 (‘盖浇饭‘, ‘beer‘)

　　2、当我们传递的参数中含有默认参数时，且参数数量不确定的时候该怎么做呢？

1 # 形参中含有位置参数，默认参数，不定长参数的时候，必须把默认参数放在最后面，否则会将默认参数覆盖
2 # 在实参中赋值时，如果想改变默认参数的默认值，也必须将该参数放在实参的最后。
3 def func(a, b, c, *args, d=110):
4     print(a, b, c,d,  args)
5 func(1, 4, 7, 3, 6, 9, 1231,12,3,3,3,54,56,67,5,44,)
6 func(1,2,3,4,4,5,6,d = 220)
7 # func(1,2,3,4,d = 220,4,5,6) # SyntaxError: positional argument follows keyword argument

　　3、当我们传递的参数中有关键字参数怎么办呢？

1 # 当我们实参传递的参数中含有多个关键字参数的时候 在形参处用**kwargs代替，接收的字典
2 def eat(**kwargs):  # ** 关键字参数
3     print(kwargs)
4 eat(good_food=‘盖浇饭‘, junk_food="麻辣烫", drink="脉动")

　　4、当上述几种参数混合在一起的时候我们怎么办呢？

1 # 多种参数混合使用的情况：位置参数  *args  默认值参数 **kwargs
2 def func(a, b, c, *args, d = 110, **kwargs):
3     print(a, b, c, args, d, kwargs)
4 func(1,4,7,3,5,8,dd=5,f=7,abc=9)
5 func(1,4,7,3,5,8,d=220,f=7,abc=9)

　　我们直接按照上面列出的多种参数混合时使用的情况来构造相关语句即可，务必记住上面的顺序，位置参数， *args，默认参数，**kwargs。

　　5、无敌传参，这个就比较牛逼了。

1 # 这个函数的参数.就可以接收所有的参数，无敌传参
2 def func(*args, **kwargs):
3     print(args, kwargs)
4 func(1, 4, a=8, b = 9, c= 10)

　　6、打散和聚合

 1 # 实参中的参数是可迭代对象，可具有打散和聚合的功效
 2 def eat(*fruit):    # 聚合成元组
 3     print(fruit)
 4 lst = ["香蕉", "茄子", "黄瓜", "辣椒", "大白梨"]
 5 # eat(lst[0], lst[1], lst[2], lst[3], lst[4])
 6 eat(*lst)   # 这里的*表示的是把lst打散
 7 def eat(**kwargs):  #  把所有的关键字参数聚合成字典
 8     print(kwargs)
 9 dic = {"a":1, "b":2, "c":3}
10 # eat(a = dic[‘a‘], b = dic[‘b‘], c=dic[‘c‘])
11 eat(**dic)  # 打散字典,依次传参
12 def read(*args):
13     print(args)
14 read(*"你好啊")

二、作用域的问题

　　作用域在函数中可按块理解，我们在运行程序的程序中，先加载的是内置命名空间，然后是全局命名空间，然后是局部命名空间，函数是局部命名空间的特有的特点，我们在函数中自己定义的变量是不能影响到全局变量的结果的，但是我们在函数内部是可以调用全局空间中的变量的，而变量在内存中的加载特点也是按照一定的方式进行加载的，可通过下面的例子可以看出来。

 1 a = 10  # 全局
 2 def func(): # 全局
 3     a = 40  # 局部
 4     b = 20  # 局部
 5     def abc():  # 局部
 6         d = 30 # 是局部
 7         print("哈哈")
 8         print(a, b) # 这?使?的是局部作?域
 9         print(locals())
10     abc()
11     # print(globals()) # 打印全局作用域中的内容
12     # print(locals()) # 打印局部作用域中的内容,locals()打印当前这个函数局部作用与中的内容
13 func()
14 print(globals()) # 打印全局作用域中的内容

三、函数的嵌套

　　函数的嵌套指的是函数中可以嵌套别的函数，解决这一问题按照我的理解最好的招数就是按照顺序来，现有一颗平常心，按照程序从上到下执行，遇见函数就执行相关函数部分的内容，执行完成这个函数后，继续刚才函数调用的位置向下执行，这样将程序完整的跑下来后就会发现函数中的嵌套关系了，但是我自己不建议记住任何的嵌套关系，我只关心函数执行的结果就可以了，可以按照顺序来的。

 1 def fun1():
 2     print(111)
 3 def fun2():
 4     print(222)
 5     fun1()
 6 fun2()
 7 print(333)
 8 
 9 def fun2():
10     print(222)
11     def fun3():
12         print(666)
13     print(444)
14     fun3()
15     print(888)
16 print(33)
17 fun2()
18 print(555)
19 
20 def func():
21     print("哈哈哈")
22 a = func # 函数可以赋值 .相当于. a和func是一回事儿
23 func()
24 a()

四、global和nonlocal 

　　global：寻找全局作用域中的内容

　　nonlocal：寻找上一级作用域中的内容，但不能是全局的。

 1 a = 10
 2 def func():
 3     global a # 这里用的a是全局的
 4     a = 20
 5     print(a)
 6 func()
 7 print(a)    # 20
 8 
 9 a = 10
10 def func1():
11     a = 20
12     print(a)
13     def fun2():
14         nonlocal a # 上一级, 且不能是全局
15         a = 30
16         print(a)
17     fun2()
18     print(a)
19 func1()
20 print(a)