Différence entre __str__ et __repr__ en Python

Question

Quelle est la différence entre __str__ et __repr__ en Python ?

Answer 1

Alex a bien résumé mais, étonnamment, il a été trop succinct.

Tout d'abord, permettez-moi de réitérer les principaux points du post d'Alex :

• L'implémentation par défaut est inutile (il est difficile de penser à une implémentation qui ne le serait pas, mais oui)
• __repr__ l'objectif est d'être sans ambiguïté
• __str__ l'objectif est d'être lisible
• Container's __str__ utilise les "objets contenus". __repr__

L'implémentation par défaut est inutile

C'est surtout une surprise car les valeurs par défaut de Python ont tendance à être assez utiles. Cependant, dans ce cas, le fait d'avoir une valeur par défaut pour le paramètre __repr__ qui agirait comme :

return "%s(%r)" % (self.__class__, self.__dict__)

aurait été trop dangereux (par exemple, trop facile de se retrouver dans une récursion infinie si les objets se référencent les uns les autres). Donc Python s'en sort. Notez qu'il existe un défaut qui est vrai : si __repr__ est défini, et __str__ ne l'est pas, l'objet se comportera comme si __str__=__repr__ .

Cela signifie, en termes simples, que presque chaque objet que vous implémentez doit avoir une fonction __repr__ qui soit utilisable pour comprendre l'objet. Mise en œuvre de __str__ est facultatif : faites-le si vous avez besoin d'une fonctionnalité de "jolie impression" (par exemple, utilisée par un générateur de rapports).

L'objectif de __repr__ doit être sans ambiguïté

Permettez-moi de le dire franchement : je ne crois pas aux débogueurs. Je ne sais pas vraiment comment utiliser un débogueur, et je n'en ai jamais utilisé un sérieusement. De plus, je crois que le grand défaut des débogueurs est leur nature même - la plupart des échecs que je débogue se sont produits il y a très longtemps, dans une galaxie très lointaine. Cela signifie que je crois, avec une ferveur religieuse, à la journalisation. La journalisation est l'élément vital de tout système de serveur décent "fire-and-forget". Python facilite la journalisation : avec peut-être quelques wrappers spécifiques à un projet, tout ce dont vous avez besoin est un fichier de type

log(INFO, "I am in the weird function and a is", a, "and b is", b, "but I got a null C — using default", default_c)

Mais vous devez faire la dernière étape - vous assurer que chaque objet que vous implémentez a une représentation utile, afin que le code comme celui-ci puisse fonctionner. C'est pour cela que l'on parle de "eval" : si vous avez suffisamment d'informations pour que eval(repr(c))==c cela signifie que vous savez tout ce qu'il y a à savoir sur c . Si c'est assez facile, au moins de manière floue, faites-le. Sinon, assurez-vous d'avoir suffisamment d'informations sur les points suivants c de toute façon. J'utilise généralement un format de type eval : "MyClass(this=%r,that=%r)" % (self.this,self.that) . Cela ne signifie pas que vous pouvez réellement construire MyClass, ou que ce sont les bons arguments du constructeur - mais c'est une forme utile pour exprimer "c'est tout ce que vous devez savoir sur cette instance".

Note : J'ai utilisé %r ci-dessus, pas %s . Vous voulez toujours utiliser repr() [ou %r caractère de formatage, de manière équivalente] à l'intérieur __repr__ ou vous allez à l'encontre de l'objectif de la répression. Vous voulez être capable de différencier MyClass(3) et MyClass("3") .

L'objectif de __str__ est d'être lisible

Plus précisément, il n'est pas destiné à être sans ambiguïté - remarquez que str(3)==str("3") . De la même manière, si vous implémentez une abstraction IP, le fait que la chaîne de caractères ressemble à 192.168.1.1 est tout à fait acceptable. Lorsque vous implémentez une abstraction de date/heure, la chaîne peut être "2010/4/12 15:35:22", etc. L'objectif est de la représenter de manière à ce qu'un utilisateur, et non un programmeur, veuille la lire. Supprimez les chiffres inutiles, faites semblant d'être une autre classe - tant que cela permet la lisibilité, c'est une amélioration.

Container's __str__ utilise les "objets contenus". __repr__

Cela semble surprenant, n'est-ce pas ? C'est un peu, mais à quel point serait-il lisible

[moshe is, 3, hello
world, this is a list, oh I don't know, containing just 4 elements]

être ? Pas vraiment. Plus précisément, les chaînes d'un conteneur trouveraient qu'il est beaucoup trop facile de perturber sa représentation des chaînes. Face à l'ambiguïté, rappelez-vous que Python résiste à la tentation de deviner. Si vous voulez le comportement ci-dessus lorsque vous imprimez une liste, il suffit de

print "["+", ".join(l)+"]"

(vous pouvez probablement aussi trouver une solution pour les dictionnaires.

Résumé

Mettre en œuvre __repr__ pour toute classe que vous implémentez. Cela devrait être une seconde nature. Implémenter __str__ si vous pensez qu'il serait utile de disposer d'une version de chaîne de caractères qui privilégie la lisibilité au détriment de l'ambiguïté.

Answer 2

Ma règle d'or : __repr__ s'adresse aux développeurs, __str__ est destiné aux clients.

Answer 3

À moins que vous n'agissiez spécifiquement pour qu'il en soit autrement, la plupart des cours n'ont pas de résultats utiles pour l'un ou l'autre :

>>> class Sic(object): pass
... 
>>> print str(Sic())
<__main__.Sic object at 0x8b7d0>
>>> print repr(Sic())
<__main__.Sic object at 0x8b7d0>
>>>

Comme vous le voyez, il n'y a pas de différence, et aucune information autre que la classe et le nom de l'objet. id . Si vous ne dérogez qu'à l'un des deux... :

>>> class Sic(object): 
...   def __repr__(object): return 'foo'
... 
>>> print str(Sic())
foo
>>> print repr(Sic())
foo
>>> class Sic(object):
...   def __str__(object): return 'foo'
... 
>>> print str(Sic())
foo
>>> print repr(Sic())
<__main__.Sic object at 0x2617f0>
>>>

comme vous le voyez, si vous remplacez __repr__ qui est AUSSI utilisé pour __str__ mais pas l'inverse.

Autres informations importantes à connaître : __str__ sur un conteneur construit utilise l'option __repr__ et non le __str__ pour les articles qu'il contient. Et, malgré les mots sur le sujet que l'on trouve dans les docs typiques, presque personne ne se soucie de faire l'effort de faire l'inventaire des éléments. __repr__ d'objets est une chaîne de caractères qui eval peut utiliser pour construire un objet équivalent (c'est tout simplement trop difficile, et le fait de ne pas savoir comment le module concerné a été importé rend la chose carrément impossible).

Donc, mon conseil : concentrez-vous sur la réalisation __str__ raisonnablement lisible par l'homme, et __repr__ le moins ambigu possible, même si cela interfère avec l'objectif flou et irréalisable de rendre __repr__ La valeur retournée par l'utilisateur est acceptable comme entrée pour __eval__ !

Answer 4

En bref, l'objectif de __repr__ doit être sans ambiguïté et __str__ est d'être lisible.

Voici un bon exemple :

>>> import datetime
>>> today = datetime.datetime.now()
>>> str(today)
'2012-03-14 09:21:58.130922'
>>> repr(today)
'datetime.datetime(2012, 3, 14, 9, 21, 58, 130922)'

Lisez cette documentation pour en savoir plus :

repr(object)

Renvoie une chaîne de caractères contenant une représentation imprimable d'un objet. C'est la même valeur que celle obtenue par les conversions (guillemets inversés). guillemets inversés). Il est parfois utile de pouvoir accéder à cette opération en tant que une fonction ordinaire. Pour de nombreux types, cette fonction tente de retourner une chaîne de caractères qui donnerait un objet de même valeur lorsqu'elle est passé à eval() sinon, la représentation est une chaîne de caractères entre entre crochets qui contient le nom du type de l'objet ainsi que 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 un paramètre __repr__() méthode.

Voici la documentation pour str :

str(object='')

Retourne une chaîne de caractères contenant une représentation d'un objet. Pour les chaînes de caractères, cela renvoie la chaîne elle-même. La différence avec repr(object) c'est que str(object) ne ne tente pas toujours de retourner une chaîne de caractères acceptable pour eval() ; son objectif est de retourner une chaîne imprimable. Si aucun argument n'est donné, retourne la chaîne vide, '' .

Answer 5

__repr__ Représentation d'un objet python. En général, eval le convertit en cet objet.

__str__ : est ce que vous pensez être cet objet sous forme de texte.

par exemple

>>> s="""w'o"w"""
>>> repr(s)
'\'w\\\'o"w\''
>>> str(s)
'w\'o"w'
>>> eval(str(s))==s
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<string>", line 1
    w'o"w
       ^
SyntaxError: EOL while scanning single-quoted string
>>> eval(repr(s))==s
True