函数参数收集与逆过程

我总是在幻想用有限来创造无限。

收集参数：针对形参，多个实参指到一个形参。

创建函数时*形参，将参数收集到一个元祖中。

创建函数时**形参，将成对的参数收集到一个字典中。

释放参数（收集的逆过程）：针对实参，一个实参释放其中的元素到多个形参上去。

调用时：*实参，意味着参数是一个元祖，将元祖中的元素按照顺序与每个形参对应。

调用时：**实参，意味着参数是一个字典，字典中的键就是形参，将与之相对应的每个值提取出来赋值上去

所谓的打散就是一放一收。

混搭的顺序：

def ddg(a,b,*kebi,key = 'yyu',**maoxian):只会有默认值

def dgg(a, b,key= 'yyu',*kebi,** maoxian): 这个不会有默认值

一、收集参数（定义的时候确定）

在python的函数中，传统的关键字传参和使用默认值传参的参数数量都非常有限。

能不能给函数提供任意多个参数了？可以这样定义

def print_str(*sst):
    print(sst)
print_str(1,2,3,4,'你是')

结果：
(1, 2, 3, 4, '你是')    #貌似可以啊

参数前的星号将所有值放置在同一个元祖中，可以说是将这些值收集起来，然后使用。

那能不能和普通参数一起使用了？

def print_str1(title,*sst):
    print(title)
    print(sst)

print_str1('你妹!',2,3,4,'m','yz')

结果：
你妹!
(2, 3, 4, 'm', 'yz')  #元祖

星号(*)：收集其余的位置参数，如果不提供任何收集的元素，打印一个空的元祖。

可变长的参数元祖必须在位置参数和默认参数之后。

星号操作符之后的形参将作为元祖传递给函数，元祖保存了所有传递给函数的‘额外’的参数。

如果没有给出额外的参数，元祖为空。

print_str1('你妹',)#除了普通参数之外，没有任何参数

结果：
你妹
()

那能够收集关键字参数了？

def print_str1(title,*sst):
    print(title)
    print(sst)
print_str1('123',sst = '1,2,3,4')

结果：
Traceback (most recent call last):   #报错
  File "I:/untitled/cx/10-28/函数1.py", line 36, in <module>
    print_str1('123',sst = '1,2,3,4')
TypeError: print_str1() got an unexpected keyword argument 'sst'

如何才能收集关键字参数了？

def print_sst2(**sst):
    print(sst)
print_sst2(x=1,y=2,z=3)
结果：
{'x': 1, 'y': 2, 'z': 3}  #生成字典

为了区分关键字参数和非关键字参数，使用双星号（**）。

**是被重载了的以便不与幂运算发生混淆。

关键字变量参数应该为函数定义的最后一个参数，带**。

关键字和非关键字可变长参数都有可能用在同一个函数中，只要关键字字典是最后一个参数并且非关键字元祖先于它出现就行。

如果混搭。。。

def print_sst3(x,y,z=3,*sst,**sss):
    print(x,y,z)
    print(sst)
    print(sss)
print_sst3(1,2,33,4,5,6,foo=1,bar=2)

结果：
1 2 33
(4, 5, 6)
{'foo': 1, 'bar': 2}

如果要使用默认值，形参必须在*之后，不然程序会为寻值。

只能有这两种
def ddg(a,b,*kebi,key = 'yyu',**maoxian):只会有默认值

def dgg(a, b,key= 'yyu',*kebi,** maoxian): 这个不会有默认值

二、参数收集的逆过程（直接引用，传入参数的时候使用特殊的符号就行）

回归一下参数收集：把参数收集到一个元祖或者字典之中，然后当成一个值来时使用。

逆过程：把整个元组或者字典的元素当成参数来使用，使用相应的值。

def hello_1(greeting='Hello',name='world'):
    print('{},{}!'.format(greeting,name)

tuple1 =('hello','kebi')
hello_1(*tuple1)    #把元祖作为参数，*可以看作是元祖的标识符。

结果：
hello,kebi!

params = {'name':'kebi','greeting':'well,,met'}
hello_1(**params)   #把字典作为参数，**可以看作是字典的标识符。
结果：
well,,met,kebi!

虽然实现的途径不同，但是达到了类似的效果。

如果没有*或**元祖或者字典只能当成一个参数。

tuple1 =('hello','kebi')
hello_1(tuple1)   #没有*

结果：
('hello', 'kebi'),world!  #元组就当做了一个参数，剩下的是默认值。

三、打散

*可以将一个序列打散

def my_num(*a):
    print(a)
l = (1,2,3,4)
s ="werrttf"
my_num(*s)
my_num(*l)

结果：
('w', 'e', 'r', 'r', 't', 't', 'f')
(1, 2, 3, 4)

def my_num(a,b,c,d):
    print(a,b,c,d)
l = (1,2,3,4)   #逆收集