python - lenguaje - ¿Cuál es el propósito de__str__ y__repr__?

python tutorial

Question

Realmente no entiendo dónde se usan __str__ y __repr__ en Python. Quiero decir, entiendo que __str__ devuelve la representación de cadena de un objeto. Pero ¿por qué iba a necesitar eso? ¿En qué caso de caso de uso? Además, leí sobre el uso de __repr__

Pero lo que no entiendo es, ¿dónde los usaría?

Answer 1

Construyendo y en las respuestas anteriores y mostrando algunos ejemplos más. Si se usa correctamente, la diferencia entre str y repr es clara. En resumen, repr debería devolver una cadena que pueda copiarse y pegarse para reconstruir el estado exacto del objeto, mientras que str es útil para logging y observing resultados de la depuración. Aquí hay algunos ejemplos para ver las diferentes salidas para algunas bibliotecas conocidas.

Fecha y hora

print repr(datetime.now())    #datetime.datetime(2017, 12, 12, 18, 49, 27, 134411)
print str(datetime.now())     #2017-12-12 18:49:27.134452

El str es bueno para imprimir en un archivo de registro, donde se puede redirigir como repr si desea ejecutarlo directamente o volcarlo como comandos en un archivo.

x = datetime.datetime(2017, 12, 12, 18, 49, 27, 134411)

Numpy

print repr(np.array([1,2,3,4,5])) #array([1, 2, 3, 4, 5])
print str(np.array([1,2,3,4,5]))  #[1 2 3 4 5]

en Numpy, la repr vuelve a ser directamente consumible.

Ejemplo personalizado de Vector3

class Vector3(object):
    def __init__(self, args):
        self.x = args[0]
        self.y = args[1]
        self.z = args[2]

    def __repr__(self):
        return "x: {0}, y: {1}, z: {2}".format(self.x, self.y, self.z)

    def __str__(self):
        return "Vector3([{0},{1},{2}])".format(self.x, self.y, self.z)

En este ejemplo, repr devuelve nuevamente una cadena que se puede consumir / ejecutar directamente, mientras que str es más útil como salida de depuración.

v = Vector3([1,2,3])
print repr(v)    #Vector3([1,2,3])
print str(v)     #Vector(x:1, y:2, z:3)

Una cosa a tener en cuenta, si str no está definido, pero repr , str llamará automáticamente a repr . Entonces, siempre es bueno, al menos, definir repr

Answer 2

El único lugar donde los usa mucho es en una sesión interactiva. Si imprimes un objeto, entonces se llamará a su método __str__ , mientras que si solo usas un objeto por sí mismo, se muestra __repr__ :

>>> from decimal import Decimal
>>> a = Decimal(1.25)
>>> print(a)
1.25                  <---- this is from __str__
>>> a
Decimal(''1.25'')       <---- this is from __repr__

El __str__ está destinado a ser lo más legible posible, mientras que __repr__ debe ser algo que podría utilizarse para recrear el objeto, aunque a menudo no será exactamente como fue creado, como en este caso.

Tampoco es inusual que tanto __str__ como __repr__ devuelvan el mismo valor (sin duda para los tipos incorporados).

Answer 3

Saltamontes, cuando tengas dudas, ve a la montaña y __repr__ . En ellos, encontrará que __repr __ () debería:

Si es posible, debería parecer una expresión de Python válida que podría usarse para recrear un objeto con el mismo valor.

Answer 4

__repr__

Llamada por la función incorporada repr() y por las conversiones de cadena (comillas inversas) para calcular la representación de cadena "oficial" de un objeto. Si es posible, debería parecer una expresión de Python válida que podría usarse para recrear un objeto con el mismo valor (dado un entorno apropiado).

__str__

Llamada por la función incorporada str() y por la declaración de impresión para calcular la representación de cadena "informal" de un objeto.

Usa __str__ si tienes una clase, y querrás una salida informativa / informal, siempre que uses este objeto como parte de una cadena. Por ejemplo, puede definir los métodos __str__ para los modelos de Django, que luego se representan en la interfaz de administración de Django. En lugar de algo como <Model object> obtendrá como nombre y apellido de una persona, el nombre y la fecha de un evento, etc.

__repr__ y __str__ son similares, de hecho a veces iguales (Ejemplo de la clase sets.py en sets.py de la biblioteca estándar):

def __repr__(self):
    """Return string representation of a set.

    This looks like ''Set([<list of elements>])''.
    """
    return self._repr()

# __str__ is the same as __repr__
__str__ = __repr__

Answer 5

str será un formato informal y legible, mientras que repr dará representación oficial de objetos.

class Complex:
    # Constructor
    def __init__(self, real, imag):
        self.real = real
        self.imag = imag

    # "official" string representation of an object
    def __repr__(self):
        return ''Rational(%s, %s)'' % (self.real, self.imag)

    # "informal" string representation of an object (readable)
    def __str__(self):
        return ''%s + i%s'' % (self.real, self.imag)

    t = Complex(10, 20)

    print (t)     # this is usual way we print the object
    print (str(t))  # this is str representation of object 
    print (repr(t))  # this is repr representation of object   

Answers : 

Rational(10, 20) # usual representation
10 + i20      # str representation
Rational(10, 20)  # repr representation