Postgraduate course, Covenant University Ota, Nigeria
Oyelade, O. J., PhD | [email protected]
Isewon, I. | [email protected]
Introduction to Python programming
Module Three: Conditional Statements
3.1 Objectives
This module covers:
•
•
•
•
The modulus operator
Boolean values and expressions
Logical operators
Conditional executions
3.2. The modulus operator
The modulus operator works on integers (and integer expressions) and yields the
remainder when the first operand is divided by the second. In Python, the modulus
operator is a percent sign (%). The syntax is the same as for other operators:
>>>
>>>
2
>>>
>>>
1
quotient = 7 / 3
print quotient
remainder = 7 % 3
print remainder
So 7 divided by 3 is 2 with 1 left over.
3.3.
Boolean values and expressions
The Python type for storing true and false values is called bool, named after the
British mathematician, George Boole. George Boole created Boolean algebra,
which is the basis of all modern computer arithmetic.
Oyelade, O. J. and Isewon I – H3AbioNet Postgraduate course, 2014
Page 1
There are only two boolean values: True and False. Capitalization is important,
since true and false are not boolean values.
>>> type(True)
<type 'bool'>
>>> type(true)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'true' is not defined
A boolean expression is an expression that evaluates to a boolean value. The
operator == compares two values and produces a boolean value:
>>> 5 == 5
True
>>> 5 == 6
False
In the first statement, the two operands are equal, so the expression evaluates to
True; in the second statement, 5 is not equal to 6, so we get False.
The == operator is one of the comparison operators; the others are:
x
x
x
x
x
!= y
> y
< y
>= y
<= y
#
#
#
#
#
x
x
x
x
x
is
is
is
is
is
not equal to
greater than
less than y
greater than
less than or
y
y
or equal to y
equal to y
Although these operations are probably familiar to you, the Python symbols are
different from the mathematical symbols. A common error is to use a single equal
sign (=) instead of a double equal sign (==). Remember that = is an assignment
operator and == is a comparison operator.
3.4
Logical operators
There are three logical operators: and, or, and not. The semantics (meaning) of
these operators is similar to their meaning in English. For example, x > 0 and
x < 10 is true only if x is greater than 0 and less than 10.
Oyelade, O. J. and Isewon I – H3AbioNet Postgraduate course, 2014
Page 2
n % 2 == 0 or n % 3 == 0 is true if either of the conditions is true, that is,
if the number is divisible by 2 or 3.
Finally, the not operator negates a boolean expression, so not(x > y) is true if
(x > y) is false, that is, if x is less than or equal to y.
3.5.
Conditional execution
In order to write useful programs, we almost always need the ability to check
conditions and change the behavior of the program accordingly. Conditional
statements give us this ability. The simplest form is the ** if statement**:
if x > 0:
print "x is positive"
The boolean expression after the if statement is called the condition. If it is true,
then the indented statement gets executed. If not, nothing happens.
The syntax for an if statement looks like this:
if BOOLEAN EXPRESSION:
STATEMENTS
As with the function definition from last module and other compound statements,
the if statement consists of a header and a body. The header begins with the
keyword if followed by a boolean expression and ends with a colon (:).
The indented statements that follow are called a block. The first unindented
statement marks the end of the block. A statement block inside a compound
statement is called the body of the statement.
Each of the statements inside the body are executed in order if the boolean
expression evaluates to True. The entire block is skipped if the boolean
expression evaluates to False.
There is no limit on the number of statements that can appear in the body of an if
statement, but there has to be at least one. Occasionally, it is useful to have a body
with no statements (usually as a place keeper for code you haven’t written yet). In
that case, you can use the pass statement, which does nothing.
if True:
# This is always true
Oyelade, O. J. and Isewon I – H3AbioNet Postgraduate course, 2014
Page 3
pass
does nothing
3.6.
# so this is always executed, but it
Alternative execution
A second form of the if statement is alternative execution, in which there are two
possibilities and the condition determines which one gets executed. The syntax
looks like this:
if x % 2 == 0:
print x, "is even"
else:
print x, "is odd"
If the remainder when x is divided by 2 is 0, then we know that x is even, and the
program displays a message to that effect. If the condition is false, the second set
of statements is executed. Since the condition must be true or false, exactly one of
the alternatives will be executed. The alternatives are called branches, because
they are branches in the flow of execution.
As an aside, if you need to check the parity (evenness or oddness) of numbers
often, you might wrap this code in a function:
def print_parity(x):
if x % 2 == 0:
print x, "is even"
else:
print x, "is odd"
For any value of x, print_parity displays an appropriate message. When you
call it, you can provide any integer expression as an argument.
>>> print_parity(17)
17 is odd.
>>> y = 41
>>> print_parity(y+1)
42 is even.
3.7. Chained conditionals
Oyelade, O. J. and Isewon I – H3AbioNet Postgraduate course, 2014
Page 4
Sometimes there are more than two possibilities and we need more than two
branches. One way to express a computation like that is a chained conditional:
if x < y:
print x, "is less than", y
elif x > y:
print x, "is greater than", y
else:
print x, "and", y, "are equal"
elif is an abbreviation of else if . Again, exactly one branch will be executed.
There is no limit of the number of elif statements but only a single (and
optional) else statement is allowed and it must be the last branch in the
statement:
if choice == 'a':
function_a()
elif choice == 'b':
function_b()
elif choice == 'c':
function_c()
else:
print "Invalid choice."
Each condition is checked in order. If the first is false, the next is checked, and so
on. If one of them is true, the corresponding branch executes, and the statement
ends. Even if more than one condition is true, only the first true branch executes.
3.8. Nested conditionals
One conditional can also be nested within another. We could have written the
trichotomy example as follows:
if x == y:
print x, "and", y, "are equal"
else:
if x < y:
print x, "is less than", y
else:
print x, "is greater than", y
Oyelade, O. J. and Isewon I – H3AbioNet Postgraduate course, 2014
Page 5
The outer conditional contains two branches. The first branch contains a simple
output statement. The second branch contains another if statement, which has two
branches of its own. Those two branches are both output statements, although they
could have been conditional statements as well.
Logical operators often provide a way to simplify nested conditional statements.
For example, we can rewrite the following code using a single conditional:
if 0 < x:
if x < 10:
print "x is a positive single digit."
The print statement is executed only if we make it past both the conditionals, so
we can use the and operator:
if 0 < x and x < 10:
print "x is a positive single digit."
These kinds of conditions are common, so Python provides an alternative syntax
that is similar to mathematical notation:
if 0 < x < 10:
print "x is a positive single digit."
This condition is semantically the same as the compound boolean expression and
the nested conditional.
3.9. The return statement
The return statement allows you to terminate the execution of a function before
you reach the end. One reason to use it is if you detect an error condition:
def print_square_root(x):
if x <= 0:
print "Positive numbers only, please."
return
result = x**0.5
print "The square root of", x, "is", result
The function print_square_root has a parameter named x. The first thing it
does is check whether x is less than or equal to 0, in which case it displays an error
Oyelade, O. J. and Isewon I – H3AbioNet Postgraduate course, 2014
Page 6
message and then uses return to exit the function. The flow of execution
immediately returns to the caller, and the remaining lines of the function are not
executed.
3.10. Keyboard input
In Input we were introduced to Python’s built-in functions that get input from the
keyboard: raw_input(for ver. 2.6 and below) and input.
When either of these functions are called, the program stops and waits for the user
to type something. When the user presses Return or the Enter key, the program
resumes and raw_input returns what the user typed as a string:
>>> my_input = raw_input()
What are you waiting for?
>>> print my_input
What are you waiting for?
Before calling raw_input, it is a good idea to print a message telling the user
what to input. This message is called a prompt. We can supply a prompt as an
argument to raw_input:
>>> name = raw_input("What...is your name? ")
What...is your name? Oyelade
>>> print name
Oyelade
Notice that the prompt is a string, so it must be enclosed in quotation marks.
If we expect the response to be an integer, we can use the input function which
evaluates the response as a Python expression:
prompt = "What...is the airspeed velocity of an unladen
swallow?\n"
speed = input(prompt)
If the user types a string of digits, it is converted to an integer and assigned to
speed. Unfortunately, if the user types characters that do not make up a valid
Python expression, the program crashes:
>>> speed = input(prompt)
Oyelade, O. J. and Isewon I – H3AbioNet Postgraduate course, 2014
Page 7
What...is the airspeed velocity of an unladen swallow?
What do you mean, an African or a European swallow?
...
SyntaxError: invalid syntax
Note: In this last example, if the user had made the response a valid Python
expression by putting quotes around it, it would not have given an error:
>>> speed = input(prompt)
What...is the airspeed velocity of an unladen swallow?
"What do you mean, an African or a European swallow?"
>>> speed
'What do you mean, an African or a European swallow?'
>>>
To avoid this kind of error, it is a good idea to use raw_input to get a string and
then use conversion commands to convert it to other types.
3.11. Type conversion
Each Python type comes with a built-in command that attempts to convert values
of another type into that type. The int(ARGUMENT) command, for example,
takes any value and converts it to an integer, if possible, or complains otherwise:
>>> int("32")
32
>>> int("Hello")
ValueError: invalid literal for int() with base 10:
'Hello'
int can also convert floating-point values to integers, but remember that it
truncates the fractional part:
>>>
-2
>>>
3
>>>
42
>>>
1
int(-2.3)
int(3.99999)
int("42")
int(1.0)
Oyelade, O. J. and Isewon I – H3AbioNet Postgraduate course, 2014
Page 8
The float(ARGUMENT) command converts integers and strings to floatingpoint numbers:
>>> float(32)
32.0
>>> float("3.14159")
3.14159
>>> float(1)
1.0
The str(ARGUMENT) command converts any argument given to it to type
string:
>>> str(32)
'32'
>>> str(3.14149)
'3.14149'
>>> str(True)
'True'
>>> str(true)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'true' is not defined
str(ARGUMENT) will work with any value and convert it into a string. As
mentioned earlier, True is boolean value; true is not.
For boolean values, the situation is especially interesting:
>>> bool(1)
True
>>> bool(0)
False
>>> bool("Ni!")
True
>>> bool("")
False
>>> bool(3.14159)
True
>>> bool(0.0)
False
Oyelade, O. J. and Isewon I – H3AbioNet Postgraduate course, 2014
Page 9
Python assigns boolean values to values of other types. For numerical types like
integers and floating-points, zero values are false and non-zero values are true. For
strings, empty strings are false and non-empty strings are true.
Exercises
1. Try to evaluate the following numerical expressions in your head, then use
the Python interpreter to check your results:
>>>
>>>
>>>
>>>
>>>
>>>
>>>
5 % 2
9 % 5
15 % 12
12 % 15
6 % 6
0 % 7
7 % 0
What happened with the last example?
if x < y:
print x, "is less than", y
elif x > y:
print x, "is greater than", y
else:
print x, "and", y, "are equal"
2. Wrap this code in a function called compare(x, y). Call compare
three times: one each where the first argument is less than, greater than, and
equal to the second argument.
3. To better understand boolean expressions, it is helpful to construct truth
tables. Two boolean expressions are logically equivalent if and only if they
have the same truth table.
The following Python script prints out the truth table for any boolean
expression in two variables: p and q:
expression = raw_input("Enter a boolean expression
in two variables, p and q: ")
Oyelade, O. J. and Isewon I – H3AbioNet Postgraduate course, 2014
Page 10
print " p
q
length = len( " p
print length*"="
%s"
q
% expression
%s" % expression)
for p in True, False:
for q in True, False:
print "%-7s %-7s %-7s" % (p, q,
eval(expression))
Copy this program to a file named p_and_q.py, then run it from the
command line and give it: p or q, when prompted for a boolean
expression. You should get the following output:
p
q
p or q
=====================
True
True
True
True
False
True
False
True
True
False
False
False
Now that we see how it works, let’s wrap it in a function to make it easier to
use:
def truth_table(expression):
print " p
q
%s"
length = len( " p
q
expression)
print length*"="
% expression
%s" %
for p in True, False:
for q in True, False:
print "%-7s %-7s %-7s" % (p, q,
eval(expression))
We can import it into a Python shell and call truth_table with a string
containing our boolean expression in p and q as an argument:
>>> from p_and_q import *
>>> truth_table("p or q")
p
q
p or q
Oyelade, O. J. and Isewon I – H3AbioNet Postgraduate course, 2014
Page 11
=====================
True
True
True
True
False
True
False
True
True
False
False
False
>>>
Use the truth_table functions with the following boolean expressions,
recording the truth table produced each time:
1.
2.
3.
4.
5.
not(p or q)
p and q
not(p and q)
not(p) or not(q)
not(p) and not(q)
Which of these are logically equivalent?
4. Enter the following expressions into the Python shell:
True or False
True and False
not(False) and True
True or 7
False or 7
True and 0
False or 8
"happy" and "sad"
"happy" or "sad"
"" and "sad"
"happy" and ""
if choice == 'a':
function_a()
elif choice == 'b':
function_b()
elif choice == 'c':
function_c()
else:
Oyelade, O. J. and Isewon I – H3AbioNet Postgraduate course, 2014
Page 12
print "Invalid choice."
5. Wrap this code in a function called dispatch(choice). Then define
function_a, function_b, and function_c so that they print out a
message saying they were called. For example:
def function_a():
print "function_a was called..."
Put the four functions ( dispatch, function_a, function_b, and
function_c into a script named mod03e05.py. At the bottom of this
script add a call to dispatch('b'). Your output should be:
function_b was called...
Finally, modify the script so that user can enter ‘a’, ‘b’, or ‘c’. Test it by
importing your script into the Python shell.
6. Write a function named is_divisible_by_3 that takes a single integer
as an argument and prints “This number is divisible by three.” if the
argument is evenly divisible by 3 and “This number is not divisible by
three.” otherwise.
Now write a similar function named is_divisible_by_5.
7. Generalize the functions you wrote in the previous exercise into a function
named is_divisible_by_n(x, n) that takes two integer arguments
and prints out whether the first is divisible by the second. Save this in a file
named mod03e07.py. Import it into a shell and try it out. A sample
session might look like this:
>>> from mod03e07 import *
>>> is_divisible_by_n(20, 4)
Yes, 20 is divisible by 4
>>> is_divisible_by_n(21, 8)
No, 21 is not divisible by 8
8. What will be the output of the following?
if "Ni!":
print 'We are the Knights who say, "Ni!"'
Oyelade, O. J. and Isewon I – H3AbioNet Postgraduate course, 2014
Page 13
else:
print "Stop it! No more of this!"
if 0:
print "And now for something completely
different..."
else:
print "What's all this, then?"
Explain what happened and why it happened.
Oyelade, O. J. and Isewon I – H3AbioNet Postgraduate course, 2014
Page 14