Functions serve as the building blocks of modular programming, enhancing code readability and facilitating reusability. In Python, a function is defined using the def keyword, followed by its name, a set of parentheses for parameters, and a return statement for outputs.

def greet_user(username):
    """Displays a simple greeting."""
    greeting = f"Hello, {username}!"
    return greeting

# Calling the function and storing the result
message = greet_user("Alice")

Functions are only executed when they are called. A function name without parentheses refers to the function's memory address, whereas adding parentheses triggers the execution logic.

Return Values

1. No Return: If no return statement is present, or if return is used without a value, the function implicitly returns None.
2. Single Value: Returns a specific object (string, list, integer, etc.).
3. Multiple Values: Multiple values separated by commas are returned as a tuple. These can be unpacked into separate variables during the call.

Parameter Handling

Parameters allow functions to receive data. Python distinguishes between formal parameters (defined in the function signature) and actual arguments (passed during the call).

• Positional Arguments: Must be passed in the exact order they are defined.
• Keyword Arguments: Passed as key=value pairs, allowing the order to be ignored.
• Default Parameters: Assigned a default value in the signature. If the caller provides a value, it overrides the default.
• Dynamic Arguments:
  • *args: Collects extra positional arguments into a tuple.
  • **kwargs: Collects extra keyword arguments into a dictionary.

Parameter Order: Positional > *args > Default > **kwargs.

The Mutable Default Argument Pitfall

When using a mutable type (like a list) as a default argument, the same object is shared across all function calls that do not provide their own argument. This can lead to unexpected data persistence.

def add_to_registry(name, registry=[]):
    registry.append(name)
    return registry

print(add_to_registry("App1"))  # ['App1']
print(add_to_registry("App2"))  # ['App1', 'App2']

Namespaces and Scope

Python manages variable accessibility through three main namespaces:

1. Built-in: Created when the Python interpreter starts (e.g., print(), len()).
2. Global: Contains names defined at the top level of a script or module.
3. Local: Created when a function is called and destroyed when the function finishes.

The LEGB Rule: Python searches for names in the order: Local -> Enclosed (Nested) -> Global -> Built-in.

• global: Used inside a local scope to modify a variable defined at the global level.
• nonlocal: Used in nested functions to modify a variable in the nearest enclosing scope (excluding the global scope).

Higher-Order Functions and Closures

Functions are first-class objects in Python. They can be assigned to variables, stored in data structures, passed as arguments, and returned from other functions.

A closure occurs when a nested function references a variable from its outer enclosing scope. Even after the outer function finishes execution, the inner function retains access to that scope's environment.

def create_multiplier(factor):
    def multiply(number):
        return number * factor
    return multiply

double = create_multiplier(2)
print(double(5))  # 10

Practical Implementations

Filtering Odd Indices

Extract elements at odd index positions from a collection.

def get_odd_index_items(items):
    return items[1::2]

Character Type Counter

Analyze a string to count digits, letters, spaces, and other symbols.

def analyze_string(content):
    stats = {"digits": 0, "letters": 0, "spaces": 0, "others": 0}
    for char in content:
        if char.isdigit():
            stats["digits"] += 1
        elif char.isalpha():
            stats["letters"] += 1
        elif char.isspace():
            stats["spaces"] += 1
        else:
            stats["others"] += 1
    return stats

Safe Dictionary Truncation

Limit the length of all values in a dictionary if they exceed a certain threshold.

def truncate_dict_values(data, limit=2):
    for key, value in data.items():
        if len(value) > limit:
            data[key] = value[:limit]
    return data

Conditional File Modification

Batch update content within a file by creating a temporary copy and replacing the original.

import os

def patch_file(path, target_str, replacement_str):
    temp_path = f"{path}.tmp"
    with open(path, 'r', encoding='utf-8') as src, \
         open(temp_path, 'w', encoding='utf-8') as dest:
        for line in src:
            dest.write(line.replace(target_str, replacement_str))
    os.remove(path)
    os.rename(temp_path, path)