# `reprlib` — Implementação alternativa à `repr()`

Código-fonte: 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 fornece uma classe, uma instância e uma função.

class `reprlib.``Repr`

  Classe que fornece serviços de formatação úteis na implementação de funções semelhantes à embutida `repr()`; limites de tamanho para diferentes tipos de objetos são adicionados para evitar a geração de representações excessivamente longas.

`reprlib.``aRepr`

  Esta é uma instância de `Repr` que é usada para fornecer a função `repr()` descrita abaixo. Alterar os atributos deste objeto afetará os limites de tamanho usados por `repr()` e pelo depurador Python.

`reprlib.``repr`(obj)

  Este é o método `repr()` de `aRepr`. Ele retorna uma string semelhante à retornada pela função embutida de mesmo nome, mas com limites na maioria dos tamanhos.

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

  Novo na versão 3.2.

## Objetos Repr

Instâncias `Repr` fornecem vários atributos que podem ser usados para fornecer limites de tamanho para as representações de diferentes tipos de objetos e métodos que formatam tipos de objetos específicos.

`Repr.``maxlevel`

  Limite de profundidade na criação de representações recursivas. O padrão é `6`.

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

  Limites no número de entradas representadas para o tipo de objeto nomeado. O padrão é `4` para `maxdict`, `5` para `maxarray` e `6` para os demais.

`Repr.``maxlong`

  Número máximo de caracteres na representação para um inteiro. Os dígitos são omitidos a partir do meio. O padrão é `40`.

`Repr.``maxstring`

  Limite no número de caracteres na representação da string. Observe que a representação “normal” da string é usada como fonte de caracteres: se sequências de escape forem necessárias na representação, elas poderão ser distorcidas quando a representação for encurtada. O padrão é `30`.

`Repr.``maxother`

  Este limite é usado para controlar o tamanho de tipos de objetos para os quais nenhum método de formatação específico está disponível no objeto `Repr`. Ele é aplicado de maneira semelhante a `maxstring`. O padrão é `20`.

`Repr.``repr`(obj)

  O equivalente ao `repr()` embutido que usa a formatação imposta pela instância.

`Repr.``repr1`(obj, level)

  Implementação recursiva usada por `repr()`. Esta usa o tipo de obj para determinar qual método de formatação chamar, passando obj e level. Os métodos específicos de tipo devem chamar `repr1()` para realizar a formatação recursiva, com `level - 1` para o valor de level na chamada recursiva.

`Repr.``repr_TYPE`(obj, level)

  Métodos de formatação para tipos específicos são implementados como métodos com um nome baseado no nome do tipo. No nome do método, TYPE é substituído por `'_'.join(type(obj).__name__.split())`. O despacho para esses métodos é tratado por `repr1()`. Métodos específicos de tipo que precisam formatar um valor recursivamente devem chamar `self.repr1(subobj, level - 1)`.

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