Day6.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "037b9831",
   "metadata": {},
   "source": [
    "\n",
    "<h1 align=\"center\" style=\"color:red\">Python-Exceptions </h1>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "acf0c011",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "27711bd2",
   "metadata": {},
   "source": [
    "## Learning agenda of this notebook\n",
    "1. What are syntax errors?\n",
    "2. What are exceptions?\n",
    "3. How to handle exceptions?\n",
    "4. Types of exceptions in Python\n",
    "5. Multiple `except` clauses\n",
    "6. Python `else` clause and `finally` keyword\n",
    "7. Python `raise` keyword to raise an Exception\n",
    "8. Python `assert` keyword as a sanity check"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "2afd74bd-7126-430a-a7a0-ec8057c6c6e9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# final vs finally keywords?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3aa307b8",
   "metadata": {},
   "source": [
    "## 1. What are Syntax Errors??\n",
    "- **Syntax Errors or Parsing Errors:** are errors that are raised before the program/script actually starts its execution. Some common parsing errors in Python are: incorrect indentation, leaving out a symbol (e.g., collon or bracket), empty block. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "603a0030",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "c7bb9b30",
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "unmatched ')' (3938186187.py, line 2)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  Cell \u001b[0;32mIn[3], line 2\u001b[0;36m\u001b[0m\n\u001b[0;31m    print(1/0))\u001b[0m\n\u001b[0m              ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m unmatched ')'\n"
     ]
    }
   ],
   "source": [
    "# Example 1: An example of syntax Error (An unmatched bracket)\n",
    "print(1/0))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1beadc90",
   "metadata": {},
   "source": [
    "**Note that in case of a syntax error in your program, none of the statement is executed**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "50d834be",
   "metadata": {},
   "outputs": [
    {
     "ename": "IndentationError",
     "evalue": "expected an indented block after 'if' statement on line 4 (2308473987.py, line 5)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  Cell \u001b[0;32mIn[4], line 5\u001b[0;36m\u001b[0m\n\u001b[0;31m    print(\"Hello\")\u001b[0m\n\u001b[0m    ^\u001b[0m\n\u001b[0;31mIndentationError\u001b[0m\u001b[0;31m:\u001b[0m expected an indented block after 'if' statement on line 4\n"
     ]
    }
   ],
   "source": [
    "# Example 2: An example of syntax Error (Incorrect Indentation)\n",
    "1/0               # note this error is not raised\n",
    "print('This will not be printed')\n",
    "if True:\n",
    "print(\"Hello\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "b7a32a8e",
   "metadata": {},
   "outputs": [],
   "source": [
    "### Syntax Error vs Logical Error vs Runtime Error"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "048085d1-6523-4a89-998f-9bab4b7e755c",
   "metadata": {},
   "source": [
    "<img src=\"https://miro.medium.com/v2/resize:fit:1400/format:webp/1*Pu15kzIBscgBxb_pQXpBnA.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5bb06d31",
   "metadata": {},
   "source": [
    "## 2. What are Exceptions?\n",
    "- **Exceptions:** An exception is an error that happens during the execution of a syntactically correct program, (e.g., division by zero), that disrupts the normal flow of program execution. When an exception occurs, Python generates an appropriate exception object (representing error)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "350f4af0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n"
     ]
    },
    {
     "ename": "ZeroDivisionError",
     "evalue": "division by zero",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mZeroDivisionError\u001b[0m                         Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[8], line 3\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;66;03m# Example 1: ZeroDivisionError is an exception that is raised when you perform a division by zero.\u001b[39;00m\n\u001b[1;32m      2\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mHello\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m----> 3\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;241m1\u001b[39m\u001b[38;5;241m/\u001b[39m\u001b[38;5;241m0\u001b[39m)\n\u001b[1;32m      4\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mEnd\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n",
      "\u001b[0;31mZeroDivisionError\u001b[0m: division by zero"
     ]
    }
   ],
   "source": [
    "# Example 1: ZeroDivisionError is an exception that is raised when you perform a division by zero.\n",
    "print(\"Hello\")\n",
    "print(1/0)\n",
    "print(\"End\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "3b9c12e7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n"
     ]
    },
    {
     "ename": "IndexError",
     "evalue": "list index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[9], line 4\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mHello\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m      3\u001b[0m mylist \u001b[38;5;241m=\u001b[39m [\u001b[38;5;241m5\u001b[39m, \u001b[38;5;241m33\u001b[39m, \u001b[38;5;241m21\u001b[39m]\n\u001b[0;32m----> 4\u001b[0m \u001b[38;5;28mprint\u001b[39m(mylist[\u001b[38;5;241m8\u001b[39m])\n",
      "\u001b[0;31mIndexError\u001b[0m: list index out of range"
     ]
    }
   ],
   "source": [
    "# Example 2: IndexError is an exception that is raised when trying to access a list index out of range\n",
    "print(\"Hello\")\n",
    "mylist = [5, 33, 21]\n",
    "print(mylist[8])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b2ee38ae",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "73ba5f15",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "5ec1d7d2",
   "metadata": {},
   "source": [
    "## 3. How to Handle Exceptions?\n",
    "<img align=\"center\" width=\"600\" height=\"800\"  src=\"images/newexceptions1.png\" > \n",
    "\n",
    "- In Python **try** and **except** keywords are used to catch and handle exceptions respectively. \n",
    "- Instructions that can raise exceptions are kept inside the `try block` and the instructions that handle the exception are written inside `except block`. \n",
    "- The code inside the `except block` will execute only in case, when the program encounters some error in the preceding `try block`.\n",
    "- Let us handle the exception `ValueError` that is raised in above program"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c13be3a9",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "32e9af8f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello!\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter Fahrenheit Temprature:  70A\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "An error occurred\n",
      "Done!\n",
      "GR8 going\n"
     ]
    }
   ],
   "source": [
    "# Example 1: Handle ValueError (if the user inputs a string instead of number)\n",
    "try:\n",
    "    print(\"Hello!\")\n",
    "    far = float(input(\"Enter Fahrenheit Temprature: \"))\n",
    "    cel = (far - 32.0) * 5.0/9.0\n",
    "    print (cel)\n",
    "    print(\"Hi\")\n",
    "\n",
    "# This block will exectue the program without any crash    \n",
    "except:\n",
    "    print(\"An error occurred\")\n",
    "    print(\"Done!\")\n",
    "\n",
    "print(\"GR8 going\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "24ae669f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n",
      "Hi\n",
      "An error occurred\n",
      "unsupported operand type(s) for +: 'int' and 'str'\n"
     ]
    }
   ],
   "source": [
    "# Example 2: Three errors are there in the try block: ZeroDivisionError, NameError, and TypeError\n",
    "# A try clause is executed up until the point, where the first exception is encountered\n",
    "try:\n",
    "    # z = 45 / 0\n",
    "    print(\"Hello\")\n",
    "    # print(Z)\n",
    "    print(\"Hi\")\n",
    "    a = 34 + 'hello'\n",
    "    print(\"Done!\")\n",
    "    \n",
    "# This block will exectue the program without any crash\n",
    "except Exception as e:\n",
    "    print(\"An error occurred\")\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "73e10931",
   "metadata": {},
   "source": [
    "**The above example of try-except statement is good as it is simple and can catch all types of exception. However, it does not help the programmer identify the root cause of the problem**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "954ccc09",
   "metadata": {},
   "source": [
    "## 4. Types of Exceptions in Python\n",
    "- There are several built-in exceptions in Python that are raised when an error occur. Some common examples of Python built-in exceptions are:\n",
    "   - **ZeroDivisionError** is raised when you perform a division by zero.\n",
    "   - **ValueError** is raised when a function or built-in operation receives an argument that has the right type but an inappropriate value.\n",
    "   - **NameError** is raised when the Python interpreter encounters a symbol that does not exist.\n",
    "   - **TypeError** is raised when you try performing an operation on unsupported types (e.g., 5 + 'hello').\n",
    "   - **IndexError** is raised when you try to refer a sequence which is out of range.\n",
    "   - **IOError** is raised when an IO operation fails, e.g.,  trying to open a file that do not exist.\n",
    "   - **EOFError** is raised when built-in function like input() hits an end of file condition, without reading any data.\n",
    "   - **ImportError** is raised when an import statement fails to find the module.\n",
    "   - **AssertionError** is raised when an assert statement fails (an assert statement allows you to create simple debug message outputs based on simple logical assertions).\n",
    ">- When an exception occurs the appropriate Exception class object is sent to the `except` clause, that we can receive as an argument.        ```except Exception as e: ```\n",
    ">- The Exception class object received contains additional information about the raised exception, so as to handle it accordingly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fc7fff9b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "ef4a15c7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Exception occured:  unsupported operand type(s) for +: 'int' and 'str'\n"
     ]
    }
   ],
   "source": [
    "# Example code that specifies the type of exception raised\n",
    "try:\n",
    "    # z = 45 / 0\n",
    "    # print(Z)\n",
    "    a = 34 + 'hello'\n",
    "except Exception as e:\n",
    "    print(\"Exception occured: \", e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "57597f8f",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eadf68bd",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "710fc4dd",
   "metadata": {},
   "source": [
    "## 5. Multiple `except` Clauses\n",
    "- Inside a try block, there may be different exceptions that can be raised.\n",
    "- Being a programmer we would like to write different handlers for different exceptions.\n",
    "- To handle this, we can have multiple except blocks for one try block.\n",
    "- The except block corresponding to the first raised exception will be executed. \n",
    "- Note: In Python there is no concept of default catch block as in C++"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "d112145f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ModuleNotFoundError Occurred and Handled\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    # z = 45 / 0\n",
    "    # print(Z)\n",
    "    # a = 34 + 'hello'\n",
    "    # list1 = [1, 5, 9]\n",
    "    # print(list1[3])\n",
    "    import kakamanna             #ModuleNotFounderror\n",
    "except ZeroDivisionError:\n",
    "    print(\"ZeroDivisionError Occurred and Handled\")\n",
    "except NameError:\n",
    "    print(\"NameError Occurred and Handled\")\n",
    "except TypeError:\n",
    "    print(\"TypeError Occurred and Handled\")\n",
    "except IndexError:\n",
    "    print(\"IndexError Occurred and Handled\")\n",
    "except ModuleNotFoundError:\n",
    "    print(\"ModuleNotFoundError Occurred and Handled\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3121031c",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "1b4c8ab0",
   "metadata": {},
   "source": [
    "## 6. Python `try-except` with `else` Clause and `finally` Keyword\n",
    "<img align=\"center\" width=\"400\" height=\"600\"  src=\"images/exceptions2.png\" > "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dbc69977",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "9d831a7f",
   "metadata": {},
   "source": [
    "### a. The  `else` Clause\n",
    "- The **`else clause`** is used if you want to execute a piece of code that should execute when no exception is raised.\n",
    "- The **`else clause`** in the try-except block must be placed after all the except clauses.\n",
    "- The code enters the else block only if the try clause does not raise an exception."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "47ee21e1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List Elements are:  [1, 5, 9]\n",
      "NameError Occurred and Handled\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    list1 = [1, 5, 9]\n",
    "    print(\"List Elements are: \", list1)\n",
    "    print(A)\n",
    "\n",
    "except ZeroDivisionError:\n",
    "    print(\"ZeroDivisionError Occurred and Handled\")\n",
    "except NameError:\n",
    "    print(\"NameError Occurred and Handled\")\n",
    "except TypeError:\n",
    "    print(\"TypeError Occurred and Handled\")\n",
    "except IndexError:\n",
    "    print(\"IndexError Occurred and Handled\")\n",
    "else:           \n",
    "    print(\"This will execute if try clause does not raise an exception\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f02683d7",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "4141c81b",
   "metadata": {},
   "source": [
    "### b. The `finally` Keyword\n",
    "- The **`finally clause`** is used to execute a piece of code that must execute, whether the `try-block` raise an exception or not.\n",
    "- The **`finally clause`** in the `try-except` block must be placed after all the `except` clauses, even after the `else` clause. \n",
    "- Used to define clean-up actions that must be executed under all circumstances."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "d20ab9d9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List Elements are:  [1, 5, 9]\n",
      "NameError Occurred and Handled\n",
      "This will always be executed\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    list1 = [1, 5, 9]\n",
    "    print(\"List Elements are: \", list1)\n",
    "    print(Z)\n",
    "\n",
    "except ZeroDivisionError:\n",
    "    print(\"ZeroDivisionError Occurred and Handled\")\n",
    "except NameError:\n",
    "    print(\"NameError Occurred and Handled\")\n",
    "except TypeError:\n",
    "    print(\"TypeError Occurred and Handled\")\n",
    "except IndexError:\n",
    "    print(\"IndexError Occurred and Handled\")\n",
    "else:           \n",
    "    print(\"This will execute if try clause does not raise an exception\")\n",
    "finally:\n",
    "    print(\"This will always be executed\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c3c2b9fa",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "10542042",
   "metadata": {},
   "source": [
    "## 7. Python `raise` Keword to Raise an Exception\n",
    "- The Python `raise` keyword is used to raise an exception.\n",
    "- You can define what kind of exception to raise, and the text to print to the user."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "1d34ca97",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Program continues as age is positive\n"
     ]
    }
   ],
   "source": [
    "# Example 1: Raise an exception if x is negative and display an appropriate message to user as to what went wrong\n",
    "# age = -1\n",
    "age = 5\n",
    "if age < 0:\n",
    "    raise Exception(\"x should not be negative. The value of age was {}\".format(age))\n",
    "print(\"Program continues as age is positive\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a2ae1c75",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "9b221010",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Program continues as x is a number\n"
     ]
    }
   ],
   "source": [
    "#Example 2: Raise an exception if x is not a number and display an appropriate message\n",
    "# x = \"hello\"\n",
    "x = 5\n",
    "if not type(x) is int:\n",
    "    raise TypeError(\"Only integers are allowed\")\n",
    "print(\"Program continues as x is a number\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5b0b352d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "1b6c472d",
   "metadata": {},
   "source": [
    ">In above examples, when we used the `raise` keyword, whenever the condition evaluated to true, the exception was raised and our program crashed midway"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9b41850e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "83f72057",
   "metadata": {},
   "source": [
    "## 8. Python `assert` Keyword\n",
    "- Instead for waiting for our program to crash midway, right in the beginning of our program we can check the conditions using the `assert` statement.\n",
    "- An `assert` statement is passed two comma separated arguments, the first is a condition, which if evaluates to False, the exception `AssertionError` is raised and the second argument is passed to it.\n",
    "- If the condition evaluates to True, program continues its execution.\n",
    "- You can think of `assert` statement as:\n",
    ">- testing an expression, and if the result is false, raise an exception (AssertionError).\n",
    ">- a sanity-check that you can turn on, or turn off when you are done with your testing of the program."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "0f2e56fa",
   "metadata": {},
   "outputs": [
    {
     "ename": "AssertionError",
     "evalue": "failed status",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAssertionError\u001b[0m                            Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[37], line 6\u001b[0m\n\u001b[1;32m      4\u001b[0m marks \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m70\u001b[39m\n\u001b[1;32m      5\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m age \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m0\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mage should be positive\u001b[39m\u001b[38;5;124m'\u001b[39m\n\u001b[0;32m----> 6\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m marks \u001b[38;5;241m<\u001b[39m \u001b[38;5;241m50\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mfailed status\u001b[39m\u001b[38;5;124m\"\u001b[39m \n\u001b[1;32m      7\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mProgram continues as age is positive\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n",
      "\u001b[0;31mAssertionError\u001b[0m: failed status"
     ]
    }
   ],
   "source": [
    "# Example 1:\n",
    "# age = -1\n",
    "age = 5\n",
    "marks = 70\n",
    "assert age > 0, 'age should be positive'\n",
    "assert marks < 50, \"failed status\" \n",
    "print(\"Program continues as age is positive\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "e5a924b2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Program continues as x is a number\n"
     ]
    }
   ],
   "source": [
    "#Example 2: \n",
    "# x = \"hello\"\n",
    "x = 5\n",
    "assert type(x) is int, 'x must be integer'\n",
    "print(\"Program continues as x is a number\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fb4a7d11",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "12e706d1",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "3c7cc6ce",
   "metadata": {},
   "source": [
    "## Check your Concepts\n",
    "\n",
    "Try answering the following questions to test your understanding of the topics covered in this notebook:\n",
    "\n",
    "1. What are exceptions in Python? When do they occur?\n",
    "2. How are exceptions different from syntax errors?\n",
    "3. What are the different types of in-built exceptions in Python? Where can you learn about them?\n",
    "4. How do you prevent the termination of a program due to an exception?\n",
    "5. What is the purpose of the `try`-`except` statements in Python?\n",
    "6. What is the syntax of the `try`-`except` statements? Give an example.\n",
    "7. What happens if an exception occurs inside a `try` block?\n",
    "8. How do you handle two different types of exceptions using `except`? Can you have multiple `except` blocks under a single `try` block?\n",
    "9. How do you create an `except` block to handle any type of exception?\n",
    "10. Illustrate the usage of `try`-`except` inside a function with an example.\n",
    "11. Differentiate between checked and unchecked exceptions\n",
    "    - **Checked Exceptions** are the exceptions which occur at compile time (e.g., file not found, no such function). Since Python is not compiled, so checked exceptions don't make much sense.\n",
    "    - **Unchecked Exception** are the exceptions which are not checked by the compiler (e.g., arithmetic exception, array out of bound). If not handled by programmer properly, the program terminate at runtime. \n",
    "12. Dig out details about User-Defined Exceptions. Python also allows you to create your own exception classes by deriving them from the standard built-in Exception class. This is useful when you need to display more specific information when an exception is caught. Dig out details about user-defined exceptions from this link:https://docs.python.org/3/tutorial/errors.html#user-defined-exceptions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e1cb9d94",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2569604b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "3f009d4a",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "<h1 align=\"center\" style=\"color:red\">Python Built-in Modules</h1>\n",
    "\n",
    "\n",
    "#### [Check out the full list of Python Built-in modules](https://docs.python.org/3/py-modindex.html)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e649ae98",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "6fb1e84f",
   "metadata": {},
   "source": [
    "## Learning agenda of this notebook\n",
    "Python has tons of Built-in modules that can be read from above link. In this notebook file, we will be discussing a short but important subset of it:\n",
    "1. What are Python Built-in Modules\n",
    "2. Different ways to import a Module in Python\n",
    "3. The Math Module \n",
    "4. The Random Module\n",
    "5. The Time Module\n",
    "6. The DateTime Module\n",
    "7. The Calendar Module\n",
    "8. The OS Module\n",
    "9. The URLLIB Module"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2e8e6829",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "3e9859d2",
   "metadata": {},
   "outputs": [],
   "source": [
    "# !ls Files/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "1a0d6f2f-de9a-4937-a302-ff9cf360e303",
   "metadata": {},
   "outputs": [],
   "source": [
    "# !cat Files/atm.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "43fcf001-8349-4914-a78b-d3989379b44e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# !cat Files/file.py"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "50ad5e55",
   "metadata": {},
   "source": [
    "## 1.  What are Python Built-in Modules\n",
    "- In Python, Modules are simply files with the `. py` extension containing Python code (variables, functions, classes etc) that can be imported inside another Python Program. \n",
    "- You can think of Python module like a C library, which is linked with C program during the linking phase.\n",
    "- Some advantages of Modular programming are:\n",
    ">- **Modularity:** We use modules to break down large programs into small manageable and organized files. \n",
    ">- **Simplicity:** Rather than focusing the entire problem at hand, a module typically focuses on one relatively small portion of the problem.\n",
    ">- **Maintainability:** Modules are typically designed so that they enforce logical boundries between different problem domains.\n",
    ">- **Reusability:** Functionality defined in a single module can be easily reused (through an appropriately defined interface) by other parts of the application. This eliminates the need to duplicate code. We can define our most used functions in a module and import it, instead of copying their definitions into different programs.\n",
    ">- **Scoping:** Modules typically define a separate namespace, which helps avoid collisions between identifiers in different areas of a program. The key benefit of using modules is _namespaces_: you must import the module to use its functions within a Python script or notebook. Namespaces provide encapsulation and avoid naming conflicts between your code and a module or across modules.\n",
    "\n",
    "\n",
    "> **Note**:  A module is a single file of Python code that is meant to be imported, while a Python package is a simple directory having collections of Python modules under a common namespace. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3d688504",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Modules -> Single file of code\n",
    "# Packages -> Multiple files of code"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7922ac39",
   "metadata": {},
   "source": [
    "## 2. Ways to Import a Python Module\n",
    "- Python math module contains rich set of functions, that allows you to perform mathematical tasks on numbers.\n",
    "- Since the math module comes packaged with the Python release, you don't have to install it separately. Using it is just a matter of importing the module"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41737b29",
   "metadata": {},
   "source": [
    "### a. Option 1: `import math`\n",
    ">- We can use the **`import`** keyword to import a module, and later using the module name we can access its functions using the dot . operator, like `math.ceil()`  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "unable-plasma",
   "metadata": {},
   "outputs": [],
   "source": [
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "d48f3f31",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['HTML', 'In', 'Out', '_', '_1', '_34', '__', '___', '__builtin__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__session__', '__spec__', '_dh', '_exit_code', '_i', '_i1', '_i10', '_i11', '_i12', '_i13', '_i14', '_i15', '_i16', '_i17', '_i18', '_i19', '_i2', '_i20', '_i21', '_i22', '_i23', '_i24', '_i25', '_i26', '_i27', '_i28', '_i29', '_i3', '_i30', '_i31', '_i32', '_i33', '_i34', '_i35', '_i36', '_i37', '_i38', '_i39', '_i4', '_i40', '_i41', '_i42', '_i43', '_i44', '_i45', '_i46', '_i47', '_i5', '_i6', '_i7', '_i8', '_i9', '_ih', '_ii', '_iii', '_oh', 'age', 'cel', 'exit', 'far', 'get_ipython', 'html_content', 'list1', 'marks', 'math', 'mylist', 'open', 'quit', 'style', 'sys', 'x']\n"
     ]
    }
   ],
   "source": [
    "# We have seen the use of dir() function. When called without argument it displays symbols of current module\n",
    "print(dir())\n",
    "# del math"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "injured-arbitration",
   "metadata": {},
   "source": [
    "Python dir() function returns the list of names in the current local scope. If the object on which method is called has a method named __dir__(), this method will be called and must return the list of attributes. It takes a single object type argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "touched-conditions",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'cbrt', 'ceil', 'comb', 'copysign', 'cos', 'cosh', 'degrees', 'dist', 'e', 'erf', 'erfc', 'exp', 'exp2', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'isqrt', 'lcm', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'nextafter', 'perm', 'pi', 'pow', 'prod', 'radians', 'remainder', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc', 'ulp']\n"
     ]
    }
   ],
   "source": [
    "print(dir(math))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "40bd84f0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This module provides access to the mathematical functions\n",
      "defined by the C standard. math \n"
     ]
    }
   ],
   "source": [
    "print(math.__doc__ , math.__name__ , math.__package__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "eb9c6a0c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8.0"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.pow(2,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "22cd180f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "-18\n",
      "3628800\n"
     ]
    }
   ],
   "source": [
    "print(math.ceil(2.3)) #ceil function for positive value round up our value \n",
    "# and for negative value , function round downs our value\n",
    "\n",
    "print(math.floor(-17.2)) # It is opposite of ceil function\n",
    "\n",
    "print(math.factorial(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "01a2098b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "front-effectiveness",
   "metadata": {},
   "source": [
    "math.ceil() function returns the smallest integral value greater than the number. If number is already integer, same number is returned."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cdf3c072",
   "metadata": {},
   "source": [
    "### b. Option 2: `import math as m`\n",
    ">- We can also import a module by using a short alias, thus saving typing time in some cases. Note that in this case, the name `math` will not be recognized in our scope. Hence, `math.ceil()` is invalid and `m.ceil()` is the correct implementation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "31e728bc",
   "metadata": {},
   "outputs": [],
   "source": [
    "import math as m"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "91f766ed",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "75c286be",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['HTML', 'In', 'Out', '_', '_1', '_34', '_50', '__', '___', '__builtin__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__session__', '__spec__', '_dh', '_exit_code', '_i', '_i1', '_i10', '_i11', '_i12', '_i13', '_i14', '_i15', '_i16', '_i17', '_i18', '_i19', '_i2', '_i20', '_i21', '_i22', '_i23', '_i24', '_i25', '_i26', '_i27', '_i28', '_i29', '_i3', '_i30', '_i31', '_i32', '_i33', '_i34', '_i35', '_i36', '_i37', '_i38', '_i39', '_i4', '_i40', '_i41', '_i42', '_i43', '_i44', '_i45', '_i46', '_i47', '_i48', '_i49', '_i5', '_i50', '_i51', '_i52', '_i53', '_i6', '_i7', '_i8', '_i9', '_ih', '_ii', '_iii', '_oh', 'age', 'cel', 'exit', 'far', 'get_ipython', 'html_content', 'list1', 'm', 'marks', 'math', 'mylist', 'open', 'quit', 'style', 'sys', 'x']\n"
     ]
    }
   ],
   "source": [
    "print(dir())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "d0c0fe79",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'cbrt', 'ceil', 'comb', 'copysign', 'cos', 'cosh', 'degrees', 'dist', 'e', 'erf', 'erfc', 'exp', 'exp2', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'isqrt', 'lcm', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'nextafter', 'perm', 'pi', 'pow', 'prod', 'radians', 'remainder', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc', 'ulp']\n"
     ]
    }
   ],
   "source": [
    "print(dir(m))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "7921f0a9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "45\n"
     ]
    }
   ],
   "source": [
    "print(m.ceil(2.3))\n",
    "print(m.floor(45.5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "05c261ac",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8.0"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m.pow(2,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b9aa324e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "a6ace8fb",
   "metadata": {},
   "source": [
    "### c. Option 3:`from math import ceil`        OR       `from math import ceil, floor`\n",
    ">- We can use the **`from`** keyword to import specific name(s) from a module instead of importing the entire contents of a module. This way we don't have to use the dot operator and can access the function directly by its name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "b62713ff",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['HTML', 'In', 'Out', '_', '_1', '_34', '_50', '_56', '__', '___', '__builtin__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__session__', '__spec__', '_dh', '_exit_code', '_i', '_i1', '_i10', '_i11', '_i12', '_i13', '_i14', '_i15', '_i16', '_i17', '_i18', '_i19', '_i2', '_i20', '_i21', '_i22', '_i23', '_i24', '_i25', '_i26', '_i27', '_i28', '_i29', '_i3', '_i30', '_i31', '_i32', '_i33', '_i34', '_i35', '_i36', '_i37', '_i38', '_i39', '_i4', '_i40', '_i41', '_i42', '_i43', '_i44', '_i45', '_i46', '_i47', '_i48', '_i49', '_i5', '_i50', '_i51', '_i52', '_i53', '_i54', '_i55', '_i56', '_i57', '_i6', '_i7', '_i8', '_i9', '_ih', '_ii', '_iii', '_oh', 'age', 'ceil', 'cel', 'exit', 'far', 'floor', 'get_ipython', 'html_content', 'list1', 'm', 'marks', 'math', 'mylist', 'open', 'pow', 'quit', 'style', 'sys', 'x']\n"
     ]
    }
   ],
   "source": [
    "from math import ceil, floor, pow\n",
    "print(dir())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "8ff2b36b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "8.0\n"
     ]
    }
   ],
   "source": [
    "print(ceil(2.3))\n",
    "print(pow(2,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e267673b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "53ef1c74",
   "metadata": {},
   "source": [
    "### d. Option 4:`from math import *`\n",
    ">- We can import all the attributes from a module using asterik `*` construct. The difference between `import math` and `from math import *` is that in the later case you can don't have to use the dot operator and can directly use the functions, e.g., `ceil()`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d4b2c91d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "50342f76",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['HTML', 'In', 'Out', '_', '_1', '_34', '_50', '_56', '__', '___', '__builtin__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__session__', '__spec__', '_dh', '_exit_code', '_i', '_i1', '_i10', '_i11', '_i12', '_i13', '_i14', '_i15', '_i16', '_i17', '_i18', '_i19', '_i2', '_i20', '_i21', '_i22', '_i23', '_i24', '_i25', '_i26', '_i27', '_i28', '_i29', '_i3', '_i30', '_i31', '_i32', '_i33', '_i34', '_i35', '_i36', '_i37', '_i38', '_i39', '_i4', '_i40', '_i41', '_i42', '_i43', '_i44', '_i45', '_i46', '_i47', '_i48', '_i49', '_i5', '_i50', '_i51', '_i52', '_i53', '_i54', '_i55', '_i56', '_i57', '_i58', '_i59', '_i6', '_i7', '_i8', '_i9', '_ih', '_ii', '_iii', '_oh', 'acos', 'acosh', 'age', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'cbrt', 'ceil', 'cel', 'comb', 'copysign', 'cos', 'cosh', 'degrees', 'dist', 'e', 'erf', 'erfc', 'exit', 'exp', 'exp2', 'expm1', 'fabs', 'factorial', 'far', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'get_ipython', 'html_content', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'isqrt', 'lcm', 'ldexp', 'lgamma', 'list1', 'log', 'log10', 'log1p', 'log2', 'm', 'marks', 'math', 'modf', 'mylist', 'nan', 'nextafter', 'open', 'perm', 'pi', 'pow', 'prod', 'quit', 'radians', 'remainder', 'sin', 'sinh', 'sqrt', 'style', 'sys', 'tan', 'tanh', 'tau', 'trunc', 'ulp', 'x']\n"
     ]
    }
   ],
   "source": [
    "from math import *\n",
    "print(dir())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "7ff51934",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5, 625.0, -0.9880316240928618)"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "floor(5.7), pow(5,4), sin(30)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "587b4cf3",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4fb09cd6",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a1475113",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0a97850e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "17bb3f2a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "87d888f4",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "e7e56f88",
   "metadata": {},
   "source": [
    "## 3. The `math` Module\n",
    "- Python math module contains rich set of functions, that allows you to perform mathematical tasks on numbers.\n",
    "- Since the math module comes packaged with the Python release, you don't have to install it separately. Using it is just a matter of importing the module\n",
    "#### [Read Python Documentation for details about `math` module](https://docs.python.org/3/library/math.html#module-math)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08897acc",
   "metadata": {},
   "source": [
    "### a. Constants of Math Module"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d28fdb10",
   "metadata": {},
   "source": [
    "- **PI:** \n",
    "    - PI is the ratio of a circle's circumference (c) to its diameter (d).\n",
    "    - It is an irrational number, so it can be approximated to the value 22/7 = 3.141592...\n",
    "    - You can access its value since it is defined as a constant inside the math module with the name of 'pi', and is given correct upto 15 digits after the decimal point\n",
    "    - Pi has been calculated to over 50 trillion digits beyond its decimal point.  PI’s infinite nature makes it a fun challenge to memorize, and to computationally calculate more and more digits\n",
    "    - Pi Day is celebrated on March 14th (3/14) around the world. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "dated-rings",
   "metadata": {},
   "outputs": [],
   "source": [
    "# First Method\n",
    "from math import *\n",
    "# pi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "9bf94b58",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['HTML', 'In', 'Out', '_', '_1', '_34', '_50', '_56', '_60', '__', '___', '__builtin__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__session__', '__spec__', '_dh', '_exit_code', '_i', '_i1', '_i10', '_i11', '_i12', '_i13', '_i14', '_i15', '_i16', '_i17', '_i18', '_i19', '_i2', '_i20', '_i21', '_i22', '_i23', '_i24', '_i25', '_i26', '_i27', '_i28', '_i29', '_i3', '_i30', '_i31', '_i32', '_i33', '_i34', '_i35', '_i36', '_i37', '_i38', '_i39', '_i4', '_i40', '_i41', '_i42', '_i43', '_i44', '_i45', '_i46', '_i47', '_i48', '_i49', '_i5', '_i50', '_i51', '_i52', '_i53', '_i54', '_i55', '_i56', '_i57', '_i58', '_i59', '_i6', '_i60', '_i61', '_i62', '_i7', '_i8', '_i9', '_ih', '_ii', '_iii', '_oh', 'acos', 'acosh', 'age', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'cbrt', 'ceil', 'cel', 'comb', 'copysign', 'cos', 'cosh', 'degrees', 'dist', 'e', 'erf', 'erfc', 'exit', 'exp', 'exp2', 'expm1', 'fabs', 'factorial', 'far', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'get_ipython', 'html_content', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'isqrt', 'lcm', 'ldexp', 'lgamma', 'list1', 'log', 'log10', 'log1p', 'log2', 'm', 'marks', 'math', 'modf', 'mylist', 'nan', 'nextafter', 'open', 'perm', 'pi', 'pow', 'prod', 'quit', 'radians', 'remainder', 'sin', 'sinh', 'sqrt', 'style', 'sys', 'tan', 'tanh', 'tau', 'trunc', 'ulp', 'x']\n"
     ]
    }
   ],
   "source": [
    "print(dir())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "4f63a1df",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.141592653589793"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "471f1e31",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.141592653589793"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Second Method\n",
    "import math\n",
    "math.pi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e4ff38fd",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "67d637ae",
   "metadata": {},
   "source": [
    "- **TAU:**\n",
    "    - TAU is the ratio of a circule's circumference (c) to its radius (r).\n",
    "    - This constant is equal to 2PI, or roughly 6.28\n",
    "    - Like PI, TAU is also an irrational number, and can be approximated to the value 2PI = 6.28318..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "028c43a3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# First Method\n",
    "from math import *\n",
    "tau"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e0172761",
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "math.tau"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "006b7b85",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "18f35283",
   "metadata": {},
   "source": [
    "- **NaN (Not a Number):**\n",
    "    - Not a Number is not a mathematical concept, rather is introduced in the field of computer science as a reference to values that are not numeric\n",
    "    - `NaN` value can be due to invalid inputs, or it can indicate that a variable that should be numerical has been corrupted by text characters or symbols"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ec1c16a6",
   "metadata": {},
   "outputs": [],
   "source": [
    "math.nan"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fe15017a",
   "metadata": {},
   "outputs": [],
   "source": [
    "type(math.nan)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bcd20fa7",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "4df04cb5",
   "metadata": {},
   "source": [
    "### b. Arithmetic Functions of Math Module"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d543f31",
   "metadata": {},
   "source": [
    "- Factorial of a number is obtained by multiplying that number and all numbers below it till one\n",
    "- Factorial is not defined for negative values as well as for decimal values. Factorial of zero is 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1d6edd43",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "eaff58d0",
   "metadata": {},
   "source": [
    "### Code using `For` loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "ad2e9bd3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30414093201713378043612608166064768844377641568960512000000000000"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def fact_loop(num):\n",
    "    if num < 0:\n",
    "        return 0\n",
    "    if num == 0:\n",
    "        return 1\n",
    "\n",
    "    factorial = 1\n",
    "    for i in range(1, num + 1):\n",
    "        factorial = factorial * i\n",
    "    return factorial\n",
    "fact_loop(50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "medieval-river",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "32daab9f",
   "metadata": {},
   "source": [
    "### Code using `recursion` loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "15432514",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30414093201713378043612608166064768844377641568960512000000000000"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def fact_recursion(num):\n",
    "    if num < 0:\n",
    "        return 0\n",
    "    if num == 0:\n",
    "        return 1\n",
    "    return num * fact_recursion(num - 1)\n",
    "fact_loop(50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ab10b2a6",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "f5acd8e2",
   "metadata": {},
   "source": [
    "### Code using `Math` Module"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "95038bb8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30414093201713378043612608166064768844377641568960512000000000000"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import math\n",
    "math.factorial(50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "215acdd8",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "9867d051",
   "metadata": {},
   "source": [
    "**Lets compare the execution time of calculating factorial using above three ways, using the `timeit()` method which returns the time taken to execute the statements a specified number of times**\n",
    "```\n",
    "timeit.timeit(stmt, setup, globals, number)\n",
    "```\n",
    "Where\n",
    "- `stmt`: Code statement(s) whose execution time is to be measured.(Use ; for multiple statements)\n",
    "- `setup`: Used to import some modules or declare some necessary variables. (Use ; for multiple statements)\n",
    "- `globals`: You can simplay pass `globals()` to the globals parameter, which will cause the code to be executed within your current global namespace\n",
    "- `number`: It specifies the number of times stmt will be executed. (Default is 1 million times)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "09b58dbb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.7772204999928363"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import timeit\n",
    "timeit.timeit(\"fact_loop(50)\", globals=globals(), number = 1000000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "b9763a00",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.701931167015573"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "timeit.timeit(\"fact_recursion(50)\", globals=globals(), number = 1000000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "e004e08c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.30003316700458527"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "timeit.timeit(\"math.factorial(50)\", setup = \"import math\", number = 1000000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4f94dc77",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "36c8d064",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "21 -11\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "print(math.ceil(20.222), math.ceil(-11.85))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "c0ed10e4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20 -14\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "print(math.floor(20.99), math.floor(-13.1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "51b4fa7d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "215.0"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.pow(3,4)\n",
    "math.radians(60)\n",
    "math.fsum([3,4,54,65,76,7,6])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "a2292213",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(20, -13)"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import math\n",
    "math.trunc(20.99), math.trunc(-13.91)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c444686b",
   "metadata": {},
   "source": [
    "Return x with the fractional part removed, leaving the integer part. This rounds toward 0: trunc() is equivalent to floor() for positive x, and equivalent to ceil() for negative x. If x is not a float, delegates to x.__trunc__, which should return an Integral value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "27959aa1",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "eeb467a3",
   "metadata": {},
   "source": [
    "### c. Power and Logarithmic Functions of Math Module"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "755e5ecd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "32 32.0 32.0\n"
     ]
    }
   ],
   "source": [
    "# Example: The power(a,b) function returns a**b. Available in the math module as well as Python built-in function\n",
    "# The pow() function in the math module is computationally faster\n",
    "import math\n",
    "a = 2\n",
    "b = 5\n",
    "print(a**b , pow(a,b), math.pow(a,b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "0c49c68a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.0 5.830951894845301 60.19136150644875\n"
     ]
    }
   ],
   "source": [
    "# Example: The sqrt(x) function returns a number y such that y² = x;\n",
    "import math\n",
    "print(math.sqrt(25), math.sqrt(34), math.sqrt(3623))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "f3d224f8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20.085536923187664 20.085536923187668\n"
     ]
    }
   ],
   "source": [
    "# Example: The exp(x) function returns e**x, where e is Euler's number (2.718281828459045)\n",
    "import math\n",
    "x = 3\n",
    "print(math.e ** x, math.exp(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "d7e30bd9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.0794415416798357 2.0794415416798357 3.0 0.9030899869919434\n"
     ]
    }
   ],
   "source": [
    "# Example: The log(x, base) function return the logarithm of x to the mentioned base. Default base is e\n",
    "# Logarithm is the inverse function to exponentiation \n",
    "\n",
    "print(math.log(8), math.log(8, math.e), math.log(8, 2), math.log(8, 10))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0eaec94f",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0e13973b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6af25ef6",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "53435ef8",
   "metadata": {},
   "source": [
    "### d. Trigonometric and Hyperbolic Functions of Math Module\n",
    "- The word trigonometry comes from the Greek words trigonon (“triangle”) and metron (“to measure”). \n",
    "- Trigonometry is the branch of mathematics dealing with the relations of the sides and angles of triangles and with the relevant functions of any angles. \n",
    "- Trigonometric functions are used in obtaining unknown angles and distances from known or measured angles in geometric figures.\n",
    "- Note: Hyperbolic functions are analogues of the ordinary trigonometric functions, but defined using the hyperbola rather than the circle. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "80c0753f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0 0.0015926529164868282 0.8939966636005579\n"
     ]
    }
   ],
   "source": [
    "# Six functions of an angle: sin(), cos(), tan(), asin(), acos(), atan().\n",
    "# The angle given to these functions should be in radians. A circle has 360 degrees and 2pi radians\n",
    "import math\n",
    "print(math.sin(0), math.sin(3.14), math.sin(90))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "603f86b5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11.53029203041011"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Examples of Hyperbolic Functions: sinh(), cosh(), tanh(), asinh(), acosh(), atanh()\n",
    "import math\n",
    "math.sinh(3.14)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b835b598",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "65283198",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "bafb9fc3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1. import math\n",
    "# 2. import math as m\n",
    "# 3. from math import func1, func2, \n",
    "# 4. from math import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "175e66df",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9f3af462",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "43637d2d",
   "metadata": {},
   "source": [
    "## 4. The `random` Module\n",
    "- The Random module is  used to perform random actions such as generating random numbers, print random value for a list or string, etc.\n",
    "#### [Read Python Documentation for details about `random` module](https://docs.python.org/3/library/random.html#module-random)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "70c6c490",
   "metadata": {},
   "outputs": [],
   "source": [
    "#import random module\n",
    "import random\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "f139fa83",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Existing functions in Random module: \n",
      "\n",
      " ['BPF', 'LOG4', 'NV_MAGICCONST', 'RECIP_BPF', 'Random', 'SG_MAGICCONST', 'SystemRandom', 'TWOPI', '_ONE', '_Sequence', '_Set', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_accumulate', '_acos', '_bisect', '_ceil', '_cos', '_e', '_exp', '_floor', '_index', '_inst', '_isfinite', '_log', '_os', '_pi', '_random', '_repeat', '_sha512', '_sin', '_sqrt', '_test', '_test_generator', '_urandom', '_warn', 'betavariate', 'choice', 'choices', 'expovariate', 'gammavariate', 'gauss', 'getrandbits', 'getstate', 'lognormvariate', 'normalvariate', 'paretovariate', 'randbytes', 'randint', 'random', 'randrange', 'sample', 'seed', 'setstate', 'shuffle', 'triangular', 'uniform', 'vonmisesvariate', 'weibullvariate']\n",
      "Random variable generators.\n",
      "\n",
      "    bytes\n",
      "    -----\n",
      "           uniform bytes (values between 0 and 255)\n",
      "\n",
      "    integers\n",
      "    --------\n",
      "           uniform within range\n",
      "\n",
      "    sequences\n",
      "    ---------\n",
      "           pick random element\n",
      "           pick random sample\n",
      "           pick weighted random sample\n",
      "           generate random permutation\n",
      "\n",
      "    distributions on the real line:\n",
      "    ------------------------------\n",
      "           uniform\n",
      "           triangular\n",
      "           normal (Gaussian)\n",
      "           lognormal\n",
      "           negative exponential\n",
      "           gamma\n",
      "           beta\n",
      "           pareto\n",
      "           Weibull\n",
      "\n",
      "    distributions on the circle (angles 0 to 2pi)\n",
      "    ---------------------------------------------\n",
      "           circular uniform\n",
      "           von Mises\n",
      "\n",
      "General notes on the underlying Mersenne Twister core generator:\n",
      "\n",
      "* The period is 2**19937-1.\n",
      "* It is one of the most extensively tested generators in existence.\n",
      "* The random() method is implemented in C, executes in a single Python step,\n",
      "  and is, therefore, threadsafe.\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# use dir() to get the list of complete functions in random module\n",
    "print(\"Existing functions in Random module: \\n\\n\", dir(random))\n",
    "print(random.__doc__)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "74f74cd2",
   "metadata": {},
   "source": [
    "### a. The `random.random()` Function\n",
    "- This function `random.random()` returns a random float value in the interval [0,1), i.e., 0 is inclusive while 1 is not"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "3363347f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.4727789534691472"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import random\n",
    "random.random()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6b43887",
   "metadata": {},
   "source": [
    "#### Question:\n",
    "Create a sequence of 10 random floating point numbers between 0-30."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "0f3f73d3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[27.881994415660614, 20.76740967281359, 26.608002142591197, 13.820219986251786, 9.616417406510768, 27.853562800960766, 26.80491829554895, 9.292950263736019, 19.431013041672635, 13.395146216014226]\n"
     ]
    }
   ],
   "source": [
    "floatSequence = []\n",
    "for i in range(1,11):\n",
    "    floatSequence.append(random.random()*30)\n",
    "print(floatSequence)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "67a64c1e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1657f91d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "33db3a65",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bc1b4c79",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "b96d3f21",
   "metadata": {},
   "source": [
    "### b. The `random.uniform()` Function\n",
    "- This function `random.uniform(a, b)` returns a random float value in the interval a and b "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "3022eec8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "97.41713939706085"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rv = random.uniform(85, 100)\n",
    "rv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "approved-african",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[6.117781179091992, 15.874609499442263, 25.889538942444332, 13.822725223698685, 0.07577742648133268, 12.725912657727235, 6.487186352051668, 20.744309654076886, 5.453403468008205, 6.917391543011977]\n"
     ]
    }
   ],
   "source": [
    "floatSequence = []\n",
    "for i in range(1,11):\n",
    "    floatSequence.append(random.uniform(0,30))\n",
    "print(floatSequence)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "90e21995",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "ee23fa99",
   "metadata": {},
   "source": [
    "### c. The `random.randint()` and `random.randrange()` Functions\n",
    "- We have seen the use of the built-in `range()` function that provides a range object, using which you can generate a list of numbers in that specific range\n",
    "- The `random.randint(start, stop)` returns one random integer (with start and stop both inclusive).\n",
    "- The `random.randrange(start, stop=None, step=1)` returns one random integer (with stop NOT inclusive). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "163d70f3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Note the stop value is also inclusive, which is unlike what we expect in Python\n",
    "import random\n",
    "random.randint(0, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "appropriate-portuguese",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "70995"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "random.randint(10001,99999)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "78f5a0da",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "2433e606",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# This fixes the problem and does not include the endpoint\n",
    "random.randrange(0, 15,2)\n",
    "# 0,2,4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "531c6b72",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "9c923557",
   "metadata": {},
   "source": [
    "### d. The `random.choice()` Function\n",
    "- This function is passed a non-empty sequence and returns a random element from that sequence\n",
    "```\n",
    "random.choice(seq)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "033d79e1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Random element from list:  Dua\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "# select a random element from a list\n",
    "list1 = ['Ehtisham','Ali', 'Ayesha', 'Dua','Adeen', 'Ahmed',]\n",
    "print(\"Random element from list: \", random.choice(list1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "a7c942ec",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fetching Random item from string:  L\n"
     ]
    }
   ],
   "source": [
    "  \n",
    "# select a random character from a string\n",
    "string = \"HappyLearning\"\n",
    "print(\"Fetching Random item from string: \", random.choice(string))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7ce9daa8",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "62ac0657",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fetching Random element from Tuple:  5\n"
     ]
    }
   ],
   "source": [
    "# select a random item from a tuple\n",
    "tuple1 = (1, 2, 3, 4, 5)\n",
    "print(\"Fetching Random element from Tuple: \",random.choice(tuple1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e735a447",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "f3716f78",
   "metadata": {},
   "source": [
    "**With this background, one should be able explore other methods as and when required**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b217032e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# random.random() -> float value between [0,1]\n",
    "# random.uniform(a,b) -> float value between [a,b]\n",
    "# random.randint(a,b) -> integer value between [a,b]\n",
    "# random.randrange(a,b) -> integer value\n",
    "# random.choice(sequence) -> return random item from sequence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bc9eccb3",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0fab8214",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "c5a57ae0",
   "metadata": {},
   "source": [
    "## Bonus Info:\n",
    "- Before, we discuss Python's `time`, `datetime`, and `calendar` modules, let me put the stage right by having a brief discussion on the concept of time and time zones:\n",
    "\n",
    "### Calendar Time:\n",
    "- The time measured from some fixed/reference point is called real time and once category of it is calendar time. Some famous reference points and their corresponding calendars are:\n",
    "    - **Hijri Calendar** (AH), measures time from the year of Hijrat, when prophet Muhammad (Peace be upon Him) migrated from Mecca to Madina\n",
    "    - **Gregorian Calendar** (AD), measures time from birth year of Jesus Christ. AD stands for Anno Domini in Latin, means \"In the year of Jesus Christ\"\n",
    "    - **UNIX Calendar**, measures time from birth year of UNIX called UNIX epoch (00:00:00 UTC on 1 January 1970)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f01b786",
   "metadata": {},
   "source": [
    "#### Time Zones:\n",
    "- Since noon happens at different times in different parts of the world, therefore, we have divided the world in different time zones.\n",
    "- On Mac, Linux, and Windows operating systems, the information about these time zones is kept in files.\n",
    "- Let me show you the contents of these files on my `Linux` system"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "positive-diagram",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[35m/usr/share/zoneinfo/\u001b[m\u001b[m\n"
     ]
    }
   ],
   "source": [
    "!ls /usr/share/zoneinfo/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "cad8e2ec",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Aden          Chongqing     Jerusalem     Novokuznetsk  Tashkent\n",
      "Almaty        Chungking     Kabul         Novosibirsk   Tbilisi\n",
      "Amman         Colombo       Kamchatka     Omsk          Tehran\n",
      "Anadyr        Dacca         Karachi       Oral          Tel_Aviv\n",
      "Aqtau         Damascus      Kashgar       Phnom_Penh    Thimbu\n",
      "Aqtobe        Dhaka         Kathmandu     Pontianak     Thimphu\n",
      "Ashgabat      Dili          Katmandu      Pyongyang     Tokyo\n",
      "Ashkhabad     Dubai         Khandyga      Qatar         Tomsk\n",
      "Atyrau        Dushanbe      Kolkata       Qostanay      Ujung_Pandang\n",
      "Baghdad       Famagusta     Krasnoyarsk   Qyzylorda     Ulaanbaatar\n",
      "Bahrain       Gaza          Kuala_Lumpur  Rangoon       Ulan_Bator\n",
      "Baku          Harbin        Kuching       Riyadh        Urumqi\n",
      "Bangkok       Hebron        Kuwait        Saigon        Ust-Nera\n",
      "Barnaul       Ho_Chi_Minh   Macao         Sakhalin      Vientiane\n",
      "Beirut        Hong_Kong     Macau         Samarkand     Vladivostok\n",
      "Bishkek       Hovd          Magadan       Seoul         Yakutsk\n",
      "Brunei        Irkutsk       Makassar      Shanghai      Yangon\n",
      "Calcutta      Istanbul      Manila        Singapore     Yekaterinburg\n",
      "Chita         Jakarta       Muscat        Srednekolymsk Yerevan\n",
      "Choibalsan    Jayapura      Nicosia       Taipei\n"
     ]
    }
   ],
   "source": [
    "!ls /usr/share/zoneinfo/Asia"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a961b9b6",
   "metadata": {},
   "source": [
    "> On all UNIX based systems (Mac, Linux), **TZ** is an environment variable that can be set to any of the above files to get the date of that appropriate zone. By default the system is configured to set it to the local time of the country"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "id": "c17413cf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tue Aug  6 22:13:55 PKT 2024\n"
     ]
    }
   ],
   "source": [
    "! date"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "d522809d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tue Aug  6 22:14:02 PKT 2024\n"
     ]
    }
   ],
   "source": [
    "! TZ=Asia/Karachi    date"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "id": "6bdefd87",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tue Aug  6 21:14:07 +04 2024\n"
     ]
    }
   ],
   "source": [
    "! TZ=Asia/Dubai   date"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "id": "705eaf74",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tue Aug  6 17:14:15 UTC 2024\n"
     ]
    }
   ],
   "source": [
    "! TZ=America/Los-Angeles   date"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eade9942",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "id": "64a13665",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Existing functions in time module: \n",
      "\n",
      " ['CLOCK_MONOTONIC', 'CLOCK_MONOTONIC_RAW', 'CLOCK_PROCESS_CPUTIME_ID', 'CLOCK_REALTIME', 'CLOCK_THREAD_CPUTIME_ID', 'CLOCK_UPTIME_RAW', '_STRUCT_TM_ITEMS', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'altzone', 'asctime', 'clock_getres', 'clock_gettime', 'clock_gettime_ns', 'clock_settime', 'clock_settime_ns', 'ctime', 'daylight', 'get_clock_info', 'gmtime', 'localtime', 'mktime', 'monotonic', 'monotonic_ns', 'perf_counter', 'perf_counter_ns', 'process_time', 'process_time_ns', 'sleep', 'strftime', 'strptime', 'struct_time', 'thread_time', 'thread_time_ns', 'time', 'time_ns', 'timezone', 'tzname', 'tzset']\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "\n",
    "# use dir() to get the list of complete functions in time module\n",
    "print(\"Existing functions in time module: \\n\\n\", dir(time))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e3e2f52f",
   "metadata": {},
   "source": [
    "##  Getting the Local Time\n",
    "- To get the current time in Python in a more perceivable Python Date Time format, we use the localtime() method. It returns the Python time according to the area you’re in."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "id": "9281f84a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time: time.struct_time(tm_year=2024, tm_mon=8, tm_mday=6, tm_hour=22, tm_min=16, tm_sec=32, tm_wday=1, tm_yday=219, tm_isdst=0)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "time.struct_time"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import time\n",
    "local_time = time.localtime()\n",
    "print(\"Time:\",local_time)\n",
    "type(local_time)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "id": "b7142ae6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Current year: 2024\n",
      "Current hour: 22\n",
      "Current minute: 16\n",
      "Current second: 32\n"
     ]
    }
   ],
   "source": [
    "print(\"Current year:\", local_time.tm_year)\n",
    "print(\"Current hour:\", local_time.tm_hour)\n",
    "print(\"Current minute:\", local_time.tm_min)\n",
    "print(\"Current second:\", local_time.tm_sec)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1621d43e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "b5b2d536",
   "metadata": {},
   "source": [
    "## Getting the Formatted Time\n",
    "- When we use the `asctime()` method, we get something much more readable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "id": "75eeafdc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Tue Aug  6 22:16:49 2024'"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "time.asctime()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "id": "011c6251",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Tue Aug  6 22:16:58 2024'"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# You can also provide a tuple or a struct_time structure as an argument.\n",
    "time.asctime(time.localtime())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "acae783c",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "31f713ec",
   "metadata": {},
   "source": [
    "**(i) The `time.sleep(seconds)` method is used to delay execution for a given number of seconds. The argument may be a floating point number for subsecond precision.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "id": "efe8425d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is printed immediately.\n",
      "This is printed after 2 seconds.\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "print(\"This is printed immediately.\")\n",
    "time.sleep(2)\n",
    "print(\"This is printed after 2 seconds.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "32bda51c",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "70465c76",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "37f6391e",
   "metadata": {},
   "source": [
    "**(ii) The `time.time()` method returns the current time in seconds since UNIX Epoch (00:00:00 UTC on 1 January 1970).**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "id": "d0fa8a98",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1722964729.8959649"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import time\n",
    "seconds = time.time()\n",
    "seconds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3d29bea9",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8275559a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "8c1d1bb6",
   "metadata": {},
   "source": [
    "**(iii) The `time.ctime(seconds)` method takes seconds passed since epoch as argument and returns a string representing local time.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "id": "7b0c0f8a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time in seconds : 1722964761.74504\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "gettime = time.time()\n",
    "print(f\"Time in seconds : {gettime}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "id": "7b34a5e3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tue Aug  6 22:19:21 2024\n"
     ]
    }
   ],
   "source": [
    "tm = time.ctime(gettime)\n",
    "print(tm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "id": "70d0bb12",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Thu Jan  1 05:00:00 1970'"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import time\n",
    "dtg1 = time.ctime(0)\n",
    "dtg1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "id": "3e3bb56a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Tue Aug  6 22:20:00 2024'"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import time\n",
    "seconds = time.time()\n",
    "dtg2 = time.ctime(seconds)\n",
    "dtg2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "id": "846302b0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Mon Aug 28 11:42:45 2079'"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import time\n",
    "dtg2 = time.ctime(3460430565.34554)\n",
    "dtg2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "40fab0e9",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "932503c0",
   "metadata": {},
   "source": [
    "**With this background, one should be able explore other methods as and when required**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "707fe243",
   "metadata": {},
   "outputs": [],
   "source": [
    "# time.localtime -> cuurent time of laptop , return in struct_time format\n",
    "# time.asctime() -> current time but in string format\n",
    "# time.sleep(second) -> execution delay for that seconds\n",
    "# time.time() -> return current time but in seconds\n",
    "# time.ctime(seconds) -> return time in string format according seconds passed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2df896a0",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9202f9ed",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "19cc43a2",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "22be4c3d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "9445c4b5",
   "metadata": {},
   "source": [
    "## 6. The `datetime` Module\n",
    "- The Python datetime module offers functions and classes for working with date and time parsing, formatting, and arithmetic. \n",
    "- The `datetime` module can support many of the same operations as `time` module, but provides a more object oriented set of types, and also has some limited support for time zones.\n",
    "#### [Read Python Documentation for details about `datetime` module](https://docs.python.org/3/library/datetime.html#module-datetime)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "id": "8d44417f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Existing functions in datetime module: \n",
      "\n",
      " ['MAXYEAR', 'MINYEAR', 'UTC', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'date', 'datetime', 'datetime_CAPI', 'sys', 'time', 'timedelta', 'timezone', 'tzinfo']\n"
     ]
    }
   ],
   "source": [
    "# import datetime module\n",
    "import datetime\n",
    "\n",
    "# use dir() to get the list of complete functions in datetime module\n",
    "print(\"Existing functions in datetime module: \\n\\n\", dir(datetime))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "id": "0e9a16a8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#The smallest year number allowed in a date or datetime object. MINYEAR is 1.\n",
    "datetime.MINYEAR"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "id": "2783e15c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9999"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#The largest year number allowed in a date or datetime object. MAXYEAR is 9999.\n",
    "datetime.MAXYEAR\n",
    "# current year -> 2022"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0b5d6348",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "f4485572",
   "metadata": {},
   "source": [
    "**(i) The `datetime.datetime.today()` and `datetime.datetime.now()` methods return a datetime object as per the time zone of the system**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "id": "a4b34e92",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.datetime(2024, 8, 6, 22, 24, 23, 267492)"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dtg = datetime.datetime.today()\n",
    "dtg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "id": "79569129",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2024-08-06 22:24:41.181660\n",
      "<class 'datetime.datetime'>\n"
     ]
    }
   ],
   "source": [
    "dtg = datetime.datetime.now()\n",
    "print(dtg)\n",
    "print(type(dtg))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "assisted-graphic",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "0b16005d",
   "metadata": {},
   "source": [
    "**(ii) Let us explore some commonly used attributes related with the `datetime` object.**\n",
    "- `dtg.year:` returns the year\n",
    "- `dtg.month:` returns the month\n",
    "- `dtg.day:` returns the date\n",
    "- `dtg.hour:` returns the hour\n",
    "- `dtg.minute:` returns the minutes\n",
    "- `dtg.second:` returns the seconds\n",
    "- `dtg.microsecond:` returns the microseconds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "id": "d96d7c8a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2024"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dtg.year"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "id": "d4801e8a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dtg.day"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "id": "90c34166",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dtg.month"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "id": "71504a3f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "22"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dtg.hour"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "id": "a13162ec",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "181660"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dtg.microsecond"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2b62edb9",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "4889c135",
   "metadata": {},
   "source": [
    "**(iii) The `datetime.datetime(year, month, day[, hour[, minute[, second[, microsecond[,tzinfo]]]]])` method is used to create a `datetime` object**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "id": "d309a238",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2021-12-31 00:00:00\n",
      "<class 'datetime.datetime'>\n"
     ]
    }
   ],
   "source": [
    "import datetime\n",
    "dtg = datetime.datetime(2021,12,31)\n",
    "print(dtg)\n",
    "print(type(dtg))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "id": "772d1470",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2021-12-31 04:30:54.000678\n"
     ]
    }
   ],
   "source": [
    "dtg = datetime.datetime(2021, 12, 31, 4, 30, 54, 678)\n",
    "print(dtg)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cbf3ed6c",
   "metadata": {},
   "source": [
    "**(iv)  The `datetime.time([hour[, minute[, second[, microsecond[, tzinfo]]]]]) ` methods returns a `time` object.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "id": "f7922e9b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10:15:54.000247\n",
      "<class 'datetime.time'>\n"
     ]
    }
   ],
   "source": [
    "t1 = datetime.time(10, 15, 54, 247)\n",
    "print(t1)\n",
    "print(type(t1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bed950cb",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "4d2112b0",
   "metadata": {},
   "source": [
    "**With this background, one should be able explore other methods as and when required**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1922fe85",
   "metadata": {},
   "source": [
    "### What is Timedelta in Python?\n",
    "- A `timedelta represents a duration` which is the difference between two dates, time, or datetime instances, to the microsecond resolution.\n",
    "- Use the `timedelta` to add or subtract weeks, days, hours, minutes, seconds, microseconds, and milliseconds from a given date and time."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e384b74b",
   "metadata": {},
   "source": [
    "<img src=\"images/14.png\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "id": "da8561f6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Current Date and time : 2024-08-06 22:29:22.316295\n"
     ]
    }
   ],
   "source": [
    "from datetime import datetime, timedelta\n",
    "print(f\"Current Date and time : {datetime.now()}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "id": "12be5f07",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.datetime(2024, 9, 1, 3, 29, 57, 692533)"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# adding  3 weeks and 4 days and 5 hours\n",
    "newDateTime = datetime.now() + timedelta(weeks=3, days=4, hours=5)\n",
    "newDateTime"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e1e15f2f",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "70b0d72b",
   "metadata": {},
   "source": [
    "#### Example 1: Calculate the difference between two dates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "id": "fb26d36a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.datetime(2024, 8, 6, 22, 30, 44, 431226)"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import datetime\n",
    "current_date = datetime.datetime.now()\n",
    "current_date"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "id": "e85cfea4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.datetime(2020, 3, 23, 0, 0)"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "givenDate = datetime.datetime(year=2020,month=3,day=23)\n",
    "givenDate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "id": "0dfdc167",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1597 days, 22:30:44.431226\n",
      "<class 'datetime.timedelta'>\n"
     ]
    }
   ],
   "source": [
    "date = current_date-givenDate\n",
    "print(date)\n",
    "print(type(date))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a721bbc8",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "29e446de",
   "metadata": {},
   "source": [
    "#### Example 2: Calculate Future Datetime\n",
    "Let’s see how to use timedelta class to calculate future dates by `adding four weeks` to a given date."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "id": "89926ca5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Current Date : 2024-08-06 22:31:29.865864\n"
     ]
    }
   ],
   "source": [
    "from datetime import datetime, timedelta\n",
    "currentDate = datetime.now()\n",
    "print(f\"Current Date : {currentDate}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "id": "05b02c45",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Future Date : 2024-09-03 22:31:29.865864\n"
     ]
    }
   ],
   "source": [
    "# adding four weeks to the current date\n",
    "FutureDate = currentDate+timedelta(weeks=4)\n",
    "print(f\"Future Date : {FutureDate}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2c50be1e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3d741d47",
   "metadata": {},
   "outputs": [],
   "source": [
    "# datetime.datetime.now()/today() -> return current date and time in datetime format\n",
    "# datetime.datetime(years, months, days, hours, mintues,seconds) -> return a object of datetime type\n",
    "# datetime.time() -> return  a object of datetime.time \n",
    "# datetime.timedelta(weeks, days, hours, mintues)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "24ce3cff",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9a4e2a52",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "39d5f5d6",
   "metadata": {},
   "source": [
    "## 7. The `calendar` Module\n",
    "- This module allows you to output calendars like the Unix `cal` program, and provides additional useful functions related to the calendar. By default, these calendars have Monday as the first day of the week, and Sunday as the last\n",
    "#### [Read Python Documentation for details about `calendar` module](https://docs.python.org/3/library/calendar.html#module-calendar)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "id": "00c616ba",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Existing functions in calendar module: \n",
      "\n",
      " ['Calendar', 'EPOCH', 'FRIDAY', 'February', 'HTMLCalendar', 'IllegalMonthError', 'IllegalWeekdayError', 'January', 'LocaleHTMLCalendar', 'LocaleTextCalendar', 'MONDAY', 'SATURDAY', 'SUNDAY', 'THURSDAY', 'TUESDAY', 'TextCalendar', 'WEDNESDAY', '_EPOCH_ORD', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_colwidth', '_get_default_locale', '_locale', '_localized_day', '_localized_month', '_monthlen', '_nextmonth', '_prevmonth', '_spacing', 'c', 'calendar', 'datetime', 'day_abbr', 'day_name', 'different_locale', 'error', 'firstweekday', 'format', 'formatstring', 'isleap', 'leapdays', 'main', 'mdays', 'month', 'month_abbr', 'month_name', 'monthcalendar', 'monthrange', 'prcal', 'prmonth', 'prweek', 'repeat', 'setfirstweekday', 'sys', 'timegm', 'week', 'weekday', 'weekheader']\n"
     ]
    }
   ],
   "source": [
    "import calendar\n",
    "\n",
    "# use dir() to get the list of complete functions in calendar module\n",
    "print(\"Existing functions in calendar module: \\n\\n\", dir(calendar))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "id": "5205f543",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                                  2030\n",
      "\n",
      "      January                   February                   March\n",
      "Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su\n",
      "    1  2  3  4  5  6                   1  2  3                   1  2  3\n",
      " 7  8  9 10 11 12 13       4  5  6  7  8  9 10       4  5  6  7  8  9 10\n",
      "14 15 16 17 18 19 20      11 12 13 14 15 16 17      11 12 13 14 15 16 17\n",
      "21 22 23 24 25 26 27      18 19 20 21 22 23 24      18 19 20 21 22 23 24\n",
      "28 29 30 31               25 26 27 28               25 26 27 28 29 30 31\n",
      "\n",
      "       April                      May                       June\n",
      "Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su\n",
      " 1  2  3  4  5  6  7             1  2  3  4  5                      1  2\n",
      " 8  9 10 11 12 13 14       6  7  8  9 10 11 12       3  4  5  6  7  8  9\n",
      "15 16 17 18 19 20 21      13 14 15 16 17 18 19      10 11 12 13 14 15 16\n",
      "22 23 24 25 26 27 28      20 21 22 23 24 25 26      17 18 19 20 21 22 23\n",
      "29 30                     27 28 29 30 31            24 25 26 27 28 29 30\n",
      "\n",
      "        July                     August                  September\n",
      "Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su\n",
      " 1  2  3  4  5  6  7                1  2  3  4                         1\n",
      " 8  9 10 11 12 13 14       5  6  7  8  9 10 11       2  3  4  5  6  7  8\n",
      "15 16 17 18 19 20 21      12 13 14 15 16 17 18       9 10 11 12 13 14 15\n",
      "22 23 24 25 26 27 28      19 20 21 22 23 24 25      16 17 18 19 20 21 22\n",
      "29 30 31                  26 27 28 29 30 31         23 24 25 26 27 28 29\n",
      "                                                    30\n",
      "\n",
      "      October                   November                  December\n",
      "Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su\n",
      "    1  2  3  4  5  6                   1  2  3                         1\n",
      " 7  8  9 10 11 12 13       4  5  6  7  8  9 10       2  3  4  5  6  7  8\n",
      "14 15 16 17 18 19 20      11 12 13 14 15 16 17       9 10 11 12 13 14 15\n",
      "21 22 23 24 25 26 27      18 19 20 21 22 23 24      16 17 18 19 20 21 22\n",
      "28 29 30 31               25 26 27 28 29 30         23 24 25 26 27 28 29\n",
      "                                                    30 31\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# calendar() method to print the calendar of whole year\n",
    "import calendar\n",
    "cy = calendar.calendar(2030) \n",
    "print(cy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0a684776-613a-422a-8af4-9745b459d5b2",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "internal-palestine",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "id": "04121b7c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     April 2022\n",
      "Mo Tu We Th Fr Sa Su\n",
      "             1  2  3\n",
      " 4  5  6  7  8  9 10\n",
      "11 12 13 14 15 16 17\n",
      "18 19 20 21 22 23 24\n",
      "25 26 27 28 29 30\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import calendar\n",
    "# month() method is used to print calendar of specific month\n",
    "\n",
    "#print calendar of November 2021\n",
    "c = calendar.month(2022,4) \n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "id": "c46a0b6e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    January 1970\n",
      "Mo Tu We Th Fr Sa Su\n",
      "          1  2  3  4\n",
      " 5  6  7  8  9 10 11\n",
      "12 13 14 15 16 17 18\n",
      "19 20 21 22 23 24 25\n",
      "26 27 28 29 30 31\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import calendar\n",
    "# month() method is used to print calendar of specific month\n",
    "\n",
    "#print calendar of November 2021\n",
    "c = calendar.month(1970,1) \n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "id": "48d3e53f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2021 is leap year:  False\n",
      "2020 was be leap year:  True\n"
     ]
    }
   ],
   "source": [
    "import calendar\n",
    "# can check wether the year is leap year or not\n",
    "print(\"2021 is leap year: \", calendar.isleap(2021))\n",
    "\n",
    "print(\"2020 was be leap year: \", calendar.isleap(2020))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d746cb9f",
   "metadata": {},
   "source": [
    "**With this background, one should be able explore other methods as and when required**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5d481de2",
   "metadata": {},
   "outputs": [],
   "source": [
    "# calendar.calendar(year) -> return a calendar of complete year\n",
    "# calendar.month(year, months) -> return a month of specific year"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8f879163",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "26acc9aa",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "b07f1899",
   "metadata": {},
   "source": [
    "## 8. The `os` Module\n",
    "- Python OS module provides the facility to establish the interaction between the user and the operating system. It offers many useful OS functions that are used to perform OS-based tasks and get related information about operating system.\n",
    "- This module provides a portable way of using operating system dependent functionality and provides dozens of functions for interacting with the operating system\n",
    "#### [Read Python Documentation for details about `os` module](https://docs.python.org/3/library/os.html#module-os)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "id": "f02e0918",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Existing functions in OS module: \n",
      "\n",
      " ['CLD_CONTINUED', 'CLD_DUMPED', 'CLD_EXITED', 'CLD_KILLED', 'CLD_STOPPED', 'CLD_TRAPPED', 'DirEntry', 'EX_CANTCREAT', 'EX_CONFIG', 'EX_DATAERR', 'EX_IOERR', 'EX_NOHOST', 'EX_NOINPUT', 'EX_NOPERM', 'EX_NOUSER', 'EX_OK', 'EX_OSERR', 'EX_OSFILE', 'EX_PROTOCOL', 'EX_SOFTWARE', 'EX_TEMPFAIL', 'EX_UNAVAILABLE', 'EX_USAGE', 'F_LOCK', 'F_OK', 'F_TEST', 'F_TLOCK', 'F_ULOCK', 'GenericAlias', 'Mapping', 'MutableMapping', 'NGROUPS_MAX', 'O_ACCMODE', 'O_APPEND', 'O_ASYNC', 'O_CLOEXEC', 'O_CREAT', 'O_DIRECTORY', 'O_DSYNC', 'O_EVTONLY', 'O_EXCL', 'O_EXLOCK', 'O_FSYNC', 'O_NDELAY', 'O_NOCTTY', 'O_NOFOLLOW', 'O_NOFOLLOW_ANY', 'O_NONBLOCK', 'O_RDONLY', 'O_RDWR', 'O_SHLOCK', 'O_SYMLINK', 'O_SYNC', 'O_TRUNC', 'O_WRONLY', 'POSIX_SPAWN_CLOSE', 'POSIX_SPAWN_DUP2', 'POSIX_SPAWN_OPEN', 'PRIO_PGRP', 'PRIO_PROCESS', 'PRIO_USER', 'P_ALL', 'P_NOWAIT', 'P_NOWAITO', 'P_PGID', 'P_PID', 'P_WAIT', 'PathLike', 'RTLD_GLOBAL', 'RTLD_LAZY', 'RTLD_LOCAL', 'RTLD_NODELETE', 'RTLD_NOLOAD', 'RTLD_NOW', 'R_OK', 'SCHED_FIFO', 'SCHED_OTHER', 'SCHED_RR', 'SEEK_CUR', 'SEEK_DATA', 'SEEK_END', 'SEEK_HOLE', 'SEEK_SET', 'ST_NOSUID', 'ST_RDONLY', 'TMP_MAX', 'WCONTINUED', 'WCOREDUMP', 'WEXITED', 'WEXITSTATUS', 'WIFCONTINUED', 'WIFEXITED', 'WIFSIGNALED', 'WIFSTOPPED', 'WNOHANG', 'WNOWAIT', 'WSTOPPED', 'WSTOPSIG', 'WTERMSIG', 'WUNTRACED', 'W_OK', 'X_OK', '_Environ', '__all__', '__builtins__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_check_methods', '_execvpe', '_exists', '_exit', '_fspath', '_fwalk', '_get_exports_list', '_spawnvef', '_walk', '_wrap_close', 'abc', 'abort', 'access', 'altsep', 'chdir', 'chflags', 'chmod', 'chown', 'chroot', 'close', 'closerange', 'confstr', 'confstr_names', 'cpu_count', 'ctermid', 'curdir', 'defpath', 'device_encoding', 'devnull', 'dup', 'dup2', 'environ', 'environb', 'error', 'execl', 'execle', 'execlp', 'execlpe', 'execv', 'execve', 'execvp', 'execvpe', 'extsep', 'fchdir', 'fchmod', 'fchown', 'fdopen', 'fork', 'forkpty', 'fpathconf', 'fsdecode', 'fsencode', 'fspath', 'fstat', 'fstatvfs', 'fsync', 'ftruncate', 'fwalk', 'get_blocking', 'get_exec_path', 'get_inheritable', 'get_terminal_size', 'getcwd', 'getcwdb', 'getegid', 'getenv', 'getenvb', 'geteuid', 'getgid', 'getgrouplist', 'getgroups', 'getloadavg', 'getlogin', 'getpgid', 'getpgrp', 'getpid', 'getppid', 'getpriority', 'getsid', 'getuid', 'initgroups', 'isatty', 'kill', 'killpg', 'lchflags', 'lchmod', 'lchown', 'linesep', 'link', 'listdir', 'lockf', 'login_tty', 'lseek', 'lstat', 'major', 'makedev', 'makedirs', 'minor', 'mkdir', 'mkfifo', 'mknod', 'name', 'nice', 'open', 'openpty', 'pardir', 'path', 'pathconf', 'pathconf_names', 'pathsep', 'pipe', 'popen', 'posix_spawn', 'posix_spawnp', 'pread', 'preadv', 'putenv', 'pwrite', 'pwritev', 'read', 'readlink', 'readv', 'register_at_fork', 'remove', 'removedirs', 'rename', 'renames', 'replace', 'rmdir', 'scandir', 'sched_get_priority_max', 'sched_get_priority_min', 'sched_yield', 'sendfile', 'sep', 'set_blocking', 'set_inheritable', 'setegid', 'seteuid', 'setgid', 'setgroups', 'setpgid', 'setpgrp', 'setpriority', 'setregid', 'setreuid', 'setsid', 'setuid', 'spawnl', 'spawnle', 'spawnlp', 'spawnlpe', 'spawnv', 'spawnve', 'spawnvp', 'spawnvpe', 'st', 'stat', 'stat_result', 'statvfs', 'statvfs_result', 'strerror', 'supports_bytes_environ', 'supports_dir_fd', 'supports_effective_ids', 'supports_fd', 'supports_follow_symlinks', 'symlink', 'sync', 'sys', 'sysconf', 'sysconf_names', 'system', 'tcgetpgrp', 'tcsetpgrp', 'terminal_size', 'times', 'times_result', 'truncate', 'ttyname', 'umask', 'uname', 'uname_result', 'unlink', 'unsetenv', 'urandom', 'utime', 'wait', 'wait3', 'wait4', 'waitpid', 'waitstatus_to_exitcode', 'walk', 'write', 'writev']\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "# to get the list of complete functions in OS module\n",
    "print(\"Existing functions in OS module: \\n\\n\", dir(os))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d023958a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "acc846b9",
   "metadata": {},
   "source": [
    "## **1- os.name()**\n",
    "- This function provides the name of the operating system module that it imports.\n",
    "- Currently, it registers 'posix', 'nt', 'os2', 'ce', 'java' and 'riscos'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "id": "4847870e",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "id": "fbb7bbe3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'posix'"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "os.name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7c20f213",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1bdeb867",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "fb5b11e7",
   "metadata": {},
   "source": [
    "Windows NT is a family of operating systems developed by Microsoft that featured multi-processing capabilities, processor independence and multi-user support. The first version was released in 1993 as Windows NT 3.1, which was produced for servers and workstations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1d3d7c96",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9d8f9a23",
   "metadata": {},
   "outputs": [],
   "source": [
    "# os module\n",
    "import os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9092184a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6e3b52dd",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "6352299e",
   "metadata": {},
   "source": [
    "### a. The `os.getcwd()`  and `os.listdir()` Function\n",
    "- The `os.getcwd()` return a unicode string representing the current working directory.\n",
    "- The `os.listdir(path=None)` return a list containing the names of the files in the pwd in arbitrary order. Does not display '.' and '..' directories. An optional path can be specified\n",
    "- `os.listdir(path=None)` method returns a list of all the files and folders present inside the specified directory. If no directory is specified then the list of files and folders inside the CWD is returned.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "id": "70c024c7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Current working directory:\n",
      " /Users/ehtishamsadiq/Data/Python_Backend\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "\n",
    "# getcwd() function is used to return the current working directory\n",
    "cwd = os.getcwd()\n",
    "print(\"Current working directory:\\n\", cwd )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "09141d6c",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "id": "df43b322",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Contents of directory: \n",
      " ['Assignments', '.DS_Store', 'images', 'README.md', 'Day2.ipynb', '.gitignore', 'Day6.ipynb', 'Day4.ipynb', 'Files', '.ipynb_checkpoints', 'Day3.ipynb', '.git', 'Day1.ipynb', 'Day5.ipynb', 'Syllabus.pdf']\n"
     ]
    }
   ],
   "source": [
    "# lisdir() function is used to return the contents of current working directory\n",
    "mylist = os.listdir()\n",
    "print(\"\\nContents of directory: \\n\", mylist )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "07be3bdd",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "id": "ec6faac9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Contents of directory: \n",
      " ['Assignments', '.DS_Store', 'images', 'README.md', 'Day2.ipynb', '.gitignore', 'Day6.ipynb', 'Day4.ipynb', 'Files', '.ipynb_checkpoints', 'Day3.ipynb', '.git', 'Day1.ipynb', 'Day5.ipynb', 'Syllabus.pdf']\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# lisdir() function is used to return the contents of current working directory\n",
    "mylist = os.listdir(os.getcwd())\n",
    "print(\"\\nContents of directory: \\n\", mylist )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dfa6ebfc",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "843543d9",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "id": "ac69c964",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Contents of directory: \n",
      " ['FoodSaver', 'Ehtisham', 'Food-donation-management-system', 'learn-javascript', 'Roadmaps', 'Assignments', '.DS_Store', 'LinkedIn-Posts', 'Github-Articles', 'facial-recognition-attendance-webapp', 'Face_Recognition', 'projects', 'Pictures', 'Web Projects', 'Face-Recognition-using-Deep-Learning-Approach', 'resumes', 'repositories', 'crowd-emotion-recognition', 'Books', 'Python_Backend', 'P0Q6R9S2-MLZone', 'Testing', 'Introduction-to-Data-Analyst-and-Data-Science', 'Artificial Intelligence Programs Informational Session 2024', 'Learn Deep Learning from Scratch', 'FoodSaver.zip']\n"
     ]
    }
   ],
   "source": [
    "path = \"/Users/ehtishamsadiq/Data/\"\n",
    "mylist = os.listdir(path)\n",
    "print(\"\\nContents of directory: \\n\", mylist )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2ad24ca6",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dirty-collapse",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "7b6c18e2",
   "metadata": {},
   "source": [
    "### b. The `os.chdir()` Function\n",
    "- The `os.chdir(path)` function is used to change the current working directory to the specified path."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "id": "967c1537",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Get current working directory:\n",
      "\n",
      "\n",
      " /Users/ehtishamsadiq/Data/Python_Backend\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "\n",
    "print(\"Get current working directory:\\n\\n\\n\", os.getcwd())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "id": "121b8266",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'/Users/ehtishamsadiq/Data'"
      ]
     },
     "execution_count": 155,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "path = \"/Users/ehtishamsadiq/Data\"\n",
    "path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "id": "ca117592",
   "metadata": {},
   "outputs": [],
   "source": [
    "os.chdir(path)\n",
    "# os.chdir(\"F:\\Python Programs\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "id": "3e6ad489",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'/Users/ehtishamsadiq/Data'"
      ]
     },
     "execution_count": 157,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "os.getcwd()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "id": "f3ba5661",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Get current working directory again:\n",
      "\n",
      "\n",
      " /Users/ehtishamsadiq/Data\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "['FoodSaver',\n",
       " 'Ehtisham',\n",
       " 'Food-donation-management-system',\n",
       " 'learn-javascript',\n",
       " 'Roadmaps',\n",
       " 'Assignments',\n",
       " '.DS_Store',\n",
       " 'LinkedIn-Posts',\n",
       " 'Github-Articles',\n",
       " 'facial-recognition-attendance-webapp',\n",
       " 'Face_Recognition',\n",
       " 'projects',\n",
       " 'Pictures',\n",
       " 'Web Projects',\n",
       " 'Face-Recognition-using-Deep-Learning-Approach',\n",
       " 'resumes',\n",
       " 'repositories',\n",
       " 'crowd-emotion-recognition',\n",
       " 'Books',\n",
       " 'Python_Backend',\n",
       " 'P0Q6R9S2-MLZone',\n",
       " 'Testing',\n",
       " 'Introduction-to-Data-Analyst-and-Data-Science',\n",
       " 'Artificial Intelligence Programs Informational Session 2024',\n",
       " 'Learn Deep Learning from Scratch',\n",
       " 'FoodSaver.zip']"
      ]
     },
     "execution_count": 158,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(\"\\nGet current working directory again:\\n\\n\\n\", os.getcwd())\n",
    "os.listdir()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6ed3a0c9",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3f877588",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "25a738ce",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "881ddaca",
   "metadata": {},
   "source": [
    "### c. The   `os.mkdir()` and `os.rmdir()`Function\n",
    "- The `os.mkdir(path)` function creates a new directory\n",
    "- The `os.rmdir(path)` function removes a directory\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "id": "427a8ca3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Current working directory : /Users/ehtishamsadiq/Data\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "\n",
    "print(f\"Current working directory : {os.getcwd()}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "id": "16b6427f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Contents of directory:  ['FoodSaver', 'Ehtisham', 'Food-donation-management-system', 'learn-javascript', 'Roadmaps', 'Assignments', '.DS_Store', 'LinkedIn-Posts', 'Github-Articles', 'facial-recognition-attendance-webapp', 'Face_Recognition', 'projects', 'Pictures', 'Web Projects', 'Face-Recognition-using-Deep-Learning-Approach', 'resumes', 'repositories', 'crowd-emotion-recognition', 'Books', 'Python_Backend', 'P0Q6R9S2-MLZone', 'Testing', 'Introduction-to-Data-Analyst-and-Data-Science', 'Artificial Intelligence Programs Informational Session 2024', 'Learn Deep Learning from Scratch', 'FoodSaver.zip']\n"
     ]
    }
   ],
   "source": [
    "list1 = os.listdir(os.getcwd())\n",
    "print(\"Contents of directory: \", list1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "id": "03de6d58",
   "metadata": {},
   "outputs": [],
   "source": [
    "os.mkdir(\"ANewDir\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "id": "cda22130",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Contents of directory:  ['FoodSaver', 'Ehtisham', 'Food-donation-management-system', 'learn-javascript', 'Roadmaps', 'Assignments', '.DS_Store', 'LinkedIn-Posts', 'Github-Articles', 'facial-recognition-attendance-webapp', 'Face_Recognition', 'projects', 'Pictures', 'Web Projects', 'Face-Recognition-using-Deep-Learning-Approach', 'resumes', 'repositories', 'crowd-emotion-recognition', 'Books', 'Python_Backend', 'P0Q6R9S2-MLZone', 'Testing', 'Introduction-to-Data-Analyst-and-Data-Science', 'Artificial Intelligence Programs Informational Session 2024', 'ANewDir', 'Learn Deep Learning from Scratch', 'FoodSaver.zip']\n"
     ]
    }
   ],
   "source": [
    "list2 = os.listdir(os.getcwd())\n",
    "print(\"Contents of directory: \", list2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "genetic-antibody",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "id": "89d5a13f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Content of directory : ['FoodSaver', 'Ehtisham', 'Food-donation-management-system', 'learn-javascript', 'Roadmaps', 'Assignments', '.DS_Store', 'LinkedIn-Posts', 'Github-Articles', 'facial-recognition-attendance-webapp', 'Face_Recognition', 'projects', 'Pictures', 'Web Projects', 'Face-Recognition-using-Deep-Learning-Approach', 'resumes', 'repositories', 'crowd-emotion-recognition', 'Books', 'Python_Backend', 'P0Q6R9S2-MLZone', 'Testing', 'Introduction-to-Data-Analyst-and-Data-Science', 'Artificial Intelligence Programs Informational Session 2024', 'Learn Deep Learning from Scratch', 'FoodSaver.zip']\n"
     ]
    }
   ],
   "source": [
    "os.rmdir(\"ANewDir\")\n",
    "print(f\"Content of directory : {os.listdir(os.getcwd())}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "83afaec8",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "a78708e6-2964-473a-a41d-e8dc67c7a6f5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Introduction to Python\n",
    "# Variables \n",
    "# Operators\n",
    "# Comments & Indentation\n",
    "# Data-Types (Mutable vs Immutable)\n",
    "# Type-Conversion (int(), float(), list(), dictionary())\n",
    "# If-Else, nested, break, continue, pass\n",
    "# For, while , nested , for-else, break\n",
    "# Functions(user-define, builtin functions)(Lambda, map, reduce, filter, sorted(key))\n",
    "# Exceptional Handling (try, except, multiple excepts, types, arise, assert)\n",
    "# Builtin Modules(math, random(random, uniform, randint, randrange, choice)\n",
    "# Time, datetime, calender(timedelta)\n",
    "# OS(getcwd(), listdir(), mkdir(), rmdir(), chdir()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2b5d7585-1448-4710-b494-a9fa240e9dde",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2282937f-d0ba-46eb-aecd-f7313a800d3b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "44f42f0e",
   "metadata": {},
   "source": [
    "## os.rename()\n",
    "A file or directory can be renamed by using the function os.rename(). A user can rename the file if it has privilege to change the file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "9cbd5b0e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[34mAssignments\u001b[m\u001b[m  Day2.ipynb   Day5.ipynb   \u001b[34mFiles\u001b[m\u001b[m        \u001b[34mimages\u001b[m\u001b[m\n",
      "\u001b[34mData-Science\u001b[m\u001b[m Day3.ipynb   Day6.ipynb   README.md\n",
      "Day1.ipynb   Day4.ipynb   \u001b[34mDay7\u001b[m\u001b[m         Syllabus.pdf\n"
     ]
    }
   ],
   "source": [
    "!ls # dir"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "019659ba",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'/Users/ehtishamsadiq/Data/Python_Backend'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import os\n",
    "os.getcwd()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "0e84840d",
   "metadata": {},
   "outputs": [],
   "source": [
    "os.mkdir(\"Data-Science\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "96ffc65d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Assignments', '.DS_Store', 'Data-Science', 'images', 'README.md', 'Day2.ipynb', '.gitignore', 'Day7', 'Day6.ipynb', 'Day4.ipynb', 'Files', '.ipynb_checkpoints', 'Day3.ipynb', '.git', 'Day1.ipynb', 'Day5.ipynb', 'Syllabus.pdf']\n"
     ]
    }
   ],
   "source": [
    "print(os.listdir())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "f593d054",
   "metadata": {},
   "outputs": [],
   "source": [
    "filename = \"Data-Science\"\n",
    "renameFile = os.rename(filename, \"Machine-Learning\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "13825aa3-cd39-4a40-82fc-04e8a49af697",
   "metadata": {},
   "outputs": [],
   "source": [
    "renameFile"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "12bed419",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Assignments', '.DS_Store', 'images', 'README.md', 'Day2.ipynb', '.gitignore', 'Day7', 'Day6.ipynb', 'Day4.ipynb', 'Files', '.ipynb_checkpoints', 'Day3.ipynb', '.git', 'Machine-Learning', 'Day1.ipynb', 'Day5.ipynb', 'Syllabus.pdf']\n"
     ]
    }
   ],
   "source": [
    "print(os.listdir())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "06637392",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b8bd018d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5c2e9db6",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "591547b1",
   "metadata": {},
   "source": [
    "### d. The   `os.system()` Function\n",
    "- The `os.system(command)` method is used to execute the command in a subshell"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "ce938430",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function system in module posix:\n",
      "\n",
      "system(command)\n",
      "    Execute the command in a subshell.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(os.system)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "64fd97a4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "This is getting more and more interesting\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import os\n",
    "\n",
    "\n",
    "print(\"\\n\")\n",
    "os.system('echo \"This is getting more and more interesting\"')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "066b931e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "Wed Aug  7 20:23:02 PKT 2024\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(\"\\n\")\n",
    "os.system('date')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "42179e50",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wed Aug  7 20:23:07 PKT 2024\n"
     ]
    }
   ],
   "source": [
    "!date"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "a16211b8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[34mAssignments\u001b[m\u001b[m\n",
      "Day1.ipynb\n",
      "Day2.ipynb\n",
      "Day3.ipynb\n",
      "Day4.ipynb\n",
      "Day5.ipynb\n",
      "Day6.ipynb\n",
      "\u001b[34mDay7\u001b[m\u001b[m\n",
      "\u001b[34mFiles\u001b[m\u001b[m\n",
      "\u001b[34mMachine-Learning\u001b[m\u001b[m\n",
      "README.md\n",
      "Syllabus.pdf\n",
      "\u001b[34mimages\u001b[m\u001b[m\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "print(os.system('ls'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "41e6003e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[34mAssignments\u001b[m\u001b[m      Day4.ipynb       \u001b[34mFiles\u001b[m\u001b[m            \u001b[34mimages\u001b[m\u001b[m\n",
      "Day1.ipynb       Day5.ipynb       \u001b[34mMachine-Learning\u001b[m\u001b[m\n",
      "Day2.ipynb       Day6.ipynb       README.md\n",
      "Day3.ipynb       \u001b[34mDay7\u001b[m\u001b[m             Syllabus.pdf\n"
     ]
    }
   ],
   "source": [
    "!ls"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "amateur-salon",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wed Aug  7 20:23:45 PKT 2024\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import os\n",
    "cmd = 'date'\n",
    "os.system(cmd)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "83e3763b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "76b29ad9",
   "metadata": {},
   "source": [
    "**Students should explore other functions like `chmod()`, `chown()`, `fstat()`, `getpid()`, `getuid()`**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "subject-effort",
   "metadata": {},
   "source": [
    "os.getuid() method in Python is used to get the current process’s real user id while os.setuid() method is used to set the current process’s real user id."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "african-diameter",
   "metadata": {},
   "source": [
    "os.getpid() method in Python is used to get the process ID of the current process."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aa32c200",
   "metadata": {},
   "outputs": [],
   "source": [
    "# os.name -> current operating system\n",
    "# os.getcwd() -> current directory present/working\n",
    "# os.listdir() -> return all the files and folders/directories in cwd\n",
    "# os.chdir(path) -> return our cwd to given path\n",
    "# os.mkdir() -> used to create a new directory in cwd\n",
    "# os.rmdir() ->  cwd , remove specific folder/file\n",
    "# os.rename() -> to remane any file and folder in cwd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1b021e19",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4f6c6ef2",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0d4d6287",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0224edbd",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "87567943",
   "metadata": {},
   "source": [
    "## 10. The `urllib` Package\n",
    "- The `urllib` package in Python 3 is a collection of following Python modules used for working with Uniform Resource Locators:\n",
    "    - `urllib.request` for opening and reading URLs, using variety of protocols\n",
    "    - `urllib.error` containing the exceptions raised by urllib.request\n",
    "    - `urllib.parse` for parsing URLs\n",
    "    - `urllib.robotparser` for parsing robots.txt files\n",
    "\n",
    "#### [Read Python Documentation for details about `urllib` package](https://docs.python.org/3/library/urllib.html#module-urllib)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "30925dca",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "463d26b5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'/Users/ehtishamsadiq/Data/Python_Backend'"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "os.getcwd()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "3b01aadf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__path__', '__spec__', 'error', 'parse', 'request', 'response']\n"
     ]
    }
   ],
   "source": [
    "import urllib\n",
    "print(dir(urllib))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "d61ea2d6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "https://pucit.edu.pk/\n"
     ]
    }
   ],
   "source": [
    "link = \"https://pucit.edu.pk/\"\n",
    "print(link)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6cfd0f13",
   "metadata": {},
   "outputs": [],
   "source": [
    "# dir(urllib.request)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "8bab92b9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<http.client.HTTPResponse at 0x106e52f50>"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "req_url = urllib.request.urlopen(link)\n",
    "req_url"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "57c5644e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "http.client.HTTPResponse"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(req_url)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "341a27b5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['__abstractmethods__', '__class__', '__del__', '__delattr__', '__dict__', '__dir__', '__doc__', '__enter__', '__eq__', '__exit__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__next__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '_abc_impl', '_checkClosed', '_checkReadable', '_checkSeekable', '_checkWritable', '_check_close', '_close_conn', '_get_chunk_left', '_method', '_peek_chunked', '_read1_chunked', '_read_and_discard_trailer', '_read_chunked', '_read_next_chunk_size', '_read_status', '_readinto_chunked', '_safe_read', '_safe_readinto', 'begin', 'chunk_left', 'chunked', 'close', 'closed', 'code', 'debuglevel', 'detach', 'fileno', 'flush', 'fp', 'getcode', 'getheader', 'getheaders', 'geturl', 'headers', 'info', 'isatty', 'isclosed', 'length', 'msg', 'peek', 'read', 'read1', 'readable', 'readinto', 'readinto1', 'readline', 'readlines', 'reason', 'seek', 'seekable', 'status', 'tell', 'truncate', 'url', 'version', 'will_close', 'writable', 'write', 'writelines']\n"
     ]
    }
   ],
   "source": [
    "print(dir(req_url))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "61b1f0ba",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "200"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "req_url.status"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "ec1f8b39",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'http.client.HTTPResponse'>\n",
      "b'<!doctype html><html itemscope=\"\" itemtype=\"http://schema.org/WebPage\" lang=\"en-PK\"><head><meta content=\"text/html; charset=UTF-8\" http-equiv=\"Content-Type\"><meta content=\"/images/branding/googleg/1x/googleg_standard_color_128dp.png\" itemprop=\"image\"><title>Google</title><script nonce=\"MKTUJnkoxYDV8uwziXVryA\">(function(){var _g={kEI:\\'EZSzZuHdAZWv0-kP7oB7\\',kEXPI:\\'0,793110,1711415,1195736,1120,8,89,538567,2872,2891,8348,3406,67693,27869,145698,2,16737,23024,6700,41948,54822,2912,2,2,1,24626,2006,8155,23351,22435,9779,62657,73179,3030,15816,1804,7734,18674,685,7900,12089,1635,9708,19568,27083,5212676,998,64,40,5,18,5991305,2840783,5,5,10,7,2,2,8,3,209,27981101,16673,43886,3,318,4,1281,3,2124363,23029351,8163,4636,11731,4705,36664,47381,11729,10894,7551,7,5394,2212,8181,154,17723,10969,20584,9929,156,11582,6757,155,2484,13504,7735,6600,2539,4600,207,121,1543,1674,4,3004,2949,16725,409,518,2805,1,6,2907,1670,5634,686,930,2000,3747,1119,3,1771,1064,180,2695,4475,1896,3337,378,475,217,4858,710,547,135,664,5402,440,339,918,2115,2574,765,1150,356,1134,436,286,2,9,3997,3,836,3731,294,405,2802,1340,2379,369,3,194,190,4,614,112,793,186,528,1720,4,134,2,907,4088,2860,2011,454,4,258,3253,44,3,856,9,494,20,3592,1869,463,1962,134,13,552,29,69,2392,117,81,2,45,881,1556,2545,578,486,1,547,2,6,1333,82,105,2,168,397,192,517,60,440,625,163,270,6,286,438,1429,384,226,9,499,1727,4717,4,456,369,1288,1945,161,1184,650,206,369,895,2,501,3,185,424,3,2,3,57,445,7,1111,160,918,379,280,61,94,150,27,208,239,3,38,50,200,302,298,3,127,442,1716,287,4,2,3,1848,2,3,1154,287,770,402,179,71,573,178,275,112,441,304,4,661,232,257,1037,80,1590,1213,711,21507326,3,14475,3,7053,330,782,47,616,4652\\',kBL:\\'Z6jn\\',kOPI:89978449};(function(){var a;((a=window.google)==null?0:a.stvsc)?google.kEI=_g.kEI:window.google=_g;}).call(this);})();(function(){google.sn=\\'webhp\\';google.kHL=\\'en-PK\\';})();(function(){\\nvar h=this||self;function l(){return window.google!==void 0&&window.google.kOPI!==void 0&&window.google.kOPI!==0?window.google.kOPI:null};var m,n=[];function p(a){for(var b;a&&(!a.getAttribute||!(b=a.getAttribute(\"eid\")));)a=a.parentNode;return b||m}function q(a){for(var b=null;a&&(!a.getAttribute||!(b=a.getAttribute(\"leid\")));)a=a.parentNode;return b}function r(a){/^http:/i.test(a)&&window.location.protocol===\"https:\"&&(google.ml&&google.ml(Error(\"a\"),!1,{src:a,glmm:1}),a=\"\");return a}\\nfunction t(a,b,c,d,k){var e=\"\";b.search(\"&ei=\")===-1&&(e=\"&ei=\"+p(d),b.search(\"&lei=\")===-1&&(d=q(d))&&(e+=\"&lei=\"+d));d=\"\";var g=b.search(\"&cshid=\")===-1&&a!==\"slh\",f=[];f.push([\"zx\",Date.now().toString()]);h._cshid&&g&&f.push([\"cshid\",h._cshid]);c=c();c!=null&&f.push([\"opi\",c.toString()]);for(c=0;c<f.length;c++){if(c===0||c>0)d+=\"&\";d+=f[c][0]+\"=\"+f[c][1]}return\"/\"+(k||\"gen_204\")+\"?atyp=i&ct=\"+String(a)+\"&cad=\"+(b+e+d)};m=google.kEI;google.getEI=p;google.getLEI=q;google.ml=function(){return null};google.log=function(a,b,c,d,k,e){e=e===void 0?l:e;c||(c=t(a,b,e,d,k));if(c=r(c)){a=new Image;var g=n.length;n[g]=a;a.onerror=a.onload=a.onabort=function(){delete n[g]};a.src=c}};google.logUrl=function(a,b){b=b===void 0?l:b;return t(\"\",a,b)};}).call(this);(function(){google.y={};google.sy=[];var d;(d=google).x||(d.x=function(a,b){if(a)var c=a.id;else{do c=Math.random();while(google.y[c])}google.y[c]=[a,b];return!1});var e;(e=google).sx||(e.sx=function(a){google.sy.push(a)});google.lm=[];var f;(f=google).plm||(f.plm=function(a){google.lm.push.apply(google.lm,a)});google.lq=[];var g;(g=google).load||(g.load=function(a,b,c){google.lq.push([[a],b,c])});var h;(h=google).loadAll||(h.loadAll=function(a,b){google.lq.push([a,b])});google.bx=!1;var k;(k=google).lx||(k.lx=function(){});var l=[],m;(m=google).fce||(m.fce=function(a,b,c,n){l.push([a,b,c,n])});google.qce=l;}).call(this);google.f={};(function(){\\ndocument.documentElement.addEventListener(\"submit\",function(b){var a;if(a=b.target){var c=a.getAttribute(\"data-submitfalse\");a=c===\"1\"||c===\"q\"&&!a.elements.q.value?!0:!1}else a=!1;a&&(b.preventDefault(),b.stopPropagation())},!0);document.documentElement.addEventListener(\"click\",function(b){var a;a:{for(a=b.target;a&&a!==document.documentElement;a=a.parentElement)if(a.tagName===\"A\"){a=a.getAttribute(\"data-nohref\")===\"1\";break a}a=!1}a&&b.preventDefault()},!0);}).call(this);</script><style>#gbar,#guser{font-size:13px;padding-top:1px !important;}#gbar{height:22px}#guser{padding-bottom:7px !important;text-align:right}.gbh,.gbd{border-top:1px solid #c9d7f1;font-size:1px}.gbh{height:0;position:absolute;top:24px;width:100%}@media all{.gb1{height:22px;margin-right:.5em;vertical-align:top}#gbar{float:left}}a.gb1,a.gb4{text-decoration:underline !important}a.gb1,a.gb4{color:#00c !important}.gbi .gb4{color:#dd8e27 !important}.gbf .gb4{color:#900 !important}\\n</style><style>body,td,a,p,.h{font-family:arial,sans-serif}body{margin:0;overflow-y:scroll}#gog{padding:3px 8px 0}td{line-height:.8em}.gac_m td{line-height:17px}form{margin-bottom:20px}.h{color:#1967d2}em{font-weight:bold;font-style:normal}.lst{height:25px;width:496px}.gsfi,.lst{font:18px arial,sans-serif}.gsfs{font:17px arial,sans-serif}.ds{display:inline-box;display:inline-block;margin:3px 0 4px;margin-left:4px}input{font-family:inherit}body{background:#fff;color:#000}a{color:#681da8;text-decoration:none}a:hover,a:active{text-decoration:underline}.fl a{color:#1967d2}a:visited{color:#681da8}.sblc{padding-top:5px}.sblc a{display:block;margin:2px 0;margin-left:13px;font-size:11px}.lsbb{background:#f8f9fa;border:solid 1px;border-color:#dadce0 #70757a #70757a #dadce0;height:30px}.lsbb{display:block}#WqQANb a{display:inline-block;margin:0 12px}.lsb{background:url(/images/nav_logo229.png) 0 -261px repeat-x;color:#000;border:none;cursor:pointer;height:30px;margin:0;outline:0;font:15px arial,sans-serif;vertical-align:top}.lsb:active{background:#dadce0}.lst:focus{outline:none}</style><script nonce=\"MKTUJnkoxYDV8uwziXVryA\">(function(){window.google.erd={jsr:1,bv:2057,de:true};\\nvar g=this||self;var k,l=(k=g.mei)!=null?k:1,n,p=(n=g.sdo)!=null?n:!0,q=0,r,t=google.erd,v=t.jsr;google.ml=function(a,b,d,m,e){e=e===void 0?2:e;b&&(r=a&&a.message);d===void 0&&(d={});d.cad=\"ple_\"+google.ple+\".aple_\"+google.aple;if(google.dl)return google.dl(a,e,d,!0),null;b=d;if(v<0){window.console&&console.error(a,b);if(v===-2)throw a;b=!1}else b=!a||!a.message||a.message===\"Error loading script\"||q>=l&&!m?!1:!0;if(!b)return null;q++;d=d||{};b=encodeURIComponent;var c=\"/gen_204?atyp=i&ei=\"+b(google.kEI);google.kEXPI&&(c+=\"&jexpid=\"+b(google.kEXPI));c+=\"&srcpg=\"+b(google.sn)+\"&jsr=\"+b(t.jsr)+\\n\"&bver=\"+b(t.bv);t.dpf&&(c+=\"&dpf=\"+b(t.dpf));var f=a.lineNumber;f!==void 0&&(c+=\"&line=\"+f);var h=a.fileName;h&&(h.indexOf(\"-extension:/\")>0&&(e=3),c+=\"&script=\"+b(h),f&&h===window.location.href&&(f=document.documentElement.outerHTML.split(\"\\\\n\")[f],c+=\"&cad=\"+b(f?f.substring(0,300):\"No script found.\")));google.ple&&google.ple===1&&(e=2);c+=\"&jsel=\"+e;for(var u in d)c+=\"&\",c+=b(u),c+=\"=\",c+=b(d[u]);c=c+\"&emsg=\"+b(a.name+\": \"+a.message);c=c+\"&jsst=\"+b(a.stack||\"N/A\");c.length>=12288&&(c=c.substr(0,12288));a=c;m||google.log(0,\"\",a);return a};window.onerror=function(a,b,d,m,e){r!==a&&(a=e instanceof Error?e:Error(a),d===void 0||\"lineNumber\"in a||(a.lineNumber=d),b===void 0||\"fileName\"in a||(a.fileName=b),google.ml(a,!1,void 0,!1,a.name===\"SyntaxError\"||a.message.substring(0,11)===\"SyntaxError\"||a.message.indexOf(\"Script error\")!==-1?3:0));r=null;p&&q>=l&&(window.onerror=null)};})();</script></head><body bgcolor=\"#fff\"><script nonce=\"MKTUJnkoxYDV8uwziXVryA\">(function(){var src=\\'/images/nav_logo229.png\\';var iesg=false;document.body.onload = function(){window.n && window.n();if (document.images){new Image().src=src;}\\nif (!iesg){document.f&&document.f.q.focus();document.gbqf&&document.gbqf.q.focus();}\\n}\\n})();</script><div id=\"mngb\"><div id=gbar><nobr><b class=gb1>Search</b> <a class=gb1 href=\"https://www.google.com/imghp?hl=en&tab=wi\">Images</a> <a class=gb1 href=\"https://maps.google.com/maps?hl=en&tab=wl\">Maps</a> <a class=gb1 href=\"https://play.google.com/?hl=en&tab=w8\">Play</a> <a class=gb1 href=\"https://www.youtube.com/?tab=w1\">YouTube</a> <a class=gb1 href=\"https://news.google.com/?tab=wn\">News</a> <a class=gb1 href=\"https://mail.google.com/mail/?tab=wm\">Gmail</a> <a class=gb1 href=\"https://drive.google.com/?tab=wo\">Drive</a> <a class=gb1 style=\"text-decoration:none\" href=\"https://www.google.com.pk/intl/en/about/products?tab=wh\"><u>More</u> &raquo;</a></nobr></div><div id=guser width=100%><nobr><span id=gbn class=gbi></span><span id=gbf class=gbf></span><span id=gbe></span><a href=\"http://www.google.com.pk/history/optout?hl=en\" class=gb4>Web History</a> | <a  href=\"/preferences?hl=en\" class=gb4>Settings</a> | <a target=_top id=gb_70 href=\"https://accounts.google.com/ServiceLogin?hl=en&passive=true&continue=https://www.google.com/&ec=GAZAAQ\" class=gb4>Sign in</a></nobr></div><div class=gbh style=left:0></div><div class=gbh style=right:0></div></div><center><br clear=\"all\" id=\"lgpd\"><div id=\"XjhHGf\"><img alt=\"Google\" height=\"92\" src=\"/images/branding/googlelogo/1x/googlelogo_white_background_color_272x92dp.png\" style=\"padding:28px 0 14px\" width=\"272\" id=\"hplogo\"><br><br></div><form action=\"/search\" name=\"f\"><table cellpadding=\"0\" cellspacing=\"0\"><tr valign=\"top\"><td width=\"25%\">&nbsp;</td><td align=\"center\" nowrap=\"\"><input name=\"ie\" value=\"ISO-8859-1\" type=\"hidden\"><input value=\"en-PK\" name=\"hl\" type=\"hidden\"><input name=\"source\" type=\"hidden\" value=\"hp\"><input name=\"biw\" type=\"hidden\"><input name=\"bih\" type=\"hidden\"><div class=\"ds\" style=\"height:32px;margin:4px 0\"><input class=\"lst\" style=\"margin:0;padding:5px 8px 0 6px;vertical-align:top;color:#000\" autocomplete=\"off\" value=\"\" title=\"Google Search\" maxlength=\"2048\" name=\"q\" size=\"57\"></div><br style=\"line-height:0\"><span class=\"ds\"><span class=\"lsbb\"><input class=\"lsb\" value=\"Google Search\" name=\"btnG\" type=\"submit\"></span></span><span class=\"ds\"><span class=\"lsbb\"><input class=\"lsb\" id=\"tsuid_1\" value=\"I\\'m Feeling Lucky\" name=\"btnI\" type=\"submit\"><script nonce=\"MKTUJnkoxYDV8uwziXVryA\">(function(){var id=\\'tsuid_1\\';document.getElementById(id).onclick = function(){if (this.form.q.value){this.checked = 1;if (this.form.iflsig)this.form.iflsig.disabled = false;}\\nelse top.location=\\'/doodles/\\';};})();</script><input value=\"AL9hbdgAAAAAZrOiIcMoqvDpTYGwTgaXvz995Bnaxr2h\" name=\"iflsig\" type=\"hidden\"></span></span></td><td class=\"fl sblc\" align=\"left\" nowrap=\"\" width=\"25%\"><a href=\"/advanced_search?hl=en-PK&amp;authuser=0\">Advanced search</a></td></tr></table><input id=\"gbv\" name=\"gbv\" type=\"hidden\" value=\"1\"><script nonce=\"MKTUJnkoxYDV8uwziXVryA\">(function(){var a,b=\"1\";if(document&&document.getElementById)if(typeof XMLHttpRequest!=\"undefined\")b=\"2\";else if(typeof ActiveXObject!=\"undefined\"){var c,d,e=[\"MSXML2.XMLHTTP.6.0\",\"MSXML2.XMLHTTP.3.0\",\"MSXML2.XMLHTTP\",\"Microsoft.XMLHTTP\"];for(c=0;d=e[c++];)try{new ActiveXObject(d),b=\"2\"}catch(h){}}a=b;if(a==\"2\"&&location.search.indexOf(\"&gbv=2\")==-1){var f=google.gbvu,g=document.getElementById(\"gbv\");g&&(g.value=a);f&&window.setTimeout(function(){location.href=f},0)};}).call(this);</script></form><div style=\"font-size:83%;min-height:3.5em\"><br><div id=\"gws-output-pages-elements-homepage_additional_languages__als\"><style>#gws-output-pages-elements-homepage_additional_languages__als{font-size:small;margin-bottom:24px}#SIvCob{color:#474747;display:inline-block;line-height:28px;}#SIvCob a{padding:0 3px;}.H6sW5{display:inline-block;margin:0 2px;white-space:nowrap}.z4hgWe{display:inline-block;margin:0 2px}</style><div id=\"SIvCob\">Google offered in:  <a dir=\"rtl\" href=\"https://www.google.com/setprefs?sig=0_TesOWgP9KY9FLNrh6kzSekBidgg%3D&amp;hl=ur&amp;source=homepage&amp;sa=X&amp;ved=0ahUKEwihqsOwmuOHAxWV1zQHHW7AHgAQ2ZgBCAY\">&#1575;&#1585;&#1583;&#1608;</a>    <a dir=\"rtl\" href=\"https://www.google.com/setprefs?sig=0_TesOWgP9KY9FLNrh6kzSekBidgg%3D&amp;hl=ps&amp;source=homepage&amp;sa=X&amp;ved=0ahUKEwihqsOwmuOHAxWV1zQHHW7AHgAQ2ZgBCAc\">&#1662;&#1690;&#1578;&#1608;</a>    <a dir=\"rtl\" href=\"https://www.google.com/setprefs?sig=0_TesOWgP9KY9FLNrh6kzSekBidgg%3D&amp;hl=sd&amp;source=homepage&amp;sa=X&amp;ved=0ahUKEwihqsOwmuOHAxWV1zQHHW7AHgAQ2ZgBCAg\">&#1587;&#1606;&#1676;&#1610;</a>  </div></div></div><span id=\"footer\"><div style=\"font-size:10pt\"><div style=\"margin:19px auto;text-align:center\" id=\"WqQANb\"><a href=\"/intl/en/ads/\">Advertising</a><a href=\"/intl/en/about.html\">About Google</a><a href=\"https://www.google.com/setprefdomain?prefdom=PK&amp;prev=https://www.google.com.pk/&amp;sig=K_MCVATlNjrxVzRmdVtSPjq0cE0Is%3D\">Google.com.pk</a></div></div><p style=\"font-size:8pt;color:#70757a\">&copy; 2024 - <a href=\"/intl/en/policies/privacy/\">Privacy</a> - <a href=\"/intl/en/policies/terms/\">Terms</a></p></span></center><script nonce=\"MKTUJnkoxYDV8uwziXVryA\">(function(){window.google.cdo={height:757,width:1440};(function(){var a=window.innerWidth,b=window.innerHeight;if(!a||!b){var c=window.document,d=c.compatMode==\"CSS1Compat\"?c.documentElement:c.body;a=d.clientWidth;b=d.clientHeight}\\nif(a&&b&&(a!=google.cdo.width||b!=google.cdo.height)){var e=google,f=e.log,g=\"/client_204?&atyp=i&biw=\"+a+\"&bih=\"+b+\"&ei=\"+google.kEI,h=\"\",k=[],l=window.google!==void 0&&window.google.kOPI!==void 0&&window.google.kOPI!==0?window.google.kOPI:null;l!=null&&k.push([\"opi\",l.toString()]);for(var m=0;m<k.length;m++){if(m===0||m>0)h+=\"&\";h+=k[m][0]+\"=\"+k[m][1]}f.call(e,\"\",\"\",g+h)};}).call(this);})();</script>  <script nonce=\"MKTUJnkoxYDV8uwziXVryA\">(function(){google.xjs={basecomb:\\'/xjs/_/js/k\\\\x3dxjs.hp.en.JFEDo3Lz0aM.O/ck\\\\x3dxjs.hp.DdUFV9urq18.L.X.O/am\\\\x3dAQAAAAEAAAAAAAAAAAAAAAAAAAAAgAgAAAAAAAAAgAEABwAAIAAgIAAAAAAAPAAAAAgAAACAEAAAA4AAAMCB-I4AQAAsAgDACw/d\\\\x3d1/ed\\\\x3d1/dg\\\\x3d0/ujg\\\\x3d1/rs\\\\x3dACT90oHoUmSfmR26q7p4rhAOE4wmWITzpg\\',basecss:\\'/xjs/_/ss/k\\\\x3dxjs.hp.DdUFV9urq18.L.X.O/am\\\\x3dAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAIAAgIAAAAAAAAAAAAAgAAACAEAAAA4A/rs\\\\x3dACT90oHyRkQIlt6dn94SN6LVvCdcXfHzuA\\',basejs:\\'/xjs/_/js/k\\\\x3dxjs.hp.en.JFEDo3Lz0aM.O/am\\\\x3dAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAgAEABwAAAAAAAAAAAAAAPAAAAAAAAAAAAAAAAAAAAMCB-I4AQAAsAgDACw/dg\\\\x3d0/rs\\\\x3dACT90oHt5yrON0GaXA_w5XCBB-7GHXO3Xg\\',excm:[]};})();</script>  <link href=\"/xjs/_/ss/k=xjs.hp.DdUFV9urq18.L.X.O/am=AQAAAAEAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAIAAgIAAAAAAAAAAAAAgAAACAEAAAA4A/d=1/ed=1/rs=ACT90oHyRkQIlt6dn94SN6LVvCdcXfHzuA/m=sb_he,d\" rel=\"stylesheet\" nonce=\"MKTUJnkoxYDV8uwziXVryA\">      <script nonce=\"MKTUJnkoxYDV8uwziXVryA\">(function(){var u=\\'/xjs/_/js/k\\\\x3dxjs.hp.en.JFEDo3Lz0aM.O/am\\\\x3dAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAgAEABwAAAAAAAAAAAAAAPAAAAAAAAAAAAAAAAAAAAMCB-I4AQAAsAgDACw/d\\\\x3d1/ed\\\\x3d1/dg\\\\x3d3/rs\\\\x3dACT90oHt5yrON0GaXA_w5XCBB-7GHXO3Xg/m\\\\x3dsb_he,d\\';var st=1;var amd=1000;var mmd=0;var pod=true;\\nvar f=this||self,g=function(a){return a};var h;var k=function(a){this.g=a};k.prototype.toString=function(){return this.g+\"\"};var l=function(a){return a instanceof k&&a.constructor===k?a.g:\"type_error:TrustedResourceUrl\"},m={};\\nvar n=/^\\\\s*(?!javascript:)(?:[\\\\w+.-]+:|[^:/?#]*(?:[/?#]|$))/i;var p=\"alternate author bookmark canonical cite help icon license modulepreload next prefetch dns-prefetch prerender preconnect preload prev search subresource\".split(\" \");function q(a,b){a.src=l(b);var c,d;(c=(b=(d=(c=(a.ownerDocument&&a.ownerDocument.defaultView||window).document).querySelector)==null?void 0:d.call(c,\"script[nonce]\"))?b.nonce||b.getAttribute(\"nonce\")||\"\":\"\")&&a.setAttribute(\"nonce\",c)};var r=function(a){var b=document;a=String(a);b.contentType===\"application/xhtml+xml\"&&(a=a.toLowerCase());return b.createElement(a)};function t(a){a=a===null?\"null\":a===void 0?\"undefined\":a;if(h===void 0){var b=null;var c=f.trustedTypes;if(c&&c.createPolicy){try{b=c.createPolicy(\"goog#html\",{createHTML:g,createScript:g,createScriptURL:g})}catch(d){f.console&&f.console.error(d.message)}h=b}else h=b}a=(b=h)?b.createScriptURL(a):a;return new k(a,m)};google.ps===void 0&&(google.ps=[]);function w(){var a=u,b=function(){};google.lx=google.stvsc?b:function(){x(a);google.lx=b};google.bx||google.lx()}function y(a,b){b&&q(a,t(b));var c=a.onload;a.onload=function(d){c&&c(d);google.ps=google.ps.filter(function(e){return a!==e})};google.ps.push(a);document.body.appendChild(a)}google.as=y;function x(a){google.timers&&google.timers.load&&google.tick&&google.tick(\"load\",\"xjsls\");var b=r(\"SCRIPT\");b.onerror=function(){google.ple=1};b.onload=function(){google.ple=0};google.xjsus=void 0;y(b,a);google.aple=-1;google.dp=!0}\\nfunction z(){var a=[u];if(!google.dp){for(var b=0;b<a.length;b++){var c=r(\"LINK\"),d=c,e=t(a[b]);if(e instanceof k)d.href=l(e).toString(),d.rel=\"preload\";else{if(p.indexOf(\"preload\")===-1)throw Error(\"a`preload\");e=n.test(e)?e:void 0;e!==void 0&&(d.href=e,d.rel=\"preload\")}c.setAttribute(\"as\",\"script\");document.body.appendChild(c)}google.dp=!0}};function A(a){var b=a.getAttribute(\"jscontroller\");return(b===\"UBXHI\"||b===\"R3fhkb\"||b===\"TSZEqd\")&&a.hasAttribute(\"data-src\")}function B(){for(var a=document.getElementsByTagName(\"img\"),b=0,c=a.length;b<c;b++){var d=a[b];if(d.hasAttribute(\"data-lzy_\")&&Number(d.getAttribute(\"data-atf\"))&1&&!A(d))return!0}return!1}for(var C=document.getElementsByTagName(\"img\"),D=0,E=C.length;D<E;++D){var F=C[D];Number(F.getAttribute(\"data-atf\"))&1&&A(F)&&(F.src=F.getAttribute(\"data-src\"))};var G,H,I,J,K;function L(){google.xjsu=u;f._F_jsUrl=u;J=function(){w()};G=!1;H=(st===1||st===3)&&!!google.caft&&!B();I=(st===2||st===3)&&!!google.rairicb&&!B();K=pod}function M(){G||H||I||(J(),G=!0)}setTimeout(function(){google&&google.tick&&google.timers&&google.timers.load&&google.tick(\"load\",\"xjspls\");L();if(H||I){if(H){var a=function(){H=!1;M()};google.caft(a);window.setTimeout(a,amd)}I&&(a=function(){I=!1;M()},(0,google.rairicb)(a),window.setTimeout(a,mmd));K&&(G||z())}else J()},0);})();window._ = window._ || {};window._DumpException = _._DumpException = function(e){throw e;};window._s = window._s || {};_s._DumpException = _._DumpException;window._qs = window._qs || {};_qs._DumpException = _._DumpException;(function(){var t=[1,4,0,0,0,574619648,0,5308416,117539216,8389136,131584,294912,60,32,67584,2629824,948027392,16777787,8898,752];window._F_toggles = window._xjs_toggles = t;})();window._F_installCss = window._F_installCss || function(css){};(function(){google.jl={bfl:0,dw:false,ine:false,ubm:false,uwp:true,vs:false};})();(function(){var pmc=\\'{\\\\x22d\\\\x22:{},\\\\x22sb_he\\\\x22:{\\\\x22agen\\\\x22:false,\\\\x22cgen\\\\x22:false,\\\\x22client\\\\x22:\\\\x22heirloom-hp\\\\x22,\\\\x22dh\\\\x22:true,\\\\x22ds\\\\x22:\\\\x22\\\\x22,\\\\x22fl\\\\x22:true,\\\\x22host\\\\x22:\\\\x22google.com\\\\x22,\\\\x22jsonp\\\\x22:true,\\\\x22msgs\\\\x22:{\\\\x22cibl\\\\x22:\\\\x22Clear Search\\\\x22,\\\\x22dym\\\\x22:\\\\x22Did you mean:\\\\x22,\\\\x22lcky\\\\x22:\\\\x22I\\\\\\\\u0026#39;m Feeling Lucky\\\\x22,\\\\x22lml\\\\x22:\\\\x22Learn more\\\\x22,\\\\x22psrc\\\\x22:\\\\x22This search was removed from your \\\\\\\\u003Ca href\\\\x3d\\\\\\\\\\\\x22/history\\\\\\\\\\\\x22\\\\\\\\u003EWeb History\\\\\\\\u003C/a\\\\\\\\u003E\\\\x22,\\\\x22psrl\\\\x22:\\\\x22Remove\\\\x22,\\\\x22sbit\\\\x22:\\\\x22Search by image\\\\x22,\\\\x22srch\\\\x22:\\\\x22Google Search\\\\x22},\\\\x22ovr\\\\x22:{},\\\\x22pq\\\\x22:\\\\x22\\\\x22,\\\\x22rfs\\\\x22:[],\\\\x22stok\\\\x22:\\\\x22pp-kQgaqXExbhn29RrSXcj3TTRs\\\\x22}}\\';google.pmc=JSON.parse(pmc);})();(function(){var b=function(a){var c=0;return function(){return c<a.length?{done:!1,value:a[c++]}:{done:!0}}};\\nvar e=this||self;var g,h;a:{for(var k=[\"CLOSURE_FLAGS\"],l=e,n=0;n<k.length;n++)if(l=l[k[n]],l==null){h=null;break a}h=l}var p=h&&h[610401301];g=p!=null?p:!1;var q,r=e.navigator;q=r?r.userAgentData||null:null;function t(a){return g?q?q.brands.some(function(c){return(c=c.brand)&&c.indexOf(a)!=-1}):!1:!1}function u(a){var c;a:{if(c=e.navigator)if(c=c.userAgent)break a;c=\"\"}return c.indexOf(a)!=-1};function v(){return g?!!q&&q.brands.length>0:!1}function w(){return u(\"Safari\")&&!(x()||(v()?0:u(\"Coast\"))||(v()?0:u(\"Opera\"))||(v()?0:u(\"Edge\"))||(v()?t(\"Microsoft Edge\"):u(\"Edg/\"))||(v()?t(\"Opera\"):u(\"OPR\"))||u(\"Firefox\")||u(\"FxiOS\")||u(\"Silk\")||u(\"Android\"))}function x(){return v()?t(\"Chromium\"):(u(\"Chrome\")||u(\"CriOS\"))&&!(v()?0:u(\"Edge\"))||u(\"Silk\")}function y(){return u(\"Android\")&&!(x()||u(\"Firefox\")||u(\"FxiOS\")||(v()?0:u(\"Opera\"))||u(\"Silk\"))};var z=v()?!1:u(\"Trident\")||u(\"MSIE\");y();x();w();var A=!z&&!w(),D=function(a){if(/-[a-z]/.test(\"ved\"))return null;if(A&&a.dataset){if(y()&&!(\"ved\"in a.dataset))return null;a=a.dataset.ved;return a===void 0?null:a}return a.getAttribute(\"data-\"+\"ved\".replace(/([A-Z])/g,\"-$1\").toLowerCase())};var E=[],F=null;function G(a){a=a.target;var c=performance.now(),f=[],H=f.concat,d=E;if(!(d instanceof Array)){var m=typeof Symbol!=\"undefined\"&&Symbol.iterator&&d[Symbol.iterator];if(m)d=m.call(d);else if(typeof d.length==\"number\")d={next:b(d)};else throw Error(\"b`\"+String(d));for(var B=[];!(m=d.next()).done;)B.push(m.value);d=B}E=H.call(f,d,[c]);if(a&&a instanceof HTMLElement)if(a===F){if(c=E.length>=4)c=(E[E.length-1]-E[E.length-4])/1E3<5;if(c){c=google.getEI(a);a.hasAttribute(\"data-ved\")?f=a?D(a)||\"\":\"\":f=(f=\\na.closest(\"[data-ved]\"))?D(f)||\"\":\"\";f=f||\"\";if(a.hasAttribute(\"jsname\"))a=a.getAttribute(\"jsname\");else{var C;a=(C=a.closest(\"[jsname]\"))==null?void 0:C.getAttribute(\"jsname\")}google.log(\"rcm\",\"&ei=\"+c+\"&tgtved=\"+f+\"&jsname=\"+(a||\"\"))}}else F=a,E=[c]}window.document.addEventListener(\"DOMContentLoaded\",function(){document.body.addEventListener(\"click\",G)});}).call(this);</script></body></html>'\n"
     ]
    }
   ],
   "source": [
    "import urllib\n",
    "try:\n",
    "    link = \"https://google.com/\"\n",
    "    request_url = urllib.request.urlopen(link)\n",
    "    print(type(request_url))\n",
    "    print(request_url.read())\n",
    "except Exception as e:\n",
    "    print(str(e))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "99f26742",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "da95afdf",
   "metadata": {},
   "source": [
    "### With Wrong URL"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "78781da7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<urlopen error [Errno 8] nodename nor servname provided, or not known>\n"
     ]
    }
   ],
   "source": [
    "import urllib\n",
    "try:\n",
    "    link = \"https://google1.com/\"\n",
    "    request_url = urllib.request.urlopen(link)\n",
    "    print(type(request_url))\n",
    "    print(request_url.status)\n",
    "    print(request_url.read())\n",
    "except Exception as e:\n",
    "    print(str(e))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ae569385",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6a9d335f",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "da51eeb9",
   "metadata": {},
   "source": [
    "## Create a GitHub Gist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "c9c12e2a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "https://raw.githubusercontent.com/ehtisham-sadiq/P0Q6R9S2-MLZone/main/Module%2002%20-%20Introduction%20to%20Python%20Programming/datasets/student.csv\n"
     ]
    }
   ],
   "source": [
    "url = \"https://raw.githubusercontent.com/ehtisham-sadiq/P0Q6R9S2-MLZone/main/Module%2002%20-%20Introduction%20to%20Python%20Programming/datasets/student.csv\"\n",
    "print(url)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "054ea853",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('myfile.csv', <http.client.HTTPMessage object at 0x111f21650>)\n"
     ]
    }
   ],
   "source": [
    "import urllib\n",
    "try:\n",
    "    dataset = urllib.request.urlretrieve(url,\"myfile.csv\")\n",
    "    print(dataset)\n",
    "except:\n",
    "    print(\"Invalid URL!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "f5b69d1d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fred,23,34,56\n",
      "Joe,99,45,56\n",
      "Jane,65,34,57\n",
      "Gigi,77,99,12\n",
      "Karla,76,84,45"
     ]
    }
   ],
   "source": [
    "!cat myfile.csv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f282a39a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7771c3b9",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "025b1001",
   "metadata": {},
   "source": [
    "### With Wrong Path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "4e18fbd1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Invalid URL!\n"
     ]
    }
   ],
   "source": [
    "url = \"https://raw.githubusercontent.com/ehtisham-sadiq/P0Q6R9S2-MLZone/main/Module%2002%20-%20Int1roduction%20to%20Python%20Programming/datasets/student.csv\"\n",
    "import urllib\n",
    "try:\n",
    "    dataset = urllib.request.urlretrieve(url,\"students.csv\")\n",
    "    print(dataset)\n",
    "except:\n",
    "    print(\"Invalid URL!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "834758db",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "c040707d",
   "metadata": {},
   "source": [
    ">**The `urllib.request.urlopen()`, may return a URLError saying `SSL: CERTIFICATE_VERIFY_FAILED`. To handle this error set  the `_create_default_https_context` attribute of `ssl` to `_create_unverified_context`**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "29a5f041",
   "metadata": {},
   "outputs": [],
   "source": [
    "import ssl\n",
    "ssl._create_default_https_context = ssl._create_unverified_context"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6eea4c4f",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "38075fc1",
   "metadata": {},
   "source": [
    "### b. The   `urllib.request.urlretrieve()` Function\n",
    "- The `urllib.request.urlretrieve(url, filename=None)` method is used to retrieve a remote file into a temporary location on disk.\n",
    "- Let us download a public csv file from github gist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "89333523",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "os.getcwd()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8897314d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "2c6a656d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'https://raw.githubusercontent.com/ehtisham-sadiq/P0Q6R9S2-MLZone/main/Module%2002%20-%20Introduction%20to%20Python%20Programming/datasets/names_addresses.txt'"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Link = \"https://raw.githubusercontent.com/ehtisham-sadiq/P0Q6R9S2-MLZone/main/Module%2002%20-%20Introduction%20to%20Python%20Programming/datasets/names_addresses.txt\"\n",
    "Link"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "52d9c88b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('details.txt', <http.client.HTTPMessage at 0x111fc8310>)"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import urllib\n",
    "dataset = urllib.request.urlretrieve(Link, 'details.txt')\n",
    "dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "b763f593",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Assignments',\n",
       " '.DS_Store',\n",
       " 'images',\n",
       " 'myfile.csv',\n",
       " 'details.txt',\n",
       " 'README.md',\n",
       " 'Day2.ipynb',\n",
       " '.gitignore',\n",
       " 'Day7',\n",
       " 'Day6.ipynb',\n",
       " 'Day4.ipynb',\n",
       " 'Files',\n",
       " '.ipynb_checkpoints',\n",
       " 'Day3.ipynb',\n",
       " '.git',\n",
       " 'Machine-Learning',\n",
       " 'Day1.ipynb',\n",
       " 'Day5.ipynb',\n",
       " 'Syllabus.pdf']"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "os.listdir()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "2aadea15",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mr. Ehtisham Sadiq\n",
      "615-555-7164\n",
      "131 Model Town, Lahore\n",
      "02-01-2001\n",
      "ehtishampucit@gmail.com\n",
      "http://www.ehtisham.me\n",
      "\n",
      "\n",
      "Mrs. Azka Noreen\n",
      "317.615.9124\n",
      "33 Garden Town, Lahore\n",
      "20/02/2000\n",
      "azka-123@gmail.com\n",
      "http://azka.pu.edu.pk\n",
      "\n",
      "\n",
      "\n",
      "Mr. Ahmed Shahzad\n",
      "321#521#9254\n",
      "69, A Wapda Town, Lahore\n",
      "12.09.2000\n",
      "Ahmed3@yahoo.com\n",
      "https://www.Ahmed.pu.edu.pk\n",
      "\n",
      "\n",
      "Ms Aqsa\n",
      "123.555.1997\n",
      "56 Joher Town, Lahore\n",
      "12/08/2001\n",
      "aqsa_007@gmail.com\n",
      "http://youtube.com\n",
      "\n",
      "Mr. B\n",
      "321-555-4321\n",
      "19 Township, Lahore\n",
      "05-07-2002\n",
      "mrB@yahoo.com\n",
      "http://facebook.com"
     ]
    }
   ],
   "source": [
    "!cat details.txt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4c8d322e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "87491b77",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6ae7b87f",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "unauthorized-vegetarian",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e305f27f",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "aa105473",
   "metadata": {},
   "source": [
    "## Check your Concepts\n",
    "\n",
    "Try answering the following questions to test your understanding of the topics covered in this notebook:\n",
    "\n",
    "1. What are modules in Python?\n",
    "2. What is a Python library?\n",
    "3. What is the Python Standard Library?\n",
    "4. What are some popular Python libraries?\n",
    "5. Where can you learn about the modules and functions available in the Python standard library?\n",
    "6. How do you install a third-party library?\n",
    "7. What is a module namespace? How is it useful?\n",
    "8. What problems would you run into if Python modules did not provide namespaces?\n",
    "9. How do you import a module?\n",
    "10. How do you use a function from an imported module? Illustrate with an example.\n",
    "11. What are some popular Python libraries?\n",
    "12. What is the purpose of the `os` module in Python?\n",
    "13. How do you identify the current working directory in a Jupyter notebook?\n",
    "14. How do you retrieve the list of files within a directory using Python?\n",
    "15. How do you create a directory using Python?\n",
    "16. How do you check whether a file or directory exists on the filesystem? Hint: `os.path.exists`.\n",
    "17. Where can you find the full list of functions contained in the `os` module?\n",
    "18. Give examples of 5 useful functions from the `os` and `os.path` modules.\n",
    "19. What are some popular Python libraries?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "81333f37",
   "metadata": {},
   "source": [
    "#### What is a Python library?\n",
    "- A Python library is a collection of related modules. \n",
    "- It contains bundles of code that can be used repeatedly in different programs. \n",
    "- It makes Python Programming simpler and convenient for the programmer. As we don’t need to write the same code again and again for different programs. \n",
    "- Python libraries play a very vital role in fields of Machine Learning, Data Science, Data Visualization, etc."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff9f2d1b",
   "metadata": {},
   "source": [
    "### What is Python Standard Library?\n",
    "- The Python Standard Library is a collection of script modules accessible to a Python program to simplify the programming process and removing the need to rewrite commonly used commands. \n",
    "- They can be used by 'calling/importing' them at the beginning of a script."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fed6dc79",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b195ab72",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c7e7860f",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8b7b7cd8",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "725bed49",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cde80539",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7603a75e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "109c3cdc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "    <style>\n",
       "        body {\n",
       "            background-color: #f2fff2;\n",
       "        }\n",
       "        h1 {\n",
       "            text-align: center;\n",
       "            font-weight: bold;\n",
       "            font-size: 36px;\n",
       "            color: #4295F4;\n",
       "            text-decoration: underline;\n",
       "            padding-top: 15px;\n",
       "        }\n",
       "        \n",
       "        h2 {\n",
       "            text-align: left;\n",
       "            font-weight: bold;\n",
       "            font-size: 30px;\n",
       "            color: #4A000A;\n",
       "            text-decoration: underline;\n",
       "            padding-top: 10px;\n",
       "        }\n",
       "        \n",
       "        h3 {\n",
       "            text-align: left;\n",
       "            font-weight: bold;\n",
       "            font-size: 30px;\n",
       "            color: #f0081e;\n",
       "            text-decoration: underline;\n",
       "            padding-top: 5px;\n",
       "        }\n",
       "\n",
       "        \n",
       "        p {\n",
       "            text-align: center;\n",
       "            font-size: 12 px;\n",
       "            color: #0B9923;\n",
       "        }\n",
       "    </style>\n",
       "\n",
       "<h1>Hello</h1>\n",
       "<p>Hello World</p>\n",
       "<h2> Hello</h2>\n",
       "<h3> World </h3>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.core.display import HTML\n",
    "\n",
    "style = \"\"\"\n",
    "    <style>\n",
    "        body {\n",
    "            background-color: #f2fff2;\n",
    "        }\n",
    "        h1 {\n",
    "            text-align: center;\n",
    "            font-weight: bold;\n",
    "            font-size: 36px;\n",
    "            color: #4295F4;\n",
    "            text-decoration: underline;\n",
    "            padding-top: 15px;\n",
    "        }\n",
    "        \n",
    "        h2 {\n",
    "            text-align: left;\n",
    "            font-weight: bold;\n",
    "            font-size: 30px;\n",
    "            color: #4A000A;\n",
    "            text-decoration: underline;\n",
    "            padding-top: 10px;\n",
    "        }\n",
    "        \n",
    "        h3 {\n",
    "            text-align: left;\n",
    "            font-weight: bold;\n",
    "            font-size: 30px;\n",
    "            color: #f0081e;\n",
    "            text-decoration: underline;\n",
    "            padding-top: 5px;\n",
    "        }\n",
    "\n",
    "        \n",
    "        p {\n",
    "            text-align: center;\n",
    "            font-size: 12 px;\n",
    "            color: #0B9923;\n",
    "        }\n",
    "    </style>\n",
    "\"\"\"\n",
    "\n",
    "html_content = \"\"\"\n",
    "<h1>Hello</h1>\n",
    "<p>Hello World</p>\n",
    "<h2> Hello</h2>\n",
    "<h3> World </h3>\n",
    "\"\"\"\n",
    "\n",
    "HTML(style + html_content)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4d9456ce-2d4a-43b4-8519-c6ff1f4b6bcd",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}