Python Function - SyntBlaze

A Python function is a first-class object that encapsulates a block of parameterized statements. It is defined using the def keyword, executes within its own local lexical scope upon invocation, and yields a value to the caller via the return statement, implicitly evaluating to None if no return is specified.

Base Syntax

Functions are declared with the def keyword, followed by an identifier, a parenthesized parameter list, and a colon. The function body must be indented.

def function_name(param1: int, param2: str = "default") -> bool:
    """Optional docstring for metadata."""
    # Lexical block / Function body
    return True

Parameter and Argument Mechanics

Python supports highly flexible parameter binding mechanisms. Arguments can be passed positionally or by keyword.

Default Parameters: Assigned at function definition time, not at execution time. (Note: Using mutable objects like list or dict as defaults results in the same object being shared across all calls).
Arbitrary Positional Arguments (*args): Captures excess positional arguments into a tuple.
Arbitrary Keyword Arguments (**kwargs): Captures excess keyword arguments into a dict.

Parameter Modifiers (Python 3.8+)

You can enforce how arguments are passed using special syntax markers / and *.

def strict_function(pos_only, /, standard, *, kw_only):
    pass

# pos_only: Must be passed by position.

# standard: Can be passed by position or keyword.

# kw_only: Must be passed by keyword.

Return Mechanics

The return statement terminates function execution and passes an object back to the caller.

def return_multiple():
    return 1, 2, 3  # Implicitly packs values into a tuple: (1, 2, 3)

def implicit_return():
    x = 5
    # Implicitly returns None

Scope and Namespaces (LEGB Rule)

When a variable is referenced inside a function, Python resolves the name using the LEGB rule, searching in this exact order:

Local: Names assigned within the function.
Enclosing: Names in the local scope of any enclosing functions (closures).
Global: Names assigned at the top-level of the module.
Built-in: Names preassigned in the built-in names module.

To modify variables outside the local scope, Python provides specific keywords:

global: Binds a local identifier to the module-level namespace.
nonlocal: Binds a local identifier to the nearest enclosing lexical scope (used in nested functions/closures).

x = 10
def outer():
    y = 20
    def inner():
        global x
        nonlocal y
        x += 1  # Modifies global x
        y += 1  # Modifies enclosing y
    inner()

First-Class Object Characteristics

Functions in Python are instances of types.FunctionType. They possess attributes (like __name__ and __doc__) and can be treated as data. This allows for higher-order functions:

Assigned to variables.
Passed as arguments to other functions.
Returned from other functions.

def execute_callback(func, value):
    return func(value) # Executing a passed function

Lambda Functions

Python supports anonymous, inline functions via the lambda keyword. Lambdas are restricted to a single expression and cannot contain statements or annotations. The result of the expression is implicitly returned.

# Syntax: lambda parameters: expression
multiply = lambda x, y: x * y

Tired of Poor Python Skills? Fix That With Deep Grasping!Learn More

​Base Syntax

​Parameter and Argument Mechanics

​Parameter Modifiers (Python 3.8+)

​Return Mechanics

​Scope and Namespaces (LEGB Rule)

​First-Class Object Characteristics

​Lambda Functions