Objektorientierte Programmierung in Python ShoppingCart

Question

Erstellen Sie eine Klasse namens ShoppingCart.

Erstellen Sie einen Konstruktor, der keine Argumente annimmt und das Gesamtattribut auf Null setzt, und initialisiert ein leeres dict-Attribut namens items.

Erstellen Sie eine Methode add_item, die Argumente item_name, quantity und price benötigt. Diese Methode sollte die Kosten der hinzugefügten Elemente zum aktuellen Wert von total hinzufügen. Es sollte auch einen Eintrag zu den Elementen dict hinzugefügt werden, so dass der Schlüssel der Elementname und der Wert die Menge des Elements ist.

Erstellen Sie eine Methode remove_item, die ähnliche Argumente wie add_item benötigt. Es sollte Artikel entfernen, die dem Warenkorb hinzugefügt wurden und nicht benötigt werden. Diese Methode sollte die Kosten der entfernten Artikel von der aktuellen Summe abziehen und auch die Artikel dict entsprechend aktualisieren.

Wenn die Menge eines zu entfernenden Artikels die aktuelle Menge dieses Artikels im Warenkorb überschreitet, nehmen Sie an, dass alle Einträge dieses Artikels entfernt werden sollen.

Erstellen Sie eine Methodenüberprüfung, die cash_paid akzeptiert und den Wert des Saldos aus der Zahlung zurückgibt. Wenn cash_paid nicht ausreicht, um die Gesamtsumme zu decken, geben Sie "Barzahlung nicht genug" zurück.

Erstellen Sie eine Klasse namens Geschäft, das einen Konstruktor hat, die keine Argumente annimmt und initialisiert eine genannte Attribut Menge bei 100

Stellen Sie sicher, Shop aus ShoppingCart erbt.

In der Shop-Klasse, überschreiben die remove_item Methode, so dass Aufruf remove_item Laden ohne Menge Argumente dekrementiert durch ein

Hier ist meine aktualisierte Code ‚‚‘.

class ShoppingCart(object): 

    def __init__(self): 
    self.total = 0 
    self.items = {} 

    def add_item(self, item_name, quantity, price): 
    self.total = (quantity * price) 
    self.items = {item_name : quantity} 

    def remove_item(self, item_name, quantity, price): 
    self.total -= (quantity * price) 
    if quantity > self.items[item_name]: 
     del self.items 
    self.items[item_name] -= quantity 

    def checkout(self, cash_paid): 
    balance = 0 
    if cash_paid < self.total: 
     return "Cash paid not enough" 
    balance = cash_paid - self.total 
    return balance 


class Shop(ShoppingCart): 

    def __init__(self): 
    ShoppingCart.__init__(self) 
    self.quantity = 100 

    def remove_item(self): 
    self.quantity -=1 


import unittest 

    class ShoppingCartTestCases(unittest.TestCase): 
     def setUp(self): 
      self.cart = ShoppingCart() 
      self.shop = Shop() 

     def test_cart_property_initialization(self): 
      self.assertEqual(self.cart.total, 0, msg='Initial value of total not correct') 
      self.assertIsInstance(self.cart.items, dict, msg='Items is not a dictionary') 

     def test_add_item(self): 
      self.cart.add_item('Mango', 3, 10) 

      self.assertEqual(self.cart.total, 30, msg='Cart total not correct after adding items') 
      self.assertEqual(self.cart.items['Mango'], 3, msg='Quantity of items not correct after adding item') 

     def test_remove_item(self): 
      self.cart.add_item('Mango', 3, 10) 
      self.cart.remove_item('Mango', 2, 10) 

      self.assertEqual(self.cart.total, 10, msg='Cart total not correct after removing item') 
      self.assertEqual(self.cart.items['Mango'], 1, msg='Quantity of items not correct after removing item') 

     def test_checkout_returns_correct_balance(self): 
      self.cart.add_item('Mango', 3, 10) 
      self.cart.add_item('Orange', 16, 10) 

      self.assertEqual(self.cart.checkout(265), 75, msg='Balance of checkout not correct') 
      self.assertEqual(self.cart.checkout(25), 'Cash paid not enough', msg='Balance of checkout not correct') 

     def test_shop_is_instance_of_shopping_cart(self): 
      self.assertTrue(isinstance(self.shop, ShoppingCart), msg='Shop is not a subclass of ShoppingCart') 

     def test_shop_remove_item_method(self): 
      for i in range(15): 
       self.shop.remove_item() 

      self.assertEqual(self.shop.quantity, 85) 

Nach dem Unittest ausgeführt wird, schlägt die test.checkout_returns_correct_balance. Dies ist die Nachricht, die ich habe:

Ich brauche wirklich etwas Hilfe mit diesem.

Answer 1

Das Problem, das Sie in Ihrem Code haben, ist, dass add_itemnicht Artikel zu einer bestehenden Gruppe von Elementen in der Warenkorb legen, setzen Ihren Warenkorb des Inhalt an die neue Sache und macht es vergessen, was es vorher hatte. Sie müssen den vorherigen Inhalt des Einkaufswagens berücksichtigen, sodass mehrere Artikel in separaten Aufrufen an add_item hinzugefügt werden können.

Ihre remove_item ist viel näher zu korrigieren, wenn ich den ganzen items Wörterbuch in löschen, es ist ein wenig übereifrigen denken, wenn alle Elemente des angeforderten Typs entfernt wurden (es soll wohl nur mit del self.items[item_name] einen Schlüssel löschen, und die > sollte wahrscheinlich >=, oder vielleicht == mit > eine Ausnahme auslösen).

Answer 2

versuchen Sie dies:

class ShoppingCart(object): 
    def __init__(self): 
     self.total = 0 
     self.items = {} 

    def add_item(self, item_name, quantity, price): 
     self.total += price*quantity 
     self.items.update({item_name: quantity}) 

    def remove_item(self, item_name, quantity, price): 
     if item_name in self.items: 
      if quantity < self.items[item_name] and quantity > 0: 
       self.items[item_name] -= quantity 
       self.total -= price*quantity 


     elif quantity >= self.items[item_name]: 
      self.total -= price*self.items[item_name] 
      del self.items[item_name] 


    def checkout (self, cash_paid): 
     if cash_paid >= self.total: 
      return cash_paid - self.total 
     return "Cash paid not enough" 

class Shop(ShoppingCart): 

    def __init__(self): 
     self.quantity = 100 

    def remove_item(self): 
     self.quantity -=1