Abstract

When a class is defined using a class statement, the class body is executed within a namespace. After the execution completes, that namespace is copied into new dict and the original definition namespace is discarded. The new copy is stored away as the class's namespace and is exposed as __dict__ through a read-only proxy.

This PEP changes the default class definition namespace to OrderedDict. The long-lived class namespace (__dict__) will remain a dict. Furthermore, the order in which the attributes are defined in each class body will now be preserved in the __definition_order__ attribute of the class. This allows introspection of the original definition order, e.g. by class decorators.

Motivation

Currently the namespace used during execution of a class body defaults to dict. If the metaclass defines __prepare__() then the result of calling it is used. Thus, before this PEP, if you needed your class definition namespace to be OrderedDict you had to use a metaclass.

Metaclasses introduce an extra level of complexity to code and in some cases (e.g. conflicts) are a problem. So reducing the need for them is worth doing when the opportunity presents itself. Given that we now have a C implementation of OrderedDict and that OrderedDict is the common use case for __prepare__(), we have such an opportunity by defaulting to OrderedDict.

The usefulness of OrderedDict-by-default is greatly increased if the definition order is directly introspectable on classes afterward, particularly by code that is independent of the original class definition. One of the original motivating use cases for this PEP is generic class decorators that make use of the definition order.

Changing the default class definition namespace has been discussed a number of times, including on the mailing lists and in PEP 422 and PEP 487 (see the References section below).

Specification

• the default class definition namespace is now OrderdDict
• the order in which class attributes are defined is preserved in the new __definition_order__ attribute on each class
• "dunder" attributes (e.g. __init__, __module__) are ignored
• __definition_order__ is a tuple (or None)
• __definition_order__ is a read-only attribute
• __definition_order__ is always set:
  1. if __definition_order__ is defined in the class body then it must be a tuple of identifiers or None; any other value will result in TypeError
  2. classes that do not have a class definition (e.g. builtins) have their __definition_order__ set to None
  3. classes for which __prepare__()` returned something other than OrderedDict (or a subclass) have their __definition_order__ set to None (except where #1 applies)

The following code demonstrates roughly equivalent semantics for the default behavior:

class Meta(type):
    def __prepare__(cls, *args, **kwargs):
        return OrderedDict()

class Spam(metaclass=Meta):
    ham = None
    eggs = 5
    __definition_order__ = tuple(k for k in locals()
                                 if not (k.startswith('__') and
                                         k.endswith('__')))

Note that [pep487] proposes a similar solution, albeit as part of a broader proposal.

Compatibility

This PEP does not break backward compatibility, except in the case that someone relies strictly on dict as the class definition namespace. This shouldn't be a problem.

Changes

In addition to the class syntax, the following expose the new behavior:

• builtins.__build_class__
• types.prepare_class
• types.new_class

Other Python Implementations

Pending feedback, the impact on Python implementations is expected to be minimal. If a Python implementation cannot support switching to OrderedDict`-by-default then it can always set __definition_order__ to None.

Implementation

The implementation is found in the tracker. [impl]

Alternatives

References

Copyright

This document has been placed in the public domain.