Java Python真的为每个新实例创建了所有绑定方法吗？

我正在阅读Python（3.4）中的类，据我所知，似乎每个新对象都有自己的绑定方法实例

class A:

    def __init__(self, name):
        self.name = name

    def foo(self):
        print(self.name)

a = A('One')
b = A('Two')

print(a.foo ==  b.foo)

此操作的输出为

False

在我看来，这是对记忆的浪费。我认为内部

a.foo

和

b.foo

会以某种方式在内存中指向一个函数：

a.foo

，其中

self

作为类实例将被传递

我认为这在语言中可能不容易实现

每个新实例是否也包含其绑定方法的新实例

如果是这样的话，这是否会影响性能，或者有理由比在其他语言中更谨慎地创建新对象，因为在其他语言中，方法是在对象之间“共享”的，比如在Java中？

每次访问方法时，都会按需绑定方法

访问函数名将调用，函数对象上的调用将返回绑定方法

绑定方法是围绕函数对象的薄包装器；它存储对原始函数和实例的引用。调用方法对象时，它会将调用传递给函数，并插入实例作为第一个参数

创建实例时不会创建方法，因此事先不需要额外的内存

您可以手动重新创建步骤：

>>> class A:
...     def __init__(self, name):
...         self.name = name
...     def foo(self):
...         print(self.name)
... 
>>> a = A('One')
>>> a.foo
<bound method A.foo of <__main__.A object at 0x100a27978>>
>>> a.foo.__self__
<__main__.A object at 0x100a27978>
>>> a.foo.__func__
<function A.foo at 0x100a22598>
>>> A.__dict__['foo']
<function A.foo at 0x100a22598>
>>> A.__dict__['foo'].__get__(a, A)
<bound method A.foo of <__main__.A object at 0x100a27978>>
>>> A.__dict__['foo'].__get__(a, A)()
One

---

这种体系结构还可以使对象工作。您可以创建自己的描述符，创建一系列有趣的绑定行为。

我制作的解密检查器显示，函数保存在主类

a

字典中，并在实例之间共享。但最后几行显示，一旦我们绑定了方法，它们就位于唯一的内存地址上

class A:

    def __init__(self, name):
        self.name = name

    def foo(self):
        print(self.name)

a = A('One')
b = A('Two')

d=a.__dict__
D=A.__dict__
print('dict a:', d)
print('dict A:', D)

print(D['foo']) #<function A.foo at 0x000001AF4258CC80>
# both next __func__ point to the parent dict
print(a.foo.__func__) #<function A.foo at 0x000001AF4258CC80>
print(b.foo.__func__) #<function A.foo at 0x000001AF4258CC80>

print(a.foo)
print(b.foo)
#already bound on unique address
print(a.foo==b.foo)

A类：
定义初始化（self，name）：
self.name=名称
def foo（self）：
打印（self.name）
a=a（‘一’）
b=A（‘两’）
d=a.。uu dict__
D=A.。uu dict__
打印（'dict a:'，d）
打印（'dict A:'，D）
打印（D['foo']）#
#两个next _; func _;都指向父dict
打印（a.foo.\u func\u）#
打印（b.foo.\u func\u）#
印刷品（a.foo）
印刷品（b.foo）
#已绑定到唯一地址
打印（a.foo==b.foo）

---

完整输出：

dict a: {'name': 'One'}
dict A: {'__module__': '__main__', '__init__': <function A.__init__ at 0x000001AF425D3730>, 'foo': <function A.foo at 0x000001AF425D3620>, '__dict__': <attribute '__dict__' of 'A' objects>, '__weakref__': <attribute '__weakref__' of 'A' objects>, '__doc__': None}
<function A.foo at 0x000001AF425D3620>
<function A.foo at 0x000001AF425D3620>
<function A.foo at 0x000001AF425D3620>
<bound method A.foo of <__main__.A object at 0x000001AF425E21D0>>
<bound method A.foo of <__main__.A object at 0x000001AF42375C50>>
False

dicta:{'name'：'One'}
格言A:{“格言模块”：“格言模块”：“格言模块”：“格言模块”：“格言模块”：“格言模块”：“格言模块”：“格言模块”：“格言模块”：“格言模块”：“格言模块”：“格言模块”：“格言模块”：“格言模块”：“格言模块”：“格言模块”：“格言模块”：“格言模块”：“格言模块”：“格言模块”：“格言模块”：“格言模块”：“格言模块”：“格言模块”：“格言模块”：“格言模块”：“格言模块”：“格言模块”：“
假的

你能链接到你读到的让你产生这种想法的东西吗？@SotiriosDelimanolis

X（）.f==X.f

会导致

错误（其中f是instace方法）。不过，每个绑定方法都引用相同的底层函数。包装器的内存开销是最小的，这里也是你的答案，所以你得到了你显然不需要更多的代表；o） @jonrsharpe:哈，但这张已经被接受了！：-P我没有完全重读这里的问题；回想起来，问题和答案都是完美的复制品。我觉得在另一个帖子上还有更多的东西要解释。
dict a: {'name': 'One'}
dict A: {'__module__': '__main__', '__init__': <function A.__init__ at 0x000001AF425D3730>, 'foo': <function A.foo at 0x000001AF425D3620>, '__dict__': <attribute '__dict__' of 'A' objects>, '__weakref__': <attribute '__weakref__' of 'A' objects>, '__doc__': None}
<function A.foo at 0x000001AF425D3620>
<function A.foo at 0x000001AF425D3620>
<function A.foo at 0x000001AF425D3620>
<bound method A.foo of <__main__.A object at 0x000001AF425E21D0>>
<bound method A.foo of <__main__.A object at 0x000001AF42375C50>>
False