Objetos heredados

Carli podrías por favorsito aclarar cuando usas algún elemento del código como buena practica, cosas como el uso del return, y get para llamar variables o consultar en lugar de llamar a los parámetros directamente, estas buenas practicas que escribes en automático me generan confusión y retrasan el proceso de aprendizaje en consultas a gtp. Me gustaría poder enfocar mas el tiempo en pensar en flujos y no en sintaxis :C. seria genial si nos dejas mensajitos aclaratorios :D

Personalmente, desde que empezamos con POO han surgido varias cosas que no me han quedado muy claras, por ejemplo: enviar como parámetro una instancia de una clase, el uso de 'raise NotImplementedError' que justamente se vé en esta clase. Sé que es difícil profundizar en todo lo que conlleva un tema y debemos consultar por nosotros mismos, pero creo que si hace falta un poco más de explicaciones y profundizar. Esta es solo mi opinión pero quisiera saber si no soy el único que piensa lo mismo...

En la clase pasada tuvo un error de identación que no aclaró en esta sesión ya que creó la clase car dentro de la clase vehicle y en esta nueva clase ya aparece corregido. Si depronto alguien se atasca con eso, sólo es correr esa clase un tab hacia atrás.

```python #Ejercicios class Vehicle: def __init__(self,brand,model,price): self.brand = brand self.model = model self.price = price self.is_available = True def sell(self): if self.is_available: self.is_available = False print(f"El vehiculo {self.brand}. Ha sido vendido.") else: print(f"El vehiculo {self.brand}. No está vendido.") def check_available(self): return self.is_available def get_price(self): return self.price def start_engine(self): raise NotImplementedError("Este método debe ser implementado por la subclase") def stop_engine(self): raise NotImplementedError("Este método debe ser implementado por la subclase") class Car(Vehicle): def start_engine(self): if not self.is_available: return f"El motor del coche {self.brand} está en marcha." else: return f"El coche {self.brand} no está disponible." def stop_engine(self): if not self.is_available: return f"El motor del coche {self.brand} se ha detenido." else: return f"El coche {self.brand} no está disponible." class Bike(Vehicle): def start_engine(self): if not self.is_available: return f"La bicicleta {self.brand} está en marcha." else: return f"La bicicleta {self.brand} no está disponible." def stop_engine(self): if not self.is_available: return f"La bicicleta {self.brand} se ha detenido." else: return f"La bicicleta {self.brand} no está disponible." class Truck(Vehicle): def start_engine(self): if not self.is_available: return f"El motor del camión {self.brand} está en marcha." else: return f"El camión {self.brand} no está disponible." def stop_engine(self): if not self.is_available: return f"El motor del camión {self.brand} se ha detenido." else: return f"El camión {self.brand} no está disponible." class Customer: def __init__(self,name): self.name = name self.purchased_vehicles = [] def buy_vehicle(self, vehicle: Vehicle): if vehicle.check_available(): vehicle.sell() self.purchased_vehicles.append(vehicle) else: print(f"Lo siento, {vehicle.brand} no está disponible.") def inquire_vehicle(self, vehicle: Vehicle): if vehicle.check_available(): availablity = "Disponible" else: availablity = "No disponible" print(f"El {vehicle.brand} está {availablity} y cuesta {vehicle.get_price()}.") class Dealership: def __init__(self): self.inventory = [] self.customers = [] def add_vehicles(self, vehicle: Vehicle): self.inventory.append(vehicle) print(f"El {vehicle.brand} ha sido añadido al inventario.") def register_customers(self, customer: Customer): self.customers.append(customer) print(f"El cliente {customer.name} ha sido añadido.") def show_available_vehicle(self): print("Vehiculos disponibles en la tienda") for vehicle in self.inventory: if vehicle.check_available(): print(f" - {vehicle.brand} por {vehicle.get_price()}.") ```

En video anterior cuando vimos como se declara la clase Bike el codigo nos tiraba un pequeño error justo al declarar: class Bike(<u>Vehicle</u>): Se omite como se resuelve y en este video simplemente no está, el error se debe a que la clase Bike se estaba creando dentro de Vehicle y debía estar fuera (Identación)

no entendi si estamos e un concesionario que tiene que ver que este en marcha, hace confuso el ejemplo

Si quieres agregar nuevos atributos a las clases hijas, puedes usar la función reservada "**super()**" así: . ```python class BaseClass: def __init__(self, base_attr): self.base_attr = base_attr class DerivedClass(BaseClass): def __init__(self, base_attr, derived_attr): super().__init__(base_attr) self.derived_attr = derived_attr ```

## Apunte sobre la Herencia en el Código 😊 **¿Qué es la Herencia?** La herencia es como una receta familiar 👨‍🍳. La clase padre (`Vehiculo`) tiene los ingredientes básicos 🧂 y las instrucciones generales 📝. Las subclases (`Car` y `Motorcycle`) heredan esos elementos, pero también pueden agregar sus propios toques especiales ✨ ¡y hasta crear nuevas recetas a partir de la original! **¿Cómo funciona en este código?** 1. **Clase Padre** `Vehiculo`**:** * Define los ingredientes básicos 🧂 (atributos) como `marca`, `modelo`, `color`, `precio`, `esta_disponible`. * Incluye instrucciones generales 📝 (métodos) como `vender`, `disponibilidad`, `get_precio`. * Tiene instrucciones "pendientes" 🚧 (`NotImplementedError` en `start_engine` y `stop_engine`) que las subclases deben completar. 2. **Subclases** `Car` **y** `Motorcycle`**:** * Heredan la receta base de `Vehiculo` 📖 * Usan `super().__init__(...)` para preparar los ingredientes básicos heredados 🧂 * Añaden sus propios ingredientes especiales ✨ (`num_puertas` para `Car` y `cilindrada` para `Motorcycle`) * Completan las instrucciones pendientes 🚧, cada una a su manera (`start_engine` y `stop_engine`) * Tienen sus propias instrucciones exclusivas 🤫 (`get_num_puertas` para `Car` y `get_cilindrada` para `Motorcycle`) **Palabras Clave especiales:** * `NotImplementedError` 🚧: Es como un recordatorio 📝 para las subclases: "¡Oye, no olvides completar esta instrucción!" * `return` : Es como devolver un regalo 🎁 al final de una función. ¡Útil para obtener información de un objeto! * `get_algo` 🔍: Es una forma educada de pedirle a un objeto que te muestre algo específico. ¡Como preguntar "¿Cuál es tu número de puertas?" a un auto! 🚗 ```python # Va ser la clase padre class Vehiculo: def __init__(self, marca, modelo, color, precio): """ Constructor de la clase Vehiculo. Inicializa un nuevo vehículo con los atributos proporcionados. """ self.marca = marca self.modelo = modelo self.color = color self.precio = precio self.esta_disponible = True # Indica si el vehículo está disponible para la venta def vender(self): """ Marca el vehículo como vendido si está disponible. """ if self.esta_disponible: self.esta_disponible = False print(f"El vehículo {self.marca} {self.modelo} ha sido vendido") else: print(f"El vehículo {self.marca} {self.modelo} no está disponible") def disponibilidad(self): """ Devuelve True si el vehículo está disponible, False de lo contrario """ return self.esta_disponible def get_precio(self): """ Devuelve el precio del vehículo """ return self.precio def start_engine(self): """ Método abstracto para encender el motor. Debe ser implementado por las subclases """ raise NotImplementedError("Subclases deben implementar este método") def stop_engine(self): """ Método abstracto para apagar el motor. Debe ser implementado por las subclases """ raise NotImplementedError("Subclases deben implementar este método") """ Subclase: Auto """ class Car(Vehiculo): def __init__(self, marca, modelo, color, precio, num_puertas): """ Constructor de la clase Car. Hereda de la clase Vehiculo y agrega el atributo num_puertas """ super().__init__(marca, modelo, color, precio) # Llama al constructor de la clase padre self.num_puertas = num_puertas def start_engine(self): """ Implementación específica para encender el motor de un auto """ print(f"El auto {self.marca} {self.modelo} está en funcionamiento") def stop_engine(self): """ Implementación específica para apagar el motor de un auto """ print(f"El auto {self.marca} {self.modelo} se detuvo") def get_num_puertas(self): """ Devuelve el número de puertas del auto """ return self.num_puertas """ Subclase: Motocicleta """ class Motorcycle(Vehiculo): def __init__(self, marca, modelo, color, precio, cilindrada): """ Constructor de la clase Motorcycle. Hereda de la clase Vehiculo y agrega el atributo cilindrada """ super().__init__(marca, modelo, color, precio) self.cilindrada = cilindrada def start_engine(self): """ Implementación específica para encender el motor de una motocicleta """ print(f"La motocicleta {self.marca} {self.modelo} está en funcionamiento") def stop_engine(self): """ Implementación específica para apagar el motor de una motocicleta """ print(f"La motocicleta {self.marca} {self.modelo} se detuvo") def get_cilindrada(self): """ Devuelve la cilindrada de la motocicleta """ return self.cilindrada # Creacion de objetos car1 = Car("Toyota", "Camry", "Rojo", 25000, 4) car2 = Car("Honda", "Civic", "Azul", 22000, 4) car3 = Car("Ford", "Mustang", "Negro", 35000, 2) motorcycle1 = Motorcycle("Honda", "CBR", "Negro", 30000, 500) motorcycle2 = Motorcycle("Honda", "CBR", "Verde", 25000, 500) # Utilizar metodos car1.start_engine() car1.stop_engine() car1.vender() motorcycle1.start_engine() motorcycle1.stop_engine() motorcycle1.vender() car1.vender() # Intentar vender de nuevo, pero no estará disponible car2.esta_disponible = False # Cambiar la disponibilidad manualmente car2.vender() motorcycle2.cilindrada = 600 # Modificar la cilindrada print(motorcycle2.cilindrada) # Imprimir la nueva cilindrada ```# Va ser la clase padre * **Reutilización de Código:** ¡No hace falta repetir la receta base una y otra vez! ♻️ * **Organización:** ¡Todo está en su lugar, como una cocina bien ordenada! 🗄️ * **Flexibilidad:** ¡Cada subclase puede tener su propio estilo! 🎨 * **Polimorfismo:** ¡Puedes tratar a todos los vehículos por igual, aunque sean diferentes! 🚗🏍️ ¡Es como si todos hablaran el mismo idioma! 🗣️ **Ejemplo de Polimorfismo:** Pythonvehiculos = \[car1, motorcycle1] `for vehiculo in` vehiculos: ` vehiculo.start_engine() 🏁 # ¡Cada vehículo se enciende a su manera!`

El curso venía bien estructurado y me estaba gustando, desde que entramos a POO sinceramente todo se desorganizó, no explica bien los conceptos, ni por qué los hace, se supone que es un curso para principiantes y me frustro mucho cuando no entiendo ni el por qué realizan ciertas cosas, no me explican la estructura ni la lógica.

No es muy claro para mí, porque en el método inquire\_vehicle usas en el print: vehicle.brand para obtener la marca, y despues vehicle.get\_price() para obtener el precio. sin embargo vehicle.price también funciona sin la necesidad del método get

```python class Product: def __init__(self, product_id, name, price, quantity): self.product_id = product_id self.name = name self.price = price self.quantity = quantity def __str__(self): return f"Product ID: {self.product_id}, Name: {self.name}, Price: {self.price}, Quantity: {self.quantity}" class Inventory: def __init__(self): self.products = {} def add_product(self, product): if product.product_id in self.products: print(f"Product with ID {product.product_id} already exists. Updating quantity.") self.products[product.product_id].quantity += product.quantity else: self.products[product.product_id] = product print(f"Product {product.name} added to inventory.") def remove_product(self, product_id): if product_id in self.products: del self.products[product_id] print(f"Product with ID {product_id} removed.") else: print(f"Product with ID {product_id} not found.") def update_quantity(self, product_id, new_quantity): if product_id in self.products: self.products[product_id].quantity = new_quantity print(f"Quantity of product {product_id} updated to {new_quantity}.") else: print(f"Product with ID {product_id} not found.") def search_product(self, product_id): if product_id in self.products: return self.products[product_id] else: return None def display_all_products(self): if self.products: print("\nInventory:") for product in self.products.values(): print(product) else: print("Inventory is empty.") if __name__ == '__main__': store_inventory = Inventory() balon = Product(1, "Balon", 10, 50) cable_usb = Product(2, "Cable_usb", 20, 75) Luces_led = Product(3, "Luces_led", 33, 30) ordenador_portatil = Product(4, "Ordenador portátil", 1000.00, 20) raton_inalambrico = Product(5, "Ratón inalámbrico", 25.00, 50) teclado_mecanico = Product(6, "Teclado mecánico", 70.00, 30) monitor_full_hd = Product(7, "Monitor Full HD", 200.00, 15) impresora_multifuncion = Product(8, "Impresora multifunción", 150.00, 10) smartphone = Product(9, "Smartphone", 500.00, 25) auriculares_bluetooth = Product(10, "Auriculares Bluetooth", 40.00, 40) cargador_portatil = Product(11, "Cargador portátil", 30.00, 60) camara_seguridad = Product(12, "Cámara de seguridad", 120.00, 20) disco_duro_externo = Product(13, "Disco duro externo", 80.00, 25) store_inventory.add_product(balon) store_inventory.add_product(cable_usb) store_inventory.add_product(Luces_led) store_inventory.add_product(ordenador_portatil) store_inventory.add_product(raton_inalambrico) store_inventory.add_product(teclado_mecanico) store_inventory.add_product(monitor_full_hd) store_inventory.add_product(impresora_multifuncion) store_inventory.add_product(smartphone) store_inventory.add_product(auriculares_bluetooth) store_inventory.add_product(cargador_portatil) store_inventory.add_product(camara_seguridad) store_inventory.add_product(disco_duro_externo) store_inventory.display_all_products() found_product = store_inventory.search_product(2) if found_product: print(f"\nFound product: {found_product}") else: print("\nProduct not found.") # Update quantity store_inventory.update_quantity(2, 100) # Remove a product store_inventory.remove_product(3) # Display the updated inventory store_inventory.display_all_products() while True: print("\n1. Añadir producto") print("2. Mostrar productos") print("3. Buscar producto por ID") print("4. Buscar producto por nombre") print("5. Actualizar cantidad") print("6. Remover producto") print("7. Salir") opcion = input("\nSeleccione una opción: ") if opcion == '1': nombre = input("Ingrese el nombre del producto: ") try: id_producto = int(input("Ingrese el ID del producto: ")) precio = float(input("Ingrese el precio del producto: ")) cantidad = int(input("Ingrese la cantidad del producto: ")) producto = Product(id_producto, nombre, precio, cantidad) store_inventory.add_product(producto) except ValueError: print("Error: Por favor ingrese valores numéricos para ID, precio y cantidad.") elif opcion == '2': store_inventory.display_all_products() elif opcion == '3': id_producto = int(input("Ingrese el ID del producto a buscar: ")) encontrar_producto = store_inventory.search_product(id_producto) if encontrar_producto: print(f"\nEncontrar producto: {encontrar_producto}") else: print("\nProducto no encontrado.") elif opcion == '4': nombre_producto = input("Ingrese el nombre del producto a buscar: ") store_inventory.buscar_por_nombre(nombre_producto) elif opcion == '5': id_producto = int(input("Ingrese el ID del producto a actualizar: ")) nueva_cantidad = int(input("Ingrese la nueva cantidad: ")) store_inventory.update_quantity(id_producto, nueva_cantidad) elif opcion == '6': id_producto = int(input("Ingrese el ID del producto a remover: ")) store_inventory.remove_product(id_producto) elif opcion == '7': print("Saliendo del programa...") break else: print("Opción inválida. Intente de nuevo.") ```class Product:     def \_\_init\_\_(*self*, *product\_id*, *name*, *price*, *quantity*):        *self*.product\_id = *product\_id*        *self*.name = *name*        *self*.price = *price*        *self*.quantity = *quantity*     def \_\_str\_\_(*self*):        return f"Product ID: {*self*.product\_id}, Name: {*self*.name}, Price: {*self*.price}, Quantity: {*self*.quantity}" class Inventory:        def \_\_init\_\_(*self*):        *self*.products = {}     def add\_product(*self*, *product*):               if *product*.product\_id in *self*.products:            print(f"Product with ID {*product*.product\_id} already exists. Updating quantity.")            *self*.products\[*product*.product\_id].quantity += *product*.quantity        else:            *self*.products\[*product*.product\_id] = *product*            print(f"Product {*product*.name} added to inventory.")     def remove\_product(*self*, *product\_id*):                if *product\_id* in *self*.products:            del *self*.products\[*product\_id*]            print(f"Product with ID {*product\_id*} removed.")        else:            print(f"Product with ID {*product\_id*} not found.")     def update\_quantity(*self*, *product\_id*, *new\_quantity*):                if *product\_id* in *self*.products:            *self*.products\[*product\_id*].quantity = *new\_quantity*            print(f"Quantity of product {*product\_id*} updated to {*new\_quantity*}.")        else:            print(f"Product with ID {*product\_id*} not found.")     def search\_product(*self*, *product\_id*):                if *product\_id* in *self*.products:            return *self*.products\[*product\_id*]        else:            return None     def display\_all\_products(*self*):               if *self*.products:            print("\nInventory:")            for product in *self*.products.values():                print(product)        else:            print("Inventory is empty.") if \_\_name\_\_ == '\_\_main\_\_':    store\_inventory = Inventory()         balon = Product(1, "Balon", 10, 50)    cable\_usb = Product(2, "Cable\_usb", 20, 75)    Luces\_led = Product(3, "Luces\_led", 33, 30)    ordenador\_portatil = Product(4, "Ordenador portátil", 1000.00, 20)    raton\_inalambrico = Product(5, "Ratón inalámbrico", 25.00, 50)    teclado\_mecanico = Product(6, "Teclado mecánico", 70.00, 30)    monitor\_full\_hd = Product(7, "Monitor Full HD", 200.00, 15)    impresora\_multifuncion = Product(8, "Impresora multifunción", 150.00, 10)    smartphone = Product(9, "Smartphone", 500.00, 25)    auriculares\_bluetooth = Product(10, "Auriculares Bluetooth", 40.00, 40)    cargador\_portatil = Product(11, "Cargador portátil", 30.00, 60)    camara\_seguridad = Product(12, "Cámara de seguridad", 120.00, 20)    disco\_duro\_externo = Product(13, "Disco duro externo", 80.00, 25)      store\_inventory.add\_product(balon)    store\_inventory.add\_product(cable\_usb)    store\_inventory.add\_product(Luces\_led)    store\_inventory.add\_product(ordenador\_portatil)    store\_inventory.add\_product(raton\_inalambrico)    store\_inventory.add\_product(teclado\_mecanico)    store\_inventory.add\_product(monitor\_full\_hd)    store\_inventory.add\_product(impresora\_multifuncion)    store\_inventory.add\_product(smartphone)    store\_inventory.add\_product(auriculares\_bluetooth)    store\_inventory.add\_product(cargador\_portatil)    store\_inventory.add\_product(camara\_seguridad)    store\_inventory.add\_product(disco\_duro\_externo)            store\_inventory.display\_all\_products()        found\_product = store\_inventory.search\_product(2)    if found\_product:        print(f"\nFound product: {found\_product}")    else:        print("\nProduct not found.")     *# Update quantity*    store\_inventory.update\_quantity(2, 100)     *# Remove a product*    store\_inventory.remove\_product(3)     *# Display the updated inventory*    store\_inventory.display\_all\_products()         while True:        print("\n1. Añadir producto")        print("2. Mostrar productos")        print("3. Buscar producto por ID")        print("4. Buscar producto por nombre")        print("5. Actualizar cantidad")        print("6. Remover producto")        print("7. Salir")         opcion = input("\nSeleccione una opción: ")         if opcion == '1':            nombre = input("Ingrese el nombre del producto: ")            try:                id\_producto = int(input("Ingrese el ID del producto: "))                precio = float(input("Ingrese el precio del producto: "))                cantidad = int(input("Ingrese la cantidad del producto: "))                producto = Product(id\_producto, nombre, precio, cantidad)                store\_inventory.add\_product(producto)            except ValueError:                print("Error: Por favor ingrese valores numéricos para ID, precio y cantidad.")         elif opcion == '2':            store\_inventory.display\_all\_products()         elif opcion == '3':            id\_producto = int(input("Ingrese el ID del producto a buscar: "))            encontrar\_producto = store\_inventory.search\_product(id\_producto)            if encontrar\_producto:                print(f"\nEncontrar producto: {encontrar\_producto}")            else:                print("\nProducto no encontrado.")         elif opcion == '4':            nombre\_producto = input("Ingrese el nombre del producto a buscar: ")            store\_inventory.buscar\_por\_nombre(nombre\_producto)         elif opcion == '5':            id\_producto = int(input("Ingrese el ID del producto a actualizar: "))            nueva\_cantidad = int(input("Ingrese la nueva cantidad: "))            store\_inventory.update\_quantity(id\_producto, nueva\_cantidad)         elif opcion == '6':            id\_producto = int(input("Ingrese el ID del producto a remover: "))            store\_inventory.remove\_product(id\_producto)         elif opcion == '7':            print("Saliendo del programa...")            break         else:            print("Opción inválida. Intente de nuevo.")

Desde que comenzamos con el tema de POO he tenido dificultades ya que me surgen muchas dudas durante los videos , al principio creí que solo era yo , pero al revisar los comentarios me doy cuenta que varios de mis compañeros tiene problemas similares.

Consulta las clases hijas a pesar de heredar, no se supone que deberían llevar un constructor como la clase padre??

Pregunta, Para que especificar que es de la clase Vehicle en la función buy\_vehicle ?? Funciona sin necesidad de esa especificacion

Ejercicio de herencia ```python # Clase base o Superclase para vehículos class Vehicle: def __init__(self, brand, model, year, max_speed, price): self.brand = brand # Marca del vehículo self.model = model # Modelo del vehículo self.year = year # Año del vehículo self.max_speed = max_speed # Velocidad máxima del vehículo self.price = price # Precio del vehículo self.available = True # Estado de disponibilidad del vehículo, inicialmente disponible def sell(self): # Método para vender el vehículo if self.available: # Verifica si el vehículo está disponible self.available = False # Marca el vehículo como no disponible print(f"El vehículo {self.brand} {self.model} ha sido vendido") else: print(f"El vehículo {self.brand} {self.model} no está disponible") def check_avaliable(self): # Método para devolver el vehículo self.available = True # Marca el vehículo como disponible print(f"El vehículo {self.brand} {self.model} ha sido devuelto") def get_price(self): # Método para obtener el precio del vehículo return self.price def start_engine(self): # Método abstracto para encender el motor (debe ser implementado por las subclases) raise NotImplementedError("Este método debe ser implementado por la Subclase") def stop_engine(self): # Método abstracto para apagar el motor (debe ser implementado por las subclases) raise NotImplementedError("Este método debe ser implementado por la Subclase") # Subclase para automóviles class Car(Vehicle): def start_engine(self): if not self.available: return f"El motor del {self.brand} {self.model} está en marcha" else: return f"El carro {self.brand} {self.model} no está disponible" def stop_engine(self): if self.available: return f"El motor del {self.brand} {self.model} se ha detenido" else: return f"El carro {self.brand} {self.model} no está disponible" # Subclase para motocicletas class MotorBike(Vehicle): def start_engine(self): if not self.available: return f"El motor de la {self.brand} {self.model} está en marcha" else: return f"La moto {self.brand} {self.model} no está disponible" def stop_engine(self): if self.available: return f"El motor de la {self.brand} {self.model} se ha detenido" else: return f"La moto {self.brand} {self.model} no está disponible" # Subclase para vehículos eléctricos class Electrics(Vehicle): def start_engine(self): if not self.available: return f"El motor del {self.brand} {self.model} está en marcha" else: return f"El vehículo eléctrico {self.brand} {self.model} no está disponible" def stop_engine(self): if self.available: return f"El motor del {self.brand} {self.model} se ha detenido" else: return f"El vehículo eléctrico {self.brand} {self.model} no está disponible" class Customer: def __init__(self, name, customer_id): # Inicializa al cliente con nombre e ID self.name = name # Nombre del cliente self.customer_id = customer_id # ID del cliente self.puchased=[] def buy_vehicle(self, vehicle : Vehicle): # Método para que el cliente compre un automóvil if Vehicle.available: # Verifica si el automóvil está disponible Vehicle.sell() # Llama al método sell del automóvil para marcarlo como vendido print(f"{self.name} ha comprado el vehiculo {vehicle.brand} {vehicle.model}") # Mensaje de confirmación self.puchased.append(vehicle) else: print(f"El automóvil {vehicle.brand} {vehicle.model} no está disponible para la compra") # Mensaje si el automóvil no está disponible def consulta(self, vehicle:Vehicle): # Método para que el cliente devuelva un automóvil if vehicle.available(): availability = "Disponible" else: availability = "No Disponible" print(f"El automóvil {vehicle.brand} está {availability} y tiene un preci de {vehicle.get_price()}") # Mensaje si el automóvil no está disponible class Dealership: def __init__(self): # Inicializa la concesionaria self.inventory = [] # Lista para almacenar los automóviles en la concesionaria self.customers = [] # Lista para almacenar los clientes registrados def add_vehicle(self, vehicle:Vehicle): # Método para agregar un automóvil a la concesionaria self.inventory.append(vehicle) # Agrega el automóvil a la lista de automóviles print(f"El vehiculo {vehicle.brand} {vehicle.model} ha sido agregado al catálogo") # Mensaje de confirmación def register_customer(self, customer:Customer): # Método para registrar un cliente en la concesionaria self.customers.append(customer) # Agrega el cliente a la lista de clientes print(f"El cliente {customer.name} ha sido registrado") # Mensaje de confirmación def show_available_vehicles(self): # Método para mostrar los automóviles disponibles en la concesionaria print("Vehiculos disponibles:") # Encabezado para la lista de automóviles for vehicle in self.inventory: # Recorre todos los automóviles en la concesionaria if vehicle.check_avaliable(): # Verifica si el automóvil está disponible print(f"{vehicle.brand} {vehicle.model} ({vehicle.year}) - Vel. Max: {vehicle.max_speed} - Precio: ${vehicle.price}") # Muestra la información del automóvil # Ejemplo de uso car1 = Car("Koenigsegg", "Jesko Absolut", 2024, "500 K/H", "$3,500,000.00 Dlls") # Crea el primer automóvil car2 = Car("SSC", "Tuatara", 2024, "474 K/h", "2,800,000.00 Dlls") # Crea el segundo automóvil car3 = Car("Bugatti", "Tourbillio", 2024, "445 K/H", "$4,200,000.00 Dlls") # Crea el tercer automóvil car4 = Car("Hennessey", "Venom F5", 2024, "435 K/H", "$3,200,000.00 Dlls") # Crea el cuarto automóvil car5 = Car("Rimac", "Nevera", 2024, "410 K/H", "$2,700,000.00 Dlls") # Crea el quinto automóvil motorbike1 = MotorBike("Dodge", "Tomahawk", 2024, "675 K/H", "$700,000.00 Dlls") motorbike2 = MotorBike("MTT", "Turbine Superbike Y2K", 2024, "365 K/H", "$550,000.00 Dlls") motorbike3 = MotorBike("Kawasaki", "Ninja H2R", 2024, "355 K/H", "$400,000.00 Dlls") electric1 = Electrics("Tesla", "Roadster", 2024, "402 K/H", "$2,700,000.00 Dlls") electric2 = Electrics("Audi", "e-Tron GT", 2024, "322 K/H", "$3,200,000.00 Dlls") electric3 = Electrics("Lucid", "Sir Dream Edition", 2024, "290 K/H", "$2,000,000.00 Dlls") print(car1.start_engine()) car1.sell() car2.sell() motorbike1.sell() electric1.sell() print(car1.start_engine()) print(car1.stop_engine()) ```

He notado que para esta clase muchos compañeros se han quejado, creo que en mi opinión lo único que he utilizado de esta clase es la herencia, por lo demás no he agregado mucho al ejercicio del concesionario. Siento que algo que de pronto podrían mejorar es que sin duda hay cosas que sobran en el código, y tener un código más limpio y coherente es mejor, por ejemplo para que quiero **una función que me diga si el vehículo esta disponible** cuando ya podemos colocar dentro del método "***if vehiculo.esta\_disponible:**".* Es como crear esa redundancia, quizás en personas que están iniciando no es evidente pero cuando ya haz programado y tienes experiencia en algunos lenguajes simplemente lo notas. O por ejemplo el simple hecho de crear una función dentro de la clase vehículo llamada **vender (sell)** desde mi punto de vista el vehículo no se vende, ese método o función debería estar en la clase de **concesionario (Dealership)** ```python # Usamos el ejemplo del consecionario class Vehiculo: def __init__(self, marca, tipo, color, precio): self.marca = marca self.tipo = tipo self.color = color self.precio = precio self.disponible = True def get_precio(self): return self.precio def disponibilidad(self): if self.disponible: print(f"\n El vehiculo {self.marca} esta disponible") else: print(f"\n El vehiculo {self.marca} NO esta disponible") def encender_motor(self): raise NotImplementedError("Esto se ve en una clase especifica") def apagar_motor(self): raise NotImplementedError("Esto se ve en una clase especifica") class Camion(Vehiculo): def encender_motor(self): if not self.disponible: return f"\n El motor del vehiculo {self.marca} esta encendido" else: return f"\n El motor del vehiculo {self.marca} no esta encendido" def apagar_motor(self): if self.disponible: return f"\n El motor del vehiculo {self.marca} esta detenido" else: return f"\n El motor del vehiculo {self.marca} no esta disponible" class Motocicleta(Vehiculo): def encender_motor(self): if not self.disponible: return f"\n La motocicleta {self.marca} esta en marcha" else: return f"\n La motocicleta {self.marca} no esta disponible" def apagar_motor(self): if self.disponible: return f"\n La motocicleta {self.marca} esta detenida" else: return f"\n La motocicleta {self.marca} no esta disponible" class Bicicleta(Vehiculo): def encender_motor(self): if not self.disponible: return f"\n La bicicleta {self.marca} esta en marcha" else: return f"\n La bicicleta {self.marca} no esta disponible" def apagar_motor(self): if self.disponible: return f"\n La bicicleta {self.marca} esta detenida" else: return f"\n La bicicleta {self.marca} no esta disponible" class Cliente: def __init__(self, nombre, presupuesto): self.nombre = nombre self.coleccion_vechiculos = [] def comprar(self, vehiculo: Vehiculo): if vehiculo.disponible: vehiculo.disponible = False self.coleccion_vechiculos.append(vehiculo) class Consecionario: def __init__(self): self.clientes = [] self.vehiculos = [] def registrar_cliente(self, cliente): self.clientes.append(cliente) print(f"\n + El cliente {cliente.nombre} fue creado exitosamente") def registrar_vehiculo(self, vehiculo): self.vehiculos.append(vehiculo) print(f"\n + El vehiculo {vehiculo.marca} de tipo {vehiculo.tipo} fue creado exitosamente") def vender_vehiculo(self, vehiculo, cliente): if vehiculo in self.vehiculos: if vehiculo.disponible == True: if cliente.presupuesto >= vehiculo.precio: cliente.comprar(vehiculo) self.vehiculos.remove(vehiculo) else: print(f"\n !!UPS¡¡ tu presupuesto de $ {cliente.presupuesto} NO alcanza para comprar el vehiculo {vehiculo.marca} con un precio de $ {vehiculo.precio}") else: print(f"\n El vehiculo {vehiculo.marca} ya no esta disponible") else: print(f"\n -> Este vehiculo {vehiculo.marca} ya no se encuentra disponible") def listar_vehiculos(self): print("\n --> Lista de vehiculos disponibles en el consecionario: ") for vehiculo in self.vehiculos: if vehiculo.disponible == True: print(f"| Marca: {vehiculo.marca} | Tipo: {vehiculo.tipo} | Color: {vehiculo.color} | Precio: $ {vehiculo.precio} | ") ```

Platzi tiene un problema muy grande y es que los cursos van estructurados para principiantes pero de un momento a otro pasan a ser para seniors, en este caso desde que entramos a POO todo se desorganizó, no explican bien los conceptos, ni por qué los hace y termina uno pasando a otras plataformas a buscar el conocimiento que se supone que están enseñando en el curso para principiantes.

En Python, "static" no es una palabra clave como en otros lenguajes como C++ o Java, donde se usa para definir métodos o variables estáticas. Sin embargo, en el contexto de Python, puedes encontrar el concepto de métodos estáticos a través del decorador `@staticmethod`. Este decorador se utiliza dentro de una clase para definir un método que no requiere acceso a la instancia (`self`) ni a la clase (`cls`). Los métodos estáticos son útiles cuando necesitas una función que esté relacionada con la lógica de la clase, pero que no dependa de sus atributos o métodos.

cuando crea los metodos en la clase Customer y pone los parametros es necesario poner los : ? porque indica que el parametro vehicle es de la clase vehicle pero con los ejemplos de las clase anteriores no era necesario poner eso o en este caso toca ponerlo por que hay subclases ?

Recuerden que existen 4 pilares de la programación (los verán en la próxima clase. Sin embargo, existe: "Herencia y Polimorfismo". *Explicación:* La herencia permite que una clase (subclase) herede atributos y métodos de otra clase (superclase). El polimorfismo permite que objetos de diferentes clases sean tratados como objetos de una misma clase base. `class Animal:` ` def hablar(self):` ` pass` `class Perro(Animal):` ` def hablar(self):` ` return "Guau"` `class Gato(Animal):` ` def hablar(self):` ` return "Miau"` `perro = Perro()` `gato = Gato()` `print(perro.hablar()) # Salida: Guau` `print(gato.hablar()) # Salida: Miau`

Hola, quisiera saber porqué hubo un cambio de la nomenclatura al referirme a un objeto. En el ejemplo de la biblioteca al referirme al usuario o al libro se escribe: def add\_book(self, ***book***): Pero en el ejemplo de la concesionaria , se escribe: def add\_vehicles(self, ***vehicle: Vehicle***): def register\_customers(self, ***customer: Customer)***: Gracias de antemano

La herencia en programación orientada a objetos permite crear una nueva clase basada en una clase existente. Esto facilita la reutilización de código y la creación de jerarquías, permitiendo que la clase hija herede propiedades y métodos de la clase padre, simplificando el desarrollo y mantenimiento.

Carli, que es lo que esta pasando, las dos clase anteriores tus códigos no están funcionando y estas creando mas confusion..

Les comparto un pequeño refactor para que quede más claro.```js class Car(Vehicle): def __init__(self, brand, model, price, engine: bool) -> None: super().__init__(brand, model, price) self.engine = engine def start_engine(self): if self.engine: print(f"Iniciando el motor de carro {self.brand} {self.model}. 🚗") def stop_engine(self): if self.engine: print(f"Deteniendo el motor de carro {self.brand} {self.model}. 💥💥") class Bike(Vehicle): def __init__(self, brand, model, price, engine) -> None: super().__init__(brand, model, price) self.engine = engine def start_engine(self): print(f"Es una cicla peee, dale pedal 🚴‍♀️🚴‍♀️") def stop_engine(self): print(f"Sin frenoos!!!!. Te juiteeeeeeee ☠️☠️") ``` 1. En las subclasess Agregue un nuevo atributo que es de tipo Boleano para poder saber si el vehiculo cuenta con motor o no. `engine: bool.` 2. Al agregar dicho atributo nuevo es necesario hacer cambios en la implementación del constructor de la subclase por esta razón queda: super().\_\_ .... codigo abajo. 3. ```js def __init__(self, brand, model, price, engine: bool) -> None: super().__init__(brand, model, price) self.engine = engine ```Ahora por último en los métodos de start y stop\_engine utilizo el atributo engine en vez de is\_available para no confundir si esta disponible para la compra o no. Espero les pueda ayudar un poco.

Hola a todos, es necesario crear en la clase padre, métodos que son propios de las clase hijas? Yo pienso que es innecesario. Atentamente Cristian

A todos los que están confundidos o perdidos desde que empezó POO, les recomiendo buscar y aprender los conocimientos básicos como lo son * Declaración de variables * Obtener información de entrada del usuario * Almacenar información * Repetir una acción haciendo uso de bucles * Escribir funciones para no repetir fragmentos de código con el mismo funcionamiento y hacer proyectos como:Par o impar 1. Juego Mad Libs 2. Contador de palabras 3. Información de la biografía 4. ¿Cuál es el acrónimo? 5. Piedra, Papel y tijera 6. Adivina el número y después si venir a estos temas para entender y no desmotivarse.

En programación orientada a objetos (POO) herencia un concepto clave que permite que una clase (llamada subclase ) herede propiedades y comportamientos (atributos y métodos) de otra clase (llamada superclase o clase base ). Esto permite reutilizar código y extenderlo sin tener que escribirlo desde cero. La herencia permite crear nuevas clases basadas en otras, aprovechando el código ya escrito. Es una manera eficiente de manejar y extender el código, haciendo que sea más organizado y fácil de mantener.

Aqui mi version de anadirles las bicis y camiones antes de ver la clase. No fue dificil porque fue casi un copy paste del ejemplo anterior, pero espero que se parezca: ```js class Car: def __init__(self, brand, model, price): self.brand = brand self.model = model self.price = price self.available = True def sell(self): if self.available: print(f"The {self.brand} {self.model} has been sold!") self.available = False else: print(f'The {self.brand} {self.model} is unavailable. Check for other options') def is_available(self): return self.available def change_availability(self): self.available = not self.available class Customer: def __init__(self, name): self.name = name self.cars = [] def buy_car(self, car): if car.is_available(): car.sell() self.cars.append(car) else: print(f'The {car.brand} {car.model} is unavailable. Check for other options') def return_car(self, car): if car in self.cars: self.cars.remove(car) car.change_availability() print(f'Car returned successfully') else: print(f'You do not have any cars to return') # Instancias de Carros toyota = Car('Toyota', 'Corolla', 20000) ford = Car('Ford', 'Explorer', 30000) tesla = Car('Tesla', 'Model S', 70000) # Instancia de Cliente cliente = Customer('Calvin') # Cliente compra un carro cliente.buy_car(toyota) # Debería marcar el carro como comprado cliente.buy_car(tesla) # Debería comprar el Tesla cliente.return_car(tesla) # Intentar añadir un carro que ya ha sido comprado # Si está disponible, lo añade; si no, muestra un mensaje # Clases heredadas class Sounds(Car): def start_engine(self): if self.is_available(): print(f'{self.brand} {self.model} engine started') else: print('There is no motor engine to start.') def stop_engine(self): if self.is_available(): print(f'{self.brand} {self.model} engine stopped') else: print('There is no motor engine to stop') # Crear una instancia de la clase Sounds ford_sounds = Sounds('Ford', 'Explorer', 30000) ford_sounds.start_engine() ford_sounds.stop_engine() #Como se puede apreciar, podemos crear clases heredas, al crear una clase, y pasarle otra clase como argumento. Esta clase nueva, heredara todos los datos # de la clase padre, osea los atributos y metodos. Y para utilizar los nuevos metodos que estan en esa clase nueva, debemos crear un nuevo objeto con esa clase #nueva, no con la clase padre. De no hacerlo, unicamente tendremos los metodos de la clase padre, y no tendremos acceso a los de la clase hijo. class Bike(Car): def rideBike(self): if self.is_available(): print(f'You are riding a {self.brand} {self.model}, be carefull!') self.is_available = False else: print('You do not have a bike to ride') def unrideBike(self): if not self.is_available(): print(f'You have unriden a {self.brand} {self.model}') self.is_Available == True else: print('You do not have a bike to unride') cdmx = Bike('cdmx', 'mx', 2000) cdmx.unrideBike() class Trucks(Car): def buyTruck(self): if self.is_available(): self.sell() self.is_available == False else: print('You cant buy this truck') def sellTruck(self): if not self.is_available(): self.is_available == True print(f'You returned the {self.brand}, {self.model}') else: print('You cant sell this truck') def loadTruck(self, material, maxCapacity): if self.is_available(): print(f'You have loaded a {self.brand} {self.model} with {material}. His maximum capacity is {maxCapacity}, be aware loading more than that!') else: print('You do not have a truck to load') def unloadTruck(self): if self.is_available(): print(f'You have unloadded the {self.brand} {self.model}') else: print('You do not have a truck to unload') international = Trucks('International', 'elephant', 200000) international.buyTruck() international.loadTruck('dirt', '2000kg') international.unloadTruck() international.sellTruck() ```

una pregunta, por que en este y los pasados ejemplos creamos nuevas variables para obtener informacion de los atributos como price y is. available? id reemplazar.simplificar:def inquire\_vehicle(self, vehicle: Vehicle): ```python def inquire_vehicle(self, vehicle: Vehicle): #method definition if vehicle.check_availability(): #checking availability -> calls the check_availability() method on the vehicle object availability = "Disponible" #assign availability status else: availability = "No disponible" #assign availability status print(f"El {vehicle.brand} está {availability} y cuesta {vehicle.get_price}") ``` por: ```js def inquire_vehicle(self, vehicle: Vehicle): print(f"El vehículo está {'Disponible' if vehicle.check_availability() else 'No disponible'}.") ``` print(f"El vehículo está {'Disponible' if vehicle.check\_availability() else 'No disponible'}.")

```python class Vehicle:#Programación de la clase 26. def __init__(self,brand,model,price): self.brand = brand self.model = model self.price = price self.is_avalaible = True def sell(self): if self.is_avalaible: self.is_avalaible = False print(f"El vehiculo {self.brand} {self.model} ha sido vendido.") else: print(f"El vehiculo {self.brand} {self.model} no esta disponible.") def check_available(self): return self.is_avalaible def get_price(self): return self.price def start_engine(self): raise NotImplementedError("Este método debe ser implementado por la subclase") def stop_engine(self): raise NotImplementedError("Este método debe ser implementado por la subclase") #Nombre de clase (Clase Padre) class Car(Vehicle): def start_engine(self): if not self.is_avalaible: return f"El motor del coche {self.brand} está encendido." #En el comentario no colocamos car.brand a pesar de ser una clase diferente. Esto es porque estamos heredando. else: return f"El coche {self.brand} no esta disponible" def stop_engine(self): if self.is_avalaible: return f"El motor del coche {self.brand} está apagado." else: return f"El coche {self.brand} no esta disponible" class Bike(Vehicle): def start_engine(self): if not self.is_avalaible: return f"La bicicleta {self.brand} está en marcha." #En el comentario no colocamos car.brand a pesar de ser una clase diferente. Esto es porque estamos heredando. else: return f"La bicicleta{self.brand} no esta disponible" def stop_engine(self): if self.is_avalaible: return f"La bicicleta {self.brand} está detenida." else: return f"La bicicleta {self.brand} no esta disponible" class Truck(Vehicle): def start_engine(self): if not self.is_avalaible: return f"El motor del camión {self.brand} está encendido." #En el comentario no colocamos car.brand a pesar de ser una clase diferente. Esto es porque estamos heredando. else: return f"El camión {self.brand} no esta disponible" def stop_engine(self): if self.is_avalaible: return f"El motor del camión {self.brand} está apagado." else: return f"El camión {self.brand} no esta disponible" class Customer: def __init__(self,name): self.name = name self.purchased_vehicles = [] #Colección de autos def buy(self,vehicle: Vehicle): #El parametro vehicle es de la clase Vehicle if vehicle.check_available(): vehicle.sell() self.purchased_vehicles.append(vehicle) else: print(f"Lo siento, el vehiculo {vehicle.brand} no esta disponible.") def inquire_vehicle(self,vehicle: Vehicle): #Consultar la disponibilidad de los vehículos. if vehicle.check_available(): avaibility = "Disponible" else: avaibility = "No disponible" print(f"El {vehicle.brand} está {avaibility} y cuesta {vehicle.get_price()}") class DealerShip: def __init__(self): self.inventory = [] self.customers = [] def add_vehicle(self,vehicle:Vehicle): self.inventory.append(vehicle) print(f"El vehiculo {vehicle.brand} {vehicle.model} ha sido añadido al inventario.") def register_customer(self,customer:Customer): self.customers.append(customer) print(f"El cliente {customer.name} ha sido registrado.") def show_available_vehicle(self): print("Vehiculos disponibles:") for vehicle in self.inventory: if vehicle.check_available(): print(f" - {vehicle.brand} por {vehicle.price}") ```

Tengo una pregunta: Era necesario crear los métodos "check\_available()" y "get\_price()" en la clase "Vehicle"? eran ya atributos de todos los objetos de "Vehicle" y se podían acceder a ellos fácilmente

En clases anteriores se revisaba la disponivilidad a través del atributo del objeto, en esta clase lo obtenemos a partir de un metodo. Me gustaria saber ¿cual es la diferencia? y en que casos es preferible usar una u otra

```js from random import * class Vehiculo: def __init__(self, marca, color): self.marca = marca self.color = color def __str__(self,): return f"Marca {self.marca}, Color {self.color} " class Carro(Vehiculo): def __init__(self, marca, color, n_puertas, velocidad_max, cilindrada): super().__init__(marca, color) self.n_puertas = n_puertas self.velocidad_max = velocidad_max self.cilindrada = cilindrada def __str__(self): return super().__str__() + f"{self.n_puertas} Puertas, {self.velocidad_max}Km/h, {self.cilindrada}Cc" class Camioneta(Carro): def __init__(self, marca, color, n_puertas, velocidad_max, cilindrada, carga): super().__init__(marca, color, n_puertas, velocidad_max, cilindrada) self.carga = carga def __str__(self): return super().__str__() + f", {self.carga}Kg" class Bicileta(Vehiculo): def __init__(self, marca, color, tipo): super().__init__(marca, color) self.tipo = tipo def __str__(self): return super().__str__() + f"{self.tipo}" class Motocileta(Bicileta): def __init__(self, marca, color, tipo, velocidad, cilindrada): super().__init__(marca, color, tipo) self.velocidad = velocidad self.cilindrada = cilindrada def __str__(self): return super().__str__() + f"{self.velocidad}Km/h , {self.cilindrada}Cc" class Clientes: def __init__(self, nombre, apellido, cedula): self.nombre = nombre self.apellido = apellido self.cedula = cedula self.base_datos_clientes = [] def cupo_cliente(self): print("Si el cliente cumple con el cupo minimo permitido por la empresa sera registrado en la base de datos") self.cupo = randint(0, 20000000) if self.cupo < 500000 : print(f"El cliente {self.nombre} {self.apellido} cuenta con un cupo de ${self.cupo}, por lo cual no es habilitado para la compra") elif self.cupo >= 500000: print(f"El cliente {self.nombre} {self.apellido} cuenta con un cupo de ${self.cupo}, se encuentra habilitado para realiza la compra") self.base_datos_clientes.append(self.cedula) print(f"El cliente {self.nombre} con la cedula {self.cedula} ha sido registrado en la base de datos") def ver_clientes(self): for cliente in self.base_datos_clientes: print(f"{cliente}") class Concesionario: def __init__(self, nombre): self.nombre = nombre self.base_datos_vehiculos = [] self.base_datos_compras = [] def registrar_vehiculo(self, vehiculo): self.base_datos_vehiculos.append(vehiculo) print(f"El Vehiculo {vehiculo.marca}/{vehiculo.color} ha sido registrado en la base de datos de la empresa") def ver_vehiculos(self): for vehiculo in self.base_datos_vehiculos: print(f"{type(vehiculo).__name__} ---> {vehiculo}") def venta_vehiculo(self, vehiculo, cliente): if vehiculo in self.base_datos_vehiculos: self.base_datos_vehiculos.remove(vehiculo) self.base_datos_compras.append(cliente.cedula) print(f"El vehiculo {type(vehiculo).__name__} ---> {vehiculo} ha sido comprado por {cliente.cedula}") else: print(f"El vehiculo {type(vehiculo).__name__} ---> {vehiculo} no se encuentra disponible en la tienda") # Creacion de Carros carro_1 = Carro("Toyota", "Negro", 4, 130, 1250) carro_2 = Carro("Mazda", "Verde", 2, 120, 1200) carro_3 = Carro("Renault", "Amarillo", 4, 140, 1500) # Creacion de Camionetas camioneta_1 = Camioneta("Chrevrolet Tracker", "Violeta", 2, 120, 1700, 200) camioneta_2 = Camioneta("Ford EcoSport", "Vinitinto", 4, 130, 1800, 250) camioneta_3 = Camioneta("Toyota Prado", "Violeta", 2, 120, 1600, 150) # Creacion de Bicicletas bicicleta_1 = Bicileta("Orbea Orca", "MultiColor", "Urbana") bicicleta_2 = Bicileta("Giant TCR", "Rojo", "Deportiva") bicicleta_3 = Bicileta("GW", "Azul", "Urbana") # Creacion de Motocicletas moto_1 = Motocileta("Suzuki", "Negro", "Urbana", 130, 125) moto_2 = Motocileta("Honda", "Blanco", "Deportiva", 250, 200) moto_3 = Motocileta("AKT", "Rojo", "Urbana", 110, 100) # Creacion Clientes cliente_1 = Clientes("Edgar Andres", "Anaya Vejar", 1093787563) cliente_2 = Clientes("Hindi Yurely", "Lopez Bayona", 1093563878) cliente_3 = Clientes("Cristian Fabian", "Arias Lopez", 1093563123) cliente_4 = Clientes("Angie Paola", "Lopez Quintero", 1093123789) # Validacion del cupo del cliente print("=" * 100) cliente_1.cupo_cliente() print("=" * 100) cliente_2.cupo_cliente() print("=" * 100) cliente_3.cupo_cliente() print("=" * 100) cliente_4.cupo_cliente() print("=" * 100) # Creacion de Concesionario y registro de vehiculos concesionario = Concesionario("Compra Venta La Chueca") print("=" * 100) concesionario.registrar_vehiculo(carro_1) print("=" * 100) concesionario.registrar_vehiculo(carro_2) print("=" * 100) concesionario.registrar_vehiculo(carro_3) print("=" * 100) concesionario.registrar_vehiculo(camioneta_1) print("=" * 100) concesionario.registrar_vehiculo(camioneta_2) print("=" * 100) concesionario.registrar_vehiculo(camioneta_3) print("=" * 100) concesionario.registrar_vehiculo(bicicleta_1) print("=" * 100) concesionario.registrar_vehiculo(bicicleta_2) print("=" * 100) concesionario.registrar_vehiculo(bicicleta_3) print("=" * 100) concesionario.registrar_vehiculo(moto_1) print("=" * 100) concesionario.registrar_vehiculo(moto_2) print("=" * 100) concesionario.registrar_vehiculo(moto_3) print("=" * 100) # Ver Vehiculos para la venta del Concesionario concesionario.ver_vehiculos() print("=" * 100) # Venta de Vehiculos concesionario.venta_vehiculo(carro_1, cliente_1) concesionario.venta_vehiculo(carro_2, cliente_1) concesionario.venta_vehiculo(carro_3, cliente_1) print("=" * 100) concesionario.venta_vehiculo(camioneta_1, cliente_2) concesionario.venta_vehiculo(camioneta_2, cliente_2) concesionario.venta_vehiculo(camioneta_1, cliente_1) print("=" * 100) concesionario.venta_vehiculo(bicicleta_1, cliente_2) concesionario.venta_vehiculo(bicicleta_2, cliente_2) concesionario.venta_vehiculo(bicicleta_3, cliente_2) print("=" * 100) concesionario.venta_vehiculo(moto_1, cliente_3) concesionario.venta_vehiculo(moto_2, cliente_3) concesionario.venta_vehiculo(moto_3, cliente_3) print("=" * 100) concesionario.venta_vehiculo(carro_1, cliente_4) concesionario.venta_vehiculo(camioneta_2, cliente_4) concesionario.venta_vehiculo(bicicleta_3, cliente_4) concesionario.venta_vehiculo(moto_1, cliente_4) ```Mi humilde aporte. Saludos..!!!