> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Python Function
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.
```python theme={"dark"}
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 `*`.
```python theme={"dark"}
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.
```python theme={"dark"}
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:
1. **L**ocal: Names assigned within the function.
2. **E**nclosing: Names in the local scope of any enclosing functions (closures).
3. **G**lobal: Names assigned at the top-level of the module.
4. **B**uilt-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).
```python theme={"dark"}
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.
```python theme={"dark"}
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.
```python theme={"dark"}
# Syntax: lambda parameters: expression
multiply = lambda x, y: x * y
```
Tired of Poor Python Skills? Fix That With Deep Grasping!
Learn More
