@staticmethod-2

 

@staticmethod en Python: El Consultor Externo 🎯

Imagina que tienes una empresa de construcción donde:

• Métodos normales = Los obreros (trabajan con materiales específicos)

• @classmethod = El arquitecto (diseña planos y organiza)

• @staticmethod = El consultor externo (da consejos sin tocar nada)

La idea principal

Un @staticmethod es un método que NO necesita acceso a self (instancia) NI a cls (clase). Es como una función normal que vive dentro de una clase por organización.

python

class Calculadora:
    def __init__(self, marca):
        self.marca = marca  # Datos de la instancia
    
    # Método normal - necesita la instancia
    def sumar(self, a, b):
        return f"Con {self.marca}: {a + b}"
    
    # @staticmethod - no necesita nada de la clase/instancia
    @staticmethod
    def convertir_celsius_a_fahrenheit(celsius):
        return (celsius * 9/5) + 32
    
    @staticmethod
    def es_par(numero):
        return numero % 2 == 0

Analogía del Restaurant Gourmet 🍽️

python

class Restaurant:
    def __init__(self, nombre, chef):
        self.nombre = nombre
        self.chef = chef
        self.platos_preparados = 0
    
    # Método normal - el chef trabajando
    def preparar_plato(self, plato):
        self.platos_preparados += 1
        return f"Chef {self.chef} preparó {plato}"
    
    # @classmethod - el gerente organizando
    @classmethod
    def abrir_restaurant(cls, nombre, chef):
        return cls(nombre, chef)
    
    # @staticmethod - el consultor nutricional
    @staticmethod
    def calcular_calorias(ingredientes):
        # No necesita saber qué restaurant es ni quién es el chef
        calorias_por_ingrediente = {
            'pollo': 200, 'arroz': 150, 'ensalada': 50, 
            'pasta': 180, 'salsa': 80
        }
        return sum(calorias_por_ingrediente.get(ing, 0) for ing in ingredientes)
    
    @staticmethod
    def recomendar_vino(plato):
        recomendaciones = {
            'carne': 'Tinto', 'pescado': 'Blanco', 
            'pasta': 'Rosado', 'ensalada': 'Agua'
        }
        return recomendaciones.get(plato, 'No hay recomendación')

Diferencia práctica: ¿Qué recibe cada método?

python

class Ejemplo:
    atributo_clase = "Soy de clase"
    
    def __init__(self):
        self.atributo_instancia = "Soy de instancia"
    
    def metodo_normal(self):
        print(f"Tengo acceso a: {self.atributo_instancia}")
    
    @classmethod
    def metodo_clase(cls):
        print(f"Tengo acceso a: {cls.atributo_clase}")
    
    @staticmethod
    def metodo_estatico():
        print("No tengo acceso a nada especial")
        # Puedo hacer cálculos independientes
        return 2 + 2

Ejemplo completo: Taller Mecánico 🔧

python

class TallerMecanico:
    total_trabajos = 0
    
    def __init__(self, nombre_mecanico):
        self.nombre_mecanico = nombre_mecanico
        self.trabajos_realizados = 0
    
    # Método normal - el mecánico trabajando
    def reparar_auto(self, modelo_auto):
        self.trabajos_realizados += 1
        TallerMecanico.total_trabajos += 1
        return f"{self.nombre_mecanico} reparó {modelo_auto}"
    
    # @classmethod - el supervisor
    @classmethod
    def obtener_estadisticas(cls):
        return f"Total trabajos en el taller: {cls.total_trabajos}"
    
    # @staticmethod - las herramientas/calculadoras
    @staticmethod
    def calcular_tiempo_reparacion(problema):
        # No necesita saber qué mecánico es ni datos del taller
        tiempos = {
            'cambio_aceite': 30,
            'frenos': 120, 
            'motor': 240,
            'electrico': 180
        }
        return tiempos.get(problema, 60)
    
    @staticmethod
    def convertir_km_a_millas(km):
        return km * 0.621371
    
    @staticmethod
    def es_vehiculo_electrico(modelo):
        electricos = ['Tesla', 'Nissan Leaf', 'Chevy Bolt']
        return any(electrico in modelo for electrico in electricos)

Uso en la práctica:

python

# Crear instancias
mecanico1 = TallerMecanico("Juan")
mecanico2 = TallerMecanico("Maria")

# Métodos normales (trabajan con instancias)
print(mecanico1.reparar_auto("Toyota Corolla"))  # Juan reparó Toyota Corolla
print(mecanico2.reparar_auto("Ford Focus"))      # Maria reparó Ford Focus

# @classmethod (trabajan con la clase)
print(TallerMecanico.obtener_estadisticas())     # Total trabajos en el taller: 2

# @staticmethod (funcionan independientemente)
print(f"Tiempo para frenos: {TallerMecanico.calcular_tiempo_reparacion('frenos')} min")
print(f"100 km = {TallerMecanico.convertir_km_a_millas(100):.1f} millas")
print(f"¿Es Tesla eléctrico? {TallerMecanico.es_vehiculo_electrico('Tesla Model 3')}")

¿Cuándo usar @staticmethod?

✅ SÍ usar staticmethod cuando:

1. Funciones utilitarias relacionadas con el dominio de la clase

2. Validaciones o cálculos que no necesitan estado de la clase

3. Organizar código relacionado lógicamente

4. Métodos que podrían ser funciones pero tienen sentido en la clase

❌ NO usar staticmethod cuando:

1. Necesitas acceso a self o datos de instancia

2. Necesitas acceso a cls o atributos de clase

3. Vas a sobreescribir el método en subclases

Resumen visual:

text

TALLER MECÁNICO 🛠️

OBREROS (métodos normales)
├── reparar_auto() - Necesita saber QUIÉN repara
└── usa self

SUPERVISOR (@classmethod)  
├── obtener_estadisticas() - Ve el panorama general
└── usa cls

CONSULTOR (@staticmethod)
├── calcular_tiempo_reparacion() - Da consejos genéricos
├── convertir_km_a_millas() - Herramientas de cálculo
└── NO usa self NI cls

Ventajas de @staticmethod:

1. Claridad: Indica que el método no modifica estado

2. Organización: Agrupa funcionalidad relacionada

3. Performance: Ligeramente más rápido (no pasa self/cls)

4. Reutilización: Puede usarse sin crear instancias

python

# Puedo usar staticmethods sin crear el taller!
tiempo = TallerMecanico.calcular_tiempo_reparacion('motor')
millas = TallerMecanico.convertir_km_a_millas(50)

print(f"Reparar motor toma: {tiempo} minutos")
print(f"50 km son {millas:.1f} millas")

¡El consultor (@staticmethod) da consejos sin necesitar conocer los detalles internos del negocio