It is a little daunting for people who are new to python or
transitioning to python from other languages to understand how keyword
arguments work when compared to positional arguments. I will succinctly explain
each of them here and show you how to use keyword arguments like a pro in no
time.
Arguments in python are parameters that are passed to
functions. When a function is called, a scope is created for the function with
the arguments bound to the parameters within that scope. The argument could be
a variable, value or object that is passed to the function (or method) as
input.
There are two types of arguments that could be passed to
python functions. They are positional arguments and keyword arguments.
Positional arguments are arguments that need to be included
by the caller in their proper position or order in the function definition. Let’s
take the complex() built-in function as an example. The syntax is complex([real[,
imag]]) where the first argument is the real number and the second is the
imaginary number. In complex numbers, the position is very important. A complex
number with real 2 and imaginary number 3 is written as 2 + 3j. If the order is
mistaken, then you have a different complex number. You need to note this when
using the complex function. For example take this code sample below:
You can see from running the code that I interchanged the
2 and 3 just to show you how positional arguments work. When you change
the position of the arguments, you get a different result. You must give the
function the same number of arguments as is defined in the positional arguments,
else it will return an error.
But there are times when you want to pass a sequence of
arguments, such as an iterable to the function, then you can use the * operator
to do this. Notice that I used this * operator in line 6 in the code below. This unpacks the
iterable and passes each of the items in the iterable to the function in order.
What are keyword arguments?
Keyword arguments, as the name denotes, are arguments that
are passed with a key=value syntax. That is a key first, an = sign, and then a
value. Unlike positional arguments, the position of parameters or the order does not matter.
You can state the arguments in any order you
like. What matters are the names of the keys. In fact, when you pass a keyword
argument, python creates a dictionary of key=value pairs for the arguments and
inserts it into the function appropriately.
Let’s take an example using our complex function again.
You can see from line 1 and 3 that I interchanged the
positions of the arguments while specifying their key=value pairs and it gave
me the same object.
Keyword arguments can seem odd as we go on to take more
complex examples, but I want you to know that as you practice with it, it would
become more natural and you would love using them. They have advantages.
In python documentation, the phrase "keyword argument" is
often shortened to kwargs. So when you see such shorthand know that it
signifies keyword arguments.
What are the advantages of using keyword arguments.
- With keyword arguments, we can leave off some of
the arguments and the default is used for those that are left off.
Notice that in line 4 first_name was not given to the
function and I asked it to use the default. In line 5, I did not pass any argument
at all, instead it just used the default.
- If we want to achieve readability in passing
arguments, we can rearrange the arguments to make them readable.
The ability to rearrange the
arguments at your willing makes you creative and provides code you can understand in the future.
- Objects that are being passed to the function
are clear to use when we are passing them.
Since we are using their names to
pass them, we understand what we are doing in case we need to debug or read the
code in the future. Consider these two lines for passing arguments to the
complex function, which do you think is more readable?
Line 1 and line 3 creates the same object, but you must
agree with me that line 3 is more readable because looking at the keys you can
easily know what object you are passing to the function.
Now that we have a basic idea of keyword arguments and how
they are used in python, let us illustrate some more features of keyword
arguments with more examples.
Keyword arguments and examples
One example of a built-in function that requires a keyword
argument in python is the sorted function.
After the first iterable, every other argument that is passed to the function
must be a keyword argument. In the code below, I tried reversing the sort order
without passing a keyword argument of reverse=True and it returned a TypeError.
There is a handy technique that comes in handy when you want
to require that all your keyword arguments be named while having the ability to
pass on arbitrary positional arguments. That is mixing positional and keyword
arguments at the same time. When the positional arguments are more than one,
you can use the *parameter statement (where parameter is a variable, value or object) to specify this.
Remember, as I said
before, when stating a keyword argument with a positional argument, the moment
you insert a keyword argument in the parameter list, any other argument that
comes next must be a keyword argument.
Let’s take this summing function as an illustrative example.
It sums all the numbers passed starting from 1 as default. Notice that I did
not pass the parameter, initial, as argument, because I wanted to use it as
default. You can experiment with it. What if you want to make the initial
starting point 2 or 3? What sum would it return?
Also, to take our knowledge one step further, what if you don’t
want to specify any positional arguments but you want an arbitrary number of
keyword arguments. You use the statement **kwargs. You must have seen this
often in the python documentation. What python does when it sees this in the
function definition is to create a dictionary with the key=value of the passed
in parameters. Let’s illustrate this with an example.
When using the **kwargs statement, order matters to the
python interpreter. It will evaluate all the keys according to the order that
they were passed.
I encourage you to use keyword arguments often. They give
beauty to your programs. If you are not familiar with them, when writing any
function ask yourself: can I use keyword arguments for this and make it more
readable? It would solve you a whole lot of headache in the future.
