Python 3.15: 7 Game-Changing Features to Try Now (Lazy Imports, frozendict, Sentinel)

The article introduces Python 3.15's notable changes, emphasizing practical impact over feature count. It recommends using uv to create an isolated test environment before experimenting.

01 Isolate Experimental Environment

Use uv to create a disposable environment, pin Python 3.15, and add development dependencies. This prevents contaminating existing projects and ensures clarity about which interpreter runs tests.

uv init python315 --no-package
cd python315
uv python install 3.15
uv python pin 3.15
uv run python --version
uv add --dev ruff

Declare the required Python version in pyproject.toml:

[project]
requires-python = ">=3.15"

Note that third-party dependencies may not yet be fully compatible.

02 Lazy Import

New lazy import syntax defers module loading until first use while keeping imports at the top level.

import sys

lazy import json

def parse_dataset(raw_data: str) -> list[dict[str, object]]:
    return json.loads(raw_data)

raw_data = '[{"product": "Laptop", "price": 1299.0}]'
print("Before first use:", "json" in sys.modules)
dataset = parse_dataset(raw_data)
print("After first use: ", "json" in sys.modules)
print(dataset)

This preserves readable dependency structure. However, import side effects (registration, patching) now occur later, which can break code that relies on immediate initialization. Test locally before enabling globally.

03 frozendict

Built-in immutable mapping for configurations that should not change after construction.

MODEL_CONFIG = frozendict(
    model="xgboost",
    max_depth=8,
    learning_rate=0.05,
)

MODEL_CONFIG["max_depth"] = 12  # raises error

Not a deep freeze: nested mutable objects (lists, dicts) remain mutable. Only when all keys and values are hashable can a frozendict serve as a dictionary key:

cache: dict[frozendict, float] = {}
config = frozendict(model="xgboost", max_depth=8)
cache[config] = 0.934

Best applied at configuration boundaries rather than replacing all dictionaries.

04 sentinel

Standardizes the "missing value" pattern to distinguish three states: omitted, explicit None, and a concrete value.

MISSING = sentinel("MISSING")

def update_threshold(value: float | None | MISSING = MISSING) -> None:
    if value is MISSING:
        print("Keep existing value")
        return
    print(f"Set threshold to {value}")

update_threshold()          # Keep existing value
update_threshold(None)      # Set threshold to None
update_threshold(0.75)      # Set threshold to 0.75

Clarifies interface semantics without inventing custom sentinel objects.

05 Unpacking in Comprehensions

Extended unpacking ( * and **) inside comprehensions flattens nested containers.

def flatten_batches(batches: list[list[int]]) -> list[int]:
    return [*batch for batch in batches]

batches = [[101, 102, 103], [104, 105], [106, 107, 108]]
print(flatten_batches(batches))  # [101, 102, 103, 104, 105, 106, 107, 108]

Set and dict comprehensions also support unpacking:

def collect_columns(column_groups: list[set[str]]) -> set[str]:
    return {*columns for columns in column_groups}

def merge_config(config_parts: list[dict[str, object]]) -> dict[str, object]:
    return {**part for part in config_parts}

Sets deduplicate; dicts overwrite duplicate keys with later values. Readability depends on nesting complexity.

06 UTF-8 Default Encoding

open()

without an explicit encoding now defaults to UTF-8, reducing platform locale surprises.

with open("customers.csv") as file:
    text = file.read()

Still recommend explicit encoding="utf-8" as part of the input contract, because the default only solves inconsistency when the encoding is omitted — it does not guarantee all files are UTF-8.

07 Sampling Profiler

High-frequency sampling profiler added. Unlike deterministic profilers, it periodically samples call stacks to identify where time is spent.

Verify the current build's help for sampling mode, output format, and permissions. Test with a pure Python workload first:

def calculate_scores(size: int) -> int:
    return sum(value * value for value in range(size))

if __name__ == "__main__":
    score = calculate_scores(15_000_000)
    print(f"Score: {score:,}")

Establish a baseline with fixed input and environment. The profiler locates hotspots; it is not a benchmark and cannot predict optimization gains alone.

08 JIT

Experimental JIT compiler benefits Python-heavy workloads (loops, branches, integer arithmetic), not tasks already delegated to native libraries like NumPy.

Benchmark example:

from time import perf_counter

def calculate_score(size: int) -> int:
    total = 0
    for value in range(size):
        if value % 2 == 0:
            total += value * value
    return total

def benchmark(runs: int = 10, size: int = 5_000_000) -> None:
    durations: list[float] = []
    for _ in range(runs):
        start = perf_counter()
        calculate_score(size)
        durations.append(perf_counter() - start)
    print(f"Fastest run: {min(durations):.3f} s")
    print(f"Average:     {sum(durations) / len(durations):.3f} s")

if __name__ == "__main__":
    benchmark()

Compare default vs. JIT-enabled runs using the same build and inputs. Discard first run (compilation overhead). JIT is not a simple performance switch; gains depend on code shape and workload.

09 Improved Error Messages

Attribute errors on wrapped objects now suggest candidates from nested objects (e.g., if container.shape fails but inner.shape exists, the error may hint at inner.shape). Low-cost usability improvement.

10 Conclusion & Recommended Workflow

Python 3.15 is still pre-release. Treat each feature as an independent experiment:

Create isolated environment with uv.

Run existing tests to verify dependency compatibility.

If startup is slow, test lazy import and check import side effects.

For mutable configs, try frozendict; for three-state APIs, try sentinel.

Audit file encoding contracts before relying on UTF-8 default.

Only profile and test JIT on genuine Python-heavy workloads.

The value lies in turning long-standing conventions into explicit language capabilities.