Python Programming Functions and Functional Programming Syllabus

What does it mean that functions are first-class objects in Python?

Functions can be assigned to variables, stored in data structures, passed as arguments, and returned from other functions, just like any other object.

What is a higher-order function?

A function that takes one or more functions as arguments and/or returns a function as its result (e.g. map, filter, and decorators).

What two methods must an object implement to follow the iterator protocol?

__iter__() (returns the iterator itself) and __next__() (returns the next item or raises StopIteration when exhausted).

What is the difference between an iterable and an iterator?

An iterable defines __iter__() and can produce an iterator (e.g. a list). An iterator defines __next__() and produces values one at a time and is itself iterable; it is consumed as you iterate.

What exception signals the end of iteration, and how does a for loop use it?

StopIteration. A for loop repeatedly calls __next__() and stops silently when StopIteration is raised.

What is a generator function and what makes it different from a normal function?

A generator function contains at least one yield statement. Calling it returns a generator (an iterator) without running the body; execution advances lazily on each next() call, pausing at each yield.

What does the yield statement do?

It produces a value to the caller and suspends the function, preserving its local state so execution resumes right after the yield on the next call to next().

What is the key advantage of generators over building and returning a list?

Generators are lazy and memory-efficient: they compute values one at a time on demand instead of storing the whole sequence in memory, enabling infinite or very large sequences.

What is a generator expression and how does it differ syntactically from a list comprehension?

A generator expression uses parentheses instead of square brackets, e.g. (x*x for x in range(10)). It produces a lazy iterator rather than a fully built list.

When you pass a generator expression as the sole argument to a function, what syntax simplification is allowed?

You may omit the extra parentheses, e.g. sum(x*x for x in range(10)) instead of sum((x*x for x in range(10))).

What is a closure?

A closure is a nested function that captures and remembers variables from its enclosing scope, so it can access those free variables even after the enclosing function has returned.

What is a free variable in the context of closures?

A free variable is a variable used in a function that is neither a local variable nor a parameter of that function, but is bound in an enclosing scope.

How can you inspect the free variables captured by a closure?

Through the function's __closure__ attribute (a tuple of cell objects); each cell's cell_contents holds the captured value. The names are in function.__code__.co_freevars.

What three conditions are required to create a closure in Python?

There must be a nested (inner) function, the inner function must reference a variable from the enclosing function, and the enclosing function must return the inner function.

What is a decorator in Python?

A decorator is a callable that takes a function (or class) and returns a modified/wrapped version, typically to add behavior without changing the original code. Applied with the @decorator syntax above a definition.

How does @my_decorator above a function definition desugar?

@my_decorator over def f(): ... is equivalent to f = my_decorator(f) after the definition.

What is the standard structure of a simple decorator?

A function that takes func, defines an inner wrapper(*args, **kwargs) that calls func and adds behavior, and returns wrapper.

Why should a decorator's wrapper accept *args and **kwargs?

So the wrapper can transparently accept and forward any arguments the original function takes, making the decorator work on functions with any signature.

What problem does @functools.wraps solve in a decorator?

It copies the wrapped function's metadata (__name__, __doc__, __module__, etc.) onto the wrapper, so the decorated function retains its original identity instead of appearing as 'wrapper'.

How does a decorator that takes arguments differ in structure from a plain decorator?

It needs three nested levels: an outer factory that accepts the arguments and returns the actual decorator, which accepts the function and returns the wrapper. Effectively f = factory(args)(f).

What does @repeat(3) above def f() desugar to (decorator with arguments)?

It desugars to f = repeat(3)(f): repeat(3) returns a decorator, which is then applied to f.

What does functools.lru_cache do?

It memoizes a function by caching results keyed on the arguments, so repeated calls with the same arguments return the stored result. It is applied as a decorator (@lru_cache(maxsize=None) for unbounded).

What does functools.partial create?

A new callable with some of the original function's arguments pre-filled (fixed), reducing the number of arguments you must supply at call time, e.g. partial(int, base=2).

What does functools.reduce require and return compared to a comprehension?

reduce takes a binary function and an iterable and folds them into one accumulated value; unlike a comprehension it returns a single scalar result, not a new sequence.

What is the purpose of functools.cache (Python 3.9+)?

It is a simple unbounded memoization decorator, equivalent to lru_cache(maxsize=None), storing all past call results without eviction.

What does the functools.wraps decorator use internally?

It is itself implemented via functools.update_wrapper, which copies attributes like __module__, __name__, __qualname__, __doc__, and __dict__, and sets __wrapped__ to the original function.

What is the difference between map() and a list comprehension?

map(f, it) applies an existing function lazily and returns an iterator; a list comprehension [f(x) for x in it] can include inline expressions and conditions and eagerly builds a list. Comprehensions are often more readable.

Can you iterate over the same generator object twice? Why or why not?

No. A generator is a one-time iterator; once exhausted it yields nothing more. You must create a new generator to iterate again.

What does functools.reduce(lambda a, b: a if a > b else b, [3, 7, 2]) compute?

It computes the maximum, 7, by cumulatively keeping the larger of each pair across the list.

How do you convert the result of map() or filter() into a concrete list?

Wrap the call in list(), e.g. list(map(str, nums)) or list(filter(is_even, nums)), because both return lazy iterators in Python 3.