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

Código fuente: Lib/reprlib.py

El módulo `reprlib` provee de los medios necesarios para producir representaciones de objetos con límites en el tamaño de las cadenas resultantes. Es usado en el depurador de Python y puede ser útil también en otros contextos.

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.

Además de las herramientas de limitación de tamaño, el módulo también provee un decorador para detectar invocaciones recursivas a `__repr__()` y sustituyendo por un marcador de posición de cadena en su lugar.

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

  Decorador para métodos `__repr__()` que detecta invocaciones recursivas dentro del mismo hilo. Si se produce una invocación recursiva, el fillvalue es retornado, si no, se produce la invocación `__repr__()` habitual. Por ejemplo:

      >>> 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.``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

El uso de envíos dinámicos por `Repr.repr1()` permite a las subclases de `Repr` añadir soporte para tipos adicionales de objetos integrados o modificar el manejo de tipos ya soportados. Este ejemplo muestra como el soporte especial para objetos de tipo archivo puede ser añadido.

    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>'