Python Modules

Learning Objectives

By the end of this lesson, you will understand how Python modules work and how they help developers organize larger applications.

What Is a Module?

A module is simply a Python file containing code that can be reused by another Python program.

A Python module normally has a .py extension.

Example

Imagine you create a file called calculator.py:

def add(a, b):
    return a + b


def subtract(a, b):
    return a - b

This file is now a module that contains reusable functions.

Why Modules Matter

Modules become extremely important as Python programs grow. A small program may fit comfortably inside one file, but large applications can contain thousands of lines of code.

Modules help developers:

• Organize code logically.
• Reuse functions and classes.
• Reduce duplicate code.
• Make programs easier to maintain.
• Separate different responsibilities.
• Work on different parts of a project independently.

shop/
├── main.py
├── products.py
├── customers.py
├── payments.py
└── reports.py

Each file can handle a specific responsibility rather than placing everything inside main.py.

Creating Your Own Module

Creating a module is very simple: create a normal Python file and place reusable code inside it.

For example, create:

calculator.py

Then add:

def add(a, b):
    return a + b


def multiply(a, b):
    return a * b


tax_rate = 0.15

The functions and variable can now be imported by another Python file.

Importing a Module

Use the import statement to import a module.

import calculator

result = calculator.add(10, 5)

print(result)

15

Python loads the calculator module and makes its members available through the module name.

Accessing Module Members

After importing a module, use dot notation to access its functions, variables, or classes.

import calculator

print(calculator.add(10, 20))
print(calculator.multiply(4, 5))
print(calculator.tax_rate)

30
20
0.15

The dot tells Python that you want something belonging to the imported module.

from ... import

Instead of importing the entire module name, you can import specific members directly.

from calculator import add

result = add(10, 5)

print(result)

15

Importing Multiple Members

You can import several members from the same module.

from calculator import add, multiply

print(add(2, 3))
print(multiply(4, 5))

5
20

Import Aliases with as

An alias gives an imported module a shorter or more convenient name.

import calculator as calc

print(calc.add(10, 20))

Python developers frequently use aliases for modules with long names or commonly recognized short names.

import math as m
import datetime as dt

Built-in Python Modules

Python comes with a large standard library containing modules that provide ready-to-use functionality.

Some useful modules include:

• math — mathematical functions
• random — random values and selections
• datetime — dates and times
• os — operating-system interaction
• sys — Python runtime information
• json — JSON data handling
• csv — CSV file handling
• statistics — statistical calculations

The math Module

The math module provides many mathematical functions and constants.

import math

print(math.sqrt(25))
print(math.ceil(4.2))
print(math.floor(4.9))
print(math.pi)

5.0
5
4
3.141592653589793

Useful math functions

• math.sqrt()
• math.ceil()
• math.floor()
• math.pow()
• math.factorial()
• math.pi

The random Module

The random module provides tools for generating pseudo-random values and making random selections.

import random

number = random.randint(1, 10)

print(number)

The exact number will vary each time the program runs.

Random choice

import random

colors = ["red", "blue", "green", "yellow"]

selected = random.choice(colors)

print(selected)

The datetime Module

The datetime module provides classes for working with dates and times.

from datetime import datetime

now = datetime.now()

print(now)

You can also format a date into a readable string.

from datetime import datetime

now = datetime.now()

formatted = now.strftime("%Y-%m-%d")

print(formatted)

2026-09-12

The actual date depends on when the program is executed.

The os Module

The os module allows Python programs to interact with parts of the operating system.

Current working directory

import os

print(os.getcwd())

Listing files

import os

files = os.listdir()

print(files)

The exact output depends on the files and folders in the current directory.

The sys Module

The sys module provides access to information and functionality related to the Python interpreter.

Python version

import sys

print(sys.version)

This displays information about the Python version being used to execute the program.

Custom Modules Across Files

One of the most useful applications of modules is splitting a program into multiple files.

Step 1 — Create a module

def calculate_subtotal(price, quantity):
    return price * quantity


def calculate_discount(amount, rate):
    return amount * rate


def calculate_final_total(amount, discount):
    return amount - discount

Step 2 — Import the module

import shop_utils

subtotal = shop_utils.calculate_subtotal(1000, 2)

discount = shop_utils.calculate_discount(
    subtotal,
    0.10
)

total = shop_utils.calculate_final_total(
    subtotal,
    discount
)

print("Subtotal:", subtotal)
print("Discount:", discount)
print("Final Total:", total)

Subtotal: 2000
Discount: 200.0
Final Total: 1800.0

if __name__ == "__main__":

You will frequently see the following pattern in Python:

def greet():
    print("Hello from Python!")


if __name__ == "__main__":
    greet()

What does __name__ mean?

Every Python module has a special variable called __name__.

When a Python file is executed directly, __name__ becomes:

"__main__"

When the same file is imported as a module, __name__ contains the module's name instead.

Example

def add(a, b):
    return a + b


if __name__ == "__main__":
    print(add(10, 5))

If you run calculator.py directly, it prints 15.

If another file imports calculator, the test print statement does not execute automatically.

Module Search Path and sys.path

When Python encounters an import statement, it needs to determine where the requested module is located.

Python searches locations listed in its module search path. This information can be inspected using sys.path.

import sys

print(sys.path)

The exact list depends on your Python installation and environment.

Common Import Errors

Import problems are common when you are first working with multiple Python files.

ModuleNotFoundError

import unknown_module

If Python cannot locate the module, it may raise:

ModuleNotFoundError

ImportError

An ImportError can occur when Python finds the module but cannot import the requested item.

from calculator import divide

If calculator.py does not contain divide, the import will fail.

Practical Real-World Examples

Modules are not just a theoretical concept. They are used constantly in professional Python development.

Example 1 — E-commerce Application

ecommerce/
├── main.py
├── products.py
├── customers.py
├── cart.py
├── payments.py
└── reports.py

Each module handles a different responsibility.

Example 2 — Data Analysis Project

analytics/
├── main.py
├── data_loader.py
├── cleaning.py
├── calculations.py
├── charts.py
└── reports.py

This makes the project easier to understand and maintain.

Example 3 — Reusable Utility Module

def clean_text(text):
    return text.strip().lower()


def word_count(text):
    return len(text.split())

Multiple programs can import and reuse these utilities.

Common Mistakes

Practice Exercises

Try these exercises yourself before looking for a solution.

Mini Challenge — Shop Utility Module

Build a small reusable module for an e-commerce application.

Requirements

1. Create a function that calculates subtotal.
2. Create a function that calculates discount.
3. Create a function that calculates tax.
4. Create a function that calculates final total.
5. Import those functions into main.py.
6. Display a professional-looking order summary.

Suggested structure

shop_project/
├── main.py
└── shop_utils.py

Example data

price = 2500
quantity = 3
discount_rate = 0.10
tax_rate = 0.15

Your program should calculate the subtotal, discount, tax, and final amount using functions imported from shop_utils.py.

Quick Knowledge Check

Test your understanding of Python modules.

Lesson Summary

Modules allow Python developers to organize and reuse code across multiple files.

You are now ready to move from individual Python files into the next level of organization: packages.