Q: functools.partial usage

`partial(multiply, 3)` creates a new callable with `a` pre-filled as 3. Calling `triple(7)` then passes `b=7`, so the full call is `multiply(3, 7)` which returns 21. The trick is that `partial` fills positional arguments from the left - so `triple` is effectively `lambda b: multiply(3, b)`. This pattern is useful whenever you want to specialize a general function without rewriting it.

Q: Passing functions as arguments

A 'first-class object' is one that can be used anywhere any other value can: passed as an argument, returned from a function, assigned to a variable, or stored in a list or dict. Python functions satisfy all of these, which is what makes higher-order functions like `map`, `sorted(key=...)`, and decorators possible. This is the mental model that makes a lot of Python idioms click - a function is just a value.

Question 1

map() return type

Accepted Answer

Both `map()` and `filter()` return lazy iterators, not lists. You have to wrap the result in `list()` to get a concrete sequence. This matters in practice because iterating the map object a second time gives you nothing - it's exhausted. If you need to reuse the result, convert to a list first.

Question 2

sorted() with key function

Accepted Answer

The `key=len` argument sorts by string length: 'fig' (3), 'date' (4), 'apple' (5), 'banana' (6). Python's sort is stable, so elements with the same length keep their original relative order. The key function is applied once per element and the results are used for comparison - the actual strings are what get returned.

Question 3

Lambda return value

Accepted Answer

A lambda is just an anonymous function. `lambda x: x * 2` creates a function that multiplies its argument by 2, and calling it with 5 returns 10. The result is printed directly, so you see 10 - not the function object or None.

Question 4

What a lambda is

Accepted Answer

lambda arguments: expression creates a small unnamed function on the spot. The body must be a single expression - no statements, no return keyword. Lambdas shine as throwaway callbacks: sorted(items, key=lambda x: x[1]) is cleaner than defining a separate named function. If the logic is more than a line, use a named def instead - readability matters more than brevity.

Question 5

What enumerate does

Accepted Answer

enumerate(iterable) yields (0, first_item), (1, second_item), and so on. You can also pass a start argument: enumerate(items, start=1) begins counting at 1. The idiom 'for i, val in enumerate(items)' is the Pythonic replacement for 'for i in range(len(items))' - it avoids the index-based lookup and makes the intent clear.

Question 6

What any() and all() do

Accepted Answer

any([False, False, True]) is True - one truthy value is enough. all([True, True, False]) is False - one falsy value breaks the chain. Both short-circuit: any() stops at the first truthy element, all() stops at the first falsy one. Edge cases worth knowing: any([]) returns False (no truthy elements), and all([]) returns True (vacuously true - no element violates the condition).

Question 7

filter with None as function

Accepted Answer

When you pass `None` as the function to `filter()`, it keeps only truthy elements. The falsy values here are 0, `''`, `None`, `[]`, and `False` - all dropped. The truthy values are 1, `'hello'`, and `[1, 2]`. A non-empty list like `[1, 2]` is truthy even though `[]` is falsy. This is a handy one-liner for stripping empty or missing values from a collection.

Question 8

Multi-key sort with tuple

Accepted Answer

The key function returns `(-score, name)`, so higher scores sort first (because negating flips the order) and ties break alphabetically. Alice and Carol both have score 90, so their negated scores are equal at -90. The tiebreaker is the name, and 'Alice' < 'Carol' alphabetically, so Alice comes first. `result[0]` is `('Alice', 90)`, and `result[0][0]` is `'Alice'`.

Question 9

functools.partial usage

Accepted Answer

`partial(multiply, 3)` creates a new callable with `a` pre-filled as 3. Calling `triple(7)` then passes `b=7`, so the full call is `multiply(3, 7)` which returns 21. The trick is that `partial` fills positional arguments from the left - so `triple` is effectively `lambda b: multiply(3, b)`. This pattern is useful whenever you want to specialize a general function without rewriting it.

Question 10

Passing functions as arguments

Accepted Answer

A 'first-class object' is one that can be used anywhere any other value can: passed as an argument, returned from a function, assigned to a variable, or stored in a list or dict. Python functions satisfy all of these, which is what makes higher-order functions like `map`, `sorted(key=...)`, and decorators possible. This is the mental model that makes a lot of Python idioms click - a function is just a value.

Question 11

functools.reduce accumulation

Accepted Answer

`reduce` starts with the first element as the initial accumulator. The steps are: `(2 - 3) = -1`, then `(-1 - 4) = -5`, then `(-5 - 5) = -10`. The key insight is that `reduce` is left-associative - it processes elements left to right, folding each into the running result. Subtraction is not commutative or associative, so the order matters here. If you expected addition you'd get 14, but with subtraction the accumulation goes negative quickly.

Question 12

map() vs list comprehension tradeoffs

Accepted Answer

The practical rule is: use `map` when you already have a named function to hand in (e.g. `map(str, nums)` instead of `[str(x) for x in nums]`). It also gives you lazy evaluation - the function is only called as items are consumed, not all at once. If you find yourself writing `map(lambda x: ..., iterable)`, the comprehension version is almost always cleaner. The other options are wrong: `map` results are exhausted after one pass, `filter(None, ...)` handles None filtering, and multi-argument transforms need `zip` or `starmap`.

Question 13

lru_cache call count

Accepted Answer

Without caching, `fib(4)` would make 9 calls because the naive recursion recomputes overlapping subproblems. With `lru_cache`, each unique argument is computed exactly once. The unique calls are `fib(4)`, `fib(3)`, `fib(2)`, `fib(1)`, and `fib(0)` - that's 5 distinct values. After `fib(2)` is cached, `fib(3)`'s second recursive call hits the cache instead of incrementing `calls`. This is exactly the exponential-to-linear speedup that makes `lru_cache` so valuable for top-down dynamic programming.

Functional Python