为什么不调用__instancecheck__？

Question

我有以下python3代码：

class BaseTypeClass(type):
    def __new__(cls, name, bases, namespace, **kwd):
        result = type.__new__(cls, name, bases, namespace)
        print("creating class '{}'".format(name))
        return result

    def __instancecheck__(self, other):
        print("doing instance check")
        print(self)
        print(other)
        return False


class A(metaclass=BaseTypeClass):
    pass

print(type(A))
print(isinstance(A(), A))

当我在Python 3.6.3 (v3.6.3:2c5fed8, Oct 3 2017, 18:11:49) [MSC v.1900 64 bit (AMD64)] on win32上运行时，我得到以下输出

creating class 'A'
<class '__main__.BaseTypeClass'>
True

为什么不输出doing instance check？ documentation说__instancecheck__方法需要在元类上定义，而不是类本身，我在这里做了。我甚至验证了自从打印creating class 'A'以来正在使用的元类。但是，当我调用isinstance时，它似乎使用的是默认实现，而不是我在元类中定义的实现。

我可能没有正确使用元类，但我无法弄清楚我犯了哪些错误。

Answer 1

isinstance函数快速检查以查看作为参数提供的实例的类型是否与类的类型相同。如果是这样，它会提前返回，并且不会调用您的自定义__instancecheck__。

这是一种优化，用于避免在不需要时对__instancecheck__（它是Pythonland代码）进行昂贵的调用。

你可以看到specific test in PyObject_IsInstance，它是在CPython实现中处理isinstance调用的函数：

/* Quick test for an exact match */
if (Py_TYPE(inst) == (PyTypeObject *)cls)
    return 1;

当然，当测试不是__instancecheck__时，你的True正确激发：

>>> isinstance(2, A)
doing instance check
<class '__main__.A'>
2
False

我不确定这是否是特定于实现的，我想是这样的，因为在the corresponding PEP section和isinstance的文档中没有提到这一点。

---

有趣的是：issubclass实际上并没有这样做。由于它的实现，它总是调用__subclasscheck__。我在这一段时间内打开了an issue，这仍然悬而未决。

Answer 2

吉姆的回答似乎很明确。

但是对于那些需要一些weid的人来说，完全定制的instancheck（好吧，现在我正在写这个，似乎没有正确的理由让人想要那个，我希望我错了），一个元类可以逃脱它，但这很棘手。

这个动态地替换了由“影子​​类”实例化的对象的实际类，“影子类”是原始的克隆。这样，本机“instancheck”总是失败，并且调用元类一。

def sub__new__(cls, *args, **kw):
    metacls = cls.__class__
    new_cls = metacls(cls.__name__, cls.__bases__, dict(cls.__dict__), clonning=cls)
    return new_cls(*args, **kw)

class M(type):
    shadows = {}
    rev_shadows = {}
    def __new__(metacls, name, bases, namespace, **kwd):
        clonning = kwd.pop("clonning", None)
        if not clonning:
            cls = super().__new__(metacls, name, bases, namespace)
            # Assumes classes don't have  a `__new__` of them own.
            # if they do, it is needed to wrap it.
            cls.__new__ = sub__new__
        else:
            cls = clonning
            if cls not in metacls.shadows:
                clone = super().__new__(metacls, name, bases, namespace)
                # The same - replace for unwrapped new.
                del clone.__new__
                metacls.shadows[cls] = clone
                metacls.rev_shadows[clone] = cls
            return metacls.shadows[cls]

        return cls

    def __setattr__(cls, attr, value):

        # Keep class attributes in sync with shadoclass
        # This could be done with 'super', but we'd need a thread lock
        # and check for re-entering.
        type.__setattr__(cls, attr, value)
        metacls = type(cls)
        if cls in metacls.shadows:
            type.__setattr__(metacls.shadows[cls], attr, value)
        elif cls in metacls.rev_shadows:
            type.__setattr__(metacls.rev_shadows[cls], attr, value)    

    def call(cls, *args, **kw):
        # When __new__ don't return an instance of its class,
        # __init__ is not called by type's __call__
        instance = cls.__new__(*args, **kw)
        instance.__init__(*args, **kw)
        return instance

    def __instancecheck__(cls, other):
        print("doing instance check")
        print(cls)
        print(other)
        return False


class A(metaclass=M):
    pass

print(type(A))
print(isinstance(A(), A))

它甚至在shadow类和实际类中都有一个机制来同步属性。它不支持的一件事是，以这种方式处理的类确实实现了自定义__new__。如果这样的__new__使用无参数super，它开始变得棘手，因为super的参数不会是影子类。