Python 函数(3)

作者: _Zhao_ | 来源:发表于2015-01-19 16:00 被阅读264次

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

    相关文章

      网友评论

        本文标题:Python 函数(3)

        本文链接:https://www.haomeiwen.com/subject/jnfhxttx.html