What a program looks like

A loop, if, try, bare call, augmented assignment, tuple unpacking, or write through a subscript or attribute at module level. Only definitions run when a module starts, so the statement would be compiled away. X = 1, X = helper(), X = ClassName(), def, class, and imports (a try/except ImportError guarded import included) do work, and a definition that is not a plain constant is evaluated once, at instantiation, in source order, so every function shares the same list or instance. Move the rest into a function, or under if __name__ == "__main__":.

async def, await, async with, and async for over a class with __aiter__ and __anext__ work, on asyncio's event loop compiled with the program (see Coroutines and asyncio). An async def that yields, and so an async for over one, an asynchronous comprehension, and an async def inside a function are refused.

Functions and __init__ take *args: T (a tuple of T), **kwargs: T (a dict[str, T]), and keyword-only parameters, f(*xs) passes a list or tuple on as *args, and keyword arguments work in every call. Other methods take neither starred nor keyword-only parameters, a call cannot unpack a dict with **, and / is refused. Every call to one of the module's own functions is checked against its signature, so a surplus or missing argument is a compile-time TypeError.

Not implemented. Each is reported by name with its location, and so is del of an attribute or a stepped slice. global, nonlocal, nested def, assert, conditional expressions, and del of a name, a list index, a list slice, or a dict key do work.

class Stack(list), class Config(dict), and a base computed by a call are refused: an instance would have to be the builtin's value too, and leaving the base out is a wrong answer. Subclass collections.UserList, UserDict, or UserString, which are ordinary classes here, or hold the value in a field.

Multiple inheritance works, along CPython's C3 method resolution order with cooperative super(), and so do metaclasses: a metaclass's __new__ and __init__ run once for each class it makes, specialized at compile time, and its __call__ replaces instantiation. The class namespace argument, __prepare__, creating a class by calling the metaclass, and class keywords other than metaclass= are refused.

Every implementation of an overridden method is reached through one indirect call, which names a single WebAssembly signature, so def m(self) in the base and def m(self, k: int) in the subclass is refused. Give the override the same parameters and return type.

A lambda's parameters, and a nested function's unannotated ones, take their types from the calls in their scope when those agree, and a sorted() key's from the elements it is given, so sorted(pairs, key=lambda kv: kv[1]) works. A parameter nothing types (a lambda only passed on to an unannotated parameter, or called with an int in one place and a str in another) holds an untyped word, so kv[1] or len(w) on it is refused rather than answering from that word. Use a named def, whose parameters can be annotated.

The method kinds, @dataclass, @abstractmethod, @functools.total_ordering, @functools.singledispatch with @f.register, the caching decorators (accepted, no effect), and decorators the program writes itself all work on module functions: a user decorator is applied at compile time and specialized for each function it wraps, factories and stacks included. functools's @cached_property and @singledispatchmethod work on methods. A user decorator on a method or a class, a wrapper that uses *args other than to pass it on, and a decorator name the program never defines are refused. Write the wrapper's work inline, or use @property.

Tuples, lists, and dicts compare by value, and a tuple works as a set member or a dict key. Comparing two with different element types ((1, 2) == (1.0, 2), True in CPython) or with element types the compiler cannot see is refused rather than read at the wrong width, and so is a list, dict, or set used as a set member or dict key (unhashable in CPython). Annotate the collections (List[Tuple[int, int]]) so both sides are known.

Every slot in a collection is read at one width, so a literal mixing types no one type holds ([1, "a"], [1, True]) is refused; use a class or a tuple for a record. An int written into a float collection is refused too, since CPython keeps the int (xs.append(3) on a List[float]). So is the other direction, because storing 2.5 where the slot is read as an integer would truncate it. Make the elements one type.

def total(cart): return cart.count has no type for cart, so the read is refused with a hint rather than answering 0. Annotate the parameter (cart: Cart). The rich comparison methods are the exception: an unannotated other in __eq__, __lt__, and the rest is typed as the class.

An unannotated parameter or return, and the elements of a bare list, set, or dict parameter or return, hold one word read back as an int. Ints, bools, None, and functions pass through; anything else is refused, since a string would lose its length and a float its width. Annotate the parameter, or write List[str] and Dict[str, int]. A bare annotation on a variable is fine: its elements take the type of the value assigned.

None is the word 0, which an untyped value can also be, so the test cannot be answered there. An Optional[int], Optional[bool], or Optional[float] is boxed, so is None, ==, and truthiness on one give CPython's answer; arithmetic between two optional numbers is refused. dict.get(key) with no default is refused unless the values are numbers or instances, since a string or collection has no distinct word for the None a missing key answers; pass a default.

The whole format specification mini-language works in f-strings, format(), .format(), and %, digit for digit with CPython. .format() and % need a literal format string, and a * width or precision in %, or a precision on %d, %x, or %o, is refused. A spec CPython rejects is a compile error carrying CPython's message when it is a literal, and traps when it is built at run time.

Float powers are CPython's, so 2.0 ** 0.5 works. A negative integer exponent traps because Python's answer is a float an int cannot hold, and a negative float to a fractional power traps because its answer is a complex number. float() and int() of a string with non-ASCII digits or spaces trap too, where CPython would accept them.

Merged modules share one namespace, so utils.format next to report.format is a compile error naming both files. Rename one.

Memory is reclaimed, and __del__ runs when the last reference goes: as a function returns, a name is rebound or deleted, or a collection lets go of what it held, in CPython's order. A generator abandoned mid-iteration runs its finally blocks then too. What differs is a temporary, which lives to the end of its statement (so print(Res().name) prints before the finalizer runs), and an object in a reference cycle, which is finalized whenever the collector next runs rather than at CPython's count.

With x = float("nan"), (x,) == (x,) and [x] == [x] are False here, where CPython answers True: floats are unboxed values, so there is no object identity for CPython's same-object shortcut to find. x == x is False in both.

No traceback is kept. An exception a __main__ block does not catch writes only the last line of CPython's report (ValueError: boom) to standard error and exits with status 1.

A generator expression goes where something walks it once: an argument of a builtin or standard-library call (sum(x * x for x in xs)), a for statement, or a comprehension. g = (f(y) for y in ys), returning one, and passing one to a function of your own are refused, because it is built as a list, which can be walked twice and measured where CPython's generator cannot. Write a list comprehension for a list, or a generator function for a lazy sequence.

sum(f(y) for y in ys) calls f for every element before sum() reads the first, where CPython interleaves them. The answer is the same; only the order of what f prints or changes can differ. A for statement over one, and any() and all(), pull it as CPython does.

No PyPI. sys, os, os.path, math, random, json, re, datetime, logging, collections, itertools, functools, and asyncio run on runtime values, checked against CPython 3.13. What is not implemented is refused at compile time, by name: the modules board tracks each feature, and Limitations has the rules these modules follow.