What does the star and doublestar operator mean in a function call?

The single star * unpacks the sequence/collection into positional arguments, so you can do this:

def sum(a, b):    return a + bvalues = (1, 2)s = sum(*values)

This will unpack the tuple so that it actually executes as:

s = sum(1, 2)

The double star ** does the same, only using a dictionary and thus named arguments:

values = { 'a': 1, 'b': 2 }s = sum(**values)

You can also combine:

def sum(a, b, c, d):    return a + b + c + dvalues1 = (1, 2)values2 = { 'c': 10, 'd': 15 }s = sum(*values1, **values2)

will execute as:

s = sum(1, 2, c=10, d=15)

Also see section 4.7.4 - Unpacking Argument Lists of the Python documentation.

Additionally you can define functions to take *x and **y arguments, this allows a function to accept any number of positional and/or named arguments that aren't specifically named in the declaration.

Example:

def sum(*values):    s = 0    for v in values:        s = s + v    return ss = sum(1, 2, 3, 4, 5)

or with **:

def get_a(**values):    return values['a']s = get_a(a=1, b=2)      # returns 1

this can allow you to specify a large number of optional parameters without having to declare them.

And again, you can combine:

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

One small point: these are not operators. Operators are used in expressions to create new values from existing values (1+2 becomes 3, for example. The * and ** here are part of the syntax of function declarations and calls.

I find this particularly useful for when you want to 'store' a function call.

For example, suppose I have some unit tests for a function 'add':

def add(a, b): return a + btests = { (1,4):5, (0, 0):0, (-1, 3):3 }for test, result in tests.items():    print 'test: adding', test, '==', result, '---', add(*test) == result

There is no other way to call add, other than manually doing something like add(test[0], test[1]), which is ugly. Also, if there are a variable number of variables, the code could get pretty ugly with all the if-statements you would need.

Another place this is useful is for defining Factory objects (objects that create objects for you).Suppose you have some class Factory, that makes Car objects and returns them.You could make it so that myFactory.make_car('red', 'bmw', '335ix') creates Car('red', 'bmw', '335ix'), then returns it.

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

This is also useful when you want to call a superclass' constructor.