TL；博士

它将传递给函数的参数分别打包到函数体中的list和dict中。当您这样定义函数签名时：

def func(*args, **kwds):
    # do stuff

它可以用任意数量的参数和关键字参数调用。非关键字参数被打包到函数体内名为args的列表中，关键字参数被包装到函数体内称为kwds的dict中。

func("this", "is a list of", "non-keyowrd", "arguments", keyword="ligma", options=[1,2,3])

现在在函数体内部，当调用函数时，有两个局部变量，args是一个值为[“this”，“is a list of”，“non-keyword”，“arguments”]的列表，kwds是一个具有值为{“keyword”：“ligma”，“options”：[1，2]}的dict

这也反过来起作用，即从呼叫者一侧起。例如，如果函数定义为：

def f(a, b, c, d=1, e=10):
    # do stuff

您可以通过打开调用范围中的可迭代项或映射来调用它：

iterable = [1, 20, 500]
mapping = {"d" : 100, "e": 3}
f(*iterable, **mapping)
# That call is equivalent to
f(1, 20, 500, d=100, e=3)

我想举一个别人没有提到的例子

*也可以打开发电机

Python3文档中的示例

x = [1, 2, 3]
y = [4, 5, 6]

unzip_x, unzip_y = zip(*zip(x, y))

unzip x将为（1，2，3），unzip y将为（4，5，6）

zip（）接收多个iretable参数，并返回一个生成器。

zip(*zip(x,y)) -> zip((1, 4), (2, 5), (3, 6))

还值得注意的是，在调用函数时也可以使用*和**。这是一个快捷方式，允许您直接使用列表/元组或字典将多个参数传递给函数。例如，如果您具有以下功能：

def foo(x,y,z):
    print("x=" + str(x))
    print("y=" + str(y))
    print("z=" + str(z))

您可以执行以下操作：

>>> mylist = [1,2,3]
>>> foo(*mylist)
x=1
y=2
z=3

>>> mydict = {'x':1,'y':2,'z':3}
>>> foo(**mydict)
x=1
y=2
z=3

>>> mytuple = (1, 2, 3)
>>> foo(*mytuple)
x=1
y=2
z=3

注意：mydict中的键必须与函数foo的参数完全相同。否则将抛出TypeError：

>>> mydict = {'x':1,'y':2,'z':3,'badnews':9}
>>> foo(**mydict)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: foo() got an unexpected keyword argument 'badnews'

*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
}

对于那些通过实例学习的人！

*的目的是让您能够定义一个函数，该函数可以接受作为列表提供的任意数量的参数（例如f（*myList））。**的目的是通过提供字典（例如f（**{'x'：1，'y'：2}））来提供函数的参数。

让我们通过定义一个函数来展示这一点，该函数接受两个正常变量x，y，并且可以接受更多的参数作为myArgs，并且可以接收更多的参数为myKW。稍后，我们将展示如何使用myArgDict喂养y。

def f(x, y, *myArgs, **myKW):
    print("# x      = {}".format(x))
    print("# y      = {}".format(y))
    print("# myArgs = {}".format(myArgs))
    print("# myKW   = {}".format(myKW))
    print("# ----------------------------------------------------------------------")

# Define a list for demonstration purposes
myList    = ["Left", "Right", "Up", "Down"]
# Define a dictionary for demonstration purposes
myDict    = {"Wubba": "lubba", "Dub": "dub"}
# Define a dictionary to feed y
myArgDict = {'y': "Why?", 'y0': "Why not?", "q": "Here is a cue!"}

# The 1st elem of myList feeds y
f("myEx", *myList, **myDict)
# x      = myEx
# y      = Left
# myArgs = ('Right', 'Up', 'Down')
# myKW   = {'Wubba': 'lubba', 'Dub': 'dub'}
# ----------------------------------------------------------------------

# y is matched and fed first
# The rest of myArgDict becomes additional arguments feeding myKW
f("myEx", **myArgDict)
# x      = myEx
# y      = Why?
# myArgs = ()
# myKW   = {'y0': 'Why not?', 'q': 'Here is a cue!'}
# ----------------------------------------------------------------------

# The rest of myArgDict becomes additional arguments feeding myArgs
f("myEx", *myArgDict)
# x      = myEx
# y      = y
# myArgs = ('y0', 'q')
# myKW   = {}
# ----------------------------------------------------------------------

# Feed extra arguments manually and append even more from my list
f("myEx", 4, 42, 420, *myList, *myDict, **myDict)
# x      = myEx
# y      = 4
# myArgs = (42, 420, 'Left', 'Right', 'Up', 'Down', 'Wubba', 'Dub')
# myKW   = {'Wubba': 'lubba', 'Dub': 'dub'}
# ----------------------------------------------------------------------

# Without the stars, the entire provided list and dict become x, and y:
f(myList, myDict)
# x      = ['Left', 'Right', 'Up', 'Down']
# y      = {'Wubba': 'lubba', 'Dub': 'dub'}
# myArgs = ()
# myKW   = {}
# ----------------------------------------------------------------------

注意事项

**专为词典保留。非可选参数赋值首先发生。不能两次使用非可选参数。如果适用，**必须始终在*之后。