Métodos estáticos y de clase en Python

Resumen

¿Cómo utilizar el método estático y el class method en Python?

El dominio de los métodos estáticos y de clase en Python es crucial para aprovechar al máximo las funciones de la programación orientada a objetos. Estos métodos ofrecen una solución eficiente para acceder y modificar las propiedades de las clases sin necesidad de crear instancias. En este artículo, exploraremos sus diferencias, aplicaciones y cómo implementarlos de manera efectiva en tus proyectos.

¿Qué es un método estático?

Un método estático en Python es un tipo de función definida dentro de una clase que no requiere acceso al estado de la instancia. Puede ser llamado directamente a través de la clase, eliminando la necesidad de instanciarla, lo que ahorra recursos y simplifica el código.

Ejemplo de implementación de un método estático para calcular impuestos:

class CalculadoraImpuestos:
    @staticmethod
    def calcular_impuesto(monto, tasa_impuesto):
        return monto * tasa_impuesto / 100

# Uso del método estático
resultado = CalculadoraImpuestos.calcular_impuesto(1000, 60)
print(resultado)  # Salida: 600.0

¿Cómo implementar un class method?

A diferencia de los métodos estáticos, los class methods son capaces de modificar el estado de la clase. Se definen utilizando el decorador @classmethod y siempre reciben el parámetro cls, que representa la propia clase. Este enfoque es útil para afectar atributos de clase o para definir constructores alternativos.

Implementación de un class method para modificar un descuento global:

class Pedido:
    descuento_global = 10

    @classmethod
    def actualizar_descuento(cls, nuevo_descuento):
        cls.descuento_global = nuevo_descuento

# Uso del class method
Pedido.actualizar_descuento(15)
print(Pedido.descuento_global)  # Salida: 15

¿Cuál es la diferencia entre los métodos estáticos y class methods?

Las diferencias esenciales entre estos dos tipos de métodos incluyen:

Acceso a la clase: Los class methods pueden acceder y modificar los atributos de la clase, mientras que los métodos estáticos no tienen esta capacidad.
Uso de argumentos: Los class methods requieren un argumento cls que apunta a la clase, permitiendo acceder a otras variables de clase y métodos, mientras que los métodos estáticos no reciben self ni cls.
Propósito: Los métodos estáticos se utilizan para funcionalidades que no dependen del estado de la clase o la instancia. Por otro lado, los class methods son ideales para modificar el estado compartido de la clase.

¿Cómo podemos aplicar estos métodos en la práctica?

Estos métodos pueden aplicarse en situaciones diversas, como verificación de condiciones o la aplicación de descuentos en ejemplos de la vida real. Imagínate un sistema de pedidos donde se necesita verificar que los pedidos exceden un valor mínimo antes de aplicarles un descuento global. Estos métodos permiten esta verificación de manera eficiente.

Aplicación práctica: Verificar el monto del pedido y aplicar un descuento

Se te desafía a crear dos métodos para:

Verificar que el monto del pedido es válido si supera un monto mínimo.
Aplicar un descuento global a cada pedido.

Este ejercicio es clave para afianzar tu conocimiento y estará integrado en una actividad donde desarrollarás tus propias soluciones. ¡No olvides dejar tus ejercicios en los comentarios! Con este conocimiento ahora puedes seguir avanzando en tu viaje por la programación orientada a objetos y explorar nuevos módulos y conceptos asíncronos.

Cornelio Reyes

student•

el parametro "cls", me comunica con que clase?? class Order???. si alguien me puede ayudar gracias...

Luis Gomez

student•

Si, hace referencia a la misma clase.

Yetzojhanan Varela Sierra

student•

para mayor claridad, imagina que tu clase se llama Order, como acá, al tu utilizar 'cls' es como si escribieras 'Order' para referirte a la misma clase donde estás escribiendo el código.

Como me dijo ChatGPT, es para trabajar dentro de la propia clase refiriendote a ella mísma como 'cls'

Carlos Eduardo Castillo Ibarra

student•

"""
Crear un método estático para verificar si el monto de un pedido es mayor a un mínimo permitido (50$ en este caso)
Crear un método clase que permita crear un pedido aplicando un descuento global
"""

class Order:
    global_discount = 15

    @staticmethod
    def min_amount(amount):
        if amount < 50:
            raise ValueError('Your orden must be minimun 50$')
        else:
            return amount
        
    @classmethod
    def new_order(cls, amount):
        if cls.min_amount(amount):
            print(f'Your orden has been created. You have a discount of {cls.global_discount}%. Total of your order: {amount - (amount * (cls.global_discount/100))}')

Order.new_order(60)

Caleb GLM

student•

class Order:
    global_discount = 10
    minimum_order_amount = 50
    
    def __init__(self, amount):
        self.amount = amount
        
    @staticmethod 
    def validate_order(amount):
        """Valida si el monto cumple con el minimo requerido"""
        return amount >= Order.minimum_order_amount
    
    @classmethod
    def update_global_discount(cls, new_discount):
        """Actualiza el descuento global"""
        if not (0 <= new_discount <= 100):
            raise ValueError("Dsicount has to be between 0 and 100")
        cls.global_discount = new_discount
        
    @classmethod
    def update_min_order_amount(cls, new_minimum):
        """Actuaiza el monto minimo de orden"""
        cls.minimum_order_amount = new_minimum
        
    @classmethod
    def _apply_discount(cls, amount):
        """Aplica el descuento global al monto"""
        return amount - (amount * (cls.global_discount / 100))
        
    @classmethod
    def create_order(cls, amount):
        """Crea una orden si el monto es valido"""
        if cls.validate_order(amount):
            order_with_disccount = cls._apply_discount(amount)
            print(f"Order sended. Total to pay => ${order_with_disccount}")
            return order_with_disccount
        else:
            print(f"Order not valid")
            return None

print(Order.global_discount) # 10      
Order.update_global_discount(50)
print(Order.global_discount) # 50
print(Order.validate_order(20)) # False
print(Order.validate_order(90)) # True
Order.update_min_order_amount(100)
print(Order.minimum_order_amount)
print(Order.validate_order(20))
print(Order.validate_order(90)) 
Order.create_order(120) # Order sended. Total to pay => $60.0
Order.create_order(10) # Order not valid


```class Order:    global\_discount = 10    minimum\_order\_amount = 50        def \_\_init\_\_(self, amount):        self.amount = amount            @staticmethod     def validate\_order(amount):        """Valida si el monto cumple con el minimo requerido"""        return amount >= Order.minimum\_order\_amount        @classmethod    def update\_global\_discount(cls, new\_discount):        """Actualiza el descuento global"""        if not (0 <= new\_discount <= 100):            raise ValueError("Dsicount has to be between 0 and 100")        cls.global\_discount = new\_discount            @classmethod    def update\_min\_order\_amount(cls, new\_minimum):        """Actuaiza el monto minimo de orden"""        cls.minimum\_order\_amount = new\_minimum            @classmethod    def \_apply\_discount(cls, amount):        """Aplica el descuento global al monto"""        return amount - (amount \* (cls.global\_discount / 100))            @classmethod    def create\_order(cls, amount):        """Crea una orden si el monto es valido"""        if cls.validate\_order(amount):            order\_with\_disccount = cls.\_apply\_discount(amount)            print(f"Order sended. Total to pay => ${order\_with\_disccount}")            return order\_with\_disccount        else:            print(f"Order not valid")            return None
print(Order.global\_discount) # 10      Order.update\_global\_discount(50)print(Order.global\_discount) # 50print(Order.validate\_order(20)) # Falseprint(Order.validate\_order(90)) # TrueOrder.update\_min\_order\_amount(100)print(Order.minimum\_order\_amount)print(Order.validate\_order(20))print(Order.validate\_order(90)) Order.create\_order(120) # Order sended. Total to pay => $60.0Order.create\_order(10) # Order not valid

Tomas Correa Zea

student•

Esta clase y la clase pasada tenian que venir despues de haber explicado lo de @property, @classmethod ,@static para no perder el hilo

Yadlif Mateo Hernandez Zapata

student•

class Order:
    def __init__(self, amount):
        self.amount = amount    
    
    
    @staticmethod
    def is_valid_amount(amount, minimun=60):
        """verifica si el monto cumple lo minimopermintio"""
        
        return amount >= minimun
    

    @classmethod
    def with_global_discount(cls, amount, discount_percentage):
        """
        Crea una instancia de Order aplicando un descuento global.
        Por ejemplo, si amount = 100 y discount_percentage = 10, el monto final será 90.
        """
        discounted_amount = amount * (1 - discount_percentage / 100)
        return cls(discounted_amount)
    
# Ejemplos de uso:

# Verificación del monto mínimo
print(Order.is_valid_amount(40))  # False
print(Order.is_valid_amount(56))  # True

# Crear un pedido con descuento
pedido_con_descuento = Order.with_global_discount(100, 10)
print(pedido_con_descuento.amount)  # 90.0
```class Order:    def \_\_init\_\_(self, amount):        self.amount = amount                @staticmethod    def is\_valid\_amount(amount, minimun=60):        """verifica si el monto cumple lo minimopermintio"""                return amount >= minimun   &#x20;
    @classmethod    def with\_global\_discount(cls, amount, discount\_percentage):        """        Crea una instancia de Order aplicando un descuento global.        Por ejemplo, si amount = 100 y discount\_percentage = 10, el monto final será 90.        """        discounted\_amount = amount \* (1 - discount\_percentage / 100)        return cls(discounted\_amount)    # Ejemplos de uso:
\# Verificación del monto mínimoprint(Order.is\_valid\_amount(40))  # Falseprint(Order.is\_valid\_amount(56))  # True
\# Crear un pedido con descuentopedido\_con\_descuento = Order.with\_global\_discount(100, 10)print(pedido\_con\_descuento.amount)  # 90.0

Juan Acevedo

student•

@staticmethod

Se utiliza cuando no necesitamos acceder ni a la instancia (self) ni a la clase (cls). Sirve para encapsular funciones que tienen una utilidad específica relacionada con la clase, pero que no necesitan modificar o acceder a sus atributos o métodos. Es como una función normal, pero organizada dentro de la clase para mantener el orden y el contexto.

✅ Ideal para funciones auxiliares que no dependen del estado de la clase ni de las instancias.
class Calculadora:
    @staticmethod
    def sumar(a, b):
        return a + b
@classmethodEste decorador permite que el método reciba la clase como primer argumento (por convención se usa cls). A diferencia del @staticmethod, este sí puede acceder y modificar atributos de la clase. Es útil para crear métodos de fábrica o para modificar el estado compartido entre todas las instancias.> ✅ Se usa cuando necesitamos trabajar con la clase en lugar de una instancia específica.
class Persona:
    especie = "Humano"

    @classmethod
    def cambiar_especie(cls, nueva_especie):
        cls.especie = nueva_especie

Hanns Maza

student•

""" 
Un metodo estatico para verificar si el monto de un pedido es mayor a un minimo permitido (
    por ejemplo 50 dolares
)

Un metodo de clase que permita crear un pedido aplicando un descuento global
"""

class Order:
    
    TAX_RATE = .18
    DISCOUNT_RATE = .05
    
    @staticmethod
    def check_valid_amount(amount:float|int):
        if not (isinstance(amount, float) or isinstance(amount, int)):
            raise TypeError("El parametro monto no es un numero")        
        return amount > 50
    
    @classmethod
    def apply_tax(cls, amoun:float):
        return amoun * cls.TAX_RATE
    
    @classmethod
    def apply_discount(cls, amoun:float):
        return amoun * cls.DISCOUNT_RATE
        
    @classmethod
    def create_order(cls, amount:float|int):
        is_valid_amount = cls.check_valid_amount(amount)
        
        # aplica un impuesto a todo
        amount_with_tax = amount + cls.apply_tax(amount)
        
        # si un un monto valido aplicara una tasa descuento
        if is_valid_amount:
            return amount_with_tax  - cls.apply_discount(amount)
        
        return amount_with_tax

    
print(Order.check_valid_amount(51))

print(Order.create_order(52)) # sin descuento 61.36, con descuento 58.76
print(Order.create_order(42)) # 49.56

Alexis Dorado Muñoz

student•

Gracias por tu aporte!

Kevin I. Villar

student•

class Order:
    # Atributo de clase
    global_discount = 15  # Descuento global en %

    def __init__(self, amount: float):
        """Inicializa una orden con el monto del pedido."""
        if amount <= 0:
            raise ValueError("❌ El monto del pedido debe ser mayor que cero.")
        self.amount = amount

    @classmethod
    def update_global_discount(cls, new_discount: float) -> None:
        """Actualiza el descuento global para todas las órdenes."""
        if not (0 <= new_discount <= 100):
            raise ValueError("❌ El descuento debe estar entre 0% y 100%.")
        cls.global_discount = new_discount
        print(f"🔄 Descuento global actualizado a {cls.global_discount}%.")

    @staticmethod
    def pedido(valor: float) -> bool:
        """Verifica si el pedido supera el monto mínimo de 50."""
        return valor > 50

Diego Arango

student•

class Order:
    DISCOUNT_RATE = 10
    
    def __init__(self, order_amount):
        self.order_amount = order_amount
    
    @staticmethod
    def allowed_min(order_amount):
        if order_amount < 50:
            raise ValueError("Your order must be min $50")
        return order_amount
            
    @classmethod
    def create_discounted_order(cls, order_amount):
        if cls.allowed_min(order_amount):
            discounted_order = order_amount - (order_amount * (cls.DISCOUNT_RATE / 100))
            return cls(discounted_order)
    
order1 = Order.create_discounted_order(120)
print(order1.order_amount)

Jaime Orlando Sánchez Mendieta

student•

#Metodo estatico para verificar monto minimo de un pedido y metodo de clase para aplicar descuentos a pedidos:
class Pedido:
    descuento_global = 10 #atributo global de la clase
    
    @staticmethod
    def precio_minimo_pedido(amount):
        return amount >= 50

    @classmethod 
    def actualizar_descuento(cls, nuevo_descuento): #se inicia con el argumento cls que referencia la clase misma
        if nuevo_descuento <= 0:
            raise ValueError('Valor invalido de descuento! debe ser mayor a 0')
        else:
            cls.descuento_global = nuevo_descuento #reasignacion de atributo
    
    @classmethod
    def aplicar_descuento_pedido(cls, amount):
        if cls.precio_minimo_pedido(amount) and cls.descuento_global > 0:
            return f'--resumen pedido--\ndescuento aplicado: {cls.descuento_global}%\ntotal a pagar: {amount * ((100-cls.descuento_global)/100)}'
        else:
            raise ValueError('Valor invalido de monto! debe ser mayor a 50')

# Uso del class method
Pedido.actualizar_descuento(1) #no necesitamos instanciar para usar el metodo

# Metodo estatico para verificar monto minimo de un pedido
print(Pedido.precio_minimo_pedido(50))

# Metodo de clase para aplicar descuentos a pedidos
print(Pedido.aplicar_descuento_pedido(55))

Platzi Team

student•

class Order:
    global_discount = 10  # 10% discount for all orders

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

    @staticmethod
    def static_method_minimum(amount, minimum=50):
        return amount >= minimum

    @classmethod
    def create_order(cls, amount):
        if cls.static_method_minimum(amount):
            return cls(amount)
        else:
            raise ValueError("Order amount is below the minimum required.")

    @classmethod
    def update_global_discount(cls, new_discount):
        cls.global_discount = new_discount
    # metodo de clase que permita crear un pedido aplicando descuento global
    def apply_global_discount(self):
        discount_amount = self.amount * (self.global_discount / 100)
        return self.amount - discount_amount
    
# Ejemplo de uso
try:
    Order.update_global_discount(15)
    print(f"Descuento de la orden: {Order.global_discount}")  # Output: 15
    order = Order.create_order(40)
    print(f"Order created with amount: {order.amount}")
    print(f"Amount after global discount: {order.apply_global_discount()}")
except ValueError as e:
    print(e)

Bautista Ribotta

student•

class Orden:    costo_llamada = 100    def __init__(self, costo_llamada):        self._costo_llamada = costo_llamada    @staticmethod    def llamar_por_telefono():        return "Hola gracias por comunicar con la empresa Telefonia"    @classmethod    def nuevo_costo_llamada(cls, nuevo_costo):        cls.costo_llamada = nuevo_costoprint(Orden.llamar_por_telefono())Orden.nuevo_costo_llamada(200)

Guillermo Cornetti

student•

class Order:

    MIN_ORDER_AMOUNT = 100  # Monto mínimo requerido
    DISCOUNT_PERCENTAGE = 10  # 10% de descuento global
    
    def __init__(self, order_id: str, amount: float):
  
        self.order_id = order_id
        self.amount = amount
        self.original_amount = amount  # Guardamos el monto original
    
    def __str__(self):
        return f"Pedido {self.order_id}: ${self.amount:.2f}"
    
    @staticmethod
    def is_valid_amount(order, min_amount: float = None) -> bool:
      
        if min_amount is None:
            min_amount = Order.MIN_ORDER_AMOUNT
        
        return order.amount >= min_amount
    
    @classmethod
    def apply_discount(cls, order) -> float:
  
        if not cls.is_valid_amount(order):
            return order.amount
        else:
            discount_amount = order.amount * (cls.DISCOUNT_PERCENTAGE / 100)
            discounted_amount = order.amount - discount_amount
            order.amount = discounted_amount
        
        return discounted_amount
    
    @classmethod
    def create_with_discount(cls, order_id: str, amount: float) -> 'Order':
     
        order = cls(order_id, amount)
        cls.apply_discount(order)
        return order

    @classmethod
    def change_discount_percentage(cls, new_percentage: float):
        cls.DISCOUNT_PERCENTAGE = new_percentage


if __name__ == "__main__":
    print("=== DEMOSTRACIÓN DE @staticmethod y @classmethod ===\n")

    #Order.change_discount_percentage(20)
 
    order1 = Order("001", 150.0)
    order2 = Order("002", 80.0)
    order3 = Order("003", 200.0)
    
    print("Pedidos creados:")
    print(f"  {order1}")
    print(f"  {order2}")
    print(f"  {order3}")
  
    print("\n=== VERIFICACIÓN DE MONTOS (@staticmethod) ===")
    orders_to_check = [order1, order2, order3]
    
    for order in orders_to_check:
        is_valid = Order.is_valid_amount(order)
        status = "✅ VÁLIDO" if is_valid else "❌ INVÁLIDO"
        print(f"  {order.order_id} (${order.original_amount}): {status}")
    
    print(f"\nVerificación con monto mínimo personalizado ($150):")
    for order in orders_to_check:
        is_valid = Order.is_valid_amount(order, min_amount=150)
        status = "✅ VÁLIDO" if is_valid else "❌ INVÁLIDO"
        print(f"  {order.order_id} (${order.original_amount}): {status}")
    
    print()

    print("=== APLICACIÓN DE DESCUENTOS (@classmethod) ===")
    print(f"Descuento global: {Order.DISCOUNT_PERCENTAGE}%")
    print()
    
    print("Aplicando descuento a pedidos existentes:")
    for order in [order1, order2, order3]:
        original = order.original_amount
        Order.apply_discount(order)
        discount_saved = original - order.amount
        print(f"  {order.order_id}: ${original:.2f} → ${order.amount:.2f} (Ahorro: ${discount_saved:.2f})")
    
    print()

    print("=== CREACIÓN CON DESCUENTO AUTOMÁTICO ===")
    discounted_order1 = Order.create_with_discount("004", 300.0)
    discounted_order2 = Order.create_with_discount("005", 500.0)
    
    print(f"  {discounted_order1}")
    print(f"  {discounted_order2}")
    
 
```class Order:
    MIN\_ORDER\_AMOUNT = 100  *# Monto mínimo requerido*    DISCOUNT\_PERCENTAGE = 10  *# 10% de descuento global*        def \_\_init\_\_(*self*, *order\_id*: str, *amount*: float):          *self*.order\_id = *order\_id*        *self*.amount = *amount*        *self*.original\_amount = *amount*  *# Guardamos el monto original*        def \_\_str\_\_(*self*):        *return* f"Pedido {*self*.order\_id}: ${*self*.amount:.2f}"        @staticmethod    def is\_valid\_amount(*order*, *min\_amount*: float = None) -> bool:              *if* *min\_amount* is None:            *min\_amount* = Order.MIN\_ORDER\_AMOUNT                *return* *order*.amount >= *min\_amount*        @classmethod    def apply\_discount(*cls*, *order*) -> float:          *if* not *cls*.is\_valid\_amount(*order*):            *return* *order*.amount        *else*:            discount\_amount = *order*.amount \* (*cls*.DISCOUNT\_PERCENTAGE / 100)            discounted\_amount = *order*.amount - discount\_amount            *order*.amount = discounted\_amount                *return* discounted\_amount        @classmethod    def create\_with\_discount(*cls*, *order\_id*: str, *amount*: float) -> 'Order':             order = *cls*(*order\_id*, *amount*)        *cls*.apply\_discount(order)        *return* order
    @classmethod    def change\_discount\_percentage(*cls*, *new\_percentage*: float):        *cls*.DISCOUNT\_PERCENTAGE = *new\_percentage*

*if* \_\_name\_\_ == "\_\_main\_\_":    print("=== DEMOSTRACIÓN DE @staticmethod y @classmethod ===\n")
    *#Order.change\_discount\_percentage(20)*     order1 = Order("001", 150.0)    order2 = Order("002", 80.0)    order3 = Order("003", 200.0)        print("Pedidos creados:")    print(f"  {order1}")    print(f"  {order2}")    print(f"  {order3}")      print("\n=== VERIFICACIÓN DE MONTOS (@staticmethod) ===")    orders\_to\_check = \[order1, order2, order3]        *for* order *in* orders\_to\_check:        is\_valid = Order.is\_valid\_amount(order)        status = "✅ VÁLIDO" *if* is\_valid *else* "❌ INVÁLIDO"        print(f"  {order.order\_id} (${order.original\_amount}): {status}")        print(f"\nVerificación con monto mínimo personalizado ($150):")    *for* order *in* orders\_to\_check:        is\_valid = Order.is\_valid\_amount(order, *min\_amount*=150)        status = "✅ VÁLIDO" *if* is\_valid *else* "❌ INVÁLIDO"        print(f"  {order.order\_id} (${order.original\_amount}): {status}")        print()
    print("=== APLICACIÓN DE DESCUENTOS (@classmethod) ===")    print(f"Descuento global: {Order.DISCOUNT\_PERCENTAGE}%")    print()        print("Aplicando descuento a pedidos existentes:")    *for* order *in* \[order1, order2, order3]:        original = order.original\_amount        Order.apply\_discount(order)        discount\_saved = original - order.amount        print(f"  {order.order\_id}: ${original:.2f} → ${order.amount:.2f} (Ahorro: ${discount\_saved:.2f})")        print()
    print("=== CREACIÓN CON DESCUENTO AUTOMÁTICO ===")    discounted\_order1 = Order.create\_with\_discount("004", 300.0)    discounted\_order2 = Order.create\_with\_discount("005", 500.0)        print(f"  {discounted\_order1}")    print(f"  {discounted\_order2}")

Juan Camilo Sánchez

student•

There I go

class Order3:

    global_discount = 15

    @staticmethod
    def pedido(amount):
        if amount > 50:
            raise ValueError('Your order must be less than 50')
        else:
            return amount
        
    @classmethod
    def created_order(cls, amount):
        if cls.pedido(amount):
                        print(f'Your order has been created. You have a discount of {cls.global_discount}%. Total of your order: {amount - (amount * (cls.global_discount/100))}')


        
print(Order3.pedido(49))
Order3.created_order(48)

Santiago Cortes

student•

class Order:
    global_discount = 10
    global_amount = 0

    def __init__(self, name:str, amount: float):
        self.name = name
        self.amount = amount

    @staticmethod
    def validate_amount_order(amount):
        return amount >= 50
    
    @classmethod
    def add_order_discount(cls, new_order:float):

        if new_order < 0:
            raise ValueError("El orden de compra no puede ser negativo")

        cls.global_amount = new_order - (cls.global_discount / 100)

    @classmethod
    def update_global_discount(cls, new_discount):
        
        if(new_discount < 0):
            raise ValueError("El descuento no puede ser negativo")

        cls.global_discount = new_discount

Order.update_global_discount(15)
print(Order.global_discount)

order_1 = Order("Perifericos Gaming",80)

validate_discount = order_1.validate_amount_order(order_1.amount)

if validate_discount:
    order_1.add_order_discount(order_1.amount)
    amount = order_1.global_amount
    discount = order_1.global_discount
    print(f"El producto {order_1.name} se aplico el descuento del {discount}%, el valor total de la orden es: ${amount} USD")
else:
    print(f"El producto {order_1.name} no aplicó el descuento, el valor total de la orden es: ${order_1.amount} USD")

Juan David Jiménez López

student•

Hola cómo yo resolví este reto fue de la siguiente manera

class Order:
    global_discount: float = 10
    minimo: float = 50

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

    @classmethod
    def update_global_discount(cls, new_discount):
        cls.global_discount = new_discount
    
    @staticmethod
    def verificar_monto( monto):
        return monto > Order.minimo
    
    @classmethod
    def crear_cuenta(cls, amount):
        total_descuento = (1 - cls.global_discount/100) * amount
        return Order(total_descuento)


Order.update_global_discount(15)
print(Order.global_discount)

orden = Order(30)
print(Order.verificar_monto(orden.amount))

orden_rebajada = Order.crear_cuenta(40000)
print(orden_rebajada.amount)
```class Order:    global\_discount: float = 10    minimo: float = 50
    def \_\_init\_\_(self, amount):        self.amount = amount
    @classmethod    def update\_global\_discount(cls, new\_discount):        cls.global\_discount = new\_discount        @staticmethod    def verificar\_monto( monto):        return monto > Order.minimo        @classmethod    def crear\_cuenta(cls, amount):        total\_descuento = (1 - cls.global\_discount/100) \* amount        return Order(total\_descuento)

Order.update\_global\_discount(15)print(Order.global\_discount)
orden = Order(30)print(Order.verificar\_monto(orden.amount))
orden\_rebajada = Order.crear\_cuenta(40000)print(orden\_rebajada.amount)

Gaiserick Jhonatan Ortiz Ramírez

student•

Les comparto un ejemplo del uso de @staticmethod despues de investigar un poco.

Gilberto Alejandro Monroy Morales

student•

Aquí mi aporte:

class Pedido:
    minimo_permitido = 50

    def __init__(self, cliente, monto):
        self.cliente = cliente
        self.monto = monto

    @staticmethod
    def validar_monto_minimo(monto):
        return monto >= Pedido.minimo_permitido
    
    @classmethod
    def crear_con_descuento(cls, cliente, monto, descuento):
        monto_con_descuento = monto * (1 - descuento / 100)
        return cls(cliente, monto_con_descuento)
    
print(Pedido.verificar_monto_minimo(60))  # True
print(Pedido.verificar_monto_minimo(40))  # False

# Creamos un pedido con descuento:
pedido1 = Pedido.crear_con_descuento("Alejandro", 100, 10)
print(pedido1.cliente)  
print(pedido1.monto)

Oscar Puentes

student•

Solución al reto:


class Pedidos:
    def __init__(self,amount,discount):
        self.amount = amount
        self.discount = discount
        self.total = 0

    def show_info(self):
        self.total = self.amount * (self.discount /  100)
        print(f"el total del descuento del pedido es {self.total}")

    @classmethod
    def new_discount(cls,new_discount,new_amount):
        cls.discount = new_discount
        cls.amount = new_amount
        cls.total = new_amount * (new_discount / 100)
        print(f"el total del descuento del pedido es {cls.total}")



    @staticmethod
    def consult_amount(amount_min, amount):
        if amount > amount_min:
            print(f"El monto {amount} es mayor al minimo establecido ({amount_min})")
        else:
            print(f"El monto {amount} es menor al minimo establecido ({amount_min})")



pedido = Pedidos(1000,10)

pedido.show_info()

#NUEVO PEDIDO,NUEVO DESCUENTO GLOBAL (NUEVO DESCUENTO,NUEVO MONTO)
pedido.new_discount(10,2000)
#CONSULTA DE MONTO (MONTO MINIMO, MONTO)
pedido.consult_amount(50, 20)

Juan José Zamora Jiménez

student•

class Order:

    global_discount = 10
    min_amount = 50

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

    @staticmethod
    def is_valid_amount(amount):
        if amount >= Order.min_amount:
            return "Amount is valid"
        else:
            raise ValueError(f"Amount must be at least {Order.min_amount}")
        
    @classmethod
    def apply_global_discount(cls, amount):
        if amount >= cls.min_amount:
            return amount - (amount * cls.global_discount / 100)
        else:
            raise ValueError(f"Amount must be at least {cls.min_amount} to apply discount")


print(Order.is_valid_amount(100))
print(Order.apply_global_discount(100))