पायथन में अपवाद प्रबंधन (Exception Handling)

In software development, anomalous execution events are divided into two categories:

• Syntax Errors (Parsing Errors): Violations of Python's formal grammar (e.g., missing colons, mismatched parentheses, invalid indentation). Caught by the tokenizer/parser *prior* to program execution. Execution cannot begin until all syntax errors are resolved.
• Exceptions (Runtime Errors): Disruptive events that occur *during* program execution when syntactically valid code attempts an illegal operation (e.g., dividing by zero, opening a non-existent file, indexing an empty list). If not caught by an exception handler, the Python interpreter halts execution and prints a diagnostic Traceback.

The Python Built-in Exception Hierarchy

All Python exceptions are classes organized in a strict object-oriented inheritance tree rooted at BaseException:

BaseException
 ├── SystemExit (Triggered by sys.exit())
 ├── KeyboardInterrupt (Triggered by Ctrl+C in terminal)
 └── Exception (Root superclass for all non-fatal application exceptions)
      ├── ArithmeticError
      │    ├── ZeroDivisionError (e.g., 10 / 0)
      │    └── OverflowError (Calculation exceeds floating-point limits)
      ├── LookupError
      │    ├── IndexError (Sequence index out of range)
      │    └── KeyError (Dictionary key not found)
      ├── ValueError (Correct type, but invalid value, e.g., int("abc"))
      ├── TypeError (Operation applied to inappropriate data type)
      ├── NameError (Identifier not found in any LEGB scope)
      └── OSError
           ├── FileNotFoundError (File path does not exist)
           └── PermissionError (Insufficient OS file access rights)

Python provides a 4-clause structured mechanism to anticipate and handle runtime exceptions gracefully:

try:
    # 1. Critical code that might raise an exception
    num = int(input("Enter numerator: "))
    den = int(input("Enter denominator: "))
    result = num / den
except ZeroDivisionError as zde:
    # 2. Handles division by zero specifically
    print(f"Math Error: Cannot divide by zero! ({zde})")
except ValueError as ve:
    # 3. Handles invalid alphanumeric conversion
    print(f"Input Error: Please enter valid integer digits only! ({ve})")
except Exception as e:
    # 4. Fallback handler for any other unexpected Exception subclass
    print(f"Unexpected Error occurred: {type(e).name} - {e}")
else:
    # 5. Executes ONLY if the try block completed with ZERO exceptions!
    print(f"Success! Calculation result = {result:.4f}")
finally:
    # 6. GUARANTEED EXECUTION! Always runs, whether an error occurred or not!
    print("Cleanup: Calculation transaction completed. Releasing locks.")

The `finally` Block Guarantee

The `finally` clause is critical for resource management (closing files, releasing database locks, terminating network sockets). It executes under all conditions—even if the `try` block executes an abrupt `return`, `break`, or raises an unhandled fatal error!

A. The `raise` Statement

You can deliberately trigger an exception when program logic detects an illegal business state using the `raise` keyword:

def withdraw_money(balance, amount):
    if amount <= 0:
        raise ValueError("Withdrawal amount must be strictly positive!")
    if amount > balance:
        raise ValueError(f"Insufficient funds! Requested {amount}, Available {balance}")
    return balance - amount

B. Defensive Programming with `assert`

The `assert condition, "Error Message"` statement tests an internal diagnostic assumption. If the condition is `False`, Python immediately raises an AssertionError:

def calculate_discount(price, discount_percent):
    assert 0 <= discount_percent <= 100, "Discount percentage must be between 0 and 100!"
    return price * (1 - discount_percent / 100)

In enterprise software engineering, standard built-in exceptions like `ValueError` are too generic to describe specific business domain failures. You create Custom Exceptions by defining a new class that inherits directly from Python's built-in Exception class:

# 1. Define custom domain exceptions inheriting from Exception:
class InvalidAgeError(Exception):
    """Raised when an applicant's age is outside legal limits."""
    pass

class UnderageVotingError(InvalidAgeError):
    """Raised when a citizen attempts voting under age 18."""
    def init(self, age, message="Citizen is below legal voting age (18)."):
        self.age = age
        self.message = f"{message} Current age: {age}"
        super().init(self.message)

# 2. Utilize the custom exception in business logic:
def cast_vote(citizen_name, age):
    if age < 0 or age > 120:
        raise InvalidAgeError(f"Absurd age entered: {age}")
    if age < 18:
        raise UnderageVotingError(age)
    print(f"Vote successfully recorded for {citizen_name}!")

try:
    cast_vote("Rohan", 16)
except UnderageVotingError as uve:
    print(f"Election Commission Alert: {uve}")