Page 14 - thinkpython
P. 14

xiv                                                                    Contents

                  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 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .  38

                     4.11  Glossary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .  38
                     4.12  Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .  39
   9   10   11   12   13   14   15   16   17   18   19