Python Functions

So, after the function definition, you have a line of code that multiplies the value stored in the “strn” variable by 3 and prints it to the console. Notice that the third line also begins with “…”. Python is not evaluating anything yet, it is waiting for your to give it the next instruction.

It is important to remember that white space is very important in Python. This is how Python can figure out which instruction belongs to a particular block. If you had not included the 3 spaces in the second line of this example, Python would assume that the new instruction does not belong to the function. These dependency on white space is a known pain point for Python programmers, and something that you will have to endure.

To keep this example super-simple, let end the function here, with only a single line of code. Your cursor is in line three. Hit Enter one more time. You should see this:

Now, let’s create a function. In Python, we use the keyword “def” to define a new function. A function definition needs a name (so we can use this name to call the function from somewhere else in our program), and an optional one or more attributes. An attribute can be a variety of things, like strings, numbers, variables, and arrays.

Here’s an example Python function, named “str_operation”, that has a single argument “strn”:

print(3 * strn)

Your CLI should look like this:

>>> def str_operation(strn):
...    print(3 * strn)
...

>>> def str_operation(strn):
...    print(3 * strn)
...
>>>

After the blank line, the CLI shows the familiar “>>>” prompt. Whatever you type now will be evaluated by python. Your new function exists in memory, and it will produce a result on the screen when you call it by name and pass an argument to it.

Now, try this:

>>> str_operation("Hello ")
Hello Hello Hello
>>>

The string “Hello” has been copied three times in the console.

Nice!

You can modify this little function like this:

>>> def str_operation(strn):
...    a = 3 * strn
...    print(a)
...
>>>

This will evaluate the expression “3 * strn” and store the result in variable “a”, then print it to the console.

When you call it, the result is exactly the same as in the first version:

>>> str_operation("Hello ")
Hello Hello Hello
>>>

Yet another version of this example is the following:

>>> def str_operation(strn, num):
...    a = num * strn
...    print(a)
...
>>>

In this version, I have added a new parameter, called “num”. In the second line, I have replaced the original “3” with “num”, so that I can repeat the string stored in “strn” as many times as I like without having to modify the program.

I can call this function like this:

>>> str_operation("Hello ",4)
Hello Hello Hello Hello
>>>

Notice that inside the parentheses I have provided the string argument, and the number argument. In this call, the arguments appear in the same order as in the function definition; this is very important to remember as Python excepts the arguments to be in the order defined in the definition of the function.

As you can see, we use functions to bundle together instructions. We can call a function by its name, and pass any required parameters to it in order to have its instructions executed. But functions can also return values to the caller. Have a look at this variation of the ”str_operation” function:

In this example, the function definition is the same as in the original example. But, instead of the function doing the calculation and printing the result to the console, it simply returns the result of the calculation using the “return” keyword. The caller of the function can then decide what to do with the returned value.

Here is the example on the CLI:

>>> def str_operation(strn, num):
...     return num * strn
...
>>> a = str_operation("Hello ", 3)
>>> print(a)
Hello Hello Hello

In this example, I have defined the new version of str_operation to return a value. Then, I call the function with its parameters, and store the returned value in a variable. Finally, I print the value stored in the “a” variable in the console.

There is a lot of flexibility in writing functions, using the return function, and in general how you structure your Python programs. For example, if you prefer a multi-step approach, you can write the function like this:

def str_operation(strn, num):
    return num * strn

print(str_operation("hello ", 3))

In this example, you have condensed four lines of code into 2 (the return line, and the print line), skipping the intermediate steps that involve the variables.

My personal preference is to code for clarity. I imagine other people reading my code, or myself reading my code sometime in the future. Will I (or my readers) be able to understand what my code does? Will they be able to improve it, or add new features? This means that usually it is bes to be more verbose, with sensible function and variable names, and a logical program structure.

From here, functions and programs get more elaborate and complicated, but you are already familiar with the basic principles.

Ready for something new? In the next chapter I will show you how to write a Python script that you can call from the command line, without using the CLI. You will build on the knowledge you gained in this chapter.