为什么我们更喜欢使用self.method（）而不是Class.method（self）

Question

For example, for some class:

class Class(object):
    def __init__(self):
        pass

    def something(self):    # yes I know this could be static
        print("something")

and instance

instance = Class()

the following are both technically valid:

instance.something()       # normal
Class.something(instance)  # but also technically valid

Is there some explicit reasoning why the first use case is preferred? I can think of examples like iterating over instances and calling methods, but I can also think of some cases where it may be easier to interpret my code when explicit reference to the Class I am using is visible.

Apologies if this has been answered before. I could not find it, which may be due to my difficulty in phrasing the question.

Answer 1

Class.something(instance) grabs the method from a specific class . self.something() uses the class for that instance, and that is not necessarily the same class .

You also repeat yourself a lot if you have to keep using the class name.

Your title uses self , which indicates code inside a method. Compare the output of the following examples:

class Animal:
    def make_sound(self):
        print('General nature sounds')

    def startle(self):
        self.make_sound()

    def pet(self):
        Animal.make_sound(self)

class Dog(Animal):
    def make_sound(self):
        # overrides Animal.make_sound()
        print('Bark!')

dog = Dog()
dog.startle()  # prints "Bark!"
dog.pet()      # prints "General nature sounds"

Animal.make_sound(self) works, but will use the original method, ignoring the new implementation for Dog.make_sound() .

For the case where you have a reference to an instance somewhere else, consider the case where you accept a class or a subclass :

class Cat(Animal):
    def make_sound(self):
        print('Meouw!')

def groom_pet(pet):
    pet.startle()
    Animal.make_sound(pet)

groom_pet(Cat())  # prints "Meouw", then "General nature sounds"

So we have a new subclass of Animal , and groom_pet() can accept any Animal instance, because subclasses will also have the same methods. But pet.startle() will end up calling the right make_sound() implementation, while Animal.make_sound() will again bypass the correct implementation.

Very rarely should you use the unbound class method over the bound method on an instance. There are reasons to use this sometimes ; specifically if you want to bypass a parent class method (so not using super().method() ), or if you want to improve performance and avoid looking up an attribute and binding the method in a tight loop.

Because such cases are rare and special, you want to stick to the normal idiom , because that aids understanding of your code for both yourself and other readers. Don't surprise those readers.