除了函数调用之外，*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())

Also, a subclass with a new attribute which makes sense only to that subclass instance can call the Base class __init__ to offload the attributes setting. This is done through *args and **kwargs. kwargs mainly used so that code is readable using named arguments. 例如

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 )

完整的代码是此处

给定一个有3项作为参数的函数

sum = lambda x, y, z: x + y + z
sum(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

想象一下这个玩具有一个三角形、圆形和矩形的袋子。那个包不能直接放进去。你需要打开袋子才能拿下这三件物品，现在它们已经装好了。Python*操作符完成这个解包过程。

*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: animals
Argument in list of arguments from *argv: fish
Argument in list of arguments from *argv: duck
Argument 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.

在函数中同时使用这两种方法的一个很好的例子是：

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

这个例子将帮助您一次记住Python中的*args、**kwargs甚至super和继承。

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


class child1(base): # inherited from base class
    def __init__(self, child_param, *args) # *args for non-keyword args
        self.child_param = child_param
        super(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_param
        super(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 # 0
print c1.child_param # 1
print c2.base_param # 0
print c2.child_param # 1

Context

• python 3.x
• unpacking with **
• use with string formatting

Use with string formatting

除了这个线索中的答案之外，这里还有另一个其他地方没有提到的细节。这扩展了Brad Solomon回答

使用python＜code＞str.format＜/code＞时，使用＜code＞**

这在某种程度上类似于您可以使用pythonf-stringsf-string，但增加了声明一个dict来保存变量的开销（f-string不需要dict）。

Quick Example

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

*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

*参数在类型元组中

def any_param(*param):
    return type(param)

any_param(1) #tuple
any_param() # tuple

对于访问元素，请不要使用*

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

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

**千瓦时

**kwd or **any This is a dict type

def func(**any):
    return type(any) # dict

def func(**any):
    return any

func(width="10",height="20") # {width="10",height="20")

• *args是一个特殊参数，可以将0个或多个（位置）参数作为元组。

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

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

*args:

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

           ↓
def test(*args):
    print(args)

test() # Here
test(1, 2, 3, 4) # Here
test((1, 2, 3, 4)) # Here
test(*(1, 2, 3, 4)) # Here

输出：

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

并且，当打印＜code＞*args＜/code＞时，将打印4个不带括号和逗号的数字：

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

输出：

1 2 3 4

并且，参数具有元组类型：

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)

输出（错误）：

SyntaxError:无效语法

并且，正常参数不能放在*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() # Here
test(name="John", age=27) # Here
test(**{"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具有dict类型：

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)

输出（错误）：

SyntaxError:无效语法

For both *args and **kwargs:

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

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

输出：

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

• def foo(param1, *param2): is a method can accept arbitrary number of values for *param2,
• def bar(param1, **param2): is a method can accept arbitrary number of values with keys for *param2
• param1 is a simple parameter.

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

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

"Infinite" Args with *args and **kwargs

*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 )
!
"""

def foo(x, y, *args):
    pass

def bar(x, y, **kwargs):
    pass

*args

据我所知，*args是一个由逗号、分隔的参数数组，所以如果你想在上面foo，它看起来像

foo("x","y",1,2,3,4,5)

所以如果你跑步

for a in args:
        print(a)  

它将按放置顺序打印参数，如1,2,3。。。

尽管这很容易实现和使用，但参数的顺序在这里很重要。因此，如果第一个参数应该是字符串，第二个参数是整数，如果调用方打乱了顺序，函数就会失败。

**kwargs

这些是关键字参数，它们是一组命名参数，作为键/值对或字典传递，用分隔，如果是多个。因此，对于栏，您可以发送

bar("x", "y", name="vinod",address="bangalore",country="india")

并且可以在函数中单独读取

Name = kwargs[ name ]
Address = kwargs[ address ] 

读取kwargs不需要在循环上枚举，参数的顺序也无关紧要。

最简单的解释是，*是传递元组的*args，**是传递字典的**kwargs。这些只是默认的通用名称。