Program Flow

Here we want to introduce the basic concepts of program flow that occur in almost every programming language.
To implement a logical program flow, we need conditional statements and loops.
Furthermore, we will learn how to implement our own functions to better structure the program flow and reuse frequently used code.

Logical Operators¶

Logical operators are used in if statements and loops to control the program flow:

Comparison operations always return an object of type bool, i.e., either True or False:

Comparison operators can only be used if these operations are defined for the data types being compared. The following comparisons work:

For complex numbers, there is no comparison operation such as < or >.

Boolean expressions can also be combined. The equivalents of the mathematical expressions $a\wedge b$, $a\vee b$, and $\neg a$ are:

Example: We want to test whether a number $x$ lies in the interval $[1/4,3/4)$:

Conditional Statements (if-statements)¶

Conditional statements in Python can be implemented as follows:

if <condition_1>:
    # If condition_1 is True:
    [do something]
    ...
    [do something more]
elif <condition_2>:
    # If condition_1 is False and condition_2 is True:
    [do something]
    ...
    [do something more]
else:
    # If both condition_1 and condition_2 are False:
    [do something]
    ...
    [do something more]

Of course, the statement can be extended with any number of elif blocks.
condition_1 and condition_2 must be Boolean variables, i.e., either True or False. The indentation of the code under the if statement determines what actions are executed when condition_1 is True. The code block that is executed ends with the last indented line. See the output of the following code for illustration:

In the following example, a random number between 1 and 10 is generated and tested to see whether it is even or odd. We will also learn about the modulo operator %, which returns the remainder of the division of two integers. Example: 8%3 equals 2, since $8=2\cdot 3+\textbf{2}$. This process is repeated 10 times. An explanation of for-loops follows in the next section.

Loops¶

for-loops¶

To understand the need for loops, let’s first consider the following code, which calculates the sum of numbers from a list:

Here, we obviously want to iterate over all elements of a list. This becomes problematic when the list contains several thousand elements. Our code would then grow to several thousand lines. Moreover, we have here relied on knowing the number of elements in the list. The lines value += a[i] only differ by the index i, and loops allow us to combine all these lines into a single structure.

The first type of loop we want to discuss here is the for loop. The general syntax is:

for <elem> in <iterable_object>:
    [do something]
    ...
    [do something more]

• <iterable_object> can be any object that provides an iterator (more on this in section Iterators)

• Examples: list, a tuple, or NumPy array (see section Linear Algebra with NumPy), string

The above example can be simplified using a for loop:

Here, the line value += elem is repeated as many times as the list contains elements. The variable elem takes on the values a[0], a[1], ..., a[4] sequentially.

In addition to the iterable data types mentioned above, there is the range class. A range object represents an interval for the iteration index with a start and end index. From the Python documentation (accessible via range?) we learn, for example:

range(stop) -> range object
range(start, stop[, step]) -> range object

Return an object that produces a sequence of integers from start (inclusive)
to stop (exclusive) by step.  range(i, j) produces i, i+1, i+2, ..., j-1.
start defaults to 0, and stop is omitted!

Here is a small test:

Note: If the number of loop iterations is known before the first iteration, a for loop should be used. Otherwise, use a while loop, which we will discuss in the following section.

Loops can be further controlled within the loop block using the continue and break statements. With break, an additional exit condition can be implemented. In the example, the number 5 is searched for in a list, and the loop is terminated upon the first occurrence of this number.

In the previous example, the loop is terminated with break after encountering the number 5 — it will not continue after the third iteration.

In contrast, continue only skips the current iteration and immediately moves to the next iteration.

Example: Calculate the sum of all even numbers from 1 to 10:

while-loops¶

In for loops, the termination condition was known before the first iteration.
If the termination condition changes during the loop, a while loop is used.
The general syntax is:

while <condition>:
    [do something]
    ...
    [do something more]

• <condition> is a Boolean expression.

• The indented loop block is executed as long as <condition> is True.

• To avoid an infinite loop, it must be ensured that <condition> becomes False after a finite number of iterations.

In the following example, random numbers are generated until a number divisible by 5 is produced:

Even in while loops, the statements continue and break apply.

Functions¶

Defining Your Own Functions¶

Frequently reused parts of a program can be encapsulated in functions to improve code readability. A function must be defined before its first call.

The general syntax of a function definition is

def <function_name>(<param1>, <param2>[, ...]):
    [do something]
    ...
    [do something more]
    return <ret1>, <ret2>[, ...]

The parameters <param1>, <param2>, etc., are passed when the function is called.
The return values <ret1>, <ret2>, etc., are returned by the function and can, for example, be stored as a tuple.
If the function does not need to return any values, e.g., a function that only prints to the console, the return line can be omitted.

Note: When return is called, the function exits immediately. Any subsequent code inside the function will not be executed.

The syntax of a function call is

<ret1>, <ret2>[, ...] = <function_name>(<param1>, <param2>[, ...])

Let’s start with a simple example. The following function sums all elements of an iterable object L and returns the result:

To execute this function, we write:

Note that we can call our sum function with parameters of any type for which all operations used in sum are defined.

Our sum function can therefore also be called with tuples:

Not with strings, however. Strings are also iterable, which allows their use in a for loop, but the += operation between an integer (note: val is an integer due to the line val = 0) and a string is not defined:

Local and Global Variables¶

It should be noted that all variables defined inside a function are only local variables. They are therefore not visible outside the function.

If a global variable with the same name already exists, the function will work only with the local variable:

In the previous example, the local variable value was only created by the line value = ....

If this line is missing, for example in a function that only reads but does not modify the value of value, the function will use the global variable with the same name:

If you want to modify a global variable inside a function, you must clarify at the beginning of the function that no new local variable should be created. This is done using the global keyword:

This approach should, however, be avoided whenever possible. Other functions might rely on the value of the global variable not changing unexpectedly.

1. What output does this program produce?

2. Explain why the value of the global variable value does not change.

3. Modify the function so that the global variable is actually changed.

Mutable vs. Immutable¶

Another interesting question is: What happens to function parameters if we modify them inside a function?
The answer can be seen with a simple test:

Although we modified a inside the function, the value of a outside the function does not change.

This is because when the function add_something is called, a copy of the reference to the value of a is passed. Since a is an immutable data type (integer), the operation a += 5 creates a new object that only the local variable a inside the function refers to.

It gets a bit more confusing, though. In the following example, the function parameter is a list, which is modified inside the function. If the function only worked with a copy, the list L should not have changed after the function call. However, this is clearly not the case:

Obviously, inside append_something, we did not work with a copy of the list, but directly with the object L.

To understand this behavior, it helps to take a closer look at how variables work in Python. Variables are identifiers for objects in memory.

Using the function id, which returns an identification number of an object, we can see where a variable’s value is stored in memory. In the following example, we create two variables that obviously have the same ID:

This can be interpreted as a and b being essentially just names that we bind to an object (here the constant 5, which resides somewhere in memory).

Initially, both a and b point to the same object in memory. Therefore, id(a) and id(b) return the same identification number, and the expression a is b evaluates to True.

If the value of b is then changed (b = b + 1), the following happens:

1. A new object with the value 6 is created.

2. The name b is bound to this new object.

3. a remains bound to the original object 5.

The original object in memory is therefore not modified; instead, a new object is created.

Let’s implement a similar test for list objects:

Here, a and b are lists with exactly the same content, but the names point to different objects in memory. This can be seen from the fact that id(a) and id(b) return different values, and the expression a is b evaluates to False.

Unlike the previously considered integers, a new object is created for each list, even if the content is identical.

Let’s slightly modify the example:

By assigning b = a, we have bound b to the same object as a. Now we need to be careful. We only modified the object behind b using b.append(4), but since a and b are bound to the same object, this operation also affects a. The position of the object in memory does not change. Thus, the object itself is mutable.

As our examples have shown, an object of type int is immutable, which means it cannot be modified. If the value of an integer is changed, a new object is created, to which the original name is bound:

Lists, on the other hand, are mutable and behave differently:

This also explains the different behavior when using lists as function parameters. The behavior for immutable data types is easy to understand if we extend our example from above with a few print statements:

The name a is initially bound to the object with the constant 1. The name is passed to the function add_something, now called a_ (for clarity; we could have kept it a), but it is still bound to the same object. Inside the function, an operation is applied to this object, here +=. A copy is created because integers are immutable, and the name a_ now points to this new object containing the constant 2. The name a outside the function add_something remains bound to the original object and is therefore unaffected by what happens inside the function.

If a in the previous example had been a list, i.e., a mutable object, an operation that modifies the list would not change the binding of the name to the object.

Conclusion:

• Immutable objects (int, float, string, tuple) → modifications create new objects.

• Mutable objects (list, dict, set, …) → modifications directly affect the passed object.

Recursive Functions¶

Recursive functions are functions that call themselves repeatedly, up to a certain termination condition. A typical example would be the following function for calculating the factorial:

Note that many algorithms can be implemented both recursively and iteratively (using a loop). For efficiency reasons, the iterative variant is usually preferred in this case.