c+和python的区别-与C ++相比，Python中方法和函数之间的差异

如果您仍然不了解方法的工作方式，那么看一下实现也许可以澄清问题。当引用的实例属性不是数据属性时，将搜索其类。如果名称表示作为函数对象的有效类属性，则通过将实例对象和刚在抽象对象中一起找到的函数对象打包（指向）来创建方法对象：这是方法对象。当使用实参列表调用方法对象时，将从实例对象和实参列表构造一个新的实参列表，并使用该新的实参列表来调用函数对象。

http://docs.python.org/2/tutorial/classes.html#method-objects

仔细阅读本节录。

它的意思是 ：

1）实例并不真正拥有一个对象，而该对象是将作为其属性的方法。

实际上，__dict__实例的中根本没有“方法”属性（__dict__是对象的名称空间）

2）实例在调用“ method”属性时似乎具有“ method”的事实是由于过程，而不是实例名称空间中是否存在方法对象

3）而且，在类的名称空间中实际上并不存在方法对象。

但是实例之间是有区别的，因为在完成这样的调用后，一定有某个地方可以导致一个真正的方法对象，一定不是吗？

为了易于表达，所谓的类的“方法”属性实际上是在类的命名空间中的功能对象。

也就是说，一对（函数的标识符，函数）是类的成员__dict__，并且此属性允许解释器在执行方法调用时构造方法对象。

4）同样，当调用“ method”属性时，类似乎具有“ method”的事实是由于过程，而不是由于类的名称空间内是否存在方法对象

编辑我对此不太确定；最后看

5）方法对象（不是“方法”对象；我的意思是，真正的对象实际上是方法的一部分，摘录中有描述）是在调用时创建的，以前不存在。

它是一种包装器：它包装指向实例对象和方法所基于的函数对象的指针。

因此，一种方法基于功能。对我来说，此函数是持有该“方法”的类的真实属性，因为该函数实际上属于__dict__该类的名称空间（）：该函数在__dict__打印时描述为。

可以使用别名im_func或从方法对象访问此功能__func__（请参见下面的代码）

。

我相信这些概念并不是很普遍地被理解和理解。但是以下代码证明了我所说的话。

class A(object):

def __init__(self,b=0):

self.b = b

print 'The __init__ object : ',__init__

def addu(self):

self.b = self.b + 10

print ' The addu object : ',addu

print ' The A.__dict__ items : ',

print ' '.join(' {0:{align}11} : {1}'.format(*it,align='^')

for it in A.__dict__.items())

a1 = A(101)

a2 = A(2002)

print ' The a1.__dict__ items:'

print ' '.join(' {0:{align}11} : {1}'.format(*it,align='^')

for it in a1.__dict__.items())

print ' The a2.__dict__ items:'

print ' '.join(' {0:{align}11} : {1}'.format(*it,align='^')

for it in a2.__dict__.items())

print ' A.addu.__func__ :',A.addu.__func__

print id(A.addu.__func__),'==',hex(id(A.addu.__func__))

print

print 'A.addu : ',

print A.addu,' ',id(A.addu),'==',hex(id(A.addu))

print 'a1.addu : ',

print a1.addu,' ',id(a1.addu),'==',hex(id(a1.addu))

print 'a2.addu : ',

print a2.addu,' ',id(a2.addu),'==',hex(id(a2.addu))

a2.addu()

print ' a2.b ==',a2.b

print ' The A.__dict__ items : ',

print ' '.join(' {0:{align}11} : {1}'.format(*it,align='^')

for it in A.__dict__.items())

结果

The __init__ object :

The addu object :

The A.__dict__ items :

__module__ : __main__

addu :

__dict__ :

__weakref__ :

__doc__ : None

__init__ :

The a1.__dict__ items:

b : 101

The a2.__dict__ items:

b : 2002

A.addu.__func__ :

18765040 == 0x11e54f0

A.addu :

18668040 == 0x11cda08

a1.addu :

>

18668040 == 0x11cda08

a2.addu :

>

18668040 == 0x11cda08

a2.b == 2012

The A.__dict__ items :

__module__ : __main__

addu :

__dict__ :

__weakref__ :

__doc__ : None

__init__ :

。

编辑

有些事情困扰着我，我不知道这个主题的深深内在之处：

上述代码显示A.addu，a1.addu并a2.addu都具有相同的方法对象，具有一个唯一的标识。

不过A.addu据说一个未绑定的方法，因为它没有涉及的特定实例的任何信息，

并a1.addu和a2.addu据说绑定方法，因为每个人都有指定的信息必须由该方法的操作中涉及的实例。

从逻辑上来说，对我而言，这意味着这3种情况下的方法应该有所不同。

但是，这三个身份相同，而且该身份不同于该方法所基于的功能的身份。

得出的结论是，该方法实际上是存在于内存中的一个对象，并且从一个实例的一个调用到另一个实例的另一个cal都没有改变。

但是，__dict__即使在创建实例和调用“方法”之后，也要打印类的名称空间addu()，该名称空间不会向addu功能对象以外的方法对象公开可以识别的新对象。

这是什么意思 ？

它给我的印象是，方法对象一经创建，就不会被破坏，而是驻留在内存（RAM）中。

但是它隐藏着，只有形成干扰者功能的过程才知道如何以及在哪里找到它。

这个隐藏的对象，即真正的方法对象，必须具有更改对该函数必须应用到的实例的引用的能力，或者可以将其更改None为未绑定方法的引用。在我看来，这就是头脑风暴的假设。

有人对这次审讯有所了解吗？

为了回答这个问题，调用.upper和.lower 函数可以认为是正确的，因为实际上它们是作为类的每个方法基于函数的。

但是，以下结果很特殊，可能是因为它们是内置的方法/函数，而不是我的代码中的用户方法/函数。

x = 'hello'

print x.upper.__func__

结果

print x.upper.__func__

AttributeError: 'builtin_function_or_method' object has no attribute '__func__'