Get Programming: Learn to code with Python

Index 437 keys (continued) counting elements 245–246 restrictions on 265–266 creating 244–245 See also key-value pairs elements at specific positions 244–245 getting positions of elements 245–246 key-value pairs lists of 255–256 adding to dictionaries randomizing 346 overview 264–265 removing items from, using pop( ) restrictions on keys 265–266 removing from dictionaries 266 operation 249–250 reversing 254–255 keywords 41 sorted, copying 280 sorting 254–255 L vs. tuples 243–244 logarithmic functions 344 L variable 244 LOOK keyword 136 last3letters list 249 loop variable 147, 162 LEFT keyword 136 loops len( ) command beginning of 166–167 customizing 152–398 getting length of tuple with 84 exiting early out of 165–166 overview 70–71 for loops vs. while loops 162–164 libraries 341–423 looping certain number of times for graphical user interfaces 362–426 for loops 146–149 adding event handlers 367–370 overview 146 adding widgets 365–366 looping N times 149–150 using tkinter library 363–364 loops over common sequence 0 to N - 1 importing 342–344 mathematical operations with math 149–150 unrolling loops 150 libraries 344–346 manipulating 164–167 random numbers with random libraries repeating tasks with 143–396 while condition is true 159–161 346–348 infinite loops 161 randomizing lists 346 looping to make guesses 159–161 replicating results using seed 348 while loops 161 simulating games of chance 346–347 lower( ) command 71, 103 timing programs with time libraries M 349–350 pausing programs 350 math libraries 344–346 using clocks 349 mathematical operations 77, 86 linebreak character 172 max_tries variable 166 list operations methods append( ) command 302 pop( ) command 249 as behaviors 306–307 reverse( ) command 254 as object operations 306–307 sort( ) command 280 overriding special methods 323–324 lists 242, 253–413 minutes_decimal variable 60 adding items to 247–249 modularity, achieving with functions 194–205 using append( ) operation 247 documenting functions 204–205 using extend( ) operation 248–249 using functions 199–203 using insert( ) operation 247 writing functions 195–199 applications of 258–260 move method 375 queues 259–260 mutable objects stacks 258–259 aliases of 275–277 changing element values 250–251 converting strings to 257

438 Index mutable objects (continued) implementing using classes 304 as function parameters 277–278 using 307–309 copying 279–282 using dot notation 301–302 advantages of using aliasing 282 object-oriented programming 71 commands to copy mutable objects objects 313–419 279–280 behaviors of 300–301 copying sorted lists 280 binding variables to 238 iterating over mutable objects 281–282 creating properties inside __init__ operation overview 235–238, 240–410 305–306 N data attributes as properties 305–306 defining stack objects 314–316 n variable 147 n_times times 150 choosing data attributes 314–315 names, descriptive and meaningful 19–20 implementing methods 315–316 naming objects 39–42 immutable 235–236, 238–410 nested conditionals, examples with 115–117 initializing with __init__ operation 305 nested functions 113, 213–214, 216 inside tuples, swapping 86–87 new scope 200 methods as operations 306–307 newline character 172, 220 multiple, printing 90 NoneType 50, 201 mutable 235–238, 240–410 nonlinearity, adding to programs 145 naming 39–42 num variable 211–212 overview 39, 46–385 numbers properties of 300 types of decimal, floating points as 48–49 absence of values 50 random with random libraries 346–348 Booleans as true/false data 49 converting between 51–52 randomizing lists 346 floating points as decimal numbers 48–49 replicating results using seed 348 impact of arithmetic on 52–53 simulating games of chance 346–347 integers as whole numbers 48 whole, integers as 48 overview 47–50 number-theoretic functions 344 strings as sequences of characters 49–50 using Stack object 317–321 O See also mutable objects online, ordering items 184–186 object aliases 274–278 operations aliases of immutable objects 274–275 on string objects 67–71 aliases of mutable objects 275–277 using len( ) command 70–71 mutable objects as function parameters using lower( ) command 71 277–278 using upper( ) command 71 overview 39, 47 object types 297–417 operator precedence rules 123–125 advantages of building new 299 operators, using special operators 326–327 components of 300–301 or operation 49, 123 object behaviors 300–301 ordering object properties 300 dictionary pairs 269 creating classes for 303–418 items online 184–186 data attributes as object properties output 305–306 showing 89–90 dot notation on class names 310–311 printing expressions 89 methods as behaviors 306–307 printing multiple objects 90 methods as object operations 306–307 visible to users 33 with parameters in __init__ operation 309–310

Index 439 overriding installing 25–27 print( ) operation 325–326 Anaconda Python Distribution 26 special methods 323–324 IDEs 27 P overview 26 setup of 28–34 parameters creating classes with, in __init__ operation file editors 32–34 309–310 IPython console 30–32 passing functions as 214–215 Q parentheses, removing 224 pausing programs 350 queues 259–260 peek results 30, 42 quotation marks 49, 66 Player class 373 pointer indexes 173 R pop( ) operation 249–250 positions, of elements 244–246 radius parameter 306 power functions 52, 344 random class 331 prettyprint method 318 random libraries, random numbers with primitives 47 print keyword 33 346–348 print statements 135, 150, 202, 352 randomizing lists 346 print( ) operation replicating results using seed 348 simulating games of chance 346–347 overriding 325–326 random numbers. See numbers overview 57, 89 random.random( ) function 346 printing randomizing lists 346 expressions 89 range keyword 153 multiple objects 90 range(N) expression 149 programming 3–9 reading input 92 accessibility of 3–4 recalculating values 36 advantages of learning 4 Rectangle class 342 as skill 10 rectangular boxes 14 basic concepts 5–7 remainder operation 52 compared with baking 11–15 removing items from lists, using pop( ) importance of 3–5 programs operation 249–250 adding nonlinearity to 145 repeating separating from tests tasks 144–145 overview 354–357 adding nonlinearity to programs 145 types of tests 357 infinite repetitions 145 structuring 112–117 timing with time libraries 349–350 tasks while conditions hold 158–399 pausing programs 350 looping while condition is true 159–161 using clocks 349 manipulating loops 164–167 properties, of objects 300 using for loops vs. while loops 162–164 pseudocode overview 178 tasks with loops 143–396 writing 18–19 looping certain number of times 146–149 .py file 34, 286 looping N times 149–150 Python programming language 25–382 downloading 26 replace( ) operation 77, 222, 224 replicating results, using seed 348 representation functions 344 requesting input 94 restrictions, on keys 265–266 return keyword 195, 198

440 Index return statements, functions without 201–203 expressions, examples of 50–51 returning functions overview 46–50, 53–385 storing input, in variables 92–93 overview 198–199, 215–218 str type 49, 66 returning more than one value 200–201 string objects 65–387 reusable subtasks 186 as sequences of characters 66–70 reusing code 189–191 creating 67 reverse find 75 indexing into 67–68 reversing lists 254–255 operations on 67–71 round( ) command 53 rubber ducky debugging 358 using len( ) command 70–71 RuntimeError 281 using lower( ) command 71 using upper( ) command 71 S slicing 68–70 string operations 73–388 sample test cases 56 mathematical 77–78 saving, files 34 related to substrings 74–77 scalars 47 counting substrings with count( ) scheduling events 328 operation 76–77 using classes 328 finding substrings with find( ) operation using too many classes 328 without using classes 328 74–75 scopes 208–213 replacing substrings with replace( ) example 208 rules 209–213 operation 77 seeds, replicating results using 348 using 76 self variable 305 string.punctuation 287 sequences of characters, strings as 49–50 strings simulating games of chance 346–347 as sequences of characters 49–50 single-character strings 83 converting to lists 257 sleep method 368 error messages 80 slicing string objects 68–70 looping over 154–155 sort( ) operation 254 strip function 222 sorting lists 254–255 structuring programs 112–117 spaces, removing 224 sublists 253 special methods 327 subpaths, creating 136 specifications 204 substrings split( ) operation 257, 287 counting with count( ) operation 76–77 spreadsheets, Excel 219 finding with find( ) operation 74–75 Spyder 27 operations related to 74–77 square brackets 68, 84, 244, 322 replacing with replace( ) operation 77 square brackets character 68, 244, 322 using 76 Stack object subtasks 191–193 creating stacks 317–321 swapcase( ) command 71 overview 317 syntax highlighting 41, 111 stacks creating 317–321 T defining objects 314–316 task abstraction 185 choosing data attributes 314–315 task dependence 184 implementing methods 315–316 task independence 184 overview 258–259 tasks statements adding conditions to 110 black boxes of code 187–191 abstracting code 188–189

Index 441 tasks, black boxes of code (continued) unit testing 355 reusing code 189–191 unittest library 353–354, 361 using code modules 188 unrolling loops 150 updating variables 42–44 breaking into smaller tasks 184–187 upper( ) command 71 repeating 144–145 users 88–391 adding nonlinearity to programs 145 getting input from 91–94 infinite repetitions 145 converting user input to different types repeating while conditions hold 158–399 93–94 looping while condition is true 159–161 prompting users 91 manipulating loops 164–167 reading input 92 using for loops vs. while loops 162–164 requesting more input 94 repeating with loops 143–396 storing input in variables 92–93 looping certain number of times 146–149 looping N times 149–150 of functions 208 subtasks 191–193 showing output 89–90 understanding 16–17 visualizing 17–18 printing expressions 89 testing 352–424 printing multiple objects 90 overview 15–19 separating programs from tests V overview 354–357 types of tests 357 ValueError 246 working with unittest library 353–354 values TestPrime class 355 time libraries, timing programs with 349–350 absence of 50 pausing programs 350 creating 263–264 using clocks 349 in dictionaries 267–269 timing programs, with time libraries 349–350 of elements, changing 250–251 pausing programs 350 overview 38, 46 using clocks 349 See also key-value pairs tkinter library 363–364, 366, 371 variable assignment 113, 274 tracing 211 variables 44–384 trigonometric functions 344 capabilities of computers 38–39 triple quotes 204, 207 creating 42 true/false data, Booleans as 49 in programming 37–38 true/false expressions 108–109, 122–123 input in variables 92–93 truth values 121 objects as 39–42 tuple objects 82–390 overview 36–39 as sequences of data 83–84 updating 42–44 operations on 84–87 visualizing tasks 17–18 getting length with len( ) command 84 performing mathematical operations 86 W swapping objects inside 86–87 vs. lists 243–244 while loops type( ) command 51, 53 for loops vs. 162–164 overview 161 U whole numbers, integers as 48 unconventional dictionaries, building widgets, adding 365–366 270–271 writing underscore character 40 code 19–21 commenting code 20–21 to make decisions 110–112 using descriptive and meaningful names 19–20

442 Index writing (continued) commands directly into IPython console 30 functions 195–199, 207–208 implementing functions 197 inputs to functions 197 returns from functions 198–199 Y yes/no questions 108–109

Thinking like a programmer: big ideas (continued) Idea Thinking like a programmer—details Section Readability Abstraction Write code that’s as simple and short as possible while being 18.2 Abstraction easy to understand. Modularity You hide implementation details from people by using your class. 32.1 Modularity Users don’t need to know the implementation to use the class. Debugging Debugging Before running a function on large input files, try it on a smaller 29.3 test file. Documenta- tion Divide your code into smaller pieces and test each one sepa- 19.1.2 Documenta- rately. After you know that each separate piece works as tion expected, you can put the pieces together to create your final program. Functions should be self-contained pieces of code that you need 29.2 to debug only once but that you can reuse many times. Using descriptive names for methods is useful in providing quick, 36.2 at-a-glance information when tests fail. While debugging, trace through a program. Go line by line, draw 22.2.2 the scope you’re in, and write down any variables and their values currently in the scope. When faced with writing a line of code, browse the Python docu- 23.1.3 mentation to see what functions you can use before writing your own. A programmer tries to make life easier for other programmers. 33.3 Document your classes and methods, and whenever possible, implement special methods.