Many Objects, One List

By the end of this lesson you can:

• Build a list of objects, in one go or one append at a time.
• Loop over the list to print, total, count and filter.
• Write a search that returns the object found, or None.
• Sort a list of objects with a key= function.

How many lines print before this stops, and what does the error say?

class MenuItem:
    """One dish on the canteen menu."""

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


menu = [MenuItem("Pizza", 4.50), MenuItem("Hot chocolate", 2.50), MenuItem]

for item in menu:
    print(item.name)

Pizza
Hot chocolate
Traceback (most recent call last):
AttributeError: type object 'MenuItem' has no attribute 'name'

A list holds anything, so it holds your objects. Build it in one go:

menu = [
    MenuItem("Pizza", 4.50),
    MenuItem("Pancake", 1.50),
    MenuItem("Hot chocolate", 2.50),
]

Or grow it one at a time — which is what you do when the data comes from the user:

menu = []
menu.append(MenuItem("Fried rice", 8.00))
menu.append(MenuItem("Ice cream", 3.50))

Printing the whole list is now one loop, and it is where __str__ pays you back:

for item in menu:
    print(item)

Without __str__ you would get three lines of <__main__.MenuItem object at 0x...>. With it, you get your own tidy lines.

Totalling and counting are the same accumulator patterns you already use, with a dot added:

total = 0
cheap_count = 0

for item in menu:
    total = total + item.price
    if item.price < 3:
        cheap_count = cheap_count + 1

print(f"Whole menu: $ {total:.2f}")
print("Dishes under $3:", cheap_count)

Filtering builds a smaller list of the same objects — not copies, the very same ones:

snacks = []
for item in menu:
    if item.price < 3:
        snacks.append(item)

Searching is the pattern you will use most, and the trick is what it gives back:

def find_item(menu, wanted):
    """Return the dish with that name, or None if it is not on the menu."""
    for item in menu:
        if item.name.lower() == wanted.lower():
            return item
    return None

It returns the object, so the caller can immediately use it — read its attributes, call its methods, change it. Always check the miss:

found = find_item(menu, "hot chocolate")

if found is None:
    print("Not on the menu today.")
else:
    print(found.name, "costs $", found.price)

Sorting needs one small function that says which fact to sort on — exactly the key= idea from lists, now reading an attribute:

def price_of(item):
    """Key function: sort a menu by price."""
    return item.price


for item in sorted(menu, key=price_of):
    print(item)

sorted calls price_of once per dish and orders by what comes back. Swap in name_of and the same menu sorts alphabetically.

One class, one list, and five things done to it. Type it out and run it.

class MenuItem:
    """One dish on the canteen menu, with today's stock."""

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

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

    def value(self):
        """Return the money this dish's remaining stock is worth."""
        return self.price * self.stock

    def __str__(self):
        return f"{self.name:<16} $ {self.price:>5.2f}   stock {self.stock}"


def price_of(item):
    """Key function: sort a menu by price."""
    return item.price


def find_item(menu, wanted):
    """Return the dish with that name, or None."""
    for item in menu:
        if item.name.lower() == wanted.lower():
            return item
    return None


menu = [
    MenuItem("Pizza", 4.50, 20),
    MenuItem("Pancake", 1.50, 35),
    MenuItem("Fried rice", 8.00, 12),
    MenuItem("Hot chocolate", 2.50, 40),
]

print("TODAY'S MENU")
for item in menu:
    print(item)

total = 0
for item in menu:
    total = total + item.value()
print(f"Stock on hand: $ {total:.2f}")

wanted = "pizza"
dish = find_item(menu, wanted)
if dish is None:
    print(wanted, "is not on the menu.")
elif dish.sell(3):
    print("Sold 3 x", dish.name, "- stock now", dish.stock)
else:
    print("Not enough", dish.name, "left.")

print("CHEAPEST FIRST")
for item in sorted(menu, key=price_of):
    print(item)

Output

TODAY'S MENU
Pizza       $  4.50   stock 20
Pancake       $  1.50   stock 35
Fried rice   $  8.00   stock 12
Hot chocolate        $  2.50   stock 40
Stock on hand: $338.50
Sold 3 x Pizza - stock now 17
CHEAPEST FIRST
Pancake       $  1.50   stock 35
Hot chocolate        $  2.50   stock 40
Pizza       $  4.50   stock 17
Fried rice   $  8.00   stock 12

Two experiments. Ask for "soup" and watch the None branch run. Then try to sell 99 pizza, and notice the refusal comes from the class, not the program.

Objects go in lists like anything else, and every loop you know then works on them: printing (which calls __str__), totalling, counting, filtering. A search should return the object itself, or None when there is no match — test that with is None. Sorting takes a small key function that reads one attribute. Throughout, keep the object and one of its attributes straight in your head: item is the dish, item.price is a number.