Métodos Especiales

 Los métodos especiales (también llamados dunder methods por “double underscore”) son funciones con nombres como __init__, __str__, __len__, etc.

Permiten que tus clases:

  • se comporten como tipos nativos

  • funcionen con operadores (+, <, ==, etc.)

  • se integren con funciones internas (len(), print(), iter(), etc.)

1. __init__ – Constructor

Ya lo conocéis: se ejecuta al crear un objeto.

def __init__(self, nombre):
    self.nombre = nombre

2. __str__ – Representación amigable

Define cómo se muestra el objeto al imprimirlo.

def __str__(self):
    return f"Producto: {self.nombre}"

3. __repr__ – Representación técnica

Pensado para depuración. Si no existe __str__, print() usa __repr__.

def __repr__(self):
    return f"Producto('{self.nombre}', {self.precio})"

4. __len__ – Longitud del objeto

Permite usar len(obj).

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

5. __eq__, __lt__, __gt__ – Comparaciones

Permiten comparar objetos con ==, <, >…

def __eq__(self, other):
    return self.id == other.id

6. __add__, __sub__, __mul__ – Sobrecarga de operadores

Permiten usar operadores matemáticos con objetos.

def __add__(self, other):
    return self.precio + other.precio

7. __getitem__ y __setitem__ – Acceso como lista/dict

Permiten usar obj[key].

def __getitem__(self, index):
    return self.items[index]

8. __iter__ – Iteración

Permite recorrer el objeto con un for.

def __iter__(self):
    return iter(self.items)

ACTIVIDAD PRÁCTICA: “Carrito de la compra inteligente”

Objetivo: que tus alumnos creen una clase que se comporte como una colección real, con métodos especiales útiles.

Enunciado

Crea una clase Carrito que:

Atributos:

  • items → lista de productos (strings)

  • precios → lista de precios (floats)

Métodos especiales:

  1. __str__() → mostrar el carrito de forma legible

  2. __len__() → número de productos

  3. __getitem__() → acceder a un producto por índice

  4. __add__() → combinar dos carritos

  5. __iter__() → recorrer productos con un for

Después:

  • Crea dos carritos

  • Añade productos

  • Combínalos con +

  • Recorre el carrito combinado

  • Muestra su longitud

Solución propuesta

class Carrito:
    def __init__(self):
        self.items = []
        self.precios = []

    def añadir(self, producto, precio):
        self.items.append(producto)
        self.precios.append(precio)

    # 1. Representación amigable
    def __str__(self):
        texto = "Carrito:\n"
        for p, precio in zip(self.items, self.precios):
            texto += f"- {p}: {precio}€\n"
        return texto

    # 2. Longitud
    def __len__(self):
        return len(self.items)

    # 3. Acceso por índice
    def __getitem__(self, index):
        return self.items[index], self.precios[index]

    # 4. Suma de carritos
    def __add__(self, other):
        nuevo = Carrito()
        nuevo.items = self.items + other.items
        nuevo.precios = self.precios + other.precios
        return nuevo

    # 5. Iteración
    def __iter__(self):
        return iter(zip(self.items, self.precios))


# --- PRUEBAS ---
c1 = Carrito()
c1.añadir("Teclado", 20)
c1.añadir("Ratón", 15)

c2 = Carrito()
c2.añadir("Monitor", 150)

# Combinar carritos
c3 = c1 + c2

print(c3)
print("Número de productos:", len(c3))

print("Primer producto:", c3[0])

print("\nRecorriendo el carrito:")
for producto, precio in c3:
    print(producto, precio)

Ejemplo de salida

Carrito:
- Teclado: 20€
- Ratón: 15€
- Monitor: 150€

Número de productos: 3
Primer producto: ('Teclado', 20)

Recorriendo el carrito:
Teclado 20
Ratón 15
Monitor 150


  
< Anterior                                            Siguiente >