位置参数

最简单的协议是类似于C语言的形参和实参。函数定义了形参，调用者传入实参。要求形参和实参个数相同，顺序也相同，即形参和实参是按照位置来匹配的。

例如，求两个参数的和，可以按以下方式定义：

def get_sum(a, b):  # 定义了两个形参，一个是a，一个是b
    return a+b
get_sum(1, 2)       # 传递进去两个实参，一个是1，一个是2

如果参数个数不同，会导致异常。下面的例子演示了形参和实参不匹配的情形：

>>> def get_sum(a, b):  # 定义函数
        return a+b

>>> get_sum(1)  # 实参个数比形参少
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: get_sum() takes exactly 2 arguments (1 given)
>>> get_sum(1, 2, 3)  # 实参个数比形参多
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: get_sum() takes exactly 2 arguments (3 given)

如果参数的顺序不一致，可能不会抛出异常，但计算结果不是我们预期的。

例如，要求两个数的差，在函数定义时第一个参数表示被减数，第二个参数表示减数。但如果在调用时将顺序颠倒，第一个实参是减数，第二个实参是被减数，得到的结果就是错误的。

>>> def get_diff(a, b):  # 定义求差的函数，第一个参数为被减数
        return a-b

>>> get_diff(10, 2)      # 使用求差函数，但是实参顺序不对，导致结果错误
8

将位置参数当作元组

上面的办法有一个缺点，即函数的参数个数是确定的，但有些情况不能确定调用函数时输入的实参数量。最简单的例子就是 Python 3 中的 print() 函数，其可以接受任意多个参数。

>>> print(1)        # 1个参数
1
>>> print(1, 2)     # 2个参数
1 2
>>> print(1, 2, 3)  # 3个参数
1 2 3

假定现在需要实现一个求和函数，但并不局限在两个数或者三个数的求和，即该函数要求能够接受任意数量的参数，然后求出所有实参的和并返回该和。

这时可以将所有的实参当作一个元组，定义函数如下：

def get_sum(*l):

这里和前面不同的是参数前面带有一个*，表示参数l是一个元组，该元组的每个元素都对应一个实参，而且顺序和实参的实际顺序一致。

>>> def get_sum(*l):  # 定义求和函数，将参数当作元组
        print("Type of l:", type(l))
        ret = 0
        for x in l:
            print("  x =", x)
            ret = ret + x
        print("sum =", ret)
        return ret
                      # 求和函数定义结束
>>> get_sum(10, 2)  # 使用求和函数，传入两个实参
Type of l: <class 'tuple'>
  x = 10
  x = 2
sum = 12
12
>>> get_sum(10, 2, 11, 28, 100)  # 使用求和函数，传入5个实参
Type of l: <class 'tuple'>
  x = 10
  x = 2
  x = 11
  x = 28
  x = 100
sum = 151
151

前面的例子是将所有的实参作为一个元组使用。那能否将部分实参作为元组使用呢？答案是可以的，但作为元组使用的参数一定要是最后的实参。我们可以将前面的实参当作普通参数使用，但后面的参数当作一个元组使用。

下面修改一下前面的求和函数，其第一个参数是一个系数k，后面是任意多个参数，其计算的结果是这些参数的和，然后乘以第一个参数k。用数学来表达就是：

y = k * (v1 + v2+ …)

这时我们可将第一个实参k作为普通的参数，其他的实参作为元组。

下面是该函数的定义和使用情况：

>>> def get_sum(k, *l):  # 第一个实参是普通参数，后面的是一个元组
        print("k =", k)
        print("Type of l:", type(l))
        ret = 0
        for x in l:  # 对元组内的数据求和
            print("  x =", x)
            ret = ret + x
        ret = ret * k  # 乘以系数k
        print("sum =", ret)
        return ret

>>> get_sum(10, 2)  # 10对应的是k，2放入到元组参数中
k = 10
Type of l: <class 'tuple'>
  x = 2
sum = 20
20
>>> get_sum(10, 2, 11, 28, 100)  # 10对应的是k，其他放入到元组参数中
k = 10
Type of l: <class 'tuple'>
  x = 2
  x = 11
  x = 28
  x = 100
sum = 1410
1410

调用时使用元组和列表

上面在调用函数时采用的是普通的方法，但是在函数定义时对参数进行了特殊处理。这里正好相反，即在函数定义时使用普通的方法，但在函数调用时传入的是元组。

注意，该元组中元素的个数和顺序一定要和函数定义时一致；传入的字典对象前需要加上一个*。

>>> def func_demo(a, b, c):  # 普通定义方法，需要3个参数
        print("  a = %s" % a)
        print("  b = %s" % b)
        print("  c = %s" % c)

>>> d = [1, 2, 3]  # 传入的是列表
>>> func_demo(*d)  # 列表有3个元素，没有问题
  a = 1            # 注意参数对象前面的*
  b = 2
  c = 3
>>> d = [1, 2]     # 列表只有2个元素，有问题
>>> func_demo(*d)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: func_demo() missing 1 required positional argument: 'c'
>>> d = (10, 20, 30)  # 参数是元组，元素个数为3，也没有问题
>>> func_demo(*d)
  a = 10
  b = 20
  c = 30

关键字参数

将实参当作元组能解决参数个数不确定的问题，但还有一个问题，即参数顺序必须一致。如果不希望调用时固定参数的顺序，可以在调用时同时指定形参和实参，这些参数又称为关键字参数。

>>> def get_diff(sub_from, sub_val):
        ret = sub_from - sub_val
        print("  %d - %d = %d" % (sub_from, sub_val, ret))
        return ret

>>> get_diff(100, 10)  # 普通调用方法，要求个数和顺序正确
  100 - 10 = 90
90
>>> get_diff(sub_from=100, sub_val=10) # 不要求顺序一致
  100 - 10 = 90
90
>>> get_diff(sub_val=10, sub_from=100) # 不要求顺序一致
  100 - 10 = 90
90

将实参当作字典

对于同时使用形参和实参，同样也会面临参数个数的问题。如果不确定参数个数，该如何处理呢？最简单的一个例子就是命令行参数，有些参数被指定了，有些没有被指定，从而导致实参的个数不定。

为了解决该问题，可以将实参当作字典，该字典的键就是形参的名字，值就是实参。由于是字典，所以其元素个数是不定的，即有些参数可能存在也可能不存在。

假定某个函数，其最多可以有 3 个参数 key1、key2 和 key3，在调用时可以指定某一个参数，也可以指定某两个参数或者都指定，则该函数可以进行如下定义：

>>> def func_demo(**d):  # 这里d匹配所有带有形参和实参的参数
        print("type of d: %s" % type(d))
        for k, v in d.items():
            print("  %s => %s" % (k, v))
        return None

>>> func_demo(key1=1)  # 只传入1个参数key1
type of d: <class 'dict'>
  key1 => 1
>>> func_demo(key2=1, key1=2)  # 只传入2个参数，key2和key1
type of d: <class 'dict'>
  key2 => 1
  key1 => 2
>>> func_demo(key2=1, key3=6, key1=2)  # 传入3个参数，key2、key3和key1
type of d: <class 'dict'>
  key2 => 1
  key3 => 6
  key1 => 2

可以看到，使用字典来表示参数时，既不要求参数个数固定，也不要求参数顺序固定，这比前面的用法要灵活得多。

调用时使用字典

和前面类似，可以在函数定义时使用普通用法，但在调用时通过传入一个字典来解决。这时需要在传入参数前面加上两个*。同样，实参个数一定要等于形参个数。由于传入的是字典，所以顺序是没有关系的。

>>> def func_demo(a, b, c):  # 普通函数定义方法
        print("  a = %s" % a)
        print("  b = %s" % b)
        print("  c = %s" % c)

>>> d = {"a": 10, "b":20, "c":30}  # 传入字典
>>> func_demo(**d)  # 注意字典对象前的**
  a = 10
  b = 20
  c = 30
>>> d = {"c":30, "a": 10, "b":20}  # 参数顺序不重要
>>> func_demo(**d)
  a = 10
  b = 20
  c = 30
>>> d = {"a": 10, "b":20}  # 但是参数的个数必须和形参一致
>>> func_demo(**d)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: func_demo() missing 1 required positional argument: 'c'

默认值

在定义函数时可以指定参数的默认值。这样在调用时即使不指定该参数的值也没有关系，因为该参数会自动等于定义时指定的默认值。

需要注意的是，带有默认值的参数一定是在最后面，不能放在没有默认值参数的前面。

>>> def get_sum(a, b=0):  # 参数b有一个默认值0，如果未指定b的值，b就为0
        return a+b

>>> get_sum(1, 2)         # 普通用法，指定了a和b的值
3
>>> get_sum(1)            # 没有指定b的值，所以b等于默认值0
1

如果有默认值的参数在没有默认值参数的前面，那么在函数定义时会抛出语法错误的异常。下面演示了这种情况。

>>> def get_sum(a=0, b):  # a有默认值，b没有默认值，a不能在b的前面
        return a+b

  File "<stdin>", line 1
SyntaxError: non-default argument follows default argument