19 |24 | {% endblock stream %} 25 | 26 | {% block data_text scoped %} 27 |output20 |21 | {{ output.text }} 22 |23 |
28 |33 | {% endblock data_text %} 34 | -------------------------------------------------------------------------------- /workshops/docs/modules/notebooks/nbconvert_templates/instructor.tpl: -------------------------------------------------------------------------------- 1 | {% extends 'workshop_notes.tpl'%} 2 | 3 | {% block any_cell %} 4 | {% if 'challenge' in cell['metadata'].get('tags', []) %} 5 |output29 |30 | {{ output.get('data', {}).get('text/plain', '') }} 31 |32 |
82 |91 | 92 | 93 | 94 | 95 | 96 | While this works, it's a bad approach for two reasons: 97 | 98 | 1. It doesn't scale: 99 | if we want to print the characters in a string that's hundreds of letters long, 100 | we'd be better off just typing them in. 101 | 102 | 2. It's fragile: 103 | if we give it a longer string, 104 | it only prints part of the data, 105 | and if we give it a shorter one, 106 | it produces an error because we're asking for characters that don't exist. 107 | 108 | 109 | 110 | 111 | 112 | 113 | 114 | Running: 115 | 116 | ```python 117 | word = 'tin' 118 | print(word[0]) 119 | print(word[1]) 120 | print(word[2]) 121 | print(word[3]) 122 | ``` 123 | 124 | 125 | 126 | 127 | 128 | Gives the error: 129 | 130 | ``` 131 | --------------------------------------------------------------------------- 132 | IndexError Traceback (most recent call last) 133 |output83 |84 | l 85 | e 86 | a 87 | d 88 | 89 |90 |
163 |172 | 173 | 174 | 175 | 176 | 177 | This is shorter --- certainly shorter than something that prints every character in a hundred-letter string --- and 178 | more robust as well: 179 | 180 | 181 | 182 | 183 | 184 | 185 | ```python 186 | word = 'oxygen' 187 | for char in word: 188 | print(char) 189 | ``` 190 | 191 |output164 |165 | l 166 | e 167 | a 168 | d 169 | 170 |171 |
192 |203 | 204 | 205 | 206 | 207 | 208 | The improved version uses a **for loop** to repeat an operation --- in this case, printing --- once for each thing in a sequence. 209 | The general form of a loop is: 210 | 211 | ```python 212 | for variable in collection: 213 | # do things with variable 214 | ``` 215 | 216 | 217 | 218 | 219 | 220 | 221 | Using the oxygen example above, the loop might look like this: 222 | 223 |  224 | 225 | where each character (`char`) in the variable `word` is looped through and printed one character after another. 226 | The numbers in the diagram denote which loop cycle the character was printed in (1 being the first loop, and 6 being the final loop). 227 | 228 | We can call the **loop variable** anything we like, 229 | but there must be a colon at the end of the line starting the loop, and we must indent anything we want to run inside the loop. Unlike many other languages, there is no command to signify the end of the loop body (e.g. `end for`); what is indented after the `for` statement belongs to the loop. 230 | 231 | 232 | 233 | 234 | 235 | 236 | 237 | 238 | ## What's in a name? 239 | 240 | 241 | In the example above, the loop variable was given the name `char` as a mnemonic; it is short for 'character'. 242 | We can choose any name we want for variables. We might just as easily have chosen the name `banana` for the loop variable, as long as we use the same name when we invoke the variable inside the loop: 243 | 244 | 245 | 246 | 247 | 248 | 249 | 250 | 251 | ```python 252 | word = 'oxygen' 253 | for banana in word: 254 | print(banana) 255 | ``` 256 | 257 |output193 |194 | o 195 | x 196 | y 197 | g 198 | e 199 | n 200 | 201 |202 |
258 |269 | 270 | 271 | 272 | 273 | 274 | It is a good idea to choose variable names that are meaningful, otherwise it would be more difficult to understand what the loop is doing. 275 | 276 | 277 | Here's another loop that repeatedly updates a variable: 278 | 279 | 280 | 281 | 282 | 283 | 284 | ```python 285 | length = 0 286 | for vowel in 'aeiou': 287 | length = length + 1 288 | print('There are', length, 'vowels') 289 | ``` 290 | 291 |output259 |260 | o 261 | x 262 | y 263 | g 264 | e 265 | n 266 | 267 |268 |
292 |298 | 299 | 300 | 301 | 302 | 303 | It's worth tracing the execution of this little program step by step. 304 | 305 | Since there are five characters in `'aeiou'`, 306 | the statement on line 3 will be executed five times. 307 | 308 | The first time around, 309 | `length` is zero (the value assigned to it on line 1) 310 | and `vowel` is `'a'`. 311 | The statement adds 1 to the old value of `length`, 312 | producing 1, 313 | and updates `length` to refer to that new value. 314 | 315 | The next time around, 316 | `vowel` is `'e'` and `length` is 1, 317 | so `length` is updated to be 2. 318 | 319 | After three more updates, 320 | `length` is 5; 321 | since there is nothing left in `'aeiou'` for Python to process, 322 | the loop finishes 323 | and the `print` statement on line 4 tells us our final answer. 324 | 325 | Note that a loop variable `vowel` is just a variable that's being used to record progress in a loop. 326 | 327 | 328 | 329 | 330 | 331 | ## Challenge - scope of the loop variable 332 | 333 | 1. In the loop over `"aeiou"` above, does the loop variable `vowel` exist after the loop has finished ? 334 | 335 | 336 | 337 | 338 | 339 | 340 | 341 | ```python 342 | length = 0 343 | for vowel in 'aeiou': 344 | length = length + 1 345 | print('After the loop, `vowel` exists and has the value: ' + vowel) 346 | 347 | # The loop variable `vowel` exists after the loop is completed, not only inside the loop 348 | ``` 349 | 350 |output293 |294 | There are 5 vowels 295 | 296 |297 |
351 |357 | 358 | 359 | 360 | 361 | 362 | Note also that finding the length of a string is such a common operation that Python actually has a built-in function to do it called `len`: 363 | 364 | 365 | 366 | 367 | 368 | 369 | ```python 370 | print(len('aeiou')) 371 | ``` 372 | 373 |output352 |353 | After the loop, `vowel` exists and has the value: u 354 | 355 |356 |
374 |380 | 381 | 382 | 383 | 384 | 385 | `len` is much faster than any function we could write ourselves, 386 | and much easier to read than a two-line loop; 387 | it will also give us the length of many other things that we haven't met yet, 388 | so we should always use it when we can. 389 | 390 | 391 | 392 | 393 | 394 | ## From 1 to N 395 | 396 | Python has a built-in function called `range` that creates a sequence of numbers. `range` can 397 | accept 1, 2, or 3 parameters. 398 | 399 | * If one parameter is given, `range` creates an array of that length, 400 | starting at zero and incrementing by 1. 401 | For example, `range(3)` produces the numbers `0, 1, 2`. 402 | * If two parameters are given, `range` starts at 403 | the first and ends just before the second, incrementing by one. 404 | For example, `range(2, 5)` produces `2, 3, 4`. 405 | * If `range` is given 3 parameters, 406 | it starts at the first one, ends just before the second one, and increments by the third one. 407 | For exmaple `range(3, 10, 2)` produces `3, 5, 7, 9`. 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | ## Challenge - loop over a range 416 | Using `range`, 417 | write a loop that uses `range` to print the first 3 natural numbers: 418 | 419 | ``` 420 | 1 421 | 2 422 | 3 423 | ``` 424 | 425 | 426 | 427 | 428 | 429 | 430 | 431 | 434 | 435 | 436 | 437 | 454 | 455 | 456 | 457 | 458 | ## Computing Powers With Loops 459 | 460 | Exponentiation is built into Python: 461 | 462 | 463 | 464 | 465 | 466 | 467 | ```python 468 | print(5 ** 3) 469 | ``` 470 | 471 |output375 |376 | 5 377 | 378 |379 |
472 |478 | 479 | 480 | 481 | 482 | 483 | ## Challenge - multiplication in a loop 484 | 485 | Write a loop that calculates the same result as `5 ** 3` using 486 | multiplication (and without exponentiation). 487 | 488 | 489 | 490 | 491 | 494 | 495 | 496 | 497 | 514 | 515 | 516 | 517 | 518 | ## Bonus challenge: reverse a string 519 | 520 | Knowing that two strings can be concatenated using the `+` operator, 521 | write a loop that takes a string 522 | and produces a new string with the characters in reverse order, 523 | so `'Newton'` becomes `'notweN'`. 524 | 525 | 526 | 527 | 528 | 531 | 532 | 533 | 534 | 552 | 553 | 554 | 555 | 556 | ## Enumerate 557 | 558 | The built-in function `enumerate` takes a sequence (e.g. a list) and generates a 559 | new sequence of the same length. Each element of the new sequence is a pair composed of the index 560 | (0, 1, 2,...) and the value from the original sequence: 561 | 562 | ``` 563 | for i, x in enumerate(xs): 564 | # Do something with i and x 565 | ``` 566 | 567 | 568 | The code above loops through `xs`, assigning the index to `i` and the value to `x`. 569 | 570 | 571 | 572 | 573 | 574 | ## Bonus challenge: enumeration for computing the value of a polynomial 575 | 576 | Suppose you have encoded a polynomial as a list of coefficients in 577 | the following way: the first element is the constant term, the 578 | second element is the coefficient of the linear term, the third is the 579 | coefficient of the quadratic term, etc. 580 | 581 | ``` 582 | x = 5 583 | cc = [2, 4, 3] 584 | ``` 585 | 586 | 587 | ``` 588 | y = cc[0] * x**0 + cc[1] * x**1 + cc[2] * x**2 589 | y = 97 590 | ``` 591 | 592 | 593 | Write a loop using `enumerate(cc)` which computes the value `y` of any 594 | polynomial, given `x` and `cc`. 595 | 596 | 597 | 598 | 599 | 602 | 603 | 604 | 605 | 627 | 628 | 629 | 630 | 631 | 632 | ```python 633 | 634 | ``` 635 | 636 | 637 | -------------------------------------------------------------------------------- /workshops/docs/modules/notebooks/wip/slicing_and_list_comprehensions.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "slideshow": { 7 | "slide_type": "slide" 8 | } 9 | }, 10 | "source": [ 11 | "## Slicing lists" 12 | ] 13 | }, 14 | { 15 | "cell_type": "code", 16 | "execution_count": 41, 17 | "metadata": {}, 18 | "outputs": [ 19 | { 20 | "data": { 21 | "text/plain": [ 22 | "[2, 4, 6]" 23 | ] 24 | }, 25 | "execution_count": 41, 26 | "metadata": {}, 27 | "output_type": "execute_result" 28 | } 29 | ], 30 | "source": [ 31 | "numbers = [2, 4, 6, 8, 10, 12]\n", 32 | "\n", 33 | "# list[start:end]\n", 34 | "# start is inclusive, end isn't\n", 35 | "\n", 36 | "numbers[0:3]" 37 | ] 38 | }, 39 | { 40 | "cell_type": "code", 41 | "execution_count": 42, 42 | "metadata": {}, 43 | "outputs": [ 44 | { 45 | "data": { 46 | "text/plain": [ 47 | "[10, 12]" 48 | ] 49 | }, 50 | "execution_count": 42, 51 | "metadata": {}, 52 | "output_type": "execute_result" 53 | } 54 | ], 55 | "source": [ 56 | "numbers[4:7]" 57 | ] 58 | }, 59 | { 60 | "cell_type": "code", 61 | "execution_count": 43, 62 | "metadata": {}, 63 | "outputs": [ 64 | { 65 | "data": { 66 | "text/plain": [ 67 | "[2, 4, 6]" 68 | ] 69 | }, 70 | "execution_count": 43, 71 | "metadata": {}, 72 | "output_type": "execute_result" 73 | } 74 | ], 75 | "source": [ 76 | "numbers[:3] # omitting start implies 0 (the very start)" 77 | ] 78 | }, 79 | { 80 | "cell_type": "code", 81 | "execution_count": 44, 82 | "metadata": {}, 83 | "outputs": [ 84 | { 85 | "data": { 86 | "text/plain": [ 87 | "[8, 10, 12]" 88 | ] 89 | }, 90 | "execution_count": 44, 91 | "metadata": {}, 92 | "output_type": "execute_result" 93 | } 94 | ], 95 | "source": [ 96 | "numbers[3:] # omitting end means to the very end eg len(numbers)" 97 | ] 98 | }, 99 | { 100 | "cell_type": "code", 101 | "execution_count": 45, 102 | "metadata": { 103 | "slideshow": { 104 | "slide_type": "subslide" 105 | } 106 | }, 107 | "outputs": [ 108 | { 109 | "data": { 110 | "text/plain": [ 111 | "[12]" 112 | ] 113 | }, 114 | "execution_count": 45, 115 | "metadata": {}, 116 | "output_type": "execute_result" 117 | } 118 | ], 119 | "source": [ 120 | "numbers[-1:] # negative values reverse direction" 121 | ] 122 | }, 123 | { 124 | "cell_type": "code", 125 | "execution_count": 46, 126 | "metadata": {}, 127 | "outputs": [ 128 | { 129 | "data": { 130 | "text/plain": [ 131 | "[2, 4, 6, 8, 10]" 132 | ] 133 | }, 134 | "execution_count": 46, 135 | "metadata": {}, 136 | "output_type": "execute_result" 137 | } 138 | ], 139 | "source": [ 140 | "numbers[:-1]" 141 | ] 142 | }, 143 | { 144 | "cell_type": "code", 145 | "execution_count": 47, 146 | "metadata": { 147 | "slideshow": { 148 | "slide_type": "subslide" 149 | } 150 | }, 151 | "outputs": [ 152 | { 153 | "data": { 154 | "text/plain": [ 155 | "[2, 6, 10]" 156 | ] 157 | }, 158 | "execution_count": 47, 159 | "metadata": {}, 160 | "output_type": "execute_result" 161 | } 162 | ], 163 | "source": [ 164 | "# you can also specify a step size\n", 165 | "# list[start:end:step]\n", 166 | "\n", 167 | "numbers[0:6:2]" 168 | ] 169 | }, 170 | { 171 | "cell_type": "code", 172 | "execution_count": 48, 173 | "metadata": { 174 | "slideshow": { 175 | "slide_type": "subslide" 176 | } 177 | }, 178 | "outputs": [ 179 | { 180 | "data": { 181 | "text/plain": [ 182 | "[2, 4, 6, 8, 10, 12]" 183 | ] 184 | }, 185 | "execution_count": 48, 186 | "metadata": {}, 187 | "output_type": "execute_result" 188 | } 189 | ], 190 | "source": [ 191 | "# [:] is a shorthand for copying a list.\n", 192 | "# Equivalent to:\n", 193 | "# n_copy = list(numbers)\n", 194 | "\n", 195 | "n_copy = numbers[:]\n", 196 | "n_copy" 197 | ] 198 | }, 199 | { 200 | "cell_type": "code", 201 | "execution_count": 49, 202 | "metadata": {}, 203 | "outputs": [ 204 | { 205 | "data": { 206 | "text/plain": [ 207 | "[2, 4, 6, 8, 10, 12]" 208 | ] 209 | }, 210 | "execution_count": 49, 211 | "metadata": {}, 212 | "output_type": "execute_result" 213 | } 214 | ], 215 | "source": [ 216 | "n_copy[3] = 8\n", 217 | "n_copy" 218 | ] 219 | }, 220 | { 221 | "cell_type": "code", 222 | "execution_count": 50, 223 | "metadata": {}, 224 | "outputs": [ 225 | { 226 | "data": { 227 | "text/plain": [ 228 | "[2, 4, 6, 8, 10, 12]" 229 | ] 230 | }, 231 | "execution_count": 50, 232 | "metadata": {}, 233 | "output_type": "execute_result" 234 | } 235 | ], 236 | "source": [ 237 | "numbers" 238 | ] 239 | }, 240 | { 241 | "cell_type": "markdown", 242 | "metadata": { 243 | "slideshow": { 244 | "slide_type": "slide" 245 | }, 246 | "tags": [ 247 | "challenge" 248 | ] 249 | }, 250 | "source": [ 251 | "### Challenge 1\n", 252 | "\n", 253 | "Given the list: `['banana', 'cherry', 'strawberry', 'orange']`\n", 254 | "\n", 255 | "Return a list of just the red fruits." 256 | ] 257 | }, 258 | { 259 | "cell_type": "markdown", 260 | "metadata": { 261 | "tags": [ 262 | "solution" 263 | ] 264 | }, 265 | "source": [ 266 | "### Solution" 267 | ] 268 | }, 269 | { 270 | "cell_type": "code", 271 | "execution_count": 51, 272 | "metadata": { 273 | "slideshow": { 274 | "slide_type": "slide" 275 | }, 276 | "tags": [ 277 | "solution" 278 | ] 279 | }, 280 | "outputs": [ 281 | { 282 | "data": { 283 | "text/plain": [ 284 | "['cherry', 'strawberry']" 285 | ] 286 | }, 287 | "execution_count": 51, 288 | "metadata": {}, 289 | "output_type": "execute_result" 290 | } 291 | ], 292 | "source": [ 293 | "fruits = ['banana', 'cherry', 'strawberry', 'orange']\n", 294 | "red_ones = fruits[1:3]\n", 295 | "red_ones" 296 | ] 297 | }, 298 | { 299 | "cell_type": "markdown", 300 | "metadata": { 301 | "slideshow": { 302 | "slide_type": "slide" 303 | } 304 | }, 305 | "source": [ 306 | "## Loops" 307 | ] 308 | }, 309 | { 310 | "cell_type": "markdown", 311 | "metadata": { 312 | "slideshow": { 313 | "slide_type": "subslide" 314 | } 315 | }, 316 | "source": [ 317 | "A `for` loop works on a sequence types, generators and iterators\n", 318 | "\n", 319 | "(this includes lists, tuples, strings and dictionaries)" 320 | ] 321 | }, 322 | { 323 | "cell_type": "code", 324 | "execution_count": 74, 325 | "metadata": {}, 326 | "outputs": [ 327 | { 328 | "name": "stdout", 329 | "output_type": "stream", 330 | "text": [ 331 | "A\n", 332 | "B\n", 333 | "C\n", 334 | "D\n", 335 | ".\n", 336 | ".\n", 337 | "m\n", 338 | "e\n", 339 | "h\n" 340 | ] 341 | } 342 | ], 343 | "source": [ 344 | "for letter in \"ABCD..meh\":\n", 345 | " print(letter)" 346 | ] 347 | }, 348 | { 349 | "cell_type": "code", 350 | "execution_count": 75, 351 | "metadata": { 352 | "slideshow": { 353 | "slide_type": "subslide" 354 | } 355 | }, 356 | "outputs": [ 357 | { 358 | "name": "stdout", 359 | "output_type": "stream", 360 | "text": [ 361 | "('Z', 99)\n", 362 | "('Y', 98)\n", 363 | "('X', 97)\n", 364 | "Z 99\n", 365 | "Y 98\n", 366 | "X 97\n" 367 | ] 368 | } 369 | ], 370 | "source": [ 371 | "ts = [('Z', 99), ('Y', 98), ('X', 97)]\n", 372 | "\n", 373 | "for t in ts:\n", 374 | " print(t)\n", 375 | " \n", 376 | "# using tuple unpacking\n", 377 | "for m, n in ts:\n", 378 | " print(m, n)" 379 | ] 380 | }, 381 | { 382 | "cell_type": "code", 383 | "execution_count": 76, 384 | "metadata": { 385 | "slideshow": { 386 | "slide_type": "subslide" 387 | } 388 | }, 389 | "outputs": [ 390 | { 391 | "name": "stdout", 392 | "output_type": "stream", 393 | "text": [ 394 | "('A', 1)\n", 395 | "('B', 2)\n", 396 | "('C', 3)\n" 397 | ] 398 | } 399 | ], 400 | "source": [ 401 | "# for on dictionary.items()\n", 402 | "d = {'A': 1, 'B': 2, 'C': 3}\n", 403 | "\n", 404 | "for item in d.items():\n", 405 | " # print(type(item))\n", 406 | " print(item)" 407 | ] 408 | }, 409 | { 410 | "cell_type": "code", 411 | "execution_count": 77, 412 | "metadata": { 413 | "slideshow": { 414 | "slide_type": "subslide" 415 | } 416 | }, 417 | "outputs": [ 418 | { 419 | "name": "stdout", 420 | "output_type": "stream", 421 | "text": [ 422 | "A 1\n", 423 | "B 2\n", 424 | "C 3\n" 425 | ] 426 | } 427 | ], 428 | "source": [ 429 | "for k, v in d.items():\n", 430 | " print(k, v)" 431 | ] 432 | }, 433 | { 434 | "cell_type": "markdown", 435 | "metadata": { 436 | "slideshow": { 437 | "slide_type": "subslide" 438 | } 439 | }, 440 | "source": [ 441 | "`while` loops keep looping while their condition is true:\n", 442 | "\n", 443 | "```\n", 444 | "while some_condition:\n", 445 | " do_stuff()\n", 446 | "```\n", 447 | "\n", 448 | "Note: If the condition for your `while` loops never becomes `False`, the loop will run forever (in Jupyter you can do *Kernel -> Interrupt* to break out of the infinite loop)." 449 | ] 450 | }, 451 | { 452 | "cell_type": "code", 453 | "execution_count": 78, 454 | "metadata": {}, 455 | "outputs": [ 456 | { 457 | "name": "stdout", 458 | "output_type": "stream", 459 | "text": [ 460 | "0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 " 461 | ] 462 | } 463 | ], 464 | "source": [ 465 | "a = 0\n", 466 | "while a < 16:\n", 467 | " print(a, end=' ')\n", 468 | " a += 1" 469 | ] 470 | }, 471 | { 472 | "cell_type": "markdown", 473 | "metadata": { 474 | "slideshow": { 475 | "slide_type": "subslide" 476 | } 477 | }, 478 | "source": [ 479 | "`break` immediately exits a loop\n", 480 | "\n", 481 | "`continue` immediately starts the next iteration of the loop\n", 482 | "\n", 483 | "Any code inside the loop after a `break` or `continue` is skipped." 484 | ] 485 | }, 486 | { 487 | "cell_type": "code", 488 | "execution_count": 79, 489 | "metadata": {}, 490 | "outputs": [ 491 | { 492 | "name": "stdout", 493 | "output_type": "stream", 494 | "text": [ 495 | "2 4 6 8 10 12 14 16 " 496 | ] 497 | } 498 | ], 499 | "source": [ 500 | "a = 0\n", 501 | "while True:\n", 502 | " a += 1\n", 503 | " \n", 504 | " if a > 16:\n", 505 | " break\n", 506 | " print('We will never see this.')\n", 507 | " \n", 508 | " if a % 2:\n", 509 | " continue\n", 510 | " print('We will also never see this.')\n", 511 | " \n", 512 | " print(a, end=' ')" 513 | ] 514 | }, 515 | { 516 | "cell_type": "markdown", 517 | "metadata": { 518 | "slideshow": { 519 | "slide_type": "slide" 520 | } 521 | }, 522 | "source": [ 523 | "## List comprehensions\n", 524 | "\n", 525 | "List comprehensions are a shorthand way to loop over a list, modify the items and create a new list." 526 | ] 527 | }, 528 | { 529 | "cell_type": "code", 530 | "execution_count": 80, 531 | "metadata": { 532 | "slideshow": { 533 | "slide_type": "subslide" 534 | } 535 | }, 536 | "outputs": [ 537 | { 538 | "data": { 539 | "text/plain": [ 540 | "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]" 541 | ] 542 | }, 543 | "execution_count": 80, 544 | "metadata": {}, 545 | "output_type": "execute_result" 546 | } 547 | ], 548 | "source": [ 549 | "# Instead of doing\n", 550 | "new_list = []\n", 551 | "for i in range(0,11):\n", 552 | " new_list.append(i**2)\n", 553 | "\n", 554 | "new_list" 555 | ] 556 | }, 557 | { 558 | "cell_type": "code", 559 | "execution_count": 81, 560 | "metadata": {}, 561 | "outputs": [ 562 | { 563 | "data": { 564 | "text/plain": [ 565 | "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]" 566 | ] 567 | }, 568 | "execution_count": 81, 569 | "metadata": {}, 570 | "output_type": "execute_result" 571 | } 572 | ], 573 | "source": [ 574 | "# Use a list comprehension instead\n", 575 | "new_list = [i**2 for i in range(0,11)]\n", 576 | "new_list" 577 | ] 578 | }, 579 | { 580 | "cell_type": "code", 581 | "execution_count": 82, 582 | "metadata": { 583 | "slideshow": { 584 | "slide_type": "subslide" 585 | } 586 | }, 587 | "outputs": [ 588 | { 589 | "data": { 590 | "text/plain": [ 591 | "[0, 1, 4, 9]" 592 | ] 593 | }, 594 | "execution_count": 82, 595 | "metadata": {}, 596 | "output_type": "execute_result" 597 | } 598 | ], 599 | "source": [ 600 | "# You can also `filter` values using an if statement inside the list comprehension\n", 601 | "new_list = [i**2 for i in range(0,11) if i < 4]\n", 602 | "new_list" 603 | ] 604 | } 605 | ], 606 | "metadata": { 607 | "celltoolbar": "Tags", 608 | "kernelspec": { 609 | "display_name": "Python 3", 610 | "language": "python", 611 | "name": "python3" 612 | }, 613 | "language_info": { 614 | "codemirror_mode": { 615 | "name": "ipython", 616 | "version": 3 617 | }, 618 | "file_extension": ".py", 619 | "mimetype": "text/x-python", 620 | "name": "python", 621 | "nbconvert_exporter": "python", 622 | "pygments_lexer": "ipython3", 623 | "version": "3.6.3" 624 | } 625 | }, 626 | "nbformat": 4, 627 | "nbformat_minor": 2 628 | } 629 | -------------------------------------------------------------------------------- /workshops/docs/modules/notebooks/wip/basics_data_carpentry.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# The Basics of Python\n", 8 | "\n", 9 | "Python is a general purpose programming language that supports rapid development\n", 10 | "of scripts and applications.\n", 11 | "\n", 12 | "Python's main advantages:\n", 13 | "\n", 14 | "* Open Source software, supported by Python Software Foundation\n", 15 | "* Available on all major platforms (ie. Windows, Linux and MacOS) \n", 16 | "* It is a general-purpose programming language, designed for readability\n", 17 | "* Supports multiple programming paradigms ('functional', 'object oriented')\n", 18 | "* Very large community with a rich ecosystem of third-party packages" 19 | ] 20 | }, 21 | { 22 | "cell_type": "markdown", 23 | "metadata": {}, 24 | "source": [ 25 | "## Interpreter\n", 26 | "\n", 27 | "Python is an interpreted language which can be used in two ways:\n", 28 | "\n", 29 | "* \"Interactive\" Mode: It functions like an \"advanced calculator\" Executing\n", 30 | " one command at a time:\n", 31 | "\n" 32 | ] 33 | }, 34 | { 35 | "cell_type": "code", 36 | "execution_count": null, 37 | "metadata": {}, 38 | "outputs": [], 39 | "source": [ 40 | "user:host:~$ python\n", 41 | "Python 3.5.1 (default, Oct 23 2015, 18:05:06)\n", 42 | "[GCC 4.8.3] on linux2\n", 43 | "Type \"help\", \"copyright\", \"credits\" or \"license\" for more information.\n", 44 | ">>> 2 + 2\n", 45 | "4\n", 46 | ">>> print(\"Hello World\")\n", 47 | "Hello World\n" 48 | ] 49 | }, 50 | { 51 | "cell_type": "markdown", 52 | "metadata": {}, 53 | "source": [ 54 | "\n", 55 | "* \"Scripting\" Mode: Executing a series of \"commands\" saved in text file,\n", 56 | " usually with a `.py` extension after the name of your file:\n", 57 | "\n", 58 | "```bash\n", 59 | "user:host:~$ python my_script.py\n", 60 | "Hello World\n", 61 | "```\n", 62 | "\n", 63 | "\n" 64 | ] 65 | }, 66 | { 67 | "cell_type": "markdown", 68 | "metadata": {}, 69 | "source": [ 70 | "## Introduction to Python built-in data types\n", 71 | "\n", 72 | "### Strings, integers and floats\n", 73 | "\n", 74 | "One of the most basic things we can do in Python is assign values to variables:\n", 75 | "\n" 76 | ] 77 | }, 78 | { 79 | "cell_type": "code", 80 | "execution_count": null, 81 | "metadata": {}, 82 | "outputs": [], 83 | "source": [ 84 | "text = \"Data Fluency\" # An example of a string\n", 85 | "number = 42 # An example of an integer\n", 86 | "pi_value = 3.1415 # An example of a float\n" 87 | ] 88 | }, 89 | { 90 | "cell_type": "markdown", 91 | "metadata": {}, 92 | "source": [ 93 | "\n", 94 | "Here we've assigned data to the variables `text`, `number` and `pi_value`,\n", 95 | "using the assignment operator `=`. To review the value of a variable, we\n", 96 | "can type the name of the variable into the Jupyter notebook and press **Shift** and **Enter**:\n", 97 | "\n" 98 | ] 99 | }, 100 | { 101 | "cell_type": "code", 102 | "execution_count": null, 103 | "metadata": {}, 104 | "outputs": [], 105 | "source": [ 106 | "text\n", 107 | "## Which Returns\n", 108 | "\"Data Fluency\"\n" 109 | ] 110 | }, 111 | { 112 | "cell_type": "markdown", 113 | "metadata": {}, 114 | "source": [ 115 | "\n", 116 | "Everything in Python has a type. To get the type of something, we can pass it\n", 117 | "to the built-in function `type`:\n", 118 | "\n" 119 | ] 120 | }, 121 | { 122 | "cell_type": "code", 123 | "execution_count": null, 124 | "metadata": {}, 125 | "outputs": [], 126 | "source": [ 127 | "type(text)\n", 128 | " str\n", 129 | "type(number)\n", 130 | " int\n", 131 | "type(6.02)\n", 132 | " float\n" 133 | ] 134 | }, 135 | { 136 | "cell_type": "markdown", 137 | "metadata": {}, 138 | "source": [ 139 | "\n", 140 | "The variable `text` is of type `str`, short for \"string\". Strings hold\n", 141 | "sequences of characters, which can be letters, numbers, punctuation\n", 142 | "or more exotic forms of text (even emoji!).\n", 143 | "\n", 144 | "We can also see the value of something using another built-in function, `print`:\n", 145 | "\n" 146 | ] 147 | }, 148 | { 149 | "cell_type": "code", 150 | "execution_count": null, 151 | "metadata": {}, 152 | "outputs": [], 153 | "source": [ 154 | "\n", 155 | "print(text)\n", 156 | "Data Fluency\n", 157 | "\n", 158 | "print(11)\n", 159 | "11\n" 160 | ] 161 | }, 162 | { 163 | "cell_type": "markdown", 164 | "metadata": {}, 165 | "source": [ 166 | "\n", 167 | "This may seem redundant, but in fact it's the only way to display output in a script:\n", 168 | "\n", 169 | "*example.py*\n" 170 | ] 171 | }, 172 | { 173 | "cell_type": "code", 174 | "execution_count": null, 175 | "metadata": {}, 176 | "outputs": [], 177 | "source": [ 178 | "# A Python script file\n", 179 | "# Comments in Python start with #\n", 180 | "# The next line assigns the string \"Data Carpentry\" to the variable \"text\".\n", 181 | "text = \"Data Fluency\"\n", 182 | "# The next line does nothing!\n", 183 | "text\n", 184 | "# The next line uses the print function to print out the value we assigned to \"text\"\n", 185 | "print(text)\n" 186 | ] 187 | }, 188 | { 189 | "cell_type": "markdown", 190 | "metadata": {}, 191 | "source": [ 192 | "*Running the script*\n", 193 | "```bash\n", 194 | "$ python example.py\n", 195 | "Data Fluency\n", 196 | "```\n", 197 | "\n", 198 | "Notice that \"Data Fluency\" is printed only once. \n", 199 | "\n", 200 | "**Tip**: `print` and `type` are built-in functions in Python. Later in this\n", 201 | "lesson, we will introduce methods and user-defined functions. The Python\n", 202 | "documentation is excellent for reference on the differences between them.\n", 203 | "\n" 204 | ] 205 | }, 206 | { 207 | "cell_type": "code", 208 | "execution_count": null, 209 | "metadata": {}, 210 | "outputs": [], 211 | "source": [ 212 | "help(print)\n" 213 | ] 214 | }, 215 | { 216 | "cell_type": "markdown", 217 | "metadata": {}, 218 | "source": [ 219 | "\n", 220 | "Will give the output\n", 221 | "\n", 222 | "```\n", 223 | "Help on built-in function print in module builtins:\n", 224 | "\n", 225 | "print(...)\n", 226 | " print(value, ..., sep=' ', end='\\n', file=sys.stdout, flush=False)\n", 227 | " \n", 228 | " Prints the values to a stream, or to sys.stdout by default.\n", 229 | " Optional keyword arguments:\n", 230 | " file: a file-like object (stream); defaults to the current sys.stdout.\n", 231 | " sep: string inserted between values, default a space.\n", 232 | " end: string appended after the last value, default a newline.\n", 233 | " flush: whether to forcibly flush the stream.\n", 234 | "```\n", 235 | "\n", 236 | "### Operators\n", 237 | "\n", 238 | "We can perform mathematical calculations in Python using the basic operators\n", 239 | " `+, -, /, *, %`:\n", 240 | "\n" 241 | ] 242 | }, 243 | { 244 | "cell_type": "code", 245 | "execution_count": null, 246 | "metadata": {}, 247 | "outputs": [], 248 | "source": [ 249 | ">>> 2 + 2 # Addition\n", 250 | "4\n", 251 | ">>> 6 * 7 # Multiplication\n", 252 | "42\n", 253 | ">>> 2 ** 16 # Power\n", 254 | "65536\n", 255 | ">>> 13 % 5 # Modulo\n", 256 | "3\n" 257 | ] 258 | }, 259 | { 260 | "cell_type": "markdown", 261 | "metadata": {}, 262 | "source": [ 263 | "\n", 264 | "We can also use comparison and logic operators:\n", 265 | "`<, >, ==, !=, <=, >=` and statements of identity such as\n", 266 | "`and, or, not`. The data type returned by this is\n", 267 | "called a _boolean_.\n", 268 | "\n", 269 | "\n" 270 | ] 271 | }, 272 | { 273 | "cell_type": "code", 274 | "execution_count": null, 275 | "metadata": {}, 276 | "outputs": [], 277 | "source": [ 278 | ">>> 3 > 4\n", 279 | "False\n", 280 | ">>> True and True\n", 281 | "True\n", 282 | ">>> True or False\n", 283 | "True\n" 284 | ] 285 | }, 286 | { 287 | "cell_type": "markdown", 288 | "metadata": {}, 289 | "source": [ 290 | "\n" 291 | ] 292 | }, 293 | { 294 | "cell_type": "markdown", 295 | "metadata": {}, 296 | "source": [ 297 | "## Sequential types: Lists and Tuples\n", 298 | "\n", 299 | "### Lists\n", 300 | "\n", 301 | "**Lists** are a common data structure to hold an ordered sequence of\n", 302 | "elements. Each element can be accessed by an index. Note that Python\n", 303 | "indexes start with 0 instead of 1:\n", 304 | "\n" 305 | ] 306 | }, 307 | { 308 | "cell_type": "code", 309 | "execution_count": null, 310 | "metadata": {}, 311 | "outputs": [], 312 | "source": [ 313 | ">>> numbers = [1, 2, 3]\n", 314 | ">>> numbers[0]\n", 315 | "1\n" 316 | ] 317 | }, 318 | { 319 | "cell_type": "markdown", 320 | "metadata": {}, 321 | "source": [ 322 | "\n", 323 | "A `for` loop can be used to access the elements in a list or other Python data structure one at a time. We will learn about loops in other lesson.\n", 324 | "\n" 325 | ] 326 | }, 327 | { 328 | "cell_type": "code", 329 | "execution_count": null, 330 | "metadata": {}, 331 | "outputs": [], 332 | "source": [ 333 | ">>> for num in numbers:\n", 334 | "... print(num)\n", 335 | "...\n", 336 | "1\n", 337 | "2\n", 338 | "3\n" 339 | ] 340 | }, 341 | { 342 | "cell_type": "markdown", 343 | "metadata": {}, 344 | "source": [ 345 | "\n", 346 | "**Indentation** is very important in Python. Note that the second line in the\n", 347 | "example above is indented. Just like three chevrons `>>>` indicate an\n", 348 | "interactive prompt in Python, the three dots `...` are Python's prompt for\n", 349 | "multiple lines. This is Python's way of marking a block of code. [Note: you\n", 350 | "do not type `>>>` or `...`.]\n", 351 | "\n", 352 | "To add elements to the end of a list, we can use the `append` method. Methods\n", 353 | "are a way to interact with an object (a list, for example). We can invoke a\n", 354 | "method using the dot `.` followed by the method name and a list of arguments\n", 355 | "in parentheses. Let's look at an example using `append`:\n", 356 | "\n" 357 | ] 358 | }, 359 | { 360 | "cell_type": "code", 361 | "execution_count": null, 362 | "metadata": {}, 363 | "outputs": [], 364 | "source": [ 365 | ">>> numbers.append(4)\n", 366 | ">>> print(numbers)\n", 367 | "[1, 2, 3, 4]\n", 368 | ">>>\n" 369 | ] 370 | }, 371 | { 372 | "cell_type": "markdown", 373 | "metadata": {}, 374 | "source": [ 375 | "\n", 376 | "To find out what methods are available for an\n", 377 | "object, we can use the built-in `help` command:\n", 378 | "\n" 379 | ] 380 | }, 381 | { 382 | "cell_type": "code", 383 | "execution_count": null, 384 | "metadata": {}, 385 | "outputs": [], 386 | "source": [ 387 | "help(numbers)\n", 388 | "\n", 389 | "Help on list object:\n", 390 | "\n", 391 | "class list(object)\n", 392 | " | list() -> new empty list\n", 393 | " | list(iterable) -> new list initialized from iterable's items\n", 394 | " ...\n" 395 | ] 396 | }, 397 | { 398 | "cell_type": "markdown", 399 | "metadata": {}, 400 | "source": [ 401 | "\n", 402 | "### Tuples\n", 403 | "\n", 404 | "A tuple is similar to a list in that it's an ordered sequence of elements.\n", 405 | "However, tuples can not be changed once created (they are \"immutable\"). Tuples\n", 406 | "are created by placing comma-separated values inside parentheses `()`.\n", 407 | "\n" 408 | ] 409 | }, 410 | { 411 | "cell_type": "code", 412 | "execution_count": null, 413 | "metadata": {}, 414 | "outputs": [], 415 | "source": [ 416 | "# Tuples use parentheses\n", 417 | "a_tuple= (1, 2, 3)\n", 418 | "another_tuple = ('blue', 'green', 'red')\n", 419 | "# Note: lists use square brackets\n", 420 | "a_list = [1, 2, 3]\n" 421 | ] 422 | }, 423 | { 424 | "cell_type": "markdown", 425 | "metadata": {}, 426 | "source": [ 427 | "\n" 428 | ] 429 | }, 430 | { 431 | "cell_type": "markdown", 432 | "metadata": {}, 433 | "source": [ 434 | "## Challenge - Tuples\n", 435 | "1. What happens when you type `a_tuple[2]=5` vs `a_list[1]=5` ?\n", 436 | "2. Type `type(a_tuple)` into python - what is the object type?\n", 437 | "\n", 438 | "\n", 439 | "\n" 440 | ] 441 | }, 442 | { 443 | "cell_type": "markdown", 444 | "metadata": {}, 445 | "source": [ 446 | "## Dictionaries\n", 447 | "\n", 448 | "A **dictionary** is a container that holds pairs of objects - keys and values.\n", 449 | "\n" 450 | ] 451 | }, 452 | { 453 | "cell_type": "code", 454 | "execution_count": null, 455 | "metadata": {}, 456 | "outputs": [], 457 | "source": [ 458 | ">>> translation = {'one': 1, 'two': 2}\n", 459 | ">>> translation['one']\n", 460 | "1\n" 461 | ] 462 | }, 463 | { 464 | "cell_type": "markdown", 465 | "metadata": {}, 466 | "source": [ 467 | "Dictionaries work a lot like lists - except that you index them with *keys*.\n", 468 | "You can think about a key as a name for or a unique identifier for a set of values\n", 469 | "in the dictionary. Keys can only have particular types - they have to be\n", 470 | "\"hashable\". Strings and numeric types are acceptable, but lists aren't.\n", 471 | "\n" 472 | ] 473 | }, 474 | { 475 | "cell_type": "code", 476 | "execution_count": null, 477 | "metadata": {}, 478 | "outputs": [], 479 | "source": [ 480 | ">>> rev = {1: 'one', 2: 'two'}\n", 481 | ">>> rev[1]\n", 482 | "'one'\n", 483 | ">>> bad = {[1, 2, 3]: 3}\n", 484 | "Traceback (most recent call last):\n", 485 | " File \"output473 |474 | 125 475 | 476 |477 |
218 |224 | 225 | 226 | 227 | 228 | 229 | but if we normalize one that’s wider than it is tall, the assertion is triggered: 230 | 231 | 232 | 233 | 234 | 235 | ```python 236 | print(normalize_rectangle( (0.0, 0.0, 5.0, 1.0) )) 237 | ``` 238 | 239 | 240 | 241 | 242 | 243 | ``` python 244 | --------------------------------------------------------------------------- 245 | AssertionError Traceback (most recent call last) 246 |output219 |220 | (0, 0, 0.2, 1.0) 221 | 222 |223 |
85 |107 | 108 | 109 | 110 | 111 | 112 | 113 | ```python 114 | # We run this to suppress various deprecation warnings from plotnine - keeps our notebook cleaner 115 | import warnings 116 | warnings.filterwarnings('ignore') 117 | ``` 118 | 119 | 120 | 121 | 122 | 123 | # Plotting in ggplot style 124 | 125 | Let's set up our working environment with necessary libraries and also load our csv file into data frame called `survs_df`, 126 | 127 | 128 | 129 | 130 | 131 | 132 | ```python 133 | import numpy as np 134 | import pandas as pd 135 | from plotnine import * 136 | 137 | %matplotlib inline 138 | survs_df = pd.read_csv('surveys.csv').dropna() 139 | ``` 140 | 141 | 142 | 143 | 144 | 145 | 146 | To produce a plot with the `ggplot` class from `plotnine`, we must provide three things: 147 | 148 | 1. A data frame containing our data. 149 | 2. How the columns of the data frame can be translated into positions, colors, sizes, and shapes of graphical elements ("aesthetics"). 150 | 3. The actual graphical elements to display ("geometric objects"). 151 | 152 | 153 | 154 | 155 | 156 | 157 | 158 | ## Introduction to plotting 159 | 160 | 161 | 162 | 163 | 164 | 165 | 166 | 167 | ```python 168 | ggplot(survs_df, aes(x='weight', y='hindfoot_length')) + geom_point() 169 | ``` 170 | 171 | 172 |  173 | 174 | 175 | 176 | 177 | 178 |output86 |87 | Requirement already satisfied: pandas in /Users/perry/.virtualenvs/python-workshop-base-ufuVBSbV/lib/python3.6/site-packages (0.25.0) 88 | Requirement already satisfied: plotnine in /Users/perry/.virtualenvs/python-workshop-base-ufuVBSbV/lib/python3.6/site-packages (0.5.1) 89 | Requirement already satisfied: numpy>=1.13.3 in /Users/perry/.virtualenvs/python-workshop-base-ufuVBSbV/lib/python3.6/site-packages (from pandas) (1.17.0) 90 | Requirement already satisfied: python-dateutil>=2.6.1 in /Users/perry/.virtualenvs/python-workshop-base-ufuVBSbV/lib/python3.6/site-packages (from pandas) (2.8.0) 91 | Requirement already satisfied: pytz>=2017.2 in /Users/perry/.virtualenvs/python-workshop-base-ufuVBSbV/lib/python3.6/site-packages (from pandas) (2019.1) 92 | Requirement already satisfied: descartes>=1.1.0 in /Users/perry/.virtualenvs/python-workshop-base-ufuVBSbV/lib/python3.6/site-packages (from plotnine) (1.1.0) 93 | Requirement already satisfied: scipy>=1.0.0 in /Users/perry/.virtualenvs/python-workshop-base-ufuVBSbV/lib/python3.6/site-packages (from plotnine) (1.3.0) 94 | Requirement already satisfied: patsy>=0.4.1 in /Users/perry/.virtualenvs/python-workshop-base-ufuVBSbV/lib/python3.6/site-packages (from plotnine) (0.5.1) 95 | Requirement already satisfied: matplotlib>=3.0.0 in /Users/perry/.virtualenvs/python-workshop-base-ufuVBSbV/lib/python3.6/site-packages (from plotnine) (3.1.1) 96 | Requirement already satisfied: statsmodels>=0.8.0 in /Users/perry/.virtualenvs/python-workshop-base-ufuVBSbV/lib/python3.6/site-packages (from plotnine) (0.10.1) 97 | Requirement already satisfied: mizani>=0.5.2 in /Users/perry/.virtualenvs/python-workshop-base-ufuVBSbV/lib/python3.6/site-packages (from plotnine) (0.5.4) 98 | Requirement already satisfied: six>=1.5 in /Users/perry/.virtualenvs/python-workshop-base-ufuVBSbV/lib/python3.6/site-packages (from python-dateutil>=2.6.1->pandas) (1.12.0) 99 | Requirement already satisfied: cycler>=0.10 in /Users/perry/.virtualenvs/python-workshop-base-ufuVBSbV/lib/python3.6/site-packages (from matplotlib>=3.0.0->plotnine) (0.10.0) 100 | Requirement already satisfied: kiwisolver>=1.0.1 in /Users/perry/.virtualenvs/python-workshop-base-ufuVBSbV/lib/python3.6/site-packages (from matplotlib>=3.0.0->plotnine) (1.1.0) 101 | Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /Users/perry/.virtualenvs/python-workshop-base-ufuVBSbV/lib/python3.6/site-packages (from matplotlib>=3.0.0->plotnine) (2.4.1.1) 102 | Requirement already satisfied: palettable in /Users/perry/.virtualenvs/python-workshop-base-ufuVBSbV/lib/python3.6/site-packages (from mizani>=0.5.2->plotnine) (3.2.0) 103 | Requirement already satisfied: setuptools in /Users/perry/.virtualenvs/python-workshop-base-ufuVBSbV/lib/python3.6/site-packages (from kiwisolver>=1.0.1->matplotlib>=3.0.0->plotnine) (39.1.0) 104 | 105 |106 |