如何用自定义分类的元素中定义的特殊方法覆盖？

Question

例如，请考虑以下内容：

class FooMeta(type):
    def __len__(cls):
        return 9000


class GoodBar(metaclass=FooMeta):
    def __len__(self):
        return 9001


class BadBar(metaclass=FooMeta):
    @classmethod
    def __len__(cls):
        return 9002

len(GoodBar) -> 9000
len(GoodBar()) -> 9001
GoodBar.__len__() -> TypeError (missing 1 required positional argument)
GoodBar().__len__() -> 9001
len(BadBar) -> 9000 (!!!)
len(BadBar()) -> 9002
BadBar.__len__() -> 9002
BadBar().__len__() -> 9002

问题是 len（badbar）返回9000而不是9002，这是预期的行为。

此行为（某种程度上）在，但它没有提及ClassMethods，我真的不理解与 @ClassMethod Decorator的互动。

除了明显的Metaclass解决方案（即，替换/扩展 foometa ），还有一种方法可以覆盖或扩展MetaClass函数，以便 len（badbar） - ＆gt; 9002 ？

编辑：

要澄清，在我的特定用例中，我不能编辑元素，我不想对其进行亚类和/或制作自己的元素这样做。

Answer 1

当使用 len（...）对类本身使用 __ len __ ，始终将忽略类中的 当执行其运算符时，以及诸如“哈希”，“”，“可以粗略地说iTer”，“ len”具有“操作员状态”，Python总是通过直接符合类的内存结构来从目标类中检索相应的方法。这些dunder方法在类的内存布局中具有“物理”插槽：如果该方法存在于您实例的类中（在这种情况下，“实例”是“ boodbar”和“ badbar”类，则是“ badbar”，则是“ badbar”的实例。 foometa”）或它的超类之一，被称为 - 否则操作员会失败。

因此，这是适用于 len（goodbar（））的推理：它将调用 __ len __ 在 goodbar（）的类中定义的 ，和 len（goodbar）和 len（badbar）将调用 __ len __ __ 在其类中定义的， foometa

我不太了解与@classmethod的互动
装饰器。

“ classMethod”装饰器从装饰函数中创建了一个特殊的描述符，因此当通过“ getAttr”从类中检索它时，python也可以使用“ cls”参数创建一个“部分”对象。就像从一个实例中检索普通方法一样，用“自我”预绑来创建一个对象一样：

这两种内容都是通过“描述符”协议携带的 - 这意味着，通过调用其 __ get__ get __来检索一个普通方法和classMethod 方法。此方法采用3个参数：“自我”，描述符本身，“实例”，实例与“ body”和“所有者”：类别的类别。事实是，对于普通方法（函数），第二个（实例）参数到 __获取__ get __ is none none 时，函数本身将返回。 @ClassMethod 用不同的对象包装一个函数 __获取__ ：一个返回等同于 partial（方法，cls）的函数第二个参数到 __获取__ 。

换句话说，这个简单的纯Python代码复制 ClassMethod Decorator的工作：

class myclassmethod:
    def __init__(self, meth):
         self.meth = meth
    def __get__(self, instance, owner):
         return lambda *args, **kwargs: self.meth(owner, *args, **kwargs)

这就是为什么您在使用 klass.__ get __（）明确调用ClassMethod时会看到相同的行为。 Klass（）.__获取__（）：该实例被忽略。

tl; dr ： len（klass）将始终通过Metaclass插槽， klass .__ len __（）将检索/code>通过getAttr机制，然后在调用之前正确绑定分类。

除了明显的元素解决方案（即，更换/扩展foometa）
有没有办法覆盖或扩展元函数，以便
Len（Badbar） - ＆GT; 9002？

（...）
为了澄清，在我的特定用例中，我无法编辑元素，我
不想将其分类和/或制作我自己的元素，除非是
这样做的唯一可能的方法。

没有其他方法。 len（badbar）将始终通过Metaclass __ Len __ 。

不过，扩展元口可能并不那么痛苦。
可以通过简单调用 type 传递新的 __ len __ 方法：

In [13]: class BadBar(metaclass=type("", (FooMeta,), {"__len__": lambda cls:9002})):
    ...:     pass
    

In [14]: len(BadBar)
Out[14]: 9002

仅当稍后将与其他类别的层次结构合并为 不同的 自定义元素您必须担心。即使还有其他类 foometa 作为metaclass的类，上面的摘要也将起作用：动态创建的元口将是新子类的元类，作为“最派生的子类”。

但是，如果有一个子类的层次结构，并且它们具有不同的元类别，即使通过这种方法创建，您也必须将两个元素组合在公共 subclass_of_the_metaclasses 之前，然后再创建新的“普通”子类。

如果是这种情况，请注意，您可以拥有一个可出现的元素，扩展您的原始元素（尽管不能躲闪），

class SubMeta(FooMeta):
    def __new__(mcls, name, bases, ns, *,class_len):
         cls = super().__new__(mcls, name, bases, ns)
         cls._class_len = class_len
         return cls

    def __len__(cls):
        return cls._class_len if hasattr(cls, "_class_len") else super().__len__()

并且：

In [19]: class Foo2(metaclass=SubMeta, class_len=9002): pass

In [20]: len(Foo2)
Out[20]: 9002

Answer 2

如您已经提到的， len（）将在对象的类型不是对象本身上找到 __ Len __ 。因此， len（badbar）被称为 type（badbar）。方法是在此处获取 badbar 的实例作为第一个参数。

class FooMeta(type):
    def __len__(cls):
        print(cls is BadBar)
        return 9000


class BadBar(metaclass=FooMeta):
    @classmethod
    def __len__(cls):
        return 9002


print(len(BadBar)) # True - 9000

这就是它的工作原理，如果您使用Metaclass的 __ len __ 做任何事情，那么与该Metaclass的其他类别将受到影响。您无法概括它。

您可以为 badbar 拥有另一个特定的元素价值。

class BadBar_meta(type):
    def __len__(cls):
        if hasattr(cls, "__len__"):
            return cls.__len__()
        return 9000


class BadBar(metaclass=BadBar_meta):
    @classmethod
    def __len__(cls):
        return 9002


print(len(BadBar))  # 9002

或者，如果您只想覆盖类的分类，则可以检查 cls class是否已经定义 __ len __ 为classMethod，如果是这样，请使用。

class FooMeta(type):
    def __len__(cls):
        m = cls.__len__
        if hasattr(m, "__self__"):
            return cls.__len__()

        return 9000


class GoodBar(metaclass=FooMeta):
    def __len__(self):
        return 9001


class BadBar(metaclass=FooMeta):
    @classmethod
    def __len__(cls):
        return 9002


print(len(GoodBar)) # 9000
print(len(BadBar))  # 9002

这里是找到ClassMethods的更强大方法。

编辑后：

如果您无法访问Metaclass，则可以装饰和猴子补丁元素：

class FooMeta(type):
    def __len__(cls):
        return 9000


class GoodBar(metaclass=FooMeta):
    def __len__(self):
        return 9001


class BadBar(metaclass=FooMeta):
    @classmethod
    def __len__(cls):
        return 9002


def decorator(mcls):
    org_len = mcls.__len__

    def custom_len(cls):
        # check too see if it is a classmethod
        if hasattr(cls.__len__, "__self__"):
            return cls.__len__()
        return org_len(cls)

    FooMeta.__len__ = custom_len
    return mcls


FooMeta = decorator(FooMeta)

print(len(GoodBar))  # 9000
print(len(BadBar))   # 9002