Python Modules and Packages: The Complete Beginner's Guide

import math
print(math.sqrt(16))

from math import sqrt, pi
print(sqrt(25), pi)

import datetime as dt
print(dt.date.today())

from math import *   # avoid

import math
print(math.pi, math.sqrt(144), math.factorial(6))

import random
random.seed(42)
print(random.randint(1, 100))

from datetime import datetime, timedelta
now = datetime.now()
print(now + timedelta(days=1))

import os
print(os.getcwd())
print(os.path.join("data", "output.csv"))

import sys
print(sys.version)
print(sys.path)

import json
data = {"name": "Alice", "age": 25}
raw = json.dumps(data, indent=2)
print(json.loads(raw)["name"])

from collections import Counter, defaultdict, deque
print(Counter(["python", "python", "java"]))

PI = 3.14159265358979

def circle_area(radius):
    return PI * radius ** 2

import mathutils
print(mathutils.circle_area(5))

import sys
print(sys.path)

def circle_area(radius):
    return 3.14159 * radius ** 2

if __name__ == "__main__":
    print(circle_area(5))

# schoolabe/__init__.py
from .math_tools import add
__version__ = "1.0.0"

pip install requests
pip freeze > requirements.txt
pip install -r requirements.txt

python -m venv venv
source venv/bin/activate
pip install requests
deactivate

import math
import json
import random
from datetime import datetime, timedelta
from collections import Counter, defaultdict

random.seed(42)

def generate_sales_data(n=20):
    products = ["Python", "Kafka", "DSA", "JS"]
    records = []
    start = datetime(2026, 1, 1)
    for i in range(n):
        records.append({
            "id": f"TXN{i+1:04d}",
            "date": (start + timedelta(days=random.randint(0, 60))).strftime("%Y-%m-%d"),
            "product": random.choice(products),
            "amount": round(random.uniform(30, 300), 2),
        })
    return records

def report(records):
    amounts = [r["amount"] for r in records]
    totals = defaultdict(float)
    for r in records:
        totals[r["product"]] += r["amount"]
    return {
        "generated_at": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
        "count": len(records),
        "total": round(sum(amounts), 2),
        "mean": round(sum(amounts) / len(amounts), 2),
        "std_dev": round(math.sqrt(sum((x - (sum(amounts)/len(amounts)))**2 for x in amounts)/len(amounts)), 2),
        "top_products": Counter(r["product"] for r in records).most_common(3),
        "revenue_by_product": dict(sorted(totals.items(), key=lambda x: x[1], reverse=True)),
    }

# mylib/utils.py
__all__ = ['format_date', 'parse_date']   # Only these are "public"

def format_date(d): ...
def parse_date(s): ...
def _internal_helper(): ...   # Leading underscore = private convention

from collections import Counter, defaultdict, deque, namedtuple, OrderedDict

# Counter: count occurrences
words = "apple banana apple cherry banana apple".split()
freq = Counter(words)
print(freq)                   # Counter({'apple': 3, 'banana': 2, 'cherry': 1})
print(freq.most_common(2))    # [('apple', 3), ('banana', 2)]
freq.update(['apple', 'date'])

# defaultdict: auto-initialize missing keys
from collections import defaultdict
graph = defaultdict(list)
graph['A'].append('B')    # No KeyError — creates [] automatically
graph['A'].append('C')

# deque: O(1) append/pop from both ends
from collections import deque
queue = deque(['a', 'b', 'c'], maxlen=5)
queue.appendleft('z')     # O(1) — unlike list insert at 0
queue.append('d')
queue.rotate(1)            # Rotate right by 1

# namedtuple: lightweight record type
Point = namedtuple('Point', ['x', 'y'])
p = Point(3, 4)
print(p.x, p.y)           # 3 4
print(p._asdict())         # {'x': 3, 'y': 4}

import itertools

# Infinite iterators
for i in itertools.count(10, 2):   # 10, 12, 14, ...
    if i > 20: break

# Combinatorics
list(itertools.combinations('ABC', 2))    # [('A','B'), ('A','C'), ('B','C')]
list(itertools.permutations('ABC', 2))    # All 2-permutations
list(itertools.product([0,1], repeat=3))  # All 3-bit binary strings

# Chaining and grouping
list(itertools.chain([1,2], [3,4], [5]))  # [1, 2, 3, 4, 5]

for key, group in itertools.groupby("AAABBBCCAA"):
    print(key, list(group))   # A [A,A,A], B [B,B,B], C [C,C], A [A,A]

# accumulate — running totals
list(itertools.accumulate([1,2,3,4,5]))           # [1, 3, 6, 10, 15]
list(itertools.accumulate([1,2,3,4,5], max))      # [1, 2, 3, 4, 5]

import functools

# lru_cache — memoize function results
@functools.lru_cache(maxsize=128)
def fibonacci(n):
    if n < 2: return n
    return fibonacci(n-1) + fibonacci(n-2)

fibonacci(100)  # Instant with caching

# partial — pre-fill arguments
from functools import partial
double = partial(pow, exp=2)
triple_add = partial(lambda a, b, c: a+b+c, c=0)  # Fix last arg

# reduce — fold a sequence
product = functools.reduce(lambda a, b: a * b, [1, 2, 3, 4, 5])  # 120

from pathlib import Path

# All path operations are object methods — no string concatenation
home = Path.home()
project = home / 'projects' / 'myapp'     # / operator joins paths!

config = project / 'config.json'
print(config.exists())                     # True/False
print(config.stem)                         # 'config'
print(config.suffix)                       # '.json'
print(config.parent)                       # ~/projects/myapp

# Glob patterns
for py_file in project.glob('**/*.py'):    # Recursive
    print(py_file.name)

# Read/write
config.write_text('{"debug": true}')
data = config.read_text()

# myapp/utils/validators.py
from ..models import User          # Two levels up, then into models
from .helpers import format_email  # Same package (utils)
from myapp.config import SETTINGS  # Absolute import — also fine

from datetime import datetime, date, timedelta, timezone

# Current time
now = datetime.now()                           # Local time (no timezone info)
utc_now = datetime.now(tz=timezone.utc)       # UTC with timezone info

# Creating dates
birthday = date(1995, 6, 15)
meeting = datetime(2026, 7, 1, 14, 30, 0)

# Arithmetic
tomorrow = date.today() + timedelta(days=1)
two_weeks = now + timedelta(weeks=2)
diff = datetime(2026, 12, 31) - now            # timedelta object
print(f"{diff.days} days until year end")

# Formatting and parsing
formatted = now.strftime("%Y-%m-%d %H:%M:%S")  # "2026-06-22 10:30:00"
parsed = datetime.strptime("22/06/2026", "%d/%m/%Y")

# ISO format (recommended for APIs/files)
iso = now.isoformat()                          # "2026-06-22T10:30:00"
back = datetime.fromisoformat(iso)

import json
from datetime import datetime

# Custom encoder for types json doesn't know about
class AppEncoder(json.JSONEncoder):
    def default(self, obj):
        if isinstance(obj, datetime):
            return obj.isoformat()
        if isinstance(obj, set):
            return sorted(obj)  # Sets → sorted lists
        if hasattr(obj, '__dict__'):
            return obj.__dict__  # Simple objects → dict
        return super().default(obj)

data = {"created": datetime.now(), "tags": {"python", "web"}}
serialized = json.dumps(data, cls=AppEncoder, indent=2)

# Read/write files safely
def load_json(path, default=None):
    try:
        with open(path, encoding='utf-8') as f:
            return json.load(f)
    except (FileNotFoundError, json.JSONDecodeError):
        return default

def save_json(path, data, indent=2):
    with open(path, 'w', encoding='utf-8') as f:
        json.dump(data, f, cls=AppEncoder, indent=indent, ensure_ascii=False)

import os, sys

# Environment variables
db_url = os.environ.get('DATABASE_URL', 'sqlite:///local.db')
debug = os.getenv('DEBUG', 'false').lower() == 'true'

# Process info
pid = os.getpid()
cwd = os.getcwd()

# sys — interpreter info
print(sys.version)        # Python version string
print(sys.platform)       # 'linux', 'darwin', 'win32'
print(sys.argv)           # Command-line arguments: [script_name, arg1, arg2, ...]

# sys.path manipulation (use sparingly)
sys.path.insert(0, '/path/to/custom/lib')  # Add at front for priority

# Exit with status code
if not os.path.exists('required_config.json'):
    print("ERROR: required_config.json missing", file=sys.stderr)
    sys.exit(1)  # Non-zero = failure

my_library/
├── pyproject.toml        ← Modern package config (replaces setup.py)
├── README.md
├── src/
│   └── my_library/
│       ├── __init__.py   ← Public API
│       ├── core.py
│       ├── utils.py
│       └── _internal.py  ← Private (underscore prefix)
└── tests/
    └── test_core.py

# pyproject.toml (minimal)
[build-system]
requires = ["setuptools>=68", "wheel"]
build-backend = "setuptools.backends.legacy:build"

[project]
name = "my-library"
version = "1.0.0"
description = "A short description"
requires-python = ">=3.10"
dependencies = ["requests>=2.28"]

[project.optional-dependencies]
dev = ["pytest", "black", "mypy"]

# src/my_library/__init__.py
"""Expose only the public API."""
from .core import MyClass, important_function
from .utils import helper

__all__ = ['MyClass', 'important_function', 'helper']
__version__ = '1.0.0'

# Install locally in editable mode for development
pip install -e ".[dev]"

# Build distribution
pip install build
python -m build  # Creates dist/*.whl and dist/*.tar.gz

# Publish to PyPI
pip install twine
twine upload dist/*