← Functions & Scope

Select a question from the sidebar

18 questions in this topic

Question 1 / 18

How do you define and call functions in Python?

Functions are defined with the def keyword:

def function_name(parameters):
    """Docstring."""
    body
    return value

Key rules:

def creates a function object and binds it to the name
Parameters are local to the function
return sends a value back (default is None)
Functions are first-class objects (can be assigned, passed, stored)
Indentation defines the function body

Return behavior:

return with no value returns None
No return statement returns None
Can return multiple values (actually returns a tuple)
return immediately exits the function

Pseudo Code

def name(params):
    """docstring"""
    body
    return value

- Functions are objects
- return None by default
- return x, y returns a tuple (x, y)

Code

# Basic function
def greet(name):
    """Return a greeting string."""
    return f"Hello, {name}!"

print(greet("Alice"))  # Hello, Alice!

# Function without return
def print_greeting(name):
    print(f"Hello, {name}!")

result = print_greeting("Bob")  # prints: Hello, Bob!
print(result)                   # None

# Multiple return values (tuple)
def min_max(numbers):
    return min(numbers), max(numbers)

lo, hi = min_max([3, 1, 4, 1, 5])
print(f"min={lo}, max={hi}")  # min=1, max=5

result = min_max([3, 1, 4])
print(type(result))  # <class 'tuple'>

# Early return
def divide(a, b):
    if b == 0:
        return None  # early exit
    return a / b

print(divide(10, 3))   # 3.333...
print(divide(10, 0))   # None

# Functions are objects
def square(x):
    return x ** 2

f = square           # assign function to variable
print(f(5))          # 25
print(type(square))  # <class 'function'>

# Functions can be passed as arguments
def apply(func, value):
    return func(value)

print(apply(square, 4))     # 16
print(apply(len, "hello"))  # 5

# Nested function definition
def outer():
    def inner():
        return "inner"
    return inner()

print(outer())  # 'inner'

# Docstring access
print(greet.__doc__)  # 'Return a greeting string.'
help(greet)

Hello, Alice!
Hello, Bob!
None
min=1, max=5
<class 'tuple'>
3.3333333333333335
None
25
<class 'function'>
16
5
inner
Return a greeting string.
Help on function greet:

greet(name)
Return a greeting string.

Key Points

•def creates a function object bound to a name
•return None by default (no return or bare return)
•Multiple return values are actually tuples
•Functions are first-class objects (assignable, passable)
•Docstrings are accessible via __doc__ or help()

Gotchas

•def is executed at runtime, not compile time -- function is created when def runs
•Functions without return give None -- do not use the result accidentally
•Parameter names are local -- they do not affect variables with the same name outside
•return immediately exits -- code after return is unreachable

Define with def name(params):, call with name(args). Returns None by default. Multiple returns create a tuple. Functions are first-class objects.

•return None by default
•Functions are first-class objects

def add(a, b):
    return a + b

print(add(3, 4))  # 7

def min_max(lst):
    return min(lst), max(lst)  # returns tuple

lo, hi = min_max([1, 5, 3])

Functions without return give None

Question 2 / 18

How do default arguments work in Python and what is the mutable default argument trap?

Default arguments provide a value when the caller does not supply one:

def func(a, b=10, c='hello'):

Critical rule: Default values are evaluated once when the function is defined, not each time the function is called.

This creates the mutable default argument trap: if the default is a mutable object (list, dict, set), the same object is shared across all calls.

The fix: Use None as the default and create a fresh object inside the function.

Why this happens: The default value is stored as an attribute of the function object (func.__defaults__). Since def runs once, the default is created once.

Pseudo Code

TRAP:
  def f(lst=[]):       # default [] created ONCE at def time
      lst.append(1)    # mutates the SAME list
      return lst
  f() -> [1]
  f() -> [1, 1]  # BUG!

FIX:
  def f(lst=None):     # None is immutable sentinel
      if lst is None:
          lst = []     # fresh list each call
      lst.append(1)
      return lst

Code

# Default arguments
def greet(name, greeting="Hello"):
    return f"{greeting}, {name}!"

print(greet("Alice"))               # Hello, Alice!
print(greet("Bob", "Howdy"))        # Howdy, Bob!

# THE MUTABLE DEFAULT TRAP
def bad_append(item, lst=[]):
    lst.append(item)
    return lst

print(bad_append(1))  # [1]
print(bad_append(2))  # [1, 2] -- BUG! Same list reused!
print(bad_append(3))  # [1, 2, 3] -- keeps accumulating!

# Inspect the default
print(bad_append.__defaults__)  # ([1, 2, 3],) -- stored on function

# THE FIX: Use None sentinel
def good_append(item, lst=None):
    if lst is None:
        lst = []
    lst.append(item)
    return lst

print(good_append(1))  # [1]
print(good_append(2))  # [2] -- fresh list each time!
print(good_append(3, [10, 20]))  # [10, 20, 3] -- uses provided list

# Same trap with dict
def bad_config(key, value, config={}):
    config[key] = value
    return config

print(bad_config("a", 1))  # {'a': 1}
print(bad_config("b", 2))  # {'a': 1, 'b': 2} -- BUG!

# Fix
def good_config(key, value, config=None):
    if config is None:
        config = {}
    config[key] = value
    return config

# Default evaluated at def time, not call time
import datetime

def bad_timestamp(when=datetime.datetime.now()):
    return when

t1 = bad_timestamp()
import time
time.sleep(0.1)
t2 = bad_timestamp()
print(t1 == t2)  # True! Same timestamp -- evaluated once at def time

def good_timestamp(when=None):
    if when is None:
        when = datetime.datetime.now()
    return when

Hello, Alice!
Howdy, Bob!
[1]
[1, 2]
[1, 2, 3]
([1, 2, 3],)
[1]
[2]
[10, 20, 3]
{'a': 1}
{'a': 1, 'b': 2}
True

Key Points

•Default values are evaluated ONCE at function definition time
•Mutable defaults (list, dict, set) are shared across calls
•Always use None as default for mutable arguments
•The pattern: if param is None: param = fresh_value
•Defaults are stored in func.__defaults__

Gotchas

•def f(lst=[]): is one of Python's most common beginner bugs
•datetime.now() as default gives the same time every call
•The None pattern also applies to dicts, sets, and any mutable object
•Default arguments must come after non-default: def f(a, b=1) is OK, def f(a=1, b) is not

Default values are evaluated once at definition time. Mutable defaults (list, dict) are shared across calls -- use None sentinel instead.

•Defaults evaluated once at def time
•Use None sentinel for mutable defaults

# BUG:
def bad(lst=[]):
    lst.append(1)
    return lst
print(bad(), bad())  # [1] [1, 1]

# FIX:
def good(lst=None):
    if lst is None:
        lst = []
    lst.append(1)
    return lst
print(good(), good())  # [1] [1]

[1, 1] [1, 1]
[1] [1]

def f(lst=[]): shares the same list across calls

Question 3 / 18

How do *args and **kwargs work?

*args collects extra positional arguments into a tuple. **kwargs collects extra keyword arguments into a dict.

Order in function signature:

def func(pos1, pos2, /, normal, *args, kw_only, **kwargs):

Positional-only (before /)
Normal parameters
*args (catches remaining positional)
Keyword-only (after *args or bare *)
**kwargs (catches remaining keyword)

Unpacking in function calls:

func(*iterable) unpacks iterable as positional args
func(**dict) unpacks dict as keyword args

Pseudo Code

def func(*args, **kwargs):
    args is a tuple of positional arguments
    kwargs is a dict of keyword arguments

Calling:
    func(1, 2, 3, a=4, b=5)
    args = (1, 2, 3)
    kwargs = {'a': 4, 'b': 5}

Unpacking:
    func(*[1, 2, 3])  -> func(1, 2, 3)
    func(**{'a': 1})   -> func(a=1)

Code

# *args -- collects positional arguments into tuple
def sum_all(*args):
    print(f"args = {args}")  # tuple
    return sum(args)

print(sum_all(1, 2, 3))       # args = (1, 2, 3), returns 6
print(sum_all(1, 2, 3, 4, 5)) # args = (1, 2, 3, 4, 5), returns 15

# **kwargs -- collects keyword arguments into dict
def print_info(**kwargs):
    print(f"kwargs = {kwargs}")  # dict
    for key, value in kwargs.items():
        print(f"  {key}: {value}")

print_info(name="Alice", age=30, city="NYC")
# kwargs = {'name': 'Alice', 'age': 30, 'city': 'NYC'}

# Both together
def func(a, b, *args, **kwargs):
    print(f"a={a}, b={b}")
    print(f"args={args}")
    print(f"kwargs={kwargs}")

func(1, 2, 3, 4, x=5, y=6)
# a=1, b=2
# args=(3, 4)
# kwargs={'x': 5, 'y': 6}

# Unpacking in calls
def add(a, b, c):
    return a + b + c

nums = [1, 2, 3]
print(add(*nums))  # 6 (unpacks list as positional args)

kw = {"a": 1, "b": 2, "c": 3}
print(add(**kw))   # 6 (unpacks dict as keyword args)

# Forwarding arguments (decorator pattern)
def decorator(func):
    def wrapper(*args, **kwargs):
        print(f"Calling {func.__name__}")
        return func(*args, **kwargs)
    return wrapper

@decorator
def greet(name, greeting="Hello"):
    return f"{greeting}, {name}!"

print(greet("Alice"))  # Calling greet, Hello, Alice!

# Practical: merge dicts with **
def create_user(**kwargs):
    defaults = {"role": "user", "active": True}
    return {**defaults, **kwargs}

user = create_user(name="Alice", role="admin")
print(user)  # {'role': 'admin', 'active': True, 'name': 'Alice'}

# *args to forward to another function
def log_and_call(func, *args, **kwargs):
    print(f"Calling {func.__name__} with args={args}, kwargs={kwargs}")
    return func(*args, **kwargs)

result = log_and_call(max, 1, 5, 3)
print(result)  # 5

args = (1, 2, 3)
6
args = (1, 2, 3, 4, 5)
15
kwargs = {'name': 'Alice', 'age': 30, 'city': 'NYC'}
name: Alice
age: 30
city: NYC
a=1, b=2
args=(3, 4)
kwargs={'x': 5, 'y': 6}
6
6
Calling greet
Hello, Alice!
{'role': 'admin', 'active': True, 'name': 'Alice'}
Calling max with args=(1, 5, 3), kwargs={}
5

Key Points

•*args collects extra positional args as a tuple
•**kwargs collects extra keyword args as a dict
•Order: positional, *args, keyword-only, **kwargs
•*iterable unpacks in calls, **dict unpacks as keywords
•Common in decorators for argument forwarding

Gotchas

•*args and **kwargs are just naming conventions -- *x and **y also work
•Cannot use *args and **kwargs with the same name as existing parameters
•dict(**dict1, **dict2) fails on duplicate keys in Python < 3.9
•Passing a dict as *args unpacks the keys, not the items

*args collects extra positional args as a tuple. **kwargs collects extra keyword args as a dict. Use *list and **dict to unpack in calls.

•*args = tuple of positional, **kwargs = dict of keyword
•Unpack with * and ** in calls

def func(*args, **kwargs):
    print(args, kwargs)

func(1, 2, x=3)  # (1, 2) {'x': 3}

def add(a, b): return a + b
print(add(*[3, 4]))    # 7
print(add(**{'a':3,'b':4}))  # 7

(1, 2) {'x': 3}
7
7

*args/**kwargs are conventions -- any names work

Question 4 / 18

What are keyword-only and positional-only arguments?

Python 3 allows you to enforce how arguments are passed:

Keyword-only arguments (after * or *args): Must be passed by name. Cannot be passed positionally.

def func(a, b, *, key_only):

Positional-only arguments (before /, Python 3.8+): Must be passed by position. Cannot be passed by name.

def func(pos_only, /, normal):

Full signature order:

def func(pos_only, /, normal, *, kw_only):

Why use these?

Keyword-only: prevent ambiguity, force clarity (e.g., verbose=True)
Positional-only: allow parameter name changes without breaking callers, match C functions

Pseudo Code

def f(a, b, /, c, d, *, e, f):
    a, b     -> positional only
    c, d     -> normal (either way)
    e, f     -> keyword only

f(1, 2, 3, d=4, e=5, f=6)  # valid
f(a=1, ...)  # TypeError (a is positional-only)
f(1, 2, 3, 4, 5, 6)  # TypeError (e, f are keyword-only)

Code

# Keyword-only arguments (after * or *args)
def connect(host, port, *, timeout=30, verbose=False):
    print(f"Connecting to {host}:{port} (timeout={timeout}, verbose={verbose})")

connect("localhost", 5432)                        # OK
connect("localhost", 5432, timeout=60)             # OK
connect("localhost", 5432, verbose=True)           # OK
# connect("localhost", 5432, 60)                   # TypeError! timeout is keyword-only

# Bare * forces keyword-only for all following params
def create_user(*, name, email, role="user"):
    return {"name": name, "email": email, "role": role}

user = create_user(name="Alice", email="alice@example.com")
print(user)
# create_user("Alice", "alice@example.com")  # TypeError!

# Positional-only arguments (before /, Python 3.8+)
def pow(base, exp, /):
    return base ** exp

print(pow(2, 10))   # 1024
# pow(base=2, exp=10)  # TypeError! positional-only

# Why positional-only? Allows renaming without breaking callers
def distance(x1, y1, x2, y2, /):
    return ((x2-x1)**2 + (y2-y1)**2) ** 0.5

print(distance(0, 0, 3, 4))  # 5.0
# Can rename params without breaking anything

# Full signature
def example(pos_only, /, normal, *, kw_only):
    print(f"pos={pos_only}, norm={normal}, kw={kw_only}")

example(1, 2, kw_only=3)         # OK
example(1, normal=2, kw_only=3)  # OK
# example(pos_only=1, ...)        # TypeError
# example(1, 2, 3)                # TypeError

# Real-world example: built-in functions use positional-only
# len() only accepts positional:
print(len([1, 2, 3]))  # 3
# len(obj=[1, 2, 3])   # TypeError

# Keyword-only with *args
def func(a, *args, verbose=False):
    if verbose:
        print(f"a={a}, extra={args}")
    return a

func(1, 2, 3, verbose=True)  # a=1, extra=(2, 3)

Connecting to localhost:5432 (timeout=30, verbose=False)
Connecting to localhost:5432 (timeout=60, verbose=False)
Connecting to localhost:5432 (timeout=30, verbose=True)
{'name': 'Alice', 'email': 'alice@example.com', 'role': 'user'}
1024
5.0
pos=1, norm=2, kw=3
pos=1, norm=2, kw=3
3
a=1, extra=(2, 3)

Key Points

•After *: keyword-only (must pass by name)
•Before /: positional-only (must pass by position, Python 3.8+)
•Keyword-only prevents positional ambiguity
•Positional-only allows internal parameter renaming
•Many built-in functions use positional-only parameters

Gotchas

•Bare * (no args) forces all following to be keyword-only: def f(*, a, b)
•Positional-only (/) requires Python 3.8+
•You can have the same name for a positional-only param and a **kwargs key
•Using keyword-only for boolean flags (verbose=True) is a best practice

After *: keyword-only (must use name). Before /: positional-only (must use position, Python 3.8+). Use keyword-only for clarity (*, verbose=False).

•* for keyword-only, / for positional-only
•Keyword-only for clarity on boolean flags

def func(pos_only, /, normal, *, kw_only):
    pass

func(1, 2, kw_only=3)         # OK
func(1, normal=2, kw_only=3)  # OK
# func(pos_only=1, ...)       # TypeError

/ requires Python 3.8+

Question 5 / 18

What is the LEGB scope rule in Python?

LEGB is the order Python looks up variable names:

L -- Local: Inside the current function E -- Enclosing: Inside enclosing functions (for nested functions) G -- Global: Module-level (top of the file) B -- Built-in: Python built-in names (print, len, range, etc.)

Python searches from innermost to outermost scope. The first match wins.

Key rules:

Assignment in a function makes a variable local (unless global or nonlocal)
Reading a variable searches LEGB
The global keyword accesses/modifies module-level variables
The nonlocal keyword accesses/modifies enclosing function variables

Pseudo Code

L - Local: variables inside current function
E - Enclosing: variables in outer function (for closures)
G - Global: module-level variables
B - Built-in: print, len, range, etc.

Lookup: L -> E -> G -> B (first match wins)
Assignment: creates in local scope by default

Code

# Local scope
def func():
    x = 10  # local
    print(x)  # 10

func()
# print(x)  # NameError: x is not defined (local to func)

# Global scope
x = "global"

def func():
    print(x)  # reads global x

func()  # 'global'

# Assignment creates local (shadowing)
x = "global"

def func():
    x = "local"  # creates NEW local x, does not modify global
    print(x)     # 'local'

func()
print(x)  # 'global' (unchanged)

# The UnboundLocalError trap
x = 10

def broken():
    print(x)  # UnboundLocalError! x is local (due to assignment below)
    x = 20    # this assignment makes x local for the ENTIRE function

# broken()  # UnboundLocalError: local variable 'x' referenced before assignment

# Enclosing scope (closures)
def outer():
    x = "enclosing"
    def inner():
        print(x)  # reads from enclosing scope
    inner()

outer()  # 'enclosing'

# global keyword
counter = 0

def increment():
    global counter
    counter += 1

increment()
increment()
print(counter)  # 2

# nonlocal keyword (for enclosing scope)
def outer():
    count = 0
    def increment():
        nonlocal count
        count += 1
    increment()
    increment()
    print(count)  # 2

outer()

# Built-in scope
print(len([1, 2, 3]))  # 3 -- len is in built-in scope

# Shadowing built-ins (bad practice)
def bad_idea():
    len = 42      # shadows built-in len
    # print(len([1,2]))  # TypeError: 'int' object is not callable
    print(len)    # 42

bad_idea()
print(len([1, 2]))  # 2 -- global len is fine

# LEGB in action
x = "global"

def outer():
    x = "enclosing"
    def inner():
        x = "local"
        print(x)  # 'local' (L)
    inner()
    print(x)      # 'enclosing' (E)

outer()
print(x)          # 'global' (G)

10
global
local
global
enclosing
2
2
3
42
2
local
enclosing
global

Key Points

•LEGB: Local -> Enclosing -> Global -> Built-in
•Assignment in a function makes a variable local
•global keyword to modify module-level variables
•nonlocal keyword to modify enclosing function variables
•UnboundLocalError occurs when reading before local assignment

Gotchas

•Assignment anywhere in a function makes the variable local for the ENTIRE function
•UnboundLocalError: reading a variable before assignment when a later assignment makes it local
•Shadowing built-ins (list = [], len = 42) is legal but dangerous
•global and nonlocal are generally discouraged -- prefer return values and parameters

LEGB: Local -> Enclosing -> Global -> Built-in. Assignment makes a variable local. Use global for module-level and nonlocal for enclosing scope.

•Local -> Enclosing -> Global -> Built-in
•Assignment makes variable local

x = "global"
def outer():
    x = "enclosing"
    def inner():
        x = "local"
        print(x)   # 'local'
    inner()
    print(x)       # 'enclosing'
outer()
print(x)           # 'global'

local
enclosing
global

Assignment anywhere in a function makes it local for the ENTIRE function

Question 6 / 18

What are global and nonlocal keywords and when should you use them?

global declares that a variable inside a function refers to the module-level (global) variable.

nonlocal declares that a variable inside a nested function refers to the enclosing function's variable.

Both are needed only for assignment -- reading from outer scopes works without them.

When to use:

global: Module-level counters, configuration, singletons (use sparingly)
nonlocal: Closures that need to modify enclosing state (counters, accumulators)

Best practice: Avoid global when possible. Prefer:

Return values from functions
Class attributes / instance variables
Mutable container arguments

Pseudo Code

global var: assignment modifies module-level variable
nonlocal var: assignment modifies enclosing function's variable

Without these keywords:
  - Reading from outer scopes: works automatically
  - Assignment: creates a new local variable (shadows outer)

Code

# global -- modify module-level variable
total = 0

def add_to_total(amount):
    global total
    total += amount

add_to_total(10)
add_to_total(20)
print(total)  # 30

# Without global: creates local variable
total = 0

def broken_add(amount):
    # total += amount  # UnboundLocalError without global!
    pass

# nonlocal -- modify enclosing function's variable
def make_counter():
    count = 0
    def increment():
        nonlocal count
        count += 1
        return count
    return increment

counter = make_counter()
print(counter())  # 1
print(counter())  # 2
print(counter())  # 3

# Without nonlocal: creates local variable
def make_broken_counter():
    count = 0
    def increment():
        # count += 1  # UnboundLocalError without nonlocal!
        return 0
    return increment

# Workaround without nonlocal: mutable container
def make_counter_alt():
    count = [0]  # mutable list
    def increment():
        count[0] += 1  # modifying contents, not rebinding
        return count[0]
    return increment

counter = make_counter_alt()
print(counter())  # 1
print(counter())  # 2

# Why avoid global (prefer class or return)
class Counter:
    def __init__(self):
        self.value = 0
    
    def increment(self):
        self.value += 1
        return self.value

c = Counter()
print(c.increment())  # 1
print(c.increment())  # 2

# nonlocal with multiple nesting levels
def outer():
    x = 1
    def middle():
        def inner():
            nonlocal x  # refers to outer's x
            x = 10
        inner()
        print(x)  # 10
    middle()

outer()

Key Points

•global: access/modify module-level variable inside a function
•nonlocal: access/modify enclosing function variable in nested function
•Only needed for assignment, not for reading
•Prefer return values and classes over global
•Mutable containers (list, dict) can work around nonlocal

Gotchas

•global and nonlocal must be declared before use in the function
•nonlocal cannot refer to global scope -- only enclosing functions
•Using global makes code harder to test and reason about
•nonlocal in deeply nested functions refers to the nearest enclosing scope

global modifies module-level variables. nonlocal modifies enclosing function variables. Both only needed for assignment. Prefer return values and classes.

•global for module-level, nonlocal for enclosing scope
•Only needed for assignment

total = 0
def add(n):
    global total
    total += n
add(5); print(total)  # 5

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

Avoid global when possible

Question 7 / 18

What are first-class functions and higher-order functions?

In Python, functions are first-class objects, meaning they can be:

Assigned to variables
Passed as arguments to other functions
Returned from functions
Stored in data structures (lists, dicts)
Created at runtime

Higher-order functions are functions that either:

Take a function as an argument, OR
Return a function

Built-in higher-order functions: map(), filter(), sorted() (with key), functools.reduce().

This is the foundation for decorators, callbacks, and functional programming patterns.

Pseudo Code

First-class: functions are objects
  f = some_function    # assign to variable
  funcs = [f1, f2]     # store in data structure
  call(f)              # pass as argument
  return f             # return from function

Higher-order: takes or returns functions
  map(func, iterable)
  filter(func, iterable)
  sorted(data, key=func)

Code

# Functions are objects
def square(x):
    return x ** 2

print(type(square))    # <class 'function'>
print(square.__name__) # 'square'

# Assign to variable
f = square
print(f(5))  # 25

# Store in data structures
operations = {
    "square": lambda x: x ** 2,
    "double": lambda x: x * 2,
    "negate": lambda x: -x
}

for name, func in operations.items():
    print(f"{name}(5) = {func(5)}")

# Pass as argument (higher-order function)
def apply_twice(func, value):
    return func(func(value))

print(apply_twice(square, 3))   # 81 (square(square(3)) = square(9))
print(apply_twice(lambda x: x + 1, 5))  # 7

# Return from function (function factory)
def make_multiplier(n):
    def multiplier(x):
        return x * n
    return multiplier

double = make_multiplier(2)
triple = make_multiplier(3)
print(double(5))   # 10
print(triple(5))   # 15

# Built-in higher-order functions
numbers = [1, -2, 3, -4, 5]

# map: apply function to each element
squares = list(map(square, numbers))
print(squares)  # [1, 4, 9, 16, 25]

# filter: keep elements where function returns truthy
positives = list(filter(lambda x: x > 0, numbers))
print(positives)  # [1, 3, 5]

# sorted with key
words = ["banana", "fig", "cherry", "apple"]
print(sorted(words, key=len))  # ['fig', 'apple', 'banana', 'cherry']

# functools.reduce
from functools import reduce
product = reduce(lambda a, b: a * b, [1, 2, 3, 4, 5])
print(product)  # 120

# Practical: strategy pattern
def process_data(data, transform):
    return [transform(x) for x in data]

data = [1, 2, 3, 4, 5]
print(process_data(data, str))             # ['1', '2', '3', '4', '5']
print(process_data(data, lambda x: x**2))  # [1, 4, 9, 16, 25]

<class 'function'>
square
25
square(5) = 25
double(5) = 10
negate(5) = -5
81
7
10
15
[1, 4, 9, 16, 25]
[1, 3, 5]
['fig', 'apple', 'banana', 'cherry']
120
['1', '2', '3', '4', '5']
[1, 4, 9, 16, 25]

Key Points

•Functions are objects: assignable, passable, returnable, storable
•Higher-order functions take or return functions
•Built-in HOFs: map, filter, sorted (with key), reduce
•Function factories return customized functions
•Foundation for decorators and functional patterns

Gotchas

•map() and filter() return iterators, not lists -- wrap with list() if needed
•List comprehensions are often more Pythonic than map/filter
•Assigning a function (f = func) does not copy it -- same object
•reduce() was moved to functools in Python 3

Functions are first-class objects: assignable, passable, returnable. Higher-order functions take or return functions. Built-in: map(), filter(), sorted(key=), reduce().

•Functions are objects
•Higher-order: takes or returns functions

def square(x): return x ** 2
f = square          # assign
print(f(5))         # 25

# Higher-order
result = list(map(square, [1, 2, 3]))  # [1, 4, 9]
positives = list(filter(lambda x: x > 0, [-1, 2, -3, 4]))

map/filter return iterators in Python 3

Question 8 / 18

What are lambda functions and when should you use them?

A lambda is an anonymous (unnamed) function defined in a single expression:

lambda parameters: expression

Limitations:

Single expression only (no statements, no assignments, no multi-line)
No docstrings
Harder to debug (shows as <lambda> in tracebacks)

When to use:

Short, throwaway functions (especially as arguments to sorted, map, filter)
Key functions: sorted(data, key=lambda x: x[1])
Simple callbacks

When NOT to use:

Complex logic (use def)
When you need a name for clarity
When you need multiple statements
When assigning to a variable (PEP 8 says use def)

Pseudo Code

lambda x: x ** 2  # equivalent to def f(x): return x ** 2
lambda x, y: x + y  # two parameters
lambda: 42  # no parameters

Use for: short callbacks, key functions, inline
Avoid for: complex logic, named assignments

Code

# Basic lambda
square = lambda x: x ** 2   # PEP 8: prefer def for assignments
print(square(5))  # 25

# Multiple parameters
add = lambda x, y: x + y
print(add(3, 4))  # 7

# No parameters
greeting = lambda: "Hello!"
print(greeting())  # Hello!

# Common use: key functions
students = [("Alice", 95), ("Bob", 87), ("Charlie", 92)]
by_grade = sorted(students, key=lambda s: s[1], reverse=True)
print(by_grade)  # [('Alice', 95), ('Charlie', 92), ('Bob', 87)]

# Common use: map and filter
numbers = [1, 2, 3, 4, 5]
squares = list(map(lambda x: x**2, numbers))
print(squares)  # [1, 4, 9, 16, 25]

evens = list(filter(lambda x: x % 2 == 0, numbers))
print(evens)  # [2, 4]

# Lambda with conditional
abs_val = lambda x: x if x >= 0 else -x
print(abs_val(-5))  # 5

# Lambda in data structures
operations = {
    "+": lambda a, b: a + b,
    "-": lambda a, b: a - b,
    "*": lambda a, b: a * b,
    "/": lambda a, b: a / b if b != 0 else None
}

print(operations["+"](10, 3))  # 13
print(operations["*"](10, 3))  # 30

# Lambda vs def -- prefer def for assignments
# Bad (PEP 8):
my_func = lambda x: x ** 2

# Good:
def my_func(x):
    return x ** 2

# Lambda closure gotcha
funcs = [lambda x: x + i for i in range(5)]
print([f(0) for f in funcs])  # [4, 4, 4, 4, 4] -- BUG! i is captured by reference

# Fix: default argument captures value
funcs = [lambda x, i=i: x + i for i in range(5)]
print([f(0) for f in funcs])  # [0, 1, 2, 3, 4] -- correct

25
7
Hello!
[('Alice', 95), ('Charlie', 92), ('Bob', 87)]
[1, 4, 9, 16, 25]
[2, 4]
5
13
30
[4, 4, 4, 4, 4]
[0, 1, 2, 3, 4]

Key Points

•Lambda: anonymous single-expression function
•Best for short callbacks and key functions
•PEP 8: do not assign lambdas to variables -- use def instead
•Limited: single expression, no statements, no docstrings
•Common with sorted(), map(), filter()

Gotchas

•Lambda in a loop captures the variable by reference, not value -- use default arg to fix
•Lambdas show as <lambda> in tracebacks -- harder to debug
•Cannot use statements (print, assignment, raise) inside lambda
•PEP 8 discourages assigning lambdas to names: use def instead

Lambda: lambda args: expression. Anonymous single-expression function. Use for short callbacks and key functions. Do not assign to variables (use def instead per PEP 8).

•Single expression only
•Best for short callbacks

# Sorting key
data = [("b", 2), ("a", 1), ("c", 3)]
print(sorted(data, key=lambda x: x[1]))  # [('a',1), ('b',2), ('c',3)]

# Filter
print(list(filter(lambda x: x > 0, [-1, 2, -3, 4])))  # [2, 4]

[('a', 1), ('b', 2), ('c', 3)]
[2, 4]

Lambda in loop captures variable by reference -- use default arg to fix

Question 9 / 18

How do map(), filter(), and reduce() work?

map(func, iterable) applies func to each element and returns an iterator of results.

filter(func, iterable) returns an iterator of elements where func(element) is truthy. If func is None, filters out falsy values.

functools.reduce(func, iterable, initial) applies a two-argument function cumulatively: reduce(f, [a,b,c]) = f(f(a,b), c).

Modern alternatives (usually preferred):

map -> list comprehension: [f(x) for x in iterable]
filter -> comprehension with condition: [x for x in iterable if cond(x)]
reduce -> sum(), math.prod(), or explicit loop

List comprehensions are generally more readable and Pythonic.

Pseudo Code

map(f, [a, b, c]) -> [f(a), f(b), f(c)]
filter(f, [a, b, c]) -> [x for x in [a,b,c] if f(x)]
reduce(f, [a, b, c]) -> f(f(a, b), c)
reduce(f, [a, b, c], init) -> f(f(f(init, a), b), c)

Code

# map -- apply function to each element
numbers = [1, 2, 3, 4, 5]
squares = list(map(lambda x: x**2, numbers))
print(squares)  # [1, 4, 9, 16, 25]

# Equivalent comprehension (preferred)
squares = [x**2 for x in numbers]

# map with multiple iterables
result = list(map(lambda a, b: a + b, [1, 2, 3], [10, 20, 30]))
print(result)  # [11, 22, 33]

# map for type conversion
strings = ["1", "2", "3"]
nums = list(map(int, strings))
print(nums)  # [1, 2, 3]

# filter -- keep elements where function is truthy
numbers = [1, -2, 3, -4, 5, 0]
positives = list(filter(lambda x: x > 0, numbers))
print(positives)  # [1, 3, 5]

# filter with None removes falsy values
mixed = [0, 1, "", "hello", None, True, False, [], [1]]
truthy = list(filter(None, mixed))
print(truthy)  # [1, 'hello', True, [1]]

# Equivalent comprehension (preferred)
positives = [x for x in numbers if x > 0]

# reduce -- cumulative application
from functools import reduce

# Sum
total = reduce(lambda a, b: a + b, [1, 2, 3, 4, 5])
print(total)  # 15

# Product
product = reduce(lambda a, b: a * b, [1, 2, 3, 4, 5])
print(product)  # 120

# With initial value
total = reduce(lambda a, b: a + b, [1, 2, 3], 100)
print(total)  # 106

# Max (reduce version -- prefer built-in max)
result = reduce(lambda a, b: a if a > b else b, [3, 1, 4, 1, 5])
print(result)  # 5

# Prefer built-ins over reduce
print(sum([1, 2, 3, 4, 5]))        # 15 (clearer than reduce)
import math
print(math.prod([1, 2, 3, 4, 5]))  # 120 (Python 3.8+)

# Chaining map and filter
result = list(
    map(lambda x: x**2,
        filter(lambda x: x > 0,
               [-1, 2, -3, 4, 5]))
)
print(result)  # [4, 16, 25]

# Comprehension is cleaner
result = [x**2 for x in [-1, 2, -3, 4, 5] if x > 0]
print(result)  # [4, 16, 25]

[1, 4, 9, 16, 25]
[11, 22, 33]
[1, 2, 3]
[1, 3, 5]
[1, 'hello', True, [1]]
15
120
106
5
15
120
[4, 16, 25]
[4, 16, 25]

Key Points

•map: applies function to each element
•filter: keeps elements where function returns truthy
•reduce: cumulative left fold
•All three return iterators (lazy) in Python 3
•List comprehensions are usually more Pythonic

Gotchas

•map/filter return iterators, not lists -- wrap with list() if needed
•reduce is in functools (not built-in in Python 3)
•reduce on empty iterable without initial value raises TypeError
•filter(None, iterable) removes all falsy values

map(f, iter): apply f to each. filter(f, iter): keep truthy. reduce(f, iter): cumulative fold. All return iterators. List comprehensions are usually preferred.

•map, filter return iterators
•Comprehensions usually preferred

print(list(map(str.upper, ["a", "b"])))  # ['A', 'B']
print(list(filter(None, [0, 1, "", "x"])))  # [1, 'x']

from functools import reduce
print(reduce(lambda a,b: a*b, [1,2,3,4]))  # 24

['A', 'B']
[1, 'x']
24

reduce is in functools, not built-in

Question 10 / 18

What is recursion in Python and what are its limitations?

Recursion is when a function calls itself. Every recursive function needs:

Base case: stops the recursion
Recursive case: calls itself with a simpler input

Python limitations:

Default recursion limit: 1000 (configurable with sys.setrecursionlimit())
No tail-call optimization (TCO)
Each call uses stack memory -> deep recursion can cause RecursionError

When to use recursion:

Tree traversal
Divide-and-conquer algorithms
Mathematical definitions (factorial, Fibonacci)
Directory traversal

When to prefer iteration:

Deep recursion (> 1000 levels)
Performance-critical code
Simple loops that could replace the recursion

Pseudo Code

def recursive_func(input):
    if base_case(input):    # stop condition
        return base_value
    return combine(recursive_func(smaller_input))

Limitations:
  - Default limit: 1000 calls deep
  - No tail-call optimization
  - Stack memory for each call

Code

# Factorial
def factorial(n):
    if n <= 1:       # base case
        return 1
    return n * factorial(n - 1)  # recursive case

print(factorial(5))   # 120
print(factorial(10))  # 3628800

# Fibonacci (naive -- exponential time)
def fib_naive(n):
    if n <= 1:
        return n
    return fib_naive(n - 1) + fib_naive(n - 2)

print(fib_naive(10))  # 55

# Fibonacci with memoization (linear time)
from functools import lru_cache

@lru_cache(maxsize=None)
def fib(n):
    if n <= 1:
        return n
    return fib(n - 1) + fib(n - 2)

print(fib(100))  # 354224848179261915075 (instant with cache)

# Binary search (recursive)
def binary_search(arr, target, low=0, high=None):
    if high is None:
        high = len(arr) - 1
    if low > high:
        return -1
    mid = (low + high) // 2
    if arr[mid] == target:
        return mid
    elif arr[mid] < target:
        return binary_search(arr, target, mid + 1, high)
    else:
        return binary_search(arr, target, low, mid - 1)

arr = [1, 3, 5, 7, 9, 11, 13]
print(binary_search(arr, 7))   # 3
print(binary_search(arr, 6))   # -1

# Flatten nested list (recursive)
def flatten(lst):
    result = []
    for item in lst:
        if isinstance(item, list):
            result.extend(flatten(item))
        else:
            result.append(item)
    return result

print(flatten([1, [2, [3, 4]], 5]))  # [1, 2, 3, 4, 5]

# Recursion limit
import sys
print(sys.getrecursionlimit())  # 1000 (default)

# Converting recursion to iteration
def factorial_iterative(n):
    result = 1
    for i in range(2, n + 1):
        result *= i
    return result

print(factorial_iterative(5))  # 120

# RecursionError example
def infinite():
    return infinite()

try:
    infinite()
except RecursionError as e:
    print(f"Error: {e}")  # maximum recursion depth exceeded

120
3628800
55
354224848179261915075
3
-1
[1, 2, 3, 4, 5]
1000
120
Error: maximum recursion depth exceeded

Key Points

•Every recursion needs a base case and recursive case
•Python default recursion limit is 1000
•No tail-call optimization in Python
•Use @lru_cache for memoized recursion
•Consider iterative alternatives for deep recursion

Gotchas

•Forgetting the base case causes infinite recursion -> RecursionError
•Naive recursive Fibonacci is O(2^n) -- use memoization
•sys.setrecursionlimit() can be increased but stack memory is still finite
•Recursion in Python is slower than iteration due to function call overhead

Recursion: function calls itself. Needs base case + recursive case. Python limit: 1000 deep (no TCO). Use @lru_cache for memoization. Prefer iteration for deep recursion.

•Base case + recursive case
•Default limit 1000, use @lru_cache

def factorial(n):
    if n <= 1: return 1
    return n * factorial(n - 1)

print(factorial(5))  # 120

from functools import lru_cache
@lru_cache
def fib(n):
    if n <= 1: return n
    return fib(n-1) + fib(n-2)

No tail-call optimization in Python

Question 11 / 18

What are closures in Python?

A closure is a function that remembers values from its enclosing scope, even after the enclosing function has finished executing.

A closure occurs when:

There is a nested function (inner function)
The inner function references variables from the enclosing function
The enclosing function returns the inner function

The inner function "closes over" the enclosing variables, keeping them alive.

Use cases:

Function factories (make_multiplier, make_adder)
Data hiding (encapsulation without classes)
Callbacks with state
Decorators (built on closures)

Pseudo Code

def outer(x):
    def inner(y):
        return x + y  # x is from enclosing scope
    return inner      # return the inner function

add5 = outer(5)  # x=5 is "closed over"
add5(3) -> 8     # inner still has access to x=5

Code

# Basic closure
def make_adder(x):
    def adder(y):
        return x + y  # x is from enclosing scope
    return adder

add5 = make_adder(5)
add10 = make_adder(10)

print(add5(3))   # 8
print(add10(3))  # 13

# x is remembered even though make_adder has finished
print(add5.__closure__)  # (<cell ...>,)
print(add5.__closure__[0].cell_contents)  # 5

# Closure as counter (with nonlocal)
def make_counter(start=0):
    count = start
    def counter():
        nonlocal count
        count += 1
        return count
    return counter

c = make_counter()
print(c())  # 1
print(c())  # 2
print(c())  # 3

# Each call to make_counter creates independent state
c1 = make_counter()
c2 = make_counter(10)
print(c1(), c1())    # 1 2
print(c2(), c2())    # 11 12

# Closure for data hiding
def make_account(initial_balance):
    balance = initial_balance
    
    def deposit(amount):
        nonlocal balance
        balance += amount
        return balance
    
    def withdraw(amount):
        nonlocal balance
        if amount > balance:
            raise ValueError("Insufficient funds")
        balance -= amount
        return balance
    
    def get_balance():
        return balance
    
    return deposit, withdraw, get_balance

deposit, withdraw, balance = make_account(100)
print(balance())      # 100
print(deposit(50))    # 150
print(withdraw(30))   # 120

# Closure gotcha: late binding
def make_functions():
    funcs = []
    for i in range(5):
        funcs.append(lambda: i)  # all capture same 'i'
    return funcs

funcs = make_functions()
print([f() for f in funcs])  # [4, 4, 4, 4, 4] -- BUG!

# Fix: capture value with default arg
def make_functions_fixed():
    funcs = []
    for i in range(5):
        funcs.append(lambda i=i: i)  # capture current value
    return funcs

funcs = make_functions_fixed()
print([f() for f in funcs])  # [0, 1, 2, 3, 4]

8
13
(<cell at <address>: int object at <address>>,)
5
1
2
3
1 2
11 12
100
150
120
[4, 4, 4, 4, 4]
[0, 1, 2, 3, 4]

Key Points

•Closure = inner function + enclosing variables
•The inner function remembers enclosing variables after outer returns
•Use nonlocal to modify enclosing variables
•Each call to the outer function creates independent state
•Foundation for decorators and function factories

Gotchas

•Late binding: closures capture variables by reference, not value
•Lambda in a loop captures the loop variable, not its value at each step
•Fix late binding with default arguments: lambda i=i: i
•__closure__ attribute shows the captured cell objects

A closure is a nested function that remembers variables from its enclosing scope. Used for function factories, counters, and decorators. Watch out for late binding in loops.

•Inner function remembers enclosing variables
•Foundation for decorators

def make_adder(x):
    def adder(y):
        return x + y
    return adder

add5 = make_adder(5)
print(add5(3))  # 8

Late binding: lambda in loop captures variable reference, not value

Question 12 / 18

How do nested functions work in Python?

Python allows defining functions inside other functions. The inner function:

Has access to the enclosing function's variables (closure)
Is local to the enclosing function (not accessible outside)
Is created each time the enclosing function runs

Use cases:

Helper functions: Internal logic not needed outside
Closures: Capturing enclosing state
Decorators: The wrapper function is nested
Encapsulation: Hiding implementation details
Avoiding code repetition within a function

Pseudo Code

def outer(x):
    def inner(y):     # nested/inner function
        return x + y  # can access outer's x
    return inner(10)  # call inner, or return inner

inner() is local to outer()
inner() has access to outer's variables
inner() is created each time outer() runs

Code

# Helper function (not needed outside)
def process_data(data):
    def clean(item):
        return item.strip().lower()
    
    def validate(item):
        return len(item) > 0
    
    cleaned = [clean(item) for item in data]
    return [item for item in cleaned if validate(item)]

result = process_data(["  Hello  ", "  ", "World  ", ""])
print(result)  # ['hello', 'world']

# clean and validate are NOT accessible here
# clean("test")  # NameError

# Nested function for DRY (Don't Repeat Yourself)
def report(users):
    def format_user(user):
        return f"{user['name']} ({user['age']})"
    
    active = [format_user(u) for u in users if u['active']]
    inactive = [format_user(u) for u in users if not u['active']]
    
    return f"Active: {', '.join(active)}\nInactive: {', '.join(inactive)}"

users = [
    {"name": "Alice", "age": 30, "active": True},
    {"name": "Bob", "age": 25, "active": False},
    {"name": "Charlie", "age": 35, "active": True}
]
print(report(users))

# Recursive helper
def flatten(lst):
    def _flatten(items, result):
        for item in items:
            if isinstance(item, list):
                _flatten(item, result)
            else:
                result.append(item)
    
    result = []
    _flatten(lst, result)
    return result

print(flatten([1, [2, [3, 4]], 5]))  # [1, 2, 3, 4, 5]

# Nested function created each time
def outer():
    def inner():
        pass
    print(id(inner))  # different id each call

outer()  # prints some id
outer()  # prints different id

['hello', 'world']
Active: Alice (30), Charlie (35)
Inactive: Bob (25)
[1, 2, 3, 4, 5]
4413536864
4413536864

Key Points

•Inner functions are local to the enclosing function
•They have access to enclosing variables (closure)
•Created each time the outer function runs
•Great for helper logic and encapsulation
•Foundation for closures and decorators

Gotchas

•Inner function is recreated each call (minor overhead)
•Inner function is not accessible outside the outer function
•Assignment in inner function creates local variable (use nonlocal to modify outer)
•Too many levels of nesting hurts readability

Functions defined inside other functions are local and have access to enclosing variables. Useful for helpers, closures, and encapsulation.

•Local to enclosing function
•Access enclosing variables

def process(data):
    def clean(s):
        return s.strip().lower()
    return [clean(item) for item in data]

print(process([" Hello ", " World "]))  # ['hello', 'world']

['hello', 'world']

Recreated each call (minor overhead)

Question 13 / 18

What are function annotations and type hints?

Function annotations (PEP 3107) let you attach metadata to parameters and return values. Type hints (PEP 484) use annotations to specify expected types.

Syntax:

def func(param: type, param2: type = default) -> return_type:

Key points:

Annotations are NOT enforced at runtime by Python
They are metadata stored in func.__annotations__
Static type checkers (mypy, pyright) use them for analysis
IDEs use them for autocompletion and error detection

Common typing module types:

List[int], Dict[str, int], Tuple[int, ...]
Optional[str] = str | None
Union[int, str] = int | str
Callable[[int, int], int]
Any, TypeVar, Protocol

Pseudo Code

def func(x: int, y: str = 'hello') -> bool:
    ...

Annotations are NOT enforced at runtime
Used by: mypy, pyright, IDEs
Stored in: func.__annotations__

Code

# Basic type hints
def greet(name: str) -> str:
    return f"Hello, {name}!"

print(greet("Alice"))    # Hello, Alice!
print(greet(42))         # Hello, 42! -- no runtime error!

# View annotations
print(greet.__annotations__)
# {'name': <class 'str'>, 'return': <class 'str'>}

# Common types
def process_scores(scores: list[int]) -> float:  # Python 3.9+
    return sum(scores) / len(scores)

# Python 3.8 and earlier: use typing module
from typing import List, Dict, Tuple, Optional, Union, Callable

def process_legacy(scores: List[int]) -> float:
    return sum(scores) / len(scores)

# Optional (can be None)
def find_user(user_id: int) -> Optional[str]:
    users = {1: "Alice", 2: "Bob"}
    return users.get(user_id)

result: Optional[str] = find_user(3)  # None

# Union types
def double(x: Union[int, float]) -> Union[int, float]:
    return x * 2

# Python 3.10+: use | syntax
def double_modern(x: int | float) -> int | float:
    return x * 2

# Callable type hint
def apply(func: Callable[[int], int], value: int) -> int:
    return func(value)

result = apply(lambda x: x ** 2, 5)  # 25

# Complex type hints
def analyze(data: dict[str, list[int]]) -> dict[str, float]:
    return {key: sum(vals) / len(vals) for key, vals in data.items()}

result = analyze({"math": [90, 85, 95], "science": [80, 88]})
print(result)  # {'math': 90.0, 'science': 84.0}

# Variable annotations
name: str = "Alice"
age: int = 30
scores: list[int] = [95, 87, 92]

# TypeVar for generics
from typing import TypeVar

T = TypeVar('T')

def first(lst: list[T]) -> T:
    return lst[0]

print(first([1, 2, 3]))      # 1 (int)
print(first(["a", "b"]))     # 'a' (str)

Hello, Alice!
Hello, 42!
{'name': <class 'str'>, 'return': <class 'str'>}
{'math': 90.0, 'science': 84.0}
1
a

Key Points

•Type hints are NOT enforced at runtime
•Stored in __annotations__, used by mypy/pyright/IDEs
•Python 3.9+: built-in types for generics (list[int], dict[str, int])
•Python 3.10+: X | Y syntax for union types
•Optional[X] is shorthand for X | None

Gotchas

•Type hints do NOT prevent passing wrong types at runtime
•Python < 3.9 needs typing.List instead of list[int]
•Circular imports can occur with type hints -- use from __future__ import annotations
•Runtime type checking requires third-party libraries (pydantic, beartype)

Type hints: def f(x: int) -> str:. Not enforced at runtime -- used by mypy, IDEs. Python 3.10+: int | str for unions. Optional[X] = X | None.

•Not enforced at runtime
•Used by mypy and IDEs

def greet(name: str) -> str:
    return f"Hello, {name}!"

def find(user_id: int) -> str | None:  # 3.10+
    return {1: "Alice"}.get(user_id)

print(greet.__annotations__)  # {'name': str, 'return': str}

{'name': <class 'str'>, 'return': <class 'str'>}

Type hints do NOT prevent wrong types at runtime

Question 14 / 18

How do docstrings work and what is the Google style?

Docstrings are string literals that appear as the first statement in a module, class, method, or function. They are stored in the __doc__ attribute.

Access: func.__doc__, help(func), IDE hover

Common styles:

Google style: Easy to read, sections with indentation
NumPy style: Sections with underlines
reStructuredText: Sphinx-compatible

PEP 257 conventions:

Use triple double quotes """"
One-line docstrings for simple functions
Multi-line for complex functions
First line is a summary, followed by blank line, then details

Pseudo Code

One-line: """Return the square of x."""

Multi-line (Google style):
"""Summary line.

Args:
    param1: Description.
    param2: Description.

Returns:
    Description of return value.

Raises:
    ValueError: If param1 is invalid.
"""

Code

# One-line docstring
def square(x):
    """Return the square of x."""
    return x ** 2

# Multi-line docstring (Google style)
def calculate_bmi(weight_kg, height_m):
    """Calculate Body Mass Index.

    Args:
        weight_kg: Weight in kilograms.
        height_m: Height in meters.

    Returns:
        The BMI value as a float.

    Raises:
        ValueError: If weight or height is non-positive.

    Examples:
        >>> calculate_bmi(70, 1.75)
        22.857142857142858
    """
    if weight_kg <= 0 or height_m <= 0:
        raise ValueError("Weight and height must be positive")
    return weight_kg / (height_m ** 2)

# Access docstring
print(calculate_bmi.__doc__)
help(calculate_bmi)

# Class docstring
class Rectangle:
    """A rectangle defined by width and height.

    Attributes:
        width: The width of the rectangle.
        height: The height of the rectangle.
    """

    def __init__(self, width, height):
        """Initialize Rectangle with width and height.

        Args:
            width: The width (must be positive).
            height: The height (must be positive).
        """
        self.width = width
        self.height = height

    def area(self):
        """Return the area of the rectangle."""
        return self.width * self.height

# Module docstring (first line of file)
# """This module provides geometric calculations."""

# Doctest (runnable examples in docstrings)
def add(a, b):
    """Add two numbers.

    Examples:
        >>> add(2, 3)
        5
        >>> add(-1, 1)
        0
    """
    return a + b

# Run doctests
if __name__ == "__main__":
    import doctest
    doctest.testmod(verbose=True)

Key Points

•Triple double quotes for docstrings
•First statement in module/class/function
•Stored in __doc__ attribute
•Google style: Args, Returns, Raises, Examples sections
•Doctests provide runnable examples in docstrings

Gotchas

•Docstrings must be the FIRST statement (not after assignments)
•f-strings cannot be docstrings (they are not string literals in bytecode)
•Docstrings are included in __doc__ -- they take memory at runtime
•Running python -O strips docstrings (optimization mode)

Docstrings are triple-quoted strings as the first statement. Stored in __doc__. Google style uses Args/Returns/Raises sections. Access with help() or IDE hover.

•First statement, triple-quoted
•Google style: Args/Returns/Raises

def add(a, b):
    """Add two numbers.

    Args:
        a: First number.
        b: Second number.

    Returns:
        Sum of a and b.
    """
    return a + b

print(add.__doc__)

Add two numbers.

Args:
a: First number.
b: Second number.

Returns:
Sum of a and b.

Must be the FIRST statement in the function

Question 15 / 18

How does Python pass arguments -- by value or by reference?

Python uses pass by assignment (also called "pass by object reference"). It is neither purely "by value" nor "by reference" in the C/C++ sense.

What happens:

The function parameter becomes a new name (local variable)
This name is bound to the same object the caller passed
Reassignment inside the function creates a new local binding (does not affect caller)
Mutation of the object (if mutable) is visible to the caller

Rules:

Immutable arguments (int, str, tuple): function cannot modify the caller's value
Mutable arguments (list, dict, set): function CAN modify the caller's object via mutation
Reassignment NEVER affects the caller (it just rebinds the local name)

Pseudo Code

Immutable (int, str, tuple):
  x = 5
  func(x) -> func receives reference to same int(5)
  Inside func: x = 10 rebinds local name, caller's x unchanged

Mutable (list, dict):
  lst = [1, 2]
  func(lst) -> func receives reference to same list
  Inside func: lst.append(3) modifies the SAME list
  Inside func: lst = [4, 5] rebinds local name, caller's lst unchanged

Code

# Immutable argument: cannot modify caller's value
def try_modify_int(x):
    print(f"Before: id={id(x)}, x={x}")
    x = 99  # rebinds local name
    print(f"After: id={id(x)}, x={x}")

n = 42
try_modify_int(n)
print(f"Caller: n={n}")  # 42 (unchanged)

# Mutable argument: mutation visible to caller
def modify_list(lst):
    lst.append(99)  # mutates the same object

my_list = [1, 2, 3]
modify_list(my_list)
print(my_list)  # [1, 2, 3, 99] (modified!)

# Reassignment does NOT affect caller
def reassign_list(lst):
    lst = [10, 20, 30]  # rebinds local name
    print(f"Inside: {lst}")

my_list = [1, 2, 3]
reassign_list(my_list)
print(f"Outside: {my_list}")  # [1, 2, 3] (unchanged)

# Common pattern: return modified value for immutables
def increment(x):
    return x + 1  # return new value

n = 5
n = increment(n)  # caller rebinds
print(n)  # 6

# Defensive copying to prevent modification
def safe_process(lst):
    local_copy = lst.copy()  # or lst[:] or list(lst)
    local_copy.sort()
    return local_copy

original = [3, 1, 4, 1, 5]
sorted_list = safe_process(original)
print(original)     # [3, 1, 4, 1, 5] (unchanged)
print(sorted_list)  # [1, 1, 3, 4, 5]

# Mutation vs reassignment: the key distinction
def demo(lst):
    # MUTATION: modifies the object -> caller sees it
    lst.append("mutation")
    
    # REASSIGNMENT: rebinds local name -> caller does NOT see it
    lst = ["new", "list"]
    lst.append("only local")
    print(f"Inside: {lst}")

my_list = [1, 2]
demo(my_list)
print(f"Outside: {my_list}")  # [1, 2, 'mutation']

Before: id=4308607968, x=42
After: id=4308609792, x=99
Caller: n=42
[1, 2, 3, 99]
Inside: [10, 20, 30]
Outside: [1, 2, 3]
6
[3, 1, 4, 1, 5]
[1, 1, 3, 4, 5]
Inside: ['new', 'list', 'only local']
Outside: [1, 2, 'mutation']

Key Points

•Python uses 'pass by assignment' (pass by object reference)
•Function parameters are new local names bound to the same objects
•Mutation of mutable objects is visible to the caller
•Reassignment inside a function only affects the local name
•Immutable objects cannot be modified, only rebound

Gotchas

•lst.sort() inside a function modifies the caller's list
•lst = sorted(lst) inside a function does NOT modify the caller's list (reassignment)
•Default mutable arguments compound this issue (shared across calls)
•If you do not want side effects, copy the argument first

Python passes by assignment (object reference). Mutation of mutable args is visible to caller. Reassignment only affects local name. Immutables cannot be modified.

•Mutation visible to caller, reassignment is not
•Copy arguments to prevent side effects

def modify(lst):
    lst.append(99)   # mutation: caller sees this
    lst = [1, 2, 3]  # reassignment: caller does NOT see this

my_list = [10]
modify(my_list)
print(my_list)  # [10, 99]

[10, 99]

lst.sort() modifies caller's list, sorted(lst) does not

Question 16 / 18

What is the difference between return and yield in a function?

return exits the function and sends a value to the caller. The function's state is destroyed.

yield pauses the function and produces a value. The function becomes a generator that can be resumed where it left off.

Key differences:

Feature	return	yield
Function type	Regular	Generator
Execution	Runs to completion	Pauses and resumes
State	Lost after return	Preserved between yields
Memory	All at once	Lazy, one at a time
Result	Single value	Iterator of values

A function with yield anywhere in its body becomes a generator function. Calling it returns a generator object (does not execute the body).

Pseudo Code

return: exits function, returns value, state destroyed
yield: pauses function, produces value, state preserved

def regular():
    return [1, 2, 3]  # all at once

def generator():
    yield 1  # pause, produce 1
    yield 2  # resume, produce 2
    yield 3  # resume, produce 3

Code

# return -- all at once
def get_squares_list(n):
    result = []
    for i in range(n):
        result.append(i ** 2)
    return result  # creates entire list in memory

print(get_squares_list(5))  # [0, 1, 4, 9, 16]

# yield -- lazy, one at a time
def get_squares_gen(n):
    for i in range(n):
        yield i ** 2  # produces one value, pauses

gen = get_squares_gen(5)
print(type(gen))   # <class 'generator'>
print(next(gen))   # 0
print(next(gen))   # 1
print(next(gen))   # 4

# Iterate with for loop
for sq in get_squares_gen(5):
    print(sq, end=" ")
print()  # 0 1 4 9 16

# Memory comparison
import sys

lst = get_squares_list(1000000)
gen = get_squares_gen(1000000)

print(f"List size: {sys.getsizeof(lst)} bytes")  # ~8 MB
print(f"Generator size: {sys.getsizeof(gen)} bytes")  # ~200 bytes

# State preservation
def countdown(n):
    print(f"Starting countdown from {n}")
    while n > 0:
        yield n
        n -= 1
    print("Blastoff!")

c = countdown(3)
print(next(c))  # Starting countdown from 3, then 3
print(next(c))  # 2 (resumes from where it paused)
print(next(c))  # 1
# next(c) would print "Blastoff!" then raise StopIteration

# yield can also receive values with send()
def accumulator():
    total = 0
    while True:
        value = yield total
        if value is None:
            break
        total += value

acc = accumulator()
next(acc)         # prime the generator (run to first yield)
print(acc.send(10))  # 10
print(acc.send(20))  # 30
print(acc.send(30))  # 60

# Multiple returns vs multiple yields
def multi_return():
    return 1  # exits here
    return 2  # never reached

def multi_yield():
    yield 1   # first value
    yield 2   # second value
    yield 3   # third value

print(multi_return())           # 1
print(list(multi_yield()))      # [1, 2, 3]

[0, 1, 4, 9, 16]
<class 'generator'>
0
1
4
0 1 4 9 16
List size: 8448728 bytes
Generator size: 200 bytes
Starting countdown from 3
3
2
1
10
30
60
1
[1, 2, 3]

Key Points

•return exits and destroys state; yield pauses and preserves state
•yield makes a function a generator (lazy iterator)
•Generators use minimal memory (one value at a time)
•Calling a generator function returns a generator object
•Use next() or for loop to consume generator values

Gotchas

•Calling gen_func() does NOT execute the body -- it returns a generator object
•Generators are one-shot: exhausted after one pass
•StopIteration is raised when generator is exhausted
•Cannot use return with a value in a generator (pre-Python 3.3)

return exits function (state destroyed). yield pauses function (state preserved), creating a generator. Generators are lazy -- produce values one at a time, using minimal memory.

•yield pauses, return exits
•Generators use minimal memory

def squares(n):
    for i in range(n):
        yield i ** 2

gen = squares(5)
print(next(gen))  # 0
print(next(gen))  # 1
print(list(gen))  # [4, 9, 16] (remaining)

0
1
[4, 9, 16]

Generators are one-shot -- cannot reuse

Question 17 / 18

What happens when you use a mutable object as a default argument?

This is one of Python's most infamous gotchas. When you use a mutable object (list, dict, set) as a default argument, the default is created once when the function is defined and shared across all calls.

Since the object is mutable, modifications persist between calls.

Why this happens:

def is an executable statement
Default values are evaluated when def runs (once)
The default object is stored in func.__defaults__
Each call that uses the default gets the SAME object

The fix: Use None as the default and create a fresh mutable object inside the function body.

This is tested in almost every Python interview.

Pseudo Code

BUG:
  def f(lst=[]):  # [] created once at def time
      lst.append(1)
      return lst
  f() -> [1]      # first call
  f() -> [1, 1]   # second call -- same list!

FIX:
  def f(lst=None):
      if lst is None:
          lst = []   # fresh list each call
      lst.append(1)
      return lst

Code

# THE BUG
def append_to(item, target=[]):
    target.append(item)
    return target

print(append_to(1))  # [1]
print(append_to(2))  # [1, 2] -- BUG! Expected [2]
print(append_to(3))  # [1, 2, 3] -- BUG! Expected [3]

# Inspect the default
print(append_to.__defaults__)  # ([1, 2, 3],)

# THE FIX
def append_to_fixed(item, target=None):
    if target is None:
        target = []
    target.append(item)
    return target

print(append_to_fixed(1))  # [1]
print(append_to_fixed(2))  # [2] -- correct!
print(append_to_fixed(3))  # [3] -- correct!

# Still works with explicit argument
print(append_to_fixed(4, [10, 20]))  # [10, 20, 4]

# Same issue with dicts
def bad_register(name, registry={}):
    registry[name] = True
    return registry

print(bad_register("Alice"))    # {'Alice': True}
print(bad_register("Bob"))      # {'Alice': True, 'Bob': True}

# Same issue with sets
def bad_collect(item, seen=set()):
    seen.add(item)
    return seen

print(bad_collect(1))  # {1}
print(bad_collect(2))  # {1, 2}

# Intentional use: memoization cache
def fibonacci(n, cache={0: 0, 1: 1}):
    if n not in cache:
        cache[n] = fibonacci(n-1) + fibonacci(n-2)
    return cache[n]

print(fibonacci(10))  # 55
print(fibonacci(20))  # 6765 (uses cached values)

# The fix with type hints
from typing import Optional

def create_user(name: str, roles: Optional[list[str]] = None) -> dict:
    if roles is None:
        roles = []
    return {"name": name, "roles": roles}

[1]
[1, 2]
[1, 2, 3]
([1, 2, 3],)
[1]
[2]
[3]
[10, 20, 4]
{'Alice': True}
{'Alice': True, 'Bob': True}
{1}
{1, 2}
55
6765

Key Points

•Default values are evaluated ONCE at def time, not per call
•Mutable defaults are shared across all calls
•Always use None as default for mutable arguments
•Pattern: if param is None: param = fresh_value
•The shared default CAN be useful intentionally (e.g., caching)

Gotchas

•This is one of the most common Python interview questions
•The bug is subtle: first call appears correct, second call reveals the issue
•func.__defaults__ shows the shared default objects
•This also applies to class method defaults

Mutable default arguments are shared across calls (created once at def time). Use None sentinel: def f(lst=None): if lst is None: lst = [].

•Defaults evaluated once at def time
•Use None sentinel for mutables

# BUG:
def bad(lst=[]):
    lst.append(1)
    return lst
print(bad(), bad())  # [1] [1, 1]

# FIX:
def good(lst=None):
    lst = lst if lst is not None else []
    lst.append(1)
    return lst
print(good(), good())  # [1] [1]

[1, 1] [1, 1]
[1] [1]

First call looks correct -- bug only shows on subsequent calls

Question 18 / 18

How do you write a function decorator from scratch?

A decorator is a function that takes a function and returns a modified version. It is syntactic sugar:

@decorator
def func():
    ...
# is equivalent to:
func = decorator(func)

Basic decorator structure:

Define outer function that takes the original function
Define inner wrapper function that calls the original
Return the wrapper

Always use @functools.wraps(func) on the wrapper to preserve the original function's name, docstring, and metadata.

Common decorator use cases:

Logging, timing, authentication
Caching (memoization)
Input validation
Retry logic

Pseudo Code

def my_decorator(func):
    @functools.wraps(func)  # preserve metadata
    def wrapper(*args, **kwargs):
        # before
        result = func(*args, **kwargs)  # call original
        # after
        return result
    return wrapper

@my_decorator
def my_function():
    ...

# equivalent to: my_function = my_decorator(my_function)

Code

import functools
import time

# Basic decorator
def timer(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        elapsed = time.time() - start
        print(f"{func.__name__} took {elapsed:.4f}s")
        return result
    return wrapper

@timer
def slow_function(n):
    """Sleep for n seconds."""
    time.sleep(n)
    return f"Done after {n}s"

result = slow_function(0.1)  # slow_function took 0.1001s
print(result)                # Done after 0.1s

# functools.wraps preserves metadata
print(slow_function.__name__)  # 'slow_function' (not 'wrapper')
print(slow_function.__doc__)   # 'Sleep for n seconds.'

# Decorator with arguments
def retry(max_attempts=3):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            for attempt in range(1, max_attempts + 1):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    print(f"Attempt {attempt} failed: {e}")
                    if attempt == max_attempts:
                        raise
        return wrapper
    return decorator

import random

@retry(max_attempts=5)
def unreliable():
    if random.random() < 0.7:
        raise ValueError("Random failure")
    return "Success!"

try:
    print(unreliable())
except ValueError:
    print("All attempts failed")

# Logging decorator
def log_calls(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        args_repr = [repr(a) for a in args]
        kwargs_repr = [f"{k}={v!r}" for k, v in kwargs.items()]
        signature = ", ".join(args_repr + kwargs_repr)
        print(f"Calling {func.__name__}({signature})")
        result = func(*args, **kwargs)
        print(f"{func.__name__} returned {result!r}")
        return result
    return wrapper

@log_calls
def add(a, b):
    return a + b

add(3, 4)
# Calling add(3, 4)
# add returned 7

# Stacking decorators
@timer
@log_calls
def multiply(a, b):
    return a * b

multiply(3, 4)
# Applied bottom-up: log_calls wraps multiply, then timer wraps that

slow_function took 0.1027s
Done after 0.1s
slow_function
Sleep for n seconds.
Attempt 1 failed: Random failure
Attempt 2 failed: Random failure
Attempt 3 failed: Random failure
Attempt 4 failed: Random failure
Attempt 5 failed: Random failure
All attempts failed
Calling add(3, 4)
add returned 7
Calling multiply(3, 4)
multiply returned 12
multiply took 0.0000s

Key Points

•@decorator is syntactic sugar for func = decorator(func)
•Always use @functools.wraps to preserve metadata
•Wrapper must accept *args, **kwargs for flexibility
•Decorator with arguments needs an extra level of nesting
•Decorators are stacked bottom-up

Gotchas

•Without @functools.wraps, __name__ and __doc__ show the wrapper, not the original
•Decorator with arguments @retry(3) needs three levels of nesting
•@retry (without parens) vs @retry() behaves differently if not handled
•Decorators run at function definition time, not call time

A decorator takes a function, wraps it, and returns the wrapper. Use @functools.wraps(func) to preserve metadata. @decorator is sugar for func = decorator(func).

•Takes function, returns wrapper
•Use @functools.wraps always

import functools

def timer(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        import time
        start = time.time()
        result = func(*args, **kwargs)
        print(f"{func.__name__}: {time.time()-start:.4f}s")
        return result
    return wrapper

@timer
def slow(): pass

Without @wraps, metadata is lost

Built by onllm.dev

Home GitHub Support awesomePrep