Einführung
ist ein einfaches praktisches Projekt, das Python-Übung auf Schleifen, Bedingungen usw. ermöglicht. Das Projekt ist unkompliziert. Wir haben eine Kaffeemaschine mit unterschiedlichen Kaffeetypen, die ein Benutzer zusammen mit den Zutaten bestellen kann, die für die Herstellung erforderlich sind, und deren Preisschild. Ein Benutzer bestellt ein Kaffeetränk, zahlt Münzen aus, die Maschine berechnet die Gesamtsumme, und wenn die Zahlung abgeschlossen ist, gibt es den Kaffee aus. Für ein besseres Verständnis dieses Projekts finden Sie meinen bereits veröffentlichten Artikel in Richtung Knowledge Science: Implementierung der Kaffeemaschine in Python
In diesem Artikel werden wir die OOP -Model der Kaffeemaschine in Python erstellen.
Was ist OOP?
Die objektorientierte Programmierung ist ein Programmierkonzept, das auf dem Erstellen von Klassen und Objekten basiert. In einfachen Worten a Klasse ist eine Vorlage oder eine Blaupause, eine definierte breite Kategorie, und Objekte sind die einzelnen Strukturen, die aus diesen Klassen geschaffen werden. Die Klasse in OOP definiert bestimmte Merkmale, die alle Objekte, die aus dieser Klasse stammen, diese genannt werden Attribute. Darüber hinaus definierte die Klasse auch bestimmte Funktionen, die sie bewirken kann. In der OOP -Terminologie werden diese genannt Methoden.
Angenommen, wir definieren eine Klasse „Katzen“. Dies ist eine breite Kategorie und enthält alle Arten von Katzen als Objekte: meine Katze Figaro, die Katzen -Simba des Nachbarn usw. Jede Katze hat einige individuelle Eigenschaften wie ihren Namen, ihre Augenfarbe, ihre Rasse usw. Diese werden als ihre Attribute codiert. Darüber hinaus werden sie auch spezifische Funktionen haben, wie in der Lage zu sein, zu jagen, zu schlafen, zu spielen, Miau usw. zu sein. Diese werden als ihre Methoden codiert.
Im Folgenden werden Klassen und Objekte codiert:
class Cat:
def __init__(self, identify, eye_color, fur_color, breed, age, size):
self.identify = identify
self.eye_color = age
self.fur_color = fur_color
self.breed = breed
self.age = age
self.size = size
def hunt(self, animal):
print(f"My cat {self.identify} is searching a {animal}")
my_cat = Cat("Figaro", "blue", "black and white", "Persian", "2", "48")
print(my_cat.identify)
neighbour_cat = Cat("Simba", "hazel", "brown", "Siamese", "3", "50")
neighbour_cat.hunt("mouse")
Wir werden das obige Konzept und die obige Funktionalität verwenden, um eine OOP -Model einer Kaffeemaschine zu erstellen.
Projektarbeit
In meinem vorherigen Artikel über die Kaffeemaschine habe ich die Arbeit des Projekts gründlich erklärt. Dieses Projekt wird in seiner Arbeit ähnlich sein, außer dass wir objektorientierte Programmierungen verwenden, um die gleichen Ergebnisse zu erzielen. Insgesamt haben wir die folgenden Schritte:
Definieren von Kursen für unsere Kaffeemaschine
Der erste Schritt in diesem Projekt besteht darin, unsere Klassen nacheinander zu definieren, und dann werden wir diese Blaupausen verwenden, um Objekte zu definieren, die während des gesamten Projekts benötigt werden.
Definition der „Menuitem“ -Klasse
Erstens werden wir die definieren MenuItem Klasse, das jedes Aspect in unserem Menü modelliert und die daraus erstellten Objekte in der nächsten Klasse verwendet, die wir erstellen werden Menu.
class MenuItem:
def __init__(self, identify, water, milk, espresso, value):
self.identify = identify
self.value = value
self.elements = {
"water": water,
"milk": milk,
"espresso": espresso
}Angenommen, wir wollen ein Objekt erstellen menuitem der Klasse MenuItem. In diesem Fall müssen wir ihm die folgenden Parameter geben: Identify des Artikels, die Menge an Wasser, die für die Herstellung dieses Menüpunkts erforderlich ist, die Menge an Milch, die für die Herstellung dieses Menüpunkts erforderlich ist, die Menge an Kaffee, die für die Herstellung dieses Menüpunkts erforderlich ist, und die Kosten für diesen Menüpunkt.
Diese MeniItem -Klasse wird verwendet, um Objekte später zu initialisieren.
Definieren Sie die „Menü“ -Klasse
Lassen Sie uns als nächstes eine Klasse definieren Menu Dies enthält die Particulars jedes Parts, die bestellt werden können. Das Objekt menu kann mit dem folgenden Konstruktor initialisiert werden, und das Menüattribut dieser Klasse ist eine Liste der 3 als Objekte aus der von uns konstruierten Klasse konstruierten Elemente MenuItem. Wir werden 3 Objekte aus dieser Klasse mit ihren definierten Parametern konstruieren. Zum Beispiel benötigt der Objekt Latte 200 ml Wasser, 150 ml Milch und 24 g Kaffee, und die Kosten betragen 2,5 USD. All dies wird im Klassenkonstruktor von modelliert Menumit der Objekte dieser Klasse initialisiert werden. Die __init__ -Methode wird immer aufgerufen, wenn wir ein Objekt erstellen.
class Menu:
def __init__(self):
self.menu = (
MenuItem(identify="latte", water=200, milk=150, espresso=24, value=2.5),
MenuItem(identify="espresso", water=50, milk=0, espresso=18, value=1.5),
MenuItem(identify="cappuccino", water=250, milk=50, espresso=24, value=3),
)
Jetzt haben wir die Menüattribute, wir werden auch zwei Methoden darin definieren. Eine davon ist, die Namen der verfügbaren Menüelemente zurückzugeben get_itemsund die zweite Methode find_drinksoll das Getränk finden, das der Benutzer durch die Eingabefunktion auswählt.
class Menu:
...
def get_items(self):
choices = ""
for merchandise in self.menu:
choices += f"{merchandise.identify}/"
return choices
def find_drink(self, order_name):
for merchandise in self.menu:
if merchandise.identify == order_name:
return merchandise
print("Sorry that merchandise just isn't out there.")Erstellen eines Objekts aus der Klasse „Menü“
Um diese Klasse und ihre zugehörigen Attribute und Methoden zu verwenden, werden wir zunächst ein Objekt initialisieren menu der Klasse Menu. Wir werden dann die Methode verwenden get_items Um dem Benutzer die Elemente anzuzeigen, die wir in unserem Menü haben.
menu = Menu()
drinks = menu.get_items()
drink_selected = enter(f"Choose your drink {drinks}: ")
menu.find_drink(drink_selected)Sobald der Benutzer sein Getränk eingegeben hat, prüfen wir, ob es im Menüobjekt mit dem vorhanden ist Menu Klasse find_drink Verfahren. Diese Methode prüft, ob die Benutzereingabe im Menü vorhanden ist, sie wird dieses Aspect zurückgegeben. Andernfalls wird er an den Benutzer ausgedruckt, dass das Getränk nicht verfügbar ist.
Wenn wir additionally eine Bestellung eines Vanille -Shake geben, druckt das Programm einfach aus, dass der Artikel nicht verfügbar ist. Wenn das Eingabetränk in unserem definierten Menü vorhanden ist, ist die Methode find_drink Gibt den Artikel zurück. Jetzt können wir diesen Aspect in unserer Codierung im Voraus verwenden.
Definieren der Kaffeemaschinenklasse
Unser nächster Schritt ist, die zu definieren CoffeeMaker Klasse. Der CoffeeMaker Die Klasse speichert die zuvor angegebenen Ressourcen und verfügt über 3 Methoden, die ihre Objekte verwendet werden können:
reportMethode: Diese Methode ermöglicht es dem Administration, die Ressourcen in der Kaffeemaschine durch Drucken eines Berichts über alle Ressourcen zu überprüfen.is_resources_sufficientMethode: Diese Methode prüft, ob die Ressourcen in der Kaffeemaschine ausreichen, um das gewünschte Getränk herzustellen. Es wird zurückkehrenTrueWenn Ressourcen ausreichen; Andernfalls wird der Benutzer wissen, welche Ressource nicht ausreicht.make_coffeeMethode: Die letzte Methode wird aufgerufen, wenn die Anforderungen des Programms erfüllt wurden, und wir müssen den Kaffee herstellen. Dieser Code wird die Ressourcen abziehen und Kaffee abgeben.
class CoffeeMaker:
def __init__(self):
self.assets = {
"water": 1000,
"milk": 1000,
"espresso": 200,
}
def report(self):
print(f"Water: {self.assets('water')}ml")
print(f"Milk: {self.assets('milk')}ml")
print(f"Espresso: {self.assets('espresso')}g")
def is_resource_sufficient(self, drink):
can_make = True
for merchandise in drink.elements:
if drink.elements(merchandise) > self.assets(merchandise):
print(f"Sorry there's not sufficient {merchandise}.")
can_make = False
return can_make
def make_coffee(self, order):
for merchandise so as.elements:
self.assets(merchandise) -= order.elements(merchandise)
print(f"Right here is your {order.identify} ☕️. Take pleasure in!")
Definieren der Klasse „MoneyMachine“
Lassen Sie uns schließlich auch die Klasse definieren MoneyMachine. Diese Klasse wird für das Geldmanagement verantwortlich sein. Es wird Münzen verarbeitet, um zu prüfen, ob die Zahlung erfolgt, und das Geld zur Geldbank hinzuzufügen.
Der MoneyMachine Die Klasse hat die folgenden Methoden:
reportMethode: Diese Methode druckt, wie viel Geld wir auf unserem Konto habenprocess_coinsMethode: Diese Methode verarbeitet die Zahlung in Type von Münzen von Nickern, Dimes, Quartieren und Pennies und berechnet die Gesamtsumme.make_paymentMethode: Diese Methode wird verwendet, um zu prüfen, ob die Zahlung erfolgt, ist abgeschlossen oder ob der Benutzer überbezahlt hat. Es wird die Änderung zurückgeben.
class MoneyMachine:
CURRENCY = "$"
COIN_VALUES = {
"quarters": 0.25,
"dimes": 0.10,
"nickles": 0.05,
"pennies": 0.01
}
def __init__(self):
self.revenue = 0
self.money_received = 0
def report(self):
print(f"Cash: {self.CURRENCY}{self.revenue}")
def process_coins(self):
"Please insert cash.")
for coin in self.COIN_VALUES:
self.money_received += int(enter(f"What number of {coin}?: ")) * self.COIN_VALUES(coin)
return self.money_received
def make_payment(self, value):
self.process_coins()
if self.money_received >= value:
change = spherical(self.money_received - value, 2)
print(f"Right here is {self.CURRENCY}{change} in change.")
self.revenue += value
self.money_received = 0
return True
else:
print("Sorry that is not sufficient cash. Cash refunded.")
self.money_received = 0
return False
Der endgültige Code
Nachdem wir unsere Klassen definiert haben, werden wir den endgültigen Code schreiben, der den Benutzer nach seiner Bestellung auffordert, überprüft, ob die Ressourcen ausreichen, die Münzen und Zahlungen verarbeiten und die Getränke ausgeben, wenn die Bedingungen erfüllt sind. All dies erfolgt durch Initialisierung von Objekten.
money_machine = MoneyMachine()
coffee_maker = CoffeeMaker()
menu = Menu()
is_on = True
whereas is_on:
choices = menu.get_items()
selection = enter(f"What would you want {choices}: ")
if selection == 'off':
is_on = False
elif selection == 'report':
coffee_maker.report()
money_machine.report()
else:
drink = menu.find_drink(selection)
if coffee_maker.is_resource_sufficient(drink) and money_machine.make_payment(drink.value):
coffee_maker.make_coffee(drink)In unserem endgültigen Code haben wir eine Weile geschaffen, die kontinuierlich ausgeführt wird, es sei denn, jemand von Administration befiehlt es, um zu stoppen. Wir haben dies mit dem getan is_on boolesche Variable, die sich ändert zu False Wenn die Verwaltung als Eingabe für die Auftragsaufforderung „ausgeht“.
Darüber hinaus haben wir wie in unserem Kaffeemaschineprojekt ohne OOP auch die Berichtsoption hinzugefügt, die den Bericht über alle Ressourcen in der Kaffeemaschine und das Geld auf dem Konto erstellt
Das Programm wird wie folgt ausgeführt: Es fordert den Benutzer auf, ein Getränk zu bestellen, indem die Menüelemente angezeigt werden. Wenn sich der vom Benutzer ausgewählte Artikel in der Liste befindet, prüft er zunächst, ob die Ressourcen ausreichen, und fragen Sie nach der Zahlung und prüfen Sie, ob die Zahlung abgeschlossen ist, und bearbeiten Sie dann die Bestellung. All dies wurde mit OOP -Konzepten von Klassen und Objekten durchgeführt.
Abschluss
Obwohl wir die Funktionen von OOP in diesem Projekt nicht vollständig untersucht haben, haben wir unsere Codezeilen erfolgreich verringert, indem wir Klassen einführen und Objekte daraus erstellen. Wenn es um komplexere Projekte mit einer Reihe verschiedener Objekte geht, die alle eine gemeinsame Blaupause teilen, ist die Einbeziehung von OOP -Konzepten wesentlich praktischer.
Trotzdem struggle dieses Kaffeemaschineprojekt mit OOP ein nützliches Tutorial, um die Grundlagen der objektorientierten Programmierung zu erfassen. Wenn Sie Vorschläge haben oder sich einen alternativen Aufgabenfluss für dieses Projekt vorstellen können, können Sie gerne teilen. Bis dahin genießen Sie Ihren Kaffee! 😀
