Week 3: Booleans, Conditionals, and Strings
Lab 2 available now.
Quiz 1 Study guide available on course home page.
Quiz 1 Friday at start of class.
Wednesday Ninja session good time to review.
Boolean Logic and Relational Operators
Our programs in the first week were entirely sequential. Each statement was
processed immediately after the preceding line. In week two, we added the
loop to allow us to repeat a task a fixed number of times. This week we will
introduce a new type, the Boolean type and show how to use it with branching
or decision structures to optionally run code based on various conditions.
Booleans and conditionals represent another computational tool we will use
throughout the semester to design algorithms for problems.
The Boolean or
bool type can only hold two possible values:
False. Note in Python, both of these values begin with an upper case letter
and the values do not have quotes around them. The value
"True" (with quotes)
is a string, not a Boolean.
One way to generate a Boolean value is to use one of the relational operators
listed below. For example, the operator
< compares two variables or expressions
left < right. If the value of
left is smaller than
right, the expression
right evaluates to
True, otherwise, the answer is
Python’s relational operators are:
less than or equal to
greater than or equal to
not equal to
Note that to check if two expressions are equal, you must use the
x == 7. Using
x = 7 in Python has a different semantic meaning — it
performs a variable assignment and stores the value of 7 in the container
Exercise: practice relational operators
What are the
bool values that result from the following expressions? Assume
x = 10. First, try to predict the value, then you can check your answers in
an interactive Python shell by typing
python3 in the terminal.
x < 10 x >= 10 x != 15 x + 15 <= 20 x % 2 == 1
% is the mod or remainder operator.
x % y returns the remainder when
x is divided by
y using integer division.
Branching with if
Programmers use branching, or conditional statements, to run different code
based on the state of the program. The simplest form of branching is an
if <condition>: <body>
<condition> should be a statement that evaluates to a Boolean value.
The code inside the
<body> only runs if the condition is
True. Here’s an
example program that warns you only if the temperature is below freezing:
def main(): temp = int(input("Enter temperature: ")) if temp < 32: print("Freezing temperatures; be sure to wear a coat!") print("Have a great day!") main()
Note the use of the
: as we saw at the end of
for loops and the
function. Like those constructs, the
<body> of an
if must be indented to
indicate that it should execute together as part of the
Other Branching Structures
In addition to the basic
if statement, Python supports two additional
if/elif/else. The general form of the
if <condition>: <body> else: <else-body>
Again, if the
<condition> evaluates to
True, Python executes the code in
<body>. However, if the condition is
False, Python executes the code in
<else-body> instead. Regardless of the value of
<condition>, exactly one
<else-body> will run, but not both. It is possible to have an
if with no
else, but any
else must be paired with a matching
We could modify the program above to print a different message if
above freezing. Regardless of the
temp value, the program will always print
Have a great day! since this message is printed outside the body of either
if or the
else as noted by the indentation.
def main(): if temp < 32: print("Freezing temperatures; be sure to wear a coat!") else: print("Spring is on its way!") print("Have a great day!") main()
The final, most complex branching variant is the
if <cond-1>: <body-1> elif <cond-2>: <body-2> elif <cond-3>: <body-3> ... else: <else-body>
All of these statements work together as one large decision block. Python will
<cond-1> and if it’s
True, it will execute
skip over the remaining bodies in the block. If
will next evaluate
<cond-2>. If that is
True, it will execute
and then skip over all the remaining bodies in the block. We can continue to
elif conditions and bodies, but each condition will only be
evaluated if all the other previous conditions were
False. Finally if all
the condition checks evaluate to
False, Python executes the
there is one. You can have an
if/elif/elif/… with no final
In summary, a decision block has a mandatory
if <condition>: at the
beginning, and optional
else: at the end, and zero or more
statements in the middle.
Exercise: practice if statements
if/else statements by writing a block of code (in
cs21/inclasss/w03/voting.py) that determines if a person’s age makes them
eligible to vote (18 or older on election day).
Some potential output might look like:
$ python voting.py Enter your age on election day: 20 You are eligible to vote $ python voting.py Enter your age on election day: 18 You are eligible to vote $ python voting.py Enter your age on election day: 2 You can't vote this year You will need to wait 16 years
Exercise: Code tracing
Code tracing is when you run through code in your head and try to determine the result. I have provided three blocks (the last purposefully being harder than the other two). What will each of these blocks do? Do they give different results, or are some of them equivalent in terms of what they print?
#Block 1 if temp >= 60: print("No coat is needed") if temp >= 40: print("Spring jacket")
#Block 2 if temp >= 60: print("No coat is needed") elif temp >= 40: print("Spring jacket")
#Block3 if temp >= 40: if temp >= 60: print("No coat is needed") else: print("Spring jacket")
In many programs, it’s convenient to ask compound questions or require multiple
True before executing some code. In these cases, we can join to
questions together using a logical operator:
both boolean expressions must be true
at least one of the two boolean expressions must be true
negates the boolean value
Below is a truth table, where
y represent Boolean values or
expressions. For example,
x could be
age >= 18 and
y could be
"Yes". Each row should be read as follows: for the given Boolean values of
y, what is the result of
x and y,
x or y, and
|x||y||x and y||x or y||not x|
Python’s precedence rules evaluate operators in this order:
Evaluate anything inside of ()
Evaluate all relational operators
Apply any not operators
Evaluate and operators
Evaluate or operators.
If tied, evaluate left to right.
For example, suppose
b = 5 and
c = 10 and a program encounters this line:
not True or b < 10 and c != 5
Python first evaluates
b < 10 (
c != 5 (True). Thus, we can simplify the line to:
not True or True and True
Next, Python evaluates
not True (
False or True and True
Next, it evaluates the
True and True clause, which is also
True. All that’s left is:
False or True
Finally, Python evaluates the
or, whose result is
Exercise: Logic Tests
For this exercise, use the program
logicTests.py to test your understanding of logical operators. You do not need to write any code for this exercise, just run the program and follow the prompts.
$ python3 logicTests.py
Exercise: Water Phase
Write a program in
phase.py that, given a temperature in °C, prints the phase of water at that temp assuming standard pressure.
$ python3 phase.py Enter a temp in °C: 150 At 150C, water is a gas $ python3 phase.py Enter a temp in °C: 20 At 20C, water is a liquid $ python3 phase.py Enter a temp in °C: -10 At -10C, water is a solid
We can compare string values just as we can compare integer and float values. That is, we can use any relational operator on a pair of a strings.
"Aardvark" < "Baboon"
Strings in python3 are compared lexicographically, i.e., based on their sorted dictionary order. So, the above expression is
Aardvark appears earlier in the dictionary than
Python actually compares the two strings character-by-character until it finds a difference. So, it will first compare
B. It finds that they are different, and so it returns True. If the expression is:
"Apple" < "Applied"
Python first compares the
A s, then each
p, then the
l s , and finally stops at the next position since
i are different. Since
e comes before
i in the alphabet, the expression returns True.
What if we had:
"apple" < "APPLE"
What does Python do here? Internally, everything in the computer is represented numerically in binary (0s and 1s). So, even text is really represented as a series of numbers (positive integers, specifically). The encoding, or conversion, is known as Unicode. We can find the conversion using the
$ python3 Python 3.5.2 (default, Nov 23 2017, 16:37:01) [GCC 5.4.0 20160609] on linux Type "help", "copyright", "credits" or "license" for more information. >>> ord('A') 65 >>> ord('B') 66 >>> ord('Z') 90 >>> ord('!') 33
So to answer our question above, we need to compare the Unicode value of
A is a small Unicode value, so the expression is
We can also convert in the other direction - from a number to a character using the
>>> chr(58) ':' >>> chr(100) 'd' >>> chr(75) 'K'
Substrings, in operator
A substring of a string is a portion of the string that appears contiguously. For example,
blue is a substring of
blueberries. Python has some commands for accessing substrings.
The most relevant for us right now is the
in takes a substring called the pattern and another string commonly called the target, and returns
True if and only if the pattern appears as a substring in the target.
Sometimes, the pattern can be a single letter, but in general, the pattern can be any string.
>>> 'a' in "apples" True >>> 'b' in "apples" False >>> "vark" in "Aardvark" True >>> "bbrries" in "blueberries" False
The print statement is nice for outputting, but it is difficult to format the output in a way we prefer. For example, every time we put out a dollar amount, we can’t guarantee two digits after the decimal point for the cents and we also have to always leave a space between the dollar sign and the amount. String formatting allows us to define string templates:
String formatting also enables optional width and precision values:
Format a number to a string with ten spaces minimum.
precision (float only )
Require exactly two digits after a decimal point.
An example, if we print out the float variable
pi from the math library:
>>> from math import pi >>> print(pi) 3.14159265359 >>> print("Pi is %f|" % (pi)) Pi is 3.141593| >>> print("Pi is %.2f|" % (pi)) Pi is 3.14| >>> print("Pi is %20.2f|" % (pi)) Pi is 3.14| >>> print("Pi is %-20.2f|" % (pi)) Pi is 3.14 |
You can combine multiple templates in a single string format:
item = "dozen eggs" qty = 4 price = 2.79 print("%d %s cost $%.2f" % (qty, item, qty*price) )
Another syntactic tool for designing programs in Python is the
You’ve previously seen
for loops, Boolean types, and
if statements. The
while loop is a mix of these three concepts. A typical
for loop executes
for a definite number of times. For example, programmers decide in advance to
loop over things like finite lists,
range() results, or the length of a
What if we are expecting a user to enter input in a specific format (e.g., a
positive integer, a valid date, or a string with no punctuation)? We could
trust the user not to make a mistake, but this approach is not very robust.
Instead, if we detect that a user made a mistake in typing input, we could
prompt the user again. But how many times should we ask? Once? Twice? 100
times? With a
for loop, you’d have to set the number in advance.
while loop can solve these types of computational problems by repeatedly
looping until a Boolean condition is met. The general syntax of a
while loop is:
while <CONDITION>: <BODY>
The <CONDITION> is a Boolean expression. When the condition evaluates to
True, the body of the loop will execute and then re-evaluate the condition.
When the condition finally evaluates to
False, Python skips the body of the
loop and executes the next line after the body.
Note that a
for loop can often be written as an equivalent
Let’s look at some examples in
While Loop Exercise (challenging)
while loops, using conditional, and formatting strings in a
echo.py. The program should repeatedly prompt the user for an
input string. If the user types anything other than
quit, you should print
their message back with a counter of how many times you’ve "echoed" a message:
$ python3 echo.py Enter a string: hello Echo #1: hello Enter a string: test string Echo #2: test string Enter a string: quit program terminates
while loop to continue asking the user for strings indefinitely until
quit, and try using string formatting to print the
Echo # …