The Practice of Computing Using Python

by Punch, William F.; Enbody, Richard

• ISBN13: 9780132805575
• ISBN10: 013280557X
• Additional ISBN(s): 9780134379760
• Edition: 2nd
• Format: Paperback
• Copyright: 2012-02-15
• Publisher: Pearson
• More Book Details
• Purchase Benefits

Summary

A problem-solving approach to programming with Python. The Practice of Computing Using Pythonintroduces CS1 students (majors and non-majors) to computational thinking using Python. With data-manipulation as a theme, readers quickly see the value in what they're learning and leave the course with a set of immediately useful computational skills that can be applied to problems they encounter in future pursuits. The book takes an "object-use-first" approachwriting classes is covered only after students have mastered using objects.

Author Biography

Richard Enbody is an Associate Professor in the Department of Computer Science and Engineering at Michigan State University. Since joining the faculty in 1987, he has served as Acting Chair of the Department, Associate Chair, and as Director of the Computer Engineering Undergraduate Program.

 

Enbody received his B.A. in Mathematics from Carleton College in 1976, and spent six years teaching high school mathematics in Vermont and New Hampshire. He earned his Ph.D. in Computer Science from the University of Minnesota.

 

Richard's research interests are in computer security, computer architecture, web-based distance education and parallel processing, especially the application of parallel processing to computational science problems. He has two patents pending on hardware buffer-overflow protection which will prevent most computer worms and viruses.

 

In 1998 Richard pioneered a CS1 course (first course in Computer Science) over the World Wide Web using RealVideo synchronized with PowerPoint. Students from as far away as Russia and Korea enrolled in the course.

When not teaching, Richard plays hockey, squash, canoes, backpacks, as well as a host of family activities.

 

Bill Punch is an Associate Professor in the Department of Computer Science at Michigan State University as well as the director of Michigan State's High Performance Computing Center.

 

Punch is co-director of the Genetic Algorithms Research and Applications Group or GARAGe. His main interests are genetic algorithms and genetic programming, including theoretical issues (parallel GA/GP) and application issues (design, layout, scheduling, etc.). He also has conducted active research in data mining, focusing on the use of ontologies such as WordNet and Wikipedia for text search.

Table of Contents

Contents
-1.0.1 Data Manipulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
-1.0.2 Problem Solving and Case Studies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
-1.0.3 Code examples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
-1.0.4 Interactive Sessions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
-1.0.5 Exercises and Programming Projects . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
-1.0.6 Self-Test Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
-1.0.7 Programming Tips . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

I Thinking About Computing 23
0 The Study of Computer Science 25
0.1 Why Computer Science? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
0.1.1 Importance of Computer Science . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
0.1.2 Computer Science Around You . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
0.1.3 Computer “Science” . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
0.1.4 Computer Science Through Computer Programming . . . . . . . . . . . . . . . . . . . 27
0.2 The Difficulty and Promise of Programming . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
0.2.1 Difficulty 1: Two Things at Once . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
A une Damoyselle malade . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
My Sweet/Cute [One] (Feminine) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
A une Damoyselle malade . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
My Sweet Dear . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
A une Damoyselle malade . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
0.2.2 Difficulty 2: What is a Good Program? . . . . . . . . . . . . . . . . . . . . . . . . . . 29
0.2.3 The Promise of a Computer Program . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
0.3 Choosing a Computer Language . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
0.3.1 Different Computer Languages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
0.3.2 Why Python? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
0.3.3 Is Python the Best Language? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
0.4 What Is Computation? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
0.5 What Is a computer? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
0.5.1 Computation in Nature . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
0.5.2 The Human Computer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
0.6 The Modern, Electronic Computer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
0.6.1 It’s the Switch! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
0.6.2 The Transistor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
0.7 A High-Level Look at a Modern Computer . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
0.8 Representing Data . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
0.8.1 Binary Data . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
0.8.2 Working with Binary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
0.8.3 Limits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
0.8.4 Representing Letters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
0.8.5 Representing Other Data . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
0.8.6 What Does a Number Represent? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
0.8.7 How to Talk About Quantities of Data . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
0.8.8 How Much Data is That? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
0.9 Overview of Coming Chapters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48

II Starting to Program 51
1 Beginnings 53
1.1 Practice, Practice, Practice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
1.2 QuickStart, the Circumference Program . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
1.2.1 Examining the code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
1.3 An Interactive Session . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
1.4 Parts of a Program . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
1.4.1 Modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
1.4.2 Statements and Expressions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
1.4.3 Whitespace . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
1.4.4 Comments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
1.4.5 Special Python Elements: Tokens . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
1.4.6 Naming Objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
1.4.7 Recommendations on Naming . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
1.5 Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
1.5.1 Variable Creation and Assignment . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
1.6 Objects and Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
1.6.1 Numbers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
1.6.2 Other Built-In Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
1.6.3 Object types: not variable types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
1.6.4 Constructing New Values . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
1.7 Operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
1.7.1 Integer Operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
1.7.2 Floating Point Operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
1.7.3 Mixed Operations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
1.7.4 Order of Operations and Parentheses . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
1.7.5 Augmented Assignment Operators: A Shortcut! . . . . . . . . . . . . . . . . . . . . . . 76
1.8 Your First Module, Math . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
1.9 Developing an Algorithm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
1.9.1 New rule, testing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
1.10 Visual Vignette: TURTLE GRAPHICS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
1.10.1 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
1.10.2 Programming Projects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
2 Control 93
2.1 The Selection Statement for Decisions: if . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
2.1.1 Booleans for Decisions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
2.1.2 The if Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
2.1.3 Example: What Lead is Safe in Basketball? . . . . . . . . . . . . . . . . . . . . . . . . 97
2.1.4 Repetition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
2.1.5 Example: Finding Perfect Numbers . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
2.1.6 Example: Classifying Numbers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
2.2 In-Depth Control . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
2.2.1 True and False: Booleans . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
2.2.2 Boolean Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
2.2.3 Relational Operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
2.2.4 Boolean Operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
2.2.5 Precedence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
2.2.6 Boolean Operators Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
2.2.7 Another Word on Assignments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
2.2.8 The Selection Statement for Decisions . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
2.2.9 More on Python Decision Statements . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
2.2.10 Repetition: the while Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
2.2.11 Sentinel Loop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
2.2.12 Summary of Repetition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
2.2.13 More on the for Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
2.2.14 Nesting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
2.2.15 Hailstone Sequence Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138
2.3 Visual Vignette: Plotting Data with pylab . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140
2.3.1 First Plot and Using a List . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140
2.3.2 More Interesting Plot: a Sine Wave . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
2.4 Computer Science Perspectives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
2.4.1 Minimal Universal Computing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
2.4.2 Programming Projects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152
3 Algorithms and Program Development 155
3.1 What Is an Algorithm? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
3.1.1 Example Algorithms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156
3.2 Algorithm Features . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157
3.2.1 Algorithm versus Program . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157
3.2.2 Qualities of an Algorithm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158
3.2.3 Can We Really Do All That? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159
3.3 What is a Program? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159
3.3.1 Readability . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160
3.3.2 Robust . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162
3.3.3 Correctness . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
3.4 Strategies for Program Design . . . . . . . . . . . . . . . . .
3.4.1 Engage and Commit . . . . . . . . . . . . . . . . . . .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. 116634
3.4.2 Understand, Then Visualize . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164
3.4.3 Think Before You Program . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165
3.4.4 Experiment . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165
3.4.5 Simplify . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166
3.4.6 Stop and Think . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166
3.4.7 Relax: Give Yourself a Break . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167
3.5 A Simple Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167
3.5.1 Build the Skeleton . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167
3.5.2 Output . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168
3.5.3 Input . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168
3.5.4 Doing the Calculation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170
4 Working with Strings 175
4.1 The String Type . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175
4.1.1 The Triple Quote String . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 176
4.1.2 Non Printing Characters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 176
4.1.3 String Representation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 176
4.1.4 Strings as a Sequence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177
4.1.5 More Indexing and Slicing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178
4.1.6 Strings are Iterable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182
4.2 String Operations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183
4.2.1 Concatenation (+) and Repetition (*) . . . . . . . . . . . . . . . . . . . . . . . . . . . 183
4.2.2 Determining When + Indicates Addition or Concatenation? . . . . . . . . . . . . . . . 184
4.2.3 Comparison Operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184
4.2.4 The in Operator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185
4.2.5 String Collections are Immutable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 186
4.3 A Preview of Functions and Methods . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187
4.3.1 First Cut: What is a Function? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188
4.3.2 A String Method . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189
4.3.3 Determining Method Names and Method Arguments . . . . . . . . . . . . . . . . . . . 191
4.3.4 String Methods . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192
4.3.5 String Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192
4.4 Formatted Output for Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194
4.4.1 Descriptor Codes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195
4.4.2 Width and Alignment Descriptors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195
4.4.3 Floating-Point Precision Descriptor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197
4.5 Control and Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198
4.6 Working with Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201
4.6.1 Example: Reordering a Person’s Name . . . . . . . . . . . . . . . . . . . . . . . . . . . 201
4.6.2 Palindromes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202
4.7 More String Formatting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204
4.8 Computer Science Perspectives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207
4.8.1 Programming Projects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213
5 Files and Exceptions I 217
5.1 What is a File? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 217
5.2 Accessing Files: Reading Text Files . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 217
5.2.1 What’s Really Happening? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 218
5.3 Accessing Files: Writing Text Files . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 218
5.4 Reading and Writing Text Files . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219
5.5 File Creation and Overwriting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 220
5.6 First Cut, Handling Errors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221
5.6.1 Error Names . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222
5.6.2 The try-except construct . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222
5.6.3 try-except Flow of Control . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223
5.6.4 Exception example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223
5.7 Example: Counting Poker Hands . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 226
5.7.1 Program to Count Poker Hands . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229

III Functions and Data Structures 239
6 Functions-QuickStart 241
6.1 What Is a Function? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 241
6.1.1 Why Have Functions? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 242
6.2 Python Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 243
6.3 Flow of Control with Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 245
6.3.1 Function Flow in Detail . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 246
6.3.2 Parameter Passing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 246
6.3.3 Another Function Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 248
6.3.4 Function Example: Word Puzzle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 250
6.3.5 Functions Calling Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 254
6.3.6 When to Use a Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 254
6.3.7 What If There is No Return Statement? . . . . . . . . . . . . . . . . . . . . . . . . . . 255
6.3.8 What If There Are Multiple Return Statements? . . . . . . . . . . . . . . . . . . . . . 256
6.4 Visual Vignette: Turtle Flag . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 256
7 Lists and Tuples 263
7.1 What Is a List? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 263
7.2 What You Already Know How To Do With Lists . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 265
7.2.1 Iteration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 265
7.2.2 Indexing and Slicing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 265
7.2.3 Operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 266
7.2.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 268
7.2.5 List Iteration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 268
7.3 Lists are different than Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 269
7.3.1 Lists are Mutable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 269
7.3.2 List Methods . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 270
7.4 OLD AND NEW FRIENDS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 273
7.4.1 Split and Multiple Assignment . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 273
7.4.2 List to String and Back Again, Using join . . . . . . . . . . . . . . . . . . . . . . . . 274
7.4.3 The Sorted Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 275
7.5 Working with Some Examples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 276
7.5.1 Anagrams . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 276
7.5.2 Example: File Analysis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 280
7.6 Mutable Objects and References . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 285
7.6.1 Shallow vs. Deep Copy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 290
7.6.2 Mutable versus Immutable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 293
7.7 Tuples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295
7.7.1 Tuples from Lists . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 297
7.7.2 Why Tuples? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 297
7.8 Lists: The Data Structure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 298
7.8.1 Example Data Structure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 298
7.8.2 Other Example Data Structures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 299
7.9 ALGORITHM EXAMPLE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 300
7.10 Python Diversion: List Comprehension . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 307
7.10.1 Comprehensions, Expressions and the Ternary Operator . . . . . . . . . . . . . . . . . 308
7.11 Visual Vignette: More Plotting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 309
7.11.1 Numpy Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 309
7.11.2 Plotting Trigonometric Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 311
7.11.3 Programming Projects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 320
8 More on Functions 325
8.1 Scope: A First Cut . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 325
8.1.1 Arguments, Parameters, and Namespaces . . . . . . . . . . . . . . . . . . . . . . . . . 326
8.1.2 Passing Mutable Objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 328
8.1.3 Returning a Complex Object . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 330
8.1.4 Refactoring evens . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 331
8.2 DEFAULT VALUES AND PARAMETERS . . . . . . . . . . . . . . . . . . . . . . . . . . . . 331
8.2.1 Example: Default Values and Parameter Keywords . . . . . . . . . . . . . . . . . . . . 332
8.3 Functions as Objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 334
8.3.1 Function Annotations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 335
8.3.2 Docstrings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 336
8.4 Example: Determining a Final Grade . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 336
8.4.1 The Data . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 336
8.4.2 The Design . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 337
8.4.3 Function: weighted_grade . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 337
8.4.4 Function: parse_line . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 338
8.4.5 Function: main . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 338
8.4.6 Example Use . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 339
8.5 Esoterica: ‘‘by value’’ or ‘‘by reference’’ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 339
8.5.1 Programming Projects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 342
9 Dictionaries and Sets 345
9.1 Dictionaries . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 345
9.1.1 Dictionary Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 346
9.1.2 Python Dictionaries . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 346
9.1.3 Dictionary Indexing and Assignment . . . . . . . . . . . . . . . . . . . . . . . . . . . . 347
9.1.4 Operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 348
9.2 Word Count Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 352
9.2.1 Count Words in a String . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 352
9.2.2 Word Frequency for Gettysburg Address . . . . . . . . . . . . . . . . . . . . . . . . . . 353
9.2.3 Output and Comments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 356
9.3 Periodic Table Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 357
9.3.1 Working with CSV Files . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 357
9.3.2 Algorithm Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 358
9.3.3 Functions for Divide and Conquer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 359
9.4 Sets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362
9.4.1 History . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362
9.4.2 What’s in a Set? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362
9.4.3 Python Sets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362
9.4.4 Methods, Operators, and Functions for Python Sets . . . . . . . . . . . . . . . . . . . 363
9.4.5 Set Methods . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 363
9.5 Set Applications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 368
9.5.1 Relationship between Words of Different Documents . . . . . . . . . . . . . . . . . . . 368
9.5.2 Output and Comments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 370
9.6 Scope: The Full Story . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 371
9.6.1 Namespaces and Scope . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 371
9.6.2 Search Rule for Scope . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 371
9.6.3 Local . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 372
9.6.4 Global . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 372
9.6.5 Built-Ins . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 375
9.6.6 Enclosed . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 376
9.7 PYTHON POINTER . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 377
9.8 Python Diversion: Dictionary and Set Comprehension . . . . . . . . . . . . . . . . . . . . . . 377
9.9 Visual Vignette: Bar Graph of Word Frequency . . . . . . . . . . . . . . . . . . . . . . . . . . 378
9.9.1 Getting the Data Right . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 378
9.9.2 Labels and the xticks Command . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 379
9.9.3 Plotting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 379
9.9.4 Programming Projects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 385
10 More Program Development 389
10.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 389
10.2 Divide and Conquer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 389
10.2.1 Top-Down Refinement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 389
10.3 The Breast Cancer Classifier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 390
10.3.1 The Problem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 390
10.3.2 The Approach: Classification . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 390
10.3.3 Training and Testing the Classifier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 390
10.3.4 Building the Classifier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 391
10.4 Designing the Classifier Algorithm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 391
10.4.1 Divided, now Conquer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 395
10.4.2 Data Structures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 395
10.4.3 File Format . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 396
10.4.4 The make_training_set Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 396
10.4.5 The make_test_set Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 400
10.4.6 The train_classifier Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 400
10.4.7 train_classifer, Round 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 402
10.4.8 Testing the Classifier on New Data . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 404
10.4.9 The report_results Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 408
10.5 Running the Classifier on Full Data . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 409
10.5.1 Training versus Testing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 409
10.6 Other Interesting Problems . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 412
10.6.1 Tag Clouds . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 412
10.6.2 S&P 500 Predictions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 413
10.6.3 Predicting Religion with Flags . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 416
10.6.4 Programming Projects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 419

IV Classes, making your own Data Structures and Algorithms 421
11 Introduction to Classes 423
11.0.5 Simple Student Class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 423
11.1 Object-Oriented Programming . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 424
11.1.1 Python Is Object-Oriented! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 424
11.1.2 Characteristics of OOP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 424
11.2 Working with Object-Oriented Programming . . . . . . . . . . . . . . . . . . . . . . . . . . . 424
11.2.1 Class and Instance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 425
11.3 Working with Classes and Instances . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 426
11.3.1 Built-In Class and Instance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 426
11.3.2 Our First Class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 426
11.3.3 Changing Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 428
11.3.4 The Special Relationship Between an Instance and Class: instance-of . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 429
11.4 Object Methods . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 431
11.4.1 Using Object Methods . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 431
11.4.2 Writing Methods . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 432
11.4.3 The Special Argument self . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 433
11.4.4 Methods are the Interface to a Class Instance . . . . . . . . . . . . . . . . . . . . . . . 435
11.5 Fitting into the Python Class Model . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 435
11.5.1 Making Programmer-Defined Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 435
11.5.2 A Student Class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 435
11.5.3 Python Standard Methods . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 436
11.5.4 Now There Are Three: Class Designer, Programmer, and User . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 439
11.6 Example: Point Class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 440
11.6.1 Construction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 441
11.6.2 Distance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 441
11.6.3 Summing Two Points . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 441
11.6.4 Improving the Point Class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 442
11.7 Python and OOP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 445
11.7.1 Encapsulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 445
11.7.2 Inheritance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 445
11.7.3 Polymorphism . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 445
11.8 An Aside: Python and Other OOP languages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 446
11.8.1 Public versus Private . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 446
11.8.2 Indicating Privacy Using Double Underscores (__) . . . . . . . . . . . . . . . . . . . . 446
11.8.3 Python’s Philosophy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 447
11.8.4 Modifying an Instance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 447
11.8.5 Programming Projects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 450
12 More on Classes 453
12.1 More About Class Properties . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 453
12.1.1 Rational Number (Fraction) Class Example . . . . . . . . . . . . . . . . . . . . . . . . 454
12.2 How Does Python Know? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 455
12.2.1 Classes, Types, and Introspection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 456
12.2.2 Remember Operator Overloading . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 457
12.3 Creating Your Own Operator Overloading . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 458
12.3.1 Mapping Operators to Special Methods . . . . . . . . . . . . . . . . . . . . . . . . . . 458
12.4 Building the Rational Number Class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 460
12.4.1 Making the Class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 461
12.4.2 Review Fraction Addition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 462
12.4.3 Back to Adding Fractions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 465
12.4.4 Equality and Reducing Rationals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 468
12.4.5 Divide and Conquer at Work . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 470
12.5 What Doesn’t Work (Yet) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 470
12.5.1 Introspection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 471
12.5.2 Repairing “int + Rational” Errors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 473
12.6 Inheritance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 474
12.6.1 The “Find the Attribute” Game . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 475
12.6.2 Using Inheritance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 477
12.6.3 Example: The Standard Model . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 478
13 Program Development with Classes 487
13.1 Predator--Prey Problem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 487
13.1.1 The Rules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 488
13.1.2 Simulation Using Object-Oriented Programming . . . . . . . . . . . . . . . . . . . . . 488
13.2 Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 489
13.2.1 Island Class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 489
13.2.2 Predator and Prey, Kinds of Animals . . . . . . . . . . . . . . . . . . . . . . . . . . . . 490
13.2.3 Predator and Prey Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 493
13.2.4 Object Diagram . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 493
13.2.5 Filling the Island . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 493
13.3 Adding Behavior . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 495
13.3.1 Refinement: Add Movement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 495
13.3.2 Refinement: Time Simulation Loop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 497
13.4 Refinement: Eating, Breeding,and Keeping Time . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 498
13.4.1 Improved Time Loop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 499
13.4.2 Breeding . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 501
13.4.3 Eating . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 502
13.4.4 The Tick of the Clock . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 503
13.5 Refinements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 504
13.5.1 Refinement: How Many Times to Move? . . . . . . . . . . . . . . . . . . . . . . . . . . 504
13.5.2 Refinement: Graphing Population Size . . . . . . . . . . . . . . . . . . . . . . . . . . . 505
V Being a better programmer 507
14 Files and Exceptions II 509
14.1 More Details on Files . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 509
14.1.1 Other File Access Methods, Reading . . . . . . . . . . . . . . . . . . . . . . . . . . . . 511
14.1.2 Other File Access Methods, Writing . . . . . . . . . . . . . . . . . . . . . . . . . . . . 512
14.1.3 Universal New Line Format . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 513
14.1.4 Moving Around in a File . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 514
14.1.5 Closing a File . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 515
14.1.6 The with Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 516
14.2 CSV Files . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 517
14.2.1 CSV Module . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 518
14.2.2 CSV Reader . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 518
14.2.3 CSV Writer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 519
14.2.4 Example: Update Some Grades . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 519
14.3 Module: os . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 521
14.3.1 Directory (Folder) Structure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 521
14.3.2 os Module Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 522
14.3.3 os Module Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 524
14.4 More on Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 525
14.4.1 Basic Exception Handling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 526
14.4.2 A Simple Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 527
14.4.3 Events . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 530
14.4.4 A Philosophy Concerning Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . 530
14.5 Exception: else and finally . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 531
14.5.1 finally and with . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 531
14.5.2 Example: Refactoring the Reprompting of a File Name . . . . . . . . . . . . . . . . . 531
14.6 More on Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 532
14.6.1 Raise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 532
14.6.2 Create Your Own . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 534
14.7 Example: Password Manager . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 534
14.7.1 Programming Projects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 540
15 Testing 541
15.1 Why Testing? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 541
15.1.1 Kinds of Errors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 541
15.1.2 “Bugs” and Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 542
15.2 Kinds of Testing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 543
15.2.1 Testing is Hard! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 544
15.2.2 Importance of Testing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 544
15.3 Example Problem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 544
15.3.1 NBA Efficiency . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 544
15.3.2 Basic Algorithm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 545
15.4 Incorporating Testing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 547
15.4.1 Catching User Errors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 547
15.4.2 Catching Developer Errors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 548
15.5 Automation of Testing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 549
15.5.1 doctest . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 550
15.5.2 Other Kinds of Testing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 552
15.5.3 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 552
16 Recursion: Another Control Mechanism 553
16.1 What Is Recursion? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 553
16.2 Mathematics and Rabbits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 555
16.3 Let’s Write Our Own: Reversing a String . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 557
16.4 How Does Recursion Actually Work? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 559
16.4.1 Stack Data Structure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 559
16.4.2 Stacks and Function Calls . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 561
16.5 Recursion in Figures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 563
16.5.1 Recursive Tree . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 563
16.5.2 Sierpinski Triangles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 564
16.6 Recursion to Non-recursion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 565
17 Other Fun Stuff with Python 569
17.1 Function Stuff . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 569
17.1.1 Having a Varying Number of Parameters . . . . . . . . . . . . . . . . . . . . . . . . . 569
17.1.2 Iterators and Generators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 572
17.1.3 Other Functional Programming Ideas . . . . . . . . . . . . . . . . . . . . . . . . . . . 575
17.1.4 Some Functional Tools: map , reduce , filter . . . . . . . . . . . . . . . . . . . . . . 576
17.1.5 Decorators, Functions calling Functions . . . . . . . . . . . . . . . . . . . . . . . . . . 577
17.2 Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 581
17.2.1 Properties . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 582
17.2.2 Serializing an Instance, pickle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 584
17.2.3 Random Numbers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 586
17.3 Other Things in Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 588
17.3.1 Data Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 588
17.3.2 Built-in Modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 588
17.3.3 Modules on the Internet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 589
18 The End, or Perhaps the Beginning 591

A. Getting and Using Python 593
A.1 About Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 593
A.1.1 History . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 593
A.1.2 Python 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 593
A.1.3 Python is Free and Portable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 594
A.1.4 Starting Python Up . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 594
A.1.5 Working with Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 596
A.1.6 Making a Program . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 597
A.2 Some Conventions for This Book . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 602
A.2.1 Interactive Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 603
A.2.2 Program: Written Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 603
A.2.3 Combined Program and Output . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 603
A.3 Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 604
B Simple Drawing with Turtle Graphics 605
B.0.1 What is a Turtle? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 605
B.0.2 Motion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 606
B.0.3 Drawing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 607
B.0.4 Color . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 608
B.0.5 Drawing with Color . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 609
B.0.6 Other commands . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 611
B.1 Tidbits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 612
B.1.1 Keeping the Window Open . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 612
B.1.2 Working Nicely With IDLE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 613
C Plotting and Numeric Tools: A Quick Survey 615
C.1 Matplotlib . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 615
C.1.1 Getting matplotlib . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 615
C.2 Working with matplotlib . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 620
C.2.1 Plot Command . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 620
C.2.2 Plot Properties . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 621
C.2.3 Tick Labels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 621
C.2.4 Bar Graphs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 622
C.2.5 Histograms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 622
C.2.6 Pie Charts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 624
C.3 Numeric Python (Numpy) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 625
C.3.1 Arrays Are Not Lists . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 625
C.3.2 Creating a numpy Array . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 625
C.3.3 Manipulating Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 625
D Table of UTF-8 One Byte Encodings 627
E Precedence 629
F Naming Conventions 631
F.1 Python Style Elements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 631
F.2 Naming Conventions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 632
F.2.1 Our Added Naming Conventions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 632
F.3 Other Python Conventions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 632
G Check Yourself Solutions 635
G.1 Chapter 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 635
G.2 Chapter 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 636
G.3 Chapter 4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 637
G.4 Chapter 5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 637
G.5 Chapter 6 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 637
G.6 Chapter 7 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 638
G.7 Chapter 8 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 638
G.8 Chapter 9 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 638
G.9 Chapter 11 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 639
G.10 Chapter 12 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 639
G.11 Chapter 14 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 639