Learn How to Use Exception Handling in Python: Absolute Beginners Tutorial

Every Python program eventually encounters something unexpected — a file that does not exist, a number that cannot be divided, or input that is not what the code expected. Exception handling gives you a structured way to respond to those situations without the program crashing.

Python separates two categories of problems: syntax errors, which are caught before your code ever runs, and exceptions, which occur during execution. This tutorial focuses entirely on exceptions — what they are, how to catch them, and how to raise them yourself when your own code needs to signal a problem.

What Is an Exception?

An exception is an event that interrupts the normal flow of a program. When Python cannot complete an operation — for example, dividing by zero or opening a file that does not exist — it creates an exception object describing what went wrong and stops executing the current block of code.

If nothing handles the exception, Python terminates the program and prints a traceback. A traceback tells you the exception type, a message explaining the problem, and the exact line where execution stopped. Reading tracebacks carefully is one of the first practical skills to develop as a Python programmer.

# This line raises a ZeroDivisionError
result = 10 / 0

# Output:
# Traceback (most recent call last):
#   File "example.py", line 2, in <module>
#     result = 10 / 0
# ZeroDivisionError: division by zero

The traceback shows the exception type on the last line — ZeroDivisionError — followed by a colon and a human-readable message. The lines above it show the call chain that led to the error.

The try and except Blocks

The try block marks code that might raise an exception. The except block defines what should happen if it does. Python attempts to run the code inside try. If an exception is raised, Python jumps immediately to the matching except clause and runs that instead.

try:
    number = int(input("Enter a number: "))
    print(10 / number)
except ZeroDivisionError:
    print("You cannot divide by zero.")
except ValueError:
    print("That was not a valid number.")

In the example above, two different exceptions can occur. If the user enters 0, Python raises ZeroDivisionError. If the user enters something that cannot be converted to an integer — like hello — Python raises ValueError. Each except clause handles one specific type.

Catching Multiple Exception Types at Once

If two exception types should trigger the same response, you can group them in a tuple inside a single except clause rather than repeating yourself.

try:
    value = int(user_input) / divisor
except (ValueError, ZeroDivisionError) as e:
    print(f"Input problem: {e}")

Common Built-in Exception Types

Python ships with dozens of built-in exception types. Knowing the ones you will encounter regularly makes it much easier to write targeted except clauses. The table below covers the exceptions absolute beginners run into the most.

The else and finally Clauses

Two optional clauses extend what you can do with a try-except block: else and finally. Neither is required, but each serves a distinct purpose.

The else Clause

The else block runs only when the try block completes without raising any exception. This lets you keep the success-path logic clearly separate from both the risky operation and the error-handling code.

try:
    f = open("data.txt", "r")
except FileNotFoundError:
    print("File not found.")
else:
    # Runs only if open() succeeded
    content = f.read()
    print(f"Read {len(content)} characters.")
    f.close()

The finally Clause

The finally block always runs — whether the try block succeeded, raised a caught exception, or raised an uncaught one. It is the right place for cleanup code that must execute no matter what happens, such as closing a file handle or releasing a network connection.

try:
    result = 10 / int(input("Divisor: "))
except (ValueError, ZeroDivisionError) as e:
    print(f"Error: {e}")
else:
    print(f"Result: {result}")
finally:
    print("Calculation attempt complete.")

Using raise to Trigger Exceptions Intentionally

You are not limited to catching exceptions that Python raises automatically. The raise keyword lets you signal that something has gone wrong in your own code — for example, when a function receives an argument that passes type checks but violates a business rule.

def set_age(age):
    if not isinstance(age, int):
        raise TypeError("age must be an integer")
    if age < 0:
        raise ValueError("age cannot be negative")
    return age

try:
    set_age(-5)
except ValueError as e:
    print(f"Invalid age: {e}")

Inside an except block you can also use raise with no arguments to re-raise the current exception after logging it or doing partial cleanup, without swallowing it.

"Errors should never pass silently. Unless explicitly silenced." — The Zen of Python, Tim Peters

Python Exception Handling Summary Points

1. The try block contains code that might fail. Python executes it normally unless an exception is raised, in which case it jumps immediately to the matching except clause.
2. Always name the exception type in an except clause. Catching broad exceptions hides bugs; catching specific types like ValueError or FileNotFoundError keeps the handler focused on the problem it was designed for.
3. The else clause runs only when the try block completes without error. The finally clause always runs, making it the right place for cleanup that must not be skipped under any circumstances.
4. You can raise exceptions deliberately with the raise keyword. Inside an except block, a bare raise re-raises the current exception, which is useful when you want to log an error without silently swallowing it.
5. Knowing the common built-in exception types — ValueError, TypeError, ZeroDivisionError, IndexError, KeyError, FileNotFoundError, and AttributeError — lets you write targeted handlers rather than guessing which exception to catch.

Exception handling is not just about preventing crashes. It is about writing code that communicates what went wrong and gives the program a clear path to recover or fail gracefully. Start with the simplest try-except structure, name your exception types, and keep the guarded blocks small.