Functions & Modular Code

A common beginner pitfall is using print() inside a function instead of return. print() writes text to stdout and evaluates to None. Attempting to assign the result of the function call to a variable captures None, causing subsequent arithmetic or operations to fail with TypeError: unsupported operand type(s) for +: 'NoneType' and 'int'.

def compute_tax(subtotal):
    print(subtotal * 0.08)  # Prints, but returns None!

tax = compute_tax(100)
try:
    total = 100 + tax  # Raises TypeError: unsupported operand type
except TypeError as e:
    print('Error:', e)

def compute_tax(subtotal):
    return subtotal * 0.08  # Yields value to caller

tax = compute_tax(100)
total = 100 + tax
print('Total successfully calculated:', total)

Writing a function name without parentheses (e.g. get_status) references the function object itself rather than executing it. Code like if get_status: will evaluate to True regardless of what the function would have returned, because a function object is always truthy in Python.

def is_authenticated():
    return False

# Bug: missing parentheses; evaluates the truthiness of the function object!
if is_authenticated:
    print('Access granted (BUG: is_authenticated was not called!)')

def is_authenticated():
    return False

# Correct: call the function with parentheses
if is_authenticated():
    print('Access granted')
else:
    print('Access denied (correct)')

The return statement terminates execution of the active function frame immediately. Any statements placed directly after return in the same block are dead code and will never run.

def get_user_status(user_id):
    return 'active'
    # Dead code: will never execute
    print('Status checked for user:', user_id)

def get_user_status(user_id):
    status = 'active'
    print('Status checked for user:', user_id)  # Executed before return
    return status

When defining parameters without default values, failing to provide the expected number of arguments at the call site raises TypeError: function() missing X required positional argument(s).

def set_credentials(username, password):
    return f'{username}:***'

try:
    set_credentials('admin')  # Missing second argument
except TypeError as e:
    print('Call error:', e)

def set_credentials(username, password):
    return f'{username}:***'

print('Success:', set_credentials('admin', 'secret_pwd'))

In Python, commas create tuples, not parentheses. Writing 'return x,' returns a single-element tuple (x,), not the scalar x itself. Accidental trailing commas in return statements frequently lead to unexpected tuple types.

def calculate_val(x):
    return x * 2,  # Trailing comma makes it a tuple!

result = calculate_val(5)
print('Result:', result)
print('Type of result:', type(result))

Python uses 'pass-by-assignment' (or pass-by-object-reference). When you pass a mutable object like a list or dict into a function, the parameter points to the exact same object in memory. Mutating methods (like .append() or [key]=val) modify the caller's data directly.

def append_status(items):
    items.append('processed')

my_list = ['task_1', 'task_2']
append_status(my_list)
print('Caller list after function call:', my_list)

In Python, def is an executable statement executed at runtime. Defining a function inside an if block creates the function only if the branch executes. Defining a function inside a loop re-creates a new function object on each iteration.

mode = 'prod'
if mode == 'prod':
    def log(msg):
        return f'[PROD] {msg}'
else:
    def log(msg):
        return f'[DEV] {msg}'

print(log('Service started'))

Python requires an indented block underneath def. If a function is a stub or abstract definition, use the pass keyword or the Ellipsis literal (...) to satisfy syntax requirements without error.

def stub_worker():
    ...

print('Stub output:', stub_worker())

Every function call allocates an interpreter stack frame (_PyInterpreterFrame). While Python 3.12 significantly reduced frame allocation overhead, millions of function calls in a tight loop still incur more overhead than an inline calculation.

Local variables within a function use LOAD_FAST and STORE_FAST bytecodes, indexing directly into a contiguous C pointer array in O(1) time. This is significantly faster than global variable lookups, which require hash table lookups in the globals dictionary.

In Python 3.12, function calls are monitored by the adaptive interpreter. After repeating a call signature, CALL bytecodes specialize into CALL_PY_EXACT_ARGS or CALL_BUILTIN_FAST, bypassing parameter binding logic.

Returning multiple values (return a, b, c) allocates a temporary tuple on the heap. While negligible in normal code, unpacking thousands of results in high-frequency loops incurs small allocation costs.

Modern web routers and chat bots (e.g. Telegram, Discord bots) store handler functions in dictionaries mapping route paths or slash commands to function objects. Looking up and executing the handler takes O(1) time.

ETL pipelines pass normalization functions as arguments into pipeline stages (e.g., pipeline.apply(clean_text)), allowing clean separation of transformation logic from stream ingestion.

Banking microservices structure transfer and payment calculations using guard clauses that validate preconditions (account status, limits, currency match) before executing financial ledger mutations.