In Python, self is not a language keyword, but a conventional name for the first parameter in instance methods, referring to the instance object that calls the method. Its explicit presence embodies Python’s core design philosophy: explicit is better than implicit, everything is an object, and a simple and consistent calling model.
1. What is the essence of self?
First, it is important to know that self is not a keyword in Python and has no special syntax meaning. It is merely a conventional name for the first parameter in instance methods, used to represent “the current object’s instance reference.”
For example:
class Dog: def bark(self): print("Woof!")When we execute:
d = Dog()d.bark()Python actually makes the following call internally:
Dog.bark(d)This means that self is the object instance d that calls the method. Therefore, the bark() method can access the object’s attributes and other methods through self.
2. Why must self be explicitly written?
Many object-oriented languages (like Java, C++) have a hidden parameter this, which is automatically present in methods. Python does not do this, due to its philosophy of “everything is an object”: methods are essentially function objects, just stored in the class’s namespace.
Python does not want to make “methods” a special syntax, but rather implements method calls through the mechanism of binding ordinary functions to objects. This design makes the relationship between functions, classes, and instances more transparent and flexible.
Python does not automatically inject the “instance reference”; the first parameter must be explicitly declared, and the community has conventionally named it self.
This makes the method calling rules simple and consistent: any function bound to an instance will have its first parameter receive the instance object.
3. The binding mechanism of methods: how self is passed in
To understand self, one must first understand how methods are bound in Python.
When we access a method via instance.method, Python performs the following steps:
1. Look for the corresponding function object of the method in the class to which the instance belongs.
2. If the function object f is found, its __get__() method is triggered (this is implemented through the descriptor mechanism).
3. The __get__() method returns a bound method object, which internally holds a reference to the current instance.
4. When we call this bound method, Python automatically passes the saved instance as the first parameter (i.e., self) to the original function.
Example:
class A: def show(self, x): print(self, x)
a = A()a.show(10)The above call is actually equivalent to:
A.show(a, 10)In other words:
🔹When accessing a method through an instance, a “bound method” with the bound instance is obtained, and self is automatically passed in during the call.
🔹When accessing a method through a class, a regular function is still obtained, and the instance must be explicitly passed as self during the call.
4. Comparison of three types of method bindings
There are three types of method binding in Python:
| Method Type | Decorator | First Parameter | Implicitly Bound Object | Usage |
|---|---|---|---|---|
| Instance Method | (none) | <span><span>self</span></span> |
Instance | Access or modify instance state |
| Class Method | <span><span>@classmethod</span></span> |
<span><span>cls</span></span> |
Class object | Operate on the class itself (e.g., factory methods) |
| Static Method | <span><span>@staticmethod</span></span> |
(none) | None | Utility function, does not depend on instance or class |
Example:
class Example: def instance_method(self): print("Instance method", self)
@classmethod def class_method(cls): print("Class method", cls)
@staticmethod def static_method(): print("Static method")Calling methods:
obj = Example()obj.instance_method() # Automatically passes instanceExample.class_method() # Automatically passes classExample.static_method() # Does not pass any object5. The role of self in inheritance and polymorphism
self always points to the actual object that calls the method. Even if the method is defined in a parent class and called after being inherited by a subclass, self still points to the subclass instance.
Example:
class Animal: def speak(self): print("Animal speaking:", type(self).__name__)
class Cat(Animal): pass
class Dog(Animal): pass
Cat().speak() # Animal speaking: Cat
Dog().speak() # Animal speaking: DogThe self accessed within the Animal.speak() method is bound at runtime to the Cat or Dog instance, which is the basis of polymorphism.
6. The collaboration of super() and self
When using super() in inheritance, Python finds the parent class’s method based on the method resolution order (MRO), but self does not change.
class Base: def show(self): print("Base:", self)
class Sub(Base): def show(self): print("Sub before") super().show() # Calls Base.show(self)
print("Sub after")
s = Sub()s.show()Output:
Sub beforeBase: <__main__.Sub object ...>Sub afterNote: Although super().show() calls the parent class method, self remains the Sub instance.
7. Common errors and misconceptions
(1) Omitting the self parameter in method definitions
class Bad: def func(): print("missing self")
Bad().func() # TypeError: Bad.func() takes 0 positional arguments but 1 was givenReason for the exception: When calling a method through an instance, Python automatically passes the instance itself as the first parameter, but the method definition does not reserve a place to receive that parameter.
(2) Misunderstanding that self is a fixed keyword
In fact, self is just a conventional parameter name and can be replaced with any name:
class A: def f(this): print(this)However, doing so violates Python community coding standards and severely harms code readability and consistency. According to PEP 8 conventions, always use self to represent the first parameter of instance methods and cls for the first parameter of class methods.
(3) Confusing class attributes with instance attributes
class Counter: count = 0 # This is a class attribute, shared by all instances
def __init__(self): self.count += 1 # This actually creates a new instance attribute!To modify a class attribute, it should be explicitly referenced by the class name:
Counter.count += 1 # Correctly modifies the class attribute8. The design philosophy of self
From a language design perspective, the design of self reflects several core principles of Python.
(1) Explicit is better than implicit
self is explicitly written as the first parameter of methods, clearly indicating the process of instance passing, avoiding the implicit behavior brought by hidden this pointers in other languages.
(2) Everything is an object
In Python, methods themselves are also objects. Specifically, they are function objects bound to classes. The binding process of methods is implemented through the descriptor protocol, rather than special syntax rules, reflecting the consistency of Python’s object model.
(3) A simple and consistent calling model
Whether it is obj.method() or Class.method(obj), they essentially pass the instance as the first parameter to the function. This design eliminates the conceptual difference between method calls and function calls, maintaining semantic consistency.
📘 Summary
In Python, self is the conventional name for the first parameter in instance methods. Through self, instance methods can access and modify the state of the object and naturally support inheritance and polymorphism features. Even when calling parent class methods through super(), self still correctly points to the actual object that initiated the call.
Therefore, a deep understanding of self not only helps grasp the underlying mechanism of method binding but is also an important cornerstone for thoroughly understanding Python’s object-oriented programming design philosophy.
“Likes are a form of appreciation, and appreciation is encouragement”