Comprehensions and Generators

Question 1

map(function, iterable, …)

Answer 1

Return an iterator that applies function to every item of iterable, yielding the results.
If additional iterable arguments are passed, function must take that many arguments
and is applied to the items from all iterables in parallel.

Question 2

> list(map(lambda *a: a, range(3), ‘abc’))
# 2 iterables

Answer 2

[(0, ‘a’), (1, ‘b’), (2, ‘c’)]

Question 3

list(map(lambda *a: a, (1, 2), ‘abc’))
# (1, 2) shortest

Answer 3

[(1, ‘a’), (2, ‘b’)]

Question 4

map() stops when the ____ o the iterable we call it with is exhausted

Answer 4

shortest

Question 5

zip(*iterables)

Answer 5

Returns an iterator of tuples, where the i-th tuple contains the i-th element from
each of the argument sequences or iterables. The iterator stops when the shortest
input iterable is exhausted. With a single iterable argument, it returns an iterator
of 1-tuples. With no arguments, it returns an empty iterator.

Question 6

> > > grades = [18, 23, 30, 27]
avgs = [22, 21, 29, 24]
list(zip(avgs, grades))

Answer 6

[(22, 18), (21, 23), (29, 30), (24, 27)]

Question 7

> > > list(map(lambda *a: a, avgs, grades))

Answer 7

[(22, 18), (21, 23), (29, 30), (24, 27)]

Question 8

filter(function, iterable)

Answer 8

Construct an iterator from those elements of iterable for which function returns
True. iterable may be either a sequence, a container which supports iteration, or an
iterator. If function is None, the identity function is assumed, that is, all elements
of iterable that are false are removed.

Question 9

> > > test = [2, 5, 8, 0, 0, 1, 0]
list(filter(None, test))

Answer 9

er(None, test))
[2, 5, 8, 1]

Question 10

> > > list(filter(lambda x: x > 4, test)) # keep only items > 4

Answer 10

[5, 8]

Question 11

> > > squares = map(lambda n: n**2, range(10))
list(squares)

Answer 11

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Question 12

LIST COMPREHENSION
»> [n ** 2 for n in range(10)]

Answer 12

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Question 13

filter passes each element in the iterable through func and return only the ones that evaluate to ____

Answer 13

true

Question 14

what prints?

sq1 = list(
map(lambda n: n ** 2, filter(lambda n: not n % 2, range(10)))
)
# equivalent, but using list comprehensions
sq2 = [n ** 2 for n in range(10) if not n % 2]
print(sq1, sq1 == sq2)

Answer 14

prints: [0, 4, 16, 36, 64] True

Question 15

You can also use nested comprehension in place of ____ loop

Answer 15

nested

Question 16

for a in range(len(items)):
for b in range(a, len(items)):
pairs.append((items[a], items[b]))

What is the equivalent nested comprehension

Answer 16

items = ‘ABCD’
pairs = [(items[a], items[b])
for a in range(len(items)) for b in range(a, len(items))]

Question 17

We can also apply filtering to a comprehension

Example

Answer 17

from math import sqrt
# this will generate all possible pairs
mx = 10

triples = [(a, b, sqrt(a2 + b2))
for a in range(1, mx) for b in range(a, mx)]

this will filter out all non-Pythagorean triples
triples = list(
filter(lambda triple: triple[2].is_integer(), triples))

print(triples) # prints: [(3, 4, 5.0), (6, 8, 10.0)]

Question 18

Another way

mx = 10
triples = [(a, b, sqrt(a2 + b2))
for a in range(1, mx) for b in range(a, mx)]

here we combine filter and map in one CLEAN list comprehension

triples = [(a, b, int(c)) for a, b, c in triples if c.is_integer()]

Answer 18

print(triples)
# prints: [(3, 4, 5), (6, 8, 10)]

Question 19

We can also make _____ comprehensions

Answer 19

dictionary

Question 20

Dictionaries do not allow _____ keys

Answer 20

duplicate

Question 21

word = ‘Hello’
swaps = {c: c.swapcase() for c in word}
print(swaps)

Answer 21

prints: {‘H’: ‘h’, ‘e’: ‘E’, ‘l’: ‘L’, ‘o’: ‘O’}

Question 22

We can also create ____ comprehensions

Answer 22

word = ‘Hello’
letters1 = {c for c in word}
letters2 = set(c for c in word)
print(letters1) # prints: {‘H’, ‘o’, ‘e’, ‘l’}
print(letters1 == letters2) # prints: True

Question 23

These are very similar to regular functions but instead of returning results through return statements, they use yield which allows them to suspend and resume their state between each call

Answer 23

generator functions

Question 24

These are very similar to list comprehensions, but instead of returning a list, they return an object that produces results one by one

Answer 24

generator expressions

Question 25

First example of generators

Answer 25

def get_squares_gen(n): # generator approach for x in range(n): yield x ** 2 # we yield, we don't return print(list(get_squares_gen(10)))

Question 26

So, in order to save memory (and time), use generator functions whenever possible.

Answer 26

True

Question 27

def fun(max): cnt = 1 while cnt <= max: yield cnt cnt += 1 ctr = fun(5) for n in ctr: print(n)

Answer 27

1 2 3 4 5

Question 28

_____ is used in generator functions to provide a sequence of values over time. When _____ is executed, it pauses the function, returns the current value and retains the state of the function.

Answer 28

yield

Question 29

In general, generator expressions behave like equivalent list comprehensions, but there is one very important thing to remember: generators allow for ____ ________ only, then they will be exhausted.

Answer 29

one iteration

Question 30

>>> cubes_gen = (k**3 for k in range(10)) # create as generator >>> cubes_gen at 0x103fb5a98> >>> type(cubes_gen) >>> list(cubes_gen) # this will exhaust the generator [0, 1, 8, 27, 64, 125, 216, 343, 512, 729] >>> list(cubes_gen)

Answer 30

nothing more to give At the end there is nothing more to give as we have looped though the elements from the genearator expression

Question 31

cubes1 = map( lambda n: (n, n**3), filter(lambda n: n % 3 == 0 or n % 5 == 0, range(N)) ) cubes2 = ( (n, n**3) for n in range(N) if n % 3 == 0 or n % 5 == 0)

Answer 31

If you print the list (cubes1), you get: [(0, 0), (3, 27), (5, 125), (6, 216), (9, 729), (10, 1000), (12, 1728), (15, 3375), (18, 5832)].