Uso de Property en Python: Getter, Setter y Eliminación de Atributos

Resumen

¿Cómo se manejan los valores acumulativos y la invocación de atributos en programación?

La manipulación de valores acumulativos y la invocación de atributos son parte esencial del flujo de trabajo en programación. Estos conceptos se vinculan directamente con el uso de propiedades, sobre todo cuando se trabaja con métodos y atributos protegidos o encapsulados. A continuación, ofreceré una visión profunda de su funcionamiento y cómo aplicar estos conceptos para optimizar el código.

¿Qué es un valor acumulativo?

Un valor acumulativo en programación representa una variable que retiene, acumula o suma valores con el tiempo, a menudo mediante procesos iterativos o recursivos. Permite realizar cálculos progresivos y es ampliamente utilizado en análisis de datos, estadísticas y modelado predictivo.

Definición y propósito: Los valores acumulativos, a menudo gestionados a través de métodos tipo "setter", permiten que una variable mantenga un estado actualizado a medida que se modifican o añaden datos.
Ejemplo de uso: Consideremos un contador que suma un valor específico cada vez que se llama a una función. Cada llamada al método "setter" podría incrementar el contador acumulativamente.

¿Cómo se invocan los atributos y métodos protegidos?

La invocación directa o indirecta de atributos es una técnica común que puede emplearse para garantizar la integridad y seguridad de los datos dentro de un programa. Esto se logra trabajando con variables y métodos protegidos.

Atributos protegidos: Estos son atributos que no son directamente accesibles desde el exterior de la clase para proteger el acceso y la manipulación inapropiada de los datos.
Método de invocación: En lugar de acceder al atributo protegido directamente, se recomienda hacerlo a través de un método dedicado dentro de la clase, que actúa como una interfaz segura entre el usuario y los datos internos.

Ejemplo de invocación directa en código Python:

class ExampleClass:
    def __init__(self):
        self._protected_attribute = 0

    def update_value(self, value):
        self._protected_attribute += value
        return self._protected_attribute

# Uso
example = ExampleClass()
updated_value = example.update_value(10)
print(updated_value)  # Salida: 10

¿Qué sucede si no tenemos un producto especificado?

En programación, a menudo nos encontramos con situaciones donde se intenta acceder a información que no ha sido previamente especificada o creada, lo cual puede llevar a errores o comportamientos no deseados. La falta de especificación de productos o datos puede abordarse siguiendo ciertas estrategias:

Validación previa: Antes de acceder o modificar un valor, verificar si dicho valor existe o si el producto ha sido inicializado adecuadamente. Esto ayuda a prevenir errores de referencia nula.
Manejo de excepciones: Utilizar estructuras de manejo de errores, como "try-except" en Python, para manejar situaciones donde el acceso a un producto inexistente pueda generar errores.

Ejemplo de manejo de excepciones en Python:

dict_products = {"item1": 100, "item2": 200}

try:
    print(dict_products["item3"])
except KeyError:
    print("El producto solicitado no existe.")

El conocimiento y aplicado correcto de estos conceptos es crucial para los desarrolladores que buscan crear aplicaciones robustas y eficientes. La práctica y la experiencia son las herramientas más valiosas para perfeccionar estas habilidades. ¡Sigue explorando y nunca dejes de aprender!

Mario Alexander Vargas Celis

student•

La gestión avanzada de propiedades en Python se refiere a la manipulación de atributos de clase utilizando propiedades (property), así como técnicas más avanzadas como la creación de propiedades dinámicas, la validación de datos y la gestión de la encapsulación. Aquí te presento un resumen de cómo se puede hacer esto:

### 1. Uso de property

La función property permite definir métodos que se pueden utilizar como atributos. Esto es útil para encapsular el acceso a los atributos, permitiendo validaciones o transformaciones al obtener o establecer el valor.

#### Ejemplo básico de property


class Persona:

&#x20;   def \_\_init\_\_(self, nombre):

&#x20;       self.\_nombre = nombre  # Atributo protegido



&#x20;   @property

&#x20;   def nombre(self):

&#x20;       return self.\_nombre



&#x20;   @nombre.setter

&#x20;   def nombre(self, nuevo\_nombre):

&#x20;       if not isinstance(nuevo\_nombre, str):

&#x20;           raise ValueError("El nombre debe ser una cadena.")

&#x20;       self.\_nombre = nuevo\_nombre



persona = Persona("Juan")

print(persona.nombre)  # Salida: Juan



persona.nombre = "Carlos"  # Cambiar el nombre

print(persona.nombre)  # Salida: Carlos



\# persona.nombre = 123  # Esto generaría un ValueError

### 2. Propiedades dinámicas

Puedes crear propiedades que calculen su valor en función de otros atributos de la clase.

#### Ejemplo de propiedades dinámicas


class Rectangulo:

&#x20;   def \_\_init\_\_(self, ancho, alto):

&#x20;       self.ancho = ancho

&#x20;       self.alto = alto



&#x20;   @property

&#x20;   def area(self):

&#x20;       return self.ancho \* self.alto



rectangulo = Rectangulo(5, 10)

print(rectangulo.area)  # Salida: 50

### 3. Validación de propiedades

Las propiedades pueden ser utilizadas para validar datos antes de asignar un valor.

#### Ejemplo de validación


class CuentaBancaria:

&#x20;   def \_\_init\_\_(self, saldo\_inicial):

&#x20;       self.\_saldo = saldo\_inicial



&#x20;   @property

&#x20;   def saldo(self):

&#x20;       return self.\_saldo



&#x20;   @saldo.setter

&#x20;   def saldo(self, nuevo\_saldo):

&#x20;       if nuevo\_saldo < 0:

&#x20;           raise ValueError("El saldo no puede ser negativo.")

&#x20;       self.\_saldo = nuevo\_saldo



cuenta = CuentaBancaria(1000)

print(cuenta.saldo)  # Salida: 1000



cuenta.saldo = 500  # Cambiar el saldo

print(cuenta.saldo)  # Salida: 500



\# cuenta.saldo = -100  # Esto generaría un ValueError

### 4. Propiedades computadas

Las propiedades también pueden ser utilizadas para computar valores basados en otros atributos. Esto es útil para mantener el código limpio y evitar duplicaciones.

#### Ejemplo de propiedades computadas


class Circulo:

&#x20;   def \_\_init\_\_(self, radio):

&#x20;       self.radio = radio



&#x20;   @property

&#x20;   def area(self):

&#x20;       import math

&#x20;       return math.pi \* (self.radio \*\* 2)



circulo = Circulo(5)

print(circulo.area)  # Salida: 78.53981633974483

### 5. Uso de @classmethod y @staticmethod con propiedades

Puedes utilizar @classmethod y @staticmethod para crear propiedades de clase y métodos estáticos, respectivamente.

#### Ejemplo de métodos de clase


class Persona:

&#x20;   cantidad\_personas = 0



&#x20;   def \_\_init\_\_(self, nombre):

&#x20;       self.nombre = nombre

&#x20;       Persona.cantidad\_personas += 1



&#x20;   @classmethod

&#x20;   def total\_personas(cls):

&#x20;       return cls.cantidad\_personas



persona1 = Persona("Juan")

persona2 = Persona("Maria")

print(Persona.total\_personas())  # Salida: 2

### Resumen

- **Propiedades**: Permiten encapsular el acceso a los atributos de una clase, añadiendo validación y lógica adicional.

- **Propiedades dinámicas**: Se pueden crear basadas en otros atributos, lo que permite una computación perezosa.

- **Validación**: Permite validar datos antes de asignarlos a un atributo.

- **Propiedades computadas**: Facilitan el cálculo de valores basados en otros atributos.

La gestión avanzada de propiedades es esencial para diseñar clases robustas y mantener un buen encapsulamiento y validación.

Fidel Ortega Guzman

student•

muy bien

Yetzojhanan Varela Sierra

student•

Mi solución a la actividad:

class Product:
    def __init__(self, name: str, stock: int, price: int):
        self.name = name
        self._stock = stock
        self._price = price

    @property
    def stock(self):
        return self._stock
    
    @property
    def price(self):
        return self._price
    
    @stock.setter
    def stock(self, new_stock: int):
        if new_stock < 0:
            raise ValueError("Stock cannot be negative")
        self._stock = new_stock

    @price.setter
    def price(self, new_price: int):
        if new_price < 0:
            raise ValueError("Price need to be a possitive number")
        self._price = new_price

    @stock.deleter
    def stock(self):
        print(f"Stock of '{self.name}' product has been deleted")
        del self._stock

    @price.deleter
    def price(self):
        print(f"Price of '{self.name}' product has been deleted.")
        del self._price

    def print_info(self):
        print(f"Producto: {self.name} - Stock: {self.stock if hasattr(self, '_stock') else 'N/A'} - $ {self.price if hasattr(self, '_price') else 'N/A'}")

#crear instancia de producto
producto1 = Product("Harina",4,1000)
producto1.print_info()

#modificar stock, precio y nombre de producto controladamente
producto1.stock = 6
producto1.price = 1200
producto1.name = "Arroz"
producto1.print_info()

#intentar establecer stock o precio negativo
#producto1.stock = -6
#producto1.price = -600

#Eliminar un stock y un precio
del producto1.stock
del producto1.price
producto1.print_info()

Alexis Dorado Muñoz

student•

Muchas gracias por tu aporte

Elmer Dario Villalba Padilla

student•

En lugar de usar del self.__salary para eliminar el atributo, usamos: self.__salary = None

Esto mantiene el atributo en el objeto, pero su valor ahora es None.

Ventajas de este enfoque:

Evita errores inesperados: El atributo sigue existiendo, por lo que no hay AttributeError si se intenta acceder a él.
Permite comprobaciones: Puedes hacer validaciones como: if employee.salary is None: print("El salario no está definido.")
Es más seguro: El objeto mantiene su estructura, lo que facilita la mantenibilidad y depuración.

Daniel Ochoa

student•

Es absurdo que hace como 10 clases, lo único que hace es explicar el código que copia y pega, necesitamos que el código se construya y paso a paso se explique para que sirven las palabras claves, no el funcionamiento de una función que ya tiene escrita, eso no tiene sentido.

Gildder Guerrero Ramirez

student•

¿Cuál es la ventaja principal de usar @property en una clase de Python?

Danny Alejandro fernandez gallego

student•

Que es property?? property te permite definir atributos con comportamiento personalizado en la clase, su principal funcion es controlar el acceso y modificación, entonces permite ocultar la complejidad interna de las clases

Juan Camilo Suarez

student•

La clase tuvo varios problemas de edición x'd

Sebastian Cerquera carvajal

student•

mi respuesta al codigo:

#Implementar validacion para asegurarse de que el precio y el stock no puedan ser negativos.
#2. Define un metodo para eliminar la informacion del inventario
class Product:
    def __init__(self, name, price, stock):
        if price < 0 or stock < 0:
            raise ValueError("Price and stock cannot be negative")
        self.name = name
        self._price = price
        self._stock = stock

    @property
    def price(self):
        return self._price

    @price.setter
    def price(self, new_price):
        if new_price < 0:
            raise ValueError("Price cannot be negative")
        self._price = new_price

    @property
    def stock(self):
        return self._stock

    @stock.setter
    def stock(self, new_stock):
        if new_stock < 0:
            raise ValueError("Stock cannot be negative")
        self._stock = new_stock

    def remove_inventory(self):
        print(f"El producto {self.name} ha sido eliminado del inventario")
        del self._price
        del self._stock


# Ejemplo de uso
prod1 = Product("Chocorramo", 2600, 3)

print(prod1.price)  # Imprime 2600
print(prod1.stock)  # Imprime 3

# Actualizar valores válidos
prod1.price = 3000
prod1.stock = 10

# Eliminar del inventario
prod1.remove_inventory()

Juan Diego

student•

El Chocorramo a 3000 😯

Alejandro Ernesto Gómez Soria

student•

Ejemplo:

class Producto:
    def __init__(self, nombre, precio):
        self._nombre = nombre
        self._precio = precio

    @property
    def nombre(self):
        return self._nombre

    @nombre.setter
    def nombre(self, valor):
        if not valor:
            raise ValueError("El nombre no puede estar vacío.")
        self._nombre = valor

    @property
    def precio(self):
        return self._precio

    @precio.setter
    def precio(self, valor):
        if valor < 0:
            raise ValueError("El precio no puede ser negativo.")
        self._precio = valor

# Uso de la clase Producto
producto = Producto("Laptop", 1500)
print(producto.nombre)  # Salida: Laptop
print(producto.precio)  # Salida: 1500

producto.nombre = "Tablet"
producto.precio = 1200
print(producto.nombre)  # Salida: Tablet
print(producto.precio)  # Salida: 1200

# Intentar asignar un valor inválido
try:
    producto.precio = -500
except ValueError as e:
    print(e)  # Salida: El precio no puede ser negativo.

Edwin Daniel Méndez Amaya

student•

class Product:
    def __init__(self, name: str, price: int):
        self.name = name 
        self._price = price 
        self.stock = True

    @property
    def price(self):
        return self._price
    
    @price.setter
    def price(self, new_price):
        if self.stock:
            if new_price <=  0:
                raise ValueError('No puedes vender un producto por 0 USD o menos ')
            else: 
                self._price = new_price
        else: 
            print('Producto no disponible')

    @price.deleter
    def price(self):
        print(f'El precio del producto {self.name} ha sido eliminado')
        del self._price


product_1 = Product('PS5', 3500)
print(product_1.price)

product_1.price = 4000
print(product_1.price)

del product_1.price
```class Product:    def \_\_init\_\_(self, name: str, price: int):        self.name = name         self.\_price = price         self.stock = True
    @property    def price(self):        return self.\_price        @price.setter    def price(self, new\_price):        if self.stock:            if new\_price <=  0:                raise ValueError('No puedes vender un producto por 0 USD o menos ')            else:                 self.\_price = new\_price        else:             print('Producto no disponible')
    @price.deleter    def price(self):        print(f'El precio del producto {self.name} ha sido eliminado')        del self.\_price

product\_1 = Product('PS5', 3500)print(product\_1.price)
product\_1.price = 4000print(product\_1.price)
del product\_1.price

LUIS FELIPE HERNANDEZ GOMEZ

student•

mi solución a la actividad:

class Producto:
    def __init__(self, 
                 precio: float, 
                 nombre: str, 
                 stock: int = 0):
        """
        Inicializa un nuevo producto con un precio, nombre y stock.
        """
        self._precio = precio
        self.nombre = nombre
        self._stock = stock

    @property
    def precio(self):
        """
        Obtiene el precio del producto.
        """
        return self._precio
    
    @precio.setter
    def precio(self, nuevo_precio: float):
        """
        Establece un nuevo precio para el producto.
        """
        if nuevo_precio < 0:
            raise ValueError("El precio no puede ser negativo.")
        self._precio = nuevo_precio

    @precio.deleter
    def precio(self):
        """
        Elimina el precio del producto.
        """
        print(f"El precio del producto {self.nombre} ha sido eliminado")
        del self._precio

    @property    
    def stock(self):
        """
        Obtiene el stock del producto.
        """
        return self._stock
    
    @stock.setter
    def stock(self, nuevo_stock):      
        """
        Establece un nuevo stock para el producto.
        """
        if not isinstance(nuevo_stock, int) or nuevo_stock < 0:
            raise ValueError("El stock debe ser un número entero no negativo.")
        self._stock = nuevo_stock

    @stock.deleter
    def stock(self):
        """
        Elimina el stock del producto.
        """
        print(f"El stock del producto {self.nombre} ha sido eliminado")
        del self._stock

# Crear instancia de Producto
producto = Producto(100.0, "Laptop", 10)
print(producto.precio)  # Acceso al precio mediante la propiedad
print(producto.stock)   # Acceso al stock mediante la propiedad
# Modificar el precio y stock de forma controlada
producto.precio = 120.0
producto.stock = 15
print(producto.precio)  # Precio actualizado
print(producto.stock)   # Stock actualizado
# Intentar establecer un precio negativo
try:
    producto.precio = -50.0
except ValueError as ve:
    print(f"Error: {ve}")  # El precio no puede ser negativo.
#producto.precio = -50.0  # Esto generará un ValueError

Diego Arango

student•

class Product:
    def __init__(self, name, price, stock ):
        self.name = name
        self._price = price
        self._stock = stock
    
    @property
    def price(self):
        return self._price

    @price.setter
    def price(self, new_price):
        if new_price < 0:
            raise ValueError("Price cannot be negative")
        self._price = new_price

    @price.deleter
    def price(self):
        print(f"The price of {self.name} has been deleted")
        del self._price
    
    @property
    def stock(self):
        return self._stock
    
    @stock.setter
    def stock(self, new_stock):
        if new_stock < 0:
            raise ValueError("Stock can not be negative")
        self._stock = new_stock
    
    @stock.deleter
    def stock(self):
        print(f"The stock of {self.name} has been deleted")
        del self._stock
    

product1 = Product("Laptop Asus", 1450, 10)
product2 = Product("Laptop Lenovo", 1450, 15)

print(product1.stock)
print(product2.stock)

product2.stock = 2
print(product2.stock)

product2.price = 1750
print(product2.price)
#product1.stock = -1

#del product2.stock

José Francisco Pérez Rodríguez

student•

Tarea realizada

"""
1. Implementa validación para asegurarte el precio y el stock no puedan ser negativos.

2. Define un mpetodo para eliminar la información del inventario.

"""

class Product:
    def __init__(self, name: str, price: int, stock: int):
        self.name = name
        self._stock = stock
        self._price = price

    @property
    def price(self):
        return self._price

    @price.setter
    def price(self, new_price):
        if new_price < 0:
            raise ValueError("El precio del producto no puede ser negativo.")
        self.price = new_price

    @property
    def stock(self):
        return self._stock

    @stock.setter
    def stock(self, new_stock):
        if new_stock < 0:
            raise ValueError("El stock del producto no puede ser negativo.")
        self._stock = new_stock
    

class Store:
    def __init__(self):
        self._inventary = []

    def add_product(self, product: Product):
        self._inventary.append(product)

    @property
    def inventary(self):
        print("\nEl inventario actual es:")
        for n in range(len(self._inventary)):
            print(f"{n + 1}. Nombre: {self._inventary[n].name}, Precio: {self._inventary[n].price}, Cantidad: {self._inventary[n].stock}")
    
    @inventary.deleter
    def inventary(self):
        print("El inventario ha sido borrado.")
        del self._inventary

if __name__ == '__main__':
    producto1 = Product("Pera", 20, 250)
    tienda = Store()
    tienda.add_product(producto1)
    tienda.inventary
    producto1.stock = 300
    tienda.inventary
    producto2 = Product("Papel", 50, 523)
    tienda.add_product(producto2)
    tienda.inventary

Jaime Orlando Sánchez Mendieta

student•

reto:

'''
    Implementa validacion para que precio y stock no puedan ser negativos
    Definir un metodo para eliminar info del inventario
'''

class Store:
    def __init__(self,price,stock):
        self.price = price
        self._stock = stock #atributo protegido

    @property #decorador property (getter) para establecer setter y deleter
    def stock(self):
        return self._stock
        
    @stock.setter
    def stock(self, value):
        #ingresando los dos valores como tupla
        new_price, new_stock = value #desempaquetamos value para usar precio y stock en los condicionales
        if new_stock <= 0:
            raise ValueError('el stock no debe ser negativo!')
        elif new_price <= 0:
            raise ValueError('el precio no debe ser negativo')
        self.price = new_price
        self._stock = new_stock
        
    @stock.deleter
    def stock(self):
        print(f'El stock ha sido eliminado!')
        del self._stock

store = Store(400,4)
print(store.stock) #getter

stored = store.stock = (5000,50) #setter. Agregamos la tupla con los valores de price y stock como argumento
print(stored)

del store.stock #deleter

Platzi Team

student•

class Product:
    def __init__(self, name, price, stock):
        self.name = name
        self.price = price
        self.stock = stock

    @property
    def price(self):
        return self._price

    @price.setter
    def price(self, value):
        if value < 0:
            raise ValueError("El precio no puede ser negativo.")
        self._price = value

    @property
    def stock(self):
        return self._stock

    @stock.setter
    def stock(self, value):
        if value < 0:
            raise ValueError("El stock no puede ser negativo.")
        self._stock = value

    def clear_inventory(self):
        print(f"El inventario del producto {self.name} ha sido eliminado.")
        self.stock = 0

# Ejemplo de uso
product = Product("Laptop", 1500, 10)
print(product.price)  # Acceder al precio mediante el getter
print(product.stock)  # Acceder al stock mediante el getter
product.price = 1200  # Modificar el precio mediante el setter
product.stock = 5     # Modificar el stock mediante el setter
print(product.price)
print(product.stock)
product.clear_inventory()  # Eliminar el inventario

Bautista Ribotta

student•

class Producto:    """    defino los atributos en el constructor, y despues si los quiero cambiar    llamo al setter, le paso el nuevo valor y el mismo setter hace la validacion    """    def __init__(self, precio, stock):        self._precio = precio        self._stock = stock    @property    def precio(self):        return self._precio    @precio.setter    def precio(self, nuevo_precio):        if self.precio < 0:            print(f"Error, el precio no puede ser negativo")        else:            self._precio = nuevo_precio    @precio.deleter    def precio(self):        del self._precio    def stock(self):        return self._stock    @stock.setter    def stock(self, nuevo_stock):        if self._stock < 0:            print("Error, el stock no puede ser menor a cero")        else:            self._stock = nuevo_stock    @stock.deleter    def stock(self):        del self._stockp1 = Producto(1000, 10)

Ana Karen Rivas Roman

student•

class Products:
    def __init__(self, name, precio,stock):
        self.name  = name
        self._precio = precio
        self._stock = stock

    @property
    def precio(self):
        return self._precio
    
    @precio.setter
    def precio(self,new_precio):
        if new_precio <=0:
            raise ValueError('El precio no puede ser menor o igual a 0')
        self._precio = new_precio

    @precio.deleter
    def precio(self):
        print('Precio eliminado')
        del self._precio

    @property
    def stock(self):
        return self._stock
    
    @stock.setter
    def stock(self,new_stock):
        if new_stock <0:
            raise ValueError('El precio no puede ser menor a 0')
        self._stock = new_stock

    @stock.deleter
    def stock(self):
        print('stock eliminado')
        del self._stock

product = Products('Gansito',25,16)
print(product.precio)
print(product.stock)

product.precio = 30
print(product.precio)
product.stock = 15
print(product.stock)

del product.precio
del product.stock
```class Products:    def \_\_init\_\_(self, name, precio,stock):        self.name  = name        self.\_precio = precio        self.\_stock = stock
    @property    def precio(self):        return self.\_precio        @precio.setter    def precio(self,new\_precio):        if new\_precio <=0:            raise ValueError('El precio no puede ser menor o igual a 0')        self.\_precio = new\_precio
    @precio.deleter    def precio(self):        print('Precio eliminado')        del self.\_precio
    @property    def stock(self):        return self.\_stock        @stock.setter    def stock(self,new\_stock):        if new\_stock <0:            raise ValueError('El precio no puede ser menor a 0')        self.\_stock = new\_stock
    @stock.deleter    def stock(self):        print('stock eliminado')        del self.\_stock
product = Products('Gansito',25,16)print(product.precio)print(product.stock)
product.precio = 30print(product.precio)product.stock = 15print(product.stock)
del product.preciodel product.stock

Gaiserick Jhonatan Ortiz Ramírez

student•

Pregunta... ¿por qué se utilizan variables protected (salary) y no private (__salary) para forzar el encapsulamiento?

Juan Camilo Sánchez

student•

There I go


class Inventory:
    def __init__(self, product, stock, price):
        self.product = product
        self._stock = stock
        self._price = price

    @property
    def stock(self):
        return self._stock
    
    @property
    def price(self):
        return self._price
    
    @stock.setter
    def stock(self, new_inventory):
        if new_inventory < 0:
            raise ValueError('El inventario no puede ser negativo')
        self._stock = new_inventory


    @price.setter
    def price(self, new_price):
        if new_price < 0:
            raise ValueError('El precio no puede ser negativo')
        self._price = new_price
    

    @stock.deleter
    def stock(self):
        print(f'El stock del {self.product} has been deleted')
        del self._stock

    @price.deleter
    def price(self):
        print(f'El precio del producto {self.product} ha sido eliminado')
        del self._price

product1 =Inventory('Destornillador', 20, 30)
print(product1.stock)


product1.stock = 40
print(product1.stock)

product1.price = 50
print(product1.price)


#inventary.stock = -40

del product1.stock

Santiago Cortes

student•

La solucion de la actividad

class Inventory:
    def __init__(self, name, price:float, stock:int):
        self.name = name
        self._price = price
        self.__stock = stock

    
    @property
    def stock(self) -> int:
        return self.__stock
    
    @property
    def price(self) -> float:
        return self._price
    
    @stock.setter
    def stock(self, new_stock):
        
        if new_stock < 0:
            raise ValueError("El stock no puede ser negativo")
        
        self.__stock = new_stock

    @price.setter
    def price(self, new_price):
        if new_price < 0:
            raise ValueError("El precio no puede ser negativo")
        
        self._price = new_price

    @price.deleter
    def price(self):
        print(f"El precio del producto {self.name} se va eliminar")
        del self._price

    @stock.deleter
    def stock(self):
        print(f"El stock del producto {self.name} se va eliminar")
        del self.__stock
    

product_1 = Inventory("Laptop", 2500.0,5)
product_2 = Inventory("Smart TV", 1200.0,10)

product_1.price = 3000.0
print(f"El producto {product_1.name} del precio es ${product_1.price}USD")
print(f"El producto {product_1.name} del stock {product_1.stock} esta disponible")

del product_1.price
print(product_1.price)
```class Inventory:    def \_\_init\_\_(self, name, price:float, stock:int):        self.name = name        self.\_price = price        self.\_\_stock = stock
        @property    def stock(self) -> int:        return self.\_\_stock        @property    def price(self) -> float:        return self.\_price        @stock.setter    def stock(self, new\_stock):                if new\_stock < 0:            raise ValueError("El stock no puede ser negativo")                self.\_\_stock = new\_stock
    @price.setter    def price(self, new\_price):        if new\_price < 0:            raise ValueError("El precio no puede ser negativo")                self.\_price = new\_price
    @price.deleter    def price(self):        print(f"El precio del producto {self.name} se va eliminar")        del self.\_price
    @stock.deleter    def stock(self):        print(f"El stock del producto {self.name} se va eliminar")        del self.\_\_stock   &#x20;
product\_1 = Inventory("Laptop", 2500.0,5)product\_2 = Inventory("Smart TV", 1200.0,10)
product\_1.price = 3000.0print(f"El producto {product\_1.name} del precio es ${product\_1.price}USD")print(f"El producto {product\_1.name} del stock {product\_1.stock} esta disponible")
del product\_1.priceprint(product\_1.price)

Juan David Jiménez López

student•

Hola yo he logrado hacer esta parte del código espero les ayude a los que lo necesitan

class Product:
    def __init__(self, name: str, stock: int, price: float):
        self.name = name
        self._stock = stock
        self._price = price

    @property
    def stock(self):
        return self._stock
    
    @property
    def price(self):
        return self._price
    
    @property.setter
    def stock(self, new_stock: int):
        if new_stock < 0:
            raise ('El stock no puede ser negativo')
        self.stock = new_stock

    @property.setter
    def price(self, new_price):
        if new_price < 0:
            raise ('El precio no puede ser negativo')
        self.stock = new_price

    @stock.deleter
    def stock(self):
        print(f"The stock of {self.name} has been deleted")
        del self._stock
    
    @price.deleter
    def price(self):
        print(f"Price of '{self.name}' product has been deleted.")
        del self._price