Exception Handling Assignment-2 Week 5.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "cca2125d",
   "metadata": {},
   "source": [
    "## Q1. Explain why we have to use the Exception class while creating a Custom Exception. Note: Here Exception class refers to the base class for all the exceptions."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b57f3743",
   "metadata": {},
   "source": [
    "The reason we use the 'Exception' class as the base class for creating custom exceptions is to ensure that our custom exceptions inherit the essential behavior and attributes of the standard exception hierarchy in Python. The 'Exception' class serves as the parent class for all built-in exceptions, providing common functionality and properties that exceptions should have.\n",
    "\n",
    "By inheriting from the 'Exception' class, our custom exceptions inherit useful methods such as '__str__()' for generating a string representation of the exception, '__repr__()' for generating a detailed representation of the exception, and others that aid in exception handling and debugging.\n",
    "\n",
    "Additionally, by using the 'Exception' class as the base, our custom exceptions become compatible with existing exception handling mechanisms in Python, allowing us to catch and handle them along with other built-in exceptions."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7b40b8be",
   "metadata": {},
   "source": [
    "## Q2. Write a python program to print Python Exception Hierarchy."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5af31e17",
   "metadata": {},
   "source": [
    "Here's a Python program that prints the Python Exception Hierarchy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "732c9f0c",
   "metadata": {},
   "outputs": [],
   "source": [
    "import builtins\n",
    "\n",
    "def print_exception_hierarchy(exception_class, indent=0):\n",
    "    print(' ' * indent + exception_class.__name__)\n",
    "    for subclass in exception_class.__subclasses__():\n",
    "        print_exception_hierarchy(subclass, indent + 4)\n",
    "        \n",
    "print_exception_hierarchy(builtins.BaseException)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7cfc3837",
   "metadata": {},
   "source": [
    "## Q3. What errors are defined in the ArithmeticError class? Explain any two with an example."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "462f32c9",
   "metadata": {},
   "source": [
    "The 'ArithmeticError' class is the base class for exceptions that occur during arithmetic operations. It serves as a parent class for various arithmetic-related exceptions. Two examples of errors defined in the ArithmeticError class are:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "81444cd6",
   "metadata": {},
   "source": [
    "(1) ZeroDivisionError: This error is raised when attempting to divide a number by zero. Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "06138954",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error: Division by zero is not allowed!\n"
     ]
    }
   ],
   "source": [
    "numerator = 10\n",
    "denominator = 0\n",
    "\n",
    "try:\n",
    "    result = numerator / denominator\n",
    "except ZeroDivisionError:\n",
    "    print(\"Error: Division by zero is not allowed!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "44edaefa",
   "metadata": {},
   "source": [
    "(2) OverflowError: This error is raised when an arithmetic operation exceeds the maximum limit that can be represented by a numeric type. Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "b04c474c",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = float('inf')\n",
    "y = x * x  # Performing an operation that results in overflow\n",
    "\n",
    "try:\n",
    "    result = y + 1\n",
    "except OverflowError:\n",
    "    print(\"Error: Arithmetic operation resulted in overflow!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5841242",
   "metadata": {},
   "source": [
    "## Q4. Why LookupError class is used? Explain with an example KeyError and IndexError."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "48903d1e",
   "metadata": {},
   "source": [
    "The 'LookupError' class is the base class for exceptions that occur when an index or key is not found in a sequence or mapping. It provides a common parent class for exceptions like 'KeyError' and 'IndexError'.\n",
    "\n",
    "KeyError: This error is raised when attempting to access a dictionary with a key that does not exist. Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "b9fa57ea",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'key2'\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    d = {\"key\" : \"kunal\", 1 : [2,3,4,5]}\n",
    "    print(d[\"key2\"])\n",
    "except KeyError as e:\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e05651a",
   "metadata": {},
   "source": [
    "IndexError: This error is raised when attempting to access a list or other sequence with an index that is out of range. Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "5af54a9f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "list index out of range\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    l = [2,3,4,5]\n",
    "    print(l[6])\n",
    "except IndexError as e:\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e43a397",
   "metadata": {},
   "source": [
    "## Q5. Explain ImportError. What is ModuleNotFoundError?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f163a16",
   "metadata": {},
   "source": [
    "ImportError: 'ImportError' is raised when an import statement fails to import a module or a name from a module. It occurs when Python encounters difficulties in finding or loading the requested module. Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "e49aedaf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No module named 'kunal'\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    import kunal\n",
    "except ImportError as e:\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e155f370",
   "metadata": {},
   "source": [
    "ModuleNotFoundError: 'ModuleNotFoundError' is a subclass of 'ImportError' that specifically indicates that the requested module could not be found. Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "d596db47",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No module named 'kunal'\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    import kunal\n",
    "except ModuleNotFoundError as e:\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "04981892",
   "metadata": {},
   "source": [
    "## Q6. List down some best practices for exception handling in python."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa06e237",
   "metadata": {},
   "source": [
    "Best practices for exception handling in Python include:\n",
    "\n",
    "(1) Be specific in exception handling: Catch and handle specific exceptions rather than using a generic 'except' block. This allows for targeted error handling and avoids unintentionally hiding other exceptions.\n",
    "\n",
    "(2) Use 'try-except-else' and 'finally' appropriately: Utilize the 'else' block to specify code that should run only if no exceptions occur in the 'try' block. Use the 'finally' block to specify code that must be executed regardless of whether an exception occurred or not, such as resource cleanup.\n",
    "\n",
    "(3) Handle exceptions at an appropriate level: Catch exceptions at the appropriate level of your code to handle them effectively. Avoid catching exceptions too early or letting them propagate too far up the call stack.\n",
    "\n",
    "(4) Provide meaningful error messages: Include informative and descriptive error messages in exception handling code to help with debugging and troubleshooting.\n",
    "\n",
    "(5) Use exception chaining: When catching an exception, consider raising a new exception while preserving the original exception's information. This helps maintain a clear trace of the exception's origin and context.\n",
    "\n",
    "(6) Log exceptions: Consider logging exceptions instead of just printing error messages. Logging provides a more structured and persistent way to record exceptions and aids in debugging and monitoring.\n",
    "\n",
    "(7) Avoid suppressing exceptions: Avoid catching exceptions without taking any action or ignoring them completely. If you catch an exception, make sure to handle it appropriately or re-raise it if necessary.\n",
    "\n",
    "(8) Keep exception handling code minimal: Try to keep exception handling code concise and focused on the specific error handling tasks. Avoid overly complex exception handling logic that might make the code harder to understand and maintain."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}