003F_Python_File_Manipulation,_Debugging_&_Logging.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "mount_file_id": "17WxddGRbDmmFxd5RWT04qYpzz4Sdf5Z9",
      "authorship_tag": "ABX9TyP3AhvNwdRKaYQsZAoRJm7y",
      "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/MohanVishe/Notes/blob/main/003F_Python_File_Manipulation%2C_Debugging_%26_Logging.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **File Input/Output (I/O)**"
      ],
      "metadata": {
        "id": "oeMtG-bHucOA"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "File I/O is a fundamental concept in programming and is used to interact with files on a computer's storage system. In Python, you can perform various file operations like opening, reading, writing, and closing files. This note provides an overview of these operations and some best practices."
      ],
      "metadata": {
        "id": "iZ2XNDwpupRw"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **1. File Basics**\n",
        "   - A file is a named location on disk used to store data permanently.\n",
        "   - Files are essential for preserving data since RAM is volatile and loses data when the computer is turned off.\n",
        "   - Common file operations: Open, Read/Write, Close."
      ],
      "metadata": {
        "id": "P0Lr4ZBtutyJ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **2. Opening a File**\n",
        "   - Python provides the `open()` function to open files. It returns a file object, often referred to as a handle.\n",
        "   - Example: `f = open('example.txt')` - opens the 'example.txt' file in the current directory.\n",
        "   - You can specify the mode for opening a file. Common modes include:\n",
        "     - `'r'`: Read (default).\n",
        "     - `'w'`: Write (creates a new file or truncates if it exists).\n",
        "     - `'x'`: Exclusive creation (fails if the file exists).\n",
        "     - `'a'`: Append (open for writing at the end without truncating).\n",
        "     - `'t'`: Text mode (default).\n",
        "     - `'b'`: Binary mode.\n",
        "     - `+`: Open for updating (both reading and writing).\n",
        "   - It's recommended to specify the encoding type when working with text mode due to platform-dependent default encodings."
      ],
      "metadata": {
        "id": "9FOPYcdAu39M"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "f =open(\"example.txt\",\"r\")"
      ],
      "metadata": {
        "id": "wgPm593mu9Le"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **3. Closing a File**\n",
        "   - Closing a file is crucial to free up resources tied to it.\n",
        "   - While Python has a garbage collector to clean up unreferenced objects, it's not entirely safe to rely on it for file closure.\n",
        "   - A safer approach is to use a `try...finally` block to ensure the file is closed even if an exception occurs:\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "wcwf8tSQuV2j"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "try:\n",
        "  f = open(\"example.txt\")\n",
        "finally:\n",
        "  f.close()"
      ],
      "metadata": {
        "id": "ExyGKONrw7pG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "   - The recommended and more elegant way is to use the `with` statement, which automatically closes the file when the block is exited:\n"
      ],
      "metadata": {
        "id": "HwOmgGHTw6Rq"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Using 'with' for reading a file\n",
        "with open('example.txt', 'r') as file:\n",
        "    data = file.read()\n",
        "    # Perform file operations within the 'with' block\n",
        "\n",
        "# The file is automatically closed when the 'with' block is exited"
      ],
      "metadata": {
        "id": "TG_JYB7vxL36"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Using the `with` statement not only ensures the proper closure of the file but also makes your code cleaner and more Pythonic."
      ],
      "metadata": {
        "id": "HsbRE01CxI0N"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##**4.Writing to a File:**\n",
        "- We need to open it in the write ('w'), append ('a'), or exclusive creation ('x') mode. Be cautious with the 'w' mode, as it will overwrite the file if it already exists, erasing all previous data. You can write a string or sequence of bytes (for binary files) using the `write()` method, which returns the number of characters written to the file."
      ],
      "metadata": {
        "id": "eRUjMvXIzl8O"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "f = open(\"test.txt\", \"w\")\n",
        "f.write(\"This is a First File\\n\")\n",
        "f.write(\"Contains two lines\\n\")\n",
        "f.close()"
      ],
      "metadata": {
        "id": "CEck2fFnzsuZ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **5.Reading From a File:**\n",
        "\n",
        "1.  `read(size)` :  Method to read a specified number of characters, or, if the size parameter is not specified, it reads and returns data up to the end of the file."
      ],
      "metadata": {
        "id": "Mw2Qjciqz6L5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "f = open(\"test.txt\", \"r\")\n",
        "data = f.read()\n",
        "print(data)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gPLsQl790DAp",
        "outputId": "498261a3-2933-4891-8e5c-4a551a31a977"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "This is a First File\n",
            "Contains two lines\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "2. `seek()`: You can also change the file cursor's position using the  method\n",
        "3. `tell()`: get the current position of cursor with the  method."
      ],
      "metadata": {
        "id": "Oi03eN2R1p8V"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "f.seek(0)  # Move the file cursor to the initial position\n",
        "print(f.read())  # Read the entire file from the beginning"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8U32ZjIc1sMQ",
        "outputId": "f4a19663-0ee1-41d0-ad73-71ab2915d433"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "This is a First File\n",
            "Contains two lines\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "f.tell()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UF4xBowP1v3T",
        "outputId": "6993ede9-ce67-4f34-ece6-fdcdb5411a8e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "40"
            ]
          },
          "metadata": {},
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "f.seek(10) # the current position of cursor change to 10"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Pt2H8CSZ1yKc",
        "outputId": "18f7a888-8b2c-4e9a-f148-f894e9e6bc9b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "10"
            ]
          },
          "metadata": {},
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "f.tell()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dEUFfzF411aF",
        "outputId": "80093c7b-2527-4397-f24f-ac777ba103d4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "10"
            ]
          },
          "metadata": {},
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "f.read(10) # Next 10 character from current position printed\n",
        "# now the current position will of cursor will be at 20"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "rY9tXTfd144_",
        "outputId": "db6fc4cf-d86b-4057-9095-48e1c7d1f84b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'First File'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "f.tell()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8mEJ8ygA18_F",
        "outputId": "f683cdaa-3692-42bd-e0ad-b313641ffabc"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "20"
            ]
          },
          "metadata": {},
          "execution_count": 27
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "4. Read a file line-by-line : using for loop"
      ],
      "metadata": {
        "id": "Hjn3AnLP23mt"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "f.seek(0)\n",
        "for line in f:\n",
        "    print(line)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NKqgvnjf27pg",
        "outputId": "55fba6b6-4361-447c-b4b6-0d5add951d2b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "This is a First File\n",
            "\n",
            "Contains two lines\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "5. Read a file line-by-line : use the `readline()` method to read individual lines, which includes the newline character."
      ],
      "metadata": {
        "id": "_LGzlhFj3EAW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "f = open(\"test.txt\", \"r\")\n",
        "print(f.readline())\n",
        "print(f.readline())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "81-04Mhk3UMD",
        "outputId": "9b770bd7-abd1-4f92-8d71-6c3e41e6b085"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "This is a First File\n",
            "\n",
            "Contains two lines\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "6. The `readlines()` method returns a list of the remaining lines in the entire file. These reading methods return empty values when they reach the end of the file.\n"
      ],
      "metadata": {
        "id": "V_etb6Ll3izV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "f.seek(0)\n",
        "f.readlines()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "I1tsN8DU3mWI",
        "outputId": "d24526db-1ef6-43c2-d334-ee8b6814106d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['This is a First File\\n', 'Contains two lines\\n']"
            ]
          },
          "metadata": {},
          "execution_count": 32
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **6.Renaming and Deleting Files in Python**\n",
        "\n",
        "In Python, you can rename and delete files using the `os` module :\n"
      ],
      "metadata": {
        "id": "0NVP8BP84b4X"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "1. Import the `os` module:"
      ],
      "metadata": {
        "id": "ERTAl5uJ4dm9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import os"
      ],
      "metadata": {
        "id": "Jxv41h9s4fUM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "2. Renaming a File:"
      ],
      "metadata": {
        "id": "Ya8Id1ea4hUJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "os.rename(\"test.txt\", \"sample.txt\")"
      ],
      "metadata": {
        "id": "m6Qp6EPl4pgv"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "3. Deleting a File:\n",
        "\n"
      ],
      "metadata": {
        "id": "tkYFF54941pn"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "os.remove(\"sample.txt\")"
      ],
      "metadata": {
        "id": "3ZDFMp4j43It"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Attempting to open and read it again will result in a `FileNotFoundError`:"
      ],
      "metadata": {
        "id": "1kvbLHBE4_jc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "try:\n",
        "    f = open(\"sample.txt\", \"r\")\n",
        "    data = f.readline()\n",
        "except FileNotFoundError as e:\n",
        "    print(f\"FileNotFoundError: {e}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3Gngr2uf5ESA",
        "outputId": "09bcd651-7245-470d-a726-f4e86118be33"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "FileNotFoundError: [Errno 2] No such file or directory: 'sample.txt'\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##  **7.Python Directory and File Management**\n",
        "\n",
        "\n",
        "**1. Get Current Directory:** `getcwd()` method"
      ],
      "metadata": {
        "id": "s9W2wmqm6BzR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "current_directory = os.getcwd()\n",
        "print(current_directory)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "P2QQWaUS6EpW",
        "outputId": "9a4c57dc-66ba-40e5-e4fc-61780e85e7b7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "/content\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**2. Changing Directory:** `chdir()` method.\n",
        "\n",
        "- we provide the new path as a string to this method. we can use either forward slashes or backward slashes to separate path elements.\n"
      ],
      "metadata": {
        "id": "_g5wkIzi6qhC"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "os.chdir(\"D:\\Data Science\\Practice\")\n",
        "new_directory = os.getcwd()\n",
        "print(new_directory)"
      ],
      "metadata": {
        "id": "d6MDPzlI6sTm"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**3. List Directories and Files:**\n",
        "- We can list all files and subdirectories inside a directory using the `listdir()` method."
      ],
      "metadata": {
        "id": "lFi5syDP7dnx"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "files_and_directories = os.listdir(os.getcwd())\n",
        "print(files_and_directories)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ShMl2pGe7fvM",
        "outputId": "7ea39cd6-e35b-4996-9335-3e0ba3a5a22f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['.config', 'drive', 'example.txt', 'sample_data']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**4. Making New Directory:**\n",
        "- You can create a new directory using the `mkdir()` method. If you don't specify the full path, the new directory is created in the current working directory.\n"
      ],
      "metadata": {
        "id": "CqsOn4V_7q9Y"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "os.mkdir('test')"
      ],
      "metadata": {
        "id": "5cuakgeN7sq8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**5.Remove Directory :**\n",
        "- `rmdir()` method can only remove empty directories.\n",
        "\n"
      ],
      "metadata": {
        "id": "xsxAgvcq5iCi"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "os.rmdir(\"test\")"
      ],
      "metadata": {
        "id": "c21RzFbJ8k-6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "- To remove a non-empty directory, you can use the `rmtree()` method from the `shutil` module.\n",
        "\n",
        "- The `shutil.rmtree()` function is used to remove non-empty directories."
      ],
      "metadata": {
        "id": "oEqKNwK_8uaK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import shutil\n",
        "\n",
        "os.mkdir('test')\n",
        "os.chdir('./test')\n",
        "f = open(\"testfile.txt\", 'w')\n",
        "f.write(\"Hello World\")\n",
        "os.chdir(\"../\")\n",
        "shutil.rmtree('test')"
      ],
      "metadata": {
        "id": "esLe0ALU8My4"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Python Debugging**"
      ],
      "metadata": {
        "id": "LDiT4TN48yCZ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Debugging in Python is the process of identifying and fixing errors or issues in your code. Here's an overview of common debugging techniques and tools in Python:\n",
        "\n",
        "**1. Print Statements:**\n",
        "One of the simplest debugging techniques is to insert print statements into your code to print the values of variables or the flow of your program. You can use the `print()` function to output information to the console.\n"
      ],
      "metadata": {
        "id": "0rn03tiaKXWz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x = 10\n",
        "print(\"The value of x is:\", x)"
      ],
      "metadata": {
        "id": "9JjpNPk-KZJy"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**2. Using `assert` Statements:**\n",
        "The `assert` statement is used to check if a given condition is `True`. If the condition is `False`, an `AssertionError` is raised, allowing you to identify issues in your code."
      ],
      "metadata": {
        "id": "qCpkZAv7KcxH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x = 10\n",
        "assert x == 5, \"x should be 5\""
      ],
      "metadata": {
        "id": "GyCVJawFKfkJ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**3. Exception Handling:**\n",
        "You can use `try...except` blocks to catch and handle exceptions. This helps prevent your program from crashing and provides information about the error."
      ],
      "metadata": {
        "id": "166WnnuvKjDw"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "try:\n",
        "    x = 10 / 0\n",
        "except ZeroDivisionError as e:\n",
        "    print(\"Error:\", e)"
      ],
      "metadata": {
        "id": "C6WuETPeKliq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**4. Using a Debugger:**\n",
        "Python has built-in debugging tools, including the `pdb` (Python Debugger) module. You can insert breakpoints in your code and step through it to examine variables and control flow."
      ],
      "metadata": {
        "id": "U-Sn2V9sKpRf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pdb\n",
        "\n",
        "x = 10\n",
        "pdb.set_trace()  # Set a breakpoint\n",
        "y = x + 5"
      ],
      "metadata": {
        "id": "8BcC3Yq-Krb4"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**5. Integrated Development Environments (IDEs):**\n",
        "Many IDEs, such as PyCharm, Visual Studio Code, and PyDev for Eclipse, have built-in debugging tools that make it easier to debug your code. They provide features like breakpoints, variable inspection, and step-by-step execution.\n",
        "\n",
        "**6. Logging:**\n",
        "The `logging` module in Python allows you to create log messages at different levels (e.g., INFO, DEBUG, ERROR) to record program execution. This can help you trace the flow of your code and identify issues."
      ],
      "metadata": {
        "id": "zWipBK5VKzUB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import logging\n",
        "\n",
        "logging.basicConfig(level=logging.DEBUG)\n",
        "logging.debug(\"This is a debug message\")"
      ],
      "metadata": {
        "id": "ceLlmCCpK1_v"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**7. Third-Party Debuggers:**\n",
        "There are third-party debugging tools and libraries available for Python, such as `pdb++,` `PyCharm Debugger`, and `Winpdb`, which offer additional features and a more user-friendly interface.\n",
        "\n",
        "**8. Unit Testing:**\n",
        "Writing unit tests for your code can help you identify issues and verify that your code works as expected. The `unittest` or `pytest` libraries are commonly used for unit testing in Python.\n",
        "\n",
        "**9. Code Linters and Analyzers:**\n",
        "Tools like `flake8` and `pylint` can help you identify and fix code style issues and potential errors in your code before you run it."
      ],
      "metadata": {
        "id": "WiQXsBip9iwG"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Python Debugger**"
      ],
      "metadata": {
        "id": "JIBuAy0mK70J"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "- `pdb` is an interactive debugger that allows you to pause your program's execution, inspect variables, and step through code. Here's a breakdown of the code and how `pdb` is used:\n",
        "\n",
        "**1. Starting the Debugger From the Command Line:**\n",
        "The initial part of the code demonstrates how to start the debugger from the command line. In this example, a function `seq(n)` is defined to print numbers from 0 to `n-1`."
      ],
      "metadata": {
        "id": "mRZKprFOLfJF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def seq(n):\n",
        "    for i in range(n):\n",
        "        print(i)\n",
        "seq(5)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cHPwpn1ULrld",
        "outputId": "f04fad27-6b25-4227-943c-b915bd4f6718"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0\n",
            "1\n",
            "2\n",
            "3\n",
            "4\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**2. Starting the Debugger From Within Your Program:**\n",
        "- The code snippet shows how to start the debugger from within your program.\n",
        "- The `pdb` module is imported, and a breakpoint is set using `pdb.set_trace()` inside the `seq(n)` function."
      ],
      "metadata": {
        "id": "auXYCnIaNJVM"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**3. Debugger Commands:**\n",
        "For interacting with `pdb`, Here are some of the most commonly used commands:\n",
        "- `list`: Lists the code surrounding the current breakpoint.\n",
        "- `p i`: Prints the value of the variable `i`.\n",
        "- `p n`: Prints the value of the variable `n`.\n",
        "- `p locals()`: Prints the local variables in the current scope.\n",
        "- `c`: Continues execution until the next breakpoint is encountered.\n",
        "- `q`: Quits the debugger and exits the program.\n",
        "- `h` or `help`: Displays a list of available commands and their descriptions."
      ],
      "metadata": {
        "id": "XwQTuQAiLalc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pdb\n",
        "\n",
        "def seq(n):\n",
        "    for i in range(n):\n",
        "        pdb.set_trace()  # Set a breakpoint\n",
        "        print(i)\n",
        "\n",
        "seq(5)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1d3MqXUuNPkK",
        "outputId": "bb545573-bdde-4fe3-cd96-afbd407dcf07"
      },
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "> \u001b[0;32m<ipython-input-4-64af0040f4b5>\u001b[0m(6)\u001b[0;36mseq\u001b[0;34m()\u001b[0m\n",
            "\u001b[0;32m      4 \u001b[0;31m    \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mn\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[0;32m      5 \u001b[0;31m        \u001b[0mpdb\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset_trace\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# Set a breakpoint\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0m\u001b[0;32m----> 6 \u001b[0;31m        \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0m\u001b[0;32m      7 \u001b[0;31m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0m\u001b[0;32m      8 \u001b[0;31m\u001b[0mseq\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0m\n",
            "ipdb> p i\n",
            "0\n",
            "ipdb> p locals()\n",
            "{'n': 5, 'i': 0}\n",
            "ipdb> c\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\n",
            "PYDEV DEBUGGER WARNING:\n",
            "sys.settrace() should not be used when the debugger is being used.\n",
            "This may cause the debugger to stop working correctly.\n",
            "If this is needed, please check: \n",
            "http://pydev.blogspot.com/2007/06/why-cant-pydev-debugger-work-with.html\n",
            "to see how to restore the debug tracing back correctly.\n",
            "Call Location:\n",
            "  File \"/usr/lib/python3.10/bdb.py\", line 347, in set_continue\n",
            "    sys.settrace(None)\n",
            "\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "0\n",
            "> \u001b[0;32m<ipython-input-4-64af0040f4b5>\u001b[0m(6)\u001b[0;36mseq\u001b[0;34m()\u001b[0m\n",
            "\u001b[0;32m      4 \u001b[0;31m    \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mn\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[0;32m      5 \u001b[0;31m        \u001b[0mpdb\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset_trace\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# Set a breakpoint\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0m\u001b[0;32m----> 6 \u001b[0;31m        \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0m\u001b[0;32m      7 \u001b[0;31m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0m\u001b[0;32m      8 \u001b[0;31m\u001b[0mseq\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0m\n",
            "ipdb> p locals()\n",
            "{'n': 5, 'i': 1}\n",
            "ipdb> h\n",
            "\n",
            "Documented commands (type help <topic>):\n",
            "========================================\n",
            "EOF    commands   enable    ll        pp       s                until \n",
            "a      condition  exit      longlist  psource  skip_hidden      up    \n",
            "alias  cont       h         n         q        skip_predicates  w     \n",
            "args   context    help      next      quit     source           whatis\n",
            "b      continue   ignore    p         r        step             where \n",
            "break  d          interact  pdef      restart  tbreak         \n",
            "bt     debug      j         pdoc      return   u              \n",
            "c      disable    jump      pfile     retval   unalias        \n",
            "cl     display    l         pinfo     run      undisplay      \n",
            "clear  down       list      pinfo2    rv       unt            \n",
            "\n",
            "Miscellaneous help topics:\n",
            "==========================\n",
            "exec  pdb\n",
            "\n",
            "ipdb> q\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Python Logging**"
      ],
      "metadata": {
        "id": "DPoM7BWdOJRc"
      }
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "aM85DEPUQxxP"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lbtJXKTj9WnO"
      },
      "source": [
        "<ul>\n",
        "<li><strong>Logging</strong> is a technique for monitoring events that take place when some software is in use.</li>\n",
        "<li>For the creation, operation, and debugging of software, logging is crucial.</li>\n",
        "<li>There are very little odds that you would find the source of the issue if your programme fails and you don't have any logging records.</li>\n",
        "<li>Additionally, it will take a lot of time to identify the cause.&nbsp;</li>\n",
        "</ul>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1EYYE6k79WnO",
        "outputId": "acbecfb5-93c2-435a-a877-cae9c43cb9f4"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "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"
          ]
        }
      ],
      "source": [
        "# first import the logging library\n",
        "import logging\n",
        "\n",
        "\"\"\" In the code above, we first import the logging module, then we call the\n",
        "    basicConfig method to configure the logging.\n",
        "\n",
        "    We set the level to DEBUG, which means that all logs of level\n",
        "    DEBUG and above will be tracked.\"\"\"\n",
        "\n",
        "logging.basicConfig(level=logging.DEBUG)\n",
        "\n",
        "# Logging Level: severity of the event being logged\n",
        "# Least severe to most severe\n",
        "logging.debug('This is a debug message')\n",
        "logging.info('This is an info 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')\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hxVC5-9a9WnP"
      },
      "source": [
        "<ul>\n",
        "<li>Some programmers utilise the idea of&nbsp;<strong>\"Printing\"</strong> the statements to check whether they were correctly performed or if an error had occurred.</li>\n",
        "<li>However, printing is not a smart move. For basic scripts, it might be the answer to your problems, however the printing solution will fall short for complex programmes.</li>\n",
        "<li>A built-in Python package called logging enables publishing status messages to files or other output streams. The file may provide details about which portion of the code is run and any issues that have come up. </li>\n",
        "</ul>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "R0ZyoA1_9WnP"
      },
      "source": [
        "<ul>\n",
        "<li>\n",
        "<p>Here are the different log levels in increasing order of severity:</p>\n",
        "<ul>\n",
        "<li>DEBUG: Detailed information, typically of interest only when diagnosing problems.</li>\n",
        "<li>INFO: Confirmation that things are working as expected.</li>\n",
        "<li>WARNING: An indication that something unexpected happened, or may happen in the future (e.g. &lsquo;disk space low&rsquo;). The software is still working as expected.</li>\n",
        "<li>ERROR: More serious problem that prevented the software from performing a function.</li>\n",
        "<li>CRITICAL: A very serious error, indicating that the program itself may be unable to continue running.</li>\n",
        "</ul>\n",
        "</li>\n",
        "</ul>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "euSr4IUK9WnP"
      },
      "source": [
        "# Debug"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vfxPX2uT9WnP",
        "outputId": "4451621c-2bb0-48e8-c23e-460ddc5a79b0"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3"
            ]
          },
          "metadata": {},
          "execution_count": 12
        }
      ],
      "source": [
        "import logging\n",
        "\n",
        "logging.basicConfig(level=logging.DEBUG)\n",
        "\n",
        "def add(x, y):\n",
        "    logging.debug('Variables are %s and %s', x, y)\n",
        "    return x + y\n",
        "\n",
        "add(1, 2)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Z-60uMXD9WnQ"
      },
      "source": [
        "# Info"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "FHerNeiL9WnQ"
      },
      "outputs": [],
      "source": [
        "import logging\n",
        "\n",
        "logging.basicConfig(level=logging.INFO)\n",
        "\n",
        "def login(user):\n",
        "    logging.info('User %s logged in', user)\n",
        "\n",
        "login('Admin User')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QRC_1kND9WnQ"
      },
      "source": [
        "# Warning"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sBtOLb2D9WnQ",
        "outputId": "7514f9d8-bcfa-4ef7-fa91-bd4e2fdbcc35"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "WARNING:root:Sorry you have Low balance: 10000\n"
          ]
        }
      ],
      "source": [
        "import logging\n",
        "\n",
        "logging.basicConfig(level=logging.WARNING)\n",
        "\n",
        "def MyBalance(amount):\n",
        "    if amount < 40000:\n",
        "        logging.warning('Sorry you have Low balance: %s', amount)\n",
        "\n",
        "MyBalance(10000)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aA8Jbmps9WnQ"
      },
      "source": [
        "# Error"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "di5U1A949WnQ",
        "outputId": "acf66fd7-4360-4090-f95f-aeaba421d335"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "ERROR:root:You are trying to divide by zero, which is not allowed\n"
          ]
        }
      ],
      "source": [
        "import logging\n",
        "\n",
        "logging.basicConfig(level=logging.ERROR)\n",
        "\n",
        "def LetUsDivide(n, d):\n",
        "    try:\n",
        "        result = n / d\n",
        "    except ZeroDivisionError:\n",
        "        logging.error('You are trying to divide by zero, which is not allowed')\n",
        "    else:\n",
        "        return result\n",
        "\n",
        "LetUsDivide(4, 0)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pydruDw-9WnQ"
      },
      "source": [
        "# Critical Errors"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZmmtyHup9WnQ",
        "outputId": "61ecaf4f-e516-4574-a781-a846a5a7c2db"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "CRITICAL:root:System failure: You need to handle the issue now\n"
          ]
        }
      ],
      "source": [
        "import logging\n",
        "\n",
        "logging.basicConfig(level=logging.CRITICAL)\n",
        "\n",
        "def LetUsCheckSystem(sys):\n",
        "    if sys != 'OK':\n",
        "        logging.critical('System failure: %s', sys)\n",
        "\n",
        "LetUsCheckSystem('You need to handle the issue now')\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Message with datetime and in our format"
      ],
      "metadata": {
        "id": "s67isEITo_YM"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import logging\n",
        "logging.basicConfig(level=logging.WARNING,format=\"%(asctime)s and  %(message)s and %(name)s and %(levelname)\")\n",
        "logging.error(\"error is in this way\")\n",
        "logging.shutdown()"
      ],
      "metadata": {
        "id": "KUXw4zx_i15p"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Saving in log file by writing \"filename\""
      ],
      "metadata": {
        "id": "WJQNfK0hpOYx"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import  logging\n",
        "logging.basicConfig(filename=\"test4.log\", level=logging.WARNING ,\n",
        "      format='%(levelname)s %(asctime)s %(name)s  %(message)s' )\n",
        "\n",
        "\n",
        "def devide(a,b) :\n",
        "    logging.info(\"the number entered by user is %s and %s\" , a,b)\n",
        "    try :\n",
        "        logging.info(\"we are into function\")\n",
        "        div = a /b\n",
        "        logging.info(\"we have completed a division operation\")\n",
        "        logging.info(\"result of code is %s \" , div)\n",
        "        return div\n",
        "    except  Exception as e :\n",
        "        logging.exception(e)\n",
        "        print(e)\n",
        "\n",
        "\n",
        "(devide(3,0))"
      ],
      "metadata": {
        "id": "jpf5qFj9o-e-",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "34263ddb-6c8e-49c0-efc1-a3df626d77e9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "ERROR:root:division by zero\n",
            "Traceback (most recent call last):\n",
            "  File \"<ipython-input-18-8b38ff22ec8b>\", line 8, in devide\n",
            "    div = a /b\n",
            "ZeroDivisionError: division by zero\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "division by zero\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6n8XPZ9A9WnR"
      },
      "source": [
        "## Save to a file"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "fn11u07l9WnR"
      },
      "outputs": [],
      "source": [
        "import os\n",
        "\n",
        "# Specify the directory and file\n",
        "dir_path = r'C:\\Users\\Dell\\Desktop\\June\\Latest\\iNeuron\\Sessions\\17_18June2023'\n",
        "log_file = 'system.txt'\n",
        "full_path = os.path.join(dir_path, log_file)\n",
        "\n",
        "# Check if the directory exists and create it if necessary\n",
        "os.makedirs(dir_path, exist_ok=True)\n",
        "\n",
        "# Try writing a test message to the file\n",
        "with open(full_path, 'w') as f:\n",
        "    f.write('This is a test message')\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0nHFxuJC9WnR",
        "outputId": "694e0f7e-e7a8-4256-81d2-582539c08367"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "/content\n"
          ]
        }
      ],
      "source": [
        "import os\n",
        "print(os.getcwd())"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QTwT-BjY9WnR",
        "outputId": "c41e4948-367b-4480-ef70-2ca8fda512f4"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "CRITICAL:root:System failure: You need to handle the issue now\n"
          ]
        }
      ],
      "source": [
        "import os\n",
        "import logging\n",
        "\n",
        "# Specify the directory and file\n",
        "dir_path = r'C:\\Users\\Dell\\Desktop\\June\\Latest\\iNeuron\\Sessions\\17_18June2023'\n",
        "log_file = 'system.txt'\n",
        "full_path = os.path.join(dir_path, log_file)\n",
        "\n",
        "# Check if the directory exists and create it if necessary\n",
        "os.makedirs(dir_path, exist_ok=True)\n",
        "\n",
        "# Set up logging\n",
        "# Get a logger instance (this will fetch the root logger)\n",
        "logger = logging.getLogger()\n",
        "\n",
        "# Set the level of the logger to CRITICAL\n",
        "# This means it will handle events of level CRITICAL and above\n",
        "logger.setLevel(logging.CRITICAL)\n",
        "\n",
        "# Create a FileHandler instance to write logs to a file\n",
        "handler = logging.FileHandler(full_path)\n",
        "\n",
        "# Set the format of the logs using a Formatter\n",
        "# This format includes the log timestamp, log level and log message\n",
        "handler.setFormatter(logging.Formatter('%(asctime)s:%(levelname)s:%(message)s'))\n",
        "\n",
        "# Add the handler to the logger\n",
        "# This connects the logger to the handler so that logs get written to the file\n",
        "logger.addHandler(handler)\n",
        "\n",
        "\n",
        "def LetUsCheckSystem(sys):\n",
        "    if sys != 'OK':\n",
        "        logging.critical('System failure: %s', sys)\n",
        "\n",
        "LetUsCheckSystem('You need to handle the issue now')\n",
        "handler.close()\n"
      ]
    }
  ]
}