ExcecptionHandling.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align:center\">\n",
    "    <a href=\"https://skills.network\" target=\"_blank\">\n",
    "    <img src=\"https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/assets/logos/SN_web_lightmode.png\" width=\"200\" alt=\"Skills Network Logo\">\n",
    "    </a>\n",
    "</p>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# **Exception Handling**\n",
    "\n",
    "Estimated time needed: **15** minutes\n",
    "    \n",
    "\n",
    "## Objectives\n",
    "\n",
    "After completing this lab you will be able to:\n",
    "\n",
    "* Understand exceptions    \n",
    "* Handle the exceptions\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Table of Contents\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* What is an Exception?\n",
    "* Exception Handling\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What is an Exception?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this section you will learn about what an exception is and see examples of them.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Definition\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An exception is an error that occurs during the execution of code. This error causes the code to raise an exception and if not prepared to handle it will halt the execution of the code.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Examples\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Run each piece of code and observe the exception raised\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "ename": "ZeroDivisionError",
     "evalue": "division by zero",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mZeroDivisionError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m/tmp/ipykernel_69/2354412189.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;36m1\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mZeroDivisionError\u001b[0m: division by zero"
     ]
    }
   ],
   "source": [
    "1/0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<code>ZeroDivisionError</code> occurs when you try to divide by zero.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'a' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m/tmp/ipykernel_69/1161414849.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0my\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0ma\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m5\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'a' is not defined"
     ]
    }
   ],
   "source": [
    "y = a + 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<code>NameError</code> -- in this case, it means that you tried to use the variable a when it was not defined.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "list index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m/tmp/ipykernel_69/1542938915.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0ma\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0ma\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m: list index out of range"
     ]
    }
   ],
   "source": [
    "a = [1, 2, 3]\n",
    "a[10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<code>IndexError</code> -- in this case, it occured because you tried to access data from a list using an index that does not exist for this list.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are many more exceptions that are built into Python, here is a list of them https://docs.python.org/3/library/exceptions.html\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exception Handling\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this section you will learn how to handle exceptions. You will understand how to make your program perform specified tasks instead of halting code execution when an exception is encountered.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Try Except\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A <code>try except</code> will allow you to execute code that might raise an exception and in the case of any exception or a specific one we can handle or catch the exception and execute specific code. This will allow us to continue the execution of our program even if there is an exception.\n",
    "\n",
    "Python tries to execute the code in the <code>try</code> block. In this case if there is any exception raised by the code in the <code>try</code> block, it will be caught and the code block in the <code>except</code> block will be executed. After that, the code that comes <em>after</em> the try except will be executed.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "ename": "IndentationError",
     "evalue": "expected an indented block (4107979928.py, line 5)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"/tmp/ipykernel_69/4107979928.py\"\u001b[0;36m, line \u001b[0;32m5\u001b[0m\n\u001b[0;31m    except:\u001b[0m\n\u001b[0m         ^\u001b[0m\n\u001b[0;31mIndentationError\u001b[0m\u001b[0;31m:\u001b[0m expected an indented block\n"
     ]
    }
   ],
   "source": [
    "# potential code before try catch\n",
    "\n",
    "try:\n",
    "    # code to try to execute\n",
    "except:\n",
    "    # code to execute if there is an exception\n",
    "    \n",
    "# code that will still execute if there is an exception"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Try Except Example\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example we are trying to divide a number given by the user, save the outcome in the variable <code>a</code>, and then we would like to print the result of the operation. When taking user input and dividing a number by it there are a couple of exceptions that can be raised. For example if we divide by zero. Try running the following block of code with <code>b</code> as a number. An exception will only be raised if <code>b</code> is zero.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Please enter a number to divide a 0\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There was an error\n"
     ]
    }
   ],
   "source": [
    "a = 1\n",
    "\n",
    "try:\n",
    "    b = int(input(\"Please enter a number to divide a\"))\n",
    "    a = a/b\n",
    "    print(\"Success a=\",a)\n",
    "except:\n",
    "    print(\"There was an error\")\n",
    "        \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Try Except Specific\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A specific <code>try except</code> allows you to catch certain exceptions and also execute certain code depending on the exception. This is useful if you do not want to deal with some exceptions and the execution should halt. It can also help you find errors in your code that you might not be aware of. Furthermore, it can help you differentiate responses to different exceptions. In this case, the code after the try except might not run depending on the error.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Do not run, just to illustrate:</b>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# potential code before try catch\n",
    "\n",
    "try:\n",
    "    # code to try to execute\n",
    "except (ZeroDivisionError, NameError):\n",
    "    # code to execute if there is an exception of the given types\n",
    "    \n",
    "# code that will execute if there is no exception or a one that we are handling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# potential code before try catch\n",
    "\n",
    "try:\n",
    "    # code to try to execute\n",
    "except ZeroDivisionError:\n",
    "    # code to execute if there is a ZeroDivisionError\n",
    "except NameError:\n",
    "    # code to execute if there is a NameError\n",
    "    \n",
    "# code that will execute if there is no exception or a one that we are handling"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also have an empty <code>except</code> at the end to catch an unexpected exception:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Do not run, just to illustrate:</b>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# potential code before try catch\n",
    "\n",
    "try:\n",
    "    # code to try to execute\n",
    "except ZeroDivisionError:\n",
    "    # code to execute if there is a ZeroDivisionError\n",
    "except NameError:\n",
    "    # code to execute if there is a NameError\n",
    "except:\n",
    "    # code to execute if ther is any exception\n",
    "    \n",
    "# code that will execute if there is no exception or a one that we are handling"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Try Except Specific Example\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is the same example as above, but now we will add differentiated messages depending on the exception, letting the user know what is wrong with the input.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Please enter a number to divide a d\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You did not provide a number\n"
     ]
    }
   ],
   "source": [
    "a = 1\n",
    "\n",
    "try:\n",
    "    b = int(input(\"Please enter a number to divide a\"))\n",
    "    a = a/b\n",
    "    print(\"Success a=\",a)\n",
    "except ZeroDivisionError:\n",
    "    print(\"The number you provided cant divide 1 because it is 0\")\n",
    "except ValueError:\n",
    "    print(\"You did not provide a number\")\n",
    "except:\n",
    "    print(\"Something went wrong\")\n",
    "        \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Try Except Else and Finally\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<code>else</code> allows one to check if there was no exception when executing the try block. This is useful when we want to execute something only if there were no errors.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>do not run, just to illustrate</b>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# potential code before try catch\n",
    "\n",
    "try:\n",
    "    # code to try to execute\n",
    "except ZeroDivisionError:\n",
    "    # code to execute if there is a ZeroDivisionError\n",
    "except NameError:\n",
    "    # code to execute if there is a NameError\n",
    "except:\n",
    "    # code to execute if ther is any exception\n",
    "else:\n",
    "    # code to execute if there is no exception\n",
    "    \n",
    "# code that will execute if there is no exception or a one that we are handling"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<code>finally</code> allows us to always execute something even if there is an exception or not. This is usually used to signify the end of the try except.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "ename": "IndentationError",
     "evalue": "expected an indented block (2829442695.py, line 5)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"/tmp/ipykernel_69/2829442695.py\"\u001b[0;36m, line \u001b[0;32m5\u001b[0m\n\u001b[0;31m    except ZeroDivisionError:\u001b[0m\n\u001b[0m         ^\u001b[0m\n\u001b[0;31mIndentationError\u001b[0m\u001b[0;31m:\u001b[0m expected an indented block\n"
     ]
    }
   ],
   "source": [
    "# potential code before try catch\n",
    "\n",
    "try:\n",
    "    # code to try to execute\n",
    "except ZeroDivisionError:\n",
    "    # code to execute if there is a ZeroDivisionError\n",
    "except NameError:\n",
    "    # code to execute if there is a NameError\n",
    "except:\n",
    "    # code to execute if ther is any exception\n",
    "else:\n",
    "    # code to execute if there is no exception\n",
    "finally:\n",
    "    # code to execute at the end of the try except no matter what\n",
    "    \n",
    "# code that will execute if there is no exception or a one that we are handling"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Try Except Else and Finally Example\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You might have noticed that even if there is an error the value of <code>a</code> is always printed. Let's use the <code>else</code> and print the value of <code>a</code> only if there is no error.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 1\n",
    "\n",
    "try:\n",
    "    b = int(input(\"Please enter a number to divide a\"))\n",
    "    a = a/b\n",
    "except ZeroDivisionError:\n",
    "    print(\"The number you provided cant divide 1 because it is 0\")\n",
    "except ValueError:\n",
    "    print(\"You did not provide a number\")\n",
    "except:\n",
    "    print(\"Something went wrong\")\n",
    "else:\n",
    "    print(\"success a=\",a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now lets let the user know that we are done processing their answer. Using the <code>finally</code>, let's add a print.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Please enter a number to divide a x\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You did not provide a number\n",
      "Processing Complete\n"
     ]
    }
   ],
   "source": [
    "a = 1\n",
    "\n",
    "try:\n",
    "    b = int(input(\"Please enter a number to divide a\"))\n",
    "    a = a/b\n",
    "except ZeroDivisionError:\n",
    "    print(\"The number you provided cant divide 1 because it is 0\")\n",
    "except ValueError:\n",
    "    print(\"You did not provide a number\")\n",
    "except:\n",
    "    print(\"Something went wrong\")\n",
    "else:\n",
    "    print(\"success a=\",a)\n",
    "finally:\n",
    "    print(\"Processing Complete\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "    \n",
    "    \n",
    "# Practice Exercises \n",
    "\n",
    "</center>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 1: Handling ZeroDivisionError\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Imagine you have two numbers and want to determine what happens when you divide one number by the other. To do this, you need to create a Python function called `safe_divide.` You give this function two numbers, a `'numerator'` and a `'denominator'`. The 'numerator' is the number you want to divide, and the `'denominator'` is the number you want to divide by. Use the user input method of Python to take the values.\n",
    "\n",
    "The function should be able to do the division for you and give you the result. But here's the catch: if you try to divide by zero (which is not allowed in math), the function should be smart enough to catch that and tell you that it's not possible to divide by zero. Instead of showing an error, it should return None, which means 'nothing' or 'no value', and print `\"Error: Cannot divide by Zero.`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the numerator value:- j\n"
     ]
    },
    {
     "ename": "ValueError",
     "evalue": "invalid literal for int() with base 10: 'j'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m/tmp/ipykernel_69/4252492908.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      7\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      8\u001b[0m \u001b[0;31m# Test case\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 9\u001b[0;31m \u001b[0mnumerator\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Enter the numerator value:-\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     10\u001b[0m \u001b[0mdenominator\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Enter the denominator value:-\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     11\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msafe_divide\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnumerator\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mdenominator\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mValueError\u001b[0m: invalid literal for int() with base 10: 'j'"
     ]
    }
   ],
   "source": [
    "def safe_divide(numerator,denominator):\n",
    "    try:\n",
    "        result = numerator / denominator\n",
    "        return result\n",
    "    except ZeroDivisionError:\n",
    "        print(\"Error: Cannot divide by zero.\")\n",
    "        return None\n",
    "# Test case\n",
    "numerator=int(input(\"Enter the numerator value:-\"))\n",
    "denominator=int(input(\"Enter the denominator value:-\"))\n",
    "print(safe_divide(numerator,denominator)) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note:- Practice handling exceptions by trying different input types like using integers, strings, zero, negative values, or other data types.**\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Click here for the hints</summary>\n",
    "\n",
    "```python\n",
    "Follow these: -\n",
    "* Define a function to perform the division and use two arguments.\n",
    "* Use the try-except block to handle ZeroDivisionError.\n",
    "* Return the result of the division if no error occurs.\n",
    "* Return None if division by zero occurs.\n",
    "* take user input for numerator and denominator values.\n",
    "* call and print your function with the user inputs.\n",
    "**Note:- Test with different inputs to validate error handling.**\n",
    "```\n",
    "\n",
    "</details>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "<details><summary>Click here for the solution</summary>\n",
    "\n",
    "```python\n",
    "\n",
    "def safe_divide(numerator,denominator):\n",
    "    try:\n",
    "        result = numerator / denominator\n",
    "        return result\n",
    "    except ZeroDivisionError:\n",
    "        print(\"Error: Cannot divide by zero.\")\n",
    "        return None\n",
    "# Test case\n",
    "numerator=int(input(\"Enter the numerator value:-\"))\n",
    "denominator=int(input(\"Enter the denominator value:-\"))\n",
    "print(safe_divide(numerator,denominator)) \n",
    "```\n",
    "\n",
    "</details>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 2: Handling ValueError\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Imagine you have a number and want to calculate its square root. To do this, you need to create a Python function. You give this function one number, `'number1'`.\n",
    "\n",
    "The function should generate the square root value if you provide a positive integer or float value as input. However, the function should be clever enough to detect the mistake if you enter a negative value. It should kindly inform you with a message saying, `'Invalid input! Please enter a positive integer or a float value.`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter the number:- 7\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Result: 2.6457513110645907\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "def perform_calculation(number1):\n",
    "    try:\n",
    "        result = math.sqrt(number1)\n",
    "        print(f\"Result: {result}\")\n",
    "    except ValueError:\n",
    "        print(\"Error: Invalid input! Please enter a positive integer or a float value.\")\n",
    "# Test case\n",
    "number1=float(input(\"Enter the number:-\"))\n",
    "perform_calculation(number1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note:- Practice handling exceptions by trying different input types like using integers, strings, zero, negative values, or other data types.**\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Click here for the hints</summary>\n",
    "\n",
    "```python\n",
    "Follow these:-\n",
    "* Define a function to perform square root of the argument. \n",
    "* Use try-except block for error handling.\n",
    "* Use `sqrt()` function from the `math` package to calculate the square root. Catch ValueError and display the error message.\"\n",
    "* Take user input of the value, number1. \n",
    "* Test with negative numbers to validate error handling.\n",
    "```\n",
    "\n",
    "</details>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Click here for the solution</summary>\n",
    "\n",
    "```python\n",
    "import math\n",
    "\n",
    "def perform_calculation(number1):\n",
    "    try:\n",
    "        result = math.sqrt(number1)\n",
    "        print(f\"Result: {result}\")\n",
    "    except ValueError:\n",
    "        print(\"Error: Invalid input! Please enter a positive integer or a float value.\")\n",
    "# Test case\n",
    "number1=float(input(\"Enter the number:-\"))\n",
    "perform_calculation(number1)\n",
    "```\n",
    "\n",
    "**Note:- Test with different inputs to validate error handling.**\n",
    "\n",
    "</details>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise 3: Handling Generic Exceptions\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Imagine you have a number and want to perform a complex mathematical task. The calculation requires dividing the value of the input argument `\"num\"` by the difference between `\"num\"` and 5, and the result has to be stored in a variable called `\"result\"`.\n",
    "\n",
    "You have to define a function so that it can perform that complex mathematical task. The function should handle any potential errors that occur during the calculation. To do this, you can use a try-except block. If any exception arises during the calculation, it should catch the error using the generic exception class `\"Exception\" as \"e\"`. When an exception occurs, the function should display `\"An error occurred during calculation.`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a number:  7\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Result: 3.5\n"
     ]
    }
   ],
   "source": [
    "def complex_calculation(num):\n",
    "    try:\n",
    "        result = num / (num - 5)\n",
    "        print (f\"Result: {result}\")\n",
    "    except Exception as e:\n",
    "        print(\"An error occurred during calculation.\")\n",
    "# Test case\n",
    "user_input = float(input(\"Enter a number: \"))\n",
    "complex_calculation(user_input)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note:- Practice handling exceptions by trying different input types like using integers, strings, zero, negative values, or other data types.**\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Click here for the hints</summary>\n",
    "\n",
    "```python\n",
    "Follow these:-\n",
    "* Define a function for the complex calculation and pass any argument.\n",
    "* Use a try-except block for error handling.\n",
    "* Perform the calculation and store the result in \"result.\"\n",
    "* Catch any exceptions using Exception as e.\n",
    "* Display \"An error occurred during calculation.\" when an exception is caught.\n",
    "* take user input\n",
    "* Call the defined function with the user input\n",
    "**Note:- Test with different inputs to validate error handling.**\n",
    "```\n",
    "\n",
    "</details>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Click here for the solution</summary>\n",
    "\n",
    "```python\n",
    "def complex_calculation(num):\n",
    "    try:\n",
    "        result = num / (num - 5)\n",
    "        print (f\"Result: {result}\")\n",
    "    except Exception as e:\n",
    "        print(\"An error occurred during calculation.\")\n",
    "# Test case\n",
    "user_input = float(input(\"Enter a number: \"))\n",
    "complex_calculation(user_input)\n",
    "```\n",
    "\n",
    "</details>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Authors\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href=\"https://www.linkedin.com/in/joseph-s-50398b136/\" target=\"_blank\">Joseph Santarcangelo</a>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <h3 align=\"center\"> © IBM Corporation 2023. All rights reserved. <h3/>\n",
    "\n",
    "<!-- ## Change Log\n",
    "\n",
    "|  Date (YYYY-MM-DD) |  Version | Changed By  |  Change Description |\n",
    "|---|---|---|---|\n",
    "| 2023-11-02 | 2.2 | Abhishek Gagneja | Updated instructions |\n",
    "| 2023-08-01 | 2.1   | Akansha Yadav | Added optional practice section |\n",
    "| 2020-09-02  | 2.0  | Simran | Template updates to the file|\n",
    "|   |   |   |   | --!>\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python",
   "language": "python",
   "name": "conda-env-python-py"
  },
  "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.7.12"
  },
  "prev_pub_hash": "abb9917dfd7a8c219ca8f58ab7002967472e0fef9004ead21334c695bee6a161"
 },
 "nbformat": 4,
 "nbformat_minor": 4
}