Python中的“类型”和“对象”有什么区别[重复]

Question

我在阅读 super 关键字上的 python documentation 时遇到了这个问题：

如果省略第二个参数，则返回的超级对象是未绑定的。如果第二个参数是对象，则 isinstance(obj, type) 必须为真。如果第二个参数是类型，issubclass(type2, type) 必须为真（这对类方法很有用）。

谁能给我一个例子来说明传递一个类型作为第二个参数和传递一个对象之间的区别？

文档是否在谈论对象的实例？

谢谢。

Answer 1

对象可以是任何 Python 类实例，它可能是用户定义的，也可能不是用户定义的。但， 当您谈论 type 时，它指的是默认对象/集合，例如 list/tuple/dict/int/str 等。

Answer 2

这里对这两个函数做一个简单的探索。通过这个练习，我发现它很有启发性。我经常会创建一个简单的程序来探索简单函数的来龙去脉并保存以供参考：

#
# Testing isinstance and issubclass
#

class C1(object):
    def __init__(self):
        object.__init__(self)

class B1(object):
    def __init__(self):
        object.__init__(self)

class B2(B1):
    def __init__(self):
        B1.__init__(self)

class CB1(C1,B1):
    def __init__(self):
        # not sure about this for multiple inheritance
        C1.__init__(self)
        B1.__init__(self)

c1 = C1()
b1 = B1()
cb1 = CB1()

def checkInstanceType(c, t):
    if isinstance(c, t):
        print c, "is of type", t
    else:
        print c, "is NOT of type", t

def checkSubclassType(c, t):
    if issubclass(c, t):
        print c, "is a subclass of type", t
    else:
        print c, "is NOT a subclass of type", t

print "comparing isinstance and issubclass"
print ""

# checking isinstance
print "checking isinstance"

# can check instance against type
checkInstanceType(c1, C1)
checkInstanceType(c1, B1)
checkInstanceType(c1, object)

# can check type against type
checkInstanceType(C1, object)
checkInstanceType(B1, object)

# cannot check instance against instance
try:
    checkInstanceType(c1, b1)
except Exception, e:
    print "failed to check instance against instance", e

print ""

# checking issubclass
print "checking issubclass"

# cannot check instance against type
try:
    checkSubclassType(c1, C1)
except Exception, e:
    print "failed to check instance against type", e

# can check type against type
checkSubclassType(C1, C1)
checkSubclassType(B1, C1)
checkSubclassType(CB1, C1)
checkSubclassType(CB1, B1)

# cannot check type against instance
try:
    checkSubclassType(C1, c1)
except Exception, e:
    print "failed to check type against instance", e

编辑： 还要考虑以下内容，因为 isinstance 可能会破坏 API 实现。一个例子是一个像字典一样的对象，但不是从 dict 派生的。 isinstance 可能会检查对象是否为字典，即使该对象支持字典样式访问： isinstance considered harmful

编辑2：

谁能给我一个例子来说明传递一个类型作为第二个参数和传递一个对象之间的区别？

在测试了上面的代码后，它告诉我第二个参数必须是一个类型。所以在以下情况下：

checkInstanceType(c1, b1)

调用将失败。可以写成：

checkInstanceType(c1, type(b1))

因此，如果您想检查一个实例与另一个实例的类型，您必须使用 type() 内置调用。

Answer 3

Python 的super 函数根据它的参数做不同的事情。以下是使用它的不同方式的演示：

class Base(object):
    def __init__(self, val):
        self.val = val

    @classmethod
    def make_obj(cls, val):
        return cls(val+1)

class Derived(Base):
    def __init__(self, val):
        # In this super call, the second argument "self" is an object.
        # The result acts like an object of the Base class.
        super(Derived, self).__init__(val+2)

    @classmethod
    def make_obj(cls, val):
        # In this super call, the second argument "cls" is a type.
        # The result acts like the Base class itself.
        return super(Derived, cls).make_obj(val)

测试输出：

>>> b1 = Base(0)
>>> b1.val
0
>>> b2 = Base.make_obj(0)
>>> b2.val
1
>>> d1 = Derived(0)
>>> d1.val
2
>>> d2 = Derived.make_obj(0)
>>> d2.val
3

3 的结果是前面修饰符的组合：1（来自 Base.make_obj）加上 2（来自 Derived.__init__）。

请注意，可以只用一个参数调用super 来获得一个“未绑定”的超级对象，这显然没有多大用处。没有任何理由这样做，除非你想弄乱 Python 内部结构并且你真的知道你在做什么。

在 Python 3 中，你也可以不带参数调用super（相当于上面函数中的调用，但更神奇）。