Python 3 Language Companion for

Python 3 Language Companion for
Starting Out with Programming Logic and Design, 3rd Edition
By Tony Gaddis
Copyright © 2013 Pearson Education, Inc.
Table of Contents
Chapter 1
Chapter 2
Chapter 3
Chapter 4
Chapter 5
Chapter 6
Chapter 7
Chapter 8
Chapter 9
Chapter 10
Chapter 11
Chapter 12
Chapter 13
Chapter 14
Chapter 15
Introduction 3
Introduction to Python 4
Input, Processing, and Output 10
Modularizing Programs with Functions 21
Decision Structures and Boolean Logic 30
Repetition Structures 39
Value-Returning Functions 48
Input Validation 60
Arrays (Lists) 62
Sorting and Searching 72
Files 77
Menu-Driven Programs 94
Text Processing 96
Recursion 100
Object-Oriented Programming 102
GUI Applications and Event-Driven Programming 111
Appendix A Introduction to IDLE
Page 1
Introduction
Welcome to the Python Language Companion for Starting Out with Programming Logic and
Design, 2nd Edition, by Tony Gaddis. You can use this guide as a reference for the Python
Programming Language as you work through the textbook. Each chapter in this guide
corresponds to the same numbered chapter in the textbook. As you work through a chapter in
the textbook, you can refer to the corresponding chapter in this guide to see how the chapter's
topics are implemented in Python. In this book you will also find Python versions of many of the
pseudocode programs that are presented in the textbook.
Page 2
Chapter 1
Introduction to Python
Installing Python
Before you can run Python programs on your computer you will need to install the Python
interpreter. You can download the latest version of the Python Windows installer from
www.python.org/download. The web site also provides downloadable versions of Python
for several other operating systems.
Note: On the download page you likely will see two current versions of Python. One will be
named Python 2.x.x, and the other will be named Python 3.x.x. This booklet is written
for the Python 3.x.x version.
When you execute the Python Windows installer, it's best to accept all of the default settings by
clicking the Next button on each screen. (Answer "Yes" if you are prompted with any Yes/No
questions.) As you perform the installation, take note of the directory where Python is being
installed. It will be something similar to C:\Python32. (The 32 in the path name represents
the Python version. The directory name Python32 would indicate Python version 3.2.) You will
need to remember this location after finishing the installation.
When the installer is finished, the Python interpreter, the IDLE programming environment, and
the Python documentation will be installed on your system. When you click the Start button
and look at your All Programs list you should see a program group named something like
Python 3.2. The program group will contain the following items:
•
•
•
•
•
IDLE (Python GUI) – When you click this item the IDLE programming environment will
execute. IDLE is an integrated development environment that you can use to create.
edit, and execute Python programs. See Appendix A for a brief introduction to IDLE.
Module Docs – This item launches a utility program that allows you to browse
documentation for the modules in the Python standard library.
Python Command Line – Clicking this item launches the Python interpreter in
interactive mode.
Python Manuals – This item opens the Python Manuals in your web browser. The
manuals include tutorials, a reference section for the Python standard library, an indepth reference for the Python language, and information on many advanced topics.
Uninstall Python – This item removes Python from your system.
Adding the Python Directory to the Path Variable
If you plan to execute the Python interpreter from a command prompt window, you will
probably want to add the Python directory to the existing contents of your system's Path
variable. (You saw the name of the Python directory while installing Python. It is something
Page 3
similar to C:\Python32.) Doing this will allow your system to find the Python interpreter
from any directory when you run it at the command-line.
Use the following instructions to edit the Path variable under Windows 7, Windows Vista or
Windows XP.
Windows 7
•
•
•
•
•
•
•
Click the Start button
Right-click Computer
On the pop-up menu select Properties.
In the window that appears next, click Advanced system settings. This displays the System
Properties window.
Click the Environment Variables... button.
In the System Variables list, scroll to the Path variable. Select the Path variable and click the
Edit button.
Add a semicolon to the end of the existing contents, and then add the Python directory path.
Click the OK buttons until all the dialog boxes are closed, and exit the control panel.
Windows Vista
•
•
•
•
•
•
•
•
Open the Control Panel.
Select System and Maintenance.
Select System.
Select Advanced System Settings.
Click the Environment Variables button.
In the System Variables list, scroll to the Path variable.
Select the Path variable and click the Edit button. Add a semicolon to the end of the
existing contents, and then add the Python directory path.
Click the OK button.
Windows XP
•
•
•
•
•
•
Open the Control Panel.
Double-click the System icon. (If you are running Windows XP in Category View, click
Performance and Maintenance in the Control Panel, and then click the System icon.)
Click the Advanced tab.
Click the Environment Variables button. In the System Variables list, scroll to the Path
variable.
Select the Path variable and click the Edit button. Add a semicolon to the end of the
existing contents, and then add the Python directory path.
Click the OK button.
Page 4
The Python Interpreter
Python is an interpreted language. When you install the Python language on your computer,
one of the items that is installed is the Python interpreter. The Python interpreter is a program
that can read Python programming statements and execute them. (Sometimes we will refer to
the Python interpreter simply as the interpreter.)
You can use the interpreter in two modes: interactive mode and script mode. In interactive
mode, the interpreter waits for you to type Python statements on the keyboard. Once you type
a statement, the interpreter executes it and then waits for you to type another statement. In
script mode, the interpreter reads the contents of a file that contains Python statements. Such a
file is known as a Python program or a Python script. The interpreter executes each statement
in the Python program as it reads it.
Interactive Mode
Once Python has been installed and set up on your system, you start the interpreter in
interactive mode by going to the operating system's command line and typing the following
command:
python
If you are using Windows, you can alternatively click the Start button, then All Programs. You
should see a program group named something like Python 3.2. (The "3.2" is the version of
Python that is installed.) Inside this program group you should see an item named Python
(command line). Clicking this menu item will start the Python interpreter in interactive mode.
When the Python interpreter starts in interactive mode, you will see something like the
following displayed in a console window:
Python 3.2 (r32:88445, Feb 20 2011, 21:30:00) [MSC v.1500 64 bit
(AMD64)] on win32
Type "copyright", "credits" or "license()" for more information.
>>>
The >>> that you see is a prompt that indicates the interpreter is waiting for you to type a
Python statement. Let's try it out. One of the simplest actions that you can perform in Python is
to display a message on the screen. For example, the following statement causes the message
Python programming is fun! to be displayed:
print('Python programming is fun!')
Notice that inside the parentheses that appear after the word print, we have written
'Python programming is fun!'. The quote marks are necessary, but they will not be
Page 5
displayed. They simply mark the beginning and the end of the text that we wish to display. Here
is an example of how you would type this statement at the interpreter's prompt:
>>> print('Python programming is fun!')
After typing the statement you press the Enter key and the Python interpreter executes the
statement, as shown here:
>>> print('Python programming is fun!') [Enter]
Python programming is fun!
>>>
After the message is displayed, the >>> prompt appears again, indicating that the interpreter is
waiting for you to enter another statement. Let's look at another example. In the following
sample session we have entered two statements.
>>> print('To be or not to be') [Enter]
To be or not to be
>>> print('That is the question.') [Enter]
That is the question.
>>>
If you incorrectly type a statement in interactive mode, the interpreter will display an error
message. This will make interactive mode useful to you while you learn Python. As you learn
new parts of the Python language, you can try them out in interactive mode and get immediate
feedback from the interpreter.
To quit the Python interpreter in interactive mode on a Windows computer, press Ctrl-Z
(pressing both keys together) followed by Enter. On a Mac, Linux, or UNIX computer, press CtrlD.
Writing Python Programs and Running Them in Script Mode
Although interactive mode is useful for testing code, the statements that you enter in
interactive mode are not saved as a program. They are simply executed and their results
displayed on the screen. If you want to save a set of Python statements as a program, you save
those statements in a file. Then, to execute the program, you use the Python interpreter in
script mode.
For example, suppose you want to write a Python program that displays the following three
lines of text:
Page 6
Nudge nudge
Wink wink
Know what I mean?
To write the program you would use a simple text editor like Notepad (which is installed on all
Windows computers) to create a file containing the following statements:
print('Nudge nudge')
print('Wink wink')
print('Know what I mean?')
Note: It is possible to use a word processor to create a Python program, but you must be sure
to save the program as a plain text file. Otherwise the Python interpreter will not be
able to read its contents.
When you save a Python program, you give it a name that ends with the .py extension, which
identifies it as a Python program. For example, you might save the program previously shown
with the name test.py. To run the program you would go to the directory in which the file is
saved and type the following command at the operating system command line:
python test.py
This starts the Python interpreter in script mode and causes it to execute the statements in the
file test.py. When the program finishes executing, the Python interpreter exits.
The IDLE Programming Environment
The previous sections described how the Python interpreter can be started in interactive mode
or script mode at the operating system command line. As an alternative, you can use
a program named IDLE, which is automatically installed when the Python language is installed.
(IDLE stands for Integrated DeveLopment Environment.) When you run IDLE, the window
shown in Figure 1-1 appears. Notice that the >>> prompt appears in the IDLE window,
indicating that the interpreter is running in interactive mode. You can type Python statements
at this prompt and see them executed in the IDLE window.
IDLE also has a built-in text editor with features specifically designed to help you write Python
programs. For example, the IDLE editor "colorizes" code so that key words and other parts of a
program are displayed in their own distinct colors. This helps make programs easier to read. In
IDLE you can write programs, save them to disk, and execute them. Appendix A provides a quick
introduction to IDLE, and leads you through the process of creating, saving, and executing a
Python program.
Page 7
Figure 1-1 IDLE
Note: Although IDLE is installed with Python, there are several other Python IDEs available.
Your instructor might prefer that you use a specific one in class.
Page 8
Chapter 2
Input, Processing, and Output
Displaying Screen Output
A function is a piece of prewritten code that performs an operation. Python has numerous builtin functions that perform various operations. Perhaps the most fundamental built-in function is
the print function, which displays output on the screen. Here is an example of a statement
that executes the print function:
print('Hello world')
When programmers execute a function, they say that they are calling the function. When you
call the print function, you type the word print, followed by a set of parentheses. Inside
the parentheses, you type an argument, which is the data that you want displayed on the
screen. In the previous example, the argument is 'Hello world'. The quote marks will not
be displayed when the statement executes, however. The quote marks simply specify the
beginning and the end of the text that we wish to display.
Suppose your instructor tells you to write a program that displays your name and address on
the computer screen. Program 2-1 shows an example of such a program, with the output that it
will produce when it runs. (The line numbers that appear in a program listing in this book are
not part of the program. We use the line numbers in our discussion to refer to parts of the
program.)
Program 2-1 (output.py)
1
print('Kate Austen')
2
print('123 Full Circle Drive')
3
print('Asheville, NC 28899')
This program is the Python
version of Program 2-1 in your
textbook!
Program Output
Kate Austen
123 Full Circle Drive
Asheville, NC 28899
Remember, these line numbers are NOT part of the program! Don't type the line numbers
when you are entering program code. All of the programs in this booklet will show line
numbers for reference purposes only.
It is important to understand that the statements in this program execute in the order that they
appear, from the top of the program to the bottom. When you run this program, the first
statement will execute, followed by the second statement, and followed by the third
statement.
Page 9
Strings and String Literals
In Python code, string literals must be enclosed in quote marks. As mentioned earlier, the quote
marks simply mark where the string data begins and ends.
In Python you can enclose string literals in a set of single-quote marks (') or a set of doublequote marks ("). The string literals in Program 2-1 are enclosed in single-quote marks, but the
program could also be written as shown here:
print("Kate Austen")
print("123 Full Circle Drive")
print("Asheville, NC 28899")
If you want a string literal to contain either a single-quote or an apostrophe as part of the
string, you can enclose the string literal in double-quote marks. For example, Program 2-2 prints
two strings that contain apostrophes.
Program 2-2 (apostrophe.py)
1 print("Don't fear!")
2 print("I'm here!")
Program Output
Don't fear!
I'm here!
Likewise, you can use single-quote marks to enclose a string literal that contains double-quotes
as part of the string. Program 2-3 shows an example.
Program 2-3 (display_quote.py)
1 print('Your assignment is to read "Hamlet" by tomorrow.')
Program Output
Your assignment is to read "Hamlet" by tomorrow.
Python also allows you to enclose string literals in triple quotes (either """ or '''). Triple
quoted strings can contain both single quotes and double quotes as part of the string. The
following statement shows an example:
print("""I'm reading "Hamlet" tonight.""")
This statement will print:
I'm reading "Hamlet" tonight.
Page 10
Triple quotes can also be used to surround multiline strings, which is something that single and
double quotes cannot be used for. Here is an example:
print("""One
Two
Three""")
This statement will print:
One
Two
Three
Variables
Variables are not declared in Python. Instead, you use an assignment statement to create a
variable. Here is an example of an assignment statement:
age = 25
After this statement executes, a variable named age will be created and it will reference the
value 25. This concept is shown in Figure 2-1. In the figure, think of the value 25 as being stored
somewhere in the computer's memory. The arrow that points from age to the value 25
indicates that the name age references the value.
Figure 2-1 The age variable references the value 25
An assignment statement is written in the following general format:
variable = expression
The equal sign (=) is known as the assignment operator. In the general format, variable is the
name of a variable and expression is a value, or any piece of code that results in a value. After
an assignment statement executes, the variable listed on the left side of the = operator will
reference the value given on the right side of the = operator.
The code in Program 2-4 demonstrates a variable. Line 1 creates a variable named room and
assigns it the value 503. The statements in lines 2 and 3 display a message. Notice that line 3
displays the value that is referenced by the room variable.
Page 11
Program 2-4 (variable_demo.py)
1 room = 503
2 print('I am staying in room number')
3 print(room)
Program Output
I am staying in room number
503
Variable Naming Rules
You may choose your own variable names in Python, as long as you do not use any of the
Python key words. The key words make up the core of the language and each has a specific
purpose. Table 2-1 shows a list of the Python key words.
Additionally, you must follow these rules when naming variables in Python:
•
•
•
•
A variable name cannot contain spaces.
The first character must be one of the letters a through z, A through Z, or an underscore
character (_).
After the first character you may use the letters a through z or A through Z, the digits 0
through 9, or underscores.
Uppercase and lowercase characters are distinct. This means the variable name
ItemsOrdered is not the same as itemsordered.
Table 2-1 The Python key words
and
del
from
as
elif
global
assert
else
if
break
except
import
class
False
in
continue
finally
is
def
for
lambda
from
global
if
import
in
is
lambda
None
nonlocal
not
or
pass
raise
return
True
try
while
with
yield
True
try
Displaying Multiple Items with the print Function
If you look back at Program 2-4 you will see that we used the following two statements in lines
3 and 4:
print('I am staying in room number')
print(room)
Page 12
We used two calls to the print function because we needed to display two pieces of data.
Line 3 displays the string literal 'I am staying in room number', and line 4 displays
the value referenced by the room variable.
This program can be simplified, however, because Python allows us to display multiple items
with one call to the print function. We simply have to separate the items with commas as
shown in Program 2-5.
Program 2-5 (variable_demo3.py)
1 room = 503
2 print('I am staying in room number', room)
Program Output
I am staying in room number 503
The statement in line 2 displays two items: a string literal followed by the value referenced by
the room variable. Notice that Python automatically printed a space between these two items.
When multiple items are printed this way in Python, they will automatically be separated by a
space.
Numeric Data Types and Literals
Python uses the int data type to store integers, and the float data type to store real
numbers. Let's look at how Python determines the data type of a number. Many of the
programs that you will see will have numeric data written into their code. For example, the
following statement, which appears in Program 2-4, has the number 503 written into it.
room = 503
This statement causes the value 503 to be stored in memory, and it makes the room variable
reference it. The following statement shows another example. This statement has the number
2.75 written into it.
dollars = 2.75
This statement causes the value 2.75 to be stored in memory, and it makes the dollars
variable reference it. A number that is written into a program's code is called a numeric literal.
When the Python interpreter reads a numeric literal in a program's code, it determines its data
type according to the following rules:
•
A numeric literal that is written as a whole number with no decimal point is considered
an int. Examples are 7, 124, and -9.
Page 13
•
A numeric literal that is written with a decimal point is considered a float. Examples
are 1.5, 3.14159, and 5.0.
So, the following statement causes the number 503 to be stored in memory as an int:
room = 503
And the following statement causes the number 2.75 to be stored in memory as a float:
dollars = 2.75
Storing Strings with the str Data Type
In addition to the int and float data types, Python also has a data type named str, which is
used for storing strings in memory. The code in Program 2-6 shows how strings can be assigned
to variables.
Program 2-6 (string_variable.py)
1 first_name = 'Kathryn'
2 last_name = 'Marino'
3 print(first_name, last_name)
Program Output
Kathryn Marino
Reading Input from the Keyboard
In this booklet we will use Python's built-in input function to read input from the keyboard.
The input function reads a piece of data that has been entered at the keyboard and returns
that piece of data, as a string, back to the program. You normally use the input function in an
assignment statement that follows this general format:
variable = input(prompt)
In the general format, prompt is a string that is displayed on the screen. The string’s purpose is
to instruct the user to enter a value. variable is the name of a variable that will reference
the data that was entered on the keyboard. Here is an example of a statement that uses the
input function to read data from the keyboard:
name = input('What is your name? ')
When this statement executes, the following things happen:
•
The string 'What is your name? ' is displayed on the screen.
Page 14
•
•
The program pauses and waits for the user to type something on the keyboard, and
then press the Enter key.
When the Enter key is pressed, the data that was typed is returned as a string, and
assigned to the name variable.
To demonstrate, look at the following interactive session:
>>> name = input('What is your name? ') [Enter]
What is your name? Holly [Enter]
>>> print(name) [Enter]
Holly
>>>
When the first statement was entered, the interpreter displayed the prompt 'What is
your name? ', and waited for the user to enter some data. The user entered Holly and
pressed the Enter key. As a result the string 'Holly' was assigned to the name variable.
When the second statement was entered, the interpreter displayed the value referenced by the
name variable.
Program 2-7 shows a complete program that uses the input function to read two strings as
input from the keyboard.
Program 2-7 (string_input.py)
1 first_name = input('Enter your first name: ')
2 last_name = input('Enter your last name: ')
3 print('Hello', first_name, last_name)
Program Output (with Input Shown in Bold)
Enter your first name: Vinny [Enter]
Enter your last name: Brown [Enter]
Hello Vinny Brown
Reading Numbers With The input Function
The input function always returns the user's input as a string, even if the user enters numeric
data. For example, suppose you call the input function and the user types the number 72 and
pressed the Enter key. The value that is returned from the input function is the string '72'.
This can be a problem if you want to use the value in a math operation. Math operations can be
performed only on numeric values, not strings.
Fortunately, Python has built-in functions that you can use to convert a string to a numeric
type. Table 2-2 summarizes two of these functions.
Page 15
Table 2-2 Data Conversion Functions
Function
Description
int(item)
You pass an argument to the int() function and it returns the
argument's value converted to an int.
float(item)
You pass an argument to the float() function and it returns the
argument's value converted to a float.
For example, suppose you are writing a payroll program and you want to get the number of
hours that the user has worked. Look at the following code:
string_value = input('How many hours did you work? ')
hours = int(string_value)
The first statement gets the number of hours from the user, and assigns that value as a string to
the string_value variable. The second statement calls the int() function, passing
string_value as an argument. The value referenced by string_value is converted to an
int, and assigned to the hours variable.
This example illustrates how the int() function works, but it is inefficient because it creates
two variables: one to hold the string that is returned from the input function, and another to
hold the integer that is returned from the int() function. The following code shows a better
approach. This one statement does all of the work that the previously shown two statements
do, and it creates only one variable:
hours = int(input('How many hours did you work? '))
This one statement uses nested function calls. The value that is returned from the input
function is passed as an argument to the int() function. This is how it works:
•
•
•
It calls the input function to get a value entered at the keyboard.
The value that is returned from the input function (a string), is passed as an argument
to the int() function.
The int value that is returned from the int() function is assigned to the hours
variable.
After this statement executes, the hours variable will be assigned the value entered at the
keyboard, converted to an int. Program 2-8 shows a sample program that uses the input
function.
Page 16
Program 2-8 (input.py)
1 age = int(input('What is your age? '))
2 print('Here is the value that you entered:')
3 print(age)
Program Output (with Input Shown in Bold)
What is your age? 28 [Enter]
Here is the value that you entered:
28
This is the Python version
of Program 2-2 in your
textbook!
You read floating-point numbers as input in a similar fashion. Suppose you want to get the
user's hourly pay rate. The following statement prompts the user to enter that value at the
keyboard, converts the value to a float, and assigns it to the pay_rate variable:
pay_rate = float(input('What is your hourly pay rate? '))
This is how it works:
•
•
•
It calls the input function to get a value entered at the keyboard.
The value that is returned from the input function (a string), is passed as an argument
to the float() function.
The float value that is returned from the float() function is assigned to the
pay_rate variable.
After this statement executes, the pay_rate variable will be assigned the value entered at
the keyboard, converted to a float.
Performing Calculations
Table 2-3 lists the math operators that are provided by the Python language.
Table 2-3 Python math operators
Symbol
Operation
Description
+
Addition
Adds two numbers
Subtraction
Subtracts one number from another
*
Multiplication Multiplies one number by another
/
Division
Divides one number by another and gives the quotient
%
Remainder
Divides one number by another and gives the remainder
**
Exponent
Raises a number to a power
Here are some examples of statements that use an arithmetic operator to calculate a value, and
assign that value to a variable:
Page 17
total = price + tax
sale = price - discount
population = population * 2
half = number / 2
leftOver = 17 % 3
result = 4**2
Program 2-9 shows an example program that performs mathematical calculations (This
program is the Python version of pseudocode Program 2-8 in your textbook.)
Program 2-9 (sale_price.py)
1
2
3
4
original_price = float(input("Enter the item's original price: "))
discount = original_price * 0.2
This is the Python version
sale_price = original_price - discount
print('The sale price is', sale_price)
of Program 2-9 in your
Program Output (With Input Shown in Bold)
Enter the item's original price: 100.00 [Enter]
The sale price is 80.0
textbook!
In Python, the order of operations and the use of parentheses as grouping symbols works just
as described in the textbook.
Integer Division
In Python, when an integer is divided by an integer the result will also be an integer. This
behavior is known as integer division. For example, look at the following statement:
number = 3 / 2
Because the numbers 3 and 2 are both treated as integers, Python will throw away (truncate)
the fractional part of the result. So, the statement will assign the value 1 to the number
variable, not 1.5.
If you want to make sure that a division operation yields a real number, at least one of the
operands must be a number with a decimal point or a variable that references a float value.
For example, we could rewrite the statement as follows:
number = 3.0 / 2.0
Page 18
Documenting a Program with Comments
To write a line comment in Python you simply place the # symbol where you want the
comment to begin. The Python interpreter ignores everything from that point to the end of the
line. Here is an example:
# This program calculates an employee's gross pay.
Page 19
Chapter 3 Modularizing Programs with Functions
Chapter 3 in your textbook discusses modules as named groups of statements that perform
specific tasks in a program. You use modules to break a program down into small, manageable
units. In Python, we use functions for this purpose. (In Python, the term "module" has a slightly
different meaning. A Python module is a file that contains a set of related program elements,
such as functions.)
In this chapter we will discuss how to define and call Python functions, use local variables in a
function, and pass arguments to a function. We also discuss global variables, and the use of
global constants.
Defining and Calling a Function
To create a function you write its definition. Here is the general format of a function definition
in Python:
def function_name():
statement
statement
etc.
The first line is known as the function header. It marks the beginning of the function definition.
The function header begins with the key word def, followed by the name of the function,
followed by a set of parentheses, followed by a colon.
Beginning at the next line is a set of statements known as a block. A block is simply a set of
statements that belong together as a group. These statements are performed any time the
function is executed. Notice in the general format that all of the statements in the block are
indented. This indentation is required because the Python interpreter uses it to tell where the
block begins and ends.
Let’s look at an example of a function. Keep in mind that this is not a complete program. We
will show the entire program in a moment.
def message():
print('I am Arthur,')
print('King of the Britons.')
This code defines a function named message. The message function contains a block with
two statements. Executing the function will cause these statements to execute.
Page 20
Calling a Function
A function definition specifies what a function does, but it does not cause the function to
execute. To execute a function, you must call it. This is how we would call the message
function:
message()
When a function is called, the interpreter jumps to that function and executes the statements
in its block. Then, when the end of the block is reached, the interpreter jumps back to the part
of the program that called the function, and the program resumes execution at that point.
When this happens, we say that the function returns. To fully demonstrate how function calling
works, look at Program 3-1.
Program 3-1 (function_demo.py)
1 # This program demonstrates a function.
2 # First, we define a function named message.
3 def message():
4
print('I am Arthur,')
5
print('King of the Britons.')
6
7 # Call the message function.
8 message()
Program Output
I am Arthur,
King of the Britons.
When the Python interpreter reads the def statement in line 3, a function named message is
created in memory, containing the block of statements in lines 4 and 5. (A function definition
creates a function, but it does not cause the function to execute.) Next, the interpreter
encounters the comment in line 7, which is ignored. Then it executes the statement in line 8,
which is a function call. This causes the message function to execute, which prints the two
lines of output.
Program 3-1 has only one function, but it is possible to define many functions in a program. In
fact, it is common for a program to have a main function that is called when the program
starts. The main function then calls other functions in the program as they are needed. It is
often said that the main function contains a program's mainline logic, which is the overall logic
of the program. Program 3-2 shows an example of a program with two functions: main and
show_message. This is the Python version of Program 3-1 in your textbook, with some extra
comments added.
Page 21
Program 3-2 (function_demo2.py)
1 # Define the main function.
2 def main():
3
print("I have a message for you.")
4
show_message()
5
print("That's all folks!")
6
7 # Define the show_message function.
8 def show_message():
9
print("Hello world")
10
11 # Call the main function.
12 main()
This is the Python version
of Program 3-1 in your
textbook!
Program Output
I have a message for you.
Hello world
That's all folks!
The main function is defined in lines 2 through 5, and the show_message function is defined
in lines 8 through 9. When the program runs, the statement in line 12 calls the main function,
which then calls the show_message function in line 4.
Indentation in Python
In Python, each line in a block must be indented. As shown in Figure 3-1, the last indented line
after a function header is the last line in the function's block.
Figure 3-1 All of the statements in a block are indented
When you indent the lines in a block, make sure each line begins with the same number of
spaces. Otherwise an error will occur. For example, the following function definition will cause
an error because the lines are all indented with different numbers of spaces.
def my_function():
Page 22
print('And now for')
print('something completely')
print('different.')
In an editor there are two ways to indent a line: (1) by pressing the Tab key at the beginning of
the line, or (2) by using the spacebar to insert spaces at the beginning of the line. You can use
either tabs or spaces when indenting the lines in a block, but don't use both. Doing so may
confuse the Python interpreter and cause an error.
IDLE, as well as most other Python editors, automatically indents the lines in a block. When you
type the colon at the end of a function header, all of the lines typed afterward will
automatically be indented. After you have typed the last line of the block you press the
Backspace key to get out of the automatic indentation.
Tip:
Python programmers customarily use four spaces to indent the lines in a block. You can
use any number of spaces you wish, as long as all the lines in the block are indented by
the same amount.
Note: Blank lines that appear in a block are ignored.
Local Variables
Anytime you assign a value to a variable inside a function, you create a local variable. A local
variable belongs to the function in which it is created, and only statements inside that function
can access the variable. (The term local is meant to indicate that the variable can be used only
locally, within the function in which it is created.) In Chapter 3 of your textbook you learned
that a variable's scope is the part of the program in which the variable may be accessed. A local
variable's scope is the function in which the variable is created.
Because a function’s local variables are hidden from other functions, the other functions may
have their own local variables with the same name. For example, look at the Program 3-3. In
addition to the main function, this program has two other functions: texas and
california. These two functions each have a local variable named birds.
Program 3-3 (birds.py)
1 # This program demonstrates two functions that
2 # have local variables with the same name.
3
4 def main():
5
# Call the texas function.
6
texas()
7
# Call the california function.
8
california()
9
Page 23
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# Definition of the texas function. It creates
# a local variable named birds.
def texas():
birds = 5000
print('texas has', birds, 'birds.')
# Definition of the california function. It also
# creates a local variable named birds.
def california():
birds = 8000
print('california has', birds, 'birds.')
# Call the main function.
main()
Program Output
texas has 5000 birds.
california has 8000 birds.
Although there are two separate variables named birds in this program, only one of them is
visible at a time because they are in different functions.
Passing Arguments to Functions
If you want a function to receive arguments when it is called, you must equip the function with
one or more parameter variables. A parameter variable, often simply called a parameter, is a
special variable that is assigned the value of an argument when a function is called. Here is an
example of a function that has a parameter variable:
def double_number(value):
result = value * 2
print(result)
This function’s name is double_number. Its purpose is to accept a number as an argument
and display the value of that number doubled. Look at the function header and notice the word
value that appear inside the parentheses. This is the name of a parameter variable. This
variable will be assigned the value of an argument when the function is called. Program 3-4
demonstrates the function in a complete program.
Page 24
Program 3-4 (pass_arg.py)
1
2
3
4
5
6
7
8
9
10
11
12
# Define the main function.
def main():
number = int(input('Enter a number and I will display that number doubled: '))
double_number(number)
# Define the double_number function.
def double_number(value):
result = value * 2
print(result)
This is the Python version of
Program 3-5 in your textbook!
# Call the main function.
main()
Program Output
Enter a number and I will display that number doubled: 20 [Enter]
40
When this program runs, the main function is called in line 12. Inside the main function, line 3
gets a number from the user and assigns it to the number variable. Line 4 calls the
double_number function passing the number variable as an argument.
The double_number function is defined in lines 26 through 36. The function has a parameter
variable named value. In line 8 a local variable named result is assigned the value of the
math expression value * 2. In line 35 the value of the result variable is displayed.
Passing Multiple Arguments
Often it is useful to pass more than one argument to a function. When you define a function,
you must have a parameter variable for each argument that you want passed into the function.
Program 3-5 shows an example. This is the Python version of pseudocode Program 3-6 in your
textbook.
Program 3-5 (multiple_args.py)
1 # This program demonstrates a function that accepts
2 # two arguments.
3
This is the Python version of
4 def main():
Program 3-6 in your textbook!
5
print('The sum of 12 and 45 is')
6
show_sum(12, 45)
7
8 # The show_sum function accepts two arguments
9 # and displays their sum.
10 def show_sum(num1, num2):
11
result = num1 + num2
12
print(result)
13
Page 25
14
15
# Call the main function.
main()
Program Output
The sum of 12 and 45 is
57
Notice that two parameter variable names, num1 and num2, appear inside the parentheses in
the show_sum function header. This is often referred to as a parameter list. Also notice that a
comma separates the variable names.
The statement in line 6 calls the show_sum function and passes two arguments: 12 and 45.
These arguments are passed by position to the corresponding parameter variables in the
function. In other words, the first argument is passed to the first parameter variable, and the
second argument is passed to the second parameter variable. So, this statement causes 12 to
be assigned to the num1 parameter and 45 to be assigned to the num2 parameter.
Making Changes to Parameters
When an argument is passed to a function in Python, the function parameter variable will
reference the argument's value. However, any changes that are made to the parameter
variable will not affect the argument. To demonstrate this look at Program 3-6.
Program 3-6 (change_me.py)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# This program demonstrates what happens when you
# change the value of a parameter.
def main():
value = 99
print('The value is', value)
change_me(value)
print('Back in main the value is', value)
def change_me(arg):
print('I am changing the value.')
arg = 0
print('Now the value is', arg)
# Call the main
main()
function.
Program Output
The value is 99
I am changing the value.
Now the value is 0
Back in main the value is 99
Page 26
The main function creates a local variable named value in line 5, assigned the value 99. The
statement in line 6 displays The value is 99. The value variable is then passed as an argument
to the change_me function in line 7. This means that in the change_me function the arg
parameter will also reference the value 99.
Global Variables
When a variable is created by an assignment statement that is written outside all the functions
in a program file, the variable is global A global variable can be accessed by any statement in
the program file, including the statements in any function. For example, look at Program 3-7.
Program 3-7 (global1.py)
1 # Create a global variable.
2 my_value = 10
3
4 # The show_value function prints
5 # the value of the global variable.
6 def show_value():
7
print(my_value)
8
9 # Call the show_value function.
10 show_value()
Program Output
10
The assignment statement in line 2 creates a variable named my_value. Because this
statement is outside any function, it is global. When the show_value function executes, the
statement in line 7 prints the value referenced by my_value.
An additional step is required if you want a statement in a function to assign a value to a global
variable. In the function you must declare the global variable, as shown in Program 3-14.
Program 3-14 (global2.py)
1 # Create a global variable.
This is the Python version of
2 number = 0
Program 3-11 in your textbook!
3
4 def main():
5
global number
6
number = int(input('Enter a number: '))
7
show_number()
8
9 def show_number():
10
print('The number you entered is', number)
Page 27
11
12
13
# Call the main function.
main()
Program Output
Enter a number: 22 [Enter]
The number you entered is 22
The assignment statement in line 2 creates a global variable named number. Notice that inside
the main function, line 5 uses the global key word to declare the number variable. This
statement tells the interpreter that the main function intends to assign a value to the global
number variable. That's just what happens in line 6. The value entered by the user is assigned
to number.
Global Constants
The Python language does not allow you to create true global constants, but you can simulate
them with global variables. If you do not declare a global variable with the global key word
inside a function, then you cannot change the variable's assignment.
Page 28
Chapter 4
Decision Structures and Boolean Logic
Relational Operators and the if Statement
Python's relational operators, shown in Table 4-1, are exactly the same as those discussed in
your textbook.
Table 4-1 Relational Operators
Operator
>
Greater than
<
Less than
>=
Greater than or equal to
<=
Less than or equal to
==
Equal to
!=
Not equal to
Meaning
The relational operators are used to create Boolean expressions, and are commonly used with
if statements. Here is the general format of the if statement in Python:
if condition:
statement
statement
etc.
For simplicity, we will refer to the first line as the if clause. The if clause begins with the
word if, followed by a condition, which is an expression that will be evaluated as either true or
false. A colon appears after the condition. Beginning at the next line is a block of statements. All
of the statements in a block must be consistently indented. This indentation is required
because the Python interpreter uses it to tell where the block begins and ends.
When the if statement executes, the condition is tested. If the condition is true, the
statements that appear in the block following the if clause are executed. If the condition is
false, the statements in the block are skipped.
Program 4-1 demonstrates the if statement. This Python program is similar to pseudocode
Program 4-1 in your textbook.
Page 29
Program 4-1 (test_average.py)
1 # This program prompts the user to enter three test
2 # scores. It displays the average of those scores and
3 # and congratulates the user if the average is 95
4 # or greater.
This is the Python version of
5
Program 4-1 in your textbook!
6 def main():
7
# Get the three test scores.
8
test1 = float(input('Enter the score for test 1: '))
9
test2 = float(input('Enter the score for test 2: '))
10
test3 = float(input('Enter the score for test 3: '))
11
12
# Calculate the average test score.
13
average = (test1 + test2 + test3) / 3.0
14
15
# Print the average.
16
print('The average score is', average)
17
18
# If the average is 95 or greater,
19
# congratulate the user.
20
if average >= 95:
21
print('Congratulations!')
22
print('That is a great average!')
23
24 # Call the main function.
25 main()
Program Output (with Input Shown in Bold)
Enter the score for test 1: 82 [Enter]
Enter the score for test 2: 76 [Enter]
Enter the score for test 3: 91 [Enter]
The average score is 83.0
Program Output (with Input Shown in Bold)
Enter the score for test 1: 93 [Enter]
Enter the score for test 2: 99 [Enter]
Enter the score for test 3: 96 [Enter]
The average score is 96.0
Congratulations!
That is a great score.
Dual Alternative Decision Structures
You use the if-else statement in Python to create a dual alternative decision structure. This
is the format of the if-else statement:
Page 30
if condition:
statement
statement
etc.
else:
statement
statement
etc.
When this statement executes, the condition is tested. If it is true, the block of indented
statements following the if clause is executed, and then control of the program jumps to the
statement that follows the if-else statement. If the condition is false, the block of indented
statements following the else clause is executed, and then control of the program jumps to
the statement that follows the if-else statement.
Program 4-2 shows an example. This is the Python version of pseudocode Program 4-2 in your
textbook. The program gets the number of hours that the user has worked (line 11) and the
user's hourly pay rate (line 12). The if-else statement in lines 15 through 18 determines
whether the user has worked more than 40 hours. If so, the calc_pay_with_OT function is
called in line 16. Otherwise the calc_regular_pay function is called in line 18.
Program 4-2 (auto_repair_payroll.py)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
# Global constants
BASE_HOURS = 40
OT_MULTIPLIER = 1.5
# Base hours per week
# Overtime multiplier
This is the Python version of
Program 4-2 in your textbook!
# The main function gets the number of hours worked and
# the hourly pay rate. It calls either the calc_pay_with_OT
# function or the calc_regular_pay function to calculate
# and display the gross pay.
def main():
# Get the hours worked and the hourly pay rate.
hours_worked = float(input('Enter the number of hours worked: '))
pay_rate = float(input('Enter the hourly pay rate: '))
# Calculate and display the gross pay.
if hours_worked > BASE_HOURS:
calc_pay_with_OT(hours_worked, pay_rate)
else:
calc_regular_pay(hours_worked, pay_rate)
# The calc_pay_with_OT function calculates pay with
# overtime. It accepts the hours worked and the hourly
# pay rate as arguments. The gross pay is displayed.
def calc_pay_with_OT(hours, rate):
# Calculate the number of overtime hours worked.
overtime_hours = hours - BASE_HOURS
#Calculate the amount of overtime pay.
overtime_pay = overtime_hours * rate * OT_MULTIPLIER
Page 31
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
# Calculate the gross pay.
gross_pay = BASE_HOURS * rate + overtime_pay
# Display the gross pay.
print('The gross pay is $', format(gross_pay, '.2f'))
# The calc_regular_pay function calculates pay with
# no overtime. It accepts the hours worked and the hourly
# pay rate as arguments. The gross pay is displayed.
def calc_regular_pay(hours, rate):
# Calculate the gross pay.
gross_pay = hours * rate
# Display the gross pay.
print('The gross pay is $', format(gross_pay, '.2f'))
# Call the main function.
main()
Program Output (with Input Shown in Bold)
Enter the number of hours worked: 40 [Enter]
Enter the hourly pay rate: 20 [Enter]
The gross pay is $800.00
Program Output (with Input Shown in Bold)
Enter the number of hours worked:50 [Enter]
Enter the hourly pay rate: 20 [Enter]
The gross pay is $1100.00
Comparing Strings
The relational operators can be used to compare strings, as shown here:
name1 = 'Mary'
name2 = 'Mark'
if name1 == name2:
print('The names are the same.')
else:
print('The names are NOT the same.')
The == operator compares name1 and name2 to determine whether they are equal. Because
the strings 'Mary' and 'Mark' are not equal, the else clause will display the message
'The names are NOT the same.'
Let's look at another example. Assume the month variable references a string. The following
code uses the != operator to determine whether the value referenced by month is not equal
to 'October'.
if month != 'October':
print('This is the wrong time for Octoberfest!')
Page 32
Program 4-3 is a complete program demonstrating how two strings can be compared. This is
the Python version of pseudocode Program 4-3 in your textbook. The program prompts the
user to enter a password and then determines whether the string entered is equal to
'prospero'.
Program 4-3 (password.py)
1 # This program demonstrates how the == operator can
2 # be used to compare strings.
This is the Python version of
3
4 def main():
Program 4-3 in your textbook!
5
# Get a password from the user.
6
password = input('Enter the password: ')
7
8
# Determine whether the correct password
9
# was entered.
10
if password == 'prospero':
11
print('Password accepted.')
12
else:
13
print('Sorry, that is the wrong password.'
14
15 # Call the main function.
16 main()
Program Output (with Input Shown in Bold)
Enter the password: ferdinand [Enter]
Sorry, that is the wrong password.
Program Output (with Input Shown in Bold)
Enter the password: prospero [Enter]
Password accepted.
String comparisons are case sensitive. For example, the strings 'saturday' and
'Saturday' are not equal because the “s” is lowercase in the first string, but uppercase in
the second string. The following sample session with Program 4-3 shows what happens when
the user enters Prospero as the password (with an uppercase P).
Program Output (with Input Shown in Bold)
Enter the password: Prospero [Enter]
Sorry, that is the wrong password.
Page 33
Nested Decision Structures
Program 4-4 shows an example of nested decision structures. As noted in your textbook, this
type of nested decision structure can also be written as an if-else-if statement, as shown in
Program 4-5.
Program 4-4 (nested_if.py)
1 def main():
2
# Prompt the user to enter the temperature.
3
temp = float(input('What is the temperature outside? '))
4
5
# Determine the type of weather we're having.
6
if temp < 30:
7
print('Wow. That is cold.')
8
else:
9
if temp < 50:
10
print('A little chilly.')
11
else:
12
if temp < 80:
13
print('Nice and warm.')
14
else:
15
print('Whew! It is hot!')
16
17 # Call the main function.
18 main()
Program Output (with Input Shown in Bold)
What is the outside temperature? 20 [Enter]
Wow! That is cold!
Program Output (with Input Shown in Bold)
What is the outside temperature? 45 [Enter]
A little chilly.
Program Output (with Input Shown in Bold)
What is the outside temperature? 70 [Enter]
Nice and warm.
Program Output (with Input Shown in Bold)
What is the outside temperature? 90 [Enter]
Whew! It is hot!
Page 34
Program 4-5 (if_elif_else.py)
1 def main():
2
# Prompt the user to enter the temperature.
3
temp = float(input('What is the temperature outside? '))
4
5
# Determine the type of weather we're having.
6
if temp < 30:
7
print('Wow. That is cold.')
8
elif temp < 50:
9
print('A little chilly.')
10
elif temp < 80:
11
print('Nice and warm.')
12
else:
13
print('Whew! It is hot!')
14
15 # Call the main function.
16 main()
Program Output (with Input Shown in Bold)
What is the outside temperature? 20 [Enter]
Wow! That is cold!
Program Output (with Input Shown in Bold)
What is the outside temperature? 45 [Enter]
A little chilly.
Program Output (with Input Shown in Bold)
What is the outside temperature? 70 [Enter]
Nice and warm.
Program Output (with Input Shown in Bold)
What is the outside temperature? 90 [Enter]
Whew! It is hot!
Note: Python does not prove a Case structure, so we can't cover that topic in this booklet.
also, we cannot provide a Python version of pseudocode Program 4-8.
Page 35
Logical Operators
Table 4-2 shows Python's logical operators, which work like the ones discussed in your
textbook.
Table 4-2 Python's Logical Operators
Operator
Meaning
and
The and operator connects two Boolean expressions into one
compound expression. Both subexpressions must be true for the
compound expression to be true.
or
The or operator connects two Boolean expressions into one
compound expression. One or both subexpressions must be true
for the compound expression to be true. It is only necessary for
one of the subexpressions to be true, and it does not matter
which.
not
The not operator is a unary operator, meaning it works with
only one operand. The operand must be a Boolean expression.
The not operator reverses the truth of its operand. If it is applied
to an expression that is true, the operator returns false. If it is
applied to an expression that is false, the operator returns true.
For example, the following if statement checks the value of x to determine if it is in the range
of 20 through 40:
if x >= 20 and x <= 40:
print(x, 'is in the acceptable range.')
The Boolean expression in the if statement will be true only when x is greater than or equal to
20 AND less than or equal to 40. The value in x must be within the range of 20 through 40 for
this expression to be true. The following statement determines whether x is outside the range
of 20 through 40:
if x < 20 or x > 40:
print(x, 'is outside the acceptable range.')
Here is an if statement using the not operator:
if not (temperature > 100):
print('This is below the maximum temperature.')
Page 36
First, the expression (temperature > 100) is tested and a value of either true or false is
the result. Then the not operator is applied to that value. If the expression (temperature
> 100) is true, the not operator returns false. If the expression (temperature > 100)
is false, the not operator returns true. The previous code is equivalent to asking: “Is the
temperature not greater than 100?”
Boolean Variables
The bool data type allows you to create variables that may reference one of two possible
values: True or False. Here are examples of how we assign values to a bool variable:
hungry = True
sleepy = False
Boolean variables are most commonly used as flags that signals when some condition exists in
the program. When the flag variable is set to False, it indicates the condition does not exist.
When the flag variable is set to True, it means the condition does exist.
For example, suppose a salesperson has a quota of $50,000. Assuming sales references the
amount that the salesperson has sold, the following code determines whether the quota has
been met:
if sales >= 50000.0:
sales_quota_met = True
else:
sales_quota_met = False
As a result of this code, the sales_quota_met variable can be used as a flag to indicate
whether the sales quota has been met. Later in the program we might test the flag in the
following way:
if sales_quota_met:
print('You have met your sales quota!')
This code displays 'You have met your sales quota!' if the bool variable sales_quota_met
is True. Notice that we did not have to use the == operator to explicitly compare the
sales_quota_met variable with the value True. This code is equivalent to the following:
if sales_quota_met == True:
print('You have met your sales quota!')
Page 37
Chapter 5
Repetition Structures
The while Loop
In Python, the while loop is written in the following general format:
while condition:
statement
statement
etc.
We will refer to the first line as the while clause. The while clause begins with the word
while, followed by a Boolean condition that will be evaluated as either true or false. A colon
appears after the condition. Beginning at the next line is a block of statements. All of the
statements in a block must be consistently indented. This indentation is required because the
Python interpreter uses it to tell where the block begins and ends.
When the while loop executes, the condition is tested. If the condition is true, the statements
that appear in the block following the while clause are executed, and then the loop starts
over. If the condition is false, the program exits the loop.
Program 5-1 shows an example of the while loop. This is the Python version of pseudocode
Program 5-2 in your textbook.
Program 5-1 (temperature.py)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
# This program assists a technician in the process
# of checking a substance's temperature.
# MAX_TEMP is used as a global constant for
# the maximum temperature.
MAX_TEMP = 102.5
# The main function
This is the Python version of
def main():
# Get the substance's temperature.
Program 5-2 in your textbook!
temperature = float(input("Enter the substance's Celsius temperature: "))
# As long as necessary, instruct the user to
# adjust the thermostat.
while temperature > MAX_TEMP:
print('The temperature is too high.')
print('Turn the thermostat down and wait')
print('5 minutes. Then take the temperature')
print('again and enter it.')
temperature = float(input('Enter the new Celsius temperature: '))
# Remind the user to check the temperature again
# in 15 minutes.
print('The temperature is acceptable.')
print('Check it again in 15 minutes.')
Page 38
27 # Call the main function.
28 main()
Program Output (with Input Shown in Bold)
Enter the substance's temperature: 104.7 [Enter]
The temperature is too high.
Turn the thermostat down and wait
5 minutes. Take the temperature
again and enter it.
Enter the new temperature: 103.2 [Enter]
The temperature is too high.
Turn the thermostat down and wait
5 minutes. Take the temperature
again and enter it.
Enter the new temperature: 102.1 [Enter]
The temperature is acceptable.
Check it again in 15 minutes.
Program Output (with Input Shown in Bold)
Enter the substance's temperature: 102.1 [Enter]
The temperature is acceptable.
Check it again in 15 minutes.
The for Loop
In Python, the for statement is designed to work with a sequence of data items. When the
statement executes, it iterates once for each item in the sequence. We will use the for
statement in the following general format:
for variable in [value1, value2, etc.]:
statement
statement
etc.
We will refer to the first line as the for clause. In the for clause, variable is the name of a
variable. Inside the brackets a sequence of values appears, with a comma separating each
value. (In Python, a comma-separated sequence of data items that are enclosed in a set of
brackets is called a list.) Beginning at the next line is a block of statements that is executed each
time the loop iterates.
The for statement executes in the following manner: The variable is assigned the first value in
the list, and then the statements that appear in the block are executed. Then, variable is
assigned the next value in the list, and the statements in the block are executed again. This
Page 39
continues until variable has been assigned the last value in the list. Program 5-2 shows a simple
example that uses a for loop to display the numbers 1 through 5.
Program 5-2 (simple_loop1.py)
1 # This program demonstrates a simple for loop
2 # that uses a list of numbers.
3
4 def main():
5
print('I will display the numbers 1 through 5.')
6
for num in [1, 2, 3, 4, 5]:
7
print(num)
8
9 # Call the main function.
10 main()
Program Output
I will display the numbers 1 through 5.
1
2
3
4
5
The first time the for loop iterates, the num variable is assigned the value 1 and then the
statement in line 7 executes (displaying the value 1). The next time the loop iterates, num is
assigned the value 2, and the print function is called (displaying the value 2). This process
continues, as shown in Figure 5-1, until num has been assigned the last value in the list. Because
the list contains five values, the loop will iterate five times.
Python programmers commonly refer to the variable that is used in the for clause as the
target variable because it is the target of an assignment at the beginning of each loop iteration
The values that appear in the list do not have to be a consecutively ordered series of numbers.
For example, Program 5-3 uses a for loop to display a list of odd numbers. There are five
numbers in the list, so the loop iterates five times.
Page 40
Figure 5-1 The for loop
Program 5-3 (simple_loop2.py)
1 # This program also demonstrates a simple for
2 # loop that uses a list of numbers.
3
4 def main():
5
print('I will display the odd numbers 1 through 9.')
6
for num in [1, 3, 5, 7, 9]:
7
print(num)
8
9 # Call the main function.
10 main()
Program Output
I will display the odd numbers 1 through 9.
1
3
5
7
9
Page 41
Program 5-4 shows another example. In this program the for loop iterates over a list of
strings. Notice that the list (in line 5) contains the three strings 'Winken', 'Blinken', and
'Nod'. As a result, the loop iterates three times.
Program 5-4 (simple_loop3.py)
1 # This program also demonstrates a simple for
2 # loop that uses a list of numbers.
3
4 def main():
5
for name in ['Winken', 'Blinken', 'Nod']:
6
print(name)
7
8 # Call the main function.
9 main()
Program Output
Winken
Blinken
Nod
Using the range Function with the for Loop
Python provides a built-in function named range that simplifies the process of writing a countcontrolled for loop. Here is an example of a for loop that uses the range function:
for num in range(5):
print(num)
Notice that instead of using a list of values, we call to the range function passing 5 as an
argument. In this statement the range function will generate a list of integers in the range of 0
up to (but not including) 5. This code works the same as the following:
for num in [0, 1, 2, 3, 4]:
print(num)
As you can see, the list contains five numbers, so the loop will iterate five times. Program 5-5
uses the range function with a for loop to display "Hello world" five times.
Program 5-5 (simple_loop4.py)
1 # This program demonstrates how the range
2 # function can be used with a for loop.
3
4 def main():
5
# Print a message five times.
This is the Python version of
6
for x in range(5):
Program 5-8 in your textbook!
Page 42
7
print('Hello world!')
8
9 # Call the main function.
10 main()
Program Output
Hello world
Hello world
Hello world
Hello world
Hello world
If you pass one argument to the range function, as demonstrated in Program 5-5, that
argument is used as the ending limit of the list. If you pass two arguments to the range
function, the first argument is used as the starting value of the list and the second argument is
used as the ending limit. Here is an example:
for num in range(1, 5):
print(num)
This code will display the following:
1
2
3
4
By default, the range function produces a list of numbers that increase by 1 for each
successive number in the list. If you pass a third argument to the range function, that
argument is used as step value. Instead of increasing by 1, each successive number in the list
will increase by the step value. Program 5-6 shows an example:
Program 5-6 (odd_numbers.py)
1 for num in range(1, 12, 2):
2
print(num)
This is the Python version of
Program 5-10 in your textbook!
Program Output
1
3
5
7
9
11
Page 43
In this for statement, three arguments are passed to the range function:
• The first argument, 1, is the starting value for the list.
• The second argument, 12, is the ending limit of the list. This means that the last number
in the list will be 11.
• The third argument, 2, is the step value. This means that 2 will be added to each
successive number in the list.
Using the Target Variable inside the Loop
In a for loop, the purpose of the target variable is to reference each item in a sequence of
items as the loop iterates. In many situations it is helpful to use the target variable in a
calculation or other task within the body of the loop. For example, suppose you need to write a
program that displays the numbers 1 through 10 and their squares, in a table similar to the
following:
Number
1
2
3
4
5
6
7
8
9
10
Square
1
4
9
16
25
36
49
64
81
100
This can be accomplished by writing a for loop that iterates over the values 1 through 10.
During the first iteration, the target variable will be assigned the value 1, during the second
iteration it will be assigned the value 2, and so forth. Because the target variable will reference
the values 1 through 10 during the loop’s execution, you can use it in the calculation inside the
loop. Program 5-7 shows how this is done.
Program 5-7 (squares.py)
1 # This program uses a loop to display a
2 # table showing the numbers 1 through 10
3 # and their squares.
4
This is the Python version of
5 def main():
Program 5-9 in your textbook!
6
# Print the table headings.
7
print('Number\tSquare')
8
print('--------------')
9
10
# Print the numbers 1 through 10
Page 44
11
12
13
14
15
16
17
# and their squares.
for number in range(1, 11):
square = number**2
print(number, '\t', square)
# Call the main function.
main()
Program Output
Number Square
-------------1
1
2
4
3
9
4
16
5
25
6
36
7
49
8
64
9
81
10
100
First, take a closer look at line 7, which displays the table headings:
print('Number\tSquare')
Notice that inside the string literal the \t escape sequence between the words Number and
Square. These are special formatting characters known as the tab escape sequence. The escape
sequence works similarly to the word Tab that is used in pseudocode in your textbook. As you
can see in the program output, the "\t" characters are not displayed on the screen, but rather
cause the output cursor to "tab over." It is useful for aligning output in columns on the screen.
The for loop that begins in line 12 uses the range function to produce a list containing the
numbers 1 through 10. During the first iteration, number will reference 1, during the second
iteration number will reference 2, and so forth, up to 10. Inside the loop, the statement in line
13 raises number to the power of 2 (recall that ** is the exponent operator), and assigns the
result to the square variable. The statement in line 14 prints the value referenced by
number, tabs over, and then prints the value referenced by square. (Tabbing over with the
\t escape sequence causes the numbers to be aligned in two columns in the output.)
Page 45
Calculating a Running Total
Your textbook discusses the common programming task of calculating the sum of a series of
values, also known as calculating a running total. Program 5-8 demonstrates how this can be
done in Python. The total variable that is declared in line 6 is the accumulator variable.
Notice that it is initialized with the value 0. During each loop iteration the user enters a number,
and in line 15 this number is added to the value already stored in total. The total variable
accumulates the sum of all the numbers entered by the user. This program is the Python
version of pseudocode Program 5-18 in your textbook.
Program 5-14 (sum_numbers.py)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# This program calculates the sum of
# five numbers entered by the user.
def main():
# Initialize an accumulator variable.
total = 0.0
This is the Python version
of Program 5-18 in your
textbook!
# Explain what we are doing.
print('This program calculates the sum of')
print('five numbers you will enter.')
# Get five numbers and accumulate them.
for counter in range(5):
number = int(input('Enter a number: '))
total = total + number
# Display the total of the numbers.
print('The total is', total)
# Call the main function.
main()
Program Output (with Example Input Shown in Bold)
This program calculates the sum of
five numbers you will enter.
Enter a number: 1 [Enter]
Enter a number: 2 [Enter]
Enter a number: 3 [Enter]
Enter a number: 4 [Enter]
Enter a number: 5 [Enter]
The total is 15.0
Page 46
Chapter 6 Value-Returning Functions
The functions that you learned about in Chapter 3 of this booklet are simple functions that do
not return a value. A function can also be written to return a value to the statement that called
the function. We refer to such a function as a value-returning function.
Generating Random Integers
Python provides several library functions for working with random numbers. To use any of
these functions you first need to write this import statement at the top of your program:
import random
The first random-number generating function that we will discuss is random.randint. The
following statement shows an example of how you might call the random.randint
function.
number = random.randint(1, 100)
The part of the statement that reads random.randint(1, 100) is a call to the function.
Notice that two arguments appear inside the parentheses: 1 and 100. These arguments tell the
function to give an integer random number in the range of 1 through 100. (The values 1 and
100 are included in the range.)
Notice that the call to the random.randint function appears on the right side of an =
operator. When the function is called, it will generate a random number in the range of 1
through 100 and then return that number. The number that is returned will be assigned to the
number variable.
Program 6-1 shows a complete demonstration. This is the Python version of pseudocode
Program 6-2 in your textbook. This program uses a for loop that iterates five times. Inside the
loop, the statement in line 8 calls the random.randint function to generate a random
number in the range of 1 through 100.
Page 47
Program 6-2 (random_numbers2.py)
1 # This program displays five random
2 # numbers in the range of 1 through 100.
3 import random
4
5 def main():
6
for count in range(5):
7
# Get a random number.
8
number = random.randint(1, 100)
9
# Display the number.
10
print(number)
11
12 # Call the main function.
13 main()
This is the Python version
of Program 6-2 in your
textbook!
Program Output
89
7
16
41
12
Other Random Number Functions
The standard library contains numerous functions for working with random numbers. In
addition to the random.randint function, you might find the random.randrange,
random, and random.uniform functions useful. (To use any of these functions you need to
write import random at the top of your program.)
If you remember how to use the range function (which we discussed in Chapter 5) then you
will immediately be comfortable with the random.randrange function. The
random.randrange function takes the same arguments as the range function. The
difference is that the random.randrange function does not return a list of values. Instead,
it returns a randomly selected value from a sequence of values. For example, the following
statement assigns a random number in the range of 0 through 9 to the number variable:
number = random.randrange(10)
The argument, in this case 10, specifies the ending limit of the sequence of values. The function
will return a randomly-selected number from the sequence of values 0 up to, but not including,
the ending limit. The following statement specifies both a starting value and an ending limit for
the sequence:
number = random.randrange(5, 10)
Page 48
When this statement executes, a random number in the range of 5 through 9 will be assigned
to number. The following statement specifies a starting value, an ending limit, and a step
value:
number = random.randrange(0, 101, 10)
In this statement the random.randrange function returns a randomly selected value from
the following sequence of numbers:
[0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
Both the random.randint and the random.randrange functions return an integer
number. The random.random function returns, however, returns a random floating-point
number. You do not pass any arguments to the random.random function. When you call it, it
returns a random floating point number in the range of 0.0 up to 1.0 (but not including 1.0).
Here is an example:
number = random.random()
The random.uniform function also returns a random floating-point number, but allows you
to specify the range of values to select from. Here is an example:
number = random.uniform(1.0, 10.0)
In this statement the random.uniform function returns a random floating-point number in
the range of 1.0 through 10.0 and assigns it to the number variable.
Writing Your Own Value-Returning Methods
Up to now, all of the functions that you have written have been simple functions that do not
return a value. You write a value-returning function in the same way that you write a simple
function, with one exception: a value-returning function must have a return statement. Here
is the general format of a value-returning function definition in Python:
def function_name():
statement
statement
etc.
return expression
One of the statements in the function must be a return statement, which takes the following
form:
Page 49
return expression
The value of the expression that follows the key word return will be sent back to the part of
the program that called the function. This can be any value, variable, or expression that has a
value (such as a math expression).
Here is a simple example of a value-returning function:
def sum(num1, num2):
result = num1 + num2
return result
Figure 6-1 illustrates various parts of the function.
Figure 6-1 Parts of the function
The purpose of this function is to accept two integer values as arguments and return their sum.
Let’s take a closer look at how it works. The first statement in the function's block assigns the
value of num1 + num2 to the result variable. Next, the return statement executes,
which causes the function to end execution and sends the value referenced by the result
variable back to the part of the program that called the function. Program 6-3 demonstrates the
function.
Program 6-2 (total_ages.py)
1 # This program uses the return value of a function.
2
This is the Python version of Program 6-6 in your
3 def main():
textbook!
4
# Get the user's age.
5
first_age = int(input('Enter your age: '))
6
7
# Get the user's best friend's age.
8
second_age = int(input("Enter your best friend's age: "))
9
10
# Get the sum of both ages.
Page 50
11
12
13
14
15
16
17
18
19
20
21
22
23
total = sum(first_age, second_age)
# Display the total age.
print('Together you are', total, 'years old.')
# The sum function accepts two numeric arguments and
# returns the sum of those arguments.
def sum(num1, num2):
result = num1 + num2
return result
# Call the main function.
main()
Program Output (with Input Shown in Bold)
Enter your age: 22 [Enter]
Enter your best friend's age: 24 [Enter]
Together you are 46 years old.
Returning Strings
So far you’ve seen examples of functions that return numbers. You can also write functions that
return strings. For example, the following function prompts the user to enter his or her name,
and then returns the string that the user entered.
def get_name():
# Get the user's name.
name = input('Enter your name: ')
# Return the name.
return name
Returning Boolean Values
Python allows you to write Boolean functions, which return either True or False. For
example, the following function accepts a number as an argument, and returns True if the
argument is an even number. Otherwise, it returns False.
Page 51
def is_even(number):
# Determine whether number is even. If it is,
# set status to true. Otherwise, set status
# to false.
if (number % 2) == 0:
status = True
else:
status = False
# Return the value of the status variable.
return status
The following code gets a number from the user, and then calls the function to determine
whether the number is even or odd:
value = int(input('Enter a number: '))
if is_even(value):
print('The number is even.')
else:
print('The number is odd.')
Math Functions
The Python standard library contains several functions that are useful for performing
mathematical operations. Table 6-2 lists many of the math functions. To use these functions
you first need to write this import statement at the top of your program:
import math
These functions typically accept one or more values as arguments, perform a mathematical
operation using the arguments, and return the result. For example, one of the functions is
named math.sqrt. The math.sqrt function accepts an argument and returns the square
root of the argument. Here is an example of how it is used:
result = math.sqrt(16)
Table 6-2 Many of the functions in the math module
Function
Description
math.acos(x)
Returns the arc cosine of x, in radians.
math.asin(x)
Returns the arc sine of x, in radians.
math.atan(x)
Returns the arc tangent of x, in radians.
math.ceil(x)
Returns the smallest integer that is greater than or equal to x.
math.cos(x)
Returns the cosine of x in radians.
math.degrees(x)
Assuming x is an angle in radians, the function returns the
angle converted to degrees.
Page 52
math.exp(x)
math.floor(x)
math.hypot(x, y)
math.log(x)
math.log10(x)
math.radians(x)
math.sin(x)
math.sqrt(x)
math.tan(x)
Returns ex
Returns the largest integer that is less than or equal to x.
Returns the length of a hypotenuse that extends from (0, 0)
to (x, y).
Returns the natural logarithm of x.
Returns the base-10 logarithm of x.
Assuming x is an angle in degrees, the function returns the
angle converted to radians.
Returns the sine of x in radians.
Returns the square root of x.
Returns the tangent of x in radians.</TB></TBL>
The math.pi and math.e Values
The Python library also defines two variables, math.pi and math.e, which are assigned
mathematical values for pi and e. You can use these variables in equations that require their
values. For example, the following statement, which calculates the area of a circle, uses pi.
(Notice that we use dot notation to refer to the variable.)
area = math.pi * radius**2
Formatting Numbers
Chapter 6 in your textbook also covers formatting functions, and gives an example for
formatting a number to look like a currency amount. In Python 3, we use the built-in format
function to format numbers for output.
When you call the built-in format function, you pass it two arguments: a numeric value, and a
format specifier. The format specifier is a string that contains special characters specifying how
the numeric value should be formatted. Let's look at an example:
format(12345.6789, '.2f')
The first argument, which is the floating-point number 12345.6789, is the number that we
want to format. The second argument, which is the string '.2f', is the format specifier. Here's
the meaning of its contents:
•
•
The .2 specifies the precision. It indicates that we want to round the number to two
decimal places.
The f specifies that the data type of the number we are formatting is a floating-point
number. (If you are formatting an integer, you cannot use f for the type. We will discuss
integer formatting momentarily.)
Page 53
The format function returns a string containing the formatted number. The following
interactive mode session demonstrates how you use the format function along with the
print function to display a formatted number:
>>> print(format(12345.6789, '.2f')) [Enter]
12345.68
>>>
Notice that the number is rounded to two decimal places. The following example shows the
same number, rounded to one decimal place:
>>> print(format(12345.6789, '.1f')) [Enter]
12345.7
>>>
Here is an example that prints multiple items, one of which is a formatted number:
>>> print('The number is', format(1.234567, '.2f')) [Enter]
The number is 1.23
>>>
In Program 6-3 a value is displayed rounded to 1, 2, 3, 4, 5, and 6 decimal places.
Program 6-3 (decimal_places.py)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# This program demonstrates how a value can be
# formatted, rounded to different numbers of
# decimal places.
def main():
my_value = 1.123456789
print(format(my_value,
print(format(my_value,
print(format(my_value,
print(format(my_value,
print(format(my_value,
print(format(my_value,
'.1f'))
'.2f'))
'.3f'))
'.4f'))
'.5f'))
'.6f'))
#
#
#
#
#
#
Rounded
Rounded
Rounded
Rounded
Rounded
Rounded
to
to
to
to
to
to
1
2
3
4
5
6
decimal
decimal
decimal
decimal
decimal
decimal
place
places
places
places
places
places
# Call the main function.
main()
Program Output
1.1
1.12
1.123
1.1235
1.12346
1.123457
Page 54
Inserting Comma Seperators
If you want the number to be formatted with comma separators, you can insert a comma into
the format specifier, as shown here:
>>> print(format(12345.6789, ',.2f')) [Enter]
12,345.68
>>>
Here is an example that formats an even larger number:
>>> print(format(123456789.456, ',.2f')) [Enter]
123,456,789.46
>>>
String Functions
Getting a String's length
You use the len function to get the length of a string. The following code demonstrates:
name = 'Charlemagne'
strlen = len(name)
After this code executes, the strlen variable will be assigned the value 11, which is the
number of characters in the string 'Charlemagne'.
Appending Strings
In Python, you do not use a function to append a string to another string. Instead, you use the +
operator. When the + operator is used with two strings, it performs string concatenation. This
means that it appends one string to another. For example, look at the following statement:
message = 'This is ' + 'one string.'
After this statement executes, the message variable will reference the string'This is one
string.'
The upper and lower Methods
The upper method returns a copy of a string with all of its letters converted to uppercase.
Here is an example:
littleName = 'herman'
Page 55
bigName = littleName.upper()
After this code executes, the bigName variable will reference the string "HERMAN".
The lower method returns a copy of a string with all of its letters converted to lowercase.
Here is an example:
bigName = 'HERMAN'
littleName = bigName.lower()
After this code executes, the littleName variable will reference the string "herman".
The find Method
In Python you can use the find method to perform a task similar to that of the contains
function discussed in your textbook. The find method searches for a substring within a string.
The method returns the index of the first occurrence of the substring, if it is found. (The index is
the character position number within the string. The first character in a string is at index 0, the
second character in a string is a index 1, and so forth.) If the substring is not found, the method
returns -1. Here is an example:
string = 'Four score and seven years ago'
position = string.find('seven')
if position != -1:
print('The word "seven" was found at index', position)
else:
print('The word "seven" was not found.')
This code will display:
The word "seven" was found at index 15
String Slicing
A slice is a span of items that are taken from a sequence. When you take a slice from a string,
you get a span of characters from within the string. String slices are also called substrings.
To get a slice of a string, you write an expression in the following general format:
string[start : end]
In the general format, start is the index of the first character in the slice, and end is the
index marking the end of the slice. The expression will return a string containing a copy of the
Page 56
characters from start up to (but not including) end. For example, suppose we have the
following:
full_name = 'Patty Lynn Smith'
middle_name = full_name[6:10]
The second statement assigns the string 'Lynn' to the middle_name variable. If you leave out
the start index in a slicing expression, Python uses 0 as the starting index. Here is an
example:
full_name = 'Patty Lynn Smith'
first_name = full_name[:5]
The second statement assigns the string 'Lynn' to first_name. If you leave out the end index
in a slicing expression, Python uses the length of the string as the end index. Here is an
example:
full_name = 'Patty Lynn Smith'
last_name = full_name[11:]
The second statement assigns the string 'Smith' to first_name. What do you think the
following code will assign to the my_string variable?
full_name = 'Patty Lynn Smith'
my_string = full_name[:]
The second statement assigns the entire string 'Patty Lynn Smith' to my_string. The
statement is equivalent to:
my_string =
full_name[0 : len(full_name)]
The slicing examples we have seen so far get slices of consecutive characters from stings. Slicing
expressions can also have step value, which can cause characters to be skipped in the string.
Here is an example of code that uses a slicing expression with a step value:
letters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
print(letters[0:26:2])
The third number inside the brackets is the step value. A step value of 2, as used in this
example, causes the slice to contain every 2nd character from the specified range in the string.
The code will print the following:
ACEGIKMOQSUWY
Page 57
You can also use negative numbers as indexes in slicing expressions, to reference positions
relative to the end of the string. Here is an example:
full_name = 'Patty Lynn Smith'
last_name = full_name[-5:]
Recall that Python adds a negative index to the length of a string to get the position referenced
by that index. The second statement in this code assigns the string 'Smith' to the last_name
variable.
Note: Invalid indexes do not cause an error. For example:
•
•
•
If the end index specifies a position beyond the end of the string, Python will use the length
of the string instead.
If the start index specifies a position before the beginning of the string, Python will use 0
instead.
If the start index is greater than the end index, the slicing expression will return an empty
string.
Page 58
Chapter 7
Input Validation
Chapter 7 in your textbook discusses the process of input validation in detail. There are no new language
features introduced in the chapter, so here we will simply show you a Python version of the pseudocode
Program 7-2. This program uses an input validation loop in lines 28 through 30 to validate that the value
entered by the user is not negative.
Program 7-2 (retail.py)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
# This program calculates retail prices.
# MARK_UP is used as a global constant for
# the markup up percentage.
MARK_UP = 2.5
This is the Python version of
Program 7-2 in your textbook!
# The main function
def main():
# Variable to control the loop.
another = 'y'
# Process one or more items.
while another == 'y' or another == 'Y':
# Display an item's retail price.
show_retail()
# Do this again?
another = input('Do you have another item? ' +
'(Enter y for yes): ')
# The show_retail function gets an item's wholesale
# cost and displays the item's retail price.
def show_retail():
# Get the item's wholesale cost.
wholesale = float(input("Enter the item's wholesale cost: "))
# Validate the wholesale cost.
while wholesale < 0:
print('ERROR: the cost cannot be negative.')
wholesale = float(input('Enter the correct wholesale cost: '))
# Calculate the retail price.
retail = wholesale * MARK_UP
# Display the retail price.
print('The retail price is $', format(retail, '.2f'))
# Call the main function.
main()
Program Output
Enter the item's wholesale cost: -.50 [Enter]
ERROR: The cost cannot be negative.
Page 59
Enter the correct wholesale cost: 0.50 [Enter]
The retail price is $ 1.25.
Do you have another item? (Enter y for yes): n [Enter]
Page 60
Chapter 8
Arrays (Lists)
In Python, you create lists instead of arrays. A list is similar to an array, but provides many more
capabilities than a traditional array. A list is an object that contains multiple data items. Each
item that is stored in a list is called an element. Here is a statement that creates a list of
integers:
even_numbers = [2, 4, 6, 8, 10]
The items that are enclosed in brackets and separated by commas are the values of the list
elements. The following is another example:
names = ['Molly', 'Steven', 'Will', 'Alicia', 'Adriana']
This statement creates a list of 5 strings.
You can use the print function to display an entire list, as shown here:
numbers = [5, 10, 15, 20]
print(numbers)
When the print function is called in the second statement, it will display the elements of the
list like this:
[5, 10, 15, 20]
List Elements and Subscripts
You access each element of a list with a subscript. As discussed in your textbook, the first
element's subscript is 0, the second element's subscript is 1, and so forth. The last element's
subscript is the array size minus 1. Program 8-1 shows an example of a list being used to hold
values entered by the user. This is the Python version of pseudocode Program 8-1 in your
textbook.
Program 8-1 (list_input.py)
1
2
3
4
5
6
7
8
9
10
# Create a list to hold the number of hours
# worked by each employee.
hours = [0, 0, 0]
This is the Python version of
Program 8-1 in your textbook!
# Get the hours worked by employee 1.
hours[0] = int(input('Enter the hours worked by employee 1: '))
# Get the hours worked by employee 2.
hours[1] = int(input('Enter the hours worked by employee 2: '))
Page 61
11
12
13
14
15
16
17
18
# Get the hours worked by employee 3.
hours[2] = int(input('Enter the hours worked by employee 3: '))
# Display the values entered.
print('The hours you entered are:')
print(hours[0])
print(hours[1])
print(hours[2])
Program Output
Enter the hours worked by employee 1: 40 [Enter]
Enter the hours worked by employee 2: 20 [Enter]
Enter the hours worked by employee 3: 15 [Enter]
The hours you entered are:
40
20
15
Using the len Function with Lists
An error will occur if you use an invalid index with a list. For example, look at the following
code:
# This code will cause an error.
my_list = [10, 20, 30, 40]
index = 0
while index < 5:
print(my_list[index])
index += 1
The last time that this loop iterates, the index variable will be assigned the value 4, which is
an invalid index for the list. As a result, the statement that calls the print function will cause
an error.
The len function, that you learned about in Chapter 6 of this language companion, can be used
with lists as well as strings. When you pass a list as an argument, the len function returns the
number of elements in the list. The previously shown code, which causes an error, can be
modified as follows to prevent the error:
my_list = [10, 20, 30, 40]
index = 0
while index < len(my_list):
print(my_list[index])
index += 1
Page 62
Iterating Over a List with the for Loop
You can easily iterate over the contents of a list with the for loop, as shown here:
numbers = [99, 100, 101, 102]
for n in numbers:
print(n)
The for statement executes in the following manner: The variable n is assigned a copy of the
first value in the list, and then the statements that appear in the block are executed. Then, the
variable n is assigned a copy of the next value in the list, and the statements in the block are
executed again. This continues until the variable has been assigned the last value in the list. If
we run this code, it will print:
99
100
101
102
Keep in mind that as the for loop executes, the n variable is assigned a copy of the list elements, and
any changes made to the n variable do not affect the list. To demonstrate, look at the following:
1
numbers = [99, 100, 101, 102]
2
3
4
5
for n in my_list:
n = 0
print(my_list)
The statement in line 3 merely reassigns the n variable to a different value (0). It does not change the
list element that n referred to before the statement executed. When this code executes, the statement
in line 5 will print:
99
100
101
102
Program 8-2 further demonstrates the use of loops with a list. This is the Python version of
pseudocode Program 8-3 in your textbook.
Program 8-2 (list_loop.py)
1
2
3
4
5
6
# Create a list to hold the number of hours
# worked by each employee.
hours = [0, 0, 0]
This is the Python version of
Program 8-3 in your textbook!
# Create a variable to use in the loop, initialized at 0.
index = 0
Page 63
7
8
9
10
11
12
13
14
15
16
# Get the hours for each employee.
while index < len(hours):
hours[index] = int(input('Enter the hours worked by employee ' +
str(index + 1) + ': '))
index += 1
# Display the values entered.
for n in hours:
print(n)
Program Output
Enter the hours worked by employee 1: 40 [Enter]
Enter the hours worked by employee 2: 20 [Enter]
Enter the hours worked by employee 3: 15 [Enter]
40
20
15
Sequentially Searching an Array
Section 8.2 in your textbook discusses the sequential search algorithm, in which a program steps
through each of an array's elements searching for a specific value. Program 8-3 shows an example of the
sequential search algorithm. This is the Python version of pseudocode Program 8-6 in the textbook.
Program 8-3 (sequential_search.py)
1 # Create a list of test scores.
This is the Python version of
2 scores = [87, 75, 98, 100, 82,
Program 8-6 in your textbook!
3
72, 88, 92, 60, 78]
4
5 # Create a Boolean variable to act as a flag.
6 found = False
7
8 # Create a variable to use as a loop counter.
9 index = 0
10
11 # Step through the list searching for a
12 # score equal to 100.
13 while found == False and index < len(scores):
14
if scores[index] == 100:
15
found = True
16
else:
17
index = index + 1
18
19 # Display the search results.
20 if found:
21
print('You earned 100 on test number ' + str(index + 1))
Page 64
22 else:
23
print('You did not earn 100 on any test.')
Program Output
You earned 100 on test number 4
Searching a String Array
Program 8-4 demonstrates how to find a string in a list of strings. This is the Python version of
pseudocode Program 8-7 in the textbook.
Program 8-4 (string_list_search.py)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
# Create a list of strings.
names = ['Ava Fischer', 'Chris Rich', 'Geri Rose',
'Matt Hoyle', 'Rose Harrison', 'Giovanni Ricci']
# Create a Boolean variable to act as a flag.
found = False
# Create a variable to use as a loop counter.
index = 0
This is the Python version of
Program 8-7 in your textbook!
# Get the string to search for.
searchValue = input('Enter a name to search for in the list: ')
# Step through the list searching for the
# specified name.
while found == False and index < len(names):
if names[index] == searchValue:
found = True
else:
index = index + 1
# Display the search results.
if found:
print('That name was found in element ' + str(index + 1))
else:
print('That name was not found in the list.')
Program Output
Enter a name to search for in the list: Matt Hoyle [Enter]
That name was found in element 3
Program Output
Enter a name to search for in the list: Terry Thompson [Enter]
That name was not found in the array.
Page 65
Passing List as an Argument to a Function
When passing a list as an argument to a function in Python, it is not necessary to pass a
separate argument indicating the list's size. This is because Python provides the len function
that reports the list's size. The following code shows a function that has been written to accept
a list as an argument:
def set_to_zero(numbers):
index = 0
while index < len(numbers):
numbers[index] = 0
index = index + 1
The function's parameter, numbers, is used to refer to a list. When you call this function and
pass a list as an argument, the loop sets each element to 0. Here is an example of a code that
calls the function:
my_list = [1, 2, 3, 4, 5]
set_to_zero(my_list)
print(my_list)
The last statement will print:
0
0
0
0
0
Program 8-5 gives a complete demonstration of passing an array to a method. This is the Python version
of pseudocode Program 8-13 in your textbook.
Program 8-5 (pass_list.py)
1 def main():
This is the Python version of
2
# Create a list.
Program 8-13 in your textbook!
3
numbers = [2, 4, 6, 8, 10]
4
5
# Get the sum of the elements.
6
sum = get_total(numbers)
7
8
# Display the sum of the list elements.
9
print('The total is', sum)
10
11 # The get_total function accepts a list as an
12 # argument returns the total of the values in
13 # the list.
Page 66
14 def get_total(value_list):
15
# Create a variable to use as an accumulator.
16
total = 0
17
18
# Calculate the total of the list elements.
19
for num in value_list:
20
total += num
21
22
# Return the total.
23
return total
24
25 # Call the main function.
26 main()
Program Output
The sum of the array elements is 30
Two-Dimensional Arrays
In Python you can create a list of lists, which acts much like a two-dimensional array. Here's an
example:
numbers = [ [1, 2, 3], [10, 20, 30] ]
This creates a list named numbers, with two elements. The first element is the following list:
[1, 2, 3]
The second element is the following list:
[10, 20, 30]
The following statement prints the contents of numbers[0], which is the first element:
print(numbers[0])
If we execute this statement, the following be displayed:
[1, 2, 3]
The following statement prints the contents of numbers[1], which is the second element:
print(numbers[1])
Page 67
If we execute this statement, the following be displayed:
[10, 20, 30]
Rows and Columns
As discussed in your textbook, we normally think of two-dimensional arrays as having rows and
columns. We can use this metaphor with two-dimensional lists as well. For example, let's say
the following two-dimensional list contains sets of test scores:
scores = [ [70, 80, 90],
[80, 60, 75],
[85, 75, 95] ]
By declaring the list this way (with each list that is an element shown on a separate line) it's
easy to see how we can think of the list as a set of rows and columns.
When processing the data in a two-dimensional list, we use two subscripts: one for the row and
another for the column. In the scores list, the elements in row 0 are referenced as follows:
scores[0][0]
scores[0][1]
scores[0][2]
The elements in row 1 are as follows:
scores[1][0]
scores[1][1]
scores[1][2]
And the elements in row 2 are as follows:
scores[2][0]
scores[2][1]
scores[2][2]
To access one of the elements in a two-dimensional list, you use both subscripts. For example,
the following statement prints the number in scores[0][2]:
print(scores[0][2])
And the following statement assigns the number 95 to scores[2][1]:
scores[2][1] = 95
Page 68
Programs that process two-dimensional lists can do so with nested loops. For example, the
following code displays all of the elements in the scores list:
NUM_ROWS = 3
NUM_COLS = 3
row = 0
while row < NUM_ROWS:
col = 0
while col < NUM_COLS:
print(scores[row][col])
col = col + 1
row = row + 1
And the following code prompts the user to enter a score, once for each element in the list:
NUM_ROWS = 3
NUM_COLS = 3
row = 0
while row < NUM_ROWS:
col = 0
while col < NUM_COLS:
scores[row][col] = int(input('Enter a score: '))
col = col + 1
row = row + 1
Program 8-6 shows a complete example. It creates a list with three rows and four columns, prompts the
user for values to store in each element, and then displays the values in each element. This is the Python
example of pseudocode Program 8-16 in your textbook.
Program 8-5 (twoD_list.py)
1 ROWS = 3
This is the Python version of
2 COLS = 4
Program 8-16 in your textbook!
3
4 # Create a 2D list.
5 values = [ [0, 0, 0, 0],
6
[0, 0, 0, 0],
7
[0, 0, 0, 0] ]
8
9 # Get values to store in the list.
10 row = 0
11 while row < ROWS:
12
col = 0
13
while col < COLS:
14
values[row][col] = int(input('Enter a number: '))
15
col = col + 1
Page 69
16
17
18
19
20
21
22
23
24
25
26
row = row + 1
# Display the vlues in the list.
print('Here are the values you entered.')
row = 0
while row < ROWS:
col = 0
while col < COLS:
print(values[row][col])
col = col + 1
row = row + 1
Program Output
Enter a number: 1 [Enter]
Enter a number: 2 [Enter]
Enter a number: 3 [Enter]
Enter a number: 4 [Enter]
Enter a number: 5 [Enter]
Enter a number: 6 [Enter]
Enter a number: 7 [Enter]
Enter a number: 8 [Enter]
Enter a number: 9 [Enter]
Enter a number: 10 [Enter]
Enter a number: 11 [Enter]
Enter a number: 12 [Enter]
Here are the values you entered.
1
2
3
4
5
6
7
8
9
10
11
12
Page 70
Chapter 9
Sorting and Searching
Chapter 9 in your textbook discusses the following sorting algorithms:
•
•
•
Bubble Sort
Selection Sort
Insertion Sort
The Binary Search algorithm is also discussed. The textbook chapter examines these algorithms
in detail, and no new language features are introduced. For these reasons we will simply
present the Python code for the algorithms in this chapter. For more in-depth coverage of the
logic involved, consult the textbook.
Bubble Sort
Program 9-1 is only a partial program. It shows the Python version of pseudocode Program 9-1,
which is the Bubble Sort algorithm.
Program 9-1 (bubble_sort.py)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#
#
#
#
#
#
#
#
#
Note: This is not a complete program.
This is the Python version of
Program 9-1 in your textbook!
The bubble_sort function uses the bubble sort algorithm
to sort a list of integers.
Note the following:
(1) We do not have to pass the array size because we
can use the len function.
(2) We do not have a separate method to swap values.
The swap is perfomed inside this method.
def bubble_sort(arr):
# Set max_element to the length of the arr list, minus
# one. This is necessary for the outer loop.
max_element = len(arr) - 1
# The outer loop positions max_element at the last element
# to compare during each pass through the list. Initially
# max_element is the index of the last element in the array.
# During each iteration, it is decreased by one.
while max_element >= 0:
# Set index to 0, necessary for the inner loop.
index = 0
# The inner loop steps through the list, comparing
# each element with its neighbor. All of the elements
# from index 0 thrugh max_element are involved in the
# comparison. If two elements are out of order, they
# are swapped.
while index <= max_element - 1:
# Compare an element with its neighbor.
if arr[index] > arr[index + 1]:
Page 71
32
33
34
35
36
37
38
39
# Swap the two elements.
temp = arr[index]
arr[index] = arr[index + 1]
arr[index + 1] = temp
# Increment index.
index = index + 1
# Decrement max_element.
max_element = max_element - 1
Selection Sort
Program 9-2 is also a partial program. It shows the Python version of the selectionSort
pseudocode module that is shown in Program 9-5 in your textbook.
This is the Python version of the
selectionSort Module shown
Program 9-2 (selection_sort.py)
1 # Note: This is not a complete program. in Program 9-5 in your textbook!
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#
# The selection_sort function performs the selection sort
# algorithm on a list of integers.
def selection_sort(arr):
# Set start_scan to 0. This is necessary for
# the outer loop. It is the starting position
# of the scan.
start_scan = 0
# The outer loop iterates once for each element in the
# list. The start_scan variable marks the position where
# the scan should begin.
while start_scan < len(arr) - 1:
# Assume the first element in the scannable area
# is the smallest value.
min_index = start_scan
min_value = arr[start_scan]
# Initialize index for the inner loop.
index = start_scan + 1
# Scan the list, starting at the 2nd element in
# the scannable area. We are looking for the smallest
# value in the scannable area.
while index < len(arr):
if arr[index] < min_value:
min_value = arr[index]
min_index = index
# Increment index.
index = index + 1
Page 72
33
34
35
36
37
38
39
40
# Swap the element with the smallest value
# with the first element in the scannable area.
arr[min_index] = arr[start_scan]
arr[start_scan] = min_value
# Increment start_scan.
start_scan = start_scan + 1
Insertion Sort
Program 9-3 is also a partial program. It shows the Python version of the insertionSort
pseudocode module that is shown in Program 9-6 in your textbook.
This is the Python version of the
insertionSort Module shown
in Program 9-6 in your textbook!
Program 9-3 (insertion_sort.py)
1 # Note: this is not a complete program.
2 #
3 # The insertion_sort function performs an insertion sort
4 # algorithm on a list of integers.
5
6 def insertion_sort(arr):
7
# Set index to 1 for the outer loop.
8
index = 1
9
10
# The outer loop steps the index variable through
11
# each subscript in the list, starting at 1. This
12
# is because element 0 is considered already sorted.
13
while index < len(arr):
14
# The first element outside the sorted subset is
15
# arr[index]. Assign the value of this element
16
# to unsorted_value.
17
unsorted_value = arr[index]
18
19
# Start the scan variable at the subscript of the
20
# first element outside the sorted subset.
21
scan = index
22
23
# Move the first element outside the sorted subset
24
# into its proper position within the sorted subset.
25
while scan > 0 and arr[scan - 1] > unsorted_value:
26
arr[scan] = arr[scan - 1]
27
scan = scan - 1
28
29
# Insert the unsorted value in its proper position
Page 73
30
31
32
33
34
# within the sorted subset.
arr[scan] = unsorted_value
# Increment index.
index = index + 1
Binary Search
Program 9-4 is also a partial program. It shows the Python version of the binarySearch
pseudocode module that is shown in Program 9-7 in your textbook.
Program 9-4 (binary_search.py)
1 # Note: This is not a complete program.
2 #
3 # The binary_search function performs a binary search on a
4 # String list. The list is searched for the string passed to
5 # the value parameter. If the string is found, its subscript
6 # is returned. Otherwise, -1 is returned indicating the value
7 # was not found in the list.
8
9 def binary_search(arr, value):
This is the Python version of the
10
# Set the initial values.
binarySearch Module shown
11
first = 0
in Program 9-7 in your textbook!
12
last = len(arr) - 1
13
position = -1
14
found = False
15
16
# Search for the value
17
while not found and first <= last:
18
# Calculate the mid point.
19
middle = (first + last) / 2
20
21
# If the value is found at the mid point...
22
if arr[middle] == value:
23
found = True
24
position = middle
25
# else if value is in the lower half...
26
elif arr[middle] > value:
27
last = middle - 1
28
# else if value is in the upper half...
29
else:
30
first = middle + 1
31
32
# Return the position of the item, or -1
Page 74
33
34
# if it was not found.
return position
Page 75
Chapter 10
Files
Opening a File
You use the open function in Python to open a file. The open function creates a file object and
associates it with a file on the disk. Here is the general format of how the open function is used:
file_variable = open(filename, mode)
In the general format:
• file_variable is the name of the variable that will reference the file object.
• filename is a string specifying the name of the file.
• mode is a string specifying the mode (reading, writing, etc.) in which the file will be
opened. Table 10-1 shows three of the strings that you can use to specify a mode.
(There are other, more complex modes. The modes shown in Table 10-1 are the ones
we will use in this book.)
Table 10-1 Some of the Python file modes
Mode
Description
'r'
Open a file for reading only. The file cannot be changed or written to.
'w'
Open a file for writing. If the file already exists, erase its contents. If
it does not exist, create it.
'a'
Open a file to be written to. All data written to the file will be
appended to its end. If the file does not exist, create it.
For example, suppose the file customers.txt contains customer data, and we want to open for
reading. Here is an example of how we would call the open function:
customer_file = open('cusomters.txt', 'r')
After this statement executes, the file named customers.txt will be opened, and the variable
customer_file will reference a file object that we can use to read data from the file.
Suppose we want to create a file named sales.txt and write data to it. Here is an example of
how we would call the open function:
sales_file = open('sales.txt', 'w')
After this statement executes, the file named sales.txt will be created, and the variable
sales_file will reference a file object that we can use to write data to the file.
Page 76
Warning:
Remember, when you use the 'w' mode you are creating the file on the disk. If a
file with the specified name already exists when the file is opened, the contents
of the existing file will be erased.
Writing Data to a File
Once you have opened a file for writing, you use the file object's write method to write data
to a file. Here is the general format of how you call the write method:
file_variable.write(string)
In the format, file_variable is a variable that references a file object, and string is a
string that will be written to the file. The file must be opened for writing (using the 'w' or 'a'
mode) or an error will occur.
Let's assume that customer_file references a file object, and the file was opened for
writing with the 'w' mode. Here is an example of how we would write the string 'Charles Pace'
to the file:
customer_file.write('Charles Pace')
The following code shows another example:
name = 'Charles Pace'
customer_file.write(name)
The second statement writes the value referenced by the name variable to the file associated
with customer_file. In this case, it would write the string 'Charles Pace' to the file. (These
examples show a string being written to a file, but you can also write numeric values.)
Closing a File
Once a program is finished working with a file, it should close the file. Closing a file disconnects
the program from the file. In Python you use the file object's close method to close a file. For
example, the following statement closes the file that is associated with customer_file:
customer_file.close()
Once a file is closed, the connection between it and the file object is removed. In order to
perform further operations on the file, it must be opened again.
Program 10-1 shows a complete Python program that that opens an output file, writes data to
it, and then closes it. This is the Python version of pseudocode Program 10-1 in your textbook.
Page 77
Program 10-1 (file_write_demo.py)
1 # This program writes three lines of data
2 # to a file.
3 def main():
4
# Open a file named philosophers.txt.
5
outfile = open('philosophers.txt', 'w')
6
7
# Write the names of three philosphers
8
# to the file.
9
outfile.write('John Locke\n')
10
outfile.write('David Hume\n')
11
outfile.write('Edmund Burke\n')
12
This is the Python version of
13
# Close the file.
Program 10-1 in your textbook!
14
outfile.close()
15
16 # Call the main function.
17 main()
When this program executes, line 5 creates a file named philosophers.dat on the disk, and lines
9 through 11 write the strings 'John Locke\n', 'David Hume\n', and 'Edmund Burke\n' to the file.
Line 14 closes the file.
Writing Newlines at the End of Each Line
Notice the use of the \n that appears inside the strings that are written to the file in lines 9, 10,
and 11. The \n sequence is known as an escape character. An escape character is a special
character that is preceded with a backslash (\), appearing inside a string literal. When a string
literal that contains escape characters is printed on the screen or written to a file, the escape
characters are treated as special commands that are embedded in the string.
The \n sequence is the newline escape character. When the \n escape character is printed by
the print function, it isn't displayed on the screen. Instead, it causes output to advance to the
next line. For example, look at the following statement:
print('One\nTwo\nThree')
When this statement executes it displays:
One
Two
Three
So why did we include a \n at the end of each item that is written to the file in Program 10-1?
Let's take a closer look. The statements in lines 9 through 11 write three strings to the file. Line
Page 78
9 writes the string 'John Locke\n', line 10 writes the string 'David Hume\n', and line 11 writes
the string 'Edmund Burke\n'. Line 14 closes the file. After this program runs, the three items
shown in Figure 10-1 will be written to the philosophers.txt file.
Figure 10-1 Contents of the file philosophers.txt
Notice that each of the strings written to the file end with \n. The \n marks the location where
a new line begins in the file. We can see how this works if we open the file in a text editor. For
example, Figure 10-2 shows the philosophers.txt file as it appears in Notepad.
Figure 10-2 Contents of philosophers.txt in Notepad
Opening a File and Reading Data from It
If a file has been opened for reading (using the 'r' mode) you can use the file object's
readline method to read a line from the file. The method returns the line as a string,
including the \n. Program 10-2 shows how we can use the readline method to read the
contents of the philosophers.txt file, one line at a time. (This is the Python version of pseudocode
Program 10-2 in your textbook.)
Program 10-2 (file_read_demo.py)
1 # This program reads the contents of the
2 # philosophers.txt file one line at a time.
3 def main():
4
# Open a file named philosophers.txt.
5
infile = open('philosophers.txt', 'r')
This is the Python version
of Program 10-2 in your
textbook!
Page 79
6
7
# Read three lines from the file
8
line1 = infile.readline()
9
line2 = infile.readline()
10
line3 = infile.readline()
11
12
# Close the file.
13
infile.close()
14
15
# Print the names that were read.
16
print('Here are the names of three philosophers:')
17
print(line1)
18
print(line2)
19
print(line3)
20
21 # Call the main function.
22 main()
Program Output
Here are the names of three philosophers:
John Locke
David Hume
Edmund Burke
The statement in line 5 opens the philosophers.txt file for reading, using the 'r' mode. It also
creates a file object and assigns the object to the infile variable. When a file is opened for
reading, a special value known as a read position is internally maintained for that file. A file’s
read position marks the location of the next item that will be read from the file. Initially, the
read position is set to the beginning of the file. After the statement in line 5 executes, the read
position for the philosophers.txt file will be positioned as shown in Figure 10-3.
Figure 10-3 Initial read position
The statement in line 8 calls the infile.readline method to read the first line from the
file. The line, which is returned as a string, is assigned to the line1 variable. After this
statement executes the line1 variable will be assigned the string 'John Locke\n'. In addition,
the file’s read position will be advanced to the next line in the file, as shown in Figure 10-4.
Page 80
Figure 10-4 Read position advanced to the next line
Then the statement in line 9 reads the next line from the file and assigns it to the line2
variable. After this statement executes the line2 variable will be assigned the string 'David
Hume\n'. The file’s read position will be advanced to the next line in the file, as shown in Figure
10-5.
Figure 10-5 Read position advanced to the next line
Then the statement in line 10 reads the next line from the file and assigns it to the line3
variable. After this statement executes the line3 variable will be assigned the string 'Edmund
Burke\n'. After this statement executes, the read position will be advanced to the end of the
file, as shown in Figure 10-6.
10-7 shows the line1, line2, and line3 variables and the strings they are assigned after
these statements have executed.
Figure 10-6 Read position advanced to the end of the file
Page 81
Figure 10-7 The strings referenced by the line1, line2, and line3 variables
The statement in line 13 closes the file. The statements in lines 17 through 19 display the
contents of the line1, line2, and line3 variables.
Note: If the last line in a file is not terminated with a \n, the readline method will return
the line without a \n.
Reading a String and Stripping the Newline from It
Sometimes complications are caused by the \n that appears at the end of the strings that are
returned from the readline method. For example, did you notice in the sample output of
Program 10-2 that a blank line is printed after each line of output? This is because each of the
strings that are printed in lines 17 through 19 end with a \n escape sequence. When the strings
are printed, the \n causes an extra blank line to appear.
The \n serves a necessary purpose inside a file: it separates the items that are stored in the file.
However, in most cases you want to remove the \n from a string after it is read from a file. Each
string in Python has a method named rstrip that removes, or "strips", specific characters
from the end of a string. The following code shows an example of how the rstrip method
can be used.
name = 'Joanne Manchester\n'
name = name.rstrip('\n')
The first statement assigns the string 'Joanne Manchester\n' to the name variable. (Notice that
the string ends with the \n escape sequence.) The second statement calls the
name.rstrip('\n') method. The method returns a copy of the name string without the
trailing \n. This string is assigned back to the name variable. The result is that the trailing \n is
stripped away from the name string.
Program 10-3 is another program that reads and displays the contents of the philosophers.txt
file. This program uses the rstrip method to strip the \n from the strings that are read from
the file before they are displayed on the screen. As a result, the extra blank lines do not appear
in the output.
Page 82
Program 10-3 (strip_newline.py)
1 # This program reads the contents of the
2 # philosophers.txt file one line at a time.
3 def main():
4
# Open a file named philosophers.txt.
5
infile = open('philosophers.txt', 'r')
6
7
# Read three lines from the file
8
line1 = infile.readline()
9
line2 = infile.readline()
10
line3 = infile.readline()
11
12
# Strip the \n from each string.
13
line1 = line1.rstrip('\n')
14
line2 = line2.rstrip('\n')
15
line3 = line3.rstrip('\n')
16
17
# Close the file.
18
infile.close()
19
20
# Print the names that were read.
21
print('Here are the names of three philosophers:')
22
print(line1)
23
print(line2)
24
print(line3)
25
26 # Call the main function.
27 main()
Program Output
Here are the names of three philosophers:
John Locke
David Hume
Edmund Burke
Concatenating a Newline to a String
Program 10-1 wrote three string literals to a file, and each string literal ended with a \n escape
sequence. In most cases, the data items that are written to a file are not string literals, but
values in memory that are referenced by variables. This would be the case in a program that
prompts the user to enter data, and then writes that data to a file.
When a program writes data that has been entered by the user to a file, it is usually necessary
to concatenate a \n escape sequence to the data before writing it. This ensures that each piece
of data is written to a separate line in the file. Program 10-4 demonstrates how this is done.
Page 83
Program 10-4 (write_names.py)
1 # This program gets three names from the user
2 # and writes them to a file.
3
4 def main():
5
# Get three names.
6
print('Enter the names of three friends.')
7
name1 = input('Friend #1: ')
8
name2 = input('Friend #2: ')
9
name3 = input('Friend #3: ')
10
11
# Open a file named friends.txt.
12
myfile = open('friends.txt', 'w')
13
14
# Write the names to the file.
15
myfile.write(name1 + '\n')
16
myfile.write(name2 + '\n')
17
myfile.write(name3 + '\n')
18
19
# Close the file.
20
myfile.close()
21
print('The names were written to friends.txt.')
22
23 # Call the main function.
24 main()
Program Output (with Input Shown in Bold)
Enter the names of three friends.
Friend #1: Joe [Enter]
Friend #2: Rose [Enter]
Friend #3: Geri [Enter]
The names were written to friends.txt.
Lines 7 through 9 prompt the user to enter three names, and those names are assigned to the
variables name1, name2, and name3. Line 12 opens a file named friends.txt for writing. Then,
lines 15 through 17 write the names entered by the user, each with '\n' concatenated to it. As a
result, each name will have the \n escape sequence added to it when written to the file. Figure
10-8 shows the contents of the file with the names entered by the user in the sample run.
Figure 10-8 The friends.txt file
Page 84
Appending Data to an Existing File
When you use the 'w' mode to open an output file and a file with the specified filename already
exists on the disk, the existing file will be erased and a new empty file with the same name will
be created. Sometimes you want to preserve an existing file and append new data to its current
contents. Appending data to a file means writing new data to the end of the data that already
exists in the file.
In Python you can use the 'a' mode to open an output file in append mode, which means the
following.
•
•
If the file already exists, it will not be erased. If the file does not exist, it will be created.
When data is written to the file, it will be written at the end of the file’s current
contents.
For example, assume the file friends.txt contains the following names, each in a separate line:
Joe
Rose
Geri
The following code opens the file and appends additional data to its existing contents.
myfile = open('friends.txt', 'a')
myfile.write('Matt\n')
myfile.write('Chris\n')
myfile.write('Suze\n')
myfile.close()
After this program runs, the file friends.txt will contain the following data:
Joe
Rose
Geri
Matt
Chris
Suze
Writing and Reading Numeric Data
Strings can be written directly to a file with the write method, but numbers must be converted
to strings before they can be written. Python has a built-in function named str that converts a
value to a string. For example, assuming the variable num is assigned the value 99, the
expression str(num) will return the string '99'.
Page 85
Program 10-5 shows an example of how you can use the str function to convert a number to a
string, and write the resulting string to a file.
Program 10-5 (write_numbers.py)
1 # This program demonstrates how numbers
2 # must be converted to strings before they
3 # are written to a text file.
4
5 def main():
6
# Open a file for writing.
7
outfile = open('numbers.txt', 'w')
8
9
# Get three numbers from the user.
10
num1 = int(input('Enter a number: '))
11
num2 = int(input('Enter another number: '))
12
num3 = int(input('Enter another number: '))
13
14
# Write the numbers to the file.
15
outfile.write(str(num1) + '\n')
16
outfile.write(str(num2) + '\n')
17
outfile.write(str(num3) + '\n')
18
19
# Close the file.
20
outfile.close()
21
print('Data written to numbers.txt')
22
23 # Call the main function.
24 main()
Program Output (with Input Shown in Bold)
Enter a number: 22 [Enter]
Enter another number: 14 [Enter]
Enter another number: -99 [Enter]
Data written to numbers.txt
The statement in line 7 opens the file numbers.txt for writing. Then the statements in lines 10
through 12 prompt the user to enter three numbers, which are assigned to the variables num1,
num2, and num3.
Take a closer look at the statement in line 15, which writes the value referenced by num1 to the
file:
outfile.write(str(num1) + '\n')
Page 86
The expression str(num1) + '\n' converts the value referenced by num1 to a string and
concatenates the \n escape sequence to the string. In the program's sample run, the user
entered 22 as the first number, so this expression produces the string '22\n'. As a result, the
string '22\n' is written to the file.
Lines 16 and 17 perform the similar operations, writing the values referenced by num2 and
num3 to the file. After these statements execute, the values shown in Figure 10-9 will be
written to the file. Figure 10-10 shows the file viewed in Notepad.
Figure 10-9 Contents of the numbers.txt file
Figure 10-10 The numbers.txt file viewed in Notepad
When you read numbers from a text file, they are always read as strings. For example, suppose
a program uses the following code to read the first line from the numbers.txt file that was
created by Program 10-5:
1
2
3
infile = open('numbers.txt', 'r')
value = infile.readline()
infile.close()
The statement in line 2 uses the readline method to read a line from the file. After this
statement executes, the value variable will reference the string '22\n'. This can cause a
problem if we intend to perform math with the value variable, because you cannot perform
math on strings. In such a case you must convert the string to a numeric type.
Python provides the built-in function int to convert a string to an integer, and the built-in
function float to convert a string to a floating-point number. For example, we could modify
the code previously shown as follows:
Page 87
1
2
3
4
infile = open('numbers.txt', 'r')
string_input = infile.readline()
value = int(string_input)
infile.close()
The statement in line 2 reads a line from the file and assigns it to the string_input variable.
As a result, string_input will reference the string '22\n'. Then the statement in line 3 uses
the int function to convert string_input to an integer, and assigns the result to value.
After this statement executes, the value variable will reference the integer 22. (Both the int
and float functions ignore the \n that appears at the end of the string that is passed as an
argument.)
This code demonstrates the steps involved in reading a string from a file with the readline
method, and then converting that string to an integer with the int function. In many
situations, however, the code can be simplified. A better way is to read the string from the file
and convert it in one statement, as shown here:
1
2
3
infile = open('numbers.txt', 'r')
value = int(infile.readline())
infile.close()
Notice in line 2 that a call to the readline method is used as the argument to the int
function. Here's how the code works: the readline method is called, and it returns a string.
That string is passed to the int function, which converts it to an integer. The result is assigned
to the value variable.
Using Loops to Process Files
Program 10-6 demonstrates how a loop can be used to collect items of data to be stored in a
file. This is the Python version of pseudocode Program 10-3 in your textbook. Figure 10-11
shows the contents of the sales.txt file containing the data entered by the user in the sample
run.
Program 10-6 (write_sales.py)
1 # This program prompts the user for sales amounts
2 # and writes those amounts to the sales.txt file.
3
4 def main():
5
# Get the number of days.
6
num_days = int(input('For how many days do ' +
7
'you have sales? '))
8
9
# Open a new file named sales.txt.
Page 88
10
sales_file = open('sales.txt', 'w')
11
12
# Get the amount of sales for each day and write
13
# it to the file.
14
for count in range(1, num_days + 1):
15
# Get the sales for a day.
16
sales = float(input('Enter the sales for day #' +
17
str(count) + ': '))
18
19
# Write the sales amount to the file.
20
sales_file.write(str(sales) + '\n')
21
22
# Close the file.
23
sales_file.close()
24
print('Data written to sales.txt.')
25
26 # Call the main function.
This is the Python version of
27 main()
Program 10-3 in your textbook!
Program Output (with Input Shown in Bold)
For how many days do you have sales? 5 [Enter]
Enter the sales for day #1: 1000.0 [Enter]
Enter the sales for day #2: 2000.0 [Enter]
Enter the sales for day #3: 3000.0 [Enter]
Enter the sales for day #4: 4000.0 [Enter]
Enter the sales for day #5: 5000.0 [Enter]
Data written to sales.txt.
Figure 10-11 Contents of the sales.txt file
Page 89
Detecting the End of a File
In Python, the readline method returns an empty string ('') when it has attempted to read
beyond the end of a file. This makes it possible to write a while loop that determines when the
end of a file has been reached. Program 10-7 demonstrates how this can be done in code. The
program reads and displays all of the values in the sales.txt file. (This is the Python version of
pseudocode Program 10-3 in your textbook.)
Program 10-7 (read_sales.py)
1 # This program reads all of the values in
2 # the sales.txt file.
This is the Python version of
3
Program 10-3 in your textbook!
4 def main():
5
# Open the sales.txt file for reading.
6
sales_file = open('sales.txt', 'r')
7
8
# Read the first line from the file, but
9
# don't convert to a number yet. We still
10
# need to test for an empty string.
11
line = sales_file.readline()
12
13
print('Here are the sales amounts:')
14
15
# As long as an empty string is not returned
16
# from readline, continue processing.
17
while line != '':
18
# Convert line to a float.
19
amount = float(line)
20
21
# Format and display the amount.
22
print('$', format(amount, '.2f'))
23
24
# Read the next line.
25
line = sales_file.readline()
26
27
# Close the file.
28
sales_file.close()
29
30 # Call the main function.
31 main()
Program Output (with Input Shown in Bold)
Here are the sales amounts:
$ 1000.00
$ 2000.00
$ 3000.00
Page 90
$ 4000.00
$ 5000.00
Using Python's for Loop to Read Lines
In the previous example you saw how the readline method returns an empty string when
the end of the file has been reached. The Python language also allows you to write a for loop
that automatically reads line in a file without testing for any special condition that signals the
end of the file. The loop does not require a priming read operation, and it automatically stops
when the end of the file has been reached. When you simply want to read the lines in a file, one
after the other, this technique is simpler and more elegant than writing a while loop that
explicitly tests for an end of the file condition. Here is the general format of the loop:
for variable in file_object:
statement
statement
etc.
In the general format, variable is the name of a variable and file_object is a variable
that references a file object. The loop will iterate once for each line in the file. The first time the
loop iterates, variable will reference the first line in the file (as a string), the second time the
loop iterates, variable will reference the second line, and so forth. Program 10-8 provides a
demonstration. It reads and displays all of the items in the sales.txt file.
Program 10-8 (read_sales2.py)
1 # This program uses the for loop to read
2 # all of the values in the sales.txt file.
3
4 def main():
5
# Open the sales.txt file for reading.
6
sales_file = open('sales.txt', 'r')
7
8
# Read all the lines from the file.
9
for line in sales_file:
10
# Convert line to a float.
11
amount = float(line)
12
# Format and display the amount.
13
print('$', format(amount, '.2f'))
14
15
# Close the file.
16
sales_file.close()
17
18 # Call the main function.
19 main()
Page 91
Program Output
$ 1000.00
$ 2000.00
$ 3000.00
$ 4000.00
$ 5000.00
Page 92
Chapter 11
Menu-Driven Programs
Chapter 11 in your textbook discusses menu-driven programs. A menu-driven program presents a list of
operations that the user may select from (the menu), and then performs the operation that the user
selected. There are no new language features introduced in the chapter, so here we will simply show
you a Python program that is menu-driven. Program 11-1 is the Python version of the pseudocode
Program 11-3.
Program 11-1 (menu_driven.py)
1 # Display the menu.
2 print('1. Convert inches to centimeters.')
3 print('2. Convert feet to meters.')
4 print('3. Convert miles to kilometers.')
5 print()
6
7 # Prompt the user for a selection.
8 menu_selection = int(input('Enter your selection: '))
9
10 # Validate the menu selection.
11 while menu_selection < 1 or menu_selection > 3:
12
print('That is an invalid selection.')
13
menu_selection = int(input('Enter 1, 2, or 3: '))
14
15 # Perform the selected operation.
16 if menu_selection == 1:
17
# Convert inches to centimeters.
18
inches = float(input('Enter the number of inches: '))
19
centimeters = inches * 2.54
20
print('That is equal to', centimeters, 'centimeters.')
21 elif menu_selection == 2:
22
# Convert feet to meters.
23
feet = float(input('Enter the number of feet: '))
24
meters = feet * 0.3048
25
print('That is equal to', meters, 'meters.')
26 elif menu_selection == 3:
27
# Convert miles to kilometers.
28
miles = float(input('Enter the number of miles: '))
29
kilometers = miles * 1.609
30
print('That is equal to', kilometers, 'kilometers.')
Program Output
1. Convert inches to centimeters.
2. Convert feet to meters.
3. Convert miles to kilometers.
Ï
Enter your selection: 1 [Enter]
This is the Python version of
Program 11-3 in your textbook!
Page 93
Enter the number of inches: 10 [Enter]
That is equal to 25.4 centimeters.
Program Output
1. Convert inches to centimeters.
2. Convert feet to meters.
3. Convert miles to kilometers.
Ï
Enter your selection: 2 [Enter]
Enter the number of feet: 10 [Enter]
That is equal to 3.048 meters.
Program Output
1. Convert inches to centimeters.
2. Convert feet to meters.
3. Convert miles to kilometers.
Ï
Enter your selection: 4 [Enter]
That is an invalid selection.
Enter 1, 2, or 3: 3 [Enter]
Enter the number of miles: 10 [Enter]
That is equal to 16.09 kilometers.
Page 94
Chapter 12
Text Processing
Chapter 12 in your textbook discusses programming techniques for working with the individual
characters in a string. Python allows you to retrieve the individual characters in a string using
subscript notation, as described in the book. For example, the following code creates the string
'Hello', and then uses subscript notation to print the first character in the string:
greeting = 'Hello'
print(greeting[0])
Although you can use subscript notation to retrieve the individual characters in a string, you
cannot use it to change the value of a character within a string. This is because strings in Python
are immutable, which means that once they are created, they cannot be changed.
Because Python strings are immutable, you cannot use an expression in the form
string[index] on the left side of an assignment operator. For example, the following code
will cause an error:
# Assign 'Bill' to friend.
friend = 'Bill'
# Can we change the first character to 'J'?
friend[0] = 'J'
# No, this will cause an error!
The last statement in this code will cause an error because it attempts to change the value of
the first character in the string 'Bill'.
In this chapter we will show you how to do the following in Python:
•
•
Use subscript notation to access the individual characters in a string.
Use string testing methods.
Because of string immutability, we will not be able to show a simple Python version of
pseudocode Program 12-3. Also, there are no string methods for inserting and deleting
characters, so we will not discuss that section in this chapter.
Character‐By‐Character Text Processing
Program 12-1 shows the Python version of pseudocode Program 12-1 in the textbook.
Program 12-1 (display_characters.py)
1 # Declare and initialize a string.
2 name = 'Jacob'
3
4 # Use subscript notation to display the
5 # individual characters in the string.
This is the Python version of
Program 12-1 in your textbook!
Page 95
6
7
8
9
10
print(name[0])
print(name[1])
print(name[2])
print(name[3])
print(name[4])
Program Output
J
a
c
o
b
Program 12-2 is the Python for loop version of pseudocode Program 12-2 in your textbook,
and Program 12-3 is the while loop version. Both of these programs use a loop to step
through all of the characters in a string.
Program 12-2 (loop_display_characters.py)
1 # Declare and initialize a string.
2 name = 'Jacob'
3
4 # Display the characters in the string.
5 for n in name:
6
print(n)
Program Output
J
a
c
o
b
This is the Python for loop
version of Program 12-2 in your
textbook!
Program 12-3 (while_display_characters.py)
1 # Declare and initialize a string.
2 name = 'Jacob'
This is the Python while loop
3
version of Program 12-2 in your
4 # Initialize index
textbook!
5 index = 0
6
7 # Display the characters in the string.
8 while index < len(name):
9
print(name[index])
10
index = index + 1
Page 96
Program Output
J
a
c
o
b
Character Testing Methods
Python provides string testing methods that are similar to the character testing library functions
shown in Table 12-2 in your textbook. The Python methods that are similar to those functions
are shown here, in Table 12-1.
Table 12-1 Character Testing Methods
Method
Description
isalnum() Returns true if the string contains only alphabetic letters or digits and is
at least one character in length. Returns false otherwise.
isalpha() Returns true if the string contains only alphabetic letters, and is at least
one character in length. Returns false otherwise.
isdigit() Returns true if the string contains only numeric digits and is at least one
character in length. Returns false otherwise.
islower() Returns true if all of the alphabetic letters in the string are lowercase,
and the string contains at least one alphabetic letter. Returns false
otherwise.
isspace() Returns true if the string contains only whitespace characters, and is at
least one character in length. Returns false otherwise. (Whitespace
characters are spaces, newlines (\n), and tabs (\t).
isupper() Returns true if all of the alphabetic letters in the string are uppercase,
and the string contains at least one alphabetic letter. Returns false
otherwise.
The difference between these methods and the character testing functions discussed in the
textbook is that the Python functions operate on an entire string. For example, the following
code determines whether all of the characters in the string referenced by the my_string
variable are uppercase:
my_string = "ABC"
if my_string.isupper():
print('That string is all uppercase.')
This code will print the message That string is all uppercase because all of the characters in the
string that is assigned to my_string are uppercase.
Page 97
These methods can be applied to an individual character in a string, however. Here is an
example:
my_string = "Abc"
if my_string[0].isupper():
print('The first character is uppercase.')
This code determines whether the character at subscript 0 in my_string is uppercase (and, it
is).
Program 12-4 further demonstrates the isupper() method. This program is the Python version of
Program 12-4 in your textbook.
Program 12-4 (count_uppercase.py)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# Prompt the user to enter a sentence.
sentence = input('Enter a sentence: ')
# Initialize index (loop counter).
index = 0
This is the Python version of
Program 12-4 in your textbook!
# Initialize uppercase_count (accumulator)
uppercase_count = 0
# Count the number of uppercase characters.
while index < len(sentence):
if sentence[index].isupper():
uppercase_count = uppercase_count + 1
index = index + 1
# Display the number of uppercase characters.
print('That string has', uppercase_count, 'uppercase letters.')
Program Output
Enter a sentence: Mr. Jones will arrive TODAY! [Enter]
That string has 7 uppercase letters.
Page 98
Chapter 13
Recursion
A Python function can call itself recursively, allowing you to design algorithms that recursively
solve a problem. Chapter 13 in your textbook describes recursion in detail, discusses problem
solving with recursion, and provides several pseudocode examples. Other than the technique of
a function recursively calling itself, no new language features are introduced. In this chapter we
will present Python versions of two of the pseudocode programs that are shown in the
textbook. Both of these programs work exactly as the algorithms are described in the textbook.
Program 13-1 is the Python version of pseudocode Program 13-2.
Program 13-1 (recursion_demo.py)
1 # This program has a recursive function.
2
3 def main():
4
# By passing the argument 5 to the message
5
# function we are telling it to display the
6
# message five times.
7
message(5)
This is the Python version of
8
Program 13-2 in your textbook!
9 def message(times):
10
if (times > 0):
11
print('This is a recursive function.')
12
message(times - 1)
13
14 # Call the main function.
15 main()
Program Output
This is a recursive
This is a recursive
This is a recursive
This is a recursive
This is a recursive
function.
function.
function.
function.
function.
Next, Program 13-2 is the Python version of pseudocode Program 13-3. This program
recursively calculates the factorial of a number.
Program 13-2 (factorial.py)
1
2
3
4
5
6
# This program uses recursion to calculate
# the factorial of a number.
This is the Python version of
Program 13-3 in your textbook!
def main():
# Get a number from the user.
number = int(input('Enter a nonnegative integer: '))
Page 99
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# Get the factorial of the number.
fact = factorial(number)
# Display the factorial.
print('The factorial of', number, 'is', fact)
# The factorial function uses recursion to
# calculate the factorial of its argument,
# which is assumed to be nonnegative.
def factorial(num):
if num == 0:
return 1
else:
return num * factorial(num - 1)
# Call the main function.
main()
Program Output (with Input Shown in Bold)
Enter a nonnegative integer: 7 [Enter]
The factorial of 7 is 5040
Page 100
Chapter 14
Object-Oriented Programming
Python is a powerful object-oriented language. An object is an entity that exists in the
computer's memory while the program is running. An object contains data and has the ability
to perform operations on its data. An object's data is commonly referred to as the object's
fields, and the operations that the object performs are the object's methods.
In addition to the many objects that are provided by the Python language, you can create
objects of your own design. The first step is to write a class. A class is like a blueprint. It is a
declaration that specifies the methods for a particular type of object. When the program needs
an object of that type, it creates an instance of the class. (An object is an instance of a class.)
Here is the general format of a class declaration in Python:
class ClassName:
Method definitions go here…
The first line of a class declaration begins with the keyword class, followed by the name of the
class, followed by a colon. The class's method definitions follow this line. Method definitions
are written much like regular function definitions. Because they belong to the class, method
definitions must be indented.
One difference that you will notice between Python class declarations and the pseudocode
class declarations in the textbook is that there are no field declarations in a Python class. This is
because an object's fields are created by assignment statements that appear inside the class's
methods.
Another difference that you will notice is the absence of access specifiers such as Private and
Public. In Python we hide a field or method by starting its name with two underscores. This is
similar to making the field or method private.
The following Python program contains a CellPhone class like the one shown in your
textbook in Class Listing 14-3. It also has a main method to demonstrate the class, like that
shown in pseudocode Program 14-3 in your textbook.
Program 14-1
1 class CellPhone:
2
def set_manufacturer(self, manufact):
3
self.__manufacturer = manufact
4
5
def set_model_number(self, model):
6
self.__model_number = model
7
8
def set_retail_price(self, retail):
This is the Python version of
Class Listing 14-3 and Program
14-1 in your textbook!
Page 101
9
self.__retail_price = retail
10
11
def get_manufacturer(self):
12
return self.__manufacturer
13
14
def get_model_number(self):
15
return self.__model_number
16
17
def get_retail_price(self):
18
return self.__retail_price
19
20 def main():
21
# Create a CellPhone object. The phone
22
# variable will reference the object.
23
phone = CellPhone()
24
25
# Store values in the object's fields.
26
phone.set_manufacturer("Motorola")
27
phone.set_model_number("M1000")
28
phone.set_retail_price(199.99)
29
30
# Display the values stored in the fields.
31
print('The manufacturer is', phone.get_manufacturer())
32
print('The model number is', phone.get_model_number())
33
print('The retail price is', phone.get_retail_price())
34
35 # Call the main function.
36 main()
Program Output
The manufacturer is Motorola
The model number is M1000
The retail price is 199.99
The CellPhone class declaration begins in line 1. It has the following method definitions:
•
•
•
•
•
•
Lines 2 through 3: the set_manufacturer method
Lines 5 through 6: the set_model_number method
Lines 8 through 9: the set_retail_price method
Lines 11 through 12: the get_manufacturer method
Lines 14 through 15: the get_model_number method
Lines 17 through 18: the get_retail_price method
Page 102
Notice that each of the methods has a parameter named self. The self parameter is
required in every method that a class has. A method operates on a specific object's data
attributes. When a method executes, it must have a way of knowing which object's data
attributes it is supposed to operate on. That's where the self parameter comes in. When a
method is called, Python automatically makes its self parameter reference the specific object
that the method is supposed to operate on.
Now let's look at the set_maufacturer method in lines 2 through 3. Notice that in addition
to the self parameter, it also has a parameter named manufact. The statement in line 3
assigns manufact to self.__manufacturer. What is self.__manufacturer? Let's
analyze it:
•
•
self refers to a specific CellPhone object in memory.
__manufacturer is the name of a field. The two underscores at the beginning of the
field name make it private to code outside the CellPhone class.
So, the statement in line 3 assigns the value of the manufact parameter to a CellPhone
object's __manufacturer field.
The set_model_number method, in lines 5 through 6 is similar. It has a model parameter
that is assigned to the object's __model_number field.
The set_retial_price method, in lines 8 through 9 is also similar. It has a retail
parameter that is assigned to the object's __retail_price field.
The get_manufacturer method, in lines 11 through 12, returns the value of the object's
__manufacturer field. The get_model_number method, in lines 14 through 15, returns
the value of the object's model_number field. The get_retail_price method, in lines
17 through 18, returns the object's __retail_price field.
Inside the main function, line 23 creates an instance of the CellPhone class in memory and
assigns it to the phone variable. We say that the object is referenced by the phone variable.
(Notice that Python does not require the New keyword, as discussed in your textbook.) Lines 26
through 28 call the object's set_manufacturer, set_model_number, and
set_retail_price methods, passing arguments to each.
Recall that in the CellPhone class, the set_manufacturer, set_model_number, and
set_retail_price methods each have two parameters. However, when we call these
methods in lines 26 through 28, we pass only one argument. The first parameter in each of
these methods is the self parameter. When you call a method, you do not pass an argument
for the self parameter because Python automatically passes a reference to the calling object
into the method's first parameter. As a result, the self parameter will automatically reference
the object that the method is to operate on. This means that:
Page 103
•
•
•
In line 26, the argument "Motorola" is being passed into the set_manufacturer
method's manufact parameter.
In line 27 the argument "M1000" is being passed into the set_model_number
method's model parameter
In line 28 the 199.99 argument is being passed into the set_retail_price
method's retail parameter.
Lines 31 through 33 call the print function to display the values of the object's fields.
Constructors
In Python, classes can have a method named __init__ which is automatically executed when
an instance of the class is created in memory. The __init__ method is commonly known as
an initializer method because it initializes the object's data attributes. (The name of the method
starts with two underscore characters, followed by the word init, followed by two more
underscore characters.)
Program 14-2 shows a version of the CellPhone class that has an __init__ method. This is
the Python version of Class Listing 14-4 combined with pseudocode Program 14-2 from your
textbook.
Program 14-2
1 class CellPhone:
2
def __init__(self, manufact, model, retail):
3
self.__manufacturer = manufact
4
self.__model_number = model
5
self.__retail_price = retail
This is the Python version of
6
Class Listing 14-4 and Program
7
def set_manufacturer(self, manufact):
14-2 in your textbook!
8
self.__manufacturer = manufact
9
10
def set_model_number(self, model):
11
self.__model_number = model
12
13
def set_retail_price(self, retail):
14
self.__retail_price = retail
15
16
def get_manufacturer(self):
17
return self.__manufacturer
18
19
def get_model_number(self):
20
return self.__model_number
21
22
def get_retail_price(self):
23
return self.__retail_price
Page 104
24
25 def main():
26
# Create a CellPhone object and initialize its
27
# fields with values passed to the __init__ method.
28
phone = CellPhone("Motorola", "M1000", 199.99)
29
30
# Display the values stored in the fields.
31
print('The manufacturer is', phone.get_manufacturer())
32
print('The model number is', phone.get_model_number())
33
print('The retail price is', phone.get_retail_price())
34
35 # Call the main function.
36 main()
Program Output
The manufacturer is Motorola
The model number is M1000
The retail price is 199.99
The statement in line 28 creates a CellPhone object in memory and assigns it to the phone
variable. Notice that the values "Motorola", "M1000", and1 99.99 appear inside the
parentheses after the class name. These values are passed as arguments to the class's
__init__ method.
Inheritance
The inheritance example discussed in your textbook starts with the GradedActivity class
(see Class Listing 14-8), which is used as a superclass. The FinalExam class is then used as a
subclass (see Class Listing 14-9) The Python versions of these classes are shown in Program 143. This program also has a main function that demonstrates how the inheritance works.
Page 105
Program 14-3 (inheritance_demo.py)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
class GradedActivity:
def set_score(self, s):
self.__score = s
def get_score(self):
return self.__score
def get_grade(self):
if self.__score >= 90:
grade = 'A'
elif self.__score >= 80:
grade = 'B'
elif self.__score >= 70:
grade = 'C'
elif self.__score >= 60:
grade = 'D'
else:
grade = 'F'
return grade
This is the Python version of
Class Listing 14-8, Class Listing
14-9, and Program 14-3 in your
textbook!
In this method, grade is a local variable.
It is not a class field.
class FinalExam(GradedActivity):
def __init__(self, questions, missed):
# Set the __num_questions and __num_missed fields.
self.__num_questions = questions
self.__num_missed = missed
Here we are calling the inherited
set_score method.
# Calculate the points for each question and
# the numeric socre for this exam.
self.__points_each = 100.0 / questions
numeric_score = 100.0 - (missed * self.__points_each)
# Call the inherited set_score method to
# set the numeric score.
self.set_score(numeric_score)
def get_points_each(self):
return self.__points_each
In this method,
numeric_score is a local
variable. It is not a class field.
def get_num_missed(self):
return self.__num_missed
def main():
# Prompt the user for the number of questions
# on the exam.
questions = int(input('Enter the number of questions on the exam: '))
# Prompt the user for the number of questions
# missed by the student.
missed = int(input('Enter the number of questions that the student missed: '))
# Create a FinalExam object.
exam = FinalExam(questions, missed)
# Display the test results.
print('Each question on the exam counts', exam.get_points_each(), 'points.')
print('The exam score is', exam.get_score())
print('The exam grade is', exam.get_grade())
# Call the main function.
main()
Page 106
Program Output
Enter the number of questions on the exam: 20 [Enter]
Enter the number of questions that the student missed: 3 [Enter]
Each question on the exam counts 5.0 points.
The exam score is 85.0
The exam grade is B
The GradedActivity class is declared in lines 1 through 19. Then the FinalExam class is
declared in lines 21 through 40. Notice the first line of the FinalExam class in line 21:
class FinalExam(GradedActivity):
By writing GradedActivity inside parentheses after the class name, we are indicating that
the FinalExam class extends the GradedActivity class. As a result, GradedActivity
is the superclass and FinalExam is the subclass.
Polymorphism
Your textbook presents a polymorphism demonstration that uses the Animal class (Class
Listing 14-10) as a superclass, and the Dog class (Class Listing 14-11) and Cat class (Class
Listing 14-12) as subclasses of Animal. The Python versions of those classes are shown here.
The main function and the show_animal_info functions are the Python equivalent of
Program 14-6 in your textbook.
Program 14-4 (polymorphism.py)
1 class Animal:
2
def show_species(self):
3
print('I am just a regular animal.')
4
5
def make_sound(self):
6
print('Grrrrrr')
7
8 class Dog(Animal):
9
def show_species(self):
10
print('I am a dog.')
11
12
def make_sound(self):
13
print('Woof! Woof!')
14
15 class Cat(Animal):
16
def show_species(self):
17
print('I am a cat.')
18
19
def make_sound(self):
Page 107
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
print('Meow')
# Here is the main function.
def main():
# Create an animal object, a Dog object, and
# a Cat object.
my_animal = Animal()
my_dog = Dog()
my_cat = Cat()
# Show info about an animal.
print('Here is info about an animal.')
show_animal_info(my_animal)
print()
# Show info about a dog.
print('Here is info about a dog.')
show_animal_info(my_dog)
print()
# Show info about a cat.
print('Here is info about a cat.')
show_animal_info(my_cat)
# The show_animal_info function accepts an Animal
# object as an argument and displays information
# about it.
def show_animal_info(creature):
creature.show_species()
creature.make_sound()
# Call the main function.
main()
Program Output
Here is info about an animal.
I am just a regular animal.
Grrrrrrr
Here is info about a dog.
I am a dog.
Woof! Woof!
Page 108
Here is info about a cat.
I am a cat.
Meow
Page 109
Chapter 15
GUI Applications and Event-Driven
Programming
Python does not have GUI programming features built into the language itself. However, it
comes with a module named Tkinter that allows you to create simple GUI programs. The name
"Tkinter" is short for "Tk interface." It is named this because it provides a way for Python
programmers to use a GUI library named Tk. Many other programming languages use the Tk
library as well.
This chapter will give you a brief introduction to GUI programming using Python and Tkinter.
We won’t go over all of the features, but we will discuss an adequate number of topics to get
you started.
Note: There are numerous GUI libraries available for Python. Because the Tkinter module
comes with Python, we will use only it in this chapter.
A GUI program presents a window with various graphical widgets that the user can interact
with and/or display data to the user. The tkinter module provides 15 widgets, which are
described in Table 15-1. We won't cover all of the Tkinter widgets, but we will demonstrate
how to create simple GUI programs that gather input and display data.
Table 15-1 Tkinter Widgets
Widget
Description
Button
A button that can cause an action to occur when it is clicked.
Canvas
A rectangular area that can be used to display graphics.
Checkbutton
A button that may be in either the "on" or "off" position.
Entry
An area in which the user may type a single line of input from the
keyboard.
Frame
A container that can hold other widgets.
Label
An area that displays one line of text or an image.
Listbox
A list from which the user may select an item
Menu
A list of menu choices that are displayed when the user clicks a
Menubutton widget.
Menubutton
A menu that is displayed on the screen and may be clicked by the
user.
Message
Displays multiple lines of text.
Radiobutton
A widget that can be either selected or deselected. Radiobuttons
usually appear in groups and allow the user to select one of
several options.
Scale
A widget that allows the user to select a value by moving a slider
along a track.
Scrollbar
Can be used with some other types of widgets to provide scrolling
Page 110
Text
Toplevel
ability.
A widget that allows the user to enter multiple lines of text input.
A container, like a Frame, but displayed in its own window.
The simplest GUI program that we can demonstrate is one that displays an empty window.
Program 15-1 shows how we can do this using the tkinter module. When the program runs,
the window shown in Figure 15-1 is displayed. To exit the program, simply click the standard
Windows close button (
) in the upper right corner of the window.
Note: Programs that use Tkinter do not always run
reliably under IDLE. This is because IDLE itself uses Tkinter.
You can always use IDLE's editor to write GUI programs,
but for the best results, run them from your operating
systems command prompt.
Program 15-1 (empty_window1.py)
1 # This program displays an empty window.
2
3 import tkinter
4
5 def main():
6
# Create the main window widget.
7
main_window = tkinter.Tk()
8
9
# Enter the tkinter main loop.
10
tkinter.mainloop()
11
12 # Call the main function.
13 main()
Figure 15-1 Window displayed by Program 15-1
Page 111
In order for the program to use the tkinter module, it must have an import statement
such as the one shown in line 3. Inside the main function, line 7 creates an instance of the
tkinter module's Tk class, and assigns it to the main_window variable. This object is the
root widget, which is the main window in the program. Line 10 calls the tkinter module's
mainloop function. This function runs like an infinite loop until you close the main window.
Most programmers prefer to take an object-oriented approach when writing a GUI program.
Rather than writing a function to create the on-screen elements of a program, it is a common
practice to write a class with an __init__ method that builds the GUI. When an instance of
the class is created, the GUI appears on the screen. To demonstrate, Program 15-2 shows an
object-oriented version of our program that displays an empty window. When this program
runs it displays the window previously shown in Figure 15-1.
Program 15-2 (empty_window2.py)
1 # This program displays an empty window.
2
3 import tkinter
4
5 class MyGUI:
6
def __init__(self):
7
# Create the main window widget.
8
self.main_window = tkinter.Tk()
9
10
# Enter the tkinter main loop.
11
tkinter.mainloop()
12
13 # Create an instance of the MyGUI class.
14 my_gui = MyGUI()
Lines 5 through 11 are the class declaration for the MyGUI class. The class's __init__
method begins in line 6. Line 8 creates the root widget and assigns it to the class field
main_window. Line 11 executes the tkinter module's mainloop function. The statement
in line 14 creates an instance of the MyGUI class. This causes the class's __init__ method to
execute, displaying the empty window on the screen.
You can use a Label widget to display a single line of text in a window. To make a Label widget
you create an instance of the tkinter module's Label class. Program 15-3 creates a window
containing a Label widget that displays the text "Hello World!" The window is shown in Figure
15-2.
Page 112
Program 15-3 (hello_world.py)
1 # This program displays a label with text.
2
This is the line continuation character.
3 import tkinter
It allows a statement to be broken up
4
into multiple lines.
5 class MyGUI:
6
def __init__(self):
7
# Create the main window widget.
8
self.main_window = tkinter.Tk()
9
10
# Create a Label widget containing the
11
# text 'Hello World!'
12
self.label = tkinter.Label(self.main_window, \
13
text='Hello World!')
14
15
# Call the Label widget's pack method.
16
self.label.pack()
17
18
# Enter the tkinter main loop.
19
tkinter.mainloop()
20
21 # Create an instance of the MyGUI class.
22 my_gui = MyGUI()
Figure 15-2 Window displayed by Program 15-3
The MyGUI class in this program is very similar to the one you saw previously in Program 15-2.
Its __init__ method builds the GUI when an instance of the class is created. Line 8 creates a
root widget and assigns it to self.main_window. The following statement appears in lines
12 and 13:
self.label = tkinter.Label(self.main_window, \
text='Hello World!')
First, let's explain the \ character at the end of the first line. This is the line continuation
character. In Python, when you want to break a long statement into multiple lines, you type the
backslash key (\) at the point where you want to break the statement, and then press the Enter
key. Now let's look at what the statement does.
This statement creates a Label widget and assigns it to self.label. The first argument inside
the parentheses is self.main_window, which is a reference to the root widget. This simply
Page 113
specifies that we want the Label widget to belong to the root widget. The second argument is
text='Hello World!'. This specifies the text that we want displayed in the label.
The statement in line 16 calls the Label widget's pack method. The pack method arranges a
widget in its proper position, and it makes the widget visible when the main window is
displayed. (You call the pack method for each widget in a window.) Line 19 calls the Tkinter
module's mainloop method which displays the program's main window, shown in Figure 152.
Let's look at another example. Program 15-4 displays a window with two Label widgets, shown
in Figure 15-3.
Program 15-4 (hello_world2.py)
1 # This program displays two labels with text.
2
3 import tkinter
4
5 class MyGUI:
6
def __init__(self):
7
# Create the main window widget.
8
self.main_window = tkinter.Tk()
9
10
# Create two Label widget.
11
self.label1 = tkinter.Label(self.main_window, \
12
text='Hello World!')
13
self.label2 = tkinter.Label(self.main_window, \
14
text='This is my GUI program.')
15
16
# Call both Label widgets' pack method.
17
self.label1.pack()
18
self.label2.pack()
19
20
# Enter the tkinter main loop.
21
tkinter.mainloop()
22
23 # Create an instance of the MyGUI class.
24 my_gui = MyGUI()
Figure 15-3 Window displayed by Program 15-4
Page 114
Notice that the two Label widgets are displayed with one stacked on top of the other. We can
change this layout by specifying an argument to pack method, as shown in Program 15-5.
When the program runs it displays the window shown in Figure 15-4.
Program 15-5 (hello_world3.py)
1 # This program uses the side='left' argument with
2 # the pack method to change the layout of the widgets.
3
4 import tkinter
5
6 class MyGUI:
7
def __init__(self):
8
# Create the main window widget.
9
self.main_window = tkinter.Tk()
10
11
# Create two Label widgets.
12
self.label1 = tkinter.Label(self.main_window, \
13
text='Hello World!')
14
self.label2 = tkinter.Label(self.main_window, \
15
text='This is my GUI program.')
16
17
# Call both Label widgets' pack method.
18
self.label1.pack(side='left')
19
self.label2.pack(side='left')
20
21
# Enter the tkinter main loop.
22
tkinter.mainloop()
23
24 # Create an instance of the MyGUI class.
25 my_gui = MyGUI()
Figure 15-4 Window displayed by Program 15-5
In lines 18 and 19 we call each Label widget's pack method passing the argument
side='left'. This specifies that the widget should be positioned as far left as possible inside
the parent widget. Because the label1 widget was added to the main_window first, it will
appear at the leftmost edge. The label2 widget was added next, so it appears next to the
label1 widget. As a result, the labels appear side by side. The valid side arguments that you
can pass to the pack method are side='top', side='bottom', side='left', and
side='right'.
Page 115
Organizing Widgets with Frames
A frame is a container. It is a widget that can hold other widgets. Frames are useful for
organizing and arranging groups of widgets in a window. For example, you can place a set of
widgets in one frame and arrange them in a particular way, then place a set of widgets in
another frame and arrange them in a different way. Program 15-6 demonstrates this. When the
program runs it displays the window shown in Figure 15-5.
Program 15-6 (frame_demo.py)
1 # This program creates labels in two different frames.
2
3 import tkinter
4
5 class MyGUI:
6
def __init__(self):
7
# Create the main window widget.
8
self.main_window = tkinter.Tk()
9
10
# Create two frames, one for the top of the
11
# window, and one for the bottom.
12
self.top_frame = tkinter.Frame(self.main_window)
13
self.bottom_frame = tkinter.Frame(self.main_window)
14
15
# Create three Label widgets for the
16
# top frame.
17
self.label1 = tkinter.Label(self.top_frame, \
18
text='Winken')
19
self.label2 = tkinter.Label(self.top_frame, \
20
text='Blinken')
21
self.label3 = tkinter.Label(self.top_frame, \
22
text='Nod')
23
24
# Pack the labels that are in the top frame.
25
# Use the side='top' argument to stack them
26
# one on top of the other.
27
self.label1.pack(side='top')
28
self.label2.pack(side='top')
29
self.label3.pack(side='top')
30
31
# Create three Label widgets for the
32
# bottom frame.
33
self.label4 = tkinter.Label(self.top_frame, \
34
text='Winken')
35
self.label5 = tkinter.Label(self.top_frame, \
36
text='Blinken')
37
self.label6 = tkinter.Label(self.top_frame, \
38
text='Nod')
Page 116
39
40
# Pack the labels that are in the bottom frame.
41
# Use the side='left' argument to arrange them
42
# horizontally from the left of the frame.
43
self.label4.pack(side='left')
44
self.label5.pack(side='left')
45
self.label6.pack(side='left')
46
47
# Yes, we have to pack the frames too!
48
self.top_frame.pack()
49
self.bottom_frame.pack()
50
51
# Enter the tkinter main loop.
52
tkinter.mainloop()
53
54 # Create an instance of the MyGUI class.
55 my_gui = MyGUI()
Figure 15-5 Window displayed by Program 15-6
Take a closer look at lines 12 and 13:
self.top_frame = tkinter.Frame(self.main_window)
self.bottom_frame = tkinter.Frame(self.main_window)
These lines create two Frame objects. The self.main_window argument that appears
inside the parentheses causes the Frames to be added to the main_window widget.
Lines 17 through 22 create three Label widgets. Notice that these widgets are added to the
self.top_frame widget. Then, lines 27 through 29 call each of the Label widgets' pack
method, passing side='top' as an argument. As shown in Figure 15-6, this causes the three
widgets to be stacked one on top of the other inside the Frame.
Lines 33 through 28 create three more Label widgets. These Label widgets are added to the
self.bottom_frame widget. Then, lines 43 through 45 call each of the Label widgets'
pack method, passing side='left' as an argument. As shown in Figure 15-6, this causes
the three widgets to appear horizontally inside the Frame.
Page 117
Lines 48 and 49 call the Frame widgets' pack method, which makes the Frame widgets visible.
Line 52 executes the tkinter module's mainloop function.
Figure 15-6 Arrangement of widgets
Button Widgets and Info Dialog Boxes
A Button is a widget that the user can click to cause an action to take place. When you create a
Button widget you can specify the text that is to appear on the face of the button, and the
name of a callback function. A callback function is a function or method that executes when the
user clicks the button.
Note: A callback function is also known as an event handler because it handles the event that
occurs when the user clicks the button.
To demonstrate, we will look at Program 15-7. This program displays the window shown in
Figure 15-7. When the user clicks the button, the program displays a separate info dialog box,
shown in Figure 15-8. We use a function named tkinter.messagebox.showinfo to
display the info dialog box. This is the general format of the showinfo function call:
tkinter.messagebox.showinfo(title, message)
In the general format, title is a string that is displayed in the dialog box's title bar, and
message is an informational string that is displayed in the main part of the dialog box.
Program 14-7 (button_demo.py)
1 # This program demonstrates a Button widget.
2 # When the user clicks the Button, an
3 # info dialog box is displayed.
4
5 import tkinter
6
Page 118
7 class MyGUI:
8
def __init__(self):
9
# Create the main window widget.
10
self.main_window = tkinter.Tk()
11
12
# Create a Button widget. The text 'Click Me!'
13
# should appear on the face of the Button. The
14
# do_something method should be executed when
15
# the user clicks the Button.
16
self.my_button = tkinter.Button(self.main_window, \
17
text='Click Me!', \
18
command=self.do_something)
19
20
# Pack the Button.
21
self.my_button.pack()
22
23
# Enter the Tkinter main loop.
24
tkinter.mainloop()
25
26
# The do_something method is a callback function
27
# for the Button widget.
28
29
def do_something(self):
30
# Display an info dialog box.
31
tkinter.messagebox.showinfo('Response', \
32
'Thanks for clicking the button.')
33
34 # Create an instance of the MyGUI class.
35 my_gui = MyGUI()
Figure 15-7 The main window displayed by Program 15-7
Figure 15-8 The info dialog box displayed by Program 15-7
Page 119
The statement in lines 16 through 18 creates the Button widget. The first argument inside the
parentheses is self.main_window, which is the parent widget. The text='Click Me!'
argument specifies that the string 'Click Me!' should appear on the face of the button. The
command='self.do_something' argument specifies the class's do_something
method as the callback function. When the user clicks the button, the do_something
method will execute.
The do_something method appears in lines 29 through 32. The method simply calls the
tkinter.messagebox. showinfo function to display the info box shown in Figure 15-8.
To dismiss the dialog box the user can click the OK button.
Creating a Quit Button
GUI programs usually have a Quit button (or an Exit button) that closes the program when the
user clicks it. To create a Quit button in a Python program you simply create a Button widget
that calls the root widget's destroy method as a callback function. Program 15-8
demonstrates how to do this. It is a modified version of Program 15-7, with a second Button
widget added as shown in Figure 15-9.
Program 15-8 (quit_button.py)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
# This program has a Quit button that calls
# the Tk class's destroy method when clicked.
import tkinter
class MyGUI:
def __init__(self):
# Create the main window widget.
self.main_window = tkinter.Tk()
# Create a Button widget. The text 'Click Me!'
# should appear on the face of the Button. The
# do_something method should be executed when
# the user clicks the Button.
self.my_button = tkinter.Button(self.main_window, \
text='Click Me!', command=self.do_something)
# Create a Quit button. When this button is clicked
# the root widget's destroy method is called.
# (The main_window variable references the root widget,
# so the callback function is self.main_window.destroy.)
self.quit_button = tkinter.Button(self.main_window, \
text='Quit', command=self.main_window.destroy)
# Pack the Buttons.
self.my_button.pack()
self.quit_button.pack()
Page 120
29
# Enter the tkinter main loop.
30
tkinter.mainloop()
31
32
# The do_something method is a callback function
33
# for the Button widget.
34
35
def do_something(self):
36
# Display an info dialog box.
37
tkinter.messagebox.showinfo('Response', \
38
'Thanks for clicking the button.')
39
40 # Create an instance of the MyGUI class.
41 my_gui = MyGUI()
Figure 15-9 The info dialog box displayed by Program 15-8
The statement in lines 22 through 23 creates the Quit button. Notice that the
self.main_window.destroy method is used as the callback function. When the user
clicks the button, this method is called and the program ends.
Getting Input with the Entry Widget
An Entry widget is a rectangular area that the user can type text into. Entry widgets are used to
gather input in a GUI program. Typically, a program will have one or more Entry widgets in a
window, along with a button that the user clicks to submit the data that he or she has typed
into the Entry widgets. The button's callback function retrieves data from the window's Entry
widgets and processes it.
You use an Entry widget's get method to retrieve the data that the user has typed into the
widget. The get method returns a string, so it will have to be converted to the appropriate
data type if the Entry widget is used for numeric input.
To demonstrate we will look at a program that allows the user to enter a distance in kilometers
into an Entry widget, and then click a button to see that distance converted to miles. The
formula for converting kilometers to miles is:
Miles = Kilometers × 0.6214
Figure 15-10 shows the window that the program displays. To arrange the widgets in the
positions shown in the figure, we will organize them in two frames, as shown in Figure 15-11.
Page 121
The label that displays the prompt and the Entry widget will be stored in the top_frame, and
their pack methods will be called with the side='left' argument. This will cause them to
appear horizontally in the frame. The Convert button and the Quit button will be stored in the
bottom_frame, and their pack methods will also be called with the side='left'
argument.
Program 15-9 shows the code for the program. Figure 15-12 shows what happens when the
user enters 1000 into the Entry widget and then clicks the Convert button.
Figure 15-10 The kilo_converter program's window
Figure 15-11 The window organized with frames
Program 15-9 (kilo_converter.py)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# This program converts distances in kilometers
# to miles. The result is displayed in an info
# dialog box.
import tkinter
class KiloConverterGUI:
def __init__(self):
# Create the main window.
self.main_window = tkinter.Tk()
# Create two frames to group widgets.
self.top_frame = tkinter.Frame(self.main_window)
self.bottom_frame = tkinter.Frame(self.main_window)
# Create the widgets for the top frame.
self.prompt_label = tkinter.Label(self.top_frame, \
text='Enter a distance in kilometers:')
self.kilo_entry = tkinter.Entry(self.top_frame, \
width=10)
Page 122
23
# Pack the top frame's widgets.
24
self.prompt_label.pack(side='left')
25
self.kilo_entry.pack(side='left')
26
27
# Create the button widgets for the bottom frame.
28
self.calc_button = tkinter.Button(self.bottom_frame, \
29
text='Convert', \
30
command=self.convert)
31
self.quit_button = tkinter.Button(self.bottom_frame, \
32
text='Quit', \
33
command=self.main_window.destroy)
34
# Pack the buttons.
35
self.calc_button.pack(side='left')
36
37
self.quit_button.pack(side='left')
38
39
# Pack the frames.
40
self.top_frame.pack()
41
self.bottom_frame.pack()
42
43
# Enter the Tkinter main loop.
44
tkinter.mainloop()
45
46
# The convert method is a callback function for
47
# the Calculate button.
48
49
def convert(self):
50
# Get the value entered by the user into the
51
# kilo_entry widget.
52
kilo = float(self.kilo_entry.get())
53
54
# Convert kilometers to miles.
55
miles = kilo * 0.6214
56
57
# Display the results in an info dialog box.
58
tkinter.messagebox.showinfo('Results', \
59
str(kilo) + ' kilometers is equal to ' + \
60
str(miles) + ' miles.')
61
62 # Create an instance of the KiloConverterGUI class.
63 kilo_conv = KiloConverterGUI()
Figure 15-12 The info dialog box
Page 123
The convert method, shown in lines 49 through 60 is the Convert button's callback function.
The statement in line 52 calls the kilo_entry widget's get method to retrieve the data that
has been typed into the widget. The value is converted to a float and then assigned to the
kilo variable. The calculation in line 55 performs the conversion and assigns the results to the
miles variable. Then, the statement in lines 58 through 60 displays the info dialog box with a
message that gives the converted value.
Page 124
Appendix A: Introduction to IDLE
IDLE is an integrated development environment that combines several development tools into
one program, including the following:
•
•
•
•
•
•
•
A Python shell running in interactive mode. You can type Python statements at the shell
prompt and immediately execute them. You can also run complete Python programs.
A text editor that color codes Python keywords and other parts of programs.
A "check module" tool that checks a Python program for syntax errors without running
the program.
Search tools that allow you to find text in one or more files.
Text formatting tools that help you maintain consistent indentation levels in a Python
program.
A debugger that allows you to single-step through each statement in a Python program
and watch the values of variables as the statements execute.
Several other advanced tools for developers.
The IDLE software is bundled with Python. When you install the Python interpreter, IDLE is
automatically installed as well. This appendix provides a quick introduction to IDLE, and
describes the basic steps of creating, saving, and executing a Python program.
Starting IDLE and Using the Python Shell
After Python is installed on your system a Python program group will appear in your Start
menu's program list. One of the items in the program group will be titled IDLE (Python GUI).
Click this item to start IDLE and you will see the Python Shell window shown in Figure A-1.
Inside this window the Python interpreter is running in interactive mode, and at the top of the
window is a menu bar that provides access to all of IDLE's tools.
The >>> prompt indicates that the interpreter is waiting for you to type a Python statement.
When you type a statement at the >>> prompt and press the Enter key, the statement is
immediately executed. For example, Figure A-2 shows the Python Shell window after three
statements have been entered and executed.
Page 125
Figure A-1 IDLE shell window
Figure A-2 Statements executed by the Python interpreter
When you type the beginning of a multiline statement, such as an if statement or a loop, each
subsequent line is automatically indented. Pressing the Enter key on an empty line indicates the
end of the multiline statement and causes the interpreter to execute it. Figure A-3 shows the
Python Shell window after a for loop has been entered and executed.
Page 126
Figure A-3 A multiline statement executed by the Python interpreter
Writing a Python Program in the IDLE Editor
To write a new Python program in IDLE you open a new editing window. As shown in Figure A-4
you click File on the menu bar, then click New Window. (Alternatively you can press Ctrl+N.)
This opens a text editing window like the one shown in Figure A-5.
To open a program that already exists, click File on the menu bar, then Open. Simply browse to
the file's location and select it, and it will be opened in an editor window.
Page 127
Figure A-4 The File menu
Figure A-5 A text editing window
Page 128
Color Coding
Code that is typed into the editor window, as well as in the Python Shell window, is colorized as
follows:
•
•
•
•
•
Python keywords are displayed in orange
Comments are displayed in red
String literals are displayed in green
Defined names, such as the names of functions and classes, are displayed in blue.
Built-in functions are displayed in purple
Figure A-6 shows an example of the editing window containing colorized Python code.
Figure A-6 Colorized code in the editing window
Tip:
You can change IDLE's color settings by clicking Options on the menu bar, then clicking
Configure IDLE. Select the Highlighting tab at the top of the dialog box and you can
specify colors for each element of a Python program.
Automatic Indentation
The IDLE editor has features that help you to maintain consistent indentation in your Python
programs. Perhaps the most helpful of these features is automatic indentation. When you type
a line that ends with a colon, such as an if clause, the first line of a loop, or a function header,
and then press the Enter key, the editor automatically indents the lines that are entered next.
Page 129
For example, suppose you are typing the code shown in Figure A-7. After you press the Enter
key at the end of the line marked
, the editor will automatically indent the lines that you
type next. Then, after you press the Enter key at the end of the line marked
, the editor
indents again. Pressing the Backspace key at the beginning of an indented line cancels one level
of indentation.
Figure A-7 Lines that cause automatic indentation
By default, IDLE indents four spaces for each level of indentation. It is possible to change the
number of spaces by clicking Options on the menu bar, then clicking Configure IDLE. Make sure
Fonts/Tabs is selected at the top of the dialog box, and you will see a slider bar that allows you
to change the number of spaces used for indentation width. However, because four spaces is
the standard width for indentation in Python, it is recommended that you keep this setting.
Saving a Program
In the editor window you can save the current program by performing any of these operations
from the File menu:
•
•
•
Save
Save As
Save Copy As
The Save and Save As operations work just like they do in any Windows application. The Save
Copy As operation works like Save As, but it leaves the original program in the editor window.
Page 130
Running a Program
Once you have typed a program into the editor, you can run it by pressing the F5 key, or as
shown in Figure A-8, by clicking Run on the editor window's menu bar, then Run Module. If the
program has not been saved since the last modification was made, you will see the dialog box
shown in Figure A-9. Click OK to save the program. When the program runs you will see its
output displayed in IDLE's Python Shell window, as shown in Figure A-10.
Figure A-8 The editor window's Run menu
Figure A-9 Save confirmation dialog box
Page 131
Figure A-10 Output displayed in the Python Shell window
If a program contains a syntax error, when you run the program you will see the dialog box
shown in Figure A-11. After you click the OK button the editor will highlight the location of the
error in the code. If you want to check the syntax of a program without trying to run it you can
click Run on the menu bar, then Check Module. Any syntax errors that are found will be
reported.
Figure A-11 Dialog box reporting a syntax error
Other Resources
This appendix has provided an overview for using IDLE to create, save, and execute programs.
IDLE provides many more advanced features. To read about additional capabilities, see the
official IDLE documentation at www.python.org/idle.
Page 132
Download PDF
Similar pages