The Python Object Model

Core structure in detail

A semi-formal description of the Python object model is presented. Currently, only the core structure is described, concerning inheritance, instance relation and attribute resolution order.

In the present scope, this document can be considered as just an appendix to [].

Preface

Author

	Ondřej Pavlata
	Jablonec nad Nisou
	Czech Republic

Document date

Initial release	August 24, 2012
Last major release	August 24, 2012
Last update	January 22, 2013

(see Document history)

Warning

This document has been created without any prepublication review except those made by the author himself.

Python version

This document refers to Python 3.x, more specifically, to CPython 3.2.3.

S1: Inheritance and the class map

An S1 structure is a structure (O, ≤, .class, r, c) where

O is a finite set of objects.
≤ is a relation between objects, called inheritance.
.class is a function between objects. For an object x, x.class is the class of x.
r is an object, called the inheritance root.
c is an object, called the metaclass root (or instance root).

Additional notation / terminology is applied:

Let T be the set of objects x such that x ≰ r. Elements of T are terminal(s).
Let C be the set of remaining objects, that is, O = T ⊎ C. Elements of C are classes.
If x ≤ y then x is an (inheritance) descendant of y and y is an (inheritance) ancestor of x. By (S1~2), inheritance is a partial order, so that corresponding notation and terminology applies to ≤. In particular, if x < y then y is said to be a strict ancestor of x.
For an object x, x.↥ (resp. x.↧) denotes the set of all (non-strict) ancestors (resp. descendants) of x.
Classes x such that x ≤ c are called metaclasses.
For objects x, y, if x.class ≤ y then x is said to be an instance of x. If x.class = y then x is a direct instance of x.
Inheritance ancestors of c are called helix objects. By further constraints, the set of helix objects contains exactly classes r and c.

The structure is subject to the following axioms:


(S1~1)	The .class map is monotone with respect to inheritance, i.e. for every classes x, y, x ≤ y implies x.class ≤ y.class.
(S1~2)	The inheritance ≤ is a partial order between objects. In addition, r is the highest class (the top of (C, ≤)), terminals are minimal – they have no strict descendants.
(S1~3)	The set {r, c} forms the least substructure. More specifically, r is different from c and is the only strict inheritance ancestor of c, r.class = c. Equivalently, {r, c} is a 2-element set that is an up-set both in inheritance and the instance tree.
(S1~4)	For every terminal object x, x.class ≰ c, i.e. the class of a terminal object is not a metaclass.
(S1~5)	The .class map forms a tree on objects called the instance tree. In addition, c is the root, terminals are (among the) leaves, i.e. the class of an object is a class.

Proposition:

Every object is an instance of r.
An object is a class iff it is an instance of c.
Helix classes are the only objects that are instances of itself.

The following table shows how the structure is reflected using the Python built-in functions.

Notation	Terminology	Python expression
r	inheritance root	`object`
c	metaclass root	`type`
x is a class		`isinstance(x,type)`
x is a metaclass		`issubclass(x,type)`
x.class	the class of x	`x.__class__`
x ≤ y	x is a descendant of y	`issubclass(x,y)`
x.class ≤ y	x is an instance of y	`isinstance(x,y)`

Note: As of version 3.2, Python allows structures that do NOT satisfy condition (S1~2). This is shown by the following code.

class M(type):
  def mro(x): return []
class X(metaclass=M): pass
print (issubclass(X,X))      # False
print (issubclass(X,object)) # False

S2: Attribute (/ method) resolution order – MRO

An S2 structure is an S1 structure equipped with (._mro, ._bas) where

._mro and ._bas are functions from the set C of classes to the set of lists of classes.

For classes x, y, we write

x ⋖ y iff y appears in x._bas.

For a class x, elements of x._bas are (direct) superclasses of x.

The structure is subject to the following conditions:


(S2~1)	The inheritance ≤ is obtained from ._mro by x ≤ y iff y appears in x._mro for every classes x, y.
(S2~2)	The inheritance ≤ is also obtained from ._bas as the reflexive transitive closure of ⋖.
(S2~3)	For every class x, (a) the list x._mro is non-repetitive, starts with x and ends with r, (b) the list x._bas is non-repetitive and does not contain x.

References


	Mark Lutz, Learning Python, O'Reilly 2009
	Ondřej Pavlata, Object Membership: The core structure of object-oriented programming, 2012–2014, http://www.atalon.cz/om/object-membership/oop/
	Chris Siebenmann, Python's attribute lookup order, 2011, http://utcc.utoronto.ca/~cks/space/blog/python/AttributeLookupOrder

Document history

August	24	2012	The initial release.
January	22	2013	Conditions (S1~1) and (S1~5) exchanged in order to be in a correspondence with axioms of S1_p.pr structures.

License

This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 3.0 License.