本篇总结函数参数匹配（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. 默认值

对于函数的调用者而言，调用时所需的参数越少，意味着使用起来也越简单。但是，有时候，为了功能的灵活，同时需要保留足够的备选参数。这些备选参数需要有以下特点：

1. 如果调用时不设定，则为默认值；
2. 如果调用时设定，则使用设定值；

这样，使得函数的易用性与灵活性同时得到保证。默认值参数就实现了这样的功能。
举例：

>>> 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

可变参数在形式上有两种：

1. 对于List对象或者Tuple对象，在变量前加*；
2. 对于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的函数参数匹配提供了多种方式，非常灵活，使用的时候即可以单独使用某一种方式，也可以混合使用多种方式。