Python 函数(3)


本篇总结函数参数匹配(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 = 20string 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 = 20name = '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的函数参数匹配提供了多种方式,非常灵活,使用的时候即可以单独使用某一种方式,也可以混合使用多种方式。

推荐阅读更多精彩内容