Python札记 -- 参数魔法

    在上一篇随笔《Python凡人笔记 -- 装饰器》中有园友提出我对Python中的参数魔法表述得不是很明确，故借此机会总结一下，再结合几个例子，希望对大家有帮助。另外竹风使用的是 Python 2.6.6

    参考资料：《Python基础教程》（第2版）Magnus Lie Hetland

    一、Python的函数返回些什么？
    一般说的函数，总会在计算之后返回点什么。像在 Pascal 里面，就有分函数和过程。让我们一起从例子里面看看 Python 的函数到底会返回些什么。

def test():
    print "This is printed"
    return
    print "This is not"

    这里的return语句只起到结束函数的作用：

>>> x = test()
This is printed

>>> x
>>>

>>> print x
None

    可以看到，第二个print语句被跳过了。单单看 x 好像没有任何东西，通过 “print x” 我们可以看到一个熟悉的值：None。
    这么看来，在Python里面，所有的函数都会返回值；当不需要它们返回值的时候，它们就返回None。

    二、什么类型的参数可以修改？
    函数通过参数来获得一系列的值。在Python中，字符串（以及数字和元组）是不可变的，即无法被修改（也就是说只能用新的值覆盖），用学术点的话来说：在函数内为不可变类型的参数赋予新值不会改变外部任何变量的值。   

>>> def try_to_change(n):
...     n = "Mr Gumby"
...
>>> name = "Mrs Entity"
>>> try_to_change(name)
>>> name
'Mrs Entity'

    我们可以看到，name 虽然作为参数传递到函数中，但是最后 name 的值并没有任何改变。其实上面的代码工作方式类似于下面这样：

>>>name = "Mrs Entity"
>>>n = name    #相当于传参数
>>>n = "Mr Gumby"    #在函数内部给n一个新的字符串
>>>name
'Mrs Entity'

    那么如果我们传的参数是一个可变的数据结构呢，比如列表？估计大家已经能猜到结果了。

>>> def change(n):
...     n[0] = "Mr Gumby"
...
>>> name = ["Mrs Entity", "Mrs Thing"]
>>> change(name)
>>> name
['Mr Gumby', 'Mrs Thing']

    这里发现参数的值改变了，这也是与前面的例子中最重要的区别。要弄清楚的是，当两个变量同时引用一个列表的时候，它们的确是同时引用了一个列表。如果想避免出现这种情况，可以复制一个列表的副本。具体做法就是传递参数的时候，将列表的分片作为参数，比如：change(name[:])。这样的话，原始的列表就是安全的。
    PS：竹风刚入门的时候曾经犯过将原始列表传入函数的错误，关键是函数里面有一个 remove 操作，结果大家也能猜到了。。。

    那如果要对一个不可变的参数进行操作呢？比如一个数字，这又该怎么办？
    这个时候我们应该从函数中返回所有需要的值，如果值多于一个拿就用元组的形式返回。例如，将变量的数值增加1的函数可以这么写：

>>> def inc(x):return x + 1
...
>>> foo = 10
>>> foo = inc(foo)
>>> foo
11

    如果真的想改变参数的话，我们可以使用一点小技巧，将值放在列表中（还记得列表是可修改的么？）：

>>> def inc(x): x[0] = x[0] + 1
...
>>> foo = [10]
>>> inc(foo)
>>> foo
[11]

    使用哪种方式，全凭个人喜好~~

    三、位置参数，关键字参数，默认参数
    到目前为止，前面例子中使用的都是位置参数，因为它们的位置很重要——事实上比它们的名字更重要。先看些简单的列子，来看看为什么会引入关键字参数。

>>> def hello_1(greeting, name):
...     print "%s, %s!" % (greeting, name)
...
>>> def hello_2(name, greeting):
...     print "%s, %s!" % (name, greeting)
...
>>> hello_1("Hello", "World")
Hello, World!
>>> hello_2("World", "Hello")
World, Hello!

    这两个函数所实现的功能是完全一样的，唯一的区别就是参数的顺序。当参数很多的时候，竹风觉得参数的顺序是很难记住的。为了让事情简单些，我们可以提供参数的名字。

>>> hello_1(greeting = "Hello", name = "World")
Hello, World!
>>> hello_1(name = "World", greeting = "Hello")
Hello, World!
>>> hello_2(greeting = "Hello", name = "World")
World, Hello!

    提供了参数的名字后，顺序就无关紧要的，就好像上面的 hello_1 调用。唯一要注意的，就是参数名和值一定要对应，不然就会出现 hello_2 那样输出 “World Hello!”了。
    这类使用参数名提供的参数叫做关键字参数。主要作用在于可以明确每个参数的作用，也就避免了下面这样奇怪的调用：

>>>stroe("Mr Brainsample", 10, 20, 13, 5)

>>>stroe(patient="Mr Brainsample", hour=10, minute=20, day=13, month=5)

    竹风以为，大部分园友看见第一种调用的时候估计是虎躯一震的。。。第二种调用虽然打的字多了点，但是参数的含义变得更加清晰，而且就算弄乱了参数的顺序，对于程序的功能也没有任何影响。
    关键字参数最实用的地方在于可以在函数中给参数提供默认值，嘎嘎，再也不用担心调用函数的时候漏参数了~~   

>>> def hello_3(greeting="Hello", name="World"):
...     print "%s, %s!" % (greeting, name)
...
>>> hello_3()    #使用默认参数
Hello, World!
>>> hello_3('Greetings')    #使用位置参数将值传给greeting
Greetings, World!
>>> hello_3('Greetings','God')    #同时使用位置参数
Greetings, God!
>>> hello_3('Greetings',name = 'Tom')    #位置参数和关键字参数混用
Greetings, Tom!
>>> hello_3(name = 'Jerry')    #只使用关键字参数指定name
Hello, Jerry!

    最后关于位置参数和关键字参数需要注意的是：同时使用位置和关键字参数的时候，必须把位置参数放置在关键字参数的前面，否则，解释器就不知道这些参数到底应该处在什么位置了。

    四、收集参数与解开参数
    铺垫了这么久，终于来到今天的两大Boss面前了。位置参数拉好仇恨，关键字参数做好治疗，其他人全力输出吧！（博主wow五人本打多了。。。无视就好。。。）
    先说说收集参数，在定义函数时，*params 收集其余的位置参数（parameter），返回元组；**kwparams 收集其余的关键字参数（key word parameter），返回字典。
    有时候能提供任意数量的参数是相当方便的，比如一个函数 add 可以求任意个数字的和，add(1,2,3) 和 add(1,2,3,4,5) 都能给出正确结果。
    用户可以给函数提供任意多的参数，实现起来也不难。注意例子中虽然只提供了一个参数，但是前面加上了个星号。   

>>> def print_params(*params):
...     print params
...
>>> print_params('Testing')
('Testing',)
>>> print_params('Testing',1,2,3)
('Testing', 1, 2, 3)

    可以看到，结果作为元组打印出来。参数前的星号将所有传进来的参数放置在同一个元组中。也可以说是把这些值收集起来，然后使用。当然也可以联合普通参数来使用：

>>> def print_params_2(title, *params):
...     print "title =",title
...     print params
...
>>> print_params_2("Test2", 1, 2, 3)
title = Test2
(1, 2, 3)
>>> print_params_2("Test3")
title = Test3
()

    完全没问题！所以星号的意思就是“收集其余的位置参数”。如果不提供任何收集的元素，params就是个空元组。
    让我们看下关键字参数的“收集”操作。

>>> def print_params_3(**kwparams):
...     print kwparams
...
>>> print_params_3(x=1, y=2, z=3)
{'y': 2, 'x': 1, 'z': 3}

    返回的是字典而不是元组。将它们放在一起看看：

>>> def print_params_4(x, y, z=3, *pospar, **keypar):
...     print x, y, z
...     print pospar
...     print keypar
...
>>> print_params_4(1, 2, 3, 5, 6, 7, foo='A', bar='B')
1 2 3
(5, 6, 7)
{'foo': 'A', 'bar': 'B'}
>>> print_params_4(1, 2, 3)
1 2 3
()
{}

    ok，跟我们期望的结果没有差别。

    收集参数打完了，再来打展开参数。
    展开参数，在调用函数时，*params 将元组拆分为位置参数（parameter）传入；**kwparams 将字典拆分为关键字参数（key word parameter）传入。
    这是两个典型的例子：   

>>> def add(x,y): return x + y
...
>>> params = (1, 2)
>>> add(*params)
3
>>> def hello_3(greeting="Hello", name="World"):
...     print "%s, %s!" % (greeting, name)
...
>>> kwparams = {'name': 'Sir Robin', 'greeting': 'Well met'}
>>> hello_3(**kwparams)
Well met, Sir Robin!

     最后我们看看这几种方式一起使用的情况：

>>> def finally_test(x, y, z=3, *params, **kwparams):    #参数的顺序应该为：位置参数，关键字参数，*params,**kwparams
...     print "pos x =",x
...     print "pos y =",y
...     print "key z =",z
...     print "params =",params
...     print "kwparams =",kwparams
...
>>> list = [1,2,3,4,5]
>>> dict = {"foo":"A", "bar":"B"}

>>> finally_test(1,2,*list,**dict)    #没有指定z的值，所以将list[0]作为z的值，其他收集为params
pos x = 1
pos y = 2
key z = 1
params = (2, 3, 4, 5)
kwparams = {'foo': 'A', 'bar': 'B'}

>>> finally_test(1,2,3,list,dict)    #错误的调用方法，会将dict也认为是个位置参数
pos x = 1
pos y = 2
key z = 3
params = ([1, 2, 3, 4, 5], {'foo': 'A', 'bar': 'B'})
kwparams = {}

>>> finally_test(1,2)    #没有多余的位置参数和关键字参数的情况
pos x = 1
pos y = 2
key z = 3
params = ()
kwparams = {}

>>> finally_test(1,2,3,*list,**dict)    #正确的调用方式
pos x = 1
pos y = 2
key z = 3
params = (1, 2, 3, 4, 5)
kwparams = {'foo': 'A', 'bar': 'B'}

    其实一般情况下会这么定义函数:
    def foo(*params,**kwparams):
        pass

    到这里就总结完了，希望对大家有用。如有不足，欢迎大家指正交流，谢谢^_^