@staticmethod

 

@staticmethod en Python

Un staticmethod es un método que no recibe ni self (instancia) ni cls (clase). Es como una función normal pero organizada dentro de una clase.

python

class Calculadora:
    @staticmethod
    def sumar(a, b):
        return a + b
    
    @staticmethod
    def es_par(numero):
        return numero % 2 == 0

# Uso - sin necesidad de instancia
print(Calculadora.sumar(5, 3))    # 8
print(Calculadora.es_par(4))      # True

# También se puede usar desde instancia (pero no es necesario)
calc = Calculadora()
print(calc.sumar(2, 2))           # 4

Analogía con Laravel

En Laravel, los métodos estáticos se usan frecuentemente:

1. Helpers y Utilidades (como los estáticos de Python)

php

// En Laravel - helpers comunes
Str::length('hola');           // 4
Str::contains('hello', 'hell'); // true

// En Python - similar concepto
class TextUtils:
    @staticmethod
    def longitud(texto):
        return len(texto)
    
    @staticmethod
    def contiene(texto, subtexto):
        return subtexto in texto

print(TextUtils.longitud('hola'))        # 4
print(TextUtils.contiene('hello', 'hell')) # True

2. Factories y Creación de Objetos

php

// En Laravel - factories
$user = User::factory()->create();

// En Python - métodos estáticos como factories
class Usuario:
    def __init__(self, nombre, email):
        self.nombre = nombre
        self.email = email
    
    @staticmethod
    def crear_admin():
        return Usuario("admin", "admin@example.com")
    
    @staticmethod
    def desde_formulario(datos):
        return Usuario(datos['nombre'], datos['email'])

admin = Usuario.crear_admin()

Comparación detallada:

Característica	Python @staticmethod	Laravel Static Methods
Sintaxis	@staticmethod	public static function
Parámetros	No recibe self ni cls	No recibe $this
Uso	Clase.metodo()	Clase::metodo()
Desde instancia	Sí (opcional)	No (solo desde clase)
Acceso a atributos	Solo a atributos de instancia si se pasa explícitamente	Solo a propiedades estáticas

Ejemplo práctico comparado:

Python:

python

class Validator:
    @staticmethod
    def es_email_valido(email):
        return '@' in email and '.' in email.split('@')[1]
    
    @staticmethod
    def normalizar_texto(texto):
        return texto.strip().lower()

# Uso
print(Validator.es_email_valido('test@example.com'))  # True
print(Validator.normalizar_texto('  HOLA Mundo  '))   # 'hola mundo'

Laravel (equivalente):

php

class Validator {
    public static function isValidEmail($email) {
        return filter_var($email, FILTER_VALIDATE_EMAIL) !== false;
    }
    
    public static function normalizeText($text) {
        return strtolower(trim($text));
    }
}

// Uso
echo Validator::isValidEmail('test@example.com');  // true
echo Validator::normalizeText('  HOLA Mundo  ');   // 'hola mundo'

¿Cuándo usar cada uno en Python?

• @classmethod: Cuando necesitas acceder o modificar la clase (cls)

• @staticmethod: Cuando el método es independiente de la clase, solo está organizado ahí

python

class Configuracion:
    tema = "oscuro"  # Atributo de clase
    
    @classmethod
    def cambiar_tema(cls, nuevo_tema):
        cls.tema = nuevo_tema  # Accede a la clase
    
    @staticmethod
    def validar_tema(tema):
        # No necesita acceder a la clase, solo valida
        return tema in ["oscuro", "claro", "auto"]

# Uso
Configuracion.cambiar_tema("claro")  # classmethod - modifica la clase
print(Configuracion.validar_tema("claro"))  # staticmethod - solo valida

En resumen:

@staticmethod en Python es el equivalente conceptual a los métodos estáticos en Laravel, pero con sintaxis diferente. Ambos sirven para organizar funciones utilitarias que no dependen del estado de objetos específicos.

@staticmethod vs @classmethod - Ejemplo MUY sencillo

La diferencia en 3 líneas:

python

class Ejemplo:
    @classmethod
    def metodo_clase(cls):    # Recibe la CLASE
        print(f"Clase: {cls}")
    
    @staticmethod
    def metodo_estatico():    # No recibe NADA
        print("Soy estático")

Ejemplo super simple:

python

class Tienda:
    impuesto = 0.21  # IVA - atributo de CLASE
    
    def __init__(self, producto, precio):
        self.producto = producto  # atributo de INSTANCIA
        self.precio = precio
    
    # @classmethod - trabaja con la CLASE
    @classmethod
    def cambiar_impuesto(cls, nuevo_impuesto):
        cls.impuesto = nuevo_impuesto  # Modifica la clase
    
    # @staticmethod - no necesita ni clase ni instancia
    @staticmethod
    def calcular_descuento(precio, descuento):
        return precio * (1 - descuento/100)

# USO
# Classmethod - modifica la CLASE
Tienda.cambiar_impuesto(0.18)  # Cambia el IVA para TODAS las tiendas
print(Tienda.impuesto)  # 0.18

# Staticmethod - solo calcula, no modifica nada
precio_final = Tienda.calcular_descuento(100, 20)
print(precio_final)  # 80.0

# También desde instancia (pero no es necesario)
mi_tienda = Tienda("Laptop", 1000)
print(mi_tienda.calcular_descuento(200, 10))  # 180.0

Analogía con personas:

python

class Persona:
    especie = "Humano"  # Todos comparten esto
    
    def __init__(self, nombre):
        self.nombre = nombre  # Cada uno tiene lo suyo
    
    @classmethod
    def cambiar_especie(cls, nueva_especie):
        """Cambia para TODOS los humanos"""
        cls.especie = nueva_especie
    
    @staticmethod
    def saludar():
        """Saludo genérico que no depende de nadie"""
        return "¡Hola!"

En resumen:

• @classmethod: "Trabajo con la familia completa" 👨‍👩‍👧‍👦

• @staticmethod: "Tengo una herramienta que cualquiera puede usar"