Python中参数传递方式

参数传递

1.位置传递

必须以在被调用函数中定义的顺序来传递
>>>def f(a,b,c):
...    print a, b, c
    
>>>f(1, 2, 3)
1 2 3

f(1, 2, 3)中的1, 2, 3分别对应f(a, b, c)中的a, c, c，以位置来传递参数

2.关键字传递

关键字传递是根据每个参数的名字传递参数
关键字传递参数可以不遵守位置对应关系
关键字传递可以和位置传递混用。== 但位置参数要出现在关键字参数之前
==

>>>def f(a,b,c):
...    print a, b, c
    
>>>f(1, c = 3, b = 2)
1 2 3

3.参数默认值

定义函数时，默认为函数的参数赋值

>>>def f(a = 10, b = 20, c = 30):
...    print a, b, c
    
>>>f()
10 20 30
>>>f(1, b = 5)
1 5 30
所有的参数要在默认值之前
>>> def test(a=1, b):
    print a, b
    
SyntaxError: non-default argument follows default argument
>设置默认参数后，当调用函数没有赋值时，使用默认值；当调用函数使用参数时，使用参数

4.包裹传递

在定义函数时，我们有时候并不知道调用的时候会传递多少个参数。这时候，包裹(packing)位置参数，或者包裹关键字参数，来进行参数传递，会非常有用。
在func的参数表中，所有的参数被name收集，根据位置合并成一个元组(tuple)，这就是包裹位置传递,为了提醒Python参数，name是包裹位置传递所用的元组名，在定义func时，在name前加*号

>>>def func(*name):
...    print type(name)
...    print name

>>>func(1,4,6)
<type 'tuple'>
(1, 4, 6)
>>>func(5,6,7,1,2,3)
<type 'tuple'>
(5, 6, 7, 1, 2, 3)

==这样传递的参数元组必须在位置和默认参数后==

>>> def test(a, b=2, *c, **d):
    print a, b, c,d

>>> test(1, 3, *[4, 5], **{'e':6, 'f':7})
1 3 (4, 5) {'e': 6, 'f': 7}

dict是一个字典，收集所有的关键字，传递给函数func。为了提醒Python，参数dict是包裹关键字传递所用的字典，在dict前加 **

>>>def func(**dict):
...    print type(dict)
...    print dict

>>>func(a=1,b=9)
<type 'dict'>
{'a': 1, 'b': 9}
>>>func(m=2,n=1,c=11)
<type 'dict'>
{'c': 11, 'm': 2, 'n': 1}

5.解包裹

在函数中，*和 **，也可以在调用的时候使用，即解包裹(unpacking)
所谓的解包裹，就是在传递tuple时，让tuple的每一个元素对应一个位置参数

>>>def func(a,b,c):
...    print a,b,c

>>>args = (1,3,4)
>>>func(*args)
1 3 4


>>> def test(a, b=2, *c, **d):
    print a, b, c,d
错误调用
>>> test(1, 3, [4, 5], {'e':6, 'f':7})
1 3 ([4, 5], {'e': 6, 'f': 7}) {}
正确调用
>>> test(1, 3, *[4, 5], **{'e':6, 'f':7})
1 3 (4, 5) {'e': 6, 'f': 7}

综上：先位置，再关键字，再包裹位置（list），再包裹关键字（dict）

测试代码：

#!/usr/bin/env python
# -*- coding:utf-8 -*-


def test_it(func, *nkwargs, **kwargs):
    try:
        retval = func(*nkwargs, **kwargs)
        result = (True, retval)
    except Exception, diag:
        result = (False, str(diag))
    return result


def test():
    funcs = (int, long, float)
    vals = (1234, 12.23, '1234', '12.34')

    for each_func in funcs:
        print '-' * 20
        for each_val in vals:
            retval = test_it(each_func, each_val)
            if retval[0]:
                print '%s(%s) = ' % (each_func.__name__, 'each_val'), retval[1]
            else:
                print '%s(%s) = FAILED' % (each_func.__name__, 'each_val'), retval[1]


if __name__ == '__main__':
    test()

Output:

--------------------
int(each_val) =  1234
int(each_val) =  12
int(each_val) =  1234
int(each_val) = FAILED invalid literal for int() with base 10: '12.34'
--------------------
long(each_val) =  1234
long(each_val) =  12
long(each_val) =  1234
long(each_val) = FAILED invalid literal for long() with base 10: '12.34'
--------------------
float(each_val) =  1234.0
float(each_val) =  12.23
float(each_val) =  1234.0
float(each_val) =  12.34