This chapter is taken from the book A Primer on Scientific Programming with Python by H. P. Langtangen, 5th edition, Springer, 2016.
The flow of computer programs often needs to branch. That is, if a condition is met, we do one thing, and if not, we do another thing. A simple example is a function defined as $$ \begin{equation} f(x) = \left\lbrace\begin{array}{ll} \sin x, & 0\leq x\leq \pi\\ 0, & \hbox{otherwise} \end{array}\right. \tag{4} \end{equation} $$ In a Python implementation of this function we need to test on the value of \( x \), which can be done as displayed below:
def f(x): if 0 <= x <= pi: value = sin(x) else: value = 0 return value
if-else test is
if condition: <block of statements, executed if condition is True> else: <block of statements, executed if condition is False>
When condition evaluates to True, the program flow branches into
the first block of statements. If condition is False, the program
flow jumps to the second block of statements, after the else: line.
As with while and for loops, the block of statements are
indented.
Here is another example:
if C < -273.15: print '%g degrees Celsius is non-physical!' % C print 'The Fahrenheit temperature will not be computed.' else: F = 9.0/5*C + 32 print F print 'end of program'
The two print statements in the if block
are executed if and only if
C < -273.15 evaluates to True. Otherwise, we jump over
the first two print statements and carry out the computation and
printing of F. The printout of end of program will be
performed regardless of the outcome of the if test since this
statement is not indented and hence neither a part of the if block
nor the else block.
The else part of an if test can be skipped, if desired:
if condition: <block of statements> <next statement>
For example,
if C < -273.15: print '%s degrees Celsius is non-physical!' % C F = 9.0/5*C + 32
In this case the computation of F will always be carried out,
since the statement is not indented and hence not a part of the
if block.
With the keyword elif, short for else if, we can have
several mutually exclusive if tests, which allows for
multiple branching of the program flow:
if condition1: <block of statements> elif condition2: <block of statements> elif condition3: <block of statements> else: <block of statements> <next statement>
The last else part can be skipped if it is not needed.
To illustrate multiple branching we will implement a hat
function, which is widely used in advanced computer simulations
in science and industry. One example of a hat function is
$$
\begin{equation}
N(x) = \left\lbrace\begin{array}{ll}
0, & x < 0\\
x, & 0\leq x < 1\\
2-x, & 1\leq x < 2\\
0, & x \geq 2
\end{array}\right.
\tag{5}
\end{equation}
$$
The Python implementation associated with (5)
needs multiple if branches:
def N(x): if x < 0: return 0.0 elif 0 <= x < 1: return x elif 1 <= x < 2: return 2 - x elif x >= 2: return 0.0
This code corresponds directly to the mathematical specification, which
is a sound strategy that help reduce the amount of errors in programs.
We could mention that there is another way of constructing the
if test that results in shorter code:
def N(x): if 0 <= x < 1: return x elif 1 <= x < 2: return 2 - x else: return 0
As a part of learning to program, understanding this latter sample code is important, but we recommend the former solution because of its direct similarity with the mathematical definition of the function.
A popular programming rule is to avoid multiple return statements in
a function - there should only be one return at the end. We can do
that in the N function by introducing a local variable, assigning
values to this variable in the blocks and returning the variable at
the end. However, we do not think an extra variable and an extra line
make a great improvement in such a short function. Nevertheless, in
long and complicated functions the rule can be helpful.
A variable is often assigned a value that depends on a
boolean expression. This can be coded using a common if-else
test:
if condition: a = value1 else: a = value2
Because this construction is often needed, Python provides a one-line syntax for the four lines above:
a = (value1 if condition else value2)
The parentheses are not required, but recommended style. One example is
def f(x): return (sin(x) if 0 <= x <= 2*pi else 0)
Since the inline if test is an expression with a value, it can be used in
lambda functions:
f = lambda x: sin(x) if 0 <= x <= 2*pi else 0
The traditional if-else construction with indented
blocks cannot be used inside
lambda functions because it is not just an expression (lambda functions
cannot have statements inside them, only a single expression).