Why are references to instance methods stored in each instance object rather than in the class object?

问题

From what I understand, each instance of a class stores references to the instance's methods.

I thought, in concept, all instances of a class have the same instance methods. If so, both memory savings and logical clarity seem to suggest that instance methods should be stored in the class object rather than the instance object (with the instance object looking them up through the class object; of course, each instance has a reference to its class). Why is this not done?

A secondary question. Why are instance methods not accessible in a way similar to instance attributes, i.e., through __dict__, or through some other system attribute? Is there any way to look at (and perhaps change) the names and the references to instance methods?

EDIT:

Oops, sorry. I was totally wrong. I saw the following Python 2 code, and incorrectly concluded from it that instance methods are stored in the instances. I am not sure what it does, since I don't use Python 2, and new is gone from Python 3.

import new
class X(object):
  def f(self):
    print 'f'
a = X()
b = X()
def g(self):
  print 'g'
# I thought this modified instance method just in a, not in b
X.f = new.instancemethod(g, a, X)

回答1:

From what I understand, each instance of a class stores references to the instance's methods.

I don't know where you got this from, but it's wrong. They don't.

Why are instance methods not accessible in a way similar to instance attributes, i.e., through __dict__, or through some other system attribute?

Well, because they are not stored on the instance.

Is there any way to look at (and perhaps change) the names and the references to instance methods?

Since these references don't exist, you cannot change them. You can of course create any attribute you want by normal assignments, but note that functions stored on the instance are not treated like ordinary methods -- the mechanism that implicitly passes the self parameter does not apply for them.

回答2:

Attribute lookup on objects in Python is non-trivial. But instance methods are certainly not stored on the instance object!

The default behavior for attribute access is to get, set, or delete the attribute from an object’s dictionary. For instance, a.x has a lookup chain starting with a.__dict__['x'], then type(a).__dict__['x'], and continuing through the base classes of type(a) excluding metaclasses.

(docs)

Note that it is possible to store a function on an instance. But that's not an instance method! When the interpreter looks up an attribute and finds that it is (a) a function and (b) on the class object, it automatically wraps it in a bound method object which passes self.

---

Is there any way to look at (and perhaps change) the names and the references to instance methods?

Well, you can certainly modify the class object after defining it. But I assume what you mean is "can you make the x method of a particular instance do something different?"

This being Python, the answer is "yes": just define a.x to be some new function. Then you will get that function back before looking on the class.

This may cause you a lot of confusion when you're trying to understand the code, though!

回答3:

Incorrect. Instances do not store references to each method.

For example:

class Foo():
    def bar(self):
        print 'bar'

f = Foo()
def alternate_bar(self):
    print 'alternate bar'

f.bar()    
Foo.bar = alternate_bar # modifies the class!
f.bar()

prints

bar
alternate bar

This is also why you provide a self to each method you define in a class. Without a reference to self, the method has no idea which instance it is working on.

回答4:

Another example

class Point:
    def __init__(self, xcoord, ycoord):
        self.x = xcoord
        self.y = ycoord
    def draw(self):
        print self.x, " ", self.y

p = Point(205.12, 305.21)

#draw the coordinates of the point instance

p.draw()

# now define a new point drawing function vdraw()

def vdraw(q):
    print "[",q.x,",",q.y,"]"

#p.draw()

#now reassign the draw() method to vdraw()

Point.draw = vdraw

# now print the coordinates of the point instance 

print p.x
print p.y

#now draw the coordinates of the point instance
p.draw()

来源：https://stackoverflow.com/questions/9774010/why-are-references-to-instance-methods-stored-in-each-instance-object-rather-tha