Function Fundamentals and Return Behavior

In Python, a function bundles a logical code block under a name for reuse and modularity. Here is a basic template for defining a function:

def compute(value):
    """Increment the provided value."""
    result = value + 1
    return result

Every function returns a value implicitly or explicitly. Observe how return semantics work:

def proc_like_func():
    note = "side-effect only"
    print(note)

def explicit_return():
    data = "explicit"
    return data

a = proc_like_func()
b = explicit_return()

print(f"Implicit return: {a!r}")   # None
print(f"Explicit return: {b!r}")   # 'explicit'

When multiple objects are returned, Python automatically packs them into a tuple:

def multiple_returns():
    return 5, "hello", [1, 2]

packed = multiple_returns()
print(type(packed))  # <class 'tuple'>

Variable Scoping: Local, Enclosing, and Global

A variable defined inside a function is local, while one defined at the top level is global. Python resolves names using the LEGB (Local, Enclosing, Global, Built‑in) rule.

label = "outer"

def outer_function():
    label = "middle"
    def inner_function():
        label = "inner"
        print(label)       # 'inner'
    inner_function()
    print(label)           # 'middle'

outer_function()
print(label)               # 'outer'

To modify a global variable inside a functon, use the global keyword:

counter = 0

def increment():
    global counter
    counter += 1

increment()
print(counter)  # 1

For nested functions, nonlocal lets you rebind names in an enclosing scope without creating a new local:

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

timer = make_counter()
print(timer())  # 1
print(timer())  # 2

Recursive Problem Solving

Recursion is a technique where a function calls itself with a smaller instance of the problem. Every recursive solution must have a base case to prevent infinite calls.

def recursive_sum(sequence):
    if not sequence:
        return 0
    return sequence[0] + recursive_sum(sequence[1:])

values = [2, 4, 6]
print(recursive_sum(values))  # 12

Binary search, a classic recursive algorithm, locates a value in a sorted collection:

def binary_search(sorted_items, target):
    if not sorted_items:
        return -1
    mid = len(sorted_items) // 2
    if sorted_items[mid] == target:
        return mid
    if sorted_items[mid] > target:
        return binary_search(sorted_items[:mid], target)
    result = binary_search(sorted_items[mid + 1:], target)
    return (mid + 1 + result) if result != -1 else -1

numbers = [1, 3, 5, 7, 9, 11]
index = binary_search(numbers, 7)
print(index)  # 3

Recursion depth is limited, so iterative approaches or tail‑call optimizations (where the language supports them) are often preferred for large input sizes.

Anonymous Funcsions with lambda

Lambda expressions create small, unnamed function objects and are frequently paired with higher‑order functions like sorted, max, or filter.

staff = {
    "Carol": 4200,
    "Dan": 3700,
    "Alice": 5100
}

top_earner = max(staff, key=lambda name: staff[name])
print(top_earner)  # 'Alice'

Although lambdas save space, a regular def is clearer for complex logic.

Working with Higher-Order Functions

Higher‑order functions accept functions as arguments or produce functions as results. Common built‑ins include map, filter, and reduce (the latter from functools).

• map applies a function to every element of an iterable:

squares = map(lambda x: x ** 2, [1, 2, 3, 4])
print(list(squares))  # [1, 4, 9, 16]

• filter keeps elements for which a predicate returns True:

positive = filter(lambda x: x > 0, [-2, 0, 7, -1])
print(list(positive))  # [7]

• reduce (from functools) cumulatively applies a function to reduce a sequence to a single value:

from functools import reduce

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

For new code, comprehensions are often more readable than map/filter. For example, the squares list above becomes [x ** 2 for x in [1, 2, 3, 4]].

Built‑in Utilities for Everyday Tasks

Python provides a rich set of built‑ins that simplify data manipulation:

• enumerate(iterable, start=0) yields index‑value pairs.
• zip(*iterables) aggregates elements from multiple iterables.
• all(iterable) / any(iterable) check truthiness across elements.
• eval(expression) and exec(statement) evaluate strings as Python code (use cautiously).
• isinstance(obj, class_or_tuple) checks an object’s type.

Using these tools reduces boilerplate and keeps code concise when applied thoughtfully.