Variable Length Argument Lists

How would you write a function in python that accepts an arbitrary number of arguments ? This is exactly where *args and **kwargs come into picture. *args (for lack of a better variable name, programmers usually go with choice of args, you can use *anything) is used to pass a non keyworded variable-length argument list. Let us look at an example -

>>> def hello_args(formal_arg, *args):
...   print 'Positional arg: %s'%formal_arg
...   for arg in args:
...     print 'Additional arg: %s'%arg
...

>>> hello_args('arg1', 'argument', 'another argument', 'yet another argument',
...     'as many arguments as you want')

Here is the output :

Positional arg: arg1
Additional arg: argument
Additional arg: another argument
Additional arg: yet another argument
Additional arg: as many arguments as you want

Similarly **kwargs (or **anything) is used to pass a keyworded variable-length argument list. Now what do I mean by keyworded - anything that has a collection of key:value pairs, a mapping basically, like a dictionary. Here is a simple example to explain **kwargs usage -

>>> def hello_kwargs(formal_arg, **kwargs):
...   print 'Positional arg: %s'%formal_arg
...   for arg in kwargs:
...     print 'Another key-value pair: %s: %s'%(arg, kwargs[arg])
...

>>> hello_kwargs('arg1', argument='value', another_argument='another value',
...     yet_another_argument='yet another value')

Here is the output :

Positional arg: arg1
Another key-value pair: argument: value
Another key-value pair: another_argument: another value
Another key-value pair: yet_another_argument: yet another value

Unpacking Argument Lists

In order to be able to use *args and **kwargs when calling functions, it is important to understand a simple yet important concept - Unpacking Argument List. This piece of code shall make the unpacking clear.

>>> range(1, 5)  # Normal call with separate arguments.
[1, 2, 3, 4]
>>> args = [1, 5]
>>> range(*args)    # Call with arguments unpacked from list.
[1, 2, 3, 4]

Similarly one can unpack the arguments from a dictionary - this time using ** rather than using * as in previous example.

>>> def make_sandwich(bread='brown', cheese='raw', lettuce='fresh', meat='extra'):
...  print 'I am making a super tasty sandwich for you !'
...  print 'You asked for %s bread, there you go !'%bread
...  print 'You shall have %s cheese, %s lettuce and %s meat.'%(cheese, lettuce,
...      meat)
...
>>> order = {'bread': 'parmesan-oregano', 'cheese': 'toasted',
...     'lettuce': 'fresh', 'meat': 'extra'}
>>> make_sandwich(**order)    # We're passing an unpacked dictionary here.

Here is your sandwich, erm… output, I mean.

I am making a super tasty sandwich for you !
You asked for parmesan-oregano bread, there you go !
You shall have toasted cheese, fresh lettuce and extra meat

Note that python allows usage of *args and **kwargs only in a specific order. All positional arguments come before *args, and *args comes before **kwargs.

A complex example using *args and **kwargs

This example requires that you know what decorators are, and how they’re used in python. Since decorators are kind of an interesting syntactic sugar constructs, I will write a post about them as well, soon. Now, let us write a function that accepts all arguments - such a function is called a catch-all function. We’re then going to use this function as a memoise function that implements caching. The benefit of having a catch-all function is that it doesn’t depend on underlying function’s definition (arguments, I mean), it has one job - to cache, and that it will for any type of functions that accepts whatever number of whatever type of arguments !

import functools

def memoize(f):
"""Memoize function f."""
cache = f.cache = {}

@functools.wraps(f)
def memoizer(*args, **kwargs):
  key = str(args) + str(kwargs)
  if key not in cache:
    cache[key] = f(*args, **kwargs)
  return cache[key]
return memoizer

And that’s it. Notice the relative position of *args and *kwargs in the above function. Let us try and write a fibonacci function that returns nth fibonacci number.

@memoize
def fibonacci(n):
  return 1 if n==0 or n==1 else fibonacci(n-1) + fibonacci(n-2)

>>> fibonacci(35):
14930352

And obviously it’s much faster than the one I wrote in previous blog post about generators since the one written with generators didn’t cache the previously computed values. Say you wanted a list of first n fibonacci numbers, the function written with generators in previous blog post would recompute lower fibonacci values each time, rather than using those already computed values from cache. This is the soul of a set of solutions referred to as Dynamic Programming. This caching function makes all kind of Dynamic Programming solutions easily implementable in python; you can do it just by decorating the intended function. Now that IS some syntactic sugar !

Thanks for reading!