作为实例方法调用时行为不同的类方法？

Question

我想知道是否有可能创建一个在作为类方法调用时与作为实例方法调用时行为不同的方法。

例如，作为一个技能改进项目，我正在编写一个Matrix 类（是的，我知道已经有非常好的矩阵类）。我为它创建了一个名为identity 的类方法，它返回一个指定大小的单位矩阵。

现在，当在Matrix 的实例 上调用时，不需要指定大小似乎是合乎逻辑的；它应该返回一个与调用它的Matrix 大小相同的单位矩阵。

换句话说，我想定义一个方法，它可以确定它是否是通过实例调用的，如果是，则访问该实例的属性。不幸的是，即使在浏览了文档和一些谷歌搜索之后，我也没有发现任何表明这是可能的。有人知道不同吗？

编辑：

哇！显然，我还不太习惯一流的功能。这就是我最终得到的结果——感谢 Unknown 提供了密钥！

class Foo(object):
    def __init__(self, bar):
        self.baz = bar
        self.bar = MethodType(lambda self: self.__class__.bar(self.baz), self, self.__class__)

    @classmethod
    def bar(cls, baz):
        return 5 * baz

Foo.bar(3) # returns 15

foo = Foo(7)
foo.bar() # returns 35

编辑 2：

简单说明一下 - 这种技术（以及下面介绍的大多数技术）不适用于定义 __slots__ 的类，因为您无法重新分配该方法。

Answer 1

我认为更大的问题是您在类 'Foo' 上重载了名称 'bar'，这是 python 不允许的。 “bar”的第二个定义破坏了“bar”的第一个定义。

尝试为您的类方法和实例方法考虑唯一名称。即

@classmethod
def create(cls, baz):
   ...

def rubber_stamp(self):
   ...

Answer 2

[已编辑：使用属性作为更直接的答案；请参阅 John Fouhy 的有用评论]

你可以使用描述符来做你想做的事：

class cls_or_inst_method(object):
    def __init__(self, class_method, instance_method):
        self.class_method = class_method
        self.instance_method = instance_method

    def __get__(self, obj, objtype):
        if obj is None:
            return self.class_method
        else:
            return lambda: self.instance_method(obj)

def my_class_method(baz):
    return baz + 1

def my_instance_method(self):
    return self.baz * 2

class Foo(object):
    baz = 10
    bar = cls_or_inst_method(my_class_method, my_instance_method)

使用上面的：

>>> print Foo.bar(5)
6
>>> my_foo = Foo()
>>> print my_foo.bar()
20

Answer 3

您可以在 init 中使用短 lambda 函数重新分配您的身份方法：

class Matrix(object):
    def __init__(self):
        self.identity = lambda s=self:s.__class__.identity(s)

        #...whatever initialization code you have...
        self.size = 10        

    @classmethod
    def identity(self, other):
        #...always do you matrix calculations on 'other', not 'self'...
        return other.size


m = Matrix()
print m.identity()
print Matrix.identity(m)

如果您不熟悉 lambda，它会创建一个匿名函数。它很少需要，但它可以使您的代码更简洁。上面的 lambda 行可以重写：

    def identity(self):
        self.__class__.indentity(self)
    self.identity = identity

Answer 4

@Unknown 你的和这个有什么区别：

class Foo(object):

    def _bar(self, baz):
        print "_bar, baz:", baz

    def __init__(self, bar):
        self.bar = self._bar
        self.baz = bar

    @classmethod
    def bar(cls, baz):
        print "bar, baz:", baz

In [1]: import foo

In [2]: f = foo.Foo(42)

In [3]: f.bar(1)
_bar, baz: 1

In [4]: foo.Foo.bar(1)
bar, baz: 1

In [5]: f.__class__.bar(1)
bar, baz: 1

Answer 5

有用的 Python hack 是我的强项。

from types import *

class Foo(object):
    def __init__(self):
        self.bar = methodize(bar, self)
        self.baz = 999

    @classmethod
    def bar(cls, baz):
        return 2 * baz


def methodize(func, instance):
    return MethodType(func, instance, instance.__class__)

def bar(self):
    return 4*self.baz


>>> Foo.bar(5)
10
>>> a=Foo()
>>> a.bar()
3996