关于python：通过getattr访问方法

Accessing methods via getattr

我偶然发现了这种行为，这表明您可以使用getattr在类实例上调用方法，作为直观命名operator.methodcaller的替代方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

from operator import methodcaller

class Foo():
def __init__(self, lst):
self.lst = lst

def summer(self):
return sum(self.lst)

my_obj = Foo(range(11))

res1 = methodcaller('summer')(my_obj) # 55
res2 = getattr(my_obj, 'summer')() # 55

assert res1 == res2

我想从内部了解一下为什么这样做有效。是因为所有方法都是属性吗？这似乎是因为dir(Foo)或dir(my_obj)包括'summer'。但我从来没有听说过被称为类或类实例属性的方法，例如，在Python中什么是"方法"中没有提到这一点？

文档中有一个解释提到了"数据属性"和"非数据属性"之间的区别，但我没有理解。

更新：由@amadan发表的评论澄清了上述大部分内容。我唯一不明白的一点是从文档中摘录的：

If you still don’t understand how methods work, a look at the
implementation can perhaps clarify matters. When a non-data attribute
of an instance is referenced, the instance’s class is searched. If
the name denotes a valid class attribute that is a function object, a
method object is created by packing (pointers to) the instance object
and the function object just found together in an abstract object:
this is the method object.

那么，非数据属性是通过检查它是否可调用来确定的，还是有其他方法用来确定它是一个函数对象？"打包指向实例对象的指针"是什么意思？什么是抽象对象？

相关讨论

是的，方法只是包含适当形式的函数的属性(它们必须接受至少一个参数，即接收器，通常称为self)。

下面是一个解释引用段落的示例：

1
2
3
4
5
6
7

class Foo():
def a(self):
print("FOO")

foo = Foo()
foo.a()
# => FOO

因此，def实际上在python 2中附加了一个属性a到Foo，作为"未绑定方法"(正如我们检查它时看到的那样，它还不知道是谁接收它)，或者只是一个普通函数值(在python 3中)：

1
2
3

Foo.a
# => <unbound method Foo.a> (Python 2)
# => <function Foo.a at 0x10919fea0> (Python 3)

您可以像调用任何函数一样调用它(…有一个例外，在python 2中：第一个参数必须是Foo类型：

1
2
3
4
5
6

Foo.a(foo)
# => FOO

Foo.a(42)
# => TypeError: unbound method a() must be called with Foo instance as first argument (got int instance instead) (Python 2)
# => 42 (Python 3)

但是，如果您试图在实例("实例属性引用")上找到它，它现在报告为"绑定方法"：

1 2	foo.a # => <bound method Foo.a of <__main__.Foo instance at 0x10ba11320>>

这可以说是"将实例对象和函数对象打包在一起"：在一个包中有一个对实例对象的引用，即<__main__.Foo instance at 0x10ba11320>(a.k.a.Foo)和一个对函数对象的引用，即Foo.a，我们称之为"绑定方法"。

与JavaScript不同，它不是纯粹的句法问题。在javascript中，方法调用和函数调用的区别在于调用本身：如果它有一个点，则它是一个方法调用：

1
2
3
4

// JavaScript
let foo = new Foo()
foo.a(); // method invocation: `a` is told that the receiver is `foo`
let z = foo.a; z() // function invocation, `a` doesn't know about `foo`

在python中，绑定函数在其内部携带其接收器：

1
2
3

// Back to Python
foo.a() // method invocation: `a` is told that the receiver is `foo`
z = foo.a; z() // STILL method invocation; `z` knows both `foo` and `Foo.a`

这个电话怎么用？段落的其余部分解释了：

When the method object is called with an argument list, a new argument list is constructed from the instance object and the argument list, and the function object is called with this new argument list.

所以，当我们说

foo.a()

它将把Foo.a解包成Foo.a和Foo；把接收者Foo预先放在参数列表中(这里没有，所以参数列表是[foo] + []作为[foo]的最终参数列表)，最后被称为Foo.a(foo)。顺便说一下，这正是您可以手动执行的操作：

1 2	Foo.a(foo) # => FOO

即使有内置对象：

1
2
3
4

"-".join(["foo","bar","baz"])
# => 'foo-bar-baz'
str.join("-", ["foo","bar","baz"])
# => 'foo-bar-baz'

这里，"-".join是一种绑定方法，它将接收端"-"和函数str.join打包在一起；当我们调用第一行时，接收端"-"是为["-", ["foo","bar","baz"]]的最后一个参数列表准备的其余参数[["foo","bar","baz"]]的，并发送到join中的函数。)EDOCX1的属性〔22〕(即str.join)。这给了我们一个清晰的第一行和第二行之间的翻译。