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

Question

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

Answer 1

来自新式和经典类< /a>：

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

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

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

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 更改（如下所述）
• 描述符 添加了
• 无法引发的新样式类对象除非派生自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 在单个英语句子中综合起来更加复杂。 此处对此进行了详细解释。 它的属性之一是，只有在搜索完基类的所有派生类后，才会搜索基类。 它们具有显示搜索顺序的 __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 代码中可能很有用：

In [3]: class A:
   ...:     def __init__(self):
   ...:         self.a = 'hi there'
   ...:

In [4]: class B(object):
   ...:     def __init__(self):
   ...:         self.a = 'hi there'
   ...:

In [6]: aobj = A()
In [7]: bobj = B()

In [8]: %timeit aobj.a
10000000 loops, best of 3: 78.7 ns per loop

In [10]: %timeit bobj.a
10000000 loops, best of 3: 86.9 ns per loop

Answer 5

Guido 写了内部故事Story on New-Style Classes，一篇关于 Python 中新式和旧式类的非常好的文章。

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

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

Answer 6

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

1. 旧式类

   类 Person(): 
         _names_cache = {} 
         def __init__(自我,名字): 
             self.name = 名字 
         def __new__(cls,名称): 
             返回 cls._names_cache.setdefault(name,object.__new__(cls,name)) 
   
     ahmed1 = 人(“艾哈迈德”) 
     ahmed2 = 人(“艾哈迈德”) 
     打印 ahmed1 是 ahmed2 
     打印艾哈迈德1 
     打印艾哈迈德2 
   
   
     >>>>>   错误的 
     <__main__.Person 实例位于 0xb74acf8c> 
     <__main__.Person 实例位于 0xb74ac6cc> 
     >>>>> 
   
     

2. 新式类

   类 Person（对象）： 
         _names_cache = {} 
         def __init__(自我,名字): 
             self.name = 名字 
         def __new__(cls,名称): 
             返回 cls._names_cache.setdefault(name,object.__new__(cls,name)) 
   
     ahmed1 = 人(“艾哈迈德”) 
     ahmed2 = 人(“艾哈迈德”) 
     打印 ahmed2 是 ahmed1 
     打印艾哈迈德1 
     打印艾哈迈德2 
   
     >>>>>   真的 
     <__main__.Person 对象位于 0xb74ac66c> 
     <__main__.Person 对象位于 0xb74ac66c> 
     >>>>> 
     

Answer 7

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

阅读 descrintro 了解更多详细信息。

Answer 8

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

super(类型[,对象或类型])

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

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