Python - Error Handling

Error Handling in Python 

Errors and exceptions are an inevitable part of programming. Python provides robust and flexible mechanisms for handling these issues, allowing developers to write safe and reliable code. Error handling refers to the process of anticipating, detecting, and responding to errors or unexpected situations that occur during the execution of a program. Without proper error handling, programs may crash or behave unpredictably.

Understanding Errors in Python

Python errors can be broadly classified into two types:

• Syntax Errors
• Exceptions (Runtime Errors)

Syntax Errors

These are the most basic type of errors and occur when Python cannot parse the code due to incorrect syntax.

# Syntax Error Example
if True
    print("Missing colon")

Exceptions

Exceptions occur during execution when an operation is syntactically correct but fails. For example, dividing by zero or accessing a non-existent file.

# Runtime Exception
a = 10
b = 0
print(a / b)  # Raises ZeroDivisionError

Common Built-in Exceptions

Python has many built-in exceptions that can be raised under different conditions:

• ZeroDivisionError
• TypeError
• ValueError
• IndexError
• KeyError
• FileNotFoundError
• ImportError

Examples of Common Exceptions

# TypeError
print("2" + 2)

# IndexError
my_list = [1, 2, 3]
print(my_list[5])

# KeyError
my_dict = {'a': 1}
print(my_dict['b'])

Handling Exceptions with try-except

The primary structure for handling exceptions in Python is the try-except block.

try:
    x = int(input("Enter a number: "))
    print("Reciprocal:", 1 / x)
except ZeroDivisionError:
    print("Cannot divide by zero.")
except ValueError:
    print("Invalid input. Please enter a number.")

Generic Exception Handling

try:
    result = 10 / 0
except Exception as e:
    print("An error occurred:", e)

Handling Multiple Exceptions

try:
    value = int("abc")
    result = 10 / value
except ValueError:
    print("Invalid value")
except ZeroDivisionError:
    print("Division by zero")

The else Clause

The else block runs only if no exceptions were raised in the try block.

try:
    num = int(input("Enter a number: "))
    reciprocal = 1 / num
except ZeroDivisionError:
    print("Can't divide by zero.")
else:
    print("Reciprocal is", reciprocal)

The finally Clause

The finally block is executed no matter what—whether an exception occurs or not. It's commonly used for clean-up actions.

try:
    f = open("example.txt", "r")
    content = f.read()
except FileNotFoundError:
    print("File not found.")
finally:
    print("Closing the file (if it was opened).")
    if 'f' in locals():
        f.close()

Raising Exceptions Manually

You can use the raise keyword to throw exceptions manually.

def divide(a, b):
    if b == 0:
        raise ZeroDivisionError("You can't divide by zero!")
    return a / b

print(divide(10, 0))

Raising Custom Exceptions

class CustomError(Exception):
    pass

def do_something(value):
    if value < 0:
        raise CustomError("Negative values are not allowed.")

do_something(-5)

Creating Custom Exception Classes

Custom exceptions allow more specific error handling.

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

def validate_age(age):
    if age < 0:
        raise ValidationError("Age cannot be negative.")

validate_age(-1)

Exception Chaining

Python allows exception chaining using the from keyword.

try:
    x = int("abc")
except ValueError as e:
    raise RuntimeError("Conversion failed") from e

Using Assertions

Assertions are used to check if a condition is true during development. They raise an AssertionError if the condition is false.

x = -1
assert x >= 0, "x must be non-negative"

Best Practices in Error Handling

• Always catch specific exceptions instead of using a generic except block.
• Use finally to release resources like files or network connections.
• Never suppress exceptions silently unless absolutely necessary.
• Use logging instead of print statements for production code.
• Document what exceptions your functions can raise.

Logging Exceptions

Instead of printing errors, you can use the logging module for more robust error tracking.

import logging

logging.basicConfig(level=logging.ERROR)

try:
    1 / 0
except ZeroDivisionError as e:
    logging.error("Exception occurred", exc_info=True)

Real-World Example: File Reader with Error Handling

def read_file(filename):
    try:
        with open(filename, 'r') as file:
            return file.read()
    except FileNotFoundError:
        print("The file does not exist.")
    except IOError:
        print("Error reading the file.")
    finally:
        print("Operation completed.")

read_file("data.txt")

Nested try-except Blocks

You can nest try-except blocks, although too much nesting should be avoided for readability.

try:
    a = int(input("Enter number: "))
    try:
        result = 10 / a
    except ZeroDivisionError:
        print("Cannot divide by zero.")
except ValueError:
    print("Invalid input.")

Silent Failures (Not Recommended)

Avoid writing empty except blocks that silently pass.

try:
    risky_operation()
except:
    pass  # Avoid this practice

Working with Multiple Resources

Use multiple try blocks to handle errors when dealing with multiple resources.

try:
    f1 = open("file1.txt", "r")
    f2 = open("file2.txt", "r")
except FileNotFoundError as e:
    print("File error:", e)
finally:
    if 'f1' in locals(): f1.close()
    if 'f2' in locals(): f2.close()

Handling Exceptions in Loops

data = ["1", "2", "three", "4"]

for item in data:
    try:
        num = int(item)
        print("Converted:", num)
    except ValueError:
        print("Cannot convert", item)

Using try-except with Input Validation

while True:
    try:
        age = int(input("Enter your age: "))
        if age < 0:
            raise ValueError("Age cannot be negative.")
        break
    except ValueError as e:
        print("Invalid input:", e)

Summary

Error handling is one of the most critical aspects of writing reliable Python programs. Python’s try-except-else-finally block structure allows programmers to handle anticipated errors gracefully. Proper error handling helps in debugging, maintaining, and scaling applications effectively.

Here’s a quick recap of what we covered:

• Syntax errors vs runtime exceptions
• try-except, else, and finally constructs
• Raising and creating custom exceptions
• Logging and best practices
• Handling multiple and nested exceptions

By incorporating effective error-handling strategies, Python developers can improve code robustness, handle edge cases smoothly, and prevent their programs from crashing unexpectedly.