Objetivo do __repr__ do Python

def __repr__(self):
  return '<%s %s (%s:%s) %s>' % (
    self.__class__.__name__, self.urlconf_name, self.app_name,
    self.namespace, self.regex.pattern)

Qual é o significado / objetivo deste método?

__repr__deve retornar uma representação imprimível do objeto, provavelmente uma das maneiras possíveis para criar esse objeto. Veja a documentação oficial aqui . __repr__é mais para desenvolvedores e __str__para usuários finais.

Um exemplo simples:

>>> class Point:
...   def __init__(self, x, y):
...     self.x, self.y = x, y
...   def __repr__(self):
...     return 'Point(x=%s, y=%s)' % (self.x, self.y)
>>> p = Point(1, 2)
>>> p
Point(x=1, y=2)

Isso é explicado muito bem na documentação do Python :

repr ( objeto ): retorna uma string contendo uma representação imprimível de um objeto. Esse é o mesmo valor gerado pelas conversões (aspas reversas). Às vezes, é útil poder acessar esta operação como uma função comum. Para muitos tipos, essa função tenta retornar uma sequência que produziria um objeto com o mesmo valor quando passado para eval()outra função ; caso contrário, a representação é uma sequência entre colchetes angulares que contém o nome do tipo do objeto juntamente com informações adicionais geralmente incluindo o nome e o endereço do objeto. Uma classe pode controlar o que essa função retorna para suas instâncias, definindo um __repr__()método.

Então, o que você está vendo aqui é a implementação padrão __repr__, útil para serialização e depuração.

__repr__é usado pelo interpretador Python independente para exibir uma classe em formato imprimível. Exemplo:

~> python3.5
Python 3.5.1 (v3.5.1:37a07cee5969, Dec  5 2015, 21:12:44) 
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> class StackOverflowDemo:
...     def __init__(self):
...         pass
...     def __repr__(self):
...         return '<StackOverflow demo object __repr__>'
... 
>>> demo = StackOverflowDemo()
>>> demo
<StackOverflow demo object __repr__>

Nos casos em que um __str__método não está definido na classe, ele chamará a __repr__função na tentativa de criar uma representação imprimível.

>>> str(demo)
'<StackOverflow demo object __repr__>'

Além disso, print()a classe chamará __str__por padrão.

Documentação , por favor

O método __repr__ simplesmente informa ao Python como imprimir objetos de uma classe

Um exemplo para ver as diferenças entre eles (copiei desta fonte ),

>>> x=4
>>> repr(x)
'4'
>>> str(x)
'4'
>>> y='stringy'
>>> repr(y)
"'stringy'"
>>> str(y)
'stringy'

Os retornos de repr()e str()são idênticos para int x, mas há uma diferença entre os valores de retorno para str y- um é formal e o outro é informal . Uma das diferenças mais importantes entre as representações formais e informais é que a implementação padrão de __repr__um valor de str pode ser chamada como um argumento para avaliar, e o valor de retorno seria um objeto de string válido, como este:

>>> repr(y)
"'a string'"
>>> y2=eval(repr(y))
>>> y==y2
True

Se você tentar chamar o valor de retorno __str__como um argumento para avaliar, o resultado não será válido.

Quando criamos novos tipos definindo classes, podemos tirar proveito de certos recursos do Python para tornar as novas classes convenientes de usar. Um desses recursos é "métodos especiais", também chamados de "métodos mágicos".

Métodos especiais têm nomes que começam e terminam com dois sublinhados. Nós os definimos, mas geralmente não os chamamos diretamente pelo nome. Em vez disso, eles são executados automaticamente sob circunstâncias específicas.

É conveniente poder gerar o valor de uma instância de um objeto usando uma instrução print. Quando fazemos isso, gostaríamos que o valor fosse representado na saída em algum formato inequívoco compreensível. O método especial repr pode ser usado para organizar isso. Se definirmos esse método, ele poderá ser chamado automaticamente quando imprimirmos o valor de uma instância de uma classe para a qual definimos esse método. Deve-se mencionar, no entanto, que também existe um método especial str , usado para uma finalidade semelhante, mas não idêntica, que pode ter precedência, se também o tivermos definido.

Se não definimos, o método repr para a classe Point3D e instanciamos my_point como uma instância do Point3D, e fazemos isso ...

print my_point ... podemos ver isso como a saída ...

Não é muito legal, né?

Portanto, definimos o método especial repr ou str , ou ambos, para obter uma saída melhor.

**class Point3D(object):
    def __init__(self,a,b,c):
        self.x = a
        self.y = b
        self.z = c
    def __repr__(self):
        return "Point3D(%d, %d, %d)" % (self.x, self.y, self.z)
    def __str__(self):
        return "(%d, %d, %d)" % (self.x, self.y, self.z)
my_point = Point3D(1, 2, 3)
print my_point # __repr__ gets called automatically
print my_point # __str__ gets called automatically**

Resultado ...

(1, 2, 3) (1, 2, 3)

Implemente repr para cada classe que você implementar. Não deve haver desculpa. Implemente str para classes que você acha que a legibilidade é mais importante da não ambiguidade.

Consulte este link: https://www.pythoncentral.io/what-is-the-difference-between- str -and- repr -in-python /