#07 - Pythonic Code & Standard Library

Writing Pythonic Code & Type Hints 🐍

Writing "Pythonic" code means prioritizing readability and simplicity, following PEP 8 (Python's official style guide), and documenting intentions cleanly.

Type Hints & Modern Typing

Type hints make your code predictable. They don't enforce types at runtime, but they allow IDEs and checkers (like mypy) to catch data bugs before your code even runs.

• Optional[T] / T | None: Indicates a value can either be of type T or None.
• Union[A, B] / A | B: Indicates a value can be type A or type B.
• Literal[...]: Restricts a variable to specific, exact values.
• TypedDict: Defines a dictionary with a fixed set of string keys and specific value types.
• Callable[[Args], Return]: Declares that a parameter expects an executable function.

from typing import TypedDict, Literal, Callable

# 1. Defining structural dictionaries with TypedDict
class UserSession(TypedDict):
    username: str
    role: Literal["admin", "moderator", "guest"]  # Restricts values to these strings
    session_id: int | None  # Modern Union/Optional shorthand

# 2. Using Callable and Type Hints in functions
def execute_transaction(user: UserSession, callback: Callable[[str], bool]) -> str:
    """Processes a user session and triggers a callback verification hook.

    Args:
        user: A UserSession TypedDict configuration map.
        callback: A function taking a string and returning a boolean status.
    """
    if user["session_id"] is None:
        return "Transaction Aborted: Invalid Session."
    success = callback(user["username"])
    return "Complete" if success else "Failed"

Standard Library Powerhouses 🧰

Python comes with built-in modules designed to eliminate boilerplate code. Let's look at three essential modules: collections, itertools, and functools.

A. The collections Module

Optimized container data types that go far beyond standard lists and dictionaries.

from collections import Counter, defaultdict, deque

# Quick Counter usage
item_counts = Counter(["apple", "banana", "apple", "orange", "banana", "apple"])
print(item_counts.most_common(1))  # Output: [('apple', 3)]

# Rolling logs with deque
recent_actions = deque(maxlen=3)
for action in ["login", "view_page", "click_cart", "checkout"]:
    recent_actions.append(action)
print(recent_actions)  # Output: deque(['view_page', 'click_cart', 'checkout'], maxlen=3)

B. The itertools Module

A toolkit of memory-efficient streaming iterators for handling complex loop structures.

• chain: Glues multiple iterables together into a single continuous stream.
• combinations / permutations: Generates mathematical arrangements without nested loops.
• groupby: Groups contiguous elements in a dataset sharing a common key (Note: Data must be sorted by the grouping key first!).

import itertools

# Chaining multiple lists cleanly
combined = list(itertools.chain([1, 2], [3, 4], [5]))
# Output: [1, 2, 3, 4, 5]

# Unique pairs combinations
pairs = list(itertools.combinations(["A", "B", "C"], 2))
print(pairs)  # Output: [('A', 'B'), ('A', 'C'), ('B', 'C')]

# Grouping sorted elements
data = [("Admin", "Alice"), ("Admin", "Bob"), ("Dev", "Charlie")]
for role, group in itertools.groupby(data, key=lambda x: x[0]):
    print(f"{role}: {list(group)}")

C. The functools Module

Higher-order tools designed to modify or optimize how functions execute.

• partial: Freezes a subset of a function's arguments to create a simpler version of it.
• reduce: Repeatedly applies a function to a sequence to boil it down to a single value.
• lru_cache: Adds memoization (caching function results based on inputs) to save time on heavy, repetitive computations.

from functools import partial, lru_cache

# 1. Freezing arguments with partial
def multiply(x, y):
    return x * y

double = partial(multiply, 2)
print(double(5))  # Output: 10

# 2. Caching heavy calculations with lru_cache
@lru_cache(maxsize=32)
def fibonacci(n: int) -> int:
    if n < 2:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

print(fibonacci(35))  # Runs instantly instead of taking minutes!

Core System Utilities (Time, Paths & Constants) 🌍

A. Dates & Time Zones (datetime)

Always prefer timezone-aware datetimes when storing information to avoid offsets across servers.

from datetime import datetime, timezone

# Create a timezone-aware UTC timestamp
utc_now = datetime.now(timezone.utc)
print(utc_now)  # Output: 2026-07-19 03:37:50.123456+00:00

# Formatting to readable string
print(utc_now.strftime("%Y-%m-%d %H:%M:%S %Z"))

B. Advanced File Automation (pathlib)

pathlib can easily scan directories using patterns like wildcards (*) and recursive matches (**/*).

from pathlib import Path

# Scan the current directory for all python files matching a pattern
workspace = Path(".")
for py_file in workspace.rglob("*.py"):
    print(f"Found python source module: {py_file.name} ({py_file.stat().st_size} bytes)")

C. Readable Enumerations (Enum)

Enums turn vague string flags into clear, immutable code constants.

from enum import Enum, auto

class OrderStatus(Enum):
    PENDING = auto()
    PROCESSING = auto()
    SHIPPED = auto()
    DELIVERED = auto()

current_status = OrderStatus.PENDING
if current_status == OrderStatus.PENDING:
    print("Order is awaiting processing.")

Modern Development Workflow Tools 🛠️

Professional developers rely on tools to keep their code formatting uniform and verify that updates don't break existing features.

A. Ruff (The Modern Standard Linter & Formatter)

Written in Rust, Ruff replaces legacy tools like Black, Flake8, and isort-and runs up to 100x faster.

• ruff check: Analyzes code for bugs, bad habits, and dead imports.
• ruff format: Auto-formats code files to perfectly match PEP 8 guidelines.

B. Basics of pytest

pytest is the go-to testing framework for Python. To write a test, create a file named test_*.py and write functions that start with test_. Use standard assert statements to check your code's behavior.

# calculator.py
def add(a: int, b: int) -> int:
    return a + b

# test_calculator.py
from calculator import add

def test_add_combines_integers():
    assert add(3, 4) == 7
    assert add(-1, 1) == 0

Run your test suite directly from your terminal:

pytest test_calculator.py

Practice Challenge: E-Commerce Metrics Engine 🏋️

Let's combine structural typing, collections, functools, Enum, pathlib, and pytest testing into a production-grade metrics engine.

Step 1: Initialize Your Workspace

uv init day_7_challenge && cd day_7_challenge
touch engine.py test_engine.py

Step 2: Implement the Main Business Logic

Open engine.py and write the processing engine:

# engine.py
from collections import Counter, defaultdict
from dataclasses import dataclass
from enum import Enum, auto
from functools import lru_cache
from typing import TypedDict

class Region(Enum):
    NORTH = auto()
    SOUTH = auto()
    EAST = auto()
    WEST = auto()

class RawOrderPayload(TypedDict):
    order_id: int
    item: str
    amount: float
    region: Region

@dataclass(frozen=True)
class AnalyticsReport:
    top_selling_item: str
    regional_spend: dict[Region, float]
    total_processed_orders: int

@lru_cache(maxsize=16)
def calculate_tax_rate(region: Region) -> float:
    """Simulates an intensive calculation to look up regional tax rates."""
    rates = {
        Region.NORTH: 0.05,
        Region.SOUTH: 0.07,
        Region.EAST: 0.06,
        Region.WEST: 0.08,
    }
    return rates[region]

def process_market_orders(orders: list[RawOrderPayload]) -> AnalyticsReport:
    if not orders:
        return AnalyticsReport(
            top_selling_item="None",
            regional_spend={},
            total_processed_orders=0,
        )

    item_counter = Counter()
    spend_map = defaultdict(float)

    for order in orders:
        item = order["item"]
        region = order["region"]
        base_amount = order["amount"]

        # Calculate gross cost including regional tax adjustments
        tax_multiplier = 1.0 + calculate_tax_rate(region)
        gross_cost = base_amount * tax_multiplier

        item_counter[item] += 1
        spend_map[region] += round(gross_cost, 2)

    top_item = item_counter.most_common(1)[0][0]

    return AnalyticsReport(
        top_selling_item=top_item,
        regional_spend=dict(spend_map),
        total_processed_orders=len(orders),
    )

Step 3: Write Your Test Suite

Open test_engine.py to write your test assertions:

# test_engine.py
from engine import process_market_orders, Region, RawOrderPayload

def test_empty_order_list_returns_clean_report():
    report = process_market_orders([])
    assert report.total_processed_orders == 0
    assert report.top_selling_item == "None"

def test_metrics_calculation_pipeline():
    sample_orders: list[RawOrderPayload] = [
        {"order_id": 101, "item": "Laptop", "amount": 1000.00, "region": Region.NORTH},
        {"order_id": 102, "item": "Mouse", "amount": 50.00, "region": Region.NORTH},
        {"order_id": 103, "item": "Laptop", "amount": 1000.00, "region": Region.WEST},
    ]

    report = process_market_orders(sample_orders)

    # Assertions checking correctness
    assert report.total_processed_orders == 3
    assert report.top_selling_item == "Laptop"
    # North costs: (1000 + 50) * 1.05 = 1102.50
    assert report.regional_spend[Region.NORTH] == 1102.50

Step 4: Validate Code Style and Run Tests

Run the standard tools in your terminal to ensure everything is formatted correctly and passing:

# 1. Run the linter to check code health
uv run ruff check engine.py

# 2. Automatically apply formatting fixes
uv run ruff format engine.py test_engine.py

# 3. Execute the tests
uv run pytest test_engine.py

Outputs will confirm that the code matches professional standard guidelines and passes the logic assertions perfectly! 🏁