Python Functions: Reusable, Flexible Building Blocks

Functions are the primary tool for avoiding repetition and structuring your code into logical units. Once you define a function, you can call it anywhere — with different inputs each time — and get consistent, predictable results. This page teaches you everything from basic function definitions to scope rules, lambdas, and practical patterns for processing data.

Defining and Calling a Function

Use the def keyword, a name, parentheses, and a colon. The function body must be indented.

def greet():
    print("Hello, world!")
    print("Welcome to Python!")

greet()   # call the function
greet()   # call it again — the body runs each time

By convention, function names use snake_case — lowercase words separated by underscores. Choose names that describe what the function does, not how.

# Good
def calculate_total():
    pass

# Avoid
def func1():
    pass

Parameters and Arguments

Parameters are the variable names listed in the function definition. Arguments are the actual values you pass when calling the function.

def greet(name):
    print(f"Hello, {name}!")

greet("Alice")   # Alice is the argument
greet("Bob")

Positional Arguments

By default, Python matches arguments to parameters by their position (left to right):

def describe_pet(animal, name):
    print(f"I have a {animal} named {name}.")

describe_pet("dog", "Rex")     # animal="dog", name="Rex"
describe_pet("cat", "Whiskers")

Default Parameter Values

Give a parameter a default value to make it optional at call time. Parameters with defaults must come after parameters without defaults:

def greet(name, greeting="Hello"):
    print(f"{greeting}, {name}!")

greet("Alice")          # Hello, Alice!
greet("Bob", "Hi")      # Hi, Bob!
greet("Carol", "Hey")   # Hey, Carol!

Keyword Arguments

Pass arguments by name to improve readability and ignore order:

def create_profile(name, age, city):
    print(f"{name}, age {age}, from {city}")

create_profile(city="Hyderabad", name="Alice", age=25)

Use keyword arguments when calling functions with many parameters or when parameter names are descriptive enough to clarify the call without reading the definition.

Return Values

Use return to send a value back to the caller. Python exits the function immediately when it hits return.

def add(a, b):
    return a + b

result = add(3, 7)
print(result)   # 10

A function without an explicit return returns None.

Returning Multiple Values

Separate multiple return values with commas — Python packs them into a tuple, and you can unpack them on the calling side:

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

low, high = min_max([4, 8, 15, 16, 23, 42])
print(f"Min: {low}, Max: {high}")   # Min: 4, Max: 42

Docstrings

A docstring is a string literal on the first line of the function body. It documents what the function does, its parameters, and its return value. IDEs and help() display it automatically.

def calculate_bmi(weight_kg, height_m):
    """
    Calculate Body Mass Index (BMI).

    Args:
        weight_kg (float): Weight in kilograms.
        height_m  (float): Height in metres.

    Returns:
        float: The BMI value rounded to one decimal place.
    """
    return round(weight_kg / height_m ** 2, 1)

print(calculate_bmi(70, 1.75))   # 22.9
help(calculate_bmi)              # prints the docstring

Variable Scope

A variable’s scope is the region of code where it is visible. Python follows the LEGB rule — it searches for a name in this order:

Local — inside the current function
Enclosing — inside any outer (enclosing) function
Global — at the top level of the module
Built-in — Python’s built-in names (len, print, …)

x = "global"

def outer():
    x = "enclosing"

    def inner():
        x = "local"
        print(x)   # local

    inner()
    print(x)       # enclosing

outer()
print(x)           # global

Modifying a Global Variable

Use the global keyword inside a function to write to a module-level variable:

counter = 0

def increment():
    global counter
    counter += 1

increment()
increment()
print(counter)   # 2

Modifying an Enclosing Variable

Use nonlocal in a nested function to write to a variable in the enclosing function’s scope:

def make_counter():
    count = 0

    def step():
        nonlocal count
        count += 1
        return count

    return step

tick = make_counter()
print(tick())   # 1
print(tick())   # 2
print(tick())   # 3

Avoid modifying global state inside functions when possible. Pass values in as arguments and return new values instead — this keeps functions predictable and easy to test.

Lambda Functions

A lambda is a nameless function written as a single expression. Use it for short, throwaway logic — especially as arguments to sorted(), map(), or filter().

# Regular function
def square(x):
    return x ** 2

# Equivalent lambda
square = lambda x: x ** 2
print(square(5))   # 25

Common Lambda Patterns

numbers = [5, 2, 9, 1, 7]

# Sort a list
print(sorted(numbers))                      # [1, 2, 5, 7, 9]

# Sort objects by a field
students = [("Alice", 91), ("Bob", 74), ("Carol", 88)]
by_score = sorted(students, key=lambda s: s[1], reverse=True)
print(by_score)   # [('Alice', 91), ('Carol', 88), ('Bob', 74)]

# Map — transform every element
squares = list(map(lambda x: x ** 2, numbers))
print(squares)    # [25, 4, 81, 1, 49]

# Filter — keep elements matching a condition
evens = list(filter(lambda x: x % 2 == 0, numbers))
print(evens)      # [2]

Use lambdas only for simple one-line expressions. If your logic needs more than one line, write a regular def function instead.

`*args` and `**kwargs`

Accept a variable number of arguments using *args (positional) and **kwargs (keyword):

def total(*amounts):
    """Accept any number of numeric amounts and return their sum."""
    return sum(amounts)

print(total(10, 20))         # 30
print(total(5, 15, 25, 45))  # 90

def display(**info):
    for key, value in info.items():
        print(f"  {key}: {value}")

display(name="Alice", role="admin", active=True)

Practical Example: Processing a List of Numbers

The following example brings together parameters, defaults, return values, docstrings, and lambdas to build a small number-crunching utility:

def process_numbers(numbers, transform=None, threshold=None):
    """
    Process a list of numbers with an optional transform and filter.

    Args:
        numbers   (list):     Input list of numbers.
        transform (callable): Optional function applied to each number.
        threshold (float):    If given, keep only numbers above this value.

    Returns:
        dict: A summary with 'data', 'count', 'total', and 'average'.
    """
    # Apply transform if provided
    if transform:
        numbers = [transform(n) for n in numbers]

    # Apply threshold filter if provided
    if threshold is not None:
        numbers = [n for n in numbers if n > threshold]

    count = len(numbers)
    total = sum(numbers)
    average = total / count if count > 0 else 0

    return {
        "data":    numbers,
        "count":   count,
        "total":   total,
        "average": round(average, 2),
    }


raw = [3, 7, 2, 9, 4, 11, 1, 8]

# Basic usage
result = process_numbers(raw)
print(result)

# Square every number, then keep only those above 25
result = process_numbers(raw, transform=lambda x: x ** 2, threshold=25)
print(result)
# {'data': [49, 81, 121, 64], 'count': 4, 'total': 315, 'average': 78.75}

Key Takeaways

One responsibility

Each function should do one thing. If you find yourself writing a function that does three unrelated things, split it into three functions.

Parameters over globals

Pass data in through parameters and return new data. Avoid reading or writing global variables inside functions.

Defaults for convenience

Use default parameter values to make common cases easy without removing flexibility for advanced callers.

Docstrings always

Write a docstring for every function that isn’t completely obvious. Future you will be grateful.

Core Python

Advanced Python

Pydantic

Python Functions: Reusable, Flexible Building Blocks

Defining and Calling a Function

Parameters and Arguments

Positional Arguments

Default Parameter Values

Keyword Arguments

Return Values

Returning Multiple Values

Docstrings

Variable Scope

Modifying a Global Variable

Modifying an Enclosing Variable

Lambda Functions

Common Lambda Patterns

`*args` and `**kwargs`

Practical Example: Processing a List of Numbers

Key Takeaways

One responsibility

Parameters over globals

Defaults for convenience

Docstrings always

​Defining and Calling a Function

​Parameters and Arguments

​Positional Arguments

​Default Parameter Values

​Keyword Arguments

​Return Values

​Returning Multiple Values

​Docstrings

​Variable Scope

​Modifying a Global Variable

​Modifying an Enclosing Variable

​Lambda Functions

​Common Lambda Patterns

​*args and **kwargs

​Practical Example: Processing a List of Numbers

​Key Takeaways

One responsibility

Parameters over globals

Defaults for convenience

Docstrings always

Defining and Calling a Function

Parameters and Arguments

Positional Arguments

Default Parameter Values

Keyword Arguments

Return Values

Returning Multiple Values

Docstrings

Variable Scope

Modifying a Global Variable

Modifying an Enclosing Variable

Lambda Functions

Common Lambda Patterns

`*args` and `**kwargs`

Practical Example: Processing a List of Numbers

Key Takeaways