Working with variables

1/19/2018

Contents

Variables in Python

We’ve seen how Python lets us work with numbers and text. We can use Python as a calculator; we can type calculations as expressions, and Python will evaluate them and display the result. A calculator usually has a memory function that you can use to avoid typing in the same value repeatedly. You can store a frequently used value or a running total in memory and recall it with the touch of a button.

A variable is how we add memory to our Python programs. You can think of a variable as a storage location you can refer to by name. You create a variable in a Python program by thinking of a name for the variable and then putting a value in the variable.

total = 0

This Python statement creates a variable with the name total. This variable could be used to hold the total of a sequence of numbers. When Python sees the word total in the program, it fetches the contents of the variable called total.

The statement above is called an assignment, which is not a piece of homework (thankfully); instead, it’s the act of assigning one thing to another. Figure 4-1 shows the anatomy of an assignment statement like this.

Figure 4-1 Anatomy of an assignment statement

The box on the left of the assignment shows the variable to be assigned. The symbol in the middle is the equals operator, which means “assignment.” The box on the right is an expression, which gives the value to be assigned. The expression can be as complicated as you like.

total = us_sales + world_wide_sales

This statement would set the value of the variable total to the result of adding the contents of the variable us_sales to the contents of the variable world_wide_sales.

MAKE SOMETHING HAPPEN

Working with variables

Let’s start up the IDLE program and do some work with the Python Shell part of IDLE. We can begin by creating a total variable.

>>> total = 0

If you type the above variable into the Python Shell part of IDLE, you’ll notice something different about the way it behaves. When we give Python something to work out, it calculates the answer and displays it. However, if we set a value in a variable (as we did above), Python doesn’t display an answer. Instead, Python performs the assignment and then awaits another command. We could ask Python to tell us the contents of total simply by entering the name of the variable into the Python Shell part of IDLE.

>>> total
0

Remember that in Chapter 2, when we entered the value 2, Python returned that value. In the above statement, we’ve given Python the value of total, which Python has worked out and returned a value of 0. Now, let’s try something a little more complex.

>>> total = total+10

This expression might appear confusing. If you’ve worked with mathematical equations, you’ll remember that the equals character means that one value is equal to another. From a mathematical point of view, the statement is obviously wrong, because the total cannot equal the total plus 10. However, it’s important to remember that in Python, the equals operator means “assign.” So, the expression total+10 is evaluated on the right side and then is assigned to the variable on the left side.

In other words, you’ve added 10 to the contents of total. You can check the value of the total variable to prove this.

>>> total
10

This sequence of actions has performed some simple data processing. The data going into the process was the value in the variable total, which emerged from the process with its value increased by 10.

Python names

We used the name total for the first variable that we created. When you write a program, you must come up with names for the variables in that program. Python has rules about the way you can form names:

A name must start with a letter or the underscore character (_) and can contain letters, numerals (digits), or the underscore character.

The name total is a perfectly legal name for a variable, as is the name xyz. However, the variable 2_be_or_not_2_be would be rejected with an error, because it starts with a numeral instead of a letter or the underscore character. Also, Python views uppercase and lowercase letters differently; for example, FRED is regarded by Python as a different name from fred.

PROGRAMMER’S POINT

Create meaningful names

I find it terribly surprising that some programmers use variable names such as X21 or silly or hello_mom. I don’t. I work very hard to make my programs as easy to read as possible. So, I’ll use names such as length or, perhaps even better, window_length_in_inches. The designers of Python have written a style guide that sets out how you should format your variable names. The names we are creating should be expressed as lowercase words separated by the underscore character. You can find more details here: https://www.python.org/dev/peps/pep-0008/#naming-conventions

Some other programming languages advise the use of camel case to separate the words in their variable names, so they create variables that look like this: windowLenghInInches. This is called camel case because the capital letters in the words cause humps, like the back of a camel. Either standard works well, but if you’re writing Python I’d advise you to stick with the Python way of doing things.

I don’t care which method you choose to make up your variable names; I only care that you strive to create names with meaning. If the name applies to a particular thing, then identify that thing. And if that thing has particular units of measurement, then add those, too. For example, if I was storing the age of a customer, I’d create a variable called customer_age_in_years.

Python allows names of any length, and the length of a variable name does not affect the speed of the program, meaning longer variable names don’t slow down the program. However, very long names can be a bit hard to read, so you should try to keep them down to the lengths shown in the examples.

CODE ANALYSIS

Typing errors and testing

We’ve seen what can happen if you type something that Python doesn’t understand. You get an error message, which is usually displayed in red. However, you can introduce other errors into your Python code that are difficult to find.

Total = total + 10

Question: Can you identify an error in the statement above, which is supposed to add 10 to the variable total?

Answer: Earlier in this chapter, we used a statement that looks like this to add 10 to the value in a variable called total. It looks like we are doing the same thing here, but that’s not the case. There is a crucial difference between this statement and the one we saw earlier. This statement assigns the result of the calculation to a newly created variable called Total. The statement would not generate any complaints from Python when it runs, but it would also not update the value of total correctly.

This is a logic error. The statement is completely legal as far as Python is concerned, but it will do the wrong thing when it runs. These errors are very dangerous because Python doesn’t alert you to their presence; instead, the program just doesn’t work correctly. Python insists on the use of lowercase letters in variable names precisely to avoid this type of error.

Question: How do we prevent logic errors?

Answer: The only way to attack logic errors is to use testing. We need to run a program with some known values (values for which we know the total) and then verify that the answers agree with the test total. If the answers make sense, we can start to build confidence in our code. However, even if a program passes all the tests, it could still be faulty because there might be a fault that is not picked up by those tests.

Tests don’t prove that a program is good; tests simply prove that a program is not as bad as it would be if it had failed the tests.

Tests work best if they are added at the time the program is created. We’ll talk about testing strategies every time we make a new program.

total = Total + 10

Question: The statement above also contains a misspelling of a variable named total. However, this time the name on the right-hand side of the equals is misspelled.

What will happen when this program runs?

Answer: Python will refuse to run this statement. It will tell you that you are using a variable with the name Total, which it hasn’t seen yet. Sometimes typing mistakes will be detected before your program runs, but other times they might not.

You might be thinking that you’ve been set up to fail because I’ve suggested that you use long, meaningful names, and typing those long, meaningful names creates more opportunities for mistakes. For now, one way around this problem is to use the text copy feature of your editor to copy names from one part of the program to another.

Later, we’ll see other ways that a programmer’s editor can prevent you from making typing errors by automatically completing names as they are typed.

MAKE SOMETHING HAPPEN

Make a “Self-Timer” party game

One of the problems with making programs is that when people use them, they come up with ideas to make them better. And that means as the programmer, you must do more work. In this “Make Something Happen,” we’ll look at improving a program we created in the previous chapter.

Refer to the “Nerves of Steel” party game that we created at the end of Chapter 3. In the game, players must remain standing right up to the moment before they think a random timer will expire.

However, one suggestion I’ve received is that the game might require more skill if the program told the players how long they had to stand. The game could be renamed “Self-Timer,” and the winner would be the person who was best at keeping track of time. The sequence of actions the program must follow are:

Set the time to remain standing to a random number.
Display the time to remain standing.
Sleep for the time to remain standing.
Display the “Time Up” message

The program will need to use a variable to store the random number of seconds for which the players must remain standing. The name stand_time would work well for such a variable.