Page 14 - thinkpython
P. 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
   9   10   11   12   13   14   15   16   17   18   19