Python try…except with Examples

Handling exceptions in programming is a crucial task. Python provides the try…except construct to help developers deal with unexpected situations that can cause their programs to crash. By understanding and using this construct effectively, you can build robust applications that gracefully handle errors and keep running even when unexpected issues arise.

What is an Exception?

In Python, an exception is an event that occurs during the execution of a program, disrupting its normal flow. Exceptions are often indicative of errors or unexpected situations, such as attempting to open a non-existent file, dividing by zero, or trying to access a non-existent list item.

Advertisement

The try…except Construct

The basic idea behind the try…except block is simple: you wrap the code that might raise an exception inside a try block. If an exception occurs within this block, instead of crashing the program, the control is passed to the accompanying except block.

Here’s a basic structure:

try:
    # Code that might raise an exception
except SomeException:
    # Handle the exception

Basic Example

Let’s see a common example where an exception might occur – dividing by zero:

try:
    result = 10 / 0
except ZeroDivisionError:
    print("You tried to divide by zero!")

If you run this code, you’ll see the message “You tried to divide by zero!” printed, and the program will continue executing normally after the except block.

Catching Multiple Exceptions

You can handle multiple exceptions by providing multiple except blocks:

try:
    # some code
except FirstException:
    # handle the first exception
except SecondException:
    # handle the second exception

For instance, handling different types of exceptions in a basic input operation:

try:
    number = int(input("Enter a number: "))
    result = 10 / number
except ZeroDivisionError:
    print("You tried to divide by zero!")
except ValueError:
    print("That's not a valid number!")

Using a Generic except

You might not always know the exact exception your code might raise. In such cases, you can catch all exceptions by using a generic except:

try:
    # some risky code
except:
    print("Something went wrong!")

However, use this approach judiciously, as it can make debugging more challenging by masking specific issues.

The else and finally Clauses

Python also provides else and finally clauses to add more control to your exception-handling mechanism:

• else: This block is executed if no exception occurs in the try block.
• finally: This block always executes after the try block, regardless of whether an exception occurred or not.

try:
    number = int(input("Enter a number: "))
except ValueError:
    print("That's not a valid number!")
else:
    print(f"You entered: {number}")
finally:
    print("Execution finished!")

Raising Exceptions

You can raise exceptions in your code using the raise keyword, allowing you to trigger exceptions under specific conditions:

x = -5

if x < 0:
    raise ValueError("Sorry, no negatives allowed!")

Conclusion

The try...except construct in Python provides a flexible mechanism to handle exceptions and ensure that your programs don't crash unexpectedly. By leveraging this mechanism along with the else, finally, and raise clauses, you can build resilient applications that handle errors gracefully and provide meaningful feedback to users. Remember to use exceptions judiciously and avoid overusing generic exception catchers to ensure maintainability and debuggability.