python 如何判断是新式类和经典类

Python中判断类是新式类还是经典类，可以通过检查类是否继承自object类来判断。新式类继承自object类，而经典类则不继承。新式类和经典类的主要区别在于新式类引入了许多新的特性和改进，比如__new__方法、super()函数等。

在详细描述新式类和经典类之前，我们先来看如何判断一个类是新式类还是经典类。可以通过以下几种方法来进行判断：

使用isinstance()函数：判断一个类是否是新式类。
查看类的__mro__属性：判断类的继承关系。
直接查看类的__bases__属性：判断类的父类。

下面我们将详细描述这三种方法以及新式类和经典类的区别和特性。

一、使用`isinstance()`函数判断

在Python中，可以通过isinstance()函数来判断一个类是否是新式类。具体做法是检查类是否是object类的实例。

class ClassicClass:
    pass
class NewStyleClass(object):
    pass
print(isinstance(ClassicClass(), object))  # False
print(isinstance(NewStyleClass(), object))  # True

在这个例子中，ClassicClass是经典类，因为它没有显式继承自object。而NewStyleClass是新式类，因为它显式继承自object。

二、查看类的`mro`属性

类的__mro__属性（Method Resolution Order，方法解析顺序）可以显示类的继承链。通过查看__mro__属性，可以判断一个类是否继承自object，从而判断其是否为新式类。

print(ClassicClass.__mro__)  # (<class '__main__.ClassicClass'>,)
print(NewStyleClass.__mro__)  # (<class '__main__.NewStyleClass'>, <class 'object'>)

从上面的输出可以看到，ClassicClass的继承链中没有object类，而NewStyleClass的继承链中包含object类。

三、直接查看类的`bases`属性

类的__bases__属性包含了类的父类信息。通过查看__bases__属性，可以判断一个类是否直接或间接继承自object。

print(ClassicClass.__bases__)  # ()
print(NewStyleClass.__bases__)  # (<class 'object'>,)

从上面的输出可以看到，ClassicClass没有父类，而NewStyleClass的父类是object。

四、经典类与新式类的区别

1、继承关系

经典类在Python 2中默认不继承object类，而新式类则显式继承object类。在Python 3中，所有的类默认都是新式类，即便没有显式继承object。

# Python 2
class ClassicClass:
    pass
class NewStyleClass(object):
    pass
Python 3
class NewStyleClass:
    pass

在Python 3中，定义的所有类实际上都是新式类，即使没有显式地继承object。

2、`new`方法

新式类引入了__new__方法，它在创建实例之前被调用。__new__方法返回一个实例，而__init__方法则初始化这个实例。经典类没有__new__方法。

class NewStyleClass(object):
    def __new__(cls, *args, kwargs):
        print("Creating instance")
        return super(NewStyleClass, cls).__new__(cls, *args, kwargs)
    def __init__(self, *args, kwargs):
        print("Initializing instance")
instance = NewStyleClass()

在这个例子中，__new__方法在实例创建之前被调用，而__init__方法在实例创建之后被调用。

3、`super()`函数

新式类引入了super()函数，它用于调用父类的方法。在经典类中，父类方法需要显式调用。

class Parent(object):
    def method(self):
        print("Parent method")
class Child(Parent):
    def method(self):
        super(Child, self).method()
        print("Child method")
instance = Child()
instance.method()

在这个例子中，super()函数用于调用父类的method方法。经典类需要显式调用父类的方法，如Parent.method(self)。

4、属性查找顺序

新式类使用广度优先搜索（BFS）查找属性，而经典类使用深度优先搜索（DFS）查找属性。

class A(object):
    def method(self):
        print("A method")
class B(A):
    pass
class C(A):
    def method(self):
        print("C method")
class D(B, C):
    pass
instance = D()
instance.method()

在这个例子中，D类的method方法会调用C类的method方法，因为新式类使用广度优先搜索查找属性。

5、描述符

新式类支持描述符协议（descriptor protocol），这使得可以更灵活地控制属性的访问。经典类不支持描述符协议。

class Descriptor(object):
    def __get__(self, instance, owner):
        return "Descriptor value"
class MyClass(object):
    attribute = Descriptor()
instance = MyClass()
print(instance.attribute)

在这个例子中，Descriptor类实现了__get__方法，这使得attribute属性的访问被描述符控制。

五、新式类的优势

新式类引入了许多改进和新特性，使得类的定义和使用更加灵活和强大。以下是新式类的一些主要优势：

1、统一的类型系统

新式类统一了类型和类的概念，使得所有的类都是type类型的实例。这使得类型检查和反射变得更加一致和方便。

print(type(NewStyleClass))  # <class 'type'>
print(isinstance(NewStyleClass, type))  # True

在这个例子中，NewStyleClass是type类型的实例，这使得类型检查更加一致。

2、支持多继承

新式类支持C3线性化算法，这使得多继承更加合理和可预测。经典类的多继承顺序可能会导致难以预料的行为。

class A(object):
    pass
class B(A):
    pass
class C(A):
    pass
class D(B, C):
    pass
print(D.__mro__)

在这个例子中，D类的继承顺序由C3线性化算法决定，保证了继承关系的一致性和可预测性。

3、增强的元类支持

新式类支持元类，这使得可以更灵活地控制类的创建和行为。元类是创建类的类，它可以拦截类的创建过程，并对其进行修改。

class Meta(type):
    def __new__(cls, name, bases, attrs):
        attrs['new_attribute'] = 'Meta attribute'
        return super(Meta, cls).__new__(cls, name, bases, attrs)
class MyClass(object, metaclass=Meta):
    pass
instance = MyClass()
print(instance.new_attribute)

在这个例子中，Meta元类在创建MyClass类时，添加了一个新的属性new_attribute。

4、描述符和属性访问控制

新式类支持描述符协议，这使得可以更灵活地控制属性的访问和修改。描述符协议包括__get__、__set__和__delete__方法。

class Descriptor(object):
    def __get__(self, instance, owner):
        return "Descriptor value"
class MyClass(object):
    attribute = Descriptor()
instance = MyClass()
print(instance.attribute)

在这个例子中，Descriptor类实现了__get__方法，使得attribute属性的访问被描述符控制。

5、`super()`函数的改进

新式类的super()函数更加灵活和强大，可以在多继承环境中正确调用父类的方法。经典类的父类方法需要显式调用。

class Parent(object):
    def method(self):
        print("Parent method")
class Child(Parent):
    def method(self):
        super(Child, self).method()
        print("Child method")
instance = Child()
instance.method()

在这个例子中，super()函数用于调用父类的method方法，这使得代码更加简洁和易读。