在python中从类vs对象调用函数

实际上，我在浏览python文档时遇到了这个示例

>>> class D(object):
     def f(self, x):
          return x

>>> d = D()
>>> D.__dict__['f'] # Stored internally as a function
<function f at 0x00C45070>
>>> id(D.__dict__['f']) # Memory location
49294384
>>> D.f             # Get from a class becomes an unbound method
<unbound method D.f>
>>> id(D.f )
48549440
>>> d.f             # Get from an instance becomes a bound method
<bound method D.f of <__main__.D object at 0x00B18C90>>
>>> id(d.f)
48549440

>>D类（对象）：
def f（自身，x）：
返回x
>>>d=d（）
>>>D.uu dict_uu['f']#作为函数内部存储
>>>id（D.uu dict_uu['f']）#内存位置
49294384
>>>D.f#从类中获取成为未绑定的方法
>>>身份证（D.f）
48549440
>>>d.f#从实例获取成为绑定方法
>>>身份证（d.f）
48549440

因此，从上面的代码中，我了解到python将类的

函数定义/声明

作为一个单独的对象存储在类

\uuuu dict\uuuu

变量内部，当我们使用

\uuuu dict\uuu

变量直接访问时，它的内存位置为

49294384

但是，当通过

类或对象访问时，为什么它显示为不同的函数/方法对象，具有不同的
内存位置48549440

当我们使用
\uu dict\uu
变量访问时，它不应该引用同一个对象吗？。如果是，为什么？
D.f
是一个带一个参数的函数（
self
）

d.f
是一种“绑定方法”，即已填入
self
参数的函数。你可以说

x = d.f
x()

因此，它不能与
D.f
相同，必须位于不同的位置。
xtofi解释了描述符对象（未绑定）和绑定方法之间的差异

我认为缺少的部分是绑定方法并没有保存在内存中，它们实际上是在每次访问它们时创建的。（您可能会得到相同的内存位置，但它不是同一个对象）

为什么？
因为对描述符的每次调用都可能导致不同的行为。这里有一个例子来解释这个想法

class A(object):
    i = 'a'

    @property
    def name(self):
        if A.i == 'a':
            return self.fa()
        else:
            return self.fb()

    def fa(self):
        print 'one function'

    def fb(self):
        print 'another function'

在一个实例上调用函数
name
会导致不同的函数调用。
如果你看一下我的示例，当我将函数作为属性访问时，
D.f和D.f
的内存位置都是相同的，我对此感到困惑，这是什么行为？id

与“内存位置”？是的，当我提到内存位置时，它是IDF表达式

d.f

产生一个临时对象。多次调用它可能会产生不同的结果（但内存可能会被重用）。例如，尝试

[id（x）for x in（d.f，d.f，d.f，d.f）]

。您的代码来自Python 2，但您链接到的文档是Python 3。Python3.Related/dupe中不再存在“Unbound methods”：@DanielRoseman，是的，很抱歉，我使用的是Python2.7，但文档中的代码都是一样的

class A(object):
    i = 'a'

    @property
    def name(self):
        if A.i == 'a':
            return self.fa()
        else:
            return self.fb()

    def fa(self):
        print 'one function'

    def fb(self):
        print 'another function'