super() 返回的超级对象的类型是什么？

Question

来自here：

super( [ type [ , object-or-type ]] )

返回一个代理对象，它将方法调用委托给type 的父类或兄弟类。这对于访问已在类中重写的继承方法很有用。搜索顺序与getattr() 使用的顺序相同，只是跳过了type 本身。

如果省略第二个参数，则返回的超级对象是 未绑定。

如果第二个参数是一个对象，isinstance(obj, type) 必须是 真的。

如果第二个参数是类型，issubclass(type2, type) 必须是 true（这对类方法很有用）。

1. 如果我是对的，类型是类，类是类型。一类 是一个对象，所以类型也是一个对象。为什么报价 当第二个参数是一个对象时区分这两种情况 什么时候是类型？

2. 当第二个参数是类型时，为什么是issubclass(type2, type) 必须是真的吗？

3. super在这三种情况下分别返回的超级对象的类型是什么？或者如何判断super返回的超级对象的类型？

   当第二个参数是对象时，因为“搜索顺序与getattr()使用的相同，只是跳过了type本身”，我猜测是super函数返回的超对象的类型应该是第一个参数type 的任何祖先类的子类，但我发现它实际上不是通过使用issubclass 进行测试的。那我是不是误会了什么？

Answer 1

您似乎将 type 与内置的 type() 混淆了。在这里，他们只是引用传递给super() 的第一个参数。

文档告诉你的是 if 你传入了两个参数，那么第二个参数 either 必须是第一个参数的实例，或者 它必须是一个子类。换句话说，isinstance(first_argument, second_argument) 或 issubclass(first_argument, second_argument) 必须为真。 这里没有别的意思。

就像int() 或str() 或任何其他内置类型一样，调用super() 返回的对象的类型就是那个类型。没有为不同的参数返回单独的类型。请参阅C source code defining the object。

super() 对象实现了一个实现特定属性行为的__getattribute__ hook。文档告诉您属性查找的 规则 与 getattr() 相同（但有文档记录的 MRO 跳过），但 not 是否意味着 super()返回一个祖先类。

实际发生的情况是 super().__getattribute__ 采用第二个参数的 MRO（type(instance).__mro__ 或 cls.__mro__，取决于 isinstance() 或 issubclass() 是否为真），找到该序列中的第一个参数并之后开始测试属性。因为首先扫描 MRO 以查找第二个参数的（类型），所以它必须是可找到的，这就是约束是什么的原因。

在纯 Python 中，这就是 super() 所做的（简化为只关注两个参数行为）：

def _supercheck(type_, obj):
    try:
        if issubclass(obj, type_):
            return obj
    except TypeError:
        # obj is not a type so issubclass throws a TypeError
        pass
    if isinstance(obj, type_):
        return type(obj)
    raise TypeError(
        "super(type, obj): obj must be an instance or subtype of type")


class super_:
    def __init__(self, type_, obj):
        # simplified for the two-argument case
        self.type_ = type_
        self.obj = obj
        self.obj_type = _supercheck(type_, obj)

    def __getattribute__(self, name):
        if name == '__class__':
            # __class__ should always come from this object, not
            # the represented MRO.
            return super().__getattribute__(name)

        # avoid infinite recursion issues
        sd = super().__getattribute__('__dict__')
        starttype = sd['obj_type']
        type_ = sd['type_']
        obj = sd['obj']

        mro = iter(starttype.__mro__)

        # skip past the start type in the MRO
        for tp in mro:
            if tp == type_:
                break

        # Search for the attribute on the remainder of the MRO
        for tp in mro:
            attrs = vars(tp)
            if name in attrs:
                res = attrs[name]
                # if it is a descriptor object, bind it
                descr = getattr(type(res), '__get__', None)
                if descr is not None:
                    res = descr(
                        res,
                        None if obj is starttype else obj,
                        starttype)
                return res

        return super().__getattribute__(name)

Answer 2

仅针对 3 种情况下关于 super 类型的第 3 点（前 2 种类似）：

class A(object):
    def sup(self):
        return (super(A, self))

class A1(object):
    def sup(self):
        return (super())


class B(object):      
    def sup(self):
        return (super(B))  

class C(A):
    def sup(self):
        return (super(A,C))      

a = A()
a_sup = a.sup()
print(type(a_sup))  #<class 'super'>
print(a_sup.__doc__)  #The most base type
print(a_sup.__self__)  #<__main__.A object at 0x7f9d0d2d8668>
print(a_sup.__self_class__) #<class '__main__.A'>
print(a_sup.__thisclass__)  #<class '__main__.A'>

print()  
a1 = A1()
a_sup = a1.sup()
print(type(a_sup))  #<class 'super'>
print(a_sup.__doc__)  #The most base type
print(a_sup.__self__)  #<__main__.A1 object at 0x7f9d0d2d86d8>
print(a_sup.__self_class__) #<class '__main__.A1'>
print(a_sup.__thisclass__) #<class '__main__.A1'>

print()    
b = B()
b_sup = b.sup()
print(type(b_sup))  #<class 'super'>
print(b_sup.__doc__) 
'''
super() -> same as super(__class__, <first argument>)
super(type) -> unbound super object
super(type, obj) -> bound super object; requires isinstance(obj, type)
super(type, type2) -> bound super object; requires issubclass(type2, type)
Typical use to call a cooperative superclass method:
class C(B):
    def meth(self, arg):
        super().meth(arg)
This works for class methods too:
class C(B):
    @classmethod
    def cmeth(cls, arg):
        super().cmeth(arg)
'''        

print(b_sup.__self__)  #None
print(b_sup.__self_class__)  #None
print(b_sup.__thisclass__)  #<class '__main__.B'>

print()
c=C()
c_sup = c.sup()
print(type(c_sup))  #<class 'super'>
print(c_sup.__doc__) #The most base type
print(c_sup.__self__) #<class '__main__.C'>
print(c_sup.__self_class__) #<class '__main__.C'>
print(c_sup.__thisclass__) #<class '__main__.A'>