Project: A Class-Based Inventory

class Item:
    """One product on the shelves."""

    def __init__(self, name, price, qty=0):
        self.name = name
        self.price = price
        self.qty = qty

    def value(self):
        """Return what this line of stock is worth."""
        return self.price * self.qty

    def restock(self, amount):
        """Add stock. Return the new quantity."""
        self.qty = self.qty + amount
        return self.qty

    def sell(self, amount=1):
        """Sell stock. Return True if there was enough."""
        if amount > self.qty:
            return False
        self.qty = self.qty - amount
        return True

    def is_low(self, level=5):
        """Return True when stock has fallen to the reorder level."""
        return self.qty <= level

    def __str__(self):
        return f"{self.name:<16} $ {self.price:>6.2f} x {self.qty:>3}  = $ {self.value():>7.2f}"

Test: make one item, print it, sell 3, print it again, then try to sell 999 and check you get False.

Bread and eggs behave like every other product, except that they lose half their value on their last day. That is one changed rule, so it is a child class.

class FreshItem(Item):
    """A fresh item IS AN item, with a shelf life."""

    def __init__(self, name, price, qty=0, days_left=3):
        super().__init__(name, price, qty)
        self.days_left = days_left

    def value(self):
        """Fresh stock is half price on its last day."""
        if self.days_left <= 1:
            return super().value() * 0.5
        return super().value()

    def __str__(self):
        return super().__str__() + f"  [days left: {self.days_left}]"

Test: a FreshItem with days_left=1, printed beside an ordinary Item of the same price and quantity. Both overrides extend the parent — neither one retypes the sum.

class Inventory:
    """The whole shop's stock: a list of items, and the jobs done to it."""

    def __init__(self, shop_name):
        self.shop_name = shop_name
        self.items = []

    def add(self, item):
        """Put a new item on the shelves."""
        self.items.append(item)

    def find(self, name):
        """Return the item with that name, or None."""
        for item in self.items:
            if item.name.lower() == name.lower():
                return item
        return None

    def remove(self, name):
        """Take an item off the shelves. Return True if it was there."""
        item = self.find(name)
        if item is None:
            return False
        self.items.remove(item)
        return True

    def total_value(self):
        """Return what all the stock is worth."""
        total = 0
        for item in self.items:
            total = total + item.value()
        return total

    def low_stock(self):
        """Return a list of the items that need reordering."""
        low = []
        for item in self.items:
            if item.is_low():
                low.append(item)
        return low

    def report(self):
        """Print the whole stock list and the total."""
        print(f"--- {self.shop_name} ---")
        for item in self.items:
            print(item)
        print(f"Total stock value: $ {self.total_value():.2f}")

Test: four items added, then shop.report().

Output

--- Shop Runcit Mia ---
Beras 5kg        $  24.50 x  12  = $  294.00
Minyak cook     $  18.90 x   8  = $  151.20
Pancake             $   3.20 x   6  = $    9.60  [days left: 1]
Telur (10)       $   6.50 x   4  = $   26.00  [days left: 5]
Total stock value: $480.80

Look at total_value. It calls item.value() without ever asking what kind of item it is, so the bread's half-price rule is applied by the bread itself. Add a third child class tomorrow and this method does not change.

Underneath the three classes, write the menu. It should hold no stock data of its own.

from toolbox import ask_number, ask_yes_no

shop = Inventory("Shop Runcit Mia")
shop.add(Item("Beras 5kg", 24.50, 12))
shop.add(Item("Minyak cook", 18.90, 8))
shop.add(FreshItem("Pancake", 3.20, 6, 1))
shop.add(FreshItem("Telur (10)", 6.50, 4, 5))

while True:
    print()
    print("1 Report   2 Sell   3 Restock   4 Low stock   5 Quit")
    choice = ask_number("Choose: ", low=1, high=5)

    if choice == 5:
        print("Goodbye!")
        break

    if choice == 1:
        shop.report()
        continue

    if choice == 4:
        for item in shop.low_stock():
            print("Reorder:", item)
        continue

    item = shop.find(input("Item name: "))
    if item is None:
        print("No such item.")
    elif choice == 2:
        if item.sell(ask_number("How many? ", low=1)):
            print("Sold. Stock now", item.qty)
        else:
            print("Not enough stock.")
    else:
        print("Stock now", item.restock(ask_number("How many? ", low=1)))

Run it. Sell 99 bags of rice, ask for "soup", type a word when it wants a number. Every refusal comes from a class or from the toolbox — none of it is in the menu.

Add two methods to Inventory: count(), returning how many item lines the shop has, and most_valuable(), returning the item object holding the most money — or None when the shelves are empty.

    def most_valuable(self):
        """Return the item worth the most, or None if there are none."""
        if len(self.items) == 0:
            return None
        best = self.items[0]
        for item in self.items:
            if item.value() > best.value():
                best = item
        return best

Add two more methods, and one small function beside the classes:

• value_of(item) — a key function.
• Inventory.sorted_items() — returns the list sorted, most valuable first. (sorted(..., reverse=True).)
• Inventory.restock_low(target) — brings every low item up to target and returns how many it touched.

Then add a menu option 6 that restocks everything low to 20 and prints how many items changed. The menu gets three lines longer; the classes do the work.