Inheritance and class attributes

Shared by every object: class attributes

So far, every attribute you've made lived on one object: self.name = name gives each object its own name. An attribute written in the class body, outside any method, belongs to the class itself. Every object of the class shares it:

class Product:
    TAX_RATE = 0.08
    made = 0

    def __init__(self, name, price):
        self.name = name
        self.price = price
        Product.made = Product.made + 1

    def price_with_tax(self):
        return round(self.price * (1 + self.TAX_RATE), 2)

tent = Product("Ridgeline tent", 289)
mug = Product("Trail mug", 14)
print(tent.price_with_tax(), mug.price_with_tax())
print(Product.made, Product.TAX_RATE)

TAX_RATE is written once and every product uses it. Change Product.TAX_RATE and every product sees the new rate. made counts how many products were created, so each __init__ adds one to Product.made.

Use class attributes for values that really are the same for every object: settings, limits, counters. Upper-case names like TAX_RATE say "this is a constant; don't change it".

class Tent:
    sleeps = 2

big = Tent()
big.sleeps = 4
small = Tent()
print(big.sleeps, small.sleeps, Tent.sleeps)

The shared-list trap

Sharing is a problem when the class attribute is something that can change, like a list. Every object then adds to the same list:

class Cart:
    items = []

    def add(self, item):
        self.items.append(item)

ana = Cart()
ben = Cart()
ana.add("tent")
print(ben.items)

Ben's cart contains Ana's tent, because both carts use the one items list on the class. The fix is to give each object its own list in __init__:

class Cart:
    def __init__(self):
        self.items = []

    def add(self, item):
        self.items.append(item)

ana = Cart()
ben = Cart()
ana.add("tent")
print(ana.items, ben.items)

The rule: anything that differs between objects, or changes over time, goes on self inside __init__.

A class built on another: inheritance

The shop also rents gear. A rental is a product, with a name and a price, plus a deposit. You could copy the whole Product class and add to it, but then a fix in one copy would miss the other. Inheritance builds the new class on the old one instead:

class Product:
    TAX_RATE = 0.08

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

    def price_with_tax(self):
        return round(self.price * (1 + self.TAX_RATE), 2)

class Rental(Product):
    def __init__(self, name, price, deposit):
        super().__init__(name, price)
        self.deposit = deposit

    def price_with_tax(self):
        return super().price_with_tax() + self.deposit

stove = Rental("Camp stove", 20, 50)
print(stove.name, stove.price, stove.deposit)
print(stove.price_with_tax())

class Rental(Product): makes Rental a subclass of Product: it gets every attribute and method Product has. Product is the parent class.

• super().__init__(name, price) runs the parent's __init__, which sets the name and price. Then Rental adds the one thing that's new.
• Defining price_with_tax again overrides the parent's version. Inside it, super().price_with_tax() still reaches the parent's version, so the rental adds the deposit to the taxed price instead of redoing the tax sum.

class Product:
    TAX_RATE = 0.08

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

    def price_with_tax(self):
        return round(self.price * (1 + self.TAX_RATE), 2)

# Write Clearance here

One call, the right method

Here's the payoff. A list can mix products, rentals and clearance items, and one loop treats them all alike. Each object runs its own class's version of the method:

class Product:
    TAX_RATE = 0.08
    def __init__(self, name, price):
        self.name = name
        self.price = price
    def price_with_tax(self):
        return round(self.price * (1 + self.TAX_RATE), 2)

class Rental(Product):
    def __init__(self, name, price, deposit):
        super().__init__(name, price)
        self.deposit = deposit
    def price_with_tax(self):
        return super().price_with_tax() + self.deposit

basket = [Product("Trail mug", 14), Rental("Camp stove", 20, 50)]
for item in basket:
    print(item.name, item.price_with_tax(), isinstance(item, Product))

The loop never asks what kind of item it holds. item.price_with_tax() finds the right method because Python looks on the object's own class first, then on its parent. isinstance(item, Product) is True for the rental too: a Rental is a Product.

Where Python looks for a method

When you write stove.price_with_tax(), Python searches in a fixed order, and uses the first match it finds:

1. the object itself (attributes set on self);
2. the object's own class, here Rental;
3. that class's parent, here Product, and its parent in turn, if it has one.

That one rule explains everything in this lesson. A subclass method with the same name is found first, so it overrides the parent's. A class attribute is found on the class when the object has no attribute of that name, and big.sleeps = 4 hides it by putting a value on the object, step 1. super() means "start the search one step up, at the parent".

Two built-ins let you ask about these relationships. isinstance(obj, Product) asks "is this object a Product, or a subclass of one?". issubclass(Rental, Product) asks the same about two classes. Both are True here.

class Shipping:
    def cost(self):
        return 5

class Express(Shipping):
    def cost(self):
        return super().cost() * 3

class Pickup(Shipping):
    def cost(self):
        return 0

print([s.cost() for s in [Shipping(), Express(), Pickup()]])

Subclassing classes you didn't write

You'll often inherit from a class that comes with Python or a library. The simplest case is your own kind of error. An empty subclass of Exception is enough to give it a name that says what went wrong, and code can catch exactly that kind:

class OutOfStock(Exception):
    pass

def reserve(item, stock):
    if stock.get(item, 0) == 0:
        raise OutOfStock(f"{item} is sold out")
    stock[item] = stock[item] - 1

stock = {"tent": 1}
try:
    reserve("tent", stock)
    reserve("tent", stock)
except OutOfStock as problem:
    print("Sorry:", problem)

class OutOfStock(Exception): pass inherits everything an exception does: it can be raised, carries a message, and shows in tracebacks. The body is empty because nothing else is needed.

def apply_code(code):
    pass

When not to inherit

Inheritance means "is a": a rental is a product, an express delivery is a kind of shipping. When the honest sentence is "has a", use an attribute instead. An order has a shipping method; it isn't one. So the order keeps a shipping object inside it:

class Order:
    def __init__(self, items, shipping):
        self.items = items
        self.shipping = shipping      # an Express(), a Pickup()...

    def total(self):
        return sum(i.price for i in self.items) + self.shipping.cost()

Keeping one object inside another is called composition. It's often the better choice, because you can swap the shipping method without making a new kind of order. Reach for inheritance when the new class really is a more specific version of the old one, and you want to keep almost all of its behavior.

class Shipping:
    name = "Standard"
    def cost(self, weight):
        return 5 + weight * 0.5

class Express(Shipping):
    name = "Express"
    def cost(self, weight):
        return super().cost(weight) * 3

class Pickup(Shipping):
    name = "Store pickup"
    def cost(self, weight):
        return 0

weight = 4
for option in [Shipping(), Express(), Pickup()]:
    print(f"{option.name}: {option.cost(weight)}")