Diferencias entre str y repr en Python

Las clases de Python tienen por defecto dos métodos que a primera vista pueden parecen el mismo __str__ y __repr__. Aunque realmente son diferentes. Por eso, para acceder a cada una de los métodos Python cuenta con dos funciones diferentes: str() y repr(). A la hora de crear nuestros objetos es necesario conocer cuales son las diferencias existen y cuando se deben usar str y repr en Python.

Los métodos en los tipos primitivos

En primer lugar, podemos ver qué pasa al usar las funciones str y repr de Python en tipos de datos primitivos. Así, podemos ver que pasa cuando se utilizan con enteros.

valor = 12

str(valor)   # '12'
repr(valor)  # '12'

No se aprecia ninguna diferencia entre uno y otro. Lo que nos puede inducir a pensar que son el mismo. Pero no sucede los mismo cuando se trabaja con otros tipos de datos como pueden ser las cadenas de texto.

cadena = 'cadena'

str(cadena)  # 'cadena'
repr(cadena) # "'cadena'"

En este caso se observa una pequeña diferencia, la función str devuelve la cadena de texto mientras que repr devuelve una cadena de texto dentro de otra. Lo que indica que no son la misma función.

Diferencias entre str y repr en Python

Ahora podemos enumerar cuales son las principales diferencias que existe entre las dos funciones son:

• En el método __str__ debe usarse para crear los mensajes que serán presentados al usuario final, por lo que deben ser fácilmente legibles. Mientras que el método __repr__ se usa para depuración y desarrollo, por lo que sus mensajes ha de ser inequívocos.
• Además, __repr__ calcula la representación de cadena “oficial” de un objeto y __str__ se usa para calcular la representación de cadena “informal” de un objeto. Por lo que la primera ha de contener más información que la segunda.
• La función print() usa __str__, al igual que la función str() para generar la cadena que representa al objeto. Solo si no se ha definido una implementación de __str__, las dos funciones usarán la implementación que exista de __repr__.

Implementación en clases

Ahora podemos crear una clase para ver nos devuelve por defecto ambas funciones.

class Clase():
    def __init__(self, valor):
        self.valor = valor

clase = Clase('uno')

str(clase)  # '<__main__.Clase object at 0x7fd903d330d0>'
repr(clase) # '<__main__.Clase object at 0x7fd903d330d0>'

Lo primero que podemos ver es que no devuelve el nombre del objeto seguido de un de un de un identificador en ambos casos. Esto es porque, como no se ha definido el método __str__ ambos usan la misma definición por defecto.

Ahora se puede definir la función __str__ para comprobar que el resultado de str() cambia, pero no el de repr()(salvo el identificador del objeto que es algo de esperar, ya que no es el mismo que antes).

class Clase():
    def __init__(self, valor):
        self.valor = valor

    def __str__(self):
        return f'El valor es {valor}'

clase = Clase('uno')

str(clase)  # 'El valor es 12'
repr(clase) # '<__main__.Clase object at 0x7fd903d33ad0>'

Finalmente se puede implementar únicamente el método __repr__, para comprobar que este reemplaza a __str__ cuando no se ha definido.

class Clase():
    def __init__(self, valor):
        self.valor = valor

    def __repr__(self):
        return f'{self.__class__.__name__}({repr(self.valor)})'

clase = Clase('uno')

str(clase)  # "Clase('uno')"
repr(clase) # "Clase('uno')"

El uso de eval

Es aconsejable que cuando implementemos nuestros el métodos __repr__ en nuestras clases estos puedan ser interpretados por eval(). Pudiendo así construir el objeto a partir del mensaje. Algo que sucede en el ejemplo anterior.

Conclusiones

En la entrada de hoy se ha visto las diferencias entre str y repr en Python, dos métodos que existen en todos los objetos y, a primera vista, pueden parecer los mismos. Hemos descubierto que básicamente __str__ se debe utilizar para crear la salida que se le mostrará al usuario, mientras que __repr__ para usar en depuración. Pudiendo disponer de esta manera de diferentes mensajes, con diferente grado de detalle, en función de que el código se ejecute en producción o mientras se esta depurando durante su escritura o mantenimiento.

Imagen de S. Hermann & F. Richter en Pixabay