Exception handling-1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "c4d1cc70",
   "metadata": {},
   "source": [
    "# Que.1: what is an Exception in python? Write the difference between Exceptions and Syntax errors."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1cf09065",
   "metadata": {},
   "source": [
    "Answer:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af108e52",
   "metadata": {},
   "source": [
    "Exception in Python:\n",
    "\n",
    "An exception in Python is an error or unexpected event that occurs during the execution of a program. When an exception occurs, the normal flow of the program is disrupted. Instead of continuing with the next line of code, Python raises an exception object. This object contains information about the error, including its type and details about where the error occurred in the code.\n",
    "\n",
    "Exceptions can be caused by a variety of reasons, such as dividing by zero, attempting to access a file that doesn't exist, trying to perform an operation on incompatible data types, and more. Python provides mechanisms for handling exceptions using try and except blocks, allowing you to gracefully respond to these unexpected situations and prevent your program from crashing."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b88b1bd9",
   "metadata": {},
   "source": [
    "Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "04585524",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "division by zero\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    a = 100/0\n",
    "except ZeroDivisionError as e:\n",
    "    print(e)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "68a9156d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "invalid literal for int() with base 10: 'praveen'\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    int(\"praveen\")\n",
    "except (ValueError, TypeError) as e:\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "62f3d7b1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "this will catch an error\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    int(\"maurya\")\n",
    "except:\n",
    "    print(\"this will catch an error\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "bf3e04ac",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No module named 'praveen'\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "3.3333333333333335"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "try:\n",
    "    import praveen\n",
    "except ImportError as e:\n",
    "    print(e)\n",
    "    \n",
    "20/6\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "edea6baa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'Key2'\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    d = {\"Key\":\"Praveen\",1:[2,3,4,5]}\n",
    "    print(d[\"Key2\"])\n",
    "except KeyError as e:\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "8e1a8d9c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'str' object has no attribute 'test'\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    \"praveen\".test()\n",
    "except AttributeError as e:\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "f034b87b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "list index out of range\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    l = [1,2,3,4,5,6]\n",
    "    print(l[6])\n",
    "except IndexError as e:\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "139929cf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "unsupported operand type(s) for +: 'int' and 'str'\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    123+\"Praveen\"\n",
    "except TypeError as e:\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "212951fa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Errno 2] No such file or directory: 'test8.txt'\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    with open(\"test8.txt\",'r') as f:\n",
    "        test = f.read()\n",
    "except Exception as e:\n",
    "    print(e)\n",
    "except FileNotFoundError as e:\n",
    "    print(\"test8\",e)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "570979cf",
   "metadata": {},
   "source": [
    "Difference between Exceptions and Syntax Errors"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "047ee25b",
   "metadata": {},
   "source": [
    " differences between exceptions and syntax errors:\n",
    "\n",
    "1. Nature of Error:\n",
    "\n",
    "Exceptions: Occur during the runtime of the program due to unexpected events or errors in logic.\n",
    "Syntax Errors: Occur during code compilation or interpretation due to violations of the Python language rules.\n",
    "2. Timing:\n",
    "\n",
    "Exceptions: Happen while the program is running.\n",
    "Syntax Errors: Detected before the program runs, preventing it from executing.\n",
    "3. Handling:\n",
    "\n",
    "Exceptions: Can be handled using try and except blocks to gracefully respond to errors.\n",
    "Syntax Errors: Must be fixed by correcting the code structure; they cannot be caught or handled at runtime.\n",
    "4. Examples:\n",
    "\n",
    "Exceptions: ZeroDivisionError, TypeError, FileNotFoundError, etc.\n",
    "Syntax Errors: Missing colons, incorrect indentation, misspelled variable names, etc."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cbfc333a",
   "metadata": {},
   "source": [
    "# Que.2: What happens when an exception is not handled? Explain with an example."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "33239a7c",
   "metadata": {},
   "source": [
    "Answer:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9686670c",
   "metadata": {},
   "source": [
    "When an exception is not handled in a program, it typically results in the termination of the program's normal execution flow. In other words, the program will abruptly stop, and the operating system may display an error message to the user. This can lead to an undesirable user experience and may also cause data corruption or loss if the program was in the middle of performing critical operations."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4fb6824",
   "metadata": {},
   "source": [
    "Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "e62fa7e4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error:division by zero\n"
     ]
    },
    {
     "ename": "ZeroDivisionError",
     "evalue": "division by zero",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mZeroDivisionError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_15788\\2888357116.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      8\u001b[0m \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      9\u001b[0m     \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf\"Result:{result}\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 10\u001b[1;33m \u001b[0mresult\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mdivide\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m10\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     11\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf\"Result:{result}\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_15788\\2888357116.py\u001b[0m in \u001b[0;36mdivide\u001b[1;34m(x, y)\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0mdivide\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0my\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m     \u001b[0mresult\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mx\u001b[0m\u001b[1;33m/\u001b[0m\u001b[0my\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      3\u001b[0m     \u001b[1;32mreturn\u001b[0m \u001b[0mresult\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[1;32mtry\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m     \u001b[0mresult\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mdivide\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m10\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mZeroDivisionError\u001b[0m: division by zero"
     ]
    }
   ],
   "source": [
    "def divide (x,y):\n",
    "    result = x/y\n",
    "    return result\n",
    "try:\n",
    "    result = divide(10,0)\n",
    "except ZeroDivisionError as e:\n",
    "    print(f\"Error:{e}\")\n",
    "else:\n",
    "    print(f\"Result:{result}\")\n",
    "result = divide(10,0)\n",
    "print(f\"Result:{result}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bbaa8858",
   "metadata": {},
   "source": [
    "Explain:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f852687b",
   "metadata": {},
   "source": [
    " We have a function divide that divides two numbers.\n",
    " We use a try and except block to catch the ZeroDivisionError that occurs when attempting to divide by zero.\n",
    "If an exception is raised, the program prints an error message and continues to execute. \n",
    "We call the divide function without any exception handling. When we attempt to divide by zero (10 / 0), a ZeroDivisionError occurs, but there is no try and except block to catch it. As a result, the program crashes, and an unhandled exception message is displayed, possibly leading to the termination of the program."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9728b301",
   "metadata": {},
   "source": [
    "# Que.3: Which python statements are used catch and handle exceptions? Explain with an example."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10ee49a0",
   "metadata": {},
   "source": [
    "Answer:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "225f02b0",
   "metadata": {},
   "source": [
    "\n",
    "In Python, the statements used to catch and handle exceptions are try, except, else, and optionally finally. Here's a brief explanation of each:\n",
    "\n",
    "try: The try block is used to enclose the code that might raise an exception. It defines the section of code where exceptions are monitored.\n",
    "\n",
    "except: The except block is used to specify what actions to take when a specific exception occurs within the try block. You can have multiple except blocks to handle different types of exceptions or handle them collectively.\n",
    "\n",
    "else (optional): The else block is executed if no exceptions are raised in the try block. It allows you to specify code that should run only when there are no exceptions. This block is often used for cleanup or additional processing.\n",
    "\n",
    "finally (optional): The finally block, if provided, is executed regardless of whether an exception occurred or not. It's commonly used for cleanup operations that must be performed, such as closing files or releasing resources, regardless of exceptions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "c81dbc9e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error:division by zero\n",
      "division could not be performed.\n",
      "Cleanup complete.\n",
      "Result: 9.333333333333334\n",
      "Cleanup complete.\n"
     ]
    }
   ],
   "source": [
    "def divide(x,y):\n",
    "    try:\n",
    "        result = x/y\n",
    "    except ZeroDivisionError as e:\n",
    "        print(f\"Error:{e}\")\n",
    "        result = None\n",
    "    return result\n",
    "try:\n",
    "    result = divide(10, 0)\n",
    "    if result is not None:\n",
    "        print(f\"Result:{result}\")\n",
    "    else:\n",
    "        print(\"division could not be performed.\")\n",
    "except Exceptioin as e:\n",
    "    print(f\"An unexptected error occurred:{e}\")\n",
    "finally:\n",
    "    print(\"Cleanup complete.\")\n",
    "try:\n",
    "    result = divide(56, 6)\n",
    "    if result is not None:\n",
    "        print(f\"Result: {result}\")\n",
    "    else:\n",
    "        print(\"Division could not be performed.\")\n",
    "except Exception as e:\n",
    "    print(f\"An unexptected error occurred:{e}\")\n",
    "finally:\n",
    "    print(\"Cleanup complete.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ac24ff5",
   "metadata": {},
   "source": [
    "# Que.4: Explain with an example:\n",
    "(a). try and else\n",
    "(b). finally\n",
    "(c). raise"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bbf72806",
   "metadata": {},
   "source": [
    "Answer:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a69f250d",
   "metadata": {},
   "source": [
    "(a) try and else:\n",
    "The try and else blocks are used together to handle exceptions in Python. The code within the try block is monitored for exceptions, and if no exceptions occur, the code within the else block is executed.\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "d4ccb4d9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number: 12\n",
      "Result:0.8333333333333334\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    x = int(input(\"Enter a number: \"))\n",
    "    result = 10/x\n",
    "except ZeroDivisionError as e:\n",
    "    print(e)\n",
    "else:\n",
    "    print(f\"Result:{result}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "81deb6dc",
   "metadata": {},
   "source": [
    "(b) finally:\n",
    "The finally block to ensure that files are properly closed, whether you are reading from or writing to them"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "4d0e6cc1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "File Content: Hello, World!\n",
      "File operations completed successfully.\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    with open(\"exam.txt\", \"w\") as file:\n",
    "        file.write(\"Hello, World!\")\n",
    "\n",
    "    \n",
    "    with open(\"example.txt\", \"r\") as file:\n",
    "        content = file.read()\n",
    "        print(\"File Content:\", content)\n",
    "except FileNotFoundError:\n",
    "    print(\"Error: File not found.\")\n",
    "except IOError as e:\n",
    "    print(f\"Error: {e}\")\n",
    "else:\n",
    "    print(\"File operations completed successfully.\")\n",
    "finally:\n",
    "    file.close()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc04c6c6",
   "metadata": {},
   "source": [
    "In this example:\n",
    "\n",
    "We first open the file in \"write\" mode (\"w\") to write the string \"Hello, World!\" into it using a with statement. This ensures that the file is closed automatically when the block is exited.\n",
    "\n",
    "Then, we open the same file in \"read\" mode (\"r\") to read its content. We use a with statement again for automatic file closure.\n",
    "\n",
    "We handle exceptions such as FileNotFoundError (if the file doesn't exist) and IOError (for other I/O errors) within try and except blocks.\n",
    "\n",
    "Regardless of whether an exception occurs or not, the finally block ensures that the file is closed properly, preventing resource leaks and maintaining the integrity of the file."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4fcd2925",
   "metadata": {},
   "source": [
    "(c) raise:\n",
    "The raise statement is used to raise an exception intentionally in your code. You can use it to create custom exceptions or re-raise exceptions that you've caught. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "a2aeb085",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Caught an exception: Input cannot be negative\n"
     ]
    }
   ],
   "source": [
    "def custom_exception(x):\n",
    "    if x < 0:\n",
    "        raise ValueError(\"Input cannot be negative\")\n",
    "    return x * 2\n",
    "\n",
    "try:\n",
    "    result = custom_exception(-5)\n",
    "except ValueError as e:\n",
    "    print(f\"Caught an exception: {e}\")\n",
    "else:\n",
    "    print(f\"Result: {result}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b128547",
   "metadata": {},
   "source": [
    "In this example:\n",
    "\n",
    "The custom_exception function checks if the input is negative and raises a ValueError with a custom message if it is.\n",
    "When we call the function with -5, it raises a ValueError intentionally.\n",
    "We catch the ValueError in the except block and print a custom error message.\n",
    "If no exception is raised (e.g., when calling the function with 10), the code in the else block prints the result."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bf62193f",
   "metadata": {},
   "source": [
    "# Que.5: What are custom Exceptions in python? why do you need custom Exception? explain with an example.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3914514f",
   "metadata": {},
   "source": [
    "Answer:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a097b4dd",
   "metadata": {},
   "source": [
    "Custom exceptions, also known as user-defined exceptions, are exceptions that you create yourself in Python. While Python provides a wide range of built-in exceptions to cover common error cases, there are situations where you might need to create your own exceptions to handle specific error conditions in your code. Custom exceptions allow you to provide more specific information about the error and can make your code more readable and maintainable."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e6d8a83",
   "metadata": {},
   "source": [
    " Why you might need custom exceptions:\n",
    "\n",
    "Specificity: Custom exceptions allow you to provide more specific error messages and information about the error condition. This helps in debugging and understanding the cause of the error.\n",
    "\n",
    "Modularity: Custom exceptions can be organized into a hierarchy, making it easier to handle different error cases in a structured way. You can define a base custom exception and then create more specific exceptions that inherit from it.\n",
    "\n",
    "Readability: Using custom exceptions in your code can make it more readable and self-explanatory. When someone reads your code, custom exceptions provide clear indications of the expected error conditions.\n",
    "\n",
    "Testing: Custom exceptions make it easier to write unit tests that specifically target different error scenarios, improving the test coverage of your code."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dc2fe7b5",
   "metadata": {},
   "source": [
    " create and use a custom exception in Python:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "a656ff7d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error: Value cannot be negative: -4\n"
     ]
    }
   ],
   "source": [
    "class NegativeValueError(Exception):\n",
    "    def __init__(self, value):\n",
    "        super().__init__(f\"Value cannot be negative: {value}\")\n",
    "        self.value = value\n",
    "\n",
    "def calculate_square_root(x):\n",
    "    if x < 0:\n",
    "        raise NegativeValueError(x)\n",
    "    return x ** 0.5\n",
    "\n",
    "try:\n",
    "    result = calculate_square_root(-4)\n",
    "except NegativeValueError as e:\n",
    "    print(f\"Error: {e}\")\n",
    "else:\n",
    "    print(f\"Result: {result}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7d029667",
   "metadata": {},
   "source": [
    "# Que.6: Create a custom exception class. Use this class to handle an exception."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "534b386d",
   "metadata": {},
   "source": [
    "Answer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "97dfa09b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Custom Exception Caught:Division by zero is not allowed\n"
     ]
    }
   ],
   "source": [
    "class MyCustomException(Exception):\n",
    "    def __init__(self, message:\"A custom occurerd\"):\n",
    "        super().__init__(message)\n",
    "        \n",
    "def divide(a,b):\n",
    "    if b == 0:\n",
    "        raise MyCustomException(\"Division by zero is not allowed\")\n",
    "    return a/b\n",
    "try:\n",
    "    result = divide(10,0)\n",
    "except MyCustomException as e:\n",
    "    print(f\"Custom Exception Caught:{e}\")\n",
    "else:\n",
    "    print(f\"Result:{result}\")\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4dd8942a",
   "metadata": {},
   "source": [
    "In this example:\n",
    "\n",
    "We define a custom exception class named MyCustomException, which inherits from the built-in Exception class. It includes a custom constructor (__init__) that allows us to provide a custom error message when an instance of this exception is raised. By default, it provides a generic message.\n",
    "\n",
    "The divide function attempts to divide two numbers a and b. If b is zero, it raises the custom MyCustomException with a specific error message.\n",
    "\n",
    "In the try block, we call the divide function with 10 and 0, which causes the custom exception to be raised.\n",
    "\n",
    "In the except block, we catch the MyCustomException and print the custom error message associated with it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ce2e2290",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}