18th_June.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyN5fwj+ZyoSVyvOkNN26Pkr",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/PritamBadwar/assignments_fsds/blob/main/18th_June.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Q1.What is the role of the 'else' block in a try-except statement? Provide an example scenario where it would be useful.\n",
        "Ans:\n",
        "  - It is an optional block, gets executed when no exception occurs\n",
        "  - It helps to seperate code execution from error handling"
      ],
      "metadata": {
        "id": "WKUIgfkN_5eB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "try:\n",
        "  #code that may raise exception\n",
        "  num1 = int(input(\"Enter the first number: \"))\n",
        "  num2 = int(input(\"Enter the second number: \"))\n",
        "  result = num1 / num2\n",
        "except ZeroDivisionError:\n",
        "  #exception handling code\n",
        "  print(\"Error: Division by zero is not allowed.\")\n",
        "else:\n",
        "  #code to be executed when no exception occurs\n",
        "  print(\"result is: \", result)"
      ],
      "metadata": {
        "id": "MdEAfOqcrZJ0",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2182f935-d89e-4595-bf8c-4115fbdc8b8a"
      },
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter the first number: 4\n",
            "Enter the second number: 2\n",
            "result is:  2.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Q2.Can a try-except block be nested inside another try-except block? Explain with an example."
      ],
      "metadata": {
        "id": "ZT1g0jEErZd-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Yes, and nested try-except allows for granular exception handling, below outer\n",
        "#condition checks for value error while inside try except block for zero divion\n",
        "#error, #e.g below\n",
        "try:\n",
        "  a = int(input(\"enter first number: \"))\n",
        "  b = int(input(\"enter second number: \"))\n",
        "  try:\n",
        "    res = a/b\n",
        "    print(res)\n",
        "  except ZeroDivisionError:\n",
        "    print(\"Error: zero division error\")\n",
        "except ValueError:\n",
        "  print(\"Error: invalid input\")"
      ],
      "metadata": {
        "id": "iNSwqkPdrcY1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "942a8861-9713-41ed-8042-455eb7a98f85"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "enter first number: 4\n",
            "enter second number: a\n",
            "Error: invalid input\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Q3.How can you create a custom exception class in Python? Provide an example that demonstrates its usage.\n",
        "Ans:\n",
        "  - Can create custom exception classes by inheriting from the built-in Exception class\n",
        "  - By creating a custom exception class, we can define your own specific exception types to handle specific error conditions in your code."
      ],
      "metadata": {
        "id": "PBz3OyNxrc25"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class MyCustomException(Exception):\n",
        "    def __init__(self, message):\n",
        "        self.message = message\n",
        "\n",
        "    def __str__(self):\n",
        "        return f\"MyCustomException: {self.message}\"\n",
        "\n",
        "def divide_numbers(num1, num2):\n",
        "    if num2 == 0:\n",
        "        raise MyCustomException(\"Division by zero is not allowed.\")\n",
        "    return num1 / num2\n",
        "\n",
        "try:\n",
        "    result = divide_numbers(10, 0)\n",
        "    print(\"Result:\", result)\n",
        "except MyCustomException as e:\n",
        "    print(\"Error:\", e)\n"
      ],
      "metadata": {
        "id": "50SCUqmmrlnu",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a5d9646d-26c4-43b6-c476-bd8f9c765323"
      },
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Error: MyCustomException: Division by zero is not allowed.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Q4.What are some common exceptions that are built-in to Python?\n",
        "Ans:\n",
        "  - SyntaxError, IndentationError, NameError, TypeError, ValueError, IndexError, ZeroDivisionError, FileNotFoundError"
      ],
      "metadata": {
        "id": "5SkO8hxLrgwQ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Q5.What is logging in Python, and why is it important in software development?\n",
        "Ans:\n",
        "  - Build in module that allows to record and store informative log records during the execution of program\n",
        "  - Logging helps with:\n",
        "    - Debugging and troubleshotting\n",
        "    - Monitoring and maintainanece\n",
        "    - Auditing and compliance\n",
        "    - Forensics and analysis\n",
        "    - Communication and collaboration\n",
        "  - The logging modules provies a flexible and standardised way to log events, errors, warnings and other relevant information making it essential tool in software development\n",
        "  - By incorporating logging into soft dev workflow, you can improve the quality, readability, maintainability of your application, monitor health of application by having centralised records of events, errors and other imp info."
      ],
      "metadata": {
        "id": "fxsHFo8asJG4"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Q6.Explain the purpose of log levels in Python logging and provide examples of when each log level would be appropriate.\n",
        "Ans:\n",
        "  - Log levels are used to indicate severity or importance of log record\n",
        "  - This helps in filtering and categorising basis significance so developer can focus on specific type of messsages\n",
        "  - Python provies several diff type of log levels as mentioned below,\n",
        "    - DEBUG:\n",
        "        - Detailed diagnostic info\n",
        "        - Typically used during development and debugging stages\n",
        "        - E.g usage: logging variables values, function calls other low level details\n",
        "    - INFO:\n",
        "        - Provides info about general progress and state of the program\n",
        "        - to track program execution flow\n",
        "        - e.g usage: logging application startup info, significant milestones\n",
        "    - WARNING:\n",
        "        - Raises flag to draw attention, not stops the program execution\n",
        "        - E.g usage: logging unusual behaviour or non critical errors\n",
        "    - ERROR:\n",
        "        - This level used for erros that occur during execution of program\n",
        "        - It indicates problem that prevents specific operation or functionality from being completed successfully\n",
        "        - e.g usage: logging failed operations, or critical errors that affects programs functionality\n",
        "    - CRITICAL:\n",
        "        - Most severe log level\n",
        "        - Indicates critical error or failure that might result in termination of program\n",
        "        - e.g usage: logging severe errors that requires immediate attention e.g system failure, security breaches etc\n",
        "  - The purpose of log levels is to provide a way to control the granularity of log records basis their significance\n",
        "  - For instance, during normal operation you can set log level to INFO or higher to see only imp messages but when debugging the specific issue, you can lower log level to DEBUG to get more detailed information"
      ],
      "metadata": {
        "id": "svzlDWfysL-f"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import logging\n",
        "\n",
        "logging.basicConfig(level=logging.DEBUG)  #configuring the logging module\n",
        "\n",
        "#log messages with diff levels\n",
        "logging.debug(\"This is debug message\")\n",
        "logging.info(\"This is an informational message.\")\n",
        "logging.warning(\"This is a warning message.\")\n",
        "logging.error(\"This is an error message.\")\n",
        "logging.critical(\"This is a critical message.\")"
      ],
      "metadata": {
        "id": "VHx3GB7nsONt",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "cadc2bc1-eee9-46f9-976a-d87713e1256d"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "WARNING:root:This is a warning message.\n",
            "ERROR:root:This is an error message.\n",
            "CRITICAL:root:This is a critical message.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Q7.What are log formatters in Python logging, and how can you customise the log message format using formatters?\n",
        "Ans:\n",
        "  - log formatters are used to define the format of log messages that are emitted by the logging system.\n",
        "  - They determine how the log records are represented as strings when they are written to the log output.\n",
        "  - The logging module provides a Formatter class that allows you to customize the log message format.\n",
        "  - The Formatter class uses placeholder variables to represent different parts of the log record, such as the log level, timestamp, logger name, and the actual log message.\n",
        "  - You can create a custom log formatter by instantiating the Formatter class and passing the desired log message format string as an argument. e.g below"
      ],
      "metadata": {
        "id": "ZqC96PQEsOnw"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import logging\n",
        "\n",
        "log_formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')\n",
        "logging.basicConfig(format=log_formatter)\n",
        "\n",
        "logging.warning(\"This is a warning message.\")\n",
        "logging.error(\"This is an error message.\")"
      ],
      "metadata": {
        "id": "Bjl2CNvZsQjN",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2ba06668-5c4e-4c79-c093-884b34dae232"
      },
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "WARNING:root:This is a warning message.\n",
            "ERROR:root:This is an error message.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Q8.How can you set up logging to capture log messages from multiple modules or classes in a Python application?\n",
        "Ans:\n",
        " - Each module or class can create its log instance and loggers can be organized in hierarchy by its name\n",
        " - Process to set up:\n",
        "    - Create and configure a logger: create a logger instance for each module using logging.getLogger() function. then rename using the __name__ attribute of module or class\n",
        "    - Set the log level: using setLevel() method, depends on severity of messages needed\n",
        "    - Add a handler: using addHandler() method, it deciders where output will be stored (destination) as in console or file or remote server."
      ],
      "metadata": {
        "id": "_kxN9pwgsQ5F"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#e.g below\n",
        "#module1.py\n",
        "import logging\n",
        "\n",
        "logger = logging.getLogger(__name__) # Create a logger\n",
        "logger.setLevel(logging.DEBUG)\n",
        "\n",
        "handler = logging.StreamHandler() # Add a handler\n",
        "handler.setLevel(logging.DEBUG)\n",
        "\n",
        "formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s') # Create a formatter\n",
        "handler.setFormatter(formatter)\n",
        "\n",
        "logger.addHandler(handler) # Add the handler to the logger\n",
        "\n",
        "logger.debug(\"Debug message from module1\") # Log messages\n",
        "logger.info(\"Info message from module1\")\n",
        "\n",
        "#same way module2.py can be setup"
      ],
      "metadata": {
        "id": "v_Z0S5FKsUDs"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Q9.What is the difference between the logging and print statements in Python? When should you use logging over print statements in a real-world application?\n",
        "Ans:\n",
        "- Both of them serves diff purpose and have diff characteristics, mentioned below are key diff betn them\n",
        "  - Output destination:\n",
        "    - Print: directly to console only\n",
        "    - lgging: allows to output in diff destinations like file, remote server, or cusotmer handlers\n",
        "  - Verbosity control:\n",
        "    - Print: basic way to display messages, lacks customization\n",
        "    - Logging: allows diff log level to filter out depends on severity\n",
        "  - Log formatting:\n",
        "    - Print: limited formatting options\n",
        "    - Logging: multiple formatting options to define structure and content of message, you can include timestamp, log level, custom messages, additional info etc\n",
        "  - Error handling:\n",
        "    - Print: not designed specifically for error handling\n",
        "    - logging: providers std way for error handling, exceptions etc to diagnose and trouble shoot issues in real world\n",
        "- To summarise: Print allows for quick debugging or temp output during development, while logging offers extensive features, structures, controls and provides maintaniblity, scaleability, effective error handling and reporting in real world applications"
      ],
      "metadata": {
        "id": "f9Hriy44sUdd"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Q10.Write a Python program that logs a message to a file named \"app.log\" with the following requirements: ● The log message should be \"Hello, World!\" ● The log level should be set to \"INFO.\" ● The log file should append new log entries without overwriting previous ones."
      ],
      "metadata": {
        "id": "tRtmV8qGsXhD"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import logging\n",
        "\n",
        "#configuring the logging module\n",
        "logging.basicConfig(level=logging.INFO,\n",
        "                    format='%(asctime)s - %(levelname)s - %(message)s',  #asctime is timestamp\n",
        "                    filename = '/content/sample_data/app.log',\n",
        "                    filemode = 'a'  #a to append to file, not to overwrite\n",
        "                    )\n",
        "#logging message\n",
        "logging.info(\"Hello, World!\")"
      ],
      "metadata": {
        "id": "axkcHHvLsXJN"
      },
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Q11.Create a Python program that logs an error message to the console and a file named \"errors.log\" if an exception occurs during the program's execution. The error message should include the exception type and a timestamp."
      ],
      "metadata": {
        "id": "VK0q7yTvsczu"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import logging, datetime\n",
        "\n",
        "#configure logging to log erros to console and file\n",
        "logging.basicConfig(level=logging.ERROR,    #basicConfig default output error to console\n",
        "                    format='%(asctime)s - %(levelname)s - %(message)s')\n",
        "\n",
        "#create a file handler to log errors to 'errors.log' file\n",
        "file_handler = logging.FileHandler('/content/sample_data/errors.log')\n",
        "file_handler.setLevel(logging.ERROR)\n",
        "\n",
        "# Create a formatter to include timestamp in log messages\n",
        "formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')\n",
        "file_handler.setFormatter(formatter)\n",
        "\n",
        "#Add a file handler to the root logger\n",
        "logging.getLogger().addHandler(file_handler)\n",
        "\n",
        "try:\n",
        "  res = 10/0\n",
        "except Exception as e:\n",
        "  # Log the error message with exception type and timestamp\n",
        "  logging.error(f\"Exception: {type(e).__name__}. Timestamp: {datetime.datetime.now()}\")"
      ],
      "metadata": {
        "id": "ywZOisEiseKD",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b564849e-abe2-41e9-b2ac-7e0f5f781b7b"
      },
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "ERROR:root:Exception: ZeroDivisionError. Timestamp: 2023-07-16 07:10:31.780680\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "%cat /content/sample_data/errors.log"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "50E65YcUiCyI",
        "outputId": "bed91687-e456-447f-e696-26a412263988"
      },
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2023-07-16 07:09:13,435 - ERROR - Exception: ZeroDivisionError. Timestamp: 2023-07-16 07:09:13.435134\n",
            "2023-07-16 07:10:24,582 - ERROR - Exception: ZeroDivisionError. Timestamp: 2023-07-16 07:10:24.582066\n",
            "2023-07-16 07:10:24,582 - ERROR - Exception: ZeroDivisionError. Timestamp: 2023-07-16 07:10:24.582066\n",
            "2023-07-16 07:10:31,780 - ERROR - Exception: ZeroDivisionError. Timestamp: 2023-07-16 07:10:31.780680\n",
            "2023-07-16 07:10:31,780 - ERROR - Exception: ZeroDivisionError. Timestamp: 2023-07-16 07:10:31.780680\n",
            "2023-07-16 07:10:31,780 - ERROR - Exception: ZeroDivisionError. Timestamp: 2023-07-16 07:10:31.780680\n"
          ]
        }
      ]
    }
  ]
}