Skip to main content

Introduction to Exception Handling: `try` and `except` Blocks

Up to this point, our scripts have followed a "happy path." We assume the user will enter the correct type of data, the files we want to read will always exist, and we'll never divide by zero. But in the real world, things go wrong. Network connections fail, files are moved, and users enter invalid input.

If you don't plan for these problems, your program will crash. Exception handling is the process of anticipating and responding to these runtime errors, and it's a fundamental part of writing robust, production-quality code. The primary tool for this in Python is the try...except block.

📚 Prerequisites​

You should be familiar with basic Python operations that can cause errors, such as:

  • Mathematical calculations (e.g., division).
  • Opening files.
  • Type conversions (e.g., int()).

🎯 Article Outline: What You'll Master​

In this article, you will learn:

  • ✅ What an Exception Is: Understand the difference between a syntax error and a runtime error (exception).
  • ✅ The try...except Block: The basic syntax for catching and handling exceptions.
  • ✅ Handling Specific Exceptions: Why it's better to catch specific errors like ValueError or FileNotFoundError instead of all errors at once.
  • ✅ A Practical Example: Building a simple, robust script that handles potential user errors.

🧠 Section 1: What is an Exception?​

An exception is an error that occurs during the execution of a program. It's different from a syntax error, which is a mistake in the code's structure (like a typo or missing colon) that Python detects before the program even starts running.

When an exception occurs, the normal flow of the program is disrupted. If the exception is not "handled," the program will terminate and print a "traceback" message.

Common Built-in Exceptions:

  • ValueError: An operation receives an argument of the right type but an inappropriate value (e.g., int('abc')).
  • TypeError: An operation is performed on an object of an inappropriate type (e.g., 'hello' + 5).
  • ZeroDivisionError: Occurs when you try to divide a number by zero.
  • FileNotFoundError: Occurs when you try to open() a file that doesn't exist in read mode.
  • IndexError: Occurs when you try to access a list index that is out of bounds.

💻 Section 2: The try...except Block​

The try...except block allows you to "try" a piece of code that might fail, and "except" (catch) the error if it does, allowing you to handle it gracefully instead of crashing.

The Syntax:

try:
    # Code that might cause an exception
    # This is the "happy path"
    ...
except ExceptionName:
    # Code that runs ONLY if an exception of type 'ExceptionName'
    # occurred in the 'try' block.
    ...

Example: Handling a ZeroDivisionError

# without_try_except.py
numerator = 10
denominator = 0
# This line will crash the program
# result = numerator / denominator
# print(result)

The code above would produce a ZeroDivisionError and stop. Let's handle it.

# with_try_except.py
numerator = 10
denominator = 0

try:
    result = numerator / denominator
    print(f"The result is {result}")
except ZeroDivisionError:
    print("Error: Cannot divide by zero. Please provide a non-zero denominator.")

print("The program continues to run after the error.")

Output:

Error: Cannot divide by zero. Please provide a non-zero denominator.
The program continues to run after the error.

Instead of crashing, our program caught the specific error, printed a helpful message, and continued its execution.

🛠️ Section 3: Handling Specific Exceptions​

It's a very important best practice to catch specific exceptions whenever possible, like we did with ZeroDivisionError.

While you can use a bare except: to catch any and all exceptions, this is dangerous. It can hide bugs and make it difficult to understand what went wrong.

A Practical Example: Robust User Input Let's write a script that asks the user for their age. This could fail in two ways: they might enter text instead of a number (ValueError), or they might enter a negative number (which is logically invalid).

# robust_input.py

try:
    age_str = input("Please enter your age: ")
    age = int(age_str) # This can raise a ValueError

    if age < 0:
        # We can raise our own exception if the logic is invalid
        raise ValueError("Age cannot be negative.")

    print(f"You will be {age + 1} on your next birthday.")

except ValueError as e:
    # The 'as e' part captures the exception object, which contains a message.
    print(f"Invalid input: {e}. Please enter a valid positive number.")

print("\n--- End of program ---")

How it works:

  1. The code inside the try block is executed.
  2. If the user enters "abc", int('abc') raises a ValueError. The except block catches it.
  3. If the user enters "-10", we check for it and raise our own ValueError to be caught by the same except block.
  4. The as e syntax assigns the actual exception object to the variable e, so we can print its specific message.
  5. If the user enters a valid age like "30", no exception occurs, and the except block is skipped entirely.

✨ Conclusion & Key Takeaways​

Exception handling is not an optional feature; it's a core component of writing reliable software. The try...except block is your primary tool for building programs that can withstand unexpected inputs and situations without crashing.

Let's summarize the key takeaways:

  • Exceptions are runtime errors that disrupt the normal flow of a program.
  • Use try blocks for code that you anticipate might fail.
  • Use except blocks to define how your program should respond to an error.
  • Be Specific: Always try to catch specific exceptions (ValueError, FileNotFoundError, etc.) rather than using a bare except:. This makes your code more predictable and easier to debug.
  • You can raise your own exceptions to signal that something has gone wrong in your program's logic.

➡️ Next Steps​

The try...except block is just the beginning. There are two more optional clauses, else and finally, that give you even more control over your program's flow. In the next article, we'll explore "Handling Specific Exceptions: else and finally blocks" to complete your exception handling toolkit.

Happy (robust) coding!