Branching

Branching with if/elif/else Statements

Branching control flow statements are based on logical conditions that are tested by the statement. The primary branching statements in Python are the if/elif/else statements. For instance, consider the following statements:

if x < 0:
    print("negative")
elif x == 0:
    print("zero")
else:
    print("positive")

If x is less than 0, it will print negative; if x is equal to 0, it will print zero, and otherwise (when x is positive) it will print positive. Note that the blocks of code that follow the branching statements must be indented. The elif (i.e., else if) and else statements are optional, and there can be multiple elif statements. Once a condition is met and the corresponding block executed, the rest of the control statements in the block are skipped.

The conditional expression is evaluated to a bool type (class). A boolean object can have one of two possible values, True and False. If the conditional expression of a branching statement evaluates to True, its corresponding block of code is executed. Note that Python will evaluate non-boolean conditional expression value with the built-in bool() function. For instance, if the conditional expression evaluates to a string "foo", it will be evaluated as bool("foo"), which, like all nonempty strings, evaluates to True. However, an empty string "" evaluates to False.

def print_nonempty(s):
    if s:
        print(s)
    else:
        print("Empty string")

print_nonempty("This should print")
print_nonempty("")      # This should print "Empty string"

This should print
Empty string

Branching with match/case Statements

In Python 3.10, a new kind of branching statement was introduced: match/case. Its use is never strictly necessary, but it can make a program more readable. For example,

if s == "red":
    print("red")
elif s == "blue":
    print("blue")
else:
    print("other")

can be written alternatively as

match s:
    case "red":
        print("red")
    case "blue":
        print("blue")
    case _:
        print("other")

In the third case _ matches when there is no other match. Once there is a match, no other cases are tested. If there is no match (and _ is not given as a case), none of the code blocks are evaluated.

There are more advanced uses of match/case statements in which patterns can be matched. See pydocs for more details.

Branching with try/except/finally Statements

Sometimes a statement can yield an exception, which is not a syntax error, but has a similar effect in that it can stop the execution of the program. Common exceptions include ZeroDivisionError, NameError and TypeError.

In general, an exception stops the execution of a program; however, certain exceptions can be anticipated and dealt with accordingly, which is called exception handling. One of the primary ways to handle exceptions is to use the try/except/finally statements. We can think of these statements as branching statements that branch based on exceptions. For instance consider the following function definition:

def plus_7(x):
    try:
        y = x + 7
    except:
        y = x
    return y

If we can add 7 to x, which is the case when x is a number, the try statement will execute, the except statement will be skipped, and the sum will be returned. If, however, we cannot add 7 to x, which is the case when x is nonnumeric, the try statement will raise an exception, so the except statement will be executed; this returns the input without change.

We will later return to exception handling to consider more advanced usage, including the finally statement.