《Think Python》简介：

Think Python is an introduction to Python programming for students with no programming experience. It starts with the most basic concepts of programming, and is carefully designed to define all terms when they are first used and to develop each new concept in a logical progression. Larger pieces, like recursion and object-oriented programming are divided into a sequence of smaller steps and introduced over the course of several chapters.

《Think Python》摘录：

The final version of the function doesn`t display anything when it runs;it only returns a value.The print statements we wrote are useful for debugging,but once you get the function working,you should remove them.Code like that is called scaffolding because it is helpful for building the program but is not part of the final product. When you start out,you should add only a line or two of code at a time.As you gain more experience,you might find yourself writing and debugging bigger chunks.Either way,incremental development can save you a lot of debugging time. The key aspects of the process are: 1.Start with a working program and make small incremental changes.At any porint,if there is an error,you should have a good idea where it is. 2.Use temporary variables to hold intermediate values ...

《Think Python》目录：

Preface v
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 Formal and natural languages . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.5 The first program . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.6 Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.7 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.8 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2 Variables, expressions and statements 11
2.1 Values and types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.2 Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.3 Variable names and keywords . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.4 Operators and operands . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.5 Expressions and statements . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.6 Interactive mode and script mode . . . . . . . . . . . . . . . . . . . . . . . . 14
2.7 Order of operations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.8 String operations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.9 Comments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.10 Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.11 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.12 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
3 Functions 19
3.1 Function calls . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
3.2 Type conversion functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
3.3 Math functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
3.4 Composition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
3.5 Adding new functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
3.6 Definitions and uses . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
3.7 Flow of execution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
3.8 Parameters and arguments . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
3.9 Variables and parameters are local . . . . . . . . . . . . . . . . . . . . . . . 24
3.10 Stack diagrams . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
3.11 Fruitful functions and void functions . . . . . . . . . . . . . . . . . . . . . . 26
3.12 Why functions? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
3.13 Importing with from . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
3.14 Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
3.15 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
3.16 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
4 Case study: interface design 31
4.1 TurtleWorld . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
4.2 Simple repetition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
4.3 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
4.4 Encapsulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
4.5 Generalization . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
4.6 Interface design . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
4.7 Refactoring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
4.8 A development plan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
4.9 docstring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
4.10 Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
4.11 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
4.12 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
5 Conditionals and recursion 41
5.1 Modulus operator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
5.2 Boolean expressions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
5.3 Logical operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
5.4 Conditional execution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
5.5 Alternative execution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
5.6 Chained conditionals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
5.7 Nested conditionals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
5.8 Recursion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
5.9 Stack diagrams for recursive functions . . . . . . . . . . . . . . . . . . . . . 45
5.10 Infinite recursion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
5.11 Keyboard input . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
5.12 Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
5.13 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
5.14 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
6 Fruitful functions 51
6.1 Return values . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
6.2 Incremental development . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
6.3 Composition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
6.4 Boolean functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
6.5 More recursion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
6.6 Leap of faith . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
6.7 One more example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
6.8 Checking types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
6.9 Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
6.10 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
6.11 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
7 Iteration 63
7.1 Multiple assignment . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
7.2 Updating variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
7.3 The while statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
7.4 break . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
7.5 Square roots . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
7.6 Algorithms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
7.7 Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
7.8 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
7.9 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
8 Strings 71
8.1 A string is a sequence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
8.2 len . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
8.3 Traversal with a for loop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
8.4 String slices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
8.5 Strings are immutable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
8.6 Searching . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
8.7 Looping and counting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
8.8 string methods . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
8.9 The in operator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
8.10 String comparison . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
8.11 Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
8.12 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
8.13 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
9 Case study: word play 81
9.1 Reading word lists . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
9.2 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
9.3 Search . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
9.4 Looping with indices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
9.5 Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
9.6 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
9.7 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
10 Lists 87
10.1 A list is a sequence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
10.2 Lists are mutable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
10.3 Traversing a list . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
10.4 List operations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
10.5 List slices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
10.6 List methods . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
10.7 Map, filter and reduce . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
10.8 Deleting elements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
10.9 Lists and strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
10.10 Objects and values . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
10.11 Aliasing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
10.12 List arguments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
10.13 Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
10.14 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
10.15 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
11 Dictionaries 101
11.1 Dictionary as a set of counters . . . . . . . . . . . . . . . . . . . . . . . . . . 102
11.2 Looping and dictionaries . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
11.3 Reverse lookup . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
11.4 Dictionaries and lists . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
11.5 Memos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
11.6 Global variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
11.7 Long integers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
11.8 Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
11.9 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
11.10 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
12 Tuples 113
12.1 Tuples are immutable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
12.2 Tuple assignment . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
12.3 Tuples as return values . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
12.4 Variable-length argument tuples . . . . . . . . . . . . . . . . . . . . . . . . 115
12.5 Lists and tuples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
12.6 Dictionaries and tuples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
12.7 Comparing tuples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
12.8 Sequences of sequences . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
12.9 Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120
12.10 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
12.11 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
13 Case study: data structure selection 123
13.1 Word frequency analysis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
13.2 Random numbers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
13.3 Word histogram . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
13.4 Most common words . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
13.5 Optional parameters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
13.6 Dictionary subtraction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
13.7 Random words . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
13.8 Markov analysis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
13.9 Data structures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
13.10 Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131
13.11 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
13.12 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
14 Files 133
14.1 Persistence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133
14.2 Reading and writing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133
14.3 Format operator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
14.4 Filenames and paths . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
14.5 Catching exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136
14.6 Databases . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
14.7 Pickling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
14.8 Pipes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138
14.9 Writing modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139
14.10 Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140
14.11 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
14.12 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
15 Classes and objects 143
15.1 User-defined types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
15.2 Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144
15.3 Rectangles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
15.4 Instances as return values . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146
15.5 Objects are mutable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146
15.6 Copying . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
15.7 Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148
15.8 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
15.9 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
16 Classes and functions 151
16.1 Time . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151
16.2 Pure functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152
16.3 Modifiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
16.4 Prototyping versus planning . . . . . . . . . . . . . . . . . . . . . . . . . . . 154
16.5 Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
16.6 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156
16.7 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156
17 Classes and methods 157
17.1 Object-oriented features . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157
17.2 Printing objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158
17.3 Another example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159
17.4 A more complicated example . . . . . . . . . . . . . . . . . . . . . . . . . . 160
17.5 The init method . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160
17.6 The __str__ method . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161
17.7 Operator overloading . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161
17.8 Type-based dispatch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161
17.9 Polymorphism . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
17.10 Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
17.11 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164
17.12 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164
18 Inheritance 167
18.1 Card objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167
18.2 Class attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168
18.3 Comparing cards . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169
18.4 Decks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170
18.5 Printing the deck . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171
18.6 Add, remove, shuffle and sort . . . . . . . . . . . . . . . . . . . . . . . . . . 171
18.7 Inheritance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172
18.8 Class diagrams . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173
18.9 Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174
18.10 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175
18.11 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 176
19 Case study: Tkinter 179
19.1 GUI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179
19.2 Buttons and callbacks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 180
19.3 Canvas widgets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181
19.4 Coordinate sequences . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182
19.5 More widgets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182
19.6 Packing widgets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183
19.7 Menus and Callables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 186
19.8 Binding . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 186
19.9 Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188
19.10 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189
19.11 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190
A Debugging 193
A.1 Syntax errors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193
A.2 Runtime errors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195
A.3 Semantic errors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198
B Analysis of Algorithms 201
B.1 Order of growth . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202
B.2 Analysis of basic Python operations . . . . . . . . . . . . . . . . . . . . . . 204
B.3 Analysis of search algorithms . . . . . . . . . . . . . . . . . . . . . . . . . . 205
B.4 Hashtables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206
B.5 Summing lists . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 209
· · · · · ·