Python中的旧样式类和新样式类有什么区别？

Question

Python 中的旧样式类和新样式类有什么区别？我应该什么时候使用其中一种？

Answer 1

来自New-style and classic classes：

直到 Python 2.1，旧式类是用户唯一可用的风格。

（旧式）类的概念与类型的概念无关： 如果x 是旧式类的实例，则x.__class__ 指定x 的类，但type(x) 始终为<type 'instance'>。

这反映了所有旧式实例独立于 他们的类是用一个内置类型实现的，称为 实例。

Python 2.2 中引入了新样式的类，以统一类和类型的概念。 新式类只是用户定义的类型，不多也不少。

如果 x 是新样式类的实例，则 type(x) 通常是 与x.__class__ 相同（尽管不能保证 - 一个 允许新样式类实例覆盖返回的值 为x.__class__)。

引入新型类的主要动机是提供具有完整元模型的统一对象模型。

它还有许多直接的好处，比如能够 子类化大多数内置类型，或者引入“描述符”， 启用计算属性。

出于兼容性原因，默认情况下类仍然是旧样式。

通过指定另一个新样式类来创建新样式类 （即类型）作为父类，或者“顶级类型”对象，如果没有 需要其他父母。

新式类的行为与旧式不同 类中的一些重要细节除了什么类型 返回。

其中一些更改是新对象模型的基础，例如 调用特殊方法的方式。其他是无法解决的“修复” 出于兼容性考虑，请在之前实现，例如方法 多继承情况下的解析顺序。

Python 3 只有新式类。

无论你是否从object 继承，类都是新式的 在 Python 3 中。

Answer 2

声明方式：

新式类继承自object，或从另一个新式类。

class NewStyleClass(object):
    pass

class AnotherNewStyleClass(NewStyleClass):
    pass

旧式类没有。

class OldStyleClass():
    pass

Python 3 注意：

Python 3 不支持旧样式类，因此上述任何一种形式都会产生新样式类。

Answer 3

新旧样式类之间的重要行为变化

• super 已添加
• MRO 已更改（如下所述）
• descriptors 已添加
• 除非从 Exception 派生，否则无法引发新样式类对象（示例如下）
• __slots__ 已添加

MRO（方法解析顺序）已更改

在其他答案中提到过，但这里有一个具体示例来说明经典 MRO 和 C3 MRO（用于新样式类）之间的区别。

问题是在多重继承中搜索属性（包括方法和成员变量）的顺序。

经典类从左到右进行深度优先搜索。停在第一场比赛。它们没有__mro__ 属性。

class C: i = 0
class C1(C): pass
class C2(C): i = 2
class C12(C1, C2): pass
class C21(C2, C1): pass

assert C12().i == 0
assert C21().i == 2

try:
    C12.__mro__
except AttributeError:
    pass
else:
    assert False

新式类 MRO 在单个英文句子中合成起来更加复杂。详细解释here。它的属性之一是基类仅在其所有派生类都被搜索后才被搜索。它们具有显示搜索顺序的__mro__ 属性。

class C(object): i = 0
class C1(C): pass
class C2(C): i = 2
class C12(C1, C2): pass
class C21(C2, C1): pass

assert C12().i == 2
assert C21().i == 2

assert C12.__mro__ == (C12, C1, C2, C, object)
assert C21.__mro__ == (C21, C2, C1, C, object)

除非派生自Exception，否则不能引发新样式类对象

在 Python 2.5 前后，可以提出许多类，而在 Python 2.6 前后，这已被删除。在 Python 2.7.3 上：

# OK, old:
class Old: pass
try:
    raise Old()
except Old:
    pass
else:
    assert False

# TypeError, new not derived from `Exception`.
class New(object): pass
try:
    raise New()
except TypeError:
    pass
else:
    assert False

# OK, derived from `Exception`.
class New(Exception): pass
try:
    raise New()
except New:
    pass
else:
    assert False

# `'str'` is a new style object, so you can't raise it:
try:
    raise 'str'
except TypeError:
    pass
else:
    assert False

Answer 4

旧样式类的属性查找速度仍然略快。这通常并不重要，但在性能敏感的 Python 2.x 代码中可能很有用：

[3] 中：A 类： ...：定义__init__（自我）： ...: self.a = '你好' ...： 在 [4] 中：B 类（对象）： ...：定义__init__（自我）： ...: self.a = '你好' ...： 在[6]中：aobj = A() 在 [7] 中：bobj = B() 在 [8] 中：%timeit aobj.a 10000000 次循环，3 次中的最佳：每个循环 78.7 ns 在 [10] 中：%timeit bobj.a 10000000 次循环，3 次中的最佳：每个循环 86.9 ns

Answer 5

Guido 写了 The Inside Story on New-Style Classes，这是一篇关于 Python 中新式和旧式类的非常棒的文章。

Python 3 只有新式类。即使您编写了一个“旧式类”，它也隐式地派生自 object。

新式类具有旧式类所缺乏的一些高级功能，如super、新的C3 mro、一些神奇的方法等。

Answer 6

这是一个非常实用的真/假区别。以下代码的两个版本之间的唯一区别在于，在第二个版本中，Person 继承自 object。除此之外，这两个版本相同，但结果不同：

1. 旧式类

   class Person():
       _names_cache = {}
       def __init__(self,name):
           self.name = name
       def __new__(cls,name):
           return cls._names_cache.setdefault(name,object.__new__(cls,name))
   
   ahmed1 = Person("Ahmed")
   ahmed2 = Person("Ahmed")
   print ahmed1 is ahmed2
   print ahmed1
   print ahmed2
   
   
   >>> False
   <__main__.Person instance at 0xb74acf8c>
   <__main__.Person instance at 0xb74ac6cc>
   >>>
   
   

2. 新型类

   class Person(object):
       _names_cache = {}
       def __init__(self,name):
           self.name = name
       def __new__(cls,name):
           return cls._names_cache.setdefault(name,object.__new__(cls,name))
   
   ahmed1 = Person("Ahmed")
   ahmed2 = Person("Ahmed")
   print ahmed2 is ahmed1
   print ahmed1
   print ahmed2
   
   >>> True
   <__main__.Person object at 0xb74ac66c>
   <__main__.Person object at 0xb74ac66c>
   >>>
   

Answer 7

新式类继承自object，并且必须在 Python 2.2 及更高版本中这样编写（即class Classname(object): 而不是class Classname:）。核心变化是统一类型和类，这样做的好处是它允许您从内置类型继承。

阅读descrintro了解更多详情。

Answer 8

新样式类可以使用super(Foo, self)，其中Foo 是一个类，self 是实例。

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

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

在 Python 3.x 中，您可以在类中简单地使用 super()，无需任何参数。