从Python留档：

如果位置参数多于形式参数槽，则引发TypeError异常，除非存在使用语法“*标识符”的形式参数；在这种情况下，该形式参数接收包含多余位置参数的元组（如果没有多余位置参数，则为空元组）。

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

*args和**kwargs是一个常见的习惯用法，允许任意数量的参数用于Python留档中第2节中描述的函数。

*args将为您提供所有函数参数作为元组：

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，尽管它在这种情况下给出了一个列表而不是元组：

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个位置参数，*之后的所有内容都只能作为关键字参数传递。

备注：

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

单个*表示可以有任意数量的额外位置参数。foo()可以像foo(1,2,3,4,5)一样调用。在foo（）的主体中，参数2是一个包含2-5的序列。

双**表示可以有任意数量的额外命名参数。bar()可以像bar(1, a=2, b=3)一样调用。在bar（）的主体中，Param2是一个包含{'a'： 2，'b'： 3}的字典

使用以下代码：

def foo(param1, *param2):print(param1)print(param2)
def bar(param1, **param2):print(param1)print(param2)
foo(1,2,3,4,5)bar(1,a=2,b=3)

的输出是

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

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

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

你可以这样做：

>>> mylist = [1,2,3]>>> foo(*mylist)x=1y=2z=3
>>> mydict = {'x':1,'y':2,'z':3}>>> foo(**mydict)x=1y=2z=3
>>> mytuple = (1, 2, 3)>>> foo(*mytuple)x=1y=2z=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允许任意数量的可选位置参数（参数），这些参数将被分配给名为args的元组。

**kwargs允许任意数量的可选关键字参数（参数），这些参数将在名为kwargs的字典中。

您可以（也应该）选择任何合适的名称，但如果目的是使参数是非特定语义学的，则args和kwargs是标准名称。

扩展，传递任意数量的参数

您还可以使用*args和**kwargs分别从列表（或任何可迭代对象）和dicts（或任何映射）传入参数。

接收参数的函数不必知道它们正在被扩展。

例如，Python 2的xrange没有明确期望*args，但因为它需要3个整数作为参数：

>>> x = xrange(3) # create our *args - an iterable of 3 integers>>> xrange(*x)    # expand herexrange(0, 2, 2)

再举一个例子，我们可以在str.format中使用字典扩展：

>>> foo = 'FOO'>>> bar = 'BAR'>>> 'this is foo, {foo} and bar, {bar}'.format(**locals())'this is foo, FOO and bar, BAR'

Python 3中的新功能：使用仅关键字参数定义函数

您可以在*args之后有仅关键字参数-例如，在这里，kwarg2必须作为关键字参数给出-而不是位置：

def foo(arg, kwarg=None, *args, kwarg2=None, **kwargs):return arg, kwarg, args, kwarg2, kwargs

用法：

>>> foo(1,2,3,4,5,kwarg2='kwarg2', bar='bar', baz='baz')(1, 2, (3, 4, 5), 'kwarg2', {'bar': 'bar', 'baz': 'baz'})

此外，*可以单独使用以指示仅紧跟关键字参数，而不允许无限的位置参数。

def foo(arg, kwarg=None, *, kwarg2=None, **kwargs):return arg, kwarg, kwarg2, kwargs

这里，kwarg2必须是一个显式命名的关键字参数：

>>> foo(1,2,kwarg2='kwarg2', foo='foo', bar='bar')(1, 2, 'kwarg2', {'foo': 'foo', 'bar': 'bar'})

我们不能再接受无限的位置参数，因为我们没有*args*：

>>> foo(1,2,3,4,5, kwarg2='kwarg2', foo='foo', bar='bar')Traceback (most recent call last):File "<stdin>", line 1, in <module>TypeError: foo() takes from 1 to 2 positional argumentsbut 5 positional arguments (and 1 keyword-only argument) were given

同样，更简单地说，这里我们要求kwarg按名称给出，而不是位置：

def bar(*, kwarg=None):return kwarg

在这个例子中，我们看到如果我们尝试在位置上传递kwarg，我们会得到一个错误：

>>> bar('kwarg')Traceback (most recent call last):File "<stdin>", line 1, in <module>TypeError: bar() takes 0 positional arguments but 1 was given

我们必须显式地将kwarg参数作为关键字参数传递。

>>> bar(kwarg='kwarg')'kwarg'

Python 2兼容演示

*args（通常表示为“star-args”）和**kwargs（可以通过说“kwargs”来暗示星星，但要明确表示“双星kwargs”）是Python使用*和**表示法的常见习语。这些特定的变量名称不是必需的（例如，您可以使用*foos和**bars），但背离惯例可能会激怒您的Python编码人员。

当我们不知道我们的函数将接收什么或我们可能传递多少参数时，我们通常会使用这些，有时即使单独命名每个变量也会变得非常混乱和冗余（但这种情况下通常显式比隐式更好）。

例1

以下函数描述了如何使用它们，并演示了行为。请注意，命名的b参数将被之前的第二个位置参数使用：

def foo(a, b=10, *args, **kwargs):'''this function takes required argument a, not required keyword argument band any number of unknown positional arguments and keyword arguments after'''print('a is a required argument, and its value is {0}'.format(a))print('b not required, its default value is 10, actual value: {0}'.format(b))# we can inspect the unknown arguments we were passed:#  - args:print('args is of type {0} and length {1}'.format(type(args), len(args)))for arg in args:print('unknown arg: {0}'.format(arg))#  - kwargs:print('kwargs is of type {0} and length {1}'.format(type(kwargs),len(kwargs)))for kw, arg in kwargs.items():print('unknown kwarg - kw: {0}, arg: {1}'.format(kw, arg))# But we don't have to know anything about them# to pass them to other functions.print('Args or kwargs can be passed without knowing what they are.')# max can take two or more positional args: max(a, b, c...)print('e.g. max(a, b, *args) \n{0}'.format(max(a, b, *args)))kweg = 'dict({0})'.format( # named args same as unknown kwargs', '.join('{k}={v}'.format(k=k, v=v)for k, v in sorted(kwargs.items())))print('e.g. dict(**kwargs) (same as {kweg}) returns: \n{0}'.format(dict(**kwargs), kweg=kweg))

我们可以查看函数签名的在线帮助，使用help(foo)，它告诉我们

foo(a, b=10, *args, **kwargs)

让我们用foo(1, 2, 3, 4, e=5, f=6, g=7)调用这个函数

其中打印：

a is a required argument, and its value is 1b not required, its default value is 10, actual value: 2args is of type <type 'tuple'> and length 2unknown arg: 3unknown arg: 4kwargs is of type <type 'dict'> and length 3unknown kwarg - kw: e, arg: 5unknown kwarg - kw: g, arg: 7unknown kwarg - kw: f, arg: 6Args or kwargs can be passed without knowing what they are.e.g. max(a, b, *args)4e.g. dict(**kwargs) (same as dict(e=5, f=6, g=7)) returns:{'e': 5, 'g': 7, 'f': 6}

例2

我们也可以使用另一个函数调用它，我们只提供a：

def bar(a):b, c, d, e, f = 2, 3, 4, 5, 6# dumping every local variable into foo as a keyword argument# by expanding the locals dict:foo(**locals())

bar(100)打印：

a is a required argument, and its value is 100b not required, its default value is 10, actual value: 2args is of type <type 'tuple'> and length 0kwargs is of type <type 'dict'> and length 4unknown kwarg - kw: c, arg: 3unknown kwarg - kw: e, arg: 5unknown kwarg - kw: d, arg: 4unknown kwarg - kw: f, arg: 6Args or kwargs can be passed without knowing what they are.e.g. max(a, b, *args)100e.g. dict(**kwargs) (same as dict(c=3, d=4, e=5, f=6)) returns:{'c': 3, 'e': 5, 'd': 4, 'f': 6}

示例3：在装饰器中的实际使用

好的，也许我们还没有看到它的实用程序。假设你有几个函数在微分代码之前和/或之后具有冗余代码。以下命名函数只是用于说明目的的伪代码。

def foo(a, b, c, d=0, e=100):# imagine this is much more code than a simple function callpreprocess()differentiating_process_foo(a,b,c,d,e)# imagine this is much more code than a simple function callpostprocess()
def bar(a, b, c=None, d=0, e=100, f=None):preprocess()differentiating_process_bar(a,b,c,d,e,f)postprocess()
def baz(a, b, c, d, e, f):... and so on

我们也许能够以不同的方式处理这个问题，但我们肯定可以使用装饰器提取冗余，因此我们下面的示例演示了*args和**kwargs如何非常有用：

def decorator(function):'''function to wrap other functions with a pre- and postprocess'''@functools.wraps(function) # applies module, name, and docstring to wrapperdef wrapper(*args, **kwargs):# again, imagine this is complicated, but we only write it once!preprocess()function(*args, **kwargs)postprocess()return wrapper

现在每个包装的函数都可以写得更简洁，因为我们已经排除了冗余：

@decoratordef foo(a, b, c, d=0, e=100):differentiating_process_foo(a,b,c,d,e)
@decoratordef bar(a, b, c=None, d=0, e=100, f=None):differentiating_process_bar(a,b,c,d,e,f)
@decoratordef baz(a, b, c=None, d=0, e=100, f=None, g=None):differentiating_process_baz(a,b,c,d,e,f, g)
@decoratordef quux(a, b, c=None, d=0, e=100, f=None, g=None, h=None):differentiating_process_quux(a,b,c,d,e,f,g,h)

通过分解我们的代码，我们减少了代码行，提高了易读性和可运维性，并为程序中的逻辑提供了唯一的规范位置。如果我们需要更改这个结构的任何部分，我们有一个地方可以进行每次更改。

除了函数调用之外，*args和**kwargs在类层次结构中也很有用，并且还可以避免在Python中编写__init__方法。类似的用法可以在Django代码等框架中看到。

例如，

def __init__(self, *args, **kwargs):for attribute_name, value in zip(self._expected_attributes, args):setattr(self, attribute_name, value)if kwargs.has_key(attribute_name):kwargs.pop(attribute_name)
for attribute_name in kwargs.viewkeys():setattr(self, attribute_name, kwargs[attribute_name])

一个子类可以是

class RetailItem(Item):_expected_attributes = Item._expected_attributes + ['name', 'price', 'category', 'country_of_origin']
class FoodItem(RetailItem):_expected_attributes = RetailItem._expected_attributes +  ['expiry_date']

然后子类被实例化为

food_item = FoodItem(name = 'Jam',price = 12.0,category = 'Foods',country_of_origin = 'US',expiry_date = datetime.datetime.now())

此外，具有仅对该子类实例有意义的新属性的子类可以调用Base类__init__来卸载属性设置。这是通过*args和**kwargs完成的。kwargs主要用于使用命名参数读取代码。例如，

class ElectronicAccessories(RetailItem):_expected_attributes = RetailItem._expected_attributes +  ['specifications']# Depend on args and kwargs to populate the data as needed.def __init__(self, specifications = None, *args, **kwargs):self.specifications = specifications  # Rest of attributes will make sense to parent class.super(ElectronicAccessories, self).__init__(*args, **kwargs)

这可以归结为

usb_key = ElectronicAccessories(name = 'Sandisk',price = '$6.00',category = 'Electronics',country_of_origin = 'CN',specifications = '4GB USB 2.0/USB 3.0')

完整的代码是这里

在Python 3.5中，您还可以在list、dict、tuple和set显示（有时也称为文字）中使用此语法。见PEP 488：额外的拆包概括。

>>> (0, *range(1, 4), 5, *range(6, 8))(0, 1, 2, 3, 5, 6, 7)>>> [0, *range(1, 4), 5, *range(6, 8)][0, 1, 2, 3, 5, 6, 7]>>> {0, *range(1, 4), 5, *range(6, 8)}{0, 1, 2, 3, 5, 6, 7}>>> d = {'one': 1, 'two': 2, 'three': 3}>>> e = {'six': 6, 'seven': 7}>>> {'zero': 0, **d, 'five': 5, **e}{'five': 5, 'seven': 7, 'two': 2, 'one': 1, 'three': 3, 'six': 6, 'zero': 0}

它还允许在单个函数调用中解压缩多个可迭代对象。

>>> range(*[1, 10], *[2])range(1, 10, 2)

（感谢mgilson的PEP链接。

让我们首先了解什么是位置参数和关键字参数。下面是一个函数定义的例子立场论据。

def test(a,b,c):print(a)print(b)print(c)
test(1,2,3)#output:123

所以这是一个带有位置参数的函数定义。您也可以使用关键字/命名参数调用它：

def test(a,b,c):print(a)print(b)print(c)
test(a=1,b=2,c=3)#output:123

现在让我们研究一个使用关键字参数的函数定义示例：

def test(a=0,b=0,c=0):print(a)print(b)print(c)print('-------------------------')
test(a=1,b=2,c=3)#output :123-------------------------

你也可以用位置参数调用这个函数：

def test(a=0,b=0,c=0):print(a)print(b)print(c)print('-------------------------')
test(1,2,3)# output :123---------------------------------

所以我们现在知道带有位置参数和关键字参数的函数定义。

现在让我们研究“*”运算符和“**”运算符。

请注意，这些操作符可用于2个领域：

a）函数调用

b）函数定义

在函数调用。中使用'*'运算符和'**'运算符

让我们直接举一个例子，然后讨论它。

def sum(a,b):  #receive args from function calls as sum(1,2) or sum(a=1,b=2)print(a+b)
my_tuple = (1,2)my_list = [1,2]my_dict = {'a':1,'b':2}
# Let us unpack data structure of list or tuple or dict into arguments with help of '*' operatorsum(*my_tuple)   # becomes same as sum(1,2) after unpacking my_tuple with '*'sum(*my_list)    # becomes same as sum(1,2) after unpacking my_list with  '*'sum(**my_dict)   # becomes same as sum(a=1,b=2) after unpacking by '**'
# output is 3 in all three calls to sum function.

所以记住

当在函数调用中使用“*”或“**”运算符时-

'*'运算符将数据结构（例如列表或元组）解压缩为函数定义所需的参数。

'**'运算符将字典解压缩为函数定义所需的参数。

现在让我们研究函数定义中的'*'运算符用法。示例：

def sum(*args): #pack the received positional args into data structure of tuple. after applying '*' - def sum((1,2,3,4))sum = 0for a in args:sum+=aprint(sum)
sum(1,2,3,4)  #positional args sent to function sum#output:10

在函数定义中，“*”运算符将接收到的参数打包成一个元组。

现在让我们看看函数定义中使用的'**'示例：

def sum(**args): #pack keyword args into datastructure of dict after applying '**' - def sum({a:1,b:2,c:3,d:4})sum=0for k,v in args.items():sum+=vprint(sum)
sum(a=1,b=2,c=3,d=4) #positional args sent to function sum

在函数定义中，'**'运算符将接收到的参数打包到字典中。

所以记住：

在函数调用中，元组或列表的'*'拆开包装数据结构转换为位置或关键字参数，以通过函数定义接收。

在函数调用中，字典的 '**' 拆开包装数据结构转换为位置参数或关键字参数，以通过函数定义接收。

在函数定义中，将'*'包位置参数转换为元组。

在函数定义中， '**' 包个关键字参数到字典中。

在函数中使用两者的一个很好的例子是：

>>> def foo(*arg,**kwargs):...     print arg...     print kwargs>>>>>> a = (1, 2, 3)>>> b = {'aa': 11, 'bb': 22}>>>>>>>>> foo(*a,**b)(1, 2, 3){'aa': 11, 'bb': 22}>>>>>>>>> foo(a,**b)((1, 2, 3),){'aa': 11, 'bb': 22}>>>>>>>>> foo(a,b)((1, 2, 3), {'aa': 11, 'bb': 22}){}>>>>>>>>> foo(a,*b)((1, 2, 3), 'aa', 'bb'){}

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

*也可以解压发生器

来自Python3 Document的示例

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))

这个例子可以帮助你一次性记住*args、**kwargs甚至super以及Python中的继承。

class base(object):def __init__(self, base_param):self.base_param = base_param

class child1(base): # inherited from base classdef __init__(self, child_param, *args) # *args for non-keyword argsself.child_param = child_paramsuper(child1, self).__init__(*args) # call __init__ of the base class and initialize it with a NON-KEYWORD arg
class child2(base):def __init__(self, child_param, **kwargs):self.child_param = child_paramsuper(child2, self).__init__(**kwargs) # call __init__ of the base class and initialize it with a KEYWORD arg
c1 = child1(1,0)c2 = child2(1,base_param=0)print c1.base_param # 0print c1.child_param # 1print c2.base_param # 0print c2.child_param # 1

这个表对于在函数建筑和函数打电话中使用*和**很方便：

            In function construction         In function call=======================================================================|  def f(*args):                 |  def f(a, b):*args     |      for arg in args:          |      return a + b|          print(arg)            |  args = (1, 2)|  f(1, 2)                       |  f(*args)----------|--------------------------------|---------------------------|  def f(a, b):                  |  def f(a, b):**kwargs  |      return a + b              |      return a + b|  def g(**kwargs):              |  kwargs = dict(a=1, b=2)|      return f(**kwargs)        |  f(**kwargs)|  g(a=1, b=2)                   |-----------------------------------------------------------------------

这真的只是总结了洛林·霍奇斯坦的回答，但我发现它很有帮助。

相关：在Python 3中使用star/spat运算符已扩大

*args和**kwargs：允许您向函数传递可变数量的参数。

*args：用于向函数发送非关键字可变长度参数列表：

def args(normal_arg, *argv):print("normal argument:", normal_arg)
for arg in argv:print("Argument in list of arguments from *argv:", arg)
args('animals', 'fish', 'duck', 'bird')

将产生：

normal argument: animalsArgument in list of arguments from *argv: fishArgument in list of arguments from *argv: duckArgument in list of arguments from *argv: bird

**kwargs*

**kwargs允许您将关键字可变长度的参数传递给函数。如果您想处理函数中的命名参数，您应该使用**kwargs。

def who(**kwargs):if kwargs is not None:for key, value in kwargs.items():print("Your %s is %s." % (key, value))
who(name="Nikola", last_name="Tesla", birthday="7.10.1856", birthplace="Croatia")

将产生：

Your name is Nikola.Your last_name is Tesla.Your birthday is 7.10.1856.Your birthplace is Croatia.

对于那些通过例子学习的人来说！

1. *的目的是让您能够定义一个函数，该函数可以采用作为列表提供的任意数量的参数（例如f(*myList)）。
2. **的目的是让您能够通过提供字典（例如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 purposesmyList    = ["Left", "Right", "Up", "Down"]# Define a dictionary for demonstration purposesmyDict    = {"Wubba": "lubba", "Dub": "dub"}# Define a dictionary to feed ymyArgDict = {'y': "Why?", 'y0': "Why not?", "q": "Here is a cue!"}
# The 1st elem of myList feeds yf("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 myKWf("myEx", **myArgDict)# x      = myEx# y      = Why?# myArgs = ()# myKW   = {'y0': 'Why not?', 'q': 'Here is a cue!'}# ----------------------------------------------------------------------
# The rest of myArgDict becomes additional arguments feeding myArgsf("myEx", *myArgDict)# x      = myEx# y      = y# myArgs = ('y0', 'q')# myKW   = {}# ----------------------------------------------------------------------
# Feed extra arguments manually and append even more from my listf("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   = {}# ----------------------------------------------------------------------

警告

1. **是专门为字典保留的。
2. 非可选参数赋值首先发生。
3. 您不能两次使用非可选参数。
4. 如果适用，**必须始终在*之后。

*表示将变量参数作为元组接收

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

像下面这样使用：

1）单身*

def foo(*args):for arg in args:print(arg)
foo("two", 3)

输出：

two3

2）现在**

def bar(**kwargs):for key in kwargs:print(key, kwargs[key])
bar(dic1="two", dic2=3)

输出：

dic1 twodic2 3

• def foo(param1, *param2):是一个方法，可以接受*param2的任意数量的值，
• def bar(param1, **param2):是一个方法，可以接受*param2键的任意数量的值
• param1是一个简单的参数。

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

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

太长别读

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

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

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

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,3]}的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 tof(1, 20, 500, d=100, e=3)

基于Nickd的回答…

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。

背景

• python3. x
• 解压**
• 使用字符串格式

与字符串格式一起使用

除了这个线程中的答案之外，这里还有另一个在其他地方没有提到的细节。

使用**解包在使用pythonstr.format时也很有用。

这有点类似于你可以用pythonf-stringsf字串做的事情，但会增加声明一个字典来保存变量的开销（f-string不需要字典）。

快速示例

  ## init varsddvars = dict()ddcalc = dict()passddvars['fname']     = 'Huomer'ddvars['lname']     = 'Huimpson'ddvars['motto']     = 'I love donuts!'ddvars['age']       = 33passddcalc['ydiff']     = 5ddcalc['ycalc']     = ddvars['age'] + ddcalc['ydiff']passvdemo = []
## ********************## single unpack supported in py 2.7vdemo.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.xvdemo.append('''Hello {fname} {lname}!
In {ydiff} years you will be {ycalc} years old!'''.format(**ddvars,**ddcalc))pass
## ********************print(vdemo[-1])

太长别读

以下是Python编程中*和**的6个不同用例：

1. 要使用#0接受任意数量的位置参数：def foo(*args): pass，这里foo接受任意数量的位置参数，即以下调用有效foo(1)、foo(1, 'bar')
2. 要使用#0接受任意数量的关键字参数：def foo(**kwargs): pass，这里'foo'接受任意数量的关键字参数，即以下调用有效foo(name='Tom')、foo(name='Tom', age=33)
3. 要使用#0接受任意数量的位置和关键字参数：def foo(*args, **kwargs): pass，这里foo接受任意数量的位置和关键字参数，即以下调用有效foo(1,name='Tom')，foo(1, 'bar', name='Tom', age=33)
4. 要使用#0强制执行仅关键字参数：def foo(pos1, pos2, *, kwarg1): pass，这里*表示foo只接受pos2之后的关键字参数，因此foo(1, 2, 3)引发TypeError，但foo(1, 2, kwarg1=3)没问题。
5. 为了表达对更多位置参数的兴趣，使用#0（注意：这只是一个约定）：def foo(bar, baz, *_): pass意味着（按照惯例）foo在工作中只使用bar和baz参数，并且会忽略其他参数。
6. 使用#0表示对更多关键字参数没有进一步的兴趣（注意：这只是一个约定）：def foo(bar, baz, **_): pass意味着（按照惯例）foo在工作中只使用bar和baz参数，并且会忽略其他参数。

奖金：从python 3.8开始，可以在函数定义中使用/来强制执行仅位置参数。在以下示例中，参数a和b是纯仓位，而c或d可以是位置或关键字，e或f必须是关键字：

def f(a, b, /, c, d, *, e, f):pass

奖金2：这个答案对同一个问题也带来了一个新的视角，它分享了*和**在function call、functions signature、for loops等中的含义。

给定一个有3个参数的函数

sum = lambda x, y, z: x + y + zsum(1,2,3) # sum 3 items
sum([1,2,3]) # error, needs 3 items, not 1 list
x = [1,2,3][0]y = [1,2,3][1]z = [1,2,3][2]sum(x,y,z) # ok
sum(*[1,2,3]) # ok, 1 list becomes 3 items

想象一下这个玩具有一个三角形、一个圆形和一个矩形物品的袋子。那个袋子不能直接装进去。你需要打开袋子来拿走这3件物品，现在它们合适了。Python*运算符执行此解包过程。

*args（或*any）表示每个参数

def any_param(*param):pass
any_param(1)any_param(1,1)any_param(1,1,1)any_param(1,...)

通知：您不能将参数传递给*args

def any_param(*param):pass
any_param() # will work correct

*args在元组类型中

def any_param(*param):return type(param)
any_param(1) #tupleany_param() # tuple

用于访问不使用*的元素

def any(*param):param[0] # correct
def any(*param):*param[0] # incorrect

**kwd

**kwd或**any这是一个字典类型

def func(**any):return type(any) # dict
def func(**any):return any
func(width="10",height="20") # {width="10",height="20")

带有*args和**kwargs的“无限”Args

*args和**kwargs只是向函数输入无限字符的某种方式，例如：

def print_all(*args, **kwargs):print(args) # print any number of arguments like: "print_all("foo", "bar")"print(kwargs.get("to_print")) # print the value of the keyworded argument "to_print"

# example:print_all("Hello", "World", to_print="!")# will print:"""('Hello', 'World')!"""

• #0是可以将0个或多个（位置）参数作为元组的特殊参数。

• #0是一个特殊参数，它可以将0个或多个（关键字）参数作为字典。

*在Python中，有2种参数位置论证和关键字论证：

*args：

例如，*args可以将0个或多个参数作为元组，如下所示：

           ↓def test(*args):print(args)
test() # Heretest(1, 2, 3, 4) # Heretest((1, 2, 3, 4)) # Heretest(*(1, 2, 3, 4)) # Here

输出：

()(1, 2, 3, 4)((1, 2, 3, 4),)(1, 2, 3, 4)

并且，当打印*args时，打印4个数字，没有括号和逗号：

def test(*args):print(*args) # Here 
test(1, 2, 3, 4)

输出：

1 2 3 4

并且，args具有元组类型：

def test(*args):print(type(args)) # Here 
test(1, 2, 3, 4)

输出：

<class 'tuple'>

但是，*args没有类型：

def test(*args):print(type(*args)) # Here 
test(1, 2, 3, 4)

输出（错误）：

TypeError：type（）接受1或3个参数

并且，正常参数可以放在*args之前，如下所示：

          ↓     ↓def test(num1, num2, *args):print(num1, num2, args)    
test(1, 2, 3, 4)

输出：

1 2 (3, 4)

但是，**kwargs不能放在*args之前，如下所示：

             ↓def test(**kwargs, *args):print(kwargs, args)    
test(num1=1, num2=2, 3, 4)

输出（错误）：

语法错误：语法无效

并且，正常参数不能放在*args之后，如下所示：

                 ↓     ↓def test(*args, num1, num2):print(args, num1, num2)    
test(1, 2, 3, 4)

输出（错误）：

TypeError：test（）缺少2个必需的仅关键字参数：'num1'和'num2'

但是，如果正常参数具有默认值，则可以将它们放在*args之后，如下所示：

                      ↓         ↓def test(*args, num1=100, num2=None):print(args, num1, num2)    
test(1, 2, num1=3, num2=4)

输出：

(1, 2) 3 4

此外，**kwargs可以放在*args之后，如下所示：

                    ↓def test(*args, **kwargs):print(args, kwargs)    
test(1, 2, num1=3, num2=4)

输出：

(1, 2) {'num1': 3, 'num2': 4}

**kwargs：

例如，**kwargs可以将0个或多个参数作为字典，如下所示：

             ↓def test(**kwargs):print(kwargs)
test() # Heretest(name="John", age=27) # Heretest(**{"name": "John", "age": 27}) # Here

输出：

{}{'name': 'John', 'age': 27}{'name': 'John', 'age': 27}

并且，当打印*kwargs时，打印2个键：

def test(**kwargs):print(*kwargs) # Here 
test(name="John", age=27)

输出：

name age

并且，kwargs具有字典类型：

def test(**kwargs):print(type(kwargs)) # Here 
test(name="John", age=27)

输出：

<class 'dict'>

但是，*kwargs和**kwargs没有类型：

def test(**kwargs):print(type(*kwargs)) # Here 
test(name="John", age=27)

def test(**kwargs):print(type(**kwargs)) # Here 
test(name="John", age=27)

输出（错误）：

TypeError：type（）接受1或3个参数

并且，正常参数可以放在**kwargs之前，如下所示：

          ↓     ↓def test(num1, num2, **kwargs):print(num1, num2, kwargs)
test(1, 2, name="John", age=27)

输出：

1 2 {'name': 'John', 'age': 27}

而且，*args可以放在**kwargs之前，如下所示：

           ↓def test(*args, **kwargs):print(args, kwargs)
test(1, 2, name="John", age=27)

输出：

(1, 2) {'name': 'John', 'age': 27}

并且，正常参数和*args不能放在**kwargs之后，如下所示：

                    ↓     ↓def test(**kwargs, num1, num2):print(kwargs, num1, num2)
test(name="John", age=27, 1, 2)

                     ↓def test(**kwargs, *args):print(kwargs, args)
test(name="John", age=27, 1, 2)

输出（错误）：

语法错误：语法无效

对于*args和**kwargs：

实际上，您可以为*args和**kwargs使用其他名称，如下所示。

            ↓        ↓def test(*banana, **orange):print(banana, orange)    
test(1, 2, num1=3, num2=4)

输出：

(1, 2) {'num1': 3, 'num2': 4}