Fundamentos de Programación y Python
¿Por qué aprender Python?
Introducción a Python
Conceptos Básicos de Programación
Práctica: Te doy la bienvenida a los ejercicios interactivos
Manipulación de Cadenas de Texto en Python
Enteros, Flotantes y Booleanos
Todo lo que Debes Saber sobre print en Python
Operaciones Matemáticas en Python
Operaciones de Entrada/Salida en Consola
Colección y Procesamiento de Datos en Python
Listas
Método slice
Listas de más dimensiones y Tuplas
Aplicación de Matrices
Diccionarios
Comprehension Lists en Python (CLASE NUEVA)
Control de Flujo en Python
Estructuras condicionales
Bucles y Control de Iteraciones
Generadores e Iteradores
Funciones y Manejo de Excepciones en Python
Uso de Funciones en Python
Funciones Lambda y Programación Funcional en Python
¿Cómo realizar una función recursiva en Python?
Manejo de Excepciones y Uso de Pass (CLASE NUEVA)
Programación Orientada a Objetos en Python
Fundamentos de Programación Orientada a Objetos en Python
Ejercicio Biblioteca con POO
Herencia en POO con Python
Objetos heredados
Los 4 pilares de la programacion orientada a objetos
Uso de super() en Python (CLASE NUEVA)
Superando los Fundamentos de Programación Orientada a Objetos en Python
Lectura y escritura de archivos
Manejo de Archivos .TXT (CLASE NUEVA)
Manejo de Archivos CSV (CLASE NUEVA)
Manejo de Archivos JSON (CLASE NUEVA)
Biblioteca estándar de Python
Librería Statistics y Análisis Estadístico (CLASE NUEVA)
Biblioteca estándar en Python (CLASE NUEVA)
Librería Os, Math y Random (CLASE NUEVA)
Proyecto final: Guerra naval
Conceptos avanzados de Python
Recapitulación de lo aprendido hasta ahora
Escribir código Pythonico y profesional
Comentarios y Docstrings en Python
Scope y closures: variables locales y globales
Anotaciones de tipo
Validación de tipos en métodos
Librería Collections y Enumeraciones
Decoradores
Decoradores en Python
Decoradores anidados y con parámetros
Uso de Decoradores en clases y métodos
Métodos y estructura de clases en Python
Métodos mágicos
Sobrecarga de operadores
Implementación de `if __name__ == "__main__":`
Metaprogramación en Python
Uso de *args y **kwargs
Métodos privados y protegidos
Gestión avanzada de propiedades
Métodos estáticos y de clase avanzados
Programación concurrente y asíncrona
Introducción a la concurrencia y paralelismo
Threading y multiprocessing en Python
Asincronismo con asyncio
Asincronismo y concurrencia
Creación de módulos y paquetes
Creación de módulos en Python
Gestión de paquetes
Publicación de paquetes en PyPI
Proyecto final
Implementación de un sistema completo
Implementación de un Sistema Completo
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
Si ya tienes una cuenta,
Herencia en POO con Python
25/63Recursos
El concepto de herencia en programación permite que una clase derive atributos y métodos de otra, facilitando la reutilización de código y la creación de estructuras jerárquicas lógicas. En este ejercicio, se aplica herencia para modelar una concesionaria que vende autos, bicicletas y camiones.
¿Cómo se crea la clase base para los vehículos?
Primero, se define una clase base llamada Vehículo, que contiene atributos comunes como marca, modelo, precio y disponibilidad. Los métodos básicos incluyen verificar disponibilidad, obtener el precio y vender el vehículo.
class Vehículo:
def __init__(self, marca, modelo, precio):
self.marca = marca
self.modelo = modelo
self.precio = precio
self.disponible = True
def vender(self):
if self.disponible:
self.disponible = False
print(f"El vehículo {self.marca} ha sido vendido.")
else:
print(f"El vehículo {self.marca} no está disponible.")
def estado(self):
return self.disponible
def get_price(self):
return self.precio
¿Cómo se implementa la herencia en las clases derivadas?
Las clases Auto, Bicicleta y Camión heredan de Vehículo. Cada una puede personalizar métodos específicos según sus necesidades.
class Auto(Vehículo):
def start(self):
if self.disponible:
return f"El motor del coche {self.marca} está en marcha."
else:
return f"El coche {self.marca} no está disponible."
def stop(self):
if self.disponible:
return f"El motor del coche {self.marca} se ha detenido."
else:
return f"El coche {self.marca} no está disponible."
¿Cómo se manejan las instancias de las clases en la concesionaria?
Se crean instancias de Auto, Cliente y Concesionaria para manejar el inventario y las ventas.
class Cliente:
def __init__(self, nombre):
self.nombre = nombre
self.autos = []
def comprar_auto(self, auto):
if auto.estado():
self.autos.append(auto)
auto.vender()
else:
print(f"El auto {auto.marca} no está disponible.")
class Concesionaria:
def __init__(self):
self.inventario = []
self.clientes = []
def añadir_auto(self, auto):
self.inventario.append(auto)
def registrar_cliente(self, cliente):
self.clientes.append(cliente)
def mostrar_disponibles(self):
for auto in self.inventario:
if auto.estado():
print(f"{auto.marca} {auto.modelo} está disponible por {auto.get_price()}.")
¿Cómo se aplican las operaciones en la concesionaria?
Finalmente, se crean instancias y se realizan operaciones para mostrar la funcionalidad del sistema.
# Crear autos
auto1 = Auto("Toyota", "Corolla", 20000)
auto2 = Auto("Honda", "Civic", 22000)
auto3 = Auto("Ford", "Mustang", 30000)
# Crear cliente
cliente = Cliente("Carlos")
# Crear concesionaria
concesionaria = Concesionaria()
concesionaria.añadir_auto(auto1)
concesionaria.añadir_auto(auto2)
concesionaria.añadir_auto(auto3)
concesionaria.registrar_cliente(cliente)
# Mostrar autos disponibles
concesionaria.mostrar_disponibles()
# Comprar auto
cliente.comprar_auto(auto1)
# Mostrar autos disponibles después de la compra
concesionaria.mostrar_disponibles()
¿Qué beneficios trae la herencia en este contexto?
- Reutilización de código: Las clases derivadas heredan atributos y métodos comunes.
- Mantenimiento: Facilita el mantenimiento y la actualización del código.
- Extensibilidad: Permite agregar nuevas clases derivadas con facilidad.
Aportes 38
Preguntas 3
Ordenar por:
La herencia, junto con la encapsulación y el polimorfismo, es una de las tres características principales de la programación orientada a objetos. La herencia permite crear clases que reutilizan, extienden y modifican el comportamiento definido en otras clases. La clase cuyos miembros se heredan se denomina clase base o padre y la clase que hereda esos miembros se denomina clase derivada o clase hija. Una clase hija solo puede tener una clase padre directa, pero la herencia es transitiva. Si ClassC se deriva de ClassB y ClassB se deriva de ClassA, ClassC hereda los miembros declarados en ClassB y ClassA.
Un ejemplo sencillo de herencia que nos permite conceptualizarlo:
```python
class Mamifero:
def __init__(self):
pass
def features(self):
print('Tiene pelaje y glandulas mamarias')
class Perro(Mamifero):
def __init__(self):
pass
def bark(self):
print('Woof!!')
def walking(self):
print('Paseando alegre')
def eat(self):
print('Comiendo contento')
class Cachorro(Perro):
def __init__(self):
pass
def play(self):
print('Jugando y mordiendo zapatos')
cachorro1 = Cachorro()
cachorro1.bark()
cachorro1.play()
cachorro1.features()
```
```python
class Car:
def __init__(self, brand,model, price):
self.brand = brand
self.model = model
self.price = price
self.is_available = True
def sell(self):
if self.is_available:
self.is_available = False
print(f"El coche {self.brand} {self.model} ha sido vendido.")
else:
print(f"El coche {self.brand} {self.model} no esta disponible.")
def check_availability(self):
return self.is_available
def get_price (self):
return self.price
class Costumer:
def __init__(self, name):
self.name = name
self.cars_purchased = []
def buy_car(self, car):
if car.check_availability():
car.sell()
self.cars_purchased.append(car)
else:
print(f"Lo siento, {car.brand} {car.model} no esta disponible.")
def inquire_car(self, car):
availability = "disponible" if car.check_availability() else "no esta disponible"
print(f"El coche {car.brand} {car.model} esta {availability} y cuesta {car.price}")
class Dealership:
def __init__(self):
self.inventory = []
self.costumers = []
def add_car(self, car):
self.inventory.append(car)
print(f"El coche {car.brand} {car.model} ha sido agragado al inventario")
def register_costumer(self, costumer):
self.costumers.append(costumer)
print(f"El cliente {costumer.name} ha sido registrado")
def show_available_cars(self):
print("Coches disponibles en la concesionaria:")
for car in self.inventory:
if car.check_availability():
print(f"{car.brand} {car.model} por {car.price}")
# Crear instancias de coches
car1 = Car("Toyota", "Corolla", "20000")
car2 = Car("Honda","Civic", "22,000")
car3 = Car("Ford","Mustang", "35,000")
# Crear instancia de cliente
costumer1 = Costumer("Carlos")
# Crear instancia de concesionaria y registrar coches y clientes
dealer = Dealership()
dealer.add_car(car1)
dealer.add_car(car2)
dealer.add_car(car3)
dealer.register_costumer(costumer1)
#Mostrar coches disponibles
dealer.show_available_cars()
# cliente consulta un coche
costumer1.inquire_car(car1)
#cliente compra coche
costumer1.buy_car(car1)
# Mostrar coches disponibles nuevamente
dealer.show_available_cars()
#cliente intenta comprar un coche ya vendido
costumer1.buy_car(car1)
```
```python
#Ejercicio hasta el momento
class Vehicle:
def __init__(self,brand,model,price):
self.brand = brand
self.model = model
self.price = price
self.is_available = True
def sell(self):
if self.is_available:
self.is_available = False
print(f"El vehiculo {self.brand}. Ha sido vendido.")
else:
print(f"El vehiculo {self.brand}. No está vendido.")
def check_available(self):
return self.is_available
def get_price(self):
return self.price
def start_engine(self):
raise NotImplementedError("Este método debe ser implementado por la subclase")
def stop_engine(self):
raise NotImplementedError("Este método debe ser implementado por la subclase")
class Car(Vehicle):
def start_engine(self):
if not self.is_available:
return f"El motor del coche {self.brand} está en marcha."
else:
return f"El coche {self.brand} no está disponible."
def stop_engine(self):
if not self.is_available:
return f"El motor del coche {self.brand} se ha detenido."
else:
return f"El coche {self.brand} no está disponible."
```
Realmente no entendí muy bien el método start\_engine
### ¿Qué es la Herencia?
Imagina que tienes un coche y una bicicleta. Ambos son **vehículos**. Aunque son diferentes, tienen cosas en común: ambos pueden moverse, tienen ruedas, y se pueden usar para transportarte. La **Herencia** es como decir:
* Tengo una "clase general" llamada **Vehículo** (que tiene cosas en común).
* Luego, creo "clases específicas" como **Coche** o **Bicicleta**, que **heredan** las cosas que son comunes de la clase **Vehículo**.
En términos simples, la **Herencia** permite que una clase (la "clase hija") tome características y comportamientos de otra clase (la "clase padre").
### ¿Por qué es útil la Herencia?
* **Reutilización de código**: No tienes que escribir las mismas cosas una y otra vez.
* **Organización**: Agrupas comportamientos comunes en una clase base (como `Vehiculo`) y especificas comportamientos únicos en clases hijas (como `Coche` y `Bicicleta`).
* El `super()` en Python es una función que se utiliza principalmente para **llamar a métodos y constructores** de la **clase padre** desde la clase hija. Su función más común es cuando queremos extender el comportamiento de la clase padre sin tener que reescribir el código que ya existe en ella.
### ¿Por qué usamos `super()`?
Cuando estás en una clase hija, puedes querer **heredar** o **usar** el comportamiento de la clase padre sin duplicar código. El uso de `super()` te permite hacer esto de manera sencilla, invocando métodos de la clase padre. Así puedes agregar cosas nuevas en la clase hija, pero también mantener las características de la clase padre.
```js
class Car:
def __init__(self,marca, model, price):
self.marca = marca
self.model = model
self.price = price
self.avalible = True
def buys(self):
if self.avalible == False:
self.purshased = True
print (f"el carro {self.model} a sido comprado por {self.price}")
class User:
def __init__(self, name):
self.name = name
self.cars_purshased = []
def sale_cars(self,car):
if car.avalible:
car.avalible = False
print(f"el carro {car.model} a sido vendido por {car.price}")
else:
print (f"el carro {car.model} no esta disponible, puede que ya haya sido vendido")
def buys_cars(self,car):
if car.avalible == False:
car.avalible =True
car.buys()
self.cars_purshased.append(car)
else:
print("el carro no se puede comprar")
class concessionaire:
def __init__(self):
self.cars_purshased = []
self.users = []
def add_car(self,car):
self.cars_purshased.append(car)
print(f"se a agregado el carro{car.model}")
def Register_user(self,user):
self.users.append(user)
print(f"Se a añadido el usuario {user.name}")
def show_available_cars(self):
print("carros disponibles:")
for car in self.cars_purshased:
if car.avalible:
print(f"{car.model} por el precio de {car.price}")
carro1 = Car(" Jeep", "Compas 2023", 120000000)
carro2 = Car(" Mazda", "Miata 2015", 70000000)
carro3 = Car(" Renold", "captur 2020", 93000000)
user1 = User("Jesus Sebastian")
user2 = User("Jesus Anegl")
user3 = User("carechimba")
Concessionaire = concessionaire()
Concessionaire.add_car(carro2)
Concessionaire.add_car(carro1)
Concessionaire.add_car(carro3)
Concessionaire.Register_user(user1)
Concessionaire.Register_user(user2)
Concessionaire.Register_user(user3)
Concessionaire.show_available_cars()
user1.sale_cars(carro1)
user3.sale_cars(carro1)
user1.buys_cars(carro1)
user1.buys_cars(carro1)
user3.sale_cars(carro1)
```class Car: def \_\_init\_\_(self,marca, model, price): self.marca = marca self.model = model self.price = price self.avalible = True def buys(self): if self.avalible == False: self.purshased = True print (f"el carro {self.model} a sido comprado por {self.price}")
class User: def \_\_init\_\_(self, name): self.name = name self.cars\_purshased = \[] def sale\_cars(self,car): if car.avalible: car.avalible = False print(f"el carro {car.model} a sido vendido por {car.price}") else: print (f"el carro {car.model} no esta disponible, puede que ya haya sido vendido") def buys\_cars(self,car): if car.avalible == False: car.avalible =True car.buys() self.cars\_purshased.append(car) else: print("el carro no se puede comprar") class concessionaire: def \_\_init\_\_(self): self.cars\_purshased = \[] self.users = \[] def add\_car(self,car): self.cars\_purshased.append(car) print(f"se a agregado el carro{car.model}") def Register\_user(self,user): self.users.append(user) print(f"Se a añadido el usuario {user.name}") def show\_available\_cars(self): print("carros disponibles:") for car in self.cars\_purshased: if car.avalible: print(f"{car.model} por el precio de {car.price}")
carro1 = Car(" Jeep", "Compas 2023", 120000000)carro2 = Car(" Mazda", "Miata 2015", 70000000)carro3 = Car(" Renold", "captur 2020", 93000000)
user1 = User("Jesus Sebastian")user2 = User("Jesus Anegl")user3 = User("carechimba")
Concessionaire = concessionaire()Concessionaire.add\_car(carro2)Concessionaire.add\_car(carro1)Concessionaire.add\_car(carro3)Concessionaire.Register\_user(user1)Concessionaire.Register\_user(user2)Concessionaire.Register\_user(user3)
Concessionaire.show\_available\_cars()
user1.sale\_cars(carro1)user3.sale\_cars(carro1)
user1.buys\_cars(carro1)user1.buys\_cars(carro1)
user3.sale\_cars(carro1)
Tengo entendido que tanto la clase Vehículo como la subclase Car deben de ir en el mismo nivel de identación, corríjanme si me equivoco.
Holaa, les comparto mi proyecto de la concesionaria "Rápidos y Furiosos", me tomo un poco comprender el tema de la funciones, pero poniéndolo en práctica lo entiendo mucho mejor, no se rindan si pasan por los mismo. ^^
```js
class Vehiculo:
def __init__(self, marca, modelo, año, precio):
self.marca = marca
self.modelo = modelo
self.año = año
self.precio = precio
self.available = True
def mostrar_vehiculos(self):
return f"Auto {self.marca} - {self.modelo} del año {self.año}, precio {self.precio}."
def estado(self):
if self.available:
self.available = False
print(f"El auto {self.marca} - {self.modelo} del año {self.año}, no se encuentra disponible")
else:
print(f"El auto {self.marca} - {self.modelo} del año {self.año}, se encuentra disponible")
class Concesionaria:
def __init__(self, nombre_con):
self.nombre_con = nombre_con
self.vehiculos = []
def agregar_vehiculo(self, vehiculo):
self.vehiculos.append(vehiculo)
def mostrar_vehiculos(self):
if self.vehiculos:
for vehiculo in self.vehiculos:
print(vehiculo.mostrar_vehiculos())
else:
print(f"{self.nombre_con}, no tiene el vehiculo disponible.")
def vender_vehiculo(self, vehiculo, comprador):
if vehiculo in self.vehiculos:
if comprador.realizar_pago(vehiculo.precio):
self.vehiculos.remove(vehiculo)
comprador.agregar_vehiculo(vehiculo)
print(f"Vehiculo {vehiculo.mostrar_vehiculos()}, a {comprador.nombre}")
else:
print("No se pudo concretar la venta, por problemas con el pago")
else:
print(f"El {vehiculo.mostrar_vehiculos()}, no se encuentra en stock.")
class User:
def __init__(self, nombre, saldo):
self.nombre = nombre
self.saldo = saldo
self.vehiculos = []
def agregar_vehiculo(self, vehiculo):
self.vehiculos.append(vehiculo)
def mostrar_vehiculos(self):
if self.vehiculos:
for vehiculo in self.vehiculos:
print(vehiculo.mostrar_vehiculos())
else:
print(f"{self.nombre}, no tiene vehiculo.")
def tiene_saldo_suficiente(self, precio):
return self.saldo >= precio
def realizar_pago(self, monto):
if self.tiene_saldo_suficiente(monto):
self.saldo -= monto
print(f"Pago realizado por: ${monto}. Saldo restante: ${self.saldo}. ")
return True
else:
print(f"Sin saldo suficiente")
return False
#Crear vehiculo
vehiculo_1 = Vehiculo("Toyota", "Yaris", "2013", 20000)
vehiculo_2 = Vehiculo("Audi", "Corola", "2020", 80000)
vehiculo_3 = Vehiculo("Ferrari", "escarabajo", "2024", 90000)
#Crear concesionaria
concesionaria = Concesionaria("Rapidos y Furiosos")
concesionaria.agregar_vehiculo(vehiculo_1)
concesionaria.agregar_vehiculo(vehiculo_2)
concesionaria.agregar_vehiculo(vehiculo_3)
#Crear comprador
comprador = User("Mari", 400000)
#Mostrar vehiculos de la concesionaria
concesionaria.mostrar_vehiculos()
#Vender vehiculo de la concesionaria
concesionaria.vender_vehiculo(vehiculo_3, comprador)
# Mostrar vehículos del comprador
comprador.mostrar_vehiculos()
```class Vehiculo: def \_\_init\_\_(self, marca, modelo, año, precio): self.marca = marca self.modelo = modelo self.año = año self.precio = precio self.available = True
def mostrar\_vehiculos(self): return f"Auto {self.marca} - {self.modelo} del año {self.año}, precio {self.precio}." def estado(self): if self.available: self.available = False print(f"El auto {self.marca} - {self.modelo} del año {self.año}, no se encuentra disponible") else: print(f"El auto {self.marca} - {self.modelo} del año {self.año}, se encuentra disponible")
class Concesionaria: def \_\_init\_\_(self, nombre\_con): self.nombre\_con = nombre\_con self.vehiculos = \[]
def agregar\_vehiculo(self, vehiculo): self.vehiculos.append(vehiculo)
def mostrar\_vehiculos(self): if self.vehiculos: for vehiculo in self.vehiculos: print(vehiculo.mostrar\_vehiculos()) else: print(f"{self.nombre\_con}, no tiene el vehiculo disponible.") def vender\_vehiculo(self, vehiculo, comprador): if vehiculo in self.vehiculos: if comprador.realizar\_pago(vehiculo.precio): self.vehiculos.remove(vehiculo) comprador.agregar\_vehiculo(vehiculo) print(f"Vehiculo {vehiculo.mostrar\_vehiculos()}, a {comprador.nombre}") else: print("No se pudo concretar la venta, por problemas con el pago") else: print(f"El {vehiculo.mostrar\_vehiculos()}, no se encuentra en stock.")
class User: def \_\_init\_\_(self, nombre, saldo): self.nombre = nombre self.saldo = saldo self.vehiculos = \[] def agregar\_vehiculo(self, vehiculo): self.vehiculos.append(vehiculo) def mostrar\_vehiculos(self): if self.vehiculos: for vehiculo in self.vehiculos: print(vehiculo.mostrar\_vehiculos()) else: print(f"{self.nombre}, no tiene vehiculo.")
def tiene\_saldo\_suficiente(self, precio): return self.saldo >= precio def realizar\_pago(self, monto): if self.tiene\_saldo\_suficiente(monto): self.saldo -= monto print(f"Pago realizado por: ${monto}. Saldo restante: ${self.saldo}. ") return True else: print(f"Sin saldo suficiente") return False #Crear vehiculo
vehiculo\_1 = Vehiculo("Toyota", "Yaris", "2013", 20000)vehiculo\_2 = Vehiculo("Audi", "Corola", "2020", 80000)vehiculo\_3 = Vehiculo("Ferrari", "escarabajo", "2024", 90000)
\#Crear concesionaria
concesionaria = Concesionaria("Rapidos y Furiosos")concesionaria.agregar\_vehiculo(vehiculo\_1)concesionaria.agregar\_vehiculo(vehiculo\_2)concesionaria.agregar\_vehiculo(vehiculo\_3)
\#Crear compradorcomprador = User("Mari", 400000)
\#Mostrar vehiculos de la concesionariaconcesionaria.mostrar\_vehiculos()
\#Vender vehiculo de la concesionariaconcesionaria.vender\_vehiculo(vehiculo\_3, comprador)
\# Mostrar vehículos del compradorcomprador.mostrar\_vehiculos()
La \*\*herencia\*\* en Python es un concepto clave de la Programación Orientada a Objetos (POO) que permite crear una nueva clase a partir de una clase existente. Esto se hace para reutilizar el código, organizar el software en jerarquías lógicas y facilitar la extensión de funcionalidades. A continuación, te explico cómo funciona la herencia en Python con ejemplos:
\### 1. \*\*Clase Base o Superclase\*\*
La clase de la que se heredan propiedades y métodos se llama \*\*superclase\*\* o \*\*clase base\*\*. Por ejemplo, consideremos la siguiente clase `Animal`:
```python
class Animal:
def \_\_init\_\_(self, nombre):
self.nombre = nombre
def hablar(self):
return f"{self.nombre} hace un sonido."
```
\### 2. \*\*Subclase o Clase Derivada\*\*
La clase que hereda de la superclase se llama \*\*subclase\*\* o \*\*clase derivada\*\*. Esta clase puede heredar los atributos y métodos de la clase base, y además, puede añadir o modificar métodos. Aquí crearemos una subclase `Perro` que hereda de `Animal`:
```python
class Perro(Animal):
def hablar(self):
return f"{self.nombre} dice ¡Guau!"
```
En este ejemplo, la clase `Perro` hereda el atributo `nombre` y el método `hablar()` de la clase `Animal`, pero sobrescribe el método `hablar()` para que el perro haga un sonido específico.
\### 3. \*\*Uso de la Herencia\*\*
Ahora podemos crear instancias de `Perro` y usar el método `hablar()`:
```python
mi\_perro = Perro("Firulais")
print(mi\_perro.hablar()) # Output: Firulais dice ¡Guau!
```
\### 4. \*\*Herencia Múltiple\*\*
Python soporta la \*\*herencia múltiple\*\*, lo que significa que una clase puede heredar de más de una clase base. Por ejemplo:
```python
class Mamifero:
def amamantar(self):
return "Este animal amamanta a sus crías."
class Perro(Animal, Mamifero):
def hablar(self):
return f"{self.nombre} dice ¡Guau!"
```
En este caso, `Perro` hereda tanto de `Animal` como de `Mamifero`. Ahora, una instancia de `Perro` puede usar métodos de ambas clases:
```python
mi\_perro = Perro("Rex")
print(mi\_perro.hablar()) # Output: Rex dice ¡Guau!
print(mi\_perro.amamantar()) # Output: Este animal amamanta a sus crías.
```
\### 5. \*\*Función `super()`\*\*
La función `super()` se utiliza para llamar a un método de la superclase desde una subclase. Es especialmente útil cuando se sobrescribe un método y se quiere extender su funcionalidad sin reemplazar completamente la implementación original. Por ejemplo:
```python
class Gato(Animal):
def hablar(self):
sonido\_original = super().hablar() # Llama al método hablar() de la clase Animal
return f"{sonido\_original} {self.nombre} dice ¡Miau!"
```
En este ejemplo, el método `hablar()` de `Gato` primero llama al método `hablar()` de `Animal` y luego añade comportamiento adicional.
```python
mi\_gato = Gato("Mishi")
print(mi\_gato.hablar()) # Output: Mishi hace un sonido. Mishi dice ¡Miau!
```
\### 6. \*\*Herencia Jerárquica\*\*
Puedes crear jerarquías más complejas donde una clase puede ser la base para otras subclases, formando un árbol de herencia. Por ejemplo:
```python
class Vehiculo:
def mover(self):
return "El vehículo se está moviendo."
class Coche(Vehiculo):
def mover(self):
return "El coche se está moviendo."
class Bicicleta(Vehiculo):
pass # Bicicleta hereda mover() de Vehiculo sin modificarlo
```
\### 7. \*\*Resumen\*\*
La herencia en Python te permite:
\- Reutilizar el código mediante la creación de nuevas clases basadas en clases existentes.
\- Sobrescribir métodos en la subclase para modificar o extender su comportamiento.
\- Utilizar `super()` para invocar métodos de la superclase.
\- Implementar herencia múltiple para crear clases que combinan funcionalidades de múltiples clases base.
Este mecanismo es fundamental para organizar y estructurar el código en proyectos de software de manera eficiente y lógica.
```python
#ESTE ES MI CODIGO, FALTA REFINAMIENTO EN LA FUNCION SELLING
class vehicle():
def __init__(self):
self.price
self.availability
class plain(vehicle):
def __init__(self):
super()
self.price=5;
self.availability=False
class car(vehicle):
def __init__(self):
super()
self.price=2;
self.availability=False
class boat(vehicle):
def __init__(self):
super()
self.price=6;
self.availability=False
class horse (vehicle):
def __init__(self):
super()
self.price=2;
self.availability=False
class builder():
def toBuild (self,type):
match type:
case 'plain':
vehicle= plain()
vehicle.availability=True;
return vehicle
case 'car':
vehicle= car()
vehicle.availability=True;
return vehicle
case 'boat':
vehicle= boat()
vehicle.availability=True;
return vehicle
case 'horse':
vehicle= horse()
vehicle.availability=True;
return vehicle
case _:
print ('thats not a vehicle we manufacture');
class seller():
def __init__(self):
self.forSale=[];
self.provider=builder();
def ordering(self,orderList):
for key,value in orderList.items():
counter=0;
while counter<value:
self.forSale.append(self.provider.toBuild(key.lower()))
counter+=1;
def selling(self,vehicleclass):
for index,elemento in enumerate(self.forSale):
if isinstance(elemento,vehicleclass):
return self.forSale.pop(index)
else:
print('something is wrong that vehicle is not in stock')
def app():
orderList={'plain':2,'car':5,'boat':4,'horse':6}
Consecionario=seller();
Consecionario.ordering(orderList)
print(Consecionario.forSale[1])
Consecionario.selling(car)
app();
```
```python
#crear clase de vehiculo con marca, modelo y precio en python
class Vehiculo:
def __init__(self, marca, modelo, precio):
self.marca = marca
self.modelo = modelo
self.precio = precio
def mostrar_informacion(self):
print(f"Marca: {self.marca}")
print(f"Modelo: {self.modelo}")
print(f"Precio: ${self.precio}")
class Usuario:
def __init__(self, nombre, dni, saldo):
self.nombre = nombre
self.dni = dni
self.saldo = saldo
self.vehiculos_comprados = []
def comprar_vehiculo(self, vehiculo):
if vehiculo.precio <= self.saldo:
self.saldo -= vehiculo.precio
self.vehiculos_comprados.append(vehiculo)
print(f"{self.nombre} ha comprado un {vehiculo.marca} {vehiculo.modelo} por ${vehiculo.precio}.")
else:
print(f"{self.nombre} no tiene suficiente saldo para comprar un {vehiculo.marca} {vehiculo.modelo}.")
def mostrar_vehiculos_comprados(self):
print(f"{self.nombre} Vehiculos comprados por Juan:")
for vehiculo in self.vehiculos_comprados:
vehiculo.mostrar_informacion()
#en caso que no tenga vehiculos comprados:
if len(self.vehiculos_comprados) == 0:
print("No ha comprado ningún vehículo.")
def vender_vehiculo(self, vehiculo, concesionaria):
if vehiculo in self.vehiculos_comprados:
self.vehiculos_comprados.remove(vehiculo)
self.saldo += vehiculo.precio
concesionaria.comprar_vehiculo(vehiculo)
print(f"{self.nombre} ha vendido un {vehiculo.marca} {vehiculo.modelo} por ${vehiculo.precio}.")
class Concesionaria:
def __init__(self):
self.vehiculos = []
def comprar_vehiculo(self, vehiculo):
self.vehiculos.append(vehiculo)
def mostrar_vehiculos(self):
print("Vehículos disponibles en la concesionaria:")
for vehiculo in self.vehiculos:
vehiculo.mostrar_informacion()
def vender_vehiculo(self, vehiculo, usuario):
if vehiculo in self.vehiculos:
self.vehiculos.remove(vehiculo)
usuario.comprar_vehiculo(vehiculo)
else:
print("El vehículo no está disponible en la concesionaria.")
# Crear vehículos
vehiculo1 = Vehiculo("Toyota", "Corolla", 20000)
vehiculo2 = Vehiculo("Ford", "Fiesta", 15000)
vehiculo3 = Vehiculo("Chevrolet", "Cruze", 18000)
# Crear usuario
usuario1 = Usuario("Juan", "12345678", 30000)
#crea concesionaria
concesionaria = Concesionaria()
# Agregar vehículos a la concesionaria
concesionaria.comprar_vehiculo(vehiculo1)
concesionaria.comprar_vehiculo(vehiculo2)
concesionaria.comprar_vehiculo(vehiculo3)
# Mostrar vehículos disponibles en
concesionaria.mostrar_vehiculos()
#usuario muestra vehiculos comprados (deberia estar vacio al principio)
usuario1.mostrar_vehiculos_comprados()
# Usuario compra un vehículo
concesionaria.vender_vehiculo(vehiculo1, usuario1)
#usuario vuelve a mostrar vehiculos comprados (deberia mostrar el vehiculo comprado)
usuario1.mostrar_vehiculos_comprados()
# Mostrar vehículos disponibles en la concesionaria después de la venta
concesionaria.mostrar_vehiculos()
#ahora la concesionaria compra el vehiculo a un usuario (en este caso el usuario1 vende el vehiculo1 a la concesionaria)
usuario1.vender_vehiculo(vehiculo1, concesionaria)
#usuario vuelve a mostrar vehiculos comprados (deberia estar vacio al principio)
usuario1.mostrar_vehiculos_comprados()
# Mostrar vehículos disponibles en la concesionaria después de la venta
concesionaria.mostrar_vehiculos()
```#crear clase de vehiculo con marca, modelo y precio en pythonclass Vehiculo: def \_\_init\_\_(self, marca, modelo, precio): self.marca = marca self.modelo = modelo self.precio = precio
def mostrar\_informacion(self): print(f"Marca: {self.marca}") print(f"Modelo: {self.modelo}") print(f"Precio: ${self.precio}")
class Usuario: def \_\_init\_\_(self, nombre, dni, saldo): self.nombre = nombre self.dni = dni self.saldo = saldo self.vehiculos\_comprados = \[]
def comprar\_vehiculo(self, vehiculo): if vehiculo.precio <= self.saldo: self.saldo -= vehiculo.precio self.vehiculos\_comprados.append(vehiculo) print(f"{self.nombre} ha comprado un {vehiculo.marca} {vehiculo.modelo} por ${vehiculo.precio}.") else: print(f"{self.nombre} no tiene suficiente saldo para comprar un {vehiculo.marca} {vehiculo.modelo}.")
def mostrar\_vehiculos\_comprados(self): print(f"{self.nombre} Vehiculos comprados por Juan:") for vehiculo in self.vehiculos\_comprados: vehiculo.mostrar\_informacion() #en caso que no tenga vehiculos comprados: if len(self.vehiculos\_comprados) == 0: print("No ha comprado ningún vehículo.") def vender\_vehiculo(self, vehiculo, concesionaria): if vehiculo in self.vehiculos\_comprados: self.vehiculos\_comprados.remove(vehiculo) self.saldo += vehiculo.precio concesionaria.comprar\_vehiculo(vehiculo) print(f"{self.nombre} ha vendido un {vehiculo.marca} {vehiculo.modelo} por ${vehiculo.precio}.")
class Concesionaria: def \_\_init\_\_(self): self.vehiculos = \[] def comprar\_vehiculo(self, vehiculo): self.vehiculos.append(vehiculo)
def mostrar\_vehiculos(self): print("Vehículos disponibles en la concesionaria:") for vehiculo in self.vehiculos: vehiculo.mostrar\_informacion() def vender\_vehiculo(self, vehiculo, usuario): if vehiculo in self.vehiculos: self.vehiculos.remove(vehiculo) usuario.comprar\_vehiculo(vehiculo) else: print("El vehículo no está disponible en la concesionaria.") # Crear vehículosvehiculo1 = Vehiculo("Toyota", "Corolla", 20000)vehiculo2 = Vehiculo("Ford", "Fiesta", 15000)vehiculo3 = Vehiculo("Chevrolet", "Cruze", 18000)
\# Crear usuariousuario1 = Usuario("Juan", "12345678", 30000)
\#crea concesionariaconcesionaria = Concesionaria()
\# Agregar vehículos a la concesionariaconcesionaria.comprar\_vehiculo(vehiculo1)concesionaria.comprar\_vehiculo(vehiculo2)concesionaria.comprar\_vehiculo(vehiculo3)# Mostrar vehículos disponibles enconcesionaria.mostrar\_vehiculos()
\#usuario muestra vehiculos comprados (deberia estar vacio al principio)usuario1.mostrar\_vehiculos\_comprados()# Usuario compra un vehículoconcesionaria.vender\_vehiculo(vehiculo1, usuario1)#usuario vuelve a mostrar vehiculos comprados (deberia mostrar el vehiculo comprado)usuario1.mostrar\_vehiculos\_comprados()# Mostrar vehículos disponibles en la concesionaria después de la ventaconcesionaria.mostrar\_vehiculos()#ahora la concesionaria compra el vehiculo a un usuario (en este caso el usuario1 vende el vehiculo1 a la concesionaria)usuario1.vender\_vehiculo(vehiculo1, concesionaria)#usuario vuelve a mostrar vehiculos comprados (deberia estar vacio al principio)usuario1.mostrar\_vehiculos\_comprados()# Mostrar vehículos disponibles en la concesionaria después de la ventaconcesionaria.mostrar\_vehiculos()
La **herencia** en Python permite que una clase (subclase) tome atributos y métodos de otra clase (superclase o clase base). Este concepto promueve la reutilización del código y facilita la creación de estructuras jerárquicas en los programas.
### 1. **Conceptos Clave**
* **Superclase**: Es la clase base o padre de la cual otras clases heredan.
* **Subclase**: Es la clase hija o derivada que hereda de la superclase.
* **Herencia Simple**: Una subclase hereda de una única superclase.
* **Herencia Múltiple**: Una subclase hereda de múltiples superclases.
### 2. **Sintaxis Básica**
La herencia se implementa especificando la clase base dentro de los paréntesis de la definición de la subclase.
```python
# Superclase
class Animal:
def speak(self):
return "El animal hace un sonido"
# Subclase
class Dog(Animal):
def speak(self):
return "El perro ladra"
```En este ejemplo:
* `Dog` hereda de `Animal`.
* La subclase puede sobrescribir (redefinir) métodos de la superclase.
### 3. **Uso del Método** `super()`
La función `super()` se utiliza para acceder a métodos o atributos de la superclase desde la subclase. Es útil cuando necesitas extender la funcionalidad de un método de la superclase sin sobrescribirlo por completo.
```python
class Animal:
def __init__(self, name):
self.name = name
def speak(self):
return f"{self.name} hace un sonido"
class Dog(Animal):
def __init__(self, name, breed):
super().__init__(name) # Llama al constructor de Animal
self.breed = breed
def speak(self):
return f"{self.name}, un {self.breed}, ladra"
```
class Carro: def \_\_init\_\_(self, nombre: str, modelo: str, precio: int): self.nombre\_carro = nombre self.modelo = modelo self.precio = precio self.disponible = True
def carror\_vendido(self): if self.disponible: self.disponible = False print(f"El carro de modelo {self.modelo} fue vendido") else: print(f"El carro {self.modelo} no esta disponible")
class User: def \_\_init\_\_(self, nombre: str, cc: int, press: int): self.nombre = nombre self.cc = cc self.press = press
def plata\_en\_cartera(self): print(f"Tengo disponible {self.press}")
class Consesionario: def \_\_init\_\_(self, lista\_carros: list\[Carro], usuario: User): self.lista\_carros = lista\_carros self.usuario = usuario
def carros\_disponibles(self): if len(self.lista\_carros) == 0: print("No hay carros disponibles") else: for carro in self.lista\_carros: print(f"""\t \tNombre: {carro.nombre\_carro} \tModelo: {carro.modelo} \tPrecio: ${carro.precio} """)
def comprar\_carro(self, modelo): for carro in self.lista\_carros: if modelo == carro.modelo: if self.usuario.press < carro.precio: print(f""" No te alcanza para comprar el carro modelo: {modelo} Tienes: {self.usuario.press} y cuesta: {carro.precio} """) return else: self.usuario.press -= carro.precio self.lista\_carros.remove(carro) print(f"¡Compraste el carro modelo: {modelo}!") return
lista\_carros = \[ Carro("Toyota Corolla", "Corolla XSE", 21000), Carro("Honda Civic", "Civic Touring", 23000), Carro("Mazda 3", "Mazda 3 Turbo", 24000), Carro("Ford Mustang", "Mustang GT", 42000),]
def main():
usuario1 = User("Juan", 11111111, 50000)
consesionario = Consesionario(lista\_carros, usuario1) consesionario.carros\_disponibles() consesionario.comprar\_carro(lista\_carros\[3].modelo) consesionario.carros\_disponibles() usuario1.plata\_en\_cartera()if \_\_name\_\_ == "\_\_main\_\_": main()
Para heredar una clase en Python, se utiliza la siguiente sintaxis:
```python
class ClaseHija(ClasePadre):
def __init__(self, atributos):
super().__init__(atributos)
```
En este ejemplo, `ClaseHija` hereda de `ClasePadre`, lo que significa que puede acceder a los métodos y atributos de `ClasePadre`. La función `super()` se utiliza para llamar al constructor de la clase padre. Esto es fundamental en la programación orientada a objetos, ya que permite reusar código y facilitar la organización de las clases.
```python
class Car:
def __init__(self,model,cost,brand):
self.model = model
self.cost = cost
self.brand = brand
self.avaliable = True
def __str__(self):
return f"Brand: {self.brand}\nModel: {self.model}\nCost:{self.cost}"
def carSold(self):
if self.avaliable:
self.avaliable = False
print(f"{self.brand} {self.model} has been sold")
else:
print(f"{self.brand} {self.model} is not avaliable")
def checkAvaliable(self):
if self.avaliable:
print(f"{self.brand} {self.model} is avaliable to sell")
else:
print(f"{self.brand} {self.model} is not avaliable to sell")
def showPrice(self):
print(f"{self.brand} {self.model} has a cost of {self.cost}")
class Customer:
def __init__(self,name):
self.name = name
self.cars_collection = []
def __str__(self) -> str:
return f"Customer name {self.name}"
def buyCar(self,car: Car):
if car.avaliable:
self.cars_collection.append(car)
print(f"{car.brand} {car.model} has been bought")
else:
print(f"{car.brand} {car.model} is not avaliable")
def showCollection(self):
for car in self.cars_collection:
print(car)
print("-----------")
def inqueryCar(self,car: Car):
if car.avaliable:
print(f"{car.brand} {car.model} has a cost of {car.cost}")
else:
print(f"car is not avaliable")
class DealerShip:
def __init__(self):
self.inventory = []
self.customers = []
def addCar(self,car: Car):
self.inventory.append(car)
print(print(f"{car.brand} {car.model} has been added"))
def addClient(self,customer: Customer):
self.customers.append(customer)
print(f"customer {customer.name} has been added")
def showAvaliableCars(self):
print("The following is the list of avaliable cars")
for car in self.inventory:
if car.avaliable:
print(car)
print("--------")
def sellCar(self,customer: Customer,car: Car):
if car in self.inventory:
customer.buyCar(car)
car.carSold()
```Esta es mi version
Como apaorte adicional la función **str** permite usar print para mostar la información del objeto en el formato construido, simplificando algunas partes del codigo como las de mostrar inventario o mostrar coleccion
Hice un ejemplo cortico, para visualizar la herencia.
Definición: En palabras sencillas, son aquellos atributos y metodos que son valga la redundancia heredados, de la clase padre o superclases.
class Animal:
*""" Clase base para mostrar la herencia"""*
** def \_\_init\_\_(self, nombre, patas):
self.nombre = nombre
self.patas = patas
def greeting(self):
print("El animal llamado " + str(self.nombre) + " Saluda")
def walking(self):
print(f"El animal llamado {self.nombre} Sale a dar un Paseo")
class Perro(Animal):
*"""Clase Hija """*
** pass
\#llamamos métodos
mi\_mascota = Perro("Rufo",4)
mi\_mascota.walking()
mi\_mascota.greeting()
Carli, Tu código no funciona..!!
Una instancia de una clase es un objeto concreto que se crea a partir de una clase, y que tiene su propio estado y comportamiento :D
La herencia es un concepto fundamental en la Programación Orientada a Objetos (POO) que permite crear nuevas clases a partir de otras ya existentes. Esto facilita la reutilización de código, ya que una clase hija (o derivada) puede heredar atributos y métodos de una clase padre (o base). Además, puedes agregar nuevos comportamientos o modificar los heredados.
Conceptos clave:
1. Clase padre (o base): Es la clase de la cual otras clases heredan.
2. Clase hija (o derivada): Es la clase que hereda de otra, tomando todos sus métodos y atributos, pero que también puede tener características propias.
Me gustó la sintaxis que usa la profe en el método inquire\_car:
`availability = "disponible" if car.check_availability() else "no disponible"`
Dejo mi solución del reto *siento que fue un poco fotocopia del ejercicio de la biblioteca JAJAJAJA*
```python
# Definición de las clases
class Carro:
def __init__(self, modelo, precio):
self.modelo = modelo
self.precio = precio
self.disponible = True
def comprar(self):
if self.disponible:
self.disponible = False
print(f"El carro {self.modelo} fue comprado por un precio de {self.precio}")
else:
print(f"El carro {self.modelo} no está disponible")
def vender(self):
self.disponible = True
print(f"El carro {self.modelo} ha sido comprado por la concesionaria a un precio de {self.precio}")
class Cliente:
def __init__(self, nombre, id_cliente):
self.nombre = nombre
self.id_cliente = id_cliente
self.carros_comprados = []
def comprar_carro(self, carro):
if carro.disponible:
carro.comprar()
self.carros_comprados.append(carro)
else:
print(f"No se puede comprar el carro {carro.modelo}, no está disponible")
def vender_carro(self, carro):
if carro in self.carros_comprados:
carro.vender()
self.carros_comprados.remove(carro)
else:
print(f"El carro {carro.modelo} no está en posesión del cliente {self.nombre}")
class Concesionario:
def __init__(self):
self.carros = []
self.clientes = []
def añadir_carro(self, carro):
self.carros.append(carro)
def registrar_cliente(self, cliente):
self.clientes.append(cliente)
def carros_disponibles(self):
print("Carros disponibles:")
for carro in self.carros:
if carro.disponible:
print(f"{carro.modelo} a un precio de {carro.precio}")
# Crear instancia de Concesionario
concesionario = Concesionario()
# Crear instancias de Carro
carro1 = Carro("Toyota Corolla", 20000)
carro2 = Carro("Honda Civic", 21000)
carro3 = Carro("Mazda 3", 22000)
carro4 = Carro("Hyundai Elantra", 19000)
carro5 = Carro("Nissan Sentra", 19500)
carro6 = Carro("Toyota RAV4", 27000)
carro7 = Carro("Honda CR-V", 28000)
carro8 = Carro("Ford Escape", 26500)
carro9 = Carro("Chevrolet Equinox", 25500)
carro10 = Carro("Mazda CX-5", 28500)
carro11 = Carro("BMW Serie 3", 41000)
carro12 = Carro("Mercedes-Benz Clase C", 42500)
carro13 = Carro("Audi A4", 43000)
carro14 = Carro("Lexus ES", 40000)
carro15 = Carro("Jaguar XE", 39000)
carro16 = Carro("Ford F-150", 30000)
carro17 = Carro("Chevrolet Silverado 1500", 31000)
carro18 = Carro("Ram 1500", 32000)
carro19 = Carro("Toyota Tacoma", 27000)
carro20 = Carro("Nissan Frontier", 26000)
carro21 = Carro("Tesla Model 3", 39000)
carro22 = Carro("Nissan Leaf", 31000)
carro23 = Carro("Chevrolet Bolt EV", 36000)
carro24 = Carro("Hyundai Kona Electric", 37000)
carro25 = Carro("Kia Niro EV", 39500)
# Crear instancias de Cliente
cliente1 = Cliente("Juan Pérez", 101)
cliente2 = Cliente("María González", 102)
cliente3 = Cliente("Carlos Ramírez", 103)
cliente4 = Cliente("Ana Fernández", 104)
cliente5 = Cliente("Luis Martínez", 105)
cliente6 = Cliente("Sofía Torres", 106)
cliente7 = Cliente("Miguel López", 107)
cliente8 = Cliente("Lucía Díaz", 108)
cliente9 = Cliente("Jorge Herrera", 109)
cliente10 = Cliente("Carmen Vega", 110)
# Añadir carros al concesionario
concesionario.añadir_carro(carro1)
concesionario.añadir_carro(carro2)
concesionario.añadir_carro(carro3)
concesionario.añadir_carro(carro4)
concesionario.añadir_carro(carro5)
concesionario.añadir_carro(carro6)
concesionario.añadir_carro(carro7)
concesionario.añadir_carro(carro8)
concesionario.añadir_carro(carro9)
concesionario.añadir_carro(carro10)
concesionario.añadir_carro(carro11)
concesionario.añadir_carro(carro12)
concesionario.añadir_carro(carro13)
concesionario.añadir_carro(carro14)
concesionario.añadir_carro(carro15)
concesionario.añadir_carro(carro16)
concesionario.añadir_carro(carro17)
concesionario.añadir_carro(carro18)
concesionario.añadir_carro(carro19)
concesionario.añadir_carro(carro20)
concesionario.añadir_carro(carro21)
concesionario.añadir_carro(carro22)
concesionario.añadir_carro(carro23)
concesionario.añadir_carro(carro24)
concesionario.añadir_carro(carro25)
# Registrar clientes en el concesionario
concesionario.registrar_cliente(cliente1)
concesionario.registrar_cliente(cliente2)
concesionario.registrar_cliente(cliente3)
concesionario.registrar_cliente(cliente4)
concesionario.registrar_cliente(cliente5)
concesionario.registrar_cliente(cliente6)
concesionario.registrar_cliente(cliente7)
concesionario.registrar_cliente(cliente8)
concesionario.registrar_cliente(cliente9)
concesionario.registrar_cliente(cliente10)
# Acciones
cliente4.comprar_carro(carro4) # Ana compra el Hyundai Elantra
concesionario.carros_disponibles()
cliente2.vender_carro(carro2) # María vende el Honda Civic
cliente1.comprar_carro(carro1) # Juan compra el Toyota Corolla
cliente3.comprar_carro(carro3) # Carlos compra el Mazda 3
concesionario.carros_disponibles()
cliente5.comprar_carro(carro5) # Luis compra el Nissan Sentra
cliente1.vender_carro(carro1) # Juan vende el Toyota Corolla
cliente6.comprar_carro(carro6) # Sofía compra el Toyota RAV4
cliente7.comprar_carro(carro7) # Miguel compra el Honda CR-V
concesionario.carros_disponibles()
cliente8.comprar_carro(carro8) # Lucía compra el Ford Escape
cliente9.comprar_carro(carro9) # Jorge compra el Chevrolet Equinox
cliente10.comprar_carro(carro10) # Carmen compra el Mazda CX-5
concesionario.carros_disponibles()
cliente6.vender_carro(carro6) # Sofía vende el Toyota RAV4
cliente3.vender_carro(carro3) # Carlos vende el Mazda 3
cliente4.vender_carro(carro4) # Ana vende el Hyundai Elantra
cliente5.vender_carro(carro5) # Luis vende el Nissan Sentra
concesionario.carros_disponibles()
cliente7.vender_carro(carro7) # Miguel vende el Honda CR-V
cliente8.vender_carro(carro8) # Lucía vende el Ford Escape
cliente9.vender_carro(carro9) # Jorge vende el Chevrolet Equinox
cliente10.vender_carro(carro10) # Carmen vende el Mazda CX-5
concesionario.carros_disponibles()
cliente2.comprar_carro(carro2) # María compra el Honda Civic
cliente2.vender_carro(carro2) # María vende el Honda Civic
concesionario.carros_disponibles()
```
**#RETO:** Para el reto de la clase anterior creé un programa en el que puedes comprar cuatro carros que ofrece el concesionario, con base en tu presupuesto. Cuando lo ejecutas (luego de ingresar el nombre y el presupuesto) se ve así:
**El código:**
```js
class Car:
def __init__(self, model, price):
# Inicializa el modelo y el precio del carro, y lo marca como disponible
self.available = True
self.model = model
self.price = int(price)
def buy(self):
# Cambia la disponibilidad del carro y muestra un mensaje de compra
if self.available:
self.available = False
print(f"El carro {self.model} ha sido comprado con éxito")
else:
print(f"El carro {self.model} no está disponible")
class Buyer:
def __init__(self, name, budget):
# Inicializa el nombre y presupuesto del comprador, y lista de carros comprados
self.name = name
self.budget = int(budget)
self.bought_cars = []
def buy_car(self, car):
# Verifica si el comprador tiene suficiente dinero y si el carro está disponible
if self.budget >= car.price:
if car.available:
car.buy() # Llama al método buy del carro
self.budget -= car.price # Descuenta el precio del carro del presupuesto
self.bought_cars.append(car) # Agrega el carro a la lista de comprados
print(f"Has comprado {car.model}")
print(f"Tu nuevo presupuesto es {self.budget}")
else:
print(f"El carro {car.model} no está disponible")
else:
print("No te alcanza para comprar el carro")
class Concesionario:
def __init__(self):
# Inicializa la lista de carros y compradores
self.cars = []
self.buyers = []
def add_car(self, car):
# Agrega un carro a la lista y muestra un mensaje
self.cars.append(car)
print(f"El carro {car.model} ha sido agregado")
def register_buyer(self, buyer):
# Registra un comprador y muestra un mensaje
self.buyers.append(buyer)
print(f"El usuario {buyer.name} ha sido registrado")
def show_available_cars(self):
# Muestra todos los carros disponibles
print("Carros disponibles")
for car in self.cars:
if car.available:
print(f"Modelo: {car.model}, Precio: {car.price}")
# Crear los carros
car1 = Car("Mazda 3", "23000")
car2 = Car("Audi A5", "43000")
car3 = Car("Toyota Prado", "35000")
car4 = Car("Honda HRV", "20000")
# Crear usuario
buyer_name = input("Tu nombre --> ")
buyer_budget = int(input("Tu presupuesto en USD --> "))
buyer = Buyer(buyer_name, buyer_budget)
# Crear Concesionario
concesionario = Concesionario()
concesionario.add_car(car1)
concesionario.add_car(car2)
concesionario.add_car(car3)
concesionario.add_car(car4)
concesionario.register_buyer(buyer)
# Clase para mostrar el menú de opciones
class Menu:
def __init__(self):
pass
@staticmethod
def show_menu():
# Muestra las opciones del menú y devuelve la elección del usuario
print("*" * 8)
print("¿Qué deseas hacer?")
print("Escribe 1 para consultar los carros disponibles")
print("Escribe 2 para comprar un carro")
print("Escribe 3 para consultar tu presupuesto")
print("Escribe 0 para salir")
return int(input("--> "))
# Crear el bucle del menú principal
while True:
decision = Menu.show_menu() # Muestra el menú y obtiene la decisión del usuario
if decision == 1:
# Muestra los carros disponibles
if len(concesionario.cars) >= 1:
concesionario.show_available_cars()
else:
print("No hay carros disponibles")
elif decision == 2:
# Filtra los carros disponibles
available_cars = [car for car in concesionario.cars if car.available]
if len(available_cars) == 0:
print("No hay carros disponibles para comprar")
continue
# Obtener el precio mínimo de los carros disponibles
min_price = min(car.price for car in available_cars)
# Verifica si el comprador tiene suficiente dinero para el carro más barato
if buyer.budget < min_price:
print("No tienes dinero suficiente para comprar ningún carro")
else:
print("Qué carro deseas comprar?")
# Muestra las opciones de compra solo para carros disponibles
if car1.available:
print(f"Escribe 1 para comprar {car1.model} por {car1.price}")
if car2.available:
print(f"Escribe 2 para comprar {car2.model} por {car2.price}")
if car3.available:
print(f"Escribe 3 para comprar {car3.model} por {car3.price}")
if car4.available:
print(f"Escribe 4 para comprar {car4.model} por {car4.price}")
print("Escribe 0 para regresar al menu")
choice = input("--> ")
# Procesa la elección del usuario para comprar un carro
if choice == "1":
buyer.buy_car(car1)
elif choice == "2":
buyer.buy_car(car2)
elif choice == "3":
buyer.buy_car(car3)
elif choice == "4":
buyer.buy_car(car4)
elif choice == "0":
continue # Regresa al menú
else:
print("Opción inválida")
elif decision == 3:
# Muestra el presupuesto actual del comprador
print(f"Tu presupuesto actual es: {buyer.budget}")
elif decision == 0:
# Mensaje de salida y finaliza el bucle
print("Saliendo del sistema. ¡Gracias!")
break
else:
# Maneja entradas inválidas
print("Opción inválida, por favor intenta nuevamente.")
```class <u>Car</u>:
def \_\_init\_\_(self, model, price):
\# Inicializa el modelo y el precio del carro, y lo marca como disponible
self.available = True
self.model = model
self.price = int(price)
def buy(self):
\# Cambia la disponibilidad del carro y muestra un mensaje de compra
if self.available:
self.available = False
print(f"El carro {self.model} ha sido comprado con éxito")
else:
print(f"El carro {self.model} no está disponible")
class <u>Buyer</u>:
def \_\_init\_\_(self, name, budget):
\# Inicializa el nombre y presupuesto del comprador, y lista de carros comprados
self.name = name
self.budget = int(budget)
self.bought\_cars = \[]
def buy\_car(self, car):
\# Verifica si el comprador tiene suficiente dinero y si el carro está disponible
if self.budget \>= car.price:
if car.available:
car.buy() # Llama al método buy del carro
self.budget -= car.price # Descuenta el precio del carro del presupuesto
self.bought\_cars.append(car) # Agrega el carro a la lista de comprados
print(f"Has comprado {car.model}")
print(f"Tu nuevo presupuesto es {self.budget}")
else:
print(f"El carro {car.model} no está disponible")
else:
print("No te alcanza para comprar el carro")
class <u>Concesionario</u>:
def \_\_init\_\_(self):
\# Inicializa la lista de carros y compradores
self.cars = \[]
self.buyers = \[]
def add\_car(self, car):
\# Agrega un carro a la lista y muestra un mensaje
self.cars.append(car)
print(f"El carro {car.model} ha sido agregado")
def register\_buyer(self, buyer):
\# Registra un comprador y muestra un mensaje
self.buyers.append(buyer)
print(f"El usuario {buyer.name} ha sido registrado")
def show\_available\_cars(self):
\# Muestra todos los carros disponibles
print("Carros disponibles")
for car in self.cars:
if car.available:
print(f"Modelo: {car.model}, Precio: {car.price}")
\# Crear los carros
car1 = Car("Mazda 3", "23000")
car2 = Car("Audi A5", "43000")
car3 = Car("Toyota Prado", "35000")
car4 = Car("Honda HRV", "20000")
\# Crear usuario
buyer\_name = input("Tu nombre --\> ")
buyer\_budget = int(input("Tu presupuesto en USD --\> "))
buyer = Buyer(buyer\_name, buyer\_budget)
\# Crear Concesionario
concesionario = Concesionario()
concesionario.add\_car(car1)
concesionario.add\_car(car2)
concesionario.add\_car(car3)
concesionario.add\_car(car4)
concesionario.register\_buyer(buyer)
\# Clase para mostrar el menú de opciones
class <u>Menu</u>:
def \_\_init\_\_(self):
pass
@staticmethod
def show\_menu():
\# Muestra las opciones del menú y devuelve la elección del usuario
print("\*" \* 8)
print("¿Qué deseas hacer?")
print("Escribe 1 para consultar los carros disponibles")
print("Escribe 2 para comprar un carro")
print("Escribe 3 para consultar tu presupuesto")
print("Escribe 0 para salir")
return int(input("--\> "))
\# Crear el bucle del menú principal
while True:
decision = Menu.show\_menu() # Muestra el menú y obtiene la decisión del usuario
if decision == 1:
\# Muestra los carros disponibles
if len(concesionario.cars) \>= 1:
concesionario.show\_available\_cars()
else:
print("No hay carros disponibles")
elif decision == 2:
\# Filtra los carros disponibles
available\_cars = \[car for car in concesionario.cars if car.available]
if len(available\_cars) == 0:
print("No hay carros disponibles para comprar")
continue
\# Obtener el precio mínimo de los carros disponibles
min\_price = min(car.price for car in available\_cars)
\# Verifica si el comprador tiene suficiente dinero para el carro más barato
if buyer.budget \< min\_price:
print("No tienes dinero suficiente para comprar ningún carro")
else:
print("Qué carro deseas comprar?")
\# Muestra las opciones de compra solo para carros disponibles
if car1.available:
print(f"Escribe 1 para comprar {car1.model} por {car1.price}")
if car2.available:
print(f"Escribe 2 para comprar {car2.model} por {car2.price}")
if car3.available:
print(f"Escribe 3 para comprar {car3.model} por {car3.price}")
if car4.available:
print(f"Escribe 4 para comprar {car4.model} por {car4.price}")
print("Escribe 0 para regresar al menu")
choice = input("--\> ")
\# Procesa la elección del usuario para comprar un carro
if choice == "1":
buyer.buy\_car(car1)
elif choice == "2":
buyer.buy\_car(car2)
elif choice == "3":
buyer.buy\_car(car3)
elif choice == "4":
buyer.buy\_car(car4)
elif choice == "0":
continue # Regresa al menú
else:
print("Opción inválida")
elif decision == 3:
\# Muestra el presupuesto actual del comprador
print(f"Tu presupuesto actual es: {buyer.budget}")
elif decision == 0:
\# Mensaje de salida y finaliza el bucle
print("Saliendo del sistema. ¡Gracias!")
break
else:
\# Maneja entradas inválidas
print("Opción inválida, por favor intenta nuevamente.")
Aca mi version del proyecto, te permite comprar boletos aereos segun el destino, y validar que tengas ese dinero en tu cuenta
```js
import random
class BankAccount:
def __init__(self, user, brand, amount):
self.user = user
self.brand = brand
self.amount = amount
self.isActive = True
def qikUser(self):
print(f'El usuario {self.user} tiene una cuenta {self.isActive} en {self.brand}, con un monto de {self.amount}')
def addCredit(self, credit):
if self.isActive:
self.amount += credit
else:
print('La cuenta está inactiva')
def retireCredit(self, credit):
if self.isActive:
if self.amount >= credit:
self.amount -= credit
print(f'Has retirado {credit} de la cuenta, tu nuevo balance es de {self.amount}')
else:
print(f'No tienes suficiente dinero en tu cuenta para retirar {credit}, tu balance es de {self.amount}')
else:
print('La cuenta está inactiva')
def accountStatus(self, status):
if status == 'activa':
self.isActive = True
elif status == 'desactiva':
self.isActive = False
else:
print('Ese no es un estado de cuenta válido')
Calvin = BankAccount('Calvin', 'qik', 2000)
Calvin.accountStatus('activa')
Calvin.addCredit(3000)
Calvin.qikUser()
class Airline:
def __init__(self, name, homeland, bank_account):
self.name = name
self.homeland = homeland
self.bank_account = bank_account
def buyTicket(self):
print('1 - República Dominicana')
print('2 - Estados Unidos')
choice = int(input('Bienvenido, ¿hacia qué país te interesaría comprar el vuelo? '))
if choice == 1:
print(f'Bienvenido a {self.name}! Elige tu destino: ')
print(f'1 - Santo Domingo, precio: {random.randint(200, 400)}')
print(f'2 - Santiago, precio: {random.randint(200, 400)}')
print(f'3 - Puerto Plata, precio: {random.randint(200, 400)}')
print(f'4 - Punta Cana, precio: {random.randint(200, 400)}')
elif choice == 2:
print(f'Bienvenido a {self.name}! Elige tu destino: ')
print(f'1 - New York, precio: {random.randint(200, 400)}')
print(f'2 - Miami, precio: {random.randint(200, 400)}')
print(f'3 - Los Angeles, precio: {random.randint(200, 400)}')
print(f'4 - Chicago, precio: {random.randint(200, 400)}')
else:
print('No hay vuelos disponibles hacia ese destino o país.')
return
choiceDestiny = int(input('¿Dónde irás? '))
flight_price = random.randint(200, 400)
if self.bank_account.amount >= flight_price:
self.bank_account.amount -= flight_price
print(f'El vuelo ha sido comprado con éxito. El coste fue de {flight_price}, te quedan {self.bank_account.amount} en tu cuenta')
else:
print('No tienes suficiente dinero para comprar el vuelo')
# Aerolínea en República Dominicana
Arajet = Airline('Arajet', 'República Dominicana', Calvin)
Arajet.buyTicket()
# Aerolínea en Estados Unidos
JetBlue = Airline('JetBlue', 'Estados Unidos', Calvin)
JetBlue.buyTicket()
```
Tenía un error al haber creado la función, y era que coloque un else, pero esto generaba que siempre saliera como que no hay carros disponibles:
Situación anterior:
```js
print(f'El cliente {customer.name} ha sido registrado en la base de datos de la concesionaria')
def show_cars(self):
print('Carros disponibles: ')
for car in self.cars:
if car.available:
print(f'{car.brand} {car.model} con un precio de {car.price}')
else:
print(f'Ha sido un excelente mes, no tenemos carros disponibles en este momento')
``` print(f'El cliente {customer.name} ha sido registrado en la base de datos de la concesionaria')
def show\_cars(self):
print('Carros disponibles: ')
for car in self.cars:
if car.available:
print(f'{car.brand} {car.model} con un precio de {car.price}')
else:
print(f'Ha sido un excelente mes, no tenemos carros disponibles en este momento')
Solución:
```js
def show_cars(self):
print('Carros disponibles: ')
available_cars = False
for car in self.cars:
if car.available:
print(f'{car.brand} {car.model} con un precio de {car.price}')
available_cars = True
if not available_cars:
print(f'Ha sido un excelente mes, no tenemos carros disponibles en este momento')
``` def show\_cars(self):
print('Carros disponibles: ')
available\_cars = False
for car in self.cars:
if car.available:
print(f'{car.brand} {car.model} con un precio de {car.price}')
available\_cars = True
if not available\_cars:
print(f'Ha sido un excelente mes, no tenemos carros disponibles en este momento')
```js
class car:
def __init__(self,name,prize,model):
self.name=name
self.prize=prize
self.model=model
self.avalilable=True
def sell(self):
if self.avalilable:
print(f"El carro {self.name} ha sido vendido")
self.avalilable=False
else:
print(f"El carro {self.name} no esta disponible")
class User:
def __init__(self,name,user_id):
self.name = name
self.user_id = user_id
def buy_car(self,car):
if car.avalilable:
car.sell()
print(f"El carro :{car.name}, modelo {car.model}ha sido comprado por {car.prize}")
else:
print(f"El carro :{car.name} no se encuentra disponible")
class concecionary:
def __init__(self):
self.car=[]
self.user=[]
def register_user(self,user):
self.user.append(user)
print(f"El usuario {user.name} ha sido registrado")
def add_car(self,car):
self.car.append(car)
print(f"El {car.name} ha sido agregado")
def show_available_cars(self):
print("Carros disponibles:")
for car in self.car:
if car.avalilable:
print(f"{car.name} modelo: {car.model} a un precio de {car.prize}")
car1=car("Corsa","27M","2008")
user1=User("Comprador Sanchez","001")
con=concecionary()
con.add_car(car1)
# Añadir usuario
con.show_available_cars()
con.register_user(user1)
user1.buy_car(car1)
con.show_available_cars()
```class car: def \_\_init\_\_(self,name,prize,model): self.name=name self.prize=prize self.model=model self.avalilable=True def sell(self): if self.avalilable: print(f"El carro {self.name} ha sido vendido") self.avalilable=False else: print(f"El carro {self.name} no esta disponible")
```python
class Vehicle:
def __init__(self, plate, model, value):
self.plate = plate
self.model = model
self.value = value
self.is_available = True
def sell(self):
if self.is_available:
self.is_available = False
print(f"El auto {self.model} de placa {self.plate} ha sido vendido", end =" ")
else:
print(f"El auto buscado no esta disponible")
def buy(self):
self.is_available = True
print(f"El auto {self.model} de placa {self.plate} nos ha sido revendido", end=" ")
def car_value(self):
print(f"El valor del auto {self.model} es {self.value}")
class Client:
def __init__(self, name, id_client):
self.name = name
self.id_client = id_client
self.bought_car = []
def client_buy_car(self, car):
if car.is_available:
car.sell()
print(f"al cliente {self.name}.")
self.bought_car.append(car)
else:
print(f"El auto{car.model} de placa {car.plate} no esta disponible.")
def client_sell_car(self, car):
if car in self.bought_car:
car.buy()
print(f"por el cliente {self.name}.")
self.bought_car.remove(car)
else:
print(f"El auto {car.model} de placa {car.plate} no pertenece al cliente {self.name}")
def show_bought_cars(self):
print(f"Autos comprados por {self.name}:")
for car in client1.bought_car:
print(car.model)
class CarDealership:
def __init__(self):
self.cars = []
self.clients = []
def add_cars(self,car):
self.cars.append(car)
print(f"El auto {car.model} de placa {car.plate} ha sido añadido al inventario.")
def add_client(self,client):
self.clients.append(client)
print(f"El cliente {client.name} ha sido registrado exitosamente.")
def show_available_cars (self):
print("Carros disponibles:")
for car in self.cars:
if car.is_available:
print(f"- Modelo: {car.model}. Placa: {car.plate} ")
def show_value(self, car):
if car.is_available:
car.car_value()
else:
print(f"El auto{car.model} de placa {car.plate} ya no esta disponible.")
#Creación de objetos
car1 = Vehicle("NTJ570","Toyota 500","6000")
car2 = Vehicle("ABC123","Ferrari i15","8000")
client1 = Client("Rigoberta","001")
carDealership = CarDealership()
#Carros en el concesionario
carDealership.add_cars(car1)
carDealership.add_cars(car2)
#Clientes del concesionario
carDealership.add_client(client1)
#Mostar autos disponibles
carDealership.show_available_cars()
#Mostrar el valor de un auto
carDealership.show_value(car1)
#Vender auto
client1.client_buy_car(car2)
#Mostar carros comprados por el cliente
client1.show_bought_cars()
#Mostrar el valor de un auto vendido
carDealership.show_value(car2)
#Mostar autos disponibles
carDealership.show_available_cars()
#Cliente revende el auto
client1.client_sell_car(car2)
#El cliente revende un auto que no tiene
client1.client_sell_car(car1)
```class Vehicle:
def \_\_init\_\_(self, plate, model, value): self.plate = plate self.model = model self.value = value self.is\_available = True
def sell(self): if self.is\_available: self.is\_available = False print(f"El auto {self.model} de placa {self.plate} ha sido vendido", end =" ") else: print(f"El auto buscado no esta disponible")
def buy(self): self.is\_available = True print(f"El auto {self.model} de placa {self.plate} nos ha sido revendido", end=" ") def car\_value(self): print(f"El valor del auto {self.model} es {self.value}")
class Client: def \_\_init\_\_(self, name, id\_client): self.name = name self.id\_client = id\_client self.bought\_car = \[]
def client\_buy\_car(self, car): if car.is\_available: car.sell() print(f"al cliente {self.name}.") self.bought\_car.append(car) else: print(f"El auto{car.model} de placa {car.plate} no esta disponible.")
def client\_sell\_car(self, car): if car in self.bought\_car: car.buy() print(f"por el cliente {self.name}.") self.bought\_car.remove(car) else: print(f"El auto {car.model} de placa {car.plate} no pertenece al cliente {self.name}")
def show\_bought\_cars(self): print(f"Autos comprados por {self.name}:") for car in client1.bought\_car: print(car.model) class CarDealership:
def \_\_init\_\_(self): self.cars = \[] self.clients = \[] def add\_cars(self,car): self.cars.append(car) print(f"El auto {car.model} de placa {car.plate} ha sido añadido al inventario.")
def add\_client(self,client): self.clients.append(client) print(f"El cliente {client.name} ha sido registrado exitosamente.")
def show\_available\_cars (self): print("Carros disponibles:") for car in self.cars: if car.is\_available: print(f"- Modelo: {car.model}. Placa: {car.plate} ")
def show\_value(self, car): if car.is\_available: car.car\_value() else: print(f"El auto{car.model} de placa {car.plate} ya no esta disponible.")
\#Creación de objetoscar1 = Vehicle("NTJ570","Toyota 500","6000")car2 = Vehicle("ABC123","Ferrari i15","8000")
client1 = Client("Rigoberta","001")
carDealership = CarDealership()
\#Carros en el concesionariocarDealership.add\_cars(car1)carDealership.add\_cars(car2)
\#Clientes del concesionariocarDealership.add\_client(client1)
\#Mostar autos disponiblescarDealership.show\_available\_cars()
\#Mostrar el valor de un autocarDealership.show\_value(car1)
\#Vender autoclient1.client\_buy\_car(car2)
\#Mostar carros comprados por el clienteclient1.show\_bought\_cars()
\#Mostrar el valor de un auto vendidocarDealership.show\_value(car2)
\#Mostar autos disponiblescarDealership.show\_available\_cars()
\#Cliente revende el autoclient1.client\_sell\_car(car2)
\#El cliente revende un auto que no tieneclient1.client\_sell\_car(car1)
Hola todos , aunque me tomo unas horas he resuelto el reto a mi manera:
class Car: def \_\_init\_\_(self, name, brand, model, price): self.name = name self.brand = brand self.model = model self.price = price self.available = True def sell(self): if self.available: self.available = False print(f"El vehículo {self.brand} {self.model} ha sido vendido.") else: print(f'El vehículo {self.name} {self.brand} {self.model} no está disponible') class Concesionario: def \_\_init\_\_(self, name): self.name = name self.cars\_inventory = \[] def add\_Cars(self, car): self.cars\_inventory.append(car) print(f'El vehículo {car.name}, {car.brand} ha sido registrado en el inventario') def sell\_car(self, brand, model): available\_car = \[car for car in self.cars\_inventory if car.brand == brand and car.model == model and car.available] if available\_car: car = available\_car\[0].sell() else: print(f"El vehículo {brand} {model} no está disponible o no existe en el inventario.") def list\_cars\_inventory(self): print(f"Inventario del concesionario {self.name}:") for car in self.cars\_inventory: status = 'Disponible' if car.available else 'Vendido' print(f"{car.brand} {car.name} ({car.model}) - {status} - ${car.price}")
\# Ejemplo de uso concesionario = Concesionario('Autos Python')
\# Crear algunos vehículoscar1 = Car('Onix', 'Chevrolet', '2020', 35000000)car2 = Car('Corolla', 'Toyota', '2022', 65000000)car3 = Car('Panamera', 'Porsche', '2006', 50000000)
\# Añadir vehículos al concesionario concesionario.add\_Cars(car1)concesionario.add\_Cars(car2)concesionario.add\_Cars(car3)
\# Listar inventario concesionario.list\_cars\_inventory()
\# Vender un vehículoconcesionario.sell\_car('Porsche', '2006')
\# Listar inventario nuevamente concesionario.list\_cars\_inventory()
Es necesario la indentacion en el caso de class car(vehicle) ?
No se entendio.
También se puede implementar la herencia y llamando a los atributos de la clase padre de una forma más "antigua":*class* BaseClass: *def* \_\_init\_\_(*self*, *a*, *b*, *c*): self.a = a self.b = b self.c = c
*def* *method\_BaseClass*(*self*): print(*f*"This method shows {self.a}, {self.b} and {self.c} from the Base Class")
*class* DerivedClass (BaseClass): *def* \_\_init\_\_(*self*, *a*, *b*, *c*, *d*, *e*, *f*): BaseClass.\_\_init\_\_(self, a, b, c)
self.d = d self.e = e self.f = f
*def* *method\_DerivedClass*(*self*): print(*f*"This method shows {self.d}, {self.e} and {self.f} from the Derived Class")
*def* *caller\_BaseClass*(*self*): BaseClass.method\_BaseClass()
*def* *show\_DerivedClass\_attributes*(*self*): print(self.d, self.e, self.f)
```python
class BaseClass:
def __init__(self, a, b, c):
self.a = a
self.b = b
self.c = c
def method_BaseClass(self):
print(f"This method shows {self.a}, {self.b} and {self.c} from the Base Class")
class DerivedClass (BaseClass):
def __init__(self, a, b, c, d, e, f):
BaseClass.__init__(self, a, b, c)
# aqui llamamamos a la clase BaseClass con su init y le mandamos sus atributos, para hacerlos disponibles dentro de la clase derivada
self.d = d
self.e = e
self.f = f
def method_DerivedClass(self):
print(f"This method shows {self.d}, {self.e} and {self.f} from the Derived Class")
def caller_BaseClass(self):
BaseClass.method_BaseClass()
def show_DerivedClass_attributes(self):
print(self.d, self.e, self.f)
```
`class Car:`
` def __init__(self, model, price):`
` self.model = model`
` self.price = price`
` self.available = True`
` def buy(self):`
` if self.available:`
` self.available = False`
` print(f"The car {self.model} has been sold")`
` else:`
` print(f"The car {self.model} is not available")`
` def return_car(self):`
` self.available = True`
` print(f"The car {self.model} is available again")`
`class User:`
` def __init__(self, name, user_id):`
` self.name = name`
` self.user_id = user_id`
` self.purchased_cars = []`
` def buy_car(self, car):`
` if car.available:`
` car.buy()`
` self.purchased_cars.append(car)`
` print(f"{self.name} has bought the car {car.model}")`
` else:`
` print(f"The car {car.model} is not available")`
`class CarDealer:`
` def __init__(self):`
` self.cars = []`
` self.users = []`
` def add_car(self, car):`
` self.cars.append(car)`
` print(f"The car {car.model} has been added")`
` def register_user(self, user):`
` self.users.append(user)`
` print(f"The user {user.name} has been registered")`
` def show_available_cars(self):`
` print("Available cars:")`
` for car in self.cars:`
` if car.available:`
` print(f"{car.model} - {car.price}")`
`# Created cars`
`car1 = Car("Toyota", "100,000")`
`car2 = Car("Suzuki", "20,000")`
`car3 = Car("BMW", "20,000")`
`car4 = Car("Ford", "30,000")`
`# Created user`
`user1 = User("Yami", "003")`
`# Created dealer`
`dealer = CarDealer()`
`dealer.add_car(car1)`
`dealer.add_car(car2)`
`dealer.add_car(car3)`
`dealer.add_car(car4)`
`dealer.register_user(user1)`
`# Show available cars`
`dealer.show_available_cars()`
`# User buys a car`
`user1.buy_car(car1)`
`# Show available cars again`
`dealer.show_available_cars()`
Reto de la consecionaria automotriz:
```js
#Automotriz
#El Rey de los SportsCar
class Car:
def __init__(self, brand, model, year, max_speed, price):
self.brand = brand # Marca del automóvil
self.model = model # Modelo del automóvil
self.year = year # Año del automóvil
self.max_speed = max_speed # Velocidad máxima del automóvil
self.price = price # Precio del automóvil
self.available = True # Estado de disponibilidad del automóvil, inicialmente disponible
def sell(self): # Método para vender el automóvil
if self.available: # Verifica si el automóvil está disponible
self.available = False # Marca el automóvil como no disponible
print(f"El automóvil {self.brand} {self.model} ha sido vendido") # Mensaje de confirmación
else:
print(f"El automóvil {self.brand} {self.model} no está disponible") # Mensaje si no está disponible
def return_car(self): # Método para devolver el automóvil
self.available = True # Marca el automóvil como disponible
print(f"El automóvil {self.brand} {self.model} ha sido devuelto") # Mensaje de confirmación
class Customer:
def __init__(self, name, customer_id): # Inicializa al cliente con nombre e ID
self.name = name # Nombre del cliente
self.customer_id = customer_id # ID del cliente
def buy_car(self, car): # Método para que el cliente compre un automóvil
if car.available: # Verifica si el automóvil está disponible
car.sell() # Llama al método sell del automóvil para marcarlo como vendido
print(f"{self.name} ha comprado el automóvil {car.brand} {car.model}") # Mensaje de confirmación
else:
print(f"El automóvil {car.brand} {car.model} no está disponible para la compra") # Mensaje si el automóvil no está disponible
def return_car(self, car): # Método para que el cliente devuelva un automóvil
car.return_car() # Llama al método return_car del automóvil para marcarlo como devuelto
print(f"{self.name} ha devuelto el automóvil {car.brand} {car.model}") # Mensaje de confirmación
class Dealership:
def __init__(self): # Inicializa la concesionaria
self.cars = [] # Lista para almacenar los automóviles en la concesionaria
self.customers = [] # Lista para almacenar los clientes registrados
def add_car(self, car): # Método para agregar un automóvil a la concesionaria
self.cars.append(car) # Agrega el automóvil a la lista de automóviles
print(f"El automóvil {car.brand} {car.model} ha sido agregado al catálogo") # Mensaje de confirmación
def register_customer(self, customer): # Método para registrar un cliente en la concesionaria
self.customers.append(customer) # Agrega el cliente a la lista de clientes
print(f"El cliente {customer.name} ha sido registrado") # Mensaje de confirmación
def show_available_cars(self): # Método para mostrar los automóviles disponibles en la concesionaria
print("Automóviles disponibles:") # Encabezado para la lista de automóviles
for car in self.cars: # Recorre todos los automóviles en la concesionaria
if car.available: # Verifica si el automóvil está disponible
print(f"{car.brand} {car.model} ({car.year}) - Vel. Max: {car.max_speed} km/h - Precio: ${car.price}") # Muestra la información del automóvil
def welcome_message(self): # Método para mostrar un mensaje de bienvenida
print("*********************************************************")
print("* Bienvenido a Concesionaria El Rey de los Sportscars! *") # Mensaje de bienvenida
print("*********************************************************")
# Crear los automóviles
car1 = Car("Koenigsegg", "Jesko Absolut", 2024, "500 K/H", "$3,500,000.00 Dlls") # Crea el primer automóvil
car2 = Car("SSC", "Tuatara", 2024, "474 K/h", "2,800,000.00 Dlls") # Crea el segundo automóvil
car3 = Car("Bugatti", "Tourbillio", 2024, "445 K/H", "$4,200,000.00 Dlls") # Crea el tercer automóvil
car4 = Car("Hennessey", "Venom F5", 2024, "435 K/H", "$3,200,000.00 Dlls") # Crea el cuarto automóvil
car5 = Car("Rimac", "Nevera", 2024, "410 K/H", "$2,700,000.00 Dlls") # Crea el quinto automóvil
# Crear cliente
customer1 = Customer("Alice", "001") # Crea un nuevo cliente
# Crear concesionaria
dealership = Dealership() # Crea una nueva concesionaria
dealership.welcome_message() # Muestra el mensaje de bienvenida
dealership.add_car(car1) # Agrega el primer automóvil al catálogo
dealership.add_car(car2) # Agrega el segundo automóvil al catálogo
dealership.add_car(car3) # Agrega el tercer automóvil al catálogo
dealership.add_car(car4) # Agrega el cuarto automóvil al catálogo
dealership.add_car(car5) # Agrega el quinto automóvil al catálogo
dealership.register_customer(customer1) # Registra el cliente en la concesionaria
# Mostrar automóviles disponibles
dealership.show_available_cars() # Muestra todos los automóviles disponibles en la concesionaria
# Realizar compra
customer1.buy_car(car1) # El cliente compra el primer automóvil
# Mostrar automóviles disponibles después de la compra
dealership.show_available_cars() # Muestra los automóviles disponibles después de la compra
# Devolver automóvil
customer1.return_car(car1) # El cliente devuelve el primer automóvil
# Mostrar automóviles disponibles después de la devolución
dealership.show_available_cars() # Muestra los automóviles disponibles después de la devolución
```
Dejo ya una lista de carros y de clientes para el final del reto por si le ahorro tiempo a alguiencarro1 = Carro("Toyota Corolla", 20000)carro2 = Carro("Honda Civic", 21000)carro3 = Carro("Mazda 3", 22000)carro4 = Carro("Hyundai Elantra", 19000)carro5 = Carro("Nissan Sentra", 19500)carro6 = Carro("Toyota RAV4", 27000)carro7 = Carro("Honda CR-V", 28000)carro8 = Carro("Ford Escape", 26500)carro9 = Carro("Chevrolet Equinox", 25500)carro10 = Carro("Mazda CX-5", 28500)carro11 = Carro("BMW Serie 3", 41000)carro12 = Carro("Mercedes-Benz Clase C", 42500)carro13 = Carro("Audi A4", 43000)carro14 = Carro("Lexus ES", 40000)carro15 = Carro("Jaguar XE", 39000)carro16 = Carro("Ford F-150", 30000)carro17 = Carro("Chevrolet Silverado 1500", 31000)carro18 = Carro("Ram 1500", 32000)carro19 = Carro("Toyota Tacoma", 27000)carro20 = Carro("Nissan Frontier", 26000)carro21 = Carro("Tesla Model 3", 39000)carro22 = Carro("Nissan Leaf", 31000)carro23 = Carro("Chevrolet Bolt EV", 36000)carro24 = Carro("Hyundai Kona Electric", 37000)carro25 = Carro("Kia Niro EV", 39500)
cliente1 = Cliente("Juan Pérez", 101)cliente2 = Cliente("María González", 102)cliente3 = Cliente("Carlos Ramírez", 103)cliente4 = Cliente("Ana Fernández", 104)cliente5 = Cliente("Luis Martínez", 105)cliente6 = Cliente("Sofía Torres", 106)cliente7 = Cliente("Miguel López", 107)cliente8 = Cliente("Lucía Díaz", 108)cliente9 = Cliente("Jorge Herrera", 109)cliente10 = Cliente("Carmen Vega", 110)```js
carro1 = Carro("Toyota Corolla", 20000)
carro2 = Carro("Honda Civic", 21000)
carro3 = Carro("Mazda 3", 22000)
carro4 = Carro("Hyundai Elantra", 19000)
carro5 = Carro("Nissan Sentra", 19500)
carro6 = Carro("Toyota RAV4", 27000)
carro7 = Carro("Honda CR-V", 28000)
carro8 = Carro("Ford Escape", 26500)
carro9 = Carro("Chevrolet Equinox", 25500)
carro10 = Carro("Mazda CX-5", 28500)
carro11 = Carro("BMW Serie 3", 41000)
carro12 = Carro("Mercedes-Benz Clase C", 42500)
carro13 = Carro("Audi A4", 43000)
carro14 = Carro("Lexus ES", 40000)
carro15 = Carro("Jaguar XE", 39000)
carro16 = Carro("Ford F-150", 30000)
carro17 = Carro("Chevrolet Silverado 1500", 31000)
carro18 = Carro("Ram 1500", 32000)
carro19 = Carro("Toyota Tacoma", 27000)
carro20 = Carro("Nissan Frontier", 26000)
carro21 = Carro("Tesla Model 3", 39000)
carro22 = Carro("Nissan Leaf", 31000)
carro23 = Carro("Chevrolet Bolt EV", 36000)
carro24 = Carro("Hyundai Kona Electric", 37000)
carro25 = Carro("Kia Niro EV", 39500)
cliente1 = Cliente("Juan Pérez", 101)
cliente2 = Cliente("María González", 102)
cliente3 = Cliente("Carlos Ramírez", 103)
cliente4 = Cliente("Ana Fernández", 104)
cliente5 = Cliente("Luis Martínez", 105)
cliente6 = Cliente("Sofía Torres", 106)
cliente7 = Cliente("Miguel López", 107)
cliente8 = Cliente("Lucía Díaz", 108)
cliente9 = Cliente("Jorge Herrera", 109)
cliente10 = Cliente("Carmen Vega", 110)
```
```python
#Reto
class Car:
def __init__(self,brand, model, color, price):
self.brand = brand
self.model = model
self.color = color
self.price = price
self.is_available = True
def sell(self):
if self.is_available:
self.is_available = False
print(f"El vehiculo {self.brand}, {self.model}, {self.color} ha sido vendido")
else:
print (f"El vehiculo {self.brand}, {self.model}, {self.color} no se encuentra disponible")
def return_car(self):
self.is_available = True
print(f"El auto {self.model} ha sido devuelto")
def car_available(self):
return self.is_available
class Client:
def __init__(self, name, last_name, age):
self.name = name
self.last_name = last_name
self.age = age
self.purchased_cars = []
def purchased_car(self, car):
if car.is_available:
car.sell()
self.purchased_cars.append(car)
else:
print(f"El auto {car.model} no se encuentra disponible")
def return_car (self, car):
if car in self.purchased_cars:
car.return_car()
self.purchased_cars.remove(car)
class Concessionaire:
def __init__(self):
self.cars = []
self.client = []
def add_car(self, car):
self.cars.append(car)
print(f"El auto {car.model} ha sido añadido")
def register_client(self, client):
self.client.append(client)
print(f"Cliente {client.name} registrado")
def remove_car(self,car):
self.cars.remove(car)
print(f"El auto {car.model} ha sido eliminado")
def remove_client(self, client):
self.client.remove(client)
print(f"Cliente {client.name} ha sido eliminado")
def show_available_cars(self):
print("Vehiculos disponibles:")
for car in self.cars:
if car.is_available:
print(f"{car.brand}, {car.model} color {car.color}, valor: {car.price}")
#Creando los vehiculos
vehicle1 = Car("Audi","A1","Blanco", 60000)
Vehicle2 = Car("Audi", "A3", "Negro", 65000)
#Creando los clientes
client1 = Client("Victor","Moritz", 28)
#Creando el concesionario
concessionaire = Concessionaire()
concessionaire.add_car(vehicle1)
concessionaire.add_car(Vehicle2)
concessionaire.register_client(client1)
#Mostrar los vehiculos
concessionaire.show_available_cars()
#Realizar compra
client1.purchased_car(vehicle1)
#Mostrar los vehiculos
concessionaire.show_available_cars()
#Regresar auto
client1.return_car(vehicle1)
#Mostrar los vehiculos
concessionaire.show_available_cars()
```#Reto
class Car: def \_\_init\_\_(self,brand, model, color, price): self.brand = brand self.model = model self.color = color self.price = price self.is\_available = True def sell(self): if self.is\_available: self.is\_available = False print(f"El vehiculo {self.brand}, {self.model}, {self.color} ha sido vendido") else: print (f"El vehiculo {self.brand}, {self.model}, {self.color} no se encuentra disponible") def return\_car(self): self.is\_available = True print(f"El auto {self.model} ha sido devuelto") def car\_available(self): return self.is\_available class Client: def \_\_init\_\_(self, name, last\_name, age): self.name = name self.last\_name = last\_name self.age = age self.purchased\_cars = \[] def purchased\_car(self, car): if car.is\_available: car.sell() self.purchased\_cars.append(car) else: print(f"El auto {car.model} no se encuentra disponible") def return\_car (self, car): if car in self.purchased\_cars: car.return\_car() self.purchased\_cars.remove(car)
class Concessionaire: def \_\_init\_\_(self): self.cars = \[] self.client = \[] def add\_car(self, car): self.cars.append(car) print(f"El auto {car.model} ha sido añadido")
def register\_client(self, client): self.client.append(client) print(f"Cliente {client.name} registrado") def remove\_car(self,car): self.cars.remove(car) print(f"El auto {car.model} ha sido eliminado") def remove\_client(self, client): self.client.remove(client) print(f"Cliente {client.name} ha sido eliminado") def show\_available\_cars(self): print("Vehiculos disponibles:") for car in self.cars: if car.is\_available: print(f"{car.brand}, {car.model} color {car.color}, valor: {car.price}")
\#Creando los vehiculosvehicle1 = Car("Audi","A1","Blanco", 60000)Vehicle2 = Car("Audi", "A3", "Negro", 65000)
\#Creando los clientesclient1 = Client("Victor","Moritz", 28)
\#Creando el concesionarioconcessionaire = Concessionaire()
concessionaire.add\_car(vehicle1)concessionaire.add\_car(Vehicle2)concessionaire.register\_client(client1)
\#Mostrar los vehiculosconcessionaire.show\_available\_cars()
\#Realizar compraclient1.purchased\_car(vehicle1)
\#Mostrar los vehiculosconcessionaire.show\_available\_cars()
\#Regresar autoclient1.return\_car(vehicle1)
\#Mostrar los vehiculosconcessionaire.show\_available\_cars()
```js
class Moto:
def __init__(self, marca, modelo):
self.marca = marca
self.modelo = modelo
self.verificacion = True
def store(self):
if self.verificacion:
self.verificacion = False
print(f"La moto {self.marca} del año {self.modelo} ha sido vendida")
else:
print(f"La moto {self.marca} no se ha vendido")
self.verificacion = True
class Client:
def __init__(self, nombre, id):
self.nombre = nombre
self.id = id
self.moto_list = []
def add_moto_to_list(self, moto):
if moto.verificacion:
moto.store()
self.moto_list.append(moto)
else:
print(f"La moto {moto.marca} no está disponible")
def return_moto(self, moto):
if moto in self.moto_list:
moto.store()
self.moto_list.remove(moto)
else:
print(f"La moto {moto.marca} no está en la lista")
class Concesionario:
def __init__(self):
self.motos = []
self.clients = []
def add_moto(self, moto):
self.motos.append(moto)
print(f"La moto {moto.marca} ha sido añadida al inventario")
def register_client(self, client):
self.clients.append(client)
print(f"El usuario {client.nombre} ha sido registrado")
def abrir_list_motos(self):
print("La lista de motos disponibles:")
for moto in self.motos:
if moto.verificacion:
print(f"La moto {moto.marca} es de modelo {moto.modelo}")
# Crear Motos
moto1 = Moto("Pulsar", "2008")
moto2 = Moto("KTM", "2023")
# Crear usuario
user1 = Client("Miguel", "002")
# Crear concesionario
concesionario = Concesionario()
concesionario.add_moto(moto1)
concesionario.add_moto(moto2)
concesionario.register_client(user1)
# Mostrar motos
concesionario.abrir_list_motos()
# Realizar venta
user1.add_moto_to_list(moto1)
# Mostrar motos
concesionario.abrir_list_motos()
# Devolver moto
user1.return_moto(moto1)
# Mostrar motos
concesionario.abrir_list_motos()
```
Para la concesionaria hice estas herencias (tienen que ver con si el auto es eléctrico, a combustible o hibrido):
```js
class Car:
def __init__(self, make, model, year, doors):
self.make = make
self.model = model
self.year = year
self.doors = doors
self.available = True
def __str__(self):
return f"{self.year} {self.make} {self.model} ({self.doors} puertas)"
def sell(self):
self.available = False
def return_car(self):
self.available = True
class ElectricCar(Car):
def __init__(self, make, model, year, doors, battery_range):
super().__init__(make, model, year, doors)
self.battery_range = battery_range
def __str__(self):
return super().__str__() + f" [Eléctrico, Autonomía: {self.battery_range} km]"
class FuelCar(Car):
def __init__(self, make, model, year, doors, fuel_type):
super().__init__(make, model, year, doors)
self.fuel_type = fuel_type
def __str__(self):
return super().__str__() + f" [Combustible, Tipo: {self.fuel_type}]"
class HybridCar(Car):
def __init__(self, make, model, year, doors, battery_range, fuel_type):
super().__init__(make, model, year, doors)
self.battery_range = battery_range
self.fuel_type = fuel_type
def __str__(self):
return super().__str__() + f" [Híbrido, Autonomía: {self.battery_range} km, Tipo: {self.fuel_type}]"
class Client:
def __init__(self, full_name, client_id, nationality):
self.full_name = full_name
self.client_id = client_id
self.nationality = nationality
self.purchased_cars = []
def buy_car(self, car):
if car.available:
car.sell()
self.purchased_cars.append(car)
print(f"{self.full_name} compró el auto: {car}")
else:
print(f"El auto {car} no está disponible.")
def sell_car(self, car):
if car in self.purchased_cars:
car.return_car()
self.purchased_cars.remove(car)
print(f"{self.full_name} vendió el auto: {car}")
else:
print(f"El auto {car} no está en la lista de autos comprados.")
def __str__(self):
return f"{self.full_name} (ID: {self.client_id}, Nacionalidad: {self.nationality})"
class Dealership:
def __init__(self):
self.cars = []
self.clients = []
def add_car(self, car):
self.cars.append(car)
print(f"El auto {car} ha sido agregado al inventario.")
def add_client(self, client):
self.clients.append(client)
print(f"El cliente {client} ha sido registrado.")
def show_available_cars(self):
print("Estos son los autos disponibles: ")
for car in self.cars:
if car.available:
print(car)
def show_clients(self):
print("Clientes registrados: ")
for client in self.clients:
print(client)
# Crear autos
car1 = FuelCar("Toyota", "Corolla", 2022, 4, "Gasolina")
car2 = ElectricCar("Tesla", "Model S", 2021, 4, 600)
car3 = FuelCar("Ford", "Mustang", 2020, 2, "Gasolina")
car4 = HybridCar("Chevrolet", "Volt", 2019, 4, 85, "Gasolina")
car5 = ElectricCar("Nissan", "Leaf", 2018, 4, 150)
# Crear clientes
client1 = Client("Juan Pérez", "JP001", "Uruguay")
client2 = Client("Ana García", "AG002", "Argentina")
client3 = Client("Luis López", "LL003", "Brasil")
client4 = Client("María Martínez", "MM004", "Paraguay")
client5 = Client("Carlos Sánchez", "CS005", "Chile")
# Crear concesionaria
dealership = Dealership()
# Agregar autos a la concesionaria
dealership.add_car(car1)
dealership.add_car(car2)
dealership.add_car(car3)
dealership.add_car(car4)
dealership.add_car(car5)
# Agregar clientes a la concesionaria
dealership.add_client(client1)
dealership.add_client(client2)
dealership.add_client(client3)
dealership.add_client(client4)
dealership.add_client(client5)
# Mostrar autos disponibles
dealership.show_available_cars()
# Compra y venta de autos
client1.buy_car(car1)
client2.buy_car(car2)
client3.buy_car(car3)
client4.buy_car(car4)
client5.buy_car(car5)
# Intentar comprar un auto ya vendido
client1.buy_car(car1)
# Mostrar autos disponibles nuevamente
dealership.show_available_cars()
# Vender autos
client1.sell_car(car1)
client2.sell_car(car2)
# Mostrar autos disponibles nuevamente
dealership.show_available_cars()
```*class* <u>Car</u>: *def* \_\_init\_\_(*self*, *make*, *model*, *year*, *doors*): *self*.make = *make* *self*.model = *model* *self*.year = *year* *self*.doors = *doors* *self*.available = True
*def* \_\_str\_\_(*self*): return *f*"{*self*.year} {*self*.make} {*self*.model} ({*self*.doors} puertas)"
*def* sell(*self*): *self*.available = False
*def* return\_car(*self*): *self*.available = True
*class* <u>ElectricCar</u>(<u>Car</u>): *def* \_\_init\_\_(*self*, *make*, *model*, *year*, *doors*, *battery\_range*): <u>super</u>().\_\_init\_\_(*make*, *model*, *year*, *doors*) *self*.battery\_range = *battery\_range*
*def* \_\_str\_\_(*self*): return <u>super</u>().\_\_str\_\_() + *f*" \[Eléctrico, Autonomía: {*self*.battery\_range} km]"
*class* <u>FuelCar</u>(<u>Car</u>): *def* \_\_init\_\_(*self*, *make*, *model*, *year*, *doors*, *fuel\_type*): <u>super</u>().\_\_init\_\_(*make*, *model*, *year*, *doors*) *self*.fuel\_type = *fuel\_type*
*def* \_\_str\_\_(*self*): return <u>super</u>().\_\_str\_\_() + *f*" \[Combustible, Tipo: {*self*.fuel\_type}]"
*class* <u>HybridCar</u>(<u>Car</u>): *def* \_\_init\_\_(*self*, *make*, *model*, *year*, *doors*, *battery\_range*, *fuel\_type*): <u>super</u>().\_\_init\_\_(*make*, *model*, *year*, *doors*) *self*.battery\_range = *battery\_range* *self*.fuel\_type = *fuel\_type*
*def* \_\_str\_\_(*self*): return <u>super</u>().\_\_str\_\_() + *f*" \[Híbrido, Autonomía: {*self*.battery\_range} km, Tipo: {*self*.fuel\_type}]"
*class* <u>Client</u>: *def* \_\_init\_\_(*self*, *full\_name*, *client\_id*, *nationality*): *self*.full\_name = *full\_name* *self*.client\_id = *client\_id* *self*.nationality = *nationality* *self*.purchased\_cars = \[]
*def* buy\_car(*self*, *car*): if *car*.available: *car*.sell() *self*.purchased\_cars.append(*car*) print(*f*"{*self*.full\_name} compró el auto: {*car*}") else: print(*f*"El auto {*car*} no está disponible.")
*def* sell\_car(*self*, *car*): if *car* in *self*.purchased\_cars: *car*.return\_car() *self*.purchased\_cars.remove(*car*) print(*f*"{*self*.full\_name} vendió el auto: {*car*}") else: print(*f*"El auto {*car*} no está en la lista de autos comprados.")
*def* \_\_str\_\_(*self*): return *f*"{*self*.full\_name} (ID: {*self*.client\_id}, Nacionalidad: {*self*.nationality})"
*class* <u>Dealership</u>: *def* \_\_init\_\_(*self*): *self*.cars = \[] *self*.clients = \[]
*def* add\_car(*self*, *car*): *self*.cars.append(*car*) print(*f*"El auto {*car*} ha sido agregado al inventario.")
*def* add\_client(*self*, *client*): *self*.clients.append(*client*) print(*f*"El cliente {*client*} ha sido registrado.")
*def* show\_available\_cars(*self*): print("Estos son los autos disponibles: ") for car in *self*.cars: if car.available: print(car)
*def* show\_clients(*self*): print("Clientes registrados: ") for client in *self*.clients: print(client)
\# Crear autoscar1 = <u>FuelCar</u>("Toyota", "Corolla", 2022, 4, "Gasolina")car2 = <u>ElectricCar</u>("Tesla", "Model S", 2021, 4, 600)car3 = <u>FuelCar</u>("Ford", "Mustang", 2020, 2, "Gasolina")car4 = <u>HybridCar</u>("Chevrolet", "Volt", 2019, 4, 85, "Gasolina")car5 = <u>ElectricCar</u>("Nissan", "Leaf", 2018, 4, 150)
\# Crear clientesclient1 = <u>Client</u>("Juan Pérez", "JP001", "Uruguay")client2 = <u>Client</u>("Ana García", "AG002", "Argentina")client3 = <u>Client</u>("Luis López", "LL003", "Brasil")client4 = <u>Client</u>("María Martínez", "MM004", "Paraguay")client5 = <u>Client</u>("Carlos Sánchez", "CS005", "Chile")
\# Crear concesionariadealership = <u>Dealership</u>()
\# Agregar autos a la concesionariadealership.add\_car(car1)dealership.add\_car(car2)dealership.add\_car(car3)dealership.add\_car(car4)dealership.add\_car(car5)
\# Agregar clientes a la concesionariadealership.add\_client(client1)dealership.add\_client(client2)dealership.add\_client(client3)dealership.add\_client(client4)dealership.add\_client(client5)
\# Mostrar autos disponiblesdealership.show\_available\_cars()
\# Compra y venta de autosclient1.buy\_car(car1)client2.buy\_car(car2)client3.buy\_car(car3)client4.buy\_car(car4)client5.buy\_car(car5)
\# Intentar comprar un auto ya vendidoclient1.buy\_car(car1)
\# Mostrar autos disponibles nuevamentedealership.show\_available\_cars()
\# Vender autosclient1.sell\_car(car1)client2.sell\_car(car2)
\# Mostrar autos disponibles nuevamentedealership.show\_available\_cars()
. La herencia es un mecanismo que permite a una clase derivada heredar atributos y métodos de una clase base. Esto facilita la reutilización del código y la creación de jerarquías de clases.
### Conceptos Clave de la Herencia
1. **Clase Base (Superclase)**: La clase de la que se heredan atributos y métodos.
2. **Clase Derivada (Subclase)**: La clase que hereda atributos y métodos de la clase base.
3. `super()`: Una función que permite acceder a los métodos y atributos de la clase base desde la clase derivada.
* **Herencia**: Permite que una clase (derivada) herede atributos y métodos de otra clase (base).
* `super()`: Permite llamar a métodos y acceder a atributos de la clase base desde la clase derivada.
* **Herencia Múltiple**: Permite que una clase herede de múltiples clases base, facilitando la combinación de funcionalidades.
Estos conceptos son fundamentales para entender y aplicar la Programación Orientada a Objetos en Python, permitiendo crear jerarquías de clases reutilizables y mantenibles.
```python
class Car:
def __init__(self, model, price):
self.model = model
self.price = price
self.available = True
def buy(self):
if self.available:
self.available = False
print(f"The car {self.model} has been sold")
else:
print(f"The car {self.model} is not available")
def return_car(self):
self.available = True
print(f"The car {self.model} is available again")
class User:
def __init__(self, name, user_id):
self.name = name
self.user_id = user_id
self.purchased_cars = []
def buy_car(self, car):
if car.available:
car.buy()
self.purchased_cars.append(car)
print(f"{self.name} has bought the car {car.model}")
else:
print(f"The car {car.model} is not available")
class CarDealer:
def __init__(self):
self.cars = []
self.users = []
def add_car(self, car):
self.cars.append(car)
print(f"The car {car.model} has been added")
def register_user(self, user):
self.users.append(user)
print(f"The user {user.name} has been registered")
def show_available_cars(self):
print("Available cars:")
for car in self.cars:
if car.available:
print(f"{car.model} - {car.price}")
# Created cars
car1 = Car("Toyota", "100,000")
car2 = Car("Suzuki", "20,000")
car3 = Car("BMW", "20,000")
car4 = Car("Ford", "30,000")
# Created user
user1 = User("Yami", "003")
# Created dealer
dealer = CarDealer()
dealer.add_car(car1)
dealer.add_car(car2)
dealer.add_car(car3)
dealer.add_car(car4)
dealer.register_user(user1)
# Show available cars
dealer.show_available_cars()
# User buys a car
user1.buy_car(car1)
# Show available cars again
dealer.show_available_cars()
```class Car:
def \_\_init\_\_(self, model, price):
self.model = model
self.price = price
self.available = True
def buy(self):
if self.available:
self.available = False
print(f"The car {self.model} has been sold")
else:
print(f"The car {self.model} is not available")
def return\_car(self):
self.available = True
print(f"The car {self.model} is available again")
class User:
def \_\_init\_\_(self, name, user\_id):
self.name = name
self.user\_id = user\_id
self.purchased\_cars = \[]
def buy\_car(self, car):
if car.available:
car.buy()
self.purchased\_cars.append(car)
print(f"{self.name} has bought the car {car.model}")
else:
print(f"The car {car.model} is not available")
class CarDealer:
def \_\_init\_\_(self):
self.cars = \[]
self.users = \[]
def add\_car(self, car):
self.cars.append(car)
print(f"The car {car.model} has been added")
def register\_user(self, user):
self.users.append(user)
print(f"The user {user.name} has been registered")
def show\_available\_cars(self):
print("Available cars:")
for car in self.cars:
if car.available:
print(f"{car.model} - {car.price}")
\# Created cars
car1 = Car("Toyota", "100,000")
car2 = Car("Suzuki", "20,000")
car3 = Car("BMW", "20,000")
car4 = Car("Ford", "30,000")
\# Created user
user1 = User("Yami", "003")
\# Created dealer
dealer = CarDealer()
dealer.add\_car(car1)
dealer.add\_car(car2)
dealer.add\_car(car3)
dealer.add\_car(car4)
dealer.register\_user(user1)
\# Show available cars
dealer.show\_available\_cars()
\# User buys a car
user1.buy\_car(car1)
\# Show available cars again
dealer.show\_available\_cars()
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?