Peter Wentworth, Jeffrey Elkner, Allen B. Downey …
[Pages:421]How to Think Like a Computer Scientist: Learning with Python 3
Documentation
Release 3rd Edition
Peter Wentworth, Jeffrey Elkner, Allen B. Downey and Chris Meyers
August 12, 2012
CONTENTS
1 The way of the program
1
1.1 The Python programming language . . . . . . . . . . . . . . . . . . . . . . . 1
1.2 What is a program? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.3 What is debugging? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.4 Syntax errors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.5 Runtime errors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.6 Semantic errors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.7 Experimental debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.8 Formal and natural languages . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.9 The first program . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.10 Comments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.11 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.12 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2 Variables, expressions and statements
11
2.1 Values and data types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.2 Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.3 Variable names and keywords . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.4 Statements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.5 Evaluating expressions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.6 Operators and operands . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.7 Type converter functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.8 Order of operations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.9 Operations on strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
2.10 Input . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
2.11 Composition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.12 The modulus operator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.13 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.14 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
3 Hello, little turtles!
25
3.1 Our first turtle program . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
3.2 Instances -- a herd of turtles . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
3.3 The for loop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
3.4 Flow of Execution of the for loop . . . . . . . . . . . . . . . . . . . . . . . . 30
i
3.5 The loop simplifies our turtle program . . . . . . . . . . . . . . . . . . . . . . 31 3.6 A few more turtle methods and tricks . . . . . . . . . . . . . . . . . . . . . . 32 3.7 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34 3.8 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
4 Functions
39
4.1 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
4.2 Functions can call other functions . . . . . . . . . . . . . . . . . . . . . . . . 42
4.3 Flow of execution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
4.4 Functions that require arguments . . . . . . . . . . . . . . . . . . . . . . . . 45
4.5 Functions that return values . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
4.6 Variables and parameters are local . . . . . . . . . . . . . . . . . . . . . . . . 47
4.7 Turtles Revisited . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
4.8 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
4.9 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
5 Conditionals
53
5.1 Boolean values and expressions . . . . . . . . . . . . . . . . . . . . . . . . . 53
5.2 Logical operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
5.3 Truth Tables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
5.4 Simplifying Boolean Expressions . . . . . . . . . . . . . . . . . . . . . . . . 55
5.5 Conditional execution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
5.6 Omitting the else clause . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
5.7 Chained conditionals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
5.8 Nested conditionals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
5.9 The return statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
5.10 Logical opposites . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
5.11 Type conversion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
5.12 A Turtle Bar Chart . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
5.13 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
5.14 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
6 Fruitful functions
71
6.1 Return values . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
6.2 Program development . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
6.3 Debugging with print . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
6.4 Composition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
6.5 Boolean functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
6.6 Programming with style . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
6.7 Unit testing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
6.8 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
6.9 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
7 Iteration
85
7.1 Assignment . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
7.2 Updating variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
7.3 The for loop revisited . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
7.4 The while statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
7.5 The Collatz 3n + 1 sequence . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
ii
7.6 Tracing a program . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90 7.7 Counting digits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92 7.8 Abbreviated assignment . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92 7.9 Help and meta-notation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93 7.10 Tables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95 7.11 Two-dimensional tables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96 7.12 Encapsulation and generalization . . . . . . . . . . . . . . . . . . . . . . . . 96 7.13 More encapsulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97 7.14 Local variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97 7.15 The break statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98 7.16 Other flavours of loops . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99 7.17 An example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100 7.18 The continue statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101 7.19 More generalization . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102 7.20 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103 7.21 Paired Data . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104 7.22 Nested Loops for Nested Data . . . . . . . . . . . . . . . . . . . . . . . . . . 104 7.23 Newton's method for finding square roots . . . . . . . . . . . . . . . . . . . . 105 7.24 Algorithms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107 7.25 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107 7.26 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
8 Strings
113
8.1 A compound data type . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
8.2 Working with strings as single things . . . . . . . . . . . . . . . . . . . . . . 113
8.3 Working with the parts of a string . . . . . . . . . . . . . . . . . . . . . . . . 115
8.4 Length . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
8.5 Traversal and the for loop . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
8.6 Slices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
8.7 String comparison . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
8.8 Strings are immutable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
8.9 The in and not in operators . . . . . . . . . . . . . . . . . . . . . . . . . 119
8.10 A find function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120
8.11 Looping and counting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
8.12 Optional parameters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
8.13 The built-in find method . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
8.14 The split method . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
8.15 Cleaning up your strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
8.16 The string format method . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
8.17 Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
8.18 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
8.19 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
9 Tuples
133
9.1 Tuples are used for grouping data . . . . . . . . . . . . . . . . . . . . . . . . 133
9.2 Tuple assignment . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
9.3 Tuples as return values . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
9.4 Composability of Data Structures . . . . . . . . . . . . . . . . . . . . . . . . 135
iii
9.5 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136 9.6 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136
10 Event-Driven Programming
137
10.1 Keypress events . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
10.2 Mouse events . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138
10.3 Automatic events from a timer . . . . . . . . . . . . . . . . . . . . . . . . . . 140
10.4 An example: state machines . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
10.5 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
10.6 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
11 Lists
145
11.1 List values . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
11.2 Accessing elements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146
11.3 List length . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146
11.4 List membership . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
11.5 List operations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148
11.6 List slices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148
11.7 Lists are mutable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148
11.8 List deletion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
11.9 Objects and references . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150
11.10 Aliasing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151
11.11 Cloning lists . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151
11.12 Lists and for loops . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152
11.13 List parameters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
11.14 List methods . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154
11.15 Pure functions and modifiers . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
11.16 Functions that produce lists . . . . . . . . . . . . . . . . . . . . . . . . . . . 156
11.17 Strings and lists . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156
11.18 list and range . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157
11.19 Nested lists . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158
11.20 Matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159
11.21 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159
11.22 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160
12 Modules
163
12.1 Random numbers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
12.2 The time module . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166
12.3 The math module . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167
12.4 Creating your own modules . . . . . . . . . . . . . . . . . . . . . . . . . . . 168
12.5 Namespaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168
12.6 Scope and lookup rules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170
12.7 Attributes and the dot operator . . . . . . . . . . . . . . . . . . . . . . . . . . 171
12.8 Three import statement variants . . . . . . . . . . . . . . . . . . . . . . . . 172
12.9 Turn your unit tester into a module . . . . . . . . . . . . . . . . . . . . . . . 172
12.10 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173
12.11 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174
13 Files
179
iv
13.1 About files . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179 13.2 Writing our first file . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179 13.3 Reading a file line-at-a-time . . . . . . . . . . . . . . . . . . . . . . . . . . . 180 13.4 Turning a file into a list of lines . . . . . . . . . . . . . . . . . . . . . . . . . 181 13.5 Reading the whole file at once . . . . . . . . . . . . . . . . . . . . . . . . . . 182 13.6 Working with binary files . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182 13.7 An example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183 13.8 Directories . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184 13.9 What about fetching something from the web? . . . . . . . . . . . . . . . . . 184 13.10 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185 13.11 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 186
14 List Algorithms
187
14.1 Test-driven development . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187
14.2 The linear search algorithm . . . . . . . . . . . . . . . . . . . . . . . . . . . 187
14.3 A more realistic problem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189
14.4 Binary Search . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192
14.5 Removing adjacent duplicates from a list . . . . . . . . . . . . . . . . . . . . 195
14.6 Merging sorted lists . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196
14.7 Alice in Wonderland, again! . . . . . . . . . . . . . . . . . . . . . . . . . . . 197
14.8 Eight Queens puzzle, part 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . 199
14.9 Eight Queens puzzle, part 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . 203
14.10 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204
14.11 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 205
15 Classes and Objects -- the Basics
209
15.1 Object-oriented programming . . . . . . . . . . . . . . . . . . . . . . . . . . 209
15.2 User-defined compound data types . . . . . . . . . . . . . . . . . . . . . . . . 209
15.3 Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211
15.4 Improving our initializer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212
15.5 Adding other methods to our class . . . . . . . . . . . . . . . . . . . . . . . . 213
15.6 Instances as arguments and parameters . . . . . . . . . . . . . . . . . . . . . 214
15.7 Converting an instance to a string . . . . . . . . . . . . . . . . . . . . . . . . 215
15.8 Instances as return values . . . . . . . . . . . . . . . . . . . . . . . . . . . . 215
15.9 A change of perspective . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216
15.10 Objects can have state . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 217
15.11 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 217
15.12 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 218
16 Classes and Objects -- Digging a little deeper
221
16.1 Rectangles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221
16.2 Objects are mutable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222
16.3 Sameness . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223
16.4 Copying . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 224
16.5 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 225
16.6 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 225
17 PyGame
227
17.1 The game loop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227
v
17.2 Displaying images and text . . . . . . . . . . . . . . . . . . . . . . . . . . . 230 17.3 Drawing a board for the N queens puzzle . . . . . . . . . . . . . . . . . . . . 232 17.4 Sprites . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 236 17.5 Events . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239 17.6 A wave of animation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 241 17.7 Aliens - a case study . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 245 17.8 Reflections . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 246 17.9 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 246 17.10 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 247
18 Recursion
249
18.1 Drawing Fractals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249
18.2 Recursive data structures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 252
18.3 Processing recursive number lists . . . . . . . . . . . . . . . . . . . . . . . . 252
18.4 Case study: Fibonacci numbers . . . . . . . . . . . . . . . . . . . . . . . . . 254
18.5 Example with recursive directories and files . . . . . . . . . . . . . . . . . . . 255
18.6 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 256
18.7 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 256
19 Exceptions
261
19.1 Catching exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 261
19.2 Raising our own exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . 263
19.3 Revisiting an earlier example . . . . . . . . . . . . . . . . . . . . . . . . . . 264
19.4 The finally clause of the try statement . . . . . . . . . . . . . . . . . . . 264
19.5 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 265
19.6 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 265
20 Dictionaries
267
20.1 Dictionary operations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 268
20.2 Dictionary methods . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 269
20.3 Aliasing and copying . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 270
20.4 Sparse matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 271
20.5 Memoization . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272
20.6 Counting letters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 273
20.7 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 273
20.8 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274
21 Even more OOP
277
21.1 MyTime . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 277
21.2 Pure functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 277
21.3 Modifiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 279
21.4 Converting increment to a method . . . . . . . . . . . . . . . . . . . . . . 279
21.5 An "Aha!" insight . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 280
21.6 Generalization . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 281
21.7 Another example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 282
21.8 Operator overloading . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 283
21.9 Polymorphism . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 285
21.10 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 287
21.11 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 287
vi
................
................
In order to avoid copyright disputes, this page is only a partial summary.
To fulfill the demand for quickly locating and searching documents.
It is intelligent file search solution for home and business.
Related searches
- dr jeffrey smith chelmsford ma
- jeffrey young early maladaptive schemas
- jeffrey young schema therapy questionnaire
- steven jeffrey smith md
- wentworth chevrolet portland oregon
- la county office of education downey ca
- dr jeffrey fein nj
- dr jeffrey stephens
- jeffrey jeffrey
- jeffrey jeffrey ware ma
- jeffrey ma 21
- jeffrey and jeffrey tax collector