我们在写Python代码的时候，有的时候需要设计一种函数，这种函数的参数个数不确定，或者说要求函数的参数不限个数，只有在函数被调用的时候，才能确定参数的数量。本文介绍如何实现这样的函数参数接口的设计。

tuple参数(*args)

我们在设计函数参数的时候，如果使用一个*符号后跟字母，表示这是一个tuple参数，tuple内数据的个数，就不限制了。

我们来设计一个简单的函数，这个函数的作用就是将tuple参数内所有的数据相加求和：

>>> def add(*args):
...     print(args)
...     print(type(args))
...     sum = 0
...     for i in range(len(args)):
...         sum += args[i]
...     print(sum)
...
>>> add(1,2,3)
(1, 2, 3)
<class 'tuple'>
6
>>> add(1,2,3,8,9,666)
(1, 2, 3, 8, 9, 666)
<class 'tuple'>
689
>>> add()
()
<class 'tuple'>
0

add函数的参数，args，符号后面必须要有字母跟随，如果参数是一个独立的*符号，语义是不一样的！

args参数在函数内部，是一个tuple类型的对象，使用时要去掉前面的符号，直接使用args。在调用函数时，看不出来这是一个tuple，调用时并无特别之处，只是参数的数量不确定，可以很多，注意哦，也可以没有参数。

实现不限参数个数的函数接口，一般都使用这种方式，tuple对象内的各数据类型应该保持一致，如果不一致，大概率这不是一个好的设计，因为对各数据的处理方式会不一样。

dict参数(**kwargs)

设计函数参数时，如果使用两个**符号后跟字母，表示这个参数是一个dict对象。这种方式也可实现函数参数的个数不限。

下面的代码示例，是一个输入dict参数的函数，函数的作用，将dict对象中的数据，全部以 key : value 配对的方式显示出来：

>>> def test_kw(**kwargs):
...     print(kwargs)
...     print(type(kwargs))
...     for k,v in kwargs.items():
...         print(k,':',v)
...
>>> test_kw(a=1,b=2,c=3,d=4)
{'a': 1, 'b': 2, 'c': 3, 'd': 4}
<class 'dict'>
a : 1
b : 2
c : 3
d : 4
>>> test_kw(a=1,b=2,c=3,d=4,x=999)
{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'x': 999}
<class 'dict'>
a : 1
b : 2
c : 3
d : 4
x : 999
>>> test_kw()
{}
<class 'dict'>

采用**kwargs参数，函数调用时，要写成key=value的形式。同样的，这种方式也兼容没有参数输入。

使用这种方式的dict参数，函数内部可能需要预先知道有哪些key值可以使用，或者就是直接遍历所有的key和value。我想到了这样一个应用场景，设计一个函数，作用是替换输入字符串中的某些字符，返回新字符串，替换规则通过**kwargs传入。代码实现如下：

>>> def char_replace(originstr, **kwargs):
...     newstr = ''
...     for c in originstr:
...         if c in kwargs.keys():
...             newstr += kwargs[c]
...         else:
...             newstr += c
...     return newstr
...
>>>
>>> char_replace('abcde', a='x')
'xbcde'
>>> char_replace('abcde', a='x',c='y')
'xbyde'
>>> char_replace('abcde', a='x',c='y',e='z')
'xbydz'

以上就是在Python中，实现函数参数个数不确定的两种方法。