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代码）进行昂贵的调用。

您可以在CPython实现中看到specific test in PyObject_IsInstance，即处理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（好吧，现在我正在写这个，似乎有没有正确的理由让人想要那个，我希望我错了），一个元类可以得到远离它，但它很棘手。

这个动态地替换了实际的类由＆＃34;影子类＆＃34;实例化的对象，即是原始的克隆。这样，原生＆＃34; instancheck＆＃34;总是失败，并调用元类一个。

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的参数不是影子类。

为什么不调用instancecheck？

2 个答案:

为什么不调用__instancecheck__？

2 个答案:

为什么不调用instancecheck？