{ "nbformat": 4, "nbformat_minor": 0, "metadata": { "colab": { "provenance": [], "authorship_tag": "ABX9TyNppYHWAwRWhUsR7hT3wxXR", "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": [ "# **How to Create a Python Package**\n", "The main difference between a module and a package is that a package is a collection of modules AND it has an __init__.py file. Depending on the complexity of the package, it may have more than one __init__.py. Let’s take a look at a simple folder structure to make this more obvious, then we’ll create some simple code to follow the structure we define." ], "metadata": { "id": "9IzzWzf9fXQX" } }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "zu6Nr7Sje8Ks", "colab": { "base_uri": "https://localhost:8080/", "height": 1000 }, "outputId": "5154dc12-3f97-4abe-e915-0a309b98f857" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "['/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', '/usr/local/lib/python3.12/dist-packages/setuptools/_vendor']\n", "11.0\n", "3.141592653589793\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", "\n", "hello newtype\n", "\n", "hello newtype\n", "123 0 RESUME 0\n", "\n", "124 2 LOAD_GLOBAL 1 (NULL + str)\n", " 12 LOAD_FAST 0 (number)\n", " 14 CALL 1\n", " 22 LOAD_GLOBAL 1 (NULL + str)\n", " 32 LOAD_FAST 0 (number)\n", " 34 CALL 1\n", " 42 BINARY_OP 0 (+)\n", " 46 RETURN_VALUE\n", "126 0 RESUME 0\n", "\n", "127 2 LOAD_GLOBAL 1 (NULL + print)\n", " 12 LOAD_CONST 1 ('Hello')\n", " 14 LOAD_FAST 0 (string)\n", " 16 CALL 2\n", " 24 POP_TOP\n", " 26 RETURN_CONST 0 (None)\n", "Content-Type: text/html; charset=utf-8\n", "Content-Length: 197010\n", "Connection: close\n", "Date: Tue, 04 Nov 2025 16:11:53 GMT\n", "Strict-Transport-Security: max-age=31536000; includeSubDomains\n", "Server: nginx\n", "Cache-Control: s-maxage=61232, max-age=0\n", "X-Powered-By: Next.js\n", "ETag: \"1tqjs67pl6480e\"\n", "X-XSS-Protection: 1; mode=block\n", "X-Content-Type-Options: nosniff\n", "Referrer-Policy: no-referrer-when-downgrade\n", "Content-Security-Policy: default-src 'self' http: https: ws: wss: data: blob: 'unsafe-eval' 'unsafe-inline'; frame-ancestors 'self';\n", "Permissions-Policy: interest-cohort=()\n", "Vary: Accept-Encoding,Accept-Encoding\n", "X-Cache: Hit from cloudfront\n", "Via: 1.1 738cdabd1c33dee5b48ea07819a43dd4.cloudfront.net (CloudFront)\n", "X-Amz-Cf-Pop: ORD58-P12\n", "X-Amz-Cf-Id: g2MJC1VjsMucF8jpwHGJo1xYkSwocG2pzJbOVPOHKStHQ-Mh70RQfg==\n", "Age: 47525\n", "\n", "\n", "b'GeeksforGeeks | Your All-in-One Learning Portal
\"geeksforgeeks\"
Data Structure
Java
Python
HTML
Interview Preparation
  • Tutorials
  • Courses
  • Tracks
Hello, What Do You Want To Learn?
21 MERN ProjectsMaster DS & MLMaster DevOps

Must Explore

Trending NowWatch VideosGfG Coding ContestAdvertise with Us
'\n", "3.141592653589793\n", "3.141592653589793\n", "3\n", "2025-11-05 05:23:58.216091\n", "Type 'exit' to exit\n", "exit\n", "Exiting the program\n" ] }, { "output_type": "error", "ename": "SystemExit", "evalue": "", "traceback": [ "An exception has occurred, use %tb to see the full traceback.\n", "\u001b[0;31mSystemExit\u001b[0m\n" ] } ], "source": [ "import sys\n", "print(sys.path)\n", "\n", "\n", "# This lists all the modules available for use\n", "#help(\"modules\")\n", "\n", "\n", "import math\n", "\n", "print (math.sqrt(121))\n", "\n", "print (math.pi)\n", "\n", "print (dir(math))\n", "\n", "\n", "def fibonacci1(count): # This function is used to print Fibonacci Series\n", "\n", " i = 0\n", "\n", " j = 1\n", "\n", " while i < count:\n", "\n", " print(i, end=', ')\n", "\n", " i, j = j, i+j\n", "\n", " print()\n", "\n", "def fibonacci2(count): # This function is used to return Fibonacci Series\n", "\n", " fibo = []\n", "\n", " i = 0\n", "\n", " j = 1\n", "\n", " while i < count:\n", "\n", " fibo.append(i)\n", "\n", " i, j = j, i+j\n", "\n", " return fibo\n", "\n", "'''\n", "# main.py\n", "import pricing\n", "\n", "\n", "net_price = pricing.get_net_price(\n", " price=100,\n", " tax_rate=0.01\n", ")\n", "\n", "print(net_price)\n", "'''\n", "# Define a function\n", "def world():\n", " print(\"Hello, World!\")\n", "\n", "# Define a variable\n", "shark = \"Sammy\"\n", "\n", "\n", "# Define a class\n", "class Octopus:\n", " def __init__(self, name, color):\n", " self.color = color\n", " self.name = name\n", "\n", " def tell_me_about_the_octopus(self):\n", " print(\"This octopus is \" + self.color + \".\")\n", " print(self.name + \" is the octopus's name.\")\n", "\n", "# Python program to\n", "# demonstrate pyperclip module\n", "\n", "'''\n", "# This will import pyperclip\n", "#import pyperclip\n", "pyperclip.copy(\"Hello world !\")\n", "pyperclip.paste()\n", "\n", "pyperclip.copy(\"Isn't pyperclip interesting?\")\n", "pyperclip.paste()\n", "\n", "# Python program to\n", "# create new type object\n", "'''\n", "\n", "# Creates a new type object\n", "NewType = type(\"NewType\", (object, ), {\"attr\": \"hello newtype\"})\n", "New = NewType()\n", "\n", "# Print the type of object\n", "print(type(New))\n", "\n", "# Print the attribute of object\n", "print(New.attr)\n", "\n", "\n", "# Creates a class\n", "class NewType:\n", " attr = \"hello newtype\"\n", "\n", "# Initialize an object\n", "New = NewType()\n", "\n", "# Print the type of object\n", "print(type(New))\n", "\n", "# Print the attribute of object\n", "print(New.attr)\n", "\n", "# This will import\n", "# dis module\n", "import dis\n", "\n", "\n", "def test(number):\n", " return (str(number)+str(number))\n", "\n", "def newFunc(string):\n", " print(\"Hello\", string)\n", "\n", "# This will display the\n", "# disassembly of test():\n", "dis.dis(test)\n", "\n", "# This will display the\n", "# disassembly of newFunc()\n", "dis.dis(newFunc)\n", "\n", "\n", "# This will import urlopen\n", "# class from urllib module\n", "from urllib.request import urlopen\n", "\n", "\n", "page = urlopen(\"https://www.geeksforgeeks.org/\")\n", "print(page.headers)\n", "\n", "# This will import urlopen\n", "# class from urllib module\n", "\n", "\n", "from urllib.request import urlopen\n", "page=urlopen(\"https://www.geeksforgeeks.org/\")\n", "\n", "# Fetches the code\n", "# of the web page\n", "content = page.read()\n", "\n", "print(content)\n", "\n", "# This will import turtle module\n", "import turtle\n", "\n", "\n", "#myTurtle = turtle.Turtle()\n", "#myWin = turtle.Screen()\n", "\n", "# Turtle to draw a spiral\n", "def drawSpiral(myTurtle, linelen):\n", " myTurtle.forward(linelen)\n", " myTurtle.right(90)\n", " drawSpiral(myTurtle, linelen-10)\n", "\n", "#drawSpiral(myTurtle, 80)\n", "#myWin.exitonclick()\n", "\n", "import math\n", "\n", "print(math.pi)\n", "\n", "from math import pi\n", "\n", "print(pi)\n", "\n", "import random\n", "\n", "print(random.randint(1,10))\n", "\n", "import datetime\n", "\n", "now = datetime.datetime.now()\n", "print(now)\n", "\n", "# This will import\n", "# sys module\n", "import sys\n", "\n", "while True:\n", " print(\"Type 'exit' to exit\")\n", " response = input()\n", " if response == \"exit\":\n", " print(\"Exiting the program\")\n", " sys.exit()\n", " print(\"You typed\", response)\n", "\n" ] }, { "cell_type": "markdown", "source": [ "# **What Are Python Modules and Why Are They Important?**\n", "Python modules are reusable pieces of code that simplify programming tasks. They allow you to group related functions, classes, and variables into a single file. By using modules, you avoid rewriting the same code repeatedly, making your programs cleaner and more efficient." ], "metadata": { "id": "YAPlDhlwfYB2" } }, { "cell_type": "code", "source": [ "import pandas as pd\n", "\n", "df = pd.DataFrame()\n", "\n", "\"\"\"My custom module providing useful utilities\"\"\"\n", "\n", "def greet(name):\n", " print(f\"Hello {name}!\")\n", "\n", "\n", "if __name__ == \"__main__\":\n", " greet(\"Reader\") # call function if run directly\n", "\n", "class Employee:\n", " def __init__(self):\n", " self.id = None\n", " self.name = None\n", " self.salary = None\n", "\n", " def inputdata(self):\n", " self.id = int(input('Enter ID: '))\n", " self.name = input('Enter Name: ')\n", " self.salary = int(input('Enter Salary: '))\n", "\n", " def displaydata(self):\n", " print('Employee ID: %d' %(self.id))\n", " print('Employee Name: %s' %(self.name))\n", " print('Employee Salary: %d' %(self.salary))\n", "\n", "\n", "def square(n):\n", " return n*n\n", "\n", "def cube(n):\n", " return n*n*n\n", "\n", "#import mymodule\n", "'''\n", "x = mymodule.Employee()\n", "x.inputdata()\n", "x.displaydata()\n", "\n", "print('Square of 5 = %d' %(mymodule.square(5)))\n", "print('Cube of 2 = %d' %(mymodule.cube(2)))\n", "'''\n", "\n", "# importing sqrt, factorial functions from math module\n", "from math import sqrt, factorial\n", "\n", "# printing the square root of 16 using sqrt() function\n", "print('The square root of 16 = ',sqrt(16))\n", "\n", "# printing the factorial of 5 using factorial() function\n", "print('The factorial of 5 = ',factorial(5))\n", "\n", "# impoting matplotlib library with an alias name\n", "import matplotlib.pyplot as matplot\n", "# input first list\n", "inputList_1 = [1, 4, 6, 8]\n", "# input first list\n", "inputList_2 = [2, 6, 3, 9]\n", "\n", "# plotting the inputList_1, inputList_2 values by taking inputList_1 on x-axis\n", "# and inputList_2 on y-axis.\n", "matplot.plot(inputList_1, inputList_2)\n", "# giving the label/name for x-axis\n", "matplot.xlabel('X-axis')\n", "# giving the label/name for y-axis\n", "matplot.ylabel('Y-axis')\n", "# giving the title of the plot\n", "matplot.title('Plot for Data Visualization')\n", "# displaying the graph\n", "matplot.show()\n", "\n", "\n", "# importing the library and module\n", "import math\n", "from math import pow\n", "# using the pow() function\n", "pow(3, 5)\n", "# printing pow()\n", "print(pow)\n", "\n", "# Example using the os module\n", "import os\n", "print(os.getcwd())\n", "print(os.listdir())\n", "# Example using the sys module\n", "import sys\n", "print(sys.version)\n", "print(sys.argv)\n", "# Example using the math module\n", "import math\n", "print(math.pi)\n", "print(math.sin(math.pi / 2))\n", "# Example using the json module\n", "import json\n", "data = {\n", " \"name\": \"John Doe\",\n", " \"age\": 30,\n", " \"city\": \"New York\"\n", "}\n", "json_data = json.dumps(data)\n", "print(json_data)\n", "# Example using the datetime module\n", "import datetime\n", "now = datetime.datetime.now()\n", "print(now)\n", "print(now.year)\n", "print(now.month)\n", "print(now.day)\n", "# Example using the re module\n", "import re\n", "text = \"The quick brown fox jumps over the lazy dog.\"\n", "result = re.search(r\"fox\", text)\n", "print(result.start(), result.end(), result[0])\n", "# Example using the random module\n", "import random\n", "print(random.randint(1, 100))\n", "print(random.choice([1, 2, 3, 4, 5]))\n", "\n", "# calculator.py\n", "\n", "def add(a, b):\n", " return a + b\n", "\n", "def sub(a, b):\n", " return a - b\n", "\n", "def mul(a, b):\n", " return a * b\n", "\n", "def div(a, b):\n", " return a / b\n", "# main.py\n", "'''\n", "#import calculator\n", "\n", "print(\"Addition of 5 and 4 is:\", calculator.add(5, 4))\n", "print(\"Subtraction of 7 and 2 is:\", calculator.sub(7, 2))\n", "print(\"Multiplication of 3 and 4 is:\", calculator.mul(3, 4))\n", "print(\"Division of 12 and 3 is:\", calculator.div(12, 3))\n", "\n", "# importing the package\n", "#import science\n", "# printing a statement\n", "print(\"We have imported the science package\")\n", "\n", "import pandas as pd\n", "df=pd.read_csv(\"file_name.csv\")\n", "\n", "def Acad():\n", " para = \"upgrad\"\n", "Acad()\n", "'''\n", "\n", "\n", "import math\n", "\n", "x = math.sqrt(16)\n", "print(x)\n", "\n", "### my_module.py\n", "\n", "def greet(name):\n", " print(\"Hello, \" + name + \"!\")\n", "\n", "### main.py\n", "\n", "\n", "\n", "import math\n", "num = 16\n", "result = math.sqrt(num)\n", "print(f\"Square root of {num} is: {result}\")\n", "\n", "import os\n", "cwd = os.getcwd()\n", "print(f\"Current working directory is: {cwd}\")\n", "\n", "import random\n", "\n", "random_number = random.randint(1, 100)\n", "print(random_number)\n", "\n", "import math\n", "\n", "number = 25\n", "square_root = math.sqrt(number)\n", "print(square_root)\n", "\n" ], "metadata": { "id": "EC_Byh6nfYO3", "colab": { "base_uri": "https://localhost:8080/", "height": 871 }, "outputId": "749399b6-8abb-4294-81b9-0d6be87a665d" }, "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Hello Reader!\n", "The square root of 16 = 4.0\n", "The factorial of 5 = 120\n" ] }, { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "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\n" }, "metadata": {} }, { "output_type": "stream", "name": "stdout", "text": [ "\n", "/content\n", "['.config', 'sample_data']\n", "3.12.12 (main, Oct 10 2025, 08:52:57) [GCC 11.4.0]\n", "['/usr/local/lib/python3.12/dist-packages/colab_kernel_launcher.py', '-f', '/root/.local/share/jupyter/runtime/kernel-96218097-3b5a-4e03-9bd4-b73ac66ebbe3.json']\n", "3.141592653589793\n", "1.0\n", "{\"name\": \"John Doe\", \"age\": 30, \"city\": \"New York\"}\n", "2025-11-05 05:33:10.622118\n", "2025\n", "11\n", "5\n", "16 19 fox\n", "45\n", "2\n", "4.0\n", "Square root of 16 is: 4.0\n", "Current working directory is: /content\n", "8\n", "5.0\n" ] } ] }, { "cell_type": "markdown", "source": [ "# **The Two Types of Modules in Python: **\n", "\n", "Built-in vs. User-Defined\n", "Python modules fall into two categories: built-in modules and user-defined modules. Built-in modules come pre-installed with Python, while user-defined modules are created by developers to fulfill specific needs. Understanding these types of modules in Python helps you work smarter by leveraging existing tools or designing your own.\n", "\n", "Below, you'll explore the details of both types and understand how to use them effectively.\n", "\n", "Built-in Modules\n", "Built-in modules are pre-packaged with Python and provide extensive functionality. They help you perform various tasks like handling files, working with math, or managing data without extra installations. These modules save time and make your programs efficient.\n", "\n", "The following examples showcase the versatility of built-in Python modules.\n", "\n", "Streamline Math Operations: The math module offers functions like sqrt() for square root calculations and pow() for powers. For example:" ], "metadata": { "id": "0SYfJ1i8fYZO" } }, { "cell_type": "code", "source": [ "import math\n", "\n", "print(math.sqrt(64)) # Output: 8.0\n", "\n", "from datetime import date\n", "\n", "today = date.today()\n", "print(\"Today's date:\", today) # Output: Today's date: 2022-11-11\n", "\n", "\"\"\"\n", "To try the examples in the browser:\n", "1. Type code in the input cell and press\n", " Shift + Enter to execute\n", "2. Or copy paste the code, and click on\n", " the \"Run\" button in the toolbar\n", "\"\"\"\n", "\n", "# The standard way to import NumPy:\n", "import numpy as np\n", "\n", "# Create a 2-D array, set every second element in\n", "# some rows and find max per row:\n", "\n", "x = np.arange(15, dtype=np.int64).reshape(3, 5)\n", "x[1:, ::2] = -99\n", "x\n", "# array([[ 0, 1, 2, 3, 4],\n", "# [-99, 6, -99, 8, -99],\n", "# [-99, 11, -99, 13, -99]])\n", "\n", "x.max(axis=1)\n", "# array([ 4, 8, 13])\n", "\n", "# Generate normally distributed random numbers:\n", "rng = np.random.default_rng()\n", "samples = rng.normal(size=2500)\n", "samples\n", "\n", "\n", "import json\n", "data = {\n", " \"name\": \"Jonny\",\n", " \"age\": 30,\n", " \"is_student\": True,\n", " \"courses\": [\"Web Dev\", \"CP\"]\n", "}\n", "json_string = json.dumps(data, indent=4)\n", "print(json_string)\n", "'''\n", "import tkinter as tk\n", "def on_button_click():\n", " label.config(text=\"Hello, Geeks!\")\n", "\n", "root = tk.Tk()\n", "root.title(\"Tkinter Example\")\n", "label = tk.Label(root, text=\"Click the button below\")\n", "label.pack(pady=40)\n", "button = tk.Button(root, text=\"Click Me\", command=on_button_click)\n", "button.pack(pady=40)\n", "root.mainloop()\n", "'''\n", "import random\n", "num = random.randint(1, 10)\n", "print(f\"Random integer between 1 and 10: {num}\")\n", "fruits = [\"Java\", \"C\", \"C++\", \"Python\"]\n", "chosen_fruit = random.choice(fruits)\n", "print(f\"Randomly chosen language: {chosen_fruit}\")\n", "\n", "import math\n", "sqrt_val = math.sqrt(64)\n", "pi_const = math.pi\n", "print(sqrt_val)\n", "print(pi_const)\n", "\n", "import datetime\n", "date_today = datetime.date.today()\n", "time_now = datetime.datetime.now().time()\n", "print(date_today)\n", "print(time_now)\n", "\n", "import os\n", "directory = os.getcwd()\n", "print(directory)\n", "\n", "import sys\n", "print(\"Python version:\", sys.version)\n", "print(\"Command line arguments:\", sys.argv)\n", "sys.exit(1)\n", "\n", "import re\n", "pattern = r\"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,4}\"\n", "\n", "text = \"Contact us at info@example.com and support@example.org for more details.\"\n", "match = re.search(pattern, text)\n", "if match:\n", " print(\"First found email:\", match.group())\n", "\n", "emails = re.findall(pattern, text)\n", "print(\"All found emails:\", emails)\n", "\n", "import hashlib\n", "message = \"Hello, World!\"\n", "hashed = hashlib.sha256(message.encode()).hexdigest()\n", "print(hashed)\n", "\n", "import calendar\n", "cal_october = calendar.month(2023, 10)\n", "print(cal_october)\n", "\n", "import heapq\n", "numbers = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]\n", "\n", "heapq.heapify(numbers)\n", "heapq.heappush(numbers, 7)\n", "print(heapq.heappop(numbers))\n", "print(heapq.heappushpop(numbers, 8))\n", "print(heapq.nlargest(3, numbers))\n", "print(heapq.nsmallest(3, numbers))\n", "\n", "import pkg_resources\n", "import subprocess\n", "\n", "# Function to list installed packages and get detailed information using 'pip show'\n", "def list_and_detail_installed_packages():\n", " # List packages using pkg_resources\n", " installed_packages = {d.project_name: d.version for d in pkg_resources.working_set}\n", " detailed_info = {}\n", " # Use subprocess to get more details with 'pip show'\n", " for package_name in installed_packages.keys():\n", " pip_show_output = subprocess.check_output(['pip', 'show', package_name], text=True)\n", " package_info = {}\n", " for line in pip_show_output.split('\\n'):\n", " if line.startswith('Name:') or line.startswith('Version:') or line.startswith('Summary:'):\n", " key, value = line.split(': ', 1)\n", " package_info[key.lower()] = value\n", " detailed_info[package_name] = package_info\n", " return detailed_info\n", "\n", "# Example usage\n", "if __name__ == '__main__':\n", " packages_info = list_and_detail_installed_packages()\n", " for package_name, info in packages_info.items():\n", " print(f'Package: {package_name}, Details: {info}')\n", "\n", "# Importing math module\n", "import math as mt\n", "\n", "# Printing all the functions in math module using dir\n", "print(dir(mt))\n", "\n", "# Importing re module\n", "import re\n", "\n", "# Printing different functions in re module\n", "print(re.__all__)\n", "\n", "# Importing getmembers and isfunction from inspect\n", "from inspect import getmembers, isfunction\n", "\n", "# Importing math module\n", "import math as mt\n", "\n", "# Printing all the functions in math module\n", "print(getmembers(mt), isfunction)\n", "\n", "import pkg_resources\n", "\n", "installed_packages = pkg_resources.working_set\n", "for package in installed_packages:\n", " print(f\"quot;{package.key}=={package.version}\")\n", "\n", "import collections\n", "nums = [1, 2, 3]\n", "# creating deque collection from the list\n", "deque = collections.deque(nums)\n", "\n", "print(deque)\n", "\n", "# adding an element at the end\n", "deque.append(4)\n", "\n", "print(deque)\n", "\n", "# adding element at the starting\n", "deque.appendleft(0)\n", "\n", "print(deque)\n", "\n", "# removing the element at the end\n", "deque.pop()\n", "\n", "print(deque)\n", "\n", "# removing element at the starting\n", "deque.popleft()\n", "\n", "print(deque)\n", "\n", "import random\n", "\n", "# generating a random number from the range 1-100\n", "print(random.randint(1, 100))" ], "metadata": { "id": "-KrdmvqTfYiP", "colab": { "base_uri": "https://localhost:8080/", "height": 491 }, "outputId": "00d52af6-9ec7-435b-e42d-e3750dd9f2a1" }, "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "8.0\n", "Today's date: 2025-11-05\n", "{\n", " \"name\": \"Jonny\",\n", " \"age\": 30,\n", " \"is_student\": true,\n", " \"courses\": [\n", " \"Web Dev\",\n", " \"CP\"\n", " ]\n", "}\n", "Random integer between 1 and 10: 6\n", "Randomly chosen language: Python\n", "8.0\n", "3.141592653589793\n", "2025-11-05\n", "06:01:39.885521\n", "/content\n", "Python version: 3.12.12 (main, Oct 10 2025, 08:52:57) [GCC 11.4.0]\n", "Command line arguments: ['/usr/local/lib/python3.12/dist-packages/colab_kernel_launcher.py', '-f', '/root/.local/share/jupyter/runtime/kernel-96218097-3b5a-4e03-9bd4-b73ac66ebbe3.json']\n" ] }, { "output_type": "error", "ename": "SystemExit", "evalue": "1", "traceback": [ "An exception has occurred, use %tb to see the full traceback.\n", "\u001b[0;31mSystemExit\u001b[0m\u001b[0;31m:\u001b[0m 1\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "/usr/local/lib/python3.12/dist-packages/IPython/core/interactiveshell.py:3561: UserWarning: To exit: use 'exit', 'quit', or Ctrl-D.\n", " warn(\"To exit: use 'exit', 'quit', or Ctrl-D.\", stacklevel=1)\n" ] } ] }, { "cell_type": "markdown", "source": [ "# **What Are Python Modules?**\n", "A module is simply a Python file and may contain Python functions, Python variables, and Python classes. Python processes modules using two key statements and a built-in function:\n", "\n", "Import: Let a client obtain a module as a whole\n", "From: Permits a client to fetch particular names from a module\n", "Reload: Gives a way to reload the code of a module without stopping Python\n", "Now let’s understand Python Modules with a real-world example:\n", "\n", "Leon, who works as a software developer, has been working on a Python project for four days. After finishing, he found some coding errors and needed to debug his code. Since he wrote everything in a single file, it was hard for him to find and fix the errors. To make this process easier, he decided to split the project into smaller, manageable parts based on the features. This way, he could debug one section at a time without affecting the rest of the code." ], "metadata": { "id": "MltuhnyrfYtG" } } ] }