Giới thiệu sách Python: Think Python

think python

Think Python

Allen B.Downey

Table of Contents

Preface

1. The Way of the Program         

                The Python Programming Language 1

                What Is a Program? 3

                What Is Debugging? 4

                Syntax Errors 4

                Runtime Errors 4

                Semantic Errors 5

                Experimental Debugging 5

                Formal and Natural Languages 6

                The First Program 7

                Debugging 8

                Glossary 9

                Exercises 11

2. Variables, Expressions, and Statements           

                Values and Types 13

                Variables 14

                Variable Names and Keywords 15

                Operators and Operands 16

                Expressions and Statements 16

                Interactive Mode and Script Mode 17

                Order of Operations 18

                String Operations 18

                Comments 19

                Debugging 19

                Glossary 20

                iiiExercises 21

3. Functions       

                Function Calls 23

                Type Conversion Functions 23

                Math Functions 24

                Composition 25

                Adding New Functions 25

                Definitions and Uses 27

                Flow of Execution 27

                Parameters and Arguments 28

                Variables and Parameters Are Local 29

                Stack Diagrams 30

                Fruitful Functions and Void Functions 31

                Why Functions? 32

                Importing with from 32

                Debugging 33

                Glossary 33

                Exercises 35

4. Case Study: Interface Design

                TurtleWorld 37

                Simple Repetition 38

                Exercises 39

                Encapsulation 40

                Generalization 41

                Interface Design 42

                Refactoring 43

                A Development Plan 44

                Docstring 44

                Debugging 45

                Glossary 45

                Exercises 46

5. Conditionals and Recursion    

                Modulus Operator 49

                Boolean Expressions 49

                Logical Operators 50

                Conditional Execution 50

                Alternative Execution 51

                Chained Conditionals 51

                Nested Conditionals 52

                iv | Table of ContentsRecursion 53

                Stack Diagrams for Recursive Functions 54

                Infinite Recursion 55

                Keyboard Input 55

                Debugging 56

                Glossary 57

                Exercises 58

6. Fruitful Functions       

                Return Values 61

                Incremental Development 62

                Composition 64

                Boolean Functions 65

                More Recursion 66

                Leap of Faith 68

                One More Example 68

                Checking Types 69

                Debugging 70

                Glossary 71

                Exercises 72

7. Iteration         

                Multiple Assignment 75

                Updating Variables 76

                The while Statement 76

                break 78

                Square Roots 79

                Algorithms 80

                Debugging 81

                Glossary 81

                Exercises 82

8. Strings             

                A String Is a Sequence 85

                len 86

                Traversal with a for Loop 86

                String Slices 87

                Strings Are Immutable 88

                Searching 89

                Looping and Counting 89

                String Methods 90

                The in Operator 91

                Table of Contents | vString Comparison 92

                Debugging 92

                Glossary 94

                Exercises 95

9. Case Study: Word Play             

                Reading Word Lists 97

                Exercises 98

                Search 99

                Looping with Indices 100

                Debugging 102

                Glossary 102

                Exercises 103

10. Lists

                A List Is a Sequence 105

                Lists Are Mutable 106

                Traversing a List 107

                List Operations 107

                List Slices 108

                List Methods 108

                Map, Filter, and Reduce 109

                Deleting Elements 111

                Lists and Strings 112

                Objects and Values 112

                Aliasing 113

                List Arguments 114

                Debugging 116

                Glossary 117

                Exercises 118

11. Dictionaries

                Dictionary as a Set of Counters 123

                Looping and Dictionaries 124

                Reverse Lookup 125

                Dictionaries and Lists 126

                Memos 128

                Global Variables 129

                Long Integers 130

                Debugging 131

                Glossary 132

                vi | Table of ContentsExercises 133

12. Tuples           

                Tuples Are Immutable 135

                Tuple Assignment 136

                Tuples as Return Values 137

                Variable-Length Argument Tuples 137

                Lists and Tuples 138

                Dictionaries and Tuples 139

                Comparing Tuples 141

                Sequences of Sequences 142

                Debugging 143

                Glossary 144

                Exercises 144

13. Case Study: Data Structure Selection              

                Word Frequency Analysis 147

                Random Numbers 148

                Word Histogram 149

                Most Common Words 150

                Optional Parameters 151

                Dictionary Subtraction 151

                Random Words 152

                Markov Analysis 153

                Data Structures 154

                Debugging 156

                Glossary 157

                Exercises 158

14. Files               

                Persistence 159

                Reading and Writing 159

                Format Operator 160

                Filenames and Paths 161

                Catching Exceptions 162

                Databases 163

                Pickling 164

                Pipes 165

                Writing Modules 166

                Debugging 167

                Glossary 168

                Table of Contents | viiExercises 169

15. Classes and Objects

                User-Defined Types 171

                Attributes 172

                Rectangles 173

                Instances as Return Values 174

                Objects Are Mutable 175

                Copying 176

                Debugging 177

                Glossary 178

                Exercises 178

16. Classes and Functions            

                Time 181

                Pure Functions 182

                Modifiers 183

                Prototyping Versus Planning 184

                Debugging 185

                Glossary 186

                Exercises 187

17. Classes and Methods             

                Object-Oriented Features 189

                Printing Objects 190

                Another Example 191

                A More Complicated Example 192

                The init Method 192

                The __str__ Method 193

                Operator Overloading 194

                Type-Based Dispatch 194

                Polymorphism 196

                Debugging 197

                Interface and Implementation 197

                Glossary 198

                Exercises 199

18. Inheritance. . . . . . . . . .                                                      201

                Card Objects 201

                Class Attributes 202

                Comparing Cards 204

                Decks 205

                viii | Table of ContentsPrinting the Deck 205

                Add, Remove, Shuffle, and Sort 206

                Inheritance 207

                Class Diagrams 209

                Debugging 210

                Data Encapsulation 211

                Glossary 212

                Exercises 213

19 Case Study: Tkinter               217

                GUI 217

                Buttons and Callbacks 218

                Canvas Widgets 219

                Coordinate Sequences 220

                More Widgets 221

                Packing Widgets 222

                Menus and Callables 224

                Binding 225

                Debugging 227

                Glossary 229

                Exercises 230

ADebugging233

BAnalysis of Algorithms243

CLumpy255

Quan điểm cá nhân: Cuốn này quá đầy đủ luôn ý.