Working with variables
- 1/19/2018
- What you will learn
- Variables in Python
- Working with text
- Working with numbers
- Weather snaps
- What you have learned
Working with numbers
Convert strings into integer values
The input function returns a string of text, which is fine if we just want to read names. However, it is not so useful if we want to read in numbers. For instance, we might want to modify the egg timer we created in Chapter 2 so that the user can enter the number of seconds that the timer must run. This would allow the user to customize their egg from raw (0 seconds) to hard boiled (600 seconds). Python provides a function called, not surprisingly, int. The int function accepts a string and returns the number in that string.
)
The first statement uses the input function to read in a string from the user. The second statement uses the int function to convert this string into a number that can be used to set the length of time the program sleeps while the egg is cooked. The final egg timer program looks like this:
# EG4-02 User Configurable Egg Timer
import time
time_text = input('Enter the cooking time in seconds: ')
time_int = int(time_text)
print('Put the egg in boiling water now')
time.sleep(time_int)
print('Take the egg out now')
You could use this program anywhere you want to have a configurable timer or alarm. You just change the messages displayed to the user.
CODE ANALYSIS
Reading numbers
Let’s look at this program and consider a few questions.
Question: How many variables are used in the program above?
Answer: There are two variables. One is called time_text and contains a string; the other is called time_int and contains an integer. I didn’t have to use these particular names; I could have called the variables x and y, but I think these names make the program clearer.
Question: Could you write the program without using the time_text variable?
Answer: Yes, I could. The input function returns a string that I could feed directly into the int function.
time_int = int(input('Enter the cooking time in seconds: '))
I’m not a huge fan of compressing programs like this though. They don’t make the program easier to understand, and they have a negligible effect on the speed of the program or the amount of memory used when it runs. This statement would also make it impossible for the program to display the string entered by the user because that string is not stored anywhere.
Question: What do you think will happen if the user enters something other than a number?
Answer: Try it using the Python Shell part of IDLE.
>>> x = int('kaboom')
This Python statement will attempt to convert the string ‘kaboom’ into a number and store it in a variable called x. As you might expect, this will not end well.
Traceback (most recent call last):
File "<pyshell#32>", line 1, in <module>
x = int('kaboom')
ValueError: invalid literal for int() with base 10: 'kaboom'
This looks worrying because it means if the user types in text rather than a number, the program will fail. For now, we’ll just have to live with this problem, but later in the book we’ll look at how our programs can deal with this error and give the user another chance to enter a number.
Whole numbers and real numbers
We know that Python is aware of two fundamental kinds of data—text data and numeric data. Now we need to delve a little deeper into how numeric data works. There are two kinds of numeric data—whole numbers and real numbers. Whole numbers have no fractional part. Up until now, every program that we have written has made use of whole numbers. A computer stores the value of a whole number exactly as entered. Real numbers, on the other hand, have a fractional element that can’t always be held accurately in a computer.
As a programmer, you need to choose which kind of number you want to use to store each value.
CODE ANALYSIS
Whole numbers versus real numbers
You can learn about the difference between whole numbers and real numbers by looking at a few situations in which they might be used.
Question: I’m building a device that can count the number of hairs on your head. Should I store this value as a whole number or as a real number?
Answer: This should be a whole number because there is no such thing as half a hair.
Question: I want to use my hair-counting machine on 100 people and determine the average number of hairs on all their heads. Should I store this value as a whole number or as a real number?
Answer: When we work out the result, we’ll find that the average includes a fractional part, which means that we should use a real number to store it.
Question: I want to keep track of the price of a product in my program. Should I use whole numbers or real numbers?
Answer: This is very tricky. You might think that the price should be stored as a real number—for example, $1.50 (one and a half dollars). However, you could also store the price as the whole number, 150 cents. The type of number you use in a situation like this depends on how that number is used. If you’re just keeping track of the total amount of money you take in while selling your product, you can use a whole number to hold the price and the total. However, if you are also lending money to people to buy your product and you want to calculate the interest to charge them, you would need a fractional component to hold the number more precisely.
PROGRAMMER’S POINT
The way you store a variable depends on what you want to do with it
It seems obvious that you would use a whole number to count the number of hairs on your head. However, one could argue that we could also use a whole number to represent the average number of hairs on 100 people’s heads. This is because the calculated average would be in the thousands. Fractions of a hair would not add much useful information, so we could drop any fractional parts and round to the nearest whole number. When you consider how you are going to represent data in a program, you must take into account how it will be used.
Real numbers and floating-point numbers
Real number types have a fractional part, which is the part of the number after the decimal point. Real numbers are not always stored exactly as they are entered into Python programs. Numbers are mapped to computer memory in a way that stores a value that is as close as possible to the original. The stored data is often called a floating-point representation. You can increase the accuracy of the storage process by using larger amounts of computer memory, but you are never able to hold all real values precisely.
This is not a problem, however. Values such as pi can never be held exactly because they “go on forever.” (I’ve got a book that contains the value of pi to 1 million decimal places, but I still can’t say that this is the exact value of pi. All I can say is that the value in the book is many times more accurate than anyone will ever need.)
When considering how numbers are stored, we need to think about range and precision. Precision sets out how precisely a number is stored. A particular floating-point variable could store the value 123456789.0 or 0.123456789, but it can’t store 123456789.123456789 because it does not have enough precision to hold 18 digits. The range of floating-point storage determines how far you can “slide” the decimal point around to store very large or very small numbers. For example, we could store the value 123,456,700, or we can store 0.0001234567. For a floating-point number in Python, we have 15 to 16 digits of precision, and we can slide the decimal point 308 places to the right (to store huge numbers) or 324 places to the left (to store tiny numbers).
The mapping of real numbers to a floating-point representation does bring some challenges when using computers. It turns out that a simple fraction such as 0.1 (a tenth) cannot be held accurately by a computer because of the way values are held. The value stored to represent 0.1 will be very close to that value, but not the same. This has implications for the way we write programs.
CODE ANALYSIS
Floating-point variables and errors
We can find out more about how floating-point values work by doing some experiments using the Python Shell. If we just type numeric expressions, we can view the results that Python calculates.
Question: What happens if we try to store a value that can’t be held accurately as a floating-point value?
Answer: We know that the value 0.1 can’t be held accurately in a computer, so let’s enter that value into the Python Shell and see what comes back.
>>> 0.1 0.1
At this point, you might think that I’ve been lying to you because I said that the value 0.1 can’t be held accurately, and now this example shows Python returning the value 0.1. However, I’m not lying to you—Python is. The Python print routine “rounds” values when it prints them. In other words, it says that if the number to be printed is 0.10000000000000000551115 or thereabouts (which it is), then it will just print 0.1.
Question: Does this “rounding” really happen?
Answer: At the moment, you’ve just got my word for it that values are rounded when printed and that errors are being hidden from us as a result. However, if we perform a simple calculation, we can introduce an error that is large enough to escape being rounded. Enter the following calculation into the Python Shell and note what comes back.
>>> 0.1+0.2 0.30000000000000004
The result of adding 0.1 to 0.2 should be 0.3. But, because the values are held as binary floating-point values, the result of the calculation contains an error large enough to escape being rounded. It turns out that our highly expensive computer really can’t get its sums right!
You might think that your all-powerful computer should be able to hold all values precisely. It comes as a bit of a shock to discover that this is not true and that a simple pocket calculator can outperform your powerful PC.
However, this lack of accuracy is not a problem in programming because we don’t usually have incoming data that is particularly precise anyway. For example, if I refine my hair counting device to measure hair length, it would be very difficult for me to measure hair length with more than a tenth of an inch (2.4 millimeters) of accuracy. For hair data analysis, we need only around three or four digits of accuracy. It is very unlikely that you will ever process any data that requires the 15 digits that Python can give you.
It is also worth noting at this point that these issues have nothing to do with Python. Most, if not all, modern computers store and manipulate floating-point values using a standard established by the Institute of Electronic and Electrical Engineers (IEEE) in 1985. All programs that run on a computer will manipulate values in the same way, so floating-point numbers in Python are no different from those in any other language.
The only difference between Python floating-point values and those in other languages is that a floating-point variable in Python occupies 8 bytes of memory, which is twice the size of the float type in the languages C, C++, Java, and C#. A Python floating-point variable equates with a double precision value in those languages.
If you really, really want to store things with even more accuracy (and I think this is terribly unlikely), you should look at the decimal and fraction libraries supplied with Python.
PROGRAMMER’S POINT
Don’t confuse precision with accuracy
It is very important to remember that numbers don’t become more accurate just because they are stored with more precision. Scientists in a laboratory measuring the length of ant legs will not be able to do this to more than a few digits of accuracy (unless they have some amazing technology), so there is no point in them using much higher precision to store and process their results. Using higher precision slows down the program and means that the variables take up more space in memory.
CODE ANALYSIS
Working with floating-point variables
We know Python automatically creates variables for use in our programs. The type of a variable is determined by what a program stores in it.
name = 'Rob' age = 25
The above statements create two variables. The variable name is of string type, because it has been assigned a string of text. However, the variable age is of integer type, because it has been assigned an integer.
We can use the Python Shell part of IDLE to learn how floating-point variables work.
Question: How do I create a floating-point variable?
Answer: We can create a floating-point variable by assigning a floating-point expression to the variable.
>>> x = 1.5
This statement creates a floating point variable called x which contains the value 1.5. We can view the contents of the variable by just entering its name.
>>> x 1.5
Question: What happens if I assign an integer to a floating-point variable?
Answer: We can investigate this behavior by creating a new variable.
>>> y = 1.0
This statement creates a variable called y that contains the integer value 1. But is y an integer or floating-point variable? We can find out by viewing the contents of y.
>>> y 1.0
Python has printed out the value with a fractional part (which is zero). This indicates that the value is a floating-point value. In other words, the presence of a decimal point in a printed value tells us that the value is floating point. The value is always floating point when a decimal is included, even if there are no decimal places.
Question: What about floating-point and integer calculations?
Answer: We can investigate the results of calculations by entering a few and then looking at the results.
>>> 2+2 4
Recall from earlier chapters that when we add two integers together, we get an integer result.
>>> 2.0+2.0 4.0
This is the same calculation, but this time Python produces a floating-point result because the operands (the things upon which the + operator is working) are both floating-point values.
>>> 2.0+2 4.0
It turns out that when an expression contains one floating-point value, the result of the calculation is automatically converted to a floating-point value. Generally, if the expression contains integers, it will generate an integer result. If the expression contains one floating-point value, the expression will generate a floating-point result.
One exception to the “integers make integers” rule is when we divide one integer by another.
>>> 1/2 0.5
The above statement divides one integer by another. The / (slash) character is how we denote division in Python programs. In this case, the result of dividing 1.0/2.0 is to produce a floating-point result of 0.5.
WHAT COULD GO WRONG
Python versions and integer division
Integer division in different versions of Python is another situation in which the strangeness of Python makes me tear my hair out. Above, I just told you that dividing an integer by an integer produces a floating-point result. This is true in Python version 3.6, the version we’re using for the examples in this book. However, in Python 2.7, this is not the case. In Python 2.7, the result of dividing an integer by an integer is another integer.
>>> 1/2 0
The value of 1/2 is a half, which can’t be held in an integer, so the result of this calculation is zero in Python 2.7. In fact, any number less than 1 is truncated to zero in this calculation. That means the result of 9/10, which should be 0.9, also turns out to be zero. This can result in sums being quite different from the values we might expect.
This raises the horrible prospect of Python programs that work correctly in Python 3.6 producing completely wrong answers when they run in older versions of Python. This has happened to me on numerous occasions. The best advice I can give is to always put a decimal point on a value if you want it to generate floating-point results when used in calculations.
I feel bad telling you this, but I’d feel worse keeping it a secret. You can get a Python 2 program to behave the same way as Python 3 by telling it to use the updated division routines:
from __future__ import division
You could give this command at the start of a program to make Python 2 division behave the same as Python 3 division.
Convert strings into floating-point values
The float function is used to convert values into floating-point values. A program can use the float function to convert a string of text into a floating-point value. It works in the same way as the int function:
)
The statements above could form the basis of an ultra-precise version of the egg timer program that lets the user time their egg to a fraction of a second. You can find this program in EG4-03 Ultra-precise Egg Timer.
The program works because the sleep function accepts a floating-point value for the duration of the delay.
time.sleep(time_float)
This means we can use the sleep function to create very short delays in programs.
The float function can also be used to convert an integer value into a floating-point value. This can be useful in older Python programs as a way of forcing the correct behavior of the divide operator (see the “What Could Go Wrong: Python Programs and Integer Division” discussion above).
z = float(1)
In the statement above, the variable z will be of type float, even though the value being assigned is an integer.
The behavior of float might seem rather familiar. This is because it behaves similarly to the int function, except that it delivers floating-point results.
Perform calculations
In Chapter 2, we saw that Python expressions are made up of operators and operands. The operators identify actions to be performed, and the operands are worked on by the operators. Now we can add a bit more detail to this explanation. Expressions can be as simple as a single value or as complex as a large calculation. Here are a few examples of numeric expressions:
2 + 3 * 4 -1 + 3 (2 + 3) * 4
These expressions are evaluated by Python working from left to right, just as you would read them yourself. Again, just as in traditional math, multiplication and division are performed first, followed by addition and subtraction.
Python achieves this order by giving each operator a priority. When it works out an expression, it finds all the operators with the highest priority and applies them first. It then looks for the operators next in priority, and so on, until the result is obtained. The order of evaluation means that the expression 2 + 3 * 4 will calculate to 14, not 20.
If you want to force the order in which an expression evaluates, you can put parentheses around the elements of the expression you want to evaluate first, as in the final example above. You can also put parentheses inside parentheses if you want—provided you make sure that you have as many opening parentheses as closing ones. Being a simple soul, I tend to make things very clear by putting parentheses around everything.
It is probably not worth getting too worked up about expression evaluation. Generally speaking, things tend to be evaluated how you would expect.
Here is a list of some other operators, with descriptions of what they do, and their precedence (priority). The operators are listed with the highest priority first.
| OPERATOR | HOW IT’S USED |
| - | Unary minus, the minus that Python finds in negative numbers, |
| * | Multiplication. Note the use of the * rather than the more mathematically correct but confusing x. |
| / | Division, because of the difficulty of drawing one number above another during editing, we use this character instead. |
| + | Addition. |
| - | Subtraction. Note that we use the same character as for unary minus. |
This is not a complete list of the operators available, but it will do for now. Because these operators work on numbers, they are often called numeric operators. However, one of them, the + operator, can be applied between strings, as you’ve already seen.
CODE ANALYSIS
Work out the results
Question: See if you can work out the values of a, b, and c when the following statements have been evaluated:
a = 1 b = 2 c = a + b c = c * (a + b) b = a + b + c
Answer: a=1, b=12, c=9. The best way to work this out is to behave like a computer would and work through each statement in turn. When I do this, I write down the variable values on a piece of paper and then update each as I go along. Doing this means that you can predict what a program will do without having to run it.
WHAT COULD GO WRONG
Dumb calculations
Because you can use the division operator in an expression, you can write silly code such as this:
>>> 1/0
This code tries to divide one by zero, giving a non-sensible result. You might think that this would cause the computer itself to crash. In the old days, this might have happened. I have fond memories of a calculator I used to own. If I tried to divide one by zero, it would just keep counting up, trying to reach a result of infinity. In a Python program, the Python engine will simply stop your program from going any further.
>>> 1/0
Traceback (most recent call last):
File "<pyshell#11>", line 1, in <module>
1/0
ZeroDivisionError: division by zero
Convert between float and int
Sometimes a program might need to convert between floating-point and integer values. A program can do this by using the int function. We’ve already used the int function to convert strings of text into integer values. To do this, we used the version of the int function that accepts a string as an input:
i = int('25')
If the int function is supplied with a string containing a number, it will read that number out of the string. In other words, the statement above will result in the variable i containing the integer value 25.
Programs can also use the int function to convert a value from floating point to integer.
i = int(2.9)
This would result in the creation of an integer variable called i that contains the value 2. You might ask why the value if i is not set to 3, because it seems reasonable to “round” a value to the nearest integer. However, in this respect Python is not reasonable. Floating-point values are always truncated. In other words, the fractional part is always discarded.
MAKE SOMETHING HAPPEN
Calculating a pizza order
You might wonder why you would need to convert floating-point values into integers. Here’s an example. Rigorous scientific research conducted by me at many hackathons I’ve attended has arrived at a figure of exactly 1.5 people per pizza. In other words, if I’m catering for 30 students I’ll need 20 pizzas, and so on.
I decided to write a Python program that works out how many pizzas I need to order, given a particular number of students. The program reads in the number of students, does the calculation, and then prints the result. This is my first version:
)
This version is fine with the test data above. If I say there are 30 students, the program will tell me I need 20 pizzas. However, there are problems with some numbers of pizzas:
How many students: 40 You will need 26.666666666666668 pizzas
I can’t ask the pizza place for a fraction of the pizza, so I need a way of converting the number of pizzas to an integer. At this point, I also must decide what the conversion will do. If I just use the int conversion on the result above, this will result in an order for 26 pizzas because the int function truncates the floating-point value. This effectively means that I’ll have pizza for only 39 people rather than 40, leaving one hungry student.
There are several ways to address this problem. I might think the best way to attack the problem is to add one extra pizza to the order to take care of any “spares.”
pizza_count = (students_int/1.5)+1
Load the example program and modify it using the above statement so that when you tell it there are 40 students, the program suggests that you buy 27 pizzas.
Then change the program to make it less generous and always rounds down to the nearest integer number of pizzas to order.
PROGRAMMER’S POINT
Never assume that you know what a program is supposed to do
If you wrote the pizza calculator for a customer, you should not decide for yourself what the program should do if it must order a fraction of a pizza. Your customer might be happy to “round down” the number of pizzas to keep their costs down. If this is the case, they will complain when your program adds an extra pizza.
As a programmer, never assume that you know what the program should do. You must always ask the customer. Otherwise, you might find yourself paying for over-ordered pizzas.
MAKE SOMETHING HAPPEN
Converting between Fahrenheit and centigrade
To convert a temperature from Fahrenheit to centigrade, you subtract 32 from the Fahrenheit value and then divide the result by 1.8. You could write a Python program to perform this calculation. If you look at the pizza order program above, you’ll discover that you already have most of the program written. You just need to change the messages that the program displays and the statements that perform the calculation.
You can now write any kind of conversion program you like, converting feet to meters, grams to ounces, or liters to gallons.