Python 3.15 Arrives: Boost Speed Without Changing a Single Line

TL;DR

Python 3.15 is an "engineering completion" release that folds best‑practice patterns (lazy import, immutable mapping, sampling profiler) into the language.

Six changes directly relevant to data engineers: lazy import, frozendict, unpacking in comprehensions, JIT upgrade, Tachyon profiler, GC rollback.

Without code changes, Python runs 12‑13% faster on ARM Macs; lazy import can halve CLI start‑up time.

Upgrade command: pyenv install 3.15.0b2 for local testing; wait for the final 3.15 release in October for production.

Three‑Layer Structure

The changes can be grouped into three conceptual layers:

┌─────────────────────────────┐
│ Syntax Surface (what you type)│ ← lazy import, frozendict, unpack comprehension
├─────────────────────────────┤
│ Performance Engine (felt)    │ ← JIT upgrade, Tachyon profiler, frame pointers
├─────────────────────────────┤
│ Ecosystem Foundation (underlying)│ ← UTF‑8 default, GC rollback, .start files
└─────────────────────────────┘

This classification is the author’s own synthesis after reading 14 PEPs.

Syntax Layer

lazy import – make imports lazy

Traditional import loads a module immediately. Python 3.15 adds the soft keyword lazy so the module is loaded only when first used.

lazy import json
lazy from pathlib import Path
lazy import numpy as np

# No module is loaded until the first use
data = json.loads('{"a": 1}')  # json loads here

Failure to import is delayed until the point of use, and the traceback shows both the call site and the original import statement.

Global control options:

# Aggressive: lazy‑load everything (may break import‑side‑effects)
export PYTHON_LAZY_IMPORTS=all
python -X lazy_imports=all your_script.py

# Safer: filter only your own modules
import sys

def my_filter(importing, imported, fromlist):
    return imported.startswith("myapp.")

sys.set_lazy_imports_filter(my_filter)
sys.set_lazy_imports("all")

Projects compatible with older Python versions can define __lazy_modules__; versions < 3.15 simply ignore it.

frozendict – immutable, hashable mapping

Before 3.15, a common workaround for an immutable mapping was tuple(sorted(d.items())) or MappingProxyType. Python 3.15 introduces the built‑in frozendict:

config = frozendict(host="localhost", port=5432)
config["host"]  # 'localhost'
config["port"] = 3306  # TypeError

# Hashable – can be used as dict key or set element
cache = {}
cache[frozendict(a=1, b=2)] = "result"

Standard‑library modules such as json, pickle, pprint, copy, and marshal already accept frozendict objects.

Note: isinstance(x, dict) no longer matches frozendict. Use isinstance(x, collections.abc.Mapping) instead.

Unpacking in comprehensions

Python 3.15 allows direct unpacking inside list comprehensions, removing a level of nesting:

# Before 3.15
[x for L in lists for x in L]

# 3.15 syntax
[*L for L in lists]

Dictionary unpacking with ** also works inside comprehensions.

Performance Layer

JIT – 12‑13% faster on Apple Silicon

Python 3.13 introduced a JIT compiler, 3.14 refined it, and 3.15 brings a "significant upgrade". Benchmarks show geometric‑mean speedups of 8‑9% on x86‑64 Linux and 12‑13% on ARM‑64 macOS. No code changes are required; simply upgrading the interpreter yields the gains.

Tachyon – built‑in statistical sampling profiler

Previous profiling tools ( cProfile, timeit, py‑spy) had drawbacks. Python 3.15 adds profiling.sampling (Tachyon), a near‑zero‑overhead sampler similar to Linux perf.

# Run and sample
python -m profiling.sampling your_script.py

# Attach to a running process
python -m profiling.sampling --attach 12345

# Sampling modes
python -m profiling.sampling --mode wall your_script.py   # wall‑clock time
python -m profiling.sampling --mode cpu your_script.py    # CPU time only
python -m profiling.sampling --mode gil your_script.py    # GIL hold time
python -m profiling.sampling --mode exception your_script.py  # exception threads

Output formats include interactive HTML flame graphs, pstats compatible files, Firefox Profiler JSON, line‑level heatmaps, and a live TUI. The --async-aware flag correctly reconstructs async call stacks.

Frame pointers enabled by default

CPython 3.15 compiles with -fno-omit-frame-pointer , allowing system‑level profilers (e.g., perf , eBPF tools) to unwind Python stacks reliably, which is valuable for teams using eBPF for observability.

Ecosystem Foundation

UTF‑8 becomes the default source encoding

Opening a file without an explicit encoding now uses UTF‑8 regardless of the OS locale. This eliminates UnicodeDecodeError on macOS and Docker containers and makes cross‑platform scripts behave consistently. To revert to the old behavior:

export PYTHONUTF8=0
# or
python -X utf8=0 your_script.py

GC rollback – incremental GC removed

Python 3.14 introduced an incremental garbage collector that caused significant memory pressure in production (see CPython issue gh‑142516). The core team reverted to the generational GC from 3.13 in 3.14.5 and 3.15. Users on 3.14.0‑3.14.4 should upgrade to 3.14.5+ or jump directly to 3.15.

.start files replace .pth import hacks

.pth files could execute arbitrary import statements at interpreter start, a security risk. Python 3.15 adds .start files with a clear pkg.mod:callable entry point, and the old import lines are silently ignored. Projects using .pth for startup initialization should migrate to .start.

Migration Guide for Data Engineers

Step 1: Local testing

pyenv install 3.15.0b2
pyenv local 3.15.0b2
pip install -r requirements.txt   # note any failures
pytest                           # run test suite

Suitable for pure‑Python CLI tools, data‑processing pipelines (Pandas/Polars), and asyncio applications. Step 2: CI configuration

jobs:
  test:
    strategy:
      matrix:
        python-version: ["3.13", "3.15.0-beta.2"]
    steps:
      - uses: actions/setup-python@v5
        with:
          python-version: ${{ matrix.python-version }}

Add 3.15 as a canary in CI to catch regressions early. Step 3: Gradual lazy‑import migration

__lazy_modules__ = [
    "heavy_parser",
    "report_generator",
    "email_sender",
]

In versions < 3.15 the list is ignored; from 3.15 onward it activates automatically, providing a zero‑risk, incremental improvement.

Upgrade Checklist

## Python 3.15 Upgrade Checklist
### Installation
- [ ] pyenv install 3.15.0b2
- [ ] pip install -r requirements.txt (record failures)
- [ ] pytest / project test suite (record failures)

### Code adaptation
- [ ] Replace isinstance(x, dict) with isinstance(x, (dict, frozendict)) or collections.abc.Mapping
- [ ] Verify open() calls now default to UTF‑8
- [ ] Migrate .pth import lines to .start files
- [ ] Update any custom lazy‑import filter via sys.set_lazy_imports_filter

### Performance verification
- [ ] Run Tachyon profiler: python -m profiling.sampling --flamegraph perf.html main.py
- [ ] Compare end‑to‑end runtime between 3.14 and 3.15
- [ ] For asyncio code, add --async-aware flag and verify task stacks

### Production deployment
- [ ] Wait for 3.15.0 final release (2026‑10‑01)
- [ ] Add 3.15 to CI matrix
- [ ] Gray‑scale rollout: start with 10% traffic