本篇总结函数参数匹配（argument match）的问题
背景
对于函数的使用者而言，关注点有两个：
1、函数所提供的接口，即，输入的问题；
2、函数的输出；
输入--->函数--->输出
对于函数本身而言，关注点有三个：
1、输入，包括输入的格式、输入的内容、校验等；
2、如何处理输入；
3、提供什么样的输出；
输入--->处理--->输出
可见，使用者不关注函数的处理过程，只关注输入和输出，而函数则不关注使用者是谁，只关注输入。
那么，可以发现，函数提供输入实际是提供接口，所以函数输入设计的实质是接口设计。
而接口设计又可以分为两部分：形式设计和内容设计。其中，形式设计回答什么形式的输入的问题，内容设计则回答输入是什么的问题。
本篇要讨论的函数参数匹配问题属于形式设计。
好了，形而上的讲了一堆东西，下面开始正题。
1. 参数匹配
首先来个C++的例子:
假设，有函数如下:
int record( string name, unsigned int age, string email)
{
// 处理过程
return 0;
}
该函数所提供的接口为 string name, unsigned int age, string email
那么如下例，使用函数:
record("Joe", 20, "Joe@email.com"); // 正确形式
record(20, "Joe", "Joe@email.com"); // 错误形式
record("Joe@email.com", 20, "Joe"); // 语法正确，但是内容错误
当使用 record(20, "Joe", "Joe@email.com"); 会出现错误。如果使用IDE那么，这里会提示错误信息；如果不是使用IDE，那么在编译时，也会有相应的错误信息提示。错误的原因是数据类型不匹配。
也就是说，在C++中，参数的匹配时是按照顺序来进行的。即：
string name = "Jone"，unsigned int age = 20，string email = "Joe@email.com"，
对于静态强类型语言，当出现string name = 20的匹配时，就会出现数据类型不匹配的错误（不考虑模板的情况）。
基本上，常见的编程语言，函数的默认参数匹配方式都采用顺序匹配方式。Python也不例外。但是Python也提供了其他的参数匹配方式：
位置匹配(顺序匹配<默认采用这种方式>)
关键字匹配
默认值
可变参数
2. 位置匹配
Python的位置匹配实例如下：
# 函数定义
>>> def record(name, age, email):
... record_name = name
... record_age = age
... record_email= email
...
# 函数使用
>>> record('Joe', 20, 'Joe@email.com') #
>>> record(20, 'Joe', 'Joe@email.com') #形式正确，内容错误
对于动态语言，上例中第二种调用，并没有类型不匹配的问题。只是内容错误而已。由此也引出了关键字匹配
3. 关键字匹配
在上述例子中第二种调用方式之所以会出现问题，原因在于：
由于采用位置匹配，所以为了保证输入内容正确，调用时，必须知晓参数的位置（或者顺序）。
采用关键字匹配就不存在这种问题。
还是先看例子：
# 函数定义
>>> def record(name, age, email):
... record_name = name
... record_age = age
... record_email= email
...
# 函数使用
>>> record(name = 'Joe', age = 20, email = 'Joe@email.com') #
>>> record(age = 20, name = 'Joe', email = 'Joe@email.com') #
可以看到，关键字匹配与位置匹配的最大区别在于：关键字匹配，在调用函数时，加入了实参与形参的对应信息。
这样做的好处在于，调用者只需要知道调用时需要输入的参数名称即可，不用理会其顺序。另外，从语义的角度来看，这种方式在表达上也更加清晰，因为调用时，十分清楚的写明了：
age = 20，name = 'Joe'，email = 'Joe@email.com'，
程序的可读性非常高。
4. 默认值
对于函数的调用者而言，调用时所需的参数越少，意味着使用起来也越简单。但是，有时候，为了功能的灵活，同时需要保留足够的备选参数。这些备选参数需要有以下特点：
- 如果调用时不设定，则为默认值；
- 如果调用时设定，则使用设定值；
这样，使得函数的易用性与灵活性同时得到保证。默认值参数就实现了这样的功能。
举例：
>>> def record(name, age, email="xxx@email.com"):
... print name, age, email
...
>>> record('Joe', 20, 'Joe@gmail.com')
Joe 20 Joe@gmail.com
>>> record('Joe', 20)
Joe 20 xxx@email.com
5. 可变参数
为什么需要可变参数
假设现在需要这样一个函数：输入两个字符串，输出两个字符串拼起来的字符串。
>>> def str_add(str1, str2):
... return str1 + str2
...
>>> str_add("I am ", "Joe ")
'I am Joe '
输入两个字符串的例子很容易实现，那么问题来了... ....
如果要求输入3个字符串呢？4个？5个？... ...总不能一个函数一个函数的写下去吧。
总结一下，很容易发现不论输入是几个字符串，所作的操作都是将所输入的字符串拼起来。这个时候，可变参数就派上用场了。
先看例子：
>>> def str_add(*str): # 定义可变参数
... print reduce(lambda x,y:x+y,str) # 将str中的所有变量相加
...
>>> str_add("I am ", "Joe")
I am Joe
>>> str_add("I am ", "Joe, ","my email is ","Joe@gmail.com")
I am Joe, my email is Joe@gmail.com
>>>
上例中，采用可变参数的函数str_add可以支持不定个数的字符串输入，输出这些字符串拼接之后的字符串。
由此可见：
可变参数的意义在于，能够使函数处理参数不定，操作具有共性的需求。而所谓的可变参数是指，参数的个数是可以变化的。
定义可变参数
弄清楚为什么要使用可变参数以后，我们来说一下上面的例子中是如何定义可变参数的。
首先，我们使用Tuple可以实现一个功能与可变参数相同的函数。
>>> def str_add(str):
... print reduce(lambda x,y:x+y, str)
...
>>> words = ("I am ", "Joe") #创建一个Tuple对象
>>> str_add(words)
I am Joe
对比这个例子和上面的例子可以发现，在本例中，需要提前构造一个Tuple对象，然后再将这个对象传入函数。
实际上，上一节的例子中str_add函数内部 *str接收到也是Tuple对象。
在Python中如果List对象或者Tuple对象使用*来修饰作为实参传入函数时，会将其变成可变参数列表传入函数。
比如下面的例子：
>>> def str_add(*str):
... print reduce(lambda x,y:x+y,str)
...
>>> words = ("I am ", "Joe")
>>> str_add(*words) #在Tuple对象words前加*作为实参传入函数
I am Joe
可变参数在形式上有两种：
- 对于List对象或者Tuple对象，在变量前加
*； - 对于Dict对象，在变量前加
**；
在Python中称加*的变量为Non-keyword Variable Arguments，称加**的变量为keyword Variable Arguments。
下面给出一个可变参数使用的完整例子
>>> def foo(name, age, *args, **kwargs):
... print name, age, args, kwargs
...
>>> info = ["Joe@gmail.com","male"]
>>> addition = {"location":"Beijing","prof":"software"}
>>> foo("Joe",20, *info, **addition) #List对象info前加*,Dict对象addition前加**
Joe 20 ('Joe@gmail.com', 'male') {'prof': 'software', 'location': 'Beijing'}
>>> foo("Joe",20, "Joe@gmail.com","male",location="Beijing",prof="software")
Joe 20 ('Joe@gmail.com', 'male') {'prof': 'software', 'location': 'Beijing'}
总结一下：
Python的函数参数匹配提供了多种方式，非常灵活，使用的时候即可以单独使用某一种方式，也可以混合使用多种方式。
