Decoradores @staticmethod y @classmethod en Python

Contenido del curso

Fundamentos de Clases y Objetos

Encapsulación y Comportamiento de Objetos

Implementar Protocolos con Métodos Especiales

Relaciones entre Clases y Polimorfismo

Diseño Avanzado y Patrones de Software

17
Loading JSON Data to Restore App State
11:43 min

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:007:18

Decoradores @staticmethod y @classmethod en Python

Curso de Python Orientado a Objetos

Clase 15 de 17

Clase 15 / 17

Comentarios (11)11 comentarios

Gabriel Obregón

Hace un año

david felipe matallana martinez

Hace 10 meses

Cristian David Sierra Cardenas

Hace 10 días

Yeferson Lasso España

Hace 5 meses

Lucho Cadiz

Hace 5 meses

Sergio Daniel Flamenco

Hace 6 meses

Diego Mauricio Zuluaga Rodríguez

Hace 8 meses

Allan Isaac Lopez Serrano

Hace 8 meses

Nicolas E Duque Aguirre

Hace 9 meses

Oscar Eduardo Barrios Blanco

Hace 9 meses

Luis Martinez

Profesor

Hace 9 meses

Oscar Eduardo Barrios Blanco

Hace 9 meses

Santiago Javier Giler Paz

Hace un año•editado

Luis Martinez

Profesor

Hace un año

Recursos

Domina cómo aplicar los decoradores @staticmethod y @classmethod en Python para escribir clases claras y reutilizables. Verás cómo centralizar utilidades como validar ISBN y cómo crear constructores alternativos que generan instancias con reglas específicas, sin depender de objetos previos.

Métodos estáticos y de clase en Python: organiza utilidades y crea instancias de forma flexible.

¿Qué es un static method y cómo validar ISBN en Python?

Un método estático encapsula lógica que no usa estado de instancia. No recibe self. Es perfecto para utilidades y validaciones puras. Aquí, Biblioteca.validar_isbn comprueba que un ISBN tenga al menos diez caracteres con len y retorna True o False.

# biblioteca.py
class Biblioteca:
    @staticmethod
    def validar_isbn(isbn: str) -> bool:
        return len(isbn) >= 10

¿Cómo se llama y se prueba el método estático?

Se invoca desde la clase, sin instanciar. Se imprime el resultado para verificar la lógica.

# main.py
from biblioteca import Biblioteca

resultado = Biblioteca.validar_isbn("12345")
print("El ISBN es válido:", resultado)  # False

resultado = Biblioteca.validar_isbn("1234567890")
print("El ISBN es válido:", resultado)  # True

Claves prácticas: usa el decorador @staticmethod, evita self, agrupa utilidades relacionadas en la clase Biblioteca, y llama como Biblioteca.validar_isbn(valor).

¿Cómo usar un class method como constructor alternativo en la clase libro?

Un método de clase opera a nivel de clase y recibe el parámetro cls. Permite crear constructores alternativos que devuelven nuevas instancias con configuraciones predefinidas. En Libro, crear_no_disponible construye un objeto con disponible=False sin tocar el constructor principal.

# libro.py
class Libro:
    @classmethod
    def crear_no_disponible(cls, titulo, autor, isbn):
        return cls(titulo, autor, isbn, disponible=False)

¿Cómo instanciar con el método de clase en main.py?

Se llama directamente desde la clase y se verifica el atributo disponible.

# main.py
from libro import Libro

libro_no_disp = Libro.crear_no_disponible(
    titulo="Libro de prueba",
    autor="Autor de prueba",
    isbn="1234567890",
)
print("Libro disponible:", libro_no_disp.disponible)  # False

Puntos clave: decorador @classmethod, uso de cls para crear instancias, retorno del objeto y acceso a atributos como disponible.

¿Cuáles son las diferencias clave entre staticmethod y classmethod?

Comprender las diferencias ayuda a separar la lógica de clase de la lógica de instancias, mejorando organización y mantenimiento.

Ámbito: @staticmethod no usa self ni cls. @classmethod recibe cls.
Propósito: @staticmethod sirve para utilidades como validar ISBN con len. @classmethod crea instancias con reglas propias, como un constructor alternativo.
Invocación: ambos se llaman desde la clase. No requieren instancia previa.
Organización: centralizan validaciones y fábricas en sus clases (Biblioteca, Libro).
Salida: @staticmethod retorna valores (por ejemplo, True/False). @classmethod retorna objetos configurados.

¿Te animas a aplicarlo? Crea un método de clase en Estudiante para generar un estudiante en una carrera específica y comparte tu código en los comentarios.

🧠✨Métodos estáticos y de clase en Python

🔹 1. @staticmethod

💡 Idea principal: Lógica independiente dentro de la clase

🧩 Características

No recibe self
No recibe cls
Funciona como una función normal, pero ubicada dentro de una clase
Útil para validaciones y operaciones auxiliares

🛠 Ejemplo: Validación de ISBN

class Biblioteca:

@staticmethod

def validar_isbn(isbn: str) -> bool:

return len(isbn) >= 10

▶ Cómo se usa

Biblioteca.validar_isbn("1234567890")

🟦 Visualízalo así

📦 Clase → contiene tareas auxiliares
🧰 Método → herramienta disponible sin instanciar
🔍 Resultado → True o False

🔹 2. @classmethod

💡 Idea principal: Crear objetos usando la clase como referencia

Recibe cls como primer argumento
Crea instancias alternativas
Permite reglas propias de construcción

🛠 Ejemplo: Libro no disponible

class Libro:

@classmethod

def crear_no_disponible(cls, titulo, autor, isbn):

return cls(titulo, autor, isbn, disponible=False)

Libro.crear_no_disponible("Título", "Autor", "1234567890")

🟩 Visualízalo así

🏭 Clase → fábrica de objetos
🎛 Método → receta alternativa
📘 Resultado → objeto con disponible=False

reto de la clase

#usuarios.py

@classmethod
    def carrera_especifica(cls, nombre, cedula):
        return cls(nombre, cedula, carrera="Enfermeria")

#main.py

ejemplo = Estudiante.carrera_especifica("prueba", "123123123")
print(ejemplo.carrera)

#SALIDA
Enfermeria

En la clase estudiante.

@classmethod
    def crear_estudiante(cls,nombre,cedula,carrera):
        return cls(nombre,cedula,carrera)

En main .py

print("Crea el nuevo usuario porfavor")
nombree = input("Ingrese el nombre ")
cedula = input("Ingrese la cedula ")
carreraa =  input("Ingrese la carrera")


nuevo_estudiante = Estudiante.crear_estudiante(nombre=nombree,cedula=cedula,carrera=carreraa)
print(f"Nuevo estudiante {nuevo_estudiante.nombre}-{nuevo_estudiante.carrera}")

de esta forma me permitio crear student dentro de una carrera especifica:

@classmethod
    def degree_software_development(cls, name, id):
        student = cls(name=name, id=id, degree="software development")
        student.limit_books = 10
        return student

no se por que, me lo podrias responder por favor.

Imagina que tienes una clase Libro. El constructor normal (__init__) siempre pide los mismos datos, pero ¿qué pasa si quieres una forma de crear un libro que ya venga marcado como "prestado"?

El @classmethod te permite usar cls(...) para llamar al constructor desde adentro, ahorrándote repetir lógica. Si tuvieras que crear ese libro sin cls, ¿qué tendrías que escribir manualmente cada vez que quisieras un libro prestado?

RETO:

usuarios.py

class Estudiante(Usuario):
    # Carreras válidas como atributo de clase
    CARRERAS_VALIDAS = ["Ingeniería", "Medicina", "Derecho", "Arquitectura", "Psicología"]
    
    def __init__(self, nombre, cedula, carrera):
        super().__init__(nombre, cedula)
        self.carrera = carrera
        self.limite_libros = 3

    def solicitar_libro(self, titulo):
        if not titulo:
            raise TituloInvalidoError(f"El libro con el titulo: {titulo}, no es válido")

        if len(self.libros_prestados) < self.limite_libros:
            self.libros_prestados.append(titulo)
            return f"Prestamo del libro: {titulo} autorizado"
        else:
            return (
                f"No puedes prestar más libros, Limite alcanzado: {self.limite_libros}"
            )

    @staticmethod
    def validar_carrera(carrera: str) -> bool:
        """
        Método estático para validar si una carrera es válida.
        No necesita acceso a la instancia ni a la clase.
        """
        return carrera in Estudiante.CARRERAS_VALIDAS

    @classmethod
    def crear_estudiante(cls, nombre: str, cedula: str, carrera: str) -> "Estudiante":
        """
        Método de clase para crear un estudiante en una carrera específica.
        Valida la carrera antes de crear la instancia.
        
        Args:
            nombre: Nombre del estudiante
            cedula: Número de cédula
            carrera: Carrera a estudiar
            
        Returns:
            Estudiante: Nueva instancia de Estudiante
            
        Raises:
            ValueError: Si la carrera no es válida
        """
        if not cls.validar_carrera(carrera):
            raise ValueError(f"La carrera '{carrera}' no es válida. Carreras válidas: {cls.CARRERAS_VALIDAS}")
        
        return cls(nombre, cedula, carrera)
    
    @classmethod
    def estudiante_ingeneria(cls, nombre: str, cedula: str) -> "Estudiante":
        """
        Factory method para crear estudiantes de Ingeniería.
        """
        return cls(nombre, cedula, "Ingeniería")
    
    @classmethod
    def estudiante_medicina(cls, nombre: str, cedula: str) -> "Estudiante":
        """
        Factory method para crear estudiantes de Medicina.
        """
        return cls(nombre, cedula, "Medicina")

main.py

# Usando el método de clase crear_estudiante
estudiante1 = Estudiante.crear_estudiante("Juan Pérez", "12345678", "Ingeniería")
print(f"Estudiante creado: {estudiante1.nombre_completo}, Carrera: {estudiante1.carrera}")

# Usando el factory method específico
estudiante2 = Estudiante.estudiante_ingeneria("María García", "87654321")
print(f"Estudiante creado: {estudiante2.nombre_completo}, Carrera: {estudiante2.carrera}")

# Usando el método estático directamente
es_valida = Estudiante.validar_carrera("Medicina")
print(f"¿Medicina es válida? {es_valida}")  # True

# Intentando crear con carrera inválida (lanza ValueError)
try:
    estudiante3 = Estudiante.crear_estudiante("Pedro", "11111111", "Filosofía")
except ValueError as e:
    print(f"Error: {e}")

Métodos agregados:

@staticmethod validar_carrera(carrera) - Valida si una carrera está en la lista de carreras válidas, sin necesidad de instancia o clase.
@classmethod crear_estudiante(nombre, cedula, carrera) - Factory method que crea un estudiante validando primero la carrera.
@classmethod estudiante_ingeneria(nombre, cedula) - Factory method específico para crear estudiantes de Ingeniería.
@classmethod estudiante_medicina(nombre, cedula) - Factory method específico para crear estudiantes de Medicina.

Diferencia principal:

@staticmethod: No tiene acceso a self ni cls, es una función independiente agrupada lógicamente en la clase.
@classmethod: Recibe cls como primer parámetro, permitiendo crear instancias de la clase o acceder a atributos de clase.

class Estudiante(Usuario):
    def __init__(self, nombre, id, carrera):
        super().__init__(nombre, id)
        self.carrera = carrera
        self.limite_libros = 3

    @classmethod
    def estudiante_de_finanzas(cls, nombre, id):
        return cls(nombre, id, carrera="Finanzas")


    @classmethod

    def crear\_estudiante\_ingenieria(cls, nombre, cedula):

        return cls(nombre, cedula, carrera="ingenieria")

Dejo el reto!

Buen ejemplo, solo algunos detalles para ir ajustando:

1. Creo que te quedó un espacio entre Estudiante y el primer ( 2. Los nombres de los metodos deben usar snake_case, guarda las mayusculas solo para nombres de clases.

Buen uso de literal string.

Sin espacios entre el nombre de la clase y el paréntesis y snake_case sin mayus para nombre de métodos,

Entendido, gracias!

@classmethod
def estudiante_sistemas(cls, nombre, cedula):
  return cls(nombre, cedula, carrera="Ing en Sistemas")

estudiante_sistemas = Estudiante.estudiante_sistemas("Santiago", 4324234234)
print(estudiante_sistemas.carrera)

No se si entendi bien lo que pidio.

Ten cuidado con la identación. de resto todo bien.

Fundamentos de Clases y Objetos

OOP in Python: Modeling Real World Systems

Classes and Objects in Python Explained

Instance Methods That Make Python Objects Act

Private Attributes and Data Integrity in Python

Encapsulación y Comportamiento de Objetos

Herencia en Python para evitar duplicación de código

Simple Inheritance With Python Classes

Python Protocol for Flexible Polymorphism

Implementar Protocolos con Métodos Especiales

Composition Over Inheritance in Python

Organizing Python Projects Into Modules

Custom Exceptions That Make Python Errors Clear

Sistema de préstamos con identificación de usuarios en Python

Relaciones entre Clases y Polimorfismo

Book Search and Lending Flow in Python OOP

Clases abstractas en Python con ABC y @abstractmethod

Decoradores property en Python para atributos con validación

Decoradores @staticmethod y @classmethod en Python

Serialización de objetos Python a JSON para persistencia de datos

Diseño Avanzado y Patrones de Software

Loading JSON Data to Restore App State

Decoradores @staticmethod y @classmethod en Python

Progreso del curso

Fundamentos de Clases y Objetos

Encapsulación y Comportamiento de Objetos

Implementar Protocolos con Métodos Especiales

Relaciones entre Clases y Polimorfismo

Diseño Avanzado y Patrones de Software

Recursos

Recursos