3.3　参数收集

在函数中，参数的个数有时候是一个，比如一个用来计算圆面积的函数，它所需要的参数就是半径（πr^2），这个函数的参数是确定的。

然而，这个世界不总是这么简单的，有时候参数个数是多个，甚至不是确定的，不确定性或许更是常态。如果读者了解量子力学就更理解真正的不确定性了。当然，不用研究量子力学也一样能够体会到，世界充满里了不确定性。也就是说，我们还要解决函数的参数个数不确定的情况。

3.3.1　参数收集

Python用这样的方式解决参数个数的不确定性：

def func(x,*arg):
    print x            
    result = x
    print arg       
    for i in arg:
        result +=i
    return result
print func(1, 2, 3, 4, 5, 6, 7, 8, 9)         #赋给函数的参数个数不仅仅是2个

运行此代码后，得到如下结果：

1                       #这是第一个print，参数x得到的值是1
(2, 3, 4, 5, 6, 7, 8, 9)#这是第二个print，参数arg得到的是一个元组
45                      #最后的计算结果

从上面例子可以看出，如果输入的参数个数不确定，其他参数全部通过*arg，以元组的形式由arg收集起来。对照上面的例子不难发现：

• 值1传给了参数x。
• 值2、3、4、5、6、7、8、9被塞入一个tuple里面，传给了arg。为了能够更明显地看出arg（名称可以不一样，但是符号*必须要有），可以用下面的一个简单函数来演示：

>>> def foo(*args):
...     print args      #打印通过这个参数得到的对象

下面演示分别传入不同的值，通过参数*args得到的结果：

>>> foo(1, 2, 3)
(1, 2, 3)
 
>>> foo("qiwsir", "qiwsir.github.io", "python")
('qiwsir', 'qiwsir.github.io', 'python')
 
>>> foo("qiwsir", 307, ["qiwsir",2], {"name":"qiwsir", "lang":"python"})
('qiwsir', 307, ['qiwsir', 2], {'lang': 'python', 'name': 'qiwsir'})

不管是什么，都一股脑地塞进了tuple中。

>>> foo("python")
('python',)

即使只有一个值，也是用tuple收集它。特别注意，在tuple中，如果只有一个元素，后面要有一个逗号。

还有一种可能，就是不给那个*args传值，这也是许可的。例如：

>>> def foo(x, *args):
...     print "x:", x
...     print "tuple:", args
... 
>>> foo(7)
x: 7
tuple: ()

这时候*args收集到的是一个空的tuple。

在各类编程语言中，常常会遇到以foo、bar、foobar等之类的命名，不管是对变量、函数还是后面要讲到的类。这是什么意思呢？下面是来自维基百科的解释。

在计算机程序设计与计算机技术的相关文档中，术语foobar是一个常见的无名氏化名，常被作为“伪变量”使用。

从技术上讲，“foobar”很可能在20世纪60年代至70年代初通过迪吉多的系统手册传播开来。另一种说法是，“foobar”可能来源于电子学中反转的foo信号；这是因为如果一个数字信号是低电平有效（即负压或零电压代表“1”），那么在信号标记上方一般会标有一根水平横线，而横线的英文即为“bar”。在《新黑客辞典》中，还提到“foo”可能早于“FUBAR”出现。

单词“foobar”或分离的“foo”与“bar”常出现于程序设计的案例中，如同Hello World程序一样，它们常被用于向学习者介绍某种程序语言。“foo”常被作为函数／方法的名称，而“bar”则常被用作变量名。

除了用args这种形式的参数接收多个值之外，还可以用“**kargs”的形式接收数值，不过这次有点不一样：

>>> def foo(**kargs):
...     print kargs
...
>>> foo(a=1, b=2, c=3)    #注意观察这次赋值的方式和打印的结果
{'a': 1, 'c': 3, 'b': 2}

如果这次还用foo（1，2，3）的方式，会有什么结果呢？

>>> foo(1, 2, 3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: foo() takes exactly 0 arguments (3 given)

如果用**kargs的形式收集值，会得到字典类型的数据，但是，需要在传值的时候说明“键”和“值”，因为在字典中是以“键值”对形式出现的。

把上面的几种情况综合起来，看看有什么效果。

>>> def foo(x, y, z, *args, **kargs):
...     print x   
...     print y
...     print z
...     print args
...     print kargs        
... 
>>> foo('qiwsir', 2, "python")
qiwsir
2
python
()
{}
>>> foo(1, 2, 3, 4, 5)
1
2
3
(4, 5)
{}
>>> foo(1, 2, 3, 4, 5, name="qiwsir")
1
2
3
(4, 5)
{'name': 'qiwsir'}

这样就能够足以应付各种各样的参数要求了。

3.3.2　更优雅的方式

>>> def add(x, y):
...     return x + y
... 
>>> add(2,3)
5

这是通常的函数调用方法，在前面已经屡次用到。这种方法简单明快，很容易理解。但是，世界总是多样性的，甚至在某种情况下你秀出下面的方式可能更优雅。

>>> bars = (2, 3)
>>> add(*bars)
5

先把要传的值放到元组中，赋值给一个变量bars，然后用add（*bars）的方式，把值传到函数内，这有点像前面收集参数的逆过程。注意，元组中元素的个数要跟函数所要求的变量个数一致。如果这样：

>>> bars = (2, 3, 4)
>>> add(*bars)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: add() takes exactly 2 arguments (3 given)

就报错了。

这是使用一个星号，以元组形式传值，如果用*的方式，是不是应该以字典的形式传值呢？理当如此。

>>> def book(author, name):
...     print "%s is writing %s" % (author, name)
... 
>>> bars = {"name":"Starter learning Python", "author":"Kivi"}
>>> book(**bars)
Kivi is writing Starter learning Python

这种调用函数传值的方式很少用到，至少在我的编程实践中用得不多，但不代表读者不用，这或许是习惯问题。

3.3.3　综合贯通

Python中函数的参数通过赋值的方式来传递引用对象。下面总结常见的函数参数定义方式，来理解参数传递的流程。

def foo(p1, p2, p3,...)

这种方式最常见了，列出有限个数的参数，并且彼此之间用逗号隔开。在调用函数的时候，按照顺序对参数进行赋值，特别要注意的是，参数的名字不重要，重要的是位置。而且，必须数量一致，一一对应。第一个对象（可能是数值、字符串等）对应第一个参数，第二个对象对应第二个参数，如此对应，不得偏左也不得偏右。

>>> def foo(p1, p2, p3):
...     print "p1==>",p1
...     print "p2==>",p2
...     print "p3==>",p3
... 
>>> foo("python", 1, ["qiwsir","github","io"])   
p1==> python
p2==> 1
p3==> ['qiwsir', 'github', 'io']
 
>>> foo("python")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: foo() takes exactly 3 arguments (1 given)    #注意看报错信息
 
>>> foo("python", 1, 2, 3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: foo() takes exactly 3 arguments (4 given)    
 
def foo(p1=value1, p2=value2,...)

这种方式要求把参数和值都写上，貌似这样就不乱了，很明确呀，颇有一个萝卜对着一个坑的意味。

还以前面的函数为例，用下面的方式赋值就不用担心顺序问题了。

>>> foo(p3=3, p1=10, p2=222)
p1==> 10
p2==> 222
p3==> 3

还可以用类似下面的方式，部分参数给予默认的值。

>>> def foo(p1, p2=22, p3=33):    #设置了两个参数p2, p3的默认值
...     print "p1==>", p1
...     print "p2==>", p2
...     print "p3==>", p3
... 
>>> foo(11)                       #p1=11，其他的参数为默认赋值
p1==> 11
p2==> 22
p3==> 33
 
>>> foo(11, 222)                  #按照顺序，p2=222，p3依旧维持原默认值
p1==> 11
p2==> 222
p3==> 33
>>> foo(11, 222, 333)  
p1==> 11
p2==> 222
p3==> 333
 
>>> foo(11, p2=122)
p1==> 11
p2==> 122
p3==> 33
 
>>> foo(p2=122)                #p1没有默认值，必须要赋值的，否则报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: foo() takes at least 1 argument (1 given)
 
def foo(*args)

这种方式适合于不确定参数个数的时候，在参数args前面加一个*，注意，仅加一个。

>>> def foo(*args):            
...     print args
... 
>>> foo("qiwsir.github.io")      
('qiwsir.github.io',)
>>> foo("qiwsir.github.io","python")
('qiwsir.github.io', 'python')
 
def foo(**args)

这种方式跟上面的区别在于，必须接收类似arg=val的形式。

>>> def foo(**args):    
...     print args
... 
 
>>> foo(1, 2, 3)                            #这样就报错了
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: foo() takes exactly 0 arguments (3 given)
 
>>> foo(a=1, b=2, c=3)    
{'a': 1, 'c': 3, 'b': 2}

下面写一个综合的，看看以上四种参数传递方法的执行顺序。

>>> def foo(x,y=2, *targs, **dargs):
...     print "x==>", x
...     print "y==>", y
...     print "targs_tuple==>", targs
...     print "dargs_dict==>", dargs
... 
 
>>> foo("1x")
x==> 1x
y==> 2
targs_tuple==> ()
dargs_dict==> {}
 
>>> foo("1x", "2y")
x==> 1x
y==> 2y
targs_tuple==> ()
dargs_dict==> {}
 
>>> foo("1x", "2y", "3t1", "3t2")
x==> 1x
y==> 2y
targs_tuple==> ('3t1', '3t2')
dargs_dict==> {}
 
>>> foo("1x", "2y", "3t1", "3t2", d1="4d1", d2="4d2")
x==> 1x
y==> 2y
targs_tuple==> ('3t1', '3t2')
dargs_dict==> {'d2': '4d2', 'd1': '4d1'}