What is the name of ** in python?

Question

When programming Python I sometimes do a ** to make a conversion. I understand what it does but what data structures am I manipulating? A dict and what is the other? An array? Is there a name for the ** operator?

Answer 1

It's not an operator as such, so it doesn't really have a name, but it is defined as a "syntactic rule". So it should be called:

• "the keyword argument unpacking syntax"

If you have a list of arguments, *args, it's called "argument unpacking", in the same manner **kwargs is called "keyword argument unpacking".

If you use it on the left hand side of an =, as in a, *middle, end = my_tuple, you'd say "tuple unpacking".

In total, there are three types of (single parameter) arguments:

def f(x)  # x: positional argument
def f(x, y=0)  # y: keyword argument
def f(x, *xs, y=0)  # y: keyword-only argument

The *args argument is called the "variable positional parameter" and **kwargs is the "variable keyword parameter". Keyword-only arguments can't be given positionally, because a variable positional parameter will take all of the arguments you pass.

Most of this can be found in PEPs 0362 and 3102, as well as in the Control Flow section of the docs. It should be noted though that the function signature object PEP is only a draft, and the terminology might just be one person's idea. But they are good terms anyway. :)

So the * and ** arguments just unpack their respective data structures:

args = (1, 2, 3)  # usually a tuple, always an iterable[1]

f(*args) → f(1, 2, 3)

# and 

kwargs = {"a": 1, "b": 2, "c": 3}  # usually a dict, always a mapping*

f(**kwargs) -> f(a=1, b=2, c=3)

[1]: Iterables are objects that implement the __iter__() method and mappings are objects that implement keys() and __getitem__(). Any object that supports this protocol will be understood by the constructors tuple() and dict(), so they can be used for unpacking arguments.

Answer 2

I don't think it has a name. In the Python Docs under "Unpacking Argument Lists", it's just referred to as "the **-operator."

I'm not sure what you mean by "the other" data structure. When you do f(**kwargs) you unpack the dictionary kwargs as a sequence of key-value pairs. I don't see that there's another structure involved.

I'll copy the example in the above documentation for clarity.

>>> def parrot(voltage, state='a stiff', action='voom'):
...     print "-- This parrot wouldn't", action,
...     print "if you put", voltage, "volts through it.",
...     print "E's", state, "!"
...
>>> d = {"voltage": "four million", "state": "bleedin' demised", "action": "VOOM"}
>>> parrot(**d)
-- This parrot wouldn't VOOM if you put four million volts through it. E's bleedin' demised !

See also: What does *args and **kwargs mean?

Answer 3

If you are unsure what to call a particular operator or if it is unnamed, you can always resort to Waka Waka Bang Splat as a reference to help you figure out what to call it. In this case for ** I would call it double-splat, though there are some alternate names for symbols.