在设计函数的时候，有时候我们能够确认参数的个数，比如一个用来计算圆面积的函数，它所需要的参数就是半径（πr^2），这个函数的参数是确定的。
> 你能不能写一个能够计算圆面积的函数呢？
然而，这个世界不总是这么简单的，也不总是这么确定的，反而不确定性是这个世界常常存在的。如果看官了解量子力学——好多人听都没有听过的东西——就更理解真正的不确定性了。当然，不用研究量子力学也一样能够体会到，世界充满里了不确定性。不是吗？塞翁失马焉知非福，这不就是不确定性吗？
## [](https://github.com/qiwsir/StarterLearningPython/blob/master/203.md#参数收集)参数收集
既然有很多不确定性，那么函数的参数的个数，也当然有不确定性，函数怎么解决这个问题呢？python用这样的方式解决参数个数的不确定性：
~~~
def func(x,*arg):
print x #输出参数x的值
result = x
print arg #输出通过*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
为了能够更明显地看出*args（名称可以不一样，但是*符号必须要有），可以用下面的一个简单函数来演示：
~~~
>>> 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”很可能在1960年代至1970年代初通过迪吉多的系统手册传播开来。另一种说法是，“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`的形式收集值，会得到dict类型的数据，但是，需要在传值的时候说明“键”和“值”，因为在字典中是以键值对形式出现的。
看官到这里可能想了，不是不确定性吗？我也不知道参数到底会可能用什么样的方式传值呀，这好办，把上面的都综合起来。
~~~
>>> 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'}
~~~
很good了，这样就能够足以应付各种各样的参数要求了。
## [](https://github.com/qiwsir/StarterLearningPython/blob/master/203.md#另外一种传值方式)另外一种传值方式
~~~
>>> 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
~~~
这种调用函数传值的方式，至少在我的编程实践中，用的不多。不过，不代表读者不用。这或许是习惯问题。
## [](https://github.com/qiwsir/StarterLearningPython/blob/master/203.md#复习)复习
python中函数的参数通过赋值的方式来传递引用对象。下面总结通过总结常见的函数参数定义方式，来理解参数传递的流程。
### [](https://github.com/qiwsir/StarterLearningPython/blob/master/203.md#def-foop1p2p3)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) #要求3个参数，实际上放置了4个，报错
~~~
### [](https://github.com/qiwsir/StarterLearningPython/blob/master/203.md#def-foop1value1p2value2)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)
~~~
### [](https://github.com/qiwsir/StarterLearningPython/blob/master/203.md#def-fooargs)def foo(*args)
这种方式适合于不确定参数个数的时候，在参数args前面加一个*，注意，仅一个哟。
~~~
>>> def foo(*args): #接收不确定个数的数据对象
... print args
...
>>> foo("qiwsir.github.io") #以tuple形式接收到，哪怕是一个
('qiwsir.github.io',)
>>> foo("qiwsir.github.io","python")
('qiwsir.github.io', 'python')
~~~
#### [](https://github.com/qiwsir/StarterLearningPython/blob/master/203.md#def-fooargs-1)def foo(**args)
这种方式跟上面的区别在于，必须接收类似arg=val形式的。
~~~
>>> def foo(**args): #这种方式接收，以dictionary的形式接收数据对象
... 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'}
~~~
- 第零章 预备
- 关于Python的故事
- 从小工到专家
- Python安装
- 集成开发环境
- 第壹章 基本数据类型
- 数和四则运算
- 除法
- 常用数学函数和运算优先级
- 写一个简单的程序
- 字符串(1)
- 字符串(2)
- 字符串(3)
- 字符串(4)
- 字符编码
- 列表(1)
- 列表(2)
- 列表(3)
- 回顾list和str
- 元组
- 字典(1)
- 字典(2)
- 集合(1)
- 集合(2)
- 第贰章 语句和文件
- 运算符
- 语句(1)
- 语句(2)
- 语句(3)
- 语句(4)
- 语句(5)
- 文件(1)
- 文件(2)
- 迭代
- 练习
- 自省
- 第叁章 函数
- 函数(1)
- 函数(2)
- 函数(3)
- 函数(4)
- 函数练习
- 第肆章 类
- 类(1)
- 类(2)
- 类(3)
- 类(4)
- 类(5)
- 多态和封装
- 特殊方法(1)
- 特殊方法(2)
- 迭代器
- 生成器
- 上下文管理器
- 第伍章 错误和异常
- 错误和异常(1)
- 错误和异常(2)
- 错误和异常(3)
- 第陆章 模块
- 编写模块
- 标准库(1)
- 标准库(2)
- 标准库(3)
- 标准库(4)
- 标准库(5)
- 标准库(6)
- 标准库(7)
- 标准库(8)
- 第三方库
- 第柒章 保存数据
- 将数据存入文件
- mysql数据库(1)
- MySQL数据库(2)
- mongodb数据库(1)
- SQLite数据库
- 电子表格
- 第捌章 用Tornado做网站
- 为做网站而准备
- 分析Hello
- 用tornado做网站(1)
- 用tornado做网站(2)
- 用tornado做网站(3)
- 用tornado做网站(4)
- 用tornado做网站(5)
- 用tornado做网站(6)
- 用tornado做网站(7)
- 第玖章 科学计算
- 为计算做准备
- Pandas使用(1)
- Pandas使用(2)
- 处理股票数据
- 附：网络文摘
- 如何成为Python高手
- ASCII、Unicode、GBK和UTF-8字符编码的区别联系