Hands-On Python

A Tutorial Introduction for Beginners

Python 3.1 Version

Dr. Andrew N. Harrington

Computer Science Department, Loyola University Chicago
© Released under the Creative commons Attribution-Noncommercial-Share
Alike 3.0 United States License
http://creativecommons.org/licenses/by-nc-sa/3.0/us/
 Contents

Chapter 1. Beginning With Python 4

1.1. Context 4
1.2. The Python Interpreter and Idle, Part I 6
1.3. Whirlwind Introduction To Types and Functions 11
1.4. Integer Arithmetic 12
1.5. Strings, Part I 14
1.6. Variables and Assignment 15
1.7. Print Function, Part I 16
1.8. Strings Part II 17
1.9. The Idle Editor and Execution 17
1.10. Input and Output 19
1.11. Defining Functions of your Own 23
1.12. Dictionaries 31
1.13. Loops and Sequences 35
1.14. Decimals, Floats, and Floating Point Arithmetic 45
1.15. Summary 47

Chapter 2. Objects and Methods 53

2.1. Strings, Part III 53
2.2. More Classes and Methods 59
2.3. Mad Libs Revisited 61
2.4. Graphics 66
2.5. Files 88
2.6. Summary 90
Chapter 3. More On Flow of Control 93
3.1. If Statements 93
3.2. Loops and Tuples 105
3.3. While Statements 109
3.4. Arbitrary Types Treated As Boolean 120
3.5. Further Topics to Consider 122
3.6. Summary 123
Chapter 4. Dynamic Web Pages 126
4.1. Web page Basics 126
4.2. Composing Web Pages in Python 128
4.3. CGI - Dynamic Web Pages 131
4.4. Summary 138

3
 CHAPTER 1

Beginning With Python

1.1. Context
You have probablry used computers to do all sorts of useful and interesting things. In each application,
the computer responds in different ways to your input, from the keyboard, mouse or a file. Still the underlying
operations are determined by the design of the program you are given. In this set of tutorials you will learn
to write your own computer programs, so you can give the computer instructions to react in the way you
want.

1.1.1. Low-Level and High-Level Computer Operations. First let us place Python programming
in the context of the computer hardware. At the most fundamental level in the computer there are instruc-
tions built into the hardware. These are very simple instructions, peculiar to the hardware of your particular
type of computer. The instructions are designed to be simple for the hardware to execute, not for humans to
follow. The earliest programming was done with such instructions. If was difficult and error-prone. A major
advance was the development of higher-level languages and translators for them. Higher-level languages
allow computer programmers to write instructions in a format that is easier for humans to understand. For
example
z = x+y
is an instruction in many high-level languages that means something like:
(1) Access the value stored at a location labeled x
(2) Calculate the sum of this value and the value stored at a location labeled y
(3) Store the result in a location labeled z.
No computer understands the high-level instruction directly; it is not in machine language. A special program
must first translate instructions like this one into machine language. This one high-level instruction might be
translated into a sequence of three machine language instructions corresponding to the three step description
above:
0000010010000001
0000000010000010
0000010110000011
Obviously high-level languages were a great advance in clarity!
If you follow a broad introduction to computing, you will learn more about the layers that connect
low-level digital computer circuits to high-level languages.

1.1.2. Why Python. There are many high-level languages. The language you will be learning is
Python. Python is one of the easiest languages to learn and use, while at the same time being very powerful:
It is used by many of the most highly productive professional programmers. A few of the places that use
Python extensively are Google, the New York Stock Exchange, Industrial Light and Magic, .... Also Python
is a free language! If you have your own computer, you can download it from the Internet....

1.1.3. Obtaining Python for Your Computer. If you are not sure whether your computer already
has Python, continue to Section 1.2.2, and give it a try. If it works, you are all set.
If you do need a copy of Python, go to the Downloads page linked to http://www.python.org. Be
careful to choose the version for your operating system and hardware. Chosse a stable version, 3.1 or later.
Do not choose a version 2.X, which is incompatible. (Version 2.6 is described in an older version of this
tutorial.)
4
 1.1. CONTEXT 5

Windows You just need to execute the installer, and interact enough to agree to all the default choices.
Python works in Windows as well as on Apples and in the free operating system Linux.
OS X Double-click on the installer. Find and run the MacPython.mpkg that is inside. Follow the
defaults for installation.
Linux Python is generally installed, though Idle is not always installed. Look for something like ’idle-
python’ (the name in the Ubuntu distribution).

1.1.4. Philosophy and Implementation of the Hands-On Python Tutorials. Although Python
is a high-level language, it is not English or some other natural human language. The Python translator does
not understand “add the numbers two and three”. Python is a formal language with its own specific rules and
formats, which these tutorials will introduce gradually, at a pace intended for a beginner. These tutorials
are also appropriate for beginners because they gradually introduce fundamental logical programming skills.
Learning these skills will allow you to much more easily program in other languages besides Python. Some
of the skills you will learn are
• breaking down problems into manageable parts
• building up creative solutions
• making sure the solutions are clear for humans
• making sure the solutions also work correctly on the computer.
Guiding Principals for the Hands-on Python Tutorials:
• The best way to learn is by active participation. Information is principally introduced in small
quantities, where your active participation, experiencing Python, is assumed. In many place you
will only be able to see what Python does by doing it yourself (in a hands-on fashion). The tutorial
will often not show. Among the most common and important words in the tutorial are “Try this:”
• Other requests are for more creative responses. Sometimes there are Hints, which end up as hy-
perlinks in the web page version, and footnote references in the pdf version. Both formats should
encourage you to think actively about your response first before looking up the hint.

The tutorials also provide labeled exercises, for further practice, without immediate answers pro-
vided. The exercises are labeled at three levels
*: Immediate reinforcement of basic ideas – preferably do on your first pass.
**: Important and more substantial – be sure you can end up doing these.
***: Most creative
• Information is introduced in an order that gives you what you need as soon as possible. The
information is presented in context. Complexity and intricacy that is not immediately needed is
delayed until later, when you are more experienced.
• In many places there are complications that are important in the beginning, because there is a
common error caused by a slight misuse of the current topic. If such a common error is likely to
make no sense and slow you down, more information is given to allow you to head off or easily
react to such an error.
Although this approach is an effective way to introduce material, it is not so good for reference. Referencing
is addressed in several ways:
• An extensive Table of Contents
• Easy jumping to chosen text in a browser like Firefox
• Cross references to sections that elaborate on an introductory section
• Concise chapter summaries, grouping logically related items, even if that does not match the order
of introduction.
Some people learn better visually and verbally from the very beginning. Some parts of the tutorial will also
have links to corresponding flash video segments. Many people will find reading faster and more effective,
but the video segments may be particularly useful where a computer interface can be not only explained but
actually demonstrated. The links to such segments will be labeled. They will need a broadband link or a
CD (not yet generated).
 1.2. THE PYTHON INTERPRETER AND IDLE, PART I 6

In the Firefox browser, the incremental find is excellent, and particularly useful with the single web page
version of the tutorials. (It only fails to search footnotes.) It is particularly easy to jump through different
sections in a form like 1.2.4.

1.2. The Python Interpreter and Idle, Part I

1.2.1. Your Python Folder and Python Examples.
First you need to set up a location to store your work and the example programs from this tutorial. If
you are on a Windows computer, follow just one of the three choices below to find an appropriate place to
download the example archive examples.zip, and then follow the later instructions to unzip the archive.
Your Own Computer: If you are at your own computer, you can put the folder for your Python
programs most anywhere you like. For Chapter 4, it will be important that none of the directories
leading down to your Python folder contain any blanks in them. In particular in Windows, “My
Documents” is a bad location. In Windows you can create a directory in C: drive, like C:\myPython.
You should have installed Python to continue.
Your Flash Drive: If you do not have your own computer, or you want to have your materials easily
travel back and forth between the lab and home, you will need a flash drive.

Plug your flash drive into the computer USB port.

On the computers in the Loyola lab DH 342, you can attach to the end of a cable that reaches close
to the keyboard. In DH 339, there are USB ports on the monitor. Please Note: Flash drives are
easy for me to forget and leave in the computer. I have lost a few this way. If you are as forgetful as
I, you might consider a string from the flash drive to something you will not forget to take with you.

Open My Computer (on the desktop) to see where the flash drive is mounted, and open that
drive.
Temporary: If you (temporarily) do not have a flash drive and you are at a Loyola lab computer:
Open My Computer from the desktop, and then select drive D:. Create a folder on drive D: with
your name or initials to make it easy for you to save and remove things. Change to that folder.
You should place the examples archive here. You will need to save your work somehow before you
log off of the computer. You may want to email individual files to yourself, or rezip the examples
folder and send just the one archive file to yourself each time until you remember a flash drive!
In Windows, after you have chosen a location for the archive, examples.zip, download it by right clicking on
http://cs.luc.edu/anh/python/hands-on/3.0/examples.zip and selecting “Save As” or the equivalent
on your browser and then navigate to save the archive to the chosen location on your computer. Note the
the examples, like this version of the tutorial, are for Python 3.1. There were major changes to Python in
version 3.0, making it incompatible with earlier versions.
If you are using Python version 2.5 or 2.6, you should continue with the older version of the tutorial.
Go to http://cs.luc.edu/~anh/python/hands-on and find the links to the proper version of the tutorial
and examples.
Once you have the archive, open a file browser window for that directory, right click on examples.zip,
select Extract All. This will create the folder examples. End up with a file browser window showing the
contents of the examples folder. This will be your Python folder in later discussion.
Caution 1: On Windows, files in a zip archive can be viewed while they are still in the zip archive.
Modifying and adding files is not so transparent. Be sure that you unzip the archive and work from the
regular directory that holds the resulting unzipped files.
Caution 2: Make sure that all the directories leading down to your Python examples directory do not
include any spaces in them. This will be important in Chapter 4 for the local webserver. In particular, that
means you should not place your folder under “My Documents”. A directory like C:\hands-on or C:\python
would be fine.
You also have the option of downloading
• An archive containing the web version of the tutorial http://cs.luc.edu/anh/python/hands-on/
3.0/handsonHtml.zip for local viewing, without the Internet. Download it and unzip as with the
 1.2. THE PYTHON INTERPRETER AND IDLE, PART I 7

examples. The local file to open in your browser in in handsonHtml folder you unzipped and the
main web page file to open is called handson.html.
• The PDF version of the tutorial for printing http://cs.luc.edu/anh/python/hands-on/3.0/
handson.pdf.
The disadvantage of a local copy is that the tutorial may be updated online after you get your download.
The change log file http://www.cs.luc.edu/~anh/python/hands-on/changelog.html will show when the
latest update was made and a summary of any major changes.
1.2.2. Running A Sample Program.
This section assumes Python, version at least 3.1, is already on your computer. Windows does not come
with Python. (To load Python see Section 1.1.2) On a Mac or Linux computer enough of Python comes
installed to be able to run the sample program.
If you are in a Windows lab with Python 3.1 installed, but not set up as the default version, see the
footnote.1
Before getting to the individual details of Python, you will run a simple text-based sample program.
Find madlib.py in your Python folder (Section 1.2.1).
Options for running the program:
• In Windows, you can display your folder contents, and double click on madlib.py to start the
program.
• In Linux or on a Mac you can open a terminal window, change into your python directory, and
enter the command
python madlib.py
The latter approach only works in a Windows command window if your operating system execution path is
set up to find Python.
In whatever manner you start the program, run it, responding to the prompts on the screen. Be sure to
press the enter key at the end of each response requested from you.
Try the program a second time and make different responses.
1.2.3. A Sample Program, Explained. If you want to get right to the detailed explanations of
writing your own Python, you can skip to the next section 1.2.4. If you would like an overview of a working
program, even if all the explanations do not make total sense yet, read on.
Here is the text of the madlib.py program, followed by line-by-line brief explanations. Do not worry if
you not totally understand the explanations! Try to get the gist now and the details later. The numbers on
the right are not part of the program file. They are added for reference in the comments below.
""" 1
String Substitution for a Mad Lib 2
Adapted from code by Kirby Urner 3
""" 4
5
storyFormat = """ 6
Once upon a time, deep in an ancient jungle, 7
there lived a {animal}. This {animal} 8
liked to eat {food}, but the jungle had 9
very little {food} to offer. One day, an 10
explorer found the {animal} and discovered 11
it liked {food}. The explorer took the 12
{animal} back to {city}, where it could 13
eat as much {food} as it wanted. However, 14
the {animal} became homesick, so the 15
1If an earlier version of Python is the default in your lab (for instance Python 2,6), you can open the examples folder and
double-click on the program default31.cmd. This will make Python 3.1 be the default version until you log out or reboot. This
is only actually important when you run a Python program directly from a Windows folder. You will shortly see how to start
a program from inside the Idle interactive environment, and as long as you run all your programs inside that environment, the
system default version is not important.
 1.2. THE PYTHON INTERPRETER AND IDLE, PART I 8

explorer brought it back to the jungle, 16

leaving a large supply of {food}. 17
18
The End 19
""" 20
21
def tellStory(): 22
userPicks = dict() 23
addPick(’animal’, userPicks) 24
addPick(’food’, userPicks) 25
addPick(’city’, userPicks) 26
story = storyFormat.format(**userPicks) 27
print(story) 28
29
def addPick(cue, dictionary): 30
’’’Prompt for a user response using the cue string, 31
and place the cue-response pair in the dictionary. 32
’’’ 33
prompt = ’Enter an example for ’ + cue + ’: ’ 34
response = input(prompt) 35
dictionary[cue] = response 36
37
tellStory() 38
input("Press Enter to end the program.") 39
Line By Line Explanation
""" 1
String Substitution for a Mad Lib 2
Adapted from code by Kirby Urner 3
""" 4
1-4 There is multi-line text enclosed in triple quotes. Quoted text is called a string. A string at the
very beginning of a file like this is documentation for the file.
5,21,29,37 Blank lines are included for human readability to separate logical parts. The computer ignores
the blank lines.
storyFormat = """ 6
Once upon a time, deep in an ancient jungle, 7
there lived a {animal}. This {animal} 8
liked to eat {food}, but the jungle had 9
very little {food} to offer. One day, an 10
explorer found the {animal} and discovered 11
it liked {food}. The explorer took the 12
{animal} back to {city}, where it could 13
eat as much {food} as it wanted. However, 14
the {animal} became homesick, so the 15
explorer brought it back to the jungle, 16
leaving a large supply of {food}. 17
18
The End 19
""" 20
6 The equal sign tells the computer that this is an assignment statement. The computer will now
associate the value of the expression between the triple quotes, a multi-line string, with the name
on the left, storyFormat.
7-20 These lines contain the body of the string and the ending triple quotes. This storyFormat string
contains some special symbols making it a format string, unlike the string in lines 1-4. The
 1.2. THE PYTHON INTERPRETER AND IDLE, PART I 9

storyFormat string will be used later to provide a format into which substitutions are made.
The parts of the string enclosed in braces are places a substitute string will be inserted later. The
substituted string will come from a custom dictionary that will contain the user’s definitions of
these words. The words in the braces: {animal}, {food}, {city}, indicate that "animal", "food",
and "city" are words in a dictionary. This custom dictionary will be created in the program and
contain the user’s definitions of these words. These user’s definitions will be substituted later in
the format string where each {...} is currently.
def tellStory(): 22
userPicks = dict() 23
addPick(’animal’, userPicks) 24
addPick(’food’, userPicks) 25
addPick(’city’, userPicks) 26
story = storyFormat.format(**userPicks) 27
print(story) 28
22 def is short for def inition. This line is the heading of a def inition, which makes the name
tellStory becomes def ined as a short way to refer to the sequence of statements that start
indented on line 23, and continue through line 27.
23 The equal sign tells the computer that this is another assignment statement. The computer will
now associate the name userPicks with a new empty dictionary created by the Python code
dict().
24-26 addPick is the name for a sequence of instructions defined on lines 29-31 for adding another
definition to a dictionary, based on the user’s input. The result of these three lines is to add
definitions for each of the three words ’animal’, ’food’, and ’city’ to the dictionary called userPicks.
27 Assign the name story to a string formed by substituting into storyFormat using definitions
from the dictionary userPicks, to give the user’s customized story.
28 This is where all the work becomes visible: Print the story string to the screen.
def addPick(cue, dictionary): 30
’’’Prompt for a user response using the cue string, 31
and place the cue-response pair in the dictionary. 32
’’’ 33
prompt = ’Enter an example for ’ + cue + ’: ’ 34
response = input(prompt) 35
dictionary[cue] = response 36
30 This line is the heading of a definition, which gives the name addPick as a short way to refer to
the sequence of statements indented on line 34-36. The name addPick is followed by two words
in parenthesis, cue and dictionary. These two words are associated with an actual cue word
and dictionary given when this definition is invoked in lines 24-26.
31-33 A documentation comment for the addPick definition.
34 The plus sign here is used to concatenate parts of the string assigned to the name prompt. The
current value of cue is placed into the string.
35 The right-hand-side of this equal sign causes an interaction with the user. The prompt string
is printed to the computer screen, and the computer waits for the user to enter a line of text.
That line of text then becomes a string inside the program. This string is assigned to the name
response.
36 The left-hand-side of the equal sign is a reference to the definition of the cue word in the dictionary.
The whole line ends up making the definition of the current cue word become the response typed
by the user.
tellStory() 38
input("Press Enter to end the program.") 39
38 The definition of tellStory above does not make the computer do anything besides remember
what the instruction tellStory means. It is only in this line, with the name, tellStory, followed
by parentheses, that the whole sequence of remembered instructions are actually carried out.
 1.2. THE PYTHON INTERPRETER AND IDLE, PART I 10

39 This line is only here to accommodate running the program in Windows by double clicking on its
file icon. Without this line, the story would be displayed and then the program would end, and
Windows would make it immediately disappear from the screen! This line forces the program to
continue being displayed until there is another response from the user, and meanwhile the user
may look at the output from tellStory.

1.2.4. Starting Idle.

The program that translates Python instructions and then executes them is the Python interpreter.
This interpreter is embedded in a number of larger programs that make it particularly easy to develop
Python programs. Such a programming environment is Idle, and it is a part of the standard distribution of
Python.
Read the section that follows for your operating system:

Windows (Assuming you already have Python installed.) Display your Python folder. You should see icon
for Idle31Shortcut (and maybe a similar icon with a number larger than 31 - ignore any other
unless you know you are using that version of Python). Double click on the appropriate shortcut,
and an Idle window should appear. After this the instructions are the same in any operating
environment. It is important to start Idle through these in several circumstances. It is best if
it you make it a habit to use this shortcut. For example the alternative of opening an existing
Python program in Windows XP or Vista from Open With Idle in the context menu looks like it
works at first but then fails miserably but inexplicably when you try to run a graphics program.
Mac OS X the new version of Python and Idle should be in a folder called MacPython 3.1, inside the
Applications folder. It is best if you can open a terminal window, change into your Python folder
from Section 1.2.1, and enter the command
idle
If the command is not recognized, you may need to include the full path to the idle program.
Linux The approach depends on the installation. In Ubuntu, you should fine idle in the Programming
section of the Applications menu. As with OS X above, you are better starting idle from a
terminal, with the current directory being your Python folder.

1.2.5. Windows in Idle. Idle has several parts you may choose to display, each with its own window.
Depending on the configuration, Idle can start up showing either of two windows, an Edit Window or a
Python Shell Window. You are likely to first see an Edit window, whose top left corner looks something like
in Windows:

For more on the Edit Window, see Section1.9.

If you see this Edit Window with its Run menu on top, go to the Run menu and choose PYTHON
SHELL to open a Python Shell Window for now. Then you may close the Edit Window.
Either initially, or after explicitly opening it, you should now see the Python Shell window, with a menu
like the following, though the text may be slightly different:
 1.3. WHIRLWIND INTRODUCTION TO TYPES AND FUNCTIONS 11

Look at the Python Shell. ...

In the Shell the last line should look like
>>>
The >>> is the prompt, telling you Idle is waiting for you to type something. Continuing on the same line
enter
6+3
Be sure to end with the Enter key. After the Shell responds, you should see something like
>>> 6+3
9
>>>
The shell evaluates the line you entered, and prints the result. You see Python does arithmetic. At the
end you see a further prompt >>> where you can enter your next line.... The result line, showing 9, that is
produced by the computer, does not start with “>>>”.

1.3. Whirlwind Introduction To Types and Functions

Python directly recognizes a variety of types of data. Here are a few:
Numbers: 3, 6, -7, 1.25
Character strings: ’hello’, ’The answer is: ’
Lists of objects of any type: [1, 2, 3, 4], [’yes’, ’no’, ’maybe’]
A special datum meaning nothing: None
Python has large collection of built-in functions that operate on different kinds of data to produce all kinds
of results. To make a function do its action, parentheses are required. These parentheses surround the
parameter or parameters, as in a function in algebra class.
The general syntax to execute a function is
functionName ( parameters )
One function is called type, and it returns the type of any object. The Python Shell will evaluate functions.
In the Shell the last line should look like
>>>
Continuing on the same line enter
 1.4. INTEGER ARITHMETIC 12

type(7)
Always remember to end with the Enter key. After the Shell responds, you should see something like
>>> type(7)
<class ’int’>
>>>
In the result, int is short for integer. The work class is basically a synonym for type in Python. At the end
you see a further prompt where you can enter your next line....
For the rest of this section, at the >>> prompt in the Python Shell, individually enter each line below
that is set off in typewriter font. So next enter
type(1.25)
Note the name in the last result is float, not real or decimal, coming from the term “floating point”, for
reasons that will be explained later, in Section 1.14.1. Enter
type(’hello’)
In your last result you see another abbreviation: str rather than string. Enter
type([1, 2, 3])
Strings and lists are both sequences of parts (characters or elements). We can find the length of that sequence
with another function with the abbreviated name len. Try both of the following, separately, in the Shell:
len([2, 4, 6])
len(’abcd’)
Some functions have no parameters, so nothing goes between the parentheses. For example, some types
serve as no-parameter functions to create a simple value of their type. Try
list()
You see the way an empty list is displayed.
Functions may also take more than one parameter. Try
max(5, 11, 2)
Above, max is short for maximum.
Some of the names of types serve as conversion functions (where there is an obvious meaning for the
conversion). Try each of the following, one at a time, in the Shell:
str(23)
int(’125’)
An often handy Shell feature: an earlier Shell line may to copied and edited by clicking anywhere in the
previously displayed line and then pressing Enter. For instance you should have entered several lines
starting with len. click on any one, press Enter, and edit the line for a different test.

1.4. Integer Arithmetic

1.4.1. Addition and Subtraction. We start with the integers and integer arithmetic, not because
arithmetic is exciting, but because the symbolism should be mostly familiar. Of course arithmetic is impor-
tant in many cases, but Python is probably more often used to manipulate text and other sorts of data, as
in the sample program in Section 1.2.2.
Python understands numbers and standard arithmetic. For the whole section on integer arithmetic,
where you see a set-off line in typewriter font, type individual lines at the >>> prompt in the Python
Shell. Press Enter after each line to get Python to respond:
77
2 + 3
5 - 7
Python should evaluate and print back the value of each expression. Of course the first one does not require
any calculation. It appears the shell just echoes back what you printed. Do note that the line with the value
produced by the shell does not start with >>> and appears at the left margin. Hence you can distinguish
what you type (after the “>>>” prompt) from what the computer responds.
 1.4. INTEGER ARITHMETIC 13

The Python Shell is an interactive interpreter. As you can see, after you press Enter, it is evaluating
the expression you typed in, and then printing the result automatically. This is a very handy environment
to check out simple Python syntax and get instant feedback. For more elaborate programs that you want
to save, we will switch to an Editor Window later.
1.4.2. Multiplication, Parentheses, and Precedence. Try in the Shell:
2 x 3
You should get your first syntax error. The ’x’ should have become highlighted, indicating the location where
the Python interpreter discovered that it cannot understand you: Python does not use x for multiplication
as you may have done in grade school. The x can be confused with the use of x as a variable (more on that
later). Instead the symbol for multiplication is an asterisk ’*’. Enter each of the following. You may include
spaces or not. The Python interpreter can figure out what you mean either way. Try in the Shell:
2*5
2 + 3 * 4
If you expected the last answer to be 20, think again: Python uses the normal precedence of arithmetic oper-
ations: Multiplications and divisions are done before addition and subtraction, unless there are parentheses.
Try
(2+3)*4
2 * (4 - 1)
Now try the following in the Shell, exactly as written, followed by Enter, with no closing parenthesis:
5 * (2 + 3
Look carefully. There is no answer given at the left margin of the next line and no prompt >>> to start a
new expression. If you are using Idle, the cursor has gone to the next line and has only indented slightly.
Python is waiting for you to finish your expression. It is smart enough to know that opening parentheses
are always followed by the same number of closing parentheses. The cursor is on a continuation line. Type
just the matching close-parenthesis and Enter,
)
and you should finally see the expression evaluated. (In some versions of the Python interpreter, the inter-
preter puts ’...’ at the beginning of a continuation line, rather than just indenting.)
Negation also works. Try in the Shell:
-(2 + 3)
1.4.3. Division and Remainders. If you think about it, you learned several ways to do division.
Eventually you learned how to do division resulting is a decimal. Try in the Shell:
5/2
14/4
As you saw in the previous section, numbers with decimal points in them are of type float in Python. They
are discussed more in Section 1.14.1.
In the earliest grades you would say “14 divided by 4 is 3 with a remainder of 2”. The problem here is
that the answer is in two parts, the integer quotient 3 and the remainder 2, and neither of these results is the
same as the decimal result. Python has separate operations to generate each part. Python uses the doubled
division symbol // for the operation that produces just the integer quotient, and introduces the symbol %
for the operation of finding the remainder. Try each in the Shell
14/4
14//4
14%4
Now predict and then try each of
23//5
23%5
20%5
6//8
6%8
 1.5. STRINGS, PART I 14

Finding remainders will prove more useful than you might think in the future!

1.5. Strings, Part I

Enough with numbers for a while. Strings of characters are another important type in Python.

1.5.1. String Delimiters, Part I. A string in Python is a sequence of characters. For Python to
recognize a sequence of characters, like hello, as a string, it must be enclosed in quotes to delimit the string.
For this whole section on strings, continue trying each set-off line of code in the Shell. Try
"hello"
Note that the interpreter gives back the string with single quotes. Python does not care what system you
use. Try
’Hi!’
Having the choice of delimiters can be handy.
Exercise 1.5.1.1. * Figure out how to give Python the string containing the text: I’m happy. Try it.
If you got an error, try it with another type of quotes, and figure out why that one works and not the first.
There are many variations on delimiting strings and embedding special symbols. We will consider more
ways later in Section 1.8.
A string can have any number of characters in it, including 0. The empty string is ’’ (two quote
characters with nothing between them).
Strings are a new Python type. Try
type(’dog’)
type(’7’)
type(7)
The last two lines show how easily you can get confused! Strings can include any characters, including digits.
Quotes turn even digits into strings. This will have consequences in the next section....

1.5.2. String Concatenation. Strings also have operation symbols. Try in the Shell (noting the space
after very):
’very ’ + ’hot’
The plus operation with strings means concatenate the strings. Python looks at the type of operands before
deciding what operation is associated with the +.
Think of the relation of addition and multiplication of integers, and then guess the meaning of
3*’very ’ + ’hot’
Were you right? The ability to repeat yourself easily can be handy.
Exercise 1.5.2.1. * Figure out a compact way to get Python to make the string, “YesYesYesYesYes”,
and try it. How about “MaybeMaybeMaybeYesYesYesYesYes” ? Hint: 2
Predict the following and then test. Remember the last section on types:
7+2
’7’+’2’
Python checks the types and interprets the plus symbol based on the type. Try
’7’+2
With mixed string and int types, Python sees an ambiguous expression, and does not guess which you want
– it just gives an error! 3

2Hint for the second one: use two *’s and a +.

3Be careful if you are a Java programmer! This is unlike Java, where the 2 would be automatically converted to ’2’ so the
concatenation would make sense.
 1.6. VARIABLES AND ASSIGNMENT 15

1.6. Variables and Assignment

Each set-off line in this section should be tried in the Shell.
Try
width = 10
Nothing is displayed by the interpreter after this entry, so it is not clear anything happened. Something has
happened. This is an assignment statement, with a variable, width, on the left. A variable is a name for a
value. An assignment statement associates a variable name on the left of the equal sign with the value of an
expression calculated from the right of the equal sign. Enter
width
Once a variable is assigned a value, the variable can be used in place of that value. The response to the
expression width is the same as if its value had been entered.
The interpreter does not print a value after an assignment statement because the value of the expression
on the right is not lost. It can be recovered if you like, by entering the variable name and we did above.
Try each of the following lines:
height = 12
area = width * height
area
The equal sign is an unfortunate choice of symbol for assignment, since Python’s usage is not the mathemati-
cal usage of the equal sign. If the symbol ←had appeared on keyboards in the early 1990’s, it would probably
have been used for assignment instead of =, emphasizing the asymmetry of assignment. In mathematics an
equation is an assertion that both sides of the equal sign are already, in fact, equal. A Python assignment
statement forces the variable on the left hand side to become associated with the value of the expression on
the right side. The difference from the mathematical usage can be illustrated. Try:
10 = width
so this is not equivalent in Python to width = 10. The left hand side must be a variable, to which the
assignment is made. Try
width = width + 5
This is, of course, nonsensical as mathematics, but it makes perfectly good sense as an assignment, with the
right-hand side calculated first. Can you figure out the value that is now associated with width? Check by
entering
width
In the assignment statement, the expression on the right is evaluated first. At that point width was associated
with its original value 10, so width + 5 had the value of 10 + 5 which is 15. That value was then assigned
to the variable on the left (width again) to give it a new value. We will modify the value of variables in a
similar way routinely.
Assignment and variables work equally well with strings. Try:
first = ’Sue’
last = ’Wong’
name = first + ’ ’ + last
name
Try entering:
first = fred
Note the different form of the error message. The earlier errors in these tutorials were syntax errors: errors in
translation of the instruction. In this last case the syntax was legal, so the interpreter went on to execute the
instruction. Only then did it find the error described. There are no quotes around fred, so the interpreter
assumed fred was an identifier, but the name fred was not defined at the time the line was executed.
It is easy to forget quotes where you need them and put them around a variable name that should not
have them!
Try in the Shell:
 1.7. PRINT FUNCTION, PART I 16

fred = ’Frederick’
first = fred
first
Now fred, without the quotes, makes sense.
There are more subtleties to assignment and the idea of a variable being a “name for” a value, but we
will worry about them later, in Section 2.4.6. They do not come up if our variables are just numbers and
strings.
Autocompletion: A handy short cut. Python remembers all the variables you have defined at any moment.
This is handy when editing. Without pressing Enter, type into the Shell just
f
Then hold down the Alt key and press the ’/’ key. This key combination is abbreviated Alt-/. You
should see f autocompleted to be first. This is particularly useful if you have long identifiers! You can
press Alt-/ several times if more than one identifier starts with the initial sequence of characters you typed.
If you press Alt-/ again you should see fred. Backspace and edit so you have fi, and then and press Alt-/
again. You should not see fred this time, since it does not start with fi.

1.6.1. Literals and Identifiers. Expressions like 27 or ’hello’ are called literals, coming from the
fact that they literally mean exactly what they say. They are distinguished from variables, who value is not
directly determined by their name.
The sequence of characters used to form a variable name (and names for other Python entities later) is
called an identifier. It identifies a Python variable or other entity.
There are some restrictions on the character sequence that make up an identifier:
• The characters must all be letters, digits, or underscores ’_’, and must start with a letter. In
particular, punctuation and blanks are not allowed.
• There are some words that are reserved for special use in Python. You may not use these words
as your own identifiers. They are easy to recognize in Idle, because they are automatically colored
orange. For the curious, you may read the full list:
False class finally is return
None continue for lambda try
True def from nonlocal while
and del global not with
as elif if or yield
assert else import pass
break except in raise
There are also identifiers that are automatically defined in Python, and that you could redefine, but you
probably should not unless you really know what you are doing! When you start the editor, we will see how
Idle uses color to help you know what identifies are predefined.
Python is case sensitive: The identifiers last, LAST, and LaSt are all different. Be sure to be consistent.
Using the Alt-/ auto-completion shortcut in Idle helps ensure you are consistent.
What is legal is distinct from what is conventional or good practice or recommended. Meaningful
names for variables are important for the humans who are looking at programs, understanding them,
and revising them. That sometimes means you would like to use a name that is more than one word
long, like price at opening, but blanks are illegal! One poor option is just leaving out the blanks, like
priceatopening. Then it may be hard to figure out where words split. Two practical options are
• underscore separated: putting underscores (which are legal) in place of the blanks, like price_at_opening.
• using camelcase: omitting spaces and using all lowercase, except capitalizing all words after the
first, like priceAtOpening
Use the choice that fits your taste (or the taste or convention of the people you are working with).

1.7. Print Function, Part I

In interactive use of the Python interpreter, you can type an expression and immediately see the result
of its evaluation. This is fine to test out syntax and maybe do simple calculator calculations. In a program
 1.9. THE IDLE EDITOR AND EXECUTION 17

run from a file like the first sample program, Python does not display expressions this way. If you want your
program to display something, you can give explicit instructions with the print function. Try in the Shell:
x = 3
y = 5
print(’The sum of’, x, ’plus’, y, ’is’, x+y)
The print function will prints as strings everything in a comma-separated sequence of expressions, and it
will separate the results with single blanks by default. Note that you can mix types: anything that is not
already a string is automatically converted to its string representation.
You can also use it with no parameters:
print()
to just advance to the next line.

1.8. Strings Part II

1.8.1. Triple Quoted String Literals. Strings delimited by one quote character are required to lie
within a single Python line. It is sometimes convenient to have a multi-line string, which can be delimited
with triple quotes: Try typing the following. You will get continuation lines until the closing triple quotes.
Try in the Shell:
sillyTest = ’’’Say,
"I’m in!"
This is line 3’’’
print(sillyTest)
The line structure is preserved in a multi-line string. As you can see, this also allows you to embed both
single and double quote characters!

1.8.2. Escape Codes. Continuing in the Shell with sillyTest, enter just
sillyTest
The answer looks strange! It indicates an alternate way to encode the string internally in Python using escape
codes. Escape codes are embedded inside string literals and start with a backslash character (\). They are
used to embed characters that are either unprintable or have a special syntactic meaning to Python that
you want to suppress. In this example you see the most common ones:
Escape code Meaning
\’ ’
\n newline
\\ \
The newline character indicates further text will appear on a new line when printed. When you use a
print function, you get the actual printed meaning of the escaped coded character.
Predict the result, and try in the Shell:
print(’a\nb\n\nc’)
Did you guess the right number of lines splitting in the right places?

1.9. The Idle Editor and Execution

1.9.1. Loading a Program in the Idle Editor, and Running It. It is time to put longer collections
of instructions together. That is most easily done by creating a text file and running the Python interpreter
on the file. Idle simplifies that process.
First you can put an existing file into an Idle Edit Window. Click on the Idle File menu and select Open.
(Or as you see, you can use the shortcut Ctrl+O. That means holding down the Ctrl key, and pressing the
letter O for Open.) You should get a file selection dialog. You should have the sample program madlib.py
displayed in the list. Select it and open it. (If you do not see the program, then you either failed to download
the example programs, Section 1.2.1, or you did not start Idle in the proper folder, Section 1.2.4.)
You will see the source code again. Now run this program from inside of Idle: Go to the Run menu of
that Edit window, and select Run Module. Notice the shortcut (F5).
 1.9. THE IDLE EDITOR AND EXECUTION 18

If the Shell window does not automatically come to the foreground, select it. You should see a line
saying “RESTART” and then the start of the execution of the Mad Lib program with the cursor waiting for
your entry after the first prompt. Finish executing the program. Be sure to type the final requested Enter,
so you get back to the interpreter prompt: >>>
Look at the editor window again. You should see that different parts of the code have different colors.
String literals are likely green. The reserved words def are likely orange. Look at the last two lines, where
the identifier tellStory is black, and the identifier input is likely purple. Only identifiers that are not
predefined by Python are black. If you create an identifier name, make sure Idle shows it in black.

1.9.2. A Bug Possible When Restarting Program Execution in Idle. When you execute a
program from the Idle Editor, the interpreter gives a banner saying “RESTART”, meaning that all the
things you defined in any shell session so far are wiped clean and the program you are running starts fresh.
There is one egregious exception to that, that was still present at least in the version of Idle for Python 3.1
in Windows. We will try to demonstrate the bug. (A bug is an error in a program.)
Start running the Mad Lib program again by going to the Editor Window containing madlib.py, and
start running the program again, but do not continue....
You should see a prompt for user input generated by the program. Ignore this prompt and go back to
the Edit Window and start the Mad Lib program again.
If this bug is still present, you should see a difference in this restart: This time after the RESTART
banner and the interpreter prompt: >>>, which looks innocent enough, but this program should show the
program’s prompt string for input.
The problem only comes up because you interrupted the last execution when user input was being waited
for. The restart was not complete here: The system is still looking for the pending user input from the last
execution.
The fix is simple: Make sure the Interpreter Window is the currently selected window, and press return
to terminate the lost user input. In some circumstances, you may need to press return a second time.
After that the program should start up normally with its prompt.
Watch out for this behavior, and remember the fix.

1.9.3. The Classic First Program . Make sure you have Idle started in your Python directory (in
Windows with the provided Idle shortcut link), where you will store program files. (Do not start Idle from
the Windows Start Menu!) If you just started Idle now, you may already have a blank Edit Window in
front of you. If not, open a new window by going to the File menu and selecting New Window. This gives
you a rather conventional text editing window with the mouse available, ability to cut and paste, plus a few
special options for Python.
Type (or paste) the following into the editor window:
print(’Hello world!’)
Save the file with the File menu -> Save, and then enter the file name hello.py. Python program files
should always be given a name ending in ".py", and you must enter the .py extension explicitly .
If you look in the editor, you should see that your text is color coded. The editor will color different
parts of Python syntax in special colors. (In version 2.4 of Python, the coloring only happens after you save
your file with the ’.py’ ending.)
Now that you have a complete, saved program, choose Run menu -> Run Module. You should see the
program run in the Python Shell window.
You just wrote and executed a program. Unlike when you use the shell, this code is saved to a file in
your Python folder. You can open and execute the file any time you want. (In Idle, use File->Open.)
To the interpreter, a program source file corresponds to a Python module. We will tend to use the more
general term: a program file is a module. Note the term from the menu when running the program.
Distinguish program code from Shell text: It is easy to confuse the Shell and the Edit windows. Make
sure you keep them straight. The hello.py program is just the line
print(’Hello world!’)
that you typed into the edit window and saved. When you ran the program in Idle, you saw results in the
Shell. First came the Restart notice, the one-line output from the program saying hello, and a further Shell
prompt:
 1.10. INPUT AND OUTPUT 19

>>> ================================ RESTART ========

>>>
Hello world!
>>>
You could also have typed this single printing line directly in the Shell in response to a Shell prompt. When
you see >>>, you could enter the print function and get the exchange between you and the Shell:
>>> print(’Hello world’)
Hello world!
>>>
The three lines above are not a program you could save in a file and run. This is just an exchange in the
Shell, with its >>> prompts, individual line to execute and the response. Again, just the single line, with no
>>>,
print(’Hello world!’)
entered into the Edit window forms a program you can save and run. We will shortly get to more interesting
many-statement programs, where it is much more convenient to use the Edit window than the Shell!

1.9.4. Program Documentation String. The program above is self evident, and shows how short
and direct a program can be (unlike other languages like Java). Still, right away, get used to documenting
a program. Python has a special feature: If the beginning of a program is just a quoted string, that string
is taken to be the program’s documentation string. Open the example file hello2.py in the Edit window:
’’’A very simple program,
showing how short a Python program can be!
Authors: ___, ___
’’’

print(’Hello world!’) #This is a stupid comment after the # mark

Most commonly, the initial documentation goes on for several lines, so a multi-line string delimiter is used
(the triple quotes). Just for completeness of illustration in this program, another form of comment is
also shown, a comment that starts with the symbol # and extends to the end of the line. The Python
interpreter completely ignores this form of comment. Such a comment should only be included for better
human understanding. Avoid making comments that do not really aid human understanding. (Do what I
say, not what I did above.) Good introductory comment strings and appropriate names for the parts of your
programs make fewer # symbol comments needed.
Run the program and see the documentation and comment make no difference in the result.

1.9.5. Screen Layout. Of course you can arrange the windows on your computer screen any way that
you like. A suggestion as you start to use the combination of the editor to write, the shell to run, and the
tutorial to follow along: Make all three mostly visible your computer screen at once. Drag the editor window
to the upper left. Place the Shell window to the lower left, and perhaps reduce its height a bit so there is not
much overlap. If you are looking at the web version of the tutorial on the screen, make it go top to bottom
on the right, but not overlap the Idle windows too much. The web page rendering should generally adapt
to the width pretty well. You can always temporarily maximize the window. Before resizing the browser
window, it is good to look for an unusual phrase on your page, and search for it after resizing, since resizing
can totally mess up your location in the web page.
There is an alternative to maximization for the Idle editor window: It you want it to go top to bottom
of the screen but not widen, you can toggle that state with Alt-2. Play with all this.

1.10. Input and Output

1.10.1. The input Function. The hello program of Section 1.9.3 always does the same thing. This is
not very interesting. Programs are only going to be reused if they can act on a variety of data. One way to
get data is directly from the user. Modify the hello.py program as follows in the editor, and save it from the
File menu with Save As...., using the name hello_you.py.
 1.10. INPUT AND OUTPUT 20

person = input(’Enter your name: ’)

print(’Hello’, person)
Run the program. In the Shell you should see
Enter your name:
Follow the instruction (and press Enter). Make sure the typing cursor is in the Shell window, at the end
of this line. After you type your response, you can see that the program has taken in the line you typed.
That is what the built-in function input does: First it prints the string you give as a parameter (in this case
’Enter your name: ’), and then it waits for a line to be typed in, and returns the string of characters
you typed. In the hello_you.py program this value is assigned to the variable person, for use later.
The parameter inside the parentheses after input is important. It is a prompt, prompting you that
keyboard input is expected at that point, and hopefully indicating what is being requested. Without the
prompt, the user would not know what was happening, and the computer would just sit there waiting!
Open the example program, interview.py. Before running it (with any made-up data), see if you can
figure out what it will do:
’’’Illustrate input and print.’’’

applicant = input("Enter the applicant’s name: ")

interviewer = input("Enter the interviewer’s name: ")
time = input("Enter the appointment time: ")
print(interviewer, "will interview", applicant, "at", time)
The statements are executed in the order they appear in the text of the program: sequentially. This is the
simplest way for the execution of the program to flow. You will see instructions later that alter that natural
flow.
If we want to reload and modify the hello_you.py program to put an exclamation point at the end,
you could try:
person = input(’Enter your name: ’)
print(’Hello’, person, ’!’)
Run it and you see that it is not spaced right. There should be no space after the person’s name, but the
default behavior of the print function is to have each field printed separated by a space. There are several
ways to fix this. You should know one. Think about it before going on to the next section. Hint: 4
1.10.2. Print with Keyword Parameter sep. One way to put punctuation but no space after the
person in hello_you.py is to use the plus operator, +. Another approach is to change the default separatpr
between fields in the print function. This will introduce a new syntax feature, keyword parameters. The
print function has a keyword parameter named sep. If you leave it out of a call to print, as we have so far,
it is set equal to a space by default. If you add a final field, sep=”, in the print function in hello_you.py,
you get the following example file, hello_you2.py:
person = input(’Enter your name: ’)
print(’Hello ’, person, ’!’, sep=’’)
Try the program.
Keyword paramaters must be listed at the end of the parameter list.
1.10.3. Numbers and Strings of Digits. Consider the following problem: Prompt the user for two
numbers, and then print out a sentence stating the sum. For instance if the user entered 2 and 3, you would
print “The sum of 2 and 3 is 5.”
You might imagine a solution like the example file addition1.py, shown below. There is a problem.
Can you figure it out before you try it? Hint: 5 End up running it in any case.
x = input("Enter an integer: ")
y = input("Enter another integer: ")
print(’The sum of ’, x, ’ and ’, y, ’ is ’, x+y, ’.’, sep=’’) # error!

4The + operation on strings adds no extra space.

5The input function produces values of string type.
 1.10. INPUT AND OUTPUT 21

We do not want string concatenation, but integer addition. We need integer operands. Briefly mentioned in
Section 1.3 was the fact that we can use type names as functions to convert types. One approach would be
to do that. Further variable names are also introduced in the example addition2.py file below to emphasize
the distinctions in types. Read and run:
’’’Conversion of strings to int before addition’’’

xString = input("Enter an integer: ")

x = int(xString)
yString = input("Enter another integer: ")
y = int(yString)
print(’The sum of ’, x, ’ and ’, y, ’ is ’, x+y, ’.’, sep=’’)
Needing ito convert string input to numbersis a common situation, both with keyboard input and later in
web pages. While the extra variables above emphasized the steps, it is more concise to write as in the
variation in example file, addition3.py, doing the conversons to type int immediately:
’’’Two numeric inputs’’’

x = int(input("Enter an integer: "))

y = int(input("Enter another integer: "))
print(’The sum of ’, x, ’ and ’, y, ’ is ’, x+y, ’.’, sep=’’)
The simple programs so far have followed a basic programming pattern: input-calculate-output. Get all the
data first, calculate with it second, and output the results last. The pattern sequence would be even clearer
if we explicitly create a named result variable in the middle, as in addition4.py:
x = int(input("Enter an integer: "))
y = int(input("Enter another integer: "))
sum = x + y
print(’The sum of ’, x, ’ and ’, y, ’ is ’, sum, ’.’, sep=’’)
We will see more complicated patterns, which involve repetition, in the future.
Exercise 1.10.3.1. * Write a version, add3.py, that asks for three numbers, and lists all three, and
their sum, in similar format to the example above.
Exercise 1.10.3.2. * a. Write a program, quotient.py, that prompts the user for two integers, and
then prints them out in a sentence with an integer division problem like "The quotient of 14 and 3 is
4 with a remainder of 2". Review Section 1.4.3 if you forget the integer division or remainder operator.
1.10.4. String Format Operation. A common convention is fill-in-the blanks. For instance,
Hello _____!
and you can fill in the name of the person greeted, and combine given text with a chosen insertion. Python has
a similar construction, better called fill-in-the-braces. There is a particular operation on strings called format,
that makes substitutions into places enclosed in braces. For instance the example file, hello_you3.py, creates
and prints the same string as in hello_you2.py from the previous section:
person = input(’Enter your name: ’)
greeting = ’Hello {}!’.format(person)
print(greeting)
There are several new ideas here!.
First method calling syntax is used. You will see in this more detail at the beginning of the next chapter.
Strings and other objects have a special syntax for functions, called methods, associated with the particular
type of object. In particular str objects have a method called format. The syntax for methods has the
object followed by a period followed by the method name, and further parameters in parentheses.
object.methodname(paramters)
In the example above, the object is the string ’Hello {}!’. The method is named format. There is
one further parameter, person.
The string has a special form, with braces embedded. Places where braces are embedded are replaced by
the value of an expression taken from the parameter list for the format method. There are many variations
 1.10. INPUT AND OUTPUT 22

on the syntax between the braces. In this case we use the syntax where the first (and only) location in the
string with braces has a substitution made from the first (and only) parameter
In the code above, this new string is assigned to the identifier greeting, and then the string is printed.
The identifier greeting was introduced to break the operations into a clearer sequence of steps. Since the
value of greeting is only referenced once, it can be eliminated with the more concise version:
person = input(’Enter your name: ’)
print(’Hello {}!’.format(person))
Consider the interview program. Suppose we want to add a period at the end of the sentence (with no space
before it). One approach would be to combine everything with plus signs. Another way is printing with
keyword sep=’’. Another approach is with string formating. Here the idea is to fill in the blanks in
_____ will interview _____ at _____.
There are multiple places to substiitute, and the format approach can be extended to multiple substitutions:
Each place in the format string where there is ’{}’, the format operation will substitute the value of the
next parameter in the format parameter list.
Run the example file interview2.py, and check that the results from all three methods match.
’’’Compare different approaches to printing with embedded values.’’’

applicant = input("Enter the applicant’s name: ")

interviewer = input("Enter the interviewer’s name: ")
time = input("Enter the appointment time: ")
print(interviewer + ’ will interview ’ + applicant + ’ at ’ + time +’.’)
print(interviewer, ’ will interview ’, applicant, ’ at ’, time, ’.’, sep=’’)
print(’{} will interview {} at {}.’.format(interviewer, applicant, time))

A technical point: Since braces have special meaning in a format string, there must be a special rule if
you want braces to actually be included in the final formatted string. The rule is to double the braces:
’{{’ and ’}}’. The example code formatBraces.py, shown below, makes setStr refer to the string
’The set is {5, 9}.’. The initial and final doubled braces in the format string generate literal braces in
the formatted string:
a = 5
b = 9
formatStr = ’The set is {{{}, {}}}.’
setStr = formatStr.format(a, b)
print(setStr)
This kind of format string depends directly on the order of the parameters to the format method. There
is another approach with a dictionary, that was used in the first sample program, and will be discussed
more in Section 1.12.2 on dictionaries. The dictionary approach is probably the best in many cases, but the
count-based approach is an easier start, particularly if the parameters are just used once, in order.
(Optional elaboration) Imagine the format parmaters numbered in order, starting from 0. In this
case 0, 1, and 2. The number of the parameter position may be included inside the braces, so an alternative
to the last line of interview2.py is (added in example file interview3.py):

print(’{0} will interview {1} at {2}.’.format(interviewer, applicant, time))

This is more verbose than the previous version, with no obvious advantage. If you desire to use some of
the parameters more than once, then the approach with the numerical identification with the parameters is
useful. Every place the string includes ’{0}’, the format operation will substitute the value of the initial
parameter in the list. Wherever ’{1}’ appears, the next format parameter will be substituted....
Predict the results of the example file arith.py shown below,and then check yourself by running it. In
this case the numbers referring to the parameter positions are necessary. They are both repeated and used
out of order:
’’’Fancier format string example.’’’
 1.11. DEFINING FUNCTIONS OF YOUR OWN 23

x = 20
y = 30
formatStr = ’{0} + {1} = {2}; {0} * {1} = {3}.’
equations = formatStr.format(x, y, x+y, x*y)
print(equations)
Try the program.

Exercise 1.10.4.1. * Write a version of Exercise 1.10.3.1, add3f.py, that uses the string format method
to construct the final string.
Exercise 1.10.4.2. * Write a version of Exercise 1.10.3.2, quotientformat.py, that uses the string
format method to construct the final string.

1.11. Defining Functions of your Own

1.11.1. Syntax Template Typography. When new Python syntax is introduced, the usual approach
will be to give both specific examples and general templates. In general templates for Python syntax the
typeface indicates the the category of each part:
Typeface Meaning
Typewriter font Text to be written verbatim
Emphasized A place where you can use an arbitrary identifier. The emphasized text attempts to
be descriptive of the meaning of the identifier in the current context.
Normal text A description of what goes in that position, without giving explicit syntax
We will use these conventions shortly in the discussion of function syntax, and will continue to use the
conventions throughout the tutorial.
1.11.2. A First Function Definition. If you know it is the birthday of a friend, Emily, you might
tell those gathered with you to sing "Happy Birthday to Emily".
We can make Python display the song. Read, and run if you like, the example program birthday1.py:
print("Happy Birthday to you!")
print("Happy Birthday to you!")
print("Happy Birthday, dear Emily.")
print("Happy Birthday to you!")
You would probably not repeat the whole song to let others know what to sing. You would give a request
to sing via a descriptive name like "Happy Birthday to Emily".
In Python we can also give a name like happyBirthdayEmily, and associate the name with whole song
by using a function definition. We use the Python def keyword, short for define.
Read for now:
def happyBirthdayEmily():
print("Happy Birthday to you!")
print("Happy Birthday to you!")
print("Happy Birthday, dear Emily.")
print("Happy Birthday to you!")
There are several parts of the syntax for a function definition to notice:
The heading contains def, the name of the function, parentheses, and finally a colon.
def function_name():
The remaining lines form the function body and are indented by a consistent amount. (The exact amount is
not important to the interpreter, though 2 or 4 spaces are common conventions.)
The whole definition does just that: defines the meaning of the name happyBirthdayEmily, but it does
not do anything else yet – for example, the definition itself does not make anything be printed yet. This is
our first example of altering the order of execution of statements from the normal sequential order. This is
important: the statements in the function definition are not executed as Python first passes over the lines.
The code above is in example file birthday2.py. Load it in Idle and execute it from there. Nothing
should happen visibly. This is just like defining a variable: Python just remembers the function definition
 1.11. DEFINING FUNCTIONS OF YOUR OWN 24

for future reference. After Idle finished executing a program, however, its version of the Shell remembers
function definitions from the program.
In the Idle Shell (not the editor), enter
happyBirthdayEmily
The result probably surprises you! When you give the Shell an identifier, it tells you its value. Above,
without parentheses, it identifies the function code as the value (and gives a location in memory of the
code). Now try the name in the Idle Shell with parentheses added:
happyBirthdayEmily()
The parentheses tell Python to execute the named function rather than just refer to the function. Python
goes back and looks up the definition, and only then, executes the code inside the function definition. The
term for this action is a function call or function invocation. Note, in the function call there is no def, but
there is the function name followed by parentheses.
function_name()
In many cases we will use a feature of program execution in Idle: that after program execution is completed,
the Idle Shell still remembers functions defined in the program. This is not true if you run a program by
selecting it directly in the operating system. The general assumption in this Tutorial will be that programs
are run in Idle and the Idle Shell is the Shell referred to. It will be explicitly stated when you should run a
program directly from the operating system. (With most of the examples in the tutorial, running from the
operating system is OK – the execution method will not actually matter.)
Look at the example program birthday3.py. See it just adds two more lines, not indented. Can you
guess what it does? Try it:
def happyBirthdayEmily(): #1
print("Happy Birthday to you!") #2
print("Happy Birthday to you!") #3
print("Happy Birthday, dear Emily.") #4
print("Happy Birthday to you!") #5

happyBirthdayEmily() #6
happyBirthdayEmily() #7
The execution sequence is different from the textual sequence:
(1) Lines 1-5: Python starts from the top, reading and remembering the definition. The definition ends
where the indentation ends. (The code also shows a blank line there, but that is only for humans,
to emphasize the end of the definition.)
(2) Line 6: this is not indented inside any definition, so the interpreter executes it directly, calling
happyBirthdayEmily() while remembering where to return.
(3) Lines 1-5: The code of the function is executed for the first time, printing out the song.
(4) End of line 6: Back from the function call. continue on.
(5) Line 7: the function is called again while this location is remembered.
(6) Lines 1-5: The function is executed again, printing out the song again.
(7) End of line 7: Back from the function call, but at this point there is nothing more in the program,
and execution stops.
Functions alter execution order in several ways: by statements not being executed as the definition is first
read, and then when the function is called during execution, jumping to the function code, and back at the
the end of the function execution.
If it also happens to be Andre’s birthday, we might define a function happyBirthdayAndre, too. Think
how to do that before going on ....

1.11.3. Multiple Function Definitions. Here is example program birthday4.py where we add a
function happyBirthdayAndre, and call them both. Guess what happens, and then try it:
def happyBirthdayEmily(): # same old function
print("Happy Birthday to you!")
print("Happy Birthday to you!")
 1.11. DEFINING FUNCTIONS OF YOUR OWN 25

print("Happy Birthday, dear Emily.")

print("Happy Birthday to you!")

def happyBirthdayAndre():
print("Happy Birthday to you!")
print("Happy Birthday to you!")
print("Happy Birthday, dear Andre.")
print("Happy Birthday to you!")

happyBirthdayEmily()
happyBirthdayAndre()
Again, everything is definitions except the last two lines. They are the only lines executed directly. The
calls to the functions happen to be in the same order as their definitions, but that is arbitrary. If the last
two lines were swapped, the order of operations would change. Do swap the last two lines so they appear as
below, and see what happens when you execute the program:
happyBirthdayAndre()
happyBirthdayEmily()
Functions that you write can also call other functions you write. It is a good convention to have the main
action of a program be in a function for easy reference. The example program birthday5.py has the two
Happy Birthday calls inside a final function, main. Do you see that this version accomplishes the same thing
as the last version? Run it.
def happyBirthdayEmily(): #1
print("Happy Birthday to you!") #2
print("Happy Birthday to you!") #3
print("Happy Birthday, dear Emily.") #4
print("Happy Birthday to you!") #5

def happyBirthdayAndre(): #6
print("Happy Birthday to you!") #7
print("Happy Birthday to you!") #8
print("Happy Birthday, dear Andre.") #9
print("Happy Birthday to you!") #10

def main(): #11

happyBirthdayAndre() #12
happyBirthdayEmily() #13

main() #14
If we want the program to do anything automatically when it is runs, we need one line outside of definitions!
The final line is the only one directly executed, and it calls the code in main, which in turn calls the code in
the other two functions.
Detailed order of execution:
(1) Lines 1-13: Definitions are read and remembered
(2) Line 14: The only line outside definitions, is executed directly. This location is remembered as
main is executed.
(3) Line 11: Start on main
(4) Line 12. This location is remembered as execution jumps to happyBirthdayAndre
(5) Lines 6-10 are executed and Andre is sung to.
(6) Return to the end of Line 12: Back from happyBirthdayAndre function call
(7) Line 13: Now happyBirthdayEmily is called as this location is remembered.
(8) Lines 1-5: Sing to Emily
(9) Return to the end of line 13: Back from happyBirthdayEmily function call, done with main
(10) Return to the end of line 14: Back from main; at the end of the program
 1.11. DEFINING FUNCTIONS OF YOUR OWN 26

There is one practical difference from the previous version. After execution, if we want to give another round
of Happy Birthday to both persons, we only need to enter one further call in the Shell to:
main()
As a simple example emphasizing the significance of a line being indented, guess what the the example file
order.py does, and run it to check:
def f():
print(’In function f’)
print(’When does this print?’)
f()
Modify the file so the second print function is outdented like below. What should happen now? Try it:
def f():
print(’In function f’)
print(’When does this print?’)
f()
The lines indented inside the function definition are remembered first, and only executed when the function
f is invoked at the end. The lines outside any function definition (not indented) are executed in order of
appearance.
Exercise 1.11.3.1. * Write a program, poem.py, that defines a function that prints a short poem or
song verse. Give a meaningful name to the function. Have the program end by calling the function three
times, so the poem or verse is repeated three times.
1.11.4. Function Parameters. As a young child, you probably heard Happy Birthday sung to a
couple of people, and then you could sing to a new person, say Maria, without needing to hear the whole
special version with Maria’s name in it word for word. You had the power of abstraction. With examples
like the versions for Emily and Andre, you could figure out what change to make it so the song could be
sung to Maria!
Unfortunately, Python is not that smart. It needs explicit rules. If you needed to explain explicitly to
someone how Happy Birthday worked in general, rather than just by example, you might say something like
this:
First you have to be given a person’s name. Then you sing the song with the person’s name inserted at
the end of the third line.
Python works something like that, but with its own syntax. The term “person’s name” serves as a
stand-in for the actual data that will be used, “Emily”, “Andre”, or “Maria”. This is just like the association
with a variable name in Python. “person’s name” is not a legal Python identifier, so we will use just person
as this stand-in.
The function definition indicates that the variable name person will be used inside the function by
inserting it between the parentheses of the definition. Then in the body of the definition of the function,
person is used in place of the real data for any specific person’s name. Read and then run example program
birthday6.py:
def happyBirthday(person): #1
print("Happy Birthday to you!") #2
print("Happy Birthday to you!") #3
print("Happy Birthday, dear " + person + ".") #4
print("Happy Birthday to you!") #5

happyBirthday(’Emily’) #6
happyBirthday(’Andre’) #7
In the definition heading for happyBirthday, person is referred to as a parameter, or a formal parameter.
This variable name is a placeholder for the real name of the person being sung to.
The last two lines of the program, again, are the only ones outside of definitions, so they are the only
ones executed directly. There is now an actual name between the parentheses in the function calls. The value
between the parentheses here in the function call is referred to as an argument or actual parameter of the
function call. The argument supplies the actual data to be used in the function execution. When the call is
 1.11. DEFINING FUNCTIONS OF YOUR OWN 27

made, Python does this by associating the formal parameter name person with the actual parameter data,
as in an assignment statement. In the first call, this actual data is ’Emily’. We say the actual parameter
value is passed to the function.
The execution in greater detail:
(1) Lines 1-5: Definition remembered
(2) Line 6: Call to happyBirthday, with actual parameter ’Emily’.
(3) Line 1: ’Emily’ is passed to the function, so person = ’Emily’
(4) Lines 2-5: The song is printed, with ’Emily’ used as the value of person in line 4: printing ’Happy
birthday, dear Emily.’
(5) End of line 6: Return from the function call and continue
(6) Line 7: Call to happyBirthday, this time with actual parameter ’Andre’
(7) Line 1: ’Andre’ is passed to the function, so person = ’Andre’
(8) Lines 2-5: The song is printed, with ’Andre’ used as the value of person in line 4: printing ’Happy
birthday, dear Andre.’
(9) End of line 7: Return from the function call, and the program is over.
The beauty of this system is that the same function definition can be used for a call with a different actual
parameter variable, and then have a different effect. The value of the variable person is used in the third
line of happyBirthday, to put in whatever actual parameter value was given.
This is the power of abstraction. It is one application of the most important principal in programming.
Rather than have a number of separately coded parts with only slight variations, see where it is appropriate to
combine them using a function whose parameters refer to the parts that are different in different situations.
Then the code is written to be simultaneously appropriate for the separate specific situations, with the
substitutions of the right parameter values.
You can go back to having a main function again, and everything works. Run birthday7.py:
def happyBirthday(person):
print("Happy Birthday to you!")
print("Happy Birthday to you!")
print("Happy Birthday, dear " + person + ".")
print("Happy Birthday to you!")

def main():
happyBirthday(’Emily’)
happyBirthday(’Andre’)

main()
Exercise 1.11.4.1. * Make your own further change to the file and save it as birthdayMany.py: Add a
function call, so Maria gets a verse, in addition to Emily and Andre. Also print a blank line between verses.
(You may either do this by adding a print line to the function definition, or by adding a print line between
all calls to the function.)
We can combine function parameters with user input, and have the program be able to print Happy Birthday
for anyone. Check out the main method and run birthday_who.py:
def happyBirthday(person):
print("Happy Birthday to you!")
print("Happy Birthday to you!")
print("Happy Birthday, dear " + person + ".")
print("Happy Birthday to you!")

def main():
userName = input("Enter the Birthday person’s name: ")
happyBirthday(userName)

main()
 1.11. DEFINING FUNCTIONS OF YOUR OWN 28

This last version illustrates several important ideas:

(1) There are more than one way to get information into a function:
(a) Have a value passed in through a parameter.
(b) Prompt the user, and obtain data from the keyboard.
(2) It is a good idea to separate the internal processing of data from the external input from the user
by the use of distinct functions. Here the user interaction is in main, and the data is manipulated
in happyBirthday.
(3) In the first examples of actual parameters, we used literal values. In general an actual parameter
can be an expression. The expression is evaluated before it is passed in the function call. One of the
simplest expressions is a plain variable name, which is evaluated by replacing it with its associated
value. Since it is only the value of the actual parameter that is passed, not any variable name,
there is no need to have an actual parameter variable name match a formal parameter name. (Here
we have the value of userName in main becoming the value of person in happyBirthday.)

1.11.5. Multiple Function Parameters. A function can have more than one parameter in a param-
eter list separated by commas. Here the example program addition5.py uses a function to make it easy to
display many sum problems. Read and follow the code, and then run:
def sumProblem(x, y):
sum = x + y
print(’The sum of ’, x, ’ and ’, y, ’ is ’, sum, ’.’, sep=’’)

def main():
sumProblem(2, 3)
sumProblem(1234567890123, 535790269358)
a = int(input("Enter an integer: "))
b = int(input("Enter another integer: "))
sumProblem(a, b)

main()
The actual parameters in the function call are evaluated left to right, and then these values are associated
with the formal parameter names in the function definition, also left to right. For example the function call
with actual parameters, f(actual1, actual2, actual3), calling the function f with definition heading
def f(formal1, formal2, formal3):
acts approximately as if the first lines executed inside the called function were
formal1 = actual1
formal2 = actual2
formal3 = actual3
Functions provide extremely important functionality to programs, allowing task to be defined once and
performed repeatedly with different data. It is essential to see the difference between the formal parameters
used to describe what is done inside the function definition (like x and y in the definition of sumProblem)
and the actual parameters (like 2 and 3 or 1234567890123 and 535790269358) which substitute for the formal
parameters when the function is actually executed. The main method above uses three different sets of
actual parameters in the three calls to sumProblem.
Exercise 1.11.5.1. ’* Modify the program above and save it as quotientProb.py. The new program
should have a quotientProblem function, printing as in the Exercise 1.10.3.2. The main method should test
the function on several sets of literal values, and also test the function with input from the user.
1.11.6. Returned Function Values. You probably have used mathematical functions in algebra class,
but they all had calculated values associated with them. For instance if you defined f (x) = x2 , then it follows
that f (3) is 32 = 9, and f (3)+f (4) is 32 +42 = 25. Function calls in expressions get replaced during evaluation
by the value of the function.
The corresponding definition and examples in Python would be the following, also in the example
program return1.py. Read and run: