Handling Errors in Python Functions

Handling Errors in Python Functions – Best Practices 2026

Proper error handling is one of the most important aspects of writing robust and maintainable Python functions. In 2026, following modern error handling practices helps create reliable code that gracefully handles unexpected situations.

TL;DR — Key Best Practices 2026

• Use specific exceptions instead of bare except:
• Keep error handling close to where the error can occur
• Use custom exception classes for domain-specific errors
• Provide clear, actionable error messages
• Always clean up resources using context managers

1. Basic Error Handling

def divide(a: float, b: float) -> float:
    """Divide two numbers with proper error handling."""
    if b == 0:
        raise ValueError("Cannot divide by zero")
    return a / b

# Good usage
try:
    result = divide(10, 0)
except ValueError as e:
    print(f"Error: {e}")

2. Modern Best Practices

from typing import Optional

class InvalidUserInputError(Exception):
    """Custom exception for invalid user input."""
    pass

def process_user_input(value: str) -> Optional[int]:
    """Process user input with clear error handling."""
    try:
        number = int(value)
        if number < 0:
            raise InvalidUserInputError("Number must be non-negative")
        return number
    except ValueError:
        raise InvalidUserInputError(f"Invalid number format: {value}") from None
    except Exception as e:
        # Log unexpected errors but don't expose details to user
        logger.error(f"Unexpected error processing input: {e}")
        raise RuntimeError("An unexpected error occurred") from e

3. Best Practices for Error Handling in Functions (2026)

• Use specific exceptions rather than catching everything with bare except:
• Create custom exception classes for your domain logic
• Provide clear, user-friendly error messages
• Use context managers to ensure resources are always cleaned up
• Log unexpected errors but don’t expose internal details to users
• Use raise ... from None to suppress unnecessary traceback when re-raising

Conclusion

Good error handling is not just about catching exceptions — it’s about writing functions that fail gracefully, provide useful feedback, and maintain system stability. In 2026, following these best practices leads to more reliable, maintainable, and professional Python code.

Next steps:

• Review your functions and improve error handling using specific exceptions and clear messages
• Related articles: Writing Functions in Python 2026 • Using Context Managers in Python 2026