Functions

Introduction

Functions are essential in keeping code efficient and readable.

They usually are instructed to produce a return value from a set of parameters that are given in the function call. In order to create a function we use the keyword def (short for define) followed by the name of the function and the parameters that it may receive inside parenthesis (a function can have no parameters).

Following the parameters there must be a colon(:) which tells python that the function definition will be the defined in the next indented block (similar to an if or a for). Then we can write the function definition inside the indented block (which we call function body).

When the goal of the function is achieved and we have our output stored we use the keyword return followed by the variable which contains the result. If a function reaches its end without passing through a return, its return value will be None.

Big projects often have innumerous functions and it is often very difficult to keep track of every single one of them. In order to prevent confusion and make the code more readable functions often have a docstring: a string at the start of the function body , surrounded by """, that describes what is the input of the function, what it does and its output.

def my_function(my_parameters):
    """docstring here"""
    # Function defined here
    return result

Afterwards it is possible to make a function call by typing its name followed by the arguments inside parenthesis. The returned value of the function can then be fetched and used accordingly.

var=my_function(my_parameters)

Example

(Taken from Big C++)

Suppose that we are given a plethora of interest rates (in percentage) and we want to compute the value of a savings account based on those interests. The result must be the final balance of the account after 10 years, the initial balance is $1000.

The balance can be calculated using this formula: $$b=1000\times(1+\frac{p}{100})^{10}$$

So, firstly we need to define the header of the function. The only parameter that we are going to use is the interest rate.

def final_balance(interest_rate):

Secondly we need to compute the final balance into a variable.

result = 1000 * (1 + p / 100) ** (10)

Lastly, having achieved our goal, we return the result and finish writing the function.

def final_balance(interest_rate):
    result = 1000 * (1 + p / 100) ** (10)
    return result

We can then use the function to produce and compare different results using distinct interest rates.

print("${:.2f}".format(final_balance(5))) # 1628.89 $
print("${:.2f}".format(final_balance(10))) # 2593.74 $
print("${:.2f}".format(final_balance(25))) # 9313.23 $

But let's suppose that you wanted to change the initial deposit of the account to 1500 and wanted to see the value of the deposit after 20 years. The solution is to add the starting balance and the number of years as a new parameters to the function definition.

def final_balance(interest_rate, years=10, initial_value=1000):
    result = initial_value * (1 + p / 100) ** years
    return result

Notice how the parameters are assigned to a value in the function header. This means that if the function is called without specifing the value of years or initial_value they will default to their default values.

print("{:.2f}".format(final_balance(5))) # 1628.89
print("{:.2f}".format(final_balance(5, 20, 1500))) # 3979.95

Some very important notes to keep in mind:

When you keep repeating the same code over and over again it is usually a sign that you could turn that code into a function. Doing this will improve drastically the readability of your code.
Try to name your functions in a way that is self describing. This also improves code readability.

   interest_rate=5                         # What is more readable?
   print(final_balance(interest_rate))
   print(calc(interest_rate))
   print(1000*(1+interest_rate/100)**(10))

Scope

Variables can be in one of three places in which Python will look for, these places are called scopes (or namespaces):

Local scope - Variables that are defined inside of functions.
Global scope - Variables that are defined at the global level.
Built-in scope - Variables that are predefined in Python.

Whenever Python looks for a variable, it will always look for it in the previous order. To use a global variable inside a function call, use the global keyword. Note: As all functions, classes and modules are also variables, Python will look for them in the same order.

After you invoke a function and its execution ends, all the local variables created by it are deleted by the garbage collector. For example:

x=5
y=2
def func():
    x=7
    print("x:", x) # prints 7
    global y
    print("y:", y) # prints 2
    y = 4
    print("y:", y) # prints 4

func()
print("x:", x) # prints 5
print("y:", y) # prints 4

Although we may use global variables in this workshop, you should avoid using them whenever possible, as they diminish readability and lead to increased memory usage. Functions and classes can be a great way to avoid them.

Lambda Functions

Lambda functions are anonymous expressions used to create small functions on-the-fly. Invoke them by using the keyword lambda, followed by its argument, a colon and the function definition.

print((lambda p: 1000 * (1 + p / 100) ** (10)) (5)) #  1628.89

Variable Argument Functions

Sometimes we need to pass an unknown number of arguments to a function, so we resort to variable argument functions. If you are wondering what this kind of witchery is, you have already seen and worked with such a function: Python's format() method.

def var_args(an_argument, *args):
    print(f"An argument: {an_argument}")
    print(f"Args tuple: {args}")
    for var in args:
        print(var)

var_args(1, 3, 5, "Olá", ["alist", "with", "items"])

# An argument: 1
# Args tuple: (3, 5, 'Olá', ['alist', 'with', 'items'])
# 3
# 5
# Olá
# ['alist', 'with', 'items']

Sometimes you need even more versatility however, for example take a look at MatPlotLib's plot method for an idea of how much information can be packed in a single method call. A large part of said magic requires the use of keyword arguments (**kwargs), which can be used alongside the variable number of arguments *args.
They are used to pass a variable number of named arguments, so you can think of it as a dictionary whose keys are always strings.

def var_args(an_argument, *args, **kwargs):
    print(f"An argument: {an_argument}")
    print(f"Args tuple: {args}")
    print(f"Kwargs dict: {kwargs}")
    for key, value in kwargs.items():
        print(f"({key}, {value})")

var_args(1, "variable", "args", key1="aValue", anotherkey=42)

# An argument: 1
# Args tuple: ('variable', 'args')
# Kwargs dict: {'key1': 'aValue', 'anotherkey': 42}
# (key1, aValue)
# (anotherkey, 42)

Note: While *args and **kwargs can have any name, these are considered the convention and you should try to use them whenever possible.

Why It just works:tm: ~ Sequence Unpacking

The magic Python is using to allow for both *args and **kwargs is called sequence unpacking:

The * operator spreads/separates all elements from a list/tuple (if used on a dictionary it would be equivalent to *adict.keys())
The ** operator spreads/separates a mapping (dictionary) into the arguments of the function/method, passing the value to the parameter whose name matches the key. If a non-existant parameter is passed, it will result in a syntax error.

# A sample program to demonstrate unpacking of 
# dictionary items using **
def unpacking(a, b, c): 
    print(a, b, c)

# A call with unpacking of list
l = [89, 144, 233]
unpacking(*l)

# A call with unpacking of dictionary 
d = {'a':2, 'b':4, 'c':10} 
unpacking(**d)

# THIS CODE IS INCORRECT
# This would try to attribute the value for 'd', but it doesn't exist
d = {'a':2, 'b':4, 'd':10} 
unpacking(**d)

Sections

Previous: Iteration
Next: Comprehensions and Generators

Provide feedback

Saved searches

Use saved searches to filter your results more quickly