《Think Python》

衬歌酒

《Think Python》
pdf
Contents
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
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
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
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 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8610 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
.......