Exercises — Lambda functions — anonymous, used with map - filter

(b) a function object. A lambda is an expression that evaluates to a function. Writing it alone doesn't call it — it just creates the helper. Compare: writing 5 produces the number 5; writing lambda x: x+1 produces a callable. You could store it: f = lambda x: x + 1, then f(4) gives 5. This is exactly the first-class idea — functions are values you can hand around.

A is a SyntaxError. A lambda body must be a single expression, and its value is automatically the return value. return is a statement, not an expression, so it is forbidden here. B is fine (identity). C is fine — a lambda may take zero arguments; (lambda: 42)() returns 42.

False. In Python 3, map returns a lazy iterator — it computes values on demand, one at a time, and is exhausted after one full pass. To see all results at once, wrap it: list(map(f, it)). This laziness is the topic of Iterators and lazy evaluation.

map applies the rule x * 3 to every element in order:

• 0 * 3 = 0
• 1 * 3 = 3
• 4 * 3 = 12

Result: [0, 3, 12].

filter keeps each x only when the predicate is truthy (True), and drops the rest. Test each:

• 3 > 5 → False → drop
• 8 > 5 → True → keep
• 5 > 5 → False → drop (5 is not strictly greater than 5)
• 10 > 5 → True → keep
• 1 > 5 → False → drop

Result: [8, 10].

sorted needs one comparable value per item. Here key=lambda s: len(s) says "compare by string length":

• 'pear' → 4
• 'fig' → 3
• 'apple' → 5

Sorting by those keys ascending (3, 4, 5) gives: ['fig', 'pear', 'apple']. Why is key called only once per item, not on every comparison? sorted uses a strategy called decorate–sort–undecorate. First it decorates: it runs your key function once on each element and pairs the result with the element, building an internal list like [(4,'pear'), (3,'fig'), (5,'apple')]. Then it sorts those pairs by their computed key. Finally it undecorates: it throws away the keys and returns just the elements in the new order. Because the keys are computed up front and stored, an item's key is never recomputed during the many pairwise comparisons a sort performs — so an expensive key (say a database lookup) runs n times, not n·log n times. See sorted and key functions.

map can take multiple iterables; it pulls one item from each and passes them together to the two-argument lambda:

• 1 + 10 = 11
• 2 + 20 = 22
• 3 + 30 = 33

Result: [11, 22, 33]. (If the iterables differ in length, map stops at the shortest.)

A map object is a one-pass iterator. The first list(result) walks it to the end, producing [1, 4, 9] and exhausting it. By the second list(result), the iterator is already standing at the end with nothing left — so it yields []. Fix: materialise once and reuse: squares = list(map(...)), then print squares twice.

The predicate is just x itself, so filter keeps items whose truthiness is True. Recall the falsy values: 0, '', None, [], False, 0.0.

• 0 → falsy → drop
• 1 → truthy → keep
• '' → falsy → drop
• 'hi' → truthy → keep
• None → falsy → drop
• [7] → non-empty list → truthy → keep
• [] → empty list → falsy → drop

Result: [1, 'hi', [7]]. This is the handy "strip the falsy values" idiom.

Read inside-out — the innermost call runs first.

1. filter(lambda x: x % 2 == 1, ...) keeps the odd numbers: [1, 3, 5].
2. map(lambda x: x * 2, ...) doubles each survivor: 2, 6, 10.

Result: [2, 6, 10]. Order matters: filtering first means map only works on 3 items, not 5.

The gotcha is that ^ in Python is bitwise XOR, not exponentiation. On integers XOR is perfectly legal, so no error is raised — the code runs and silently produces wrong values:

• 1 ^ 2 = 3
• 2 ^ 2 = 0
• 3 ^ 2 = 1

So squares becomes [3, 0, 1] instead of [1, 4, 9] — a silent logic bug, the most dangerous kind, because nothing crashes to warn you. The core lesson: power in Python is **, not ^. Fix: lambda x: x ** 2 → [1, 4, 9].

Filter first (thin the belt), then map (reshape survivors):

words = ['cat', 'elephant', 'dog', 'hippopotamus', 'ox']
out = list(map(lambda w: w.upper(),
               filter(lambda w: len(w) > 3, words)))

• filter keeps words with len > 3: ['elephant', 'hippopotamus'].
• map uppercases each: ['ELEPHANT', 'HIPPOPOTAMUS'].

Result: ['ELEPHANT', 'HIPPOPOTAMUS'].

sorted compares tuples element by element. We want score descending but name ascending — opposite directions. Trick: negate the numeric key so "larger score" becomes "smaller sort key".

students = [('Ana', 88), ('Bo', 88), ('Cy', 91), ('Di', 75)]
out = sorted(students, key=lambda s: (-s[1], s[0]))

Keys computed: Ana→(-88,'Ana'), Bo→(-88,'Bo'), Cy→(-91,'Cy'), Di→(-75,'Di'). Ascending on those keys: Cy(-91), then the two -88s broken by name (Ana before Bo), then Di(-75).

Result: [('Cy', 91), ('Ana', 88), ('Bo', 88), ('Di', 75)].

pairs = [(1, 3), (2, 2), (5, 1), (0, 9)]
products = map(lambda p: p[0] * p[1], pairs)      # 3, 4, 5, 0
out = list(filter(lambda n: n > 5, products))

• Products: 1*3=3, 2*2=4, 5*1=5, 0*9=0 → [3, 4, 5, 0].
• Keep > 5: none of 3, 4, 5, 0 exceed 5.

Result: [] (empty list). Note 5 > 5 is False — a classic off-by-boundary check.

It prints [2, 2, 2], not [0, 1, 2]. Each lambda closes over the variable i, not its value at creation time. By the time we call the functions, the loop has finished and i is stuck at its final value 2. All three lambdas look up the same i. Fix — bind the value now with a default argument (evaluated at definition time):

funcs = [lambda i=i: i for i in range(3)]
print([f() for f in funcs])   # [0, 1, 2]

This is a higher-order subtlety: functions capture names, and lambdas are no exception.

spy prints once (seen 1), then first = 10. map is lazy: next(gen) pulls exactly one item off the belt, so spy runs only for 1. The elements 2 and 3 are never touched because we never asked for them. If we later did list(gen), spy would fire for 2 and 3 — and note the 1 is already consumed, so it wouldn't reappear. Full output:

seen 1
first = 10

This demonstrates why lazy iterators can save work — untaken items cost nothing.

Output first: range(4) is 0,1,2,3 → ['even', 'odd', 'even', 'odd']. A ternary (a if cond else b) is a single expression, so it's legal inside a lambda. But a list comprehension is usually clearer:

result = ['even' if x % 2 == 0 else 'odd' for x in range(4)]

Rule of thumb: keep the lambda when the rule is tiny and you're feeding a function-taking tool (map/filter/sorted(key=...)). Switch to a named def the moment the logic needs a name to explain itself, multiple statements, or reuse. A named def from Functions and def wins on readability whenever the "cleverness cost" outweighs the "one-liner benefit".

1. list(map(lambda x: x + 1, [0, 9])) ::: [1, 10]
2. list(filter(lambda x: x, [0, 2, '', 'a'])) ::: [2, 'a']
3. sorted([-3, 1, -2], key=lambda x: abs(x)) ::: [1, -2, -3]
4. list(map(lambda a, b: a * b, [2, 3], [4, 5])) ::: [8, 15]
5. (lambda: 7)() ::: 7