The Art of Simple Python Functions

A well-written function is like a craftsman's tool—perfectly suited to its task, reliable in your hands, and beautiful in its simplicity. It does exactly what its name promises, nothing more, nothing less.

Functions That Tell Their Story

The best functions announce their purpose clearly:

def calculate_circle_area(radius):
    return 3.14159 * radius * radius

def is_valid_email(email):
    return '@' in email and '.' in email.split('@')[1]

def format_currency(amount):
    return f"${amount:.2f}"

Each name tells you exactly what happens inside. No mystery, no surprises. When you see calculate_circle_area(5) in your code, you immediately know what's being calculated and what you'll get back.

The Single Purpose Principle

Great functions do one thing completely:

def read_file_lines(filename):
    with open(filename, 'r') as file:
        return file.readlines()

def clean_line(line):
    return line.strip().lower()

def count_words(text):
    return len(text.split())

Rather than cramming multiple operations into one function, each handles a distinct task. This makes them easier to test, easier to reuse, and easier to understand when you encounter them months later.

Parameters That Make Sense

The best functions ask for exactly what they need:

def greet_user(name, time_of_day):
    greetings = {
        'morning': 'Good morning',
        'afternoon': 'Good afternoon',
        'evening': 'Good evening'
    }
    greeting = greetings.get(time_of_day, 'Hello')
    return f"{greeting}, {name}!"

def calculate_tax(price, tax_rate):
    return price * tax_rate

def create_filename(base_name, extension):
    return f"{base_name}.{extension}"

Each parameter has a clear purpose. The function signature tells you exactly what information you need to provide. No guessing about what goes where.

Return Values You Can Trust

Good functions return exactly what their name suggests:

def get_file_size(filename):
    import os
    return os.path.getsize(filename)

def find_largest_number(numbers):
    return max(numbers)

def convert_to_uppercase(text):
    return text.upper()

If a function is called get_file_size, it returns a file size. If it's called find_largest_number, it returns the largest number. The return value matches the promise made by the name.

Handling the Unexpected Gracefully

Well-crafted functions anticipate problems and handle them clearly:

def divide_safely(a, b):
    if b == 0:
        return None
    return a / b

def get_user_age(user_data):
    if 'age' not in user_data:
        return 0
    return user_data['age']

def read_config_file(filename):
    try:
        with open(filename, 'r') as file:
            return file.read()
    except FileNotFoundError:
        return ""

Each function has a plan for when things don't go as expected. The error handling is explicit and predictable. You know what you'll get back even when the ideal scenario doesn't happen.

Building Larger Solutions

Simple functions combine naturally to solve complex problems:

def load_student_data(filename):
    lines = read_file_lines(filename)
    students = []
    for line in lines:
        clean = clean_line(line)
        if clean:
            students.append(clean)
    return students

def calculate_average_grade(grades):
    if not grades:
        return 0
    return sum(grades) / len(grades)

def generate_report(students, grades):
    average = calculate_average_grade(grades)
    student_count = len(students)
    return f"Report: {student_count} students, average grade: {average:.1f}"

Each function handles its piece of the puzzle. When you need to modify how grades are calculated, you only touch calculate_average_grade. When the report format changes, you only modify generate_report.

Functions That Work Together

Related functions naturally support each other:

def parse_date_string(date_str):
    parts = date_str.split('-')
    year, month, day = int(parts[0]), int(parts[1]), int(parts[2])
    return year, month, day

def format_date(year, month, day):
    return f"{month:02d}/{day:02d}/{year}"

def convert_date_format(date_str):
    year, month, day = parse_date_string(date_str)
    return format_date(year, month, day)

The functions fit together like well-made joints in furniture. Each has its role, and they combine smoothly to accomplish larger tasks.

The Beauty of Predictability

When functions are written this way, your code becomes predictable in the best possible sense. You can trust that calculate_circle_area will always return a number. You know that clean_line will always return a string. You can depend on divide_safely to never crash your program.

This predictability isn't boring—it's liberating. When you trust your functions completely, you can focus on solving higher-level problems instead of wondering whether your tools will work correctly.

Growing Elegant Solutions

Start with functions that do simple things well. Give them clear names, straightforward parameters, and predictable return values. Let them handle errors gracefully. Build larger solutions by combining these reliable pieces.

The result is code that feels effortless to read and modify. Functions that serve their purpose quietly and completely, like well-made tools in the hands of a skilled craftsperson. Code that would make the masters of our field smile—not because it's clever, but because it's clear.

---

Aaron Rose is a software engineer and technology writer at tech-reader.blog and the author of Think Like a Genius.