Demystifying *args and **kwargs in Python

One element of Python functions that has confused me over the last few years has been the use of *args and **kwargs in function calls. In Django, it often comes up when overriding class functions, which, if I'm being honest, I often look up how to do, then copy the code over without really dig into the what is actually happening.

That ends today.

Variadic arguments

To start, I'll cover the concept of variadic arguments.

In a function definition, prefixing a parameter name with * will set that parameter as variadic, meaning that all arguments passed to the function starting at the position of the variadic parameter will be stored as a tuple.

def fruits(*args)
    return args

a = fruits("orange", "banana", "apple")

print(a)  # ("orange", "banana", "apple")

As you can see in the above example, the three arguments passed to the function get returned in a tuple as the single variable args which gets printed on the last line.

If we modify the function to take an argument before *args and return args, you'll see that args now only includes the latter two argument values.

def fruits(favorite, *args):
    return (favorite, args)

a, b = fruits("orange", "banana", "apple")

print(a)  # "orange"
print(b)  # ("banana", "apple")

Keyword variadic arguments

Keyword arguments can also be stored by prefixing the parameter name with **. The arguments captured by the keyword variadic parameter are stored in a dictionary in order to preserve the key-value association of the keyword arguments being passed in.

Here's an example of what this looks like in action.

def fruits(favorite, *args, **kwargs):
    return (favorite, args, kwargs)

a, b, c = fruits("orange", "banana", "apple", gross="durian")

print(a)  # "orange"
print(b)  # ("banana", "apple")
print(c)  # {"gross": "durian"}

Playing with variadic arguments

Variadic arguments are unpacked similarly when passed into a function. Positional arguments stored as a tuple can be passed to a function by prefixing the variable name of the tuple with *. Additionally, keyword arguments stored in a dictionary can be passed to a function by prefixing the variable name with **.

This can be particularly useful when you need to pass arguments from one function to the other. As mentioned above, sometimes this can happen when overriding a class function in a framework like Django.

An example of this would be adding custom data to the context data of a custom ListView class.

class SomeArticleView(ListView):
    model = Article
    template_name = "articles/my_template.html"

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context["extra_stuff"] = "some neat value"
        return context

This makes sure that any arguments passed into get_context_data are preserved while an additional key-value pair is added to the context.

Another situation where this can be useful is if multiple function calls take the same arguments. Arguments can be stored in a single variable and passed into multiple functions as by simple using * or ** before the variable name, depending on the context.