Function arguments In Python

amitu.com
Function arguments:
positional and keyword
Excerpt from Python For Programmers

amitu.com Descriptors In Python
This is from a section in my “Python for
Developers” book. The book covers python
material for people who are already
developers, even python developers.
Check it out: amitu.com/python/

In this we are going to learn about function
arguments in Python
Positional and Keyword arguments, *
and ** syntax etc.

amitu.com Function arguments: positional and keyword
Functions can take arguments when called.
Here we have deﬁned a function foo, that takes
a single “positional argument”, x.
When we called foo(12), 12 got assigned to x
when the control was inside foo().

We can have more than one arguments:
So far so good.

One problem with function taking many arguments
is remembering the order of arguments.

Knowing that a function add_user() exists is not
enough, nor is knowing that it takes name, gender
and location. You must also remember in what order
those three must be supplied.
How do we make such obviously wrong code
look wrong?

Sometimes your code editor can help you. But we
can not always rely on that. What if you are
browsing code on GitHub?

To solve this precise problem, Python
supports function calling using what is called
“keyword argument” syntax:
… as against “positional arguments”, eg
foo(10, 20), where arguments are identiﬁed by
their position.

When using keyword arguments, you can even
change the order of keyword arguments, and
python will do the right thing.

We can also mix both positional and
keyword arguments:
isn't Python cool?

There is one constraint—we can not pass a
positional argument after a keyword argument. If we
use both, all positional arguments must come before
any keyword argument.

Default Values
Next:

In Python, we can deﬁne functions with
arguments that take default values.

We deﬁned foo() to have default value of
10 for y. If we don't pass anything for y,
python uses the default value.

Only y has a default value, x is still a
required argument.

We can still use keyword arguments:
Or a mixed arguments:

NOTE: like we can not pass keyword arguments after
positional arguments when calling function, we
similarly cannot deﬁne functions with default values
before arguments that do not have default values.
Arguments with default values must come at the end.

Mutable default value
gotcha

One common gotcha when using default arguments is
using a mutable type as the default value.
Default value for users here is a list, [ ], which is a
mutable data type in Python.

Let us say our intention is to create a users list. If it is
not passed we want to use an empty list by default. We
append to passed list, or the default empty list, and
returned the modiﬁed list.

So far, so good, and it seems to be working ﬁne.
Let us see when and where the problem begins.
What happened here? Why is “sam” in the
free_users list? add_user() should have taken
default empty list, and added “richard” and
returned that. Why two members?

What is happening is that, the empty list we have used
as default value of users in the function deﬁnition…
… the same instance is used as value of users,
every time we do not pass the second parameter.
And by the second time function is called,
the list is not empty any more!

The proper way to write such a function would
be using a value that would never make sense
to be passed, say None or -1.
ASIDE: such use of a value that is used for a
special purpose is called a sentinel value.

There is another subtle mistake we can make.
Let us look at another version of add_user() to
give emphasis to it.
Here, we ﬁrst check if the passed in value is None.
We have used strong identity check (is None).

The difference is subtle users is None vs not users.
First creates a new list if nothing was passed (and we took
the default value of None), other if empty list was passed.

Yet another more reliable way to create
sentinel values is:

The reason such NotPassed is preferable over None
is because our code can have None assigned to
something by mistake, but getting NotPassed
assigned to some variable has to be intentional.

Variable Arguments
Sometimes we want to write functions that
take variable number of arguments.

This is how we write a function in Python that
takes variable number of arguments:

Note the *args. The * indicates to Python
that this function takes the variable number
of positional arguments, and when the
function is called, all those arguments are
stored in tuple() and passed to the function
by the name args. Instead of args, we could
have called it anything.

We can not treat args as a keyword argument.
But we can achieve the same by * syntax:

We have used * while calling the function. When
using this syntax, we must pass an iterable. It
can be a tuple, a list, or any iterable.
Note that the list was converted to a tuple.
Whatever you pass will get converted to tuple.

We can use this syntax even for functions that do
not take a variable number of arguments…

… as long as the number of items we pass is correct.

You can also mix variable arguments with
positional arguments.

Remember that we can not pass positional
arguments after keyword arguments.

In Python 2, this would not be valid:

Python 3 accepts it, but treats y as a compulsory
keyword argument.

A variable number of arguments works with default
value arguments too.
… both in Python 2 and Python 3.

But there is a possibility of ambiguity here.
Python would not accept it.

Like we have *arg syntax which tells Python to
capture all remaining positional arguments,
there is a similar **kw syntax that tells Python
to capture all remaining keyword arguments
even ones we never deﬁned.

Python will capture all the keyword
arguments in a dict(), so everything that we
know about dict() can be used with them.

A new dictionary is constructed for you every
time a function that takes variable number of
keyword arguments is called.

In this case, our function accepts no
positional argument, so we can not call it
with a positional argument.

You can mix and match all forms of
arguments in a single function.
Just be careful that keyword arguments must come after
positional ones, and there must not be any ambiguities.

Finally, you can use the **{} syntax when
calling a function too.
Even when the function being called doesn't
take keyword arguments…

With these features, we can create a "universal
function" that can be called with any combination of
positional and keyword arguments:
These play special role when we are writing generic
decorators, or when we want to override a method
without knowing the parent methods signature.

Thats it for now!
You have seen a section in my “Python for
Developers” book. The book covers
python material for people who're already
developers, even python developers.
Check it out: amitu.com/python/

Function arguments In Python

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Function arguments In Python (20)

Recently uploaded (20)

Function arguments In Python