What is except in Python? Absolute Beginners Tutorial

When Python runs into a problem it cannot handle on its own, it raises an exception and the program crashes. The except keyword is how you stop that from happening. It gives you a place to catch the error and decide what to do next.

This tutorial covers what an exception is, why Python raises one, what the except keyword does, and how to write a complete try/except block from scratch. Every example is copy-ready and aimed at people who are new to Python.

What is an Exception?

An exception is Python's way of saying "something went wrong at runtime." Unlike a syntax error, which Python spots before the program runs, an exception happens while the code is actually executing. The most common ones beginners encounter are ValueError, TypeError, ZeroDivisionError, and FileNotFoundError.

When Python raises an exception and there is no code in place to handle it, the program stops immediately and prints a traceback. The traceback tells you the type of exception and where it occurred, but it also means your script has crashed.

The example below shows what a crash looks like without except, then what happens when you add it:

# Without error handling — this crashes
number = int("hello")   # raises ValueError
print("This line never runs")

Running the code above produces a ValueError: invalid literal for int() with base 10: 'hello' and the script stops. Now compare that to the version with except:

# With error handling — the program keeps running
try:
    number = int("hello")
except ValueError:
    print("That is not a valid number.")

print("The program continues here.")

The except Keyword Explained

The except keyword always appears as part of a try/except block. The try clause holds the code that might raise an error. If that error occurs, Python jumps directly to the matching except clause and runs whatever is inside it. If no error occurs, the except clause is skipped entirely.

The structure looks like this:

try:
    # code that might raise an exception
    risky_operation()
except SomeExceptionType:
    # code that runs only if SomeExceptionType was raised
    handle_the_error()

You can also capture the exception object using the as keyword, which lets you inspect or log the error message:

try:
    age = int(input("Enter your age: "))
except ValueError as e:
    print("Input was not a number.")
    print("Details:", e)

The variable e is just a name — you could call it anything. Convention is to use e or err. Printing it gives you the exception's message string, which is useful for debugging.

The comparison below shows how the three most common except patterns differ from each other:

Catching Multiple Exceptions

A single try block can have several except clauses stacked underneath it. Python checks each one from top to bottom and runs the first one that matches the raised exception. Only one except clause runs per exception — the rest are skipped.

Notice three things in the example below. The expected error cases (ValueError, ZeroDivisionError) print a message and return None explicitly — the caller can then check for None rather than silently receiving it. The broad except Exception clause calls raise with no argument, which re-raises the original exception after logging it. This preserves the full traceback rather than swallowing an unexpected error.

def parse_and_divide(text, divisor):
    try:
        number = int(text)
        result = number / divisor
    except ValueError:
        print("Could not convert to integer.")
        return None
    except ZeroDivisionError:
        print("Divisor cannot be zero.")
        return None
    except Exception as e:
        print("Unexpected error:", e)
        raise          # re-raises the original exception unchanged
    return result

You can also catch several exception types in a single clause by grouping them in a tuple:

try:
    value = int(input("Enter a number: "))
    print(10 / value)
except (ValueError, ZeroDivisionError) as e:
    print("Invalid input:", e)

Beyond except, a full try block can also include an else clause and a finally clause. These are optional but useful. In the example below, open() is called inside a context manager (with) nested inside try. This is the Pythonic approach — the context manager guarantees the file handle is closed when the with block exits, even if an error occurs inside it, so you do not need to call f.close() manually in finally.

try:
    with open("data.txt", "r") as f:
        file_content = f.read()
except FileNotFoundError:
    print("File not found.")
else:
    # Runs only if no exception occurred
    print(file_content)
finally:
    # Always runs — good for cleanup
    print("Done.")

The Zen of Python holds that silent errors are nearly always a mistake — an error worth ignoring is one you have consciously chosen to silence. — Tim Peters, The Zen of Python (PEP 20)

Python Learning Summary Points

1. The except keyword always follows a try: block. It defines the code Python runs when a specific exception type is raised inside the try block.
2. Specifying the exception type (e.g., except ValueError:) is strongly preferred over a bare except:. Named exceptions make your intent clear and avoid catching signals like KeyboardInterrupt by accident.
3. Use except ExceptionType as e: to capture the exception object. The variable e holds the error message and other details you can log or display.
4. Multiple except clauses can follow a single try block. Python runs the first clause whose type matches and skips the rest.
5. The optional else clause runs only when the try block completes without any exception. The optional finally clause always runs regardless of outcome and is used for cleanup.

Exception handling is one of the most practical skills in Python. Once you understand how try and except work together, you can write programs that recover from bad input, missing files, and unexpected runtime conditions — instead of crashing and leaving the user with a traceback.