26. Methods and self

You have called methods on objects many times — "hello".upper(), my_list.append(x), math.floor(n). This chapter shows how to define your own methods that belong to a particular object, and what self is. Understanding self once explains a lot of Python code.

Functions on objects, the long way

In Python, a method is just a function defined inside a class. But before classes, think about a plain dictionary holding a counter:

counter = {"count": 0}

def step(c):
    c["count"] = c["count"] + 1

step(counter)
step(counter)
step(counter)
print(counter["count"])   # 3

The function step takes the dictionary itself as its first argument, then uses it to update the count. Every call has to pass counter explicitly: step(counter). This works but reads awkwardly.

Methods and self in a class

Python's class syntax solves this. A method is a function defined inside a class body. When you call obj.method(), Python automatically passes obj as the first argument. By convention that first parameter is named self:

class Counter:
    def __init__(self):
        self.count = 0

    def step(self):
        self.count = self.count + 1

counter = Counter()
counter.step()
counter.step()
counter.step()
print(counter.count)   # 3

counter.step() is exactly the same as calling Counter.step(counter) — Python fills in self automatically from the object before the dot.

Inside the body, self is a normal parameter. Write self.x to read a field, self.x = ... to change one. The name self is a strong convention in Python; every method should use it.

Built-in method calls

Python's built-in types use the same mechanism. A string is an object; calling s.upper() passes s as self to the string's upper method:

name = "keiko"

print(name.upper())    # KEIKO
print(len(name))       # 5

Every method you call on a list, string, or dictionary works this way. Your own classes behave identically.

A small game object

Method syntax shines when several pieces of state go together. Here is a dog with a name and a number of barks left:

class Dog:
    def __init__(self, name, barks_left):
        self.name = name
        self.barks_left = barks_left

    def bark(self):
        if self.barks_left <= 0:
            print(f"{self.name} is hoarse.")
            return
        print(f"{self.name}: Woof!")
        self.barks_left = self.barks_left - 1

dog = Dog("Rex", 3)
dog.bark()       # Rex: Woof!
dog.bark()       # Rex: Woof!
dog.bark()       # Rex: Woof!
dog.bark()       # Rex is hoarse.

The Dog object holds the state; the method changes it on every call. This is the core of object orientation: an object with data and the methods that act on it.

Common mistake: forgetting self in the definition

If you forget self as the first parameter, Python still passes the object, but your method receives it in the wrong slot:

class Counter:
    def __init__(self):
        self.count = 0

    def step():         # missing self
        self.count += 1

c = Counter()
c.step()   # TypeError: step() takes 0 positional arguments but 1 was given

The fix is always to add self as the first parameter of every method.

Homework

Stuck or finished? Open the homework solutions page.