Python 3.7: What's New, Release History & Support Lifecycle

What Is New in Python 3.7

Python 3.7 was released on June 27, 2018. The defining additions are the dataclasses module, contextvars for async context propagation, breakpoint() as a standardized debugger entry point, postponed annotation evaluation, and nanosecond-precision time functions. CPython's startup time also improved significantly.

What Are the Key New Features in Python 3.7?

dataclasses -- Boilerplate-Free Classes (PEP 557)

The @dataclass decorator auto-generates __init__, __repr__, __eq__, and optionally __lt__, __hash__, and __post_init__ based on class-level type annotations. This is the single most adopted stdlib addition of Python 3.7.

from dataclasses import dataclass, field

@dataclass(order=True)
class Point:
    x: float
    y: float
    label: str = field(default="origin", compare=False)

p1 = Point(1.0, 2.0)
p2 = Point(1.0, 2.0, label="home")
print(p1 == p2)  # True -- label excluded from comparison
print(repr(p1))  # Point(x=1.0, y=2.0, label='origin')

You control which fields participate in comparison, hashing, and repr independently. For mutable default values, use field(default_factory=list) -- not a bare [].

contextvars -- Context-Local State (PEP 567)

Context variables are the async-safe replacement for thread-local storage. Each coroutine runs in its own context copy, so setting a ContextVar inside a coroutine doesn't bleed into sibling coroutines sharing the same thread.

from contextvars import ContextVar

request_id: ContextVar[str] = ContextVar("request_id", default="none")

async def handle_request(rid: str):
    token = request_id.set(rid)
    await do_work()  # request_id is "rid" here, not visible to other coroutines
    request_id.reset(token)

async def do_work():
    print(request_id.get())  # prints the request-specific value

breakpoint() -- Pluggable Debugger (PEP 553)

Instead of importing pdb and calling pdb.set_trace(), you now just call breakpoint(). The actual debugger is configurable via the PYTHONBREAKPOINT environment variable -- set it to a dotted import path, or to 0 to disable all breakpoints without touching code.

# In code
breakpoint()  # drops into pdb by default

# To use a different debugger:
# PYTHONBREAKPOINT=pudb.set_trace

# To silence all breakpoints:
# PYTHONBREAKPOINT=0

How Did asyncio Change in Python 3.7?

Python 3.7 is where asyncio became genuinely pleasant to use. The biggest change: asyncio.run(coro) -- a single call to run a top-level coroutine, create an event loop, and clean it up automatically. Previously this required four or five lines of boilerplate.

import asyncio

async def main():
    print("hello")
    await asyncio.sleep(1)
    print("world")

asyncio.run(main())  # Python 3.7+

Other asyncio additions: asyncio.create_task() replaces the verbose loop.create_task(), asyncio.get_running_loop() raises RuntimeError if no loop is active (safer than get_event_loop()), and asyncio.current_task() / asyncio.all_tasks() for task introspection.

Postponed Annotation Evaluation (PEP 563)

With from __future__ import annotations, all annotations are stored as strings (lazily) rather than evaluated at definition time. This solves forward reference problems and reduces import-time overhead for annotation-heavy code.

from __future__ import annotations

class Node:
    def next(self) -> Node:  # Forward reference -- works without quotes
        ...

    def clone(self) -> Node:
        ...

Without the import, Node would not yet be defined at class body evaluation time. Postponed evaluation was planned to become the default in 3.10, but that change was deferred indefinitely due to compatibility concerns with runtime annotation consumers.

Performance Improvements and CPython Changes

• Startup time improved -- method resolution and attribute lookup are faster, particularly for classes with many inherited attributes.
• Six new nanosecond-precision time functions: time.time_ns(), time.perf_counter_ns(), time.monotonic_ns(), etc. These avoid floating-point precision loss on high-resolution clocks.
• Hash-based .pyc files (PEP 552) allow content-based validation instead of timestamp comparison, enabling reproducible bytecode in build systems.
• Dict ordering is now a language guarantee, not just a CPython implementation detail. Code can rely on insertion order without worrying about interpreter portability.
• UTF-8 mode (-X utf8 or PYTHONUTF8=1) forces UTF-8 as the default encoding regardless of locale settings -- useful in containers and CI pipelines.