{ "nbformat": 4, "nbformat_minor": 0, "metadata": { "colab": { "provenance": [], "authorship_tag": "ABX9TyMb0Fj112CKhs3nPXUvhwsY", "include_colab_link": true }, "kernelspec": { "name": "python3", "display_name": "Python 3" }, "language_info": { "name": "python" } }, "cells": [ { "cell_type": "markdown", "metadata": { "id": "view-in-github", "colab_type": "text" }, "source": [ "\"Open" ] }, { "cell_type": "markdown", "source": [ "# **Python modules**\n", "\n", " are files containing Python definitions and statements (variables, functions, classes, and runnable code) that are grouped together to provide reusable functionality. Any .py file is a module; packages are collections of modules organized in directories with an init.py (or implicit namespace packages). Modules promote code reuse, encapsulation, namespace separation, and easier testing.\n", "\n", "How modules are used\n", "\n", "Importing:\n", "import module — imports the module as a namespace (use module.name).\n", "from module import name — imports specific names into the local namespace.\n", "from module import * — imports all public names (generally discouraged).\n", "import module as alias — imports with a shorter alias.\n" ], "metadata": { "id": "Kzd7Ic2vfUv3" } }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "I0Q23N2ce7fn", "colab": { "base_uri": "https://localhost:8080/" }, "outputId": "8b28b6f2-6c67-42ad-c54c-249829d7b33e" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "200\n", "https://www.google.com/\n", "\n", "deque(['name', 'age', 'DOB'])\n", "After extend([50, 60, 70]): deque([5, 10, 20, 30, 40, 50, 60, 70])\n", "After extendleft([0, 5]): deque([5, 0, 5, 10, 20, 30, 40, 50, 60, 70])\n", "After remove(20): deque([5, 0, 5, 10, 30, 40, 50, 60, 70])\n", "After pop and popleft: deque([0, 5, 10, 30, 40, 50, 60])\n", "After clear(): deque([])\n", "1\n", "4\n", "7\n", "3\n", "2\n", "deque([30, 20, 10, 20, 30, 40, 50, 20])\n", "deque([20, 30, 40, 50, 20, 30, 20, 10])\n", "deque([10, 20, 30, 20, 50, 40, 30, 20])\n", "4.0\n", "3.141592653589793\n", "5.0\n", "3.141592653589793\n", "3.0\n", "7.0\n", "120\n", "-1.0\n", "69\n", "banana\n", "/content\n", "['.config', 'sample_data']\n", "2025-11-05 06:11:27.086616\n", "3.12.12 (main, Oct 10 2025, 08:52:57) [GCC 11.4.0]\n", "['/content', '/env/python', '/usr/lib/python312.zip', '/usr/lib/python3.12', '/usr/lib/python3.12/lib-dynload', '', '/usr/local/lib/python3.12/dist-packages', '/usr/lib/python3/dist-packages', '/usr/local/lib/python3.12/dist-packages/IPython/extensions', '/root/.ipython']\n", "[{'id': 1, 'name': 'Leanne Graham', 'username': 'Bret', 'email': 'Sincere@april.biz', 'address': {'street': 'Kulas Light', 'suite': 'Apt. 556', 'city': 'Gwenborough', 'zipcode': '92998-3874', 'geo': {'lat': '-37.3159', 'lng': '81.1496'}}, 'phone': '1-770-736-8031 x56442', 'website': 'hildegard.org', 'company': {'name': 'Romaguera-Crona', 'catchPhrase': 'Multi-layered client-server neural-net', 'bs': 'harness real-time e-markets'}}, {'id': 2, 'name': 'Ervin Howell', 'username': 'Antonette', 'email': 'Shanna@melissa.tv', 'address': {'street': 'Victor Plains', 'suite': 'Suite 879', 'city': 'Wisokyburgh', 'zipcode': '90566-7771', 'geo': {'lat': '-43.9509', 'lng': '-34.4618'}}, 'phone': '010-692-6593 x09125', 'website': 'anastasia.net', 'company': {'name': 'Deckow-Crist', 'catchPhrase': 'Proactive didactic contingency', 'bs': 'synergize scalable supply-chains'}}, {'id': 3, 'name': 'Clementine Bauch', 'username': 'Samantha', 'email': 'Nathan@yesenia.net', 'address': {'street': 'Douglas Extension', 'suite': 'Suite 847', 'city': 'McKenziehaven', 'zipcode': '59590-4157', 'geo': {'lat': '-68.6102', 'lng': '-47.0653'}}, 'phone': '1-463-123-4447', 'website': 'ramiro.info', 'company': {'name': 'Romaguera-Jacobson', 'catchPhrase': 'Face to face bifurcated interface', 'bs': 'e-enable strategic applications'}}, {'id': 4, 'name': 'Patricia Lebsack', 'username': 'Karianne', 'email': 'Julianne.OConner@kory.org', 'address': {'street': 'Hoeger Mall', 'suite': 'Apt. 692', 'city': 'South Elvis', 'zipcode': '53919-4257', 'geo': {'lat': '29.4572', 'lng': '-164.2990'}}, 'phone': '493-170-9623 x156', 'website': 'kale.biz', 'company': {'name': 'Robel-Corkery', 'catchPhrase': 'Multi-tiered zero tolerance productivity', 'bs': 'transition cutting-edge web services'}}, {'id': 5, 'name': 'Chelsey Dietrich', 'username': 'Kamren', 'email': 'Lucio_Hettinger@annie.ca', 'address': {'street': 'Skiles Walks', 'suite': 'Suite 351', 'city': 'Roscoeview', 'zipcode': '33263', 'geo': {'lat': '-31.8129', 'lng': '62.5342'}}, 'phone': '(254)954-1289', 'website': 'demarco.info', 'company': {'name': 'Keebler LLC', 'catchPhrase': 'User-centric fault-tolerant solution', 'bs': 'revolutionize end-to-end systems'}}, {'id': 6, 'name': 'Mrs. Dennis Schulist', 'username': 'Leopoldo_Corkery', 'email': 'Karley_Dach@jasper.info', 'address': {'street': 'Norberto Crossing', 'suite': 'Apt. 950', 'city': 'South Christy', 'zipcode': '23505-1337', 'geo': {'lat': '-71.4197', 'lng': '71.7478'}}, 'phone': '1-477-935-8478 x6430', 'website': 'ola.org', 'company': {'name': 'Considine-Lockman', 'catchPhrase': 'Synchronised bottom-line interface', 'bs': 'e-enable innovative applications'}}, {'id': 7, 'name': 'Kurtis Weissnat', 'username': 'Elwyn.Skiles', 'email': 'Telly.Hoeger@billy.biz', 'address': {'street': 'Rex Trail', 'suite': 'Suite 280', 'city': 'Howemouth', 'zipcode': '58804-1099', 'geo': {'lat': '24.8918', 'lng': '21.8984'}}, 'phone': '210.067.6132', 'website': 'elvis.io', 'company': {'name': 'Johns Group', 'catchPhrase': 'Configurable multimedia task-force', 'bs': 'generate enterprise e-tailers'}}, {'id': 8, 'name': 'Nicholas Runolfsdottir V', 'username': 'Maxime_Nienow', 'email': 'Sherwood@rosamond.me', 'address': {'street': 'Ellsworth Summit', 'suite': 'Suite 729', 'city': 'Aliyaview', 'zipcode': '45169', 'geo': {'lat': '-14.3990', 'lng': '-120.7677'}}, 'phone': '586.493.6943 x140', 'website': 'jacynthe.com', 'company': {'name': 'Abernathy Group', 'catchPhrase': 'Implemented secondary concept', 'bs': 'e-enable extensible e-tailers'}}, {'id': 9, 'name': 'Glenna Reichert', 'username': 'Delphine', 'email': 'Chaim_McDermott@dana.io', 'address': {'street': 'Dayna Park', 'suite': 'Suite 449', 'city': 'Bartholomebury', 'zipcode': '76495-3109', 'geo': {'lat': '24.6463', 'lng': '-168.8889'}}, 'phone': '(775)976-6794 x41206', 'website': 'conrad.com', 'company': {'name': 'Yost and Sons', 'catchPhrase': 'Switchable contextually-based project', 'bs': 'aggregate real-time technologies'}}, {'id': 10, 'name': 'Clementina DuBuque', 'username': 'Moriah.Stanton', 'email': 'Rey.Padberg@karina.biz', 'address': {'street': 'Kattie Turnpike', 'suite': 'Suite 198', 'city': 'Lebsackbury', 'zipcode': '31428-2261', 'geo': {'lat': '-38.2386', 'lng': '57.2232'}}, 'phone': '024-648-3804', 'website': 'ambrose.net', 'company': {'name': 'Hoeger LLC', 'catchPhrase': 'Centralized empowering task-force', 'bs': 'target end-to-end models'}}]\n", "\n" ] } ], "source": [ "# importing random module\n", "import random\n", "\n", "# generating random number\n", "random_number = random.randint(1, 100)\n", "\n", "# initializing no. of guess to 0\n", "guess_count = 0\n", "'''\n", "# running loop until user guess the random number\n", "while True:\n", " # getting user input\n", "\n", " user_guessed_number = int(input(\"Enter a number in the range of 1-100:- \"))\n", "\n", " # checking for the equality\n", " if user_guessed_number == random_number:\n", " print(f\"You have guessed the number in {guess_count} guesses\")\n", " # breaking the loop\n", " break\n", " elif user_guessed_number < random_number:\n", " print(\"Your number is low\")\n", " elif user_guessed_number > random_number:\n", " print(\"Your number is high\")\n", "\n", " # incrementing the guess count\n", " guess_count += 1\n", "\n", "'''\n", "\n", "import requests\n", "\n", "# sening a get request\n", "request = requests.get(\"https://www.google.com/\")\n", "\n", "#\n", "print(request.status_code)\n", "print(request.url)\n", "print(request.request)\n", "\n", "## Scrping the ConsumerReport products list using BeautifulSoup\n", "\n", "## importing bs4, requests modules\n", "import bs4\n", "import requests\n", "\n", "## initializing url\n", "url = \"https://www.consumerreports.org/cro/a-to-z-index/products/index.htm\"\n", "\n", "## getting the reponse from the page using get method of requests module\n", "page = requests.get(url)\n", "\n", "## storing the content of the page in a variable\n", "html = page.content\n", "\n", "## creating BeautifulSoup object\n", "soup = bs4.BeautifulSoup(html, \"lxml\")\n", "\n", "## see the class or id of the tag which contains names ans links\n", "div_class = \"crux-body-copy\"\n", "\n", "## getting all the divs using find_all method\n", "div_tags = soup.find_all(\"div\", class_=div_class) ## finding divs whichs has mentioned class\n", "\n", "## we will see all the tags with a tags which has name and link inside the div\n", "for tag in div_tags:\n", " print(tag)\n", "\n", "\n", "from collections import deque\n", "\n", "# Declaring deque\n", "de = deque(['name','age','DOB'])\n", "\n", "print(de)\n", "\n", "from collections import deque\n", "\n", "dq = deque([10, 20, 30])\n", "\n", "# Add elements to the right\n", "dq.append(40)\n", "\n", "# Add elements to the left\n", "dq.appendleft(5)\n", "\n", "# extend(iterable)\n", "dq.extend([50, 60, 70])\n", "print(\"After extend([50, 60, 70]):\", dq)\n", "\n", "# extendleft(iterable)\n", "dq.extendleft([0, 5])\n", "print(\"After extendleft([0, 5]):\", dq)\n", "\n", "# remove method\n", "dq.remove(20)\n", "print(\"After remove(20):\", dq)\n", "\n", "# Remove elements from the right\n", "dq.pop()\n", "\n", "# Remove elements from the left\n", "dq.popleft()\n", "\n", "print(\"After pop and popleft:\", dq)\n", "\n", "# clear() - Removes all elements from the deque\n", "dq.clear() # deque: []\n", "print(\"After clear():\", dq)\n", "\n", "import collections\n", "\n", "dq = collections.deque([1, 2, 3, 3, 4, 2, 4])\n", "\n", "# Accessing elements by index\n", "print(dq[0])\n", "print(dq[-1])\n", "\n", "# Finding the length of the deque\n", "print(len(dq))\n", "\n", "from collections import deque\n", "\n", "# Create a deque\n", "dq = deque([10, 20, 30, 40, 50, 20, 30, 20])\n", "\n", "# 1. Counting occurrences of a value\n", "print(dq.count(20)) # Occurrences of 20\n", "print(dq.count(30)) # Occurrences of 30\n", "\n", "# 2. Rotating the deque\n", "dq.rotate(2) # Rotate the deque 2 steps to the right\n", "print(dq)\n", "\n", "dq.rotate(-3) # Rotate the deque 3 steps to the left\n", "print(dq)\n", "\n", "# 3. Reversing the deque\n", "dq.reverse() # Reverse the deque\n", "print(dq)\n", "\n", "import math\n", "\n", "print(math.sqrt(16)) # Outputs 4.0\n", "print(math.pi) # Outputs 3.141592653589793\n", "\n", "from math import sqrt, pi\n", "\n", "print(sqrt(25)) # Outputs 5.0\n", "print(pi) # Outputs 3.141592653589793\n", "\n", "import math as m\n", "\n", "print(m.sqrt(9)) # Outputs 3.0\n", "\n", "from math import *\n", "\n", "print(sqrt(49)) # Outputs 7.0\n", "\n", "import math\n", "\n", "print(math.factorial(5)) # Outputs 120\n", "print(math.cos(math.pi)) # Outputs -1.0\n", "\n", "import random\n", "\n", "print(random.randint(1, 100)) # Random number between 1 and 100\n", "print(random.choice(['apple', 'banana', 'cherry'])) # Random choice\n", "\n", "import os\n", "\n", "print(os.getcwd()) # Current working directory\n", "print(os.listdir(\".\")) # Files in the current directory\n", "\n", "from datetime import datetime\n", "\n", "current_time = datetime.now()\n", "print(current_time) # Outputs the current date and time\n", "\n", "import sys\n", "\n", "print(sys.version) # Python version\n", "print(sys.path) # Module search path\n", "\n", "import requests\n", "res = requests.get('https://jsonplaceholder.typicode.com/users')\n", "print(res.json())\n", "\n", "\n", "from modulefinder import ModuleFinder\n", "f = ModuleFinder()\n", "# Run the main script\n", "#f.run_script('run.py')\n", "# Get names of all the imported modules\n", "names = list(f.modules.keys())\n", "# Get a sorted list of the root modules imported\n", "basemods = sorted(set([name.split('.')[0] for name in names]))\n", "# Print it nicely\n", "print(\"/n\".join(basemods))\n", "\n" ] }, { "cell_type": "markdown", "source": [ "# **Module attributes:**\n", "name — module name (equals \"main\" when run as a script).\n", "\n", "file — path to the module file (when available).\n", "\n", "Packaging: use packages (directories) to structure larger projects; use relative imports within packages.\n", "\n", "Common built-in (standard library) modules and when to use them\n", "\n", "os — interacting with the operating system: file paths, environment variables, process management.\n", "\n", "sys — interpreter-level operations: argv, exit, stdin/stdout, module search path (sys.path).\n", "\n", "pathlib — object-oriented filesystem paths (recommended over os.path).\n", "\n", "io — core tools for text and binary I/O, file-like objects.\n", "glob — filename pattern matching (wildcards).\n", "\n", "shutil — high-level file operations: copy, move, archive, disk usage.\n", "\n", "logging — configurable logging framework for applications.\n", "\n", "argparse — command-line argument parsing for scripts." ], "metadata": { "id": "a6fQqRmxfVdW" } }, { "cell_type": "code", "source": [ "import math\n", "\n", "print(math.log2(2))\n", "print(math.sqrt(16))\n", "print(math.pow(2,4))\n", "\n", "from math import sqrt, exp, log2\n", "\n", "print(sqrt(4))\n", "print(exp(0))\n", "print(log2(2))\n", "\n", "from math import *\n", "\n", "print(sqrt(4))\n", "print(pow(2, 2))\n", "print(log2(2))\n", "\n", "import numpy as np\n", "print(np.log2(2))\n", "\n", "from random import randint as rt\n", "print(rt(1, 10)) # Generates a random number between 1 and 10\n", "\n", "import os\n", "print(os.environ['PYTHONPATH'].split(os.pathsep))\n", "\n", "def greet(name=\"\"):\n", " print(f\"Hello! Nice to meet you {name}\")\n", "\n", "if __name__ == \"__main__\":\n", " greet()\n", "\n", "from importlib import reload\n", "\n", "\n", "import math\n", "\n", "print(math.__doc__)\n", "'''\n", "import Geography as geo\n", "\n", "geo.getCountry()\n", "geo.getState()\n", "\n", "import utils\n", "\n", "print(utils.greet(\"LabEx\"))\n", "print(utils.calculate_area(5))\n", "'''\n", "\n", "import math\n", "import os\n", "\n", "print(type(math)) ## \n", "print(type(os)) ## \n", "\n", "import inspect\n", "\n", "def check_module_type(module):\n", " if inspect.ismodule(module):\n", " print(f\"Module: {module.__name__}\")\n", " print(f\"File: {module.__file__}\")\n", " else:\n", " print(\"Not a module\")\n", "\n", "import sys\n", "\n", "def detailed_module_analysis(module):\n", " print(\"Module Analysis:\")\n", " print(f\"Name: {module.__name__}\")\n", " print(f\"Type: {type(module)}\")\n", " print(f\"File Path: {getattr(module, '__file__', 'No file path')}\")\n", " print(f\"Built-in: {module.__name__ in sys.builtin_module_names}\")\n", "\n", "\n", "import math\n", "import sys\n", "#import custom_module ## Assume this is a user-defined module\n", "\n", "def classify_module(module):\n", " if module.__name__ in sys.builtin_module_names:\n", " return \"Built-in Module\"\n", " elif hasattr(module, '__file__'):\n", " if 'site-packages' in module.__file__:\n", " return \"Third-party Module\"\n", " else:\n", " return \"User-defined Module\"\n", " else:\n", " return \"Unknown Module Type\"\n", "\n", "## Example usage\n", "print(classify_module(math)) ## Built-in Module\n", "#print(classify_module(custom_module)) ## User-defined Module\n", "\n", "import math\n", "\n", "print(math.pi) ## Built-in mathematical constants\n", "print(math.sqrt(16)) ## Built-in mathematical functions\n", "\n", "\n", "import numpy as np\n", "import pandas as pd\n", "\n", "## NumPy array operations\n", "arr = np.array([1, 2, 3, 4])\n", "print(np.mean(arr))\n", "\n", "## Pandas DataFrame\n", "df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})\n", "print(df.describe())\n", "\n", "import ctypes\n", "\n", "## Loading a C extension module\n", "libc = ctypes.CDLL('libc.so.6')\n", "\n", "import inspect\n", "import sys\n", "\n", "def analyze_module_type(module):\n", " if module.__name__ in sys.builtin_module_names:\n", " return \"Built-in Module\"\n", " elif 'site-packages' in str(module.__file__):\n", " return \"Third-party Module\"\n", " elif module.__file__:\n", " return \"User-defined Module\"\n", " else:\n", " return \"Unknown Module Type\"\n", "\n", "## Example usage\n", "import math\n", "#import utils\n", "import numpy as np\n", "\n", "print(analyze_module_type(math)) ## Built-in Module\n", "#print(analyze_module_type(utils)) ## User-defined Module\n", "print(analyze_module_type(np)) ## Third-party Module\n", "'''\n", "import types\n", "\n", "def check(object):\n", " print(object)\n", "\n", " if type(object) is types.IntType:\n", " print(\"INTEGER\")\n", " if type(object) is types.FloatType:\n", " print(\"FLOAT\")\n", " if type(object) is types.StringType:\n", " print(\"STRING\")\n", " if type(object) is types.ClassType:\n", " print(\"CLASS\")\n", " if type(object) is types.InstanceType:\n", " print(\"INSTANCE\")\n", " print\n", "\n", "check(0)\n", "check(0.0)\n", "check(\"0\")\n", "\n", "class A:\n", " pass\n", "\n", "class B:\n", " pass\n", "\n", "check(A)\n", "check(B)\n", "\n", "a = A()\n", "b = B()\n", "\n", "#check(a)\n", "#check(b)\n", "'''\n", "from itertools import combinations\n", "\n", "items = [1, 2, 3]\n", "comb = list(combinations(items, 2))\n", "print(comb) # Output: [(1, 2), (1, 3), (2, 3)]\n", "\n", "from collections import defaultdict\n", "\n", "fruits = defaultdict(int)\n", "fruits['apple'] += 1\n", "fruits['banana'] += 2\n", "print(fruits)\n", "\n", "import math\n", "\n", "result = math.sqrt(16) # Output: 4.0\n", "\n", "import os\n", "\n", "current_dir = os.getcwd() # Get the current working directory\n", "\n", "from pathlib import Path\n", "\n", "path = Path('/path/to/file.txt')\n", "print(path.exists()) # Check if file exists" ], "metadata": { "id": "FdSdS8g6fVlG", "colab": { "base_uri": "https://localhost:8080/" }, "outputId": "ed6307ec-baaf-49c3-d41b-9f3a33f3257a" }, "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "1.0\n", "4.0\n", "16.0\n", "2.0\n", "1.0\n", "1.0\n", "2.0\n", "4.0\n", "1.0\n", "1.0\n", "4\n", "['/env/python']\n", "Hello! Nice to meet you \n", "This module provides access to the mathematical functions\n", "defined by the C standard.\n", "\n", "\n", "Built-in Module\n", "3.141592653589793\n", "4.0\n", "2.5\n", " A B\n", "count 3.0 3.0\n", "mean 2.0 5.0\n", "std 1.0 1.0\n", "min 1.0 4.0\n", "25% 1.5 4.5\n", "50% 2.0 5.0\n", "75% 2.5 5.5\n", "max 3.0 6.0\n", "Built-in Module\n", "User-defined Module\n", "[(1, 2), (1, 3), (2, 3)]\n", "defaultdict(, {'apple': 1, 'banana': 2})\n", "False\n" ] } ] }, { "cell_type": "markdown", "source": [ "configparser — parsing .ini-style configuration files.\n", "json — encode/decode JSON.\n", "\n", "csv — read/write CSV files.\n", "\n", "pickle — serialize and deserialize Python objects (binary; security considerations).\n", "\n", "datetime — dates, times, time arithmetic, timezone-aware objects.\n", "time — lower-level time functions and sleeping.\n", "\n", "collections — specialized container datatypes: Counter, deque, defaultdict, OrderedDict, namedtuple.\n", "\n", "itertools — fast iterator-building blocks (combinatorics, infinite sequences).\n", "\n", "functools — higher-order functions and utilities: partial, lru_cache, wraps.\n", "\n", "operator — functional equivalents of operators (itemgetter, attrgetter).\n", "\n", "math — mathematical functions for floats (sqrt, trig, log).\n", "\n", "statistics — basic statistics: mean, median, stdev.\n", "\n", "random — pseudo-random number generation and sampling.\n", "hashlib — secure hash algorithms (SHA, MD5).\n", "\n", "hmac — keyed-hash message authentication.\n", "secrets — cryptographically strong random numbers for\n", "\n", "security-sensitive contexts (tokens, passwords).\n", "re — regular expressions.\n", "subprocess — run and control external processes.\n", "\n", "threading, multiprocessing, concurrent.futures — concurrency primitives and pools for threads/processes.\n", "\n", "socket — low-level network communication.\n", "http.client, http.server, urllib.request, urllib.parse — HTTP client/server and URL handling.\n", "\n", "xml.etree.ElementTree — XML parsing and generation.\n", "\n", "sqlite3 — embedded SQL database engine.\n", "ssl — TLS/SSL support.\n", "\n" ], "metadata": { "id": "u6KsEQtFfVtQ" } }, { "cell_type": "code", "source": [ "import json\n", "\n", "data = {\"name\": \"Alice\", \"age\": 30}\n", "json_data = json.dumps(data) # Convert Python dict to JSON string\n", "\n", "import re\n", "\n", "pattern = r'\\d+'\n", "match = re.search(pattern, 'My number is 12345')\n", "print(match.group())\n", "\n", "import subprocess\n", "\n", "result = subprocess.run(['ls', '-l'], stdout=subprocess.PIPE)\n", "print(result.stdout.decode())\n", "\n", "import sys\n", "print(sys.argv) # Command-line arguments\n", "\n", "import logging\n", "logging.basicConfig(level=logging.INFO)\n", "logging.info('This is an info message')\n", "\n", "\n", "import socket\n", "\n", "s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n", "s.connect(('example.com', 80))\n", "s.sendall(b'GET / HTTP/1.1\\r\\nHost: example.com\\r\\n\\r\\n')\n", "response = s.recv(4096)\n", "\n", "import threading\n", "\n", "def print_numbers():\n", " for i in range(5):\n", " print(i)\n", "\n", "thread = threading.Thread(target=print_numbers)\n", "thread.start()\n", "thread.join()\n", "\n", "import multiprocessing\n", "\n", "def print_numbers():\n", " for i in range(5):\n", " print(i)\n", "\n", "process = multiprocessing.Process(target=print_numbers)\n", "process.start()\n", "process.join()\n", "\n", "import hashlib\n", "\n", "hash_object = hashlib.sha256(b'hello')\n", "print(hash_object.hexdigest())\n", "\n", "from abc import ABC, abstractmethod\n", "\n", "class Animal(ABC):\n", " @abstractmethod\n", " def sound(self):\n", " pass\n", "\n", "class Dog(Animal):\n", " def sound(self):\n", " return \"Woof!\"\n", "\n", "\n", "\n", "import math\n", "\n", "print(type([1,2,3]))\n", "print(type(math))\n", "print(dir([1,2,3]))\n", "print(dir(math))\n", "\n", "\n", "\n", "import math\n", "x = math.sqrt(16)\n", "print(\"Square root of 16 is:\",x)\n", "\n", "import os\n", "file_path = \"/path/to/file.txt\"\n", "if os.path.exists(file_path):\n", " os.remove(file_path)\n", " print(\"File deleted.\")\n", "else:\n", " print(\"File does not exist.\")\n", "\n", "import numpy as np\n", "arr = np.array([1, 2, 3, 4, 5])\n", "print(\"Array:\", arr)\n", "print(\"Sum:\", np.sum(arr))\n", "print(\"Mean:\", np.mean(arr))\n", "print(\"Standard deviation:\", np.std(arr))\n", "\n", "\n", "import pandas as pd\n", "file_path = \"/path/to/file.csv\"\n", "#df = pd.read_csv(file_path)\n", "print(\"Data types:\")\n", "print(df.dtypes)\n", "print(\"Summary statistics:\")\n", "print(df.describe())\n", "\n", "\n", "import matplotlib.pyplot as plt\n", "x_values = [1, 2, 3, 4, 5]\n", "y_values = [2, 4, 6, 8, 10]\n", "plt.plot(x_values, y_values)\n", "plt.title(\"Line chart\")\n", "plt.xlabel(\"X values\")\n", "plt.ylabel(\"Y values\")\n", "plt.show()\n", "\n", "#calling modules\n", "import math # this is a math module\n", "import random # this is a random module\n", "\n", "# now, we use some of the math and random module function to check whether the modules are working or not.\n", "cos30 = math.cos(30)\n", "tan10 = math.tan(10)\n", "pie = math.pi\n", "\n", "# now, using the random module to generate some random numbers\n", "random_int = random.randint(0,20)\n", "\n", "\n", "print(f\"Value of cos30 is: {cos30}\")\n", "print(f\"Value of tan10 is: {tan10}\")\n", "print(f\"Value of pie is: {pie}\")\n", "print(f\"The random number generated using random int function: {random_int}\")\n", "\n", "'''\n", "# This is variables module\n", "## this is a function in module\n", "def factorial(n):\n", " if n == 1 || n == 0:\n", " return 1\n", " else:\n", " return n * factorial(n-1)\n", "\n", "## this is dictionary in module\n", "power = {\n", " 1 : 1,\n", " 2 : 4,\n", " 3 : 9,\n", " 4 : 16,\n", " 5 : 25,\n", " 6 : 36,\n", " 7 : 49,\n", " 8 : 64,\n", " 9 : 81,\n", " 10 : 100\n", "}\n", "\n", "## This is a list in the module\n", "alphabets = [a,b,c,d,e,f,g,h]\n", "\n", "\n", "import variables\n", "\n", "fact_of_6 = variables.factorial(6)\n", "\n", "power_of_6 = variables.power[6]\n", "\n", "alphabet_2 = variables.alphabets[1]\n", "\n", "print(f\"The factorial of 6 is : {fact_of_6}\")\n", "print(f\"Power of 6 is : {power_of_6}\")\n", "print(f\"Second Alphabet is : {alphabrt_2}\")\n", "'''\n", "\n", "import math\n", "\n", "print(f\"The value of pie using math module is : {math.pi}\")\n", "print(\"The value of pi, we studied is 3.14\")\n", "\n", "\n", "from math import sqrt, factorial, pi\n", "\n", "print(sqrt(100))\n", "print(factorial(10))\n", "print(pi)\n", "\n", "\n", "from math import *\n", "\n", "print(pi)\n", "print(sin(155))\n", "print(tan(0))\n", "\n", "\n", "import math as m\n", "import numpy as np\n", "import random as r\n", "\n", "print(m.pi)\n", "print(r.randint(0,10))\n", "print(np.__version__)\n", "\n", "\n" ], "metadata": { "id": "UcHfmfAzfV0u", "colab": { "base_uri": "https://localhost:8080/", "height": 1000 }, "outputId": "aa0bbffa-0651-4546-ba3c-a51acbd36033" }, "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "12345\n", "total 4\n", "drwxr-xr-x 1 root root 4096 Nov 3 14:39 sample_data\n", "\n", "['/usr/local/lib/python3.12/dist-packages/colab_kernel_launcher.py', '-f', '/root/.local/share/jupyter/runtime/kernel-8a5e6f5b-4bea-4c92-aef8-d7d1fa2c2cd2.json']\n", "0\n", "1\n", "2\n", "3\n", "4\n", "0\n", "1\n", "2\n", "3\n", "4\n", "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824\n", "\n", "\n", "['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']\n", "['__doc__', '__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', 'sumprod', 'tan', 'tanh', 'tau', 'trunc', 'ulp']\n", "Square root of 16 is: 4.0\n", "File does not exist.\n", "Array: [1 2 3 4 5]\n", "Sum: 15\n", "Mean: 3.0\n", "Standard deviation: 1.4142135623730951\n", "Data types:\n", "A int64\n", "B int64\n", "dtype: object\n", "Summary statistics:\n", " A B\n", "count 3.0 3.0\n", "mean 2.0 5.0\n", "std 1.0 1.0\n", "min 1.0 4.0\n", "25% 1.5 4.5\n", "50% 2.0 5.0\n", "75% 2.5 5.5\n", "max 3.0 6.0\n" ] }, { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "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\n" }, "metadata": {} }, { "output_type": "stream", "name": "stdout", "text": [ "Value of cos30 is: 0.15425144988758405\n", "Value of tan10 is: 0.6483608274590866\n", "Value of pie is: 3.141592653589793\n", "The random number generated using random int function: 20\n", "The value of pie using math module is : 3.141592653589793\n", "The value of pi, we studied is 3.14\n", "10.0\n", "3628800\n", "3.141592653589793\n", "3.141592653589793\n", "-0.8733119827746476\n", "0.0\n", "3.141592653589793\n", "5\n", "2.0.2\n" ] } ] }, { "cell_type": "markdown", "source": [ "tempfile — create temporary files and directories securely.\n", "pathlib — (listed again intentionally) modern path handling; prefer over os.path in new code.\n", "\n", "contextlib — utilities for context managers (contextmanager, closing).\n", "enum — enumeration types.\n", "\n", "typing — type hints and related utilities.\n", "\n", "unittest — testing framework; unittest.mock — mocking utilities.\n", "\n", "pkgutil, importlib — import mechanisms, dynamic importing, package discovery.\n", "\n", "locale — localization and formatting rules.\n", "Practical tips\n", "\n", "Prefer higher-level modules: pathlib over os.path; json over eval for JSON; secrets over random for security.\n", "\n", "Use virtual environments and pip for third-party modules; keep standard library for well-tested utilities.\n", "\n", "Read documentation (Python Standard Library docs) for behavior, thread-safety, and performance trade-offs.\n", "\n", "Keep imports at top of module, group standard library, third-party, then local imports; follow PEP 8." ], "metadata": { "id": "ZN9XROc6fV9O" } } ] }