What is a Module?

A module is simply a Python file that contains:

• Functions
• Classes
• Variables
• Executable code

When you import a module, Python executes the module’s code and makes its contents available for use.

Why Use Modules?

Modules provide several benefits:

1. Code Organization: Break large programs into manageable pieces
2. Reusability: Write code once and use it in multiple programs
3. Namespace Management: Avoid naming conflicts by organizing code into separate namespaces
4. Maintainability: Easier to maintain and update code when it’s organized into modules

Creating a Module

To create a module, simply create a Python file with a .py extension:

1
# math_utils.py - A simple module
2

3
def add(a, b):
4
    """Add two numbers."""
5
    return a + b
6

7
def multiply(a, b):
8
    """Multiply two numbers."""
9
    return a * b
10

11
def power(base, exponent):
12
    """Raise base to the power of exponent."""
13
    return base ** exponent
14

15
PI = 3.14159
16
E = 2.71828

This file (math_utils.py) is now a module that can be imported into other Python programs.

Built-in Modules

Python comes with a large standard library of built-in modules. Some commonly used ones include:

• math - Mathematical functions
• random - Random number generation
• datetime - Date and time operations
• os - Operating system interface
• sys - System-specific parameters
• json - JSON encoder and decoder
• re - Regular expressions
• collections - Specialized container datatypes

1
import math
2
import random
3
import datetime
4

5
# Using math module
6
print(math.pi)           # 3.141592653589793
7
print(math.sqrt(16))     # 4.0
8
print(math.factorial(5)) # 120
9

10
# Using random module
11
print(random.randint(1, 10))  # Random integer between 1 and 10
12
print(random.choice(['a', 'b', 'c']))  # Random choice from list
13

14
# Using datetime module
15
now = datetime.datetime.now()
16
print(now)  # Current date and time

Module Search Path

When you import a module, Python searches for it in the following order:

1. Current directory - The directory containing the script
2. PYTHONPATH - Directories listed in the PYTHONPATH environment variable
3. Standard library - Built-in modules
4. Site-packages - Third-party packages installation directory

You can view the search path using sys.path:

1
import sys
2

3
for path in sys.path:
4
    print(path)

Module Attributes

Every module has special attributes that provide information about it:

1
import math
2

3
print(math.__name__)      # 'math' - Module name
4
print(math.__file__)      # Path to module file
5
print(dir(math))          # List of names in module

1
# my_module.py
2
def greet():
3
    print("Hello from my_module!")
4

5
if __name__ == '__main__':
6
    print("Running as main program")
7
    greet()
8
else:
9
    print("Imported as a module")

Module Documentation

You can document your module using a docstring at the top of the file:

1
"""
2
Math Utilities Module
3

4
This module provides basic mathematical operations
5
including addition, multiplication, and power functions.
6
"""
7

8
def add(a, b):
9
    """Add two numbers."""
10
    return a + b
11

12
def multiply(a, b):
13
    """Multiply two numbers."""
14
    return a * b

Organizing Code in Modules

1
"""
2
Calculator Module
3

4
Provides basic arithmetic operations.
5
"""
6

7
def add(a, b):
8
    """Add two numbers."""
9
    return a + b
10

11
def subtract(a, b):
12
    """Subtract b from a."""
13
    return a - b
14

15
def multiply(a, b):
16
    """Multiply two numbers."""
17
    return a * b
18

19
def divide(a, b):
20
    """Divide a by b."""
21
    if b == 0:
22
        raise ValueError("Cannot divide by zero")
23
    return a / b
24

25
def power(a, b):
26
    """Raise a to the power of b."""
27
    return a ** b

Module Execution

When Python imports a module, it executes all the code in the module file. This means:

• Function and class definitions are executed
• Module-level code runs immediately
• Variables are initialized

1
# example_module.py
2
print("Module is being imported!")
3

4
def my_function():
5
    print("Function called")
6

7
# This runs when module is imported
8
my_variable = "Initialized"
9

10
# This also runs
11
print(f"Variable value: {my_variable}")

When you import this module, you’ll see the print statements execute.

Reloading Modules

By default, Python imports a module only once. If you modify a module, you need to reload it. Use importlib.reload():

1
import importlib
2
import my_module
3

4
# Modify my_module.py, then reload
5
importlib.reload(my_module)

Note

In most cases, you should restart your Python interpreter instead of reloading modules. Reloading is mainly useful during development.

Best Practices

1. Use descriptive names: Module names should be clear and descriptive
2. Keep modules focused: Each module should have a single, well-defined purpose
3. Document your modules: Include docstrings explaining what the module does
4. Avoid circular imports: Don’t create modules that import each other
5. Use if __name__ == '__main__': For code that should only run when executed directly

Exercises

1
import math
2

3
print(math.sqrt(16))
4
print(math.pi)
5
print(math.factorial(5))

1
import random
2

3
for i in range(5):
4
    print(random.randint(1, 100))

1
import math
2

3
print(math.__name__)
4
names = dir(math)
5
print(names[:5])