Python 3.15 Beta: 6 Must‑Try Features to Boost Your Projects Now

Python 3.15 beta is out with the feature set essentially frozen, and the author highlights six changes that are immediately useful in real projects.

01 lazy import – stop scattering imports in functions

Typical CLI tools import heavy modules at the top level, causing a noticeable start‑up delay (e.g., a --help call that waits two seconds). The old workaround was to move the import inside a function, which makes the code harder to read and can hide side‑effects. Python 3.15 adds a soft keyword lazy that creates a proxy and defers the actual import until the name is first accessed.

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

print("Starting up…")  # runs before any import

data = json.loads('{"name": "Yang"}')  # json imported here
path = Path(".")  # pathlib imported here

The feature works for any import and can be toggled globally with -X lazy_imports, the PYTHON_LAZY_IMPORTS environment variable, or sys.set_lazy_imports(). The author advises applying it only to modules that have no side‑effects.

02 frozendict + sentinel – clean immutable data handling

Immutable dictionaries have long required third‑party packages or workarounds. Python 3.15 now provides a built‑in frozendict type:

config = frozendict(host="localhost", port=2077, debug=False)
config["host"]  # 'localhost'
config["debug"] = True  # TypeError
hash(config)  # works because it is immutable

Typical use cases include configuration constants, cache keys, and default function arguments. The author also recommends using the new sentinel type for unique placeholder values instead of object():

NOT_SET = sentinel("NOT_SET")

def get_setting(name: str, default=NOT_SET):
    value = read_from_env(name)
    return default if value is NOT_SET else value

03 profiling.sampling – low‑overhead runtime profiling

The new profiling.sampling module (code‑named Tachyon) periodically captures stack snapshots, offering a statistical profiler that adds far less overhead than cProfile. It can be run as a new process, generate a flame‑graph, or attach to an already running process:

# Run a new process and generate a flame‑graph
python -m profiling.sampling run --flamegraph -o profile.html app.py

# Attach to a live process for 30 seconds
python -m profiling.sampling attach --duration 30 12345 --flamegraph -o hot.html

This is especially valuable for diagnosing production issues without restarting the service.

04 JIT speed‑up

Python 3.13 introduced a JIT with modest gains; Python 3.15 shows measurable improvements: 8–9 % faster on x86‑64 Linux and 12–13 % on AArch64 macOS (geometric mean). The author suggests benchmarking CPU‑bound workloads with python3.15 -m timeit or pyperformance to see real‑world benefits.

05 Unpacking in comprehensions – cleaner syntax

List and dict comprehensions can now unpack iterables directly:

names = [*group for group in groups]
config = {**c for c in configs}
all_perms = {*p for p in permissions}

This reduces visual noise compared to nested for clauses.

06 Other practical tweaks

UTF‑8 is now the default file encoding; open("file.txt") no longer follows the system locale.

Improved error messages suggest likely attribute names (e.g., "Did you mean '.append'?").

TypedDict gains closed=True to forbid extra keys and extra_items=float to restrict the type of additional values.

Incremental GC introduced in 3.14 was reverted because of memory‑growth complaints.

Recommendations

Apply lazy import to heavy, side‑effect‑free dependencies in start‑up‑critical projects.

Adopt profiling.sampling for production diagnostics.

Replace custom immutable‑dict patterns with frozendict and sentinel in libraries.

Benchmark JIT gains on your own workloads before deciding to upgrade.

Enable the new unpacking syntax where it simplifies code, but keep lines under 60 characters for readability.

Overall, the author stresses that the real value comes from testing these changes in your own codebase rather than relying on headline numbers.