Try-Except Blocks

Handling errors gracefully is crucial in making your applications robust and user-friendly. Python provides the `try-except` construct to handle exceptions, allowing your program to manage errors without crashing unexpectedly.

This tutorial will cover the basics of the `try-except` block, how to catch specific exceptions, the use of `else` and `finally` clauses, and practical examples to demonstrate effective error handling.

### Basic Try-Except Block

The basic syntax of a `try-except` block in Python allows you to catch and handle exceptions that occur during runtime.


try:
    # Risky code that might raise an exception
    result = 10 / 0
except ZeroDivisionError:
    # Code to run if a ZeroDivisionError occurs
    print("You can't divide by zero!")
You can't divide by zero!

- **`try`**: Contains the code that might raise an exception.
- **`except ZeroDivisionError`**: Catches and handles the `ZeroDivisionError`.

### Catching Specific Exceptions

You can catch [different types of exceptions](/tutorials/exceptions) and handle them separately.


try:
    # Risky code
    result = int('abc')
except ValueError:
    # Code to run if a ValueError occurs
    print("A value error occurred: invalid literal for int()")
except TypeError:
    # Code to run if a TypeError occurs
    print("A type error occurred.")
A value error occurred: invalid literal for int()

- **`except ValueError`**: Catches the `ValueError` if the conversion to an integer fails.
- **`except TypeError`**: Catches the `TypeError`.

### Catching Multiple Exceptions

You can catch multiple exceptions in a single `except` block by specifying a tuple of exceptions.


try:
    # Risky code
    result = 10 / 'a'
except (ZeroDivisionError, TypeError, ValueError) as e:
    print(f"An error occurred: {e}")
An error occurred: unsupported operand type(s) for /: 'int' and 'str'

- **`except (ZeroDivisionError, TypeError, ValueError) as e`**: Catches any of the specified exceptions and assigns the exception object to `e`.

### Using Else and Finally Clauses

The `else` clause is executed if no exceptions occur, and the `finally` clause is executed no matter what, allowing for cleanup actions.


try:
    # Risky code
    result = 10 / 2
except ZeroDivisionError:
    print("You can't divide by zero!")
else:
    print(f"Division result: {result}")
finally:
    print("Execution completed.")
Division result: 5.0
Execution completed.

- **`else`**: Executes if no exceptions are raised.
- **`finally`**: Executes regardless of whether an exception was raised or not (used for cleanup actions like closing a file).

### Practical Examples

#### Reading from a File

A common use of `try-except` is handling errors that arise when working with files.


try:
    with open('sample.txt', 'r') as file:
        content = file.read()
except FileNotFoundError:
    print("The file was not found.")
except IOError:
    print("An I/O error occurred.")
else:
    print("File read successfully.")
finally:
    print("File operation completed.")
The file was not found.
File operation completed.

- **`FileNotFoundError`**: Handles the error when the file is not found.
- **`IOError`**: Handles other I/O errors.
- **`else` and `finally`**: Provide additional logic for successful operations and cleanup.

#### Handling User Input

You can use `try-except` blocks to ensure that user inputs are valid.


try:
    age = int(input("Enter your age: "))
except ValueError:
    print("Invalid input! Please enter an integer.")
else:
    print(f"Your age is {age}")
finally:
    print("Input operation completed.")
- **`ValueError`**: Catches invalid input when converting the input to an integer.

### Custom Exception Handling

You can also combine `try-except` blocks with custom exceptions for more descriptive error handling.


class CustomError(Exception):
    def __init__(self, message):
        super().__init__(message)

def divide(a, b):
    if b == 0:
        raise CustomError("Division by zero is not allowed.")
    return a / b

try:
    result = divide(10, 0)
except CustomError as e:
    print(e)
else:
    print(f"Result: {result}")
finally:
    print("Division operation completed.")
Division by zero is not allowed.
Division operation completed.

- **`CustomError`**: A user-defined exception class.
- **`raise CustomError`**: Raises the custom exception when a division by zero is attempted.

### Conclusion

The `try-except` construct in Python provides a powerful way to handle errors and exceptions gracefully. By catching specific exceptions, using `else` and `finally` clauses, and creating custom exceptions, you can make your code robust, maintainable, and user-friendly. Effective error handling ensures that your applications can handle unexpected situations without crashing and provide meaningful feedback to users and developers.

You may also like