python的传参分析

在python中，可以对一个方法设置参数，通常有位置参数、关键字参数、默认参数和可变参数，下面实际看看各种参数的使用。

一. 位置参数

调用方法的时候，传入的参数必须和定义的参数位置保持一致。例如：

def hello(arg1, arg2):
    print arg1, arg2


hello('世界', '你好')
hello('你好', '世界')


# 位置参数，如果传入的参数位置传入不对，得到的结果自然也会有问题
# 世界 你好
# 你好 世界

二. 关键字参数

调用方法的时候，传入参数的形式是 key=value，这种键值对的形式。

#!/usr/bin/env python
# -*- coding:utf8 -*-


def hello(arg1, arg2):
    print arg1, arg2


# 关键字参数可以无序
hello(arg1='世界', arg2='你好')
hello(arg2='你好', arg1='世界')
# 位置参数在前，关键字参数在后
hello('世界', arg2='你好')
hello('你好', arg2='世界')

# 这种调用错误，位置参数不能在关键字参数后面
# hello(arg1='你好', '世界')

# 世界 你好
# 世界 你好
# 世界 你好
# 你好 世界

三. 默认参数

方法的默认参数，是指即使不传入参数，方法也可以被调用，只不过值是默认的。

# 注意：位置参数在前，默认参数在后
# def hello_world(arg1='世界', arg2):
#     print arg1, arg2

def hello_world(arg1, arg2='你好'):
    print arg1, arg2


hello_world('世界')

# 世界 你好

四. 可变参数

有时候，对于方法的参数定义，我们并不能很清楚的知道有多少个参数，所以，对于不确定的参数定义，可变参数就显得非常实用了。

1. 位置可变参数

位置可变参数，我们用*args，这个来表示。

def hello_motos(*args):
    # 可变参数的长度
    print args.__len__()
    # 计算可变参数中具体参数的下标
    print args.index('nihao')
    # 是可迭代的对象
    print args.__iter__()
    for arg in args.__iter__():
        print arg


hello_motos('世界', 'shijie', '你好', 'nihao')


# 4
# 3
# <tupleiterator object at 0x103f1c3d0>
# 世界
# shijie
# 你好
# nihao

2. 可变关键字参数

可变关键字参数，我们用**kwargs，这个表示。

def hello_k(**kwargs):
    # 可变关键字参数的长度
    print kwargs.__len__()
    # 获取指定key对应的value
    print kwargs.get('a')
    # 可变关键字参数的迭代对象
    print kwargs.iteritems()
    for key, value in kwargs.iteritems():
        print key, value
    # 可变关键字参数的key迭代对象
    print kwargs.iterkeys()
    for key in kwargs.iterkeys():
        print key
    # 可变关键字参数的value迭代对象
    print kwargs.itervalues()
    for value in kwargs.itervalues():
        print value


hello_k(a='世界', b='shijie', c='你好', d='nihao')


# 4
# 世界
# <dictionary-itemiterator object at 0x10aa0cdb8>
# a 世界
# c 你好
# b shijie
# d nihao
# <dictionary-keyiterator object at 0x10aa0cdb8>
# a
# c
# b
# d
# <dictionary-valueiterator object at 0x10aa0cdb8>
# 世界
# 你好
# shijie
# nihao

五. 参数的混合使用

实际应用中，比较常见的就是参数的混合使用，位置参数、默认参数、可变参数，在一个可以使用的依赖包中间，是非常容易遇见的，也方便我们子级在开发中多多注意。

def hello_all(a, b, c=0, *args, **kwargs):
    print a, b, c, args, kwargs


# 只传位置参数
hello_all('世界', '你好')
# 世界 你好 0 () {}

# 位置参数、默认参数
hello_all('世界', '你好', 1)
# 世界 你好 1 () {}

# 默认参数是int,但是给的是str，不符合
# hello_all('世界', '你好', 'shijie', 'nihao')
hello_all('世界', '你好', 1, 'shijie', 'nihao')
# 世界 你好 1 ('shijie', 'nihao') {}
hello_all('世界', '你好', 1, 'shijie', 'nihao', k='hahah')
# 世界 你好 1 ('shijie', 'nihao') {'k': 'hahah'}
hello_all('世界', '你好', 1, 'shijie', 'nihao')
# 世界 你好 1 ('shijie', 'nihao') {}
hello_all(1, 2, 3, 4, x='shijie', y='nihao')
# 1 2 3 (4,) {'y': 'nihao', 'x': 'shijie'}