Murakami Sale
 
 

Recently Viewed clear list


Q&A | August 19, 2014

Richard Kadrey: IMG Powell’s Q&A: Richard Kadrey



Describe your latest book. The Getaway God is the sixth book in the Sandman Slim series. In it, the very unholy nephilim, James Stark, aka Sandman... Continue »
  1. $17.49 Sale Hardcover add to wish list

spacer

On Order

$132.95
New Trade Paper
Currently out of stock.
Add to Wishlist
available for shipping or prepaid pickup only
Qty Store Section
- Local Warehouse Software Engineering- Programming and Languages

The Practice of Computing Using Python

by

The Practice of Computing Using Python Cover

 

Synopses & Reviews

Publisher Comments:

ALERT: Before you purchase, check with your instructor or review your course syllabus to ensure that you select the correct ISBN. Several versions of Pearson's MyLab & Mastering products exist for each title, including customized versions for individual schools, and registrations are not transferable. In addition, you may need a CourseID, provided by your instructor, to register for and use Pearson's MyLab & Mastering products.

 

Packages

Access codes for Pearson's MyLab & Mastering products may not be included when purchasing or renting from companies other than Pearson; check with the seller before completing your purchase.

 

Used or rental books

If you rent or purchase a used book with an access code, the access code may have been redeemed previously and you may have to purchase a new access code.

 

Access codes

Access codes that are purchased from sellers other than Pearson carry a higher risk of being either the wrong ISBN or a previously redeemed code. Check with the seller prior to purchase.

  -- A problem-solving approach to programming with Python.

 

The Practice of Computing Using Python introduces 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” approach–writing classes is covered only after students have mastered using objects.   

Synopsis:

A problem-solving approach to programming with Python.

 

The Practice of Computing Using Python introduces 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” approach–writing classes is covered only after students have mastered using objects.   

Synopsis:

A problem-solving approach to programming with Python.

 

The Practice of Computing Using Python introduces 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” approach–writing classes is covered only after students have mastered using objects.   

About the Author

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

Product Details

ISBN:
9780132805575
Author:
Punch, William F.
Publisher:
Addison-Wesley Professional
Author:
Punch, William F
Author:
Enbody, Richard
Subject:
Programming Languages - General
Subject:
Software Engineering - Programming and Languages
Copyright:
Edition Description:
Trade paper
Publication Date:
20120217
Binding:
TRADE PAPER
Language:
English
Pages:
792
Dimensions:
9 x 7.4 x 1.1 in 998 gr

Related Subjects

Computers and Internet » Computer Languages » Python
Computers and Internet » Software Engineering » Programming and Languages

The Practice of Computing Using Python New Trade Paper
0 stars - 0 reviews
$132.95 Backorder
Product details 792 pages Addison Wesley Longman - English 9780132805575 Reviews:
"Synopsis" by , A problem-solving approach to programming with Python.

 

The Practice of Computing Using Python introduces 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” approach–writing classes is covered only after students have mastered using objects.   

"Synopsis" by , A problem-solving approach to programming with Python.

 

The Practice of Computing Using Python introduces 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” approach–writing classes is covered only after students have mastered using objects.   

spacer
spacer
  • back to top
Follow us on...




Powell's City of Books is an independent bookstore in Portland, Oregon, that fills a whole city block with more than a million new, used, and out of print books. Shop those shelves — plus literally millions more books, DVDs, and gifts — here at Powells.com.