问题：**（双星号/星号）和*（星号/星号）对参数有什么作用？
在以下方法定义中，*和**做param2什么？
def foo(param1, *param2):
def bar(param1, **param2):
In the following method definitions, what does the * and ** do for param2?
def foo(param1, *param2):
def bar(param1, **param2):
回答 0
的*args和**kwargs是一种常见的成语，以允许参数，以作为部分所述功能的任意数量的多个上定义函数 Python文档英寸
该*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)
# age 27
# name one
这两个习惯用法都可以与普通参数混合使用，以允许使用一组固定参数和一些可变参数：
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
该函数仅接受3个位置参数，之后的所有内容*只能作为关键字参数传递。
The *args and **kwargs is a common idiom to allow arbitrary number of arguments to functions as described in the section more on defining functions in the Python documentation.
The *args will give you all function parameters as a tuple:
def foo(*args):
for a in args:
print(a)
foo(1)
# 1
foo(1,2,3)
# 1
# 2
# 3
The **kwargs will give you all
keyword arguments except for those corresponding to a formal parameter as a dictionary.
def bar(**kwargs):
for a in kwargs:
print(a, kwargs[a])
bar(name='one', age=27)
# age 27
# name one
Both idioms can be mixed with normal arguments to allow a set of fixed and some variable arguments:
def foo(kind, *args, **kwargs):
pass
It is also possible to use this the other way around:
def foo(a, b, c):
print(a, b, c)
obj = {'b':10, 'c':'lee'}
foo(100,**obj)
# 100 10 lee
Another usage of the *l idiom is to unpack argument lists when calling a function.
def foo(bar, lee):
print(bar, lee)
l = [1,2]
foo(*l)
# 1 2
In Python 3 it is possible to use *l on the left side of an assignment (Extended Iterable Unpacking), though it gives a list instead of a tuple in this context:
first, *rest = [1,2,3,4]
first, *l, last = [1,2,3,4]
Also Python 3 adds new semantic (refer PEP 3102):
def func(arg1, arg2, arg3, *, kwarg1, kwarg2):
pass
Such function accepts only 3 positional arguments, and everything after * can only be passed as keyword arguments.
回答 1
另外值得一提的是，你可以使用*和**调用功能，以及时。这是一个快捷方式，允许您使用列表/元组或字典将多个参数直接传递给函数。例如，如果您具有以下功能：
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必须完全像function参数一样命名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'
It’s also worth noting that you can use * and ** when calling functions as well. This is a shortcut that allows you to pass multiple arguments to a function directly using either a list/tuple or a dictionary. For example, if you have the following function:
def foo(x,y,z):
print("x=" + str(x))
print("y=" + str(y))
print("z=" + str(z))
You can do things like:
>>> 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
Note: The keys in mydict have to be named exactly like the parameters of function foo. Otherwise it will throw a 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'
回答 2
单个*表示可以有任意数量的额外位置参数。foo()可以像这样调用foo(1,2,3,4,5)。在foo（）主体中，param2是一个包含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}
The single * means that there can be any number of extra positional arguments. foo() can be invoked like foo(1,2,3,4,5). In the body of foo() param2 is a sequence containing 2-5.
The double ** means there can be any number of extra named parameters. bar() can be invoked like bar(1, a=2, b=3). In the body of bar() param2 is a dictionary containing {‘a’:2, ‘b’:3 }
With the following code:
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)
the output is
1
(2, 3, 4, 5)
1
{'a': 2, 'b': 3}
回答 3
这是什么**（双星）和*（明星）的参数做
它们允许定义函数以接受并允许用户传递任意数量的参数，位置（*）和关键字（**）。
定义功能
*args允许任意数量的可选位置参数（参数），这些参数将分配给名为的元组args。
**kwargs允许任意数量的可选关键字参数（参数），这些参数将位于名为的字典中kwargs。
您可以（并且应该）选择任何适当的名称，但是如果目的是使参数具有非特定的语义，args并且kwargs是标准名称。
扩展，传递任意数量的参数
您还可以分别使用*args和**kwargs传入列表（或任何可迭代的）和字典（或任何映射）的参数。
接收参数的函数不必知道它们正在扩展。
例如，Python 2的xrange并不明确期望*args，但是因为它使用3个整数作为参数：
>>> x = xrange(3) # create our *args - an iterable of 3 integers
>>> xrange(*x) # expand here
xrange(0, 2, 2)
再举一个例子，我们可以在下面使用dict扩展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 arguments
but 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”来暗示星号，但是用“ double-star kwargs”来明确表示）是使用*和**表示法的Python的常见用法。这些特定的变量名称不是必需的（例如，您可以使用*foos和**bars），但是背离约定可能会激怒您的Python编码人员。
当我们不知道函数将要接收什么或我们可能传递多少个参数时，我们通常会使用它们，有时甚至即使分别命名每个变量也会变得非常混乱和多余（但这是通常显式的情况比隐式更好）。
例子1
以下功能描述了如何使用它们，并演示了行为。请注意，命名b参数将由前面的第二个位置参数使用：
def foo(a, b=10, *args, **kwargs):
'''
this function takes required argument a, not required keyword argument b
and 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 1
b not required, its default value is 10, actual value: 2
args is of type <type 'tuple'> and length 2
unknown arg: 3
unknown arg: 4
kwargs is of type <type 'dict'> and length 3
unknown kwarg - kw: e, arg: 5
unknown kwarg - kw: g, arg: 7
unknown kwarg - kw: f, arg: 6
Args or kwargs can be passed without knowing what they are.
e.g. max(a, b, *args)
4
e.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 100
b not required, its default value is 10, actual value: 2
args is of type <type 'tuple'> and length 0
kwargs is of type <type 'dict'> and length 4
unknown kwarg - kw: c, arg: 3
unknown kwarg - kw: e, arg: 5
unknown kwarg - kw: d, arg: 4
unknown kwarg - kw: f, arg: 6
Args or kwargs can be passed without knowing what they are.
e.g. max(a, b, *args)
100
e.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 call
preprocess()
differentiating_process_foo(a,b,c,d,e)
# imagine this is much more code than a simple function call
postprocess()
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 wrapper
def wrapper(*args, **kwargs):
# again, imagine this is complicated, but we only write it once!
preprocess()
function(*args, **kwargs)
postprocess()
return wrapper
现在，由于我们考虑了冗余性，每个包装函数都可以更加简洁地编写：
@decorator
def foo(a, b, c, d=0, e=100):
differentiating_process_foo(a,b,c,d,e)
@decorator
def bar(a, b, c=None, d=0, e=100, f=None):
differentiating_process_bar(a,b,c,d,e,f)
@decorator
def baz(a, b, c=None, d=0, e=100, f=None, g=None):
differentiating_process_baz(a,b,c,d,e,f, g)
@decorator
def 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允许我们这样做的代码，我们减少了代码行，提高了可读性和可维护性，并且在程序中具有唯一的规范逻辑位置。如果需要更改此结构的任何部分，则可以在一个位置进行每次更改。
What does ** (double star) and * (star) do for parameters
They allow for functions to be defined to accept and for users to pass any number of arguments, positional (*) and keyword (**).
Defining Functions
*args allows for any number of optional positional arguments (parameters), which will be assigned to a tuple named args.
**kwargs allows for any number of optional keyword arguments (parameters), which will be in a dict named kwargs.
You can (and should) choose any appropriate name, but if the intention is for the arguments to be of non-specific semantics, args and kwargs are standard names.
Expansion, Passing any number of arguments
You can also use *args and **kwargs to pass in parameters from lists (or any iterable) and dicts (or any mapping), respectively.
The function recieving the parameters does not have to know that they are being expanded.
For example, Python 2’s xrange does not explicitly expect *args, but since it takes 3 integers as arguments:
>>> x = xrange(3) # create our *args - an iterable of 3 integers
>>> xrange(*x) # expand here
xrange(0, 2, 2)
As another example, we can use dict expansion in str.format:
>>> foo = 'FOO'
>>> bar = 'BAR'
>>> 'this is foo, {foo} and bar, {bar}'.format(**locals())
'this is foo, FOO and bar, BAR'
New in Python 3: Defining functions with keyword only arguments
You can have keyword only arguments after the *args – for example, here, kwarg2 must be given as a keyword argument – not positionally:
def foo(arg, kwarg=None, *args, kwarg2=None, **kwargs):
return arg, kwarg, args, kwarg2, kwargs
Usage:
>>> foo(1,2,3,4,5,kwarg2='kwarg2', bar='bar', baz='baz')
(1, 2, (3, 4, 5), 'kwarg2', {'bar': 'bar', 'baz': 'baz'})
Also, * can be used by itself to indicate that keyword only arguments follow, without allowing for unlimited positional arguments.
def foo(arg, kwarg=None, *, kwarg2=None, **kwargs):
return arg, kwarg, kwarg2, kwargs
Here, kwarg2 again must be an explicitly named, keyword argument:
>>> foo(1,2,kwarg2='kwarg2', foo='foo', bar='bar')
(1, 2, 'kwarg2', {'foo': 'foo', 'bar': 'bar'})
And we can no longer accept unlimited positional arguments because we don’t have *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 arguments
but 5 positional arguments (and 1 keyword-only argument) were given
Again, more simply, here we require kwarg to be given by name, not positionally:
def bar(*, kwarg=None):
return kwarg
In this example, we see that if we try to pass kwarg positionally, we get an error:
>>> bar('kwarg')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: bar() takes 0 positional arguments but 1 was given
We must explicitly pass the kwarg parameter as a keyword argument.
>>> bar(kwarg='kwarg')
'kwarg'
Python 2 compatible demos
*args (typically said “star-args”) and **kwargs (stars can be implied by saying “kwargs”, but be explicit with “double-star kwargs”) are common idioms of Python for using the * and ** notation. These specific variable names aren’t required (e.g. you could use *foos and **bars), but a departure from convention is likely to enrage your fellow Python coders.
We typically use these when we don’t know what our function is going to receive or how many arguments we may be passing, and sometimes even when naming every variable separately would get very messy and redundant (but this is a case where usually explicit is better than implicit).
Example 1
The following function describes how they can be used, and demonstrates behavior. Note the named b argument will be consumed by the second positional argument before :
def foo(a, b=10, *args, **kwargs):
'''
this function takes required argument a, not required keyword argument b
and 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))
We can check the online help for the function’s signature, with help(foo), which tells us
foo(a, b=10, *args, **kwargs)
Let’s call this function with foo(1, 2, 3, 4, e=5, f=6, g=7)
which prints:
a is a required argument, and its value is 1
b not required, its default value is 10, actual value: 2
args is of type <type 'tuple'> and length 2
unknown arg: 3
unknown arg: 4
kwargs is of type <type 'dict'> and length 3
unknown kwarg - kw: e, arg: 5
unknown kwarg - kw: g, arg: 7
unknown kwarg - kw: f, arg: 6
Args or kwargs can be passed without knowing what they are.
e.g. max(a, b, *args)
4
e.g. dict(**kwargs) (same as dict(e=5, f=6, g=7)) returns:
{'e': 5, 'g': 7, 'f': 6}
Example 2
We can also call it using another function, into which we just provide 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) prints:
a is a required argument, and its value is 100
b not required, its default value is 10, actual value: 2
args is of type <type 'tuple'> and length 0
kwargs is of type <type 'dict'> and length 4
unknown kwarg - kw: c, arg: 3
unknown kwarg - kw: e, arg: 5
unknown kwarg - kw: d, arg: 4
unknown kwarg - kw: f, arg: 6
Args or kwargs can be passed without knowing what they are.
e.g. max(a, b, *args)
100
e.g. dict(**kwargs) (same as dict(c=3, d=4, e=5, f=6)) returns:
{'c': 3, 'e': 5, 'd': 4, 'f': 6}
Example 3: practical usage in decorators
OK, so maybe we’re not seeing the utility yet. So imagine you have several functions with redundant code before and/or after the differentiating code. The following named functions are just pseudo-code for illustrative purposes.
def foo(a, b, c, d=0, e=100):
# imagine this is much more code than a simple function call
preprocess()
differentiating_process_foo(a,b,c,d,e)
# imagine this is much more code than a simple function call
postprocess()
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
We might be able to handle this differently, but we can certainly extract the redundancy with a decorator, and so our below example demonstrates how *args and **kwargs can be very useful:
def decorator(function):
'''function to wrap other functions with a pre- and postprocess'''
@functools.wraps(function) # applies module, name, and docstring to wrapper
def wrapper(*args, **kwargs):
# again, imagine this is complicated, but we only write it once!
preprocess()
function(*args, **kwargs)
postprocess()
return wrapper
And now every wrapped function can be written much more succinctly, as we’ve factored out the redundancy:
@decorator
def foo(a, b, c, d=0, e=100):
differentiating_process_foo(a,b,c,d,e)
@decorator
def bar(a, b, c=None, d=0, e=100, f=None):
differentiating_process_bar(a,b,c,d,e,f)
@decorator
def baz(a, b, c=None, d=0, e=100, f=None, g=None):
differentiating_process_baz(a,b,c,d,e,f, g)
@decorator
def 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)
And by factoring out our code, which *args and **kwargs allows us to do, we reduce lines of code, improve readability and maintainability, and have sole canonical locations for the logic in our program. If we need to change any part of this structure, we have one place in which to make each change.
回答 4
首先让我们了解什么是位置参数和关键字参数。下面是带有位置参数的函数定义的示例。
def test(a,b,c):
print(a)
print(b)
print(c)
test(1,2,3)
#output:
1
2
3
因此，这是带有位置参数的函数定义。您也可以使用关键字/命名参数来调用它：
def test(a,b,c):
print(a)
print(b)
print(c)
test(a=1,b=2,c=3)
#output:
1
2
3
现在让我们研究一个带有关键字参数的函数定义示例：
def test(a=0,b=0,c=0):
print(a)
print(b)
print(c)
print('-------------------------')
test(a=1,b=2,c=3)
#output :
1
2
3
-------------------------
您也可以使用位置参数调用此函数：
def test(a=0,b=0,c=0):
print(a)
print(b)
print(c)
print('-------------------------')
test(1,2,3)
# output :
1
2
3
---------------------------------
因此，我们现在知道带有位置参数以及关键字参数的函数定义。
现在让我们研究“ *”运算符和“ **”运算符。
请注意，这些运算符可以在两个区域中使用：
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 '*' operator
sum(*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 = 0
for a in args:
sum+=a
print(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=0
for k,v in args.items():
sum+=v
print(sum)
sum(a=1,b=2,c=3,d=4) #positional args sent to function sum
在函数定义中，“ **”运算符将接收到的参数打包到字典中。
因此请记住：
在函数调用中，“ *” 将元组或列表的数据结构解压缩为位置或关键字参数，以供函数定义接收。
在函数调用中，“ **” 将字典的数据结构解压缩为位置或关键字参数，以供函数定义接收。
在函数定义中，“ *” 将位置参数打包到元组中。
在函数定义中，“ **” 将关键字参数打包到字典中。
Let us first understand what are positional arguments and keyword arguments.
Below is an example of function definition with Positional arguments.
def test(a,b,c):
print(a)
print(b)
print(c)
test(1,2,3)
#output:
1
2
3
So this is a function definition with positional arguments.
You can call it with keyword/named arguments as well:
def test(a,b,c):
print(a)
print(b)
print(c)
test(a=1,b=2,c=3)
#output:
1
2
3
Now let us study an example of function definition with keyword arguments:
def test(a=0,b=0,c=0):
print(a)
print(b)
print(c)
print('-------------------------')
test(a=1,b=2,c=3)
#output :
1
2
3
-------------------------
You can call this function with positional arguments as well:
def test(a=0,b=0,c=0):
print(a)
print(b)
print(c)
print('-------------------------')
test(1,2,3)
# output :
1
2
3
---------------------------------
So we now know function definitions with positional as well as keyword arguments.
Now let us study the ‘*’ operator and ‘**’ operator.
Please note these operators can be used in 2 areas:
a) function call
b) function definition
The use of ‘*’ operator and ‘**’ operator in function call.
Let us get straight to an example and then discuss it.
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 '*' operator
sum(*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.
So remember
when the ‘*’ or ‘**’ operator is used in a function call –
‘*’ operator unpacks data structure such as a list or tuple into arguments needed by function definition.
‘**’ operator unpacks a dictionary into arguments needed by function definition.
Now let us study the ‘*’ operator use in function definition.
Example:
def sum(*args): #pack the received positional args into data structure of tuple. after applying '*' - def sum((1,2,3,4))
sum = 0
for a in args:
sum+=a
print(sum)
sum(1,2,3,4) #positional args sent to function sum
#output:
10
In function definition the ‘*’ operator packs the received arguments into a tuple.
Now let us see an example of ‘**’ used in function definition:
def sum(**args): #pack keyword args into datastructure of dict after applying '**' - def sum({a:1,b:2,c:3,d:4})
sum=0
for k,v in args.items():
sum+=v
print(sum)
sum(a=1,b=2,c=3,d=4) #positional args sent to function sum
In function definition The ‘**’ operator packs the received arguments into a dictionary.
So remember:
In a function call the ‘*’ unpacks data structure of tuple or list into positional or keyword arguments to be received by function definition.
In a function call the ‘**’ unpacks data structure of dictionary into positional or keyword arguments to be received by function definition.
In a function definition the ‘*’ packs positional arguments into a tuple.
In a function definition the ‘**’ packs keyword arguments into a dictionary.
回答 5
该表非常适合在函数构造和函数调用中使用*和使用：**
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) |
-----------------------------------------------------------------------
这实际上只是用来总结Lorin Hochstein的答案，但我发现它很有帮助。
相关：在Python 3中已扩展了star / splat运算符的用法
This table is handy for using * and ** in function construction and function call:
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) |
-----------------------------------------------------------------------
This really just serves to summarize Lorin Hochstein’s answer but I find it helpful.
Relatedly: uses for the star/splat operators have been expanded in Python 3
回答 6
*并**在函数参数列表中有特殊用法。*
表示该参数是一个列表，并且**表示该参数是一个字典。这允许函数接受任意数量的参数
* and ** have special usage in the function argument list. *
implies that the argument is a list and ** implies that the argument
is a dictionary. This allows functions to take arbitrary number of
arguments
回答 7
对于那些通过榜样学习的人！
- 的目的
* 是使您能够定义一个函数，该函数可以采用以列表形式提供的任意数量的参数（例如f(*myList)）。
- 目的
**是通过提供字典（例如f(**{'x' : 1, 'y' : 2})）使您能够输入函数的参数。
就让我们一起来通过定义一个函数，它有两个正常的变量x，y以及可以接受更多的论据myArgs，并能接受更多的论据myKW。稍后，我们将展示如何y使用进行订阅myArgDict。
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 = {}
# ----------------------------------------------------------------------
注意事项
** 专为字典保留。- 非可选参数分配首先发生。
- 您不能两次使用非可选参数。
- 如果适用，
**必须*始终紧随其后。
For those of you who learn by examples!
- The purpose of
* is to give you the ability to define a function that can take an arbitrary number of arguments provided as a list (e.g. f(*myList) ).
- The purpose of
** is to give you the ability to feed a function’s arguments by providing a dictionary (e.g. f(**{'x' : 1, 'y' : 2}) ).
Let us show this by defining a function that takes two normal variables x, y, and can accept more arguments as myArgs, and can accept even more arguments as myKW. Later, we will show how to feed y using myArgDict.
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 = {}
# ----------------------------------------------------------------------
Caveats
** is exclusively reserved for dictionaries.- Non-optional argument assignment happens first.
- You cannot use a non-optional argument twice.
- If applicable,
** must come after *, always.
回答 8
从Python文档中：
如果位置参数多于形式参数槽，则将引发TypeError异常，除非存在使用语法“ * identifier”的形式参数；否则，将引发TypeError异常。在这种情况下，该形式参数会接收包含多余位置参数的元组（如果没有多余位置参数，则为空元组）。
如果任何关键字参数与形式参数名称都不对应，则除非存在使用语法“ ** identifier”的形式参数，否则将引发TypeError异常；否则，将引发TypeError异常。在这种情况下，该形式参数将接收包含多余关键字参数的字典（使用关键字作为键，并将参数值用作对应的值），或者如果没有多余的关键字参数，则接收一个（新的）空字典。
From the Python documentation:
If there are more positional arguments than there are formal parameter slots, a TypeError exception is raised, unless a formal parameter using the syntax “*identifier” is present; in this case, that formal parameter receives a tuple containing the excess positional arguments (or an empty tuple if there were no excess positional arguments).
If any keyword argument does not correspond to a formal parameter name, a TypeError exception is raised, unless a formal parameter using the syntax “**identifier” is present; in this case, that formal parameter receives a dictionary containing the excess keyword arguments (using the keywords as keys and the argument values as corresponding values), or a (new) empty dictionary if there were no excess keyword arguments.
回答 9
* 表示将可变参数作为元组接收
** 表示接收可变参数作为字典
使用方式如下：
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
* means receive variable arguments as tuple
** means receive variable arguments as dictionary
Used like the following:
1) single *
def foo(*args):
for arg in args:
print(arg)
foo("two", 3)
Output:
two
3
2) Now **
def bar(**kwargs):
for key in kwargs:
print(key, kwargs[key])
bar(dic1="two", dic2=3)
Output:
dic1 two
dic2 3
回答 10
我想举一个别人没有提到的例子
*也可以打开生成器包装
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（）接收多个可初始化的参数，并返回一个生成器。
zip(*zip(x,y)) -> zip((1, 4), (2, 5), (3, 6))
I want to give an example which others haven’t mentioned
* can also unpack a generator
An example from Python3 Document
x = [1, 2, 3]
y = [4, 5, 6]
unzip_x, unzip_y = zip(*zip(x, y))
unzip_x will be [1, 2, 3], unzip_y will be [4, 5, 6]
The zip() receives multiple iretable args, and return a generator.
zip(*zip(x,y)) -> zip((1, 4), (2, 5), (3, 6))
回答 11
在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链接。）
In Python 3.5, you can also use this syntax in list, dict, tuple, and set displays (also sometimes called literals). See PEP 488: Additional Unpacking Generalizations.
>>> (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}
It also allows multiple iterables to be unpacked in a single function call.
>>> range(*[1, 10], *[2])
range(1, 10, 2)
(Thanks to mgilson for the PEP link.)
回答 12
除函数调用外，* args和** kwargs在类层次结构中很有用，并且还避免了必须__init__在Python中编写方法。在类似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')
完整的代码在这里
In addition to function calls, *args and **kwargs are useful in class hierarchies and also avoid having to write __init__ method in Python. Similar usage can seen in frameworks like Django code.
For example,
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])
A subclass can then be
class RetailItem(Item):
_expected_attributes = Item._expected_attributes + ['name', 'price', 'category', 'country_of_origin']
class FoodItem(RetailItem):
_expected_attributes = RetailItem._expected_attributes + ['expiry_date']
The subclass then be instantiated as
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. For example,
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)
which can be instatiated as
usb_key = ElectronicAccessories(name = 'Sandisk',
price = '$6.00',
category = 'Electronics',
country_of_origin = 'CN',
specifications = '4GB USB 2.0/USB 3.0')
The complete code is here
回答 13
建立在昵称的答案上 …
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 aka关键字参数）都可以使用** kwargs。
Building on nickd’s answer…
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)
Output:
1
(2, 3, 4, 5)
1
{'a': 2, 'b': 3}
1
(2, 3, 4)
{'s': 5}
Basically, any number of positional arguments can use *args and any named arguments (or kwargs aka keyword arguments) can use **kwargs.
回答 14
*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.
*args and **kwargs: allow you to pass a variable number of arguments to a function.
*args: is used to send a non-keyworded variable length argument list to the function:
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')
Will produce:
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 allows you to pass keyworded variable length of arguments to a function. You should use **kwargs if you want to handle named arguments in a function.
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")
Will produce:
Your name is Nikola.
Your last_name is Tesla.
Your birthday is 7.10.1856.
Your birthplace is Croatia.
回答 15
这个例子可以帮助您记住*args，**kwargs甚至super可以立即在Python中继承。
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
This example would help you remember *args, **kwargs and even super and inheritance in Python at once.
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
回答 16
在函数中同时使用两者的一个很好的例子是：
>>> 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')
{}
A good example of using both in a function is:
>>> 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')
{}
回答 17
TL; DR
以下是6种不同的使用情况*，并**在Python编程：
- 要使用
*args：接受任意数量的位置参数 def foo(*args): pass，此处foo接受任意数量的位置参数，即以下调用有效foo(1)，foo(1, 'bar')
- 要使用
**kwargs：接受任意数量的关键字参数 def foo(**kwargs): pass，此处的’foo’接受任意数量的关键字参数，即以下调用有效foo(name='Tom')，foo(name='Tom', age=33)
- 要使用
*args, **kwargs：接受任意数量的位置和关键字参数 def foo(*args, **kwargs): pass，此处foo接受任意数量的位置和关键字参数，即以下调用是有效的foo(1,name='Tom')，foo(1, 'bar', name='Tom', age=33)
- 要使用
*：强制使用 仅关键字参数def foo(pos1, pos2, *, kwarg1): pass，这*意味着foo仅在pos2之后接受关键字参数，因此foo(1, 2, 3)引发TypeError但foo(1, 2, kwarg1=3)可以。
- 要使用
*_（注：仅是一种约定）对更多的位置参数不再表示兴趣 def foo(bar, baz, *_): pass：（按约定）意味着（按约定）在其工作中foo仅使用bar和baz参数，而将忽略其他参数。
- 要使用
\**_（注：仅是一种约定）对更多关键字参数不再表示兴趣 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
TL;DR
Below are 6 different use cases for * and ** in python programming:
- To accept any number of positional arguments using
*args: def foo(*args): pass, here foo accepts any number of positional arguments, i. e., the following calls are valid foo(1), foo(1, 'bar')
- To accept any number of keyword arguments using
**kwargs: def foo(**kwargs): pass, here ‘foo’ accepts any number of keyword arguments, i. e., the following calls are valid foo(name='Tom'), foo(name='Tom', age=33)
- To accept any number of positional and keyword arguments using
*args, **kwargs: def foo(*args, **kwargs): pass, here foo accepts any number of positional and keyword arguments, i. e., the following calls are valid foo(1,name='Tom'), foo(1, 'bar', name='Tom', age=33)
- To enforce keyword only arguments using
*: def foo(pos1, pos2, *, kwarg1): pass, here * means that foo only accept keyword arguments after pos2, hence foo(1, 2, 3) raises TypeError but foo(1, 2, kwarg1=3) is ok.
- To express no further interest in more positional arguments using
*_ (Note: this is a convention only): def foo(bar, baz, *_): pass means (by convention) foo only uses bar and baz arguments in its working and will ignore others.
- To express no further interest in more keyword arguments using
\**_ (Note: this is a convention only): def foo(bar, baz, **_): pass means (by convention) foo only uses bar and baz arguments in its working and will ignore others.
BONUS: From python 3.8 onward, one can use / in function definition to enforce positional only parameters. In the following example, parameters a and b are positional-only, while c or d can be positional or keyword, and e or f are required to be keywords:
def f(a, b, /, c, d, *, e, f):
pass
回答 18
TL; DR
它包传递给函数的参数将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它是一个dict具有价值{"keyword" : "ligma", "options" : [1,2,3]}
这也可以反向进行，即从呼叫方进行。例如，如果您将函数定义为：
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)
TL;DR
It packs arguments passed to the function into list and dict respectively inside the function body. When you define a function signature like this:
def func(*args, **kwds):
# do stuff
it can be called with any number of arguments and keyword arguments. The non-keyword arguments get packed into a list called args inside the the function body and the keyword arguments get packed into a dict called kwds inside the function body.
func("this", "is a list of", "non-keyowrd", "arguments", keyword="ligma", options=[1,2,3])
now inside the function body, when the function is called, there are two local variables, args which is a list having value ["this", "is a list of", "non-keyword", "arguments"] and kwds which is a dict having value {"keyword" : "ligma", "options" : [1,2,3]}
This also works in reverse, i.e. from the caller side. for example if you have a function defined as:
def f(a, b, c, d=1, e=10):
# do stuff
you can call it with by unpacking iterables or mappings you have in the calling scope:
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)
回答 19
语境
- python 3.x
- 开箱
**
- 与字符串格式一起使用
与字符串格式一起使用
除了此主题中的答案外，这是其他地方未提及的另一个细节。这扩展了布拉德·所罗门的答案
**使用python时，使用进行解包也很有用str.format。
这有点类似于您可以使用python f-strings f-string进行的操作，但是增加了声明保留变量的字典的开销（f-string不需要字典）。
快速范例
## 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])
Context
- python 3.x
- unpacking with
**
- use with string formatting
Use with string formatting
In addition to the answers in this thread, here is another detail that was not mentioned elsewhere. This expands on the answer by Brad Solomon
Unpacking with ** is also useful when using python str.format.
This is somewhat similar to what you can do with python f-strings f-string but with the added overhead of declaring a dict to hold the variables (f-string does not require a 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])
回答 20
def foo(param1, *param2):是一种方法，可以接受任意数量的值*param2，def bar(param1, **param2): 是一种可以使用键接受任意数量的值的方法 *param2param1 是一个简单的参数。
例如，在Java中实现varargs的语法如下：
accessModifier methodName(datatype… arg) {
// method body
}
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 *param2param1 is a simple parameter.
For example, the syntax for implementing varargs in Java as follows:
accessModifier methodName(datatype… arg) {
// method body
}
