| Repr Objects |
| ------------ |
| |
| :class:`Repr` instances provide several members which can be used to provide |
| size limits for the representations of different object types, and methods |
| which format specific object types. |
| |
| |
n | .. attribute:: XXX Class.maxlevel |
n | .. attribute:: Repr.maxlevel |
| |
| Depth limit on the creation of recursive representations. The default is ``6``. |
| |
| |
n | .. attribute:: XXX Class.maxdict |
n | .. attribute:: Repr.maxdict |
| XXX Class.maxlist |
| Repr.maxlist |
| XXX Class.maxtuple |
| Repr.maxtuple |
| XXX Class.maxset |
| Repr.maxset |
| XXX Class.maxfrozenset |
| Repr.maxfrozenset |
| XXX Class.maxdeque |
| Repr.maxdeque |
| XXX Class.maxarray |
| Repr.maxarray |
| |
| Limits on the number of entries represented for the named object type. The |
| default is ``4`` for :attr:`maxdict`, ``5`` for :attr:`maxarray`, and ``6`` for |
| the others. |
| |
| .. versionadded:: 2.4 |
| :attr:`maxset`, :attr:`maxfrozenset`, and :attr:`set`. |
| |
n | . |
| |
n | |
| .. attribute:: XXX Class.maxlong |
| .. attribute:: Repr.maxlong |
| |
| Maximum number of characters in the representation for a long integer. Digits |
| are dropped from the middle. The default is ``40``. |
| |
| |
n | .. attribute:: XXX Class.maxstring |
n | .. attribute:: Repr.maxstring |
| |
| Limit on the number of characters in the representation of the string. Note |
| that the "normal" representation of the string is used as the character source: |
| if escape sequences are needed in the representation, these may be mangled when |
| the representation is shortened. The default is ``30``. |
| |
| |
n | .. attribute:: XXX Class.maxother |
n | .. attribute:: Repr.maxother |
| |
| This limit is used to control the size of object types for which no specific |
| formatting method is available on the :class:`Repr` object. It is applied in a |
| similar manner as :attr:`maxstring`. The default is ``20``. |
| |
| |
n | .. method:: XXX Class.repr(obj) |
n | .. method:: Repr.repr(obj) |
| |
| The equivalent to the built-in :func:`repr` that uses the formatting imposed by |
| the instance. |
| |
| |
n | .. method:: XXX Class.repr1(obj, level) |
n | .. method:: Repr.repr1(obj, level) |
| |
| Recursive implementation used by :meth:`repr`. This uses the type of *obj* to |
| determine which formatting method to call, passing it *obj* and *level*. The |
| type-specific methods should call :meth:`repr1` to perform recursive formatting, |
| with ``level - 1`` for the value of *level* in the recursive call. |
| |
| |
n | .. method:: XXX Class.repr_type(obj, level) |
n | .. method:: Repr.repr_TYPE(obj, level) |
| :noindex: |
| |
| Formatting methods for specific types are implemented as methods with a name |
n | based on the type name. In the method name, *type* is replaced by |
n | based on the type name. In the method name, **TYPE** is replaced by |
| ``string.join(string.split(type(obj).__name__, '_'))``. Dispatch to these |
| methods is handled by :meth:`repr1`. Type-specific methods which need to |
| recursively format a value should call ``self.repr1(subobj, level - 1)``. |
| |
| |
| .. _subclassing-reprs: |
| |
| Subclassing Repr Objects |
| ------------------------ |
| |
| The use of dynamic dispatching by :meth:`Repr.repr1` allows subclasses of |
| :class:`Repr` to add support for additional built-in object types or to modify |
| the handling of types already supported. This example shows how special support |
| for file objects could be added:: |
| |
n | import repr |
n | import repr as reprlib |
| import sys |
| |
n | class MyRepr(repr.Repr): |
n | class MyRepr(reprlib.Repr): |
| def repr_file(self, obj, level): |
| if obj.name in ['<stdin>', '<stdout>', '<stderr>']: |
| return obj.name |
| else: |
t | return `obj` |
t | return repr(obj) |
| |
| aRepr = MyRepr() |
| print aRepr.repr(sys.stdin) # prints '<stdin>' |
| |