# `reprlib` — Implementación `repr()` alternativa

Código fuente: Lib/reprlib.py

The `reprlib` module provides a means for producing object representations with limits on the size of the resulting strings. This is used in the Python debugger and may be useful in other contexts as well.

Este módulo provee una clase, una instancia y una función:

class reprlib.Repr

  Clase que provee de servicios de formateo útiles en la implementación de funciones similar a la integrada `repr()`; los límites de tamaño para diferentes tipos de objetos son añadidos para evitar la generación de representaciones que son excesivamente largas.

reprlib.aRepr

  Esta es una instancia de `Repr` que es usada para proveer la función `repr()` descrita debajo. Cambiar los atributos de este objeto afectará los límites de tamaño usados por `repr()` y el depurador de Python.

reprlib.repr(obj)

  Este es el método `repr()` de `aRepr`. Retorna una cadena similar a la retornada por la función integrada del mismo nombre, pero con límites en la mayoría de tamaños.

In addition to size-limiting tools, the module also provides a decorator for detecting recursive calls to `__repr__()` and substituting a placeholder string instead.

@reprlib.recursive_repr(fillvalue='...')

  Decorator for `__repr__()` methods to detect recursive calls within the same thread. If a recursive call is made, the fillvalue is returned, otherwise, the usual `__repr__()` call is made. For example:

      >>> from reprlib import recursive_repr
      >>> class MyList(list):
      ...     @recursive_repr()
      ...     def __repr__(self):
      ...         return '<' + '|'.join(map(repr, self)) + '>'
      ...
      >>> m = MyList('abc')
      >>> m.append(m)
      >>> m.append('x')
      >>> print(m)
      <'a'|'b'|'c'|...|'x'>

  Nuevo en la versión 3.2.

## Objetos Repr

Las instancias `Repr` proveen varios atributos que pueden ser usados para proporcionar límites de tamaño para las representaciones de diferentes tipos de objetos, y métodos que formatean tipos de objetos específicos.

Repr.fillvalue

  Esta cadena se muestra para referencias recursivas. El valor predeterminado es `...`.

  Nuevo en la versión 3.11.

Repr.maxlevel

  Límite de profundidad en la creación de representaciones recursivas. El valor por defecto es `6`.

Repr.maxdict
Repr.maxlist
Repr.maxtuple
Repr.maxset
Repr.maxfrozenset
Repr.maxdeque
Repr.maxarray

  Límites en el número de entradas representadas por el tipo de objeto nombrado. El valor por defecto es `4` para `maxdict`, `5` para `maxarray`, y `6` para los otros.

Repr.maxlong

  Máximo número de caracteres en la representación para un entero. Los dígitos son eliminados desde el medio. El valor por defecto es `40`.

Repr.maxstring

  Límite en el número de caracteres en la representación de la cadena. Fíjese que la representación «normal» de la cadena es la usada como la fuente de caracteres: si se necesitan secuencias de escape en la representación, estas pueden ser desordenadas cuando la representación se ha acortado. El valor por defecto es `30`.

Repr.maxother

  Este límite es usado para controlar el tamaño de los tipos de objetos para los cuales no hay ningún método de formateo específico en el objeto `Repr`. Se aplica de una manera similar a `maxstring`. El valor por defecto es `20`.

Repr.repr(obj)

  El equivalente a la función integrada `repr()` que usa el formateo impuesto por la instancia.

Repr.repr1(obj, level)

  Implementación recursiva usada por `repr()`. Este usa el tipo de obj para determinar qué método invocar, pasándole obj y level. Los métodos de tipo específico deben invocar `repr1()` para realizar formateo recursivo, con `level - 1` para el valor de level en la invocación recursiva.

Repr.repr_TYPE(obj, level)

  Métodos de formateo para tipos específicos son implementados como métodos con un nombre basado en el nombre del tipo. En el nombre del método, TYPE es reemplazado por `'_'.join(type(obj).__name__.split())`. El envío a estos métodos es gestionado por `repr1()`. Los métodos de tipo específico que necesitan formatear recursivamente un valor deben invocar `self.repr1(subobj, level - 1)`.

## Subclasificando Objetos Repr

The use of dynamic dispatching by `Repr.repr1()` allows subclasses of `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:

    import reprlib
    import sys

    class MyRepr(reprlib.Repr):

        def repr_TextIOWrapper(self, obj, level):
            if obj.name in {'<stdin>', '<stdout>', '<stderr>'}:
                return obj.name
            return repr(obj)

    aRepr = MyRepr()
    print(aRepr.repr(sys.stdin))         # prints '<stdin>'

    <stdin>