Question 1

Functions without return

Accepted Answer

A function that reaches the end without a return statement implicitly returns None. The message is built inside the function but never returned, so 'result' is assigned None. This is a common beginner mistake - always check that your function explicitly returns the value you need.

Question 2

Closure captures variable by reference

Accepted Answer

make_adder returns the inner function 'adder', which closes over the variable 'n'. When add5 = make_adder(5) is called, n is bound to 5 in adder's closure. Calling add5(3) then returns 3 + 5 = 8. Closures are the foundation of decorators and factory functions.

Question 3

Lambda as sort key

Accepted Answer

The key function is called on each element to produce the sort key. lambda p: p[1] extracts the second element of each tuple. Sorting by the second element ('a', 'b', 'c' alphabetically) puts (2,'a') first, (1,'b') second, (3,'c') third. The original tuples are kept intact - only their order changes.

Question 4

*args collects positional arguments

Accepted Answer

The *nums syntax packs all positional arguments into a tuple called 'nums'. Inside the function, nums is (1, 2, 3, 4), and sum() works on any iterable, so it returns 10. Use *args when you want a function to accept a variable number of positional arguments.

Question 5

What happens without a base case

Accepted Answer

Python enforces a maximum recursion depth (default ~1000). When exceeded, it raises RecursionError: maximum recursion depth exceeded. The function doesn't run forever - the call stack has a finite size and Python protects against overflowing it. You can inspect and change the limit with sys.getrecursionlimit() and sys.setrecursionlimit(), but this is rarely the right fix - rethink the algorithm instead.

Question 6

map() returns an iterator

Accepted Answer

map() returns a lazy iterator of type 'map', not a list. It doesn't compute any values until you iterate over it. To get a list, wrap it: list(map(...)). This lazy evaluation is memory-efficient for large inputs - you only process elements as you need them.

Question 7

Unpacking into function call

Accepted Answer

The * operator in a function call unpacks an iterable into positional arguments. add(*[1, 2, 3]) is equivalent to add(1, 2, 3), which returns 1 + 2 + 3 = 6. You can also use ** to unpack a dict into keyword arguments.

Question 8

Forgetting to return a computed value

Accepted Answer

double() computes n * 2 and stores it in a local variable, but never returns it. When a function exits without a return statement, Python returns None automatically. Assigning the result of double(5) to x means x is None, not 10. The fix is a single 'return result' line at the end.

Question 9

Lambda with multiple arguments

Accepted Answer

A lambda can take multiple arguments separated by commas before the colon. lambda x, y: x * y is exactly equivalent to 'def multiply(x, y): return x * y', just written inline. Lambdas are expressions, not statements - they are useful when you need a short function object without giving it a name in the surrounding scope.

Question 10

Tracing a simple recursive function

Accepted Answer

Each call prints n before making the recursive call, so the output appears in descending order. When n reaches 0, the base case runs: 'done' is printed and the function returns without recursing further. Tracing through a recursive function call-by-call is the most reliable way to understand what it produces.

Question 11

filter() is also lazy

Accepted Answer

filter() returns a lazy filter object, not a list. Wrapping it in list() forces evaluation - it iterates the source and keeps only elements where the function returns True. x % 2 == 0 is True for 2 and 4, so the result is [2, 4]. Like map(), filter() is memory-efficient for large iterables because values are produced one at a time.