PyQuiz 27 – __str__ personalizado en Python

El reto

class Punto:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    def __str__(self):
        return f'({self.x}, {self.y})'
p = Punto(3, 4)
print(p)

¿Cuál es el resultado?

• a) (3, 4)
• b) <Punto object>
• c) Error

Piensa tu respuesta antes de seguir leyendo…

Concepto: __str__ personalizado

El método especial __str__ define cómo se convierte un objeto a cadena de texto cuando se usa str(objeto) o se pasa a print(). Es parte del protocolo de representación de objetos en Python y permite controlar lo que el usuario ve al imprimir una instancia de una clase.

Sin __str__, Python usa una representación por defecto como <NombreClase object at 0x...>, que muestra la dirección de memoria y no aporta información útil. Al definir __str__, puedes devolver cualquier cadena descriptiva.

Existe también __repr__, pensado para desarrolladores: devuelve una representación inequívoca del objeto, ideal para depuración. Si __str__ no está definido, Python usa __repr__ como sustituto. La convención es: __str__ para el usuario final, __repr__ para el desarrollador.

Paso a paso

1. class Punto: — se define una clase llamada Punto.
2. def __init__(self, x, y): self.x = x; self.y = y — el constructor almacena las coordenadas x e y como atributos del objeto.
3. def __str__(self): return f'({self.x}, {self.y})' — se define el método especial __str__. Devolverá la cadena '(3, 4)' para este objeto.
4. p = Punto(3, 4) — se crea una instancia con x=3 e y=4.
5. print(p) — print() llama internamente a str(p), que a su vez invoca p.__str__(). El método devuelve '(3, 4)', que es lo que se imprime.

Solución

Respuesta correcta: A) (3, 4)

__str__ define cómo se muestra el objeto con print(). Retorna '(3, 4)'.

Sabías que…

Además de __str__, Python tiene un ecosistema de métodos especiales (dunder methods) que permiten que tus objetos se comporten como tipos nativos:

class Punto:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __str__(self):
        return f'({self.x}, {self.y})'  # para print()

    def __repr__(self):
        return f'Punto({self.x}, {self.y})'  # para el REPL y depuración

    def __add__(self, otro):
        return Punto(self.x + otro.x, self.y + otro.y)

    def __eq__(self, otro):
        return self.x == otro.x and self.y == otro.y

p1 = Punto(1, 2)
p2 = Punto(3, 4)
print(p1 + p2)      # (4, 6) -> usa __add__ y __str__
print(p1 == p1)     # True  -> usa __eq__
print(repr(p1))     # Punto(1, 2) -> usa __repr__
print([p1])         # [Punto(1, 2)] -> listas usan __repr__

Prueba tú mismo

Añade un método __repr__ a la clase Punto que devuelva 'Punto(x=3, y=4)'. ¿Qué imprime repr(Punto(3, 4))?

Más PyQuizzes en elpythonista.com/pyquizzes

Tutorial relacionado: Tutorial de Python