Ejercicio Biblioteca con POO

```python #Ejercicio concesionario class Vehiculo: def __init__(self, modelo, precio): self.modelo = modelo self.precio = precio self.disponible = True def vender(self): if self.disponible: self.disponible = False print(f"El vehículo {self.modelo} ha sido vendido.") else: print(f"El vehículo {self.modelo} no está disponible.") def hacer_disponible(self): self.disponible = True print(f"El vehículo {self.modelo} está disponible para la venta nuevamente.") class Cliente: def __init__(self, nombre, id_cliente): self.nombre = nombre self.id_cliente = id_cliente self.vehiculos_comprados = [] def comprar_vehiculo(self, vehiculo): if vehiculo.disponible: vehiculo.vender() self.vehiculos_comprados.append(vehiculo) else: print(f"El vehículo {vehiculo.modelo} no está disponible.") def devolver_vehiculo(self, vehiculo, concesionario): if vehiculo in self.vehiculos_comprados: vehiculo.hacer_disponible() self.vehiculos_comprados.remove(vehiculo) concesionario.agregar_vehiculo(vehiculo) else: print(f"El vehículo {vehiculo.modelo} no está en la lista de comprados.") class Concesionario: def __init__(self): self.vehiculos = [] self.clientes = [] def agregar_vehiculo(self, vehiculo): self.vehiculos.append(vehiculo) print(f"El vehículo {vehiculo.modelo} ha sido agregado al inventario.") def registrar_cliente(self, cliente): self.clientes.append(cliente) print(f"El cliente {cliente.nombre} ha sido registrado.") def mostrar_vehiculos_disponibles(self): print("Vehículos disponibles:") for vehiculo in self.vehiculos: if vehiculo.disponible: print(f"{vehiculo.modelo} por ${vehiculo.precio}") # Crear los vehículos vehiculo1 = Vehiculo("Dlorean", 1500) vehiculo2 = Vehiculo("Mazda", 600) # Crear cliente cliente1 = Cliente("Alex", "001") # Crear concesionario concesionario = Concesionario() concesionario.agregar_vehiculo(vehiculo1) concesionario.agregar_vehiculo(vehiculo2) concesionario.registrar_cliente(cliente1) # Mostrar vehículos disponibles concesionario.mostrar_vehiculos_disponibles() # Realizar compra cliente1.comprar_vehiculo(vehiculo1) # Mostrar vehículos disponibles concesionario.mostrar_vehiculos_disponibles() # Devolver vehículo cliente1.devolver_vehiculo(vehiculo1, concesionario) # Mostrar vehículos disponibles concesionario.mostrar_vehiculos_disponibles() ```

Con todo respeto, les sugiero no colocar muchos atributos a las clases mientras están aprendiendo este tema. Si, entiendo que algunos de ustedes quieran hacer este ejercicio de la forma más realista posible, pero la verdad es que se van a complicar en cosas innecesarias. Ahora mismo necesitan desarrollar su lógica, no hacer una aplicación real con sus pocos conocimientos.

Camaradas qué significa el simbolito que aparece automáticamente en vscode cuando inicia uno el código de una clase: --> None, Porfis

```js class Car: def __init__(self, model, price): self.model = model self.price = price self.available = True def sell(self): if self.available: self.available = False print(f"El carro {self.model} ha sido vendido") else: print(f"El carro {self.model} ya no está disponible") def __repr__(self): return f"{self.model} (${self.price})" class Person: def __init__(self, name, id): self.name = name self.id = id self.bought_cars = [] def buy_car(self, car): if car.available: car.sell() # Marca el carro como vendido self.bought_cars.append(car) print(f"{self.name} ha comprado el vehículo {car.model} por {car.price}") else: print(f"El carro {car.model} ya no está disponible") def sell_car(self, car, dealer): if car in self.bought_cars: self.bought_cars.remove(car) dealer.add_car(car) # Añade el carro al inventario del concesionario print(f"Tu carro {car.model} lo pondremos a la venta y te avisaremos cuando completemos el proceso") else: print(f"No tienes el carro {car.model} en tu colección") class Dealer: def __init__(self): self.cars = [] def add_car(self, car): if car not in self.cars: self.cars.append(car) print(f"El carro {car.model} ha sido incluido en nuestra línea de carros para la venta") else: print(f"El carro {car.model} ya está en la línea de carros para la venta") def sell_car(self, car): if car in self.cars: if car.available: car.sell() self.cars.remove(car) print(f"El carro {car.model} ha sido vendido") else: print(f"El carro {car.model} ya no está disponible") else: print(f"El carro {car.model} no está en la línea de carros para la venta") def available_cars(self): print("Vehículos disponibles:") for car in self.cars: if car.available: print(f"{car}") # Crear carros car1 = Car("spark gt", "20.000.000") car2 = Car("aveo", "18.000.000") car3 = Car("toyota hilux", "80.000.000") car4 = Car("hyundai", "17.000.000") # Crear personas person1 = Person("Laura", "0001") person2 = Person("Andres", "0002") person3 = Person("Sore", "0003") # Crear dealer dealer = Dealer() dealer.add_car(car1) dealer.add_car(car2) dealer.add_car(car3) dealer.add_car(car4) # Mostrar carros disponibles dealer.available_cars() # Comprar un carro person1.buy_car(car1) # Mostrar carros disponibles después de la compra dealer.available_cars() # Vender un carro de una persona al dealer person1.sell_car(car1, dealer) # Mostrar carros disponibles después de añadir un carro al dealer dealer.available_cars() ```class Car: def \_\_init\_\_(self, model, price): self.model = model self.price = price self.available = True def sell(self): if self.available: self.available = False print(f"El carro {self.model} ha sido vendido") else: print(f"El carro {self.model} ya no está disponible") def \_\_repr\_\_(self): return f"{self.model} (${self.price})" class Person: def \_\_init\_\_(self, name, id): self.name = name self.id = id self.bought\_cars = \[] def buy\_car(self, car): if car.available: car.sell() # Marca el carro como vendido self.bought\_cars.append(car) print(f"{self.name} ha comprado el vehículo {car.model} por {car.price}") else: print(f"El carro {car.model} ya no está disponible") def sell\_car(self, car, dealer): if car in self.bought\_cars: self.bought\_cars.remove(car) dealer.add\_car(car) # Añade el carro al inventario del concesionario print(f"Tu carro {car.model} lo pondremos a la venta y te avisaremos cuando completemos el proceso") else: print(f"No tienes el carro {car.model} en tu colección") class Dealer: def \_\_init\_\_(self): self.cars = \[] def add\_car(self, car): if car not in self.cars: self.cars.append(car) print(f"El carro {car.model} ha sido incluido en nuestra línea de carros para la venta") else: print(f"El carro {car.model} ya está en la línea de carros para la venta") def sell\_car(self, car): if car in self.cars: if car.available: car.sell() self.cars.remove(car) print(f"El carro {car.model} ha sido vendido") else: print(f"El carro {car.model} ya no está disponible") else: print(f"El carro {car.model} no está en la línea de carros para la venta") def available\_cars(self): print("Vehículos disponibles:") for car in self.cars: if car.available: print(f"{car}") \# Crear carroscar1 = Car("spark gt", "20.000.000")car2 = Car("aveo", "18.000.000")car3 = Car("toyota hilux", "80.000.000")car4 = Car("hyundai", "17.000.000") \# Crear personasperson1 = Person("Laura", "0001")person2 = Person("Andres", "0002")person3 = Person("Sore", "0003") \# Crear dealerdealer = Dealer()dealer.add\_car(car1)dealer.add\_car(car2)dealer.add\_car(car3)dealer.add\_car(car4) \# Mostrar carros disponiblesdealer.available\_cars() \# Comprar un carroperson1.buy\_car(car1) \# Mostrar carros disponibles después de la compradealer.available\_cars() \# Vender un carro de una persona al dealerperson1.sell\_car(car1, dealer) \# Mostrar carros disponibles después de añadir un carro al dealerdealer.available\_cars()

Hola dejo aqui el codigo de mi programa de la consecionaria de coches dura un rato haciendo y lo que se me dificulto fue llamar a las funciones de otras clases dentro de clases realmente me confundi y se que el codigo no esta depurado pero ya hace lo que debe y me siento bien por eso aqui mi aporte (Trate de comentar el codigo lo mejor que puedo y de echo eso me ayudo a hacer ciertas elecciones): ```python # Vamos a crear un programa para hacer una concesionaria de Vehículos # Se puede hacer una compra y venta # se puede preguntar cuáles están disponibles, su precio y poder adquirir una venta # Creamos una clase para los coches class Car: def __init__(self, model, price): # Creamos el constructor de la clase self.model = model # Definimos variable de modelo self.price = price # Definimos variable de precio self.available = True # Definimos si el coche está disponible def sold(self, dealership): # Creamos una función para realizar una venta if self.available: # Para poder vender primero tenemos que ver si está disponible self.available = False # Una vez vendido cambiamos su disponibilidad ya que se vendió dealership.forsell.remove(self) # Quitamos el coche de la lista de coches a la venta print(f"El {self.model} ha sido vendido a un precio de {self.price}") # Le damos un mensaje con el modelo del auto vendido else: # Si ya no está disponible print(f"El {self.model} no está disponible") # Mostramos mensaje diciendo que ya no está disponible def make_available(self, dealership): # Creamos otra función para hacerlo disponible otra vez en caso que quiera regresar el coche self.available = True # Volvemos a ponerlo disponible dealership.forsell.append(self) # Añadimos el coche a la lista de coches a la venta de la concesionaria print(f"El {self.model} a la venta nuevamente a un precio de {self.price}") # Damos un mensaje de que vuelve a estar disponible class Customer: # Creamos otra clase de tipo comprador def __init__(self, name, id): # Creamos su constructor self.name = name # Variable de nombre del cliente self.id = id # Creamos un ID único de cada cliente para identificarlo self.cars_buy = [] # Creamos una lista para saber cuál carro compró o cuántos carros ha comprado ese cliente def buy(self, car, dealership): # Creamos una función para la acción de comprar if car.available: # Solo podemos comprar un coche que está disponible car.sold(dealership) # Hacemos la función de venderlo creada dentro del objeto Car self.cars_buy.append(car) # Añadimos a la lista el carro comprado print(f"El cliente {self.name} ha comprado el {car.model} a un precio de {car.price}") else: # Si no está disponible print(f"El {car.model} no está disponible") # Mandamos mensaje de que no está disponible def sell(self, car, dealership): # Creamos una función en la cual el cliente pueda vender un coche a la concesionaria if car in self.cars_buy: # Primero checamos si realmente el cliente cuenta con ese coche self.cars_buy.remove(car) # Eliminamos el coche de la lista de coches del cliente print (f"El cleinte {self.name} a puesto ") car.make_available(dealership) # Marcamos el coche como disponible nuevamente else: # Si no es propietario del coche no lo puede vender print(f"El cliente no puede vender el {car.model}, ya no cuenta con él") class Dealership: # Creamos una clase concesionaria def __init__(self): # Creamos el constructor self.forsell = [] # Creamos una lista para poner los carros con los que cuenta la concesionaria a la venta def add_car(self, car): # Añadimos un coche a la concesionaria self.forsell.append(car) print(f"El coche {car.model} ha sido añadido a la concesionaria.") def show_available_cars(self): # Mostramos los coches disponibles en la concesionaria print("Coches disponibles:") for car in self.forsell: if car.available: print(f"{car.model} por {car.price}") # Creamos los coches car1 = Car("Tesla Cybertruck", "333,777$") car2 = Car("Chevrolet Camaro", "1,250,000$") car3 = Car("Lamborghini", "757,062.06$") # Creamos los clientes user1 = Customer("Gabriel", "01") user2 = Customer("Mayte", "02") user3 = Customer("David", "03") # Creamos la concesionaria dealership = Dealership() #Añadimos los coches a la concesionaria dealership.add_car(car1) dealership.add_car(car2) dealership.add_car(car3) # Mostramos los coches disponibles en la concesionaria dealership.show_available_cars() # Probando funciones de las clases car3.sold(dealership) car3.sold(dealership) dealership.show_available_cars() car3.make_available(dealership) dealership.show_available_cars() # Realizar compra user1.buy(car1, dealership) # Mostramos los coches disponibles en la concesionaria dealership.show_available_cars() # Devolver coche a la concesionaria user1.sell(car1, dealership) # Mostramos los coches disponibles en la concesionaria dealership.show_available_cars() ```

Hola!! Se me dificulta un poco el tema de la lógica de las clases y me enredo mucho en el objetivo de crear y utilizar las funciones, pero lo intenté y basándome muuuucho en el ejemplo de la profesora hice este: ```js # Clase para definir las caractéristicas de los autos: class Car: def __init__(self, branch, model, year, color, price): self.branch = branch self.model = model self.year = year self.color = color self.price = price self.stock = 3 def sell(self): if self.stock > 0: self.stock -= 1 print(f'El auto {self.branch}, {self.model}, {self.year}, {self.color}, {self.price} se encuentra disponible.') else: print(f'El auto {self.branch}, {self.model}, {self.year}, {self.color}, {self.price} se encuentra agotado en este momento.') def buy(self): self.stock += 1 print(f'El auto {self.branch}, {self.model}, {self.year}, {self.color}, {self.price} ahora esta disponible.') # Clase para realizar consultas de los autos disponibles y sus precios: class Car_agency: def __init__(self): self.cars = [] def add_car(self, car): self.cars.append(car) print(f'El auto {car.branch}, {car.model}, {car.year}, {car.color}, {car.price} se ha agregado.') def show_availables_cars(self): print('Autos Disponibles:') for car in self.cars: if car.stock > 0: print(f'Marca: {car.branch}, Modelo: {car.model}, Año: {car.year}, Color: {car.color}, Precio: {car.price}') def check_price(self, car): for car in self.cars: if self.cars[0] == car: print(f'El auto {car.branch} tiene un precio de ${car.price}') # Crear objetos. # Autos: tesla = Car('Tesla', '3', 2019, 'Red', 700000) toyota = Car('Toyota', 'Prius', 2024, 'Black', 499000) byd = Car('BYD', 'Fenix', 2023, 'Silver', 500000) # Agencia: agency = Car_agency() # Comprar un auto: agency.add_car(tesla) agency.add_car(toyota) agency.add_car(byd) # Mostrar autos disponibles: agency.show_availables_cars() # Consultar precio: agency.check_price('Tesla') ```Gracias!

Los if y else de las lineas 27 y 31 son innecesarios, verdad? pues ese condicional ya se estableció en la función burrow de la clase de los libros

Hola profe!, creo haber entendido la idea =P Aqui mi aporte : *class* <u>Vehiculo</u>:    *def* \_\_init\_\_(*self*, *marca*, *description*, *modelo*, *cantidad*, *precio*):        *self*.marca = *marca*        *self*.description = *description*        *self*.modelo = *modelo*        *self*.cantidad = *cantidad*        *self*.precio = *precio*        *self*.disponible = True          #Objetos creadosvehiculo1 = <u>Vehiculo</u>("Renault: Duster", "Caminotera", *f*"Modelo: {2020}", 5, 40000000) vehiculo2 = <u>Vehiculo</u>("Volkswagen: Amarok", "Camioneta", *f*"Modelo: {2024}", 2, 90000000 )vehiculo3 = <u>Vehiculo</u>("Chevrolet: Aveo family", "carro", *f*"Modelo: {2012}", 3, 25000000 )           #Clase usuario    *class* <u>User</u>:    *def* \_\_init\_\_(*self*, *name*, *last\_name*, *user\_id*=<u>int</u>()):        *self*.name=*name*        *self*.last\_name = *last\_name*        *self*.user\_id = *user\_id*         # Funcion para consulta de precio    *def* consultar\_precio(*self*,*vehiculo*):        if *vehiculo*.disponible == True:            print(*f*"el precio del vehiculo {*vehiculo*.marca} es: ${*vehiculo*.precio}")                       #Funcion para compra de vehiculo         *def* comprar\_vehiculo(*self*, *vehiculo*):        if *vehiculo*.cantidad < 1:            *vehiculo*.disponible = False        if *vehiculo*.disponible == True:            *vehiculo*.cantidad -= 1            print(*f*"El vehiculo {*vehiculo*.marca} fue comprado quedan disponible {*vehiculo*.cantidad}")        else:            print("Vehiculo no se encuentra en stock")                                                    #Creacion de objetos usuariosuser1 = <u>User</u>("Jack", "Fajardo", 1)user2 = <u>User</u>("Angelica", "Lafaurie", 2) \#Clase consecionario*class* <u>Consecionario</u>:    *def* \_\_init\_\_(*self*):        *self*.vehiculos = \[]        *self*.users = \[]          #Funcion para agregar vehiculos creados a consecionario  en lista vehiculos    *def* add\_cars (*self*, *vehiculo*):        if *vehiculo* in *self*.vehiculos:            print("Vehiculo ya se encuentra agregado")        else:            *self*.vehiculos.append(*vehiculo*)            print(*f*"vehiculo {*vehiculo*.marca} ha sido agregado")        #funcion para agregar usuarios creados a consecionarios en lista users    *def* add\_user (*self*,*user*):        if *user* in *self*.users:            print("Vehiculo ya se encuentra agregado")        else:            *self*.users.append(*user*)            print(*f*"El usuario {*user*.name}")          #funcion para validar la disponibilidad de vehiculos    *def* disponibilidad\_vehiculo(*self*):        print("vehiculos disponibles")        for vehiculo in *self*.vehiculos:            if vehiculo.disponible == True:                print(*f*"{vehiculo.marca}, {vehiculo.description},{vehiculo.modelo}")                     #Se establece consecionario            consecionario = <u>Consecionario</u>()#En la clase consecionario se llama la funcion add\_cars y se pasa como parametro un objeto vehiculo llamado vehiculo1consecionario.add\_cars(vehiculo1)#En la clase consecionario se llama la funcion add\_cars y se pasa como parametro un objeto vehiculo llamado vehiculo2consecionario.add\_cars(vehiculo2)#En la clase consecionario se llama la funcion add\_cars y se pasa como parametro un objeto vehiculo llamado vehiculo3consecionario.add\_cars(vehiculo3)#En la clase consecionario se llama la funcion add\_users y se pasa como parametro un objeto user llamado user1consecionario.add\_user(user1)#En la clase consecionario se llama la funcion add\_users y se pasa como parametro un objeto user llamado user2consecionario.add\_user(user2)#En la clase consecionario se llama la funcion disponibilidad\_vehiculo para verificar de la disponibilidad de los vehiculosconsecionario.disponibilidad\_vehiculo()#En el objeto user1 se llama funcion consultar precio se pasa como parametro un objeto vehiculo para verificar el precio que esta como atributo en dicho objetouser1.consultar\_precio(vehiculo3)#En el objeto user1 se llama funcion consultar precio se pasa como parametro un objeto vehiculo para verificar el precio que esta como atributo en dicho objetouser2.comprar\_vehiculo(vehiculo2)#En el objeto user1 se llama funcion consultar precio se pasa como parametro un objeto vehiculo para verificar el precio que esta como atributo en dicho objetouser1.comprar\_vehiculo(vehiculo2)#En el objeto user1 se llama funcion consultar precio se pasa como parametro un objeto vehiculo para verificar el precio que esta como atributo en dicho objetouser1.comprar\_vehiculo(vehiculo2)#En la clase consecionario se llama la funcion disponibilidad\_vehiculo para verificar de la disponibilidad de los vehiculosconsecionario.disponibilidad\_vehiculo() \#En la linea 99, 101, y 103 se realiza prueba de la funcion comprar\_vehiculo agotando la cantidad del bjeto como parametro para verificar el condicional que me indica cuando esa cantidad de vehicula se agota       

Compañeros la siguiente es para compartir con ustedes mi realización con la venta de motos. ```js class Moto: def __init__(self, marca, modelo): self.marca = marca self.modelo = modelo self.verificacion = True def store(self): if self.verificacion: self.verificacion = False print(f"La moto {self.marca} del año {self.modelo} ha sido vendida") else: print(f"La moto {self.marca} no se ha vendido") self.verificacion = True class Client: def __init__(self, nombre, id): self.nombre = nombre self.id = id self.moto_list = [] def add_moto_to_list(self, moto): if moto.verificacion: moto.store() self.moto_list.append(moto) else: print(f"La moto {moto.marca} no está disponible") def return_moto(self, moto): if moto in self.moto_list: moto.store() self.moto_list.remove(moto) else: print(f"La moto {moto.marca} no está en la lista") class Concesionario: def __init__(self): self.motos = [] self.clients = [] def add_moto(self, moto): self.motos.append(moto) print(f"La moto {moto.marca} ha sido añadida al inventario") def register_client(self, client): self.clients.append(client) print(f"El usuario {client.nombre} ha sido registrado") def abrir_list_motos(self): print("La lista de motos disponibles:") for moto in self.motos: if moto.verificacion: print(f"La moto {moto.marca} es de modelo {moto.modelo}") # Crear Motos moto1 = Moto("Pulsar", "2008") moto2 = Moto("KTM", "2023") # Crear usuario user1 = Client("Miguel", "002") # Crear concesionario concesionario = Concesionario() concesionario.add_moto(moto1) concesionario.add_moto(moto2) concesionario.register_client(user1) # Mostrar motos concesionario.abrir_list_motos() # Realizar venta user1.add_moto_to_list(moto1) # Mostrar motos concesionario.abrir_list_motos() # Devolver moto user1.return_moto(moto1) # Mostrar motos concesionario.abrir_list_motos() ```

aca las cosas que aprendi resolviendo este reto : 1Claro, vamos a profundizar en esto. La representación por defecto que estás viendo de tus objetos, como <\_\_main\_\_.plain object at 0x7f692a2ffc40>, se debe a la forma en que Python muestra instancias d 2 el metodo enumerate y las bases para usarlo. 3 el metodo isinstance y las bases para usarlo.

Hola, dejo mi córdigo. Si alguien tiene un comentario o sugerencia, le agradezco. Saludos!! ```python # rental class Rental: def __init__(self) -> None: self.cars = [] # list of available cars in the rental def addCar(self, car): self.cars.append(car) def hireCar(self,car,user): if car.status: if user.age >= 18: self.cars.remove(car) car.status = False else: print("Clients must be at least 18 to hire a car :(") else: print("This car can't be rented because is unavailable!") def returnCar(self,car): car.status = True print("Thanks for using our rental! Hope you had a comfortable ride") def availableCars(self): print("List of available cars: ") for car in self.cars: if car.status: print(f" - {car.brand} {car.model} / {car.plate} / ${car.price}") class Car: def __init__(self, brand, model, plate, price) -> None: self.brand = brand self.model = model self.plate = plate self.price = price self.status = True class User: def __init__(self, name, age) -> None: self.name = name self.age = age def get_car(self, rental): rental.hireCar() ```*# rental class* Rental: *def* \_\_init\_\_(*self*) -> None: *self*.cars = \[] *# list of available cars in the rental* *def* addCar(*self*, *car*): *self*.cars.append(*car*) *def* hireCar(*self*,*car*,*user*): if *car*.status: if *user*.age >= 18: *self*.cars.remove(*car*) *car*.status = False else: print("Clients must be at least 18 to hire a car :(") else: print("This car can't be rented because is unavailable!") *def* returnCar(*self*,*car*): *car*.status = True print("Thanks for using our rental! Hope you had a comfortable ride") *def* availableCars(*self*): print("List of available cars: ") for car in *self*.cars: if car.status: print(*f*" - {car.brand} {car.model} / {car.plate} / ${car.price}") *class* Car: *def* \_\_init\_\_(*self*, *brand*, *model*, *plate*, *price*) -> None: *self*.brand = *brand* *self*.model = *model* *self*.plate = *plate* *self*.price = *price* *self*.status = True *class* User: *def* \_\_init\_\_(*self*, *name*, *age*) -> None: *self*.name = *name* *self*.age = *age* *def* get\_car(*self*, *rental*): *rental*.hireCar()

```python class Vehicle: def __init__(self, car, brand, price, year): # Inicializa los atributos del vehículo self.car = car self.brand = brand self.price = price self.year = year self.available = True self.owner = None def buy_car(self, client_name): # Verifica si el coche está disponible para la compra if self.available: self.available = False self.owner = client_name print(f"El coche {self.car} ha sido comprado por el cliente {self.owner}") else: print(f"El coche {self.car} ya fue comprado") def sell_car(self): # Marca el coche como disponible después de la venta self.available = True print(f"El coche {self.car} ha sido vendido por {self.owner}") self.owner = None class Client: def __init__(self, name, id_client): # Inicializa los atributos del cliente self.name = name self.id_client = id_client self.buyed_car = [] def my_car(self, car): # Intenta comprar el coche si está disponible if car.available: car.buy_car(self.name) self.buyed_car.append(car) else: print(f"El coche {car.car} no está disponible") def sell_client_car(self, car, dealer): # Vende el coche si el cliente lo ha comprado previamente if car in self.buyed_car: car.sell_car() self.buyed_car.remove(car) dealer.receive_car(car) else: print(f"No has comprado el coche {car.car}") class Dealer: def __init__(self): # Inicializa las listas de coches y clientes self.cars = [] self.clients = [] def add_cars(self, car): # Agrega un coche al stock self.cars.append(car) print(f"El coche {car.car} de la marca {car.brand} ha sido agregado al stock") def register_client(self, client): # Registra un nuevo cliente self.clients.append(client) print(f"El cliente {client.name} ha sido agregado") def show_available_cars(self): # Muestra todos los coches disponibles print("Coches Disponibles:") for car in self.cars: if car.available: print(f"- {car.car} de la marca {car.brand}, año {car.year}") def show_client_purchases(self): # Muestra los coches comprados por cada cliente for client in self.clients: print(f"{client.name} ha comprado los siguientes coches:") if client.buyed_car: for car in client.buyed_car: print(f"- {car.car} de la marca {car.brand}, año {car.year}") else: print("No ha comprado ningún coche.") def receive_car(self, car): # Recibe el coche vendido por un cliente car.available = True self.cars.append(car) print(f"El coche {car.car} ha sido recibido de vuelta en el concesionario") # Crear instancias de Vehicle car1 = Vehicle("Corolla", "Toyota", "25.000€", "2021") car2 = Vehicle("Spark", "Chevrolet", "15.000€", "2020") # Crear instancia de Client client1 = Client("Andrés", "0001") # Crear instancia de Dealer y agregar coches y clientes stock = Dealer() stock.add_cars(car1) stock.add_cars(car2) stock.register_client(client1) # Mostrar coches disponibles y realizar compra stock.show_available_cars() client1.my_car(car1) # Mostrar coches disponibles y compras de los clientes stock.show_available_cars() stock.show_client_purchases() ```

aquí mi aporte del concesionario:#crear clase de vehiculo con marca, modelo y precio en pythonclass Vehiculo:    def \_\_init\_\_(self, marca, modelo, precio):        self.marca = marca        self.modelo = modelo        self.precio = precio     def mostrar\_informacion(self):        print(f"Marca: {self.marca}")        print(f"Modelo: {self.modelo}")        print(f"Precio: ${self.precio}") class Usuario:    def \_\_init\_\_(self, nombre, dni, saldo):        self.nombre = nombre        self.dni = dni        self.saldo = saldo        self.vehiculos\_comprados = \[]     def comprar\_vehiculo(self, vehiculo):        if vehiculo.precio <= self.saldo:            self.saldo -= vehiculo.precio            self.vehiculos\_comprados.append(vehiculo)            print(f"{self.nombre} ha comprado un {vehiculo.marca} {vehiculo.modelo} por ${vehiculo.precio}.")        else:            print(f"{self.nombre} no tiene suficiente saldo para comprar un {vehiculo.marca} {vehiculo.modelo}.")     def mostrar\_vehiculos\_comprados(self):        print(f"{self.nombre} Vehiculos comprados por Juan:")        for vehiculo in self.vehiculos\_comprados:            vehiculo.mostrar\_informacion()        #en caso que no tenga vehiculos comprados:        if len(self.vehiculos\_comprados) == 0:             print("No ha comprado ningún vehículo.")    def vender\_vehiculo(self, vehiculo, concesionaria):        if vehiculo in self.vehiculos\_comprados:            self.vehiculos\_comprados.remove(vehiculo)            self.saldo += vehiculo.precio            concesionaria.comprar\_vehiculo(vehiculo)            print(f"{self.nombre} ha vendido un {vehiculo.marca} {vehiculo.modelo} por ${vehiculo.precio}.") class Concesionaria:    def \_\_init\_\_(self):           self.vehiculos = \[]            def comprar\_vehiculo(self, vehiculo):        self.vehiculos.append(vehiculo)     def mostrar\_vehiculos(self):        print("Vehículos disponibles en la concesionaria:")        for vehiculo in self.vehiculos:            vehiculo.mostrar\_informacion()    def vender\_vehiculo(self, vehiculo, usuario):        if vehiculo in self.vehiculos:            self.vehiculos.remove(vehiculo)            usuario.comprar\_vehiculo(vehiculo)        else:            print("El vehículo no está disponible en la concesionaria.")            # Crear vehículosvehiculo1 = Vehiculo("Toyota", "Corolla", 20000)vehiculo2 = Vehiculo("Ford", "Fiesta", 15000)vehiculo3 = Vehiculo("Chevrolet", "Cruze", 18000) \# Crear usuariousuario1 = Usuario("Juan", "12345678", 30000) \#crea concesionariaconcesionaria = Concesionaria() \# Agregar vehículos a la concesionariaconcesionaria.comprar\_vehiculo(vehiculo1)concesionaria.comprar\_vehiculo(vehiculo2)concesionaria.comprar\_vehiculo(vehiculo3)# Mostrar vehículos disponibles enconcesionaria.mostrar\_vehiculos() \#usuario muestra vehiculos comprados (deberia estar vacio al principio)usuario1.mostrar\_vehiculos\_comprados()# Usuario compra un vehículoconcesionaria.vender\_vehiculo(vehiculo1, usuario1)#usuario vuelve a mostrar vehiculos comprados (deberia mostrar el vehiculo comprado)usuario1.mostrar\_vehiculos\_comprados()# Mostrar vehículos disponibles en la concesionaria después de la ventaconcesionaria.mostrar\_vehiculos()#ahora la concesionaria compra el vehiculo a un usuario (en este caso el usuario1 vende el vehiculo1 a la concesionaria)usuario1.vender\_vehiculo(vehiculo1, concesionaria)#usuario vuelve a mostrar vehiculos comprados (deberia estar vacio al principio)usuario1.mostrar\_vehiculos\_comprados()# Mostrar vehículos disponibles en la concesionaria después de la ventaconcesionaria.mostrar\_vehiculos()     ```python #crear clase de vehiculo con marca, modelo y precio en python class Vehiculo: def __init__(self, marca, modelo, precio): self.marca = marca self.modelo = modelo self.precio = precio def mostrar_informacion(self): print(f"Marca: {self.marca}") print(f"Modelo: {self.modelo}") print(f"Precio: ${self.precio}") class Usuario: def __init__(self, nombre, dni, saldo): self.nombre = nombre self.dni = dni self.saldo = saldo self.vehiculos_comprados = [] def comprar_vehiculo(self, vehiculo): if vehiculo.precio <= self.saldo: self.saldo -= vehiculo.precio self.vehiculos_comprados.append(vehiculo) print(f"{self.nombre} ha comprado un {vehiculo.marca} {vehiculo.modelo} por ${vehiculo.precio}.") else: print(f"{self.nombre} no tiene suficiente saldo para comprar un {vehiculo.marca} {vehiculo.modelo}.") def mostrar_vehiculos_comprados(self): print(f"{self.nombre} Vehiculos comprados por Juan:") for vehiculo in self.vehiculos_comprados: vehiculo.mostrar_informacion() #en caso que no tenga vehiculos comprados: if len(self.vehiculos_comprados) == 0: print("No ha comprado ningún vehículo.") def vender_vehiculo(self, vehiculo, concesionaria): if vehiculo in self.vehiculos_comprados: self.vehiculos_comprados.remove(vehiculo) self.saldo += vehiculo.precio concesionaria.comprar_vehiculo(vehiculo) print(f"{self.nombre} ha vendido un {vehiculo.marca} {vehiculo.modelo} por ${vehiculo.precio}.") class Concesionaria: def __init__(self): self.vehiculos = [] def comprar_vehiculo(self, vehiculo): self.vehiculos.append(vehiculo) def mostrar_vehiculos(self): print("Vehículos disponibles en la concesionaria:") for vehiculo in self.vehiculos: vehiculo.mostrar_informacion() def vender_vehiculo(self, vehiculo, usuario): if vehiculo in self.vehiculos: self.vehiculos.remove(vehiculo) usuario.comprar_vehiculo(vehiculo) else: print("El vehículo no está disponible en la concesionaria.") # Crear vehículos vehiculo1 = Vehiculo("Toyota", "Corolla", 20000) vehiculo2 = Vehiculo("Ford", "Fiesta", 15000) vehiculo3 = Vehiculo("Chevrolet", "Cruze", 18000) # Crear usuario usuario1 = Usuario("Juan", "12345678", 30000) #crea concesionaria concesionaria = Concesionaria() # Agregar vehículos a la concesionaria concesionaria.comprar_vehiculo(vehiculo1) concesionaria.comprar_vehiculo(vehiculo2) concesionaria.comprar_vehiculo(vehiculo3) # Mostrar vehículos disponibles en concesionaria.mostrar_vehiculos() #usuario muestra vehiculos comprados (deberia estar vacio al principio) usuario1.mostrar_vehiculos_comprados() # Usuario compra un vehículo concesionaria.vender_vehiculo(vehiculo1, usuario1) #usuario vuelve a mostrar vehiculos comprados (deberia mostrar el vehiculo comprado) usuario1.mostrar_vehiculos_comprados() # Mostrar vehículos disponibles en la concesionaria después de la venta concesionaria.mostrar_vehiculos() #ahora la concesionaria compra el vehiculo a un usuario (en este caso el usuario1 vende el vehiculo1 a la concesionaria) usuario1.vender_vehiculo(vehiculo1, concesionaria) #usuario vuelve a mostrar vehiculos comprados (deberia estar vacio al principio) usuario1.mostrar_vehiculos_comprados() # Mostrar vehículos disponibles en la concesionaria después de la venta concesionaria.mostrar_vehiculos() ```

```python class Auto: def __init__(self, marca, precio): self.marca = marca self.precio = precio self.disponible = True def hacer_disponible(self): self.disponible = True print(f"El auto {self.marca} esta disponible") def vender_auto(self): self.disponible = False print(f"El auto {self.marca} fue vendido") class User: def __init__(self, nombre, id_user): self.nombre = nombre self.id_user = id_user self.autos_comprados = [] def comprar_auto(self, auto): if auto.disponible: self.autos_comprados.append(auto) auto.disponible = False else: print('El auto no esta disponible') def devolver_auto(self, auto): if auto in self.autos_comprados: self.autos_comprados.remove(auto) auto.disponible = True print(f"El auto {auto.marca} fue devuelto") else: print(f"El auto {auto.marca} no esta en la lista de autos comprados") class Concesionaria: def __init__(self): self.autos = [] self.users = [] def agregar_auto(self, auto): self.autos.append(auto) print(f"Se agrego el auto {auto.marca}") def agregar_user(self, user): self.users.append(user) print(f"Se agrego el usuario {user.nombre}") def autos_disponibles(self): for auto in self.autos: if auto.disponible: print(f"Auto {auto.marca} disponible") def vender_auto(self, auto, user): if auto in self.autos: user.comprar_auto(auto) print(f"El auto {auto.marca} fue vendido a {user.nombre}") else: print(f"El auto {auto.marca} no esta en la lista de autos") # Crear autos auto1 = Auto('Toyota', 10000) auto2 = Auto('Nissan', 20000) auto3 = Auto('Ford', 15000) # Crear usuarios user1 = User('Juan', 1) # Crear concesionaria concesionaria = Concesionaria() # Agregar autos a la concesionaria concesionaria.agregar_auto(auto1) concesionaria.agregar_auto(auto2) concesionaria.agregar_auto(auto3) # Agregar usuario a la concesionaria concesionaria.agregar_user(user1) # Autos disponibles concesionaria.autos_disponibles() # Vender auto concesionaria.vender_auto(auto1, user1) # Autos disponibles concesionaria.autos_disponibles() # Devolver auto user1.devolver_auto(auto1) # Autos disponibles concesionaria.autos_disponibles() ```

***<u>Que tengo que hacerle a mi código para que al final me muestre de nuevo los modelos disponibles y tambien quisiera saber una forma de implementar el user\_id y que aparezco a quien se ha vendido ? </u>*** Code: from typing import Any class vehiculo: def \_\_init\_\_(self, model, price): self.model = model self.price = price self.available = True def buy(self): if self.available: self.available = False print(f"El auto {self.model} ha sido vendido por {self.price} a") else: print(f"El auto {self.model} no se encuentra disponible") def return\_vehiculo(self): self.available = True print(f"El vehiculo {self.model} ha sido devuelto con éxito") class client: def \_\_init\_\_(self, name, user\_id): self.name = name self.user\_id = user\_id self.bought\_vehiculos = \[] def buy\_vehiculo(self, vehiculo): if vehiculo.available: vehiculo.buy() self.bought\_vehiculos.append(vehiculo) else: print(f"El vehiculo {self.model} no se encuentra disponible") def return\_vehiculo(self, vehiculo): if vehiculo in self.bought\_vehiculos: vehiculo.return\_vehiculo() self.bought\_vehiculos.remove(vehiculo) else: print(f"El modelo {self.model} no ha sido comprado") class agencia: def \_\_init\_\_(self): self.vehiculos = \[] self.clients = \[] def add\_vehiculo(self, vehiculo): self.vehiculos.append(vehiculo) print(f"el Modelo {vehiculo.model} ha sido agregado") def register\_client(self, client): self.clients.append(client) print(f"El cliente {client.name} ha sido registrado exitosamente") def show\_available\_vehiculos(self,): print("vehiculos disponibles") for vehiculo in self.vehiculos: if vehiculo.available: print(f"{vehiculo.model}, {vehiculo.price}") # Implementación de los vehículos... vehiculo1 = vehiculo("cybertruck", "2,199,900") vehiculo2 = vehiculo("RAM 1200", "444,900.00") # Registro de Cliente... client1 = client("Aguilar Avendaño Carlos Daniel", "001") client2 = client("Aguilar Avendaño Ángel de Jesús", "002") # Crear la Agencia... agencia = agencia() agencia.add\_vehiculo(vehiculo1) agencia.add\_vehiculo(vehiculo2) agencia.register\_client(client1,) agencia.register\_client(client2) # Mostrar Vehículos disponibles... agencia.show\_available\_vehiculos # Comprar un Vehículo... client1.buy\_vehiculo(vehiculo1) # Mostrar modelos disponibles... agencia.show\_available\_vehiculos # Devolver vehiculo... client1.return\_vehiculo(vehiculo1) # Mostrar modelos disponibles... agencia.show\_available\_vehiculos ***<u>Muchas gracias... </u>***

```js ##Definicion clase vehiculo class vehicle: def __init__(self, model, year, stock): self.model=model self.year=year self.stock=stock def incStock(self): self.stock+=1 def decStock(self): self.stock-=1 def showStock(self): print(f"Car´s in stock: {self.stock}") ##Definicion clase usuario class user: def __init__(self, name, id): self.name=name self.id=id def buy(self, vehicle): if vehicle.stock >= 1: vehicle.decStock() print(f"You have bought a new car {vehicle.model} {vehicle.year}") #Definicion de concesionario class vendor: def __init__(self): self.cars=[] def addCar(self, vehicle): self.cars.append(vehicle) def sellCar(self, user, vehicle): user.buy(vehicle) def showStock(self): print(f"brands in stock: {len(self.cars)}") def showDetailStock(self, vehicle): print(f"Model: {vehicle.model} has {vehicle.stock} existences in stock") #### Definicion de objetos vehiculo toyota=vehicle("corola", 2015, 5) hyundai=vehicle("civic", 2022, 3) #### Definicion de usuario hugo=user("Hugo", 1234) #### DEfinicion consecionario rentCar=vendor() #### INTERACCIONES rentCar.addCar(toyota) rentCar.addCar(hyundai) rentCar.showStock() rentCar.showDetailStock(toyota) rentCar.showDetailStock(hyundai) rentCar.sellCar(hugo, hyundai) rentCar.showDetailStock(toyota) rentCar.showDetailStock(hyundai) ```

Les comparto mi ejercicio de la concesionaria: ```js class Vehicle: def __init__(self, brand, model, price): self.brand = brand self.model = model self.price = price self.available = True def sell(self): if self.available: self.available = False print(f"El vehículo {self.brand} {self.model} ha sido vendido.") else: print(f"El vehículo {self.brand} {self.model} ya no está disponible.") def make_available(self): self.available = True print(f"El vehículo {self.brand} {self.model} está ahora disponible para la venta.") class User: def __init__(self, name, user_id, balance): self.name = name self.user_id = user_id self.balance = balance self.owned_vehicles = [] def buy_vehicle(self, vehicle): if not vehicle.available: print(f"El vehículo {vehicle.brand} {vehicle.model} no está disponible para la compra.") return if self.balance >= vehicle.price: self.balance -= vehicle.price vehicle.sell() self.owned_vehicles.append(vehicle) print(f"{self.name} ha comprado el vehículo {vehicle.brand} {vehicle.model} por ${vehicle.price}.") else: print(f"{self.name} no tiene suficiente saldo para comprar el vehículo {vehicle.brand} {vehicle.model}.") def show_owned_vehicles(self): print(f"\nVehículos de {self.name}:") if self.owned_vehicles: for vehicle in self.owned_vehicles: print(f" - {vehicle.brand} {vehicle.model} (${vehicle.price})") else: print("No posee ningún vehículo actualmente.") class Dealership: def __init__(self): self.vehicles = [] self.users = [] def add_vehicle(self, vehicle): self.vehicles.append(vehicle) print(f"El vehículo {vehicle.brand} {vehicle.model} ha sido agregado al inventario por ${vehicle.price}.") def add_user(self, user): self.users.append(user) print(f"El usuario {user.name} ha sido registrado con un saldo de ${user.balance}.") def show_available_vehicles(self): print("\nVehículos disponibles:") available_vehicles = [vehicle for vehicle in self.vehicles if vehicle.available] if available_vehicles: for vehicle in available_vehicles: print(f" - {vehicle.brand} {vehicle.model}: ${vehicle.price}") else: print("No hay vehículos disponibles en este momento.") def find_vehicle(self, brand, model): for vehicle in self.vehicles: if vehicle.brand.lower() == brand.lower() and vehicle.model.lower() == model.lower(): return vehicle print(f"No se encontró el vehículo {brand} {model}.") return None # Crear vehículos car1 = Vehicle("Toyota", "Corolla", 20000) car2 = Vehicle("Ford", "Focus", 22000) car3 = Vehicle("Tesla", "Model 3", 35000) # Crear usuarios user1 = User("Daniel", "001", 25000) user2 = User("Ana", "002", 50000) # Crear concesionaria dealership = Dealership() # Agregar vehículos a la concesionaria dealership.add_vehicle(car1) dealership.add_vehicle(car2) dealership.add_vehicle(car3) # Registrar usuarios dealership.add_user(user1) dealership.add_user(user2) # Mostrar vehículos disponibles dealership.show_available_vehicles() # Comprar vehículos user1.buy_vehicle(car1) # Daniel compra el Toyota Corolla user2.buy_vehicle(car3) # Ana compra el Tesla Model 3 # Mostrar vehículos disponibles después de las compras dealership.show_available_vehicles() # Mostrar vehículos comprados por los usuarios user1.show_owned_vehicles() user2.show_owned_vehicles() # Intentar comprar un vehículo no disponible user1.buy_vehicle(car1) # Devolver el vehículo al inventario (hacerlo disponible nuevamente) car1.make_available() dealership.show_available_vehicles() # Buscar un vehículo específico vehicle = dealership.find_vehicle("Ford", "Focus") if vehicle: print(f"Se encontró el vehículo: {vehicle.brand} {vehicle.model} por ${vehicle.price}") ```class Vehicle: def \_\_init\_\_(self, brand, model, price): self.brand = brand self.model = model self.price = price self.available = True def sell(self): if self.available: self.available = False print(f"El vehículo {self.brand} {self.model} ha sido vendido.") else: print(f"El vehículo {self.brand} {self.model} ya no está disponible.") def make\_available(self): self.available = True print(f"El vehículo {self.brand} {self.model} está ahora disponible para la venta.") class User: def \_\_init\_\_(self, name, user\_id, balance): self.name = name self.user\_id = user\_id self.balance = balance self.owned\_vehicles = \[] def buy\_vehicle(self, vehicle): if not vehicle.available: print(f"El vehículo {vehicle.brand} {vehicle.model} no está disponible para la compra.") return if self.balance >= vehicle.price: self.balance -= vehicle.price vehicle.sell() self.owned\_vehicles.append(vehicle) print(f"{self.name} ha comprado el vehículo {vehicle.brand} {vehicle.model} por ${vehicle.price}.") else: print(f"{self.name} no tiene suficiente saldo para comprar el vehículo {vehicle.brand} {vehicle.model}.") def show\_owned\_vehicles(self): print(f"\nVehículos de {self.name}:") if self.owned\_vehicles: for vehicle in self.owned\_vehicles: print(f" - {vehicle.brand} {vehicle.model} (${vehicle.price})") else: print("No posee ningún vehículo actualmente.") class Dealership: def \_\_init\_\_(self): self.vehicles = \[] self.users = \[] def add\_vehicle(self, vehicle): self.vehicles.append(vehicle) print(f"El vehículo {vehicle.brand} {vehicle.model} ha sido agregado al inventario por ${vehicle.price}.") def add\_user(self, user): self.users.append(user) print(f"El usuario {user.name} ha sido registrado con un saldo de ${user.balance}.") def show\_available\_vehicles(self): print("\nVehículos disponibles:") available\_vehicles = \[vehicle for vehicle in self.vehicles if vehicle.available] if available\_vehicles: for vehicle in available\_vehicles: print(f" - {vehicle.brand} {vehicle.model}: ${vehicle.price}") else: print("No hay vehículos disponibles en este momento.") def find\_vehicle(self, brand, model): for vehicle in self.vehicles: if vehicle.brand.lower() == brand.lower() and vehicle.model.lower() == model.lower(): return vehicle print(f"No se encontró el vehículo {brand} {model}.") return None \# Crear vehículoscar1 = Vehicle("Toyota", "Corolla", 20000)car2 = Vehicle("Ford", "Focus", 22000)car3 = Vehicle("Tesla", "Model 3", 35000) \# Crear usuariosuser1 = User("Daniel", "001", 25000)user2 = User("Ana", "002", 50000) \# Crear concesionariadealership = Dealership() \# Agregar vehículos a la concesionariadealership.add\_vehicle(car1)dealership.add\_vehicle(car2)dealership.add\_vehicle(car3) \# Registrar usuariosdealership.add\_user(user1)dealership.add\_user(user2) \# Mostrar vehículos disponiblesdealership.show\_available\_vehicles() \# Comprar vehículosuser1.buy\_vehicle(car1) # Daniel compra el Toyota Corollauser2.buy\_vehicle(car3) # Ana compra el Tesla Model 3 \# Mostrar vehículos disponibles después de las comprasdealership.show\_available\_vehicles() \# Mostrar vehículos comprados por los usuariosuser1.show\_owned\_vehicles()user2.show\_owned\_vehicles() \# Intentar comprar un vehículo no disponibleuser1.buy\_vehicle(car1) \# Devolver el vehículo al inventario (hacerlo disponible nuevamente)car1.make\_available()dealership.show\_available\_vehicles() \# Buscar un vehículo específicovehicle = dealership.find\_vehicle("Ford", "Focus")if vehicle: print(f"Se encontró el vehículo: {vehicle.brand} {vehicle.model} por ${vehicle.price}")

Oigan solo para que jueguen, a la class Library le agregué un método para que funcione como buscador de libros ya sea por autor o título...def find\_book(*self*, *title*=None, *author*=None):        print("Resultado de la búsqueda:")        found\_books = \[]                *# Search for matching books using regex*        *for* book *in* *self*.books:            matches\_title = bool(*title*) and bool(re.search(*title*, book.title, re.IGNORECASE)) *if* *title* *else* False            matches\_author = bool(*author*) and bool(re.search(*author*, book.author, re.IGNORECASE)) *if* *author* *else* False                        *# Add book if it matches the title or author or both*            *if* matches\_title or matches\_author:                found\_books.append(book)                *# Display results*        *if* found\_books:            *for* book *in* found\_books:                print(f"{book.title} por {book.author} | Disponible: {'Sí' *if* book.available *else* 'No'}")        *else*:            print("No se encontraron libros que coincidan con la búsqueda.") Les dejo la función para que la agreguen y jueguen: ```js def find_book(self, title=None, author=None): print("Resultado de la búsqueda:") found_books = [] # Search for matching books using regex for book in self.books: matches_title = bool(title) and bool(re.search(title, book.title, re.IGNORECASE)) if title else False matches_author = bool(author) and bool(re.search(author, book.author, re.IGNORECASE)) if author else False # Add book if it matches the title or author or both if matches_title or matches_author: found_books.append(book) # Display results if found_books: for book in found_books: print(f"{book.title} por {book.author} | Disponible: {'Sí' if book.available else 'No'}") else: print("No se encontraron libros que coincidan con la búsqueda.") ```

Este es mi ejercicio, lo "conté" como una historia para que se entienda mejor la ejecución. ```python class Vehiculo: def __init__(self, marca, tipo, color, precio): self.marca = marca self.tipo = tipo self.color = color self.precio = precio self.disponible = True class Cliente: def __init__(self, nombre, presupuesto): self.nombre = nombre self.presupuesto = presupuesto self.vehiculo = '' def comprar(self, vehiculo): vehiculo.disponible = False self.vehiculo = vehiculo.marca self.presupuesto -= vehiculo.precio print(f"\n -- El cliente {self.nombre} ha comprado '{vehiculo.tipo} {vehiculo.marca}' de color {vehiculo.color}") def mirarBilletera(self): print(f"\n -+ Tu presupuesto actual es de: $ {self.presupuesto}") def vehiculoNuevo(self): print(f"\n {self.nombre} tu nuevo vehiculo es un {self.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} | ") ## Aqui inicia la instancia de obj # clientes cliente1 = Cliente("Cristian", 2000) cliente2 = Cliente("Maria", 3500) cliente3 = Cliente("Santiago", 5500) # vehiculos vehiculo1 = Vehiculo("Renault", "Sedan", "Azul", 1500) vehiculo2 = Vehiculo("Chevrolet", "Camioneta", "Rojo", 3500) vehiculo3 = Vehiculo("Ford", "Camioneta", "Verde", 2500) vehiculo4 = Vehiculo("Huskvarna", "Motocicleta", "Blanca", 1500) vehiculo5 = Vehiculo("Foton", "Camion", "Blanco", 5500) # consecionario consecionario = Consecionario() # Agregamos clientes consecionario.registrar_cliente(cliente1) consecionario.registrar_cliente(cliente2) # Agregamos vehiculos consecionario.registrar_vehiculo(vehiculo1) consecionario.registrar_vehiculo(vehiculo2) consecionario.registrar_vehiculo(vehiculo3) consecionario.registrar_vehiculo(vehiculo4) consecionario.registrar_vehiculo(vehiculo5) # Un Cliente llega al consecionario y revisa la lista de vehiculos consecionario.listar_vehiculos() # Ahora el cliente revisa su presupuesto cliente1.mirarBilletera() # Le gusto el Ford consecionario.vender_vehiculo(vehiculo3, cliente1) # revisa la lista de vehiculos consecionario.listar_vehiculos() # Como no alcanzo toco ir por el Renault consecionario.vender_vehiculo(vehiculo1, cliente1) # El cliente mira para ver si le alcanza para los dulces cliente1.mirarBilletera() print("\n Cambio de historia: Cliente 2") # Entra el cliente numero 2 cliente2.mirarBilletera() # Mira la lista consecionario.listar_vehiculos() # Le gusto el camion Foton consecionario.vender_vehiculo(vehiculo5, cliente2) # Como no alcanzo toco para la Ford consecionario.vender_vehiculo(vehiculo3, cliente2) # El cliente 2 revisa si le alcanzo para la gaseosa cliente2.mirarBilletera() # Los clientes revisan sus vehiculos. cliente1.vehiculoNuevo() cliente2.vehiculoNuevo() # llego un cliente 3 a preguntar si aun tienen la Ford consecionario.vender_vehiculo(vehiculo3, cliente3) # Como no esta disponible decide llevarse la motocicleta consecionario.vender_vehiculo(vehiculo4, cliente3) # la lista quedo asi consecionario.listar_vehiculos() ```

```js class Book: def __init__(self, title, author): self.title = title self.author = author self.available = True def borrow(self): if self.available: self.available = False print(f"El libro {self.title} ha sido prestado") else: print(f"El libro {self.title} no está disponible") def return_book(self): self.available = True print(f"El libro {self.title} ha sido devuelto") class User: def __init__(self, name, user_id): self.name = name self.user_id = user_id self.borrowed_books = [] def borrow_book(self, book): if book.available: book.borrow() self.borrowed_books.append(book) else: print(f"El libro {book.title} No esta disponible") def return_book(self, book): if book in self.borrowed_books: book.return_book() self.borrowed_books.remove(book) else: print(f"El libro {book.title} No esta en la lista de prestados") class Library: def __init__(self): self.books = [] self.users = [] def add_book(self, book): self.books.append(book) print(f"El libro {book.title} ha sido agregado") def register_user(self, user): self.users.append(user) print(f"El usuario {user.name} ha sido registrado") def show_available_books(self): print("Libros disponibles:") for book in self.books: if book.available: print(f"{book.title} por {book. author}") #Crear los libros book1 = Book("El principito", "Antoine de Saint-Exupéry") book2 = Book("1984", "George Orwell") #Crear usuario user1 = User("Carli", "001") #Crear Biblioteca library = Library() library.add_book(book1) library.add_book(book2) library.register_user(user1) #Mostrar libros library.show_available_books() #Realizar prestamo user1.borrow_book(book1) #Mostrar libros library.show_available_books() #Devolver libro user1.return_book(book1) #Mostrar libros library.show_available_books() ```

**Este es el código:** `class ``Book``:` ` def __init__(self, title, author):` ` self.title = title` ` self.author = author` ` self.available = True` ` ` ` def borrow(self):` ` if self.available:` ` self.available = False` ` print(f"El libro {self.title} ha sido prestado")` ` else:` ` print(f"El libro {self.title} no está disponible")` ` def return_book(self):` ` self.available = True` ` print(f"El libro {self.title} ha sido devuelto")` `class ``User``:` ` def __init__(self, name, user_id):` ` self.name = name` ` self.user_id = user_id` ` self.borrowed_books = []` ` def borrow_book(self, book):` ` if book.available:` ` book.borrow()` ` self.borrowed_books.append(book)` ` else:` ` print(f"El libro {book.title} No esta disponible")` ` def return_book(self, book):` ` if book in self.borrowed_books:` ` book.return_book()` ` self.borrowed_books.remove(book)` ` else:` ` print(f"El libro {book.title} No esta en la lista de prestados")` `class ``Library``:` ` def __init__(self):` ` self.books = []` ` self.users = []` ` ` ` def add_book(self, book):` ` self.books.append(book)` ` print(f"El libro {book.title} ha sido agregado")` ` def register_user(self, user):` ` self.users.append(user)` ` print(f"El usuario {user.name} ha sido registrado")` ` def show_available_books(self):` ` print("Libros disponibles:")` ` for book in self.books:` ` if book.available:` ` print(f"{book.title} por {book. author}")` `#Crear los libros` `book1 = Book("El principito", "Antoine de Saint-Exupéry")` `book2 = Book("1984", "George Orwell")` `#Crear usuario` `user1 = User("Carli", "001")` `#Crear Biblioteca` `library = Library()` `library.add_book(book1)` `library.add_book(book2)` `library.register_user(user1)` `#Mostrar libros` `library.show_available_books()` `#Realizar prestamo` `user1.borrow_book(book1)` `#Mostrar libros` `library.show_available_books()` `#Devolver libro` `user1.return_book(book1)` `#Mostrar libros` `library.show_available_books()`

```python class Vehiculo: """Clase que registra un tipo de vehiculo""" def __init__(self, marca, modelo, anio, precio): """Vehiculos""" self.marca = marca self.modelo = modelo self.anio = anio self.precio = precio self.disponible = True def disponibilidad(self): """Consulta la disponibilidad del vehiculo""" if self.disponible: print(f'El vehículo {self.modelo} esta disponible.') else: print(f'El vehículo {self.modelo} no esta disponible.') class Client: """Clase de clientes""" def __init__(self, nombre, user_id): self.nombre = nombre self.user_id = user_id def comprar_vehiculo(self, vehiculo): """Compra un vehiculo""" if vehiculo.disponible: print(f'El vehículo {vehiculo.modelo} ha sido vendido') vehiculo.disponible = False else: print(f'El vehículo {vehiculo.modelo} no esta disponible') def consultar_disponibilidad(self, vehiculo): """Consulta la disponibilidad del vehiculo""" vehiculo.disponibilidad() class Concesionaria: """Clase concesionaria""" def __init__(self): self.vehiculos = [] self.clientes = [] def add_vehiculo(self, vehiculo): """Permite añadir un vehiculo a la coleccion de vehiculos""" self.vehiculos.append(vehiculo) def add_cliente(self, cliente): """Permite añadir un cliente a la coleccion de clientes""" self.clientes.append(cliente) def remove_vehiculo(self, vehiculo): """Permite remover un vehiculo de la coleccion de vehiculos""" if vehiculo in self.vehiculos: self.vehiculos.remove(vehiculo) print('El vehículo a sido removido de la concesionaria') else: print('El vehículo no se encuentra en la concesionaria.') def remove_cliente(self, cliente): """Permite remover un cliente de la coleccion de clientes""" if cliente in self.clientes: self.clientes.remove(cliente) print('El cliente a sido removido la lista de clientes.') else: print('El cliente no se encuentra en la lista de clientes.') def mostrar_clientes(self): """Muestra todos los clientes""" print('CLIENTES:') for cliente in self.clientes: print(f'Cliente: {cliente.nombre}, ID: {cliente.user_id}') def mostrar_vehiculos(self): """Muestra todos los vehiculos""" print('VEHICULOS DISPONIBLES:') for vehiculo in self.vehiculos: if vehiculo.disponible: print(f'Modelo: {vehiculo.modelo}, Marca: {vehiculo.marca}, Precio: {vehiculo.precio}') vehiculo1 = Vehiculo('Alfa Romeo', 'Tonale', 2024, 15000) vehiculo2 = Vehiculo('Audi', 'Q8 E-Tron', 2024, 10000) cliente1 = Client('Marcos Aguirre', 1) concesionaria = Concesionaria() concesionaria.add_vehiculo(vehiculo1) concesionaria.add_vehiculo(vehiculo2) concesionaria.add_cliente(cliente1) concesionaria.mostrar_vehiculos() concesionaria.mostrar_clientes() vehiculo1.disponibilidad() cliente1.comprar_vehiculo(vehiculo1) cliente1.consultar_disponibilidad(vehiculo2) concesionaria.mostrar_vehiculos() ```

class Vehicle: def \_\_init\_\_(self, modelVehicle, costVehicle): self.modelVehicle = modelVehicle self.costVehicle = costVehicle self.availableVehicle = True def sellVehicle(self): self.availableVehicle = False print(f"El Vehiculo {self.modelVehicle} ha sido vendido exitosamente por un valor de {self.costVehicle}$\n") class User: def \_\_init\_\_(self, username, balance): self.username = username self.balance = balance def buyVehicle(self, vehicle): if vehicle.availableVehicle: if self.balance >= vehicle.costVehicle: vehicle.sellVehicle() self.balance -= vehicle.costVehicle print(f"El vehiculo {vehicle.modelVehicle} ha sido comprado exitosamenten") print(f"El dinero sobrante es {self.balance}\n") else: print("No hay dinero suficiente para comprar el vehiculo\n") else: print(f"El Vehiculo {vehicle.modelVehicle} ya no esta disponible\n") class Concessionarie: def \_\_init\_\_(self): self. vehicles = \[] self.users = \[] def addVehicle(self, vehicle): self.vehicles.append(vehicle) print(f"El Vehiculo {vehicle.modelVehicle} se ha agregado a la concesionaria\n") def addUser(self, user): self.users.append(user) print(f"El usuario {user.username} ha sido registrado\n") def showAvailableVehicle(self): available = \[vehicle for vehicle in self.vehicles if vehicle.availableVehicle] if available: print("Vehiculos disponible:") for vehicle in available: print(f"{vehicle.modelVehicle} por {vehicle.costVehicle}$") \#Crear vehiculosvehicle1 = Vehicle("Hyundai Accend", 10000)vehicle2 = Vehicle("Toyota Hilux", 40000)vehicle3 = Vehicle("Mazda RX7", 120000) \#Crear Usuariouser1 = User("Alex", 100000) \#Agregar la Concesionariaconcessionarie = Concessionarie() \#Agregar Vehiculosconcessionarie.addVehicle(vehicle1)concessionarie.addVehicle(vehicle2)concessionarie.addVehicle(vehicle3) \#Agregar Usuarioconcessionarie.addUser(user1) \#Ver Vehiculos disponiblesconcessionarie.showAvailableVehicle() user1.buyVehicle(vehicle2) concessionarie.showAvailableVehicle()

El código que compartiste implementa una concesionaria de vehículos utilizando programación orientada a objetos en Python, lo cual es muy similar al ejercicio de la biblioteca que se vio en la clase. Tienes clases para `Vehicle`, `User` y `Concessionarie`, cada una con atributos y métodos que permiten gestionar la compra y venta de vehículos. Asegúrate de que cada clase está correctamente definida y que los métodos cumplen con sus funciones. Por ejemplo, el método `buyVehicle` en la clase `User` verifica si el vehículo está disponible y si el usuario tiene suficiente balance para comprarlo. Esto es un gran ejercicio en el uso de clases y objetos. Si necesitas más ayuda con el código o con conceptos específicos de programación orientada a objetos, no dudes en preguntar.

    Bueno yo lo hice asi, tomando de ejemplo la biblioteca

```python class Vehicle: def __init__(self, model, year, price): self.model = model self.year = year self.price = price self.available = True def sell(self): if self.available: self.available = False print(f"El vehiculo {self.model} ha sido vendido por {self.price}") else: print(f"El vehiculo {self.model} no está disponible") def return_car(self): self.available = True print(f"El vehiculo {self.model} ha sido devuelto por {self.price}") class User: def __init__(self, name, user_id): self.name = name self.user_id = user_id self.owned_cars = [] def buy_vehicle(self, vehicle): if vehicle.available: vehicle.sell() self.owned_cars.append(vehicle) else: print(f"El vehiculo {vehicle.model} no está disponible") def return_vehicle(self, vehicle): if vehicle in self.owned_cars: vehicle.return_car() self.owned_cars.remove(vehicle) else: print(f"El vehiculo {vehicle.model} no está en la lista de vehiculos comprados") class CarDealership: def __init__(self): self.list_vehicles = [] self.list_users = [] def add_vehicle(self, vehicle): self.list_vehicles.append(vehicle) print(f"Se añadió un nuevo vehículo de tipo: {vehicle.model}") def register_user(self, user): self.list_users.append(user) print(f"El usuario {user.name} ha sido registrado") def show_available_vehicles(self): print("=================================================================") print("Vehiculos disponibles:") for vehicle in self.list_vehicles: if vehicle.available: print(f"{vehicle.model} del año {vehicle.year} por el precio de ${vehicle.price}") print("=================================================================") vehicle1 = Vehicle("Lamborghini", 2020, 4999999.99) vehicle2 = Vehicle("Ferrari", 2019, 3999999.99) user1 = User("Ricardo", 1) user2 = User("Pedro", 2) concesionaria = CarDealership() concesionaria.add_vehicle(vehicle1) concesionaria.add_vehicle(vehicle2) concesionaria.register_user(user1) concesionaria.register_user(user2) concesionaria.show_available_vehicles() user1.buy_vehicle(vehicle1) user2.buy_vehicle(vehicle1) concesionaria.show_available_vehicles() user1.return_vehicle(vehicle1) concesionaria.show_available_vehicles() ```

```js class Car: def __init__(self, model, year, price): self.model = model self.year = year self.price = price self.available = True def purchase(self): if self.available: self.available = False print(f'The car {self.model} has been purchased') else: print(f'The car {self.model} it is not available') class Customer: def __init__(self, name, user_id): self.name = name self.user_id = user_id self.purchased_cars = [] def purchase_car(self, car): if car.available: car.purchase() self.purchased_cars.append(car) else: print(f'The car {car.model} it is not available') class Store: def __init__(self): self.cars = [] self.customers = [] def add_car(self, car): self.cars.append(car) print(f'The car {car.model} has been added to store') def register_customer(self, customer): self.customers.append(customer) print(f'The customer {customer.name} has been added') def show_available_cars(self): print('Cars availables') for car in self.cars: if car.available: print(f'Model: {car.model} Year: {car.year} Price: {car.price}') car1 = Car('Subaru Impresa', '2015', '$ 35.000') car2 = Car('Renault Space', '2019', '$ 18.000') car3 = Car('BMW 1 Series', '2014', '$ 12.000') customer1 = Customer('Alonso', '001') customer2 = Customer('Teresa', '002') customer3 = Customer('Matteo', '003') store = Store() store.add_car(car1) store.add_car(car2) store.add_car(car3) store.register_customer(customer1) store.register_customer(customer2) store.register_customer(customer3) store.show_available_cars() customer1.purchase_car(car1) store.show_available_cars() ```

con algiunos error pero ya arreglado

El código proporcionado tiene algunos errores y mejoras que puedes aplicar: 1. **Constructor de la clase `Vehiculo`:** Debes usar `__init__` en lugar de `_init_`. 2. **Nombre de la clase `concesionario`:** Debe comenzar con mayúscula: `Concesionario`. 3. **Método `comprado`:** En la clase `Vehiculo`, el método debe llamarse `comprado` y no `compra`. 4. **Método `compra_vehi`:** En la clase `User`, el método se llama igual que el atributo. Cambia el nombre del método para evitar conflictos. 5. **Mensajes de print:** Asegúrate de que sean claros y precisos. Aquí tienes el código corregido: ```python from typing import Any class Vehiculo: def __init__(self, marca, precio): self.marca = marca self.precio = precio self.disponible = True def comprado(self): if self.disponible: self.disponible = False print(f"El vehiculo {self.marca} ha sido comprado") else: print(f"El vehiculo {self.marca} no está disponible") class User: def __init__(self, name, user_id): self.name = name self.user_id = user_id self.compra_vehiculos = [] def comprar_vehiculo(self, vehiculo): if vehiculo.disponible: vehiculo.comprado() self.compra_vehiculos.append(vehiculo) else: print(f"El vehiculo {vehiculo.marca} no está disponible") class Concesionario: def __init__(self): self.vehiculos = [] self.users = [] def add_vehiculo(self, vehiculo): self.vehiculos.append(vehiculo) print(f"El vehiculo {vehiculo.marca} ha sido agregado") def register_user(self, user): self.users.append(user) print(f"El usuario {user.name} ha sido registrado") def muestra_vehi_disponible(self): print("Vehículos disponibles:") for vehiculo in self.vehiculos: if vehiculo.disponible: print(f"{vehiculo.marca} por {vehiculo.precio}") ``` Asegúrate de probar el código después de realizar estas correcciones para verificar su funcionamiento adecuado.

Adjunto el reto del Concesionario class Auto: def \_\_init\_\_(self, id\_car, marca, modelo, color, precio): self.id = id\_car self.marca = marca self.modelo = modelo self.color = color self.precio = precio self.disponible = True def alquiler(self): if self.disponible: self.disponible = False print(f"El auto {self.id} se ha alquilado") else: print(f"El auto {self.id} no está disponible") def compra(self): self.disponible = False print(f"El auto {self.id} ha sido comprado") def venta(self): self.disponible = True print(f"El auto {self.id} ha sido vendido") class Usuario: def \_\_init\_\_(self, nombre, cedula, edad, telefono, correo): self.nombre = nombre self.cedula = cedula self.edad = edad self.telefono = telefono self.correo = correo self.autos = \[] def alquilar(self, auto): if auto.disponible: auto.alquiler() self.autos.append(auto) else: print(f"El auto {auto.id} no está disponible") def comprar(self, auto): if auto.disponible: auto.compra() self.autos.append(auto) else: print(f"El auto {auto.id} no está disponible") def vender(self, auto): if auto in self.autos: auto.venta() self.autos.remove(auto) else: print( f"El auto {auto.id} no está en la lista de autos del usuario") class Concesionario: def \_\_init\_\_(self, nombre, direccion, telefono, correo): self.nombre = nombre self.direccion = direccion self.telefono = telefono self.correo = correo self.autos = \[] self.usuarios = \[] def agregar\_auto(self, auto): self.autos.append(auto) print(f"El auto {auto.id} ha sido agregado al concesionario") def agregar\_usuario(self, usuario): self.usuarios.append(usuario) print(f"El usuario {usuario.nombre} ha sido agregado al concesionario") def mostrar\_autos(self): print("Estos son los autos disponibles:") for auto in self.autos: if auto.disponible: print( f"{auto.id} de la marca {auto.marca} modelo {auto.modelo} color" ) \# Parametrizamos la clase Auto \# Crear objetos auto1 = Auto("A1", "Toyota", "Corolla", "Rojo", 250000) auto2 = Auto("A2", "Honda", "Civic", "Azul", 300000) auto3 = Auto("A3", "Ford", "Mustang", "Blanco", 500000) auto4 = Auto("A4", "Audi", "Sport", "gris", 4582000) auto5 = Auto("A5", "Chevrom", "Perla", "Amarillo", 330000) auto6 = Auto("A6", "Viuc", "wagon", "blanco", 300000) auto7 = Auto("A7", "Chevrolet", "camioneta", "Blanco", 500000) auto8 = Auto("A8", "Ra", "Sport", "gris", 4582000) \# Parametrizamos la clase Usuario usuario1 = Usuario("Juan", "123456789", 30, "1234567890", "[email protected]") usuario2 = Usuario("Maria", "987654321", 25, "9876543210", "[email protected]") usuario3 = Usuario("Pedro", "456789123", 35, "4567890123", "[email protected]") print(100 \* "\*") print("Información General de Concesionario".join(" ")) concesionario1 = Concesionario("Mi Concesionario", "Calle 123, Ciudad", "4567890", "[email protected]") \# Agregar autos al concesionario print(100 \* "\*") concesionario1.agregar\_auto(auto1) concesionario1.agregar\_auto(auto2) concesionario1.agregar\_auto(auto3) concesionario1.agregar\_auto(auto4) concesionario1.agregar\_auto(auto5) concesionario1.agregar\_auto(auto6) concesionario1.agregar\_auto(auto7) concesionario1.agregar\_auto(auto8) \# agregar usuarios al concesionario print("AGREGAMOS USUARIOS AL CONCESIONARIO ") print(100 \* "\*") concesionario1.agregar\_usuario(usuario1) concesionario1.agregar\_usuario(usuario2) concesionario1.agregar\_usuario(usuario3) \# llamar métodos \# agregamos autos al usuario3 print(100 \* "\*") print("Agregamos autos al usuario3".join(" ")) usuario3.autos.append(auto3) usuario3.autos.append(auto4) usuario3.autos.append(auto5) print(100 \* "\*") print("Agregamos los autos disponibles en el concesionario".join(" ")) concesionario1.mostrar\_autos() print(100 \* "\*") print("Llamamos los métodos para aquiler, compra y venta por usuario") \# alquilamos un auto usuario1.alquilar(auto1) \# compramos un auto usuario2.comprar(auto2) \# vendemos un auto usuario3.vender(auto3) print(100 \* "\*") \# mostrar listado carros usuario3 print("Aqui mostramos los vehiculos a cargo del usuario3:") for auto in usuario3.autos: \# imprimir datos numerados print( f"Codi\_Auto:{auto.id}, Model\_car: {auto.marca}, model: {auto.modelo}, color: {auto.color}, valor : {auto.precio}")

Este es mi Ejercicio class Cars:    def \_\_init\_\_(self, brand, reference, color, year, price) :        self.brand=brand        self.reference=reference        self.year=year        self.color=color        self.price=price        self.available=True     def sell\_car(self):        if self.available:            self.available=False            print(f"El automovil {self.brand} {self.reference} ha sido vendido")        else:            print(f"El automovil {self.brand} {self.reference} no esta disponible")     def buy\_car(self):        self.available=True        print(f"El automovil {self.brand} {self.reference} ha sido comprado")class User:    def \_\_init\_\_(self, name, user\_id):        self.name=name        self.user\_id=user\_id        self.purchased\_cars=\[]    def purchased\_car(self, car):        if car.available:            car.sell\_car()            self.purchased\_cars.append(car)        else:            print(f"El automovil {car.brand} no esta disponible")    def car\_sale(self, car):        if car in self.purchased\_cars:            car.buy\_car()            self.purchased\_cars.remove(car)         else:            print(f"El automovil{car.brand} no esta en tu lista de comprados") class Concessionaire:    def \_\_init\_\_(self):        self.cars=\[]        self.users=\[]     def add\_car(self,car):        self.cars.append(car)        print(f"El automovil  {car.brand} ha sido agregado")     def register\_user(self, user):        self.users.append(user)        print(f"El usuario {user.name} ha sido registrado")     def show\_available\_cars(self):        print("Automoviles disponibles")        for car in self.cars:            if car.available:                print (f"{car.brand} por {car.reference}") \# Creación de Carroscar1=Cars("Mazda", "CX5", "Red", "2023", "$38.000")car2=Cars("Mazda", "CX3", "Grey", "2024", "$34.000")car3=Cars("Mazda", "CX50", "Black", "2024", "$46.000") \# Creación de  Usuariosuser1 =User("Rodrigo Restrepo", "1")user2 =User("Maribel Sanchez", "2") \# Creación Concesionarioconcessionaire=Concessionaire()concessionaire.add\_car(car1)concessionaire.add\_car(car2)concessionaire.add\_car(car3)concessionaire.register\_user(user1)concessionaire.register\_user(user2) \# Exhibición de carrosconcessionaire.show\_available\_cars() \# Realizar venta del carrouser1.purchased\_car(car1) \# Exhibición de carrosconcessionaire.show\_available\_cars() \# Realizar compra del carrouser1.car\_sale(car1) \# Exhibición de carrosconcessionaire.show\_available\_cars()

`#BOOK` `class Book:` ` def __init__(self, title, author, lable, isbn, year):` ` self.title = title` ` self.author = author` ` self.lable = lable` ` self.isbn = isbn` ` self.year = year` ` self.available = True` ` def info(self):` ` return f"{self.title} by {self.author} ({self.year}) - {self.lable} - ISBN: {self.isbn}"` ` def update_availability(self, available):` ` self.available = available` ` state = available if available else "not available"` ` print(f"Book '{self.title}' is now {state}.")` ` ` `# USER ` `class User:` ` def __init__(self, id_user, name, email):` ` self.id_user = id_user` ` self.name = name` ` self.email = email` ` self.loaned_books = []` ` def loan_book(self, book):` ` if book.available` ` self.loaned_books.append(book)` ` book.update_availability(False)` ` print(f"Book '{book.title}' has been loaned to {self.name} ")` ` else:` ` print(f"Book '{book.title}' is not available for loan.")` ` def return_book(self, book):` ` if book in self.loaned_books:` ` self.loaned_books.remove(book)` ` book.update_availability(True)` ` print(f"Book '{book.title}' has been returned by {self.name}.")` `#LIBRARIAN` `class Librarian:` ` def __init__(self, id_librarian, name):` ` self.id_librarian = id_librarian` ` self.name = name` ` def add_book(self, book, library):` ` library.books.append(book)` ` print(f"Book '{book.title}' has been added to the library.")` ` def remove_books(self, book, library):` ` if book in library.books:` ` library.books.remove(book)` ` print(f"Book '{book.title}' has been removed from the library.")` ` else:` ` print(f"Book '{book.title}' is not found in the library.")` ` def search_book(self, title, author, isbn):` ` self.title = title` ` for book in library.books:` ` if book.title == title:` ` print(f"Book '{book.title}' found in the library.")` ` else:` ` print(f"Book '{book.title}' is not found in the library.")` ` ` `#LIBRARY` `class Library:` ` def __init__(self):` ` self.books = []` ` self.librarians = []` ` self.users = []` ` ` ` def user_register(self, user)` ` self.users.append(user)` ` print(f"User '{user.name}' has been registered.")` ` def remove_user(self, user):` ` if user in self.users:` ` self.users.remove(user)` ` ` ` def librarian_register(self, librarian):` ` self.librarians.append(librarian)` ` print(f"Librarian '{librarian.name}' has been registered.")` ` ` ` def list_books(self):` ` for book in self.books:` ` print(book.info())` ` def list_users(self):` ` for user in self.users:` ` print(user.name , user.email)` `#LOAN` `class Loan:` ` ` ` def __init__(self, id_loan, user, book, date_loan, date_return):` ` self.id_loan = id_loan` ` self.user = user` ` self.book = book` ` self.date_loan = date_loan` ` self.date_return = date_return` ` ` ` def finalize_loan(self)` ` print(f"""Loan with ID {self.id_loan} has been finalized.` ` must be returned by {self.user.name} on {self.date_return}.""")` `#Create a library instance` `my_library = Library()` `#Create some books` `book1 = Book("The Great Gatsby", "F. Scott Fitzgerald", "Paperback", "978-0743273565", 1925)` `book2 = Book("To Kill a Mockingbird", "Harper Lee", "Paperback", "978-0061120084", 1960)` `book3 = Book("1984", "George Orwell", "Paperback", "978-04515249", 1949)` `#Create some Librarians` `librarian1 = Librarian("001", "John Smith")` `librarian2 = Librarian("002", "Jane Doe")` `#Create some Users` `user1 = User("001", "Alice", "[email protected]")` `user2 = User("002", "Bob", "[email protected]")` `#Add books to the library` `my_library.add_book(book1, my_library)` `my_library.add_book(book2, my_library)` `my_library.add_book(book3, my_library)` `my_library.list_books()` `#Register users ` `my_library.user_register(user1)` `my_library.user_register(user2)` `#Register librarians` `my_library.librarian_register(librarian1)` `my_library.librarian_register(librarian2)` `#Loan a book to a user` `user1.loan_book(book1)` `user2.loan_book(book2)`

para el reto lo realice de la siguiente manera: 

resultado 

Aqui esta mi reto, usando las librerias de la clase. class vehicle: def \_\_init\_\_(self, model, brand, price): self.model = model self.brand = brand self.price = price self.available = True # Indica si el vehiculo esta disponible para la venta def sell(self): if self.available: self.available = False print(f"El vehiculo{self.model} ha sido vendido") else: print(f"El vehiculo{self.model} no esta disponible para la venta") def return\_vehicle(self): self.available = True print(f"El vehiculo{self.model} ha sido devuelto y esta disponible para la venta") class customer: def \_\_init\_\_(self, name, customer\_id): self.name = name self.customer\_id = customer\_id self.purchased\_vehicles = \[] def buy\_vehicle(self, vehicle): if vehicle.available: vehicle.sell() self.purchased\_vehicles.append(vehicle) print(f"{self.name} ha comprado el vehiculo{vehicle.model}") else: print(f"El vehiculo{vehicle.model} no esta disponible para la venta") def return\_vehicle(self, vehicle): if vehicle in self.purchased\_vehicles: vehicle.return\_vehicle() self.purchased\_vehicles.remove(vehicle) else: print(f"{self.name} no ha comprado el vehiculo{vehicle.model}") class Dealership: def \_\_init\_\_(self): self.vehicles = \[] self.customers = \[] def add\_vehicle(self, vehicle): self.vehicles.append(vehicle) print(f"El vehiculo{vehicle.model}ha sido agregado a la consesionaria") def register\_customer(self, customer): self.customers.append(customer) print(f"El cliente {customer.name} ha sido registrado en la consesionaria") def show\_available\_vehicles(self): print("Vehiculos disponibles:") for vehicle in self.vehicles: if vehicle.available: print(f"{vehicle.model} - ${vehicle.price}") \#Ejemplo de uso vehicle1 = vehicle(" Model S ", "Tesla", 79999) vehicle2 = vehicle("Mustang", "Ford" , 55999) \#crear cliente customer1 = customer("Ana Judy", "001") \#Crear concesionaria dealership = Dealership() dealership.add\_vehicle(vehicle1) dealership.add\_vehicle(vehicle2) dealership.register\_customer(customer1) \#Mostrar vehiculos disponibles dealership.show\_available\_vehicles() \#Realizar compra customer1.buy\_vehicle(vehicle1) \#Mostrar vehiculos disponibles despues de la compra dealership.show\_available\_vehicles() \#Devolver vehiculo customer1.return\_vehicle(vehicle1) \#Mostrar vehiculos disponibles despues de la devolucion dealership.show\_available\_vehicles()

Les comparto mi codigo referente al ejercicio : ```python class Car: def __init__(self, car_brand:str, car_reference:str, car_registration:str, sale_price:int): self.is_available = True self.car_brand = car_brand self.car_reference = car_reference self.car_registration = car_registration self.sale_price = sale_price def sale(self): if self.is_available: self.is_available = False print(f"El vehiculo {self.car_brand} - {self.car_reference} con matricula: {self.car_registration} ha sido vendido exitosamente") else: print(f"El vehiculo {self.car_brand} - {self.car_reference} con matricula: {self.car_registration} no esta disponible en inventario") class Client: def __init__(self, name:str, dni:str): self.name = name self.dni = dni self.cars = [] def purchase(self, car): if car in self.cars: print(f"El cliente {self.name} ya ha comprado el vehiculo con matricula: {car.car_registration}") elif car.is_available: self.cars.append(car) car.sale() else: car.sale() print("No fue posible realizar la venta del vehiculo, contactese con la sala de ventas") def show_purchased_cars(self): print(f"Vehiculos comprados por {self.name}:") for car in self.cars: print(f" {car.car_brand} - {car.car_reference}, matricula: {car.car_registration}") class Car_dealer: def __init__(self): self.clients = [] self.cars_stock = [] def add_car(self,car): if not any(existing_car.car_registration == car.car_registration for existing_car in self.cars_stock): self.cars_stock.append(car) print(f"El vehiculo {car.car_brand} - {car.car_reference} ha sido registrado.") else: print(f"El usuario {car.car_brand} - {car.car_reference} ya está registrado.") def add_client(self,client): if not any(existing_client.dni == client.dni for existing_client in self.clients): self.clients.append(client) print(f"El usuario {client.name} ha sido registrado.") else: print(f"El usuario {client.name} ya está registrado.") def show_available_cars(self): print(f"Los vehiculos disponibles para la venta son:") for car in self.cars_stock: if car.is_available: print(f" {car.car_brand} - {car.car_reference}, valor: ${car.sale_price:,.0f}, matricula: {car.car_registration}") def show_cars_sold(self): print(f"Los vehiculos vendidos son:") for car in self.cars_stock: if not car.is_available: print(f" {car.car_brand} - {car.car_reference}, matricula: {car.car_registration}") def select_car(self, car_registration:str): return next((car for car in self.cars_stock if car.car_registration == car_registration), None) def select_car_by_brand(self, car_brand:str): return [car.car_reference for car in self.cars_stock if car.car_brand == car_brand and car.is_available] def select_cars_in_price_range(self, min_price:int, max_price:int): return [car.car_reference for car in self.cars_stock if min_price <= car.sale_price <= max_price and car.is_available] ```class Car:    def \_\_init\_\_(self, car\_brand:str, car\_reference:str, car\_registration:str, sale\_price:int):        self.is\_available = True        self.car\_brand = car\_brand        self.car\_reference = car\_reference        self.car\_registration = car\_registration        self.sale\_price = sale\_price     def sale(self):        if self.is\_available:            self.is\_available = False            print(f"El vehiculo {self.car\_brand} - {self.car\_reference} con matricula: {self.car\_registration} ha sido vendido exitosamente")        else:            print(f"El vehiculo {self.car\_brand} - {self.car\_reference} con matricula: {self.car\_registration} no esta disponible en inventario") class Client:    def \_\_init\_\_(self, name:str, dni:str):        self.name = name        self.dni = dni        self.cars = \[]     def purchase(self, car):        if car in self.cars:            print(f"El cliente {self.name} ya ha comprado el vehiculo con matricula: {car.car\_registration}")        elif car.is\_available:            self.cars.append(car)            car.sale()        else:            car.sale()            print("No fue posible realizar la venta del vehiculo, contactese con la sala de ventas")     def show\_purchased\_cars(self):        print(f"Vehiculos comprados por {self.name}:")        for car in self.cars:            print(f"    {car.car\_brand} - {car.car\_reference}, matricula: {car.car\_registration}") class Car\_dealer:    def \_\_init\_\_(self):        self.clients = \[]        self.cars\_stock = \[]     def add\_car(self,car):        if not any(existing\_car.car\_registration == car.car\_registration for existing\_car in self.cars\_stock):            self.cars\_stock.append(car)            print(f"El vehiculo {car.car\_brand} - {car.car\_reference} ha sido registrado.")        else:            print(f"El usuario  {car.car\_brand} - {car.car\_reference}  ya está registrado.")     def add\_client(self,client):        if not any(existing\_client.dni == client.dni for existing\_client in self.clients):            self.clients.append(client)            print(f"El usuario {client.name} ha sido registrado.")        else:            print(f"El usuario {client.name} ya está registrado.")     def show\_available\_cars(self):        print(f"Los vehiculos disponibles para la venta son:")        for car in self.cars\_stock:            if car.is\_available:                print(f"    {car.car\_brand} - {car.car\_reference}, valor: ${car.sale\_price:,.0f}, matricula: {car.car\_registration}")     def show\_cars\_sold(self):        print(f"Los vehiculos vendidos son:")        for car in self.cars\_stock:            if not car.is\_available:                print(f"    {car.car\_brand} - {car.car\_reference}, matricula: {car.car\_registration}")     def select\_car(self, car\_registration:str):        return next((car for car in self.cars\_stock if car.car\_registration == car\_registration), None)        def select\_car\_by\_brand(self, car\_brand:str):        return \[car.car\_reference for car in self.cars\_stock if car.car\_brand == car\_brand and car.is\_available]     def select\_cars\_in\_price\_range(self, min\_price:int, max\_price:int):        return \[car.car\_reference for car in self.cars\_stock if min\_price <= car.sale\_price <= max\_price and car.is\_available]

```js class Carro: def __init__(self, marca, año, precio): self.marca = marca self.año = año self.precio = precio self.disponible = True def vender_carro(self): if self.disponible: self.disponible = False print(f"El carro {self.marca} del año {self.año} por el precio de US {self.precio} ha sido vendido.") else: print(f"El carro {self.marca} no está a la venta.") class Comprador: def __init__(self, nombre, id): self._nombre = nombre self._id = id self._carros_comprados = [] def comprar_auto(self, carro): if carro.disponible: carro.venta_carro() self._carros_comprados.append(carro) else: print(f"El auto {carro.marca} no está a la venta.") @property def nombre(self): return self._nombre @property def id(self): return self._id def agregar_carro(self, carro): self._carros_comprados.append(carro) def mostrar_carros_comprados(self): if self._carros_comprados: print(f"Carros comprados por {self.nombre}:") for carro in self._carros_comprados: print(f"- {carro.marca} del año {carro.año}") else: print(f"{self.nombre} no ha comprado ningún carro.") class Concesionario: def __init__(self): self.carros = [] self.compradores = [] def añadir_carro(self, carro): self.carros.append(carro) print(f"El carro {carro.marca} del añó {carro.año} por el precio de US {carro.precio} ha sido añadido.") def añadir_comprador(self, comprador): self.compradores.append(comprador) print(f"El comprador {comprador._nombre} con el id {comprador._id} ha sido creado.") def vender_carro(self, comprador, carro): if carro in self.carros and carro.disponible: carro.disponible = False comprador.agregar_carro(carro) print(f"El carro {carro.marca} del año {carro.año} ha sido vendido a {comprador.nombre} por US ${carro.precio}.") else: print(f"El carro {carro.marca} no está disponible para la venta.") def mostrar_carros_disponibles(self): print("Carros disponibles:") for carro in self.carros: if carro.disponible: print(f"Marca: {carro.marca}, año: {carro.año}, precio (US): {carro.precio}") #Inventario inicial carros carro1 = Carro("Kia Soluto", 2024, 16000) carro2 = Carro("Fiat Mobi Like", 2024, 14000) carro3 = Carro("Renault Sandero 1.6 Authentique", 2024, 15000) carro4 = Carro("Chevrolet Joy", 2024, 15500) carro5 = Carro("Suzuki Swift 1.2 Dzire", 2024, 16000) carro6 = Carro("Kia Picanto Zenith MEC", 2024, 16000) #Creo el concesionario concesionario = Concesionario() concesionario.añadir_carro(carro1) concesionario.añadir_carro(carro2) concesionario.añadir_carro(carro3) concesionario.añadir_carro(carro4) concesionario.añadir_carro(carro5) concesionario.añadir_carro(carro6) #Creo un comprador comprador1 = Comprador("Carli", "001") concesionario.añadir_comprador(comprador1) #Muestro los autos disponibles concesionario.mostrar_carros_disponibles() #Muestro los autos disponibles despues de la primera venta concesionario.mostrar_carros_disponibles() #Creo un segundo comprador comprador2 = Comprador("Fredhy", "002") concesionario.añadir_comprador(comprador2) #Venta de auto concesionario.vender_carro(comprador1, carro4) concesionario.vender_carro(comprador2, carro4) concesionario.vender_carro(comprador2, carro5) #Muestro los autos disponibles despues de la segunda venta concesionario.mostrar_carros_disponibles() ```

Aquí está el código de mi reto:'''RETO Desarrolla una concesionaria de vehículos en la cual se puedan gestionar las compras y ventas de vehículos.Un usuario podrá ver los vehículos disponibles, su precio y realizar la compra de uno.Aplica los conceptos de programación orientada a objetos vistos en este ejercicio.''' def fill\_with\_blank\_spaces(final\_spaces, filled\_spaces): response = "" for i in range(final\_spaces - filled\_spaces): response += " " return response class Car: def \_\_init\_\_(self, id, brand, model, price): self.id = id self.brand = brand self.model = model self.price = price self.in\_stock = True def sell(self): if self.in\_stock: self.in\_stock = False print("El {} {} con referencia {} ha sido vendido por {}€".format(self.brand, self.model, self.id, self.price)) else: print("El {} {} con referencia {} no está en stock".format()) class User: def \_\_init\_\_(self, id, username): self.id = id self.username = username self.owned\_cars = \[] def buy\_car(self, car): if car.in\_stock: car.sell() self.owned\_cars.append(car) else: print("El vehículo {} {} con referencia {} ya no está en stock".format(car.brand, car.model, car.id)) def show\_owned\_cars(self): print("-----------------------------------------------------------------------") print("El usuario {} posee los siguientes vehículos:".format(self.username)) print("-----------------------------------------------------------------------") for car in self.owned\_cars: print(" - {} {}".format(car.brand, car.model)) print("-----------------------------------------------------------------------") class CarDealership: def \_\_init\_\_(self): self.cars = \[] self.users = \[] def add\_car(self, car): self.cars.append(car) print("El concesionario ha adquirido una nueva unidad de {} {}. Su número de referencia es '{}'".format(car.brand, car.model, car.id)) def add\_user(self, user): self.users.append(user) print("El usuario {} ha sido añadido en el sistema".format(user.username)) def show\_available\_cars(self): column\_spaces = 20 print('''-----------------------------------------------------------------------CATÁLOGO DE VEHÍCULOS-----------------------------------------------------------------------REFERENCIA MARCA MODELO PRECIO''') for car in self.cars: if car.in\_stock: print("{}{}{}{}{}{}{}{}".format( car.id, fill\_with\_blank\_spaces(column\_spaces, len(car.id)), car.brand, fill\_with\_blank\_spaces(column\_spaces, len(car.brand)), car.model, fill\_with\_blank\_spaces(column\_spaces, len(car.model)), car.price, fill\_with\_blank\_spaces(column\_spaces, len(car.price)) )) print('''-----------------------------------------------------------------------''') \# Creación de vehículoscar1 = Car('V001', 'Dacia', 'Sandero', '21000')car2 = Car('V002', 'Hyundai', 'Tucson', '17500')car3 = Car('V003', 'Toyota', 'Corolla', '50000')car4 = Car('V004', 'Kia', 'Sportage', '18000')car5 = Car('V005', 'Toyota', 'Yaris Cross', '25000') \# Creación de usuariosuser1 = User('U001', 'victor.munoz')user2 = User('U002', 'jordi.guillem.fragoso')user3 = User('U003', 'fermin.santin') \# Creación de concesionariocar\_dealership = CarDealership() car\_dealership.add\_car(car1)car\_dealership.add\_car(car2)car\_dealership.add\_car(car3)car\_dealership.add\_car(car4)car\_dealership.add\_car(car5) car\_dealership.add\_user(user1)car\_dealership.add\_user(user2)car\_dealership.add\_user(user3) \# Mostrar vehículoscar\_dealership.show\_available\_cars() \# Compra de Vehiculosuser1.buy\_car(car1)user2.buy\_car(car1)car\_dealership.show\_available\_cars()user2.buy\_car(car3)user2.buy\_car(car2)car\_dealership.show\_available\_cars() car6 = Car('V006', 'SEAT', 'León FR', '27000')car\_dealership.add\_car(car6)car\_dealership.show\_available\_cars() user1.show\_owned\_cars()user2.show\_owned\_cars() ```js ''' RETO Desarrolla una concesionaria de vehículos en la cual se puedan gestionar las compras y ventas de vehículos. Un usuario podrá ver los vehículos disponibles, su precio y realizar la compra de uno. Aplica los conceptos de programación orientada a objetos vistos en este ejercicio. ''' def fill_with_blank_spaces(final_spaces, filled_spaces): response = "" for i in range(final_spaces - filled_spaces): response += " " return response class Car: def __init__(self, id, brand, model, price): self.id = id self.brand = brand self.model = model self.price = price self.in_stock = True def sell(self): if self.in_stock: self.in_stock = False print("El {} {} con referencia {} ha sido vendido por {}€".format(self.brand, self.model, self.id, self.price)) else: print("El {} {} con referencia {} no está en stock".format()) class User: def __init__(self, id, username): self.id = id self.username = username self.owned_cars = [] def buy_car(self, car): if car.in_stock: car.sell() self.owned_cars.append(car) else: print("El vehículo {} {} con referencia {} ya no está en stock".format(car.brand, car.model, car.id)) def show_owned_cars(self): print("-----------------------------------------------------------------------") print("El usuario {} posee los siguientes vehículos:".format(self.username)) print("-----------------------------------------------------------------------") for car in self.owned_cars: print(" - {} {}".format(car.brand, car.model)) print("-----------------------------------------------------------------------") class CarDealership: def __init__(self): self.cars = [] self.users = [] def add_car(self, car): self.cars.append(car) print("El concesionario ha adquirido una nueva unidad de {} {}. Su número de referencia es '{}'".format(car.brand, car.model, car.id)) def add_user(self, user): self.users.append(user) print("El usuario {} ha sido añadido en el sistema".format(user.username)) def show_available_cars(self): column_spaces = 20 print(''' ----------------------------------------------------------------------- CATÁLOGO DE VEHÍCULOS ----------------------------------------------------------------------- REFERENCIA MARCA MODELO PRECIO ''') for car in self.cars: if car.in_stock: print("{}{}{}{}{}{}{}{}".format( car.id, fill_with_blank_spaces(column_spaces, len(car.id)), car.brand, fill_with_blank_spaces(column_spaces, len(car.brand)), car.model, fill_with_blank_spaces(column_spaces, len(car.model)), car.price, fill_with_blank_spaces(column_spaces, len(car.price)) )) print('''----------------------------------------------------------------------- ''') # Creación de vehículos car1 = Car('V001', 'Dacia', 'Sandero', '21000') car2 = Car('V002', 'Hyundai', 'Tucson', '17500') car3 = Car('V003', 'Toyota', 'Corolla', '50000') car4 = Car('V004', 'Kia', 'Sportage', '18000') car5 = Car('V005', 'Toyota', 'Yaris Cross', '25000') # Creación de usuarios user1 = User('U001', 'victor.munoz') user2 = User('U002', 'jordi.guillem.fragoso') user3 = User('U003', 'fermin.santin') # Creación de concesionario car_dealership = CarDealership() car_dealership.add_car(car1) car_dealership.add_car(car2) car_dealership.add_car(car3) car_dealership.add_car(car4) car_dealership.add_car(car5) car_dealership.add_user(user1) car_dealership.add_user(user2) car_dealership.add_user(user3) # Mostrar vehículos car_dealership.show_available_cars() # Compra de Vehiculos user1.buy_car(car1) user2.buy_car(car1) car_dealership.show_available_cars() user2.buy_car(car3) user2.buy_car(car2) car_dealership.show_available_cars() car6 = Car('V006', 'SEAT', 'León FR', '27000') car_dealership.add_car(car6) car_dealership.show_available_cars() user1.show_owned_cars() user2.show_owned_cars() ```

```python class Vehiculo: def __init__(self, marca, modelo, precio): self.marca = marca self.modelo = modelo self.precio = precio self.disponible = True def comprar(self): if self.disponible: self.disponible = False print(f"El vehiculo {self.modelo} ha sido comprado") else: print(f"Vehículo no disponible: Marca {self.marca}, Modelo {self.modelo}") def mostrarInfo(self): if self.disponible: print(f"Vehículo disponible: Marca {self.marca}, Modelo {self.modelo}, Precio ${self.precio}") else: print(f"Vehículo no disponible: Marca {self.marca}, Modelo {self.modelo}") class Usuario: def __init__(self, name, user_id): self.name = name self.user_id = user_id self.vehiculosComprados = [] def comprarVehiculo(self, vehiculo): if vehiculo.disponible: vehiculo.comprar() self.vehiculosComprados.append(vehiculo) else: print(f"El vehiculo {vehiculo.modelo} no esta disponible") class Concecionario: def __init__(self): self.vehiculos = [] self.users = [] def agregarVehiculos(self, vehiculo): self.vehiculos.append(vehiculo) print(f"El vehiculo {vehiculo.marca} {vehiculo.modelo} ha sido agregado") def registrarUsuarios(self, user): self.users.append(user) print(f"El usuario {user.name} ha sido registrado") def mostrarVehiculosDisponibles(self): print(f"Vehiculos disponibles: ") for vehiculo in self.vehiculos: if vehiculo.disponible: print(f"Marca {self.marca}, Modelo {self.modelo}, Precio ${self.precio}") else: print(f"Vehículo no disponible: Marca {self.marca}, Modelo {self.modelo}") #Crear vehiculos carro1 = Vehiculo("Toyota", "Corolla", "9000") carro2 = Vehiculo("corsa", "Chevrolet", "3000") carro3 = Vehiculo("aveo", "Chevrolet", "4500") #Crear usuario usuario1 = Usuario("Chu", "01") usuario2 = Usuario("Sam", "02") usuario3 = Usuario("yari", "03") #Agregar usuario y carro a concecionaria concecionario = Concecionario() concecionario.agregarVehiculos(carro1) concecionario.agregarVehiculos(carro2) concecionario.agregarVehiculos(carro3) concecionario.registrarUsuarios(usuario1) concecionario.registrarUsuarios(usuario2) concecionario.registrarUsuarios(usuario3) #Comprar vehiculo usuario1.comprarVehiculo(carro1) usuario2.comprarVehiculo(carro2) usuario3.comprarVehiculo(carro3) ```

<question> Para entender el uso de `self` como parámetro en las funciones de la clase `Book`, es esencial saber que `self` se refiere a la instancia actual de la clase. Esto permite acceder a las variables y métodos de la clase dentro de sus propias funciones. Al utilizar `self`, se pueden manipular los atributos del objeto directamente, lo que es fundamental en la programación orientada a objetos. Por ejemplo, al prestar o retornar un libro, `self` permite verificar y actualizar el estado de la instancia del libro específico. </question>

Me parece una muy buena clase. Siempre he preferido la programación funcional que la POO, pero la verdad es que nunca nadie me había explicado así la POO.

Hola, este es el ejemplo que realice para la actividad de esta clase: ```js class Car: def __init__(self, model, price): self.model = model self.price = price self.available = True def buy(self): if self.available: self.available = False print(f"\nEl vehículo {self.model} ha sido vendido") else: print(f"\nEl vehículo {self.model} no esta disponible") def sell(self): self.available = True print(f"\nEl vehículo {self.model} ha sido comprado") class User: def __init__(self, name, user_id): self.name = name self.user_id = user_id self.buy_cars = [] def buy_car(self, car): if car.available: car.buy() self.buy_cars.append(car) else: print(f"\nEl vehículo {car.model} no esta disponible") def sell_cars(self, car): if car in self.buy_cars: car.sell() self.buy_cars.remove(car) else: print(f"\nEl vehículo {car.model} no esta en la lista de vendidos") class Library: def __init__(self): self.cars = [] self.users = [] def add_car(self, car): self.cars.append(car) print(f"El vehículo {car.model} ha sido agregado") def register_user(self, user): self.users.append(user) print(f"El usuario {user.name} ha sido registrado") def show_available_cars(self): print("\nVehículos disponibles: ") i = 1 for car in self.cars: if car.available: print(f"{i}- {car.model} con un precio de {car.price} pesos") i = i+1 # Vehículos car1 = Car("Porsche Cayman", "$1,200,000") car2 = Car("Chevrolet Corvette C6", "$600,000") car3 = Car("Ford Mustang GT", "$760,000") # Usuarios user1 = User("Javier", "001") # Crear la biblioteca library = Library() library.add_car(car1) library.add_car(car2) library.add_car(car3) library.register_user(user1) # Mostrar vehículos library.show_available_cars() # Realizar una compra user1.buy_car(car1) # Mostrar vehículos library.show_available_cars() # Realizar una venta user1.sell_cars(car1) # Mostrar vehículos library.show_available_cars() ```

Dejo aporte:   

```python class Vehicle: def __init__(self, brand:str, reference:str, model:str, price:int ): self.brand = brand self.reference = reference self.model = model self.price = price self.available = True def buy(self): if self.available: self.available = False print(f"el vehículo {self.brand}, referencia {self.reference} y modelo {self.model} a sido comprado") else: print(f"el vehículo {self.brand}, referencia {self.reference} y modelo {self.model} no esta disponible") def sell(self): self.available = True print(f"el vhiculo {self.brand}, referencia {self.reference} y modelo {self.model} a sido vendido") class User: def __init__ (self, document:str, name:str, phone:str, address:str): self.document = document self.name = name self.phone = phone self.address = address self.my_vehicles = [] def buy(self, vehicle:Vehicle): if vehicle.available: vehicle.buy() self.my_vehicles.append(vehicle) else: vehicle.buy() def sell(self, vehicle:Vehicle): vehicle.sell() self.my_vehicles.remove(vehicle) class VehicleDealership: def __init__(self): self.available_vehicles = [] self.registered_customers = [] def buy_vehicle(self, vehicle:Vehicle): self.available_vehicles.append(vehicle) print(f"el concesionario compró el vehiculo de marca {vehicle.brand}, referencia {vehicle.reference} y modelo {vehicle.model}") def sell_vehicle(self, vehicle:Vehicle): print(f"el concesionario vendio el vehiculo de marca {vehicle.brand}, referencia {vehicle.reference} y modelo {vehicle.model}") self.available_vehicles.remove(vehicle) def register_user(self, user:User): self.registered_customers.append(user) print(f"cliente {user.name} ha sido registrado!") def show_available_vehicles(self): print("*****Vehiculos disponibles para vender!*****") for vehicle in self.available_vehicles: if vehicle.available: print(f"marca: {vehicle.brand}, referencia: {vehicle.reference}, modelo: {vehicle.model}, precio: {vehicle.price}" ) ```class Vehicle:    def \_\_init\_\_(self, brand:str, reference:str, model:str, price:int ):        self.brand = brand        self.reference = reference        self.model = model        self.price = price        self.available = True     def buy(self):        if self.available:            self.available = False            print(f"el vehículo {self.brand}, referencia {self.reference} y modelo {self.model} a sido comprado")        else:            print(f"el vehículo {self.brand}, referencia {self.reference} y modelo {self.model} no esta disponible")     def sell(self):        self.available = True        print(f"el vhiculo {self.brand}, referencia {self.reference} y modelo {self.model} a sido vendido")    class User:    def \_\_init\_\_ (self, document:str, name:str, phone:str, address:str):        self.document = document        self.name = name        self.phone = phone        self.address = address        self.my\_vehicles = \[]     def buy(self, vehicle:Vehicle):        if vehicle.available:            vehicle.buy()            self.my\_vehicles.append(vehicle)        else:            vehicle.buy()     def sell(self, vehicle:Vehicle):        vehicle.sell()        self.my\_vehicles.remove(vehicle) class VehicleDealership:    def \_\_init\_\_(self):        self.available\_vehicles = \[]        self.registered\_customers = \[]     def buy\_vehicle(self, vehicle:Vehicle):        self.available\_vehicles.append(vehicle)        print(f"el concesionario compró el vehiculo de marca {vehicle.brand}, referencia {vehicle.reference} y modelo {vehicle.model}")     def sell\_vehicle(self, vehicle:Vehicle):        print(f"el concesionario vendio el vehiculo de marca {vehicle.brand}, referencia {vehicle.reference} y modelo {vehicle.model}")        self.available\_vehicles.remove(vehicle)     def register\_user(self, user:User):        self.registered\_customers.append(user)        print(f"cliente {user.name} ha sido registrado!")     def show\_available\_vehicles(self):        print("\*\*\*\*\*Vehiculos disponibles para vender!\*\*\*\*\*")        for vehicle in self.available\_vehicles:             if vehicle.available:                 print(f"marca: {vehicle.brand}, referencia: {vehicle.reference}, modelo: {vehicle.model}, precio: {vehicle.price}" )

Ejercicio de concesionario de vehículos: class Vehiculo:    def \_\_init\_\_(self,referencia,marca,año,color,valor):        self.referencia = referencia        self.marca = marca        self.año = año        self.color = color        self.valor = valor        self.disponible = True     #acciones de tipo comercial que se pueden hacer con los vehículos    def vender(self):        if self.disponible:            self.disponible = False            print(" ")            print(f"Saliendo vehículo {self.referencia}, ha sido vendido.")            print(" ")        else:            print(f"El vehículo {self.referencia} no está disponible.")     def comprar(self):        self.disponible = True        print(" ")        print(f"Ingresando vehículo {self.referencia},  se encuentra disponible para la venta.")         print(" ") class Cliente:    def \_\_init\_\_(self,nombre,userid):        self.nombre = nombre        self.userid = userid        self.vehiculoscomprados = \[]     #acciones de tipo comercial que puede realizar un cliente    def comprarVehiculo(self,vehiculo):        if vehiculo.disponible:            vehiculo.vender()            self.vehiculoscomprados.append(vehiculo)        else:            print(f"El vehículo {self.referencia} no está disponible.")                             def venderVehiculo(self,vehiculo):        if vehiculo in self.vehiculoscomprados:            vehiculo.comprar()             self.vehiculoscomprados.remove(vehiculo)               else:            print(f"El vehículo {vehiculo.referencia} no está en la lista de comprados")     def mostrarvehiculosporcliente(self,cliente):        print(f"Vehículos del cliente: {cliente.nombre}")        for vehiculo in self.vehiculoscomprados:            print(f"{vehiculo.referencia} por {vehiculo.marca}")         print(" ")                             class Concesionario:    print(" ")    print("\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*")    print("BIENVENIDOS AL CONCESIONARIO DE CARLOS NOVOA")    print("\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*")    print(" ")    def \_\_init\_\_(self):        self.vehiculos = \[]        self.clientes = \[]     def registrarvehiculo(self,vehiculo):        self.vehiculos.append(vehiculo)        print(f"El vehículo {vehiculo.referencia} ha sido ingresado al stock de vehículos del concesionario.")     def registrarcliente(self,cliente):        self.clientes.append(cliente)        print(f"El cliente {cliente.nombre} ha sido registrado.")     def mostrarvehiculosdisponibles(self):        print("Los vehículos disponibles en el concesionario son:")        for vehiculo in self.vehiculos:            if vehiculo.disponible:                print(f"{vehiculo.referencia} valor {vehiculo.valor}")         print(" ")                 \#crear vehículosvehiculo1 = Vehiculo("Corsa","CHEVROLET","2002","gris plata","6000000")vehiculo2 = Vehiculo("Renault","LOGAN","2008","negro","15000000")vehiculo3 = Vehiculo("Cerato forte","KIA","2012","gris","32000000")vehiculo4 = Vehiculo("Cerato pro","KIA","2018","vino tinto","63000000") \#crear clientecliente1 = Cliente("Roko","80491515")cliente2 = Cliente("NN","52703781") \#crear concesionarioconcesionario1 = Concesionario() \#ingresar vehículosprint("Ingreso de vehículos a concesionario")concesionario1.registrarvehiculo(vehiculo1)concesionario1.registrarvehiculo(vehiculo2)concesionario1.registrarvehiculo(vehiculo3)concesionario1.registrarvehiculo(vehiculo4)print(" ")#ingresar clientesprint("Registro de clientes")concesionario1.registrarcliente(cliente1)concesionario1.registrarcliente(cliente2)print(" ")#mostrar vehículosconcesionario1.mostrarvehiculosdisponibles() \#vehiculos clientecliente1.mostrarvehiculosporcliente(cliente1) \#realizar compracliente1.comprarVehiculo(vehiculo1) \#vehiculos clientecliente1.mostrarvehiculosporcliente(cliente1) \#mostrar vehículosconcesionario1.mostrarvehiculosdisponibles() \#realizar ventacliente1.venderVehiculo(vehiculo1) \#mostrar vehículosconcesionario1.mostrarvehiculosdisponibles() \#vehiculos clientecliente1.mostrarvehiculosporcliente(cliente1) \#realizar compracliente2.comprarVehiculo(vehiculo2) \#realizar compracliente1.comprarVehiculo(vehiculo3) \#mostrar vehículosconcesionario1.mostrarvehiculosdisponibles() \#vehiculos clientecliente1.mostrarvehiculosporcliente(cliente1)cliente2.mostrarvehiculosporcliente(cliente2) \#realizar compracliente1.comprarVehiculo(vehiculo4) \#vehiculos clientecliente1.mostrarvehiculosporcliente(cliente1)                    \#realizar compracliente2.comprarVehiculo(vehiculo1) \#vehiculos clientecliente2.mostrarvehiculosporcliente(cliente2) \#mostrar vehículos                concesionario1.mostrarvehiculosdisponibles()

Mi aporte al ejercicio de la clase ```python ```

```python class auto: def __init__ (self, modelo, precio): self.modelo=modelo self.precio=precio self.disponible=True def vendido(self): self.disponible=False print(f"el auto {self.modelo} no esta disponible para la venta") def venta(self): self.disponible=True print(f"el auto {self.modelo} se encuenta disponible para la venta y su precio es de {self.precio}$") class comprador: def __init__(self, presupuesto): self.presupuesto=presupuesto def comprar(self, auto): if auto.disponible and self.presupuesto >= auto.precio: print(f"el comprador ha adquirido el auto {auto.modelo} por un precio de {auto.precio}$") else: print("no puedes comprar este vehivulo") class consesionario: def __init__(self): self.autos=[] def autos_disponibles(self, auto): self.autos.append(auto.modelo) if auto.modelo in self.autos: print(f"el auto {auto.modelo} esta a la venta") print(self.autos) def vendidos(self, auto, comprador): if comprador.presupuesto >= auto.precio and auto.modelo in self.autos: auto.vendido() self.autos.remove(auto.modelo) print(self.autos) ```class auto:    def \_\_init\_\_ (self, modelo, precio):        self.modelo=modelo        self.precio=precio        self.disponible=True    def vendido(self):        self.disponible=False        print(f"el auto {self.modelo} no esta disponible para la venta")    def venta(self):        self.disponible=True        print(f"el auto {self.modelo} se encuenta disponible para la venta y su precio es de {self.precio}$") class comprador:    def \_\_init\_\_(self, presupuesto):        self.presupuesto=presupuesto     def comprar(self, auto):        if auto.disponible and self.presupuesto >= auto.precio:            print(f"el comprador ha adquirido el auto {auto.modelo} por un precio de {auto.precio}$")        else:            print("no puedes comprar este vehivulo") class consesionario:    def \_\_init\_\_(self):        self.autos=\[]    def autos\_disponibles(self, auto):        self.autos.append(auto.modelo)        if auto.modelo in self.autos:            print(f"el auto {auto.modelo} esta a la venta")            print(self.autos)    def vendidos(self, auto, comprador):        if comprador.presupuesto >= auto.precio and auto.modelo in self.autos:            auto.vendido()            self.autos.remove(auto.modelo)            print(self.autos)

hola, muy buenas a todos. he escrito mi código pero no puedo verificar si funciona o no. al momento de ejecutarlo no muestra el nombre de mis argumentos si no su posición en memoria, no se porque pasa esto ni estoy seguro de como arreglarlo y que el código funcione al mismo tiempo, espero que alguien pueda ayudarme con este problema

`    ````python class Car: def __init__(self, model, price): self.model = model self.price = price self.available = True #se vende un carro a un cliente def sell(self): self.available = False print(f"El vehículo {self.model} ha sido vendido") #se compra un carro para el stock def buy(self): self.available = True print(f"El vehículo {self.model} se encuentra en stock") class Customer: def __init__(self, name, customer_num): self.name = name self.customer_num = customer_num self.sold_cars = [] #lista de carros vendidos self.bought_cars = [] #lista de carros comprados #se le vende un carro al cliente def sell_car(self, car): if car.available: car.sell() self.sold_cars.append(car) else: print(f"El vehículo {self.model} no está en stock") # se le compra un carro a un cliente def buy_car(self, car): if car.available: car.buy() self.bought_cars.append(car) #print(f"El vehículo {self.model} ya está en stock") # else: class Dealer: def __init__(self): self.cars = [] self.customers = [] def add_car(self, car): self.cars.append(car) print(f"El vehículo {car.model} ha sido agragado") def register_customer(self, customer): self.customers.append(customer) print(f"cliente {customer.name} ha sido registrado") def show_available_cars(self): print ("Vehiculos disponibles:") for car in self.cars: if car.available: print(f"El vehículo {car.model} tiene un precio de: {car.price}") #Crear vehículos car1 = Car("CRV", 310.000) car2 = Car("Versa", 150.000) car3 = Car("Tiguan", 450.000) #crear clientes customer1 = Customer("Anel", "001") customer2 = Customer("Carol", "002") #crear inventario del concesionario dealer = Dealer() dealer.add_car(car1) dealer.add_car(car2) dealer.register_customer(customer1) dealer.register_customer(customer2) #mostrar vehículos dealer.show_available_cars() #realizar venta customer1.sell_car(car1) customer2.sell_car(car2) #mostrar vehículos dealer.show_available_cars() #comprar vehículo customer1.buy_car(car3) #mostrar vehículos dealer.show_available_cars() ```

Aporte de conceptos en mis palabras: **Variable**: Una caja o espacio en memoria para almacenar datos de distintos tipos (números, texto, etc.). **Función**: Porción de código reutilizable que puede recibir **parámetros,** realizar acciones y/o devolver un valor. **Clase**: Plantilla que define las características (atributos) y comportamientos (métodos) que tendrán los objetos. **Objeto**: I**nstancia de una clase**, es decir, una manifestación concreta de esa plantilla **Método**: Función que pertenece a un objeto y puede acceder a sus atributos y otros métodos **Parámetro**: Variables definidas en una función o método, que se usa para recibir valores al ser llamada. **Atributo**: Es una variable que pertenece a un objeto, y almacena datos específicos de ese objeto. `__init__`: Es el **método constructor** que inicializa un nuevo objeto, asignando valores a sus atributos. `self`: Es la referencia al objeto actual que está siendo manipulado o creado.

Hola. Sé que el atributo de vender según el enunciado es que sea de la concecionaria, pero también le agregué este aributo al cliente, sólo porque pienso que de manera intuitiva cliente es quien compra. funciona igual, aunque para efectos prácticos en un caso real sólo uno de ellos tendría este atributo: ```js #CONCESIONARIA #Desarrolla una concesionaria de vehículos en la cual se puedan gestionar las compras y ventas de vehículos. #Un usuario podrá ver los vehículos disponibles, su precio y realizar la compra de uno. #Aplica los conceptos de programación orientada a objetos vistos en este ejercicio. class Car: def __init__(self, model, value): self.model = model self.value = value self.available = True class Dealer: def __init__(self): self.inventory = [] def buy_car(self,Car): self.inventory.append(Car) print(f"La compra ha sido un éxito. El auto {Car.model} ha sido aregado al inventario") def sells_car(self, Car, Customer): if Car.available: self.inventory.remove(Car) print(f"El auto {Car.model} ha sido vendido a {Customer}") else: print("El auto no está disponible.") class Customer: def __init__(self, name): self.name = name def customer_buys(self, name, Car): self.Car = Car self.name = name if Car.available: dealership.inventory.remove(Car) print(f"El auto {Car.model} ha sido vendido a {client.name}") Car.available = False else: print("Auto fuera de Stock") def inquiry_inventory(self, Client): self.Client = Client print("Autos disponibles:") for car in dealership.inventory: if car.available: print(f"{car.model} - Costo: {car.value}") #Creando autos Car1 = Car("Toyota Corolla", 55000) Car2 = Car("Honda Civic", 45000) Car3 = Car("Chevrolet Impala", 55000) #Creando Concecionaria dealership = Dealer() #Creando cliente Cristian = ("Cristian") Anthony = ("Anthony") client = Customer(Cristian) client = Customer(Anthony) client.inquiry_inventory(client) #Concesionario comprando auto: dealership.buy_car(Car1) dealership.buy_car(Car2) dealership.buy_car(Car3) #Cristian pregunta por stock client.inquiry_inventory(client) #Cristian compra un auto client.customer_buys(Cristian, Car1) #dealership.sell_car(Customer) #Anthony pregunta por stock client.inquiry_inventory(client) #Anthony compra un auto client.customer_buys(Anthony, Car2) #Anthony quiere comprar otro auto igual client.customer_buys(Anthony, Car2) #Cnosulta de stock: client.inquiry_inventory(client) #Concecionaria vende auto dealership.sells_car(Car3, Anthony) client.inquiry_inventory(client) ```

```js class Vehiculo(): def __init__(self, marca, modelo, color, precio): self.marca = marca self.modelo = modelo self.color = color self.precio = precio self.is_available = True def venta(self): if self.is_available: self.is_available = False print(f"Se ha vendido de manera exitosa el {self.marca} {self.modelo} {self.color} a un precio de {self.precio}") else: print(f"No tenemos en inventario el vehiculo {self.marca} {self.modelo} color {self.color}") def compra(self): self.is_available = True print(f"El vehículo {self.marca} {self.modelo} {self.color} ha sido comprado por un valor de {self.precio}") class Cliente(): def __init__(self, name, client_id): self.name = name self.client_id = client_id self.comprados = [] def vehiculos_comprados(self, vehiculo): if vehiculo.is_available: vehiculo.venta() self.comprados.append(vehiculo) else: print(f"El vehículo {vehiculo.marca} {vehiculo.modelo} no se encuentra disponible") def vender_vehiculo(self, vehiculo): if vehiculo in self.comprados: vehiculo.compra() self.comprados.remove(vehiculo) else: print(f"El cliente no posee el vehículo {vehiculo.marca} {vehiculo.modelo}") class Concesionario(): def __init__(self): self.vehiculos = [] self.clientes = [] def agregar_vehiculo(self, vehiculo): self.vehiculos.append(vehiculo) print(f"El vehículo {vehiculo.marca} {vehiculo.modelo} {vehiculo.color} ha sido agregado al inventario del concesionario") def comprar_vehiculo(self, vehiculo): if vehiculo in self.vehiculos and not vehiculo.is_available: vehiculo.compra() else: print(f"El vehículo {vehiculo.marca} {vehiculo.modelo} no está disponible para compra") def registrar_cliente(self, cliente): self.clientes.append(cliente) print(f"El cliente {cliente.name} ha sido registrado exitosamente") def mostrar_vehiculos_disponibles(self): print("Vehículos disponibles en el concesionario:") for vehiculo in self.vehiculos: if vehiculo.is_available: print(f"{vehiculo.marca} {vehiculo.modelo} {vehiculo.color} - Precio: {vehiculo.precio}") # Crear los objetos vehiculo1 = Vehiculo("Mazda", "CX5", "Blanco Perlado", "165.000.000 COP") vehiculo2 = Vehiculo("Mazda", "CX3", "Rojo Especial", "135.000.000 COP") vehiculo3 = Vehiculo("Mazda", "CX7", "Azul Perlado", "155.000.000 COP") vehiculo4 = Vehiculo("Mazda", "3", "Gris Espacial", "145.000.000 COP") cliente1 = Cliente("Edgar Rojas", "2.000.009.495") cliente2 = Cliente("Andrés Góngora", "79.755.067") # Crear el objeto de la clase Concesionario concesionario = Concesionario() concesionario.agregar_vehiculo(vehiculo1) concesionario.agregar_vehiculo(vehiculo2) concesionario.agregar_vehiculo(vehiculo3) concesionario.agregar_vehiculo(vehiculo4) concesionario.registrar_cliente(cliente1) concesionario.registrar_cliente(cliente2) # Mostrar vehículos disponibles concesionario.mostrar_vehiculos_disponibles() # Registrar compra de vehículo cliente1.vehiculos_comprados(vehiculo1) # Mostrar vehículos disponibles nuevamente concesionario.mostrar_vehiculos_disponibles() # Concesionario compra de nuevo el vehículo vendido por el cliente concesionario.comprar_vehiculo(vehiculo1) # Mostrar vehículos disponibles después de la compra concesionario.mostrar_vehiculos_disponibles() ```class Vehiculo(): def \_\_init\_\_(self, marca, modelo, color, precio): self.marca = marca self.modelo = modelo self.color = color self.precio = precio self.is\_available = True def venta(self): if self.is\_available: self.is\_available = False print(f"Se ha vendido de manera exitosa el {self.marca} {self.modelo} {self.color} a un precio de {self.precio}") else: print(f"No tenemos en inventario el vehiculo {self.marca} {self.modelo} color {self.color}") def compra(self): self.is\_available = True print(f"El vehículo {self.marca} {self.modelo} {self.color} ha sido comprado por un valor de {self.precio}") class Cliente(): def \_\_init\_\_(self, name, client\_id): self.name = name self.client\_id = client\_id self.comprados = \[] def vehiculos\_comprados(self, vehiculo): if vehiculo.is\_available: vehiculo.venta() self.comprados.append(vehiculo) else: print(f"El vehículo {vehiculo.marca} {vehiculo.modelo} no se encuentra disponible") def vender\_vehiculo(self, vehiculo): if vehiculo in self.comprados: vehiculo.compra() self.comprados.remove(vehiculo) else: print(f"El cliente no posee el vehículo {vehiculo.marca} {vehiculo.modelo}") class Concesionario(): def \_\_init\_\_(self): self.vehiculos = \[] self.clientes = \[] def agregar\_vehiculo(self, vehiculo): self.vehiculos.append(vehiculo) print(f"El vehículo {vehiculo.marca} {vehiculo.modelo} {vehiculo.color} ha sido agregado al inventario del concesionario") def comprar\_vehiculo(self, vehiculo): if vehiculo in self.vehiculos and not vehiculo.is\_available: vehiculo.compra() else: print(f"El vehículo {vehiculo.marca} {vehiculo.modelo} no está disponible para compra") def registrar\_cliente(self, cliente): self.clientes.append(cliente) print(f"El cliente {cliente.name} ha sido registrado exitosamente") def mostrar\_vehiculos\_disponibles(self): print("Vehículos disponibles en el concesionario:") for vehiculo in self.vehiculos: if vehiculo.is\_available: print(f"{vehiculo.marca} {vehiculo.modelo} {vehiculo.color} - Precio: {vehiculo.precio}") \# Crear los objetosvehiculo1 = Vehiculo("Mazda", "CX5", "Blanco Perlado", "165.000.000 COP")vehiculo2 = Vehiculo("Mazda", "CX3", "Rojo Especial", "135.000.000 COP")vehiculo3 = Vehiculo("Mazda", "CX7", "Azul Perlado", "155.000.000 COP")vehiculo4 = Vehiculo("Mazda", "3", "Gris Espacial", "145.000.000 COP") cliente1 = Cliente("Edgar Rojas", "2.000.009.495")cliente2 = Cliente("Andrés Góngora", "79.755.067") \# Crear el objeto de la clase Concesionarioconcesionario = Concesionario()concesionario.agregar\_vehiculo(vehiculo1)concesionario.agregar\_vehiculo(vehiculo2)concesionario.agregar\_vehiculo(vehiculo3)concesionario.agregar\_vehiculo(vehiculo4)concesionario.registrar\_cliente(cliente1)concesionario.registrar\_cliente(cliente2) \# Mostrar vehículos disponiblesconcesionario.mostrar\_vehiculos\_disponibles() \# Registrar compra de vehículocliente1.vehiculos\_comprados(vehiculo1) \# Mostrar vehículos disponibles nuevamenteconcesionario.mostrar\_vehiculos\_disponibles() \# Concesionario compra de nuevo el vehículo vendido por el clienteconcesionario.comprar\_vehiculo(vehiculo1) \# Mostrar vehículos disponibles después de la compraconcesionario.mostrar\_vehiculos\_disponibles()

class Vehiculo(): def \_\_init\_\_(self, marca, modelo, color, precio): self.marca = marca self.modelo = modelo self.color = color self.precio = precio self.is\_available = True def venta(self): if self.is\_available: self.is\_available = False print(f"Se ha vendido de manera exitosa el {self.marca} {self.modelo} {self.color} a un precio de {self.precio}") else: print(f"No tenemos en inventario el vehiculo {self.marca} {self.modelo} color {self.color}") def compra(self): self.is\_available = True print(f"El vehículo {self.marca} {self.modelo} {self.color} ha sido comprado por un valor de {self.precio}") class Cliente(): def \_\_init\_\_(self, name, client\_id): self.name = name self.client\_id = client\_id self.comprados = \[] def vehiculos\_comprados(self, vehiculo): if vehiculo.is\_available: vehiculo.venta() self.comprados.append(vehiculo) else: print(f"El vehículo {vehiculo.marca} {vehiculo.modelo} no se encuentra disponible") def vender\_vehiculo(self, vehiculo): if vehiculo in self.comprados: vehiculo.compra() self.comprados.remove(vehiculo) else: print(f"El cliente no posee el vehículo {vehiculo.marca} {vehiculo.modelo}") class Concesionario(): def \_\_init\_\_(self): self.vehiculos = \[] self.clientes = \[] def agregar\_vehiculo(self, vehiculo): self.vehiculos.append(vehiculo) print(f"El vehículo {vehiculo.marca} {vehiculo.modelo} {vehiculo.color} ha sido agregado al inventario del concesionario") def comprar\_vehiculo(self, vehiculo): if vehiculo in self.vehiculos and not vehiculo.is\_available: vehiculo.compra() else: print(f"El vehículo {vehiculo.marca} {vehiculo.modelo} no está disponible para compra") def registrar\_cliente(self, cliente): self.clientes.append(cliente) print(f"El cliente {cliente.name} ha sido registrado exitosamente") def mostrar\_vehiculos\_disponibles(self): print("Vehículos disponibles en el concesionario:") for vehiculo in self.vehiculos: if vehiculo.is\_available: print(f"{vehiculo.marca} {vehiculo.modelo} {vehiculo.color} - Precio: {vehiculo.precio}") \# Crear los objetos vehiculo1 = Vehiculo("Mazda", "CX5", "Blanco Perlado", "165.000.000 COP") vehiculo2 = Vehiculo("Mazda", "CX3", "Rojo Especial", "135.000.000 COP") vehiculo3 = Vehiculo("Mazda", "CX7", "Azul Perlado", "155.000.000 COP") vehiculo4 = Vehiculo("Mazda", "3", "Gris Espacial", "145.000.000 COP") cliente1 = Cliente("Edgar Rojas", "2.000.009.495") cliente2 = Cliente("Andrés Góngora", "79.755.067") \# Crear el objeto de la clase Concesionario concesionario = Concesionario() concesionario.agregar\_vehiculo(vehiculo1) concesionario.agregar\_vehiculo(vehiculo2) concesionario.agregar\_vehiculo(vehiculo3) concesionario.agregar\_vehiculo(vehiculo4) concesionario.registrar\_cliente(cliente1) concesionario.registrar\_cliente(cliente2) \# Mostrar vehículos disponibles concesionario.mostrar\_vehiculos\_disponibles() \# Registrar compra de vehículo cliente1.vehiculos\_comprados(vehiculo1) \# Mostrar vehículos disponibles nuevamente concesionario.mostrar\_vehiculos\_disponibles() \# Concesionario compra de nuevo el vehículo vendido por el cliente concesionario.comprar\_vehiculo(vehiculo1) \# Mostrar vehículos disponibles después de la compra concesionario.mostrar\_vehiculos\_disponibles()

```js class Car: def __init__(self, brand, model, prize): self.brand = brand self.model = model self.prize = prize self.available = True def buy(self): if self.available: self.available = False print(f"El carro {self.brand} modelo {self.model} ha sido comprado") else: print(f"el carro {self.brand} no está disponible") def sell(self): self.available = True print(f"El carro {self.brand} se ha vendido por un costo de {self.prize}") class Customer: def __init__(self, name, budget): self.name = name self.budget = budget self.bought_cars = [] def buy_car(self, car): if car.available: if self.budget >= car.prize: car.buy() self.bought_cars.append(car) elif self.budget < car.prize: print(f"Lo sentimos, no tienes el dinero suficiente para comprar el carro {car.brand}, modelo {car.model}") else: print(f"el carro {car.brand}, modelo {car.model} no está dispobible") def sell_car(self, car): if car in self.bought_cars: car.sell() self.bought_cars.remove(car) else: print(f"No tienes en tu poder el carro {car.brand} modelo {car.model}") class CarShop: def __init__(self): self.cars = [] self.customers = [] def add_car(self, car): self.cars.append(car) print(f"El carro {car.brand}, modelo {car.model} ha sido agregado") def add_customer(self, customer): self.customers.append(customer) print(f"La persona {customer.name}, ahora es nuestro cliente") def show_cars(self): print("Los carros en nuestro consecionario son:") for car in self.cars: if car.available: print(f"Los carros disponibles son {car.brand} modelo {car.model}") car1 = Car("Mazda 3", "2020", 70000000) car2 = Car("Chevrolet aveo", "2010", 12000000) car3 = Car("Hyunday i35", "2012", 20000000) customer1 = Customer("Brahjan Sanchez", 25000000) customer2 = Customer("Sarita Benavides", 1000000000) car_shop = CarShop() car_shop.add_car(car1) car_shop.add_car(car2) car_shop.add_car(car3) car_shop.add_customer(customer1) car_shop.add_customer(customer2) car_shop.show_cars() customer1.buy_car(car2) customer2.buy_car(car2) customer1.sell_car(car3) customer1.sell_car(car2) ```class Car:    def \_\_init\_\_(self, brand, model, prize):        self.brand = brand        self.model = model        self.prize = prize        self.available = True        def buy(self):        if self.available:            self.available = False            print(f"El carro {self.brand} modelo {self.model} ha sido comprado")        else:            print(f"el carro {self.brand} no está disponible")        def sell(self):        self.available = True         print(f"El carro {self.brand} se ha vendido por un costo de {self.prize}") class Customer:    def \_\_init\_\_(self, name, budget):        self.name = name         self.budget = budget        self.bought\_cars = \[]     def buy\_car(self, car):        if car.available:            if self.budget >= car.prize:                car.buy()                self.bought\_cars.append(car)            elif self.budget < car.prize:                print(f"Lo sentimos, no tienes el dinero suficiente para comprar el carro {car.brand}, modelo {car.model}")        else:            print(f"el carro {car.brand}, modelo {car.model} no está dispobible")        def sell\_car(self, car):        if car in self.bought\_cars:            car.sell()            self.bought\_cars.remove(car)         else:            print(f"No tienes en tu poder el carro {car.brand} modelo {car.model}") class CarShop:    def \_\_init\_\_(self):        self.cars = \[]        self.customers = \[]        def add\_car(self, car):        self.cars.append(car)        print(f"El carro {car.brand}, modelo {car.model} ha sido agregado")        def add\_customer(self, customer):        self.customers.append(customer)        print(f"La persona {customer.name}, ahora es nuestro cliente")        def show\_cars(self):        print("Los carros en nuestro consecionario son:")        for car in self.cars:            if car.available:                print(f"Los carros disponibles son {car.brand} modelo {car.model}") car1 = Car("Mazda 3", "2020", 70000000)car2 = Car("Chevrolet aveo", "2010", 12000000)car3 = Car("Hyunday i35", "2012", 20000000) customer1 = Customer("Brahjan Sanchez", 25000000)customer2 = Customer("Sarita Benavides", 1000000000) car\_shop = CarShop() car\_shop.add\_car(car1)car\_shop.add\_car(car2)car\_shop.add\_car(car3) car\_shop.add\_customer(customer1)car\_shop.add\_customer(customer2) car\_shop.show\_cars() customer1.buy\_car(car2)customer2.buy\_car(car2)customer1.sell\_car(car3)customer1.sell\_car(car2)

\#Ejercicio concesionario class Vehiculo:    def \_\_init\_\_(self, modelo, precio):        self.modelo = modelo        self.precio = precio        self.disponible = True     def vender(self):        if self.disponible:            self.disponible = False            print(f"El vehículo {self.modelo} ha sido vendido.")        else:            print(f"El vehículo {self.modelo} no está disponible.")     def retornar\_disponible(self):        self.disponible = True        print(f"El vehículo {self.modelo} está disponible para la venta nuevamente.") class Cliente:    def \_\_init\_\_(self, nombre, id\_cliente):        self.nombre = nombre        self.id\_cliente = id\_cliente        self.vehiculos\_comprados = \[]     def comprar\_vehiculo(self, vehiculo):        if vehiculo.disponible:            vehiculo.vender()            self.vehiculos\_comprados.append(vehiculo)        else:            print(f"El vehículo {vehiculo.modelo} no está disponible.")     def devolver\_vehiculo(self, vehiculo, concesionario):        if vehiculo in self.vehiculos\_comprados:            vehiculo.retornar\_disponible()            self.vehiculos\_comprados.remove(vehiculo)            concesionario.agregar\_vehiculo(vehiculo)        else:            print(f"El vehículo {vehiculo.modelo} no está en la lista de comprados.") class Concesionario:    def \_\_init\_\_(self):        self.vehiculos = \[]        self.clientes = \[]     def agregar\_vehiculo(self, vehiculo):        self.vehiculos.append(vehiculo)        print(f"El vehículo {vehiculo.modelo} ha sido agregado al inventario.")     def registrar\_cliente(self, cliente):        self.clientes.append(cliente)        print(f"El cliente {cliente.nombre} ha sido registrado.")     def mostrar\_vehiculos\_disponibles(self):        print("Vehículos disponibles:")        for vehiculo in self.vehiculos:            if vehiculo.disponible:                print(f"{vehiculo.modelo} por ${vehiculo.precio}") \# Crear los vehículosvehiculo1 = Vehiculo("Kia", 35999999)vehiculo2 = Vehiculo("Mazda", 52900000) \# Crear clientecliente1 = Cliente("Camilo Gutierrez", "001") \# Crear concesionarioconcesionario = Concesionario()concesionario.agregar\_vehiculo(vehiculo1)concesionario.agregar\_vehiculo(vehiculo2)concesionario.registrar\_cliente(cliente1) \# Mostrar vehículos disponiblesconcesionario.mostrar\_vehiculos\_disponibles() \# Realizar compracliente1.comprar\_vehiculo(vehiculo1) \# Mostrar vehículos disponiblesconcesionario.mostrar\_vehiculos\_disponibles() \# Devolver vehículocliente1.devolver\_vehiculo(vehiculo1, concesionario) \# Mostrar vehículos disponiblesconcesionario.mostrar\_vehiculos\_disponibles()

```js class Vehicle: def __init__(self, trademark, color = "Blanco", model = "" , price=""): self.trademark = trademark self.color = color self.model = model self.price = price self.available_for_sale = True self.available_for_buy = True #Ahora que puedo hacer con esos vehículos def sell(self): if self.available_for_sale: self.available_for_sale = False print(f"Venta del vehículo {self.trademark}, color {self.color}, modelo {self.model}, ha sido aprobada por ${self.price} COP") else: print("Vehíclo NO disponible, ya ha sido vendido") def buy(self): if self.available_for_buy: self.available_for_buy = False print(f"Compra del vehículo {self.trademark}, color {self.color}, modelo {self.model}, ha sido aprobada por ${self.price} COP") else: print("Vehíclo ya fue comprado por el concesionario") class Customer: def __init__(self, name, payment_method): self.name = name self.payment_method = payment_method self.bought_vehicules = [] self.sold_vehicle = [] def buy_vehicle(self, vehicle): if vehicle.available_for_sale: vehicle.sell() self.bought_vehicules.append(vehicle) else: print("El vehíclo ya no está disponible") def sell_vehicle(self, vehicle): if vehicle.available_for_buy: vehicle.buy() self.sold_vehicle.append(vehicle) else: print("El vehícul ya fue comprado por el concesionario") class Dealer_ship: def __init__(self): self.vehicles = [] self.customers = [] def add_vehicle(self, vehicle): self.vehicles.append(vehicle) print(f"El vehículo {vehicle.trademark} {vehicle.color} {vehicle.model}, ha sido agregado con éxito al concesionario") def register_customer(self, customer): self.customers.append(customer) print(f"El cliente {customer.name} ha sido registrado con éxtio") def show_avaible_vehicles(self, customer): print(f"Los vehículos disponibles son: ") for vehicle in self.vehicles: if vehicle.available_for_sale: print(f"{vehicle.trademark} modelo {vehicle.model} color {vehicle.color} por un valor de ${vehicle.price} COP") for vehicle in customer.sold_vehicle: print(f"{vehicle.trademark} modelo {vehicle.model} color {vehicle.color} por un valor de ${vehicle.price} COP") #crear los objetos clase vehículo vehicle1 = Vehicle("Mazda 2", "Rojo", "2022", "40.000.000") vehicle2 = Vehicle("Mazda 3", "Negro", "2024", "50.000.000") vehicle3 = Vehicle("Chevrolet Sonic", model ="2019", price= "44.000.000") vehicle4 = Vehicle("Ford fiesta", "Gris", "2023", "38.000.000") #crear los objetos clase cliente customer1 = Customer("Daniel", "Efectivo") customer2 = Customer("Mateo", "Crédito") customer3 = Customer("Maria", "Transferenecia") #Crear objeto clase concesionario dealer_ship = Dealer_ship() #Interacción entre objetos #Registro de vehículos en consecionario dealer_ship.add_vehicle(vehicle1) dealer_ship.add_vehicle(vehicle2) dealer_ship.add_vehicle(vehicle3) dealer_ship.add_vehicle(vehicle4) #Mostrar vehículos disponibles dealer_ship.show_avaible_vehicles(customer1) #Compra de vehiculo por parte del cliente customer1.buy_vehicle(vehicle3) #Tratar de comprar el mismo vehículo customer2.buy_vehicle(vehicle3) #Mostrar vehículo dispobiles dealer_ship.show_avaible_vehicles(customer1) #Mostrar desde el concesionario que el vehículo ya no esta disponible vehicle3.sell() #Venta de vehículo por parte del cliente customer1.sell_vehicle(vehicle3) #creacion de un vehículo que vendará el cliente 3 vehicle5 = Vehicle("Toyota Prado", "Negra", "2025", "160.000.000") #Venta de vehículo por parte del cliente customer3.sell_vehicle(vehicle5) dealer_ship.add_vehicle(vehicle5) #Se agregra nuevamente el vehículo al concesionario dealer_ship.add_vehicle(vehicle3) #Mostrar nuevamente lista de vehículos disponibles con la compra que hizo el concesionario dealer_ship.show_avaible_vehicles(customer1) ```

Comparto mi código: class Car: def \_\_init\_\_(self, model, model\_year, price): self.model = model self.model\_year = model\_year self.price = price self.available = True class Client: def \_\_init\_\_(self, name): self.name = name def purchase(self,car): if car.available: car.available = False print(f'Congrats you have been purchased a car.') else: print(f'The car isn\\'t available.') class Delearship: def \_\_init\_\_(self): self.cars = \[] def add\_car(self, car): self.cars.append(car) def show\_available\_cars(self): print('Available cars: ') for car in self.cars: if car.available: print(f'{car.model} {car.model\_year}, cost: {car.price}') car1 = Car('Vento',2019,'$180,000') car2 = Car('Beat',2019,'$100,000') client1 = Client('Javi') delearship = Delearship() delearship.add\_car(car1) delearship.add\_car(car2) delearship.show\_available\_cars() client1.purchase(car1) delearship.show\_available\_cars()

Hola a todos, aquí les envío la solución al reto: \# Clase auto, marca, modelo, año, precioclass Car:    def \_\_init\_\_(self,maker,model, year,price):        self.maker = maker        self.model = model        self.year = year        self.price = price        self.available = True     def compra(self):        if self.available:            self.available = False            print(f"El auto marca {self.maker}, modelo {self.model} ha sido vendido")        else:            print(f"El auto marca {self.maker}, modelo {self.model} no está disponible")            # Clase cliente, nombre, autos compradosclass Customer:    def \_\_init\_\_(self, client\_id,name, phone, address):        self.client\_id = client\_id        self.name = name        self.phone = phone        self.address = address        self.cars\_bought = \[]     def compra\_auto(self, car):        if car.available:            car.compra()            self.cars\_bought.append(car)            print(f"Usted ha comprado el auto {car.maker}, modelo {car.model}, año {car.year}, muchas gracias")        else:            print(f"El auto marca {car.maker}, modelo {car.model}, año {car.year} no tiene stock")    \# Clase Compraventaclass Compraventa():    def \_\_init\_\_(self):        self.customers = \[]        self.cars = \[]        self.cars\_stock = \[]     def add\_cars(self, car):        self.cars.append(car)        print(f"El auto {car.model} ha sido agregado")     def register\_customer(self, customer):        self.customers.append(customer)        print(f"El cliente {customer.name} ha sido registrado")    def show\_available\_cars(self):        print(f"Los autos disponibles: ")        for car in self.cars:            if car.available:                print(f"Marca {car.maker}, modelo {car.model}, año {car.year}, precio {car.price} .") \# Crear compraventacompraventa = Compraventa() \# Crear autoscar1 = Car("Mazda", "CX30", 2024, 21890000)car2 = Car("Suzuki", "Jimny", 2024, 19000000)car3 = Car("Ford", "Fiesta", "2024", "18999000") \# Agregar autoscompraventa.add\_cars(car1)compraventa.add\_cars(car2)compraventa.add\_cars(car3) \# Crear clientescliente1 = Customer(1,"Cristian", "966688111", "Av Matta 490 Valparaiso")cliente2 = Customer(2, "Claudio", "23323345", "Av Grecia 235, Santiago") \# Registrar clientescompraventa.register\_customer(cliente1)compraventa.register\_customer(cliente2) \# Mostrar autoscompraventa.show\_available\_cars() \# Comprar autocliente1.compra\_auto(car2)cliente2.compra\_auto(car2)cliente2.compra\_auto(car3)

\#Ejercicio concesionaria coches \#Comenzamos definiendo la clase "coche" class Coche:    def \_\_init\_\_(self,marca,modelo,precio):        self.marca=marca        self.precio= precio        self.modelo=modelo        self.vendido = False # Esta parte nos dice si ya se vendió    def \_\_str\_\_(self):        return f"{self.marca} {self.modelo} - Precio: ${self.precio} {'(Vendido)' if self.vendido else'(Disponible)'}" \# Clase Concesionariaclass Concesionaria:    def \_\_init\_\_(self,nombre):        self.nombre=nombre        self.coches=\[] #lista de los coches en la concesionaria    # Definimos ahora la función que agrega coches:    def agregar\_coches(self,coche):        self.coches.append(coche)    def mostrar\_coches\_disponibles(self):        for coche in self.coches:            if not coche.vendido:                print(coche)     def vender\_coche(self, marca, modelo):        for coche in self.coches:            if coche.marca == marca and coche.modelo == modelo and not coche.vendido:                coche.vendido = True                print(f"¡Has comprado el {coche.marca} {coche.modelo} por ${coche.precio}!")                return        print(f"No se encontró un {marca} {modelo} disponible para la venta.") ##### ###pequeño ejemplo de uso concesionaria = Concesionaria("Super Autos")coche1 = Coche("Toyota", "Corolla", 20000)coche2 = Coche("Honda", "Civic", 22000)coche3 = Coche("Ford", "Mustang", 30000) concesionaria.agregar\_coches(coche1)concesionaria.agregar\_coches(coche2)concesionaria.agregar\_coches(coche3) \# Mostramos los coches disponiblesconcesionaria.mostrar\_coches\_disponibles() \# Compramos un cocheconcesionaria.vender\_coche("Toyota", "Corolla") \# Mostrar coches disponibles después de la compraconcesionaria.mostrar\_coches\_disponibles()# Intentamos comprar el mismo cocheconcesionaria.vender\_coche("Toyota", "Corolla")

```python """ Crear una concecionaria de vehiculos en la cual se podra hacer la compra y venta, ademas de gestionar los vehiculos un usuario va a poder preguntar cuales son los que estan disponibles, su precio y tambien va a poder comprar uno """ class Vehiculo: def __init__(self, marca, modelo, precio): self.marca = marca self.modelo = modelo self.precio = precio self.disponible = True def vender(self): if self.disponible: self.disponible = False print(f"El vehiculo de marca {self.marca} y de modelo {self.modelo} ha sido vendido") else: print(f"El vehiculo de marca {self.marca} y de modelo {self.modelo} no esta disponible") def __str__(self): return f"{self.marca} {self.modelo}" class Comprador: def __init__(self, nombre, user_id): self.nombre = nombre self.id = user_id self.vehiculos_comprados = [] def comprarVehiculo(self, vehiculo): if vehiculo.disponible: vehiculo.vender() self.vehiculos_comprados.append(vehiculo) else: print(f"El vehiculo de marca {vehiculo.marca} y de modelo {vehiculo.modelo} no esta disponible") def verVehiculos(self): for i in self.vehiculos_comprados: print(i) class Concecionaria: def __init__(self): self.vehiculos = [] self.users = [] def agregar_vehiculos(self, vehiculo): self.vehiculos.append(vehiculo) print(f"El vehiculo de marca {vehiculo.marca} y de modelo {vehiculo.modelo} ha sido agregado") def registrar_usuario(self, user_id): self.users.append(user_id) print(f"El comprador {user_id.nombre} ha sido registrado/a") def mostrar_vehiculos_disponibles(self): print("Vehiculos disponibles:") for vehiculo in self.vehiculos: if vehiculo.disponible: print(f"{vehiculo.marca}, {vehiculo.modelo} -> {vehiculo.precio}") vehiculo1 = Vehiculo("Toyota", "2015", "$ 50.000") vehiculo2 = Vehiculo("Ferrari", "2023", "$ 1.000.000") vehiculo3 = Vehiculo("Mercedes Benz", "2010", "$ 10.000") usuario1 = Comprador("Francys Ninee", "001") concecionaria = Concecionaria() concecionaria.agregar_vehiculos(vehiculo1) concecionaria.agregar_vehiculos(vehiculo2) concecionaria.agregar_vehiculos(vehiculo3) print("") concecionaria.registrar_usuario(usuario1) print("") #Primero debemos mostrar los vehiculos disponibles concecionaria.mostrar_vehiculos_disponibles() print("") #El usuario ve los vehiculos disponibles y compra uno usuario1.comprarVehiculo(vehiculo1) usuario1.comprarVehiculo(vehiculo2) print("") #El usuario podra ver los vehiculos que ha comprado print("Mis autos:") print("") usuario1.verVehiculos() ```"""Crear una concecionaria de vehiculos en la cual se podra hacer la compray venta, ademas de gestionar los vehiculos un usuario va a poder preguntarcuales son los que estan disponibles, su precio y tambien va a podercomprar uno """ class Vehiculo:    def \_\_init\_\_(self, marca, modelo, precio):        self.marca = marca        self.modelo = modelo        self.precio = precio        self.disponible = True            def vender(self):        if self.disponible:            self.disponible = False            print(f"El vehiculo de marca {self.marca} y de modelo {self.modelo} ha sido vendido")        else:            print(f"El vehiculo de marca {self.marca} y de modelo {self.modelo} no esta disponible")        def \_\_str\_\_(self):        return f"{self.marca} {self.modelo}"            class Comprador:    def \_\_init\_\_(self, nombre, user\_id):        self.nombre = nombre        self.id = user\_id        self.vehiculos\_comprados = \[]            def comprarVehiculo(self, vehiculo):        if vehiculo.disponible:            vehiculo.vender()            self.vehiculos\_comprados.append(vehiculo)        else:            print(f"El vehiculo de marca {vehiculo.marca} y de modelo {vehiculo.modelo} no esta disponible")                def verVehiculos(self):        for i in self.vehiculos\_comprados:            print(i) class Concecionaria:    def \_\_init\_\_(self):        self.vehiculos = \[]        self.users = \[]            def agregar\_vehiculos(self, vehiculo):        self.vehiculos.append(vehiculo)        print(f"El vehiculo de marca {vehiculo.marca} y de modelo {vehiculo.modelo} ha sido agregado")            def registrar\_usuario(self, user\_id):        self.users.append(user\_id)        print(f"El comprador {user\_id.nombre} ha sido registrado/a")            def mostrar\_vehiculos\_disponibles(self):        print("Vehiculos disponibles:")        for vehiculo in self.vehiculos:            if vehiculo.disponible:                print(f"{vehiculo.marca}, {vehiculo.modelo} -> {vehiculo.precio}")                vehiculo1 = Vehiculo("Toyota", "2015", "$ 50.000")vehiculo2 = Vehiculo("Ferrari", "2023", "$ 1.000.000")vehiculo3 = Vehiculo("Mercedes Benz", "2010", "$ 10.000") usuario1 = Comprador("Francys Ninee", "001") concecionaria = Concecionaria() concecionaria.agregar\_vehiculos(vehiculo1)concecionaria.agregar\_vehiculos(vehiculo2)concecionaria.agregar\_vehiculos(vehiculo3)print("")concecionaria.registrar\_usuario(usuario1)print("") \#*Primero debemos mostrar los vehiculos disponibles* concecionaria.mostrar\_vehiculos\_disponibles()print("") \#*El usuario ve los vehiculos disponibles y compra uno* usuario1.comprarVehiculo(vehiculo1)usuario1.comprarVehiculo(vehiculo2)print("")#*El usuario podra ver los vehiculos que ha comprado* print("Mis autos:")print("") usuario1.verVehiculos()

```js class Car: def __init__(self, precio, marca ) -> None: self.marca=marca self.precio=precio self.available=True def venta(self): if self.available: self.available=False print(f"El Vehiculo Marca {self.marca} modelo {self.precio} ha sido VENDIDO") else: print(f"El Vehiculo {self.marca} modelo {self.precio} esta Disponible para su Venta") def compra(self): if self.available: self.available=False print(f"El Vehiculo {self.marca} modelo {self.precio} se ha comprano") else: print(f"El Vehiculo {self.marca} modelo {self.precio} No se pudo realizar la compra") class User: def __init__(self, name, user_id) -> None: self.name=name self.user_id=user_id self.borrwed_cars=[] def compra_car(self, car): if car.available: car.venta() self.borrwed_cars.append(car) else: print(f"El Vehiculo {car.marca } Se Vendio ") def venta_car(self, car): if car in self.borrwed_cars: car.compra_car() self.borrwed_cars.remove(car) else: print(f"El Vehiculo {car.marca} esta disponible para su venta ") class Library: def __init__(self) -> None: self.cars=[] self.users=[] def add_car(self, car): self.cars.append(car) print(f"El Vehiculo {car.marca} ha sido Comprado") def register_user(self, user): self.users.append(user) print(f"El Usuario {user.name} ha sido registrado ") def show_available_car(self): print(f"Vehiculos Disponibles") for car in self.cars: if car.available: print(f" {car.precio} por {car.marca} ") car1 = Car(" BMW "," $ 35 000") car2 = Car(" FORD ", " $ 55 000") user1= User(" Luis Miguel", "Alania Canchoricra") library = Library() library.add_car(car1) library.add_car(car2) library.register_user(user1) library.show_available_car() user1.venta_car(car1) library.show_available_car() user1.compra_car(car2) library.show_available_car() ```

En POO, todo gira entorno a los objetos . Los objetos son cosas o conceptos que tienen atributos (datos) y metodos (acciones). Para crearlos, usamos clases que son como moldes o plantillas que definen qué características y comportamientos tendrán los objetos. En el ejemplo de la clase usamos la orientación enfocada a objetos **** aplicada a un sistema simple de biblioteca. Usamos las clases para representar objetos reales (libros, usuarios y la biblioteca misma) y sus interacciones. De esta forma, se puede ver cómo POO facilita el trabajo con entidades complejas, organizándolas en pequeñas partes que puedes manejar fácilmente.

Me tardé una hora para hacer esto!!! pero es poco a poco. Les comparto mi resumen: En Programación Orientada a Objetos (POO), se utilizan **clases** para definir el comportamiento y los atributos de los objetos, y **métodos** para interactuar con esos objetos. La estructura básica en POO se puede resumir en: 1. **Clases**: Son las plantillas o modelos que describen qué atributos y comportamientos tendrán los objetos. 2. **Objetos**: Son instancias concretas de una clase. 3. **Atributos**: Son las características o propiedades que describen a los objetos (también llamados variables de instancia). 4. **Métodos**: Son las funciones definidas dentro de una clase, que describen las acciones que un objeto puede realizar.

class Vehicle:    def \_\_init\_\_(*self*, *brand*: str, *model*: str, *price*: float) -> None:        *self*.brand = *brand*        *self*.model = *model*        *self*.price = *price*        *self*.available = True     def sell(*self*) -> None:        """Mark the vehicle as sold if available."""        if *self*.available:            *self*.available = False            print(f"The vehicle {*self*.brand} {*self*.model} has been sold")        else:            print(f"The vehicle {*self*.brand} {*self*.model} is not available")     def return\_vehicle(*self*) -> None:        """Mark the vehicle as available."""        *self*.available = True        print(f"The vehicle {*self*.brand} {*self*.model} has been returned") class Dealership:    def \_\_init\_\_(*self*) -> None:        *self*.vehicles = \[]        *self*.users = \[]     def add\_vehicle(*self*, *vehicle*: Vehicle) -> None:        """Add a vehicle to the dealership."""        *self*.vehicles.append(*vehicle*)        print(f"The vehicle {*vehicle*.brand} {*vehicle*.model} has been added to the dealership")     def register\_user(*self*, *user*: 'User') -> None:        """Register a new user."""        *self*.users.append(*user*)        print(f"The user {*user*.first\_name} {*user*.last\_name} has been registered")     def show\_available\_vehicles(*self*) -> None:        """Display all available vehicles."""        print("Available vehicles: ")        for vehicle in *self*.vehicles:            if vehicle.available:                print(f" {vehicle.brand} {vehicle.model} for {vehicle.price}") class User:    def \_\_init\_\_(*self*, *first\_name*: str, *last\_name*: str) -> None:        *self*.first\_name = *first\_name*        *self*.last\_name = *last\_name*

Hola, comparto el resultado del ejercicio. ```js #1: Crear la clase vehiculo: donde un vehiculo se puede compar #2: Crear la clase Usuario: donde un usuario puede comprar un carro #3: Crear la clase concecioario: donde puede vender un carro a un usuario y ver los carros disponibles #from typing import Any class Vehicle: #creamos el la función tipo constructor de la clase vehiculo def __init__(self,brand,price,reference_id): self.brand = brand self.price = price self.reference_id = reference_id self.available = True #Creamos la función tipo comprar def sell_vehicle(self): if self.available: self.available = False print(f"El Vehiculo con referencia {self.reference_id}, de la marca {self.brand} ha sido vendido") else: print(f"El Vehiculo con referencia {self.reference_id}, de la marca {self.brand} no está disponible") class User: def __init__(self,name,usser_id): self.name = name self.usser_id = usser_id self.bought_vehicle = [] def buy_vehicle(self, vehicle): if vehicle.available: vehicle.sell_vehicle() self.bought_vehicle.append(vehicle) else: print(f"El Vehiculo con referencia {vehicle.reference_id}, de la marca {vehicle.brand} no está disponible") class Authorized_dealer: def __init__(self): self.vehicles = [] self.users = [] def add_vehicle(self, vehicle): self.vehicles.append(vehicle) print(f"La referencia {vehicle.reference_id}, de la marca {vehicle.brand} ha sido agregado") def register_user(self, user): self.users.append(user) print(f"El usuario con user id {user.usser_id} y nombre {user.name} ha sido registrado") def show_available_vehicles(self): print("Vehiculos disponibles:") for vehicle in self.vehicles: if vehicle.available: print(f"{vehicle.reference_id} de la marca {vehicle.brand} con un valor de {vehicle.price}") # 1: Crear objetos de la clase vehiculos, es decir crear el inventario de carros disponibles vehicles_001 = Vehicle("Chevrolet Onix", "3000", "Ch_On_00") vehicles_002 = Vehicle("Suzuki Swift", "3400", "Su_Sf_00") vehicles_003 = Vehicle("Kia Picanto", "4000", "K_Pi_00") vehicles_004 = Vehicle("Mazda 2", "2000", "Mz_Da_00") # 2: Crear objetos de la clase usuarios user1 = User("Mery","001M") user2 = User("Dayahna","001") #crear un objeto de la clase concesionario Authorized_dealer = Authorized_dealer() #Crear el concesionario, donde se agregaran el inventario de carros y usuarios #Crear lista de carros Authorized_dealer.add_vehicle(vehicles_001) Authorized_dealer.add_vehicle(vehicles_002) Authorized_dealer.add_vehicle(vehicles_003) Authorized_dealer.add_vehicle(vehicles_004) #crear lista de usuarios Authorized_dealer.register_user(user1) Authorized_dealer.register_user(user2) #Mostrar listado de carros Authorized_dealer.show_available_vehicles() #vender un carro user1.buy_vehicle(vehicles_001) #Mostrar listado de carros Authorized_dealer.show_available_vehicles() ```#1: Crear la clase vehiculo: donde un vehiculo se puede compar#2: Crear la clase Usuario: donde un usuario puede comprar un carro#3: Crear la clase concecioario: donde puede vender un carro a un usuario y  ver los carros disponibles#from typing import Any class Vehicle:    #creamos el la función tipo constructor de la clase vehiculo    def \_\_init\_\_(self,brand,price,reference\_id):        self.brand = brand        self.price = price        self.reference\_id = reference\_id        self.available = True        #Creamos la función tipo comprar        def sell\_vehicle(self):            if self.available:                self.available = False                print(f"El Vehiculo con referencia {self.reference\_id}, de la marca {self.brand} ha sido vendido")            else:                print(f"El Vehiculo con referencia {self.reference\_id}, de la marca {self.brand} no está disponible")class User:    def \_\_init\_\_(self,name,usser\_id):        self.name = name        self.usser\_id = usser\_id        self.bought\_vehicle = \[]            def buy\_vehicle(self, vehicle):        if vehicle.available:            vehicle.sell\_vehicle()            self.bought\_vehicle.append(vehicle)        else:            print(f"El Vehiculo con referencia {vehicle.reference\_id}, de la marca {vehicle.brand} no está disponible") class Authorized\_dealer:    def \_\_init\_\_(self):        self.vehicles = \[]        self.users = \[]        def add\_vehicle(self, vehicle):        self.vehicles.append(vehicle)        print(f"La referencia {vehicle.reference\_id}, de la marca {vehicle.brand} ha sido agregado")     def register\_user(self, user):        self.users.append(user)        print(f"El usuario con user id {user.usser\_id} y nombre {user.name} ha sido registrado")     def show\_available\_vehicles(self):        print("Vehiculos disponibles:")        for vehicle in self.vehicles:            if vehicle.available:                print(f"{vehicle.reference\_id} de la marca {vehicle.brand} con un valor de {vehicle.price}") \# 1: Crear objetos de la clase vehiculos, es decir crear el inventario de carros disponiblesvehicles\_001 = Vehicle("Chevrolet Onix", "3000", "Ch\_On\_00")vehicles\_002 = Vehicle("Suzuki Swift", "3400", "Su\_Sf\_00")vehicles\_003 = Vehicle("Kia Picanto", "4000", "K\_Pi\_00")vehicles\_004 = Vehicle("Mazda 2", "2000", "Mz\_Da\_00")# 2: Crear objetos de la clase usuariosuser1 = User("Mery","001M")user2 = User("Dayahna","001") \#crear un objeto de la clase concesionarioAuthorized\_dealer = Authorized\_dealer()#Crear el concesionario, donde se agregaran el inventario de carros y usuarios#Crear lista de carrosAuthorized\_dealer.add\_vehicle(vehicles\_001)Authorized\_dealer.add\_vehicle(vehicles\_002)Authorized\_dealer.add\_vehicle(vehicles\_003)Authorized\_dealer.add\_vehicle(vehicles\_004)#crear lista de usuariosAuthorized\_dealer.register\_user(user1)Authorized\_dealer.register\_user(user2) \#Mostrar listado de carrosAuthorized\_dealer.show\_available\_vehicles() \#vender un carrouser1.buy\_vehicle(vehicles\_001) \#Mostrar listado de carrosAuthorized\_dealer.show\_available\_vehicles()

```python class car: def __init__(self, marca, modelo, costo): self.marca = marca self.modelo = modelo self.costo = costo self.available = True def sell_car(self): if self.available: self.available = False print(f"El carro {self.marca} del modelo {self.modelo} cuyo costo es {self.costo} ha sido vendido") else: print(f"El carro {self.marca} del modelo {self.modelo} cuyo costo es {self.costo} ya no está disponible") def buy_car(self): self.available = True print(f"El carro {self.marca} del modelo {self.modelo} se ha comprado en {self.costo} ha sido comprado por el concesionario") class User: def __init__(self, name, user_id): self.name = name self.user_id = user_id self.carros_comprados = [] def comprar_carro(self, carro): if carro.available: carro.sell_car() self.carros_comprados.append(carro) else: print(f"El carro {car.marca} de {car.modelo} con un costo de {car.costo} no esta disponible") def vender_carro(self, carro): if carro in self.comprar_carro: carro.vender_carro() self.carros_comprados.remove(carro) else: print(f"El carro {carro.marca} con modelo {carro.modelo} No esta en la lista de vendidos") class concesionario: def __init__(self): self.carros = [] self.users = [] def add_car(self, carro): self.carros.append(carro) print(f"El carro {carro.marca} del modelo {carro.modelo} cuyo costo es {carro.costo} ha sido agregado") def register_user(self, user): self.users.append(user) print(f"El usuario {user.name} ha sido registrado") def show_available_cars(self): print("Carros disponibles:") for carro in self.carros: if carro.available: print(f"{carro.marca}, {carro.modelo}, {carro.costo}") #Crear los carros carro_1 = car("Chevrolet", "Spark", 45500000 ) carro_2 = car("Renault", "Sandero", 48000000) carro_3 = car("Tesla", "Cybertruck", 899999990) #Agregar usuarios user1 = User("Carli", "001") user2 = User("Robin", "002") user3 = User("Caro", "003") #Crear concesionario concesionario = concesionario() concesionario.add_car(carro_1) concesionario.add_car(carro_2) concesionario.add_car(carro_3) #library.register_user(user1) #Mostrar carro concesionario.show_available_cars() #Realizar compra user1.comprar_carro(carro_1) #Mostrar carros concesionario.show_available_cars() #Vender carro al concesionario user3.comprar_carro(carro_3) #Mostrar carros concesionario.show_available_cars() ```class car:    def \_\_init\_\_(self, marca, modelo, costo):        self.marca = marca        self.modelo = modelo        self.costo = costo        self.available = True        def sell\_car(self):        if self.available:            self.available = False            print(f"El carro {self.marca} del modelo {self.modelo} cuyo costo es {self.costo} ha sido vendido")        else:            print(f"El carro {self.marca} del modelo {self.modelo} cuyo costo es {self.costo} ya no está disponible")     def buy\_car(self):        self.available = True        print(f"El carro {self.marca} del modelo {self.modelo} se ha comprado en {self.costo} ha sido comprado por el concesionario") class User:    def \_\_init\_\_(self, name, user\_id):        self.name = name        self.user\_id = user\_id        self.carros\_comprados = \[]     def comprar\_carro(self, carro):        if carro.available:            carro.sell\_car()            self.carros\_comprados.append(carro)        else:            print(f"El carro {car.marca} de {car.modelo} con un costo de {car.costo} no esta disponible")     def vender\_carro(self, carro):        if carro in self.comprar\_carro:            carro.vender\_carro()            self.carros\_comprados.remove(carro)        else:            print(f"El carro {carro.marca} con modelo {carro.modelo} No esta en la lista de vendidos") class concesionario:    def \_\_init\_\_(self):        self.carros = \[]        self.users = \[]        def add\_car(self, carro):        self.carros.append(carro)        print(f"El carro {carro.marca} del modelo {carro.modelo} cuyo costo es {carro.costo} ha sido agregado")     def register\_user(self, user):        self.users.append(user)        print(f"El usuario {user.name} ha sido registrado")     def show\_available\_cars(self):        print("Carros disponibles:")        for carro in self.carros:            if carro.available:                print(f"{carro.marca}, {carro.modelo}, {carro.costo}") \#Crear los carroscarro\_1 = car("Chevrolet", "Spark", 45500000 )carro\_2 = car("Renault", "Sandero", 48000000)carro\_3 = car("Tesla", "Cybertruck", 899999990) \#Agregar usuariosuser1 = User("Carli", "001")user2 = User("Robin", "002")user3 = User("Caro", "003") \#Crear concesionarioconcesionario = concesionario()concesionario.add\_car(carro\_1)concesionario.add\_car(carro\_2)concesionario.add\_car(carro\_3)#library.register\_user(user1) \#Mostrar carroconcesionario.show\_available\_cars() \#Realizar comprauser1.comprar\_carro(carro\_1) \#Mostrar carrosconcesionario.show\_available\_cars() \#Vender carro al concesionariouser3.comprar\_carro(carro\_3) \#Mostrar carrosconcesionario.show\_available\_cars()

Por aquí va mi aporte al reto. Quise hacerlo más estilo "compra-venta de carros", pero me costó incluir la parte de "compra" por el concesionario, porque no supe por dónde introducir los carros al sistema. De pronto puedan checar mi código y hacerme alguna sugerencia. ¡Muchas gracias! ```js # %% class Car: def __init__(self, brand, price): self.brand = brand self.price = price self.available = True def sell_car(self): if self.available == True: self.available = False print(f"Se vendió el carro {self.brand} por {self.price} con éxito") else: print(f"El carro {self.brand} no se encuentra disponible") def buy_car(self): self.available = True print(f"El carro {self.brand} se adquirió para la concesionaria por {self.price}") class User: def __init__(self, name, user_id): self.name = name self.user_id = user_id self.owned_cars = [] def acquire_car(self, car): if car.available: car.sell_car() self.owned_cars.append(car) else: print(f"El carro {car.brand} no se encuentra disponible") class Car_dealer: def __init__(self): self.cars = [] self.users = [] def add_car(self, car): self.cars.append(car) print(f"Se adquirió el carro {car.brand} para el concesionario") def register_user(self, user): self.users.append(user) print(f"El usuario {user.name} ha sido registrado") def show_available_cars(self): print("Los carros disponibles son:") for car in self.cars: if car.available: print(f"{car.brand} por {car.price}") # %% # crear cada uno de los objetos carros, usuarios y concesionario car_1 = Car("volkswagen", "280000") car_2 = Car("chevrolet", "140000") user_1 = User("juan", "054") car_dealer = Car_dealer() # %% # añadir los carros y usuarios al concesionario car_dealer.add_car(car_1) car_dealer.add_car(car_2) car_dealer.register_user(user_1) # %% # realizar una compra por parte del usuario car_dealer.show_available_cars() user_1.acquire_car(car_1) car_dealer.show_available_cars() ```

```python class Car: def __init__(self, model, brand, price, stock): self.model = model self.brand = brand self.price = price self.stock = stock self.available = True def add_stock(self, cant): self.stock += cant def decrease_stock(self, cant): self.stock -= cant def set_estatus(self): # Si el stock es mayor a cero cambiamos estado = True, de lo contrario False. if self.stock > 0: self.available = True else: self.available = False # Comprar auto, actualizar stock y cambiar estado def buy(self, cant): # Si está disponible y si hay stock if self.available and self.stock >= cant: self.decrease_stock(cant) self.set_estatus() print(f"El auto {self.model} de marca {self.brand} vendido correctamente!") else: print(f"El auto {self.model} de marca {self.brand} NO está disponible") # Actualizar stock def return_car(self, car, cant): self.add_stock(cant) self.set_estatus() print(f"El auto {self.model} de marca {self.brand} devuelto correctamente!") class User: def __init__(self, name, id): self.name = name self.id = id self.bought_cars = [] # Comprar auto def buy_car(self, car, cant, dealer): # buscar auto en la concesionaria i = dealer.search_car(car, dealer.cars) # Si existe realizar compra auto, actualizar stock autos comprados if i >= 0 and dealer.cars[i].available: dealer.cars[i].buy(cant) # Si existe en la lista comprada, actualizamos if len(self.bought_cars) > 0: j = dealer.search_car(car, self.bought_cars) else: j = -1 if j >= 0: self.bought_cars[j].add_stock(cant) else: car.stock = cant self.bought_cars.append(car) self.show_bought_cars() else: print(f"No disponible la compra del auto {car.model} de marca {car.brand}") # Devolver auto def return_car(self, car, cant, dealer): # Buscar auto en la lista comprada if len(self.bought_cars) > 0: i = dealer.search_car(car, self.bought_cars) else: i = -1 # Si existe auto, devolver auto y actualizar stocks en ambas listas if i >= 0: # Actualizando lista vehiculos comprados if cant == self.bought_cars[i].stock: self.bought_cars.remove(car) else: self.bought_cars[i].decrease_stock(cant) # Actualizando lista disponibles j = dealer.search_car(car, dealer.cars) dealer.cars[j].return_car(car, cant) self.show_bought_cars() else: print(f"Usted No cuenta con el auto {car.model} de marca {car.brand}") self.show_bought_cars() def show_bought_cars(self): print("Lista vehiculos comprados") print("-" * 25) for car in self.bought_cars: print(f"* Modelo: {car.model} de marca: {car.brand}. Precio: {car.price} - Cantidad: {car.stock}") class Dealer: def __init__(self): self.cars = [] self.users = [] def search_car(self, car, list_cars): found = False i=0 for xcar in list_cars: if car.model == xcar.model: found = True break i += 1 if found: print(f"Auto encontrado: modelo {car.model} marca {car.brand}") return i else: return -1 def add_car(self, car): # buscamos si existe el auto if len(self.cars) > 0: i = self.search_car(car, self.cars) else: i = -1 # Si existe auto, actualizamos stock, de lo contrario realizamos un nuevo registro. if i >= 0: print(f"Actualizando stock del auto {car.model} de marca {car.brand} en {car.stock} unidades") self.cars[i].add_stock(car.stock) else: print(f"El auto {car.model} de marca {car.brand} ha sido registrado") self.cars.append(car) def register_user(self, user): self.users.append(user) def show_available_cars(self): print("Lista vehiculos disponibles") print("-" * 27) for car in self.cars: if car.available: print(f"* {car.model} de marca {car.brand}. Precio: {car.price} - Unidades: {car.stock}") # Crear Autos car1 = Car("Hilux", "Toyota", "$25,000", 10) car2 = Car("CRV", "Honda", "$30,000", 8) car3 = Car("Haval Hybrid H6", "Great Wall Motors", "$35,000", 5) # Crear Usuarios user1 = User("Luis", "0001") # Concesionaria dealer1 = Dealer() # Agregar autos dealer1.add_car(car1) dealer1.add_car(car2) dealer1.add_car(car3) # Registrar usuarios dealer1.register_user(user1) # Mostrar autos disponibles dealer1.show_available_cars() print("*" * 100) # Crear nuevos autos car3 = Car("Haval Hybrid H6", "Great Wall Motors", "$35,000", 10) car4 = Car("Cybertruck", "Tesla", "$100,000", 3) car5 = Car("Tiggo 8 pro", "Chery", "$23,000", 6) # Agregar los nuevos autos dealer1.add_car(car3) dealer1.add_car(car4) dealer1.add_car(car5) print("*" * 100) # Mostrar autos disponibles dealer1.show_available_cars() print("*" * 100) # Comprar auto user1.buy_car(car3, 15, dealer1) print("*" * 100) # Mostrar autos disponibles dealer1.show_available_cars() print("*" * 100) # Comprar auto user1.buy_car(car3, 6, dealer1) print("*" * 100) dealer1.show_available_cars() print("*" * 100) # Devolver autos car7 = Car("Haval Hybrid H6", "Great Wall Motor", "$35,000", 3) user1.return_car(car7, 3, dealer1) print("*" * 100) # Mostrar autos disponibles dealer1.show_available_cars() print("*" * 100) # Devolver un auto que no existe en la lista vehiculos comprados car8 = Car("Haval Hybrid H7", "Great Wall Motor", "$40,000", 10) user1.return_car(car8, 10, dealer1) print("*" * 100) # Mostrar autos disponibles dealer1.show_available_cars() ```Result: 

class Vehiculo: def \_\_init\_\_(self, marca, modelo, precio): self.marca = marca self.modelo = modelo self.precio = precio self.vendido = False def mostrar\_informacion(self): print (f"Marca : {self.marca}") print (f"Modelo : {self.modelo}") print (f"Precio : {self.precio}") class Coche(Vehiculo): def \_\_init\_\_ (self, marca, modelo, precio, puertas): super().\_\_init\_\_(marca, modelo ,precio) self.puertas = puertas def mostrar\_informacion (self): super().mostrar\_informacion() print(f"Puertas: {self.puertas}") print("-"\*30) class Moto (Vehiculo): def \_\_init\_\_ (self, marca, modelo, precio, cilindrada): super().\_\_init\_\_(marca, modelo ,precio) self.cilindrada = cilindrada def mostrar\_informacion (self): super().mostrar\_informacion() print(f"Cilindrada: {self.cilindrada}cc") print("-"\*30) class Camioneta (Vehiculo): def \_\_init\_\_ (self, marca, modelo, precio, capacidad\_carga): super().\_\_init\_\_(marca, modelo ,precio) self.capacidad\_carga = capacidad\_carga def mostrar\_informacion (self): super().mostrar\_informacion() print(f"Capacidad de carga: {self.capacidad\_carga}kg") print("-"\*30) class Concesionaria: def \_\_init\_\_(self, nombre): self.nombre = nombre self.vehiculos =\[] #Lista de vehiculos dispobibles def agregar\_vehiculo(self, vehiculo): self.vehiculos.append(vehiculo) def mostrar\_vehiculos\_disponibles(self): print(f"Vehiculos disponibles en {self.nombre}:") disponible = False for idx, vehiculo in enumerate(self.vehiculos): if not vehiculo.vendido: print(f"id: {idx}") vehiculo.mostrar\_infomacion() disponible = True if not disponible: print("no hay vehiculos dispoibles en este momento") def vender\_vehiculo(self, idx): if 0 <= idx < len(self.vehiculos): vehiculo = self.vehiculos\[idx] if not vehiculo.vendido: vehiculo.vendido = True print(f"Has comprado el {vehiculo.marca} {vehiculo.modelo} por ${vehiculo.precio}") else: print("El vehiculo ya ha sido vendido") else: print("ID de vehuiculo ivalido") class Cliente: def \_\_init\_\_(self, nombre): self.nombre = nombre def ver\_vehiculos(self, concesionaria): concesionaria.mostrar\_vehiculos\_disponibles() def comprar\_vehiculo(self, concesionaria, idx): concesionaria.vender\_vehiculo(idx) def main(): mi\_concesionaria = Concesionaria("Autos Martinez") coche1 = Coche("Toyota", "Corolla", 20000, 4) coche2 = Coche("hyundai", "i10", 10000, 2) moto1 = Moto("Suzuki", "Ninja", 2000, 689) camioneta1 = Camioneta("Toyota", "Hilux",45000, 1000) mi\_concesionaria.agregar\_vehiculo(coche1) mi\_concesionaria.agregar\_vehiculo(coche2) mi\_concesionaria.agregar\_vehiculo(moto1) mi\_concesionaria.agregar\_vehiculo(camioneta1) cliente = Cliente("David") while True: print("Bienvenido a la concesionaria. Que desea hacer?") print("1. Ver Vehiculos disponibles") print("2. Comprar un vehiculo") print("3. Salir") opcion = input("Ingrese una opción (1/2/3): ") if opcion == "1": cliente.ver\_vehiculos(mi\_concesionaria) elif opcion == "2": try: id\_vehiculo = int(input("Ingresa el ID del vehiculo que deseas compra: ")) cliente.comprar\_vehiculo(mi\_concesionaria, id\_vehiculo) except ValueError: print("Por favor ingresa un numero vlaido") elif opcion == "3": print("Gracias por visitar la concesionaria, hasta pronto") break else: print("opcion ivalida por favor intenta de nuevo") if \_\_name\_\_ == "\_\_main\_\_": main()

Para mejorar un poco la impresión en consola utiliza **\t** ```js print(f"\t - El libro {book.title} por {book.author}") ```

```python class Vehicle: def __init__(self, brand, model, price): self.brand = brand self.model = model self.price = price self.available = True def purchase(self): if self.available: self.available = False print(f"El vehiculo {self.model} ha sido comprado por {self.price}") else: print(f"El vehiculo {self.model} cuyo precio es {self.price} no está disponible") class User: def __init__(self, name, user_id): self.name = name self.user_id = user_id self.buy = [] def self_buy_vehicle(self, vehicle): if vehicle.available: vehicle.purchase() self.buy.append(vehicle) else: print(f"El vehiculo {vehicle.brand} No esta disponible") class Dealership: def __init__(self): self.vehicle = [] self.users = [] def add_vehicle(self, vehicle): self.vehicle.append(vehicle) print(f"El vehiculo {vehicle.brand} cuyo valor es {vehicle.price} ha sido agregado") def register_user(self, user): self.users.append(user) print(f"El usuario {user.name} ha sido registrado") def show_available_vehicles(self): print("Los vehiculos disponibles son: ") for vehicle in self.vehicle: if vehicle.available: print(f"El {vehicle.brand} modelo {vehicle.model} de valor {vehicle.price}") #Crear vehiculos vehicle1 = Vehicle("Chevrolet", "Malibu", "$24,000") vehicle2 = Vehicle("Nissa", "Altima", "$25,000") vehicle3 = Vehicle("Lamborghini", "Hurricane", "$210,000") #Crear usuario user1 = User("Paolo", "001") user2 = User("Mishell", "002") #Crear consesionario dealership = Dealership() dealership.add_vehicle(vehicle1) dealership.add_vehicle(vehicle2) dealership.add_vehicle(vehicle3) dealership.register_user(user1) dealership.register_user(user2) #Mostrar vehiculos dealership.show_available_vehicles() #Realizar compra user1.self_buy_vehicle(vehicle2) #Mostrar vehiculos dealership.show_available_vehicles() #Realizar compra user2.self_buy_vehicle(vehicle3) #Mostrar vehiculos dealership.show_available_vehicles() #Realizar compra user1.self_buy_vehicle(vehicle3) ```class Vehicle:    def \_\_init\_\_(self, brand, model, price):        self.brand = brand         self.model = model        self.price = price        self.available = True     def purchase(self):        if self.available:            self.available = False            print(f"El vehiculo {self.model} ha sido comprado por {self.price}")        else:            print(f"El vehiculo {self.model} cuyo precio es {self.price} no está disponible") class User:    def \_\_init\_\_(self, name, user\_id):        self.name = name        self.user\_id = user\_id        self.buy = \[]     def self\_buy\_vehicle(self, vehicle):        if vehicle.available:            vehicle.purchase()            self.buy.append(vehicle)        else:            print(f"El vehiculo {vehicle.brand} No esta disponible") class Dealership:    def \_\_init\_\_(self):        self.vehicle = \[]        self.users = \[]        def add\_vehicle(self, vehicle):        self.vehicle.append(vehicle)        print(f"El vehiculo {vehicle.brand} cuyo valor es {vehicle.price} ha sido agregado")     def register\_user(self, user):        self.users.append(user)        print(f"El usuario {user.name} ha sido registrado")        def show\_available\_vehicles(self):        print("Los vehiculos disponibles son: ")        for vehicle in self.vehicle:            if vehicle.available:                print(f"El {vehicle.brand} modelo {vehicle.model} de valor {vehicle.price}") \#Crear vehiculosvehicle1 = Vehicle("Chevrolet", "Malibu", "$24,000")vehicle2 = Vehicle("Nissa", "Altima", "$25,000")vehicle3 = Vehicle("Lamborghini", "Hurricane", "$210,000") \#Crear usuariouser1 = User("Paolo", "001")user2 = User("Mishell", "002") \#Crear consesionariodealership = Dealership()dealership.add\_vehicle(vehicle1)dealership.add\_vehicle(vehicle2)dealership.add\_vehicle(vehicle3)dealership.register\_user(user1)dealership.register\_user(user2) \#Mostrar vehiculosdealership.show\_available\_vehicles() \#Realizar comprauser1.self\_buy\_vehicle(vehicle2) \#Mostrar vehiculosdealership.show\_available\_vehicles() \#Realizar comprauser2.self\_buy\_vehicle(vehicle3) \#Mostrar vehiculosdealership.show\_available\_vehicles() \#Realizar comprauser1.self\_buy\_vehicle(vehicle3)

Tengo una pregunta realice el código, pero al vender el carro al concesionario aparece doble vez el vehículo. no estoy muy seguro porque sucede eso. ```js class Car: def __init__(self, brand, version, price): self.brand = brand self.version = version self.price = price self.available = True def sell(self): if self.available: self.available = False print(f"El vehiculo {self.brand} {self.version} ha sido vendido") else: print(f"El vehiculo {self.brand}{self.version} ya no esta disponible") def purchase(self): self.available = True print(f"El vehiculo {self.brand} {self.version} ha sido comprado y esta disponible") class Customer: def __init__(self,name,customer_id): self.name = name self.customer_id = customer_id self.purchased_cars = [] def purchase_car(self, car): if car.available: car.sell() self.purchased_cars.append(car) print(f"El carro {car.brand} {car.version} ha sido comprado por {self.name} en ${car.price}") else: print(f"El carro {car.brand} {car.version} no esta disponible") def sell(self,car,concessionaire): if car in self.purchased_cars: self.purchased_cars.remove(car) car.purchase() concessionaire.add_car(car) else: print(f"El carro {car.brand} {car.version} no esta en la lista de carros vendidos") class Concessionaire: def __init__(self): self.cars = [] self.customers = [] def add_car(self, car): self.cars.append(car) print(f"El carro {car.brand} {car.version} ha sido agregado") def register_customer(self, customer): self.customers.append(customer) print(f"El cliente {customer.name} ha sido registrado") def show_available_cars(self): print("Carros disponibles: ") a = 1 for car in self.cars: if car.available: print(f"{a}. {car.brand} {car.version} ") a += 1 #Registrar clientes cliente1 = Customer("Catalina","001") cliente2 = Customer("Brayan","002") cliente3 = Customer("Santiago","003") #Crear los carros carro1 = Car("Nissan","Versa", 1000) carro2 = Car("Nissan","Sentra", 5000) carro3 = Car("Lamborghini","Veneno", 1000000) #Crea el concesionario concesionario = Concessionaire() concesionario.add_car(carro1) concesionario.add_car(carro2) concesionario.add_car(carro3) concesionario.register_customer(cliente1) concesionario.register_customer(cliente2) concesionario.register_customer(cliente3) #Mostrar carros print("\n") concesionario.show_available_cars() #realizar una compra print("\n") cliente1.purchase_car(carro2) cliente2.purchase_car(carro3) #Mostrar carros print("\n") concesionario.show_available_cars() #Vender carros print("\n") cliente1.sell(carro2,concesionario) #Mostrar carros print("\n") concesionario.show_available_cars() ```

**#RETO:** Creé un programa en el que puedes comprar cuatro carros que ofrece el concesionario, con base en tu presupuesto: ```js class Car: def __init__(self, model, price): # Inicializa el modelo y el precio del carro, y lo marca como disponible self.available = True self.model = model self.price = int(price) def buy(self): # Cambia la disponibilidad del carro y muestra un mensaje de compra if self.available: self.available = False print(f"El carro {self.model} ha sido comprado con éxito") else: print(f"El carro {self.model} no está disponible") class Buyer: def __init__(self, name, budget): # Inicializa el nombre y presupuesto del comprador, y lista de carros comprados self.name = name self.budget = int(budget) self.bought_cars = [] def buy_car(self, car): # Verifica si el comprador tiene suficiente dinero y si el carro está disponible if self.budget >= car.price: if car.available: car.buy() # Llama al método buy del carro self.budget -= car.price # Descuenta el precio del carro del presupuesto self.bought_cars.append(car) # Agrega el carro a la lista de comprados print(f"Has comprado {car.model}") print(f"Tu nuevo presupuesto es {self.budget}") else: print(f"El carro {car.model} no está disponible") else: print("No te alcanza para comprar el carro") class Concesionario: def __init__(self): # Inicializa la lista de carros y compradores self.cars = [] self.buyers = [] def add_car(self, car): # Agrega un carro a la lista y muestra un mensaje self.cars.append(car) print(f"El carro {car.model} ha sido agregado") def register_buyer(self, buyer): # Registra un comprador y muestra un mensaje self.buyers.append(buyer) print(f"El usuario {buyer.name} ha sido registrado") def show_available_cars(self): # Muestra todos los carros disponibles print("Carros disponibles") for car in self.cars: if car.available: print(f"Modelo: {car.model}, Precio: {car.price}") # Crear los carros car1 = Car("Mazda 3", "23000") car2 = Car("Audi A5", "43000") car3 = Car("Toyota Prado", "35000") car4 = Car("Honda HRV", "20000") # Crear usuario buyer_name = input("Tu nombre --> ") buyer_budget = int(input("Tu presupuesto en USD --> ")) buyer = Buyer(buyer_name, buyer_budget) # Crear Concesionario concesionario = Concesionario() concesionario.add_car(car1) concesionario.add_car(car2) concesionario.add_car(car3) concesionario.add_car(car4) concesionario.register_buyer(buyer) # Clase para mostrar el menú de opciones class Menu: def __init__(self): pass @staticmethod def show_menu(): # Muestra las opciones del menú y devuelve la elección del usuario print("*" * 8) print("¿Qué deseas hacer?") print("Escribe 1 para consultar los carros disponibles") print("Escribe 2 para comprar un carro") print("Escribe 3 para consultar tu presupuesto") print("Escribe 0 para salir") return int(input("--> ")) # Crear el bucle del menú principal while True: decision = Menu.show_menu() # Muestra el menú y obtiene la decisión del usuario if decision == 1: # Muestra los carros disponibles if len(concesionario.cars) >= 1: concesionario.show_available_cars() else: print("No hay carros disponibles") elif decision == 2: # Filtra los carros disponibles available_cars = [car for car in concesionario.cars if car.available] if len(available_cars) == 0: print("No hay carros disponibles para comprar") continue # Obtener el precio mínimo de los carros disponibles min_price = min(car.price for car in available_cars) # Verifica si el comprador tiene suficiente dinero para el carro más barato if buyer.budget < min_price: print("No tienes dinero suficiente para comprar ningún carro") else: print("Qué carro deseas comprar?") # Muestra las opciones de compra solo para carros disponibles if car1.available: print(f"Escribe 1 para comprar {car1.model} por {car1.price}") if car2.available: print(f"Escribe 2 para comprar {car2.model} por {car2.price}") if car3.available: print(f"Escribe 3 para comprar {car3.model} por {car3.price}") if car4.available: print(f"Escribe 4 para comprar {car4.model} por {car4.price}") print("Escribe 0 para regresar al menu") choice = input("--> ") # Procesa la elección del usuario para comprar un carro if choice == "1": buyer.buy_car(car1) elif choice == "2": buyer.buy_car(car2) elif choice == "3": buyer.buy_car(car3) elif choice == "4": buyer.buy_car(car4) elif choice == "0": continue # Regresa al menú else: print("Opción inválida") elif decision == 3: # Muestra el presupuesto actual del comprador print(f"Tu presupuesto actual es: {buyer.budget}") elif decision == 0: # Mensaje de salida y finaliza el bucle print("Saliendo del sistema. ¡Gracias!") break else: # Maneja entradas inválidas print("Opción inválida, por favor intenta nuevamente.") ```Resultado (ejemplo de uso): ![]()![]() 

🟢 **Qué es 'self' en POO de Python** En Python, `self` es una convención que se utiliza como el primer parámetro en los métodos de una clase. Se refiere a la **instancia actual del objeto** y se utiliza para acceder a las variables y métodos de esa instancia. En otras palabras, ya que la clase es una plantilla para crear objetos, debes utilizar un **nombre general** para que Python reconozca que haces referencia a un **objeto**. ```python class MyClass: def __init__ (yomismo, propiedad): yomismo.property = propiedad objeto1 = MyClass(5) objeto2 = MyClass("otro valor") objeto1.property # 5 objeto2.property # "otro valor" ``` En el código 👆, puedes ver que `yomismo` hace referencia a los objetos que creas. El parámetro `propiedad` hace referencia a los argumentos `5` y `"otro valor"` cuando **instancias un objeto** (aquí se invoca el método `__init__`). La propiedad `property` se inicializa con el valor del parámetro `propiedad`. Por eso les puse nombres diferentes. Y finalmente, `yomismo` hace referencia a cada uno de los objetos que instancias a partir de una clase, en este caso `objeto1` y `objeto2`. Es por eso que siempre debes definir `self` en tus métodos, porque Python utiliza el primer parámetro como referencia a la **instancia del objeto**. Los demás parámetros los puedes utilizar como si fueran de una función. Espero haberte ayudado. **¡Nunca pares de aprender!** 🚀🚀

```python #Consideraciónes del Consecionaria: # - Se puede hacer la compra de los vehiculos # - Se puede hacer la venta de los vehiculos # - Gestionar los vehiculos y los users # - Los usuarios podran ver los vehiculos disponibles # - Los usuarios podran comprar los vehiculos disponibles # - Los usuarios podran vender vehiculos registrados en la consecionaria class Car: def __init__(self, car, brand, price): self.car_name = car self.car_brand = brand self.price = price self.available_car = True def buy_car(self): if self.available_car: self.available_car = False print(f"El carro {self.car_name} marca {self.car_brand}") print(f"Ha sido vendido exitosamente por $ {self.price}") else: print(f"El carro {self.car_name} marca {self.car_brand}, no esta disponible en estos momentos") def sell_car(self,asking_price): if asking_price >= self.price * 0.6: self.available_car = True print(f"El carro {self.car_name} marca {self.car_brand} fue vendido exitosatamente por $ {asking_price}") else: print(f"El precio pedido de {asking_price} por el carro {self.car_name} marca {self.car_brand} no supera el monto aceptable ") class User: def __init__(self, name, budget): self.name_user = name self.budge_user = budget self.enabled_user = True def user_sell_car(self, car, asking_price): if self.enabled_user: print() car.sell_car(asking_price) def user_buy_car(self, car): if self.enabled_user: if car.price <= self.budge_user and car.available_car: car.buy_car() elif car.price >= self.budge_user and (car.available_car) : print(f"Lo sentimos {self.name_user} el precio del vehiculo supera su presupuesto") print(f"Precio del vehiculo $ {car.price}") print(f"Su presupuesto actual registrado es de $ {self.budge_user}") print("El monto restante seria de $", car.price - self.budge_user) else: print(f"EL carro {car.car_name} no esta disponible") else: print(f"La venta no se pudo efectuar el {self.name_user}, esta deshabilitado para comprar") class Consecionario: def __init__(self): self.cars_of_concesionario = [] self.user_of_concesionario = [] def add_car(self, car): if car.available_car: self.cars_of_concesionario.append(car) else: print(f"El carro {car.car_name} marca no esta habilitado para agregarlo al consecionario") def register_user(self, user): if user.enabled_user: self.user_of_concesionario.append(user) else: print(f"El user {user.name_user} esta deshabilitado ") def show_cars_consecionario(self): print("Carros disponibles son-->") for car in self.cars_of_concesionario: if car.available_car: print(f"carro -> {car.car_name} marca -> {car.car_brand} precio -> {car.price}") #Crear carros car1 = Car("agt400","Mercees",100100) car2 = Car("xyz123", "BMW", 85000) car3 = Car("abc456", "Audi", 95000) #Crear users user1 = User("jdmaster",120120120) user2 = User("Ungenio",1) #Añadir carro al consecionario Consecionario = Consecionario() Consecionario.add_car(car1) Consecionario.add_car(car2) Consecionario.add_car(car3) #Añadir users al consecionario Consecionario.register_user(user1) Consecionario.register_user(user2) #Mostrar los carros disponibles Consecionario.show_cars_consecionario() #Prueba: user1 intente comprar el car1 user1.user_buy_car(car1) #Mostrar los carros disponibles Consecionario.show_cars_consecionario() #Prueba: user2 intente comprar todos los carros user2.user_buy_car(car1) user2.user_buy_car(car2) user2.user_buy_car(car3) #Prueba: user1 intenta comprar todos los carros user1.user_buy_car(car1) user1.user_buy_car(car2) user1.user_buy_car(car3) #Prueba: User1 vende el car1 user1.user_sell_car(car1,60060) #Mostrar los carros disponibles Consecionario.show_cars_consecionario() ```#Consideraciónes del Consecionaria:# - Se puede hacer la compra de los vehiculos# - Se puede hacer la venta de los vehiculos# - Gestionar los vehiculos y los users # - Los usuarios podran ver los vehiculos disponibles# - Los usuarios podran comprar los vehiculos disponibles # - Los usuarios podran vender vehiculos registrados en la consecionaria class Car:        def \_\_init\_\_(self, car, brand, price):        self.car\_name = car        self.car\_brand = brand        self.price = price        self.available\_car = True     def buy\_car(self):                if self.available\_car:            self.available\_car = False            print(f"El carro {self.car\_name} marca {self.car\_brand}")            print(f"Ha sido vendido exitosamente por $ {self.price}")        else:            print(f"El carro {self.car\_name} marca {self.car\_brand}, no esta disponible en estos momentos")                def sell\_car(self,asking\_price):                if asking\_price >= self.price \* 0.6:            self.available\_car = True            print(f"El carro {self.car\_name} marca {self.car\_brand} fue vendido exitosatamente por $ {asking\_price}")        else:            print(f"El precio pedido de {asking\_price} por el carro {self.car\_name} marca {self.car\_brand} no supera el monto aceptable ") class User:    def \_\_init\_\_(self, name, budget):        self.name\_user = name        self.budge\_user = budget        self.enabled\_user = True                def user\_sell\_car(self, car, asking\_price):                if self.enabled\_user:            print()            car.sell\_car(asking\_price)        def user\_buy\_car(self, car):                if self.enabled\_user:            if car.price <= self.budge\_user and car.available\_car:                 car.buy\_car()            elif car.price >= self.budge\_user and (car.available\_car) :                 print(f"Lo sentimos {self.name\_user} el precio del vehiculo supera su presupuesto")                print(f"Precio del vehiculo $ {car.price}")                print(f"Su presupuesto actual registrado es de $ {self.budge\_user}")                print("El monto restante seria de $", car.price - self.budge\_user)            else:                print(f"EL carro {car.car\_name} no esta disponible")                             else:             print(f"La venta no se pudo efectuar el {self.name\_user}, esta deshabilitado para comprar")                        class Consecionario:        def \_\_init\_\_(self):        self.cars\_of\_concesionario = \[]        self.user\_of\_concesionario = \[]                 def add\_car(self, car):        if car.available\_car:            self.cars\_of\_concesionario.append(car)        else:            print(f"El carro {car.car\_name} marca no esta habilitado para agregarlo al consecionario")        def register\_user(self, user):        if user.enabled\_user:            self.user\_of\_concesionario.append(user)                else:            print(f"El user {user.name\_user} esta deshabilitado ")        def show\_cars\_consecionario(self):                print("Carros disponibles son-->")        for car in self.cars\_of\_concesionario:            if car.available\_car:                print(f"carro -> {car.car\_name} marca -> {car.car\_brand} precio -> {car.price}")                                         #Crear carroscar1 = Car("agt400","Mercees",100100)car2 = Car("xyz123", "BMW", 85000)car3 = Car("abc456", "Audi", 95000) \#Crear usersuser1 = User("jdmaster",120120120)user2 = User("Ungenio",1) \#Añadir carro al consecionarioConsecionario = Consecionario()Consecionario.add\_car(car1)Consecionario.add\_car(car2)Consecionario.add\_car(car3) \#Añadir users al consecionarioConsecionario.register\_user(user1)Consecionario.register\_user(user2) \#Mostrar los carros disponiblesConsecionario.show\_cars\_consecionario() \#Prueba: user1 intente comprar el car1user1.user\_buy\_car(car1) \#Mostrar los carros disponiblesConsecionario.show\_cars\_consecionario() \#Prueba: user2 intente comprar todos los carrosuser2.user\_buy\_car(car1)user2.user\_buy\_car(car2)user2.user\_buy\_car(car3) \#Prueba: user1 intenta comprar todos los carrosuser1.user\_buy\_car(car1)user1.user\_buy\_car(car2)user1.user\_buy\_car(car3) \#Prueba: User1 vende el car1 user1.user\_sell\_car(car1,60060) \#Mostrar los carros disponiblesConsecionario.show\_cars\_consecionario()

Dejo mi aporte de la solución, también agregué una funcion en la que los usuarios podían contar con vehiculos antes de la concesionaria ```python #Desarrolla una concesionaria de vehículos en la cual se puedan gestionar las compras y ventas de vehículos. Un usuario podrá ver los vehículos disponibles, su precio y realizar la compra de uno. Aplica los conceptos de programación orientada a objetos vistos en este ejercicio. class Vehiculo: def __init__(self, modelo, precio): self.modelo=modelo self.precio=precio self.available=True def vendido(self, user): if self.available: self.available=False print(f"El vehículo {self.modelo} ha sido vendido al cliente {user.nombre}") print() else: print(f"El vehículo {self.available} no se encuentra disponible en la concesionaria") print() def comprar(self): self.available=True print(f"El vehiculo {self.available} ha sido comprado por la concesionaria") class User: def __init__(self, nombre, id): self.nombre=nombre self.id=id self.autos_user=[] def add_vehiculos_usuario(self, vehiculo): vehiculo.available=False self.autos_user.append(vehiculo) def show_usar_cars(self): print(f"Vehículos del usuario {self.nombre}:") for car in self.autos_user: print(f"Modelo: {car.modelo}") print() def comprar_vehiculo(self, vehiculo): if vehiculo.available: vehiculo.vendido(self) self.autos_user.append(vehiculo) else: print(f"El vehículo {vehiculo.modelo} no está disponible") def vender_vehiculo(self, vehiculo, concesionaria): if vehiculo in self.autos_user: self.autos_user.remove(vehiculo) print(f"El vehiculo {vehiculo.modelo} del usuario {self.nombre} ha sido vendido a la concesionaria") vehiculo.available=True concesionaria.add_vehiculo(vehiculo) else: print(f"{self.nombre} No tiene en poseción el vehículo {vehiculo.modelo} y por lo tanto no se puede vender") print() class Concesionaria: def __init__(self): self.vehiculos_concesionaria=[] self.usuarios=[] def add_vehiculo(self, vehiculo): self.vehiculos_concesionaria.append(vehiculo) print(f"El vehiculo {vehiculo.modelo} ha sido agregado a la concesionaria") print() def registrar_usuario(self, user): self.usuarios.append(user) print(f"El usuario {user.nombre} ha sido registrado") print() def show_vehiculos(self): print("Vehiculos disponibles en concesionaria:") for car in self.vehiculos_concesionaria: if car.available: print(f"Modelo: {car.modelo}\t${car.precio}") print() #se crean los autos auto1=Vehiculo("Mazda 3", "1,200,000") auto2=Vehiculo("Jetta 2024", "450,000") auto3=Vehiculo("Onix 2021", "350,000") auto4=Vehiculo("Chevy 2009", "60,000") auto5=Vehiculo("Stratus 2006", "25,000") #Se crean usuarios user1=User("Eli","001") user2=User("Eduardo","002") #Se registran los usuario de los usuarios user1.add_vehiculos_usuario(auto4) user2.add_vehiculos_usuario(auto5) user1.show_usar_cars() user2.show_usar_cars() #Crear concesionaria y agregar autos concesionaria=Concesionaria() concesionaria.add_vehiculo(auto1) concesionaria.add_vehiculo(auto2) concesionaria.add_vehiculo(auto3) concesionaria.registrar_usuario(user1) concesionaria.registrar_usuario(user2) #Mostrar autos de la concesionaria concesionaria.show_vehiculos() #usuarios compran autos user1.comprar_vehiculo(auto1) user2.comprar_vehiculo(auto2) #Mostrar autos en concesionaria y usuarios concesionaria.show_vehiculos() user1.show_usar_cars() user2.show_usar_cars() #Vender autos de usuarios y a cual concesionaria user1.vender_vehiculo(auto4, concesionaria) user2.vender_vehiculo(auto5, concesionaria) user2.vender_vehiculo(auto5, concesionaria) #Mostrar vehiculos de usuarios y concesionaria user1.show_usar_cars() user2.show_usar_cars() concesionaria.show_vehiculos() ```#Desarrolla una concesionaria de vehículos en la cual se puedan gestionar las compras y ventas de vehículos. Un usuario podrá ver los vehículos disponibles, su precio y realizar la compra de uno. Aplica los conceptos de programación orientada a objetos vistos en este ejercicio. class Vehiculo:    def \_\_init\_\_(self, modelo, precio):        self.modelo=modelo        self.precio=precio        self.available=True     def vendido(self, user):        if self.available:            self.available=False            print(f"El vehículo {self.modelo} ha sido vendido al cliente {user.nombre}")            print()        else:            print(f"El vehículo {self.available} no se encuentra disponible en la concesionaria")            print()        def comprar(self):        self.available=True        print(f"El vehiculo {self.available} ha sido comprado por la concesionaria")                        class User:    def \_\_init\_\_(self, nombre, id):        self.nombre=nombre        self.id=id        self.autos\_user=\[]            def add\_vehiculos\_usuario(self, vehiculo):        vehiculo.available=False        self.autos\_user.append(vehiculo)        def show\_usar\_cars(self):        print(f"Vehículos del usuario {self.nombre}:")        for car in self.autos\_user:            print(f"Modelo: {car.modelo}")        print()            def comprar\_vehiculo(self, vehiculo):        if vehiculo.available:            vehiculo.vendido(self)            self.autos\_user.append(vehiculo)        else:            print(f"El vehículo {vehiculo.modelo} no está disponible")        def vender\_vehiculo(self, vehiculo, concesionaria):        if vehiculo in self.autos\_user:            self.autos\_user.remove(vehiculo)            print(f"El vehiculo {vehiculo.modelo} del usuario {self.nombre} ha sido vendido a la concesionaria")            vehiculo.available=True            concesionaria.add\_vehiculo(vehiculo)        else:            print(f"{self.nombre} No tiene en poseción el vehículo {vehiculo.modelo} y por lo tanto no se puede vender")            print()            class Concesionaria:    def \_\_init\_\_(self):        self.vehiculos\_concesionaria=\[]        self.usuarios=\[]        def add\_vehiculo(self, vehiculo):        self.vehiculos\_concesionaria.append(vehiculo)        print(f"El vehiculo {vehiculo.modelo} ha sido agregado a la concesionaria")        print()            def registrar\_usuario(self, user):        self.usuarios.append(user)        print(f"El usuario {user.nombre} ha sido registrado")        print()        def show\_vehiculos(self):        print("Vehiculos disponibles en concesionaria:")        for car in self.vehiculos\_concesionaria:            if car.available:                print(f"Modelo: {car.modelo}\t${car.precio}")        print() \#se crean los autosauto1=Vehiculo("Mazda 3", "1,200,000")auto2=Vehiculo("Jetta 2024", "450,000")auto3=Vehiculo("Onix 2021", "350,000")auto4=Vehiculo("Chevy 2009", "60,000")auto5=Vehiculo("Stratus 2006", "25,000") \#Se crean usuariosuser1=User("Eli","001")user2=User("Eduardo","002") \#Se registran los usuario de los usuariosuser1.add\_vehiculos\_usuario(auto4)user2.add\_vehiculos\_usuario(auto5)user1.show\_usar\_cars()user2.show\_usar\_cars() \#Crear concesionaria y agregar autosconcesionaria=Concesionaria()concesionaria.add\_vehiculo(auto1)concesionaria.add\_vehiculo(auto2)concesionaria.add\_vehiculo(auto3)concesionaria.registrar\_usuario(user1)concesionaria.registrar\_usuario(user2) \#Mostrar autos de la concesionariaconcesionaria.show\_vehiculos() \#usuarios compran autosuser1.comprar\_vehiculo(auto1)user2.comprar\_vehiculo(auto2) \#Mostrar autos en concesionaria y usuariosconcesionaria.show\_vehiculos()user1.show\_usar\_cars()user2.show\_usar\_cars() \#Vender autos de usuarios y a cual concesionariauser1.vender\_vehiculo(auto4, concesionaria)user2.vender\_vehiculo(auto5, concesionaria)user2.vender\_vehiculo(auto5, concesionaria) \#Mostrar vehiculos de usuarios y concesionariauser1.show\_usar\_cars()user2.show\_usar\_cars()concesionaria.show\_vehiculos()

Dejo mi aporte con respecto al ejercicio de concesionarios ```js class Carro : def __init__(self, precio, modelo): self.precio = precio self.modelo = modelo self.available = True def sale_car(self): if self.available: self.available = False print('El carro con el modelo {self.modelo} fue vendido') else: print('Carro no disponible para su venta') def devolucion_car(self): self.available = True print('Se devolvió el carro') class User : def __init__(self, name, user_id, dinero): self.user_id = user_id self.name = name self.dinero = dinero self.carros_comprados = [] def compra_cars(self, carro): if carro.available: if self.dinero >= carro.precio: carro.sale_car() self.carros_comprados.append(carro) self.dinero -= carro.precio print(f'Felicidades {self.name} por la compra de tu nuevo carro, tu nuevo saldo es {self.dinero}') else: print(f'No tienes el monto suficiente para la compra {self.name}') else: print(f'El carro no esta disponible {self.name}') class Concesionaria : def __init__(self): self.users = [] self.carros = [] def register_user(self, user): self.users.append(user) print(f'El usuario {user.name} fue refistrado exitosamente') def add_carro(self, carro): self.carros.append(carro) print(f'El carro con modelo {carro.modelo} ha sido agregado') def available_car(self): available = [carro for carro in self.carros if carro.available] if available: print('Carros disponibles') for carro in available: print(f'{carro.modelo} con precio de {carro.precio}') else: print('No hay carros disponibles') concesio = Concesionaria() user1 = User('Cesar', 1, 8000) user2 = User('Cristina', 2, 8800) vehi1 = Carro(1580, 'Kia pride') vehi2 = Carro(2390, 'Kia rio') concesio.register_user(user1) concesio.register_user(user2) concesio.add_carro(vehi1) concesio.add_carro(vehi2) user1.compra_cars(vehi1) user2.compra_cars(vehi2) concesio.available_car() ```class Carro :    def \_\_init\_\_(self, precio, modelo):        self.precio = precio        self.modelo = modelo        self.available = True     def sale\_car(self):        if self.available:            self.available = False            print('El carro con el modelo {self.modelo} fue vendido')        else:            print('Carro no disponible para su venta')     def devolucion\_car(self):        self.available = True        print('Se devolvió el carro') class User :    def \_\_init\_\_(self, name, user\_id, dinero):        self.user\_id = user\_id        self.name = name        self.dinero = dinero        self.carros\_comprados = \[]        def compra\_cars(self, carro):        if carro.available:            if self.dinero >= carro.precio:                carro.sale\_car()                self.carros\_comprados.append(carro)                self.dinero -= carro.precio                print(f'Felicidades {self.name} por la compra de tu nuevo carro, tu nuevo saldo es {self.dinero}')            else:                print(f'No tienes el monto suficiente para la compra {self.name}')        else:            print(f'El carro no esta disponible {self.name}') class Concesionaria :    def \_\_init\_\_(self):        self.users = \[]        self.carros = \[]        def register\_user(self, user):        self.users.append(user)        print(f'El usuario {user.name} fue refistrado exitosamente')        def add\_carro(self, carro):        self.carros.append(carro)        print(f'El carro con modelo {carro.modelo} ha sido agregado')            def available\_car(self):        available = \[carro for carro in self.carros if carro.available]        if available:            print('Carros disponibles')            for carro in available:                print(f'{carro.modelo} con precio de {carro.precio}')        else:            print('No hay carros disponibles') concesio = Concesionaria()user1 = User('Cesar', 1, 8000)user2 = User('Cristina', 2, 8800)vehi1 = Carro(1580, 'Kia pride')vehi2 = Carro(2390, 'Kia rio')concesio.register\_user(user1)concesio.register\_user(user2)concesio.add\_carro(vehi1)concesio.add\_carro(vehi2)user1.compra\_cars(vehi1)user2.compra\_cars(vehi2)concesio.available\_car()

```python class Car: # Comprar y vender autos. def __init__(self, title, price): self.title = title self.price = price self.available = True def sell(self): if self.available: self.available = False print(f"El auto {self.title} ha sido vendido a un precio de {self.price}") else: print(f"El auto {self.title} no se encuentra disponible") def buy(self): self.available = True print(f"El auto {self.title} ha sido comprado por la concesionaria") class User: # Ver autos disponibles con el precio y poder comprarlos. def __init__(self, name, userID): self.name = name self.userID = userID self.carsBought = [] def buyCar(self, car): if car.available: car.sell() self.carsBought.append(car) else: print(f"El auto {car.title} no está disponible") def sellCar(self, car): if car in self.carsBought: car.buy() self.carsBought.remove(car) else: print(f"El auto {car.title} no está en la lista de comprados") class Dealership: # Mostrar autos y usuarios disponibles. def __init__(self): self.cars = [] self.users = [] def addCar(self, car): self.cars.append(car) print(f"El auto {car.title} ha sido agregado") def registerUser(self, user): self.users.append(user) print(f"El usuario {user.name} ha sido registrado") def showAvailableCars(self): print("Autos disponibles:") for car in self.cars: if car.available: print(f"{car.title} a ${car.price}") # Crear los autos: car1 = Car("Aston Martin DB12", "314.000") car2 = Car("Audi A5", "88.000") car3 = Car("Ford Mustang", "40.000") # Crear los usuarios: user1 = User("Denis", "001") user2 = User("Marcelo", "002") # Crear la concesionaria: dealership = Dealership() dealership.addCar(car1) dealership.addCar(car2) dealership.addCar(car3) dealership.registerUser(user1) dealership.registerUser(user2) # Mostrar autos: dealership.showAvailableCars() # Usuario compra auto: user1.buyCar(car1) # Mostrar autos: dealership.showAvailableCars() # Usuario vende auto: user1.sellCar(car1) # Mostrar autos: dealership.showAvailableCars() ```

Hola compañeros! Espero que estén todos bien. Yo he intentado darle una vuelta de rosca al ejercicio y he añadido un pequeño "control de stock" de los coches disponibles. ```js from datetime import datetime class Car: def __init__(self, marca, modelo, precio): self.marca = marca self.modelo = modelo self.precio = precio self.is_available = True def check_availability(self): return self.is_available def get_precio(self): return self.precio class User: def __init__(self, name, name_id): self.name = name self.name_id = name_id self.car_boughts = [] # Lista para almacenar los coches comprados def buy_car(self, concesionario, car): # Se efectúa la compra si hay stock disponible del coche if (car.marca, car.modelo) in concesionario.stock and concesionario.stock[(car.marca, car.modelo)]["stock"] > 0: # Obtener el coche desde el concesionario car, precio, fecha_compra = concesionario.sell_car(car.marca, car.modelo) # Se registra la compra del coche con la fecha actual self.car_boughts.append({ 'marca': car.marca, 'modelo': car.modelo, 'precio': precio, 'fecha_compra': fecha_compra }) print(f"{self.name} ha comprado un {car.marca} {car.modelo} por {car.precio}€ el {fecha_compra}. Stock disponible del modelo de coche vendido: {concesionario.stock[(car.marca, car.modelo)]["stock"]}") def mostrar_compras(self): # Muestra todas las compras del usuario if self.car_boughts: for compra in self.car_boughts: print(f"Marca: {compra['marca']}, Modelo: {compra['modelo']}, Precio: {compra['precio']}€, Fecha de compra: {compra['fecha_compra']}") else: print(f"{self.name} no ha realizado ninguna compra aún.") class Concesionario: def __init__(self): self.cars = [] self.users = [] self.stock = {} def add_car(self, car): if (car.marca, car.modelo) in self.stock: self.stock[(car.marca, car.modelo)]["stock"] += 1 else: self.stock[(car.marca, car.modelo)] = { "car": car, "precio": car.precio, "stock": 1 } print(f'El coche {car.marca} {car.modelo} ha sido registrado. Precio de venta: {car.precio}') def register_user(self, user): self.users.append(user) print(f"El usuario {user.name} ha sido registrado") def show_available_cars(self): print("Coches disponibles:") for (marca, modelo), data in self.stock.items(): if data["stock"] > 0: print(f"{marca} {modelo}. Precio = {data['precio']}. Stock disponible = {data['stock']}") def sell_car(self, marca, modelo): if (marca, modelo) in self.stock and self.stock[(marca, modelo)]["stock"] > 0: car = self.stock[(marca, modelo)]["car"] precio = self.stock[(marca, modelo)]["precio"] self.stock[(marca, modelo)]["stock"] -= 1 fecha_compra = datetime.now().strftime("%Y-%m-%d %H:%M:%S") return car, precio, fecha_compra else: return None, None, None # Crear modelos de coches coche1 = Car("Toyota", "Prius", 27000) coche2 = Car("Renault", "Traffic", 25000) # Crear usuarios user1 = User("Rober","001") # Crear concesionario concesionario = Concesionario() concesionario.add_car(coche1) concesionario.add_car(coche2) concesionario.register_user(user1) # Mostrar coches disponibles concesionario.show_available_cars() concesionario.add_car(coche1) concesionario.show_available_cars() # Consultar precio de coche coche2.get_precio() # Comprar coche user1.buy_car(concesionario, coche2) ```

Hola, me compliqué bastante con el reto de esta clase pero aprendí mucho en el proceso, aquí mi solución: class Vehicle: def __init__(self, brand, year, price): self.brand = brand self.year = year self.price = price self.available = True def selled(self, vehicle): if self.available: self.available = False print(f"La compra del vehiculo {vehicle.brand} del {vehicle.year} ha sido realizada con exito") else: print(f"El vehiculo {vehicle.brand} del {vehicle.year} no está disponible") def added(self, vehicle): self.available = True print((f"El vehiculo {vehicle.brand} del {vehicle.year} ha sido añadido")) class User: def __init__(self, name, user_id, store): self.name = name self.user_id = user_id self.store = store def buy_vehicle(self, vehicle, store): for vehicle in self.store.vehicles: if vehicle.available: vehicle.selled(vehicle) self.store.vehicles.remove(vehicle) else: print(f"El vehiculo {vehicle.brand} del {vehicle.year} no esta disponible") def show_available_vehicles(self, store): if len(self.store.vehicles) > 0: print("Vehiculos disponibles: ") for vehicle in self.store.vehicles: if vehicle.available: print(f"{vehicle.brand} del {vehicle.year}. Precio: {vehicle.price}") else: print("NO hay vehiculos disponibles") class Store: def __init__(self): self.vehicles = [] self.users = [] def add_vehicle(self, vehicle): self.vehicles.append(vehicle) print(f"El vehiculo {vehicle.brand} del {vehicle.year} ha sido agregado") def register_user(self, user): self.users.append(user) print(f"El usuario {user.name} ha sido registrado") v1 = Vehicle("Nissan", "1993", "$20 000") v2 = Vehicle("Toyota", "2020", "$40 000") shop = Store() user1 = User("Marilyn", "001", shop) shop.add_vehicle(v1) shop.add_vehicle(v2) shop.register_user(user1) user1.show_available_vehicles(shop) user1.buy_vehicle(v1, shop) user1.show_available_vehicles(shop) user1.buy_vehicle(v2, shop) user1.buy_vehicle(v1, shop) user1.show_available_vehicles(shop)

```js class Dealer: def __init__(self): self.vehicles = [] self.users = [] def add_vehicle(self, vehicle): self.vehicles.append(vehicle) print(f'El vehiculo {vehicle.name} ha sido agregado') def show_available_vehicles(self): print('Vehiculos disponibles: ') for vehicle in self.vehicles: if vehicle.available: print(f'{vehicle.name} por {vehicle.price}') class Vehicle: def __init__(self, name, price): self.name = name self.price = price self.available = True def acquire(self): if self.available: self.available = False print(f'Ha adquirido el vehiculo {self.name}') else: print(f'El vehiculo {self.name}, no se encuentra disponible') def deliver(self): self.available = True print(f'Ha entregado el vehiculo {self.name}') class User: def __init__(self, name, user_id): self.name = name self.user_id = user_id self.list_vehicles = [] def purchase(self, vehicle): if vehicle.available: vehicle.acquire() self.list_vehicles.append(vehicle) else: print(f'El vehiculo {vehicle.name}, no se encuentra disponible') def deliver_vehicle(self, vehicle): if vehicle in self.list_vehicles: vehicle.deliver() self.list_vehicles.remove(vehicle) else: print(f'El vehiculo {vehicle.name} no esta en mi poder.') #Creacion de los objetos vehiculo_1 = Vehicle('Mazda 3', 5000) vehiculo_2 = Vehicle('Suzuki', 3000) usuario_1 = User('Andres', '001') consecionario = Dealer() #Agregando los vehiculos al consecionario. consecionario.add_vehicle(vehiculo_1) consecionario.add_vehicle(vehiculo_2) #Mostrar vehiculos disponibles consecionario.show_available_vehicles() #Usuario compra el vehiculo usuario_1.purchase(vehiculo_1) #usuario_1.purchase(vehiculo_2) #Mostrar vehiculos disponibles consecionario.show_available_vehicles() usuario_1.deliver_vehicle(vehiculo_1) consecionario.show_available_vehicles() ```

```js class Dealer: def __init__(self): self.vehicles = [] self.users = [] def add_vehicle(self, vehicle): self.vehicles.append(vehicle) print(f'El vehiculo {vehicle.name} ha sido agregado') def show_available_vehicles(self): print('Vehiculos disponibles: ') for vehicle in self.vehicles: if vehicle.available: print(f'{vehicle.name} por {vehicle.price}') class Vehicle: def __init__(self, name, price): self.name = name self.price = price self.available = True def acquire(self): if self.available: self.available = False print(f'Ha adquirido el vehiculo {self.name}') else: print(f'El vehiculo {self.name}, no se encuentra disponible') def deliver(self): self.available = True print(f'Ha entregado el vehiculo {self.name}') class User: def __init__(self, name, user_id): self.name = name self.user_id = user_id self.list_vehicles = [] def purchase(self, vehicle): if vehicle.available: vehicle.acquire() self.list_vehicles.append(vehicle) else: print(f'El vehiculo {vehicle.name}, no se encuentra disponible') def deliver_vehicle(self, vehicle): if vehicle in self.list_vehicles: vehicle.deliver() self.list_vehicles.remove(vehicle) else: print(f'El vehiculo {vehicle.name} no esta en mi poder.') #Creacion de los objetos vehiculo_1 = Vehicle('Mazda 3', 5000) vehiculo_2 = Vehicle('Suzuki', 3000) usuario_1 = User('Andres', '001') consecionario = Dealer() #Agregando los vehiculos al consecionario. consecionario.add_vehicle(vehiculo_1) consecionario.add_vehicle(vehiculo_2) #Mostrar vehiculos disponibles consecionario.show_available_vehicles() #Usuario compra el vehiculo usuario_1.purchase(vehiculo_1) #usuario_1.purchase(vehiculo_2) #Mostrar vehiculos disponibles consecionario.show_available_vehicles() usuario_1.deliver_vehicle(vehiculo_1) consecionario.show_available_vehicles() ```class Dealer:    def \_\_init\_\_(self):        self.vehicles = \[]        self.users = \[]        def add\_vehicle(self, vehicle):        self.vehicles.append(vehicle)        print(f'El vehiculo {vehicle.name} ha sido agregado')        def show\_available\_vehicles(self):        print('Vehiculos disponibles: ')        for vehicle in self.vehicles:            if vehicle.available:                print(f'{vehicle.name} por {vehicle.price}') class Vehicle:    def \_\_init\_\_(self, name, price):        self.name = name        self.price = price        self.available = True        def acquire(self):        if self.available:            self.available = False            print(f'Ha adquirido el vehiculo {self.name}')        else:            print(f'El vehiculo {self.name}, no se encuentra disponible')        def deliver(self):        self.available = True        print(f'Ha entregado el vehiculo {self.name}') class User:    def \_\_init\_\_(self, name, user\_id):        self.name = name        self.user\_id = user\_id        self.list\_vehicles = \[]        def purchase(self, vehicle):        if vehicle.available:            vehicle.acquire()            self.list\_vehicles.append(vehicle)        else:            print(f'El vehiculo {vehicle.name}, no se encuentra disponible')     def deliver\_vehicle(self, vehicle):        if vehicle in self.list\_vehicles:            vehicle.deliver()            self.list\_vehicles.remove(vehicle)        else:            print(f'El vehiculo {vehicle.name} no esta en mi poder.') \#Creacion de los objetosvehiculo\_1 = Vehicle('Mazda 3', 5000)vehiculo\_2 = Vehicle('Suzuki', 3000)usuario\_1 = User('Andres', '001')consecionario = Dealer() \#Agregando los vehiculos al consecionario.consecionario.add\_vehicle(vehiculo\_1)consecionario.add\_vehicle(vehiculo\_2)#Mostrar vehiculos disponiblesconsecionario.show\_available\_vehicles()#Usuario compra el vehiculousuario\_1.purchase(vehiculo\_1)#usuario\_1.purchase(vehiculo\_2)#Mostrar vehiculos disponiblesconsecionario.show\_available\_vehicles() usuario\_1.deliver\_vehicle(vehiculo\_1) consecionario.show\_available\_vehicles()

`class Dealer:    def __init__(self):        self.vehicles = []        self.users = []        def add_vehicle(self, vehicle):        self.vehicles.append(vehicle)        print(f'El vehiculo {vehicle.name} ha sido agregado')        def show_available_vehicles(self):        print('Vehiculos disponibles: ')        for vehicle in self.vehicles:            if vehicle.available:                print(f'{vehicle.name} por {vehicle.price}')` `class Vehicle:    def __init__(self, name, price):        self.name = name        self.price = price        self.available = True        def acquire(self):        if self.available:            self.available = False            print(f'Ha adquirido el vehiculo {self.name}')        else:            print(f'El vehiculo {self.name}, no se encuentra disponible')        def deliver(self):        self.available = True        print(f'Ha entregado el vehiculo {self.name}')` `class User:    def __init__(self, name, user_id):        self.name = name        self.user_id = user_id        self.list_vehicles = []        def purchase(self, vehicle):        if vehicle.available:            vehicle.acquire()            self.list_vehicles.append(vehicle)        else:            print(f'El vehiculo {vehicle.name}, no se encuentra disponible')` `    def deliver_vehicle(self, vehicle):        if vehicle in self.list_vehicles:            vehicle.deliver()            self.list_vehicles.remove(vehicle)        else:            print(f'El vehiculo {vehicle.name} no esta en mi poder.')` `#Creacion de los objetosvehiculo_1 = Vehicle('Mazda 3', 5000)vehiculo_2 = Vehicle('Suzuki', 3000)usuario_1 = User('Andres', '001')consecionario = Dealer()` `#Agregando los vehiculos al consecionario.consecionario.add_vehicle(vehiculo_1)consecionario.add_vehicle(vehiculo_2)#Mostrar vehiculos disponiblesconsecionario.show_available_vehicles()#Usuario compra el vehiculousuario_1.purchase(vehiculo_1)#usuario_1.purchase(vehiculo_2)#Mostrar vehiculos disponiblesconsecionario.show_available_vehicles()` `usuario_1.deliver_vehicle(vehiculo_1)` `consecionario.show_available_vehicles()`

Vale, logre terminar el Código: ```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: self.available = False print(f'El carro {self.brand} {self.model} ha sido vendido por un valor de {self.price}') def resell(self): if not self.available: self.available = True print(f'El carro {self.brand} {self.model} ha sido recomprado por la concesionaria por un valor de {self.price}') class Customer: def __init__(self, name, customer_id): self.name = name self.customer_id = customer_id def buy_car(self, *cars): for car in cars: # Se recorre la lista de carros, si el carro esta disponible se vende, si no, se imprime un mensaje if car.available: car.sell() print(f'Felicitaciones {self.name}, has comprado un {car.brand} {car.model} por un valor de {car.price}') else: print(f'Lo sentimos {self.name}, el carro {car.brand} {car.model} no esta disponible en estos momentos') def sell_car(self, car): if not car.available: car.resell() print(f'{self.name}, Te hemos comprado el carro {car.brand} {car.model} por un valor de {car.price}') else: print(f'El carro {car.brand} {car.model} no ha sido Comprado') class Dealership: def __init__(self): self.cars = [] self.customers = [] def add_car(self, car): self.cars.append(car) #Se agrega el carro a la lista de carros print(f'El carro {car.brand} {car.model} ha sido agregado a la concesionaria') def register_customer(self, customer): self.customers.append(customer) #Se agrega el cliente a la lista de clientes print(f'El cliente {customer.name} ha sido registrado en la base de datos de la concesionaria') def show_cars(self): print('Carros disponibles: ') for car in self.cars: if car.available: print(f'{car.brand} {car.model} con un precio de {car.price}') else: print(f'Ha sido un excelente mes, no tenemos carros disponibles en este momento') # Listado de carros car1 = Car('Toyota', 'Corolla', 20000) car2 = Car('Chevrolet', 'Spark', 15000) car3 = Car('Mazda', 'CX-5', 30000) # Listado de clientes customer1 = Customer('David', 1) customer2 = Customer('Paula', 2) customer3 = Customer('Luis', 3) # Crear la concesionaria dealership = Dealership() dealership.add_car(car1) dealership.add_car(car2) dealership.add_car(car3) dealership.register_customer(customer1) dealership.register_customer(customer2) dealership.register_customer(customer3) # Mostrar los carros disponibles dealership.show_cars() customer1.buy_car(car1, car2) customer2.buy_car(car1) customer1.sell_car(car1) customer2.buy_car(car1) customer3.buy_car(car3) dealership.show_cars() ```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:            self.available = False            print(f'El carro {self.brand} {self.model} ha sido vendido por un valor de {self.price}')        def resell(self):        if not self.available:            self.available = True            print(f'El carro {self.brand} {self.model} ha sido recomprado por la concesionaria por un valor de {self.price}') class Customer:    def \_\_init\_\_(self, name, customer\_id):        self.name = name        self.customer\_id = customer\_id        def buy\_car(self, \*cars):        for car in cars: # Se recorre la lista de carros, si el carro esta disponible se vende, si no, se imprime un mensaje            if car.available:                car.sell()                print(f'Felicitaciones {self.name}, has comprado un {car.brand} {car.model} por un valor de {car.price}')            else:                print(f'Lo sentimos {self.name}, el carro {car.brand} {car.model} no esta disponible en estos momentos')                    def sell\_car(self, car):        if not car.available:            car.resell()            print(f'{self.name}, Te hemos comprado el carro {car.brand} {car.model} por un valor de {car.price}')        else:            print(f'El carro {car.brand} {car.model} no ha sido Comprado')            class Dealership:    def \_\_init\_\_(self):        self.cars = \[]        self.customers = \[]            def add\_car(self, car):        self.cars.append(car)     #Se agrega el carro a la lista de carros        print(f'El carro {car.brand} {car.model} ha sido agregado a la concesionaria')            def register\_customer(self, customer):        self.customers.append(customer)  #Se agrega el cliente a la lista de clientes        print(f'El cliente {customer.name} ha sido registrado en la base de datos de la concesionaria')            def show\_cars(self):        print('Carros disponibles: ')        for car in self.cars:            if car.available:                print(f'{car.brand} {car.model} con un precio de {car.price}')        else:                print(f'Ha sido un excelente mes, no tenemos carros disponibles en este momento')                    \# Listado de carros car1 = Car('Toyota', 'Corolla', 20000)car2 = Car('Chevrolet', 'Spark', 15000)car3 = Car('Mazda', 'CX-5', 30000) \# Listado de clientescustomer1 = Customer('David', 1)customer2 = Customer('Paula', 2)customer3 = Customer('Luis', 3) \# Crear la concesionariadealership = Dealership()dealership.add\_car(car1)dealership.add\_car(car2)dealership.add\_car(car3)dealership.register\_customer(customer1)dealership.register\_customer(customer2)dealership.register\_customer(customer3) \# Mostrar los carros disponiblesdealership.show\_cars() customer1.buy\_car(car1, car2)customer2.buy\_car(car1) customer1.sell\_car(car1) customer2.buy\_car(car1)customer3.buy\_car(car3) dealership.show\_cars()

```python #Reto #Se tiene una concesionaría de vehículos en la cual se va a poder hacer la compra y venta. Ademas de gestionar los vehículos, un usuario va a poder preguntar, ¿cuáles son los que están disponibles?, su precio y también podrá comprar uno. #Nota: con un poco de ayuda de IA y sigo aprendiendo import datetime class Inventario: def __init__(self): self.inventario = {} self.ventas = [] self.sucursales = {} def agregar_auto(self, auto, cantidad, precio_compra, sucursal="central"): if auto in self.inventario: self.inventario[auto]["cantidad"] += cantidad else: self.inventario[auto] = { "cantidad": cantidad, "precio_compra": precio_compra, "precio_venta": 0, } # Agregar la cantidad de autos a la sucursal if sucursal not in self.sucursales: self.sucursales[sucursal] = {} if auto in self.sucursales[sucursal]: self.sucursales[sucursal][auto] += cantidad else: self.sucursales[sucursal][auto] = cantidad def establecer_precio_venta(self, auto, precio_venta): if auto in self.inventario: self.inventario[auto]["precio_venta"] = precio_venta else: print(f"El producto {auto} no existe en el inventario.") def vender_auto(self, auto, cantidad, sucursal="central"): if auto in self.inventario and self.inventario[auto]["cantidad"] >= cantidad: self.inventario[auto]["cantidad"] -= cantidad ingreso = cantidad * self.inventario[auto]["precio_venta"] costo = cantidad * self.inventario[auto]["precio_compra"] utilidad = ingreso - costo fecha = datetime.datetime.now() # Registrar la venta self.ventas.append({ "auto": auto, "cantidad": cantidad, "ingreso": ingreso, "costo": costo, "utilidad": utilidad, "fecha": fecha, "sucursal": sucursal, }) # Reducir la cantidad del producto en la sucursal if sucursal in self.sucursales and auto in self.sucursales[sucursal]: self.sucursales[sucursal][auto] -= cantidad else: print(f"El producto {auto} no existe en la sucursal {sucursal}.") else: print(f"El producto {auto} no tiene suficiente stock o no existe en el inventario.") def traspasar_auto(self, auto, cantidad, sucursal_origen, sucursal_destino): if sucursal_origen in self.sucursales and auto in self.sucursales[sucursal_origen] and self.sucursales[sucursal_origen][auto] >= cantidad: self.sucursales[sucursal_origen][auto] -= cantidad if sucursal_destino not in self.sucursales: self.sucursales[sucursal_destino] = {} if auto in self.sucursales[sucursal_destino]: self.sucursales[sucursal_destino][auto] += cantidad else: self.sucursales[sucursal_destino][auto] = cantidad else: print(f"No hay suficiente stock del auto {auto} en la sucursal {sucursal_origen}.") def generar_reporte_ventas(self): total_ingreso = sum(venta["ingreso"] for venta in self.ventas) total_costo = sum(venta["costo"] for venta in self.ventas) total_utilidad = sum(venta["utilidad"] for venta in self.ventas) print("Reporte de Ventas:") print(f"Total Ingreso: ${total_ingreso:.2f}") print(f"Total Costo: ${total_costo:.2f}") print(f"Total Utilidad: ${total_utilidad:.2f}\n") for venta in self.ventas: print(f"Auto: {venta['auto']} | Cantidad: {venta['cantidad']} | Ingreso: ${venta['ingreso']:.2f} | Costo: ${venta['costo']:.2f} | Utilidad: ${venta['utilidad']:.2f} | Fecha: {venta['fecha']} | Sucursal: {venta['sucursal']}") def generar_reporte_inventario(self): print("Reporte de Inventario:") for auto, detalles in self.inventario.items(): print(f"Producto: {auto} | Cantidad: {detalles['cantidad']} | Precio Compra: ${detalles['precio_compra']:.2f} | Precio Venta: ${detalles['precio_venta']:.2f}") def generar_reporte_inventario_sucursal(self, sucursal): print(f"Reporte de Inventario para la Sucursal {sucursal}:") if sucursal in self.sucursales: for auto, cantidad in self.sucursales[sucursal].items(): print(f"Auto: {auto} | Cantidad: {cantidad}") else: print(f"La sucursal {sucursal} no tiene autos.") #Ejemplos de uso de programa de inventario inventario = Inventario() #Agregar auto al inventario inventario.agregar_auto("March",5,165000) inventario.agregar_auto("Mazda 2",4,210000) inventario.agregar_auto("Mini Cooper",2,400000) #Establecer precios de venta inventario.establecer_precio_venta("March",190000) inventario.establecer_precio_venta("Mazda 2",260000) inventario.establecer_precio_venta("Mini Cooper",460000) #Vender auto inventario.vender_auto("March",2) inventario.vender_auto("Mazda 2",1) inventario.vender_auto("Mini Cooper",2) #Traspasar autos entre sucursales inventario.traspasar_auto("March",1,"central","sucursal_1") #Generar reportes inventario.generar_reporte_ventas() inventario.generar_reporte_inventario() inventario.generar_reporte_inventario_sucursal("sucursal_1") inventario.generar_reporte_inventario_sucursal("central") ```#Reto#Se tiene una concesionaría de vehículos en la cual se va a poder hacer la compra y venta. Ademas de gestionar los vehículos, un usuario va a poder preguntar, ¿cuáles son los que están disponibles?, su precio y también podrá comprar uno. import datetime class Inventario:    def \_\_init\_\_(self):        self.inventario = {}        self.ventas = \[]        self.sucursales = {}     def agregar\_auto(self, auto, cantidad, precio\_compra, sucursal="central"):        if auto in self.inventario:            self.inventario\[auto]\["cantidad"] += cantidad        else:            self.inventario\[auto] = {                "cantidad": cantidad,                "precio\_compra": precio\_compra,                "precio\_venta": 0,            }         # Agregar la cantidad de autos a la sucursal        if sucursal not in self.sucursales:            self.sucursales\[sucursal] = {}        if auto in self.sucursales\[sucursal]:            self.sucursales\[sucursal]\[auto] += cantidad        else:            self.sucursales\[sucursal]\[auto] = cantidad        def establecer\_precio\_venta(self, auto, precio\_venta):        if auto in self.inventario:            self.inventario\[auto]\["precio\_venta"] = precio\_venta        else:            print(f"El producto {auto} no existe en el inventario.")     def vender\_auto(self, auto, cantidad, sucursal="central"):        if auto in self.inventario and self.inventario\[auto]\["cantidad"] >= cantidad:            self.inventario\[auto]\["cantidad"] -= cantidad            ingreso = cantidad \* self.inventario\[auto]\["precio\_venta"]            costo = cantidad \* self.inventario\[auto]\["precio\_compra"]            utilidad = ingreso - costo            fecha = datetime.datetime.now()             # Registrar la venta            self.ventas.append({                "auto": auto,                "cantidad": cantidad,                "ingreso": ingreso,                "costo": costo,                "utilidad": utilidad,                "fecha": fecha,                "sucursal": sucursal,            })             # Reducir la cantidad del producto en la sucursal            if sucursal in self.sucursales and auto in self.sucursales\[sucursal]:                self.sucursales\[sucursal]\[auto] -= cantidad            else:                print(f"El producto {auto} no existe en la sucursal {sucursal}.")         else:            print(f"El producto {auto} no tiene suficiente stock o no existe en el inventario.")     def traspasar\_auto(self, auto, cantidad, sucursal\_origen, sucursal\_destino):        if sucursal\_origen in self.sucursales and auto in self.sucursales\[sucursal\_origen] and self.sucursales\[sucursal\_origen]\[auto] >= cantidad:            self.sucursales\[sucursal\_origen]\[auto] -= cantidad            if sucursal\_destino not in self.sucursales:                self.sucursales\[sucursal\_destino] = {}            if auto in self.sucursales\[sucursal\_destino]:                self.sucursales\[sucursal\_destino]\[auto] += cantidad            else:                self.sucursales\[sucursal\_destino]\[auto] = cantidad        else:            print(f"No hay suficiente stock del auto {auto} en la sucursal {sucursal\_origen}.")     def generar\_reporte\_ventas(self):        total\_ingreso = sum(venta\["ingreso"] for venta in self.ventas)        total\_costo = sum(venta\["costo"] for venta in self.ventas)        total\_utilidad = sum(venta\["utilidad"] for venta in self.ventas)         print("Reporte de Ventas:")        print(f"Total Ingreso: ${total\_ingreso:.2f}")        print(f"Total Costo: ${total\_costo:.2f}")        print(f"Total Utilidad: ${total\_utilidad:.2f}\n")         for venta in self.ventas:            print(f"Auto: {venta\['auto']} | Cantidad: {venta\['cantidad']} | Ingreso: ${venta\['ingreso']:.2f} | Costo: ${venta\['costo']:.2f} | Utilidad: ${venta\['utilidad']:.2f} | Fecha: {venta\['fecha']} | Sucursal: {venta\['sucursal']}")     def generar\_reporte\_inventario(self):        print("Reporte de Inventario:")        for auto, detalles in self.inventario.items():            print(f"Producto: {auto} | Cantidad: {detalles\['cantidad']} | Precio Compra: ${detalles\['precio\_compra']:.2f} | Precio Venta: ${detalles\['precio\_venta']:.2f}")     def generar\_reporte\_inventario\_sucursal(self, sucursal):        print(f"Reporte de Inventario para la Sucursal {sucursal}:")        if sucursal in self.sucursales:            for auto, cantidad in self.sucursales\[sucursal].items():                print(f"Auto: {auto} | Cantidad: {cantidad}")        else:            print(f"La sucursal {sucursal} no tiene autos.") \#Ejemplos de uso de programa de inventario inventario = Inventario()        #Agregar auto al inventarioinventario.agregar\_auto("March",5,165000)inventario.agregar\_auto("Mazda 2",4,210000)inventario.agregar\_auto("Mini Cooper",2,400000) \#Establecer precios de ventainventario.establecer\_precio\_venta("March",190000)inventario.establecer\_precio\_venta("Mazda 2",260000)inventario.establecer\_precio\_venta("Mini Cooper",460000) \#Vender autoinventario.vender\_auto("March",2)inventario.vender\_auto("Mazda 2",1)inventario.vender\_auto("Mini Cooper",2) \#Traspasar autos entre sucursalesinventario.traspasar\_auto("March",1,"central","sucursal\_1") \#Generar reportesinventario.generar\_reporte\_ventas()inventario.generar\_reporte\_inventario()inventario.generar\_reporte\_inventario\_sucursal("sucursal\_1")inventario.generar\_reporte\_inventario\_sucursal("central")

\#Reto#Se tiene una concesionaría de vehículos en la cual se va a poder hacer la compra y venta. Ademas de gestionar los vehículos, un usuario va a poder preguntar, ¿cuáles son los que están disponibles?, su precio y también podrá comprar uno. import datetime class Inventario:    def \_\_init\_\_(self):        self.inventario = {}        self.ventas = \[]        self.sucursales = {}     def agregar\_auto(self, auto, cantidad, precio\_compra, sucursal="central"):        if auto in self.inventario:            self.inventario\[auto]\["cantidad"] += cantidad        else:            self.inventario\[auto] = {                "cantidad": cantidad,                "precio\_compra": precio\_compra,                "precio\_venta": 0,            }         # Agregar la cantidad de autos a la sucursal        if sucursal not in self.sucursales:            self.sucursales\[sucursal] = {}        if auto in self.sucursales\[sucursal]:            self.sucursales\[sucursal]\[auto] += cantidad        else:            self.sucursales\[sucursal]\[auto] = cantidad        def establecer\_precio\_venta(self, auto, precio\_venta):        if auto in self.inventario:            self.inventario\[auto]\["precio\_venta"] = precio\_venta        else:            print(f"El producto {auto} no existe en el inventario.")     def vender\_auto(self, auto, cantidad, sucursal="central"):        if auto in self.inventario and self.inventario\[auto]\["cantidad"] >= cantidad:            self.inventario\[auto]\["cantidad"] -= cantidad            ingreso = cantidad \* self.inventario\[auto]\["precio\_venta"]            costo = cantidad \* self.inventario\[auto]\["precio\_compra"]            utilidad = ingreso - costo            fecha = datetime.datetime.now()             # Registrar la venta            self.ventas.append({                "auto": auto,                "cantidad": cantidad,                "ingreso": ingreso,                "costo": costo,                "utilidad": utilidad,                "fecha": fecha,                "sucursal": sucursal,            })             # Reducir la cantidad del producto en la sucursal            if sucursal in self.sucursales and auto in self.sucursales\[sucursal]:                self.sucursales\[sucursal]\[auto] -= cantidad            else:                print(f"El producto {auto} no existe en la sucursal {sucursal}.")         else:            print(f"El producto {auto} no tiene suficiente stock o no existe en el inventario.")     def traspasar\_auto(self, auto, cantidad, sucursal\_origen, sucursal\_destino):        if sucursal\_origen in self.sucursales and auto in self.sucursales\[sucursal\_origen] and self.sucursales\[sucursal\_origen]\[auto] >= cantidad:            self.sucursales\[sucursal\_origen]\[auto] -= cantidad            if sucursal\_destino not in self.sucursales:                self.sucursales\[sucursal\_destino] = {}            if auto in self.sucursales\[sucursal\_destino]:                self.sucursales\[sucursal\_destino]\[auto] += cantidad            else:                self.sucursales\[sucursal\_destino]\[auto] = cantidad        else:            print(f"No hay suficiente stock del auto {auto} en la sucursal {sucursal\_origen}.")     def generar\_reporte\_ventas(self):        total\_ingreso = sum(venta\["ingreso"] for venta in self.ventas)        total\_costo = sum(venta\["costo"] for venta in self.ventas)        total\_utilidad = sum(venta\["utilidad"] for venta in self.ventas)         print("Reporte de Ventas:")        print(f"Total Ingreso: ${total\_ingreso:.2f}")        print(f"Total Costo: ${total\_costo:.2f}")        print(f"Total Utilidad: ${total\_utilidad:.2f}\n")         for venta in self.ventas:            print(f"Auto: {venta\['auto']} | Cantidad: {venta\['cantidad']} | Ingreso: ${venta\['ingreso']:.2f} | Costo: ${venta\['costo']:.2f} | Utilidad: ${venta\['utilidad']:.2f} | Fecha: {venta\['fecha']} | Sucursal: {venta\['sucursal']}")     def generar\_reporte\_inventario(self):        print("Reporte de Inventario:")        for auto, detalles in self.inventario.items():            print(f"Producto: {auto} | Cantidad: {detalles\['cantidad']} | Precio Compra: ${detalles\['precio\_compra']:.2f} | Precio Venta: ${detalles\['precio\_venta']:.2f}")     def generar\_reporte\_inventario\_sucursal(self, sucursal):        print(f"Reporte de Inventario para la Sucursal {sucursal}:")        if sucursal in self.sucursales:            for auto, cantidad in self.sucursales\[sucursal].items():                print(f"Auto: {auto} | Cantidad: {cantidad}")        else:            print(f"La sucursal {sucursal} no tiene autos.") \#Ejemplos de uso de programa de inventario inventario = Inventario()        #Agregar auto al inventarioinventario.agregar\_auto("March",5,165000)inventario.agregar\_auto("Mazda 2",4,210000)inventario.agregar\_auto("Mini Cooper",2,400000) \#Establecer precios de ventainventario.establecer\_precio\_venta("March",190000)inventario.establecer\_precio\_venta("Mazda 2",260000)inventario.establecer\_precio\_venta("Mini Cooper",460000) \#Vender autoinventario.vender\_auto("March",2)inventario.vender\_auto("Mazda 2",1)inventario.vender\_auto("Mini Cooper",2) \#Traspasar autos entre sucursalesinventario.traspasar\_auto("March",1,"central","sucursal\_1") \#Generar reportesinventario.generar\_reporte\_ventas()inventario.generar\_reporte\_inventario()inventario.generar\_reporte\_inventario\_sucursal("sucursal\_1")inventario.generar\_reporte\_inventario\_sucursal("central") Nota: con un poco de ayuda de la IA por que sigo aprendiendo =)

```python class Carro: def __init__(self,modelo,precio): self.modelo=modelo self.precio=precio self.disponibles=True def ventas(self): if self.disponibles: self.disponibles=False print(f"El vehiculo {self.modelo} ha sido vendido") else: print(f"El vehiculo {self.modelo} no esta disponible") def devolver_carro(self): self.disponibles=True print(f"El vehiculo {self.modelo} ha sido devuelto") class User: def __init__(self,name,user_id): self.name=name self.user_id=user_id self.carros_comprado=[] def carro_comprado(self,carro): if carro.disponibles: carro.ventas() self.carros_comprado.append(carro) else: print(f"El vehiculo {carro.modelo} noi esta disponible") def devolver_carro(self,carro): if carro in self.carros_comprado: carro.devolver_carro() self.carros_comprado.remove(carro) else: print(f"El vehiculo {carro.modelo} no esta en la lista de vendidos") class Concesionario: def __init__(self): self.carros=[] self.users=[] def add_carro(self,carro): self.carros.append(carro) print(f"El vehiculo {carro.modelo} ha sido agregado") def register_user(self,user): self.users.append(user) print(f"El usuario {user.name} ha sido registrado") def carros_disponibles(self): print("Vehiculos disponibles: ") for carro in self.carros: if carro.disponibles: print(f"{carro.modelo} por ${carro.precio}") #Crear los Carros carro1=Carro("Camaro","3500") carro2=Carro("mustan gt 4","7500") #Crear usario user1=User("Lucas","0001") #Crear lista de carros concesionario=Concesionario() concesionario.add_carro(carro1) concesionario.add_carro(carro2) concesionario.register_user(user1) #Mostrar carros concesionario.carros_disponibles() #realisar venta user1.carro_comprado(carro1) #Mostrar carros concesionario.carros_disponibles() #Devolucion Carro user1.devolver_carro(carro1) #Mostrar carros concesionario.carros_disponibles() ```class Carro:    def \_\_init\_\_(self,modelo,precio):        *self*.modelo=modelo        *self*.precio=precio        *self*.disponibles=True    def ventas(self):        if *self*.disponibles:            *self*.disponibles=False            print(f"El vehiculo {*self*.modelo} ha sido vendido")        else:            print(f"El vehiculo {*self*.modelo} no esta disponible")    def devolver\_carro(self):        *self*.disponibles=True        print(f"El vehiculo {*self*.modelo} ha sido devuelto")class User:    def \_\_init\_\_(self,name,user\_id):        *self*.name=name        *self*.user\_id=user\_id        *self*.carros\_comprado=\[]    def carro\_comprado(self,carro):        if carro.disponibles:            carro.ventas()            *self*.carros\_comprado.append(carro)        else:            print(f"El vehiculo {carro.modelo} noi esta disponible")    def devolver\_carro(self,carro):        if carro in *self*.carros\_comprado:            carro.devolver\_carro()            *self*.carros\_comprado.remove(carro)        else:            print(f"El vehiculo {carro.modelo} no esta en la lista de vendidos")class Concesionario:    def \_\_init\_\_(self):        *self*.carros=\[]        *self*.users=\[]    def add\_carro(self,carro):        *self*.carros.append(carro)        print(f"El vehiculo {carro.modelo} ha sido agregado")    def register\_user(self,user):        *self*.users.append(user)        print(f"El usuario {user.name} ha sido registrado")    def carros\_disponibles(self):        print("Vehiculos disponibles: ")        for carro in *self*.carros:            if carro.disponibles:                print(f"{carro.modelo} por ${carro.precio}")*#Crear los Carros*carro1=Carro("Camaro","3500")carro2=Carro("mustan gt 4","7500")*#Crear usario*user1=User("Lucas","0001")*#Crear lista de carros*concesionario=Concesionario()concesionario.add\_carro(carro1)concesionario.add\_carro(carro2)concesionario.register\_user(user1)*#Mostrar carros*concesionario.carros\_disponibles()*#realisar venta*user1.carro\_comprado(carro1)*#Mostrar carros*concesionario.carros\_disponibles()*#Devolucion Carro*user1.devolver\_carro(carro1)*#Mostrar carros*concesionario.carros\_disponibles()

Mi humilde aporte, 100% funcional: (en Chile a los vehículos les decimos autos :D) ```js #Consesionaria de vehiculos, compra y venta, usuario puede preguntar disponibilidad y precio. # # class Auto: def __init__(self, marca, precio): self.marca = marca self.precio = precio self.available = True def vender(self): if self.available: self.available = False print(f"El Auto {self.marca} ha sido comprado") else: print(f"El Auto {self.marca} no está disponible") def comprar(self): self.available = True print (f"El Auto {self.marca} desde ahora esta en nuestro catálogo") class User: def __init__(self, name, user_id): self.name = name self.user_id = user_id self.staffautos = [] def comprarauto(self, auto): if auto.available: auto.vender() self.staffautos.append(auto) def venderauto(self, auto): if auto in self.staffautos: auto.comprar() self.staffautos.remove(auto) print(f"El auto {auto.marca} ha sido vendido a la automotora") else: print(f"El auto {auto.marca} ha sido comprado por la automotora") def show_autos_staffautos(self): print(f"Autos en el Garage de {self.name}") for auto in self.staffautos: print (f"El auto {auto.marca} se encuentra en el Garage") class Automotora: def __init__(self): self.autos = [] self.users = [] def add_auto(self, auto): self.autos.append(auto) print(f"El auto {auto.marca} ha sido agregado") def register_user(self,user): self.users.append(user) print(f"El usuario {user.name} ha sido registrado") def show_available_autos(self): print("Autos disponibles") for auto in self.autos: if auto.available: print (f"{auto.marca} precio {auto.precio}") #Crear los autos auto1 = Auto("Lada", 1000) auto2 = Auto("Mercedez", 2000) #Crear Usuario user1 = User ("Carli", "001") #Crear Automotora automotora = Automotora() automotora.add_auto(auto1) automotora.add_auto(auto2) automotora.register_user(user1) #Mostrar autos automotora.show_available_autos() #Usuario Compra Auto user1.comprarauto(auto2) #Mostrar autos en automora y garage automotora.show_available_autos() user1.show_autos_staffautos() #Usuario Vende Auto user1.venderauto(auto2) #Mostrar nuevo inventario automotora automotora.show_available_autos() ```#Consesionaria de vehiculos, compra y venta, usuario puede preguntar disponibilidad y precio. # # class Auto:    def \_\_init\_\_(self, marca, precio):        self.marca = marca        self.precio = precio        self.available = True        def vender(self):        if self.available:            self.available = False            print(f"El Auto {self.marca} ha sido comprado")        else:            print(f"El Auto {self.marca} no está disponible")        def comprar(self):        self.available = True        print (f"El Auto {self.marca} desde ahora esta en nuestro catálogo") class User:    def \_\_init\_\_(self, name, user\_id):        self.name = name        self.user\_id = user\_id        self.staffautos = \[]        def comprarauto(self, auto):        if auto.available:            auto.vender()            self.staffautos.append(auto)        def venderauto(self, auto):        if auto in self.staffautos:            auto.comprar()            self.staffautos.remove(auto)            print(f"El auto {auto.marca} ha sido vendido a la automotora")        else:            print(f"El auto {auto.marca} ha sido comprado por la automotora")        def show\_autos\_staffautos(self):        print(f"Autos en el Garage de {self.name}")        for auto in self.staffautos:            print (f"El auto {auto.marca} se encuentra en el Garage") class Automotora:    def \_\_init\_\_(self):        self.autos = \[]        self.users = \[]        def add\_auto(self, auto):        self.autos.append(auto)        print(f"El auto {auto.marca} ha sido agregado")        def register\_user(self,user):        self.users.append(user)        print(f"El usuario {user.name} ha sido registrado")     def show\_available\_autos(self):        print("Autos disponibles")        for auto in self.autos:            if auto.available:                print (f"{auto.marca} precio {auto.precio}") \#Crear los autosauto1 = Auto("Lada", 1000)auto2 = Auto("Mercedez", 2000) \#Crear Usuariouser1 = User ("Carli", "001") \#Crear Automotoraautomotora = Automotora()automotora.add\_auto(auto1)automotora.add\_auto(auto2)automotora.register\_user(user1) \#Mostrar autosautomotora.show\_available\_autos() \#Usuario Compra Autouser1.comprarauto(auto2) \#Mostrar autos en automora y garageautomotora.show\_available\_autos()user1.show\_autos\_staffautos() \#Usuario Vende Autouser1.venderauto(auto2) \#Mostrar nuevo inventario automotoraautomotora.show\_available\_autos()

Ejercicio: ```python class Car: def __init__(self, brand, price, state, id_car): self.brand = brand self.price = price self.state = state self.id_car = id_car self.available = True self.available_for_client = True def sale_car(self): if self.available: self.available = False print("Se acaba de realizar una venta de las siguientes caracteristicas ") print(f"Marca: {self.brand}\n{self.price}\n{self.state}") else: print("Este vehiculo no se encuentra disponible") def buy_car(self): self.available = True print("Se acaba de realizar una compra con las siguientes caracteristicas") print(f"Marca: {self.brand}\n Precio: {self.price}\n Estado: {self.state}") class Client: def __init__(self,name, user_id): self.name = name self.user_id = user_id self.list_cars = [] def add_list_car(self, car): if car.available: car.sale_car() self.list_cars.append(car) else: print(f"El carro {car.id_car} no se encuentra a la venta") def sale_car_user(self, car): if car.available: car.buy_car() self.sale_car_user.remove(car) else: print("No tengo este carro disponible para la venta") def show_available_cars_client(self): print("Carros Disponibles") for car in self.list_cars: if car.available_for_client: print(f"Carro disponible para cliente {self.name}: {car.id_car}") class Dealership: def __init__(self): self.cars = [] self.clients = [] def add_list(self,car): self.cars.append(car) print(f"El carro {car.id_car} se encuentra disponible a la venta") def register_client(self, client): self.clients.append(client) print(f"El usuario {client.name} ha sido registrado") def show_available_cars(self): print("Carros Disponibles") for car in self.cars: if car.available: print(f"Carro disponible: {car.id_car}") car1 = Car("Audi",50000,"Nuevo","001") car2 = Car("Beantly",30000,"SemiNuevo","002") car3 = Car("Mercedez",25000,"SemiNuevo","003") car4 = Car("Ferrari",60000,"Nuevo","004") car5 = Car("Hyundai",15000,"Nuevo","005") car6 = Car("Toyota",5000,"Nuevo","006") car7 = Car("Mazda",14000,"Nuevo","007") car8 = Car("Bajaj",10000,"Nuevo","008") car9 = Car("Honda",9000,"SemiNuevo","009") car10 = Car("Kia",1000,"SemiNuevo","010") client1 = Client("David","001") client2 = Client("Betzi","002") client3 = Client("Luis","003") #Crear lista dealership1 = Dealership() dealership1.add_list(car1) dealership1.add_list(car2) dealership1.add_list(car3) dealership1.add_list(car4) dealership1.add_list(car5) dealership1.add_list(car6) dealership1.add_list(car7) dealership1.add_list(car8) dealership1.add_list(car9) dealership1.add_list(car10) dealership1.register_client(client1) dealership1.register_client(client2) dealership1.register_client(client3) #Vendiendo carros client1.add_list_car(car1) client1.add_list_car(car2) client1.add_list_car(car3) client2.add_list_car(car4) client2.add_list_car(car5) client2.add_list_car(car6) client3.add_list_car(car7) client3.add_list_car(car8) client3.add_list_car(car9) #Mostrando lista por cliente dealership1.show_available_cars() client1.show_available_cars_client() ```

\# Clase Autoclass Auto:    def \_\_init\_\_(self, marca, nombre, modelo, matricula, precio):        self.marca = marca        self.nombre = nombre                self.modelo = modelo               self.precio = precio        self.matricula = matricula        self.disponible = True  # El auto está disponible por defecto        def marcar\_disponible(self):        self.disponible = True        def marcar\_no\_disponible(self):        self.disponible = False        def \_\_str\_\_(self):        estado = "Disponible" if self.disponible else "No disponible"        return f"Marca: {self.marca}, Nombre: {self.nombre}, Modelo: {self.modelo}, Matrícula: {self.matricula}, Precio: {self.precio}, Estado: {estado}" \# Clase Clienteclass Cliente:    def \_\_init\_\_(self, id, nombre):        self.id = id        self.nombre = nombre        self.propiedad\_autos = \[]  # Lista de autos que el cliente ha comprado        def \_\_str\_\_(self):        autos = ", ".join(\[f"{auto.nombre} ({auto.matricula})" for auto in self.propiedad\_autos]) if self.propiedad\_autos else "Ninguno"        return f"ID: {self.id}. Nombre: {self.nombre}. Autos en propiedad: {autos}"     def listar\_autos(self):        if self.propiedad\_autos:            print(f"El cliente {self.nombre} tiene los siguientes autos:")            for auto in self.propiedad\_autos:                print(f"- {auto}")        else:            print(f"{self.nombre} no ha comprado ningún auto.") \# Clase Gerenciaclass Gerencia:    def vender\_auto(self, auto, cliente):        # Verificar si el auto está disponible        if auto.disponible:            auto.marcar\_no\_disponible()  # Marcar el auto como no disponible            cliente.propiedad\_autos.append(auto)  # Agregar el auto a la lista de propiedad del cliente            print(f"El auto {auto.nombre} ha sido vendido a {cliente.nombre}.")        else:            print(f"El auto {auto.nombre} no está disponible para la venta.")        def devolver\_auto(self, auto, cliente):        # Verificar si el cliente tiene el auto en su propiedad antes de devolverlo        if auto in cliente.propiedad\_autos:            auto.marcar\_disponible()  # Marcar el auto como disponible de nuevo            cliente.propiedad\_autos.remove(auto)  # Remover el auto de la propiedad del cliente            print(f"El auto {auto.nombre} ha sido devuelto por {cliente.nombre}.")        else:            print(f"El cliente {cliente.nombre} no tiene el auto {auto.nombre}.")        def autos\_disponibles(self, autos):        # Mostrar los autos disponibles en el inventario        disponibles = \[auto for auto in autos if auto.disponible]        if disponibles:            print("Autos disponibles en el inventario:")            for auto in disponibles:                print(f"- {auto}")        else:            print("No hay autos disponibles.") \# Ejemplo de uso \# Crear autosauto1 = Auto('Renault', 'Logan', 2010, 'ABX511', 15000000)auto2 = Auto('Ford', 'Mustang', 2022, 'XYZ123', 30000000) \# Crear clientecliente1 = Cliente(103, 'Amber') \# Crear gerenciagerencia = Gerencia() \# Listar autos disponibles en el inventariogerencia.autos\_disponibles(\[auto1, auto2]) \# Vender un auto a un clientegerencia.vender\_auto(auto1, cliente1) \# Mostrar la información del cliente después de la compraprint(cliente1) \# Listar autos del clientecliente1.listar\_autos() \# Imprimir el estado del auto después de la compraprint(auto1) \# El cliente devuelve el autogerencia.devolver\_auto(auto1, cliente1) \# Listar autos disponibles en el inventario después de la devolucióngerencia.autos\_disponibles(\[auto1, auto2]) \# Imprimir el estado del auto después de la devoluciónprint(auto1)

```js # Clase Auto class Auto: def __init__(self, marca, nombre, modelo, matricula, precio): self.marca = marca self.nombre = nombre self.modelo = modelo self.precio = precio self.matricula = matricula self.disponible = True # El auto está disponible por defecto def marcar_disponible(self): self.disponible = True def marcar_no_disponible(self): self.disponible = False def __str__(self): estado = "Disponible" if self.disponible else "No disponible" return f"Marca: {self.marca}, Nombre: {self.nombre}, Modelo: {self.modelo}, Matrícula: {self.matricula}, Precio: {self.precio}, Estado: {estado}" # Clase Cliente class Cliente: def __init__(self, id, nombre): self.id = id self.nombre = nombre self.propiedad_autos = [] # Lista de autos que el cliente ha comprado def __str__(self): autos = ", ".join([f"{auto.nombre} ({auto.matricula})" for auto in self.propiedad_autos]) if self.propiedad_autos else "Ninguno" return f"ID: {self.id}. Nombre: {self.nombre}. Autos en propiedad: {autos}" def listar_autos(self): if self.propiedad_autos: print(f"El cliente {self.nombre} tiene los siguientes autos:") for auto in self.propiedad_autos: print(f"- {auto}") else: print(f"{self.nombre} no ha comprado ningún auto.") # Clase Gerencia class Gerencia: def vender_auto(self, auto, cliente): # Verificar si el auto está disponible if auto.disponible: auto.marcar_no_disponible() # Marcar el auto como no disponible cliente.propiedad_autos.append(auto) # Agregar el auto a la lista de propiedad del cliente print(f"El auto {auto.nombre} ha sido vendido a {cliente.nombre}.") else: print(f"El auto {auto.nombre} no está disponible para la venta.") def devolver_auto(self, auto, cliente): # Verificar si el cliente tiene el auto en su propiedad antes de devolverlo if auto in cliente.propiedad_autos: auto.marcar_disponible() # Marcar el auto como disponible de nuevo cliente.propiedad_autos.remove(auto) # Remover el auto de la propiedad del cliente print(f"El auto {auto.nombre} ha sido devuelto por {cliente.nombre}.") else: print(f"El cliente {cliente.nombre} no tiene el auto {auto.nombre}.") def autos_disponibles(self, autos): # Mostrar los autos disponibles en el inventario disponibles = [auto for auto in autos if auto.disponible] if disponibles: print("Autos disponibles en el inventario:") for auto in disponibles: print(f"- {auto}") else: print("No hay autos disponibles.") # Ejemplo de uso # Crear autos auto1 = Auto('Renault', 'Logan', 2010, 'ABX511', 15000000) auto2 = Auto('Ford', 'Mustang', 2022, 'XYZ123', 30000000) # Crear cliente cliente1 = Cliente(103, 'Amber') # Crear gerencia gerencia = Gerencia() # Listar autos disponibles en el inventario gerencia.autos_disponibles([auto1, auto2]) # Vender un auto a un cliente gerencia.vender_auto(auto1, cliente1) # Mostrar la información del cliente después de la compra print(cliente1) # Listar autos del cliente cliente1.listar_autos() # Imprimir el estado del auto después de la compra print(auto1) # El cliente devuelve el auto gerencia.devolver_auto(auto1, cliente1) # Listar autos disponibles en el inventario después de la devolución gerencia.autos_disponibles([auto1, auto2]) # Imprimir el estado del auto después de la devolución print(auto1) ```# Clase Autoclass Auto:    def \_\_init\_\_(self, marca, nombre, modelo, matricula, precio):        self.marca = marca        self.nombre = nombre                self.modelo = modelo               self.precio = precio        self.matricula = matricula        self.disponible = True  # El auto está disponible por defecto        def marcar\_disponible(self):        self.disponible = True        def marcar\_no\_disponible(self):        self.disponible = False        def \_\_str\_\_(self):        estado = "Disponible" if self.disponible else "No disponible"        return f"Marca: {self.marca}, Nombre: {self.nombre}, Modelo: {self.modelo}, Matrícula: {self.matricula}, Precio: {self.precio}, Estado: {estado}" \# Clase Clienteclass Cliente:    def \_\_init\_\_(self, id, nombre):        self.id = id        self.nombre = nombre        self.propiedad\_autos = \[]  # Lista de autos que el cliente ha comprado        def \_\_str\_\_(self):        autos = ", ".join(\[f"{auto.nombre} ({auto.matricula})" for auto in self.propiedad\_autos]) if self.propiedad\_autos else "Ninguno"        return f"ID: {self.id}. Nombre: {self.nombre}. Autos en propiedad: {autos}"     def listar\_autos(self):        if self.propiedad\_autos:            print(f"El cliente {self.nombre} tiene los siguientes autos:")            for auto in self.propiedad\_autos:                print(f"- {auto}")        else:            print(f"{self.nombre} no ha comprado ningún auto.") \# Clase Gerenciaclass Gerencia:    def vender\_auto(self, auto, cliente):        # Verificar si el auto está disponible        if auto.disponible:            auto.marcar\_no\_disponible()  # Marcar el auto como no disponible            cliente.propiedad\_autos.append(auto)  # Agregar el auto a la lista de propiedad del cliente            print(f"El auto {auto.nombre} ha sido vendido a {cliente.nombre}.")        else:            print(f"El auto {auto.nombre} no está disponible para la venta.")        def devolver\_auto(self, auto, cliente):        # Verificar si el cliente tiene el auto en su propiedad antes de devolverlo        if auto in cliente.propiedad\_autos:            auto.marcar\_disponible()  # Marcar el auto como disponible de nuevo            cliente.propiedad\_autos.remove(auto)  # Remover el auto de la propiedad del cliente            print(f"El auto {auto.nombre} ha sido devuelto por {cliente.nombre}.")        else:            print(f"El cliente {cliente.nombre} no tiene el auto {auto.nombre}.")        def autos\_disponibles(self, autos):        # Mostrar los autos disponibles en el inventario        disponibles = \[auto for auto in autos if auto.disponible]        if disponibles:            print("Autos disponibles en el inventario:")            for auto in disponibles:                print(f"- {auto}")        else:            print("No hay autos disponibles.") \# Ejemplo de uso \# Crear autosauto1 = Auto('Renault', 'Logan', 2010, 'ABX511', 15000000)auto2 = Auto('Ford', 'Mustang', 2022, 'XYZ123', 30000000) \# Crear clientecliente1 = Cliente(103, 'Amber') \# Crear gerenciagerencia = Gerencia() \# Listar autos disponibles en el inventariogerencia.autos\_disponibles(\[auto1, auto2]) \# Vender un auto a un clientegerencia.vender\_auto(auto1, cliente1) \# Mostrar la información del cliente después de la compraprint(cliente1) \# Listar autos del clientecliente1.listar\_autos() \# Imprimir el estado del auto después de la compraprint(auto1) \# El cliente devuelve el autogerencia.devolver\_auto(auto1, cliente1) \# Listar autos disponibles en el inventario después de la devolucióngerencia.autos\_disponibles(\[auto1, auto2]) \# Imprimir el estado del auto después de la devoluciónprint(auto1)

class Vehiculo: def \_\_init\_\_(self, marca, modelo, año, precio): self.marca = marca self.modelo = modelo self.año = año self.precio = precio self.estado = "Disponible" # Puede ser "Vendido", "Devuelto" o "Disponible" def \_\_str\_\_(self): return f"Vehículo: {self.marca} {self.modelo} ({self.año}) - {self.estado}" class Concesionario: def \_\_init\_\_(self): self.inventario = \[] def agregar\_vehiculo(self, vehiculo): self.inventario.append(vehiculo) def vender\_vehiculo(self, vehiculo): vehiculo.estado = "Vendido" print(f"El vehículo {vehiculo} ha sido vendido.") def devolver\_vehiculo(self, vehiculo): vehiculo.estado = "Devuelto" print(f"El vehículo {vehiculo} ha sido devuelto.") def vehiculos\_disponibles(self): disponibles = \[vehiculo for vehiculo in self.inventario if vehiculo.estado == "Disponible"] return disponibles def listado\_vehiculos(self): for vehiculo in self.inventario: print(vehiculo) \# Ejemplo de uso: concesionario = Concesionario() \# Crear algunos vehículos auto1 = Vehiculo("Toyota", "Corolla", 2022, 20000) auto2 = Vehiculo("Honda", "Civic", 2023, 25000) \# Agregar vehículos al inventario concesionario.agregar\_vehiculo(auto1) concesionario.agregar\_vehiculo(auto2) \# Vender un vehículo concesionario.vender\_vehiculo(auto1) \# Mostrar vehículos disponibles print("Vehículos disponibles:") for vehiculo in concesionario.vehiculos\_disponibles(): print(vehiculo)

Hola tengo una duda, estoy haciendo el reto del concesionario, pero para saber si un vehículo está dentro de la lista de disponibles me está sacando error, alguien sabe cómo puedo buscar si un objeto "Vehículo" está en una lista donde están todos los vehículos disponibles o comprados por el concesionario`?` ```python class Vehiculos: def __init__(self, marca, modelo, año, cc, cantidad_puertas, peso, tipo): self.marca = marca self.modelo = modelo self.año = año self.cc = cc self.cantidad_puertas = cantidad_puertas self.peso = peso self.tipo = tipo class Clientes: def __init__(self, name, cedula): self.name = name self.cedula = cedula self.car_owned = [] def owned (self, vehiculo): self.car_owned.append(vehiculo) class Vendedor: def __init__(self, name, id): self.name = name self.id = id class Consecionario: def __init__(self): self.vehiculos = [] self.clientes = [] self.vendedores = [] self.vendidos = [] def buy_car(self, vehiculo, precio): if vehiculo.tipo == "nuevo": precio_venta_sugerido = precio*1.5 else: precio_venta_sugerido = precio*1.15 self.vehiculos.append([vehiculo, str(precio), str(precio_venta_sugerido)]) print(f"El vehiculo {vehiculo.marca}, {vehiculo.modelo} con estado {vehiculo.tipo} y motor {vehiculo.cc} ha sido comprado y agregado a la lista de disponibles") def sell_car(self, vehiculo, cliente, vendedor): vehiculo_encontrado = False for i in range(len(self.vehiculos)): if vehiculo in self.vehiculos[i]: precio_venta = self.vehiculos[i][2] self.vehiculos.remove(self.vehiculos[i]) vehiculo_encontrado = True if vehiculo_encontrado == True: self.vendidos.append([vendedor, cliente, vehiculo, precio_venta]) print(f"El vehiculo {vehiculo.marca}, {vehiculo.modelo} con estado {vehiculo.tipo} y motor {vehiculo.cc} ha sido vendido por el vendedor {vendedor.name} al cliente {cliente.name} por un valor de {precio_venta}") else: print(f"Vehiculo no disponible para la venta") def show_available_cars(self): print("Los vehiculos disponibles a la venta son:") i = 0 for car in self.vehiculos: i +=1 print(f"{i}) Marca {car[0].marca}| Modelo: {car[0].modelo}| Año: {car[0].año}| CC: {car[0].cc}| Puertas: {car[0].cantidad_puertas}| Peso: {car[0].peso}| Tipo: {car[0].tipo}| Precio de compra: {car[1]}| Precio de venta sugerido {car[2]}") def show_selled_cars(self): print("Los vehiculos que se han vendido son:") i = 0 for car in self.vendidos: print(f"{i}) Vendedor: {car[0].name}| Vendedor_id: {car[0].id}| Cliente: {car[1].name}| Cédula: {car[1].cedula}| Marca {car[2].marca}| Modelo: {car[2].modelo}| Año: {car[2].año}| CC: {car[2].cc}| Precio de venta: {car[3]}") #Creo los automoviles carro1= Vehiculos("Kia", "Picanto", "2023", "1250", "4", "1.5 T", "nuevo") carro2= Vehiculos("Nissan", "March", "2021", "1600", "4", "1.7 T", "usado") carro3= Vehiculos("Toyota", "Yaris", "2024", "2000 Turbo", "4", "2.3 T", "nuevo") carro4= Vehiculos("Mazda", "3", "2020", "2000", "4", "1.9 T", "usado") #Creo los clientes cliente1 = Clientes("Juan", "111111111") cliente2 = Clientes("Maritza", "777777777") cliente3 = Clientes("Nancy", "33333333") #Creo los vendedores vendedor1 = Vendedor("Ricardo", "001") vendedor2 = Vendedor("Laura", "002") vendedor3 = Vendedor("Camila", "003") vendedor4 = Vendedor("Malory", "004") #Comienso la compra de los carros Yokomotor = Consecionario() Yokomotor.buy_car(carro1, 25500000) Yokomotor.buy_car(carro2, 34800000) Yokomotor.buy_car(carro3, 65900000) Yokomotor.buy_car(carro4, 55900000) Yokomotor.show_available_cars() Yokomotor.show_selled_cars() #Comienso la venta de los carros Yokomotor.sell_car(carro1, cliente3, vendedor4) Yokomotor.sell_car(carro3, cliente1, vendedor4) Yokomotor.sell_car(carro2, cliente2, vendedor3) Yokomotor.sell_car(carro4, cliente2, vendedor2) #Yokomotor.sell_car(carro3, cliente2, vendedor1) Yokomotor.show_available_cars() Yokomotor.show_selled_cars() ```class Vehiculos:    def \_\_init\_\_(self, marca, modelo, año, cc, cantidad\_puertas, peso, tipo):        self.marca = marca        self.modelo = modelo        self.año = año        self.cc = cc        self.cantidad\_puertas = cantidad\_puertas        self.peso = peso        self.tipo = tipo class Clientes:    def \_\_init\_\_(self, name, cedula):        self.name = name        self.cedula = cedula        self.car\_owned  = \[]     def owned (self, vehiculo):        self.car\_owned.append(vehiculo) class Vendedor:    def \_\_init\_\_(self, name, id):        self.name = name        self.id = id class Consecionario:    def \_\_init\_\_(self):        self.vehiculos = \[]        self.clientes = \[]        self.vendedores = \[]        self.vendidos = \[]        def buy\_car(self, vehiculo, precio):        if vehiculo.tipo == "nuevo":            precio\_venta\_sugerido = precio\*1.5        else:            precio\_venta\_sugerido = precio\*1.15         self.vehiculos.append(\[vehiculo, str(precio), str(precio\_venta\_sugerido)])        print(f"El vehiculo {vehiculo.marca}, {vehiculo.modelo} con estado {vehiculo.tipo} y motor {vehiculo.cc} ha sido comprado y agregado a la lista de disponibles")     def sell\_car(self, vehiculo, cliente, vendedor):        vehiculo\_encontrado = False        for i in range(len(self.vehiculos)):            if vehiculo in self.vehiculos\[i]:                precio\_venta = self.vehiculos\[i]\[2]                self.vehiculos.remove(self.vehiculos\[i])                vehiculo\_encontrado = True                if vehiculo\_encontrado == True:            self.vendidos.append(\[vendedor, cliente, vehiculo, precio\_venta])            print(f"El vehiculo {vehiculo.marca}, {vehiculo.modelo} con estado {vehiculo.tipo} y motor {vehiculo.cc} ha sido vendido por el vendedor {vendedor.name} al cliente {cliente.name} por un valor de {precio\_venta}")        else:            print(f"Vehiculo no disponible para la venta")     def show\_available\_cars(self):        print("Los vehiculos disponibles a la venta son:")        i = 0        for car in self.vehiculos:            i +=1            print(f"{i}) Marca {car\[0].marca}| Modelo: {car\[0].modelo}| Año: {car\[0].año}| CC: {car\[0].cc}| Puertas: {car\[0].cantidad\_puertas}| Peso: {car\[0].peso}| Tipo: {car\[0].tipo}| Precio de compra: {car\[1]}| Precio de venta sugerido {car\[2]}")     def show\_selled\_cars(self):        print("Los vehiculos que se han vendido son:")        i = 0        for car in self.vendidos:            print(f"{i}) Vendedor: {car\[0].name}| Vendedor\_id: {car\[0].id}| Cliente: {car\[1].name}| Cédula: {car\[1].cedula}| Marca {car\[2].marca}| Modelo: {car\[2].modelo}| Año: {car\[2].año}| CC: {car\[2].cc}| Precio de venta: {car\[3]}") \#Creo los automovilescarro1= Vehiculos("Kia", "Picanto", "2023", "1250", "4", "1.5 T", "nuevo")carro2= Vehiculos("Nissan", "March", "2021", "1600", "4", "1.7 T", "usado")carro3= Vehiculos("Toyota", "Yaris", "2024", "2000 Turbo", "4", "2.3 T", "nuevo")carro4= Vehiculos("Mazda", "3", "2020", "2000", "4", "1.9 T", "usado") \#Creo los clientescliente1 = Clientes("Juan", "111111111")cliente2 = Clientes("Maritza", "777777777")cliente3 = Clientes("Nancy", "33333333") \#Creo los vendedoresvendedor1 = Vendedor("Ricardo", "001")vendedor2 = Vendedor("Laura", "002")vendedor3 = Vendedor("Camila", "003")vendedor4 = Vendedor("Malory", "004") \#Comienso la compra de los carrosYokomotor = Consecionario()Yokomotor.buy\_car(carro1, 25500000)Yokomotor.buy\_car(carro2, 34800000)Yokomotor.buy\_car(carro3, 65900000)Yokomotor.buy\_car(carro4, 55900000) Yokomotor.show\_available\_cars()Yokomotor.show\_selled\_cars() \#Comienso la venta de los carrosYokomotor.sell\_car(carro1, cliente3, vendedor4)Yokomotor.sell\_car(carro3, cliente1, vendedor4)Yokomotor.sell\_car(carro2, cliente2, vendedor3)Yokomotor.sell\_car(carro4, cliente2, vendedor2)#Yokomotor.sell\_car(carro3, cliente2, vendedor1) Yokomotor.show\_available\_cars()Yokomotor.show\_selled\_cars()        

Me tomó un par de horas, pero creo que por fin estoy aprendiendo :)      Prueba:  

```js class Car: def __init__(self, brand, model, year, price, available): self.brand = brand self.model = model self.year = year self.price = price self.available = available def available_car(self): if self.available: print(f"El auto {self.brand} {self.model} esta disponible para vender") else: print(f"El auto {self.brand} {self.model} no esta disponible para vender") class Cliente: def __init__(self, name, id): self.name = name self.id = id def buy_car(self, car): if car.available: car.available = False print(f"{self.name} ha comprado el auto {car.brand} {car.model} en el concesionario") def sold_car(self, car): if not car.available: car.available = True print(f"{self.name} ha vendido el auto {car.brand} {car.model} al concesionario") class Concesionaria(): def __init__(self): self.cars = [] self.clientes = [] def agregar_vehiculo(self, vehiculo): self.cars.append(vehiculo) print(f"El auto {vehiculo.brand} {vehiculo.model} ingreso al deposito") def registrar_cliente(self, cliente): self.clientes.append(cliente) print(f"El cliente {cliente.name} ha sido registrado.") def mostrar_vehiculos_disponibles(self): print("Vehículos disponibles:") for vehiculo in self.cars: if vehiculo.available: print(f"{vehiculo.model} por ${vehiculo.price}") car1 = Car("Toyota", "Corolla", 2022, 25000, True) car2 = Car("Honda", "Civic", 2021, 22000, True) car3 = Car("Ford", "Mustang", 2023, 35000, True) cliente1 = Cliente("Juan", 12345) cliente2 = Cliente("María", 67890) concesionaria = Concesionaria() concesionaria.agregar_vehiculo(car1) concesionaria.agregar_vehiculo(car2) concesionaria.agregar_vehiculo(car3) concesionaria.registrar_cliente(cliente1) concesionaria.registrar_cliente(cliente2) concesionaria.mostrar_vehiculos_disponibles() cliente1.buy_car(car1) concesionaria.mostrar_vehiculos_disponibles() cliente1.sold_car(car1) concesionaria.mostrar_vehiculos_disponibles() ```class Car:  def \_\_init\_\_(self, brand, model, year, price, available):    self.brand = brand    self.model = model    self.year = year    self.price = price    self.available = available   def available\_car(self):    if self.available:      print(f"El auto {self.brand} {self.model} esta disponible para vender")    else:      print(f"El auto {self.brand} {self.model} no esta disponible para vender") class Cliente:  def \_\_init\_\_(self, name, id):    self.name = name    self.id = id   def buy\_car(self, car):    if car.available:      car.available = False      print(f"{self.name} ha comprado el auto {car.brand} {car.model} en el concesionario")   def sold\_car(self, car):    if not car.available:      car.available = True      print(f"{self.name} ha vendido el auto {car.brand} {car.model} al concesionario")   class Concesionaria():    def \_\_init\_\_(self):        self.cars = \[]        self.clientes = \[]     def agregar\_vehiculo(self, vehiculo):        self.cars.append(vehiculo)        print(f"El auto {vehiculo.brand} {vehiculo.model} ingreso al deposito")     def registrar\_cliente(self, cliente):        self.clientes.append(cliente)        print(f"El cliente {cliente.name} ha sido registrado.")     def mostrar\_vehiculos\_disponibles(self):        print("Vehículos disponibles:")        for vehiculo in self.cars:            if vehiculo.available:                print(f"{vehiculo.model} por ${vehiculo.price}") car1 = Car("Toyota", "Corolla", 2022, 25000, True)car2 = Car("Honda", "Civic", 2021, 22000, True)car3 = Car("Ford", "Mustang", 2023, 35000, True) cliente1 = Cliente("Juan", 12345)cliente2 = Cliente("María", 67890) concesionaria = Concesionaria()concesionaria.agregar\_vehiculo(car1)concesionaria.agregar\_vehiculo(car2)concesionaria.agregar\_vehiculo(car3) concesionaria.registrar\_cliente(cliente1)concesionaria.registrar\_cliente(cliente2) concesionaria.mostrar\_vehiculos\_disponibles() cliente1.buy\_car(car1)concesionaria.mostrar\_vehiculos\_disponibles() cliente1.sold\_car(car1)concesionaria.mostrar\_vehiculos\_disponibles()

Aqui mi aporte ```js #Tendremos una consecionaria #Se pueden hacer compras y ventas de vehiculos #Gestionar Vehiculos, Modelo, Precio, Disponibilidad, Color class Vehiculo: def __init__(self, modelo, precio, color): self.modelo = modelo self.precio = precio self.color = color self.available_car = True def vender(self): self.available_car = False print(f"El vehículo {self.modelo} ha sido vendido.") def comprar(self): self.available_car = True print(f"El vehículo {self.modelo} ha sido comprado y está disponible nuevamente.") class Cliente: def __init__(self, name, user_id): self.name = name self.user_id = user_id def comprar_vehiculo(self, vehiculo, consecionaria): if vehiculo.available_car: consecionaria.vender_vehiculo(vehiculo) print(f"{self.name} ha comprado el vehículo {vehiculo.modelo} por ${vehiculo.precio}.") else: print(f"Lo siento, {self.name}, el vehículo {vehiculo.modelo} no está disponible.") def vender_vehiculo(self, vehiculo, consecionaria): consecionaria.comprar_vehiculo(vehiculo) print(f"{self.name} ha vendido el vehículo {vehiculo.modelo} por ${vehiculo.precio}.") class Consecionaria: def __init__(self): self.cars_for_sell = [] def register_a_car(self, car): self.cars_for_sell.append(car) print(f"Se ha registrado el vehículo {car.modelo} por un precio de ${car.precio}.") def show_pasarell_cars(self): print("Los vehículos disponibles son:") for car in self.cars_for_sell: if car.available_car: print(f"{car.modelo} ({car.color}) por un precio de ${car.precio}") def vender_vehiculo(self, vehiculo): if vehiculo in self.cars_for_sell and vehiculo.available_car: vehiculo.vender() else: print(f"El vehículo {vehiculo.modelo} no está disponible o no está registrado en la consecionaria.") def comprar_vehiculo(self, vehiculo): if vehiculo in self.cars_for_sell and not vehiculo.available_car: vehiculo.comprar() else: print(f"El vehículo {vehiculo.modelo} ya está disponible o no está registrado en la consecionaria.") # Creamos los vehículos vehiculo1 = Vehiculo("Mazda", 350000, "Rojo") vehiculo2 = Vehiculo("Mini Cooper", 450000, "Azul") # Creamos a los clientes cliente1 = Cliente("Sebastian", "Chevy") # Creamos la consecionaria consecionaria = Consecionaria() # Registramos los vehículos consecionaria.register_a_car(vehiculo1) consecionaria.register_a_car(vehiculo2) # Mostrar los coches disponibles en la consecionaria consecionaria.show_pasarell_cars() # Cliente compra un vehículo cliente1.comprar_vehiculo(vehiculo1, consecionaria) # Mostrar los coches disponibles después de la compra consecionaria.show_pasarell_cars() # Cliente vende un vehículo cliente1.vender_vehiculo(vehiculo1, consecionaria) # Mostrar los coches disponibles después de la venta consecionaria.show_pasarell_cars() ```

# Hello folk En el reto me pareció interesante que lo más difícil no fue escribir el código sino mas bien que al principio no sabia muy bien cual seria la lógica y no sabia que métodos debería tener cada clase, al final pude escribir un código en el cual creo que terminaron sobrando barias cosas, sobre todo la clase "vehicle" que hice ya que siento se podría manejar como información y no hacer una clase que ni siquiera tiene métodos aparte del constructor. acá les dejo mi código para que lo lean, lo utilicen y me digan que cosas podría mejorar. ```js # script to learn OOP in python # proyect dealership #---------------------------------- # declares the variables vehicles_data = [ # Cars (including electric cars) {"license_plate": "ABC1234", "brand": "Toyota", "model": "Corolla", "year": 2020, "price": 15000, "color": "Red", "engine_type": "Gasoline", "transmission": "Automatic", "distance_traveled": 30000, "available": True}, {"license_plate": "DEF5678", "brand": "Ford", "model": "Mustang", "year": 2019, "price": 25000, "color": "Blue", "engine_type": "Gasoline", "transmission": "Manual", "distance_traveled": 20000, "available": True}, {"license_plate": "GHI9101", "brand": "Tesla", "model": "Model 3", "year": 2021, "price": 35000, "color": "White", "engine_type": "Electric", "transmission": "Automatic", "distance_traveled": 15000, "available": True}, {"license_plate": "JKL1121", "brand": "Chevrolet", "model": "Bolt EV", "year": 2020, "price": 32000, "color": "Gray", "engine_type": "Electric", "transmission": "Automatic", "distance_traveled": 12000, "available": True}, {"license_plate": "MNO3141", "brand": "Nissan", "model": "Leaf", "year": 2018, "price": 20000, "color": "Green", "engine_type": "Electric", "transmission": "Automatic", "distance_traveled": 18000, "available": True}, # Motorcycles {"license_plate": "PQR5161", "brand": "Harley-Davidson", "model": "Sportster", "year": 2018, "price": 12000, "color": "Black", "engine_type": "Gasoline", "transmission": "Manual", "distance_traveled": 15000, "available": True}, {"license_plate": "STU7181", "brand": "Yamaha", "model": "YZF-R3", "year": 2019, "price": 5500, "color": "Blue", "engine_type": "Gasoline", "transmission": "Manual", "distance_traveled": 8000, "available": True}, {"license_plate": "VWX9201", "brand": "Ducati", "model": "Panigale V4", "year": 2020, "price": 22000, "color": "Red", "engine_type": "Gasoline", "transmission": "Manual", "distance_traveled": 5000, "available": True}, {"license_plate": "YZA1221", "brand": "Kawasaki", "model": "Ninja 400", "year": 2021, "price": 6000, "color": "Green", "engine_type": "Gasoline", "transmission": "Manual", "distance_traveled": 3000, "available": True}, {"license_plate": "BCD3241", "brand": "BMW", "model": "S1000RR", "year": 2017, "price": 16000, "color": "White", "engine_type": "Gasoline", "transmission": "Manual", "distance_traveled": 20000, "available": True}, # Other Types (Bicycles, Electric Bicycles, Electric Scooters) {"license_plate": "BIKE12345", "brand": "Trek", "model": "Domane SL 7", "year": 2022, "price": 7000, "color": "Red", "engine_type": "None", "transmission": "Manual", "distance_traveled": 500, "available": True}, {"license_plate": "EBIKE6789", "brand": "Specialized", "model": "Turbo Vado SL", "year": 2021, "price": 4500, "color": "Blue", "engine_type": "Electric", "transmission": "Automatic", "distance_traveled": 300, "available": True}, {"license_plate": "BIKE24680", "brand": "Cannondale", "model": "SuperSix EVO", "year": 2020, "price": 4000, "color": "Black", "engine_type": "None", "transmission": "Manual", "distance_traveled": 1000, "available": True}, {"license_plate": "SC1234567", "brand": "Razor", "model": "EcoSmart Metro HD", "year": 2021, "price": 600, "color": "White", "engine_type": "Electric", "transmission": "Automatic", "distance_traveled": 200, "available": True}, {"license_plate": "SC2345678", "brand": "Xiaomi", "model": "Mi Electric Scooter Pro 2", "year": 2022, "price": 550, "color": "Black", "engine_type": "Electric", "transmission": "Automatic", "distance_traveled": 100, "available": True} ] inventory = [] # creating the classes class Vehicle: def __init__(self, license_plate, brand, model, year, price, color, engine_type, transmission, distance_traveled, available): self.license_plate = license_plate self.brand = brand self.model = model self.year = year self.price = price self.color = color self.engine_type = engine_type self.transmission = transmission self.distance_traveled = distance_traveled self.available = available class Dealership: def __init__(self, name, location): self.name = name self.location = location self.inventory = [] def add_inventory(self, vehicles_data): inventory = [ Vehicle( license_plate = data ["license_plate"], brand = data ["brand"], model = data ["model"], year = data ["year"], price = data ["price"], color = data ["color"], engine_type = data ["engine_type"], transmission = data ["transmission"], distance_traveled = data ["distance_traveled"], available = data ["available"] ) for data in vehicles_data ] self.inventory.extend(inventory) print(f"Inventory updated with {len(inventory)} vehicles.") def add_vehicle(self, vehicle): self.inventory.append(vehicle) def sell_vehicle(self, license_plate, customer): for vehicle in self.inventory: if vehicle.license_plate == license_plate: vehicle.available = False self.inventory.remove(vehicle) customer.garage.append(vehicle) print(f"Vehicle {license_plate} sold to {customer.name}.") return True else: print(f"Vehicle {license_plate} not found in inventory.") return False def buy_vehicle(self, license_plate, customer): for vehicle in customer.garage: if vehicle.license_plate == license_plate and vehicle.available: vehicle.available = True customer.garage.remove(vehicle) self.inventory.append(vehicle) print(f"Vehicle {license_plate} bought by {customer.name}.") def list_vehicles(self): for vehicle in self.inventory: print(f"{self.name}'s vehicle inventory: \nLicense plate: {vehicle.license_plate}\nBrand: {vehicle.brand}\n Model: {vehicle.model}\nYear: {vehicle.year}\n Price: {vehicle.price}\n Color: {vehicle.color}\n 'Engine type': {vehicle.engine_type}\nTransmission: {vehicle.transmission}\nDistance traveled: {vehicle.distance_traveled}\nAvailable: {vehicle.available}\n") class Customer: def __init__(self, name, id_number): self.name = name self.id_number = id_number self.garage = [] def buy_my_vehicle(self, dealership, license_plate): dealership.sell_vehicle(license_plate, self) def sell_my_vehicle(self, dealership, license_plate): for vehicle in self.garage: if vehicle.license_plate == license_plate: vehicle.available = True dealership.buy_vehicle(license_plate, self) def drive_vehicle(self, license_plate, distance): for vehicle in self.garage: if vehicle.license_plate == license_plate: vehicle.distance_traveled += distance print(f"Vehicle {license_plate} traveled {distance} Km.") return True else: print(f"Vehicle {license_plate} not found in garage.") return False def check_garage(self): n = 0 print(f"\n{self.name}'s garage") if len(self.garage) == 0: print("Garage is empty.") else: for vehicle in self.garage: n += 1 print(f"vehicle {n}:") print(f"License plate: {vehicle.license_plate}\nBrand: {vehicle.brand}\nModel: {vehicle.model}\n") # inicializing variables and creating objects dealership1 = Dealership("Prime Autos", "1234 Elm Street, Springfield, IL, USA") dealership1.add_inventory(vehicles_data) dealership2 = Dealership("Green Wheels Dealership", "5678 Oak Avenue, Greenfield, CA, USA") dealership2.add_inventory(vehicles_data) customer1 = Customer("John Doe", "123456789") customer2 = Customer("Jane Smith", "987654321") customer3 = Customer("Bob Johnson", "456789123") customer4 = Customer("Alice Brown", "321654987") dealership1.list_vehicles() customer1.buy_my_vehicle(dealership1, "ABC1234") customer1.buy_my_vehicle(dealership1, "DEF5678") customer1.check_garage() customer1.drive_vehicle("ABC1234", 100) customer1.sell_my_vehicle(dealership1, "ABC1234") customer1.check_garage() dealership1.list_vehicles() customer2.check_garage() ```

```js class Vehiculo: def __init__(self, marca, precio): self.marca = marca self.precio = precio self.disponible = True def sell(self): if self.disponible: self.disponible = False print(f"El vehículo {self.marca} ha sido vendido.") else: print(f"El vehículo {self.marca} no está disponible.") def mostrar_info(self): disponibilidad = "disponible" if self.disponible else "no disponible" print(f"{self.marca} - Precio: ${self.precio}, Estado: {disponibilidad}") class Concesionaria: def __init__(self): self.vehiculos = [] def agregar_vehiculo(self, vehiculo): self.vehiculos.append(vehiculo) print(f"El vehículo {vehiculo.marca} ha sido agregado a la concesionaria.") def mostrar_vehiculos_disponibles(self): print("Vehículos disponibles:") for vehiculo in self.vehiculos: vehiculo.mostrar_info() def sell_vehiculo(self, vehiculo): if vehiculo in self.vehiculos: vehiculo.sell() else: print(f"El vehículo {vehiculo.marca} no está en la concesionaria.") def vender_a_usuario(self, usuario, vehiculo): if vehiculo in self.vehiculos: if vehiculo.disponible: usuario.comprar_vehiculo(self, vehiculo) else: print(f"El vehículo {vehiculo.marca} no está disponible.") else: print(f"El vehículo {vehiculo.marca} no está en la concesionaria.") class Usuario: def __init__(self, nombre): self.nombre = nombre self.vehiculos_comprados = [] def comprar_vehiculo(self, concesionaria, vehiculo): if vehiculo in concesionaria.vehiculos and vehiculo.disponible: vehiculo.sell() self.vehiculos_comprados.append(vehiculo) print(f"{self.nombre} ha comprado el vehículo {vehiculo.marca}.") else: print(f"El vehículo {vehiculo.marca} no está disponible o no está en la concesionaria.") vehiculo1 = Vehiculo("Toyota Corolla", 15000) vehiculo2 = Vehiculo("Honda Civic", 18000) vehiculo3 = Vehiculo("Ford Focus", 17000) vehiculo4 = Vehiculo("Chevrolet Cruze", 16000) concesionaria = Concesionaria() concesionaria.agregar_vehiculo(vehiculo1) concesionaria.agregar_vehiculo(vehiculo2) concesionaria.agregar_vehiculo(vehiculo3) concesionaria.agregar_vehiculo(vehiculo4) concesionaria.mostrar_vehiculos_disponibles() usuario = Usuario("Eze") concesionaria.vender_a_usuario(usuario, vehiculo2) concesionaria.mostrar_vehiculos_disponibles() concesionaria.vender_a_usuario(usuario, vehiculo2) vehiculo_fantasma = Vehiculo("Tesla Model S", 90000) concesionaria.vender_a_usuario(usuario, vehiculo_fantasma) print(f"\nVehículos comprados por {usuario.nombre}:") for vehiculo in usuario.vehiculos_comprados: vehiculo.mostrar_info() ```class Vehiculo: def \_\_init\_\_(self, marca, precio): self.marca = marca self.precio = precio self.disponible = True def sell(self): if self.disponible: self.disponible = False print(f"El vehículo {self.marca} ha sido vendido.") else: print(f"El vehículo {self.marca} no está disponible.") def mostrar\_info(self): disponibilidad = "disponible" if self.disponible else "no disponible" print(f"{self.marca} - Precio: ${self.precio}, Estado: {disponibilidad}") class Concesionaria: def \_\_init\_\_(self): self.vehiculos = \[] def agregar\_vehiculo(self, vehiculo): self.vehiculos.append(vehiculo) print(f"El vehículo {vehiculo.marca} ha sido agregado a la concesionaria.") def mostrar\_vehiculos\_disponibles(self): print("Vehículos disponibles:") for vehiculo in self.vehiculos: vehiculo.mostrar\_info() def sell\_vehiculo(self, vehiculo): if vehiculo in self.vehiculos: vehiculo.sell() else: print(f"El vehículo {vehiculo.marca} no está en la concesionaria.") def vender\_a\_usuario(self, usuario, vehiculo): if vehiculo in self.vehiculos: if vehiculo.disponible: usuario.comprar\_vehiculo(self, vehiculo) else: print(f"El vehículo {vehiculo.marca} no está disponible.") else: print(f"El vehículo {vehiculo.marca} no está en la concesionaria.") class Usuario: def \_\_init\_\_(self, nombre): self.nombre = nombre self.vehiculos\_comprados = \[] def comprar\_vehiculo(self, concesionaria, vehiculo): if vehiculo in concesionaria.vehiculos and vehiculo.disponible: vehiculo.sell() self.vehiculos\_comprados.append(vehiculo) print(f"{self.nombre} ha comprado el vehículo {vehiculo.marca}.") else: print(f"El vehículo {vehiculo.marca} no está disponible o no está en la concesionaria.") vehiculo1 = Vehiculo("Toyota Corolla", 15000) vehiculo2 = Vehiculo("Honda Civic", 18000) vehiculo3 = Vehiculo("Ford Focus", 17000) vehiculo4 = Vehiculo("Chevrolet Cruze", 16000) concesionaria = Concesionaria() concesionaria.agregar\_vehiculo(vehiculo1) concesionaria.agregar\_vehiculo(vehiculo2) concesionaria.agregar\_vehiculo(vehiculo3) concesionaria.agregar\_vehiculo(vehiculo4) concesionaria.mostrar\_vehiculos\_disponibles() usuario = Usuario("Eze") concesionaria.vender\_a\_usuario(usuario, vehiculo2) concesionaria.mostrar\_vehiculos\_disponibles() concesionaria.vender\_a\_usuario(usuario, vehiculo2) vehiculo\_fantasma = Vehiculo("Tesla Model S", 90000) concesionaria.vender\_a\_usuario(usuario, vehiculo\_fantasma) print(f"\nVehículos comprados por {usuario.nombre}:") for vehiculo in usuario.vehiculos\_comprados: vehiculo.mostrar\_info()

```python #------------------------------------------------------------------------ #------------------CONCESIONARIO DE VEHÍCULOS---------------------------- #------------------------------------------------------------------------ #------------------------------------------------------------------------ #LIBRERÍAS NECESARIAS #------------------------------------------------------------------------ import string import random #------------------------------------------------------------------------ #VARIABLES GLOBALES #1. Para generar placas automáticamente #------------------------------------------------------------------------ # Letras: letters = string.ascii_uppercase # Números: nums = string.digits #------------------------------------------------------------------------ # DEFINICIÓN DE CLASES #------------------------------------------------------------------------ #------------------------------------------------------------------------ #1. Concesionario: # Funciones: # Cotizar, Registrar cliente, registrar vehículo, disponibilidad # Constructor: # Nombre #------------------------------------------------------------------------ class Concesionario: def __init__(self, name): self.name = name self.cars = [] self.clients = [] def quote_car(self,car): print(f"El vehículo {car.brand} {car.model} cuesta ${car.price} USD") def register_car(self,car): self.cars.append(car) print(f"El vehículo {car.brand} {car.model} de placas {car.plate} ha sido adquirido por el concesionario {self.name}") def register_client(self,client): self.clients.append(client) print(f"El cliente {client.name} ha sido registrado") def show_available_cars(self): print(f"Vehículos disponibles de {self.name}:") for car in self.cars: if car.available: print(f"{car.brand} {car.model} de placas {car.plate}") #------------------------------------------------------------------------ #2. Vehículo: # Funciones: # Vender, Comprar # Constructor: # Modelo, Marca, Año modelo, precio, placa #------------------------------------------------------------------------ class Car: def __init__(self, brand, model, year_model, input_plate, price): self.brand = brand self.model = model self.year_model = year_model self.plate = input_plate self.price = price self.available = True def purchase(self, plate,conces): if self.available and (self.plate == plate or self.plate == "None"): self.available = False conces.cars.remove(self) if self.plate == "None": self.plate = ''.join(random.choice(letters) for _ in range(3)) + ''.join(random.choice(nums) for _ in range(3)) print(f"El vehículo {self.brand} {self.model} ha sido vendido con placas {self.plate}") else: print(f"El vehículo {self.brand} {self.model} no está disponible con la placa {plate}. Busca con otra placa.") def sell(self, conces): self.available = True conces.register_car(self) print(f"El vehículo {self.brand} {self.model} de placas {self.plate} ha sido vendido a {conces.name}") #------------------------------------------------------------------------ #3. Cliente: # Funciones: # Comprar,Vender #------------------------------------------------------------------------ class Client: def __init__(self, name, client_id): self.name = name self.client_id = client_id self.purchased_cars = [] def sell_car(self,car,conces): if car in self.purchased_cars: car.sell(conces) self.purchased_cars.remove(car) else: print(f"El vehículo {car.brand} {car.model} no de propiedad de {self.name}") def purchase_car(self,car,plate,conces): if car.available: car.purchase(plate,conces) self.purchased_cars.append(car) else: print(f"El vehículo {car.brand} {car.model} no está disponible") ```Arriba la construcción de la jerarquía de clases dell reto, enseguida un ejemplo de implementación de objetos. ```js #------------------------------------------------------------------------ # IMPLEMENTACIÓN #------------------------------------------------------------------------ #Crear vehículos veh_nuevo = Car("Tesla","Model S",2024,"None",100000) veh_usado = Car("Mazda", "CX50",2024,"ABC123",90000) #Crear clientes cliente1 = Client("Juan Hurtado","001") #Crear concesionario conces1 = Concesionario("Jorge Cortés") conces2 = Concesionario("Súper usados") #Gestionar compra conces1.register_car(veh_nuevo) conces1.register_car(veh_usado) conces1.show_available_cars() conces1.quote_car(veh_nuevo) conces1.quote_car(veh_usado) cliente1.purchase_car(veh_nuevo,"Es nuevo",conces1) cliente1.purchase_car(veh_usado,"ABC123",conces1) #Gestionar venta cliente1.sell_car(veh_nuevo,conces2) conces1.show_available_cars() conces2.show_available_cars() ```

```python class Vehiculo: def __init__(self, precio, marca, modelo): self.precio = precio self.marca = marca self.modelo = modelo self.disponible = True def comprar_vehiculo(self): self.disponible = False class Persona: def __init__(self,Nombre,Cedula): self.Nombre = Nombre self.Cedula = Cedula self.VehiculosComprados = [] def comprar_vehiculo(self,vehiculo,consecionario,pago): if pago >= vehiculo.precio: print (f"\nEl vehiculo {vehiculo.marca} ha sido comprado por el usuario {self.Nombre}") vehiculo.comprar_vehiculo() consecionario.ventaVehiculo(vehiculo) consecionario.verVehiculos() else: print (f"\nEl pago dado por el usuario {self.Nombre} es Insuficuente") print("\n") class Consecionario: def __init__(self): self.Usuarios = [] self.Vehiculos = [] def agregarUsuarios(self, usuario): self.Usuarios.append(usuario) print(f"El usuario {usuario.Nombre} fue agregado a la base de datos") print("\n") def agregarVehiculo(self, vehiculo): self.Vehiculos.append(vehiculo) print(f"El vehiculo {vehiculo.modelo} de la marca {vehiculo.marca} fue agregado a la base de datos") print("\n") def ventaVehiculo (self, vehiculo): self.Vehiculos.remove(vehiculo) print("\n") def verVehiculos (self): print("\nLos vehiculos disponibles son:") for vehicle in self.Vehiculos: if vehicle.disponible: print(f"{vehicle.marca}") #Crear Vehiculos Ferrari = Vehiculo(100000,"Ferrari",2020) Ford = Vehiculo(10000,"Ford",2010) Nissan = Vehiculo(1000,"Nissan",2006) Ferrari_Jaguar = Vehiculo(100000,"Ferrari Jaguar",2020) Ford_Raptor = Vehiculo(10000,"Ford Raptor",2010) Nissan_nitro = Vehiculo(1000,"Nissan nitro",2006) #Crear Uusraios Pablo = Persona("Pablo","1") Natalia = Persona("Natalia","2") Jose = Persona("Jose","3") Maria = Persona("Maria","4") Beatriz = Persona("Beatriz","5") #Crear Consecionario consecionario = Consecionario() #Agregar Usuarios y Vehiculos consecionario.agregarVehiculo(Ferrari) consecionario.agregarVehiculo(Ford) consecionario.agregarVehiculo(Nissan) consecionario.agregarVehiculo(Ferrari_Jaguar) consecionario.agregarVehiculo(Ford_Raptor) consecionario.agregarVehiculo(Nissan_nitro) consecionario.agregarUsuarios(Pablo) consecionario.agregarUsuarios(Natalia) consecionario.agregarUsuarios(Jose) consecionario.agregarUsuarios(Maria) consecionario.agregarUsuarios(Beatriz) #Ver Vehiculos consecionario.verVehiculos() #Comprar y Venta Pablo.comprar_vehiculo(Ferrari_Jaguar,consecionario,10000) Pablo.comprar_vehiculo(Ferrari_Jaguar,consecionario,100000) ```Mi aporte al reto