68

As mentioned in PythonCookbook, * can be added before a tuple. What does * mean here?

Chapter 1.18. Mapping Names to Sequence Elements:

from collections import namedtuple
Stock = namedtuple('Stock', ['name', 'shares', 'price'])
s = Stock(*rec) 
# here rec is an ordinary tuple, for example: rec = ('ACME', 100, 123.45)

In the same section, **dict presents:

from collections import namedtuple
Stock = namedtuple('Stock', ['name', 'shares', 'price', 'date', 'time'])
# Create a prototype instance
stock_prototype = Stock('', 0, 0.0, None, None)
# Function to convert a dictionary to a Stock
def dict_to_stock(s):
    return stock_prototype._replace(**s)

What is **'s function here?

6
  • 1
    Please read Python tutorial. (Unpacking Argument Lists)
    – falsetru
    Commented Feb 16, 2014 at 8:51
  • 1
    And it's not **tuple but **dictionary. Commented Feb 16, 2014 at 8:53
  • @MartijnPieters SORRY for that, I will try to fix it.
    – heLomaN
    Commented Feb 16, 2014 at 9:05
  • No problem, just pointing to a misunderstanding on your part. Commented Feb 16, 2014 at 9:07
  • 3
    @MartijnPieters This is not a duplicate question if you starting with the language. For me this question gave a different perspective then *arg and **kwargs. Commented Jul 3, 2018 at 0:24

1 Answer 1

182

In a function call

*t means "treat the elements of this iterable as positional arguments to this function call."

def foo(x, y):
    print(x, y)

>>> t = (1, 2)
>>> foo(*t)
1 2

Since v3.5, you can also do this in a list/tuple/set literals:

>>> [1, *(2, 3), 4]
[1, 2, 3, 4]

**d means "treat the key-value pairs in the dictionary as additional named arguments to this function call."

def foo(x, y):
    print(x, y)

>>> d = {'x':1, 'y':2}
>>> foo(**d)
1 2

Since v3.5, you can also do this in a dictionary literals:

>>> d = {'a': 1}
>>> {'b': 2, **d}
{'b': 2, 'a': 1}

In a function signature

*t means "take all additional positional arguments to this function and pack them into this parameter as a tuple."

def foo(*t):
    print(t)

>>> foo(1, 2)
(1, 2)

**d means "take all additional named arguments to this function and insert them into this parameter as dictionary entries."

def foo(**d):
    print(d)

>>> foo(x=1, y=2)
{'y': 2, 'x': 1}

In assignments and for loops

*x means "consume additional elements in the right hand side", but it doesn't have to be the last item. Note that x will always be a list:

>>> x, *xs = (1, 2, 3, 4)
>>> x
1
>>> xs
[2, 3, 4]

>>> *xs, x = (1, 2, 3, 4)
>>> xs
[1, 2, 3]
>>> x
4

>>> x, *xs, y = (1, 2, 3, 4)
>>> x
1
>>> xs
[2, 3]
>>> y
4

>>> for (x, *y, z) in [ (1, 2, 3, 4) ]: print(x, y, z)
...
1 [2, 3] 4

Note that parameters that appear after the starred parameter (the one marked *) are keyword-only:

def f(a, *, b): ...

f(1, b=2)  # fine
f(1, 2)    # error: b is keyword-only

Python3.8 added positional-only parameters, meaning parameters that cannot be used as keyword arguments. They appear before a / (a pun on * preceding keyword-only args).

def f(a, /, p, *, k): ...

f(  1,   2, k=3)  # fine
f(  1, p=2, k=3)  # fine
f(a=1, p=2, k=3)  # error: a is positional-only
3
  • 3
    Nice answer. I'll just add keyword operator to make this answer easier to find when somebody searches for python operator ** expecting * or ** this is called operator in this context. Commented Jan 5, 2021 at 13:49
  • 2
    Great answer. Just to add that in the case of "In a function signature" the common idiom is to use *args for positional arguments and **kwargs for keyword arguments. Commented Jan 26, 2021 at 12:41
  • 2
    @GuzmanOjero this is true, but only if there is no meaningful alternative.
    – Elazar
    Commented Jan 26, 2021 at 16:28

Not the answer you're looking for? Browse other questions tagged or ask your own question.