file_handling_exception_handling_and_memory_mangment.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "collapsed_sections": [
        "-2cQjpeVePfC"
      ]
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# THEORETICAL QUESTIONS\n"
      ],
      "metadata": {
        "id": "-2cQjpeVePfC"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "1. What is the difference between interpreted and compiled languages?\n"
      ],
      "metadata": {
        "id": "WJBYV2xtAeWg"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Compiled languages translate the entire source code into machine code before execution using a compiler, making them faster since they run directly as executable files. However, any code modification requires recompilation. Examples include C, C++, and Rust. On the other hand, interpreted languages execute code line by line at runtime using an interpreter, which makes debugging easier but slows down execution. Python, JavaScript, and Ruby are common examples. Some languages, like Java and Python, use a hybrid approach where code is first compiled to an intermediate bytecode and then interpreted. Compiled languages are typically machine-dependent, whereas interpreted languages are more portable."
      ],
      "metadata": {
        "id": "iolIkg6oCVMO"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "2. What is exception handling in Python?\n"
      ],
      "metadata": {
        "id": "eolLThEfCZCl"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Exception handling in Python is a mechanism that allows a program to handle runtime errors gracefully instead of crashing. It is done using the `try`, `except`, `else`, and `finally` blocks. When an error (exception) occurs inside the `try` block, Python jumps to the corresponding `except` block to handle it, preventing abrupt termination. If no exception occurs, the `else` block (if present) executes. The `finally` block, if used, runs regardless of whether an exception occurred, making it useful for cleanup tasks like closing files or releasing resources. Common exceptions include `ZeroDivisionError`, `TypeError`, and `FileNotFoundError`. Example:  \n",
        "\n",
        "```python\n",
        "try:\n",
        "    x = 10 / 0  # This will cause a ZeroDivisionError\n",
        "except ZeroDivisionError:\n",
        "    print(\"Cannot divide by zero!\")\n",
        "finally:\n",
        "    print(\"Execution completed.\")\n",
        "```  \n",
        "This ensures that even if an error occurs, the program handles it without crashing."
      ],
      "metadata": {
        "id": "xJTzuk7tCcPA"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "3. What is the purpose of the finally block in exception handling?\n"
      ],
      "metadata": {
        "id": "zHb8UHvqFs6d"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "The `finally` block in Python's exception handling ensures that certain code runs **no matter what**, whether an exception occurs or not. It is typically used for **cleanup operations**, such as closing files, releasing resources, or disconnecting from a database. Since it executes after the `try` and `except` blocks, it guarantees that necessary actions (like freeing memory or logging information) are performed even if an error occurs.  \n",
        "\n",
        "**Example:**  \n",
        "```python\n",
        "try:\n",
        "    file = open(\"data.txt\", \"r\")\n",
        "    content = file.read()\n",
        "except FileNotFoundError:\n",
        "    print(\"File not found!\")\n",
        "finally:\n",
        "    print(\"Closing the file...\")\n",
        "    file.close()  # Ensures the file is closed even if an error occurs\n",
        "```\n",
        "Here, the `finally` block ensures that the file is closed, preventing resource leaks."
      ],
      "metadata": {
        "id": "0BilnDOtF8U8"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "4. What is logging in Python?\n"
      ],
      "metadata": {
        "id": "gPqrlw2GF--Y"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Logging in Python is a way to track events and messages during program execution, helping with debugging, monitoring, and troubleshooting. The built-in `logging` module allows developers to record messages at different severity levels: **DEBUG, INFO, WARNING, ERROR, and CRITICAL**. Unlike `print()`, logging provides better control over message formatting, output destinations (console, files, etc.), and filtering based on severity.  \n",
        "\n",
        "**Example:**  \n",
        "```python\n",
        "import logging\n",
        "\n",
        "logging.basicConfig(level=logging.INFO, format=\"%(asctime)s - %(levelname)s - %(message)s\")\n",
        "\n",
        "logging.info(\"This is an info message.\")\n",
        "logging.warning(\"This is a warning.\")\n",
        "logging.error(\"An error occurred!\")\n",
        "```\n",
        "This logs messages with timestamps and severity levels, making debugging more efficient."
      ],
      "metadata": {
        "id": "wrb9Cnh-Gh5n"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "5.What is the significance of the __del__ method in Python?"
      ],
      "metadata": {
        "id": "o7750rH4Gi26"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "The `__del__` method in Python is a **destructor** that is called when an object is about to be destroyed (i.e., when it is no longer referenced and garbage collected). It allows you to define cleanup actions like closing files, releasing resources, or logging object deletion. However, relying on `__del__` is not always recommended since garbage collection timing can be unpredictable.  \n",
        "\n",
        "### **Example:**  \n",
        "```python\n",
        "class MyClass:\n",
        "    def __init__(self, name):\n",
        "        self.name = name\n",
        "        print(f\"Object {self.name} created.\")\n",
        "\n",
        "    def __del__(self):\n",
        "        print(f\"Object {self.name} is being deleted.\")\n",
        "\n",
        "obj = MyClass(\"A\")\n",
        "del obj  # Explicitly deleting the object triggers __del__()\n",
        "```\n",
        "### **Key Points:**\n",
        "- It is automatically called when an object is garbage collected.\n",
        "- It is useful for resource cleanup but should not be solely relied upon for critical tasks.\n",
        "- In some cases, circular references may delay object deletion, so explicit resource management (`with` statements) is preferred."
      ],
      "metadata": {
        "id": "ulxAvGGrG0E6"
      }
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "tpTdaMhQG89w"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "6. What is the difference between import and from ... import in Python?"
      ],
      "metadata": {
        "id": "aQPIp2A5HBRG"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "The difference between `import` and `from ... import` in Python lies in how modules and their contents are accessed.  \n",
        "\n",
        "- **`import module`**: Imports the entire module, and you must use the module name to access its functions or variables.  \n",
        "  ```python\n",
        "  import math\n",
        "  print(math.sqrt(16))  # Access using math.\n",
        "  ```  \n",
        "\n",
        "- **`from module import name`**: Imports specific functions or variables from a module, allowing direct access without the module name.  \n",
        "  ```python\n",
        "  from math import sqrt\n",
        "  print(sqrt(16))  # Direct access, no math. prefix needed.\n",
        "  ```  \n",
        "\n",
        "- **`from module import *`**: Imports everything from the module but can cause namespace conflicts.  \n",
        "  ```python\n",
        "  from math import *\n",
        "  print(sqrt(16))  # Works, but not recommended for large modules.\n",
        "  ```  \n",
        "\n",
        "Using `import module` is preferred for clarity, while `from ... import` is useful when you need only specific functions."
      ],
      "metadata": {
        "id": "rS51hnWIHHGL"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "7. How can you handle multiple exceptions in Python?"
      ],
      "metadata": {
        "id": "l2Q5GvT4HPdt"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "In Python, multiple exceptions can be handled using multiple `except` blocks or a single `except` block with a tuple of exceptions.  \n",
        "\n",
        "### **1. Using Multiple `except` Blocks**\n",
        "Each `except` block handles a specific exception type separately.  \n",
        "```python\n",
        "try:\n",
        "    x = 10 / 0\n",
        "except ZeroDivisionError:\n",
        "    print(\"Cannot divide by zero!\")\n",
        "except ValueError:\n",
        "    print(\"Invalid value!\")\n",
        "```  \n",
        "\n",
        "### **2. Using a Tuple of Exceptions**\n",
        "If multiple exceptions should be handled the same way, they can be grouped in a tuple.  \n",
        "```python\n",
        "try:\n",
        "    x = int(\"abc\")  # Causes ValueError\n",
        "except (ZeroDivisionError, ValueError) as e:\n",
        "    print(f\"Error occurred: {e}\")\n",
        "```  \n",
        "\n",
        "### **3. Using `except Exception` for All Errors**\n",
        "Catching `Exception` handles all errors, but it should be used cautiously to avoid masking unexpected issues.  \n",
        "```python\n",
        "try:\n",
        "    x = 10 / 0\n",
        "except Exception as e:\n",
        "    print(f\"An error occurred: {e}\")\n",
        "```  \n",
        "\n",
        "Using specific exceptions is generally better for debugging and code clarity."
      ],
      "metadata": {
        "id": "ZzXyJdGOHVvq"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "8.What is the purpose of the with statement when handling files in Python?"
      ],
      "metadata": {
        "id": "bBsDPDK-HeQO"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "The `with` statement in Python is used when handling files to ensure **proper resource management**. It **automatically closes the file** after execution, even if an exception occurs, preventing resource leaks and making the code cleaner.  \n",
        "\n",
        "### **Example Without `with` (Manual Closing Required)**  \n",
        "```python\n",
        "file = open(\"example.txt\", \"r\")\n",
        "content = file.read()\n",
        "file.close()  # Must be closed manually\n",
        "```  \n",
        "\n",
        "### **Example With `with` (Automatic Closing)**  \n",
        "```python\n",
        "with open(\"example.txt\", \"r\") as file:\n",
        "    content = file.read()  # File closes automatically after the block\n",
        "```  \n",
        "\n",
        "### **Advantages of Using `with`**\n",
        "- **Automatic resource cleanup** (file is closed even if an error occurs).  \n",
        "- **More readable and concise** code.  \n",
        "- **Prevents memory leaks** by ensuring proper file closure.  \n",
        "\n",
        "It is the recommended way to handle files in Python."
      ],
      "metadata": {
        "id": "f_8E5Rz5Hsop"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "9. What is the difference between multithreading and multiprocessing?\n"
      ],
      "metadata": {
        "id": "dIgpAiJRH1ah"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "The main difference between **multithreading** and **multiprocessing** in Python lies in how tasks are executed and how they utilize system resources.  \n",
        "\n",
        "### **1. Multithreading**  \n",
        "- Uses **multiple threads** within the **same process** to perform tasks concurrently.  \n",
        "- Threads **share memory** and resources, making communication easier but causing potential race conditions.  \n",
        "- Due to Python's **Global Interpreter Lock (GIL)**, multithreading does not achieve true parallelism for CPU-bound tasks but works well for I/O-bound tasks like file handling and network requests.  \n",
        "- Implemented using the `threading` module.  \n",
        "\n",
        "**Example:**  \n",
        "```python\n",
        "import threading\n",
        "\n",
        "def task():\n",
        "    print(\"Thread running\")\n",
        "\n",
        "t = threading.Thread(target=task)\n",
        "t.start()\n",
        "```\n",
        "\n",
        "### **2. Multiprocessing**  \n",
        "- Uses **multiple processes**, each with its **own memory space**, achieving true parallelism.  \n",
        "- Ideal for CPU-bound tasks like data processing and mathematical computations since each process runs independently.  \n",
        "- More resource-intensive but avoids GIL limitations.  \n",
        "- Implemented using the `multiprocessing` module.  \n",
        "\n",
        "**Example:**  \n",
        "```python\n",
        "import multiprocessing\n",
        "\n",
        "def task():\n",
        "    print(\"Process running\")\n",
        "\n",
        "p = multiprocessing.Process(target=task)\n",
        "p.start()\n",
        "```\n",
        "\n",
        "### **Key Differences**  \n",
        "| Feature         | Multithreading | Multiprocessing |\n",
        "|---------------|---------------|---------------|\n",
        "| Execution | Concurrent (shared memory) | Parallel (separate memory) |\n",
        "| Resource Usage | Low (same process) | High (separate processes) |\n",
        "| Best For | I/O-bound tasks | CPU-bound tasks |\n",
        "| GIL Impact | Affected | Not affected |\n",
        "\n",
        "Multiprocessing is better for CPU-heavy tasks, while multithreading is useful for tasks involving waiting (e.g., network requests, file I/O)."
      ],
      "metadata": {
        "id": "sqr8XBC-H64x"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Logging in a program provides several advantages, making debugging, monitoring, and maintaining software easier and more efficient:  \n",
        "\n",
        "1. **Debugging and Troubleshooting** – Helps track errors and unexpected behavior without using excessive `print()` statements.  \n",
        "2. **Better Control** – Supports different log levels (`DEBUG`, `INFO`, `WARNING`, `ERROR`, `CRITICAL`), allowing selective message filtering.  \n",
        "3. **Persistent Record Keeping** – Logs can be stored in files for later analysis, useful in long-running applications.  \n",
        "4. **Easier Maintenance** – Helps developers understand application behavior over time and identify patterns in failures.  \n",
        "5. **Improves Performance** – Unlike `print()`, logging can be configured to output only necessary information, reducing console clutter.  \n",
        "6. **Thread-Safe and Multiprocess Compatible** – Works efficiently in multi-threaded and multi-process applications.  \n",
        "7. **Customizable Output** – Can log messages to files, databases, or remote servers instead of just the console.  \n",
        "\n",
        "### **Example:**  \n",
        "```python\n",
        "import logging\n",
        "\n",
        "logging.basicConfig(filename=\"app.log\", level=logging.INFO, format=\"%(asctime)s - %(levelname)s - %(message)s\")\n",
        "\n",
        "logging.info(\"Application started\")\n",
        "logging.warning(\"Low disk space warning!\")\n",
        "logging.error(\"An error occurred\")\n",
        "```\n",
        "This logs messages to `app.log`, providing a structured way to monitor program execution."
      ],
      "metadata": {
        "id": "ufbuCV0JITqs"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "11. What is memory management in Python?\n"
      ],
      "metadata": {
        "id": "aEYwCzYrIfD_"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Memory management in Python refers to how the interpreter **allocates, tracks, and deallocates memory** for variables, objects, and data structures during program execution. Python manages memory automatically using **reference counting** and **garbage collection** to free unused memory.  \n",
        "\n",
        "### **Key Features of Python's Memory Management:**  \n",
        "1. **Automatic Memory Allocation** – Python dynamically allocates memory for objects when they are created.  \n",
        "2. **Reference Counting** – Each object keeps track of the number of references to it; when this count drops to zero, the object is deleted.  \n",
        "3. **Garbage Collection (GC)** – Python uses a garbage collector to remove objects with circular references that are no longer accessible.  \n",
        "4. **Memory Pools (PyMalloc)** – Python optimizes memory usage by reusing small memory blocks through a private heap.  \n",
        "5. **`del` Statement** – Manually deletes references to objects, reducing memory usage.  \n",
        "\n",
        "### **Example:**  \n",
        "```python\n",
        "import gc\n",
        "\n",
        "a = [1, 2, 3]  # Memory allocated\n",
        "b = a          # Reference count increases\n",
        "del a          # `b` still holds reference, so memory isn't freed\n",
        "gc.collect()   # Forces garbage collection\n",
        "```\n",
        "Python’s memory management system ensures efficient use of memory without manual intervention, making development easier and safer."
      ],
      "metadata": {
        "id": "nhGP2pYkI0pj"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "12. What are the basic steps involved in exception handling in Python?"
      ],
      "metadata": {
        "id": "GYvU7ee6I6XN"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "The basic steps involved in **exception handling** in Python ensure that errors are caught and handled gracefully, preventing program crashes.  \n",
        "\n",
        "### **1. Try Block (`try`)**  \n",
        "Wrap the code that may raise an exception inside a `try` block.  \n",
        "\n",
        "### **2. Except Block (`except`)**  \n",
        "If an exception occurs, it is caught by an `except` block, where you define how to handle it.  \n",
        "\n",
        "### **3. Else Block (`else`)** *(Optional)*  \n",
        "If no exception occurs, the `else` block executes.  \n",
        "\n",
        "### **4. Finally Block (`finally`)** *(Optional)*  \n",
        "The `finally` block executes **regardless of whether an exception occurs**, useful for cleanup operations like closing files or releasing resources.  \n",
        "\n",
        "### **Example:**  \n",
        "```python\n",
        "try:\n",
        "    x = 10 / 0  # This raises a ZeroDivisionError\n",
        "except ZeroDivisionError:\n",
        "    print(\"Cannot divide by zero!\")\n",
        "else:\n",
        "    print(\"Division successful!\")\n",
        "finally:\n",
        "    print(\"Execution completed.\")  # Always runs\n",
        "```\n",
        "### **Output:**  \n",
        "```\n",
        "Cannot divide by zero!\n",
        "Execution completed.\n",
        "```\n",
        "This structure ensures **controlled error handling** and improves program stability."
      ],
      "metadata": {
        "id": "2fTILqJ1JJgM"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "13. Why is memory management important in Python?"
      ],
      "metadata": {
        "id": "A2NCvPk-JRZo"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Memory management is important in Python because it ensures **efficient use of system resources**, prevents memory leaks, and improves program performance. Since Python dynamically allocates and deallocates memory for objects, **proper memory management prevents excessive memory usage** that can slow down or crash applications.  \n",
        "\n",
        "### **Key Reasons Why Memory Management is Important in Python:**  \n",
        "1. **Prevents Memory Leaks** – Unused objects are automatically removed via garbage collection, preventing memory wastage.  \n",
        "2. **Optimizes Performance** – Efficient memory allocation and deallocation help programs run faster and use less RAM.  \n",
        "3. **Supports Large-Scale Applications** – Proper memory management ensures stability in data-intensive applications.  \n",
        "4. **Automatic Garbage Collection** – Python removes unreferenced objects, reducing manual memory handling.  \n",
        "5. **Efficient Use of Memory Pools** – Python's memory allocator (`PyMalloc`) optimizes memory allocation for small objects, improving execution speed.  \n",
        "\n",
        "### **Example of Inefficient Memory Use:**  \n",
        "```python\n",
        "lst = []\n",
        "while True:  # Infinite loop keeps appending, causing memory bloat\n",
        "    lst.append(\"Memory leak!\")\n",
        "```\n",
        "### **Example of Proper Memory Management:**  \n",
        "```python\n",
        "import gc\n",
        "\n",
        "lst = [1, 2, 3]\n",
        "del lst  # Manually delete reference\n",
        "gc.collect()  # Force garbage collection to free memory\n",
        "```\n",
        "By managing memory properly, Python applications **run efficiently without excessive RAM consumption**."
      ],
      "metadata": {
        "id": "Jr0gDD5-JddX"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "14. What is the role of try and except in exception handling?"
      ],
      "metadata": {
        "id": "mSxJRH7xZlcG"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "The `try` and `except` blocks play a crucial role in **exception handling** in Python by allowing programs to handle errors gracefully without crashing.  \n",
        "\n",
        "### **Role of `try`:**  \n",
        "- The `try` block contains **code that may raise an exception**.  \n",
        "- If no error occurs, the `except` block is skipped.  \n",
        "\n",
        "### **Role of `except`:**  \n",
        "- If an error occurs inside the `try` block, Python jumps to the `except` block instead of stopping the program.  \n",
        "- The `except` block specifies **how to handle the error**.  \n",
        "\n",
        "### **Example:**  \n",
        "```python\n",
        "try:\n",
        "    x = 10 / 0  # This causes a ZeroDivisionError\n",
        "except ZeroDivisionError:\n",
        "    print(\"Cannot divide by zero!\")\n",
        "```\n",
        "### **Output:**  \n",
        "```\n",
        "Cannot divide by zero!\n",
        "```\n",
        "This ensures **controlled error handling**, preventing unexpected program crashes."
      ],
      "metadata": {
        "id": "IX4_qhdvaOu3"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "15.How does Python's garbage collection system work?"
      ],
      "metadata": {
        "id": "H0E2gCs6aTjc"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Python’s **garbage collection (GC) system** automatically manages memory by identifying and deallocating objects that are no longer in use. It prevents **memory leaks** and optimizes performance by reclaiming memory occupied by unused objects.  \n",
        "\n",
        "### **How Python’s Garbage Collection Works:**  \n",
        "1. **Reference Counting** – Each object has a reference count, which increases when assigned to a variable and decreases when a reference is deleted. When the count reaches zero, the object is automatically deallocated.  \n",
        "   ```python\n",
        "   import sys\n",
        "   a = [1, 2, 3]\n",
        "   print(sys.getrefcount(a))  # Reference count increases\n",
        "   del a  # Reference count drops, object gets deleted\n",
        "   ```\n",
        "\n",
        "2. **Garbage Collector (GC) for Circular References** – If two objects reference each other (circular references), their reference count never drops to zero. Python’s **`gc` module** detects and removes such objects.  \n",
        "   ```python\n",
        "   import gc\n",
        "   gc.collect()  # Manually trigger garbage collection\n",
        "   ```\n",
        "\n",
        "3. **Generational Garbage Collection** – Python divides objects into **three generations** based on their lifespan. New objects start in Generation 0, and surviving objects move to higher generations. Older objects are checked less frequently to improve efficiency.\n",
        "\n",
        "### **Why Is This Important?**  \n",
        "- **Prevents memory leaks** by automatically freeing unused memory.  \n",
        "- **Improves performance** by optimizing memory allocation.  \n",
        "- **Reduces manual memory management** required in languages like C.  \n",
        "\n",
        "Python’s GC system ensures efficient **memory management without developer intervention**, making programming easier and safer."
      ],
      "metadata": {
        "id": "jxanwv2OavTV"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "16.What is the purpose of the else block in exception handling?"
      ],
      "metadata": {
        "id": "SuBena59a5CO"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "The **`else` block** in exception handling is used to specify code that should **only run if no exceptions occur** in the `try` block. It helps separate normal execution from error-handling logic, improving code readability and structure.  \n",
        "\n",
        "### **Purpose of the `else` Block:**  \n",
        "1. **Ensures Clarity** – Keeps the main logic separate from error handling.  \n",
        "2. **Executes Only if No Errors Occur** – If an exception occurs in `try`, the `else` block is skipped.  \n",
        "3. **Improves Code Structure** – Helps differentiate successful execution from error handling.  \n",
        "\n",
        "### **Example Usage:**  \n",
        "```python\n",
        "try:\n",
        "    num = int(input(\"Enter a number: \"))  # May raise ValueError\n",
        "except ValueError:\n",
        "    print(\"Invalid input! Please enter a number.\")\n",
        "else:\n",
        "    print(f\"Success! You entered {num}.\")\n",
        "```\n",
        "### **Scenario 1: Valid Input (No Exception)**\n",
        "```\n",
        "Enter a number: 10  \n",
        "Success! You entered 10.\n",
        "```\n",
        "### **Scenario 2: Invalid Input (Exception Occurs)**\n",
        "```\n",
        "Enter a number: hello  \n",
        "Invalid input! Please enter a number.\n",
        "```\n",
        "Here, the `else` block executes **only when `try` succeeds**, ensuring clear and structured exception handling."
      ],
      "metadata": {
        "id": "kyWfyTfLa-zX"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "17. What are the common logging levels in Python?\n"
      ],
      "metadata": {
        "id": "ghKewUPDbL0i"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "In Python, the **logging module** provides several logging levels to categorize messages based on their importance. These levels help in **debugging, monitoring, and troubleshooting applications** efficiently.  \n",
        "\n",
        "### **Common Logging Levels in Python:**  \n",
        "1. **DEBUG (10)** – Used for **detailed diagnostic information** during development.  \n",
        "   ```python\n",
        "   logging.debug(\"This is a debug message.\")\n",
        "   ```\n",
        "2. **INFO (20)** – Used for **general information** about program execution.  \n",
        "   ```python\n",
        "   logging.info(\"Application started successfully.\")\n",
        "   ```\n",
        "3. **WARNING (30)** – Indicates a **potential issue** that does not stop execution.  \n",
        "   ```python\n",
        "   logging.warning(\"Low disk space warning.\")\n",
        "   ```\n",
        "4. **ERROR (40)** – Indicates a **serious issue** that prevents part of the program from running.  \n",
        "   ```python\n",
        "   logging.error(\"File not found!\")\n",
        "   ```\n",
        "5. **CRITICAL (50)** – Indicates a **severe error** that may cause the program to crash.  \n",
        "   ```python\n",
        "   logging.critical(\"System failure! Shutting down.\")\n",
        "   ```\n",
        "\n",
        "### **Example Usage:**  \n",
        "```python\n",
        "import logging\n",
        "logging.basicConfig(level=logging.DEBUG)  # Set logging level\n",
        "logging.info(\"This is an informational message.\")\n",
        "logging.error(\"An error occurred.\")\n",
        "```\n",
        "These levels allow developers to control the amount of logging output and filter messages based on their importance."
      ],
      "metadata": {
        "id": "G5-1wldpbip1"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "18.What is the difference between os.fork() and multiprocessing in Python?"
      ],
      "metadata": {
        "id": "aE_P5b5qbo6x"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "The main difference between `os.fork()` and the `multiprocessing` module in Python lies in their approach to **creating new processes**, platform compatibility, and usability.  \n",
        "\n",
        "### **1. `os.fork()` (Low-Level, Unix-Only)**  \n",
        "- **Creates a child process** by duplicating the parent process.  \n",
        "- Returns **0 in the child process** and the **child’s PID in the parent**.  \n",
        "- **Only available on Unix/Linux** (not supported on Windows).  \n",
        "- Requires **manual process management** (e.g., `os.wait()` to avoid zombie processes).  \n",
        "- **Shares memory** (copy-on-write), but modifying shared objects can cause issues.  \n",
        "\n",
        "#### **Example of `os.fork()`:**  \n",
        "```python\n",
        "import os\n",
        "\n",
        "pid = os.fork()\n",
        "if pid == 0:\n",
        "    print(\"Child process executing\")\n",
        "else:\n",
        "    print(f\"Parent process, child PID: {pid}\")\n",
        "```\n",
        "\n",
        "---\n",
        "\n",
        "### **2. `multiprocessing` (High-Level, Cross-Platform)**  \n",
        "- **Provides a more user-friendly API** for spawning processes.  \n",
        "- Works on **both Windows and Unix** using different mechanisms (`fork` on Unix, `spawn` on Windows).  \n",
        "- Creates **separate memory spaces**, avoiding shared-memory issues.  \n",
        "- Supports **process pools, queues, and shared data structures**.  \n",
        "- Handles process cleanup automatically.  \n",
        "\n",
        "#### **Example of `multiprocessing`:**  \n",
        "```python\n",
        "from multiprocessing import Process\n",
        "\n",
        "def worker():\n",
        "    print(\"Worker process executing\")\n",
        "\n",
        "p = Process(target=worker)\n",
        "p.start()\n",
        "p.join()  # Waits for the process to finish\n",
        "```\n",
        "\n",
        "---\n",
        "\n",
        "### **Key Differences:**\n",
        "| Feature          | `os.fork()` | `multiprocessing` |\n",
        "|-----------------|------------|------------------|\n",
        "| **Platform**    | Unix/Linux only | Cross-platform (Windows & Unix) |\n",
        "| **API Level**   | Low-level (manual management) | High-level (easier to use) |\n",
        "| **Memory Sharing** | Shared (copy-on-write) | Separate memory spaces |\n",
        "| **Process Control** | Manual (`os.wait()`) | Automatic (`Process.join()`) |\n",
        "| **Use Case**    | When low-level process control is needed | For parallel computing in a portable way |\n",
        "\n",
        "If you need **cross-platform support and easier process management**, use `multiprocessing`. If you're on **Unix and require low-level control**, `os.fork()` might be useful."
      ],
      "metadata": {
        "id": "OkFdENgObzdY"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "19.What is the importance of closing a file in Python?\n"
      ],
      "metadata": {
        "id": "5lEGnN8ucK-y"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Closing a file in Python is important because it **frees system resources**, **ensures data is saved**, and **prevents file corruption**. When a file is opened using `open()`, the operating system allocates resources to it. If the file is not properly closed using `file.close()`, it can lead to issues such as **memory leaks, unflushed data, or file locks**.  \n",
        "\n",
        "### **Key Reasons to Close a File:**  \n",
        "1. **Frees System Resources** – Prevents excessive open file handles, which can slow down the system.  \n",
        "2. **Ensures Data Integrity** – Any buffered data is written to the file before closing, preventing data loss.  \n",
        "3. **Avoids File Corruption** – Particularly important when writing to a file.  \n",
        "4. **Prevents File Locking Issues** – Some operating systems lock open files, preventing modifications by other programs.  \n",
        "\n",
        "### **Example Without Closing the File:**  \n",
        "```python\n",
        "file = open(\"example.txt\", \"w\")\n",
        "file.write(\"Hello, World!\")\n",
        "# Forgot to close the file – data might not be saved immediately!\n",
        "```\n",
        "\n",
        "### **Example with Proper Closing:**  \n",
        "```python\n",
        "file = open(\"example.txt\", \"w\")\n",
        "file.write(\"Hello, World!\")\n",
        "file.close()  # Ensures data is saved and resources are freed\n",
        "```\n",
        "\n",
        "### **Using `with` for Automatic Closing:**  \n",
        "A better practice is using the `with` statement, which **automatically closes the file** when the block ends.  \n",
        "```python\n",
        "with open(\"example.txt\", \"w\") as file:\n",
        "    file.write(\"Hello, World!\")  # File closes automatically after this block\n",
        "```\n",
        "This ensures that files are always properly closed, **even if an exception occurs**."
      ],
      "metadata": {
        "id": "W5P4bh2VcQfK"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "20.What is the difference between file.read() and file.readline() in Python?\n"
      ],
      "metadata": {
        "id": "8DT0z0FbcbDr"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "The difference between `file.read()` and `file.readline()` in Python lies in how they read data from a file:  \n",
        "\n",
        "### **1. `file.read()` – Reads the Entire File or a Given Number of Bytes**  \n",
        "- Reads the **entire file** as a single string (or up to a specified number of bytes).  \n",
        "- Can be **memory-intensive** if the file is large.  \n",
        "- Example:  \n",
        "  ```python\n",
        "  with open(\"example.txt\", \"r\") as file:\n",
        "      content = file.read()  # Reads the entire file\n",
        "      print(content)\n",
        "  ```\n",
        "\n",
        "- Reading a specific number of bytes:  \n",
        "  ```python\n",
        "  with open(\"example.txt\", \"r\") as file:\n",
        "      content = file.read(10)  # Reads the first 10 characters\n",
        "      print(content)\n",
        "  ```\n",
        "\n",
        "---\n",
        "\n",
        "### **2. `file.readline()` – Reads a Single Line at a Time**  \n",
        "- Reads **only one line** at a time from the file.  \n",
        "- Useful for **processing files line by line** (e.g., logs, CSV files).  \n",
        "- Example:  \n",
        "  ```python\n",
        "  with open(\"example.txt\", \"r\") as file:\n",
        "      line1 = file.readline()  # Reads the first line\n",
        "      print(line1)\n",
        "  ```\n",
        "\n",
        "- To read multiple lines one by one:  \n",
        "  ```python\n",
        "  with open(\"example.txt\", \"r\") as file:\n",
        "      for line in file:\n",
        "          print(line.strip())  # Reads and prints each line\n",
        "  ```\n",
        "\n",
        "---\n",
        "\n",
        "### **Key Differences:**\n",
        "| Feature         | `file.read()`          | `file.readline()`        |\n",
        "|---------------|----------------------|----------------------|\n",
        "| **Reads**      | Entire file (or specified bytes) | One line at a time |\n",
        "| **Memory Usage** | High (for large files) | Low (efficient for large files) |\n",
        "| **Return Type**  | String | String (single line) |\n",
        "| **Use Case**    | Reading the whole file at once | Processing line by line |\n",
        "\n",
        "If working with **large files**, use `file.readline()` or **iterate** over the file to avoid high memory usage."
      ],
      "metadata": {
        "id": "1IZFyqUlcgea"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "21.What is the logging module in Python used for?\n"
      ],
      "metadata": {
        "id": "tSzaoaIIczI3"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "The **logging module** in Python is used for **tracking events, debugging, and monitoring applications** by recording messages at different severity levels. It helps developers log information about program execution, errors, warnings, and system behavior in a structured way.  \n",
        "\n",
        "### **Key Features of the `logging` Module:**  \n",
        "- Provides different **logging levels** (DEBUG, INFO, WARNING, ERROR, CRITICAL).  \n",
        "- Allows logging to **console, files, or external systems**.  \n",
        "- Supports **custom log formatting**.  \n",
        "- Helps with **troubleshooting and debugging** without cluttering the main code.  \n",
        "- Can be configured to **filter logs based on severity**.  \n",
        "\n",
        "### **Basic Example of Logging in Python:**  \n",
        "```python\n",
        "import logging\n",
        "\n",
        "logging.basicConfig(level=logging.INFO)  # Set logging level\n",
        "logging.info(\"Application started\")\n",
        "logging.warning(\"Low disk space warning\")\n",
        "logging.error(\"File not found!\")\n",
        "```\n",
        "\n",
        "### **Logging to a File:**  \n",
        "```python\n",
        "logging.basicConfig(filename=\"app.log\", level=logging.DEBUG, format=\"%(asctime)s - %(levelname)s - %(message)s\")\n",
        "logging.debug(\"Debugging message logged\")\n",
        "```\n",
        "\n",
        "The `logging` module is widely used in production applications to **diagnose issues, monitor system health, and generate audit logs** efficiently."
      ],
      "metadata": {
        "id": "7TBCZKQjc3ko"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "22. What is the os module in Python used for in file handling?\n"
      ],
      "metadata": {
        "id": "_wMjlQUtdFNT"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "The **`os` module** in Python is used for **interacting with the operating system**, including **file handling operations** like creating, deleting, renaming, and navigating directories. It provides functions to work with files and directories in a platform-independent way.  \n",
        "\n",
        "### **Key File Handling Functions in `os` Module:**  \n",
        "1. **Check if a file exists:**  \n",
        "   ```python\n",
        "   import os\n",
        "   print(os.path.exists(\"example.txt\"))  # Returns True if the file exists\n",
        "   ```\n",
        "\n",
        "2. **Create a directory:**  \n",
        "   ```python\n",
        "   os.mkdir(\"new_folder\")  # Creates a new folder\n",
        "   ```\n",
        "\n",
        "3. **Remove a file:**  \n",
        "   ```python\n",
        "   os.remove(\"example.txt\")  # Deletes a file\n",
        "   ```\n",
        "\n",
        "4. **Rename a file:**  \n",
        "   ```python\n",
        "   os.rename(\"old.txt\", \"new.txt\")  # Renames a file\n",
        "   ```\n",
        "\n",
        "5. **Get the current working directory:**  \n",
        "   ```python\n",
        "   print(os.getcwd())  # Prints the current directory\n",
        "   ```\n",
        "\n",
        "6. **List files in a directory:**  \n",
        "   ```python\n",
        "   print(os.listdir(\".\"))  # Lists all files and folders in the current directory\n",
        "   ```\n",
        "\n",
        "7. **Remove a directory:**  \n",
        "   ```python\n",
        "   os.rmdir(\"new_folder\")  # Deletes an empty directory\n",
        "   ```\n",
        "\n",
        "### **Why Use the `os` Module for File Handling?**  \n",
        "- **Cross-platform compatibility** (works on Windows, Linux, macOS).  \n",
        "- **Efficient file and directory management** without manual intervention.  \n",
        "- **Automates file system operations** in scripts and applications.  \n",
        "\n",
        "For advanced file handling, **`shutil`** (for copying/moving files) and **`pathlib`** (modern file path handling) can also be useful."
      ],
      "metadata": {
        "id": "nOqpymLhdJMQ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "23.What are the challenges associated with memory management in Python?"
      ],
      "metadata": {
        "id": "oFX0V6d_dYFe"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Memory management in Python comes with several challenges due to its dynamic nature, automatic memory handling, and the use of **garbage collection**. Here are the primary challenges associated with memory management in Python:\n",
        "\n",
        "### 1. **Garbage Collection and Cyclic References**  \n",
        "- Python uses a **garbage collector** to manage memory automatically, but **cyclic references** (objects that reference each other) can create issues where memory is not properly freed.  \n",
        "- Even though Python's garbage collector detects and cleans up cyclic references, it’s not always immediate, leading to memory **bloating** or delays in deallocation.\n",
        "\n",
        "### 2. **Memory Leaks**  \n",
        "- While Python handles most memory allocation and deallocation automatically, **memory leaks** can still occur when objects are not properly dereferenced or when large data structures are retained unnecessarily.  \n",
        "- For example, **circular references** (where objects reference each other) can lead to memory not being freed even after objects are no longer needed.\n",
        "\n",
        "### 3. **Memory Fragmentation**  \n",
        "- Memory fragmentation can occur in systems where memory is allocated and deallocated in small chunks, potentially leading to inefficient use of memory, particularly for long-running programs.  \n",
        "- This issue may not always be visible but can become critical in **resource-constrained environments** (like embedded systems).\n",
        "\n",
        "### 4. **Managing Large Objects**  \n",
        "- Handling **large objects** (e.g., large datasets, images, or large files) may cause the **memory footprint** to grow rapidly, leading to inefficient memory usage.  \n",
        "- Python’s memory model does not provide manual control over memory allocations (unlike languages like C/C++), so developers need to be mindful of the data they store and manage in memory.\n",
        "\n",
        "### 5. **Object Overhead**  \n",
        "- Every Python object, including basic data types like integers and strings, has some **overhead** due to internal data structure management (e.g., reference counting, type information).  \n",
        "- This overhead means that Python's memory usage may be higher compared to low-level languages, and developers need to be aware of how much memory their programs are consuming, especially when dealing with large numbers of small objects.\n",
        "\n",
        "### 6. **Unpredictable Garbage Collection**  \n",
        "- Python's garbage collection process is **non-deterministic**, meaning that the timing of when memory is actually freed can be unpredictable.  \n",
        "- The **reference counting** system ensures that objects are deallocated when their reference count drops to zero, but the garbage collector’s handling of cycles can delay memory release, especially in complex programs.\n",
        "\n",
        "### 7. **Global Interpreter Lock (GIL)**  \n",
        "- The **GIL** (in CPython) can lead to memory management inefficiencies when multi-threading is used, as it limits concurrent execution of Python bytecode. While this does not directly affect memory management, it impacts the **performance** of memory-intensive operations in multi-threaded environments.\n",
        "\n",
        "### 8. **Limited Control Over Memory Allocation**  \n",
        "- Unlike languages like C or C++, Python does not provide **fine-grained control over memory allocation**. Developers cannot allocate or free memory directly, which can make optimizing memory usage for complex data structures or algorithms challenging.\n",
        "\n"
      ],
      "metadata": {
        "id": "MAR6vzEsdcQ7"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "24.How do you raise an exception manually in Python?\n"
      ],
      "metadata": {
        "id": "U1DGMXBzdwFi"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "In Python, you can raise an exception manually using the `raise` keyword followed by an instance of an exception class. Here's the general syntax:\n",
        "\n",
        "```python\n",
        "raise ExceptionType(\"Error message\")\n",
        "```\n",
        "\n",
        "Where `ExceptionType` is the type of the exception you want to raise (e.g., `ValueError`, `TypeError`, `CustomError`, etc.), and `\"Error message\"` is an optional message providing more details about the error.\n",
        "\n",
        "### **Example of Raising an Exception:**\n",
        "\n",
        "1. **Raising a built-in exception:**\n",
        "   ```python\n",
        "   raise ValueError(\"Invalid input value!\")\n",
        "   ```\n",
        "\n",
        "2. **Raising a custom exception:**\n",
        "   You can define your own exception class by inheriting from the `Exception` class, then raise it as needed.\n",
        "   ```python\n",
        "   class CustomError(Exception):\n",
        "       def __init__(self, message):\n",
        "           self.message = message\n",
        "           super().__init__(self.message)\n",
        "\n",
        "   raise CustomError(\"This is a custom error!\")\n",
        "   ```\n",
        "\n",
        "3. **Raising exceptions with conditions:**\n",
        "   You can raise an exception based on specific conditions in your program:\n",
        "   ```python\n",
        "   age = -5\n",
        "   if age < 0:\n",
        "       raise ValueError(\"Age cannot be negative!\")\n",
        "   ```\n",
        "\n",
        "Raising exceptions manually is useful when you want to signal errors in your code or when something goes wrong in a specific scenario that you define."
      ],
      "metadata": {
        "id": "ZNy4tcPKd05e"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "25. Why is it important to use multithreading in certain applications?"
      ],
      "metadata": {
        "id": "kd6BBvkMd98n"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Multithreading is important in certain applications because it allows for **concurrent execution of tasks**, which can significantly improve performance and responsiveness, especially in scenarios where multiple operations can be performed independently. Here are some reasons why using multithreading is crucial in specific applications:\n",
        "\n",
        "### 1. **Improved Performance and Efficiency**  \n",
        "- Multithreading allows an application to perform **multiple tasks simultaneously**, making better use of **multi-core processors**. For example, one thread can handle I/O operations, while others perform computations, reducing idle CPU time and speeding up overall execution.\n",
        "  \n",
        "### 2. **Better Resource Utilization**  \n",
        "- **I/O-bound tasks**, like reading files, making network requests, or interacting with databases, often involve waiting for external resources. Using multithreading can allow the CPU to continue executing other tasks while waiting for I/O operations to complete, improving the system's responsiveness.\n",
        "  \n",
        "### 3. **Responsiveness in GUI Applications**  \n",
        "- In **graphical user interface (GUI)** applications, the main thread is responsible for handling user input and updating the interface. If a time-consuming task is run on the main thread, the application becomes unresponsive. By using multithreading, these tasks can be offloaded to background threads, keeping the interface responsive.\n",
        "\n",
        "### 4. **Real-time Applications**  \n",
        "- In **real-time systems**, where tasks must be completed within specific time constraints (e.g., gaming, embedded systems, or robotics), multithreading can allow different parts of the system to operate simultaneously, meeting deadlines and ensuring the system performs as expected.\n",
        "\n",
        "### 5. **Parallelism for Computational Tasks**  \n",
        "- **CPU-bound tasks** (tasks that require significant computation) can be parallelized across multiple threads to **distribute the load** across multiple processor cores, resulting in faster execution. This is especially beneficial in applications like scientific computing, machine learning, and simulations.\n",
        "\n",
        "### 6. **Better Scalability**  \n",
        "- Multithreading enables an application to scale effectively with the **number of available CPU cores**. As hardware improves (with more cores), multithreaded applications can take advantage of this extra processing power without needing significant changes in the codebase.\n",
        "\n",
        "### 7. **Asynchronous Task Handling**  \n",
        "- For applications that handle many independent tasks concurrently (such as **web servers** or **network applications**), multithreading allows tasks to be processed asynchronously without blocking the main thread, ensuring continuous operation and efficient handling of requests.\n",
        "\n",
        "---\n",
        "\n",
        "In summary, multithreading is essential for enhancing **performance, responsiveness, and resource efficiency**, especially in applications involving **parallel processing**, **I/O-bound operations**, and **real-time tasks**."
      ],
      "metadata": {
        "id": "KQe2QKN5eBaA"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# PRACTICAL QUESTIONS"
      ],
      "metadata": {
        "id": "EIgFlUhxebAp"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "1.How can you open a file for writing in Python and write a string to it?\n"
      ],
      "metadata": {
        "id": "RRr5ETcEei6o"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "with open(\"file1.txt\" ,\"w\") as file:\n",
        "  file.writelines(\"this is a strign\\nhello\")"
      ],
      "metadata": {
        "id": "cR5MZyh1Hn4M"
      },
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "2. Write a Python program to read the contents of a file and print each line."
      ],
      "metadata": {
        "id": "55P0YXkErVWX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#downloading file to read\n",
        "import urllib.request as u\n",
        "url=\"https://raw.githubusercontent.com/khp11/khp/refs/heads/master/requirements.txt\"\n",
        "u.urlretrieve(url,\"dwd.txt\")\n",
        "#reading the file\n",
        "\n",
        "with open(\"dwd.txt\", \"r\") as f:\n",
        "  for i in f:\n",
        "    print(i)\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "70SKxQHFrYm0",
        "outputId": "5c28bbe1-0696-43e7-e886-df8c044817c3"
      },
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Verification Check: Implement an additional verification mechanism to cross-check the payment status between G2A and Bitbay before processing and delivering an order.\n",
            "\n",
            "Timezone Manipulation Detection: Detect and block any suspicious changes in browser timezone settings during the payment process.\n",
            "\n",
            "Auditing and Monitoring: Enhance logging and monitoring to detect and flag potentially fraudulent activities, such as rapid timezone changes or mismatched order statuses.\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "3.How would you handle a case where the file doesn't exist while trying to open it for reading?\n"
      ],
      "metadata": {
        "id": "YzL6d5Rbx7Q-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "try:\n",
        "  with open(\"dwds.txt\") as f:\n",
        "      f.read()\n",
        "except FileNotFoundError:\n",
        "  print(\"No such file exist currenlty named like that\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fUVIlruZx5q5",
        "outputId": "03423e46-f222-4781-fca2-3d2f1ed16c82"
      },
      "execution_count": 41,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "no such file exist currenlty named like that\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "4.Write a Python script that reads from one file and writes its content to another file.\n"
      ],
      "metadata": {
        "id": "CYIb9DAfzH6A"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#downloading file\n",
        "import urllib.request as u\n",
        "u.urlretrieve(\"https://raw.githubusercontent.com/khp11/khp/refs/heads/master/requirements.txt\",\"newdw.txt\")\n",
        "with open(\"newdw.txt\" , \"r\") as fr:\n",
        "  with open(\"newwr.txt\" ,\"w\") as fd:\n",
        "    fd.write(fr.read())"
      ],
      "metadata": {
        "id": "z6JLOXzK1EnN"
      },
      "execution_count": 30,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "5.How would you catch and handle division by zero error in Python?\n"
      ],
      "metadata": {
        "id": "qrCT-_YI_s9l"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def divison(a,b):\n",
        "  try :\n",
        "\n",
        "    return a/b\n",
        "\n",
        "  except ZeroDivisionError:\n",
        "      print(\"cant divide by zero\")\n",
        "\n",
        "print(divison(9,9))\n",
        "divison(9,0)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NJZ7tFf__xPC",
        "outputId": "f6b0d6da-fad2-4326-90b1-7d6fc2faf78a"
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1.0\n",
            "cant divide by zero\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "6.Write a Python program that logs an error message to a log file when a division by zero exception occurs.\n"
      ],
      "metadata": {
        "id": "J83yYl2tAlov"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import logging\n",
        "#set logging method for rootlogger\n",
        "#logging.basicConfig(level=logging.error)\n",
        "\n",
        "#create individual logger\n",
        "logger1 = logging.getLogger(\"logger1\")\n",
        "logger2 = logging.getLogger(\"logger2\")\n",
        "\n",
        "#set different levels for each logger\n",
        "logger1.setLevel(logging.INFO)\n",
        "logger2.setLevel(logging.ERROR)\n",
        "\n",
        "#filehandler creation\n",
        "fh1 = logging.FileHandler(\"fh1.log\" ,mode=\"a\",delay =False)\n",
        "fh2 = logging.FileHandler(\"fh2.log\",mode =\"a\",delay=False)\n",
        "#setting level of file handler\n",
        "fh1.setLevel(logging.INFO)\n",
        "fh2.setLevel(logging.ERROR)\n",
        "#formatting the log file\n",
        "formatter = logging.Formatter(\"%(asctime)s-%(message)s\")\n",
        "fh1.setFormatter(formatter)\n",
        "fh2.setFormatter(formatter)\n",
        "#adding file handler to loggers\n",
        "logger1.addHandler(fh1)\n",
        "logger2.addHandler(fh2)\n",
        "\n",
        "def divison(a,b):\n",
        "  try :\n",
        "    c=a/b\n",
        "    logger1.info(f\"division of {a}/{b} is attempted\")\n",
        "    return c\n",
        "\n",
        "  except ZeroDivisionError:\n",
        "      print(\"cant divide by zero\")\n",
        "      logger2.error(\"!!!Divison by Zero attempted\")\n",
        "\n",
        "\n",
        "print(divison(9,9))\n",
        "divison(9,0)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AZ1j5_xAAjMX",
        "outputId": "868f975b-69a3-4c60-cd2f-e85e92801740"
      },
      "execution_count": 109,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "INFO:logger1:division of 9/9 is attempted\n",
            "ERROR:logger2:!!!Divison by Zero attempted\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1.0\n",
            "cant divide by zero\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "7 How do you log information at different levels (INFO, ERROR, WARNING) in Python using the logging module?"
      ],
      "metadata": {
        "id": "WI66a-CKDlf5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import logging\n",
        "\n",
        "logger1 = logging.getLogger(\"logger1\")\n",
        "logger1.setLevel(logging.INFO)\n",
        "fh1 = logging.FileHandler(\"m.log\", mode = \"a\", delay= False)\n",
        "fh1.setLevel(logging.INFO)\n",
        "formatter = logging.Formatter(\"%(asctime)s-%(message)s\")\n",
        "fh1.setFormatter(formatter)\n",
        "logger1.addHandler(fh1)\n",
        "#logging.basicConfig(level=logging.INFO,filename=\"m.log\",filemode=\"a\", format=\"%(asctime)s-%(levelname)s-%(message)s\")\n",
        "def division(a,b):\n",
        "  if b<0.000001 and b>0:\n",
        "    logging.warning(\"very unusual attempt of divison taken\")\n",
        "\n",
        "  try :\n",
        "    c = a/b\n",
        "    logger1.info(f\"division attempted {a}/{b}\")\n",
        "    return c\n",
        "  except ZeroDivisionError:\n",
        "    #print(\"cant be divide by zero\")\n",
        "    logger1.error(\"cant be divided by zero\")\n",
        "\n",
        "\n",
        "division(9,0)\n",
        "print(division(9,0.00000001))\n",
        "division(9,9)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3TBjVpYWDrut",
        "outputId": "3a409578-53cd-43c0-81c0-8b81a02d0c1c"
      },
      "execution_count": 118,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "ERROR:logger1:cant be divided by zero\n",
            "WARNING:root:very unusual attempt of divison taken\n",
            "INFO:logger1:division attempted 9/1e-08\n",
            "INFO:logger1:division attempted 9/9\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "900000000.0\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1.0"
            ]
          },
          "metadata": {},
          "execution_count": 118
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "8.Write a program to handle a file opening error using exception handling.\n"
      ],
      "metadata": {
        "id": "iUf5D3_iIo8C"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import urllib.request as u\n",
        "u.urlretrieve(\"https://raw.githubusercontent.com/khp11/khp/refs/heads/master/requirements.txt\",\"fnew.txt\")\n",
        "\n",
        "try:\n",
        "    # Attempt to open a file in read mode\n",
        "    with open(\"fnew.txt\", \"r\") as file:\n",
        "        content = file.read()\n",
        "        print(content)\n",
        "\n",
        "except FileNotFoundError:\n",
        "    print(\"Error: The file does not exist. Please check the file name and try again.\")\n",
        "\n",
        "except PermissionError:\n",
        "    print(\"Error: You do not have permission to access this file.\")\n",
        "\n",
        "except IsADirectoryError:\n",
        "    print(\"Error: Expected a file but found a directory instead.\")\n",
        "\n",
        "except IOError:\n",
        "    print(\"Error: An I/O error occurred while accessing the file.\")\n",
        "\n",
        "except Exception as e:\n",
        "    print(f\"An unexpected error occurred: {e}\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OMaYKTleIocy",
        "outputId": "ac36ee9a-5ff8-41f6-fa58-02aaf251b1c3"
      },
      "execution_count": 61,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "kine1-Implement an additional verification mechanism to cross-check the payment status between G2A and Bitbay before processing and delivering an order.\n",
            "line2- Detect and block any suspicious changes in browser timezone settings during the payment process.\n",
            "line3-Enhance logging and monitoring to detect and flag potentially fraudulent activities, such as rapid timezone changes or mismatched order statuses.\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "9.How can you read a file line by line and store its content in a list in Python?\n"
      ],
      "metadata": {
        "id": "6DKV_avXPMRM"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import urllib.request as u\n",
        "u.urlretrieve(\"https://raw.githubusercontent.com/khp11/khp/refs/heads/master/requirements.txt\", \"fnew2.txt\")\n",
        "contentnlist=[]\n",
        "with open(\"fnew2.txt\" , \"r\") as file:\n",
        "  #contentlist = file.readlines()\n",
        "  for line in file:\n",
        "    contentnlist.append(line)\n",
        "\n",
        "contentnlist\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8ARlrZcxPaDs",
        "outputId": "7dbb6e09-12a2-409a-c55e-5be67e54dc71"
      },
      "execution_count": 70,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['kine1-Implement an additional verification mechanism to cross-check the payment status between G2A and Bitbay before processing and delivering an order.\\n',\n",
              " 'line2- Detect and block any suspicious changes in browser timezone settings during the payment process.\\n',\n",
              " 'line3-Enhance logging and monitoring to detect and flag potentially fraudulent activities, such as rapid timezone changes or mismatched order statuses.\\n']"
            ]
          },
          "metadata": {},
          "execution_count": 70
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "10.How can you append data to an existing file in Python?"
      ],
      "metadata": {
        "id": "MyR5dfoFTHRZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import urllib.request as u\n",
        "u.urlretrieve(\"https://raw.githubusercontent.com/khp11/khp/refs/heads/master/requirements.txt\", \"q10.txt\")\n",
        "\n",
        "with open(\"q10.txt\" , \"a\") as file:\n",
        "  file.write(\"its a new line appended here\")"
      ],
      "metadata": {
        "id": "qjCWMABVTNu6"
      },
      "execution_count": 74,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "11.Write a Python program that uses a try-except block to handle an error when attempting to access a\n",
        "dictionary key that doesn't exist."
      ],
      "metadata": {
        "id": "CkTa7n6ZViGm"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "dict1= {\"man\":\"insaan\" , \"cat\": \"billi\", \"rat\":\"chuhan\"}\n",
        "def searchmean(input1):\n",
        "  try:\n",
        "    return dict1[input1]\n",
        "  except KeyError:\n",
        "    print(\"theres no key named like this exist here\")\n",
        "\n",
        "print(searchmean(\"man\"))\n",
        "searchmean(\"smean\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Z2v0LatDYgH6",
        "outputId": "232e2ec8-ee00-4990-93b5-1cd7d6f44102"
      },
      "execution_count": 85,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "insaan\n",
            "theres no key named like this exist here\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "12.Write a program that demonstrates using multiple except blocks to handle different types of exceptions.\n"
      ],
      "metadata": {
        "id": "rzkmpjeMbBwq"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import urllib.request as u\n",
        "u.urlretrieve(\"https://raw.githubusercontent.com/khp11/khp/refs/heads/master/requirements.txt\",\"fnew.txt\")\n",
        "\n",
        "try:\n",
        "    # Attempt to open a file in read mode\n",
        "    with open(\"fnew.txt\", \"r\") as file:\n",
        "        content = file.read()\n",
        "        print(content)\n",
        "\n",
        "except FileNotFoundError:\n",
        "    print(\"Error: The file does not exist. Please check the file name and try again.\")\n",
        "\n",
        "except PermissionError:\n",
        "    print(\"Error: You do not have permission to access this file.\")\n",
        "\n",
        "except IsADirectoryError:\n",
        "    print(\"Error: Expected a file but found a directory instead.\")\n",
        "\n",
        "except IOError:\n",
        "    print(\"Error: An I/O error occurred while accessing the file.\")\n",
        "\n",
        "except Exception as e:\n",
        "    print(f\"An unexpected error occurred: {e}\")\n"
      ],
      "metadata": {
        "id": "TlTuXUpPY7dB"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "13.How would you check if a file exists before attempting to read it in Python?"
      ],
      "metadata": {
        "id": "pJPTLW8pbNmY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "if \"fh1.txt\" in os.listdir():\n",
        "  print(\"yes file exist\")\n",
        "\n",
        "\n",
        "else:\n",
        "  print(\"file not exist in this current directroy \",os.getcwd())\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Q8z30alGcD0j",
        "outputId": "4424c5db-786c-4aa0-b77b-fd092e0ad14c"
      },
      "execution_count": 97,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "file not exist in this current directroy  /content\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "14.Write a program that uses the logging module to log both informational and error messages."
      ],
      "metadata": {
        "id": "Uv7x0nLef1r5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#logging\n",
        "import logging\n",
        "logging1 = logging.getLogger(\"logging1\")\n",
        "logging1.setLevel(logging.INFO)\n",
        "fh3 = logging.FileHandler(\"nmm.log\",mode=\"a\", delay=False)\n",
        "fh3.setLevel(logging.INFO)\n",
        "formatter = logging.Formatter(\"%(asctime)s: %(levelname)s-:%(message)s\")\n",
        "fh3.setFormatter(formatter)\n",
        "logging1.addHandler(fh3)\n",
        "\n",
        "def login(name):\n",
        "  if len(name)>20:\n",
        "    logging1.error(f\"{name}is too long to get entered\")\n",
        "  else:\n",
        "    logging1.info(f\"succesfully logged in as {name}\")\n",
        "    return \"welcome u logged in succesfuly\"\n",
        "def logout(name):\n",
        "  logging1.info(f\" logged out as {name}\")\n",
        "  print(\"logged out\")\n",
        "\n",
        "login(\"jddddddddddddddddddddddddddddd\")\n",
        "print(login(\"sjs\"))\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "isnl7ntkfzAd",
        "outputId": "17b1cf09-d0a9-48da-c641-8a9cb29db302"
      },
      "execution_count": 126,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "ERROR:logging1:jdddddddddddddddddddddddddddddis too long to get entered\n",
            "INFO:logging1:succesfully logged in as sjs\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "welcome u logged in succesfuly\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "15.Write a Python program that prints the content of a file and handles the case when the file is empty."
      ],
      "metadata": {
        "id": "c3ix9dp3szDi"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import urllib.request as u\n",
        "import os\n",
        "u.urlretrieve(\"https://raw.githubusercontent.com/khp11/khp/refs/heads/master/empty.txt\", \"q15.txt\")\n",
        "#making the file empty\n",
        "with open(\"q15.txt\",\"w\") as file:\n",
        "  file.write(\"\")\n",
        "#real answer\n",
        "with open(\"q15.txt\",\"r\") as file:\n",
        "  if os.path.getsize(\"q15.txt\") == 0:\n",
        "    print(file.tell(),\"file is empty\")\n",
        "  else:\n",
        "    file.read()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nnUANYCms5Ua",
        "outputId": "6fa3c510-1965-4392-c7ad-338d4035da8a"
      },
      "execution_count": 153,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0 file is empty\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "16.Demonstrate how to use memory profiling to check the memory usage of a small program."
      ],
      "metadata": {
        "id": "kra-KsWAtamt"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install memory-profiler\n",
        "\n",
        "from memory_profiler import memory_usage\n",
        "\n",
        "def create_large_list():\n",
        "    large_list = [i for i in range(10**5)]\n",
        "    return large_list\n",
        "\n",
        "mem_usage = memory_usage((create_large_list))\n",
        "print(f\"Memory Usage in(Mb) at different state of time: {mem_usage}\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XI56p_D7taEG",
        "outputId": "52e4a10d-9bd0-4095-ad10-7944059a5e20"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Collecting memory-profiler\n",
            "  Downloading memory_profiler-0.61.0-py3-none-any.whl.metadata (20 kB)\n",
            "Requirement already satisfied: psutil in /usr/local/lib/python3.11/dist-packages (from memory-profiler) (5.9.5)\n",
            "Downloading memory_profiler-0.61.0-py3-none-any.whl (31 kB)\n",
            "Installing collected packages: memory-profiler\n",
            "Successfully installed memory-profiler-0.61.0\n",
            "Memory Usage in(Mb) at different state of time: [129.4453125, 129.45703125, 129.609375, 129.921875, 130.17578125, 130.17578125, 130.17578125, 130.17578125, 130.17578125, 130.17578125, 130.17578125, 129.19140625, 129.19140625]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "17.Write a Python program to create and write a list of numbers to a file, one number per line."
      ],
      "metadata": {
        "id": "xfzqxGbFtINW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "with open(\"q17.txt\",\"w\") as file:\n",
        "  for i in range (10):\n",
        "    file.write(f\"{i}\\n\")"
      ],
      "metadata": {
        "id": "xyEZe8-KA4t-"
      },
      "execution_count": 22,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "18.How would you implement a basic logging setup that logs to a file with rotation after 1MB?\n"
      ],
      "metadata": {
        "id": "gBYOxKAZuUnm"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import logging\n",
        "logger1= logging.getLogger(\"logger1\")\n",
        "logger1.setLevel(logging.DEBUG)\n",
        "#fh1 = logging.FileHandler(\"q18.txt\" , mode = \"a\", delay= False)\n",
        "fh1 = logging.handlers.RotatingFileHandler(\"q18.log\" ,mode = \"a\", maxBytes= 1*1024*1024, backupCount=5)\n",
        "fh1.setLevel(logging.DEBUG)\n",
        "formatter= logging.Formatter(\"%(asctime)s::%(levelname)s::%(message)s\")\n",
        "fh1.setFormatter(formatter)\n",
        "logger1.addHandler(fh1)\n",
        "\n",
        "for i in range(20):\n",
        "  logger1.info(f\"{i}checking the limit of this log file testing my code and seeing the other fiel it crtes\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nISOHMXEthfu",
        "outputId": "791d2bda-f342-4e72-9a3a-7ac1c45747af"
      },
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "INFO:logger1:0checking the limit of this log file testing my code and seeing the other fiel it crtes\n",
            "INFO:logger1:1checking the limit of this log file testing my code and seeing the other fiel it crtes\n",
            "INFO:logger1:2checking the limit of this log file testing my code and seeing the other fiel it crtes\n",
            "INFO:logger1:3checking the limit of this log file testing my code and seeing the other fiel it crtes\n",
            "INFO:logger1:4checking the limit of this log file testing my code and seeing the other fiel it crtes\n",
            "INFO:logger1:5checking the limit of this log file testing my code and seeing the other fiel it crtes\n",
            "INFO:logger1:6checking the limit of this log file testing my code and seeing the other fiel it crtes\n",
            "INFO:logger1:7checking the limit of this log file testing my code and seeing the other fiel it crtes\n",
            "INFO:logger1:8checking the limit of this log file testing my code and seeing the other fiel it crtes\n",
            "INFO:logger1:9checking the limit of this log file testing my code and seeing the other fiel it crtes\n",
            "INFO:logger1:10checking the limit of this log file testing my code and seeing the other fiel it crtes\n",
            "INFO:logger1:11checking the limit of this log file testing my code and seeing the other fiel it crtes\n",
            "INFO:logger1:12checking the limit of this log file testing my code and seeing the other fiel it crtes\n",
            "INFO:logger1:13checking the limit of this log file testing my code and seeing the other fiel it crtes\n",
            "INFO:logger1:14checking the limit of this log file testing my code and seeing the other fiel it crtes\n",
            "INFO:logger1:15checking the limit of this log file testing my code and seeing the other fiel it crtes\n",
            "INFO:logger1:16checking the limit of this log file testing my code and seeing the other fiel it crtes\n",
            "INFO:logger1:17checking the limit of this log file testing my code and seeing the other fiel it crtes\n",
            "INFO:logger1:18checking the limit of this log file testing my code and seeing the other fiel it crtes\n",
            "INFO:logger1:19checking the limit of this log file testing my code and seeing the other fiel it crtes\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "19.Write a program that handles both IndexError and KeyError using a try-except block."
      ],
      "metadata": {
        "id": "QZqec0u3DycO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def access_elements(data_structure, index=None, key=None):\n",
        "    try:\n",
        "        if index is not None:\n",
        "            # Attempt to access the element at the specified index\n",
        "            value = data_structure[index]\n",
        "            print(f\"Value at index {index}: {value}\")\n",
        "        if key is not None:\n",
        "            # Attempt to access the value associated with the specified key\n",
        "            value = data_structure[key]\n",
        "            print(f\"Value for key '{key}': {value}\")\n",
        "    except IndexError:\n",
        "        print(f\"Error: The index {index} is out of range.\")\n",
        "    except KeyError:\n",
        "        print(f\"Error: The key '{key}' does not exist in the dictionary.\")\n",
        "    except TypeError:\n",
        "        print(\"Error: The provided data structure does not support indexing or key access.\")\n",
        "\n",
        "# Example usage:\n",
        "my_list = [10, 20, 30]\n",
        "my_dict = {'a': 100, 'b': 200}\n",
        "\n",
        "access_elements(my_list, index=1)       # Valid index\n",
        "access_elements(my_list, index=5)       # IndexError\n",
        "access_elements(my_dict, key='a')       # Valid key\n",
        "access_elements(my_dict, key='z')       # KeyError\n",
        "access_elements(42, index=0)            # TypeError\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GIbJnOQwDyCs",
        "outputId": "5a69374b-1d65-4ffe-d726-378909c38868"
      },
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Value at index 1: 20\n",
            "Error: The index 5 is out of range.\n",
            "Value for key 'a': 100\n",
            "Error: The key 'z' does not exist in the dictionary.\n",
            "Error: The provided data structure does not support indexing or key access.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "20.How would you open a file and read its contents using a context manager in Python?"
      ],
      "metadata": {
        "id": "0XODoiksFixi"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import urllib.request as u\n",
        "u.urlretrieve(\"https://raw.githubusercontent.com/khp11/khp/refs/heads/master/requirements.txt\", \"q20.txt\")\n",
        "\n",
        "with open(\"q20.txt\",\"r\") as file:\n",
        "  print(file.read())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RU9OprfxFn7I",
        "outputId": "1ea30e43-4652-4655-9e14-cd842bd72234"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "kine1-Implement an additional verification mechanism to cross-check the payment status between G2A and Bitbay before processing and delivering an order.\n",
            "line2- Detect and block any suspicious changes in browser timezone settings during the payment process.\n",
            "line3-Enhance logging and monitoring to detect and flag potentially fraudulent activities, such as rapid timezone changes or mismatched order statuses.\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "21.Write a Python program that reads a file and prints the number of occurrences of a specific word."
      ],
      "metadata": {
        "id": "Up5Y-lJlHSDq"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#downloading the file\n",
        "\n",
        "import urllib.request as u\n",
        "\n",
        "u.urlretrieve(\"https://raw.githubusercontent.com/khp11/khp/refs/heads/master/requirements.txt\", \"q21.txt\")\n",
        "\n",
        "\n",
        "\n",
        "def wordcounter(filename, wordtochoose):\n",
        "  counter =0\n",
        "  file= open(filename,\"r\")\n",
        "  for line in file:\n",
        "    c=line.split(\" \")\n",
        "    c.sort()\n",
        "    for i in c:\n",
        "      if i==wordtochoose:\n",
        "        counter=counter+1\n",
        "  file.close()\n",
        "  return counter\n",
        "\n",
        "wordcounter(\"q21.txt\", \"to\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uJED_-FVHSq6",
        "outputId": "0ca3e412-c53b-448b-86bd-56e3d11ab917"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {},
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "22.How can you check if a file is empty before attempting to read its contents?"
      ],
      "metadata": {
        "id": "f5gf8CLG2yDu"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import urllib.request as u\n",
        "import os\n",
        "u.urlretrieve(\"https://raw.githubusercontent.com/khp11/khp/refs/heads/master/requirements.txt\", \"q22.txt\")\n",
        "\n",
        "\n",
        "if os.path.getsize(\"q22.txt\")==0:\n",
        "  print(\"file is empty , nothing to read here ;-0\")\n",
        "else:\n",
        "  with open(\"q22.txt\" ,\"r\") as file:\n",
        "    print(file.read())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kveCVbNl276O",
        "outputId": "a50db841-c516-4730-cfef-eec8ca2de71e"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "kine1-Implement an additional verification mechanism to cross-check the payment status between G2A and Bitbay before processing and delivering an order.\n",
            "line2- Detect and block any suspicious changes in browser timezone settings during the payment process.\n",
            "line3-Enhance logging and monitoring to detect and flag potentially fraudulent activities, such as rapid timezone changes or mismatched order statuses.\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "23. Write a Python program that writes to a log file when an error occurs during file handling.\n"
      ],
      "metadata": {
        "id": "r7poIZU_3nbZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import logging\n",
        "\n",
        "# Create a logger object\n",
        "logger = logging.getLogger(\"FileErrorLogger\")\n",
        "logger.setLevel(logging.ERROR)  # Set logging level to ERROR\n",
        "\n",
        "# Create a FileHandler to write logs to a file\n",
        "file_handler = logging.FileHandler(\"error.log\")\n",
        "file_handler.setLevel(logging.ERROR)  # Set handler level to ERROR\n",
        "\n",
        "# Define a log format\n",
        "formatter = logging.Formatter(\"%(asctime)s - %(levelname)s - %(message)s\")\n",
        "file_handler.setFormatter(formatter)\n",
        "\n",
        "# Add the FileHandler to the logger\n",
        "logger.addHandler(file_handler)\n",
        "\n",
        "def read_file(file_path):\n",
        "    try:\n",
        "        with open(file_path, \"r\") as file:\n",
        "            content = file.read()\n",
        "            print(\"File content successfully read.\")\n",
        "            return content\n",
        "    except FileNotFoundError:\n",
        "        logger.error(f\"File '{file_path}' not found.\")\n",
        "        print(\"Error: File not found.\")\n",
        "    except PermissionError:\n",
        "        logger.error(f\"Permission denied for file '{file_path}'.\")\n",
        "        print(\"Error: Permission denied.\")\n",
        "    except Exception as e:\n",
        "        logger.error(f\"Unexpected error while reading file '{file_path}': {e}\")\n",
        "        print(\"Error: Something went wrong.\")\n",
        "\n",
        "# Example usage\n",
        "file_name = \"test.txt\"  # Change this to a non-existing file to test logging\n",
        "read_file(file_name)\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zOpBxPYH3XnG",
        "outputId": "5204d4c2-39be-4e99-db90-bcc318204d26"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "ERROR:FileErrorLogger:File 'test.txt' not found.\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Error: File not found.\n"
          ]
        }
      ]
    }
  ]
}