Errors are an unavoidable part of software development. A program may receive invalid user input, fail to find a file, encounter a network problem, or attempt an operation that Python cannot perform.

Instead of allowing these problems to crash an application, Python provides a powerful mechanism called exception handling.

Python exception handling allows developers to detect errors, respond to them gracefully, and keep applications running when appropriate.

In this guide, you’ll learn how exception handling works in Python, including try, except, else, and finally, how to raise custom exceptions, handle multiple exceptions, create custom exception classes, and follow exception-handling best practices.

---

What Is an Exception in Python?

An exception is an event that occurs during program execution when Python encounters an error or an unexpected situation.

For example:

number = 10
result = number / 0

Python cannot divide a number by zero, so it raises an exception:

ZeroDivisionError: division by zero

Without exception handling, the program stops at that point.

Exception handling allows us to respond to the problem instead.

Program
   │
   ▼
Execute Code
   │
   ▼
Exception Occurs?
   │
 ┌─┴───────────┐
 │             │
 No           Yes
 │             │
 ▼             ▼
Continue     Handle Exception
 │             │
 └──────┬──────┘
        ▼
    Continue Program

---

Error vs Exception in Python

The terms error and exception are often used interchangeably, but they can have different meanings in Python programming.

An error generally indicates that something has gone wrong, while an exception is an object raised during program execution that can potentially be handled.

For example:

print("Hello"

This produces a syntax error because the Python code is incomplete.

On the other hand:

number = int("hello")

produces a ValueError during execution.

Understanding this distinction is useful when learning Python exception handling.

---

Common Python Exceptions

Python provides many built-in exception classes.

Some of the most common ones are:

Exception	When It Occurs
ValueError	A value has an inappropriate format
TypeError	An operation is performed on an inappropriate type
ZeroDivisionError	Division by zero is attempted
IndexError	A sequence index doesn’t exist
KeyError	A dictionary key doesn’t exist
FileNotFoundError	A requested file cannot be found
AttributeError	An object doesn’t have the requested attribute
NameError	A variable or name doesn’t exist
ImportError	An import cannot be completed
ModuleNotFoundError	A requested module cannot be found

Let’s look at some examples.

---

What Is the try Block?

The try block contains code that might raise an exception.

try:
    number = 10 / 0

However, using try alone isn’t enough.

You normally combine it with except.

try:
    number = 10 / 0
except ZeroDivisionError:
    print("You cannot divide by zero.")

Output:

You cannot divide by zero.

Instead of terminating the application, Python executes the exception-handling code.

---

What Is the except Block?

The except block defines what should happen when a particular exception occurs.

try:
    age = int("hello")
except ValueError:
    print("Please enter a valid number.")

Output:

Please enter a valid number.

This is useful when you know which exception your code might produce.

---

Handling Multiple Exceptions

A try block can potentially raise different exceptions.

For example:

try:
    number = int(input("Enter a number: "))
    result = 100 / number

except ValueError:
    print("Please enter a valid number.")

except ZeroDivisionError:
    print("Number cannot be zero.")

If the user enters:

hello

Python raises ValueError.

If the user enters:

0

Python raises ZeroDivisionError.

Each exception receives an appropriate response.

---

Handling Multiple Exceptions in One except

You can handle multiple exception types using a tuple.

try:
    number = int(input("Enter a number: "))
    result = 100 / number

except (ValueError, ZeroDivisionError):
    print("Invalid input.")

This approach is useful when different exceptions require the same response.

However, if each exception requires a different response, separate except blocks are usually clearer.

---

Catching the Exception Object

You can store the exception in a variable using as.

try:
    number = 10 / 0

except ZeroDivisionError as error:
    print("Error:", error)

Output:

Error: division by zero

The error variable contains information about the exception.

This can be particularly useful for logging and debugging.

---

The else Block

Python’s else block runs only when the try block completes successfully without raising an exception.

try:
    number = int("100")

except ValueError:
    print("Invalid number.")

else:
    print("Conversion successful.")

Output:

Conversion successful.

A useful way to understand the structure is:

try
 │
 ├── Exception? ──► except
 │
 └── No exception ─► else

The else block is useful when you want to separate successful logic from error-handling logic.

---

The finally Block

The finally block runs whether or not an exception occurs.

try:
    number = 10 / 2

except ZeroDivisionError:
    print("Cannot divide by zero.")

finally:
    print("This code always runs.")

Output:

This code always runs.

If an exception occurs:

try:
    number = 10 / 0

except ZeroDivisionError:
    print("Cannot divide by zero.")

finally:
    print("This code always runs.")

Output:

Cannot divide by zero.
This code always runs.

The finally block is commonly used for cleanup operations.

---

Understanding try, except, else, and finally

These four components can work together:

try:
    # Code that may fail
    result = 100 / number

except ZeroDivisionError:
    # Handle the exception
    print("Cannot divide by zero.")

else:
    # Runs if no exception occurs
    print("Result:", result)

finally:
    # Always runs
    print("Operation complete.")

The general flow is:

                 ┌──────────────┐
                 │     try      │
                 └──────┬───────┘
                        │
              ┌─────────┴─────────┐
              │                   │
          Exception            No Exception
              │                   │
              ▼                   ▼
          `except`              `else`
              │                   │
              └─────────┬─────────┘
                        ▼
                    `finally`
                        │
                        ▼
                    Continue

---

A Real-World Example: User Input

Suppose an application asks the user for their age.

try:
    age = int(input("Enter your age: "))

    if age < 0:
        raise ValueError("Age cannot be negative.")

except ValueError as error:
    print("Invalid age:", error)

else:
    print("Your age is:", age)

This handles both invalid numeric input and invalid values.

For example:

Enter your age: abc
Invalid age: invalid literal for int() with base 10: 'abc'

Or:

Enter your age: -5
Invalid age: Age cannot be negative.

---

Raising Exceptions With raise

Python allows developers to deliberately raise exceptions using the raise statement.

age = -10

if age < 0:
    raise ValueError("Age cannot be negative.")

Output:

ValueError: Age cannot be negative.

This is useful when your application needs to enforce business rules.

For example:

def withdraw(balance, amount):
    if amount > balance:
        raise ValueError("Insufficient balance.")

    return balance - amount

Now invalid operations are rejected explicitly.

---

Why Use raise?

Exception handling isn’t only about catching errors.

It is also about communicating invalid states.

Consider:

def calculate_discount(price, percentage):
    if price < 0:
        raise ValueError("Price cannot be negative.")

    if not 0 <= percentage <= 100:
        raise ValueError(
            "Discount must be between 0 and 100."
        )

    return price * (1 - percentage / 100)

The function clearly communicates its requirements.

This makes application logic easier to understand and test.

---

Re-Raising Exceptions

Sometimes you want to log or inspect an exception and then allow it to continue propagating.

You can use raise without an exception object:

try:
    result = 10 / 0

except ZeroDivisionError:
    print("An error occurred.")
    raise

The original exception is raised again.

This is useful when lower-level code should record information but higher-level code should decide how to respond.

---

Custom Exceptions in Python

Python allows you to create your own exception classes.

For example:

class InsufficientBalanceError(Exception):
    pass

You can then raise it:

def withdraw(balance, amount):
    if amount > balance:
        raise InsufficientBalanceError(
            "Insufficient account balance."
        )

    return balance - amount

And handle it:

try:
    balance = withdraw(1000, 1500)

except InsufficientBalanceError as error:
    print(error)

Output:

Insufficient account balance.

Custom exceptions make complex applications easier to organize.

---

Creating Custom Exception Hierarchies

For larger applications, custom exceptions can be organized into a hierarchy.

class ApplicationError(Exception):
    pass


class AuthenticationError(ApplicationError):
    pass


class AuthorizationError(ApplicationError):
    pass


class PaymentError(ApplicationError):
    pass

Now you can catch all application-specific errors:

try:
    process_request()

except ApplicationError as error:
    print("Application error:", error)

Or handle a specific exception:

try:
    authenticate_user()

except AuthenticationError:
    print("Authentication failed.")

This pattern is useful in APIs and backend applications.

---

Python Exception Hierarchy

Python’s built-in exceptions follow an inheritance hierarchy.

A simplified structure looks like this:

BaseException
│
├── SystemExit
├── KeyboardInterrupt
│
└── Exception
    │
    ├── ArithmeticError
    │   └── ZeroDivisionError
    │
    ├── LookupError
    │   ├── IndexError
    │   └── KeyError
    │
    ├── ValueError
    ├── TypeError
    ├── OSError
    │   └── FileNotFoundError
    └── RuntimeError

Most application-level exceptions inherit from Exception.

---

Why You Should Usually Avoid Catching BaseException

You might see code like:

try:
    risky_operation()

except BaseException:
    print("Something went wrong.")

This is generally too broad.

BaseException includes system-level exceptions such as KeyboardInterrupt and SystemExit.

Application code will usually want:

except Exception as error:
    ...

or, even better, a specific exception:

except ValueError:
    ...

Catch the narrowest exception that you can reasonably handle.

---

Catching All Exceptions

You can technically write:

try:
    risky_operation()

except Exception as error:
    print("An unexpected error occurred:", error)

This can be useful at application boundaries for logging or returning a generic error response.

However, using broad exception handling everywhere is a bad practice.

It can hide programming bugs.

Prefer:

except ValueError:
    ...

when you know exactly what you expect.

---

Exception Handling With Files

File operations are a common source of exceptions.

Consider:

try:
    with open("data.txt", "r") as file:
        content = file.read()

except FileNotFoundError:
    print("The file does not exist.")

This prevents the program from crashing if the requested file isn’t available.

The with statement also handles file cleanup automatically.

---

Exception Handling With Dictionaries

Accessing a missing dictionary key can raise KeyError.

user = {
    "name": "Aarav"
}

try:
    email = user["email"]

except KeyError:
    print("Email address is not available.")

Output:

Email address is not available.

If the missing key is an expected possibility, get() can often be cleaner:

email = user.get("email")

Use exception handling when the exceptional condition represents an actual error or when the operation itself naturally raises the exception.

---

Exception Handling With Lists

Accessing an invalid list index raises IndexError.

numbers = [10, 20, 30]

try:
    print(numbers[5])

except IndexError:
    print("The requested index does not exist.")

Output:

The requested index does not exist.

---

Exception Handling in Functions

Exception handling can be placed inside functions.

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

    except ZeroDivisionError:
        return None

You can then call:

result = divide(10, 0)

print(result)

Output:

None

However, returning None isn’t always the best approach.

In many applications, allowing the exception to propagate to a layer that knows how to handle it can be cleaner.

---

Exception Handling in APIs

Exception handling is particularly important in backend applications.

For example, a FastAPI endpoint might validate input and raise an HTTP-specific exception:

from fastapi import HTTPException


def get_user(user_id):
    user = find_user(user_id)

    if user is None:
        raise HTTPException(
            status_code=404,
            detail="User not found"
        )

    return user

A well-designed API should return useful error responses without exposing internal implementation details.

For example:

{
    "detail": "User not found"
}

instead of exposing a database stack trace.

---

Logging Exceptions

Printing an error isn’t always enough for a production application.

Python’s logging module can record exception information.

import logging

logger = logging.getLogger(__name__)

try:
    result = 10 / 0

except ZeroDivisionError:
    logger.exception("Failed to calculate result.")

logger.exception() is particularly useful inside an exception handler because it records the exception traceback.

In production, logs can be sent to centralized monitoring and observability systems.

---

Exception Handling and Cleanup

The finally block is useful when a resource needs cleanup.

For example:

file = None

try:
    file = open("data.txt", "r")
    content = file.read()

except FileNotFoundError:
    print("File not found.")

finally:
    if file:
        file.close()

However, for files, the preferred approach is generally a context manager:

with open("data.txt", "r") as file:
    content = file.read()

The context manager handles cleanup automatically.

---

Context Managers and Exception Safety

Python’s with statement is designed to manage resources safely.

Examples include:

• Files
• Database connections
• Locks
• Network resources
• Temporary resources

For example:

with open("data.txt", "r") as file:
    data = file.read()

Even if an exception occurs inside the block, Python handles the context manager’s cleanup logic.

This is usually preferable to manually managing resource cleanup.

---

Nested Exception Handling

You can use try blocks inside other try blocks.

try:
    number = int(input("Enter a number: "))

    try:
        result = 100 / number
        print(result)

    except ZeroDivisionError:
        print("Cannot divide by zero.")

except ValueError:
    print("Invalid number.")

Nested exception handling can be useful, but excessive nesting can make code difficult to understand.

Before nesting multiple try blocks, consider whether the logic can be simplified.

---

Exception Handling With Loops

Exception handling can also be used to repeatedly request valid input.

while True:
    try:
        age = int(input("Enter your age: "))
        break

    except ValueError:
        print("Please enter a valid number.")

print("Age:", age)

If the user enters invalid input, the program asks again.

This is a practical pattern for command-line applications.

---

Common Python Exception Handling Mistakes

1. Using an Empty except

Avoid:

try:
    risky_operation()

except:
    pass

This hides the error completely.

The application may continue running while silently producing incorrect results.

Instead:

except ValueError as error:
    logger.exception("Invalid value")

---

2. Catching Exception Everywhere

Avoid:

try:
    do_everything()

except Exception:
    pass

This can hide programming errors and make debugging extremely difficult.

Catch specific exceptions whenever possible.

---

3. Using Exceptions for Normal Control Flow

Don’t use exceptions for situations that can be handled simply through normal logic.

For example:

if "email" in user:
    email = user["email"]

may be clearer than deliberately triggering a KeyError.

---

4. Exposing Internal Errors to Users

Avoid returning raw exception details:

{
    "error": "Traceback ... database connection failed..."
}

Users generally need a safe, meaningful message.

Detailed technical information should normally go into secure application logs.

---

5. Ignoring Exceptions

This is dangerous:

try:
    process_payment()
except Exception:
    pass

A payment failure could be silently ignored.

Errors should be handled, logged, retried, or propagated appropriately.

---

Best Practices for Python Exception Handling

1. Catch Specific Exceptions

Prefer:

except ValueError:

over:

except Exception:

when possible.

2. Keep try Blocks Small

Instead of:

try:
    user = get_user()
    process_user(user)
    send_email(user)
    generate_report(user)

except Exception:
    ...

consider limiting the try block to the operation that can reasonably raise the exception you’re handling.

This makes error handling more predictable.

3. Don’t Hide Errors

Always make sure exceptions are handled intentionally.

4. Use Custom Exceptions for Domain Errors

For complex applications, custom exceptions can make business logic clearer.

5. Log Unexpected Exceptions

Use structured logging and monitoring in production applications.

6. Don’t Expose Sensitive Information

Exception messages and stack traces can reveal:

• File paths
• Database information
• Internal implementation details
• Configuration information
• Secrets

Return safe messages to external users.

7. Use Context Managers

Use with whenever possible for resources that support context management.

8. Preserve Exception Context

When converting one exception into another, Python supports explicit exception chaining:

try:
    value = int("abc")

except ValueError as error:
    raise RuntimeError(
        "Could not process the input."
    ) from error

The from error syntax preserves the relationship between the original and new exceptions.

---

Exception Handling vs Validation

Exception handling and validation are related but not identical.

Validation checks whether data satisfies expected rules.

if age < 0:
    raise ValueError("Age cannot be negative.")

Exception handling determines what the application does when an exception occurs:

try:
    process_age(age)

except ValueError:
    print("Invalid age.")

A good application typically uses both.

---

When Should You Raise an Exception?

Raise an exception when an operation cannot reasonably continue because the input or state violates an expected condition.

Good example:

def set_age(age):
    if age < 0:
        raise ValueError("Age cannot be negative.")

    return age

Poor example:

def add(a, b):
    try:
        return a + b
    except Exception:
        return None

The second example hides potentially useful programming errors.

---

Python Exception Handling Cheat Sheet

TRY
────────────────────────────────
try:
    risky_operation()


EXCEPT
────────────────────────────────
try:
    risky_operation()
except ValueError:
    handle_error()


EXCEPTION OBJECT
────────────────────────────────
except ValueError as error:
    print(error)


MULTIPLE EXCEPTIONS
────────────────────────────────
except ValueError:
    ...

except TypeError:
    ...


ELSE
────────────────────────────────
try:
    operation()
except ValueError:
    handle_error()
else:
    success()


FINALLY
────────────────────────────────
try:
    operation()
finally:
    cleanup()


RAISE
────────────────────────────────
raise ValueError("Invalid value")


CUSTOM EXCEPTION
────────────────────────────────
class PaymentError(Exception):
    pass

---

Key Takeaways

Here are the most important points to remember about Python exception handling:

1. Exceptions are runtime events that can interrupt normal program execution.
2. Use try for code that may raise an exception.
3. Use except to handle specific exceptions.
4. Use else for code that should execute only when no exception occurs.
5. Use finally for cleanup code that should run regardless of success or failure.
6. Use raise when your application needs to explicitly signal an invalid state.
7. Create custom exceptions when domain-specific errors need clear representation.
8. Catch specific exceptions instead of using broad exception handlers everywhere.
9. Never silently ignore important exceptions.
10. Use logging to investigate unexpected production failures.
11. Use context managers for resource cleanup whenever possible.
12. Never expose sensitive internal error information to end users.

---

Frequently Asked Questions About Python Exception Handling

1. What is exception handling in Python?

Python exception handling is a mechanism for detecting and responding to runtime exceptions without unnecessarily terminating the application.

It primarily uses try, except, else, and finally.

---

2. What is the difference between try and except in Python?

The try block contains code that may raise an exception.

The except block contains the code that handles the exception.

try:
    result = 10 / 0

except ZeroDivisionError:
    print("Cannot divide by zero.")

---

3. What is the purpose of finally in Python?

The finally block runs whether an exception occurs or not.

It is commonly used for cleanup operations.

try:
    process_data()

finally:
    close_connection()

For resources such as files, context managers are often a better approach.

---

4. What is the difference between raise and except?

raise is used to create or propagate an exception.

except is used to catch and handle an exception.

For example:

if age < 0:
    raise ValueError("Invalid age")

can be handled with:

try:
    validate_age(age)

except ValueError:
    print("Invalid age.")

---

5. Should I catch Exception in Python?

Only when there is a good reason.

For most application logic, catching specific exceptions is preferable:

except ValueError:

rather than:

except Exception:

Broad exception handling can hide bugs if used indiscriminately.

---

6. Can I create my own exceptions in Python?

Yes. Custom exceptions can inherit from Exception.

class PaymentError(Exception):
    pass

You can then raise and handle PaymentError like other exceptions.

---

7. What happens if an exception is not handled?

If an exception isn’t handled by the surrounding code, it propagates up the call stack.

If nothing handles it, Python terminates the current program or request and displays an error traceback.

---

8. Why is exception handling important in Python?

Exception handling helps applications respond gracefully to unexpected conditions such as invalid input, missing files, failed network operations, database errors, and invalid application states.

It improves reliability, debugging, and user experience when implemented correctly.

---