Introducción
es un proyecto práctico simple que permite la práctica de Python en bucles, condiciones, etc. El proyecto es sencillo; Tenemos una máquina de café que tiene diferentes tipos de café que un usuario puede pedir, junto con los ingredientes que se requieren para hacerlos y su precio. Un usuario ordeña una bebida de café, paga en monedas, la máquina calcula el total y si el pago está completo, dispensa el café. Para una mejor comprensión de este proyecto, consulte mi artículo ya publicado sobre la ciencia de datos: Implementación de la máquina de café en Python
En este artículo, construiremos la versión OOP de la cafetera en Python.
¿Qué es OOP?
La programación orientada a objetos es un concepto de programación basado en la creación de clases y objetos. En palabras simples, un Clase es una plantilla o un plan, una categoría amplia definida y Objetos son las estructuras individuales que se crean a partir de estas clases. La clase en OOP define ciertas características que tendrán todos los objetos que provienen de esta clase, estos se llaman el Atributos. Además, la clase también definió ciertas funciones que puede hacer. En la terminología OOP, estos se llaman Métodos.
Supongamos que definimos una clase “gatos”. Esta es una categoría amplia e incluirá todo tipo de gatos como sus objetos: mi gato Figaro, el gato del vecino Simba, etc. Cada gato tendrá algunas características individuales como su nombre, color de los ojos, su raza, etc. Estos serán codificados como sus atributos. Además, también tendrán funciones específicas como poder cazar, dormir, jugar, maullarse, etc. Estos serán codificados como sus métodos.
Lo siguiente es cómo se codifican las clases y los objetos:
class Cat:
def __init__(self, name, eye_color, fur_color, breed, age, length):
self.name = name
self.eye_color = age
self.fur_color = fur_color
self.breed = breed
self.age = age
self.length = length
def hunt(self, animal):
print(f"My cat {self.name} is hunting a {animal}")
my_cat = Cat("Figaro", "blue", "black and white", "Persian", "2", "48")
print(my_cat.name)
neighbour_cat = Cat("Simba", "hazel", "brown", "Siamese", "3", "50")
neighbour_cat.hunt("mouse")Utilizaremos el concepto y la funcionalidad anteriores para construir una versión OOP de una máquina de café.
Proyecto de trabajo
En mi artículo anterior sobre la cafetera, expliqué completamente el funcionamiento del proyecto. Este proyecto será similar en su trabajo, excepto que utilizaremos la programación orientada a objetos para lograr los mismos resultados. En general, tenemos los siguientes pasos:
Definición de clases para nuestra cafetera
El primer paso en este proyecto es definir nuestras clases, una por una, y luego vamos a usar estos planos para definir los objetos necesarios en todo el proyecto.
Definición de la clase “Menuitem”
En primer lugar, definiremos el MenuItem clase, que modelará cada elemento en nuestro menú, y usará los objetos creados a partir de él en la próxima clase que creemos Menu.
class MenuItem:
def __init__(self, name, water, milk, coffee, cost):
self.name = name
self.cost = cost
self.ingredients = {
"water": water,
"milk": milk,
"coffee": coffee
}Supongamos que queremos crear un objeto menuitem de la clase MenuItem. En ese caso, necesitaremos darle los siguientes parámetros: nombre del artículo, la cantidad de agua requerida para hacer este elemento de menú, la cantidad de leche requerida para hacer este elemento de menú, la cantidad de café requerida para hacer este elemento de menú y el costo de este elemento de menú.
Esta clase Meniitem se usará para inicializar objetos más adelante.
Definición de la clase “Menú”
A continuación, definamos una clase Menu Eso contendrá los detalles de cada elemento que se puede pedir. El objeto menu Se puede inicializar con el constructor a continuación, y el atributo de menú de esta clase será una lista de los 3 elementos construidos como objetos de la clase que construimos anteriormente MenuItem. Construiremos 3 objetos a partir de esta clase con sus parámetros definidos. Entonces, por ejemplo, el café con leche requerirá 200 ml de agua, 150 ml de leche y 24 g de café, y el costo será de $ 2.5. Todo esto se modelará dentro del constructor de clases de Menuque se utilizará para inicializar objetos de esta clase. El método __init__ siempre se llama cada vez que creamos un objeto.
class Menu:
def __init__(self):
self.menu = [
MenuItem(name="latte", water=200, milk=150, coffee=24, cost=2.5),
MenuItem(name="espresso", water=50, milk=0, coffee=18, cost=1.5),
MenuItem(name="cappuccino", water=250, milk=50, coffee=24, cost=3),
]
Ahora tenemos los atributos del menú, también definiremos dos métodos en él. Una es devolver los nombres de los elementos del menú disponibles. get_itemsy el segundo método find_drinkes encontrar la bebida que el usuario selecciona a través de la función de entrada.
class Menu:
...
def get_items(self):
options = ""
for item in self.menu:
options += f"{item.name}/"
return options
def find_drink(self, order_name):
for item in self.menu:
if item.name == order_name:
return item
print("Sorry that item is not available.")Creación de un objeto en la clase “Menú”
Para poner esta clase y sus atributos y métodos asociados para usar, primero inicializaremos un objeto menu de la clase Menu. Luego usaremos el método get_items Para mostrar al usuario los elementos que tenemos en nuestro menú.
menu = Menu()
drinks = menu.get_items()
drink_selected = input(f"Select your drink {drinks}: ")
menu.find_drink(drink_selected)Una vez que el usuario haya escrito su bebida, verificaremos si está presente en el objeto de menú utilizando el Menu clase find_drink método. Este método verifica si la entrada del usuario está presente en el menú, devolverá ese elemento, de lo contrario, imprimirá al usuario que la bebida no está disponible.
Entonces, si damos un pedido de un batido de vainilla, el programa simplemente imprimirá que el artículo no está disponible. Cuando la bebida de entrada está presente en nuestro menú definido, el método find_drink devolverá el artículo. Ahora podemos usar este elemento en nuestra codificación por delante.
Definición de la clase de “cafetería”
Nuestro siguiente paso es definir el CoffeeMaker clase. El CoffeeMaker La clase almacenará los recursos especificados de antemano y tendrá 3 métodos que sus objetos se pueden usar:
reportMétodo: Este método permitirá que la administración verifique los recursos en la máquina de café imprimiendo un informe de todos los recursos.is_resources_sufficientMétodo: Este método verificará si los recursos en la máquina de café son suficientes para hacer la bebida deseada. VolveráTrueSi los recursos son suficientes; de lo contrario, el usuario sabe qué recurso es insuficiente.make_coffeeMétodo: El último método se llamará cuando se hayan cumplido los requisitos del programa, y tenemos que preparar el café. Este pedazo de código deducirá los recursos y dispensará el café.
class CoffeeMaker:
def __init__(self):
self.resources = {
"water": 1000,
"milk": 1000,
"coffee": 200,
}
def report(self):
print(f"Water: {self.resources['water']}ml")
print(f"Milk: {self.resources['milk']}ml")
print(f"Coffee: {self.resources['coffee']}g")
def is_resource_sufficient(self, drink):
can_make = True
for item in drink.ingredients:
if drink.ingredients[item] > self.resources[item]:
print(f"Sorry there is not enough {item}.")
can_make = False
return can_make
def make_coffee(self, order):
for item in order.ingredients:
self.resources[item] -= order.ingredients[item]
print(f"Here is your {order.name} ☕️. Enjoy!")
Definición de la clase de “MoneyMachine”
Por último, definamos también la clase MoneyMachine. Esta clase será responsable de la administración del dinero. Procesará monedas para verificar si se realiza el pago y agregará el dinero recibido al banco de dinero.
El MoneyMachine La clase tiene los siguientes métodos:
reportMétodo: este método imprimirá cuánto dinero tenemos en nuestra cuentaprocess_coinsMétodo: Este método procesará el pago en forma de monedas de monedas de monedas, monedas de diez centavos, cuartos y centavos y calculará el total.make_paymentMétodo: Este método se utilizará para verificar si se realiza el pago, está completo o si el usuario ha pagado en exceso; devolverá el cambio.
class MoneyMachine:
CURRENCY = "$"
COIN_VALUES = {
"quarters": 0.25,
"dimes": 0.10,
"nickles": 0.05,
"pennies": 0.01
}
def __init__(self):
self.profit = 0
self.money_received = 0
def report(self):
print(f"Money: {self.CURRENCY}{self.profit}")
def process_coins(self):
"Please insert coins.")
for coin in self.COIN_VALUES:
self.money_received += int(input(f"How many {coin}?: ")) * self.COIN_VALUES[coin]
return self.money_received
def make_payment(self, cost):
self.process_coins()
if self.money_received >= cost:
change = round(self.money_received - cost, 2)
print(f"Here is {self.CURRENCY}{change} in change.")
self.profit += cost
self.money_received = 0
return True
else:
print("Sorry that's not enough money. Money refunded.")
self.money_received = 0
return False
El código final
Ahora que hemos definido nuestras clases, escribiremos el código final que le pedirá al usuario su pedido, verificaremos que los recursos sean suficientes, procesar las monedas y los pagos y dispensar las bebidas cuando se cumplan las condiciones. Todo esto se hará inicializando objetos.
money_machine = MoneyMachine()
coffee_maker = CoffeeMaker()
menu = Menu()
is_on = True
while is_on:
options = menu.get_items()
choice = input(f"What would you like {options}: ")
if choice == 'off':
is_on = False
elif choice == 'report':
coffee_maker.report()
money_machine.report()
else:
drink = menu.find_drink(choice)
if coffee_maker.is_resource_sufficient(drink) and money_machine.make_payment(drink.cost):
coffee_maker.make_coffee(drink)En nuestro código final, hemos creado un bucle de tiempo que se ejecuta continuamente a menos que alguien de la administración lo ordena que se detenga. Hemos hecho esto usando el is_on variable booleana, que cambia a False Cuando los tipos de gestión se “apagan” como entrada en la solicitud de pedido.
Además, al igual que lo hicimos en nuestro proyecto Coffee Machine sin OOP, también hemos agregado la opción de informe que proporciona un informe de todos los recursos en la máquina de café y el dinero en la cuenta
El programa se ejecutará de la siguiente manera: le pedirá al usuario que solicite una bebida mostrando los elementos del menú. Si el artículo seleccionado por el usuario está en la lista, primero verificará si los recursos son suficientes, solicite el pago y verifique si el pago está completo y luego procesará el pedido. Todo esto se ha hecho utilizando conceptos OOP de clases y objetos.
Conclusión
Si bien no hemos explorado completamente las capacidades de OOP en este proyecto, hemos disminuido con éxito nuestras líneas de código al introducir clases y crear objetos de ellas. Cuando se trata de proyectos más complejos con varios objetos diferentes, todos comparten un plan común, la inclusión de conceptos OOP es mucho más útil.
Sin embargo, este proyecto de máquina de café que usa OOP ha sido un tutorial útil para comprender los conceptos básicos de la programación orientada a objetos. Si tiene alguna sugerencia o puede pensar en un flujo alternativo de tareas para este proyecto, no dude en compartir. Hasta entonces, disfruta de tu café! 😀