Gestión de Biblioteca con Programación Orientada a Objetos
Resumen
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.
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.
Buen consejo!
Pues si , pero pues de eso se trata, aprender.
#Ejercicio concesionarioclassVehiculo:def__init__(self, modelo, precio): self.modelo = modelo
self.precio = precio
self.disponible =Truedefvender(self):if self.disponible: self.disponible =Falseprint(f"El vehículo {self.modelo} ha sido vendido.")else:print(f"El vehículo {self.modelo} no está disponible.")defhacer_disponible(self): self.disponible =Trueprint(f"El vehículo {self.modelo} está disponible para la venta nuevamente.")classCliente:def__init__(self, nombre, id_cliente): self.nombre = nombre
self.id_cliente = id_cliente
self.vehiculos_comprados =[]defcomprar_vehiculo(self, vehiculo):if vehiculo.disponible: vehiculo.vender() self.vehiculos_comprados.append(vehiculo)else:print(f"El vehículo {vehiculo.modelo} no está disponible.")defdevolver_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.")classConcesionario:def__init__(self): self.vehiculos =[] self.clientes =[]defagregar_vehiculo(self, vehiculo): self.vehiculos.append(vehiculo)print(f"El vehículo {vehiculo.modelo} ha sido agregado al inventario.")defregistrar_cliente(self, cliente): self.clientes.append(cliente)print(f"El cliente {cliente.nombre} ha sido registrado.")defmostrar_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("Dlorean",1500)vehiculo2 = Vehiculo("Mazda",600)# Crear clientecliente1 = Cliente("Alex","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()
Amigo, tienes un error tu código, lo ejecuté pero al final me muestra:
"Vehículos disponibles:
Dlorean por $1500
Mazda por $600
Dlorean por $1500"
Es decir que, cuando el cliente devuelve el vehículo Dlorean, lo estás agregando de nuevo al inventario del concesionario sin eliminar el vehículo original que ya estaba allí. Esto hace que el vehículo Dlorean aparezca dos veces en la lista de inventario del concesionario.
Por lo que a la hora de definir la función devolver_vehiculo, no debes utilizar concesionario.agregar_vehiculo(vehiculo), por lo que la función debe ser: " def devolver_vehiculo(self, vehiculo, concesionario): if vehiculo in self.vehiculos_comprados: vehiculo.hacer_disponible() self.vehiculos_comprados.remove(vehiculo) else: print(f"El vehículo {vehiculo.modelo} no está en la lista de comprados.")"
Camaradas qué significa el simbolito que aparece automáticamente en vscode cuando inicia uno el código de una clase: --> None,
Porfis
Eso significa que no va a recibir ningun argumento.
En las clases, se hereda si pones entre parentesis otra clase o un objeto
class Hijo(Padre)
la clase hijo hereda del padre.
O en funciones, es una buena práctica indicarle qué tipo de dato van a recibir las funciones, aunque no influya directamente en la función. Pero es una muy buena práctica.
def numeros(num1, num2): -> int
Los numeros que recibe son de tipo entero
Gracias
classCar: def __init__(self, model, price): self.model= model
self.price= price
self.available=True def sell(self):if self.available: self.available=Falseprint(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})"classPerson: 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")classDealer: 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()```classCar: def \_\_init\_\_(self, model, price): self.model= model self.price= price self.available=True  def sell(self):if self.available: self.available=Falseprint(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})"classPerson: 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")classDealer: 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()
Con todo respeto, se nota que la profe sabe muchísimo.. no lo discuto. Pero en la explicación le está faltando mucho, sobretodo para quienes recién inician. Cuesta mucho seguirle el hilo, va muy rápido sin dar explicación y descripción detallada del porqué lleva cada paso a paso. Es la primera vez que me sucede esto en la plataforma. :(
El curso de programacion basica te podría ayudar, si bien allí se maneja Js y Html, estos conceptos base te pueden ayudar a tu logica de programación, busca retos y más explicaciones en otras paginas o ayudate de la IA para entender. Gran parte de este conocimiento solo lo entiendes practicando.
Nunca pares de aprender!
¿Qué es __init**_ _? ¿Por qué y para qué está allí? ¿Qué tipos de uso tiene?. Por favor, necesitamos que los profesores se comporten de forma académica, nada hacemos con puro leer a alguien codeando, necesitamos explicación de lo que se hace. Ya lo he puesto varias veces. Creo que es todo el curso que considero, está fatal para la enseñanza. =(**
__init __ es un contructor y lo que busca es plantear el estado inicial del objeto. este estado inicial puede cambiar o puede permanecer igual durante la ejecucion del codigo es decir va depender de lo que se requiera programar
Seria una buena idea que los códigos dejados en los recursos de la clase estuvieran comentados para una mejor comprensión del código.
¿Es normal que en la definición de una clase, se ejecute el metodo de otra? como hizo en la clase User al llamar a un métido de la clase libro, ¿no deberia hacerlo la lógica del código que usa esa clase?
Hola compañero, respondiendo tu pregunta, si es algo normal y es algo habitual en la POO, como podemos ver en el ejercicio, a los métodos de la clase User les pasamos objetos de la clase Book, lo que nos pone a disposición los métodos de la clase Book, por lo que podemos reutilizar el código ya existente, además de que si puedes analizar la lógica, un Usuario al prestar un libro activa el método de prestar de libro, ya que un libro se le puede prestar a un usuario pero un libro solamente no puede ser prestado si no hay un usuario al que se le pueda prestar. Espero haber podido explicarme. Mucho éxito compañero
Favor de considerar la restructuracion de la clase, el ir escibiendo codigo sin explicar a detalle en un tema complejo hace dificil el entendimiento.
por que hay dos funciones que se llaman return_book? esto es buena practica?
Las dos funciones con el nombre 'return_book' corresponden a clases distintas, una al usuario y otra al libro, reflejando acciones relevantes a cada una. Es una práctica aceptable siempre y cuando el contexto y la funcionalidad estén claramente definidos por la estructura y responsabilidades de las clases involucradas.
Aunque se vea raro, está bien porque estamos aprendiendo, pero ya a un nivel alto profesional en proyectos grandes, es muy buena práctica llevar un tipo de secuencia y orden en donde aplican funcione con el mismo nombre dentro de distintas clases. Vas a agradecer y amar que sea así jajaja.
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
De acuerdo contigo, además tampoco me gusta que la propiedad available del libro sea una característica del libro, debería ser la biblioteca la que en su lista de libros se esté definido cuales tiene, cuales están disponibles para prestamo y cuales están prestados.
De acuerdo. En una biblioteca real, la disponibilidad es una característica del inventario, no del libro en sí. Permite tener múltiples copias de un mismo libro. Toda la lógica de préstamo y devolución está en la clase Library, lo que facilita la implementación de reglas adicionales (como límites de préstamo) en el futuro. Podemos saber fácilmente quién tiene prestado cada libro.
from typing import List, Dict
classBook:def__init__(self, title:str, author:str, isbn:str): self.title = title
self.author = author
self.isbn = isbn
def__str__(self):returnf"'{self.title}' por {self.author}"classUser:def__init__(self, name:str, user_id:str): self.name = name
self.user_id = user_id
classLibrary:def__init__(self): self.inventory: Dict[str, Dict]={} self.users: List[User]=[]defadd_book(self, book: Book, quantity:int=1)->None:if book.isbn in self.inventory: self.inventory[book.isbn]['available']+= quantity
else: self.inventory[book.isbn]={'book': book,'available': quantity,'borrowed':[]}print(f"Añadido(s) {quantity} ejemplar(es) de {book} al inventario")defregister_user(self, user: User)->None: self.users.append(user)print(f"Usuario '{user.name}' registrado")defshow_available_books(self)->None: available_books =[(info['book'], info['available'])for info in self.inventory.values()if info['available']>0]ifnot available_books:print("No hay libros disponibles en la biblioteca")else:print("Libros disponibles:")for book, quantity in available_books:print(f"{book} - {quantity} ejemplar(es) disponible(s)")defborrow_book(self, user: User, isbn:str)->None:if isbn notin self.inventory:print(f"El libro con ISBN {isbn} no está en nuestro inventario")return book_info = self.inventory[isbn]if book_info['available']>0: book_info['available']-=1 book_info['borrowed'].append(user)print(f"{user.name} ha tomado prestado '{book_info['book'].title}'")else:print(f"No hay ejemplares disponibles de '{book_info['book'].title}'")defreturn_book(self, user: User, isbn:str)->None:if isbn notin self.inventory:print(f"El libro con ISBN {isbn} no pertenece a nuestro inventario")return book_info = self.inventory[isbn]if user in book_info['borrowed']: book_info['available']+=1 book_info['borrowed'].remove(user)print(f"{user.name} ha devuelto '{book_info['book'].title}'")else:print(f"{user.name} no tenía prestado '{book_info['book'].title}'")deffind_book(self, isbn:str)-> Book:return self.inventory[isbn]['book']if isbn in self.inventory elseNonedeffind_books_by_author(self, author:str)-> List[Book]:return[info['book']for info in self.inventory.values()if info['book'].author.lower()== author.lower()]# Ejemplo de usoif __name__ =="__main__": library = Library()# Crear libros book1 = Book("El principito","Antoine de Saint-Exupéry","978-3140464079") book2 = Book("1984","George Orwell","978-0451524935")# Añadir libros a la biblioteca library.add_book(book1,2) library.add_book(book2,1)# Crear usuarios user1 = User("Carli","001") user2 = User("Ana","002")# Registrar usuarios library.register_user(user1) library.register_user(user2)# Mostrar libros disponibles inicialmenteprint("\nLibros disponibles inicialmente:") library.show_available_books()# Realizar préstamos library.borrow_book(user1,"978-3140464079") library.borrow_book(user2,"978-3140464079") library.borrow_book(user1,"978-0451524935")# Mostrar libros disponibles después de los préstamosprint("\nLibros disponibles después de los préstamos:") library.show_available_books()# Devolver libros library.return_book(user1,"978-3140464079") library.return_book(user1,"978-0451524935")# Mostrar libros disponibles después de las devolucionesprint("\nLibros disponibles después de las devoluciones:") library.show_available_books()# Prestar todos los libros disponibles library.borrow_book(user2,"978-3140464079") library.borrow_book(user2,"978-0451524935")# Mostrar libros disponibles cuando no hay ningunoprint("\nIntentando mostrar libros disponibles cuando no hay ninguno:") library.show_available_books()from typing import List, Dict
classBook:def__init__(self, title:str, author:str, isbn:str): self.title = title
self.author = author
self.isbn = isbn
def__str__(self):returnf"'{self.title}' por {self.author}"classUser:def__init__(self, name:str, user_id:str): self.name = name
self.user_id = user_id
classLibrary:def__init__(self): self.inventory: Dict[str, Dict]={} self.users: List[User]=[]defadd_book(self, book: Book, quantity:int=1)->None:if book.isbn in self.inventory: self.inventory[book.isbn]['available']+= quantity
else: self.inventory[book.isbn]={'book': book,'available': quantity,'borrowed':[]}print(f"Añadido(s) {quantity} ejemplar(es) de {book} al inventario")defregister_user(self, user: User)->None: self.users.append(user)print(f"Usuario '{user.name}' registrado")defshow_available_books(self)->None: available_books =[(info['book'], info['available'])for info in self.inventory.values()if info['available']>0]ifnot available_books:print("No hay libros disponibles en la biblioteca")else:print("Libros disponibles:")for book, quantity in available_books:print(f"{book} - {quantity} ejemplar(es) disponible(s)")defborrow_book(self, user: User, isbn:str)->None:if isbn notin self.inventory:print(f"El libro con ISBN {isbn} no está en nuestro inventario")return book_info = self.inventory[isbn]if book_info['available']>0: book_info['available']-=1 book_info['borrowed'].append(user)print(f"{user.name} ha tomado prestado '{book_info['book'].title}'")else:print(f"No hay ejemplares disponibles de '{book_info['book'].title}'")defreturn_book(self, user: User, isbn:str)->None:if isbn notin self.inventory:print(f"El libro con ISBN {isbn} no pertenece a nuestro inventario")return book_info = self.inventory[isbn]if user in book_info['borrowed']: book_info['available']+=1 book_info['borrowed'].remove(user)print(f"{user.name} ha devuelto '{book_info['book'].title}'")else:print(f"{user.name} no tenía prestado '{book_info['book'].title}'")deffind_book(self, isbn:str)-> Book:return self.inventory[isbn]['book']if isbn in self.inventory elseNonedeffind_books_by_author(self, author:str)-> List[Book]:return[info['book']for info in self.inventory.values()if info['book'].author.lower()== author.lower()]# Ejemplo de usoif __name__ =="__main__": library = Library()# Crear libros book1 = Book("El principito","Antoine de Saint-Exupéry","978-3140464079") book2 = Book("1984","George Orwell","978-0451524935")# Añadir libros a la biblioteca library.add_book(book1,2) library.add_book(book2,1)# Crear usuarios user1 = User("Carli","001") user2 = User("Ana","002")# Registrar usuarios library.register_user(user1) library.register_user(user2)# Mostrar libros disponibles inicialmenteprint("\nLibros disponibles inicialmente:") library.show_available_books()# Realizar préstamos library.borrow_book(user1,"978-3140464079") library.borrow_book(user2,"978-3140464079") library.borrow_book(user1,"978-0451524935")# Mostrar libros disponibles después de los préstamosprint("\nLibros disponibles después de los préstamos:") library.show_available_books()# Devolver libros library.return_book(user1,"978-3140464079") library.return_book(user1,"978-0451524935")# Mostrar libros disponibles después de las devolucionesprint("\nLibros disponibles después de las devoluciones:") library.show_available_books()# Prestar todos los libros disponibles library.borrow_book(user2,"978-3140464079") library.borrow_book(user2,"978-0451524935")# Mostrar libros disponibles cuando no hay ningunoprint("\nIntentando mostrar libros disponibles cuando no hay ninguno:") library.show_available_books()```from typing import List, Dict
classBook:  def \_\_init\_\_(self, title: str, author: str, isbn: str):  self.title = title  self.author = author  self.isbn = isbn  def \_\_str\_\_(self):  return f"'{self.title}' por {self.author}"classUser:  def \_\_init\_\_(self, name: str, user\_id: str):  self.name = name  self.user\_id = user\_idclassLibrary:  def \_\_init\_\_(self):  self.inventory: Dict\[str, Dict] = {}  self.users: List\[User] = \[]  def add\_book(self, book: Book, quantity: int = 1) -> None:  if book.isbn in self.inventory:  self.inventory\[book.isbn]\['available'] += quantity  else:  self.inventory\[book.isbn] = {'book': book, 'available': quantity, 'borrowed': \[]}  print(f"Añadido(s) {quantity} ejemplar(es) de {book} al inventario")  def register\_user(self, user: User) -> None:  self.users.append(user)  print(f"Usuario '{user.name}' registrado")  def show\_available\_books(self) -> None:  available\_books = \[(info\['book'], info\['available']) for info in self.inventory.values() if info\['available'] > 0]     if not available\_books:  print("No hay libros disponibles en la biblioteca")  else:  print("Libros disponibles:")  for book, quantity in available\_books:  print(f"{book} - {quantity} ejemplar(es) disponible(s)")  def borrow\_book(self, user: User, isbn: str) -> None:  if isbn not in self.inventory:  print(f"El libro con ISBN {isbn} no está en nuestro inventario")  return     book\_info = self.inventory\[isbn]  if book\_info\['available'] > 0:  book\_info\['available'] -= 1  book\_info\['borrowed'].append(user)  print(f"{user.name} ha tomado prestado '{book\_info\['book'].title}'")  else:  print(f"No hay ejemplares disponibles de '{book\_info\['book'].title}'")  def return\_book(self, user: User, isbn: str) -> None:  if isbn not in self.inventory:  print(f"El libro con ISBN {isbn} no pertenece a nuestro inventario")  return     book\_info = self.inventory\[isbn]  if user in book\_info\['borrowed']:  book\_info\['available'] += 1  book\_info\['borrowed'].remove(user)  print(f"{user.name} ha devuelto '{book\_info\['book'].title}'")  else:  print(f"{user.name} no tenía prestado '{book\_info\['book'].title}'")  def find\_book(self, isbn: str) -> Book:  return self.inventory\[isbn]\['book'] if isbn in self.inventory else None  def find\_books\_by\_author(self, author: str) -> List\[Book]:  return \[info\['book'] for info in self.inventory.values() if info\['book'].author.lower() == author.lower()]
\# Ejemplo de uso
if \_\_name\_\_ =="\_\_main\_\_":  library = Library()  \# Crear libros  book1 = Book("El principito", "Antoine de Saint-Exupéry", "978-3140464079")  book2 = Book("1984", "George Orwell", "978-0451524935")  \# Añadir libros a la biblioteca  library.add\_book(book1, 2)  library.add\_book(book2, 1)  \# Crear usuarios  user1 = User("Carli", "001")  user2 = User("Ana", "002")  \# Registrar usuarios  library.register\_user(user1)  library.register\_user(user2)  \# Mostrar libros disponibles inicialmente  print("\nLibros disponibles inicialmente:")  library.show\_available\_books()  \# Realizar préstamos  library.borrow\_book(user1, "978-3140464079")  library.borrow\_book(user2, "978-3140464079")  library.borrow\_book(user1, "978-0451524935")  \# Mostrar libros disponibles después de los préstamos  print("\nLibros disponibles después de los préstamos:")  library.show\_available\_books()  \# Devolver libros  library.return\_book(user1, "978-3140464079")  library.return\_book(user1, "978-0451524935")  \# Mostrar libros disponibles después de las devoluciones  print("\nLibros disponibles después de las devoluciones:")  library.show\_available\_books()  \# Prestar todos los libros disponibles  library.borrow\_book(user2, "978-3140464079")  library.borrow\_book(user2, "978-0451524935")  \# Mostrar libros disponibles cuando no hay ninguno  print("\nIntentando mostrar libros disponibles cuando no hay ninguno:")  library.show\_available\_books()
Compañeros la siguiente es para compartir con ustedes mi realización con la venta de motos.
classMoto: def __init__(self, marca, modelo): self.marca= marca
self.modelo= modelo
self.verificacion=True def store(self):if self.verificacion: self.verificacion=Falseprint(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=TrueclassClient: 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")classConcesionario: 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}")# CrearMotosmoto1 =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()
Que original e ingenioso :O
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:
# Clase para definir las caractéristicas de los autos:classCar: 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-=1print(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+=1print(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:classCar_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!
Gracias por tu aporte
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):
# 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 classCar: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 defsold(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 ventaprint(f"El {self.model} ha sido vendido a un precio de {self.price}")# Le damos un mensaje con el modelo del auto vendidoelse:# Si ya no está disponibleprint(f"El {self.model} no está disponible")# Mostramos mensaje diciendo que ya no está disponibledefmake_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 concesionariaprint(f"El {self.model} a la venta nuevamente a un precio de {self.price}")# Damos un mensaje de que vuelve a estar disponibleclassCustomer:# 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 clientedefbuy(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 compradoprint(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 defsell(self, car, dealership):# Creamos una función en la cual el cliente pueda vender un coche a la concesionariaif 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 clienteprint(f"El cleinte {self.name} a puesto ") car.make_available(dealership)# Marcamos el coche como disponible nuevamenteelse:# Si no es propietario del coche no lo puede venderprint(f"El cliente no puede vender el {car.model}, ya no cuenta con él")classDealership:# Creamos una clase concesionariadef__init__(self):# Creamos el constructor self.forsell =[]# Creamos una lista para poner los carros con los que cuenta la concesionaria a la ventadefadd_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.")defshow_available_cars(self):# Mostramos los coches disponibles en la concesionariaprint("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 concesionariadealership = Dealership()#Añadimos los coches a la concesionariadealership.add_car(car1)dealership.add_car(car2)dealership.add_car(car3)# Mostramos los coches disponibles en la concesionariadealership.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 comprauser1.buy(car1, dealership)# Mostramos los coches disponibles en la concesionariadealership.show_available_cars()# Devolver coche a la concesionariauser1.sell(car1, dealership)# Mostramos los coches disponibles en la concesionariadealership.show_available_cars()
We also have to practice the english skills guys!
classCar:def__init__(self, brand, model, year, kilometers_driven, price): self.brand = brand
self.model = model
self.year = year
self.kilometers_driven = kilometers_driven
self.price = price
self.sold =Falsedefsell(self):ifnot self.sold: self.sold =Trueprint(f"The car {self.brand}{self.model} has been sold.")else:print(f"The car {self.brand}{self.model} is already sold.")defdisplay_info(self): status ="Sold"if self.sold else"Available" info =(f"Car Information:\n"f"Brand: {self.brand}\n"f"Model: {self.model}\n"f"Year: {self.year}\n"f"Kilometers Driven: {self.kilometers_driven}\n"f"Price: ${self.price}\n"f"Status: {status}")print(info)classDealership:def__init__(self): self.inventory =[]defadd_car(self, car): self.inventory.append(car)print(f"Added {car.brand}{car.model} to inventory.")deflist_available_cars(self):print("Available Cars in Inventory:")for car in self.inventory:ifnot car.sold: car.display_info()print("-"*20)defsell_car(self, car):if car in self.inventory: car.sell()else:print("Car not found in inventory.")#create dealershipdealership = Dealership()#add cars to dealershipcar1 = Car("Toyota","Corolla",2020,15000,18000)car2 = Car("Honda","Civic",2019,20000,17000)car3 = Car("Ford","Mustang",2021,5000,30000)dealership.add_car(car1)dealership.add_car(car2)dealership.add_car(car3)#list available carsdealership.list_available_cars()#sell a cardealership.sell_car(car2)#list available cars after selling onedealership.list_available_cars()# Display information of a specific carcar1.display_info()
Hola, sé que quedo REEEEEmal pero seguimos aprendiendo jajajaja
classAuto: def __init__(self, modelo, año, precio): self.modelo= modelo
self.año= año
self.precio= precio
self.disponibilidad=True def disponibilidad(self, disponibilidad):if self.disponibilidad==True:print(f"El auto {self.modelo}, {self.año}, se encuentra disponible para la venta")else:print(f"El auto {self.modelo}, {self.año},no se encuentra disponible para la venta")classConcesionario: def __init__(self): self.autos=[Auto("BMW",2018,100),Auto("Ford",2021,300),Auto("Mazda",2019,200),Auto("Chevrolet",2023,400),Auto("Subaru",2018,600),] def catalogo(self):return self.autos def añadir_autos(self, auto): self.autos.append(auto)print("El auto {self.autos}, se ha añadido a inventario correctamente") def vender_auto(self, id):if self.autos[id].disponibilidad:print("El auto {self.auto} ha sido vendido")else:print("El auto no esta disponible")classComprador: def __init__(self, nombre, identificacion): self.nombre= nombre
self.identificacion= identificacion
self.garage=[] def comprar_auto(self, autos, model):for auto inautos:if auto.modelo== model and auto.disponibilidad:print(f"La compra del auto ha sido exitosa") self.garage.append(auto)returnprint("El carro no esta disponible")motoresycarros =Concesionario()carro_nuevo1 =Auto("Mercedez Benz",2007,250)carro_nuevo2 =Auto("Volswagen",2013,280)comprador1 =Comprador("Nicole",1012)catalog = motoresycarros.catalogo()motoresycarros.añadir_autos(carro_nuevo1)motoresycarros.añadir_autos(carro_nuevo2)comprador1.comprar_auto(catalog,"BMW")
Saludos, compañera.
#Me gustó tu código, me resulta creativo. Si me lo permites, te hago una observación:#1. Coloca tu función 'def disponibilidad(self, disponibilidad)' en 'class Concesionario' (en vez de 'class Auto') para que puedas combinarlo con tu lista de 'self.autos = []'#Te quedaría más o menos así:classAuto:def__init__(self, modelo, año, precio): self.modelo = modelo
self.año = año
self.precio = precio
self.disponible =True#Renombré este booleano para no causar errores con a función disponibilidad.classConcesionario:def__init__(self): self.autos =[]#Aquí, dejamos vacío para que añadamos los autos con un '.append()'defdisponibilidad(self):print('🚧Vehículos Disponibles:')for vehicles in self.autos:#Aquí añades un for loop para que no tengas que imprimir manualmente como habías hecho arriba.if vehicles.disponible:#Mira, aquí no hace falta que pongas 'if self.disponibilidad == True:'print(f'{vehicles.modelo}')def añadir_autos(self, auto): self.autos.append(auto)print(f"El auto {auto.modelo}{auto.año}, se ha añadido a inventario correctamente")#Recuerda añadir una letra 'f' para que funcione tu 'print()'.defvender_auto(self,id):if self.autos[id].disponibilidad:print("El auto {self.auto} ha sido vendido")else:print("El auto no esta disponible")classComprador:def__init__(self, nombre, identificacion): self.nombre = nombre
self.identificacion = identificacion
self.garage =[]defcomprar_auto(self,model):if model.disponible: model.disponible =Falseprint(f'The vehicle {model.modelo} has been purchased')print("El carro no esta disponible")motoresycarros = Concesionario()comprador1 = Comprador("Nicole","1012")#Aquí creamos los vehiculos, en vez de hacerlo dentro de la lógica del consecionario.#Por cierto, tuve que cambiar los números (int) a str porque sería más rollo para trabajarlos como intcarro_nuevo1 = Auto("Mercedez Benz","2007","250")carro_nuevo2 = Auto("Volswagen","2013","280")carro_nuevo3 = Auto("BMW","2018","100")carro_nuevo4 = Auto("Ford","2021","300")carro_nuevo5 = Auto("Mazda","2019","200")carro_nuevo6 = Auto("Chevrolet","2023","400")carro_nuevo7 = Auto("Subaru","2018","600")#Los añadimos a la concesionaria motoresycarros.añadir_autos(carro_nuevo1)motoresycarros.añadir_autos(carro_nuevo2)motoresycarros.añadir_autos(carro_nuevo3)motoresycarros.añadir_autos(carro_nuevo4)motoresycarros.añadir_autos(carro_nuevo5)motoresycarros.añadir_autos(carro_nuevo6)motoresycarros.añadir_autos(carro_nuevo7)#Aquí eliminé tu función 'def catalogo(self): return self.autos' ya que todo quedó dentro de 'def disponibilidad()'motoresycarros.disponibilidad()#Aquí, imprimimos.comprador1.comprar_auto(carro_nuevo1)#Aquí, le habías pasado strings, pero necesitabas pasarle el objeto creado.
mi solución al reto de la clase
classcarro: def __init__(self, marca, precio): self.marca= marca
self.precio= precio
self.disponible=True def vender_carro(self):if self.disponible: self.disponible=Falseprint(f"el carro {self.marca} ha sido vendido")else:print(f"el carro {self.marca} no esta disponible") def comprarCarro(self): self.disponible=Trueprint(f"el carro {self.marca} ha sido comprado por un valor de ${self.precio}")classcliente: def __init__(self, nombre): self.nombre= nombre
self.carros_vendidos=[] self.carros_comprados=[] def vender_carro(self, carro):if carro.disponible: carro.vender_carro() self.carros_vendidos.append(carro) def comprar_carro(self, carro):if carro.comprarCarro: carro.comprar_carro() self.carros_comprados.append(carro)else:print(f"carro {self.marca} no disponible")classconcesionario: def __init__(self): self.carros_vendidos=[] self.users=[] def añadircarros(self,carro): self.carros_vendidos.append(carro)print(f"el carro {carro.marca} ha sido comprado por un valor de ${carro.precio}") def registrarUsuarios(self, usuario): self.users.append(usuario)print(f"el usuario {usuario.nombre} ha ingresado a la tienda") def mostrarCarrosDisponibles(self):print("Carros Disponibles")for carro in self.carros_vendidos:if carro.disponible:print(f"{carro.marca} con un valor de ${carro.precio}")
Al crear una instancia de la clase Book sin especificar todos sus atributos, como book1 = Book("1984"), Python generará un error si el constructor (__init__) de la clase Book está diseñado para requerir todos los parámetros. Dado que en el transcript se menciona que el constructor de Book toma al menos el título y el autor, omitir el segundo parámetro causará un TypeError indicando que falta un argumento requerido. Es importante siempre proporcionar todos los argumentos necesarios al crear instancias de clases.
Mi Concesionario:
class Vehiculo:
contador_id = 1
def __init__(self, marca, modelo, color, precio):
self.id = Vehiculo.contador_id
Vehiculo.contador_id += 1
self.marca = marca
self.modelo = modelo
self.color = color
self.precio = precio
self.disponible = True
def mostrar_info(self):
return (f"| ID: {self.id:<3} "
f"| Marca: {self.marca:<10} "
f"| Modelo: {self.modelo:<10} "
f"| Color: {self.color:<10} "
f"| Precio: ${self.precio:<8,.2f} "
f"| Estado: {'Disponible' if self.disponible else 'Vendido':<10} |")
class Concesionario:
def __init__(self, nombre):
self.nombre = nombre
self.lista_vehiculos = []
def agregar_vehiculos(self, vehiculo):
self.lista_vehiculos.append(vehiculo)
def mostrar_vehiculo(self):
if not self.lista_vehiculos:
return "No hay vehículos en el concesionario."
info = f"El concesionario {self.nombre} tiene los vehículos:\n"
for vehiculo in self.lista_vehiculos:
info += vehiculo.mostrar_info() + "\n"
return info
def vender_vehiculo(self, id_vehiculo):
for vehiculo in self.lista_vehiculos:
if vehiculo.id == id_vehiculo:
if vehiculo.disponible:
vehiculo.disponible = False
return f"✅ Se vendió el vehículo:\n{vehiculo.mostrar_info()}"
else:
return "⚠️ Ese vehículo ya fue vendido."
return "❌ Vehículo no encontrado."
# --- Programa principal ---
if __name__ == "__main__":
# Crear un concesionario
mi_concesionario = Concesionario("Autos GPT")
# Agregar vehículos
v1 = Vehiculo("Toyota", "Corolla", "Rojo", 25000)
v2 = Vehiculo("Honda", "Civic", "Azul", 27000)
v3 = Vehiculo("Ford", "Focus", "Negro", 23000)
mi_concesionario.agregar_vehiculos(v1)
mi_concesionario.agregar_vehiculos(v2)
mi_concesionario.agregar_vehiculos(v3)
# Mostrar los vehículos
print(mi_concesionario.mostrar_vehiculo())
# Vender un vehículo (por ID)
print(mi_concesionario.vender_vehiculo(2)) # Se intenta vender el Honda Civic
# Mostrar nuevamente los vehículos para ver el cambio