可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple。而关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。请看示例：

def person(name, age, **kw):
    print('name:', name, 'age:', age, 'other:', kw)

函数person除了必选参数name和age外，还接受关键字参数kw。在调用该函数时，可以只传入必选参数：

>>> person('Michael', 30)
name: Michael age: 30 other: {}

也可以传入任意个数的关键字参数：

>>> person('Bob', 35, city='Beijing')
name: Bob age: 35 other: {'city': 'Beijing'}
>>> person('Adam', 45, gender='M', job='Engineer')
name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}

关键字参数有什么用？它可以扩展函数的功能。比如，在person函数里，我们保证能接收到name和age这两个参数，但是，如果调用者愿意提供更多的参数，我们也能收到。试想你正在做一个用户注册的功能，除了用户名和年龄是必填项外，其他都是可选项，利用关键字参数来定义这个函数就能满足注册的需求。

和可变参数类似，也可以先组装出一个dict，然后，把该dict转换为关键字参数传进去：

>>> extra = {'city': 'Beijing', 'job': 'Engineer'}
>>> person('Jack', 24, city=extra['city'], job=extra['job'])
name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}

当然，上面复杂的调用可以用简化的写法：

>>> extra = {'city': 'Beijing', 'job': 'Engineer'}
>>> person('Jack', 24, **extra)
name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}

extra表示把extra这个dict的所有key-value用关键字参数传入到函数的kw参数，kw将获得一个dict，注意kw获得的dict是extra的一份拷贝，对kw的改动不会影响到函数外的extra。

Python函数关键字参数教程

关键字参数，就是我们在函数传递实参时，可以通过参数名指定，我们具体传递的是哪个形参，但关键字参数的实参和形参的个数还必须是一一对应的。

Python函数位置参数详解

语法

def func_name(param1, param2):

# 执行语句...

return val

#调用函数

func_name(p1, p2)

说明

我们定义了一个函数，函数名为 func_name，该函数有两个位置参数，在函数调用时，我们需要同样的传入两个参数。

这里的实参 p1 对应的就是形参 param1，实参 p2 对应的就是形参 param2。

Python函数关键字参数详解

语法

def func_name(param1, param2):

# 执行语句...

return val

# 调用函数

func_name(param1 = p1, param2 = p2)

func_name(param2 = p2, param1 = p1)

参数

参数

描述

def

定义函数所使用的关键字，所有的函数前面都必须使用该关键字。

func_name

函数的名称。

param1

函数的形参1。

param2

函数的形参2，函数可以有任意多个形参。

return

后面接函数的返回值，函数的返回值只能有一个，可以是任意的数据类型。

说明

我们定义了一个函数，函数名为 func_name，该函数接受两个参数。接着，我们两次调用了函数 func_name。

第一次调用时，我们通过关键字参数指定形参 param1 对应的实参为 p1，形参 param2 对应的实参为 p2，第二次调用，同样使用关键字参数指定实参和形参的对应关系。

这样，通过关键字参数，形参的顺序就不必跟实参的顺序一样了。

案例

Python函数位置参数

Python函数使用位置参数，则参数顺序和个数必须一一对应

print("嗨客网(www.haicoder.net)")

# Python函数使用位置参数，则参数顺序和个数必须一一对应

def area(a, b, c):

s = (a + b + c) / 2

ret = (s*(s-a)*(s-b)*(s-c)) ** 0.5

return ret

ret = area(3, 4, 5)

print("area =", ret)

程序运行后，控制台输出如下：

我们定义了一个函数 area，该函数传入三个参数 a、b 和 c，该函数实现的是求任意三角形的面积的逻辑，并通过返回值返回求得的面积。

最后，我们调用了 area 函数，并传入了三个参数，使用 ret 变量来接受 area 函数返回的值，最后使用 print 函数打印最后的结果。

因此，我们的函数的形参有三个，且这里使用的是函数的位置参数，因此，我们的实参的顺序和个数必须和形参完全保持一致。

Python函数位置参数

Python函数使用位置参数，如果形参和实数个数不一样，程序报错

print("嗨客网(www.haicoder.net)")

# Python函数使用位置参数，如果形参和实数个数不一样，程序报错

def area(a, b, c):

s = (a + b + c) / 2

ret = (s*(s-a)*(s-b)*(s-c)) ** 0.5

return ret

ret = area(3, 4, 5, 6)

print("area =", ret)

程序运行后，控制台输出如下：

我们定义了一个函数 area，该函数传入三个参数 a、b 和 c，我们在调用该函数时，实参传递了四个，因此，实参和形参的个数不对应，程序报错。

Python函数关键字参数

Python 函数使用位置参数，则参数顺序可以不一致

print("嗨客网(www.haicoder.net)")

# Python函数使用位置参数，则参数顺序可以不一致

def sub(a, b):

return a - b

ret = sub(a = 1024, b = 512)

print("sub =", ret)

ret = sub(b = 512, a = 1024)

print("sub =", ret)

程序运行后，控制台输出如下：

我们定义了一个函数 sub，该函数传入两个参数 a 和 b，该函数实现的是求 a 和 b 的差的逻辑，并通过返回值返回求得的差值。

最后，我们使用了关键字参数的形式，两次调用了 sub 函数，第一次调用时，首先显式指定形参 a 的值为 1024，形参 b 的值为 512，第二次调用时，首先显式指定形参 b 的值为 512，形参 a 的值为 1024。

我们打印两次调用的结果，发现都是一样的正确的结果，因此，使用函数的关键字参数，实参的顺序和形参的顺序不必完全保持一致。

Python函数关键字参数

Python 函数使用位置参数，参数个数必须一致

print("嗨客网(www.haicoder.net)")

# Python函数使用位置参数，参数个数必须一致

def sub(a, b):

return a - b

ret = sub(b = 512)

print("sub =", ret)

程序运行后，控制台输出如下：

我们定义了一个函数 sub，该函数传入两个参数 a 和 b，我们使用位置参数调用该函数时，实参传递了一个，因此，实参和形参的个数不对应，程序报错。

Python函数关键字参数总结

关键字参数，就是我们在函数传递实参时，可以通过参数名指定，我们具体传递的是哪个形参，但关键字参数的实参和形参的个数还必须是一一对应的。Python 函数关键字参数定义：

def func_name(param1, param2):

# 执行语句...

return val

# 调用函数

func_name(param1 = p1, param2 = p2)

func_name(param2 = p2, param1 = p1)

隐式调用中，传参都需要关键字参数
但有时候写成params={‘a’：1，‘b’: 2}
fun(params)

有时候写成fun(params=params)

def __getattr__(self, name):        # 当访问object不存在的属性时会调用该方法，即没有明确定义函数时，去method中寻找隐性调用方法
    def wrapper(*args, **kwargs):
        # 隐式调用全部使用kwargs
        # 处理传来的非关键字参数，直接写params，没写params=params
        if len(args) > 0:       # 处理直接写params
            for arg in args:  # args是元祖
                if isinstance(arg, dict) is not True:
                    print('隐式调用参数有误，非关键字参数')
                kwargs = {**kwargs, **arg}  # 合并字典
        if len(kwargs) > 0:     # 有两种情况，一种是直接params=params 一种是关键字直接写比如instId=BTC-USDT
            for i in kwargs.keys():
                if isinstance(kwargs[i], dict): # 如果关键字传参，参数本身就是字典情况处理
                    kwargs = {**kwargs, **kwargs[i]}.pop(i) # 处理params=params, value中字典放到kwarg，删除params这个item
        # 如果调用方法名称中，不包含async（非异步），用act函数
        return self.act(*args, **kwargs) if name.find('async') < 0 else self.asyncact(*args, **kwargs)
    return wrapper