1. Introduction

Python is the programming language this text uses to introduce computer programming. To run a Python program you need an interpreter. The Python interpreter is a program that reads a Python program and then executes the statements found in it, as depicted in Fig. 1.1. While studying this text you will write many Python programs. Once your program is written and you are ready to try it you will tell the Python interpreter to execute your Python program so you can see what it does.

For this process to work you must first have Python installed on your computer. Python is free and available for download from the internet. The next section of this chapter will take you through downloading and installing Python. Within the last few years there were some changes to the Python programming language between Python 2 and Python 3. The text will describe differences between the two versions of Python as they come up. In terms of learning to program, the differences between the two versions of Python are pretty minor.

To write Python programs you need an editor to type in the program. It is convenient to have an editor that is designed for writing Python programs. An editor that is specifically designed for writing programs is called an IDE or Integrated Development Environment. An IDE is more than just an editor. It provides highlighting and indentation that can help as you write a program. It also provides a way to run your program straight from the editor. Since you will typically run your program many times as you write it, having a way to run it quickly is handy. This text uses the Wing IDE 101 in many of its examples. This IDE is simple to install and is free for educational use. Wing IDE 101 is available for Mac OS X, Microsoft Windows, and Linux.

When learning to program and even as a seasoned professional, it can be advantageous to run your program using a tool called a debugger. A debugger allows you to run your program, stop it at any point, and inspect the state of the program to help you better understand what is happening as your program executes. The Wing IDE includes an integrated debugger for that purpose. There are certainly other IDEs that might be used and nothing presented in this text precludes you from using something else. Some examples of IDEs for Python development include Netbeans, Eclipse, Eric, and IDLE. Eric’s debugger is really quite nice and could serve as an alternative to Wing should Wing IDE 101 not be an option for some reason.

To begin writing Python programs on your own computer, you need to have Python installed. There were some significant changes between Python 2.7 and Python 3 which included a few changes that make programs written for version 3 incompatible with programs written for version 2.7 and vice versa. If you are using this book as part of an introductory course, your instructor may prefer you install one version or the other. Example programs in this text are written using Python 3 syntax but the differences between Python 2 and 3 are few enough that it is possible to use either Python 2 or 3 when writing programs for the exercises in this text. Inset boxes titled Python 2 3 will highlight the differences when they are first encountered in the text.

If you are running Windows you will likely have to install Python yourself. You can get the installation package from http://​python.​org. Click the DOWNLOAD link on the page. Then pick the appropriate installer package. Most will want to download the latest version of the Python 3 Windows x86 MSI Installer package. Once you have downloaded it, double-click the package and take all the defaults to install it as pictured in Fig. 1.2.

If you have a Mac, then Python is already installed and may be the version you want to use, depending on how new your Mac is. You can find out which version of Python you have by opening a terminal window. Go to the Applications folder and look in the Utilities sub-folder for the Terminal application. Start a terminal and in the window type python. You should see something like this:

You can press and hold the control key (i.e. the ctrl key) and press ‘d’ to exit Python or just close the terminal window. If you do not have version 3.1 or newer installed on your Mac you may wish to download the latest Python 3 MacOS Installer Disk Image from the http://​python.​org web site. Once the file is downloaded you can double-click the disk image file and then look for the Python.mpkg file and double-click it as pictured in Fig. 1.3. You will need an administrator password to install it which in most cases is just your own password.

While you don’t need an IDE like Wing to write and run Python programs, the debugger support that an IDE like Wing provides will help you understand how Python programs work. It is also convenient to write your programs in an IDE so you can run them quickly and easily. To install Wing IDE 101 you need to go to the http://​wingware.​com web site. Find the Download link at the top of the web page and select Wing IDE 101 to download the installation package. Be sure to pick Wing IDE 101 to download if you don’t want to pay for a license. If you are installing on a Mac, pick the Mac version. If you are installing on Windows, pick the Windows version. Download and run the installation package if you are using Windows. Running the Windows installer should display an installer window like that pictured in Fig. 1.4. Take all the defaults to install it.

If you are installing Wing IDE 101 on a Mac then you need to mount the disk image. To do this you must double-click a file that looks like wingide-101-3.2.2-1-i386.dmg. After double-clicking that file you will have a mounted disk image of the same name, minus the .dmg extension). If you open a Finder window for that disk image you will see a window that looks like Fig. 1.5. Drag the Wing IDE icon to your Applications folder and you can add it to your dock if you like.

To try out the installation of your IDE and Python you should write a program and run it. The traditional first program is the Hello World program. This program simply prints “Hello World!” to the screen when it is run. This can be done with one statement in Python. Open your IDE if you have not already done so. If you are using Windows you can select it by going to the Start menu in the bottom left hand corner and selecting All Programs. Look for Wing IDE 101 under the Start menu and select it. If you are using a Mac, go to the Applications folder and double-click the Wing IDE icon or click on it in your dock if you installed the icon on your dock. Once you’ve done this you will have a window that looks like Fig. 1.8.

In the IDE window you go to the File menu and select New to get a new edit tab within the IDE. You then enter one statement, the print statement shown in Fig. 1.8 to print Hello World! to the screen. After entering the one line program you can run it by clicking the green debug button (i.e. that button that looks like a bug) at the top of the window. You will be prompted to save the file. Click the Save Selected Files button and save it as helloworld.py. You should then see Hello World! printed at the bottom of the IDE window in the Debug I/O tab.

The CPU is the brain of the computer. It is able to store values in memory, retrieve values from memory, add/subtract two numbers, compare two numbers and do one of two things depending on the outcome of that comparison. The CPU can also control which instruction it will execute next. Normally there are a list of instructions, one after another, that the CPU executes. Sometimes the CPU may jump to a different location within that list of instructions depending on the outcome of some comparison.

That’s it. A CPU can’t do much more than what was described in the previous paragraph. CPU’s aren’t intelligent by any leap of the imagination. In fact, given such limited power, it’s amazing how much we are able to do with a computer. Everything we use a computer for is built on the work of many, many people who have built layers and layers of programs that make our life easier.

The memory of a computer is a place where values can be stored and retrieved. It is a relatively fast storage device, but it loses its contents as soon as the computer is turned off. It is called volatile store. The memory of a computer is divided into different locations. Each location within memory has an address and can hold a value. Figure 1.9 shows the contents of memory location 100 containing the number 48.

The hard drive is non-volatile storage or sometimes called persistent storage. Values can be stored and retrieved from the hard drive, but it is relatively slow compared to the memory and CPU. However, it retains its contents even when the power is off.

In a computer, everything is stored as a sequence of 0’s and 1’s. For instance, the string 01010011 can be interpreted as the decimal number 83. It can also represent the capital letter ‘S’. How we interpret these strings of 0’s and 1’s is up to us. We can tell the CPU how to interpret a location in memory by which instruction we tell the CPU to execute. Some instructions treat 01010011 as the number 83. Other instructions treat it as the letter ‘S’.

One digit in a binary number is called a bit. Eight bits grouped together are called a byte. Four bytes grouped together are called a word. bytes are called a kilobyte (i.e. KB). kilobytes are called a megabyte (i.e. MB). megabytes are called a gigabyte (i.e. GB). gigabytes are called a terabyte (i.e. TB). Currently memories on computers are usually in the 1–8 GB range. Hard Drives on computers are usually in the 500 GB to 2 TB range.

Each digit in a decimal number represents a power of 10. The right-most digit is the number of ones, the next digit is the number of 10’s, and so on. To interpret integers as binary numbers we use powers of 2 just as we use powers of 10 when interpreting integers as decimal numbers. The right-most digit of a binary number represents the number of times is needed in the representation of the integer. Our choices are only 0 or 1 (i.e. we can use one if the number is odd), because 0 and 1 are the only choices for digits in a binary number. The next right-most is and so on. So 01010011 is . Any binary number can be converted to its decimal representation by following the steps given above. Any decimal number can be converted to its binary representation by subtracting the largest power of two that is less than the number, marking that digit as a 1 in the binary number and then repeating the process with the remainder after subtracting that power of two from the number.

To add two numbers in binary we perform addition just the way we would in base 10 format. So, for instance, . In decimal format this is . In binary format, any time we add two 1’s, the result is 0 and 1 is carried.

To represent negative numbers in a computer we would like to pick a format so that when a binary number and its opposite are added together we get zero as the result. For this to work we must have a specific number of bits that we are willing to work with. Typically thirty-two or sixty-four bit addition is used. To keep things simple we’ll do some eight bit addition in this text. Consider .

It turns out that the 2’s complement of a number is the negative of that number in binary. For example, the numbers and . is the 2’s complement of . It can be found by reversing all the 1’s and 0’s (which is called the 1’s complement) and then adding 1 to the result.

If binary does that mean that 253 can’t be represented? The answer is yes and no. It turns out that can represent or it can represent depending on whether we want to represent both negative and positive values or just positive values. The CPU instructions we choose to operate on these values determine what types of values they are. We can choose to use signed integers in our programs or unsigned integers. The type of value is determined by us when we write the program.

Typically, 4 bytes, or one word, are used to represent an integer. This means that different signed integers can be represented from to . In fact, Python can handle more integers than this but it switches to a different representation to handle integers outside this range. If we chose to use unsigned integers we could represent numbers from 0 to using one word of memory.

Not only can represent , it can also represent a character in the alphabet. If is to be interpreted as a character almost all computers use a convention called ASCII which stands for the American Standard Code for Information Interchange [12]. This standard equates numbers from 0 to 127 to characters. In fact, numbers from 128 to 255 also define extended ASCII codes which are used for some character graphics. Each ASCII character is contained in one byte. Figure 1.10 shows the characters and their equivalent integer representations.

If we were to have to write programs as sequences of numbers we wouldn’t get very far. It would be so tedious to program that no one would want to be a programmer. In the spring of 2006 Money Magazine ranked Software Engineer [4] as the number one job in America in terms of overall satisfaction which included things like compensation, growth, and stress-levels. So it must not be all that tedious.

A programming language is really a set of tools that allow us to program at a much higher level than the 0’s and 1’s that exist at the lowest levels of the computer. Python and the Wing IDE provides us with a couple of tools. The lower right corner of the Wing IDE has a tab labeled Python Shell. The shell allows programmers to interact with the Python interpreter. The interpreter is a program that interprets the programs we write. If you have a Mac or Linux computer you can also start the Python interpreter by opening up a terminal window. If you use Windows you can start a Command Prompt by looking under the Accessories program group. Typing python at a command prompt starts a Python interpreter as shown in Fig. 1.11.

Consider computing the area of a shape constructed of overlapping regular polygons. In Fig. 1.12 all angles are right angles and all distances are in meters. Our job is to figure out the area in square meters. The lighter lines in the middle help us figure out how to compute the area. We can compute the area of the two rectangles and then subtract one of the overlapping parts since otherwise the overlapping part would be counted twice.

This can be computed on your calculator of course. The Python Shell is like a calculator and Fig. 1.11 shows how it can be used to compute the area of the shape. The first line sets a variable called R1_width to the value of 10. Then R1_height is set to 8. We can store a value in memory and give it a name. This is called an assignment statement. Your calculator can store values. So can Python. In Python these values can be given names that mean something in our program. R1_height is the name we gave to the height of the R1 rectangle. Anytime we want to retrieve that value we can just write R1_height and Python will retrieve its value for us.

Interacting directly with the Python shell is a good way to quickly see how something works. However, it is also painful because mistakes can’t be undone. In the next section we’ll go back to writing programs in an editor so they can be changed and run as many times as we like. In fact, this is how most Python programming is done. Write a little, then test it by running it. Then write a little more and run it again. This is called prototyping and is an effective way to write programs. You should write all your programs using prototyping while reading this text. Write a little, then try it. That’s an effective way to program and takes less time than writing a lot and then trying to figure out what went wrong.

Most programmers do not have to work with binary number representations. Programming languages let programmers write numbers in base 10 and they do the conversion for us. However, once in a while a programmer must be concerned about the binary representation of a number. As we’ve seen, converting between binary and decimal isn’t hard, but it is somewhat tedious. The difficulty arises because 10 is not a power of 2. Converting between base 10 and base 2 would be a lot easier if 10 were a power of 2. When computer programmers have to work with binary numbers they don’t want to have to write out all the zeroes and ones. This would obviously be tedious as well. Instead of converting numbers to base 10 or writing all numbers in binary, computer programmers have adopted two other representations for binary numbers, base 16 (called hexadecimal) and base 8 (called octal).

In hexadecimal each digit of a number can represent 16 different binary numbers. The 16 hexadecimal digits are 0–9, and A–F. Since 16 is a power of 2, there are exactly four binary digits that make up each hexadecimal digit. So, is and is . So, the binary number is in hexadecimal notation and in octal notation. If we wish to convert either of these two numbers to binary format the conversion is just as easy. is for instance. Again, these conversions can be done quickly because there are four binary digits in each hexadecimal digit and three binary digits in each octal digit.

Since , each digit of an octal number represents three binary digits. The octal digits are 0–7. The number . When converting a binary number to octal or hexadecimal we must be sure to start with the right-most bits. Since there are only 8 bits in the left-most octal digit corresponds to the left-most two binary digits. The other two octal digits each have three binary digits. Again, Python has built-in support for representing octal digits. Writing a number with a leading zero and the letter o means that it is in octal format. So is the Python representation of and it is equal to .

Writing programs is an error-prone activity. Programmer’s almost never write a non-trivial program perfectly the first time. As programmers we need a tool like an Integrated Development Environment (i.e. IDE) that helps us find and fix our mistakes. Going to the File menu of the Wing IDE window and selecting New opens a new edit pane. An edit pane can be used to write a program but it won’t execute each line as you press enter. When writing a program we can write a little bit and then execute it in the Python interpreter by pressing F5 on the keyboard or by clicking the debug button.

When we write a program we will almost certainly have to debug it. Debugging is the word we use when we have to find errors in our program. Errors are very common and typically you will find a lot of them before the program works perfectly. Debugging refers to removing bugs from a program. Bugs are another name for errors. The use of the words bug and debugging in Computer Science dates back to at least 1952 and probably much earlier. Wikipedia has an interesting discussion of the word debugging if you want to know more. While you can use the Python Shell for some limited debugging, a debugger is a program that assists you in debugging your program. Figure 1.13 has a picture of the Wing IDE with the program we’ve been working on typed into the editor part of the IDE. To use the debugger we can click the mouse in the area where the red circle appears next to the numbers. This is called setting a breakpoint. A breakpoint tells Python to stop running when Python reaches that statement in the program. The program is not finished when it reaches that step, but it stops so you can inspect the state of the program.

Not every error is found using a debugger. Sometimes errors are syntax errors. A syntax error occurs when we write something that is not part of the Python language. Many times a syntax error can occur if we forget to write something. For instance, if we forget a parenthesis or a double quote is left out it will not be a correct Python program. Syntax errors are typically easier to find than bugs in our program because Python can flag them right away for us. These errors are usually highlighted right away by the IDE or interpreter. Syntax errors are those errors that are reported before the program starts executing. You can tell its a syntax error in Wing because there will not be any Stack Data. Since a syntax error shows up before the program runs, the program is not currently executing and therefore there is not state information in the stack data. When a syntax error is reported the editor or Python will typically indicate the location of the error after it actually occurs so the best way to find syntax errors is to look backwards from where the error is first reported.

Earlier in this chapter we found that bytes in memory can be interpreted in different ways. The way bytes in memory are interpreted is determined by the type of the value or object and the operations we apply to these values. Each value in Python is called an object. Each object is of a particular type. There are several data types in Python. These include integer (called int in Python), float, boolean (called bool in Python), string (called str in Python), list, tuple, set, dictionary (called dict in Python), and None.

In the next chapters we’ll cover each of these types and discuss the operations that apply to them. Each type of data and the operations it supports is covered when it is needed to learn a new programming skill. The sections on each of these types can also serve as a reference for you as you continue working through the text. You may find yourself coming back to the sections describing these types and their operations over and over again. Reviewing types and their operations is a common practice among programmers as they design and write new programs.

There is one type in Python that is typically not seen, but nevertheless is important to understand. It is called the reference type. A reference is a pointer that points to an object. A pointer is the address of an object. Each object in memory is stored at a unique address and a reference is a pointer that points to an object.

An assignment statement makes a reference point to an object. The general form of an assignment statement is:

An identifier is any letters, digits, or underscores written without spaces between them. The identifier must begin with a letter or underscore. It cannot start with a digit. The expression is any expression that when evaluated results in one of the types described in Sect. 1.10. The left hand side of the equals sign must be an identifier and only one identifier. The right hand side of the equals sign can contain any expression that may be evaluated.

In Fig. 1.15, the variable R1_width (orange in the figure) is a reference that points at the integer object 10 colored green in the figure. This is what happens in memory in response to the assignment statement:

The is the reference value, written in hexadecimal, which is a pointer (i.e. the address) that points at the integer object 10. However, typically you don’t see reference values in Python. Instead, you see what a reference points to. So if you type R1_width in the Python shell after executing the statement above, you won’t see printed to the screen, you’ll see 10, the value that R1_width refers to. When you set a breakpoint and look at the stack data in the debugger you will also see what the reference refers to, not the reference itself (see Fig. 1.13).

It is possible, and common, in Python to write statements like this:

According to what we have just seen, Fig. 1.16 depicts the state of memory after executing the first line of code and before executing the second line of code. In the second line of code, writing x = x + 1 is not an algebraic statement. It is an assignment statement where one is added to the value that x refers to. The correct way to read an assignment statement is from right to left. The expression on the right hand side of the equals sign is evaluated to produce an object. The equals sign takes the reference to the new value and stores it in the reference named by the identifier on the left hand side of the equals sign. So, to properly understand how an assignment statement works, it must be read from right to left. After executing the second statement (the line beginning with a pound sign is a comment and is not executed), the state of memory looks like Fig. 1.17. The reference called x is updated to point to the new value that results from adding the old value referred to by x and the 1 together.

The space for the two left over objects containing the integers 1 in Fig. 1.17 is reclaimed by the garbage collector. You can think of the garbage collector as your favorite arcade game character running around memory looking for unattached objects (objects with no references pointing to them—the stuff in the cloud in Fig. 1.17). When such an object is found the garbage collector reclaims that memory for use later much like the video game character eats dots and fruit as it runs around.

The garbage collector reclaims the space in memory occupied by unreferenced objects so the space can be used later. Not all programming languages include garbage collection but many languages developed recently include it and Python is one of these languages. This is a nice feature of a language because otherwise we would have to be responsible for freeing all of our own memory ourselves.

In most programming languages, including Python, there is a distinction between integers and real numbers. Integers, given the type name int in Python, are written as a sequence of digits, like 83 for instance. Real numbers, called float in Python, are written with a decimal point as in 83.0. This distinction affects how the numbers are stored in memory and what type of value you will get as a result of some operations.

In Fig. 1.18 the type of the result is a float if either operand is a float unless noted otherwise in the table.

Dividing the integer 83 by 2 yields 41.5 if it is written . However, if it is written then the result is . This goes back to long division as we first learned in elementary school. is with a remainder of . The result of floor division isn’t always an int. yields so be careful. While floor division returns an integer, it doesn’t necessarily return an int.

We can insure a number is a float or an integer by writing float or int in front of the number. So, float(83)//2 also yields 41.0. Likewise, int(83.0)//2 yields 41.

In Example 1.5 the lbs were first converted to ounces. Then the whole gallons were computed from the ounces by converting to an integer the result of dividing the ounces float by 128. On line 4 the remaining ounces were computed after taking out the number of ounces contained in the computed gallons.

Several of the operations between ints and floats are given in Fig. 1.18. If you need to round a float to the nearest integer (instead of truncating the fractional portion) you can use the round function. Absolute value is taken using abs. There are other operations between floats and ints that are not discussed in this chapter. A complete list of all operations supported by integers and floats are given in Chaps.  8 and 9. If you need to read some documentation about an operator you can use the appendices or you can search for Python documentation on the internet or you can start a Python shell and type help(float) or help(int). This help facility is built into the Python programming language. There is extensive documentation for every type within Python. Typing help(type) in the Python shell where type is any type within Python will provide you with all the operations that are available on that type of value.

Strings are another type of data in Python. A string is a sequence of characters.

This is a short program that initializes a variable called name to the string ‘Sophus Lie’. A string literal is an actual string value written in your program. String literals are delimited by either double or single quotes. Delimited means that they start and end with quotes. In the code above the string literal Sophus Lie is delimited by single quotes. The string A famous Norwegian Mathematician is is delimited by double quotes. If you use a single quote at the beginning of a string literal, you must use a single quote at the end of the string literal. Delimiters must come in matching pairs.

Strings are one type of sequence in Python. There are other kinds of sequences in Python as well, such as lists which we’ll look at in a couple of chapters. Python supports operations on sequences. For instance, you can get an individual item from a sequence. Writing,

will print the first character of the string that name references. The 0 is called an index. Each subsequent character is assigned a subsequent position in the string. Notice the first position in the string is assigned 0 as its index. The second character is assigned index 1, and so on. Strings and their operations are discussed in more detail in Chap. 3.

It is possible in Python to convert an integer to a string. For instance,

This program converts 83 to ‘83’ and back again. Integers and floats can be converted to a string by using the str conversion operator. Likewise, an integer or a float contained in a string can be converted to its numeric equivalent by using the int or float conversion operator. Conversion between numeric types and string types is frequently used in programs especially when producing output and getting input.

Conversion of numeric values to strings should not be confused with ASCII conversion. Integers may represent ASCII codes for characters. If you want to convert an integer to its ASCII character equivalent you use the conversion operator. For instance, chr(83) is ‘S’. Likewise, if you want to convert a character to its ASCII code equivalent you use the conversion operator. So ord(‘S’) is equal to 83.

You might have noticed in Fig. 1.19 there is an operator called int and another called float. Both of these operators are also numeric operators and appear in Fig. 1.18. This is called an overloaded operator because int and float are operators that work for both numeric and string operands. Python supports overloaded operators like this. This is a nice feature of the language since both versions of int and float do similar things.

To get input from the user you can use the input function. When the input function is called the program stops running the program, prompts the user to enter something at the keyboard by printing a string called the prompt to the screen, and then waits for the user to press the Enter key. The user types a string of characters and presses enter. Then the input function returns that string and Python continues running the program by executing the next statement after the input statement.

The input function prints the prompt “Please enter your name:” to the screen and waits for the user to enter input in the Python Shell window. The program does not continue executing until you have provided the input requested. When the user enters some characters and presses enter, Python takes what they typed before pressing enter and stores it in the variable called name in this case. The type of value read by Python is always a string. If we want to convert it to an integer or some other type of value, then we need to use a conversion operator. For instance, if we want to get an int from the user, we must use the int conversion operator.

In this chapter just about every fragment of code prints something. When a value is printed, it appears on the console. The location of the console can vary depending on how you run a program. If a program is run from within the Wing IDE, the console is the Python Shell window in the IDE. If the program is debugged from within Wing IDE 101, the output appears in the Debug I/O window.

When printing, we may print as many items as we like on one line by separating each item by a comma. Each time a comma appears between items in a print statement, a space appears in the output.

To print the contents of variables without spaces appearing between the items, the variables must be converted to strings and string concatenation can be used. The operator adds numbers together, but it also concatenates strings. For the correct operator to be called, each item must first be converted to a string before concatenation can be performed.

In Example 1.9, line 4 of the program prints three items to the console. The last two items are the = and the value that the answer variable references. The first item in the print statement is the result of concatenating str(base), the caret, and str(exp). Both base and exp must be converted to strings first, then string concatenation will be performed by the operator because the operands on either side of the are both strings.

Line 4 in Example 1.10 prints the result of formatting a string. To use Python formatting, a format string must be written first, followed by a percent sign, followed by the replacement values. If there is more than one replacement value, they must be written in parentheses. Each time a % appears inside the format string it is replaced by one of the values that appear after the format string. How a value is formatted when it is placed in the format string is controlled by the format specifier. Figure 1.20 contains some specifiers for common types of data in Python. Every format specifier may include an optional width field. If specified, the width field specifies the actual width of the replaced data. If the width of the data being inserted into the format string exceeds the allotted width, the entire field is included anyway, stretching the width of the formatted string. String formatting can be very useful when generating a printed report of some data.

As a programmer, you will soon discover that things can go wrong when writing a program. No programmer writes every program correctly the first time. We are all human and make mistakes. What makes a programmer a really good programmer is when they can find their mistakes and correct them. Debugging programs is a skill that can be learned and therefore can be taught as well. But, it takes lots of practice and patience. Fortunately, you will have many chances to practice as you work your way through this book.

Sometimes, especially when you are first learning to debug your programs, it can help to have someone to talk to. Just the act of reading your code to someone else may cause you to find your mistake. Of course, if you are using this text as part of a course you may not want to read your code to another class member as that may violate the guidelines your instructor has set forth. But, nevertheless, you might find that reading your code to someone else may help you discover problems. This is called a code walk-through by programming professionals. It is a common practice and is frequently required when writing commercially available programs.

There is no substitute for thorough testing. You should run your program using varied values for input. Try to think of values that might cause your program to break. For instance, what if 0 is entered for an integer? What if a non-integer value is entered when an integer was required? What happens if the user enters a string of characters when a number was required?

Sometimes the problems in our code are not due to user input. They are just plain old mistakes in programming caused either by temporarily forgetting something, or by our misunderstanding how something works. For instance, in this chapter we learned about assignment statements. You can store a value in the memory of a computer and point a named reference at the value so you can retrieve it later. But, you must assign a name to a value before you can retrieve it. If you don’t understand that concept, or if you forgot where you assigned a value a name in your program, you might accidentally write some code that tries to use that value before it is assigned a name. For instance, consider the program in Fig. 1.21. The program is trying to use the gallons variable which has not been assigned a value. The error message is on the right side of the window. The line where the error was first detected by Python is highlighted.

In the example in Fig. 1.21 the actual error is not on the line that is highlighted. The highlighted line is the line where Python first detected the error. This is a very common occurrence when debugging. Detection of an error frequently occurs after the location of the actual error. To become a good programmer you must learn to look backwards through your code from the point where an error is detected to find the location where it occurred. In this case, the gallon variable should have been written as gallons on line 3 but was incorrectly typed.

Another common error is the index out of range error. This can occur when trying to access a value in a sequence by indexing into the sequence. If the index is for an item that is outside the range of the sequence, an index out of range error will occur. For instance, if you have a string called x that is one character long and you try to access the second element of the string, your program will abort with an index out of range error. Figure 1.22 shows this happening in a snippet of code.

Once again, in the example in Fig. 1.22 the error did not occur on the line that is highlighted. The error occurred because the programmer meant to take the str(83) which would result in “83” as a string instead of the chr(83) which results in the string “S”. If the string had been “83” then line 3 would have worked and would have printed 3 to the screen.

When an error occurs it is called an uncaught exception. Uncaught exceptions result in the program terminating. They cannot be recovered from. Because uncaught exceptions result in the program terminating it is vital to test your code so that all variations of running the program are tested before the program is released to users. Even so, there are times when a user may encounter an error. Perhaps it has happened to you? In any case, thorough testing is critical to your success as a programmer and learning to debug and test your code is as important as learning to program in the first place. As new topics are introduced in this text, debugging techniques will also be introduced to provide you with the information you need to become a better debugger.

   

 

These are solutions to the Practice Problems in this chapter. You should only consult these answers after you have tried each of them for yourself first. Practice Problems are meant to help reinforce the material you have just read so make use of them.