Classes, objects and __init__

Forty students, each with a name and a list of marks, can live in two lists side by side, until someone sorts one of them and the marks no longer line up with the names. A classclass: A type of object defined with a class statement. The class holds the methods and the class attributes, and calling it, as in Student("Asha", [78, 91, 85]), creates a new object of that type. keeps each student’s data together with the operations on it: class Student: defines a new type of object, and calling it, as in Student("Asha", [78, 91, 85]), creates one object of that type, an instanceinstance: An object made by calling a class. Each instance keeps attributes of its own in its own dictionary; type(obj) gives the class it was made from, and isinstance(obj, Student) checks it., then runs the class’s __init__ method to give the object its first attributesattribute: A name attached to an object and read with a dot, as in asha.name. A read looks in the object first and then in its class; an assignment stores the name in the object itself..

Functions written inside the class are its methodsmethod: A function that belongs to a value and is called with a dot after it, such as text.strip(). String methods return a new string and leave the original as it was. More in “Essential string methods for cleaning text”: asha.average() runs average with asha passed in as the first parameter, which by convention is named selfself: The usual name of a method's first parameter: the instance the method was called on. A call such as asha.average() passes asha in as self, so the method works on that object's attributes.. Below you will step through what a call of a class does, spell a method call out the long way, follow Python’s search for an attribute, keep the attributes every instance shares apart from each object’s own, and reproduce the bug that puts one customer’s shopping in every basket.

Calling a class makes a new object and fills it in

Here is a small class and two students made from it:

class Student:
    """A student and the marks they scored."""

    def __init__(self, name, marks):
        self.name = name
        self.marks = list(marks)  # a list of this student's own

    def average(self):
        return sum(self.marks) / len(self.marks)

    def add_mark(self, mark):
        self.marks.append(mark)


asha = Student("Asha", [78, 91, 85])
ravi = Student("Ravi", [64, 70])
asha.add_mark(96)

print(asha.name, asha.marks, asha.average())
print(ravi.name, ravi.marks, ravi.average())
print(type(asha).__name__, isinstance(asha, Student))
print(asha is ravi, asha.marks is ravi.marks)
print(vars(ravi))

Asha [78, 91, 85, 96] 87.5
Ravi [64, 70] 67.0
Student True
False False
{'name': 'Ravi', 'marks': [64, 70]}

• The class statement runs its body once and creates a class object called Student. Class names use CapWords, as PEP 8 recommends, which tells a reader at a glance that Student(...) creates an object.
• Student("Asha", [78, 91, 85]) makes a new, empty instance and calls __init__ on it with the arguments, so inside __init__ the name self is the new object. __init__ creates attributes by assigning to self, and the call of the class returns the finished object.
• Methods are ordinary functions defined in the class body. Each one receives the instance as its first parameter, so self.marks inside average() means the marks of whichever student the method was called on.
• Each instance has attributes of its own. asha.add_mark(96) changed Asha’s list only, because __init__ built a new list for every student with list(marks), which also copies the caller’s list instead of keeping a reference to it.
• type(asha) is the class, isinstance(asha, Student) asks whether an object is an instance of a class, and vars(ravi) shows the attributes of one instance as a dictionary.

Step through the first call of the program and watch the new object, on the right, fill in:

Strictly, creating the empty object is the job of another special method, __new__, which a class rarely needs to replace; __init__ only fills the object in, as the second and third steps showed. That is why __init__ must return None: a return with any other value makes the call fail with TypeError.

self is the object the method was called on

The name self is a convention, not a keyword. What is special is the call itself: when you call a method through an instance, Python passes that instance as the first argument. One function, stored once in the class, serves every student. Step through the two calls of average() in the program above and watch what self is in each:

Both calls ran the same function, and only self differed, so each read its own marks. These three calls of a counter’s method do the same thing:

class Counter:
    def __init__(self, start=0):
        self.value = start

    def step(self, by=1):
        self.value += by
        return self.value


c = Counter(10)
print(c.step(5))           # the usual call
print(Counter.step(c, 5))  # the same call, spelled out
print(type(c).step(c, 5))  # type(c) is Counter

bound = c.step             # a bound method: the function plus the instance
print(bound.__self__ is c, bound.__func__ is Counter.step)
print(bound())             # self is already filled in

try:
    Counter.step()         # through the class nothing fills in self
except TypeError as error:
    print("TypeError:", error)

15
20
25
True True
26
TypeError: Counter.step() missing 1 required positional argument: 'self'

c.step(5) is shorthand for Counter.step(c, 5), and because type(c) is Counter, also for type(c).step(c, 5). Reading c.step without calling it gives a bound methodbound method: What reading a method through an instance gives: the function together with that instance, so calling it later passes the instance in as self. c.step is a bound method; c.step(5) calls it., a small object that holds the function in __func__ and the instance in __self__, so calling it later fills in self by itself. Through the class nothing is filled in: Counter.step() has no instance to pass, and Python names the missing argument.

The same rule explains two messages that beginners meet. A method written without the parameter, such as def step(by):, receives the instance in by, and a call with one more argument fails with “takes 1 positional argument but 2 were given”. And a name without self. in front of it, inside a method, is a local variable, not an attribute:

class Product:
    def __init__(self, name, price):
        name = name  # BUG: a local variable, gone when __init__ returns
        self.price = price

    def label(self):
        return f"{self.name}: {self.price}"


pen = Product("pen", 20)
print(vars(pen))
print(pen.label())

{'price': 20}

Traceback (most recent call last):
  File "forgot_self.py", line 12, in <module>
    print(pen.label())
          ~~~~~~~~~^^
  File "forgot_self.py", line 7, in label
    return f"{self.name}: {self.price}"
              ^^^^^^^^^
AttributeError: 'Product' object has no attribute 'name'

name = name assigned the parameter to itself and vanished when __init__ returned, so vars(pen) holds only price. Nothing fails until another method reads self.name, which can be far from the line with the bug. When an AttributeError names an attribute you are sure you set, print vars() of the object and check each assignment in __init__ for a missing self..

Python looks in the object first, then in its class

An instance keeps its own attributes in a dictionary, obj.__dict__, which vars(obj) returns. The class has a dictionary too, holding its methods and its class attributesclass attribute: An attribute assigned in the class body. Its one value is kept in the class and shared by every instance that has no attribute of its own with that name.. Reading an attribute through an instance checks the two in order:

Follow three reads and one assignment through those two steps, on the asha of the first program:

Methods are found in the second step, which is why every instance can call them without storing a copy. Writing follows a different rule: asha.x = 1 stores x in the instance’s own dictionary and never touches the class. Read through to the class, write to the instance: those two rules explain the rest of this lesson. Later lessons of this module build on them: inheritance adds the parent classes to the second step, and a property, in the next lesson, lets a class run a method of its own when a name is read or assigned.

class Student:
    def __init__(self, name, marks):
        self.name = name
        self.marks = list(marks)

    def reset(self):
        self.marks = []
        self.flagged = False


print(Student.__static_attributes__)
print(vars(Student("Asha", [90])))

('flagged', 'marks', 'name')
{'name': 'Asha', 'marks': [90]}

A class attribute is shared until an object assigns its own

A value assigned in the class body is a class attribute, one value for every instance; a value assigned through self is an instance attributeinstance attribute: An attribute stored in one object's own dictionary, usually set on self in __init__. Each instance has its own value, and vars(obj) shows them., one per object. Here two accounts share one interest rate, until one of them gets a rate of its own:

class Account:
    interest_rate = 0.03  # class attributes: one value, shared
    minimum_balance = 500

    def __init__(self, owner):
        self.owner = owner  # instance attribute: one per account


a = Account("Asha")
b = Account("Ravi")
print(a.interest_rate, b.interest_rate, Account.interest_rate)

Account.interest_rate = 0.035  # change it on the class ...
print(a.interest_rate, b.interest_rate)  # ... and every account sees it

a.interest_rate = 0.05  # assign through one instance
print(a.interest_rate, b.interest_rate, Account.interest_rate)
print(vars(a))
print(vars(b))

del a.interest_rate  # remove the instance attribute
print(a.interest_rate)  # the class attribute shows through again
print(sorted(k for k in vars(Account) if not k.startswith("__")))

0.03 0.03 0.03
0.035 0.035
0.05 0.035 0.035
{'owner': 'Asha', 'interest_rate': 0.05}
{'owner': 'Ravi'}
0.035
['interest_rate', 'minimum_balance']

• interest_rate and minimum_balance live in the class. Every account reads them through the second step of the search, so changing Account.interest_rate changed the rate of both accounts at once.
• a.interest_rate = 0.05 did not change the class. It created an instance attribute on a, which hides the class attribute for a alone: vars(a) now holds it and vars(b) does not.
• del a.interest_rate removed the instance attribute, and the class attribute showed through again. The last line lists the class’s own names, leaving out the special ones that start with two underscores.

Step through the same run and watch which box answers each read of the rate:

Then press Edit on the program, add Account.minimum_balance = 1000 and print(a.minimum_balance, b.minimum_balance) at the end, and run it: the new line prints 1000 1000, because neither account has a minimum_balance of its own. The table sums the two kinds up:

A list in the class body is one list for every instance

A class attribute that holds a list, a dictionary or a set is shared just like a number, with one difference that causes real bugs: methods usually change such a value in place instead of assigning to it, so the change goes to the class’s object, and every instance sees it.

class Basket:
    items = []  # BUG: one list, created once, for every basket

    def add(self, item):
        self.items.append(item)  # finds the class's list and changes it


first = Basket()
second = Basket()
first.add("rice")
second.add("soap")
print(first.items, second.items)
print(first.items is second.items is Basket.items)
print(vars(first))


class FixedBasket:
    def __init__(self):
        self.items = []  # a new list for every basket

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


first = FixedBasket()
second = FixedBasket()
first.add("rice")
second.add("soap")
print(first.items, second.items)
print(vars(first))

['rice', 'soap'] ['rice', 'soap']
True
{}
['rice'] ['soap']
{'items': ['rice']}

Step through the same program and watch where each append lands:

self.items.append(...) reads self.items, finds the class’s list in the second step and appends to it. Nothing is ever assigned to the instance, so vars(first) is empty and both baskets show both items. The fix is to create the list in __init__, which runs once for every new object. A mutable default value, as in def __init__(self, items=[]), hides the same trap, which the lesson on parameters explains: the default is created once, when the function is defined.

Numbers fail the other way round. self.issued += 1 looks as if it updates a shared counter, but augmented assignmentaugmented assignment: An assignment that combines an operator with =, such as count += 5. A number or a string is rebound to the result, while += changes a list in place. More in “Operators, precedence and the walrus” reads first and assigns second, and the assignment lands on the instance:

class Ticket:
    issued = 0  # meant to count every ticket ever made

    def __init__(self, seat):
        self.seat = seat
        self.issued += 1  # reads the class's 0, then writes an instance attribute


a = Ticket("A1")
b = Ticket("A2")
print(Ticket.issued, a.issued, b.issued)


class CountedTicket:
    issued = 0

    def __init__(self, seat):
        self.seat = seat
        type(self).issued += 1  # rebinds the class attribute itself


a = CountedTicket("A1")
b = CountedTicket("A2")
print(CountedTicket.issued, a.issued, vars(a))

0 1 1
2 2 {'seat': 'A1'}

Step through both versions and watch where each read finds issued and where the new value goes:

Each ticket ended up with an issued of its own, 1, while the class kept 0. To change a class attribute from a method, assign to the class: type(self).issued += 1 as here, or Ticket.issued += 1 when the subclasses that a later lesson introduces should share one count.

Practise: a bank account that keeps its own history

The exercise asks for a complete BankAccount class with deposits, withdrawals and interest. Its starter code has the bug of the last section, which the sample tests catch: every account must keep its own list of transactions, while the interest rate stays one class attribute for every account that has not set its own.

class BankAccount:
    interest_rate = 0.04  # one rate for every account
    transactions = []

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

    def deposit(self, amount):
        """Add amount (more than 0), record ("deposit", amount), return the new balance."""
        self.balance += amount
        self.transactions.append(("deposit", amount))
        return self.balance

    def withdraw(self, amount):
        """Take amount (more than 0, at most the balance), record ("withdraw", amount), return the new balance."""
        return self.balance

    def add_interest(self):
        """Add round(balance * interest_rate, 2), record ("interest", interest), return the interest."""
        return 0

from bank import BankAccount


def raises_value_error(call, *args):
    try:
        call(*args)
    except ValueError:
        return True
    return False


def test_deposit_and_withdraw():
    """deposits and withdrawals change the balance and return it"""
    acc = BankAccount("Asha", 100)
    assert acc.owner == "Asha"
    assert acc.deposit(50) == 150
    assert acc.withdraw(30) == 120
    assert acc.withdraw(120) == 0
    assert acc.balance == 0
    assert acc.transactions == [("deposit", 50), ("withdraw", 30), ("withdraw", 120)]


def test_rejects_bad_amounts():
    """amounts of 0 or less, and withdrawals above the balance, raise ValueError and change nothing"""
    acc = BankAccount("Ravi", 40)
    for bad in (0, -5):
        assert raises_value_error(acc.deposit, bad), f"deposit({bad}) should raise ValueError"
    for bad in (0, -5, 41):
        assert raises_value_error(acc.withdraw, bad), f"withdraw({bad}) should raise ValueError"
    assert acc.balance == 40
    assert acc.transactions == []


def test_own_transactions():
    """every account keeps its own list of transactions"""
    a = BankAccount("Asha")
    b = BankAccount("Ravi")
    a.deposit(10)
    b.deposit(20)
    b.withdraw(5)
    assert a.transactions == [("deposit", 10)]
    assert b.transactions == [("deposit", 20), ("withdraw", 5)]
    assert a.transactions is not b.transactions


def test_interest_rate_is_shared():
    """the class-level rate applies to every account that has not set its own"""
    a = BankAccount("Asha", 1000)
    b = BankAccount("Ravi", 500)
    assert a.add_interest() == 40.0
    old = BankAccount.interest_rate
    try:
        BankAccount.interest_rate = 0.05
        assert b.add_interest() == 25.0
        b.interest_rate = 0.1
        assert b.add_interest() == 52.5
        assert a.add_interest() == 52.0
    finally:
        BankAccount.interest_rate = old
    assert a.balance == 1092.0
    assert a.transactions == [("interest", 40.0), ("interest", 52.0)]

Last, a run of questions on objects, self, attribute lookup and shared attributes. It opens with whichever of these ideas your answers on this page found hardest, and explains every option you pick:

Interview questions

Fresher · What is self in a Python method, and why does a method need it?

self is the first parameter of a method: the instance the method was called on. Python passes it automatically when a method is called through an instance, so account.deposit(50) runs Account.deposit(account, 50), and inside the method self.balance means that account’s balance. The name is a convention, not a keyword, but every Python programmer expects it. A method needs the parameter because it is one function, stored once in the class and shared by all instances: the instance passed in is how it knows whose attributes to read and change. Reading account.deposit without calling it gives a bound method, which has already captured the instance. A method defined without the parameter fails as soon as it is called through an instance, with “takes 0 positional arguments but 1 was given”.

Key takeaways

• class Name: creates a new type; calling the class creates an instance and runs __init__, which sets the instance’s attributes on self.
• obj.method(x) is type(obj).method(obj, x): self is the instance, passed in as the first argument.
• Reading obj.name looks in the instance’s own attributes first and then in the class; assigning obj.name = … writes to the instance.
• A class attribute is shared by every instance; an instance attribute with the same name hides it for one object.
• Create lists, dictionaries and other mutable values in __init__, or every instance shares one; change a class attribute through the class, never through self.
• vars(obj) shows an object’s own attributes, which makes most attribute bugs visible.