Feb_12th_assignment.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Answer 1\n",
    "\n",
    "An exception in Python is an error that occurs during the execution of a program. When an error occurs, Python raises an exception which is a special object that represents the error.\n",
    "\n",
    "There are several types of exceptions in Python, including:\n",
    "\n",
    "SyntaxError: Raised when there is an error in the syntax of a program.\n",
    "\n",
    "TypeError: Raised when an operation or function is applied to an object of inappropriate type.\n",
    "\n",
    "ValueError: Raised when a built-in operation or function receives an argument that has the right type but an inappropriate value.\n",
    "\n",
    "NameError: Raised when a local or global name is not found.\n",
    "\n",
    "IndexError: Raised when an index is out of range.\n",
    "\n",
    "KeyError: Raised when a key is not found in a dictionary.\n",
    "\n",
    "AttributeError: Raised when an attribute reference or assignment fails.\n",
    "\n",
    "ZeroDivisionError: Raised when the second argument of a division or modulo operation is zero.\n",
    "\n",
    "The main difference between exceptions and syntax errors is that syntax errors occur when there is a problem with the code itself, while exceptions occur during the execution of the code. Exceptions can occur even if the code is syntactically correct, but there is a problem with the logic or data being processed.\n",
    "\n",
    "Another difference between exceptions and syntax errors is how they are handled. Syntax errors must be fixed by changing the code, while exceptions can be caught and handled using exception handling mechanisms such as try-except blocks. In this way, exceptions provide a way for a program to gracefully handle errors and continue executing, rather than simply crashing."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Answer 2\n",
    "\n",
    "When an exception is not handled in a Python program, it will result in the program terminating abruptly and displaying an error message that describes the exception. This can cause unexpected behavior and can make it difficult to determine the cause of the error.\n",
    "\n",
    "Here is an example of what happens when an exception is not handled:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example code that raises a NameError exception\n",
    "\n",
    "print(my_variable) # Raises a NameError because my_variable is not defined"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, the program tries to print the value of a variable called my_variable. However, my_variable is not defined in the program, so a NameError exception is raised.\n",
    "\n",
    "If the exception is not handled using a try-except block or other exception handling mechanism, the program will terminate with an error message like this:\n",
    "Traceback (most recent call last):\n",
    "  \n",
    "  File \"example.py\", line 2, in <module>\n",
    "    \n",
    "    print(my_variable)\n",
    "\n",
    "    NameError: name 'my_variable' is not defined\n",
    "\n",
    "    \n",
    "This error message indicates that a NameError exception was raised on line 2 of the program because the name my_variable is not defined. Since the exception was not handled, the program terminated abruptly.\n",
    "\n",
    "To prevent this kind of unexpected termination, it is a good practice to always include exception handling in your Python programs. This allows you to gracefully handle errors and continue executing the program, even when unexpected exceptions occur."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Answer 3\n",
    "\n",
    "To catch and handle exceptions in Python, you can use a try-except block. A try-except block allows you to catch and handle exceptions that occur during the execution of a program. The basic syntax of a try-except block is as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'try:\\n    # code that may raise an exception\\nexcept ExceptionType:\\n    # code to handle the exception'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "try:\n",
    "    # code that may raise an exception\n",
    "except ExceptionType:\n",
    "    # code to handle the exception"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this syntax, you include the code that may raise an exception in the try block. If an exception occurs, Python will immediately jump to the except block and execute the code inside it. The ExceptionType parameter specifies the type of exception to catch. If the exception that occurs matches the specified type, the except block will be executed.\n",
    "\n",
    "Here are some examples of using try-except blocks to catch and handle exceptions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Variable is not defined\n",
      "Cannot divide by zero\n",
      "Invalid input\n"
     ]
    }
   ],
   "source": [
    "# Example 1: Handling a NameError exception\n",
    "try:\n",
    "    print(my_variable) # Raises a NameError because my_variable is not defined\n",
    "except NameError:\n",
    "    print(\"Variable is not defined\")\n",
    "\n",
    "# Output: Variable is not defined\n",
    "\n",
    "# Example 2: Handling a ZeroDivisionError exception\n",
    "try:\n",
    "    result = 10 / 0 # Raises a ZeroDivisionError\n",
    "except ZeroDivisionError:\n",
    "    print(\"Cannot divide by zero\")\n",
    "\n",
    "# Output: Cannot divide by zero\n",
    "\n",
    "# Example 3: Handling multiple exception types\n",
    "try:\n",
    "    result = int(\"not a number\") # Raises a ValueError\n",
    "except ValueError:\n",
    "    print(\"Invalid input\")\n",
    "except TypeError:\n",
    "    print(\"Incorrect type\")\n",
    "\n",
    "# Output: Invalid input\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Example 1, we use a try-except block to catch a NameError exception that is raised when an undefined variable is used. The except block prints a message indicating that the variable is not defined.\n",
    "\n",
    "In Example 2, we use a try-except block to catch a ZeroDivisionError exception that is raised when we attempt to divide by zero. The except block prints a message indicating that division by zero is not allowed.\n",
    "\n",
    "In Example 3, we use a try-except block to catch a ValueError exception that is raised when we try to convert a string that cannot be converted to an integer. We also demonstrate that we can handle multiple exception types in the same try-except block. If the exception type matches the first except block, it will be handled there. Otherwise, Python will try to match the exception with the next except block."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Answer 4\n",
    "\n",
    "try and else\n",
    "The else block is used to specify code that should be executed only if no exception is raised in the try block. Here's an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cannot divide by zero\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    x = 1 / 0\n",
    "except ZeroDivisionError:\n",
    "    print(\"Cannot divide by zero\")\n",
    "else:\n",
    "    print(\"The result is:\", x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, the try block raises a ZeroDivisionError, so the except block is executed and \"Cannot divide by zero\" is printed. Since there is no else block, the program terminates at this point.\n",
    "\n",
    "However, if we change the example to:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The result is: 0.5\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    x = 1 / 2\n",
    "except ZeroDivisionError:\n",
    "    print(\"Cannot divide by zero\")\n",
    "else:\n",
    "    print(\"The result is:\", x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this case, the try block does not raise an exception, so the else block is executed and \"The result is: 0.5\" is printed.\n",
    "\n",
    "finally\n",
    "The finally block is used to specify code that should be executed regardless of whether an exception is raised or not. Here's an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    f = open(\"myfile.txt\", \"r\")\n",
    "    print(f.read())\n",
    "except FileNotFoundError:\n",
    "    print(\"File not found\")\n",
    "finally:\n",
    "    f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, the try block opens a file for reading and reads its contents. If the file is not found, the except block is executed and \"File not found\" is printed. Regardless of whether an exception is raised or not, the finally block is executed to close the file.\n",
    "\n",
    "raise\n",
    "The raise statement is used to raise an exception manually. Here's an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = -1\n",
    "if x < 0:\n",
    "    raise ValueError(\"x cannot be negative\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, the program checks if x is negative. If it is, the raise statement raises a ValueError exception with the message \"x cannot be negative\". This will cause the program to terminate unless the exception is caught and handled using a try-except block."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Answer 5\n",
    "\n",
    "Custom exceptions in Python are exceptions that you define yourself. They are used to create more specific and descriptive exceptions that are tailored to your program's needs. You can use them to provide more detailed information about the type of error that occurred or to add additional functionality to the exception.\n",
    "\n",
    "You might need to create custom exceptions if the built-in exceptions don't provide enough detail for your use case. For example, if you are building a program that deals with network connectivity, you might want to define a custom NetworkError exception that provides more information about the type of network error that occurred, such as a DNS resolution error or a connection timeout.\n",
    "\n",
    "Here's an example of how to define and use a custom exception in Python:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x cannot be negative\n"
     ]
    }
   ],
   "source": [
    "class MyException(Exception):\n",
    "    def __init__(self, message):\n",
    "        self.message = message\n",
    "\n",
    "def my_function(x):\n",
    "    if x < 0:\n",
    "        raise MyException(\"x cannot be negative\")\n",
    "    else:\n",
    "        print(\"x is:\", x)\n",
    "\n",
    "try:\n",
    "    my_function(-1)\n",
    "except MyException as e:\n",
    "    print(e.message)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, we define a custom MyException exception by subclassing the built-in Exception class. We provide an __init__ method to initialize the exception with a custom message.\n",
    "\n",
    "We also define a function my_function that takes a parameter x. If x is negative, the function raises a MyException with the message \"x cannot be negative\". Otherwise, it prints the value of x.\n",
    "\n",
    "Finally, we use a try-except block to call my_function with a negative value of x. Since this raises a MyException, the except block is executed and the message \"x cannot be negative\" is printed.\n",
    "\n",
    "In this way, we can use custom exceptions to make our code more descriptive and to provide more detailed information about the errors that occur in our programs."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Answer 6\n",
    "\n",
    "Here's an example of how to create a custom exception class in Python and use it to handle an exception:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number cannot be negative\n"
     ]
    }
   ],
   "source": [
    "class NegativeNumberException(Exception):\n",
    "    def __init__(self, message):\n",
    "        self.message = message\n",
    "\n",
    "def process_input(num):\n",
    "    if num < 0:\n",
    "        raise NegativeNumberException(\"Number cannot be negative\")\n",
    "    else:\n",
    "        print(\"The number is:\", num)\n",
    "\n",
    "try:\n",
    "    process_input(-5)\n",
    "except NegativeNumberException as e:\n",
    "    print(e.message)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, we define a custom exception class NegativeNumberException by subclassing the built-in Exception class. We provide an __init__ method to initialize the exception with a custom message.\n",
    "\n",
    "We also define a function process_input that takes a parameter num. If num is negative, the function raises a NegativeNumberException with the message \"Number cannot be negative\". Otherwise, it prints the value of num.\n",
    "\n",
    "Finally, we use a try-except block to call process_input with a negative value of num. Since this raises a NegativeNumberException, the except block is executed and the message \"Number cannot be negative\" is printed.\n",
    "\n",
    "In this way, we can use custom exceptions to make our code more descriptive and to provide more detailed information about the errors that occur in our programs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}