Python type() or __class__, == or is

Question

我想测试一个对象是否是一个类的实例，并且只有这个类（没有子类）。我可以这样做：

obj.__class__ == Foo
obj.__class__ is Foo
type(obj) == Foo
type(obj) is Foo

有理由选择一个而不是另一个吗？ （性能差异、陷阱等）

换句话说：a) 使用__class__ 和type(x) 之间有什么实际区别吗？ b) 使用is比较类对象总是安全的吗？

---

更新：感谢大家的反馈。我仍然对类对象是否是单例感到困惑，我的常识说它们是，但是很难得到确认（尝试谷歌搜索“python”，“class”和“unique”或“singleton”） .

我还想澄清一下，对于我的特殊需求，“更便宜”的解决方案是最好的，因为我正在尝试优化少数专业课程中的大部分（几乎达到目的明智的做法是放弃 Python 并在 C 中开发该特定模块）。但问题背后的原因是为了更好地理解该语言，因为它的某些功能有点太晦涩，我无法轻松找到该信息。这就是为什么我让讨论扩展一点而不是满足于__class__ is，所以我可以听到更有经验的人的意见。到目前为止，它非常富有成效！

我运行了一个小测试来对 4 个备选方案的性能进行基准测试。探查器结果是：

               Python  PyPy (4x)
type()    is   2.138   2.594
__class__ is   2.185   2.437
type()    ==   2.213   2.625
__class__ ==   2.271   2.453

不出所料，is 在所有情况下的表现都优于==。 type() 在 Python 中表现更好（快 2%），__class__ 在 PyPy 中表现更好（快 6%）。有趣的是，__class__ == 在 PyPy 中的表现优于 type() is。

---

更新 2： 很多人似乎不明白我所说的“类是单例”是什么意思，所以我将举例说明：

>>> class Foo(object): pass
...
>>> X = Foo
>>> class Foo(object): pass
...
>>> X == Foo
False
>>> isinstance(X(), Foo)
False
>>> isinstance(Foo(), X)
False

>>> x = type('Foo', (object,), dict())
>>> y = type('Foo', (object,), dict())
>>> x == y
False
>>> isinstance(x(), y)
False

>>> y = copy.copy(x)
>>> x == y
True
>>> x is y
True
>>> isinstance(x(), y)
True
>>> y = copy.deepcopy(x)
>>> x == y
True
>>> x is y
True
>>> isinstance(x(), y)
True

如果有 N 个 type 类型的对象并不重要，给定一个对象，只有一个是它的类，因此在这种情况下进行比较以供参考是安全的。而且由于参考比较总是比价值比较便宜，我想知道我上面的断言是否成立。我得出的结论是确实如此，除非有人提出相反的证据。

Answer 1

type() 的结果等同于新样式类中的obj.__class__，并且类对象使用is 比较不安全，请改用==。

对于新样式类，这里最好的方式是type(obj) == Foo。

正如迈克尔霍夫曼在他的回答中指出的那样，新旧样式类之间存在差异，因此对于向后兼容的代码，您可能需要使用 obj.__class__ == Foo。

对于那些声称isinstance(obj, Foo) 更可取的人，请考虑以下情况：

class Foo(object):
    pass

class Bar(Foo):
    pass

>>> obj = Bar()
>>> isinstance(obj, Foo)
True
>>> type(obj) == Foo
False

OP 想要 type(obj) == Foo 的行为，即使 Foo 是 Bar 的基类，它也会为假。

Answer 2

is 应该只用于身份检查，而不是类型检查（规则有一个例外，您可以并且应该使用is 来检查单身人士）。

注意：我通常也不会使用 type 和 == 进行类型检查。类型检查的首选方法是isinstance(obj, Foo)。如果您有理由检查某些东西是否不是子类实例，那么它对我来说就像一个可疑的设计。当class Foo(Bar):，然后Bar 是一个 Foo，你应该避免你的代码的某些部分必须在Foo实例上工作但在@987654331上中断的任何情况@ 实例。

Answer 3

对于老式类，有区别：

>>> class X: pass
... 
>>> type(X)
<type 'classobj'>
>>> X.__class__
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: class X has no attribute '__class__'
>>> x = X()
>>> x.__class__
<class __main__.X at 0x171b5d50>
>>> type(x)
<type 'instance'>

新型类的重点是统一类和类型。从技术上讲，__class__ 是唯一适用于新式和旧式类实例的解决方案，但它也会对旧式类对象本身抛出异常。你可以在任何对象上调用type()，但不是每个对象都有__class__。此外，你可以用__class__ 做垃圾处理，而你不能用type() 做垃圾处理。

>>> class Z(object):
...     def __getattribute__(self, name):
...             return "ham"
... 
>>> z = Z()
>>> z.__class__
'ham'
>>> type(z)
<class '__main__.Z'>

就我个人而言，我通常有一个只有新样式类的环境，并且就样式而言，我更喜欢使用type()，因为我通常更喜欢内置函数而不是使用魔法属性。例如，我也更喜欢bool(x) 而不是x.__nonzero__()。

Answer 4

更新：感谢大家的反馈。我仍然对类对象是否是单例感到困惑，我的常识说它们是，但是很难得到确认（尝试谷歌搜索“python”，“class”和“unique”或“singleton”） .

我可以确认__instance__ 是单身人士。这是证据。

>>> t1=File.test()
made class
>>> t2=File.test()
made class
>>> print t1.__class__()
made class
<File.test object at 0x1101bdd10>
>>> print t2.__class__()
made class
<File.test object at 0x1101bdd10>

您可以看到t1 和t2 在内存中打印出相同的值，即使t1 和t2 在内存中的值不同。这是证明。

>>> print t1
<File.test object at 0x1101bdc90>
>>> print t2
<File.test object at 0x1101bdcd0>

__instance__ 方法仅在您使用 class "name"(object): 时才存在。如果您使用经典样式类class "name":，则__instance__ 方法不存在。

这意味着成为您可能想要使用的最通用的type，除非您知道事实实例确实存在。