07-Exception_handling/03_handling_exceptions_using_try-except_block.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "21775a1c",
   "metadata": {},
   "source": [
    "# Module 7: Exception handling\n",
    "\n",
    "## Part 3: Handling exceptions using try-except blocks\n",
    "\n",
    "In Python, you can handle exceptions using the try-except block. This construct allows you to catch and handle specific exceptions\n",
    "that may occur during the execution of your code. By handling exceptions, you can prevent your program from crashing and provide \n",
    "alternative actions or error messages to users.\n",
    "\n",
    "### 3.1. Syntax of the try-except block\n",
    "\n",
    "The try-except block consists of the try block, where you place the code that might raise an exception, and one or more except \n",
    "blocks that define how to handle specific exceptions. \n",
    "\n",
    "Here's the basic syntax:\n",
    "\n",
    "```python\n",
    "try:\n",
    "    # Code that might raise an exception\n",
    "    # ...\n",
    "except ExceptionType:\n",
    "    # Exception handling code\n",
    "    # ...\n",
    "```\n",
    "\n",
    "In the except block, you specify the type of exception you want to handle by mentioning the ExceptionType. If an exception of that \n",
    "type occurs in the try block, the corresponding except block is executed. \n",
    "\n",
    "For example, if you want to handle a ValueError, you can write the following code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a4f9ee41",
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    age = int(input(\"Enter your age: \"))\n",
    "except ValueError:\n",
    "    print(\"Invalid age. Please enter a valid integer.\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "d9a32061",
   "metadata": {},
   "source": [
    "In the above example, if the user enters a non-integer value for the age, a ValueError will be raised, and the corresponding except\n",
    "ValueError block will be executed, displaying the error message.\n",
    "\n",
    "### 3.2. Handling multiple exceptions\n",
    "\n",
    "You can handle multiple exceptions by using multiple except blocks. Each except block can handle a specific type of exception. \n",
    "The first except block that matches the raised exception type will be executed, and subsequent except blocks will be skipped.\n",
    "\n",
    "```python\n",
    " try:\n",
    "    # Code that might raise an exception\n",
    "    # ...\n",
    "except ValueError:\n",
    "    # Exception handling code for ValueError\n",
    "    # ...\n",
    "except TypeError:\n",
    "    # Exception handling code for TypeError\n",
    "    # ...\n",
    "```\n",
    "\n",
    "In the above example, if a ValueError occurs, the first except ValueError block will be executed. If a TypeError occurs, the second \n",
    "except TypeError block will be executed.\n",
    "\n",
    "For example, if you want to handle multiple exceptions, you can write the following code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3bcba3ea",
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    age = int(input(\"Enter your age: \"))\n",
    "    result = 10 / age\n",
    "except ValueError:\n",
    "    print(\"Invalid age. Please enter a valid integer.\")\n",
    "except ZeroDivisionError:\n",
    "    print(\"Error: Cannot divide by zero.\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "ca17f1f2",
   "metadata": {},
   "source": [
    "In this example, we added another except block to handle the ZeroDivisionError exception. If the user enters an age of 0, a ZeroDivisionError will occur when trying to calculate 10 / age. The second except block will catch this specific exception and display an appropriate error message.\n",
    "\n",
    "### 3.3. Handling multiple exceptions with a single except block\n",
    "\n",
    "If you want to handle multiple exceptions with the same handling code, you can specify multiple exception types within a single except\n",
    "block. This is useful when you want to provide the same error handling logic for different types of exceptions.\n",
    "\n",
    "```python\n",
    "try:\n",
    "    # Code that might raise an exception\n",
    "    # ...\n",
    "except (ExceptionType1, ExceptionType2):\n",
    "    # Exception handling code for ExceptionType1 and ExceptionType2\n",
    "    # ...\n",
    "```\n",
    "\n",
    "Using the same example, if you want to handle exceptions on the same except block, you can write the following code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9d84e730",
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    age = int(input(\"Enter your age: \"))\n",
    "    result = 10 / age\n",
    "except (ValueError, ZeroDivisionError):\n",
    "    print(\"Invalid age or division by zero.\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "bfbbc7a1",
   "metadata": {},
   "source": [
    "In this example, we use a single except block followed by parentheses to define a tuple of exception types (ValueError, ZeroDivisionError). This allows us to handle both ValueError and ZeroDivisionError exceptions in the same block. If either of these exceptions occurs, the code inside the except block will be executed, and the corresponding error message will be displayed.\n",
    "\n",
    "### 3.4. Handling all exceptions\n",
    "\n",
    "To handle all other exceptions that are not explicitly caught by specific except blocks, you can use a generic except block \n",
    "without specifying the exception type. However, it is generally recommended to catch specific exceptions whenever possible \n",
    "to provide more meaningful error handling. \n",
    "\n",
    "Here's an example of a generic except block:\n",
    "\n",
    "```python\n",
    "try:\n",
    "    # Code that might raise an exception\n",
    "    # ...\n",
    "except:\n",
    "    # Generic exception handling code\n",
    "    # ...\n",
    "```\n",
    "\n",
    "In the above example, if any exception occurs that is not caught by previous except blocks, the generic except block will be executed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4b07325b",
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    age = int(input(\"Enter your age: \"))\n",
    "    result = 10 / age\n",
    "except Exception as e:\n",
    "    print(\"An error occurred:\", str(e))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "74fffe31",
   "metadata": {},
   "source": [
    "In this example, we use a single except block without specifying any particular exception type. This allows us to handle all exceptions that may occur within the try block. \n",
    "\n",
    "The Exception class serves as a base class for all built-in exceptions in Python.\n",
    "\n",
    "### 3.5. Handling specific exceptions in a hierarchical manner\n",
    "\n",
    "When handling specific exceptions, it's important to consider the exception hierarchy. Python has a built-in hierarchy of exceptions,\n",
    " where some exceptions are subclasses of others. You can handle exceptions in a hierarchical manner by starting with the most specific\n",
    "  exceptions and moving towards more general ones.\n",
    "\n",
    "For example, if you want to handle a specific exception like FileNotFoundError and its parent exception IOError, you can write \n",
    "the code as follows:\n",
    "\n",
    "```python\n",
    "try:\n",
    "    # Code that might raise an exception\n",
    "    # ...\n",
    "except FileNotFoundError:\n",
    "    # Exception handling code for FileNotFoundError\n",
    "    # ...\n",
    "except IOError:\n",
    "    # Exception handling code for IOError\n",
    "    # ...\n",
    "```\n",
    "\n",
    "In the above example, if a FileNotFoundError occurs, the first except FileNotFoundError block will be executed. If an IOError\n",
    "occurs that is not a FileNotFoundError, the second except IOError block will be executed.\n",
    "\n",
    "Here's an example that demonstrates hierarchical exception handling:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c9af336b",
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    # Code that may raise exceptions\n",
    "    x = int(input(\"Enter a number: \"))\n",
    "    y = int(input(\"Enter another number: \"))\n",
    "    result = x / y\n",
    "except ValueError:\n",
    "    # Handle specific exception types first\n",
    "    print(\"Invalid input. Please enter valid integers.\")\n",
    "except ZeroDivisionError:\n",
    "    # Handle more specific exception types next\n",
    "    print(\"Error: Cannot divide by zero.\")\n",
    "except Exception:\n",
    "    # Handle more general exception types last\n",
    "    print(\"An error occurred.\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "88f5847b",
   "metadata": {},
   "source": [
    "First, we handle the ValueError exception, which occurs when the user enters a non-integer value. We provide an appropriate error message for this specific exception type.\n",
    "\n",
    "Next, we handle the ZeroDivisionError exception, which occurs when the user enters 0 as the second number for division. Again, we display a specific error message for this exception type.\n",
    "\n",
    "Lastly, we have a more general Exception block to handle any remaining exceptions that were not caught by the specific exception blocks. This acts as a catch-all block to handle unexpected or unknown exceptions.\n",
    "\n",
    "By organizing the exception handling in a hierarchical manner, we can address specific exception types first and gradually handle more general exception types if needed. This approach allows for more targeted and precise exception handling based on the specific error scenarios.\n",
    "\n",
    "### 3.6. The else block\n",
    "\n",
    "In addition to the try and except blocks, you can include an optional else block after all the except blocks. The code inside the\n",
    "else block is executed if no exceptions occur in the try block. It is often used to perform cleanup or additional actions that \n",
    "should only happen when no exceptions are raised.\n",
    "\n",
    "```python\n",
    "try:\n",
    "    # Code that might raise an exception\n",
    "    # ...\n",
    "except ExceptionType:\n",
    "    # Exception handling code\n",
    "    # ...\n",
    "else:\n",
    "    # Code that executes if no exceptions occur\n",
    "    # ...\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "68243464",
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    # Code that may raise exceptions\n",
    "    x = int(input(\"Enter a number: \"))\n",
    "    y = int(input(\"Enter another number: \"))\n",
    "    result = x / y\n",
    "except ValueError:\n",
    "    # Handle specific exception types first\n",
    "    print(\"Invalid input. Please enter valid integers.\")\n",
    "except ZeroDivisionError:\n",
    "    # Handle more specific exception types next\n",
    "    print(\"Error: Cannot divide by zero.\")\n",
    "except Exception:\n",
    "    # Handle more general exception types last\n",
    "    print(\"An error occurred.\")\n",
    "else:\n",
    "    # Code to execute if no exception occurs\n",
    "    print(\"Division result:\", result)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "c7944f0c",
   "metadata": {},
   "source": [
    "In this updated code, we've added an else block after the except blocks. The code inside the else block will only execute if no exception occurs in the try block. In this case, it simply displays the division result.\n",
    "\n",
    "The else block provides a way to separate the code that should run when no exception occurs, making the code more readable and clear. It is especially useful when we want to perform certain actions only if the code in the try block executes successfully.\n",
    "\n",
    "Note that the else block is optional and can be omitted if there is no specific action to be taken when no exception occurs.\n",
    "\n",
    "### 3.7. The finally block\n",
    "\n",
    "Another optional block that can be used with the try-except block is the finally block. The code inside the finally block is \n",
    "always executed, regardless of whether an exception was raised or not. It is commonly used to release resources, close files, \n",
    "or perform other cleanup actions.\n",
    "\n",
    "```python\n",
    "try:\n",
    "    # Code that might raise an exception\n",
    "    # ...\n",
    "except ExceptionType:\n",
    "    # Exception handling code\n",
    "    # ...\n",
    "finally:\n",
    "    # Code that always executes\n",
    "    # ...\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ed8ebc9b",
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    # Code that may raise exceptions\n",
    "    x = int(input(\"Enter a number: \"))\n",
    "    y = int(input(\"Enter another number: \"))\n",
    "    result = x / y\n",
    "except ValueError:\n",
    "    # Handle specific exception types first\n",
    "    print(\"Invalid input. Please enter valid integers.\")\n",
    "except ZeroDivisionError:\n",
    "    # Handle more specific exception types next\n",
    "    print(\"Error: Cannot divide by zero.\")\n",
    "except Exception:\n",
    "    # Handle more general exception types last\n",
    "    print(\"An error occurred.\")\n",
    "else:\n",
    "    # Code to execute if no exception occurs\n",
    "    print(\"Division result:\", result)\n",
    "finally:\n",
    "    # Code that will always be executed, regardless of exceptions\n",
    "    print(\"Finally block executed.\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "id": "10e4f2de",
   "metadata": {},
   "source": [
    "In this updated code, we've added a finally block after the except and else blocks. The code inside the finally block will always execute, regardless of whether an exception occurred or not.\n",
    "\n",
    "The finally block is useful for cleaning up resources or performing actions that should occur regardless of the outcome of the code in the try block. It ensures that certain code is executed, even if an exception is raised and caught.\n",
    "\n",
    "In this example, the finally block simply prints a message indicating that it has been executed.\n",
    "\n",
    "Note that the finally block is optional, and it can be omitted if there is no specific cleanup or action needed to be performed regardless of exceptions.\n",
    "\n",
    "### 3.8. Summary\n",
    "\n",
    "Handling exceptions using the try-except block is a powerful technique in Python to deal with potential errors and ensure the\n",
    "smooth execution of your code. By catching and handling exceptions, you can provide better error messages, recover from unexpected situations, and prevent your program from crashing.\n",
    "\n",
    "Catching specific exceptions allows you to handle different types of exceptions differently in your code. By specifying \n",
    "the exception type in the except block, you can provide customized error handling for specific scenarios. You can catch a single\n",
    "specific exception, handle multiple specific exceptions, or handle multiple exceptions with a single except block. \n",
    "It's important to consider the exception hierarchy and handle exceptions in a hierarchical manner to ensure that exceptions \n",
    "are handled appropriately."
   ]
  }
 ],
 "metadata": {
  "jupytext": {
   "cell_metadata_filter": "-all",
   "main_language": "python",
   "notebook_metadata_filter": "-all"
  },
  "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.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}