Intuition What this page isThe parent note taught you the rules . This page runs those rules through every situation you could meet — empty inputs, laziness traps, nesting, multi-argument lambdas, truthiness edge cases, and an exam twist. We first draw a matrix of every case-class, then work examples until every cell is filled.
Think of a lambda-with-a-tool problem as having a few independent "dials". Each dial can be in a few positions. The matrix below lists every position we must cover so you never meet a case we didn't show.
Cell
Case class
What could bite you
A map transforms a normal listforgetting list(...) → see <map object>
B filter selects with a predicatex % 2 == 0 vs x % 2 == 1 sign of remainder
C empty / degenerate iterable []result is [], not an error
D laziness — iterator exhausts after one passsecond list() gives []
E nesting map(f, filter(g, it))inside-out evaluation order
F multi-argument lambda + sorted(key=...)one comparable value per item
G truthiness filter(lambda x: x, ...)drops 0, '', None, [], False
H ternary inside lambda (the only "logic" allowed)if/else as an expression , not a statement
I real-world word problem choosing map vs filter
J exam twist — map over two iterablesmap(f, a, b) stops at the shorter
We now work 10 examples , each tagged with the cell(s) it covers. Together they fill the whole table.
Intuition The conveyor-belt mental modelRead the picture above like a factory line. Items ride in on the left. filtersome through. mapevery item. The dashed cloud on the right means the belt is lazy — nothing actually moves until a list(...) at the end pulls the items off.
map on a normal list (Cell A)
Statement. list(map(lambda x: x * 3, [1, 2, 3, 4])) = ?
Forecast: guess the list before reading.
Write the rule: lambda x: x * 3 — the per-item transform.
Why this step? map needs a function; this is it, supplied inline.
map calls it once per element: 1→3, 2→6, 3→9, 4→12.
Why this step? map transforms every item — no item is skipped.Wrap in list(...) to materialise the lazy iterator.
Why this step? Without it you'd print <map object at 0x...>.
Result: [3, 6, 9, 12]
Verify: length in = length out = 4 (map never changes count). ✓
filter with an even/odd predicate (Cell B)
Statement. list(filter(lambda x: x % 2 == 0, [10, 15, 20, 25])) = ?
Forecast: which survive the gate?
Predicate: lambda x: x % 2 == 0 returns True/False.
Why this step? filter selects, so it needs a truth test , not a transform.
Test each: 10→True, 15→False, 20→True, 25→False.
Why this step? % is the remainder operator; == 0 means "divides evenly".
Keep only the True ones.
Result: [10, 20]
Verify: each kept item really is even (10/2=5, 20/2=10, whole numbers). ✓
Worked example Ex 3 — Empty / degenerate input (Cell C)Statement. list(map(lambda x: x + 100, [])) and list(filter(lambda x: x > 0, [])) = ?
Forecast: crash, or something calmer?
The loop body of map/filter runs once per element .
Why this step? Recall the from-scratch version: a for x in it: loop.
With zero elements, the loop body runs zero times .
Why this step? No items ⇒ nothing appended ⇒ the result list stays [].
Result: both give [] — no error .
Verify: empty in ⇒ empty out is the safe, expected behaviour (an "identity" edge case). ✓
Worked example Ex 4 — Laziness: the one-pass trap (Cell D)Statement. What does the second list(...) print?
m = map ( lambda x: x * 2 , [ 1 , 2 , 3 ]) a = list (m) # ? b = list (m) # ? Forecast: are a and b equal?
a = list(m) pulls every value: [2, 4, 6].
Why this step? list drives the iterator to completion.The iterator m is now exhausted — its internal cursor sits past the end.
Why this step? Lazy iterators compute on demand and remember position; they don't rewind.
b = list(m) finds nothing left → [].
Result: a = [2, 4, 6], b = [].
Verify: a + b == [2, 4, 6] (the second pass added nothing). ✓
Common mistake "I'll reuse the samemap object twice"
It works once . Re-create the map(...) or store list(m) in a variable and reuse that .
Worked example Ex 5 — Nesting: filter first, then map (Cell E)Statement. Square only the odd numbers of [1, 2, 3, 4, 5, 6].
list ( map ( lambda x: x * x, filter ( lambda x: x % 2 == 1 , [ 1 , 2 , 3 , 4 , 5 , 6 ]))) Forecast: what's left after both stages?
Read inside-out : the innermost call runs first — filter(lambda x: x % 2 == 1, ...).
Why this step? Function calls evaluate their arguments before the outer call runs.
Filter keeps odds: [1, 3, 5].
Why this step? Odd numbers leave remainder 1 when divided by 2.
map(lambda x: x*x, ...) squares each survivor: 1→1, 3→9, 5→25.
Why this step? map transforms the already-thinned stream — cheaper than squaring all six.
Result: [1, 9, 25]
Verify: 3 odds in ⇒ 3 squares out; every output is an odd number squared. ✓
Worked example Ex 6 — Multi-argument lambda withsorted's key (Cell F)
Statement. Sort students by their score (descending), then show names.
people = [( "Asha" , 82 ), ( "Ravi" , 91 ), ( "Meena" , 77 )] ranked = sorted (people, key =lambda p: p[ 1 ], reverse = True ) names = list ( map ( lambda p: p[ 0 ], ranked)) Forecast: who is first?
key=lambda p: p[1] hands sorted one comparable value per item — the score.
Why this step? sorted compares items; a tuple would compare by name first, which we don't want.reverse=True flips ascending → descending, so highest score leads.
Why this step? We want a ranking, top down.map(lambda p: p[0], ranked) pulls the name (index 0) out of each ranked tuple.
Result: ranked = [("Ravi",91),("Asha",82),("Meena",77)], names = ["Ravi","Asha","Meena"].
Verify: scores 91 ≥ 82 ≥ 77 are non-increasing. ✓ See sorted and key functions .
Worked example Ex 7 — Truthiness filter (Cell G)Statement. list(filter(lambda x: x, [0, 1, '', 'hi', None, [], [0], False, 5])) = ?
Forecast: which of these count as "empty/false"?
filter(lambda x: x, ...) keeps x when bool(x) is True.
Why this step? The lambda just returns the item itself; filter then asks bool(...).Falsy values dropped: 0, '', None, [], False.
Why this step? Python treats "empty or zero" containers/numbers as False.
Truthy survivors: 1, 'hi', [0] (a non-empty list is truthy even if it holds a 0), 5.
Result: [1, 'hi', [0], 5]
Verify: every survivor is non-empty / non-zero; every dropped value is a canonical falsy. ✓
Worked example Ex 8 — Ternary inside a lambda (Cell H)Statement. Label each number even/odd:
list ( map ( lambda x: 'even' if x % 2 == 0 else 'odd' , [ 1 , 2 , 3 , 4 ])) Forecast: guess the four labels.
a if condition else b is an expression (it produces a value), so it's legal in a lambda.
Why this step? Lambdas forbid statements (if x: on its own line) but allow this one-line conditional.Evaluate per item: 1→odd, 2→even, 3→odd, 4→even.
Why this step? map runs the tiny classifier once per element.
Result: ['odd', 'even', 'odd', 'even']
Verify: even indices of value (2, 4) map to 'even'. ✓
elif too"
A ternary has exactly A if C else B. Need three branches? Nest — A if C1 else (B if C2 else C) — or better, use a named def . Readability wins.
Worked example Ex 9 — Real-world word problem (Cell I)Statement. A shop's cart prices are [199, 0, 499, 0, 89] (the 0s are removed items). Compute the total after adding 18% GST, ignoring removed items.
Forecast: map or filter first — and why?
Filter out removed items (the 0s): filter(lambda p: p > 0, prices) → [199, 499, 89].
Why this step? We select real items before doing any maths — filter is the selector.Map each surviving price to its GST-inclusive value: lambda p: p * 1.18.
Why this step? Every real item is transformed the same way — that's map's job.Sum the results with built-in sum(...).
Why this step? sum folds the mapped iterator into one number (a higher-order reduction).
prices = [ 199 , 0 , 499 , 0 , 89 ] total = sum ( map ( lambda p: p * 1.18 , filter ( lambda p: p > 0 , prices))) Result: 787 * 1.18 = 928.66
Verify: kept sum 199 + 499 + 89 = 787; 787 * 1.18 = 928.66. Units: rupees × (dimensionless factor) = rupees. ✓
Worked example Ex 10 — Exam twist:map over TWO iterables (Cell J)
Statement. list(map(lambda a, b: a + b, [1, 2, 3, 4], [10, 20, 30])) = ?
Forecast: four results or three?
When you pass two iterables, map calls the lambda with one element from each , in lock-step.
Why this step? The lambda has two parameters a, b; map feeds them in parallel.
Pairs: (1,10), (2,20), (3,30) → sums 11, 22, 33.
Why this step? map stops at the shortest iterable, so the leftover 4 is never used.
Result: [11, 22, 33] (length 3, not 4).
Verify: min(len([1,2,3,4]), len([10,20,30])) == 3 matches the output length. ✓
Recall Did we fill every cell? (reveal)A→Ex1 · B→Ex2 · C→Ex3 · D→Ex4 · E→Ex5 · F→Ex6 · G→Ex7 · H→Ex8 · I→Ex9 · J→Ex10. Every row is worked. ✓
Recall Rapid self-testlist(map(lambda x: x*3, [1,2,3,4])) ::: [3, 6, 9, 12]
list(filter(lambda x: x % 2 == 0, [10,15,20,25])) ::: [10, 20]
list(filter(lambda x: x, [0,1,'', 'hi', None, [], [0], False, 5])) ::: [1, 'hi', [0], 5]
list(map(lambda a,b: a+b, [1,2,3,4],[10,20,30])) ::: [11, 22, 33]
Second list() on an exhausted map object gives? ::: []
Functions and def — every lambda here has an equivalent named def.First-class functions — why we can hand functions to map/filter/sorted.List comprehensions — Ex 5 is [x*x for x in nums if x % 2 == 1].Iterators and lazy evaluation — the engine behind Ex 3, 4, 10.sorted and key functions — the tool in Ex 6.Higher-order functions — sum(map(...)) in Ex 9.
Have a list, want a result
Use filter with a predicate
Use sorted with key lambda
