Why Does self Exist in Python?

self is simply the name that a method uses for the object it was called on. It is the first parameter of the method, and the interpreter passes the instance in automatically.

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

    def increment(self, by=1):
        self.count += by
        return self.count

    def who(self):
        return self


c = Counter()
print(c.increment())
print(c.increment(5))
print(c.who() is c)

The increment method reads and writes self.count, so each call works on the object it was called through. The who method returns self itself, and the identity check confirms that it is the very same object and not a copy of it.

The last line is worth pausing on, because the statement c.increment() is really just a short way of writing Counter.increment(c). Python looks up increment on the class and then calls it with the instance as the first argument. The dot notation is a convenience, and self is what makes that convenience work.

Because self is an ordinary parameter, it can be anything that the method is called with. That is what makes it possible to call a method in an unbound way, and it is also what makes the calling convention visible rather than hidden, because you can always see which object a method operates on by reading its first line.

Calling a method on the class does not supply an instance, so Python raises a TypeError that complains about the missing argument.

class Greeter:
    def hello(self):
        return 'hello'


try:
    Greeter.hello()
except TypeError as error:
    print('TypeError:', error)

# It works if you pass the instance yourself.
print(Greeter.hello(Greeter()))

The error message names the method and says that it takes 2 arguments but only 1 was given, because self counts as one of them. The second call shows the underlying mechanism. The class attribute is just a plain function, and you can call it with any object you like as the first argument, including an instance of a completely unrelated class.

That last point is the reason Python methods are sometimes called unbound functions when they are reached through the class, and it explains a common beginner mistake. Python has no implicit this of the kind that Java and C# use. The instance is always passed explicitly, so the method on the class needs one more argument.

There are two practical notes. Greeter.hello(Greeter()) works, but it is ugly, and the normal way to call a method is through an instance. The same rule applies to class methods and static methods, which behave differently. A class method receives the class as its first argument automatically, and a static method receives nothing at all.

Python passes the instance as the first argument of every method, and the name self is simply the conventional name for that parameter. It could be called anything, such as this or obj, and the code would work in exactly the same way, because the interpreter passes the instance positionally and the body of the method refers to it by name.

The reason the language works this way is that it has no implicit this. In Java and C# the receiver is supplied by the runtime and is referred to through a keyword that cannot be passed around or reassigned. Python makes the receiver an ordinary argument, and that means the method is an ordinary function that happens to take the instance first. This single decision explains several Python features. You can call a method with any object as the receiver, you can store a bound method and call it later, and a function whose first parameter looks like self can be used interchangeably as a method.

The cost is that self has to be written on every method definition and on every attribute access inside the method, and forgetting it produces the familiar TypeError about the number of arguments. There is no compiler check for it either, because the parameter really is optional at the language level.

Two related conventions complete the picture. PEP 8 says that self should be named self for instance methods, cls for class methods, and that it should always be the first argument. There are also a few idioms that deliberately do not follow the convention, namely static methods, which take no receiver at all, and the __new__ constructor, which receives the class because it runs before the instance exists.