0Pricing
Python Academy · Lección

Métodos mágicos: __str__ y __repr__

Implemente métodos dunder para obtener representaciones legibles de los objetos.

Métodos mágicos: __str__ y __repr__ es una lección gratuita de Python Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Python Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Python Academy incluye 4 lecciones en total.

¿Qué son los métodos mágicos?

Los métodos mágicos (dunder) son métodos especiales con dobles guiones bajos que Python llama en contextos específicos, como al imprimir o comparar.

class Foo:
    def __str__(self):
        return "I am Foo"

f = Foo()
print(f)        # I am Foo
print(str(f))   # I am Foo

__repr__: representación para desarrolladores

__repr__ debe devolver una cadena inequívoca que, idealmente, permita recrear el objeto. Se muestra en el REPL y se usa mediante repr().

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

    def __repr__(self):
        return f"Point({self.x}, {self.y})"

p = Point(3, 4)
print(repr(p))  # Point(3, 4)

__str__: representación para usuarios

__str__ proporciona una cadena comprensible para las personas. print() y str() lo llaman. Si no existe, Python recurre a __repr__.

class Temperature:
    def __init__(self, celsius):
        self.celsius = celsius

    def __str__(self):
        return f"{self.celsius}°C"

    def __repr__(self):
        return f"Temperature({self.celsius})"

t = Temperature(100)
print(t)        # 100°C
print(repr(t))  # Temperature(100)

Cuándo se llama a cada uno

__str__: print(), str() y f-strings. __repr__: REPL, repr() y contenedores que muestran sus elementos.

class Item:
    def __str__(self): return "str"
    def __repr__(self): return "repr"

x = Item()
print(x)         # str
print([x])       # [repr]  ← list uses repr for elements

__format__ para formato personalizado

Defina __format__ para controlar cómo muestran su objeto las f-strings con especificaciones de formato.

class Money:
    def __init__(self, amount):
        self.amount = amount

    def __format__(self, spec):
        if spec == "usd":
            return f"${self.amount:.2f}"
        return str(self.amount)

m = Money(9.5)
print(f"{m:usd}")  # $9.50

__bool__ para la evaluación de verdad

__bool__ permite evaluar su objeto en contextos booleanos. Devuelva True o False.

class Bag:
    def __init__(self, items):
        self.items = items

    def __bool__(self):
        return len(self.items) > 0

b = Bag([])
if not b:
    print("Bag is empty")  # Bag is empty

__len__ para len()

__len__ permite usar len(obj). También se utiliza para __bool__ cuando no se define __bool__.

class Stack:
    def __init__(self):
        self.data = []

    def push(self, v): self.data.append(v)

    def __len__(self):
        return len(self.data)

s = Stack()
s.push(1)
print(len(s))  # 1

__eq__ para la igualdad

Defina __eq__ para especificar qué hace que dos instancias sean iguales mediante ==.

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

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

print(Vector(1,2) == Vector(1,2))  # True

__hash__ junto con __eq__

Cuando define __eq__, Python establece __hash__ en None, lo que hace que el objeto no sea hashable. Defina también __hash__ si necesita usar el objeto en conjuntos o diccionarios.

class Point:
    def __init__(self, x, y): self.x, self.y = x, y
    def __eq__(self, o): return (self.x, self.y) == (o.x, o.y)
    def __hash__(self): return hash((self.x, self.y))

pts = {Point(1,2), Point(1,2)}
print(len(pts))  # 1

__add__ y la aritmética

Los operadores aritméticos corresponden a métodos dunder: __add__ para +, __sub__ para -, etc.

class Vector:
    def __init__(self, x, y): self.x, self.y = x, y
    def __add__(self, o): return Vector(self.x+o.x, self.y+o.y)
    def __repr__(self): return f"Vector({self.x},{self.y})"

print(Vector(1,2) + Vector(3,4))  # Vector(4,6)

__getitem__ para la indexación

__getitem__ permite que su clase admita la indexación con corchetes, como obj[key].

class Matrix:
    def __init__(self, data):
        self.data = data

    def __getitem__(self, idx):
        return self.data[idx]

m = Matrix([[1,2],[3,4]])
print(m[0])     # [1, 2]
print(m[1][0])  # 3

Comprobación rápida

¿Qué método dunder se llama cuando usa print(obj)?

Repaso

Los métodos mágicos aportan un comportamiento idiomático de Python a sus clases. __repr__ está dirigido a los desarrolladores y __str__, a los usuarios. Defina __eq__, __hash__ y los métodos dunder aritméticos para que los objetos sean plenamente funcionales.

Preguntas frecuentes

¿La lección «Métodos mágicos: __str__ y __repr__» es gratis?

Sí — el texto completo de «Métodos mágicos: __str__ y __repr__» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Python Academy, actualiza a CoddyKit PRO. El curso de Python Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Métodos mágicos: __str__ y __repr__»?

Implemente métodos dunder para obtener representaciones legibles de los objetos. Practicas Python Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Python Academy?

No se requiere experiencia previa. Python Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «Métodos mágicos: __str__ y __repr__»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Python Academy?

Sí. Cada lección de Python Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Clases y el método __init__
  2. Atributos de instancia frente a atributos de clase
  3. Métodos de instancia y self
  4. Métodos mágicos: __str__ y __repr__
← Volver a Python Academy