Session 29 - Lambdas & Functional Tools

Discussion prompt

Before we open Session 29 - Lambdas & Functional Tools: without looking back, what was the main idea of Session 28 - Dataclasses, and what could you do by the end of it that you could not do before?

Hint: One sentence for the idea, one for the skill. If the second one is blank, that is the part to revisit.

Discussion prompt

A function is a value, like 7 or "hi". You can store it in a variable, put it in a list, or pass it to another function.

That is stated as though it always holds. Do one of two things: produce a case where it fails, or say precisely what rules such a case out. "It just does" is not on the menu.

Hint: Hunt at the extremes first — zero, one, negative, empty, equal. If every extreme survives, the reason they survive is the proof.

Put in order

Put the moves of Store a function in a variable into the order they have to happen.

1. Line 4 copies the function, not its result
2. yeller("hi") calls it just like shout would
3. Printing the name alone shows the function object

Why: These are the moves of the worked example in the order it makes them, and each one is set up by the one before it. No parentheses, so yeller now refers to the same function object as shout.

Comparison matrix

From Store a function in a variable: refill the prints column from what you know. The rest of the table is as it appeared.

Discussion prompt

Explain The name without () is the function itself by analogy to something with no Python Fundamentals in it at all — a queue, a recipe, a map, a bank balance, whatever fits. Then say where your analogy breaks.

Hint: An analogy that never breaks is not an analogy, it is the same idea wearing a hat. Find the seam — that is the part that is actually new.

Discussion prompt

Pass a function as an argument — before any calculation: what is the plan? Name the moves in order, in plain English, without doing the arithmetic.

Hint: It starts with: add_one is passed in as fn (no parentheses)

Comparison matrix

From Pass a function as an argument: every row here is a choice with a cost. Fill the value column, then say which row you would actually pick and what you give up for it.

Discussion prompt

Explain Passing a function customizes behavior to a student a year behind you. No notation, no jargon they have not met — and it still has to be true.

Hint: If your explanation needs a symbol they have never seen, you are describing the notation rather than the idea.

Sort into buckets

Every line below is part of the definition of first-class value or of lambda — one or the other, never both. Put each where it belongs.

first-class value

Something you can name, store, pass as an argument, and return.; In Python, functions are first-class - they are ordinary values.

lambda

An anonymous function written inline; The expression's value is returned automatically - no return keyword.

b1

Something you can name, store, pass as an argument, and return. In Python, functions are first-class - they are ordinary values.

b2

An anonymous function written inline: lambda parameters: expression. The expression's value is returned automatically - no return keyword.

Fill in the blanks

From A lambda and its def twin — one line has had its right-hand side removed. Put it back.

square = **lambda n: n * n**
print(square(6))

def square_def(n):
return n * n
print(square_def(6))

Why: square is what everything below it consumes, so the wrong expression here fails later and somewhere else. lambda n: n * n and def square_def(n): return n * n compute the same thing.

Draw it

Draw what A lambda and its def twin just did — the shape of it, not the line-by-line working. One picture, labels only where you need them. Then check it against the steps: anything you could not draw is a step you followed rather than understood.

Predict first

Lambdas take arguments and defaults too is about to be worked. State your hypothesis first: which rule or definition decides this one, and what is the first move it forces? Then watch whether the example agrees with you.

Correct: A lambda can have several parameters

Why: add takes a and b just like a def would.

A hypothesis you wrote down is falsifiable; a vague sense of how it will go is not. If the example opens somewhere else, that gap is the thing worth chasing.

Annotate

Walk the callouts on Lambdas take arguments and defaults too. Each one is a place this is easy to get subtly wrong.

• add takes a and b just like a def would.
• greet's name defaults to "you" when omitted.
• Verified by execution: 7, then Hi you, then Hi Ana.

Sort into buckets

These are the pieces of Session 29 - Lambdas & Functional Tools, out of order. Put each one back under the part of the lesson it belongs to.

Functions Are Values

A function is a first-class value; Store a function in a variable; The name without () is the function itself

lambda: Tiny Functions

lambda makes a function with no name; A lambda and its def twin; The shape of a lambda

sorted with a key

sorted returns a new list; The original list is unchanged; key= chooses what to sort by

s1

Functions Are Values is where Session 29 - Lambdas & Functional Tools puts A function is a first-class value, Store a function in a variable, The name without () is the function itself. Knowing which part of the lesson a problem belongs to is most of knowing which method to reach for.

s2

lambda: Tiny Functions is where Session 29 - Lambdas & Functional Tools puts lambda makes a function with no name, A lambda and its def twin, The shape of a lambda. Knowing which part of the lesson a problem belongs to is most of knowing which method to reach for.

s3

sorted with a key is where Session 29 - Lambdas & Functional Tools puts sorted returns a new list, The original list is unchanged, key= chooses what to sort by. Knowing which part of the lesson a problem belongs to is most of knowing which method to reach for.

Discussion prompt

Sort words by length — before any calculation: what is the plan? Name the moves in order, in plain English, without doing the arithmetic.

Hint: It starts with: No key sorts alphabetically

Predict first

The table runs: 1 | Bo | 19 · 2 | Cy | 25

In Sort dictionaries by a field, given the rows so far: what is the next one — the row where order is 3?

Correct: 3 | Ana | 30

Why: The relationship between the columns, not the individual numbers, is what generates the next row. For each dict p, key returns p["age"], so sorted orders by age.

Step through it

Step through Sort dictionaries by a field one row at a time. What is driving the change, and what would the row after the last one be?

1. Step 1: order is 1
2. Step 2: order is 2
3. Step 3: order is 3

Fill in the blanks

From Sort by abs, and case-insensitively — one line has had its right-hand side removed. Put it back.

nums = [-3, 1, -2, 4]
print(sorted(nums, key=abs))

words = ["banana", "Apple", "cherry"]
print(sorted(words))
print(sorted(words, key=str.lower))

Why: nums is what everything below it consumes, so the wrong expression here fails later and somewhere else. It sorts by |n|: 1, 2, 3, 4, keeping each number's own sign.

Sort into buckets

Sort these by key p[1], from memory, without looking back at Ties keep their original order. Telling them apart on the spot is the skill; the table is only where the answer happens to be written down.

1

('b', 1); ('d', 1)

2

('a', 2); ('c', 2)

g1

key p[1] is "1" for ('b', 1), ('d', 1) — that is what the table on "Ties keep their original order" records, and it is the single property separating this group from the rest.

g2

key p[1] is "2" for ('a', 2), ('c', 2) — that is what the table on "Ties keep their original order" records, and it is the single property separating this group from the rest.

Put in order

Put the moves of A named key function into the order they have to happen.

1. The key returns a tuple: wins, then fewer losses
2. Pass the name - no parentheses
3. Read the ranking

Why: These are the moves of the worked example in the order it makes them, and each one is set up by the one before it. Tuples compare left to right, so more wins wins; ties break on fewer losses (the minus flips it).

Step through it

Step through A named key function one row at a time. What is driving the change, and what would the row after the last one be?

1. Step 1: player is C
2. Step 2: player is A
3. Step 3: player is B

Match the pairs

Match each term to the definition this lesson gave it — not the one you would guess from the word.

• t1. first-class value
• t2. lambda
• t3. lazy iterator

• d1. Something you can name, store, pass as an argument, and return. In Python, functions are first-class - they are ordinary values.
• d2. An anonymous function written inline: lambda parameters: expression. The expression's value is returned automatically - no return keyword.
• d3. An object that produces values one at a time, only when asked. map and filter are lazy: they compute nothing until you loop over them or call list().

Why: These are the working definitions of first-class value, lambda, lazy iterator as Session 29 - Lambdas & Functional Tools uses them. Pairing them correctly is the test of whether you could state each one with the slide switched off.

Discussion prompt

A map object is not a list — before any calculation: what is the plan? Name the moves in order, in plain English, without doing the arithmetic.

Hint: It starts with: map returns a lazy object, not the answers

Discussion prompt

Explain filter keeps items where the test is True to a student a year behind you. No notation, no jargon they have not met — and it still has to be true.

Hint: If your explanation needs a symbol they have never seen, you are describing the notation rather than the idea.

Predict first

The table runs: 5 | False | no · 12 | True | yes · 8 | False | no · 130 | True | yes

In Keep the big numbers, given the rows so far: what is the next one — the row where n is 44?

Correct: 44 | True | yes

Why: The relationship between the columns, not the individual numbers, is what generates the next row. Verified by execution: line 3 prints <filter object at 0x...>.

Step through it

Step through Keep the big numbers one row at a time. What is driving the change, and what would the row after the last one be?

1. Step 1: n is 5
2. Step 2: n is 12
3. Step 3: n is 8
4. Step 4: n is 130
5. Step 5: n is 44

Fill in the blanks

From filter with a named test — one line has had its right-hand side removed. Put it back.

def is_even(n):
return n % 2 == 0

nums = [1, 2, 3, 4, 5, 6]
evens = list(filter(is_even, nums))
print(evens)
print([n for n in nums if n % 2 == 0])

Why: evens is what everything below it consumes, so the wrong expression here fails later and somewhere else. filter calls is_even on each number and keeps the True ones.

Comparison matrix

From filter with a named test: refill the result column from what you know. The rest of the table is as it appeared.

Discussion prompt

Explain A comprehension does map and filter at once by analogy to something with no Python Fundamentals in it at all — a queue, a recipe, a map, a bank balance, whatever fits. Then say where your analogy breaks.

Hint: An analogy that never breaks is not an analogy, it is the same idea wearing a hat. Find the seam — that is the part that is actually new.

Discussion prompt

map vs comprehension — before any calculation: what is the plan? Name the moves in order, in plain English, without doing the arithmetic.

Hint: It starts with: map needs a lambda and a list() wrapper

Put in order

Put the moves of map + filter vs one comprehension into the order they have to happen.

1. Nested map/filter is hard to read
2. The comprehension states it plainly
3. Identical output

Why: These are the moves of the worked example in the order it makes them, and each one is set up by the one before it. You read it inside-out: filter first, then map, then list.

Draw it

Draw what map + filter vs one comprehension just did — the shape of it, not the line-by-line working. One picture, labels only where you need them. Then check it against the steps: anything you could not draw is a step you followed rather than understood.

Discussion prompt

Code is read far more than it is written. A comprehension reads like a sentence; nested map(filter(...)) reads like a puzzle.

That is stated as though it always holds. Do one of two things: produce a case where it fails, or say precisely what rules such a case out. "It just does" is not on the menu.

Hint: Hunt at the extremes first — zero, one, negative, empty, equal. If every extreme survives, the reason they survive is the proof.

Predict first

A student writes this, and it looks reasonable:

Reusing a map object after it is already spent.

It is wrong. Say what breaks — and say it before you turn the page.

Correct: A map yields each value once. After first consumes them, nothing is left, so second is empty - not the crash you might expect, just silent [].

Materialize once into a list, then reuse the list.

Why: A map yields each value once. After first consumes them, nothing is left, so second is empty - not the crash you might expect, just silent [].

Predict first

A student writes this, and it looks reasonable:

Printing or indexing the map object directly.

It is wrong. Say what breaks — and say it before you turn the page.

Correct: It is lazy, not a sequence, so m[0] raises TypeError - you never see the numbers.

Wrap it in list() first, then index or print.

Why: It is lazy, not a sequence, so m[0] raises TypeError - you never see the numbers.

Discussion prompt

The rule this trap just fixed:

Verified by execution: m[0] is 10. Convert with list() before you index, slice, len, or print the contents.

Now break it on purpose. Build a case that violates it and follow the consequences until something visibly fails. Where does the failure first show up — and would you have noticed it if you had not been looking?

Hint: The dangerous rules are the ones whose violation still produces an answer. If yours fails loudly, try to find one that fails quietly.

Predict first

A student writes this, and it looks reasonable:

A lambda so dense you cannot read it at a glance.

It is wrong. Say what breaks — and say it before you turn the page.

Correct: Verified by execution: ['A', 'B'].

Give the logic a name with def.

Why: Verified by execution: ['A', 'B']. The output is right, yet the tie-break rule is buried in a hard-to-name lambda.

Annotate

Walk the callouts on Trap: cramming logic into a lambda. Each one is a place this is easy to get subtly wrong.

• Verified by execution: ['A', 'B']. The output is right, yet the tie-break rule is buried in a hard-to-name lambda.
• Verified by execution: ['A', 'B']. rank_key can be read, reused, and tested. Rule of thumb: if a lambda needs a second glance, make it a def.

Predict first

A student writes this, and it looks reasonable:

Passing a compare function like Python 2's cmp=.

It is wrong. Say what breaks — and say it before you turn the page.

Correct: sorted has no cmp parameter anymore, so this raises TypeError before any sorting happens.

Use key= to say what to sort by.

Why: sorted has no cmp parameter anymore, so this raises TypeError before any sorting happens.

Predict first

A student writes this, and it looks reasonable:

Calling the function instead of passing it.

It is wrong. Say what breaks — and say it before you turn the page.

Correct: The parentheses call len immediately, and len needs one argument, so it crashes before sorted can use it.

Pass the function name - no parentheses.

Why: The parentheses call len immediately, and len needs one argument, so it crashes before sorted can use it.

Sort into buckets

Some of these hold up and some are the exact mistakes this lesson is built to prevent. Sort them.

Holds up

A function is a value, like 7 or "hi". You can store it in a variable, put it in a list, or pass it to another function.; shout is the function; shout("hi") runs it. The parentheses are what trigger the call - the bare name is just the value.; When a tool takes a function as an argument, you control what it does without rewriting the tool. sorted, map, and filter all work this way.

Breaks

Reusing a map object after it is already spent.; Printing or indexing the map object directly.

sound

These are stated as this lesson states them — each one survives the edge cases Session 29 - Lambdas & Functional Tools puts it through.

flawed

Each of these is lifted from a trap in this deck: reasonable-sounding, and wrong in a way that only shows up once you rely on it.

Discussion prompt

Outside this lesson: where does Session 29 - Lambdas & Functional Tools actually turn up? Name one concrete situation — a job, a piece of software someone ships, a decision somebody has to make — and say which part of Transform or select a list is doing the work in it.

Hint: Vague is the failure mode here. "Engineering" is not a situation; "deciding whether this build is fast enough to ship" is.

Check your understanding

What does this print?

• A. ['fig', 'pear', 'kiwi', 'banana'] (correct)
• B. ['banana', 'fig', 'kiwi', 'pear']
• C. ['banana', 'pear', 'kiwi', 'fig']
• D. ['fig', 'kiwi', 'pear', 'banana']

Answer: A

Why: key=len sorts by length ascending: fig(3), then pear and kiwi(4) keeping their original order, then banana(6). Verified by execution.

Why B tempts people

That is alphabetical order (no key), not sorted by length.

Why C tempts people

That is length descending - this call has no reverse=True.

Why D tempts people

pear and kiwi both have length 4; a stable sort keeps pear before kiwi, since pear comes first in the input.

Sort into buckets

Sort these by len, from memory, without looking back at Check: sort by length. Telling them apart on the spot is the skill; the table is only where the answer happens to be written down.

4

pear; kiwi

3

fig

6

banana

g1

len is "4" for pear, kiwi — that is what the table on "Check: sort by length" records, and it is the single property separating this group from the rest.

g2

len is "3" for fig — that is what the table on "Check: sort by length" records, and it is the single property separating this group from the rest.

g3

len is "6" for banana — that is what the table on "Check: sort by length" records, and it is the single property separating this group from the rest.

Check your understanding

What does print(result) show?

• A. <map object at 0x...> (correct)
• B. [10, 20, 30, 40]
• C. [1, 2, 3, 4]
• D. map(<lambda>, [1, 2, 3, 4])

Answer: A

Why: map returns a lazy iterator, and printing it shows the object like <map object at 0x...>, not the values. You need list(result) to see [10, 20, 30, 40]. Verified by execution.

Why B tempts people

That is what list(result) prints - map on its own stays lazy and shows the object.

Why C tempts people

The lambda multiplies by 10, so the values would be 10..40 - but only after list() forces them.

Why D tempts people

Python does not echo the source; a map object prints as <map object at 0x...>.

Check your understanding

What does this print?

• A. [9, 1, 4] (correct)
• B. [1, 4, 9]
• C. [6, 2, 4]
• D. <map object at 0x...>

Answer: A

Why: map applies n * n in the original order: 3 to 9, 1 to 1, 2 to 4, and list keeps that order. Verified by execution.

Why B tempts people

map does not sort; it keeps the input order (3, 1, 2), giving [9, 1, 4].

Why C tempts people

n * n is n squared, not n times 2: 3 squared is 9, not 6.

Why D tempts people

list() forces the values, so you get a real list, not the map object.

Check your understanding

What does this print?

• A. [3, 2] (correct)
• B. [True, False, True]
• C. [1]
• D. [2, 3]

Answer: A

Why: filter keeps items where n > 1 is True: 3 and 2 (in original order); 1 is dropped. Verified by execution.

Why B tempts people

filter returns the kept items, not the True/False results of the test - that would be map.

Why C tempts people

filter keeps the items where the test is True, not the ones where it is False, so 1 is removed, not kept.

Why D tempts people

filter preserves the original order (3 before 2), so it is [3, 2], not [2, 3].

Step through it

Step through Check: filter keeps which? one row at a time. What is driving the change, and what would the row after the last one be?

1. Step 1: n is 3
2. Step 2: n is 1
3. Step 3: n is 2

Check your understanding

What does print(second) show?

• A. [] (correct)
• B. [2, 3, 4]
• C. [1, 2, 3]
• D. TypeError

Answer: A

Why: A map object yields each value once. first drained it, so second gets an empty list - no error, just []. Verified by execution.

Why B tempts people

That is what first holds. The iterator is already spent, so second cannot see those values again.

Why C tempts people

The lambda adds 1, and in any case result is empty by the time second reads it.

Why D tempts people

Re-reading a spent iterator is not an error; it simply produces nothing.

Check your understanding

What happens?

• A. TypeError: 'cmp' is an invalid keyword argument for sort() (correct)
• B. [1, 2, 3]
• C. [3, 2, 1]
• D. [3, 1, 2]

Answer: A

Why: Python 3 removed cmp=; sorting is controlled by key=. Passing cmp= raises TypeError before any sorting. Verified by execution.

Why B tempts people

It would sort to [1, 2, 3] only if the argument were valid - but cmp= is rejected outright.

Why C tempts people

There is no descending here, and more importantly cmp= is not accepted at all.

Why D tempts people

The original list is never returned; the invalid keyword raises an error instead.

Comparison matrix

From Check: key= vs cmp=: every row here is a choice with a cost. Fill the exists in Python 3? column, then say which row you would actually pick and what you give up for it.

Check your understanding

What happens with key=len()?

• A. TypeError: len() takes exactly one argument (0 given) (correct)
• B. ['hi', 'hey']
• C. ['hey', 'hi']
• D. It sorts alphabetically

Answer: A

Why: len() calls len immediately with no argument, which is an error, so sorted never runs. Use key=len (no parentheses). Verified by execution.

Why B tempts people

That is the result of key=len (no parentheses) - here the () causes a crash first.

Why C tempts people

sorted by length descending would need key=len and reverse=True; this line errors instead.

Why D tempts people

No sorting happens at all - len() raises before sorted can compare anything.

Comparison matrix

From Check: pass the function, do not call it: refill the meaning column from what you know. The rest of the table is as it appeared.

Draw it

One page, no notation unless you need it: draw how these connect — Functions Are Values · lambda: Tiny Functions · sorted with a key · map: Transform Each Item · filter: Keep Some Items · Why a Comprehension Wins. Put an arrow wherever one of them is what makes another possible, and label the arrow with why.