Decorators & Closures — Python Questions with Answers

Q28. easy

A lambda is best described as:

add = lambda a, b: a + b
print(sorted(data, key=lambda x: x[1]))

1. A A small anonymous function limited to a single expression
2. B A named recursive function
3. C A class method
4. D A loop construct

Q1. medium

What is a nested function in Python?

def outer():
    def inner():
        print("inside")
    inner()

outer()   # inside

1. A A function defined inside another function
2. B A function that calls itself
3. C Two functions with the same name
4. D A function imported from another module

Q5. medium

Why can a function be passed as an argument to another function?

def shout(t): return t.upper()
funcs = [shout, str.lower]
print(funcs[0]("hi"))   # HI

1. A Functions are first-class objects - they can be stored in variables, passed around, and returned
2. B Because of a special decorator
3. C Only lambda functions can be passed
4. D They can't - only their results can

Q6. medium

What is a higher-order function?

def apply_twice(f, x):
    return f(f(x))

print(apply_twice(lambda n: n + 3, 10))   # 16

1. A A function that takes another function as an argument and/or returns a function
2. B A function with many arguments
3. C A recursive function
4. D A function defined at the top of a file

Q7. medium

What does the @ symbol mean above a function definition? @timer def slow(): ...

@timer
def slow(): ...
# is exactly the same as:
def slow(): ...
slow = timer(slow)

1. A It applies a decorator - shorthand for slow = timer(slow)
2. B It's a comment
3. C It imports timer
4. D It makes slow private

Q14. medium

Which is a common REAL use for decorators?

1. A Logging, timing, caching, access control, retrying - cross-cutting concerns
2. B Declaring variables
3. C Importing modules
4. D Creating loops

Q16. medium

Can you stack multiple decorators on one function? @a @b def f(): ...

@a
@b
def f(): ...
# equivalent to: f = a(b(f))

1. A Yes - they apply bottom-up: f = a(b(f))
2. B No, only one decorator per function
3. C Yes, but they apply top-down: f = b(a(f))
4. D Only if they take arguments

Q19. medium

What is the output? def power(base): def raise_to(exp): return base ** exp return raise_to square = power(2) print(square(5))

1. A 32
2. B 10
3. C 25
4. D 7

Q20. medium

How can you inspect the values a closure has captured?

def outer():
    x = 42
    return lambda: x
f = outer()
print(f.__closure__[0].cell_contents)   # 42

1. A func.__closure__ (each cell has .cell_contents)
2. B func.__vars__
3. C func.closure()
4. D You can't inspect them

Q21. medium

Why might you prefer a CLOSURE over a full CLASS for simple state?

1. A Less boilerplate when you only need one method plus some remembered state
2. B Closures are always faster
3. C Classes can't hold state
4. D Closures support inheritance

Q23. medium

What is the output ORDER? @deco def f(): print("body") # where deco prints 'decorating' at wrap time print("---") f()

1. A decorating / --- / body (decorator runs at definition, before the call)
2. B --- / decorating / body
3. C body / decorating / ---
4. D --- / body

Q25. medium

Which built-in decorators are common on class methods?

1. A @property, @staticmethod, @classmethod
2. B @public, @private, @protected
3. C @method, @class, @object
4. D @get, @set, @delete

Q27. medium

What is the output? def tag(name): def deco(f): def wrapper(): return f"<{name}>{f()}</{name}>" return wrapper return deco @tag("b") def text(): return "hi" print(text())

1. A <b>hi</b>
2. B hi
3. C <b></b>
4. D <tag>hi</tag>

Q29. medium

Why can't a lambda contain statements like if/for or assignments?

grade = lambda s: "pass" if s >= 50 else "fail"   # OK
# lambda s: for i in s: ...   # SyntaxError

1. A A lambda body must be a single EXPRESSION - use def for anything with statements
2. B Lambdas are too slow for them
3. C They can, with semicolons
4. D Only in Python 2

Q2. hard

What is a CLOSURE?

def make_adder(n):
    def add(x):
        return x + n   # remembers n
    return add

add5 = make_adder(5)
print(add5(10))   # 15 - n=5 is remembered

1. A An inner function that remembers variables from its enclosing function, even after that function has finished
2. B A function that closes a file
3. C The end of a loop
4. D A private variable

Q3. hard

What is the output? def outer(): x = 10 def inner(): return x return inner f = outer() print(f())

f = outer()   # outer finishes, but x lives on in f
print(f())     # 10

1. A 10
2. B None
3. C NameError - x is gone
4. D <function>

Q4. hard

Which keyword lets an inner function MODIFY a variable in the enclosing (outer) function?

def counter():
    count = 0
    def inc():
        nonlocal count
        count += 1
        return count
    return inc

c = counter()
print(c(), c(), c())   # 1 2 3

1. A nonlocal
2. B global
3. C outer
4. D enclosing

Q8. hard

What is a decorator?

def logged(func):
    def wrapper(*args, **kwargs):
        print(f"calling {func.__name__}")
        return func(*args, **kwargs)
    return wrapper

@logged
def greet(): print("hi")

1. A A function that takes a function and returns a NEW function, usually adding behavior around it
2. B A comment style
3. C A type of loop
4. D A class attribute

Q9. hard

In a decorator's wrapper, why use *args and **kwargs? def wrapper(*args, **kwargs):

def logged(func):
    def wrapper(*args, **kwargs):
        return func(*args, **kwargs)   # pass all through
    return wrapper

1. A So the wrapper can accept ANY arguments and pass them through to the wrapped function unchanged
2. B To make it faster
3. C They are required keywords for decorators
4. D To limit the function to two arguments

Q10. hard

What is the output? def deco(f): def wrapper(): print("before") f() print("after") return wrapper @deco def hello(): print("hello") hello()

# output:
# before
# hello
# after

1. A before / hello / after
2. B hello
3. C before / after
4. D hello / before / after

Q11. hard

After @deco wraps hello(), what does hello.__name__ show WITHOUT functools.wraps?

from functools import wraps
def deco(f):
    @wraps(f)          # preserves f's name/doc
    def wrapper(*a, **k):
        return f(*a, **k)
    return wrapper

1. A 'wrapper' - the wrapper's name replaces the original, losing metadata
2. B 'hello' - the name is preserved automatically
3. C 'deco'
4. D An empty string

Q12. hard

What does functools.wraps do inside a decorator?

1. A Copies the original function's name, docstring and metadata onto the wrapper
2. B Wraps the function in a try/except
3. C Makes the function run twice
4. D Caches the result

Q13. hard

How can a decorator itself take arguments? @repeat(3) def greet(): ...

def repeat(n):
    def decorator(func):
        def wrapper(*a, **k):
            for _ in range(n):
                func(*a, **k)
        return wrapper
    return decorator

@repeat(3)
def hi(): print("hi")   # prints hi 3 times

1. A You need THREE nested functions - the outer takes the argument and returns the actual decorator
2. B Decorators can't take arguments
3. C Use @repeat, 3
4. D Pass it to the wrapped function instead

Q15. hard

What does @functools.lru_cache do?

from functools import lru_cache
@lru_cache
def fib(n):
    return n if n < 2 else fib(n-1) + fib(n-2)
print(fib(50))   # instant, not slow

1. A Caches a function's results so repeated calls with the same arguments return instantly
2. B Limits how many times a function runs
3. C Logs the function calls
4. D Clears memory

Q17. hard

What is the output? def make_multipliers(): return [lambda x: x * i for i in range(3)] print([m(10) for m in make_multipliers()])

# Fix with a default argument to capture the value:
[lambda x, i=i: x * i for i in range(3)]
# -> [0, 10, 20]

1. A [20, 20, 20] - all lambdas share the SAME i, which ends at 2
2. B [0, 10, 20]
3. C [0, 20, 40]
4. D [10, 10, 10]

Q18. hard

How do you FIX late-binding so each lambda captures its own i? [lambda x: x * i for i in range(3)]

mults = [lambda x, i=i: x * i for i in range(3)]
print([m(10) for m in mults])   # [0, 10, 20]

1. A Add a default argument: [lambda x, i=i: x * i for i in range(3)]
2. B Use global i
3. C Remove the loop
4. D It cannot be fixed

Q22. hard

A class-based decorator implements which method to make instances act as the wrapper?

class CountCalls:
    def __init__(self, f):
        self.f = f
        self.n = 0
    def __call__(self, *a, **k):
        self.n += 1
        return self.f(*a, **k)

1. A __call__
2. B __wrap__
3. C __deco__
4. D __init__ only

Q24. hard

Why does a decorator usually RETURN the wrapper function instead of calling it?

1. A The decorator replaces the original name; it must return a callable to be called later, not the result of one call
2. B Returning is optional
3. C To save memory
4. D So the function runs immediately once

Q26. hard

What is memoization (as done by a caching decorator)?

def memoize(f):
    cache = {}
    def wrapper(n):
        if n not in cache:
            cache[n] = f(n)
        return cache[n]
    return wrapper

1. A Storing results of expensive calls and reusing them for repeated inputs
2. B Writing memos in comments
3. C Freeing memory automatically
4. D Running a function in memory only

Q30. hard

What is the output? counter = 0 def make(): counter = 0 def inc(): nonlocal counter counter += 1 return counter return inc a = make() b = make() print(a(), a(), b())

1. A 1 2 1 - each closure has its OWN independent counter
2. B 1 2 3 - they share one counter
3. C 1 1 1
4. D Error