Think Python_ An Introduction to Software Design_ How To Think Like A Computer Scientist
Preface v
1 The way of the program 1
1.1 The Python programming language . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.2 What is a program? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.3 What is debugging? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.4 Formal and natural languages . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.5 The first program . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.6 Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.7 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.8 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2 Variables, expressions and statements 9
2.1 Values and types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.2 Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.3 Variable names and keywords . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.4 Statements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.5 Operators and operands . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.6 Expressions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.7 Order of operations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.8 String operations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.9 Comments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.10 Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.11 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.12 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
xii Contents
3 Functions 17
3.1 Function calls . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
3.2 Type conversion functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
3.3 Math functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
3.4 Composition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
3.5 Adding new functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
3.6 Definitions and uses . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
3.7 Flow of execution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
3.8 Parameters and arguments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
3.9 Variables and parameters are local . . . . . . . . . . . . . . . . . . . . . . . . . 22
3.10 Stack diagrams . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
3.11 Fruitful functions and void functions . . . . . . . . . . . . . . . . . . . . . . . . 24
3.12 Why functions? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
3.13 Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
3.14 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
3.15 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
4 Case study: interface design 29
4.1 TurtleWorld . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 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 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
4.11 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
4.12 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
Contents xiii
5 Conditionals and recursion 39
5.1 Modulus operator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
5.2 Boolean expressions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
5.3 Logical operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
5.4 Conditional execution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
5.5 Alternative execution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
5.6 Chained conditionals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
5.7 Nested conditionals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
5.8 Recursion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
5.9 Stack diagrams for recursive functions . . . . . . . . . . . . . . . . . . . . . . . 43
5.10 Infinite recursion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
5.11 Keyboard input . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
5.12 Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
5.13 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
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
xiv Contents
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 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 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 81
9.1 Reading word lists . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
9.2 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
9.3 Search . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
9.4 Looping with indices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
9.5 Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
9.6 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
9.7 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
Contents xv
10 Lists 89
10.1 A list is a sequence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
10.2 Lists are mutable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
10.3 Traversing a list . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
10.4 List operations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
10.5 List slices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
10.6 List methods . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
10.7 Map, filter and reduce . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
10.8 Deleting elements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
10.9 Lists and strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
10.10 Objects and values . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
10.11 Aliasing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
10.12 List arguments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
10.13 Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
10.14 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
10.15 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
11 Dictionaries 103
11.1 Dictionary as a set of counters . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
11.2 Looping and dictionaries . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
11.3 Reverse lookup . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
11.4 Dictionaries and lists . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
11.5 Memos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
11.6 Global variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
11.7 Long integers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
11.8 Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
11.9 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
11.10 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
xvi 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 . . . . . . . . . . . . . . . . . . . . . . . . . . 117
12.5 Lists and tuples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
12.6 Dictionaries and tuples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
12.7 Comparing tuples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
12.8 Sequences of sequences . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
12.9 Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
12.10 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
12.11 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
13 Case study: data structure selection 127
13.1 Word frequency analysis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
13.2 Random numbers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
13.3 Word histogram . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
13.4 Most common words . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130
13.5 Optional parameters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130
13.6 Dictionary subtraction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131
13.7 Random words . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131
13.8 Markov analysis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
13.9 Data structures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133
13.10 Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
13.11 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
13.12 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136
14 Files 137
14.1 Persistence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
14.2 Reading and writing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
14.3 Format operator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138
14.4 Filenames and paths . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139
Contents xvii
14.5 Catching exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140
14.6 Databases . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
14.7 Pickling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
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 User-defined types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
15.2 Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148
15.3 Rectangles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
15.4 Instances as return values . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150
15.5 Objects are mutable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150
15.6 Copying . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151
15.7 Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152
15.8 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
15.9 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
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
xviii Contents
17 Classes and methods 161
17.1 Object-oriented features . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161
17.2 Printing objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162
17.3 Another example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
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 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168
17.12 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169
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 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179
18.11 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 180
19 Case study: Tkinter 183
19.1 GUI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183
19.2 Buttons and callbacks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184
19.3 Canvas widgets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185
19.4 Coordinate sequences . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 186
Contents xix
19.5 More widgets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 186
19.6 Packing widgets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187
19.7 Menus and Callables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190
19.8 Binding . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191
19.9 Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193
19.10 Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193
19.11 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194
A Debugging 197
A.1 Syntax errors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197
A.2 Runtime errors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 199
A.3 Semantic errors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201