Gestión avanzada de propiedades

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` ```python class Persona: def \_\_init\_\_(self, nombre): self.\_nombre = nombre # Atributo protegido @property def nombre(self): return self.\_nombre @nombre.setter def nombre(self, nuevo\_nombre): if not isinstance(nuevo\_nombre, str): raise ValueError("El nombre debe ser una cadena.") 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 ```python class Rectangulo: def \_\_init\_\_(self, ancho, alto): self.ancho = ancho self.alto = alto @property def area(self): 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 ```python class CuentaBancaria: def \_\_init\_\_(self, saldo\_inicial): self.\_saldo = saldo\_inicial @property def saldo(self): return self.\_saldo @saldo.setter def saldo(self, nuevo\_saldo): if nuevo\_saldo < 0: raise ValueError("El saldo no puede ser negativo.") 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 ```python class Circulo: def \_\_init\_\_(self, radio): self.radio = radio @property def area(self): import math 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 ```python class Persona: cantidad\_personas = 0 def \_\_init\_\_(self, nombre): self.nombre = nombre Persona.cantidad\_personas += 1 @classmethod def total\_personas(cls): 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.

Mi solución a la actividad: ```js 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() ```

¿Realmente ni siquiera prestan atencion a la edición de las clases antes de subirlas a la plataforma? La clase llega al minuto 5.28, y luego vuelve a comenzar nuevamente desde el principio en lo que parece ser una segunda toma de lo mismo que ya se mostró en el video. Realmente un desastre las ultimas clases del "curso".

```python 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

Ejemplo: ```js 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. ```

```js from enum import Enum class TipoTransaccion(Enum): """ Enumeración para los tipos de transacciones que se pueden realizar sobre el salario de un empleado. """ AGREGAR_SALARIO = 1 # Añadir un bono o incremento al salario. QUITAR_SALARIO = 2 # Reducir el salario (e.g., por deducciones). MOSTRAR_SALARIO = 3 # Consultar el salario actual. DEFINIR_NUEVO_SALARIO = 4 # Establecer un nuevo salario (reemplaza el anterior). ELIMINAR_SALARIO = 5 # Elimina el salario de un empleado. FALLO_TRANSACCION = 6 # Indica que una transacción no se pudo realizar. class Empleado: """ Clase que representa a un empleado con su nombre y salario. Permite gestionar el salario y registrar las transacciones realizadas. """ def __init__(self, nombre, salario): """ Constructor de la clase Empleado. Args: nombre (str): El nombre del empleado. salario (float): El salario inicial del empleado. Debe ser mayor que 0. """ self.nombre = nombre self._salario = salario # El salario se guarda como un atributo "protegido" (_salario). self.__transacciones = [] # Lista privada para registrar las transacciones. Se usa __ para "ocultarla" (name mangling). def __registrar_transaccion(self, tipo_transaccion: TipoTransaccion): """ Método privado para registrar una transacción en la lista de transacciones. Args: tipo_transaccion (TipoTransaccion): El tipo de transacción a registrar. """ self.__transacciones.append(tipo_transaccion) print(f"Transacción de tipo: {tipo_transaccion.name}") # Mejor usar .name para obtener el nombre del enum @property def salario(self): """ Getter para el salario. Permite acceder al salario como una propiedad (empleado.salario). Registra una transacción de tipo MOSTRAR_SALARIO. """ self.__registrar_transaccion(TipoTransaccion.MOSTRAR_SALARIO) return self._salario @salario.setter def salario(self, nuevo_salario): """ Setter para el salario. Permite modificar el salario, validando que sea un valor positivo. Registra una transacción de tipo DEFINIR_NUEVO_SALARIO si es válido, o FALLO_TRANSACCION si no. Args: nuevo_salario (float): El nuevo salario a asignar. """ if nuevo_salario > 0: self.__registrar_transaccion(TipoTransaccion.DEFINIR_NUEVO_SALARIO) self._salario = nuevo_salario print(f"Se ha asignado nuevo salario: {nuevo_salario}") else: self.__registrar_transaccion(TipoTransaccion.FALLO_TRANSACCION) print("El nuevo salario no puede ser menor o igual a cero") def agregar_salario(self, salario_extra): """ Agrega un monto adicional al salario actual del empleado. Args: salario_extra (float): El monto a agregar al salario. Debe ser mayor que 0. """ if salario_extra > 0: self.__registrar_transaccion(TipoTransaccion.AGREGAR_SALARIO) self._salario += salario_extra print(f"Se ha agregado salario extra. Nuevo salario: {self._salario}") else: self.__registrar_transaccion(TipoTransaccion.FALLO_TRANSACCION) print("El salario extra no puede ser menor o igual a cero") def quitar_salario(self, salario_restar): """ Reduce el salario actual del empleado en un monto específico. Args: salario_restar (float): El monto a restar del salario. Debe ser mayor que 0. """ if salario_restar > 0: if salario_restar <= self._salario: self.__registrar_transaccion(TipoTransaccion.QUITAR_SALARIO) self._salario -= salario_restar print(f"Se ha quitado salario. Nuevo salario: {self._salario}") else: print("El salario a quitar no puede ser superior al saldo actual.") self.__registrar_transaccion(TipoTransaccion.FALLO_TRANSACCION) else: self.__registrar_transaccion(TipoTransaccion.FALLO_TRANSACCION) print("El salario a restar no puede ser menor o igual a cero") @salario.deleter def salario(self): self.__registrar_transaccion(TipoTransaccion.ELIMINAR_SALARIO) del self._salario print(f"Se ha eliminado el salario correctamente de { self.nombre } ") def mostrar_transacciones(self): """ Muestra un historial de todas las transacciones realizadas sobre el salario del empleado. """ print(f"Transacciones para el empleado {self.nombre}:") for transaccion in self.__transacciones: print(f"- {transaccion.name}") # .name para una representación más legible # Uso de la clase Empleado y sus métodos empleado1 = Empleado("Juan Pérez", 2000.0) # Crear un empleado con salario inicial # Obtener el salario (usando el getter) print(f"Salario actual de {empleado1.nombre}: {empleado1.salario}") # Establecer un nuevo salario (usando el setter) empleado1.salario = 2500.0 # Agregar salario extra empleado1.agregar_salario(200.0) # Quitar salario empleado1.quitar_salario(100.0) # Intentar quitar más salario del disponible empleado1.quitar_salario(3000.0) # Intentar asignar un salario negativo empleado1.salario = -500 #Mostrar historial de transacciones. empleado1.mostrar_transacciones() # Crear otro empleado empleado2 = Empleado("Maria Gomez", 1800.0) print(f"Salario actual de {empleado2.nombre}: {empleado2.salario}") #Eliminando el salario del empleado2.salario empleado2.mostrar_transacciones() #Maria no deberia de tener transacciones de Juan. ```from enum import Enum class TipoTransaccion(Enum):    """    Enumeración para los tipos de transacciones que se pueden realizar sobre el salario de un empleado.    """    AGREGAR\_SALARIO = 1       *# Añadir un bono o incremento al salario.*    QUITAR\_SALARIO = 2        *# Reducir el salario (e.g., por deducciones).*    MOSTRAR\_SALARIO = 3       *# Consultar el salario actual.*    DEFINIR\_NUEVO\_SALARIO = 4  *# Establecer un nuevo salario (reemplaza el anterior).*    ELIMINAR\_SALARIO = 5     *# Elimina el salario de un empleado.*    FALLO\_TRANSACCION = 6     *# Indica que una transacción no se pudo realizar.* class Empleado:    """    Clase que representa a un empleado con su nombre y salario.    Permite gestionar el salario y registrar las transacciones realizadas.    """    def \_\_init\_\_(self, nombre, salario):        """        Constructor de la clase Empleado.         Args:            nombre (str): El nombre del empleado.            salario (float): El salario inicial del empleado.  Debe ser mayor que 0.        """        self.nombre = nombre        self.\_salario = salario  *# El salario se guarda como un atributo "protegido" (\_salario).*        self.\_\_transacciones = \[]  *# Lista privada para registrar las transacciones.  Se usa \_\_ para "ocultarla" (name mangling).*     def \_\_registrar\_transaccion(self, tipo\_transaccion: TipoTransaccion):        """        Método privado para registrar una transacción en la lista de transacciones.         Args:            tipo\_transaccion (TipoTransaccion): El tipo de transacción a registrar.        """        self.\_\_transacciones.append(tipo\_transaccion)        print(f"Transacción de tipo: {tipo\_transaccion.name}") *# Mejor usar .name para obtener el nombre del enum*     @property    def salario(self):        """        Getter para el salario.  Permite acceder al salario como una propiedad (empleado.salario).        Registra una transacción de tipo MOSTRAR\_SALARIO.        """        self.\_\_registrar\_transaccion(TipoTransaccion.MOSTRAR\_SALARIO)        return self.\_salario     @salario.setter    def salario(self, nuevo\_salario):        """        Setter para el salario. Permite modificar el salario, validando que sea un valor positivo.        Registra una transacción de tipo DEFINIR\_NUEVO\_SALARIO si es válido, o FALLO\_TRANSACCION si no.         Args:            nuevo\_salario (float): El nuevo salario a asignar.        """        if nuevo\_salario > 0:            self.\_\_registrar\_transaccion(TipoTransaccion.DEFINIR\_NUEVO\_SALARIO)            self.\_salario = nuevo\_salario            print(f"Se ha asignado nuevo salario: {nuevo\_salario}")        else:            self.\_\_registrar\_transaccion(TipoTransaccion.FALLO\_TRANSACCION)            print("El nuevo salario no puede ser menor o igual a cero")     def agregar\_salario(self, salario\_extra):        """        Agrega un monto adicional al salario actual del empleado.         Args:            salario\_extra (float): El monto a agregar al salario. Debe ser mayor que 0.        """        if salario\_extra > 0:            self.\_\_registrar\_transaccion(TipoTransaccion.AGREGAR\_SALARIO)            self.\_salario += salario\_extra            print(f"Se ha agregado salario extra. Nuevo salario: {self.\_salario}")        else:            self.\_\_registrar\_transaccion(TipoTransaccion.FALLO\_TRANSACCION)            print("El salario extra no puede ser menor o igual a cero")     def quitar\_salario(self, salario\_restar):        """        Reduce el salario actual del empleado en un monto específico.         Args:            salario\_restar (float): El monto a restar del salario.  Debe ser mayor que 0.        """        if salario\_restar > 0:            if salario\_restar <= self.\_salario:                self.\_\_registrar\_transaccion(TipoTransaccion.QUITAR\_SALARIO)                self.\_salario -= salario\_restar                print(f"Se ha quitado salario. Nuevo salario: {self.\_salario}")            else:                print("El salario a quitar no puede ser superior al saldo actual.")                self.\_\_registrar\_transaccion(TipoTransaccion.FALLO\_TRANSACCION)        else:            self.\_\_registrar\_transaccion(TipoTransaccion.FALLO\_TRANSACCION)            print("El salario a restar no puede ser menor o igual a cero")     @salario.deleter    def salario(self):        self.\_\_registrar\_transaccion(TipoTransaccion.ELIMINAR\_SALARIO)        del self.\_salario        print(f"Se ha eliminado el salario correctamente de { self.nombre } ")     def mostrar\_transacciones(self):        """        Muestra un historial de todas las transacciones realizadas sobre el salario del empleado.        """        print(f"Transacciones para el empleado {self.nombre}:")        for transaccion in self.\_\_transacciones:            print(f"- {transaccion.name}")  *# .name para una representación más legible* *# Uso de la clase Empleado y sus métodos*empleado1 = Empleado("Juan Pérez", 2000.0)  *# Crear un empleado con salario inicial* *# Obtener el salario (usando el getter)*print(f"Salario actual de {empleado1.nombre}: {empleado1.salario}") *# Establecer un nuevo salario (usando el setter)*empleado1.salario = 2500.0 *# Agregar salario extra*empleado1.agregar\_salario(200.0) *# Quitar salario*empleado1.quitar\_salario(100.0) *# Intentar quitar más salario del disponible*empleado1.quitar\_salario(3000.0) *# Intentar asignar un salario negativo*empleado1.salario = -500 *#Mostrar historial de transacciones.*empleado1.mostrar\_transacciones() *# Crear otro empleado*empleado2 = Empleado("Maria Gomez", 1800.0)print(f"Salario actual de {empleado2.nombre}: {empleado2.salario}") *#Eliminando el salario*del empleado2.salarioempleado2.mostrar\_transacciones() *#Maria no deberia de tener transacciones de Juan.*

```js class Producto: def __init__(self, id, name, price, stock): self.id = id self.name = name self._price = price self._stock = stock @property def product(self): return self.id, self.name, self._price, self._stock @product.setter def product(self, newProduct): if newProduct[0] < 0 or newProduct[1] < 0: raise ValueError("El precio y/o stock no pueden ser negativos") self._price = newProduct[0] self._stock = newProduct[1] @product.deleter def product(self): print(f"El producto {self.name} ha sido eliminado") del self def calcular_valor(self): total = self._price * self._stock return print(f"El valor total del inventario es {total}") #Instancia de producto prod1 = Producto(1, "Huevo", 3, 20) print(prod1.product) prod1.product = (5, 10) print(prod1.product) #del prod1.product #print(prod1.product) prod1.calcular_valor() ```

```python class Producto: def __init__(self, name, precio, stock): self.name = name self._precio = precio self._stock = stock @property def precio(self): return self._precio @property def stock(self): return self._stock @precio.setter def precio(self, nuevo_precio): if nuevo_precio < 0: raise ValueError("Precio no puede ser negativo") self._precio = nuevo_precio @stock.setter def stock(self, nuevo_stock): if nuevo_stock < 0: raise ValueError("Stock no puede ser negativo") self._stock = nuevo_stock @precio.deleter def precio(self): print(f"El precio del producto {self.name} a sido eliminado") del self._precio @stock.deleter def stock(self): print(f"El stock del producto {self.name} a sido eliminado") del self.stock def precio_intentario_total_producto(self): total = self._precio * self._stock return f"Valor total del inventario del producto es = $ {total:.2f}" producto1 = Producto("Teclado", 100, 10) print(producto1.precio) print(producto1.stock) producto1.precio = 150 producto1.stock = 20 print(producto1.precio) print(producto1.stock) print(producto1.precio_intentario_total_producto()) ```


```js class Producto: def __init__(self, name:str, precio:float, stock:int): self.name = name self._precio = precio self.stock = stock @property def stock(self): return self._stock @property def precio(self): return self._precio @stock.setter def stock(self, nuevo_stock): if nuevo_stock < 0: raise ValueError("El stock no puede ser negativo") self._stock = nuevo_stock @precio.setter def precio(self, nuevo_precio): if nuevo_precio < 0: raise ValueError("El precio no puede ser negativo") self._precio = nuevo_precio @stock.deleter def stock(self): print("El stock ha sido eliminado") del self._stock @precio.deleter def precio(self): print("El precio ha sido eliminado") del self._precio def __info__(self): return f"Producto: {self.name}, Precio: {self.precio}, Stock: {self.stock}" #crear una instancia de Producto producto = Producto("Laptop", 1000, 10) print(producto.__info__()) producto.stock = 20 print(producto.__info__()) #producto.stock = -10 producto.precio = 2000 print(producto.__info__()) #producto.precio = -2000 producto.precio = 1000 print(producto.__info__()) del producto.stock ```

Termiando, lo hice de este modo:class Producto:    def \_\_init\_\_(self, nombre, marca, precio, stock):        self.nombre = nombre        self.marca = marca        self.\_precio = precio        self.\_stock = stock        @property    def precio(self):        return self.\_precio        @property    def stock(self):        return self.\_stock        @precio.setter    def precio(self, nuevo\_precio):        if nuevo\_precio < 0:            raise ValueError("El precio asignado no puede ser negativo.")        self.\_precio = nuevo\_precio        @stock.setter    def stock(self, nuevo\_stock):        if nuevo\_stock < 0:            raise ValueError("El stock de unidades no puede ser negativo.")        self.\_stock = nuevo\_stock     def inventario(self):        return self.\_stock    #instanciando el productoescobas = Producto('Escoba de micro fibra','Rey', 6800, 12)print(escobas.inventario())#donde es validado el precio y el stock que no puede ser negativoescobas.precio = 10000escobas.stock = 2print(escobas.precio)print(escobas.inventario()) ```python class Producto: def __init__(self, nombre, marca, precio, stock): self.nombre = nombre self.marca = marca self._precio = precio self._stock = stock @property def precio(self): return self._precio @property def stock(self): return self._stock @precio.setter def precio(self, nuevo_precio): if nuevo_precio < 0: raise ValueError("El precio asignado no puede ser negativo.") self._precio = nuevo_precio @stock.setter def stock(self, nuevo_stock): if nuevo_stock < 0: raise ValueError("El stock de unidades no puede ser negativo.") self._stock = nuevo_stock def inventario(self): return self._stock #instanciando el producto escobas = Producto('Escoba de micro fibra','Rey', 6800, 12) print(escobas.inventario()) #donde es validado el precio y el stock que no puede ser negativo escobas.precio = 10000 escobas.stock = 2 print(escobas.precio) print(escobas.inventario()) ```


```js class Producto: def __init__(self,name,price): self.name=name self._price=price @property def price(self): return self._price @price.setter def price(self,new_price): if new_price<0: raise ValueError('Price must be positive') self._price=new_price @price.deleter def price(self): print(f'The price for {self.name} has been deleted') del self._price producto1=Producto('leche de almendras',1200) print(producto1.price) producto1.price=1500 print(producto1.price) del producto1.price ```

```js class LessZero(Exception): def __init__(self, message): super().__init__(message) class Producto: def __init__(self, name: str, price: float, stock: int): self._price = price self._name = name self._stock = stock @property def price(self): return self._price @price.setter def price(self, new_price): try: if(new_price > 0): self._price = new_price else: raise LessZero("The new price is negative") except LessZero as e: print(e) @price.deleter def price(self): del self._price @property def stock(self): return self._stock @stock.setter def stock(self, new_stock): try: if(new_stock > 0): self._stock = new_stock else: raise LessZero("The new stock is negative") except LessZero as e: print(e) @stock.deleter def stock(self): del self._stock def total(self): return self.price * self.stock ```

```python class Product: def __init__(self, name, price, stock): self.name = name self._price = price self._stock = stock @property def price(self): return self._price @property def stock(self): return self._stock @price.setter def price(self, new_price): if new_price < 0: raise ValueError("Error. El precio no puede ser negativo") self._price = new_price @stock.setter def stock(self, updated_stock): if updated_stock < 0: raise ValueError("Error. El stock no puede ser negativo") self._stock = updated_stock @stock.deleter def stock(self): print(f"El producto {self.name} ha sido eliminado de stock") del self._stock def calcular_total(self): return self._stock * self._price producto1 = Product("Playera", 300, 20) print(f"Precio: {producto1.price}") print(f"Cantidad: {producto1.stock}") producto1.price = 250 producto1.stock = 11 print(f"Precio: {producto1.price}") print(f"Cantidad: {producto1.stock}") #producto1.price = -250 #producto1.stock = -3 print(f"Valor total de inventario de {producto1.name}:", producto1.calcular_total()) del producto1.stock ```

```python class Producto: def __init__(self, nombre, precio, stock): self._nombre = nombre self._precio = precio self._stock = stock @property def nombre(self): return self._nombre @property def precio(self): return self._precio @property def stock(self): return self._stock @nombre.setter def nombre(self, nombre_nuevo): if not isinstance(nombre_nuevo, str): raise ValueError("El nombre del producto debe ser una cadena de texto.") self._nombre = nombre_nuevo @nombre.deleter def nombre(self): print(f"El nombre del producto {self.nombre} ha sido eliminado.") del self._nombre @precio.setter def precio(self, precio_nuevo): if precio_nuevo < 0: raise ValueError("El precio del producto no puede ser negativo.") self._precio = precio_nuevo @precio.deleter def precio(self): print(f"El precio del producto {self.nombre} ha sido eliminado.") del self._precio @stock.setter def stock(self, stock_nuevo): if stock_nuevo < 0: raise ValueError("El stock del producto no puede ser negativo.") self._stock = stock_nuevo @stock.deleter def stock(self): print(f"El stock del producto {self.nombre} ha sido eliminado.") del self._stock def calcular_valor_inv(self, inventario: list) -> float: total = 0 for i in inventario: total += i.precio * i.stock return total class Inventario: def __init__(self, productos=[]): self._inventario = productos @property def inventario(self): return self._inventario def actualizar_inventario(self, accion:str, producto:Producto): # accion puede ser: agregar, eliminar if accion == 'agregar': self.inventario.append(producto) elif accion == 'eliminar': for p in self._inventario: if p == producto: self.inventario.remove(p) else: raise ValueError("La acción a realizar no es válida. Solo se admite agregar o eliminar") def consultar_inventario(self): inv_imprimir = [] for p in self._inventario: inv_imprimir.append((p.nombre, p.precio, p.stock)) return inv_imprimir # Crear instancias de productos p1 = Producto('p1', 10, 1) p2 = Producto('p2', 20, 2) p3 = Producto('p3', 30, 3) p4 = Producto('p4', 40, 4) p5 = Producto('p5', 50, 5) p6 = Producto('p6', 60, 6) # Modificar el precio y stock de un producto con valores válidos p1.precio = 11 print(p1.precio) p1.stock = 11 print(p1.stock) # Modificar el precio y stock de un producto con valores Inválidos #p1.precio = -11 #(p1.precio) #p1.stock = -11 #print(p1.stock) # Para calcular el total del inventario, se crea la clase inventario # Crear una instancia de inventario, inicializandolo con 3 productos, puede ser vacía inventario1 = Inventario([p1, p2, p3]) #Consultamos el inventario print(inventario1.consultar_inventario()) # Agregamos un nuevo producto y consultamos inventario1.actualizar_inventario('agregar', p4) print(inventario1.consultar_inventario()) # Eliminamos un producto y consultamos inventario1.actualizar_inventario('eliminar', p1) print(inventario1.consultar_inventario()) # Agregamos los productos p5, y p6 y consultamos inventario1.actualizar_inventario('agregar', p5) inventario1.actualizar_inventario('agregar', p6) print(inventario1.consultar_inventario()) # Usamos mal el metodo actualizar #inventario1.actualizar_inventario('eli', p4) # ValueError: La acci�n a realizar no es v�lida. Solo se admite agregar o eliminar #print(inventario1.consultar_inventario()) # LLamamos a la función que calcula el valor total del inventario total_inv = p6.calcular_valor_inv(inventario1.inventario) print(f'El valor total del inventario es: $ {total_inv}') ```

Aquí dejo mi código de resolución del reto para esta clase:class Producto: def \_\_init\_\_(self, nombre, precio, stock): self.nombre = nombre self.\_precio = precio # Atributo protegido mediante \_ self.\_stock = stock # Atributo protegido mediante \_ @property def precio(self): return self.\_precio @precio.setter def precio(self, nuevo\_precio): if nuevo\_precio < 0: raise ValueError("El precio de un producto no puede ser negativo") self.\_precio = nuevo\_precio @precio.deleter def precio(self): del self.\_precio print(f"El precio de {self.nombre} ha sido borrado") @property def stock(self): return self.\_stock @stock.setter def stock(self, nuevo\_stock): if nuevo\_stock < 0: raise ValueError("El stock de un procuto no puede ser negativo") @stock.deleter def stock(self): del self.\_stock print(f"El stock del producto {self.nombre} ha sido borrado") # Método que calcula el valor total del producto en el inventario # stock \* precio def valor\_total\_en\_inventario (self): return self.\_stock \* self.\_precio def listar\_inventario(): print("===========================================================================================================================") print("INVENTARIO") print("===========================================================================================================================") print("ARTÍCULO\t\t\tPRECIO UNITARIO\t\t\tCANTIDAD\t\t\tPRECIO EN INVENTARIO") print("---------------------------------------------------------------------------------------------------------------------------") print(f"{producto1.nombre}\t\t\t{producto1.precio}\t\t\t\t{producto1.stock}\t\t\t\t{producto1.valor\_total\_en\_inventario()}") print("---------------------------------------------------------------------------------------------------------------------------") print(f"{producto2.nombre}\t\t\t{producto2.precio}\t\t\t\t{producto2.stock}\t\t\t\t{producto2.valor\_total\_en\_inventario()}") print("---------------------------------------------------------------------------------------------------------------------------") print(f"{producto3.nombre}\t\t\t{producto3.precio}\t\t\t\t{producto3.stock}\t\t\t\t{producto3.valor\_total\_en\_inventario()}") print("---------------------------------------------------------------------------------------------------------------------------") print(f"{producto4.nombre}\t\t\t{producto4.precio}\t\t\t\t{producto4.stock}\t\t\t\t{producto4.valor\_total\_en\_inventario()}") print("---------------------------------------------------------------------------------------------------------------------------") print(f"{producto5.nombre}\t\t\t{producto5.precio}\t\t\t\t{producto5.stock}\t\t\t\t{producto5.valor\_total\_en\_inventario()}") print("===========================================================================================================================") \# PRUEBASproducto1 = Producto("Pegamento", 0, 0)producto2 = Producto("Destornillador", 0, 0)producto3 = Producto("Alicates", 0, 0)producto4 = Producto("Lijadora", 0, 0)producto5 = Producto("Linterna", 0, 0) \## Getterslistar\_inventario() \## Settersproducto1.precio = 6producto1.stock = 50producto2.precio = 12producto2.stock = 80producto3.precio =20producto3.stock = 77producto4.precio = 54producto4.stock = 10producto5.precio = 27producto5.stock = 8listar\_inventario() \## Control de precio y stock negativo# producto1.precio = -1# producto1.stock = -75# listar\_inventario() \## Deleterdel producto3.preciodel producto5.stock ```js class Producto: def __init__(self, nombre, precio, stock): self.nombre = nombre self._precio = precio # Atributo protegido mediante _ self._stock = stock # Atributo protegido mediante _ @property def precio(self): return self._precio @precio.setter def precio(self, nuevo_precio): if nuevo_precio < 0: raise ValueError("El precio de un producto no puede ser negativo") self._precio = nuevo_precio @precio.deleter def precio(self): del self._precio print(f"El precio de {self.nombre} ha sido borrado") @property def stock(self): return self._stock @stock.setter def stock(self, nuevo_stock): if nuevo_stock < 0: raise ValueError("El stock de un procuto no puede ser negativo") @stock.deleter def stock(self): del self._stock print(f"El stock del producto {self.nombre} ha sido borrado") # Método que calcula el valor total del producto en el inventario # stock * precio def valor_total_en_inventario (self): return self._stock * self._precio def listar_inventario(): print("===========================================================================================================================") print("INVENTARIO") print("===========================================================================================================================") print("ARTÍCULO\t\t\tPRECIO UNITARIO\t\t\tCANTIDAD\t\t\tPRECIO EN INVENTARIO") print("---------------------------------------------------------------------------------------------------------------------------") print(f"{producto1.nombre}\t\t\t{producto1.precio}\t\t\t\t{producto1.stock}\t\t\t\t{producto1.valor_total_en_inventario()}") print("---------------------------------------------------------------------------------------------------------------------------") print(f"{producto2.nombre}\t\t\t{producto2.precio}\t\t\t\t{producto2.stock}\t\t\t\t{producto2.valor_total_en_inventario()}") print("---------------------------------------------------------------------------------------------------------------------------") print(f"{producto3.nombre}\t\t\t{producto3.precio}\t\t\t\t{producto3.stock}\t\t\t\t{producto3.valor_total_en_inventario()}") print("---------------------------------------------------------------------------------------------------------------------------") print(f"{producto4.nombre}\t\t\t{producto4.precio}\t\t\t\t{producto4.stock}\t\t\t\t{producto4.valor_total_en_inventario()}") print("---------------------------------------------------------------------------------------------------------------------------") print(f"{producto5.nombre}\t\t\t{producto5.precio}\t\t\t\t{producto5.stock}\t\t\t\t{producto5.valor_total_en_inventario()}") print("===========================================================================================================================") # PRUEBAS producto1 = Producto("Pegamento", 0, 0) producto2 = Producto("Destornillador", 0, 0) producto3 = Producto("Alicates", 0, 0) producto4 = Producto("Lijadora", 0, 0) producto5 = Producto("Linterna", 0, 0) ## Getters listar_inventario() ## Setters producto1.precio = 6 producto1.stock = 50 producto2.precio = 12 producto2.stock = 80 producto3.precio =20 producto3.stock = 77 producto4.precio = 54 producto4.stock = 10 producto5.precio = 27 producto5.stock = 8 listar_inventario() ## Control de precio y stock negativo # producto1.precio = -1 # producto1.stock = -75 # listar_inventario() ## Deleter del producto3.precio del producto5.stock ```

```js class Producto: def __init__(self, nombre, precio, stock): self.nombre = nombre 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("Precio no puede ser negativo") self._precio = new_precio @property def stock(self): return self._stock @stock.setter def stock(self, new_stock): if new_stock < 0: raise ValueError("Stock no puede ser negativo") self._stock = new_stock def total_inventario(self): return self._precio * self._stock @property def info(self): return f"Producto: {self.nombre}, Precio: {self._precio}, Stock: {self._stock}" @info.deleter def info(self): print(f"La información del producto {self.nombre} ha sido eliminada") del self._precio del self._stock # Crear instancia de Producto producto = Producto("Camisa", 500, 100) print(f"INFO: {producto.info}") print(f"Total inventario: {producto.total_inventario()}") print(f"Stock: {producto.stock}") print(f"Precio: {producto.precio}") # Modificar el precio de forma controlada producto.precio = 600 print(f"INFO: {producto.info}") print(f"Total inventario: {producto.total_inventario()}") print(f"Stock: {producto.stock}") print(f"Precio: {producto.precio}") producto.stock = 200 print(f"INFO: {producto.info}") print(f"Total inventario: {producto.total_inventario()}") print(f"Stock: {producto.stock}") print(f"Precio: {producto.precio}") # Intentar establecer un precio negativo # producto.precio = -100 # Eliminar la información del producto del producto.info ```

```js """ Implementa una clase producto utiliza @property para controlar el acceso y modificacion del precio """ class Producto: def __init__(self, nombre, precio, cantidad): self._nombre = nombre self._precio = precio self._cantidad = cantidad @property def precio(self): return self._precio @precio.setter def precio(self, nuevo_precio): if nuevo_precio < 100: raise ValueError("El nuevo precio no puede ser tan bajo") self._precio = nuevo_precio @precio.deleter def precio(self): print(f'El precio de {self._nombre} a sido borrado') del self._precio producto = Producto('Camisa', 100, 10) print(producto.precio) # Modificar el salario de forma controlada usando el setter producto.precio = 500 print(producto.precio) # Eliminar el precio usando el deleter del producto.precio ```

```js class Producto: def __init__(self, nombre, precio, stock): self.nombre = nombre self._precio = precio self._stock = stock # Validación inicial if precio < 0: raise ValueError("El precio no puede ser negativo") if stock < 0: raise ValueError("El stock no puede ser negativo") @property def precio(self): return self._precio @precio.setter def precio(self, nuevo_precio): if nuevo_precio < 0: raise ValueError("El precio no puede ser negativo") self._precio = nuevo_precio @precio.deleter def precio(self): print(f"El precio del producto '{self.nombre}' ha sido eliminado") del self._precio @property def stock(self): return self._stock @stock.setter def stock(self, nuevo_stock): if nuevo_stock < 0: raise ValueError("El stock no puede ser negativo") self._stock = nuevo_stock @stock.deleter def stock(self): print(f"El stock del producto '{self.nombre}' ha sido eliminado") del self._stock def valor_total_inventario(self): return self._precio * self._stock # Ejemplo de uso producto = Producto("Laptop", 1500, 10) print(f"Precio inicial: {producto.precio}") # 1500 print(f"Stock inicial: {producto.stock}") # 10 print(f"Valor total en inventario: {producto.valor_total_inventario()}") # 15000 # Modificar el precio y el stock producto.precio = 2000 producto.stock = 8 print(f"Nuevo precio: {producto.precio}") # 2000 print(f"Nuevo stock: {producto.stock}") # 8 print(f"Nuevo valor total en inventario: {producto.valor_total_inventario()}") # 16000 # Intentar establecer valores negativos # producto.precio = -500 # Generará un ValueError # producto.stock = -10 # Generará un ValueError # Eliminar el precio y el stock #del producto.precio #del producto.stock ```

`class Product:    ` `def __init__(self,product: str ,stock: int, price: float):        self.product = product        self._stock = stock        self._price = price        ## Propiedades del campo Price    @property #Propiedad para obtener informacion protegida    def price(self):        return self._price        @price.setter #Propiedad para modificar valor    def price(self,mod_price: float):        if mod_price < 1: #Se valida que el precio no sea cero ni, negativo            raise ValueError(F"Error, El precio no puede ser menor a 1")        else:            self._price = mod_price        @price.deleter #Propiedad para eliminar registros protegidos.    def price(self):        print(f"El precio del producto {self.product} ha sido eliminado.")        del self._price` `#### PROPIEDADES DEL CAMPO STOCK` `    @property #Toma dato protegido    def stock(self):        return self._stock        @stock.setter    def stock(self,add_stock: int):        if add_stock < 1:            raise ValueError(F"No se ha sumado nada al stock del producto {self.product}, favor de validar.")        else:            self._stock += add_stock #Se añade cantidad al inventario        def stock_value(self):        stock_values = self.price * self.stock        print(F"El valor monetario del stock del producto {self.product} es de ${stock_values}.")    ` `#Se crea instanciaproduct = Product('coca-cola',10,20.50) ` `#Imprimir productoprint(f"Producto: {product.product} Precio: ${product.price}") # Producto: coca-cola Precio: $20.5` `#Cambio de precioproduct.price = 10.8print(product.price) #10.8` `#Eliminar preciodel product.price # El precio del producto coca-cola ha sido eliminado.` `#Se añaden 5 unidades al stockproduct.stock = 0` `product.stock_value() #Result : El valor monetario del stock del producto coca-cola es de $205.0.`

```python 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, price): if price < 0: raise ValueError('El precio no puede ser menor a 0') self._price = price print(f'Se ha actualizado el precio a {self._price}') @property def stock(self): return self._stock @stock.setter def stock(self, stock): if stock < 0: raise ValueError('El stock no puede ser menor a 0') self._stock = stock print(f'Se ha actualizado el stock a {self._stock}') def calculate_inventory_value(self): return self._price * self._stock prod1 = Product("Tablet", 1000, 2) prod1.price = 1500 try: prod1.price = -10 except ValueError as e: print(e) prod1.stock = 2 try: prod1.stock = -10 except ValueError as e: print(e) print('Valor inventario:', prod1.calculate_inventory_value()) ```

````python # comparto el codigo explicado paso a paso class Employee: """ Clase que representa a un empleado, con control sobre el salario. Atributos: - name (str): El nombre del empleado. - _salary (float): El salario del empleado, almacenado de forma protegida. """ def __init__(self, name, salary): """ Inicializa un nuevo objeto de la clase Employee con un nombre y un salario inicial. Parámetros: - name (str): El nombre del empleado. - salary (float): El salario inicial del empleado. """ self.name = name # Nombre del empleado self._salary = salary # Salario almacenado como un atributo protegido @property def salary(self): """ Getter para el salario, permite acceder al salario de forma controlada. Retorna: - float: El salario actual del empleado. """ return self._salary @salary.setter def salary(self, new_salary): """ Setter para el salario, permite actualizar el salario de forma controlada. Parámetros: - new_salary (float): El nuevo salario del empleado. Debe ser mayor o igual a 0. Lanza: - ValueError: Si el nuevo salario es negativo. """ if new_salary < 0: raise ValueError("Salary cannot be negative") # Control de salario no negativo self._salary = new_salary @salary.deleter def salary(self): """ Deleter para el salario, elimina el atributo `_salary` y muestra un mensaje de confirmación. """ print(f"The salary of {self.name} has been deleted") del self._salary # Ejemplo de uso de la clase Employee employee = Employee("Ana", 5000) # Crear una instancia con un salario inicial de 5000 print(employee.salary) # Output: 5000 # Modificar el salario de forma controlada usando el setter employee.salary = 6000 # Cambia el salario a 6000 print(employee.salary) # Output: 6000 # Intentar establecer un salario negativo (descomentando se lanzaría un error) # employee.salary = -1000 # Eliminar el salario usando el deleter del employee.salary # Output: "The salary of Ana has been deleted" ```class Employee:    """    Clase que representa a un empleado, con control sobre el salario.        Atributos:    - name (str): El nombre del empleado.    - \_salary (float): El salario del empleado, almacenado de forma protegida.    """        def \_\_init\_\_(self, name, salary):        """        Inicializa un nuevo objeto de la clase Employee con un nombre y un salario inicial.         Parámetros:        - name (str): El nombre del empleado.        - salary (float): El salario inicial del empleado.        """        self.name = name           *# Nombre del empleado*        self.\_salary = salary       *# Salario almacenado como un atributo protegido*     @property    def salary(self):        """        Getter para el salario, permite acceder al salario de forma controlada.                Retorna:        - float: El salario actual del empleado.        """        return self.\_salary     @salary.setter    def salary(self, new\_salary):        """        Setter para el salario, permite actualizar el salario de forma controlada.         Parámetros:        - new\_salary (float): El nuevo salario del empleado. Debe ser mayor o igual a 0.                Lanza:        - ValueError: Si el nuevo salario es negativo.        """        if new\_salary < 0:            raise ValueError("Salary cannot be negative")  *# Control de salario no negativo*        self.\_salary = new\_salary     @salary.deleter    def salary(self):        """        Deleter para el salario, elimina el atributo `\_salary` y muestra un mensaje de confirmación.        """        print(f"The salary of {self.name} has been deleted")        del self.\_salary *# Ejemplo de uso de la clase Employee*employee = Employee("Ana", 5000)    *# Crear una instancia con un salario inicial de 5000*print(employee.salary)               *# Output: 5000* *# Modificar el salario de forma controlada usando el setter*employee.salary = 6000               *# Cambia el salario a 6000*print(employee.salary)               *# Output: 6000* *# Intentar establecer un salario negativo (descomentando se lanzaría un error)# employee.salary = -1000* *# Eliminar el salario usando el deleter*del employee.salary  *# Output: "The salary of Ana has been deleted"* ````

````js """ Implementa una clase producto utiliza @property para controlar el acceso y modificacion del precio """ class Producto: def __init__(self, nombre, precio, cantidad): self._nombre = nombre self._precio = precio self._cantidad = cantidad @property def precio(self): return self._precio @precio.setter def precio(self, nuevo_precio): if nuevo_precio < 100: raise ValueError("El nuevo precio no puede ser tan bajo") self._precio = nuevo_precio @precio.deleter def precio(self): print(f'El precio de {self._nombre} a sido borrado') del self._precio producto = Producto('Camisa', 100, 10) print(producto.precio) # Modificar el salario de forma controlada usando el setter producto.precio = 500 print(producto.precio) # Eliminar el precio usando el deleter del producto.precio ```"""     Implementa una clase producto    utiliza @property para controlar el acceso y modificacion del precio"""class Producto:    def \_\_init\_\_(self, nombre, precio, cantidad):        self.\_nombre = nombre        self.\_precio = precio        self.\_cantidad = cantidad        @property    def precio(self):        return self.\_precio        @precio.setter    def precio(self, nuevo\_precio):        if nuevo\_precio < 100:            raise ValueError("El nuevo precio no puede ser tan bajo")        self.\_precio = nuevo\_precio        @precio.deleter    def precio(self):        print(f'El precio de {self.\_nombre} a sido borrado')        del self.\_precio producto = Producto('Camisa', 100, 10)print(producto.precio) *# Modificar el salario de forma controlada usando el setter*producto.precio = 500print(producto.precio) *# Eliminar el precio usando el deleter*del producto.precio ````