1. What are Modules in Python?In Python, a module is a file containing Python code. It can be a Python file (with .py extension) or a compiled Python file (with .pyc extension). It contains functions, classes, and variables that can be used by other Python programs.Modules help us to organize our code into separate files, which can be used in other programs, making our code more reusable.Table of ContentsModules- What are modules?- Creating and importing modules- Importing specific functions or variables from a moduleStandard Library Modules- Commonly used modules (e.g. math, random, os, sys)- Overview of their functions and capabilitiesPackages- What are packages?- Creating and importing packagesCustom Modules and Packages- Writing your own modules and packages- Organizing code into reusable components1.1. Creating a ModuleTo create a module, we simply need to create a Python file with .py extension and add our functions, classes, and variables in it.Example: create a module named my_module.py with a function greet(name).pythonCopy code# my_module.py
def greet(name):
print(f”Hello, {name}!”)1.2. Importing a Module:We can import a module in our Python code using the import keyword. Once imported, we can use the functions, classes, and variables defined in that module.Example: Importing my_module and using its greet() function in our code.pythonCopy codeimport my_module
my_module.greet(“Alice”) # Output: Hello, Alice!1.3. Importing specific functions or variables from a Module:We can also import specific functions or variables from a module, instead of importing the whole module.Example: Importing only greet() function from my_module.pythonCopy codefrom my_module import greet
greet(“Bob”) # Output: Hello, Bob!We can also import multiple functions or variables from a module by separating them with commas.Example: Importing both greet() and name variables from my_module.pythonCopy codefrom my_module import greet, name
greet(name) # Output: Hello, Alice!1.4. Renaming a Module:We can rename a module while importing it using the as keyword.Example: Importing my_module as m.pythonCopy codeimport my_module as m
m.greet(“Charlie”) # Output: Hello, Charlie!2. Standard Library ModulesPython’s standard library provides a large set of modules that can be used to add various functionalities to your Python programs. These modules are pre-installed with Python, and can be easily imported into your code. In this tutorial, we will cover some of the most commonly used standard library modules and their functions.2.1. Math moduleThe math module provides a set of mathematical operations and constants. Here are some commonly used functions in the math module:1. math.ceil(x): Returns the smallest integer greater than or equal to x.2. math.floor(x): Returns the largest integer less than or equal to x.3. math.sqrt(x): Returns the square root of x.4. math.pow(x, y): Returns x raised to the power of y.5. math.sin(x): Returns the sine of x in radians.6. math.cos(x): Returns the cosine of x in radians.7. math.tan(x): Returns the tangent of x in radians.8. math.pi: The mathematical constant pi.Here’s an example of how to use the math module:pythonCopy codeimport math
x = 3.7
print(math.ceil(x)) # Output: 4
print(math.floor(x)) # Output: 3
print(math.sqrt(x)) # Output: 1.9235384061671346
print(math.pi) # Output: 3.1415926535897932.2. Random moduleThe random module provides functions for generating random numbers. Here are some commonly used functions in the random module:1. random.random(): Returns a random float between 0 and 1.2. random.randint(a, b): Returns a random integer between a and b, inclusive.3. random.choice(seq): Returns a random element from seq.4. random.shuffle(seq): Shuffles the elements of seq in place.5. random.sample(seq, k): Returns k unique elements from seq without replacement.Here’s an example of how to use the random module:pythonCopy codeimport random
print(random.random()) # Output: 0.9560342718897579
print(random.randint(1, 10)) # Output: 7
print(random.choice([‘apple’, ‘banana’, ‘cherry’])) # Output: banana
my_list = [1, 2, 3, 4, 5]
random.shuffle(my_list)
print(my_list) # Output: [5, 3, 2, 4, 1]
print(random.sample([1, 2, 3, 4, 5], 3)) # Output: [3, 2, 4]2.3. OS moduleThe os module provides a way to work with the operating system. It allows you to interact with the file system, environment variables, and other operating system features.Here are some common functions and constants provided by the os module:Functions1. os.getcwd(): returns the current working directory2. os.chdir(path): changes the current working directory to the specified path3. os.listdir(path): returns a list of all files and directories in the specified path4. os.mkdir(path): creates a new directory at the specified path5. os.rmdir(path): removes the directory at the specified path6. os.remove(path): removes the file at the specified path7. os.rename(src, dst): renames a file or directory from src to dstConstants1. os.sep: the separator used by the operating system for file paths (e.g. “/” on Unix-like systems, “” on Windows)2. os.linesep: the line separator used by the operating system (e.g. “n” on Unix-like systems, “rn” on Windows)3. os.name: the name of the operating system (e.g. “posix” on Unix-like systems, “nt” on Windows)Here’s an example of how to use the os module:pythonCopy codeimport os
# get the current working directory
cwd = os.getcwd()
print(“Current working directory:”, cwd)
# change the current working directory
os.chdir(“/path/to/new/directory”)
# list all files and directories in the current directory
files = os.listdir()
print(“Files in current directory:”, files)
# create a new directory
os.mkdir(“new_directory”)
# rename a file
os.rename(“old_name.txt”, “new_name.txt”)
# remove a file
os.remove(“file_to_remove.txt”)2.4. The sys ModuleThe sys module provides access to some variables and functions that interact with the Python interpreter. It allows you to do things like exit the program or get information about the version of Python being used.Here are some common variables and functions provided by the sys module:Variables1. sys.argv: a list containing the command-line arguments passed to the program2. sys.path: a list of directories that Python searches for modules3. sys.version: a string containing the version of Python being used4. sys.platform: a string containing the name of the platform (e.g. “linux”, “win32”, “darwin”)Functions1. sys.exit([arg]): exits the program with an optional exit code2. sys.getsizeof(object): returns the size of the object in bytes3. sys.getdefaultencoding(): returns the default string encoding used by the systemHere’s an example of how to use the sys module:pythonCopy codeimport sys
# print the command-line arguments passed to the program
print(“Command-line arguments:”, sys.argv)
# print the directories that Python searches for modules
print(“Module search path:”, sys.path)
# print the version of Python being used
print(“Python version:”, sys.version)
# exit the program with an exit code of 0
sys.exit(0)3. What are packages in Python?In Python, a package is a way to organize related modules into a single directory hierarchy. It provides a structured approach to organizing code, making it easier to manage and reuse.A package is essentially a directory that contains one or more Python module files, along with an optional __init__.py file. The __init__.py file is used to mark the directory as a package and can also contain the initialization code that is executed when the package is imported.Packages help in organizing code into logical units and provide a means to encapsulate related functionality. They allow for better code reusability and maintainability by providing a hierarchical structure for organizing modules.Packages also enable the use of namespaces, which helps avoid naming conflicts between modules. By grouping modules within a package, you can provide a unique namespace for each module, making it easier to identify and access specific functionality.3.1. Creating and Importing Packages:To create a package, follow these steps:Create a new directory with a valid Python identifier as the package name.Within the package directory, create Python module files (.py) to define the functionality.Include an __init__.py file in the package directory to make it a package.Example:
Suppose you want to create a package named mypackage. You would follow this structure:markdownCopy codemypackage/
├── __init__.py
├── module1.py
└── module2.pyTo import the package and access its modules, you can use:pythonCopy codeimport mypackage.module1
import mypackage.module24. Custom Modules and Packages:Custom modules are Python files that contain functions, classes, or variables. They can be created within a package to provide specific functionality. These modules can be imported and used within the package or by other modules outside the package.Example:
Suppose you have a package mypackage with two modules, module1.py and module2.py. module1.py contains a function function1() and module2.py contains a class Class2(). You can use them as follows:pythonCopy codeimport mypackage.module1
from mypackage.module2 import Class2
mypackage.module1.function1()
obj = Class2()4.1. Writing Your Own Modules and Packages:To create a custom module, write a Python file (.py) with the desired functionality.Modules can contain functions, classes, variables, or other definitions.To create a package, organize related modules within a directory hierarchy.The package directory should include an __init__.py file to mark it as a package.Custom modules and packages allow you to encapsulate and organize code in a modular and reusable manner.4.2. Organizing Code into Reusable Components:Packages and custom modules provide a structured approach to organizing code into logical units.By dividing your code into modules, you can isolate specific functionality and promote code reuse.Packages allow for further organization by grouping related modules together.This modular approach makes it easier to manage and maintain your codebase.It also enables collaboration, as different developers can work on separate modules or packages simultaneously.ConclusionBy writing your own modules and organizing them into packages, you can create modular and reusable components that promote code organization, reusability, and maintainability. This allows you to build scalable and well-structured Python projects.AuthorVaneesh BehlPassionately working as an Automation Developer for more than a decade.
