*args和**kwargs是一种常见的习惯用法，允许任意数量的函数参数，如Python文档中关于定义函数的更多章节所述。

*参数将以元组的形式提供所有函数参数：

def foo(*args):
    for a in args:
        print(a)        

foo(1)
# 1

foo(1,2,3)
# 1
# 2
# 3

**kwargs会给你所有关键字参数，但与作为字典的形式参数相对应的参数除外。

def bar(**kwargs):
    for a in kwargs:
        print(a, kwargs[a])  

bar(name='one', age=27)
# name one
# age 27

这两种习惯用法都可以与普通参数混合使用，以允许使用一组固定参数和一些可变参数：

def foo(kind, *args, **kwargs):
   pass

也可以使用其他方式：

def foo(a, b, c):
    print(a, b, c)

obj = {'b':10, 'c':'lee'}

foo(100,**obj)
# 100 10 lee

*l习惯用法的另一个用法是在调用函数时打开参数列表。

def foo(bar, lee):
    print(bar, lee)

l = [1,2]

foo(*l)
# 1 2

在Python 3中，可以在赋值的左侧使用*l（Extended Iterable Unpacking），尽管它在上下文中给出了一个列表而不是元组：

first, *rest = [1,2,3,4]
first, *l, last = [1,2,3,4]

Python 3还添加了新的语义（参见PEP 3102）：

def func(arg1, arg2, arg3, *, kwarg1, kwarg2):
    pass

例如，以下命令在python 3中有效，但在python 2中无效：

>>> x = [1, 2]
>>> [*x]
[1, 2]
>>> [*x, 3, 4]
[1, 2, 3, 4]

>>> x = {1:1, 2:2}
>>> x
{1: 1, 2: 2}
>>> {**x, 3:3, 4:4}
{1: 1, 2: 2, 3: 3, 4: 4}

这样的函数只接受3个位置参数，*之后的所有参数只能作为关键字参数传递。

注：

语义上用于传递关键字参数的Python dict是任意排序的。然而，在Python 3.6中，关键字参数保证记住插入顺序。“**kwargs中元素的顺序现在对应于关键字参数传递给函数的顺序。”-Python3.6中的新功能事实上，CPython 3.6中的所有dict都将记住插入顺序作为实现细节，这在Python 3.7中成为标准。

def foo（param1，*param2）：是一个可以接受任意数量的*param2值的方法，def bar（param1，**param2）：是一种方法，可以接受任意数量的带有*param2键的值param1是一个简单的参数。

例如，在Java中实现varargs的语法如下：

accessModifier methodName(datatype… arg) {
    // method body
}

从Python文档中：

如果位置参数多于形式参数槽，则会引发TypeError异常，除非存在使用语法“*identifier”的形式参数；在这种情况下，该形参接收包含多余位置参数的元组（如果没有多余位置参数，则为空元组）。如果任何关键字参数与正式参数名称不对应，则会引发TypeError异常，除非存在使用语法“**标识符”的正式参数；在这种情况下，该形参接收包含多余关键字参数的字典（使用关键字作为关键字，将参数值作为对应值），如果没有多余关键字参数，则接收（新的）空字典。

上下文

python 3.x使用打开包装**与字符串格式一起使用

与字符串格式一起使用

除了本主题中的答案之外，还有一个其他地方没有提到的细节。这扩展了Brad Solomon的答案

使用python str.format时，使用**解包也很有用。

这有点类似于使用python f-string f-string所做的操作，但增加了声明dict以保存变量的开销（f-string不需要dict）。

快速示例

  ## init vars
  ddvars = dict()
  ddcalc = dict()
  pass
  ddvars['fname']     = 'Huomer'
  ddvars['lname']     = 'Huimpson'
  ddvars['motto']     = 'I love donuts!'
  ddvars['age']       = 33
  pass
  ddcalc['ydiff']     = 5
  ddcalc['ycalc']     = ddvars['age'] + ddcalc['ydiff']
  pass
  vdemo = []

  ## ********************
  ## single unpack supported in py 2.7
  vdemo.append('''
  Hello {fname} {lname}!

  Today you are {age} years old!

  We love your motto "{motto}" and we agree with you!
  '''.format(**ddvars)) 
  pass

  ## ********************
  ## multiple unpack supported in py 3.x
  vdemo.append('''
  Hello {fname} {lname}!

  In {ydiff} years you will be {ycalc} years old!
  '''.format(**ddvars,**ddcalc)) 
  pass

  ## ********************
  print(vdemo[-1])

根据尼克的回答。。。

def foo(param1, *param2):
    print(param1)
    print(param2)


def bar(param1, **param2):
    print(param1)
    print(param2)


def three_params(param1, *param2, **param3):
    print(param1)
    print(param2)
    print(param3)


foo(1, 2, 3, 4, 5)
print("\n")
bar(1, a=2, b=3)
print("\n")
three_params(1, 2, 3, 4, s=5)

输出：

1
(2, 3, 4, 5)

1
{'a': 2, 'b': 3}

1
(2, 3, 4)
{'s': 5}

基本上，任何数量的位置参数都可以使用*args，任何命名参数（或kwargs又名关键字参数）都可以使用**kwargs。

*表示以元组形式接收变量参数

**表示接收变量参数作为字典

使用方式如下：

1） 单个*

def foo(*args):
    for arg in args:
        print(arg)

foo("two", 3)

输出：

two
3

2） 现在**

def bar(**kwargs):
    for key in kwargs:
        print(key, kwargs[key])

bar(dic1="two", dic2=3)

输出：

dic1 two
dic2 3