Many Objects from One Class

By the end of this lesson you can:

• Build a list of instances with a comprehension or a loop.
• Loop a list of instances and call methods on each.
• Filter, sort and find max/min using key=lambda x: x.attr.
• Sum, count and average an attribute across the list.

Same data, two shapes. Compare:

# list of dicts (PY-L2-11)
heroes = [
    {"name": "Aisyah",  "hp": 100},
    {"name": "Wei Jie", "hp": 85},
]
for h in heroes:
    print(h["name"], h["hp"])

# list of instances (today)
class Hero:
    def __init__(self, name, hp):
        self.name = name
        self.hp   = hp

heroes = [Hero("Aisyah", 100), Hero("Wei Jie", 85)]
for h in heroes:
    print(h.name, h.hp)

Same result. The class version is a bit longer up-front (you have to define Hero) but the loop and every operation that follows is cleaner — dots instead of brackets, no quoted keys.

Build many at once

Use a list comprehension over data:

# From a list of tuples
raw = [("Aisyah", 100), ("Wei Jie", 85), ("Priya", 70)]
heroes = [Hero(name, hp) for name, hp in raw]

# From parallel lists
names = ["Aisyah", "Wei Jie", "Priya"]
hps   = [100, 85, 70]
heroes = [Hero(n, hp) for n, hp in zip(names, hps)]

One line, three (or twelve, or a thousand) heroes. Avoid the typo trap of hand-typing each one.

Filter by attribute

# Heroes still alive
alive = [h for h in heroes if h.hp > 0]

# Heroes with low HP
low_hp = [h for h in heroes if h.hp < 30]

The condition uses h.attr — same as h["attr"] in the dict version.

Sort by attribute

# Sort by HP ascending
by_hp = sorted(heroes, key=lambda h: h.hp)

# Highest HP first
strongest_first = sorted(heroes, key=lambda h: h.hp, reverse=True)

Same sorted + key pattern from PY-L2-04. The key function pulls an attribute out for comparison.

Max / min by attribute

top = max(heroes, key=lambda h: h.attack)
weakest = min(heroes, key=lambda h: h.hp)
print(top.name, "is the strongest attacker")

Notice: returns the whole instance, not just the attribute value. Then we read .name off the winner.

Sum / count an attribute

total_hp = sum(h.hp for h in heroes)              # generator expression
party_size = len(heroes)
avg_hp = total_hp / party_size

# Count those matching a condition
n_alive = sum(1 for h in heroes if h.is_alive())

The generator expression (h.hp for h in heroes) is like a list comprehension but doesn't build an intermediate list — efficient for big iterations.

Group by attribute

by_class = {}                  # name → list of heroes
for h in heroes:
    by_class.setdefault(h.class_name, []).append(h)

for class_name, group in by_class.items():
    print(f"{class_name}: {len(group)} hero(es)")

Same group-by recipe from PY-L2-12. setdefault creates the empty list if it's not there yet, otherwise gives you the existing one.

Call a method on each

for h in heroes:
    h.take_damage(10)             # every hero takes 10 damage

Loop and invoke. This is the action half of OOP — same method, many instances, different effects on each.

Save as party.py:

# party.py — operations on a list of Hero instances

class Hero:
    def __init__(self, name, hp=100, attack=10, role="fighter"):
        self.name   = name
        self.hp     = hp
        self.max_hp = hp
        self.attack = attack
        self.role   = role

    def is_alive(self):
        return self.hp > 0

    def take_damage(self, amount):
        self.hp = max(0, self.hp - amount)

    def report(self):
        return f"{self.name:<10} {self.role:<8} HP {self.hp:>3}/{self.max_hp:<3} ATK {self.attack:>2}"

# 5 heroes built from tuples
specs = [
    ("Aisyah",  100, 12, "fighter"),
    ("Wei Jie",  85, 18, "ranger"),
    ("Priya",    70, 25, "mage"),
    ("Iman",    120,  8, "tank"),
    ("Aizat",    60, 14, "rogue"),
]
party = [Hero(*spec) for spec in specs]

# 1. List everyone
print("=== Roster ===")
for h in party:
    print("  " + h.report())

# 2. Filter — only mages
mages = [h for h in party if h.role == "mage"]
print(f"\nMages in party: {len(mages)}")

# 3. Sort — by attack, descending
ranked = sorted(party, key=lambda h: h.attack, reverse=True)
print("\n=== By ATK (best first) ===")
for h in ranked:
    print(f"  {h.name:<10} ATK {h.attack}")

# 4. Max — strongest hitter
strongest = max(party, key=lambda h: h.attack)
print(f"\nStrongest: {strongest.name} (ATK {strongest.attack})")

# 5. Sum / Avg
total_hp = sum(h.hp for h in party)
print(f"Party HP : {total_hp}")
print(f"Avg HP   : {total_hp / len(party):.1f}")

# 6. Call a method on each — a meteor strike
print("\n=== Meteor strike (everyone takes 40) ===")
for h in party:
    h.take_damage(40)
    print("  " + h.report())

# 7. Filter — survivors
survivors = [h for h in party if h.is_alive()]
print(f"\nSurvivors: {len(survivors)} of {len(party)}")

# 8. Group by role
by_role = {}
for h in party:
    by_role.setdefault(h.role, []).append(h.name)
print(f"\nBy role: {by_role}")

Read the diff

Eight different operations, all in 70 lines. Hero(*spec) unpacks each tuple into the constructor — same trick as PY-L2-04 unpacking applied to function calls. The eight ops match exactly the patterns from PY-L2-11's list-of-dicts lesson — but with dotted attribute access, no quoted keys.

A list of instances behaves exactly like a list of dicts — but with dotted access. Build with a comprehension. Filter with [x for x in lst if condition]. Sort with sorted(lst, key=lambda x: x.attr). Max/min the same way. Sum and count with generator expressions. Group with setdefault. Call a method on every instance with a simple loop. Same eight patterns, two flavours; today's flavour is cleaner.