Realmente no entiendo dónde están __str__y dónde se __repr__usan en Python. Quiero decir, entiendo que __str__devuelve la representación de cadena de un objeto. Pero, ¿por qué necesitaría eso? ¿En qué escenario de caso de uso? Además, leí sobre el uso de__repr__

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

__repr__

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

__str__

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

Úselo __str__si tiene una clase y querrá una salida informativa / informal, siempre que use este objeto como parte de una cadena. Por ejemplo, puede definir __str__métodos para los modelos de Django, que luego se renderizan en la interfaz de administración de Django. En lugar de algo como <Model object>, recibirás el 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 BaseSetclase sets.pyde 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__

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

>>> 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 por humanos, mientras que el __repr__objetivo debe ser algo que pueda usarse para recrear el objeto, aunque a menudo no será exactamente como se creó, como en este caso.

Tampoco es inusual para ambos __str__y __repr__para devolver el mismo valor (sobre todo para los tipos predefinidos).

Saltamontes, en caso de duda ve a la montaña y lee los Textos Antiguos . En ellos encontrarás que __repr __ () debería:

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

Construyendo y sobre las respuestas anteriores y mostrando algunos ejemplos más. Si se usa correctamente, la diferencia entre stry repres clara. En resumen reprdebe devolver una cadena que puede ser distribuido, copiado-pegado a reconstruir el estado exacto del objeto, mientras que stres útil para loggingy observingresultados de depuración. A continuación se muestran algunos ejemplos para ver las diferentes salidas de 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 stres bueno para imprimir en un archivo de registro, donde como reprpuede ser re-utilizados si desea ejecutarlo directamente o descargarla 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 el repres nuevamente consumible directamente.

Ejemplo de Vector3 personalizado

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

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

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

En este ejemplo, reprdevuelve de nuevo una cadena que se puede consumir / ejecutar directamente, mientras que stres más útil como salida de depuración.

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

Una cosa a tener en cuenta, si strno está definida repr, strllamará automáticamente repr. Entonces, siempre es bueno al menos definirrepr

Tengamos una clase sin __str__función.

class Employee:

    def __init__(self, first, last, pay):
        self.first = first 
        self.last = last
        self.pay = pay

emp1 = Employee('Ivan', 'Smith', 90000)

print(emp1)

Cuando imprimimos esta instancia de la clase emp1, esto es lo que obtenemos:

<__main__.Employee object at 0x7ff6fc0a0e48>

Esto no es muy útil, y ciertamente esto no es lo que queremos imprimir si lo estamos usando para mostrar (como en html)

Entonces ahora, la misma clase, pero con __str__función:

class Employee:

    def __init__(self, first, last, pay):
        self.first = first 
        self.last = last
        self.pay = pay

    def __str__(self):
        return(f"The employee {self.first} {self.last} earns {self.pay}.")
        # you can edit this and use any attributes of the class

emp2 = Employee('John', 'Williams', 90000)

print(emp2)

Ahora, en lugar de imprimir que hay un objeto, obtenemos lo que especificamos con el retorno de la __str__función:

The employee John Williams earns 90000

strserá un formato informal y legible, mientras que reprofrecerá una representación oficial del objeto.

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

str y repr son ambas formas de representar. Puede usarlos cuando esté escribiendo una clase.

class Fraction:
def __init__(self, n, d):
    self.n = n
    self.d = d
def __repr__(self):
    return "{}/{}".format(self.n, self.d)

por ejemplo, cuando imprimo una instancia, devuelve cosas.

print(Fraction(1, 2))

resultados en

1/2

mientras

class Fraction:
def __init__(self, n, d):
    self.n = n
    self.d = d
def __str__(self):
    return "{}/{}".format(self.n, self.d)
print(Fraction(1, 2))

también resulta en

1/2

Pero, ¿qué pasa si escribes ambos, cuál usa Python?

class Fraction:
def __init__(self, n, d):
    self.n = n
    self.d = d
def __str__(self):
    return "str"
def __repr__(self):
    return "repr"

print(Fraction(None, None))

Esto resulta en

str

Entonces, Python realmente usa el método str , no el método repr cuando ambos están escritos.