6

可以使用 getattr(obj, attr) 或 inspect.getmembers(obj) 获取对象属性，然后按名称过滤：

import inspect

class Foo(object):

    def __init__(self):

        self.a = 100

    def method(self): pass

foo = Foo()
method_by_getattr = getattr(foo, 'method')

foo_members = inspect.getmembers(foo) 
method_by_inspect = [member[1] for member in foo_members 
                        if member[0] == "method"][0]

print (id(method_by_getattr), method_by_getattr, type(method_by_getattr))
print (id(method_by_inspect), method_by_inspect, type(method_by_inspect))

a_by_getattr = getattr(foo, "a")
a_by_inspect = [member[1] for member in foo_members
                        if member[0] == "a"][0]

print (id(a_by_getattr), a_by_getattr, type(a_by_getattr))
print (id(a_by_inspect), a_by_inspect, type(a_by_inspect))

# (38842160L, <bound method Foo.method of <__main__.Foo object at 0x00000000025EF390>>, <type 'instancemethod'>)
# (39673576L, <bound method Foo.method of <__main__.Foo object at 0x00000000025EF390>>, <type 'instancemethod'>)
# (34072832L, 100, <type 'int'>)
# (34072832L, 100, <type 'int'>)

对于“a”属性，getattr 和 inspect.getmembers 返回相同的对象。但是对于“方法”方法，它们返回不同的对象（从不同的 id 可以看出）。

为什么会这样？

4

2 回答 2

10

毫驼得到绿色检查，但我想我会添加一点。

tl;博士

绑定的方法对象是瞬态的。也就是说，每次您抓取它们时都会重新创建它们。

class Foo(object):
    def bar(object): pass

foo = Foo()
m1 = foo.bar
m2 = foo.bar
print (id(m1))
print (id(m2))

# 38121264
# 38952752

更多细节：描述符协议

每次获取绑定的方法对象时都会重新创建它们，因为存储在类中的函数对象实现了描述符协议。

bar 函数存储在类 dict 中：

class Foo(object):
    def bar(object): pass

print (Foo.__dict__['bar'])

# <function bar at 0x00000000025F2208>

当 Foo 实例尝试访问 bar 时，它没有它。所以它在它的类上查找它并在类字典中找到它。函数对象根据描述符协议实现__get__方法。所以实际调用来获取绑定方法是这样的：

print(Foo.__dict__['bar'].__get__(foo, Foo))

# <bound method Foo.bar of <__main__.Foo object at 0x00000000025719B0>>

这相当于：

print (foo.bar)

# <bound method Foo.bar of <__main__.Foo object at 0x00000000025719B0>>

您可以像这样获得原始功能：

print (foo.bar.im_func) # Python 2.x

# <function bar at 0x00000000025F2208>    

print (foo.bar.__func__) # Python 3.x

# <function bar at 0x00000000025F2208>
于 2012-10-12T12:04:58.000 回答
6

我对您的示例进行了一些重组，以更好地说明我将用来解释行为的变体

带有临时变量

import inspect

def print_id(obj):
    print "{} => {}".format(id(obj), obj)

def getmember(obj, name):
    #members = dict(inspect.getmembers(obj))
    #return members[name]
    return [member 
            for _name, member in inspect.getmembers(obj) 
            if name == _name][0]

class Foo(object):
    def bar(self): pass

foo = Foo()

m1 = foo.bar
m2 = getattr(foo, 'bar')
m3 = getmember(foo, 'bar')

print_id(m1)
print_id(m2)
print_id(m3)

但是，如果您检查 REPL 中的对象，您的代码的基本结构可能如下所示：

没有临时变量

#...
foo = Foo()

print_id(foo.bar)
print_id(getattr(foo, 'bar'))
print_id(getmember(foo, 'bar'))

该id()函数基本上返回对象的内存地址。也就是说，它不是在整个程序运行时创建的所有对象之间唯一的标识。它仅在任何给定时间点存在于流程中的所有对象之间是唯一的。

适合这两个示例之间差异的解释是，foo.bar以三种方式中的任何一种解析每次都会为您提供一个新对象。在第一个示例中，这些对象存储在临时变量中，因此所有三个必须位于不同的内存地址。

在第二个例子中，绑定的方法对象在打印出来后就不再需要了；Python 引用计数 GC 将释放其内存。这意味着下一次创建绑定的方法对象时，它是一个新对象，恰好在与前一个相同的内存地址创建。这就是为什么您似乎多次获得同一个对象的原因。

你总是得到一个新的绑定方法对象可以简单地显示：

>>> foo.bar == foo.bar
True
>>> foo.bar is foo.bar
False
于 2012-10-11T22:03:42.223 回答