**（双星/星号）和 *（星号/星号）在函数调用中意味着什么？

Question

在 zip(*x) 或 f(**k) 等代码中，* 和 ** 的作用是什么> 分别是什么意思？ Python 如何实现该行为，以及对性能有何影响？

---

_{另请参阅：将元组扩展为参数。请使用该问题来结束 OP 需要在参数上使用 * 并且不知道它存在的问题。同样，对于使用 ** 的情况，请使用 Converting Python dict to kwargs?。}

_{请参阅**（双星/星号）和*（星号/星号）对参数有什么作用？了解互补内容关于参数的问题。}

Answer 1

单星号 * 将序列或集合解包为位置参数。假设我们

def add(a, b):
    return a + b

values = (1, 2)

使用 * 解包运算符，我们可以编写 s = add(*values)，这相当于编写 s = add(1, 2 ）。

双星 ** 对字典做同样的事情，为命名参数提供值：

values = { 'a': 1, 'b': 2 }
s = add(**values) # equivalent to add(a=1, b=2)

两个运算符都可以用于同一个函数调用。例如，给定：

def sum(a, b, c, d):
    return a + b + c + d

values1 = (1, 2)
values2 = { 'c': 10, 'd': 15 }

则 s = add(*values1, **values2) 相当于 s = sum(1, 2, c=10, d=15) 。

另请参阅 Python 中教程的相关部分文档。

---

同样，* 和 ** 也可用于参数。使用 * 允许函数接受任意数量的位置参数，这些参数将被收集到单个参数中：

def add(*values):
    s = 0
    for v in values:
        s = s + v
    return s

现在，当调用该函数时，如 s = add(1, 2, 3, 4 , 5)，values 将是元组 (1, 2, 3, 4, 5) （当然，它会产生结果 15）。

类似地，标有 ** 的参数将接收一个 dict：

def get_a(**values):
    return values['a']

s = get_a(a=1, b=2)      # returns 1

这允许指定大量可选参数而无需声明它们。

同样，两者可以结合起来：

def add(*values, **options):
    s = 0
    for i in values:
        s = s + i
    if "neg" in options:
        if options["neg"]:
            s = -s
    return s
        
s = add(1, 2, 3, 4, 5)            # returns 15
s = add(1, 2, 3, 4, 5, neg=True)  # returns -15
s = add(1, 2, 3, 4, 5, neg=False) # returns 15

Answer 2

在函数调用中，单星将列表转换为单独的参数（例如，给定 zip(*x) 与 zip(x1, x2, x3) 相同>x=[x1,x2,x3]），双星将字典转换为单独的关键字参数（例如 f(**k) 与 f( x=my_x, y=my_y) 给定 k = {'x':my_x, 'y':my_y}

在函数定义中，情况相反：单星。将任意数量的参数转换为列表，双开头将任意数量的关键字参数转换为字典，例如 def foo(*x) 表示“foo 接受任意数量的参数，并且它们。可以通过x访问（即如果用户调用foo(1,2,3)，x将是(1, 2, 3))" 和 def bar(**k) 表示“bar 接受任意数量的关键字参数，并且可以通过 k 访问它们（即如果用户调用 bar(x=42, y=23)，k 将是 {'x': 42, 'y': 23}< /代码>）”。

Answer 3

我发现这对于存储函数调用的参数特别有用。

例如，假设我对函数“add”进行了一些单元测试：

def add(a, b):
    return a + b

tests = { (1,4):5, (0, 0):0, (-1, 3):3 }

for test, result in tests.items():
    print('test: adding', test, '==', result, '---', add(*test) == result)

除了手动执行诸如 add(test[0], test[1]) 之类的操作之外，没有其他方法可以调用 add ，这很丑。另外，如果变量的数量可变，那么代码可能会因为您需要的所有 if 语句而变得非常难看。

另一个有用的地方是定义工厂对象（为您创建对象的对象）。
假设您有一些工厂类，它生成 Car 对象并返回它们。
您可以让 myFactory.make_car('red', 'bmw', '335ix') 创建 Car('red', 'bmw', '335ix')，然后返回它。

def make_car(*args):
    return Car(*args)

当您想要调用超类的构造函数时，这也很有用。

Answer 4

它被称为扩展调用语法。来自文档：

如果语法*表达式出现在函数调用中，则表达式的计算结果必须为序列。该序列中的元素被视为附加位置参数；如果有位置参数 x1,..., xN，并且表达式计算结果为序列 y1, ..., yM，则这相当于使用 M+N 位置参数 x1, ..., xN, y1, 的调用。 ..，yM。

和：

如果语法**表达式出现在函数调用中，则表达式必须计算为映射，其内容被视为附加关键字参数。如果关键字同时出现在表达式中并作为显式关键字参数出现，则会引发 TypeError 异常。

Answer 5

当定义可能有许多具有相同值的键的字典时，它也很有用。例如，

d = {'a':'r1', 'b':'r1','c':'r1','d':'r2'}

可以写成，

d = {**dict.fromkeys(['a','b','c'],'r1'),'d':'r2'}