Exception Handling

Exception handling in Python allows programmers to anticipate and manage runtime errors, ensuring that the program doesn't crash unexpectedly. Instead of halting the program when an error occurs, exception handling allows you to "catch" errors and handle them gracefully.

What are Exceptions?

Exceptions are errors that occur during the execution of a program. When an error occurs, Python stops the normal flow and looks for code to handle the exception.

Types of Errors and Exceptions

➤ 1. Syntax Errors:

These errors occur when the code does not conform to the syntax rules of Python. These errors are detected before the program runs (during parsing).

if True
    print("Hello")

➤ 2. Runtime Errors (Exceptions):

These errors occur while the program is running. They can be caused by operations like division by zero, accessing a non-existent index, or invalid type conversions.

x = 10 / 0  # ZeroDivisionError

➤ 3. Logical Errors:

• These are mistakes in logic that don’t cause the program to crash but lead to incorrect results.
• Example:

a = 5
b = 10
result = a * b  # This is correct, but suppose you meant to do addition.

🔧 Built-in Exceptions:

Python provides built-in exceptions for common errors, such as ValueError, TypeError, IndexError, FileNotFoundError, etc.

🔚 Using try, except, else, and finally

In Python, the basic structure of exception handling is as follows. The finally block is always executed, even if an exception is raised.

try:
    # Code that may raise an exception
except ExceptionType as e:
    # Code to handle the exception
else:
    # Code that runs if no exception occurs
finally:
    # Code that runs no matter what (can be used for cleanup)

🔍 The try and except Block

• The try block contains the code that might throw an exception. If an exception occurs, the code inside the except block is executed.

try:
    x = 10 / 0  # This will raise a ZeroDivisionError
except ZeroDivisionError:
    print("Cannot divide by zero!")

else

• The else block runs if no exception is raised inside the try block. It's typically used for code that should run only if no errors occurred.

try:
    x = 10 / 2  # No error here
except ZeroDivisionError:
    print("Cannot divide by zero!")
else:
    print("Division was successful!")

finally

• The finally block always runs, whether or not an exception was raised. It is commonly used for cleanup operations like closing files or releasing resources.

try:
    file = open("sample.txt", "r")
    data = file.read()
except FileNotFoundError:
    print("File not found!")
finally:
    file.close()  # Ensure the file is closed no matter what

👤 Custom/User-Defined Exceptions

Create your own exception classes by inheriting from Exception.

class MyError(Exception):
    pass

try:
    raise MyError("Something went wrong!")
except MyError as e:
    print(e)

---

⚠️ Warnings

Use the warnings module to issue alerts that aren't fatal errors.

import warnings

warnings.warn("This is a warning message", UserWarning)

Example code: with all parts together:

try:
    number = int(input("Enter a number: "))
    result = 10 / number
except ValueError:
    print("That's not a valid number!")
except ZeroDivisionError:
    print("You can't divide by zero!")
else:
    print(f"Result is {result}")
finally:
    print("Execution completed.")

In this example:

• If the user enters a non-numeric value, a ValueError will be raised, and the corresponding message will be printed.
• If the user enters 0, a ZeroDivisionError will occur.
• If no exception is raised, the division result will be printed.
• Regardless of the outcome, the finally block will always print "Execution completed."

Summary of Key Points:

• try: Code that might raise an exception.
• except: Code to handle the exception.
• else: Code that runs when no exception occurs.
• finally: Code that always runs, typically for cleanup purposes.

This structure helps make Python programs more robust and resilient to errors.