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.

Juan Camilo Mesa Muñoz

student•

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.

Carli Code

teacher•

Buen consejo!

Alexis Dorado Muñoz

student•

Pues si , pero pues de eso se trata, aprender.

Belman Alexis Marin Franco

student•

#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()

Carlos Andrés Roa French

student•

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.")"

Roberto Arriaga

student•

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

Porfis

Juan Camilo Suarez

student•

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

Roberto Arriaga

student•

Gracias

laura vanessa bermudez florez

student•

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
&#x20;   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")
&#x20;   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 = \[]
&#x20;   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")
&#x20;   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 = \[]
&#x20;   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")
&#x20;   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")
&#x20;   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()

David Israel González Hurtado

student•

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.

Enrique Gálvez

student•

¿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?

Gustavo Garcia Adame

student•

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

Yanina Maria Eva Roldan

student•

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. :(

Yeferson Duarte

student•

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!

José Miguel Vásquez Guerra

student•

¿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. =(**

Carlos Eduardo Rondón Almeyda

student•

__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

Leo

student•

por que hay dos funciones que se llaman return_book? esto es buena practica?

Platzi

student•

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.

José Miguel Vásquez Guerra

student•

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.

Santiago Felipe Lasso Patiño

student•

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

Carlos Gutiérrez

student•

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.

Cesar Augusto Vega Lizarazo

student•

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

class Book:
    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}"

class User:
    def __init__(self, name: str, user_id: str):
        self.name = name
        self.user_id = user_id

class Library:
    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()from typing import List, Dict

class Book:
    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}"

class User:
    def __init__(self, name: str, user_id: str):
        self.name = name
        self.user_id = user_id

class Library:
    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()
```from typing import List, Dict



class Book:

&#x20;   def \_\_init\_\_(self, title: str, author: str, isbn: str):

&#x20;       self.title = title

&#x20;       self.author = author

&#x20;       self.isbn = isbn



&#x20;   def \_\_str\_\_(self):

&#x20;       return f"'{self.title}' por {self.author}"



class User:

&#x20;   def \_\_init\_\_(self, name: str, user\_id: str):

&#x20;       self.name = name

&#x20;       self.user\_id = user\_id



class Library:

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

&#x20;       self.inventory: Dict\[str, Dict] = {}

&#x20;       self.users: List\[User] = \[]



&#x20;   def add\_book(self, book: Book, quantity: int = 1) -> None:

&#x20;       if book.isbn in self.inventory:

&#x20;           self.inventory\[book.isbn]\['available'] += quantity

&#x20;       else:

&#x20;           self.inventory\[book.isbn] = {'book': book, 'available': quantity, 'borrowed': \[]}

&#x20;       print(f"Añadido(s) {quantity} ejemplar(es) de {book} al inventario")



&#x20;   def register\_user(self, user: User) -> None:

&#x20;       self.users.append(user)

&#x20;       print(f"Usuario '{user.name}' registrado")



&#x20;   def show\_available\_books(self) -> None:

&#x20;       available\_books = \[(info\['book'], info\['available']) for info in self.inventory.values() if info\['available'] > 0]

&#x20;      &#x20;

&#x20;       if not available\_books:

&#x20;           print("No hay libros disponibles en la biblioteca")

&#x20;       else:

&#x20;           print("Libros disponibles:")

&#x20;           for book, quantity in available\_books:

&#x20;               print(f"{book} - {quantity} ejemplar(es) disponible(s)")



&#x20;   def borrow\_book(self, user: User, isbn: str) -> None:

&#x20;       if isbn not in self.inventory:

&#x20;           print(f"El libro con ISBN {isbn} no está en nuestro inventario")

&#x20;           return

&#x20;      &#x20;

&#x20;       book\_info = self.inventory\[isbn]

&#x20;       if book\_info\['available'] > 0:

&#x20;           book\_info\['available'] -= 1

&#x20;           book\_info\['borrowed'].append(user)

&#x20;           print(f"{user.name} ha tomado prestado '{book\_info\['book'].title}'")

&#x20;       else:

&#x20;           print(f"No hay ejemplares disponibles de '{book\_info\['book'].title}'")



&#x20;   def return\_book(self, user: User, isbn: str) -> None:

&#x20;       if isbn not in self.inventory:

&#x20;           print(f"El libro con ISBN {isbn} no pertenece a nuestro inventario")

&#x20;           return

&#x20;      &#x20;

&#x20;       book\_info = self.inventory\[isbn]

&#x20;       if user in book\_info\['borrowed']:

&#x20;           book\_info\['available'] += 1

&#x20;           book\_info\['borrowed'].remove(user)

&#x20;           print(f"{user.name} ha devuelto '{book\_info\['book'].title}'")

&#x20;       else:

&#x20;           print(f"{user.name} no tenía prestado '{book\_info\['book'].title}'")



&#x20;   def find\_book(self, isbn: str) -> Book:

&#x20;       return self.inventory\[isbn]\['book'] if isbn in self.inventory else None



&#x20;   def find\_books\_by\_author(self, author: str) -> List\[Book]:

&#x20;       return \[info\['book'] for info in self.inventory.values() if info\['book'].author.lower() == author.lower()]



\# Ejemplo de uso

if \_\_name\_\_ == "\_\_main\_\_":

&#x20;   library = Library()



&#x20;   \# Crear libros

&#x20;   book1 = Book("El principito", "Antoine de Saint-Exupéry", "978-3140464079")

&#x20;   book2 = Book("1984", "George Orwell", "978-0451524935")



&#x20;   \# Añadir libros a la biblioteca

&#x20;   library.add\_book(book1, 2)

&#x20;   library.add\_book(book2, 1)



&#x20;   \# Crear usuarios

&#x20;   user1 = User("Carli", "001")

&#x20;   user2 = User("Ana", "002")



&#x20;   \# Registrar usuarios

&#x20;   library.register\_user(user1)

&#x20;   library.register\_user(user2)



&#x20;   \# Mostrar libros disponibles inicialmente

&#x20;   print("\nLibros disponibles inicialmente:")

&#x20;   library.show\_available\_books()



&#x20;   \# Realizar préstamos

&#x20;   library.borrow\_book(user1, "978-3140464079")

&#x20;   library.borrow\_book(user2, "978-3140464079")

&#x20;   library.borrow\_book(user1, "978-0451524935")



&#x20;   \# Mostrar libros disponibles después de los préstamos

&#x20;   print("\nLibros disponibles después de los préstamos:")

&#x20;   library.show\_available\_books()



&#x20;   \# Devolver libros

&#x20;   library.return\_book(user1, "978-3140464079")

&#x20;   library.return\_book(user1, "978-0451524935")



&#x20;   \# Mostrar libros disponibles después de las devoluciones

&#x20;   print("\nLibros disponibles después de las devoluciones:")

&#x20;   library.show\_available\_books()



&#x20;   \# Prestar todos los libros disponibles

&#x20;   library.borrow\_book(user2, "978-3140464079")

&#x20;   library.borrow\_book(user2, "978-0451524935")



&#x20;   \# Mostrar libros disponibles cuando no hay ninguno

&#x20;   print("\nIntentando mostrar libros disponibles cuando no hay ninguno:")

&#x20;   library.show\_available\_books()

Miguel Santa

student•

Compañeros la siguiente es para compartir con ustedes mi realización con la venta de motos.

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()

Juan Sebastian Gomez Poblador

student•

Que original e ingenioso :O

Samuel Martínez Hernández

student•

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:
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!

Alexis Dorado Muñoz

student•

Gracias por tu aporte

Gabriel Maxemin

student•

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 
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()

Nicole Alejandra Gonzalez Palomino

student•

Hola, sé que quedo REEEEEmal pero seguimos aprendiendo jajajaja

class Auto:
    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")

class Concesionario:
    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")


class Comprador:
    def __init__(self, nombre, identificacion):
        self.nombre = nombre
        self.identificacion = identificacion 
        self.garage = []

    def comprar_auto(self, autos, model):
        for auto in autos:
            if auto.modelo == model and auto.disponibilidad:
                print(f"La compra del auto ha sido exitosa")
                self.garage.append(auto)
                return

        print("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")

Arvin Fernando Morales Villalobos

student••

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í:

class Auto:
    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.



class Concesionario:
    def __init__(self):
        self.autos = [] #Aquí, dejamos vacío para que añadamos los autos con un '.append()'

    def disponibilidad(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()'.
    
    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")


class Comprador:
    def __init__(self, nombre, identificacion):
        self.nombre = nombre
        self.identificacion = identificacion 
        self.garage = []

    def comprar_auto(self,model):
        if model.disponible:
            model.disponible = False
            print(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 int
carro_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.

david felipe matallana martinez

student•

mi solución al reto de la clase

class carro:
    def __init__(self, marca, precio):
        self.marca = marca
        self.precio = precio
        self.disponible = True
    
    def vender_carro(self):
        if self.disponible:
            self.disponible = False
            print(f"el carro {self.marca} ha sido vendido")
        else:
            print(f"el carro {self.marca} no esta disponible")

    def comprarCarro(self):
        self.disponible = True
        print(f"el carro {self.marca} ha sido comprado por un valor de ${self.precio}")
    
class cliente:
    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")        


        
class concesionario:
    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}")

David Saúl Martínez Sánchez

student•

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.

Juan Silva

student•

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

print(mi_concesionario.mostrar_vehiculo())

Cristian Vélez

student•

lass Carro:
    def __init__(self, nombre_carro, precio_carro):
        self.nombre_carro = nombre_carro
        self.precio_carro = precio_carro
        self.disponible = True

    def Vender(self):
        if self.disponible:
            self.disponible = False
            print(f"El auto {self.nombre_carro} ha sido adquirido")
        else:
            print(f"El auto {self.nombre_carro} no esta disponible")


class Cliente:
    def __init__(self, nombre, id_cliente):
        self.nombre = nombre 
        self.id_cliente = id_cliente
        self.carro_propiedad = []

    def Comprar(self, carro):
        if carro.disponible:
            carro.Vender()
            self.carro_propiedad.append(carro)
        else:
            print(f"El carro {self.nombre_carro} no esta disponible")
        
class Concesionario:
    def __init__(self):
        self.carros = []
        self.clientes = []

    def añadir_carro(self, carro):
        print(f"el carro {carro.nombre_carro} y precio de {carro.precio_carro} ha sido añadido")
    
    def añadir_cliente(self, cliente):
        print(f"El cliente {cliente.nombre} {cliente.id_cliente} ha sido añadido")
        for carro in self.carros:
            if carros.disponible:
                print(f"{self.nombre_carro} con precio de {self.precio_carro}")

Concesionario1 = Concesionario()

carro1 = Carro("Mazda 3", "50.000.000")
carro2 = Carro("Chevrolet Aveo", "40.000.000")

cliente1 = Cliente("Mario", "101")
cliente2 = Cliente("daniel", "202")

Concesionario1.añadir_carro(carro1)
Concesionario1.añadir_carro(carro2)
Concesionario1.añadir_cliente(cliente1)
Concesionario1.añadir_cliente(cliente2)

cliente1.Comprar(carro1)
```lass Carro:    def \_\_init\_\_(self, nombre\_carro, precio\_carro):        self.nombre\_carro = nombre\_carro        self.precio\_carro = precio\_carro        self.disponible = True
    def Vender(self):        if self.disponible:            self.disponible = False            print(f"El auto {self.nombre\_carro} ha sido adquirido")        else:            print(f"El auto {self.nombre\_carro} no esta disponible")

class Cliente:    def \_\_init\_\_(self, nombre, id\_cliente):        self.nombre = nombre         self.id\_cliente = id\_cliente        self.carro\_propiedad = \[]
    def Comprar(self, carro):        if carro.disponible:            carro.Vender()            self.carro\_propiedad.append(carro)        else:            print(f"El carro {self.nombre\_carro} no esta disponible")        class Concesionario:    def \_\_init\_\_(self):        self.carros = \[]        self.clientes = \[]
    def añadir\_carro(self, carro):        print(f"el carro {carro.nombre\_carro} y precio de {carro.precio\_carro} ha sido añadido")        def añadir\_cliente(self, cliente):        print(f"El cliente {cliente.nombre} {cliente.id\_cliente} ha sido añadido")        for carro in self.carros:            if carros.disponible:                print(f"{self.nombre\_carro} con precio de {self.precio\_carro}")
Concesionario1 = Concesionario()
carro1 = Carro("Mazda 3", "50.000.000")carro2 = Carro("Chevrolet Aveo", "40.000.000")
cliente1 = Cliente("Mario", "101")cliente2 = Cliente("daniel", "202")
Concesionario1.añadir\_carro(carro1)Concesionario1.añadir\_carro(carro2)Concesionario1.añadir\_cliente(cliente1)Concesionario1.añadir\_cliente(cliente2)
cliente1.Comprar(carro1)

Edwin Maurizzio Segura Chivatá

student•

Buena crack!

Jack Fajardo

student•

Hola profe!, creo haber entendido la idea =P Aqui mi aporte :

class Vehiculo: 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 = Vehiculo("Renault: Duster", "Caminotera", f"Modelo: {2020}", 5, 40000000) vehiculo2 = Vehiculo("Volkswagen: Amarok", "Camioneta", f"Modelo: {2024}", 2, 90000000 )vehiculo3 = Vehiculo("Chevrolet: Aveo family", "carro", f"Modelo: {2012}", 3, 25000000 )

#Clase usuario class User: def __init__(self, name, last_name, user_id=int()): 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 = User("Jack", "Fajardo", 1)user2 = User("Angelica", "Lafaurie", 2)

#Clase consecionarioclass Consecionario: 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 = Consecionario()#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

Cristian Ruz Sanchez

student•

Le sugiero cambiar su estilo de comentario en la parte superior a code inline

Gorka Gallardo Castany

student•

Con todo respeto a la profesora, entiendo que explicar las cosas no es nada sencillo. Pero en este curso veo 0 sentido pedagogico y demasiada velocidad para explicar conceptos complejos como POO. En esta misma clase sin ir mas lejos no se explica ABSOLUTAMENTE NADA, la profesora se limita a programar y a decir en voz alta lo que escribe, nada mas. Lo siento pero eso no es enseñar. Me da la sensacion de que este curso no es para aprender a programar realmente, como programador al menos me da esa sensacion, es como si fuera un curso de adaptacion para pasar de un lenguaje x a Python, por que la profesora ya da por hecho que sabes de lo que se esta hablando, para alguien que viene de 0 este curso es infumable y viendo las clases que hay por delante miedo me da seguir con el curso. En si el curso es completo en contenido pero es exageradamente rapido, para alguien nuevo no da tiempo de aprender nada. MI recomendacion es que cambien de nivel basico a intermedio este curso por que mucha gente nueva caera aqui y pensara "Donde me he metido?"

Gestión de Biblioteca con Programación Orientada a Objetos

Fundamentos de Programación y Python

Fundamentos de Programación con Python para Principiantes

Instalación y Uso Básico de Python en Windows y Mac

Semántica y Sintaxis en Programación Python

Práctica: Te doy la bienvenida a los ejercicios interactivos

Manejo de Cadenas y Operaciones Básicas en Python

Tipos de Datos en Python: Enteros, Flotantes y Booleanos

Dominio de la función `print` en Python: usos y formatos avanzados

Operaciones matemáticas avanzadas en Python: módulo, potencia y más

Entrada de información y manejo de tipos de datos en Python

Colección y Procesamiento de Datos en Python

Manipulación de Listas en Python: Creación, Indexación y Métodos Básicos

Copiar listas en Python sin compartir memoria con slicing

Manejo de Matrices y Tuplas en Python

Matrices en Juegos y Imágenes con Python

Diccionarios en Python: Uso y Manipulación de Datos

Control de Flujo en Python

Estructuras Condicionales en Programación: Uso de If, Else y Elif

Iteración y control de flujo con bucles en Python

Iteradores y Generadores en Python: Uso Eficiente de Memoria

Listas por comprensión en Python: creación y optimización de listas

Funciones y Manejo de Excepciones en Python

Funciones y Parámetros en Python: Crea una Calculadora Básica

Funciones Lambda en Python: Uso y Aplicaciones Prácticas

Recursividad en Python: Factoriales y Serie de Fibonacci

Manejo de Excepciones y Errores en Python

Programación Orientada a Objetos en Python

Programación Orientada a Objetos en Python: Clases y Métodos Básicos

Gestión de Biblioteca con Programación Orientada a Objetos

Herencia y Polimorfismo en Programación Orientada a Objetos

Programación Orientada a Objetos: Implementación de Clases y Herencia

Polimorfismo en Programación Orientada a Objetos

Herencia y Uso de la Función super() en Python

Programación Orientada a Objetos: Atributos, Métodos y `super()` en Python

Lectura y escritura de archivos

Manipulación de Archivos TXT y CSV en Python

Manipulación de archivos CSV con Python: lectura y escritura

Manejo de Archivos JSON en Python para Aplicaciones Web y APIs

Biblioteca estándar de Python

Uso Eficiente de la Biblioteca Estándar de Python

Uso de las librerías OS, Math y Random en Python

Análisis de Datos de Ventas con Python y Statistics

Desarrollo del juego Batalla Naval en Python

Conceptos avanzados de Python

Programación Avanzada en Python: POO, Excepciones y Proyectos

Escritura de Código Pytónico y Buenas Prácticas en Python

Comentarios y Docstrings: Buenas Prácticas en Programación

Tiempo de vida y alcance de variables en Python

Anotaciones de Tipo en Python para Código Más Legible

Validación de Tipos y Manejo de Excepciones en Python

Estructuras de Datos Avanzadas en Python: Collection y Enumeraciones

Decoradores

Decoradores en Python: Extiende Funcionalidades de Funciones

Uso de Decoradores Anidados y con Parámetros en Python

Decoradores en Programación Orientada a Objetos en Python

Métodos y estructura de clases en Python

Uso de Métodos Mágicos en Python

Sobrecarga de Operadores en Python: Personaliza Comportamiento de Clases

Ejecutar scripts Python con `if __name__ == '__main__'`

Metaprogramación en Python: Métodos `__new__` y `__init__`

Uso de *args y **kwargs en funciones de Python

Métodos y Atributos Privados y Protegidos en Python

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

Métodos estáticos y de clase en Python

Programación concurrente y asíncrona

Concurrencia y Paralelismo en Python: Técnicas y Librerías Básicas

Concurrencia y Paralelismo en Python: `threading` y `multiprocessing`

Asincronismo en Python con AsyncIO y Corrutinas

Sincronía y Concurrencia en Python: Teoría y Práctica

Creación de módulos y paquetes

Módulos y Paquetes en Python: Reutilización y Organización de Código

Uso de Paquetes y Subpaquetes en Python con Visual Studio Code

Publicación de Paquetes Python en PyPI

Proyecto final

Sistema de Gestión de Reservas en Python Avanzado

Sistema de Gestión de Reservas en Python Avanzado

Reto

Ejecutar scripts Python con `if name == 'main'`

Metaprogramación en Python: Métodos `new` y `init`