Classes and objects

You have used objects since your first lesson: every string, list and dictionary is one. Now you will build your own kind. The fundamentals lesson on records and objects explains why programs group data with the behaviour that belongs to it. This lesson shows how Python spells that idea.

From a dictionary to a class

A dictionary can hold a record, and for small jobs it is a good choice:

account = {"owner": "Asha", "balance": 100}
account["balance"] = account["balance"] + 50
print(account)

account["balence"] = 0  # a typo creates a new key, silently
print(account)

{'owner': 'Asha', 'balance': 150}
{'owner': 'Asha', 'balance': 150, 'balence': 0}

The second assignment is a typo, and Python accepted it. The dictionary has no idea what a bank account should look like, so it now carries a stray balence key. A class lets you write down the shape once, and attach the operations that belong to it.

Your first class

A class is a blueprint. Calling it builds an instance, one object made from that blueprint. The __init__ method runs on each new instance and sets up its starting state.

class Account:
    def __init__(self, owner, balance):
        self.owner = owner
        self.balance = balance


acct = Account("Asha", 100)
print(acct.owner)
print(acct.balance)
print(type(acct))

Asha
100
<class '__main__.Account'>

Read the class from the top:

• class Account: starts the definition. Class names use CapitalisedWords, as PEP 8 recommends.
• __init__ is a method, which is a function defined inside a class. Python calls it for you when you write Account("Asha", 100). The double underscores on both sides are why people call it “dunder init”.
• self.owner = owner stores a value on the new instance. Values stored this way are attributes.

What self means

The first parameter of every ordinary method receives the instance the method was called on. By convention it is named self. You never pass it yourself, because Python fills it in. Each instance keeps its own attributes:

class Account:
    def __init__(self, owner, balance):
        self.owner = owner
        self.balance = balance


first = Account("Asha", 100)
second = Account("Ben", 20)
first.balance = 150
print(first.balance)
print(second.balance)

150
20

Changing first left second alone, because self was a different object each time.

Adding methods

A method is where behaviour lives. It reads and changes the instance through self:

class Account:
    def __init__(self, owner, balance):
        self.owner = owner
        self.balance = balance

    def deposit(self, amount):
        self.balance = self.balance + amount

    def describe(self):
        return f"{self.owner}: {self.balance}"


acct = Account("Asha", 100)
acct.deposit(50)
print(acct.describe())

Asha: 150

acct.deposit(50) is shorthand. Python looks up deposit on the class and passes acct as self. You can write that call out in full, which makes it plain that nothing magical is happening:

class Account:
    def __init__(self, owner, balance):
        self.owner = owner
        self.balance = balance

    def deposit(self, amount):
        self.balance = self.balance + amount


acct = Account("Asha", 100)
acct.deposit(50)
Account.deposit(acct, 25)
print(acct.balance)

175

Both lines changed the same balance: 100, plus 50, plus 25. You will almost always use the short form, but it helps to know that acct.deposit(50) and Account.deposit(acct, 50) mean the same thing.

__init__ takes parameters like any function, so default values work:

class Account:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self.balance = balance


print(Account("Ben").balance)
print(Account("Asha", 100).balance)

0
100

Class attributes

A name assigned directly inside the class body, outside any method, is a class attribute. It belongs to the class and every instance can read it.

class Account:
    bank_name = "Pybank"
    open_accounts = 0

    def __init__(self, owner):
        self.owner = owner
        Account.open_accounts = Account.open_accounts + 1


a = Account("Asha")
b = Account("Ben")
print(a.bank_name, b.bank_name)
print(Account.open_accounts)

Pybank Pybank
2

bank_name is the same for every account, so it belongs on the class. open_accounts is a counter that all instances update together, which is why __init__ writes to it through Account.open_accounts and not through self.

Reading and writing behave differently, and this is the part that surprises people. Reading a.bank_name finds the class attribute when the instance has none of its own. But assigning a.bank_name = ... never changes the class. It creates a new attribute on that one instance, which hides the class attribute for that instance only:

class Account:
    bank_name = "Pybank"

    def __init__(self, owner):
        self.owner = owner


a = Account("Asha")
b = Account("Ben")
a.bank_name = "Other Bank"
print(a.bank_name)
print(b.bank_name)
print(Account.bank_name)

Other Bank
Pybank
Pybank

Common pitfalls

Putting a mutable value at class level. A list or dictionary written in the class body is created once and shared by every instance:

class Basket:
    items = []

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


mon = Basket()
tue = Basket()
mon.add("apple")
print(tue.items)

['apple']

Nobody added anything to tue, yet its list has an apple in it. self.items found no instance attribute, so it fell back to the one list on the class, and append changed that shared list. The fix is to create the list inside __init__, so every instance gets its own:

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

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


mon = Basket()
tue = Basket()
mon.add("apple")
print(tue.items)

[]

Use class attributes for constants and for counters you update through the class name. Anything that should differ from one instance to the next belongs in __init__.

A typo in an attribute name. Reading a misspelled attribute fails loudly. Writing one succeeds quietly:

class Account:
    def __init__(self, owner, balance):
        self.owner = owner
        self.balance = balance


acct = Account("Asha", 100)
acct.balence = 500  # typo: creates a new attribute
print(acct.balance)
print(acct.balence)
try:
    print(acct.blance)
except AttributeError as error:
    print("AttributeError:", error)

100
500
AttributeError: 'Account' object has no attribute 'blance'

The assignment acct.balence = 500 created a second attribute, and balance stayed at 100. A test that reads the attribute back catches this kind of mistake, and so does a type checker.

Forgetting self. If you write def deposit(amount): without self, calling acct.deposit(50) fails with a TypeError that says the method took 1 positional argument but 2 were given. Python passed the instance as the first argument, and your method had no parameter to receive it. Likewise, inside a method, write self.balance to reach the attribute. A bare balance is a local variable that does not exist.

Forgetting the parentheses. acct.describe is the method itself. acct.describe() calls it.

Checking what something is

isinstance(value, Class) answers whether a value was made from a class, and __class__.__name__ gives the class name as text:

class Account:
    def __init__(self, owner):
        self.owner = owner


acct = Account("Asha")
print(isinstance(acct, Account))
print(isinstance("Asha", Account))
print(acct.__class__.__name__)

True
False
Account

You met isinstance with built-in types earlier. It works the same way with the classes you write.

class Rectangle:
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def area(self):
        return self.width * self.height

    def perimeter(self):
        return 2 * (self.width + self.height)


r = Rectangle(3, 4)
print(r.area())
print(r.perimeter())
r.width = 10
print(r.area())

12
14
40

error: cannot withdraw 500, balance is 150
120

class Account:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self.balance = balance

    def deposit(self, amount):
        if amount <= 0:
            raise ValueError(f"deposit must be positive: {amount}")
        self.balance = self.balance + amount

    def withdraw(self, amount):
        if amount > self.balance:
            raise ValueError(f"cannot withdraw {amount}, balance is {self.balance}")
        self.balance = self.balance - amount


acct = Account("Asha", 100)
acct.deposit(50)
try:
    acct.withdraw(500)
except ValueError as error:
    print("error:", error)
acct.withdraw(30)
print(acct.balance)

error: cannot withdraw 500, balance is 150
120

class TallyCounter:
    total = 0

    def __init__(self):
        self.count = 0

    def hit(self):
        self.count = self.count + 1
        TallyCounter.total = TallyCounter.total + 1


a = TallyCounter()
b = TallyCounter()
a.hit()
a.hit()
b.hit()
print(a.count, b.count, TallyCounter.total)
print(a.total)

2 1 3
3

Summary

• A class statement defines a blueprint. Calling the class creates an instance and runs __init__ on it.
• self is the instance a method was called on. Python passes it for you, so acct.deposit(50) is Account.deposit(acct, 50).
• Attributes set on self belong to one instance. Names assigned in the class body belong to the class and are shared.
• Assigning through an instance never changes a class attribute. It creates an instance attribute that hides it.
• Create mutable per-instance values, such as lists, inside __init__, not in the class body.