Modules and Packages

Reviewed & published by Brayan K

Organize your code, reuse functionality, and explore Python's powerful built-in libraries.

Part of the free Python course at LearnCodingFast — hands-on lessons with examples you run in your browser, plus practice exercises and a quick quiz.

What You'll Learn in This Lesson

• What modules are and how they keep code organized
• All 4 ways to import: import x, from x import y, as alias, *
• The math module: sqrt, ceil, floor, pow, pi
• The random module: random numbers, choices, shuffle
• The datetime module: dates, times, formatting
• How to install external packages with pip

What Are Modules?

A module is simply a Python file (.py) that contains code you can reuse. Instead of writing everything in one file, you split your code into organized pieces.

Why Use Modules?

Importing Modules

Use the import keyword to use a module:

# Different ways to import
import math
print("Using import math:")
print(f"  math.sqrt(25) = {math.sqrt(25)}")
print(f"  math.pi = {math.pi:.4f}")

from math import sqrt, ceil
print("\nUsing from math import sqrt, ceil:")
print(f"  sqrt(49) = {sqrt(49)}")
print(f"  ceil(4.2) = {ceil(4.2)}")

import datetime as dt
print("\nUsing import datetime as dt:")
print(f"  1 January 2026 was a {dt.date(2026, 1, 1):%A}")

# ✅ Expected output:
# Using import math:
#   math.sqrt(25) = 5.0
#   math.pi = 3.1416
#
# Using from math import sqrt, ceil:
#   sqrt(49) = 7.0
#   ceil(4.2) = 5
#
# Using import datetime as dt:
#   1 January 2026 was a Thursday

Worked Example: The Import Styles Side by Side

Here is one small program that uses three of those import styles at once. Read it line by line — every line says what it prints and why that style was chosen. Then run it and check your reading against the real output.

import math                     # Style 1: the whole module. You keep the "math." prefix.
from math import sqrt, floor    # Style 2: copy just two names into THIS file.
import statistics as stats      # Style 3: same module, shorter local name (an alias).

readings = [4.0, 9.0, 16.0, 25.0]

# Style 1 — the prefix tells a reader exactly where hypot() came from.
print("hypot(3, 4) =", math.hypot(3, 4))       # 5.0  (the long side of a 3-4-5 triangle)

# Style 2 — no prefix needed, because sqrt now lives in your own namespace.
# "Namespace" just means the set of names your file can see.
roots = [sqrt(r) for r in readings]
print("roots       =", roots)                  # [2.0, 3.0, 4.0, 5.0]

# floor() cuts a decimal DOWN to the nearest whole number - it never rounds up.
print("floor(3.9)  =", floor(3.9))             # 3

# Style 3 — the alias 'stats' IS the statistics module from here on.
print("mean        =", stats.mean(readings))   # 13.5

# A module is just an object holding names. dir() lists them, which is handy
# when you half-remember a function name.
print("has sqrt?   =", "sqrt" in dir(math))    # True

# ✅ Expected output:
# hypot(3, 4) = 5.0
# roots       = [2.0, 3.0, 4.0, 5.0]
# floor(3.9)  = 3
# mean        = 13.5
# has sqrt?   = True

🎯 Your Turn: Write the Import Lines

The body of this program is already written. Only the three import lines are missing — one of each style. Fill in each ___, run it, and check it against the expected output in the comment at the bottom.

# 🎯 YOUR TURN — replace each ___ so the program runs.

___ math                        # 👉 import the WHOLE math module (style 1)
from random import ___, seed    # 👉 you need randint below; seed is already listed for you
import datetime as ___          # 👉 give datetime the short alias dt (style 3)

seed(7)   # Fixes the random number generator so everyone gets the SAME roll.

roll = randint(1, 6)                    # a whole number from 1 to 6, both included
print("dice roll:", roll)

print("circle area (r=3):", round(math.pi * 3 ** 2, 2))   # pi x radius squared

print("1 Jan 2026 is a", dt.date(2026, 1, 1).strftime("%A"))   # %A = weekday name

# ✅ Expected output:
# dice roll: 3
# circle area (r=3): 28.27
# 1 Jan 2026 is a Thursday

The math Module

Python's built-in math module provides mathematical functions:

import math

print("=== Math Module ===")
print(f"Square root of 64: {math.sqrt(64)}")
print(f"2 to the power of 10: {math.pow(2, 10)}")
print(f"Ceiling of 3.2: {math.ceil(3.2)}")
print(f"Floor of 3.8: {math.floor(3.8)}")
print(f"Pi: {math.pi:.6f}")
print(f"Factorial of 5: {math.factorial(5)}")

# ✅ Expected output:
# === Math Module ===
# Square root of 64: 8.0
# 2 to the power of 10: 1024.0
# Ceiling of 3.2: 4
# Floor of 3.8: 3
# Pi: 3.141593
# Factorial of 5: 120

The random Module

Generate random numbers for games, testing, or simulations:

import random

print("=== Random Module ===")
print(f"Random number 1-100: {random.randint(1, 100)}")
print(f"Random decimal: {random.random():.4f}")

colors = ["red", "blue", "green", "yellow"]
print(f"Random color: {random.choice(colors)}")

numbers = [1, 2, 3, 4, 5]
random.shuffle(numbers)
print(f"Shuffled: {numbers}")

print(f"Pick 2 colors: {random.sample(colors, 2)}")

The datetime Module

Work with dates and times:

from datetime import datetime, date, timedelta

# Current date and time
now = datetime.now()
print("=== Datetime Module ===")
print(f"Now: {now}")
print(f"Date only: {date.today()}")
print(f"Year: {now.year}, Month: {now.month}, Day: {now.day}")

# Formatting dates
print(f"\nFormatted: {now.strftime('%B %d, %Y')}")
print(f"Time: {now.strftime('%H:%M:%S')}")

# Date math
tomorrow = date.today() + timedelta(days=1)
next_week = date.today() + timedelta(weeks=1)
print(f"\nTomorrow: {tomorrow}")
print(f"Next week: {next_week}")

The os Module

Interact with your computer's operating system:

import os

print("=== OS Module ===")
print(f"Current directory: {os.getcwd()}")
print(f"Operating system: {os.name}")

# Path operations (works on any OS)
path = os.path.join("folder", "subfolder", "file.txt")
print(f"\nJoined path: {path}")
print(f"File name: {os.path.basename(path)}")
print(f"Directory: {os.path.dirname(path)}")

# Check if path exists
print(f"\nCurrent dir exists: {os.path.exists('.')}")

The json Module

JSON (JavaScript Object Notation) is a universal format for storing and exchanging data. It's used by almost every API.

import json

# Python dictionary
user = {
    "name": "Alice",
    "age": 25,
    "is_student": True,
    "skills": ["Python", "JavaScript"]
}

# Convert to JSON string
json_string = json.dumps(user, indent=2)
print("=== Python to JSON ===")
print(json_string)

# Convert back to Python
parsed = json.loads(json_string)
print(f"\n=== Back to Python ===")
print(f"Name: {parsed['name']}")
print(f"Skills: {parsed['skills']}")

# ✅ Expected output:
# === Python to JSON ===
# {
#   "name": "Alice",
#   "age": 25,
#   "is_student": true,
#   "skills": [
#     "Python",
#     "JavaScript"
#   ]
# }
#
# === Back to Python ===
# Name: Alice
# Skills: ['Python', 'JavaScript']

Creating Your Own Module

Any Python file can be a module. Just save your code and import it:

Step 1: Create helpers.py

# helpers.py
def greet(name):
    return f"Hello, {name}!"

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

Step 2: Import in another file

# main.py
import helpers

print(helpers.greet("World"))
print(helpers.add(5, 3))

# Simulating a custom module

# This would be in my_helpers.py:
def greet(name):
    return f"Hello, {name}!"

def calculate_area(length, width):
    return length * width

PI = 3.14159

# Using the "module":
print(greet("Python Learner"))
print(f"Area: {calculate_area(5, 3)}")
print(f"PI value: {PI}")

# ✅ Expected output:
# Hello, Python Learner!
# Area: 15
# PI value: 3.14159

Understanding Packages

A package is a folder containing multiple modules. It must have an __init__.py file (can be empty).

my_package/
    __init__.py      ← Makes it a package
    greetings.py     ← Module 1
    math_utils.py    ← Module 2
    helpers.py       ← Module 3

from my_package import greetings
from my_package.math_utils import calculate
import my_package.helpers as h

Installing External Packages with pip

pip is Python's package manager. It downloads packages from PyPI (Python Package Index) — a library of over 400,000 packages!

Popular packages to try:

• • requests — make HTTP requests to APIs
• • flask — build web applications
• • pandas — data analysis
• • pygame — create games

Common Mistakes to Avoid

Practical Example: Password Generator

Use multiple modules to create a random password generator:

import random
import string

def generate_password(length=12):
    """Generate a secure random password."""
    # All possible characters
    characters = string.ascii_letters + string.digits + "!@#$%"
    
    # Generate password
    password = ''.join(random.choice(characters) for _ in range(length))
    return password

# Generate passwords of different lengths
print("=== Password Generator ===")
print(f"8 chars:  {generate_password(8)}")
print(f"12 chars: {generate_password(12)}")
print(f"16 chars: {generate_password(16)}")

Practical Example: Date Calculator

Calculate days between dates and future dates:

from datetime import datetime, date, timedelta

def days_until(target_date, today=None):
    """Days from today (or the day you pass in) until a target date."""
    today = today or date.today()
    target = datetime.strptime(target_date, "%Y-%m-%d").date()
    delta = target - today
    return delta.days

def add_days(start_date, days):
    """Add days to a date."""
    start = datetime.strptime(start_date, "%Y-%m-%d").date()
    result = start + timedelta(days=days)
    return result.strftime("%B %d, %Y")

# Examples. days_until() counts from the real today unless you pass a day,
# so pinning one here gives the same answer whenever you run it.
print("=== Date Calculator ===")
print(f"Days from 2026-01-01 until 2026-12-31: {days_until('2026-12-31', date(2026, 1, 1))}")
print(f"30 days from 2025-01-01: {add_days('2025-01-01', 30)}")

# ✅ Expected output:
# === Date Calculator ===
# Days from 2026-01-01 until 2026-12-31: 364
# 30 days from 2025-01-01: January 31, 2025

Practical Example: Data Analyzer

Use json and math to analyze data:

import json
import math

# Sample data (could come from a file or API)
data_json = '''
{
    "students": [
        {"name": "Alice", "score": 85},
        {"name": "Bob", "score": 92},
        {"name": "Charlie", "score": 78},
        {"name": "Diana", "score": 95}
    ]
}
'''

# Parse JSON
data = json.loads(data_json)
scores = [s["score"] for s in data["students"]]

# Calculate statistics
average = sum(scores) / len(scores)
highest = max(scores)
lowest = min(scores)

print("=== Student Score Analysis ===")
print(f"Students: {len(scores)}")
print(f"Average: {average:.1f}")
print(f"Highest: {highest}")
print(f"Lowest: {lowest}")
print(f"Range: {highest - lowest}")

# ✅ Expected output:
# === Student Score Analysis ===
# Students: 4
# Average: 87.5
# Highest: 95
# Lowest: 78
# Range: 17

🎯 Mini-Challenge: Build Your Own Mini-Module

Time to write one with no code pre-filled. Treat the block below as a file called temps.py — a tiny module of temperature helpers that another program could import. Only the brief is given; the code is yours.

# 🎯 MINI-CHALLENGE: temps.py — your own mini-module
#
# 1. Import the statistics module (whole module, keep the prefix).
# 2. Create a constant list:
#        READINGS = [12.5, 18.0, 21.5, 9.0, 15.0]      # degrees Celsius
# 3. Write to_fahrenheit(c) that returns  c * 9 / 5 + 32
# 4. Write summary(readings) that returns a dictionary with three keys:
#        "count"  -> how many readings there are
#        "mean_c" -> statistics.mean of the readings, rounded to 1 decimal place
#        "max_f"  -> the HIGHEST reading converted to Fahrenheit, rounded to 1 dp
# 5. Print summary(READINGS)
#
# ✅ Expected output:
# {'count': 5, 'mean_c': 15.2, 'max_f': 70.7}

# your code here

Summary: Quick Reference

Key Built-in Modules:

• • math — mathematical functions
• • random — random number generation
• • datetime — dates and times
• • os — operating system interaction
• • json — JSON data handling
• • string — string constants and utilities

Wrapping Up

You now know how to organize your code into reusable modules, use Python's powerful standard library, and install external packages. This is how professional developers work!

🏅 Intermediate Track Complete! You now code like a real developer!

Functions, Lists, Dictionaries, File Handling, Exceptions, Modules — you've completed all 11 beginner and intermediate lessons. You now have the full Python toolkit that powers real applications.

Practice quiz

Continue this course

• Previous: Exception Handling
• Next: Object-Oriented Programming — Model real-world concepts using classes, objects, and methods
• Quick reference: Python cheat sheet › Standard Library