Objectif de __repr__ de Python

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

Quelle est la signification / le but de cette méthode?

__repr__doit renvoyer une représentation imprimable de l'objet, probablement l' une des manières possibles de créer cet objet. Voir la documentation officielle ici . __repr__est plus pour les développeurs que __str__pour les utilisateurs finaux.

Un exemple simple:

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

Ceci est assez bien expliqué dans la documentation Python :

repr ( object ): renvoie une chaîne contenant une représentation imprimable d'un objet. C'est la même valeur produite par les conversions (guillemets inversés). Il est parfois utile de pouvoir accéder à cette opération comme une fonction ordinaire. Pour de nombreux types, cette fonction tente de renvoyer une chaîne qui donnerait un objet avec la même valeur lorsqu'elle est passée à eval(), sinon la représentation est une chaîne entre crochets qui contient le nom du type de l'objet avec des informations supplémentaires comprenant souvent le nom et l'adresse de l'objet. Une classe peut contrôler ce que cette fonction renvoie pour ses instances en définissant une __repr__()méthode.

Donc, ce que vous voyez ici est l'implémentation par défaut de __repr__, qui est utile pour la sérialisation et le débogage.

__repr__est utilisé par l'interpréteur Python autonome pour afficher une classe au format imprimable. Exemple:

~> 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__>

Dans les cas où une __str__méthode n'est pas définie dans la classe, elle appellera la __repr__fonction pour tenter de créer une représentation imprimable.

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

De plus, print()la classe appellera __str__par défaut.

Documentation , s'il vous plaît

La méthode __repr__ indique simplement à Python comment imprimer les objets d'une classe

Un exemple pour voir les différences entre eux (j'ai copié à partir de cette source ),

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

Les retours de repr()et str()sont identiques pour int x, mais il y a une différence entre les valeurs de retour pour str y- l'un est formel et l'autre est informel . L'une des différences les plus importantes entre les représentations formelles et informelles est que l'implémentation par défaut de __repr__pour une valeur str peut être appelée en tant qu'argument pour eval, et la valeur de retour serait un objet chaîne valide, comme ceci:

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

Si vous essayez d'appeler la valeur de retour de __str__comme argument à eval, le résultat ne sera pas valide.

Lorsque nous créons de nouveaux types en définissant des classes, nous pouvons profiter de certaines fonctionnalités de Python pour rendre les nouvelles classes pratiques à utiliser. L'une de ces caractéristiques est les «méthodes spéciales», également appelées «méthodes magiques».

Les méthodes spéciales ont des noms qui commencent et se terminent par deux traits de soulignement. Nous les définissons, mais nous ne les appelons généralement pas directement par leur nom. Au lieu de cela, ils s'exécutent automatiquement dans des circonstances spécifiques.

Il est pratique de pouvoir afficher la valeur d'une instance d'un objet à l'aide d'une instruction d'impression. Lorsque nous faisons cela, nous aimerions que la valeur soit représentée dans la sortie dans un format compréhensible et non ambigu. La méthode spéciale repr peut être utilisée pour faire en sorte que cela se produise. Si nous définissons cette méthode, elle peut être appelée automatiquement lorsque nous imprimons la valeur d'une instance d'une classe pour laquelle nous avons défini cette méthode. Il faut cependant mentionner qu'il existe également une méthode spéciale str , utilisée dans un but similaire, mais pas identique, qui peut avoir la priorité, si nous l'avons également définie.

Si nous n'avons pas défini, la méthode repr pour la classe Point3D, et avons instancié my_point en tant qu'instance de Point3D, puis nous faisons ceci ...

print my_point ... nous pouvons voir cela comme la sortie ...

Pas très gentil, hein?

Donc, nous définissons la méthode spéciale repr ou str , ou les deux, pour obtenir un meilleur résultat.

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

Production ...

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

Implémentez repr pour chaque classe que vous implémentez. Il ne devrait y avoir aucune excuse. Implémentez str pour les classes dont vous pensez que la lisibilité est plus importante que la non-ambiguïté.

Reportez-vous à ce lien: https://www.pythoncentral.io/what-is-the-difference-between- str -and- repr -in-python /