Lesson 4: More operators and conditionals

(c) 2016 Justin Bois. This work is licensed under a Creative Commons Attribution License CC-BY 4.0. All code contained herein is licensed under an MIT license.

This tutorial was generated from a Jupyter notebook. You can download the notebook here.

In this tutorial, we will examine more operators beyond the arithmetic and assignment operators we have already encountered. We'll look at relational operators, identity operators, and logical operators. We'll use these operators in conditional statements, which help a program decide what to do in certain situations. We will also start using Atom .py files that we will then run.

Relational operators

Suppose we want to compare the values of two numbers. We may want to know if they are equal for example. The operator used to test for equality is a ==, an example of a relational operator (also called a comparison operator).

The equality relational operator

Let's test out the == to see how it works.

In [1]:
5 == 5
Out[1]:
True
In [2]:
5 == 4
Out[2]:
False

Notice that using the operator gives either True or False. These are important keywords in Python that indicate truth. True and False have a special type, called bool, short for Boolean.

In [3]:
type(True)
Out[3]:
bool
In [4]:
type(False)
Out[4]:
bool

Now, let's try it out with some floats.

In [5]:
5.3 == 5.3
Out[5]:
True
In [6]:
2.1 + 3.2 == 5.3
Out[6]:
False

Yikes! Python is telling us that 2.1 + 3.2 is not 5.3. This is floating point arithmetic coming back to haunt us! Note that some floating point numbers that can be exactly represented with binary numbers do not have this problem.

In [7]:
2.2 + 3.2 == 5.4
Out[7]:
True

This behavior is unpredictable, so here is a rule.

Never use the `==` operator with floats.

Other relational operators

As you might expect, there are other relational operators. The relational operators are

English Python
is equal to ==
is not equal to !=
is greater than >
is less than <
is greater than or equal to >=
is less than or equal to <=

We can try some of them out!

In [8]:
4 < 5
Out[8]:
True
In [9]:
5.7 <= 3
Out[9]:
False
In [10]:
'steph curry' > 'lebron james'
Out[10]:
True

Whoa. What happened on that last one? The Python interpreter clearly thinks Steph Curry is better than LeBron James, but that seems kind of subjective. Yes, Steph Curry was unanimously voted MVP, but LeBron won the title. To understand what the interpreter is doing, we need to understand how it compares strings.

A brief aside on Unicode

In Python, characters are encoded with Unicode. This is a standardized library of characters from many languages around the world that contains over 100,000 characters. Each character has a unique number associated with it. We can access what number is assigned to a character using Python's built-in ord() function.

In [11]:
ord('a')
Out[11]:
97
In [12]:
ord('λ')
Out[12]:
955

The relational operators on characters compare the values that the ord function returns. So, using a relational operator on 'a' and 'b' means you are comparing ord('a') and ord('b'). When comparing strings, the interpreter first compares the first character of each string. If they are equal, it compares the second character, and so on. So, the reason that 'steph curry' > 'lebron james' gives a value of True is because ord('s') > ord('l').

Note that a result of this scheme is that testing for equality of strings means that all characters must be equal. This is the most common use case for relational operators with strings.

In [13]:
'lebron' == 'lebron james'
Out[13]:
False
In [14]:
'lebron' == 'LeBron'
Out[14]:
False
In [15]:
'LeBron James' == 'LeBron James'
Out[15]:
True
In [16]:
'AGTCACAGTA' == 'AGTCACAGCA'
Out[16]:
False

Chaining relational operators

Python allow chaining of relational operators.

In [17]:
4 < 6 < 6.1 < 9.3
Out[17]:
True
In [18]:
4 < 6.1 < 6 < 9.3
Out[18]:
False

This is convenient do to. However, it is important not to do the following, even though it is legal.

In [19]:
4 < 6.1 > 5
Out[19]:
True

In other words, do not mix the direction of the relational operators. You could run into trouble because, in this case, 5 and 4 are never compared. An expression with different relations among all three numbers also returns True.

In [20]:
4 < 6.1 > 3
Out[20]:
True

So, I issue a warning.

Do not mix the directions of chained relational operators.

Identity operators

Identity operators check to see if two variables occupy the same space in memory; i.e., they are the same object (we'll learn more about objects as we go along in the bootcamp). This is different that the equality relational operator, ==, which checks to see if two variables have the same value. The two identity operators are in the table below.

English Python
is the same object is
is not the same object is not

That's right. The operators are pretty much the same as English! Let's see these operators in action and get at the difference between == and is.

In [21]:
str_1 = 'Hello, world.'
str_2 = 'Hello, world.'

str_1 == str_2, str_1 is str_2
Out[21]:
(True, False)

So, even though str_1 and str_2 have the same value, they do not occupy the same place in memory. Here are a few more examples.

In [22]:
str_1 = 'Hello, world.'
str_2 = str_1

str_1 == str_2, str_1 is str_2
Out[22]:
(True, True)
In [23]:
a = 5.6
b = 5.6

a == b, a is b
Out[23]:
(True, False)
In [24]:
a = 5.6
b = a

a == b, a is b
Out[24]:
(True, True)
In [25]:
a = 5.6
b = a
a = 6.1

a == b, a is b
Out[25]:
(False, False)

In the last two examples, we see that assigning b = a, where a is a float in this case, means that a and b occupy the same memory. However, reassigning the value of a resulted in the interpreter placing a in a new space in memory. We can double check the values.

In [26]:
a, b
Out[26]:
(6.1, 5.6)

This automatic reassigning happens with immutable variables. This means that once the variables are created, their values cannot be changed. If we do change the value, as we did by setting a = 6.1, the variable gets a new place in memory. All variables we've encountered so far, ints, floats, and strs, are immutable. We will see encounter mutable data types in future lessons.

Logical operators

Logical operators can be used to connect relational and identity operators. Python has three logical operators.

Logic Python
AND and
OR or
NOT not

The and operator means that if both operands are True, return True. The or operator gives True if either of the operands are True. Finally, the not operator negates the logical result.

That might be as clear as mud to you. It is easier to learn this, as usual, by example.

In [27]:
True and True
Out[27]:
True
In [28]:
True and False
Out[28]:
False
In [29]:
True or False
Out[29]:
True
In [30]:
True or True
Out[30]:
True
In [31]:
not False and True
Out[31]:
True
In [32]:
not(False and True)
Out[32]:
True
In [33]:
not False or True
Out[33]:
True
In [34]:
not (False or True)
Out[34]:
False
In [35]:
7 == 7 or 7.6 == 9.1
Out[35]:
True
In [36]:
7 == 7 and 7.6 == 9.1
Out[36]:
False

I think these example will help you get the hang of it. Note that it is important to specify the ordering of your operations, particularly when using the not operator.

Note also that

a < b < c

is equivalent to

(a < b) and (b < c)

With these new type of operators in hand, we can construct a more complete table of operator precedence.

precedence operators
1 **
2 *, /, //, %
3 +, -
4 <, >, <=, >=
5 ==, !=
6 =, +=, -=, *=, /=, **=, %=, //=
7 is, is not
8 and, or, not

Operators we left out

We have left out a few operators in Python. Two that we left out are the membership operators, in and not in, which we will visit in a forthcoming lesson. The others we left out are bitwise operators and operators on sets, which we will not be covering in the bootcamp.

The numerical values of True and False

As we move to conditionals, it is important to take a moment to evaluate the numerical values of the keywords True and False. They have numerical values of 1 and 0, respectively.

In [37]:
True == 1
Out[37]:
True
In [38]:
False == 0
Out[38]:
True

You can do arithmetic on True and False, but you will get implicit type conversion.

In [39]:
True + False
Out[39]:
1
In [40]:
type(True + False)
Out[40]:
int

.py files

We already say .py files in lesson 1, but now that we're going to use them in earnest, let's revisit them briefly.

We now move out of one-liners that we can just enter at an IPython prompt and evaluate. We will be preparing multi-line sets of instructions and then running them. We store the code in Python source files. These are standard text files with a .py suffix. You can create them using Atom. To run the contents of the file (after saving it), you enter %run filename.py at an IPython prompt. So, if I have a file that I saved as

/Users/Justin/bootcamp/my_python_file.py

I need to be sure I am in the directory /Users/Justin/bootcamp/ and then, at an IPython prompt, do

%run my_python_file.py

Unless you are using Python as a fancy desktop calculator, you will invariably be writing .py files.

For our first .py file, we will write a simple conditional. We will then run our .py file in the IPython console. We will be learning coding in this way for the rest of the bootcamp, as our expressions become more and more sophisticated.

Conditionals

Conditionals are used to tell your computer to do a set of instructions depending on whether or not a Boolean is True. In other words, we are telling the computer:

if something is true:
    do task a
otherwise:
    do task b

In fact, the syntax in Python is almost exactly the same. As an example, let's ask whether or not a codon is the canonical start codon (AUG).

In [41]:
codon = 'AUG'

if codon == 'AUG':
    print('This codon is the start codon.')

This codon is the start codon.

The syntax of the if statement is apparent in the above example. The Boolean expression, codon == 'AUG', is called the condition. If it is True, the indented statement below it is executed. This brings up a very important aspect of Python syntax.

Indentation matters.

Any lines with the same level of indentation will be evaluated together.

In [42]:
codon = 'AUG'

if codon == 'AUG':
    print('This codon is the start codon.')
    print('Same level of intentation, so still printed!')

This codon is the start codon.
Same level of intentation, so still printed!

What happens if our codon is not the start codon?

In [43]:
codon = 'AGG'

if codon == 'AUG':
    print('This codon is the start codon.')

Nothing is printed. This is because we did not tell Python what to do if the Boolean expression codon == 'AUG' evaluated False. We can add that with an else clause in the conditional.

In [44]:
codon = 'AGG'

if codon == 'AUG':
    print('This codon is the start codon.')
else:
    print('This codon is not the start codon.')

This codon is not the start codon.

Great! Now, we have a construction that can choose which action to take depending on a value. So, if we're zooming along an RNA sequence, we could pick out the start codon and infer where translation would start. Now, what if we want to know if we hit a canonical stop codon (UAA, UAG, or UGA)? We can nest the conditionals!

In [45]:
codon = 'UAG'

if codon == 'AUG':
    print('This codon is the start codon.')
else:
    if codon == 'UAA' or codon == 'UAG' or codon == 'UGA':
        print('This codon is a stop codon.')
    else:
        print('This codon is neither a start nor stop codon.')

This codon is a stop codon.

Notice that the indentation defines which clause the statement belongs to. E.g., the second if statement is executed as part of the first else clause.

While this nesting is very nice, we can be more concise by using an elif clause.

In [46]:
codon = 'UGG'

if codon == 'AUG':
    print('This codon is the start codon.')
elif codon == 'UAA' or codon == 'UAG' or codon == 'UGA':
    print('This codon is a stop codon.')
else:
    print('This codon is neither a start nor stop codon.')

This codon is neither a start nor stop codon.