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
Biblioteca estándar en Python (CLASE NUEVA)
Librería Os, Math y Random (CLASE NUEVA)
Librería Statistics y Análisis Estadístico (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
You don't have access to this class
Keep learning! Join and start boosting your career
If you already have an account,
Resources
How to create classes and inheritance in object-oriented programming?
Object-oriented programming allows us to model real-world situations through classes and objects. In this exercise, we will learn how to create a basic structure of classes that represent different types of vehicles, including cars, bicycles and trucks. In addition, we will add additional classes to simulate a dealership and its customers, taking advantage of inheritance to encourage reuse and simplicity in the code.
How to define a class and apply inheritance?
We start with the creation of a Vehicle class that will serve as a superclass for our other classes. This class defines the fundamental parameters that all vehicles share in common.
class Vehicle: def __init__(self, brand, model, price): self.brand = brand self.model = model self.price = price self.available = True
def start(self): pass # Specific implementation in child classes
def stop(self): pass # Specific implementation in child classesCreating subclasses: Bicycle and Truck
Our Vehicle class can be expanded by inheritance. Next, we create the classes Bicycle and Truck that inherit from Vehicle, adapting the functions of the superclass to their specific use.
class Bicycle(Vehicle): def start(self): print(f "The bicycle {self.brand} is running")
def stop(self): print(f "The bicycle {self.brand} has stopped")
class Truck(Vehicle): def start(self): print(f "The truck {self.brand}engine is running")
def stop(self): print(f "The truck {self.brand}engine has stopped")How to manage customers and dealers in an OOP system?
The Buyer and Dealership classes will allow interaction between vehicles and customers within the context of a store.
Buyer class implementation
This class does not inherit from any other class, but integrates the functionality to buy and consult available vehicles.
class Buyer: def __init__(self, name): self.name = name self.collection_vehicles = []
def buy_vehicle(self, vehicle): if vehicle.available: self.collection_vehicles.append(vehicle) vehicle.available = False print(f"{vehicle.make} has been added to {self.name}' s collection ") else: print(f "Sorry, the {vehicle.make} is unavailable")Dealer class development
The Dealership will manage the vehicle inventory and customer registration, allowing the addition and display of inventory.
class Dealership: def __init__(self): self.inventory = []self.customers = []
def add_vehicle(self, vehicle): self.inventory.append(vehicle) print(f"{vehicle.make} has been added to inventory")
def register_customer(self, customer): self.customers.append(customer) print(f"{customer.name} has been registered as a customer")
def show_vehicles_available(self): print("Vehicles available in the store:") for vehicle in self.inventory: if vehicle.available: print(f "Brand: {vehicle.brand}, Price: {vehicle.price}")
Final Motivation
This basic system reflects how the object-oriented paradigm can be applied to represent complex situations and relationships efficiently. With this knowledge of classes and inheritance, you are equipped to create more detailed and realistic systems. Keep exploring and developing your programming skills!
Contributions 49
Questions 4
Sort by:
Carli podrías por favorsito aclarar cuando usas algún elemento del código como buena practica, cosas como el uso del return, y get para llamar variables o consultar en lugar de llamar a los parámetros directamente, estas buenas practicas que escribes en automático me generan confusión y retrasan el proceso de aprendizaje en consultas a gtp. Me gustaría poder enfocar mas el tiempo en pensar en flujos y no en sintaxis :C. seria genial si nos dejas mensajitos aclaratorios :D
Personalmente, desde que empezamos con POO han surgido varias cosas que no me han quedado muy claras, por ejemplo: enviar como parámetro una instancia de una clase, el uso de 'raise NotImplementedError' que justamente se vé en esta clase. Sé que es difícil profundizar en todo lo que conlleva un tema y debemos consultar por nosotros mismos, pero creo que si hace falta un poco más de explicaciones y profundizar.
Esta es solo mi opinión pero quisiera saber si no soy el único que piensa lo mismo...
En la clase pasada tuvo un error de identación que no aclaró en esta sesión ya que creó la clase car dentro de la clase vehicle y en esta nueva clase ya aparece corregido. Si depronto alguien se atasca con eso, sólo es correr esa clase un tab hacia atrás.
El curso venía bien estructurado y me estaba gustando, desde que entramos a POO sinceramente todo se desorganizó, no explica bien los conceptos, ni por qué los hace, se supone que es un curso para principiantes y me frustro mucho cuando no entiendo ni el por qué realizan ciertas cosas, no me explican la estructura ni la lógica.
no entendi si estamos e un concesionario que tiene que ver que este en marcha, hace confuso el ejemplo
Si quieres agregar nuevos atributos a las clases hijas, puedes usar la función reservada "**super()**" así:
.
```python
class BaseClass:
def __init__(self, base_attr):
self.base_attr = base_attr
class DerivedClass(BaseClass):
def __init__(self, base_attr, derived_attr):
super().__init__(base_attr)
self.derived_attr = derived_attr
```
## Apunte sobre la Herencia en el Código 😊
**¿Qué es la Herencia?**
La herencia es como una receta familiar 👨🍳. La clase padre (`Vehiculo`) tiene los ingredientes básicos 🧂 y las instrucciones generales 📝. Las subclases (`Car` y `Motorcycle`) heredan esos elementos, pero también pueden agregar sus propios toques especiales ✨ ¡y hasta crear nuevas recetas a partir de la original!
**¿Cómo funciona en este código?**
1. **Clase Padre** `Vehiculo`**:**
* Define los ingredientes básicos 🧂 (atributos) como `marca`, `modelo`, `color`, `precio`, `esta_disponible`.
* Incluye instrucciones generales 📝 (métodos) como `vender`, `disponibilidad`, `get_precio`.
* Tiene instrucciones "pendientes" 🚧 (`NotImplementedError` en `start_engine` y `stop_engine`) que las subclases deben completar.
2. **Subclases** `Car` **y** `Motorcycle`**:**
* Heredan la receta base de `Vehiculo` 📖
* Usan `super().__init__(...)` para preparar los ingredientes básicos heredados 🧂
* Añaden sus propios ingredientes especiales ✨ (`num_puertas` para `Car` y `cilindrada` para `Motorcycle`)
* Completan las instrucciones pendientes 🚧, cada una a su manera (`start_engine` y `stop_engine`)
* Tienen sus propias instrucciones exclusivas 🤫 (`get_num_puertas` para `Car` y `get_cilindrada` para `Motorcycle`)
**Palabras Clave especiales:**
* `NotImplementedError` 🚧: Es como un recordatorio 📝 para las subclases: "¡Oye, no olvides completar esta instrucción!"
* `return` : Es como devolver un regalo 🎁 al final de una función. ¡Útil para obtener información de un objeto!
* `get_algo` 🔍: Es una forma educada de pedirle a un objeto que te muestre algo específico. ¡Como preguntar "¿Cuál es tu número de puertas?" a un auto! 🚗
```python
# Va ser la clase padre
class Vehiculo:
def __init__(self, marca, modelo, color, precio):
"""
Constructor de la clase Vehiculo. Inicializa un nuevo vehículo con los atributos proporcionados.
"""
self.marca = marca
self.modelo = modelo
self.color = color
self.precio = precio
self.esta_disponible = True # Indica si el vehículo está disponible para la venta
def vender(self):
"""
Marca el vehículo como vendido si está disponible.
"""
if self.esta_disponible:
self.esta_disponible = False
print(f"El vehículo {self.marca} {self.modelo} ha sido vendido")
else:
print(f"El vehículo {self.marca} {self.modelo} no está disponible")
def disponibilidad(self):
"""
Devuelve True si el vehículo está disponible, False de lo contrario
"""
return self.esta_disponible
def get_precio(self):
"""
Devuelve el precio del vehículo
"""
return self.precio
def start_engine(self):
"""
Método abstracto para encender el motor. Debe ser implementado por las subclases
"""
raise NotImplementedError("Subclases deben implementar este método")
def stop_engine(self):
"""
Método abstracto para apagar el motor. Debe ser implementado por las subclases
"""
raise NotImplementedError("Subclases deben implementar este método")
"""
Subclase: Auto
"""
class Car(Vehiculo):
def __init__(self, marca, modelo, color, precio, num_puertas):
"""
Constructor de la clase Car. Hereda de la clase Vehiculo y agrega el atributo num_puertas
"""
super().__init__(marca, modelo, color, precio) # Llama al constructor de la clase padre
self.num_puertas = num_puertas
def start_engine(self):
"""
Implementación específica para encender el motor de un auto
"""
print(f"El auto {self.marca} {self.modelo} está en funcionamiento")
def stop_engine(self):
"""
Implementación específica para apagar el motor de un auto
"""
print(f"El auto {self.marca} {self.modelo} se detuvo")
def get_num_puertas(self):
"""
Devuelve el número de puertas del auto
"""
return self.num_puertas
"""
Subclase: Motocicleta
"""
class Motorcycle(Vehiculo):
def __init__(self, marca, modelo, color, precio, cilindrada):
"""
Constructor de la clase Motorcycle. Hereda de la clase Vehiculo y agrega el atributo cilindrada
"""
super().__init__(marca, modelo, color, precio)
self.cilindrada = cilindrada
def start_engine(self):
"""
Implementación específica para encender el motor de una motocicleta
"""
print(f"La motocicleta {self.marca} {self.modelo} está en funcionamiento")
def stop_engine(self):
"""
Implementación específica para apagar el motor de una motocicleta
"""
print(f"La motocicleta {self.marca} {self.modelo} se detuvo")
def get_cilindrada(self):
"""
Devuelve la cilindrada de la motocicleta
"""
return self.cilindrada
# Creacion de objetos
car1 = Car("Toyota", "Camry", "Rojo", 25000, 4)
car2 = Car("Honda", "Civic", "Azul", 22000, 4)
car3 = Car("Ford", "Mustang", "Negro", 35000, 2)
motorcycle1 = Motorcycle("Honda", "CBR", "Negro", 30000, 500)
motorcycle2 = Motorcycle("Honda", "CBR", "Verde", 25000, 500)
# Utilizar metodos
car1.start_engine()
car1.stop_engine()
car1.vender()
motorcycle1.start_engine()
motorcycle1.stop_engine()
motorcycle1.vender()
car1.vender() # Intentar vender de nuevo, pero no estará disponible
car2.esta_disponible = False # Cambiar la disponibilidad manualmente
car2.vender()
motorcycle2.cilindrada = 600 # Modificar la cilindrada
print(motorcycle2.cilindrada) # Imprimir la nueva cilindrada
```# Va ser la clase padre
* **Reutilización de Código:** ¡No hace falta repetir la receta base una y otra vez! ♻️
* **Organización:** ¡Todo está en su lugar, como una cocina bien ordenada! 🗄️
* **Flexibilidad:** ¡Cada subclase puede tener su propio estilo! 🎨
* **Polimorfismo:** ¡Puedes tratar a todos los vehículos por igual, aunque sean diferentes! 🚗🏍️ ¡Es como si todos hablaran el mismo idioma! 🗣️
**Ejemplo de Polimorfismo:**
Pythonvehiculos = \[car1, motorcycle1]
`for vehiculo in` vehiculos:
` vehiculo.start_engine() 🏁 # ¡Cada vehículo se enciende a su manera!`
```python
#Ejercicios
class Vehicle:
def __init__(self,brand,model,price):
self.brand = brand
self.model = model
self.price = price
self.is_available = True
def sell(self):
if self.is_available:
self.is_available = False
print(f"El vehiculo {self.brand}. Ha sido vendido.")
else:
print(f"El vehiculo {self.brand}. No está vendido.")
def check_available(self):
return self.is_available
def get_price(self):
return self.price
def start_engine(self):
raise NotImplementedError("Este método debe ser implementado por la subclase")
def stop_engine(self):
raise NotImplementedError("Este método debe ser implementado por la subclase")
class Car(Vehicle):
def start_engine(self):
if not self.is_available:
return f"El motor del coche {self.brand} está en marcha."
else:
return f"El coche {self.brand} no está disponible."
def stop_engine(self):
if not self.is_available:
return f"El motor del coche {self.brand} se ha detenido."
else:
return f"El coche {self.brand} no está disponible."
class Bike(Vehicle):
def start_engine(self):
if not self.is_available:
return f"La bicicleta {self.brand} está en marcha."
else:
return f"La bicicleta {self.brand} no está disponible."
def stop_engine(self):
if not self.is_available:
return f"La bicicleta {self.brand} se ha detenido."
else:
return f"La bicicleta {self.brand} no está disponible."
class Truck(Vehicle):
def start_engine(self):
if not self.is_available:
return f"El motor del camión {self.brand} está en marcha."
else:
return f"El camión {self.brand} no está disponible."
def stop_engine(self):
if not self.is_available:
return f"El motor del camión {self.brand} se ha detenido."
else:
return f"El camión {self.brand} no está disponible."
class Customer:
def __init__(self,name):
self.name = name
self.purchased_vehicles = []
def buy_vehicle(self, vehicle: Vehicle):
if vehicle.check_available():
vehicle.sell()
self.purchased_vehicles.append(vehicle)
else:
print(f"Lo siento, {vehicle.brand} no está disponible.")
def inquire_vehicle(self, vehicle: Vehicle):
if vehicle.check_available():
availablity = "Disponible"
else:
availablity = "No disponible"
print(f"El {vehicle.brand} está {availablity} y cuesta {vehicle.get_price()}.")
class Dealership:
def __init__(self):
self.inventory = []
self.customers = []
def add_vehicles(self, vehicle: Vehicle):
self.inventory.append(vehicle)
print(f"El {vehicle.brand} ha sido añadido al inventario.")
def register_customers(self, customer: Customer):
self.customers.append(customer)
print(f"El cliente {customer.name} ha sido añadido.")
def show_available_vehicle(self):
print("Vehiculos disponibles en la tienda")
for vehicle in self.inventory:
if vehicle.check_available():
print(f" - {vehicle.brand} por {vehicle.get_price()}.")
```
En video anterior cuando vimos como se declara la clase Bike el codigo nos tiraba un pequeño error justo al declarar:
class Bike(<u>Vehicle</u>):
Se omite como se resuelve y en este video simplemente no está, el error se debe a que la clase Bike se estaba creando dentro de Vehicle y debía estar fuera (Identación)
Platzi tiene un problema muy grande y es que los cursos van estructurados para principiantes pero de un momento a otro pasan a ser para seniors, en este caso desde que entramos a POO todo se desorganizó, no explican bien los conceptos, ni por qué los hace y termina uno pasando a otras plataformas a buscar el conocimiento que se supone que están enseñando en el curso para principiantes.
Carli, que es lo que esta pasando, las dos clase anteriores tus códigos no están funcionando y estas creando mas confusion..
Desde que comenzamos con el tema de POO he tenido dificultades ya que me surgen muchas dudas durante los videos , al principio creí que solo era yo , pero al revisar los comentarios me doy cuenta que varios de mis compañeros tiene problemas similares.
Como mejora en este curso me gustaría que las clases tengan ejemplos ya preparados, así nos podemos enfocar en lo relevante.
Mi percepción fue que la mayor parte del tiempo estuvimos viendo cómo se escribían los métodos de clase, en lugar de centrarnos en lo fundamental, que es ver como distintas clases que heredan de una misma clase padre pueden ser tratadas igual.
En Python, las clases hijas pueden tener su propio constructor, el cual se define mediante el método `__init__`. Al crear una clase hija, puedes llamar al constructor de la clase madre usando `super().__init__()`, permitiendo así inicializar atributos de la clase madre y añadir atributos específicos a la clase hija.
Ejemplo:
```python
class Vehiculo:
def __init__(self, marca):
self.marca = marca
class Bicicleta(Vehiculo):
def __init__(self, marca, tipo):
super().__init__(marca)
self.tipo = tipo
```
En este ejemplo, `Bicicleta` hereda de `Vehiculo` y tiene su propio constructor.
Hola, quisiera saber porqué hubo un cambio de la nomenclatura al referirme a un objeto. En el ejemplo de la biblioteca al referirme al usuario o al libro se escribe:
def add\_book(self, ***book***):
Pero en el ejemplo de la concesionaria , se escribe:
def add\_vehicles(self, ***vehicle: Vehicle***):
def register\_customers(self, ***customer: Customer)***:
Gracias de antemano
las funciones de inicio y apagado no podrian ser heredadas directamente desde la clase padre?
Yo como principiante no he entendido mucho, siento que tiene mucha dificultad para alguien que está empezando, la verdad al principio parece normal, pero se ha saltado a cosas con mucha complejidad" A mi punto de vista", y muchas veces no explica bien.
Ejercicio de herencia
```python
# Clase base o Superclase para vehículos
class Vehicle:
def __init__(self, brand, model, year, max_speed, price):
self.brand = brand # Marca del vehículo
self.model = model # Modelo del vehículo
self.year = year # Año del vehículo
self.max_speed = max_speed # Velocidad máxima del vehículo
self.price = price # Precio del vehículo
self.available = True # Estado de disponibilidad del vehículo, inicialmente disponible
def sell(self): # Método para vender el vehículo
if self.available: # Verifica si el vehículo está disponible
self.available = False # Marca el vehículo como no disponible
print(f"El vehículo {self.brand} {self.model} ha sido vendido")
else:
print(f"El vehículo {self.brand} {self.model} no está disponible")
def check_avaliable(self): # Método para devolver el vehículo
self.available = True # Marca el vehículo como disponible
print(f"El vehículo {self.brand} {self.model} ha sido devuelto")
def get_price(self): # Método para obtener el precio del vehículo
return self.price
def start_engine(self): # Método abstracto para encender el motor (debe ser implementado por las subclases)
raise NotImplementedError("Este método debe ser implementado por la Subclase")
def stop_engine(self): # Método abstracto para apagar el motor (debe ser implementado por las subclases)
raise NotImplementedError("Este método debe ser implementado por la Subclase")
# Subclase para automóviles
class Car(Vehicle):
def start_engine(self):
if not self.available:
return f"El motor del {self.brand} {self.model} está en marcha"
else:
return f"El carro {self.brand} {self.model} no está disponible"
def stop_engine(self):
if self.available:
return f"El motor del {self.brand} {self.model} se ha detenido"
else:
return f"El carro {self.brand} {self.model} no está disponible"
# Subclase para motocicletas
class MotorBike(Vehicle):
def start_engine(self):
if not self.available:
return f"El motor de la {self.brand} {self.model} está en marcha"
else:
return f"La moto {self.brand} {self.model} no está disponible"
def stop_engine(self):
if self.available:
return f"El motor de la {self.brand} {self.model} se ha detenido"
else:
return f"La moto {self.brand} {self.model} no está disponible"
# Subclase para vehículos eléctricos
class Electrics(Vehicle):
def start_engine(self):
if not self.available:
return f"El motor del {self.brand} {self.model} está en marcha"
else:
return f"El vehículo eléctrico {self.brand} {self.model} no está disponible"
def stop_engine(self):
if self.available:
return f"El motor del {self.brand} {self.model} se ha detenido"
else:
return f"El vehículo eléctrico {self.brand} {self.model} no está disponible"
class Customer:
def __init__(self, name, customer_id): # Inicializa al cliente con nombre e ID
self.name = name # Nombre del cliente
self.customer_id = customer_id # ID del cliente
self.puchased=[]
def buy_vehicle(self, vehicle : Vehicle): # Método para que el cliente compre un automóvil
if Vehicle.available: # Verifica si el automóvil está disponible
Vehicle.sell() # Llama al método sell del automóvil para marcarlo como vendido
print(f"{self.name} ha comprado el vehiculo {vehicle.brand} {vehicle.model}") # Mensaje de confirmación
self.puchased.append(vehicle)
else:
print(f"El automóvil {vehicle.brand} {vehicle.model} no está disponible para la compra") # Mensaje si el automóvil no está disponible
def consulta(self, vehicle:Vehicle): # Método para que el cliente devuelva un automóvil
if vehicle.available():
availability = "Disponible"
else:
availability = "No Disponible"
print(f"El automóvil {vehicle.brand} está {availability} y tiene un preci de {vehicle.get_price()}") # Mensaje si el automóvil no está disponible
class Dealership:
def __init__(self): # Inicializa la concesionaria
self.inventory = [] # Lista para almacenar los automóviles en la concesionaria
self.customers = [] # Lista para almacenar los clientes registrados
def add_vehicle(self, vehicle:Vehicle): # Método para agregar un automóvil a la concesionaria
self.inventory.append(vehicle) # Agrega el automóvil a la lista de automóviles
print(f"El vehiculo {vehicle.brand} {vehicle.model} ha sido agregado al catálogo") # Mensaje de confirmación
def register_customer(self, customer:Customer): # Método para registrar un cliente en la concesionaria
self.customers.append(customer) # Agrega el cliente a la lista de clientes
print(f"El cliente {customer.name} ha sido registrado") # Mensaje de confirmación
def show_available_vehicles(self): # Método para mostrar los automóviles disponibles en la concesionaria
print("Vehiculos disponibles:") # Encabezado para la lista de automóviles
for vehicle in self.inventory: # Recorre todos los automóviles en la concesionaria
if vehicle.check_avaliable(): # Verifica si el automóvil está disponible
print(f"{vehicle.brand} {vehicle.model} ({vehicle.year}) - Vel. Max: {vehicle.max_speed} - Precio: ${vehicle.price}") # Muestra la información del automóvil
# Ejemplo de uso
car1 = Car("Koenigsegg", "Jesko Absolut", 2024, "500 K/H", "$3,500,000.00 Dlls") # Crea el primer automóvil
car2 = Car("SSC", "Tuatara", 2024, "474 K/h", "2,800,000.00 Dlls") # Crea el segundo automóvil
car3 = Car("Bugatti", "Tourbillio", 2024, "445 K/H", "$4,200,000.00 Dlls") # Crea el tercer automóvil
car4 = Car("Hennessey", "Venom F5", 2024, "435 K/H", "$3,200,000.00 Dlls") # Crea el cuarto automóvil
car5 = Car("Rimac", "Nevera", 2024, "410 K/H", "$2,700,000.00 Dlls") # Crea el quinto automóvil
motorbike1 = MotorBike("Dodge", "Tomahawk", 2024, "675 K/H", "$700,000.00 Dlls")
motorbike2 = MotorBike("MTT", "Turbine Superbike Y2K", 2024, "365 K/H", "$550,000.00 Dlls")
motorbike3 = MotorBike("Kawasaki", "Ninja H2R", 2024, "355 K/H", "$400,000.00 Dlls")
electric1 = Electrics("Tesla", "Roadster", 2024, "402 K/H", "$2,700,000.00 Dlls")
electric2 = Electrics("Audi", "e-Tron GT", 2024, "322 K/H", "$3,200,000.00 Dlls")
electric3 = Electrics("Lucid", "Sir Dream Edition", 2024, "290 K/H", "$2,000,000.00 Dlls")
print(car1.start_engine())
car1.sell()
car2.sell()
motorbike1.sell()
electric1.sell()
print(car1.start_engine())
print(car1.stop_engine())
```
He notado que para esta clase muchos compañeros se han quejado, creo que en mi opinión lo único que he utilizado de esta clase es la herencia, por lo demás no he agregado mucho al ejercicio del concesionario.
Siento que algo que de pronto podrían mejorar es que sin duda hay cosas que sobran en el código, y tener un código más limpio y coherente es mejor, por ejemplo para que quiero **una función que me diga si el vehículo esta disponible** cuando ya podemos colocar dentro del método "***if vehiculo.esta\_disponible:**".*
Es como crear esa redundancia, quizás en personas que están iniciando no es evidente pero cuando ya haz programado y tienes experiencia en algunos lenguajes simplemente lo notas.
O por ejemplo el simple hecho de crear una función dentro de la clase vehículo llamada **vender (sell)** desde mi punto de vista el vehículo no se vende, ese método o función debería estar en la clase de **concesionario (Dealership)**
```python
# Usamos el ejemplo del consecionario
class Vehiculo:
def __init__(self, marca, tipo, color, precio):
self.marca = marca
self.tipo = tipo
self.color = color
self.precio = precio
self.disponible = True
def get_precio(self):
return self.precio
def disponibilidad(self):
if self.disponible:
print(f"\n El vehiculo {self.marca} esta disponible")
else:
print(f"\n El vehiculo {self.marca} NO esta disponible")
def encender_motor(self):
raise NotImplementedError("Esto se ve en una clase especifica")
def apagar_motor(self):
raise NotImplementedError("Esto se ve en una clase especifica")
class Camion(Vehiculo):
def encender_motor(self):
if not self.disponible:
return f"\n El motor del vehiculo {self.marca} esta encendido"
else:
return f"\n El motor del vehiculo {self.marca} no esta encendido"
def apagar_motor(self):
if self.disponible:
return f"\n El motor del vehiculo {self.marca} esta detenido"
else:
return f"\n El motor del vehiculo {self.marca} no esta disponible"
class Motocicleta(Vehiculo):
def encender_motor(self):
if not self.disponible:
return f"\n La motocicleta {self.marca} esta en marcha"
else:
return f"\n La motocicleta {self.marca} no esta disponible"
def apagar_motor(self):
if self.disponible:
return f"\n La motocicleta {self.marca} esta detenida"
else:
return f"\n La motocicleta {self.marca} no esta disponible"
class Bicicleta(Vehiculo):
def encender_motor(self):
if not self.disponible:
return f"\n La bicicleta {self.marca} esta en marcha"
else:
return f"\n La bicicleta {self.marca} no esta disponible"
def apagar_motor(self):
if self.disponible:
return f"\n La bicicleta {self.marca} esta detenida"
else:
return f"\n La bicicleta {self.marca} no esta disponible"
class Cliente:
def __init__(self, nombre, presupuesto):
self.nombre = nombre
self.coleccion_vechiculos = []
def comprar(self, vehiculo: Vehiculo):
if vehiculo.disponible:
vehiculo.disponible = False
self.coleccion_vechiculos.append(vehiculo)
class Consecionario:
def __init__(self):
self.clientes = []
self.vehiculos = []
def registrar_cliente(self, cliente):
self.clientes.append(cliente)
print(f"\n + El cliente {cliente.nombre} fue creado exitosamente")
def registrar_vehiculo(self, vehiculo):
self.vehiculos.append(vehiculo)
print(f"\n + El vehiculo {vehiculo.marca} de tipo {vehiculo.tipo} fue creado exitosamente")
def vender_vehiculo(self, vehiculo, cliente):
if vehiculo in self.vehiculos:
if vehiculo.disponible == True:
if cliente.presupuesto >= vehiculo.precio:
cliente.comprar(vehiculo)
self.vehiculos.remove(vehiculo)
else:
print(f"\n !!UPS¡¡ tu presupuesto de $ {cliente.presupuesto} NO alcanza para comprar el vehiculo {vehiculo.marca} con un precio de $ {vehiculo.precio}")
else:
print(f"\n El vehiculo {vehiculo.marca} ya no esta disponible")
else:
print(f"\n -> Este vehiculo {vehiculo.marca} ya no se encuentra disponible")
def listar_vehiculos(self):
print("\n --> Lista de vehiculos disponibles en el consecionario: ")
for vehiculo in self.vehiculos:
if vehiculo.disponible == True:
print(f"| Marca: {vehiculo.marca} | Tipo: {vehiculo.tipo} | Color: {vehiculo.color} | Precio: $ {vehiculo.precio} | ")
```
No es muy claro para mí, porque en el método inquire\_vehicle usas en el print:
vehicle.brand para obtener la marca, y despues vehicle.get\_price() para obtener el precio. sin embargo vehicle.price también funciona sin la necesidad del método get
```python
class Product:
def __init__(self, product_id, name, price, quantity):
self.product_id = product_id
self.name = name
self.price = price
self.quantity = quantity
def __str__(self):
return f"Product ID: {self.product_id}, Name: {self.name}, Price: {self.price}, Quantity: {self.quantity}"
class Inventory:
def __init__(self):
self.products = {}
def add_product(self, product):
if product.product_id in self.products:
print(f"Product with ID {product.product_id} already exists. Updating quantity.")
self.products[product.product_id].quantity += product.quantity
else:
self.products[product.product_id] = product
print(f"Product {product.name} added to inventory.")
def remove_product(self, product_id):
if product_id in self.products:
del self.products[product_id]
print(f"Product with ID {product_id} removed.")
else:
print(f"Product with ID {product_id} not found.")
def update_quantity(self, product_id, new_quantity):
if product_id in self.products:
self.products[product_id].quantity = new_quantity
print(f"Quantity of product {product_id} updated to {new_quantity}.")
else:
print(f"Product with ID {product_id} not found.")
def search_product(self, product_id):
if product_id in self.products:
return self.products[product_id]
else:
return None
def display_all_products(self):
if self.products:
print("\nInventory:")
for product in self.products.values():
print(product)
else:
print("Inventory is empty.")
if __name__ == '__main__':
store_inventory = Inventory()
balon = Product(1, "Balon", 10, 50)
cable_usb = Product(2, "Cable_usb", 20, 75)
Luces_led = Product(3, "Luces_led", 33, 30)
ordenador_portatil = Product(4, "Ordenador portátil", 1000.00, 20)
raton_inalambrico = Product(5, "Ratón inalámbrico", 25.00, 50)
teclado_mecanico = Product(6, "Teclado mecánico", 70.00, 30)
monitor_full_hd = Product(7, "Monitor Full HD", 200.00, 15)
impresora_multifuncion = Product(8, "Impresora multifunción", 150.00, 10)
smartphone = Product(9, "Smartphone", 500.00, 25)
auriculares_bluetooth = Product(10, "Auriculares Bluetooth", 40.00, 40)
cargador_portatil = Product(11, "Cargador portátil", 30.00, 60)
camara_seguridad = Product(12, "Cámara de seguridad", 120.00, 20)
disco_duro_externo = Product(13, "Disco duro externo", 80.00, 25)
store_inventory.add_product(balon)
store_inventory.add_product(cable_usb)
store_inventory.add_product(Luces_led)
store_inventory.add_product(ordenador_portatil)
store_inventory.add_product(raton_inalambrico)
store_inventory.add_product(teclado_mecanico)
store_inventory.add_product(monitor_full_hd)
store_inventory.add_product(impresora_multifuncion)
store_inventory.add_product(smartphone)
store_inventory.add_product(auriculares_bluetooth)
store_inventory.add_product(cargador_portatil)
store_inventory.add_product(camara_seguridad)
store_inventory.add_product(disco_duro_externo)
store_inventory.display_all_products()
found_product = store_inventory.search_product(2)
if found_product:
print(f"\nFound product: {found_product}")
else:
print("\nProduct not found.")
# Update quantity
store_inventory.update_quantity(2, 100)
# Remove a product
store_inventory.remove_product(3)
# Display the updated inventory
store_inventory.display_all_products()
while True:
print("\n1. Añadir producto")
print("2. Mostrar productos")
print("3. Buscar producto por ID")
print("4. Buscar producto por nombre")
print("5. Actualizar cantidad")
print("6. Remover producto")
print("7. Salir")
opcion = input("\nSeleccione una opción: ")
if opcion == '1':
nombre = input("Ingrese el nombre del producto: ")
try:
id_producto = int(input("Ingrese el ID del producto: "))
precio = float(input("Ingrese el precio del producto: "))
cantidad = int(input("Ingrese la cantidad del producto: "))
producto = Product(id_producto, nombre, precio, cantidad)
store_inventory.add_product(producto)
except ValueError:
print("Error: Por favor ingrese valores numéricos para ID, precio y cantidad.")
elif opcion == '2':
store_inventory.display_all_products()
elif opcion == '3':
id_producto = int(input("Ingrese el ID del producto a buscar: "))
encontrar_producto = store_inventory.search_product(id_producto)
if encontrar_producto:
print(f"\nEncontrar producto: {encontrar_producto}")
else:
print("\nProducto no encontrado.")
elif opcion == '4':
nombre_producto = input("Ingrese el nombre del producto a buscar: ")
store_inventory.buscar_por_nombre(nombre_producto)
elif opcion == '5':
id_producto = int(input("Ingrese el ID del producto a actualizar: "))
nueva_cantidad = int(input("Ingrese la nueva cantidad: "))
store_inventory.update_quantity(id_producto, nueva_cantidad)
elif opcion == '6':
id_producto = int(input("Ingrese el ID del producto a remover: "))
store_inventory.remove_product(id_producto)
elif opcion == '7':
print("Saliendo del programa...")
break
else:
print("Opción inválida. Intente de nuevo.")
```class Product:
def \_\_init\_\_(*self*, *product\_id*, *name*, *price*, *quantity*): *self*.product\_id = *product\_id* *self*.name = *name* *self*.price = *price* *self*.quantity = *quantity*
def \_\_str\_\_(*self*): return f"Product ID: {*self*.product\_id}, Name: {*self*.name}, Price: {*self*.price}, Quantity: {*self*.quantity}"
class Inventory:
def \_\_init\_\_(*self*): *self*.products = {}
def add\_product(*self*, *product*): if *product*.product\_id in *self*.products: print(f"Product with ID {*product*.product\_id} already exists. Updating quantity.") *self*.products\[*product*.product\_id].quantity += *product*.quantity else: *self*.products\[*product*.product\_id] = *product* print(f"Product {*product*.name} added to inventory.")
def remove\_product(*self*, *product\_id*): if *product\_id* in *self*.products: del *self*.products\[*product\_id*] print(f"Product with ID {*product\_id*} removed.") else: print(f"Product with ID {*product\_id*} not found.")
def update\_quantity(*self*, *product\_id*, *new\_quantity*): if *product\_id* in *self*.products: *self*.products\[*product\_id*].quantity = *new\_quantity* print(f"Quantity of product {*product\_id*} updated to {*new\_quantity*}.") else: print(f"Product with ID {*product\_id*} not found.")
def search\_product(*self*, *product\_id*): if *product\_id* in *self*.products: return *self*.products\[*product\_id*] else: return None
def display\_all\_products(*self*): if *self*.products: print("\nInventory:") for product in *self*.products.values(): print(product) else: print("Inventory is empty.")
if \_\_name\_\_ == '\_\_main\_\_': store\_inventory = Inventory()
balon = Product(1, "Balon", 10, 50) cable\_usb = Product(2, "Cable\_usb", 20, 75) Luces\_led = Product(3, "Luces\_led", 33, 30) ordenador\_portatil = Product(4, "Ordenador portátil", 1000.00, 20) raton\_inalambrico = Product(5, "Ratón inalámbrico", 25.00, 50) teclado\_mecanico = Product(6, "Teclado mecánico", 70.00, 30) monitor\_full\_hd = Product(7, "Monitor Full HD", 200.00, 15) impresora\_multifuncion = Product(8, "Impresora multifunción", 150.00, 10) smartphone = Product(9, "Smartphone", 500.00, 25) auriculares\_bluetooth = Product(10, "Auriculares Bluetooth", 40.00, 40) cargador\_portatil = Product(11, "Cargador portátil", 30.00, 60) camara\_seguridad = Product(12, "Cámara de seguridad", 120.00, 20) disco\_duro\_externo = Product(13, "Disco duro externo", 80.00, 25)
store\_inventory.add\_product(balon) store\_inventory.add\_product(cable\_usb) store\_inventory.add\_product(Luces\_led) store\_inventory.add\_product(ordenador\_portatil) store\_inventory.add\_product(raton\_inalambrico) store\_inventory.add\_product(teclado\_mecanico) store\_inventory.add\_product(monitor\_full\_hd) store\_inventory.add\_product(impresora\_multifuncion) store\_inventory.add\_product(smartphone) store\_inventory.add\_product(auriculares\_bluetooth) store\_inventory.add\_product(cargador\_portatil) store\_inventory.add\_product(camara\_seguridad) store\_inventory.add\_product(disco\_duro\_externo)
store\_inventory.display\_all\_products()
found\_product = store\_inventory.search\_product(2) if found\_product: print(f"\nFound product: {found\_product}") else: print("\nProduct not found.")
*# Update quantity* store\_inventory.update\_quantity(2, 100)
*# Remove a product* store\_inventory.remove\_product(3)
*# Display the updated inventory* store\_inventory.display\_all\_products()
while True: print("\n1. Añadir producto") print("2. Mostrar productos") print("3. Buscar producto por ID") print("4. Buscar producto por nombre") print("5. Actualizar cantidad") print("6. Remover producto") print("7. Salir")
opcion = input("\nSeleccione una opción: ")
if opcion == '1': nombre = input("Ingrese el nombre del producto: ") try: id\_producto = int(input("Ingrese el ID del producto: ")) precio = float(input("Ingrese el precio del producto: ")) cantidad = int(input("Ingrese la cantidad del producto: ")) producto = Product(id\_producto, nombre, precio, cantidad) store\_inventory.add\_product(producto) except ValueError: print("Error: Por favor ingrese valores numéricos para ID, precio y cantidad.")
elif opcion == '2': store\_inventory.display\_all\_products()
elif opcion == '3': id\_producto = int(input("Ingrese el ID del producto a buscar: ")) encontrar\_producto = store\_inventory.search\_product(id\_producto) if encontrar\_producto: print(f"\nEncontrar producto: {encontrar\_producto}") else: print("\nProducto no encontrado.")
elif opcion == '4': nombre\_producto = input("Ingrese el nombre del producto a buscar: ") store\_inventory.buscar\_por\_nombre(nombre\_producto)
elif opcion == '5': id\_producto = int(input("Ingrese el ID del producto a actualizar: ")) nueva\_cantidad = int(input("Ingrese la nueva cantidad: ")) store\_inventory.update\_quantity(id\_producto, nueva\_cantidad)
elif opcion == '6': id\_producto = int(input("Ingrese el ID del producto a remover: ")) store\_inventory.remove\_product(id\_producto)
elif opcion == '7': print("Saliendo del programa...") break
else: print("Opción inválida. Intente de nuevo.")
Consulta las clases hijas a pesar de heredar, no se supone que deberían llevar un constructor como la clase padre??
Pregunta, Para que especificar que es de la clase Vehicle en la función buy\_vehicle ?? Funciona sin necesidad de esa especificacion
No aclarasteis cómo solucionar el error de class car(vehicle
buenas noches , no se alguien vaya a leer este mensaje en algun momento pero considero que de un momento a otro saltamos de ser principiantes a avanzados y la verdad yo estoy empezando en este mundo de la programación y a partir de la clase 23 se me dificulto enteder los conceptos y me quede con cara de what? cuando dijo lo encender motor y apagar motor
En Python, cuando se utiliza `print()` con una cadena que incluye variables u otros valores, la `f` se refiere a una f-string (cadena formateada). Esto permite incluir directamente las variables dentro de la cadena utilizando llaves `{}`. Por ejemplo, `nombre = "Juan"` y `print(f"Hola, {nombre}")` mostrará "Hola, Juan". Sin la `f`, Python no interpretará las variables y solo mostrará el texto literal. Esto es especialmente útil para hacer el código más legible y conciso.
Como aclaraste el nameError: name ‘Vehicle’ is not defined
Nunca explico esto de una forma clara.def comprar\_auto(self, vehiulo:Vehiculo):
Entonces, toco preguntarle a Gemini.
`vehiculo: Vehiculo`**:** Esta parte indica que el método `comprar_auto` espera un argumento llamado `vehiculo`. La anotación `: Vehiculo` (a partir de Python 3.5) sugiere que se espera que este argumento sea una instancia de la clase `Vehiculo`. Esto es una forma de "tipado de datos" que ayuda a hacer el código más legible y a prevenir errores.
Para los que tengan error al momento que ella ejecuta, deben fijarse que estaba mala la identacion y en este video ya estaba corregido, aunque no fue explicado.
Que paso?
Las clases estaban definidas dentro de la clase Vehicle por lo tanto eran clases anidadas, lo cual no es lo que buscamos, queremos que sean subclases independientes que hereden de Vehicle, por lo tanto solo acomoden la identacion al mismo nivel de la clase padre
Al igual que muchos está clase se me hizo un reto por varios conceptos nuevos. Estoy utilizando Github copilot mientras hago el ejercicio: allí simplemente preguntas directamente la línea de código que no entiendes y amplia la explicación de manera estupenda. 
Podemos usar la librería estándar de Python `abc` para convertir los métodos `stop_engine` y `start_engine` en abstractos. Esto permite definirlos solo en las clases hijas, dejando a la clase padre como una plantilla. Aquí tienes un ejemplo:
Para declarar clases en diferentes archivos y usar herencia en Python, sigue estos pasos:
1. **Crea archivos separados** para cada clase. Por ejemplo, `vehiculo.py`, `bicicleta.py`, `camion.py`.
2. En `vehiculo.py`, declara tu clase base:
```python
class Vehiculo:
def __init__(self, marca):
self.marca = marca
```
3. En `bicicleta.py` y `camion.py`, importa la clase base y declara las clases hijas:
```python
from vehiculo import Vehiculo
class Bicicleta(Vehiculo):
pass # Implementa métodos específicos
```
```python
from vehiculo import Vehiculo
class Camion(Vehiculo):
pass # Implementa métodos específicos
```
4. En el archivo principal, importa las clases necesarias y crea instancias:
```python
from bicicleta import Bicicleta
from camion import Camion
mi_bicicleta = Bicicleta("Giant")
mi_camion = Camion("Volvo")
```
Esto te permitirá organizar mejor tu código y utilizar la herencia sin problemas.
Objetos heredados:
Para crear una clase a partir de otra oara que herede sus atributos se hace:
class NombreClaseHijo(NombreClasePadre):
En Python, "static" no es una palabra clave como en otros lenguajes como C++ o Java, donde se usa para definir métodos o variables estáticas. Sin embargo, en el contexto de Python, puedes encontrar el concepto de métodos estáticos a través del decorador `@staticmethod`. Este decorador se utiliza dentro de una clase para definir un método que no requiere acceso a la instancia (`self`) ni a la clase (`cls`). Los métodos estáticos son útiles cuando necesitas una función que esté relacionada con la lógica de la clase, pero que no dependa de sus atributos o métodos.
cuando crea los metodos en la clase Customer y pone los parametros es necesario poner los : ? porque indica que el parametro vehicle es de la clase vehicle pero con los ejemplos de las clase anteriores no era necesario poner eso o en este caso toca ponerlo por que hay subclases ?
Recuerden que existen 4 pilares de la programación (los verán en la próxima clase. Sin embargo, existe: "Herencia y Polimorfismo". *Explicación:* La herencia permite que una clase (subclase) herede atributos y métodos de otra clase (superclase). El polimorfismo permite que objetos de diferentes clases sean tratados como objetos de una misma clase base.
`class Animal:`
` def hablar(self):`
` pass`
`class Perro(Animal):`
` def hablar(self):`
` return "Guau"`
`class Gato(Animal):`
` def hablar(self):`
` return "Miau"`
`perro = Perro()`
`gato = Gato()`
`print(perro.hablar()) # Salida: Guau`
`print(gato.hablar()) # Salida: Miau`
La herencia en programación orientada a objetos permite crear una nueva clase basada en una clase existente. Esto facilita la reutilización de código y la creación de jerarquías, permitiendo que la clase hija herede propiedades y métodos de la clase padre, simplificando el desarrollo y mantenimiento.
Les comparto un pequeño refactor para que quede más claro.```js
class Car(Vehicle):
def __init__(self, brand, model, price, engine: bool) -> None:
super().__init__(brand, model, price)
self.engine = engine
def start_engine(self):
if self.engine:
print(f"Iniciando el motor de carro {self.brand} {self.model}. 🚗")
def stop_engine(self):
if self.engine:
print(f"Deteniendo el motor de carro {self.brand} {self.model}. 💥💥")
class Bike(Vehicle):
def __init__(self, brand, model, price, engine) -> None:
super().__init__(brand, model, price)
self.engine = engine
def start_engine(self):
print(f"Es una cicla peee, dale pedal 🚴♀️🚴♀️")
def stop_engine(self):
print(f"Sin frenoos!!!!. Te juiteeeeeeee ☠️☠️")
```
1. En las subclasess Agregue un nuevo atributo que es de tipo Boleano para poder saber si el vehiculo cuenta con motor o no. `engine: bool.`
2. Al agregar dicho atributo nuevo es necesario hacer cambios en la implementación del constructor de la subclase por esta razón queda: super().\_\_ .... codigo abajo.
3. ```js
def __init__(self, brand, model, price, engine: bool) -> None:
super().__init__(brand, model, price)
self.engine = engine
```Ahora por último en los métodos de start y stop\_engine utilizo el atributo engine en vez de is\_available para no confundir si esta disponible para la compra o no.
Espero les pueda ayudar un poco.
Hola a todos, es necesario crear en la clase padre, métodos que son propios de las clase hijas?
Yo pienso que es innecesario.
Atentamente
Cristian
A todos los que están confundidos o perdidos desde que empezó POO, les recomiendo buscar y aprender los conocimientos básicos como lo son
* Declaración de variables
* Obtener información de entrada del usuario
* Almacenar información
* Repetir una acción haciendo uso de bucles
* Escribir funciones para no repetir fragmentos de código con el mismo funcionamiento
y hacer proyectos como:Par o impar
1. Juego Mad Libs
2. Contador de palabras
3. Información de la biografía
4. ¿Cuál es el acrónimo?
5. Piedra, Papel y tijera
6. Adivina el número
y después si venir a estos temas para entender y no desmotivarse.
En programación orientada a objetos (POO) herencia un concepto clave que permite que una clase (llamada subclase ) herede propiedades y comportamientos (atributos y métodos) de otra clase (llamada superclase o clase base ). Esto permite reutilizar código y extenderlo sin tener que escribirlo desde cero. La herencia permite crear nuevas clases basadas en otras, aprovechando el código ya escrito. Es una manera eficiente de manejar y extender el código, haciendo que sea más organizado y fácil de mantener.
Aqui mi version de anadirles las bicis y camiones antes de ver la clase. No fue dificil porque fue casi un copy paste del ejemplo anterior, pero espero que se parezca:
```js
class Car:
def __init__(self, brand, model, price):
self.brand = brand
self.model = model
self.price = price
self.available = True
def sell(self):
if self.available:
print(f"The {self.brand} {self.model} has been sold!")
self.available = False
else:
print(f'The {self.brand} {self.model} is unavailable. Check for other options')
def is_available(self):
return self.available
def change_availability(self):
self.available = not self.available
class Customer:
def __init__(self, name):
self.name = name
self.cars = []
def buy_car(self, car):
if car.is_available():
car.sell()
self.cars.append(car)
else:
print(f'The {car.brand} {car.model} is unavailable. Check for other options')
def return_car(self, car):
if car in self.cars:
self.cars.remove(car)
car.change_availability()
print(f'Car returned successfully')
else:
print(f'You do not have any cars to return')
# Instancias de Carros
toyota = Car('Toyota', 'Corolla', 20000)
ford = Car('Ford', 'Explorer', 30000)
tesla = Car('Tesla', 'Model S', 70000)
# Instancia de Cliente
cliente = Customer('Calvin')
# Cliente compra un carro
cliente.buy_car(toyota) # Debería marcar el carro como comprado
cliente.buy_car(tesla) # Debería comprar el Tesla
cliente.return_car(tesla)
# Intentar añadir un carro que ya ha sido comprado
# Si está disponible, lo añade; si no, muestra un mensaje
# Clases heredadas
class Sounds(Car):
def start_engine(self):
if self.is_available():
print(f'{self.brand} {self.model} engine started')
else:
print('There is no motor engine to start.')
def stop_engine(self):
if self.is_available():
print(f'{self.brand} {self.model} engine stopped')
else:
print('There is no motor engine to stop')
# Crear una instancia de la clase Sounds
ford_sounds = Sounds('Ford', 'Explorer', 30000)
ford_sounds.start_engine()
ford_sounds.stop_engine()
#Como se puede apreciar, podemos crear clases heredas, al crear una clase, y pasarle otra clase como argumento. Esta clase nueva, heredara todos los datos
# de la clase padre, osea los atributos y metodos. Y para utilizar los nuevos metodos que estan en esa clase nueva, debemos crear un nuevo objeto con esa clase
#nueva, no con la clase padre. De no hacerlo, unicamente tendremos los metodos de la clase padre, y no tendremos acceso a los de la clase hijo.
class Bike(Car):
def rideBike(self):
if self.is_available():
print(f'You are riding a {self.brand} {self.model}, be carefull!')
self.is_available = False
else:
print('You do not have a bike to ride')
def unrideBike(self):
if not self.is_available():
print(f'You have unriden a {self.brand} {self.model}')
self.is_Available == True
else:
print('You do not have a bike to unride')
cdmx = Bike('cdmx', 'mx', 2000)
cdmx.unrideBike()
class Trucks(Car):
def buyTruck(self):
if self.is_available():
self.sell()
self.is_available == False
else:
print('You cant buy this truck')
def sellTruck(self):
if not self.is_available():
self.is_available == True
print(f'You returned the {self.brand}, {self.model}')
else:
print('You cant sell this truck')
def loadTruck(self, material, maxCapacity):
if self.is_available():
print(f'You have loaded a {self.brand} {self.model} with {material}. His maximum capacity is {maxCapacity}, be aware loading more than that!')
else:
print('You do not have a truck to load')
def unloadTruck(self):
if self.is_available():
print(f'You have unloadded the {self.brand} {self.model}')
else:
print('You do not have a truck to unload')
international = Trucks('International', 'elephant', 200000)
international.buyTruck()
international.loadTruck('dirt', '2000kg')
international.unloadTruck()
international.sellTruck()
```
una pregunta, por que en este y los pasados ejemplos creamos nuevas variables para obtener informacion de los atributos como price y is. available?
id reemplazar.simplificar:def inquire\_vehicle(self, vehicle: Vehicle):
```python
def inquire_vehicle(self, vehicle: Vehicle): #method definition
if vehicle.check_availability(): #checking availability -> calls the check_availability() method on the vehicle object
availability = "Disponible" #assign availability status
else:
availability = "No disponible" #assign availability status
print(f"El {vehicle.brand} está {availability} y cuesta {vehicle.get_price}")
```
por:
```js
def inquire_vehicle(self, vehicle: Vehicle):
print(f"El vehículo está {'Disponible' if vehicle.check_availability() else 'No disponible'}.")
```
print(f"El vehículo está {'Disponible' if vehicle.check\_availability() else 'No disponible'}.")
```python
class Vehicle:#Programación de la clase 26.
def __init__(self,brand,model,price):
self.brand = brand
self.model = model
self.price = price
self.is_avalaible = True
def sell(self):
if self.is_avalaible:
self.is_avalaible = False
print(f"El vehiculo {self.brand} {self.model} ha sido vendido.")
else:
print(f"El vehiculo {self.brand} {self.model} no esta disponible.")
def check_available(self):
return self.is_avalaible
def get_price(self):
return self.price
def start_engine(self):
raise NotImplementedError("Este método debe ser implementado por la subclase")
def stop_engine(self):
raise NotImplementedError("Este método debe ser implementado por la subclase")
#Nombre de clase (Clase Padre)
class Car(Vehicle):
def start_engine(self):
if not self.is_avalaible:
return f"El motor del coche {self.brand} está encendido."
#En el comentario no colocamos car.brand a pesar de ser una clase diferente. Esto es porque estamos heredando.
else:
return f"El coche {self.brand} no esta disponible"
def stop_engine(self):
if self.is_avalaible:
return f"El motor del coche {self.brand} está apagado."
else:
return f"El coche {self.brand} no esta disponible"
class Bike(Vehicle):
def start_engine(self):
if not self.is_avalaible:
return f"La bicicleta {self.brand} está en marcha."
#En el comentario no colocamos car.brand a pesar de ser una clase diferente. Esto es porque estamos heredando.
else:
return f"La bicicleta{self.brand} no esta disponible"
def stop_engine(self):
if self.is_avalaible:
return f"La bicicleta {self.brand} está detenida."
else:
return f"La bicicleta {self.brand} no esta disponible"
class Truck(Vehicle):
def start_engine(self):
if not self.is_avalaible:
return f"El motor del camión {self.brand} está encendido."
#En el comentario no colocamos car.brand a pesar de ser una clase diferente. Esto es porque estamos heredando.
else:
return f"El camión {self.brand} no esta disponible"
def stop_engine(self):
if self.is_avalaible:
return f"El motor del camión {self.brand} está apagado."
else:
return f"El camión {self.brand} no esta disponible"
class Customer:
def __init__(self,name):
self.name = name
self.purchased_vehicles = [] #Colección de autos
def buy(self,vehicle: Vehicle): #El parametro vehicle es de la clase Vehicle
if vehicle.check_available():
vehicle.sell()
self.purchased_vehicles.append(vehicle)
else:
print(f"Lo siento, el vehiculo {vehicle.brand} no esta disponible.")
def inquire_vehicle(self,vehicle: Vehicle): #Consultar la disponibilidad de los vehículos.
if vehicle.check_available():
avaibility = "Disponible"
else:
avaibility = "No disponible"
print(f"El {vehicle.brand} está {avaibility} y cuesta {vehicle.get_price()}")
class DealerShip:
def __init__(self):
self.inventory = []
self.customers = []
def add_vehicle(self,vehicle:Vehicle):
self.inventory.append(vehicle)
print(f"El vehiculo {vehicle.brand} {vehicle.model} ha sido añadido al inventario.")
def register_customer(self,customer:Customer):
self.customers.append(customer)
print(f"El cliente {customer.name} ha sido registrado.")
def show_available_vehicle(self):
print("Vehiculos disponibles:")
for vehicle in self.inventory:
if vehicle.check_available():
print(f" - {vehicle.brand} por {vehicle.price}")
```
Tengo una pregunta: Era necesario crear los métodos "check\_available()" y "get\_price()" en la clase "Vehicle"? eran ya atributos de todos los objetos de "Vehicle" y se podían acceder a ellos fácilmente
En clases anteriores se revisaba la disponivilidad a través del atributo del objeto, en esta clase lo obtenemos a partir de un metodo.
Me gustaria saber ¿cual es la diferencia? y en que casos es preferible usar una u otra
Hi there.
Estuve viendo la clase y noté que hay muchos comentarios respecto a la manera en que la profe ha llevado las clases. Es cierto que, de pronto, se le escapa uno que otro método o función por explicar, pero no está de más decir que ella nos está brindando las herramientas; depende de nosotros aprovecharlas y aprender. Es decir, no podemos limitarnos solo a ver y copiar código. Tenemos que ir más allá: leer documentación, entender cómo funciona cada cosa, qué se está haciendo.
Si no entiendes un método, una variable o una función, busca ayuda: puede ser una persona que sepa del tema o incluso una inteligencia artificial enfocada en código que te explique lo que hace. Luego de entenderlo, lo ideal es practicar y escribir código con eso. De eso se trata aprender: entender algo y practicarlo hasta dominarlo.
También vi que se comentó acerca del método creado en la clase padre, donde se usa un `raise`. `Raise` es básicamente una forma más simplificada y óptima de manejar errores, similar al `try-except`. En ese caso, lo que hace es crear una especie de método abstracto, es decir, un método que **debe** ser implementado por las clases hijas. De lo contrario, lanzará un error mediante `raise`.
* **Coche NO DISPONIBLE (vendido o no en inventario)** → El motor puede estar encendido, porque ya no está esperando ser vendido, está "en uso" de alguna manera.
* **Coche DISPONIBLE** → El motor debe estar apagado, porque está en el inventario esperando ser vendido y no debería estar en funcionamiento.
```js
from random import *
class Vehiculo:
def __init__(self, marca, color):
self.marca = marca
self.color = color
def __str__(self,):
return f"Marca {self.marca}, Color {self.color} "
class Carro(Vehiculo):
def __init__(self, marca, color, n_puertas, velocidad_max, cilindrada):
super().__init__(marca, color)
self.n_puertas = n_puertas
self.velocidad_max = velocidad_max
self.cilindrada = cilindrada
def __str__(self):
return super().__str__() + f"{self.n_puertas} Puertas, {self.velocidad_max}Km/h, {self.cilindrada}Cc"
class Camioneta(Carro):
def __init__(self, marca, color, n_puertas, velocidad_max, cilindrada, carga):
super().__init__(marca, color, n_puertas, velocidad_max, cilindrada)
self.carga = carga
def __str__(self):
return super().__str__() + f", {self.carga}Kg"
class Bicileta(Vehiculo):
def __init__(self, marca, color, tipo):
super().__init__(marca, color)
self.tipo = tipo
def __str__(self):
return super().__str__() + f"{self.tipo}"
class Motocileta(Bicileta):
def __init__(self, marca, color, tipo, velocidad, cilindrada):
super().__init__(marca, color, tipo)
self.velocidad = velocidad
self.cilindrada = cilindrada
def __str__(self):
return super().__str__() + f"{self.velocidad}Km/h , {self.cilindrada}Cc"
class Clientes:
def __init__(self, nombre, apellido, cedula):
self.nombre = nombre
self.apellido = apellido
self.cedula = cedula
self.base_datos_clientes = []
def cupo_cliente(self):
print("Si el cliente cumple con el cupo minimo permitido por la empresa sera registrado en la base de datos")
self.cupo = randint(0, 20000000)
if self.cupo < 500000 :
print(f"El cliente {self.nombre} {self.apellido} cuenta con un cupo de ${self.cupo}, por lo cual no es habilitado para la compra")
elif self.cupo >= 500000:
print(f"El cliente {self.nombre} {self.apellido} cuenta con un cupo de ${self.cupo}, se encuentra habilitado para realiza la compra")
self.base_datos_clientes.append(self.cedula)
print(f"El cliente {self.nombre} con la cedula {self.cedula} ha sido registrado en la base de datos")
def ver_clientes(self):
for cliente in self.base_datos_clientes:
print(f"{cliente}")
class Concesionario:
def __init__(self, nombre):
self.nombre = nombre
self.base_datos_vehiculos = []
self.base_datos_compras = []
def registrar_vehiculo(self, vehiculo):
self.base_datos_vehiculos.append(vehiculo)
print(f"El Vehiculo {vehiculo.marca}/{vehiculo.color} ha sido registrado en la base de datos de la empresa")
def ver_vehiculos(self):
for vehiculo in self.base_datos_vehiculos:
print(f"{type(vehiculo).__name__} ---> {vehiculo}")
def venta_vehiculo(self, vehiculo, cliente):
if vehiculo in self.base_datos_vehiculos:
self.base_datos_vehiculos.remove(vehiculo)
self.base_datos_compras.append(cliente.cedula)
print(f"El vehiculo {type(vehiculo).__name__} ---> {vehiculo} ha sido comprado por {cliente.cedula}")
else:
print(f"El vehiculo {type(vehiculo).__name__} ---> {vehiculo} no se encuentra disponible en la tienda")
# Creacion de Carros
carro_1 = Carro("Toyota", "Negro", 4, 130, 1250)
carro_2 = Carro("Mazda", "Verde", 2, 120, 1200)
carro_3 = Carro("Renault", "Amarillo", 4, 140, 1500)
# Creacion de Camionetas
camioneta_1 = Camioneta("Chrevrolet Tracker", "Violeta", 2, 120, 1700, 200)
camioneta_2 = Camioneta("Ford EcoSport", "Vinitinto", 4, 130, 1800, 250)
camioneta_3 = Camioneta("Toyota Prado", "Violeta", 2, 120, 1600, 150)
# Creacion de Bicicletas
bicicleta_1 = Bicileta("Orbea Orca", "MultiColor", "Urbana")
bicicleta_2 = Bicileta("Giant TCR", "Rojo", "Deportiva")
bicicleta_3 = Bicileta("GW", "Azul", "Urbana")
# Creacion de Motocicletas
moto_1 = Motocileta("Suzuki", "Negro", "Urbana", 130, 125)
moto_2 = Motocileta("Honda", "Blanco", "Deportiva", 250, 200)
moto_3 = Motocileta("AKT", "Rojo", "Urbana", 110, 100)
# Creacion Clientes
cliente_1 = Clientes("Edgar Andres", "Anaya Vejar", 1093787563)
cliente_2 = Clientes("Hindi Yurely", "Lopez Bayona", 1093563878)
cliente_3 = Clientes("Cristian Fabian", "Arias Lopez", 1093563123)
cliente_4 = Clientes("Angie Paola", "Lopez Quintero", 1093123789)
# Validacion del cupo del cliente
print("=" * 100)
cliente_1.cupo_cliente()
print("=" * 100)
cliente_2.cupo_cliente()
print("=" * 100)
cliente_3.cupo_cliente()
print("=" * 100)
cliente_4.cupo_cliente()
print("=" * 100)
# Creacion de Concesionario y registro de vehiculos
concesionario = Concesionario("Compra Venta La Chueca")
print("=" * 100)
concesionario.registrar_vehiculo(carro_1)
print("=" * 100)
concesionario.registrar_vehiculo(carro_2)
print("=" * 100)
concesionario.registrar_vehiculo(carro_3)
print("=" * 100)
concesionario.registrar_vehiculo(camioneta_1)
print("=" * 100)
concesionario.registrar_vehiculo(camioneta_2)
print("=" * 100)
concesionario.registrar_vehiculo(camioneta_3)
print("=" * 100)
concesionario.registrar_vehiculo(bicicleta_1)
print("=" * 100)
concesionario.registrar_vehiculo(bicicleta_2)
print("=" * 100)
concesionario.registrar_vehiculo(bicicleta_3)
print("=" * 100)
concesionario.registrar_vehiculo(moto_1)
print("=" * 100)
concesionario.registrar_vehiculo(moto_2)
print("=" * 100)
concesionario.registrar_vehiculo(moto_3)
print("=" * 100)
# Ver Vehiculos para la venta del Concesionario
concesionario.ver_vehiculos()
print("=" * 100)
# Venta de Vehiculos
concesionario.venta_vehiculo(carro_1, cliente_1)
concesionario.venta_vehiculo(carro_2, cliente_1)
concesionario.venta_vehiculo(carro_3, cliente_1)
print("=" * 100)
concesionario.venta_vehiculo(camioneta_1, cliente_2)
concesionario.venta_vehiculo(camioneta_2, cliente_2)
concesionario.venta_vehiculo(camioneta_1, cliente_1)
print("=" * 100)
concesionario.venta_vehiculo(bicicleta_1, cliente_2)
concesionario.venta_vehiculo(bicicleta_2, cliente_2)
concesionario.venta_vehiculo(bicicleta_3, cliente_2)
print("=" * 100)
concesionario.venta_vehiculo(moto_1, cliente_3)
concesionario.venta_vehiculo(moto_2, cliente_3)
concesionario.venta_vehiculo(moto_3, cliente_3)
print("=" * 100)
concesionario.venta_vehiculo(carro_1, cliente_4)
concesionario.venta_vehiculo(camioneta_2, cliente_4)
concesionario.venta_vehiculo(bicicleta_3, cliente_4)
concesionario.venta_vehiculo(moto_1, cliente_4)
```Mi humilde aporte. Saludos..!!!
Want to see more contributions, questions and answers from the community?