Python Expressions¶

Read time: 31 minutes (7938 words)

Text: Chapter 2, section 2.6, 2.7

We have played at a low level with a fair amount of Python, but it is time to get into details at a more complete level. Let’s start With a simple assignment statement, and move into expressions.

We have seen a basic assignment statement. It is formed by naming a container to receive a value on the left hand side of an assignment operator, which is just the familiar equal sign (=). What goes on the right hand side can be a simple value (actually, it is called a literal value because it is literally there), or it can be a more complex expression, something we will get to in a bit.

It is common to put a value into a container another way. Very few useful programs can be written by just assigning values to containers then manipulating those containers. Instead, we want to let the user of the program decide what values we should use when the program is run.

Python has a simple statement that lets the user do just that. It looks like this:

x = input("Enter the price of the car: ")


This statement looks a bit like a simple assignment statement, but it involves another of those funny function things. This one, the input function, wants a string as a parameter. The string should be a message to the user telling them what to enter. Whatever they type will be placed in the container on the left.

There is a problem with this, will the user type in what you told them to enter? Well, if your users are anything like those I have run into, the answer is a big NO!. They will do whatever they like. Python deals with this by accepting whatever they type in as a string, even if that input is actually a nice number. In order to put that string into a container we intend to use as a number, we need to ask Python to convert it for us. That is done by using a special fnnction whose name is the type of the number we want. In this case, since we want to allow dollars and cents in the price, we will use the float function. (If we want to chop off the fractional part, we would use the int function).

price = input("enter the price of the car: ")
price = float(price)


Is there anything wrong with using the same variable twice in this code? Actually, no. In the first line we get a string from the user and save it in a container named price. In the second line, we retrieve that string, hand it to the float function and put whatever comes back into the same container. Python lets this happen without complaining. Any container can hold anything Python can set up. That is kind of nice when you are learning, but it is also a source of problems if you are not careful.

It is up to you to know what is in a given container at any time. If you forget, you can ask Python to tell you by using the type function.

>>> price = input("Enter the price of the car: ")
Enter the price of the car: 10000.00
>>> print (type(price))
<class 'str'>
>>> price = float(price)
>>> print(type(price))
<class 'float'>


Wow, did you see that? I put a function call inside another function call. Perhaps we need to study this a bit more.

Dealing with problems¶

In the above example, we assumed that the user actually typed in a good number. What happens if they do something funny?

>>> price = input("Enter the price of the car: ")
Enter the price of the car: 123,456.78
>>> price = float(price)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: could not convert string to float: '123,456.78'


This response is called an exception, meaning that Python cannot figure out what to do. That simple comma, something we humans might do automatically, is a problem here! For the present, we will assume that users do what we ask them to do (not a good idea in real life). We will see what we can do about this kind of problem later on.

Expressions¶

An expression is just a series of Python components that consist of numbers, math operators and variables we set up to hold interesting data. Where expressions can go in a program is kind of interesting. The answer is basically simple. An expression can go any place Python wants to obtain a single value that it can use for some purpose. If we put an expression in that spot, Python will stop what it is doing and evaluate the expression to reduce it to a value it can use.

As we saw in the last example above, this can get pretty interesting. The print function wants a single parameter to print. Instead, we gave it the name of a function to activate first, so it stopped and asked that function to do its job and give us back a value to print. The second function needed a parameter, so we gave it the name of a variable. When the second function got done, the value it handed back was the thing finally printer. In this case, it was a funny looking string. Phew!

A more normal expression¶

Here is a common example:

a = 5
b = 6
c = a + b


The first two lines are simple assignments of a value to a variable. The last line has an expression in it. The expression is the thing on the right-hand side of the assignment operator (the equal sign). The expression is a simple mathematical addition of two terms. In this example the terms are just the names of variables we created above this expression. Python will look into the containers it set up to hold values when we defined the variables and pull out the current value stored there. (Remember that those containers are called variables for a reason. That value might change as the program runs!)

Once both terms have been looked up, the math plus operator (+) tells Python to add the two terms producing a single result that is the sum of the two values. That final value is placed in the container named c. Simple enough.

Expressions can get more complex and involve more operators. For now, let’s concentrate on the big four:

• + - addition
• - - subtraction
• * - multiplication
• / - division
• // - integer division (no fraction!)

That last one is odd in that we might not want to produce a result with a fraction. We control this by picking the right operator.

Operator precedence¶

There is something about the way computers evaluate expressions that catches beginners off guard. Each operator has a precedence which is a fancy term for importance in an expression. We always do the important operations first, then the less important after that according to the precedence rules. This is not so bad, but you must remember it to make sure you do the right math!

In our big four (OK five) the precedence rules are these:

• Multiply and division have identical precedence and have the highest precedence (importance)
• addition and subtraction are equal, and lower in precedence

So how do we evaluate something like this:

d = a + 2 * b


A typical beginner would do the addition first, then the multiply. It is common to work from left to right, since that is the way we read (here at least). However, the multiply operator has a higher precedence so it should happen first. Plugging in the current values from our code above this is what python would do:

d = 5 + 2 * 6
d = 5 + 12
d = 17


Using parentheses to force things¶

Suppose we really wanted Python to add two to the current value of a, then do the multiplication. How can we make that happen?

Here is how:

d = (a + 2) * b


Now the rules are a bit different. We always evaluate everything inside paremtheses before applying any precedence rules for operators outside those parentheses. If we have multiple operators inside the parentheses, the normal rules apply as we evaluate the sub-expression, just like before. Phew.

We can have multiple levels of parentheses. When you do this, you get into trouble fast. It is a common mistake to have unbalanced parentheses. There must be as many open parentheses marks as close parentheses marks, and they must not overlap wrongly.

What do you thing this will do?

>>> a = (5 * ( 3 + ( 7 / 2 + 6) * 2)
...


OK, that was a test. Now evaluate this:

>>> a = (5 * ( 3 + ( 7 / 2 + 6) * 2))
>>> print(a)
110.0


Did you figure it out, or did you just let Python do the thinking?

Other operators¶

Python has a few other operators you can use.

The exponential operator¶

Suppose you want to raise some number to a power. You can use the ** operator

>>> print(3 ** 2)
9


Hmmm:

print(9 ** 0.5)
3.0


The remainder operator¶

Sometimes it is handy to figure out the remainder after division, where we are doing integer division.

>>> print( 7/2 )
3.5
>>> print( 7 // 2)
3
>>> print(7 % 3)
1


That % operator is called the modulus operator (or just mod). Most languages have this one.

When would this be useful? A common situation is printing out a bunch of text and wanting to cause some additional lines to be skipped when the page gets full. The % operator will produce a zero result when the division has no remainder. So, if we wanted to do something every 77 lines, we might do this:

if (num_lines % 77) == 0:
# print extra stuff


Note

We will get into logical expressions soon

Another example is converting time in seconds to hours, minutes and seconds (see the book for examples of this).