Don't like this style? Click here to change it! blue.css
Math Task 1: Change this scatter plot to give me random points near the line y=3x + 1
We need to head back to the last set of notes to finish off "comprehensions".
So last time we explored many built-in iterable types in Python. Today let's build one from scratch. The
yield keyword, acts like a partial
return. A function which "yields" results will
execute to the first yield, then wait for someone to call
next on it:
Explore Task 2: Use the terminal to decide what the
Fib Yielder Task 3: Write a generator that yields the Fibonacci sequence. Print the first 10 terms.
So generators are functions which can be iterated. Just like we had "list comprehensions" we can do "generator comprehensions":
Comprehension Task 4: Write a generator, using the
() notation, which
yields the first 10 perfect squares. Now yield the first 10 triangular numbers.
Consumption Task 5: Now use the
sum operator to add the first 10
perfect squares. Add the first 10 triangular numbers.
Any of our comprehensions can also be used as a natural "filter" on an iterable:
Capital Task 6: Build a generator which yields only the capital letters in the string "I Am Good Enough, Smart Enough, and Doggone It People Like Me!".
So far we've been making sets of commands for our programs to run. Sometimes putting those commands into "functions". This is called imperative programming. There are several other programming paradigms including declarative programming (tell the computer what it should do but not how) and Object-Oriented programming (make many objects which contain both data and actions).
Today we're going to explore a style of coding called functional programming. In functional programming we try to have a series of functions that define your program and functions don't have some lasting side-effect.
Python is not naturally a functional language, but it supports some features of functional programming. Because I want you to be exposed to this type of thinking let's explore some basic building blocks:
map: consumes a function and an iterable creates an iterable of the function called on each thing in the iterable.
Map Task 7: Map the function
ord onto every character in "Andy is
the greatest". Make a list out of the output. (These are the ascii values of those characters.)
filter: consumes a Boolean function and an iterable, returns an iterable containing only the
elements for which the function returns
Prime Task 8: Write a function called
is_prime which consumes an
integer and returns
True if the integer is prime (
Filter Task 9: Now use your function to filter the numbers 2 to 50 and display a tuple of the primes.
reduce: consumes a function (which consumes two elements and returns one), an iterable, and a starting value. It returns the result of having the function aggregate through the iterator.
This one is a little complicated to think out so pay close attention:
Reduce Task 10: Write a "reducing function" to help you count the number of
multiples of 3 in an iterable. Call it on
So in Python you can make un-named, one-off, simple functions called lambdas.
The format is:
lambda x, y, ... : expression_of_x_y
These are really nice for using map, reduce, and filter.
Lambda Task 11: Use a lambda and map to double the numbers from 1 to 12.
Lambda Task 12: Use a lambda and filter to make a list of the multiples of 5 less than 131.
split to write a function
which consumes a sentence and returns the sentence where each word has been alphabetized. For instance: "Andy is
the greatest" should return "Adny is eht aeegrstt".