Python - Defining a Function

Defining a Function in Python

Functions are foundational building blocks in Python programming, enabling developers to encapsulate logic, improve readability, and encourage code reuse. This comprehensive guide delves into every aspect of defining and using functions in Python—from basics to advanced patterns— providing clear explanations, practical examples, and best practices for writing clean, maintainable code.

1. Introduction to Functions

1.1 What Is a Function?

A function is a self-contained block of code that performs a specific task or calculates a value. In Python, functions help break complex problems into smaller, reusable components. Core benefits include:

• Reusability: Write code once, reuse it multiple times.
• Modularity: Each function handles one responsibility.
• Readability: Named functions convey intention.
• Maintainability: Independent units are easier to test and debug.

1.2 Anatomy of a Function

A typical function includes:

• Function header: The def keyword, function name, and parameter list.
• Docstring: Optional description of purpose, parameters, and return values.
• Body: Logic and statements executed when called.
• Return statement: Sends back a result (optional).

2. Basic Function Structure

2.1 Defining and Calling a Function

def add(a, b):
    """Return sum of a and b."""
    return a + b

result = add(5, 7)
print(result)  # Output: 12

This example shows parameter passing, return values, and basic docstring usage.

2.2 Parameter Types

Python allows:

• Positional parameters: Order matters
• Keyword parameters: By name
• Default parameters: Provide fallback values
• Variable-length parameters: *args and **kwargs

2.3 Positional vs Keyword Arguments

def divide(a, b):
    return a / b

x = divide(10, 2)         # Positional
y = divide(b=5, a=25)     # Keyword

2.4 Default Parameter Values

def greet(name, msg="Hello"):
    return f"{msg}, {name}!"

print(greet("Alice"))           # "Hello, Alice!"
print(greet("Bob", msg="Hi"))   # "Hi, Bob!"

2.5 Mutable Default Arguments Caveat

Avoid mutable defaults like lists or dicts; they persist across calls:

def append_item(value, lst=[]):
    lst.append(value)
    return lst

print(append_item(1))  # [1]
print(append_item(2))  # [1, 2]  ← Unexpected

Correct pattern:

def append_item(value, lst=None):
    if lst is None:
        lst = []
    lst.append(value)
    return lst

3. Advanced Parameter Handling

3.1 Variable Positional Arguments *args

def sum_all(*args):
    total = 0
    for num in args:
        total += num
    return total

print(sum_all(1, 2, 3, 4))  # 10

3.2 Variable Keyword Arguments **kwargs

def describe_person(**kwargs):
    for key, val in kwargs.items():
        print(f"{key}: {val}")

describe_person(name="Alice", age=30, city="Paris")

3.3 Mixing Parameter Types

def func(a, b=2, *args, **kwargs):
    print(a, b, args, kwargs)

func(1, 3, 4, 5, x=100, y=200)
# 1 3 (4, 5) {'x':100, 'y':200}

4. Return Values and Multiple Return

4.1 Single Return

def double(x):
    return x * 2

print(double(7))  # 14

4.2 Multiple Return via Tuple Unpacking

def min_max(numbers):
    return min(numbers), max(numbers)

low, high = min_max([3, 1, 9, 4])
print(low, high)  # 1 9

4.3 Returning None Implicitly

Functions without return produce None by default.

5. Docstrings and Annotations

5.1 Writing Docstrings

def multiply(a, b):
    """
    Multiply two numbers and return the result.

    Args:
      a (int): The first number.
      b (int): The second number.

    Returns:
      int: Product of a and b.
    """
    return a * b

5.2 Accessing Docstrings at Runtime

print(multiply.__doc__)

5.3 Type Annotations

def greet(name: str, age: int = 0) -> str:
    return f"{name} is {age} years old."

5.4 Optional and Union Types

from typing import Optional, Union

def to_int(s: str) -> Optional[int]:
    try:
        return int(s)
    except ValueError:
        return None

def process(val: Union[int, float]) -> float:
    return val * 2.5

6. Anonymous Functions with lambda

6.1 Basic Lambda Syntax

square = lambda x: x * x
print(square(6))  # 36

6.2 Common Patterns

• Sorting lists: sorted(items, key=lambda x: x.price)
• Using with map/filter:

nums = [1, 2, 3, 4, 5]
squares = list(map(lambda x: x*x, nums))
evens = list(filter(lambda x: x%2 == 0, nums))

6.3 Limitations

Limited to single expressions – no statements, loops, or multi-line logic. For complex processing, prefer named functions.

7. Functions as First-Class Objects

7.1 Passing Functions

def apply(func, x):
    return func(x)

print(apply(lambda x: x + 10, 5))  # 15

7.2 Returning Functions (Closures)

def make_multiplier(n):
    def multiplier(x):
        return x * n
    return multiplier

double = make_multiplier(2)
print(double(8))  # 16

7.3 Assigning to Variables

def greet(name):
    return f"Hello {name}"

say_hello = greet
print(say_hello("Alice"))  # Hello Alice

8. Nested and Inner Functions

8.1 Defining Inside Another

def outer():
    def inner():
        print("Inner here")
    inner()

outer()

8.2 Use Cases: Factories and Decorators

• Create specialized functions dynamically
• Wrap or modify functionality

9. Decorators

9.1 Basic Decorator Pattern

def my_decorator(func):
    def wrapper(*args, **kwargs):
        print("Before")
        result = func(*args, **kwargs)
        print("After")
        return result
    return wrapper

@my_decorator
def say_hi():
    print("Hi!")

say_hi()

9.2 Decorators with Arguments

def repeat(n):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(n):
                func(*args, **kwargs)
        return wrapper
    return decorator

@repeat(3)
def greet():
    print("Hello!")

9.3 Practical Decorator Examples

• Logging execution time
• Enforcing access policies
• Memoization/caching

10. Recursive Functions

10.1 Basic Recursion

def factorial(n):
    if n == 0:
        return 1
    else:
        return n * factorial(n-1)

print(factorial(5))  # 120

10.2 Recursive Fibonacci

def fib(n):
    if n <= 1:
        return n
    return fib(n-1) + fib(n-2)

print([fib(i) for i in range(10)])

10.3 Tail Recursion Optimization

Python doesn’t optimize tail calls; iterative loops are preferred for deep recursion.

11. Variable Scope and Name Resolution

11.1 Local vs Global

x = 10

def func():
    x = 5  # local
    print(x)

func()    # 5
print(x)  # 10

11.2 The global Keyword

x = 5

def modify():
    global x
    x = 20

modify()
print(x)  # 20

11.3 The nonlocal Keyword

def outer():
    x = 5
    def inner():
        nonlocal x
        x = 10
    inner()
    return x

print(outer())  # 10

12. Anonymous Functions Alternative: functools.partial

12.1 Freezing Arguments

from functools import partial

def power(base, exp):
    return pow(base, exp)

square = partial(power, exp=2)
print(square(5))  # 25

13. Introspection and Metadata

13.1 Checking Function Metadata

def func(a, b=2):
    """Example doc."""
    pass

print(func.__name__)     # "func"
print(func.__doc__)      # "Example doc."
print(func.__defaults__) # (2,)

13.2 The inspect Module

import inspect
sig = inspect.signature(func)
print(sig)              # (a, b=2)
print(sig.parameters)   # mapping of params

14. Best Practices in Function Design

14.1 Single Responsibility Principle

Functions should do one thing, not multiple. Keep them short and focused.

14.2 Meaningful Names

Name functions clearly: calculate_total is better than ct.

14.3 Use Docstrings and Types

Document purpose, arguments, return types, and exceptions. Use type hints for clarity and tool support.

14.4 Keep Functions Small

Ideally under ~50 lines–encourage reuse and improve testing.

15. Example: Building a Calculator Module

# calc.py
def add(a: float, b: float) -> float:
    """Add two numbers."""
    return a + b

def sub(a: float, b: float) -> float:
    return a - b

def mul(a: float, b: float) -> float:
    return a * b

def div(a: float, b: float) -> float:
    if b == 0:
        raise ValueError("Cannot divide by zero")
    return a / b

# main.py
import calc
print(calc.add(4, 5))
print(calc.div(10, 0))  # triggers ValueError

Defining functions in Python is more than just grouping statements—it’s about capturing intent, ensuring clarity, supporting reuse, and designing maintainable code. This guide covered:

• Basic definitions and parameter types
• Return values, docstrings, annotations
• Lambda, closures, decorators, recursion
• Scope rules, introspection, best practices, performance

Armed with these techniques, you can write functions that are readable, efficient, robust, and ready for real-world Python applications.