Python 3.12-3.13: Type Parameters, f-strings and Removals

Description

Python 3.12 and 3.13 tidied up a lot of everyday code: generics without TypeVar boilerplate, f-strings that behave like normal code, @override, itertools.batched, copy.replace and @deprecated. They also removed a set of old standard-library modules, and laid the groundwork for running without the GIL. Some of these are new syntax, and that matters as much as what they do: a file using new syntax can't even be read by an older Python.

Here's the kind of bug we mean. A library adds a convenience in a minor release:

log.info(f"loaded {", ".join(names)}")

It works on the maintainer's Python 3.12 - and every user on 3.11 gets a SyntaxError when the module is imported, before a single function runs. Python 3.12 relaxed f-string grammar (PEP 701) so the expression can reuse the enclosing quotes; 3.11's parser can't read the file at all.

We'll go from simple to more technical:

1. Type parameter syntax: def first[T], class Box[T] and type aliases.
2. f-strings, @override and batched in 3.12.
3. What 3.13 added: a new REPL, copy.replace, @deprecated and more.
4. What 3.12 and 3.13 removed, and how to upgrade safely.

Type parameter syntax (3.12)

Before 3.12, a generic function needed a module-level type variable:

from typing import TypeVar
T = TypeVar("T")
def first(items: list[T]) -> T: ...

PEP 695 puts the type parameters in the definition:

def first[T](items: list[T]) -> T:
    return items[0]

class Box[T]:
    def __init__(self, item: T) -> None:
        self.item = item

def largest[T: (int, float)](xs: list[T]) -> T: ...      # constrained
def save[T: Model](obj: T) -> T: ...                     # bounded

type Pair = tuple[int, int]
type Tree = dict[str, Tree] | None                        # refers to itself - no quotes needed

• The parameters are scoped to the function or class (first.__type_params__ is (T,)), so there's no shared global T and no naming ceremony.
• type statements create a TypeAliasType whose value is evaluated lazily - on first access to Pair.__value__ - which is why recursive aliases and forward references work without quotes.
• Like all annotations, these are for type checkers; nothing is enforced at run time.

f-strings, @override and batched (3.12)

• f-strings are parsed like normal code (PEP 701): expressions may reuse the enclosing quote character (f"{", ".join(names)}" printed Ada, Bo), nest f-strings, contain backslashes and comments, and span lines. Convenient - but it's new syntax, so a file using it doesn't parse on 3.11 or older.
• @typing.override marks a method as overriding a base-class method. A type checker reports an error when the base method doesn't exist (say, after it was renamed), catching silent "overrides" of nothing. At run time it only sets __override__ = True.
• itertools.batched(iterable, n) yields tuples of up to n items: batched(range(7), 3) gives (0, 1, 2), (3, 4, 5), (6,). In 3.13, strict=True raises ValueError: batched(): incomplete batch if the last one is short.
• 3.12 also gave each subinterpreter its own GIL (PEP 684) and made None, small ints and other singletons immortal (PEP 683) - groundwork for free-threading.

Python 3.13

• A new interactive REPL with colors, multi-line editing and history, and paste mode.
• Experimental free-threaded build (python3.13t, PEP 703) and an experimental JIT (PEP 744), both off by default - see Free-Threaded Python and Subinterpreters.
• copy.replace(obj, **changes) copies an immutable object with some fields changed - frozen dataclasses, named tuples, datetime - copy.replace(config, retries=5) leaves the original untouched.
• @warnings.deprecated("use fetch_v2") (PEP 702) emits a DeprecationWarning when the function is called and makes type checkers flag every call.
• locals() semantics (PEP 667) are defined precisely in functions: it returns a snapshot, so writing to it never changes local variables.

What's gone

PEP 594 retired old, unmaintained standard-library modules ("dead batteries"), after deprecation in 3.11:

Code (or an old dependency) that imports one fails with ModuleNotFoundError: No module named 'cgi' on upgrade - every one in the table failed that way on 3.14. Run your test suite with -W error::DeprecationWarning on the release before an upgrade: removals are always announced as deprecation warnings first.

Which tool for which job?

Common mistakes

Check yourself

Try to answer before opening each one - recalling beats re-reading.

1. Why can't a library that supports Python 3.11 use f"{", ".join(names)}"?

2. Why does type Tree = dict[str, Tree] | None work without quotes?

3. What does @override do at run time?

Key takeaways

• def f[T] and type X = ... replace TypeVar boilerplate; aliases are lazy.
• PEP 701 f-strings and type-parameter syntax raise your minimum Python to 3.12.
• @override, batched, copy.replace, @deprecated - small, useful, checked by tools.
• 3.12 and 3.13 removed the dead batteries; heed deprecation warnings before upgrading.