Python Modules & Packages

# math_utils.py — a module
def add(a, b): return a + b
def subtract(a, b): return a - b
PI = 3.14159

# myproject/
# ├── __init__.py        # marks this as a package
# ├── main.py
# ├── utils/
# │   ├── __init__.py
# │   ├── string_helpers.py
# │   └── math_helpers.py
# └── models/
#     ├── __init__.py
#     └── user.py

# 1. Import the whole module
import math
print(math.sqrt(16))

# 2. Import with an alias
import math as m
print(m.pi)

# 3. Import specific names from a module
from math import sqrt, pi
print(sqrt(25))
print(pi)

# 4. Import everything (generally discouraged)
from math import *
print(sin(0))   # messy, pollutes namespace

# 5. Import a module with a shorter alias
import pandas as pd
import numpy as np

df = pd.DataFrame({"score": [88, 92, 79]})
print(df["score"].mean())
print(np.array([1, 2, 3]) * 2)

import sys
print(sys.path)   # List of directories Python searches

import sys, types, textwrap

# --- simulating myproject/utils/math_helpers.py and myproject/models/user.py ---
# (on your machine these already exist as separate files — no simulation needed)
for name in ["myproject", "myproject.utils", "myproject.models"]:
    pkg = types.ModuleType(name)
    pkg.__path__ = []
    sys.modules[name] = pkg

math_helpers = types.ModuleType("myproject.utils.math_helpers")
math_helpers.clamp = lambda n, low, high: max(low, min(n, high))
sys.modules["myproject.utils.math_helpers"] = math_helpers

user = types.ModuleType("myproject.models.user")
user.User = type("User", (), {"__repr__": lambda self: "<User>"})
sys.modules["myproject.models.user"] = user

# --- myproject/utils/string_helpers.py ---
string_helpers_src = """
from . import math_helpers        # import from same package
from ..models import user         # import from sibling package
from .math_helpers import clamp   # import specific name

print("clamp(15, 0, 10) ->", clamp(15, 0, 10))
print("imported ok:", math_helpers.__name__, "and", user.__name__)
"""

string_helpers = types.ModuleType("myproject.utils.string_helpers")
string_helpers.__package__ = "myproject.utils"
exec(compile(textwrap.dedent(string_helpers_src), "string_helpers.py", "exec"), string_helpers.__dict__)

# greetings.py
"""A simple module for greeting people."""

def hello(name: str) -> str:
    """Return a friendly greeting."""
    return f"Hello, {name}!"

def goodbye(name: str) -> str:
    return f"Goodbye, {name}!"

# This code runs only when the module is executed directly
if __name__ == "__main__":
    print(hello("World"))

# main.py
import sys, types, textwrap

# --- simulating greetings.py sitting next to main.py ---
# (on your machine this block isn't needed — the real file already exists)
_greetings_src = '''
def hello(name):
    return f"Hello, {name}!"

def goodbye(name):
    return f"Goodbye, {name}!"
'''
greetings = types.ModuleType("greetings")
sys.modules["greetings"] = greetings
exec(compile(textwrap.dedent(_greetings_src), "greetings.py", "exec"), greetings.__dict__)

import greetings
print(greetings.hello("Alice"))
print(greetings.goodbye("Bob"))

# analytics/
# ├── __init__.py
# ├── core/
# │   ├── __init__.py
# │   ├── stats.py
# │   └── utils.py
# ├── visualization/
# │   ├── __init__.py
# │   ├── charts.py
# │   └── tables.py
# └── data/
#     ├── __init__.py
#     └── loaders.py

import sys, types, textwrap

# --- simulating the analytics/ package living on disk ---
# (on your machine these already exist as real files — no simulation needed)
def install_package(name):
    pkg = types.ModuleType(name)
    pkg.__path__ = []
    sys.modules[name] = pkg
    return pkg

def install_module(fullname, source):
    package = fullname.rpartition(".")[0]
    if package and package not in sys.modules:
        install_package(package)
    mod = types.ModuleType(fullname)
    mod.__package__ = package
    sys.modules[fullname] = mod
    exec(compile(textwrap.dedent(source), fullname + ".py", "exec"), mod.__dict__)
    return mod

install_package("analytics")
install_module("analytics.core.stats", '''
def mean(values):
    return sum(values) / len(values)

def median(values):
    s = sorted(values)
    mid = len(s) // 2
    return s[mid] if len(s) % 2 else (s[mid - 1] + s[mid]) / 2
''')
install_module("analytics.visualization.charts", '''
def bar_chart(values):
    return "".join("#" * v + "\\n" for v in values)
''')
install_module("analytics.data.loaders", '''
def load_csv(text):
    return [line.split(",") for line in text.strip().splitlines()]
''')

from analytics.core.stats import mean, median
from analytics.visualization.charts import bar_chart
from analytics.data.loaders import load_csv

print("mean:", mean([1, 2, 3, 4, 5]))
print("median:", median([1, 2, 3, 4, 5]))
print(bar_chart([2, 4, 1]))
print("first row:", load_csv("a,b,c\n1,2,3")[0])

# analytics/__init__.py
"""
Analytics package — data analysis and visualisation tools.
"""

from .core.stats import mean, median, standard_deviation
from .visualization.charts import bar_chart, line_chart
from .data.loaders import load_csv, load_json

__all__ = ["mean", "median", "standard_deviation",
           "bar_chart", "line_chart", "load_csv", "load_json"]

import sys, types, textwrap

# --- simulating the whole analytics/ package, including its __init__.py ---
# (on your machine this already exists as real files — no simulation needed)
def install_package(name):
    pkg = types.ModuleType(name)
    pkg.__path__ = []
    sys.modules[name] = pkg
    return pkg

def install_module(fullname, source):
    package = fullname.rpartition(".")[0]
    if package and package not in sys.modules:
        install_package(package)
    mod = sys.modules.get(fullname)
    if mod is None:
        mod = types.ModuleType(fullname)
        sys.modules[fullname] = mod
    # a package's own __init__.py resolves "." against itself, not its parent
    mod.__package__ = fullname if hasattr(mod, "__path__") else package
    exec(compile(textwrap.dedent(source), fullname + ".py", "exec"), mod.__dict__)
    return mod

install_package("analytics")
install_module("analytics.core.stats", '''
def mean(values):
    return sum(values) / len(values)

def median(values):
    s = sorted(values)
    mid = len(s) // 2
    return s[mid] if len(s) % 2 else (s[mid - 1] + s[mid]) / 2

def standard_deviation(values):
    m = mean(values)
    return (sum((x - m) ** 2 for x in values) / len(values)) ** 0.5
''')
install_module("analytics.visualization.charts", '''
def bar_chart(values):
    return "".join("#" * v + "\\n" for v in values)

def line_chart(values):
    return " -> ".join(str(v) for v in values)
''')
install_module("analytics.data.loaders", '''
def load_csv(text):
    return [line.split(",") for line in text.strip().splitlines()]

def load_json(text):
    import json
    return json.loads(text)
''')
install_module("analytics", '''
from .core.stats import mean, median, standard_deviation
from .visualization.charts import bar_chart, line_chart
from .data.loaders import load_csv, load_json

__all__ = ["mean", "median", "standard_deviation",
           "bar_chart", "line_chart", "load_csv", "load_json"]
''')

import analytics
print(analytics.mean([1,2,3,4,5]))   # clean and explicit

# mymodule.py
import sys, types, textwrap

# --- simulating mymodule.py existing as its own file ---
# (on your machine this block isn't needed — just save the file below)
_mymodule_src = '''
def public_func():
    return "I am public!"

def _private_func():          # convention: underscore means private
    return "I am private!"

__all__ = ["public_func"]     # only public_func is exported
'''
mymodule = types.ModuleType("mymodule")
sys.modules["mymodule"] = mymodule
exec(compile(textwrap.dedent(_mymodule_src), "mymodule.py", "exec"), mymodule.__dict__)

# In another file
from mymodule import *   # only public_func is imported

print(public_func())
try:
    print(_private_func())
except NameError:
    print("_private_func was not imported — exactly as expected!")

# Create a virtual environment (Python 3.3+)
python -m venv .venv

# Activate it
# On macOS/Linux:
source .venv/bin/activate

# On Windows:
.venv\Scripts\activate

# Once activated, your prompt changes to show (.venv)
# Now install packages — they go into this environment only
pip install requests pandas flask

# Generate a requirements file
pip freeze > requirements.txt

# Install from a requirements file
pip install -r requirements.txt

requests==2.31.0
pandas==2.1.4
flask==3.0.0

# In your project root (with setup.py or pyproject.toml)
pip install -e .

# Now you can import your package from anywhere
import mypackage