Python : Comment imprimer une classe ou objets de classe à l’aide de print() ?

Question

Je suis en train d'apprendre les ficelles du métier en Python. Lorsque j'essaie d'imprimer un objet de la classe Foobar à l'aide de l' print() fonction, je obtenir un résultat comme ceci:

<__main__.Foobar instance at 0x7ff2a18c>

Est-il possible que je peux configurer l' impression comportement (ou de la représentation de chaîne) d'une classe et de ses objets? Par exemple, quand je l'appelle print() sur un objet de classe, je voudrais imprimer ses membres de données dans un certain format. Comment atteindre cet objectif en Python?

Si vous êtes familier avec des classes C++, le ci-dessus peut être réalisé de la norme ostream par l'ajout d'un friend ostream& operator << (ostream&, const Foobar&) méthode de la classe.

Answer 1

>>> class Test:
...     def __repr__(self):
...         return "Test()"
...     def __str__(self):
...         return "member of Test"
... 
>>> t = Test()
>>> t
Test()
>>> print t
member of Test

L' __str__ méthode est ce qui se passe lors de l'impression, et l' __repr__ méthode est ce qui arrive lorsque vous utilisez l' repr() de la fonction (ou quand vous le regardez avec l'invite de commandes). Si ce n'est pas le plus Pythonic méthode, je m'excuse, parce que je suis encore à apprendre trop, mais il fonctionne.

Si aucun __str__ la méthode est donnée, Python imprimer le résultat d' __repr__ à la place. Si vous définissez __str__ mais pas __repr__, Python va utiliser ce que vous voyez ci-dessus que l' __repr__, mais toujours utiliser __str__ pour l'impression.

Answer 2

Comme Chris Lutz mentionné, cela est défini par l' __repr__ méthode dans votre classe.

À partir de la documentation de l' repr():

Pour de nombreux types, cette fonction fait une tentative de retour à une chaîne qui donnerait un objet avec la même valeur lorsqu'il est passé à l' eval(), sinon la représentation est une chaîne de caractères placée entre crochets qui contient le nom du type de l'objet avec de l'information supplémentaire, souvent, y compris le nom et l'adresse de l'objet. Une classe peut contrôler ce que cette fonction renvoie pour son cas par la définition d'un __repr__() méthode.

Compte tenu de la suite de la classe de Test:

class Test:
    def __init__(self, a, b):
        self.a = a
        self.b = b

    def __repr__(self):
        return "<Test a:%s b:%s>" % (self.a, self.b)

    def __str__(self):
        return "From str method of Test: a is %s, b is %s" % (self.a, self.b)

..il s'agira de la manière suivante dans l'interface Python:

>>> t = Test(123, 456)
>>> t
<Test a:123 b:456>
>>> print repr(t)
<Test a:123 b:456>
>>> print t
From str method of Test: a is 123, b is 456
>>> print str(t)
From str method of Test: a is 123, b is 456

Si aucun __str__ méthode est définie, print t (ou print str(t)) va utiliser le résultat d' __repr__ au lieu

Si aucun __repr__ méthode est définie, la valeur par défaut est utilisé, qui est à peu près l'équivalent de..

def __repr__(self):
    return "<%s instance at %s>" % (self.__class__.__name__, id(self))

Answer 3

Juste pour ajouter mon grain de sel à @dbr réponse, voici un exemple de la façon de mettre cette phrase à partir de la documentation officielle qu'il a citées:

"[...] pour retourner une chaîne qui donnerait un objet avec la même valeur lorsqu'il est passé à la fonction eval(), [...]"

Compte tenu de cette définition de la classe:

class Test(object):
    def __init__(self, a, b):
        self._a = a
        self._b = b

    def __str__(self):
        return "An instance of class Test with state: a=%s b=%s" % (self._a, self._b)

    def __repr__(self):
        return 'Test("%s","%s")' % (self._a, self._b)

Maintenant, il est facile à sérialiser instance de Test classe:

x = Test('hello', 'world')
print 'Human readable: ', str(x)
print 'Object representation: ', repr(x)
print

y = eval(repr(x))
print 'Human readable: ', str(y)
print 'Object representation: ', repr(y)
print

Ainsi, l'exécution dernier morceau de code, nous allons obtenir:

Human readable:  An instance of class Test with state: a=hello b=world
Object representation:  Test("hello","world")

Human readable:  An instance of class Test with state: a=hello b=world
Object representation:  Test("hello","world")

Mais, comme je l'ai dit dans mon dernier commentaire: plus d'infos juste ici!

Answer 4

Vous devez utiliser réimpr. Il s’agit d’une fonction standard comme init. Par exemple :