Python 3.15: Lazy Imports, Faster JIT, Upgrade Now

Python 3.15 shipped on October 9 with five changes worth your attention — and one of them can silently corrupt file I/O on Windows before you realize what happened. Here is what actually matters, with code you can use today.

Lazy Imports Are Finally a Language Feature

PEP 810 adds lazy as a soft keyword that defers module loading until the name is first accessed. No third-party library. No importlib ceremony. Just:

lazy import boto3
lazy import pandas as pd
lazy from pathlib import Path

The module does not load at startup. It loads the first time you call boto3.client() or pd.DataFrame(). For CLI tools, Lambda functions, and microservices where most code paths never touch the heavy dependencies, this can eliminate seconds of cold-start time with zero architectural changes.

One restriction worth knowing: lazy import only works at module level. You cannot use it inside functions, class bodies, or try blocks. And import errors surface at use time, not startup — so if you depend on catching ImportError at boot, test that path explicitly.

The Breaking Change Nobody Will Notice Until Production

open() without an explicit encoding= parameter now defaults to UTF-8 everywhere (PEP 686). On Linux and macOS, this changes nothing — UTF-8 was already the default. On Windows, it replaces the system codepage (often cp1252).

If you have any code that reads legacy-encoded files on Windows without specifying encoding, you are getting either garbled text or a UnicodeDecodeError waiting for its moment. The fix takes five seconds:

# Before (implicit encoding — dangerous now)
with open('data.csv') as f:
    content = f.read()

# After (explicit — safe everywhere)
with open('data.csv', encoding='utf-8') as f:
    content = f.read()

Run a quick search for open( calls without encoding= before you deploy. You will likely find a few.

The JIT Is Faster — Opt In and Measure

Python 3.15’s JIT compiler has been rebuilt around a tracing front end. Published pyperformance benchmarks show a 7–8% geometric mean improvement on x86-64 Linux and 11–12% on AArch64 macOS. That is real. It is also not the PyPy moment people keep waiting for.

The JIT remains opt-in for now. Enable it with one environment variable:

PYTHON_JIT=1 python app.py

The gains are strongest on arithmetic-heavy loops. If your workload is dominated by object allocation and library calls — web frameworks, ORMs, data pipelines — benchmark before assuming a win. A quick way to measure against your actual code:

PYTHON_JIT=0 pyperformance run -o without-jit.json
PYTHON_JIT=1 pyperformance run -o with-jit.json
pyperformance compare without-jit.json with-jit.json

frozendict and sentinel: Two Patterns You Have Been Reinventing

If you have ever written _MISSING = object() to distinguish “no value provided” from None, or wrapped a dict in MappingProxyType to make it read-only, Python 3.15 ships the proper versions of both patterns as built-ins.

frozendict is an immutable, hashable dictionary. Unlike MappingProxyType, a frozendict is hashable — which means it can be used as a dictionary key or in a set:

config = frozendict({'host': 'localhost', 'port': 5432})
lookup = {config: connection_pool}  # this works now

sentinel fixes the one awkward part of the object() pattern — the repr. Give it a name:

_MISSING = sentinel('MISSING')

def fetch(key, default=_MISSING):
    if default is _MISSING:
        raise KeyError(key)
    return default

When _MISSING appears in a traceback or debug session now, it says MISSING instead of <object object at 0x...>. A small thing, a meaningful improvement.

Tachyon: A Production Profiler in the Standard Library

Python 3.15 ships profiling.sampling — a statistical sampling profiler named Tachyon — that reads a running program’s stack from a separate process. Near-zero overhead, no instrumentation, no restart required:

# Attach to a running process
python -m profiling.sampling attach <PID>

# Profile a script from the start
python -m profiling.sampling run app.py

This is py-spy built into the standard library. For teams that have avoided production profiling because the tooling was complicated to install and configure, the barrier is now gone.

Should You Upgrade?

The major packages are ready. Django, FastAPI, numpy, pandas, SQLAlchemy, and pytest are all green on pyreadiness.org/3.15. debugpy 1.8.22 explicitly supports 3.15 — update your editor extension before switching.

A four-step check covers most upgrade risks:

1. Surface deprecation warnings: python3.15 -W error -c "import your_package"
2. Search your codebase for open( without encoding=
3. Check for imports of sre_compile, sre_parse, or sre_constants — those modules are gone
4. Replace any bare asyncio.get_event_loop() with asyncio.get_running_loop()

If your codebase passes those checks, 3.15 is a clean upgrade. The lazy imports alone are worth it for anything startup-sensitive, and the full changelog is worth a skim — frozendict and sentinel will quietly clean up patterns you have copy-pasted across projects for years.