Think Python2: How to Think Like a Computer Scientist.pdf

【核心代码】

Contents
Preface v
1 The way of the program 1
1.1 What is a program? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.2 Running Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.3 The first program . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.4 Arithmetic operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.5 Values and types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.6 Formal and natural languages . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.7 Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.8 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.9 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2 Variables, expressions and statements 9
2.1 Assignment statements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.2 Variable names . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.3 Expressions and statements . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.4 Script mode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.5 Order of operations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.6 String operations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.7 Comments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.8 Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.9 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.10 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
xiv Contents
3 Functions 17
3.1 Function calls . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
3.2 Math functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
3.3 Composition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
3.4 Adding new functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
3.5 Definitions and uses . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
3.6 Flow of execution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
3.7 Parameters and arguments . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
3.8 Variables and parameters are local . . . . . . . . . . . . . . . . . . . . . . . 22
3.9 Stack diagrams . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
3.10 Fruitful functions and void functions . . . . . . . . . . . . . . . . . . . . . . 24
3.11 Why functions? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
3.12 Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
3.13 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
3.14 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
4 Case study: interface design 29
4.1 The turtle module . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
4.2 Simple repetition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
4.3 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
4.4 Encapsulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
4.5 Generalization . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
4.6 Interface design . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
4.7 Refactoring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
4.8 A development plan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
4.9 docstring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
4.10 Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
4.11 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
4.12 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
Contents xv
5 Conditionals and recursion 39
5.1 Floor division and modulus . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
5.2 Boolean expressions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
5.3 Logical operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
5.4 Conditional execution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
5.5 Alternative execution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
5.6 Chained conditionals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
5.7 Nested conditionals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
5.8 Recursion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
5.9 Stack diagrams for recursive functions . . . . . . . . . . . . . . . . . . . . . 44
5.10 Infinite recursion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
5.11 Keyboard input . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
5.12 Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
5.13 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
5.14 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
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
xvi Contents
7 Iteration 63
7.1 Reassignment . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
7.2 Updating variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
7.3 The while statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
7.4 break . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
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 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
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 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
8.11 Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
8.12 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
8.13 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
9 Case study: word play 83
9.1 Reading word lists . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
9.2 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
9.3 Search . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
9.4 Looping with indices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
9.5 Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
9.6 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
9.7 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
Contents xvii
10 Lists 89
10.1 A list is a sequence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
10.2 Lists are mutable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
10.3 Traversing a list . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
10.4 List operations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
10.5 List slices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
10.6 List methods . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
10.7 Map, filter and reduce . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
10.8 Deleting elements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
10.9 Lists and strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
10.10 Objects and values . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
10.11 Aliasing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
10.12 List arguments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
10.13 Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
10.14 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
10.15 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
11 Dictionaries 103
11.1 A dictionary is a mapping . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
11.2 Dictionary as a collection of counters . . . . . . . . . . . . . . . . . . . . . . 104
11.3 Looping and dictionaries . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
11.4 Reverse lookup . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
11.5 Dictionaries and lists . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
11.6 Memos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
11.7 Global variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
11.8 Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
11.9 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
11.10 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
xviii Contents
12 Tuples 115
12.1 Tuples are immutable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
12.2 Tuple assignment . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
12.3 Tuples as return values . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
12.4 Variable-length argument tuples . . . . . . . . . . . . . . . . . . . . . . . . 118
12.5 Lists and tuples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
12.6 Dictionaries and tuples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120
12.7 Sequences of sequences . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
12.8 Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
12.9 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
12.10 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
13 Case study: data structure selection 125
13.1 Word frequency analysis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
13.2 Random numbers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
13.3 Word histogram . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
13.4 Most common words . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
13.5 Optional parameters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
13.6 Dictionary subtraction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
13.7 Random words . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130
13.8 Markov analysis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130
13.9 Data structures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
13.10 Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133
13.11 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
13.12 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
14 Files 137
14.1 Persistence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
14.2 Reading and writing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
14.3 Format operator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138
14.4 Filenames and paths . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139
14.5 Catching exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140
Contents xix
14.6 Databases . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
14.7 Pickling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142
14.8 Pipes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142
14.9 Writing modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
14.10 Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144
14.11 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
14.12 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
15 Classes and objects 147
15.1 Programmer-defined types . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
15.2 Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148
15.3 Rectangles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
15.4 Instances as return values . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150
15.5 Objects are mutable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151
15.6 Copying . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151
15.7 Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152
15.8 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
15.9 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154
16 Classes and functions 155
16.1 Time . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
16.2 Pure functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156
16.3 Modifiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157
16.4 Prototyping versus planning . . . . . . . . . . . . . . . . . . . . . . . . . . . 158
16.5 Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159
16.6 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160
16.7 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160
17 Classes and methods 161
17.1 Object-oriented features . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161
17.2 Printing objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162
17.3 Another example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
xx Contents
17.4 A more complicated example . . . . . . . . . . . . . . . . . . . . . . . . . . 164
17.5 The init method . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164
17.6 The __str__ method . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165
17.7 Operator overloading . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165
17.8 Type-based dispatch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166
17.9 Polymorphism . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167
17.10 Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168
17.11 Interface and implementation . . . . . . . . . . . . . . . . . . . . . . . . . . 169
17.12 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169
17.13 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170
18 Inheritance 171
18.1 Card objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171
18.2 Class attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172
18.3 Comparing cards . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173
18.4 Decks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174
18.5 Printing the deck . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174
18.6 Add, remove, shuffle and sort . . . . . . . . . . . . . . . . . . . . . . . . . . 175
18.7 Inheritance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 176
18.8 Class diagrams . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177
18.9 Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178
18.10 Data encapsulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179
18.11 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 180
18.12 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181
19 The Goodies 183
19.1 Conditional expressions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183
19.2 List comprehensions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184
19.3 Generator expressions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185
19.4 any and all . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185
19.5 Sets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 186
19.6 Counters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187
Contents xxi
19.7 defaultdict . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188
19.8 Named tuples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189
19.9 Gathering keyword args . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190
19.10 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191
19.11 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192
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 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 209