Python中的抽象基类及元类

发表于： 2024年1月26日 2024年1月26日
分类： python
标签： Python

ABCMeta解析

示例代码如下：

class ABC(metaclass=ABCMeta):
    """Helper class that provides a standard way to create an ABC using
    inheritance.
    """
    __slots__ = ()

代码解析如下：

这段 Python 代码定义了一个名为 ABC 的类，它是由抽象基底类元类（ ABCMeta ）生成的。

class ABC(metaclass=ABCMeta): 这行代码定义了一个名为 ABC 的类，并且它使用 ABCMeta 作为它的元类。元类是类的类，它定义了类的行为。使用 ABCMeta 作为元类的类，我们通常认为它是一个抽象基类（Abstract Base Class, ABC）。抽象基类是一种提供接口的类，接口是指在子类中应实现的方法集。实质上，抽象基类是不能直接实例化的类，是为了被其他类继承的模板。
__slots__ = () 是一种 Python 中的类变量，用来为实例保留固定的空间，以保存实例的属性。Python 默认是为每个对象保存一个 dict，以存放实例的所有属性，但大多数时候，对象的属性并不需要增加或者删除，也就是并不需要一个可以动态增长的 dictionary。这种情况下，可以使用 __slots__ 优化内存使用。__slots__ = () 为空元组表示 ABC 对象不包含任何实例属性。
之前三个双引号 """Helper class that provides a standard way to create an ABC using inheritance.""" 是一个多行字符串，在这里它是被用作类的文档字符串（docstring），用于描述类的基本功能。在实际编程中，这是一种很好的编程习惯，可以帮助其他程序员理解你的代码。

总的来说，这段代码创建了一个抽象基类（ABC）模板，没有任何实例属性，并且加入了类的说明文档。

ABCMeta示例

在Python中，ABCMeta是一个元类，用于定义抽象基类(ABC，Abstract Base Class)，抽象基类是提供给其他类继承的模板，它不能被实例化。使用抽象基类可以强制子类必须实现某些方法。

下面是一个使用ABCMeta元类的例子：

from abc import ABCMeta, abstractmethod

class AbstractClass(metaclass=ABCMeta):
    @abstractmethod
    def do_something(self):
        pass

class SubClass(AbstractClass):
    def do_something(self):
        super().do_something()
        print("子类实现了抽象方法")

# 实例化子类
s = SubClass()
s.do_something()

在上面的例子中，AbstractClass 使用ABCMeta作为元类，并定义了一个抽象方法do_something。抽象方法是一种必须在子类中实现的方法，如果不实现，Python解释器会抛出TypeError错误。

然后，SubClass类继承了AbstractClass，实现了其中的抽象方法do_something。当我们创建SubClass的实例并调用do_something方法时，它会按照SubClass重写的逻辑执行。

这样，AbstractClass就担任了一种“规范”或是”标准模板”的角色，它规定子类必须实现特定方法，确保了子类具有特定的行为方式。

在Python中，super().do_something() 通常是用来调用父类(超类)中的方法。在上面的场景下，由于在 AbstractClass 中 do_something 方法仅仅是一个声明，并且没有进行任何实现（就是 pass 语句），所以在 SubClass 的 do_something 方法中调用 super().do_something() 基本上没有任何作用。

然而，如果在 AbstractClass 中 do_something 方法有具体的实现并且期望在子类中先执行父类的逻辑，然后再根据需要在子类中添加一些额外的逻辑，那么就需要在子类的方法中调用 super().do_something()。

举个例子，我们假设现在有这样两个类：

class MyBaseClass:
    def do_something(self):
        print("做了一些事情")

class MyDerivedClass(MyBaseClass):
    def do_something(self):
        super().do_something()
        print("子类做了一些其他事情")

在这个例子中，如果你创建一个 MyDerivedClass 的对象并调用 do_something 方法，首先会打印 “做了一些事情”，然后打印 “子类做了一些其他事情”。

总的来说，是否需要在子类中调用 super().do_something()，取决于你的设计需求。如果你想在子类中使用和修改父类的行为，那么就需要调用 super().do_something()。如果你完全想重写父类的行为，那么就不需要调用它。

@abstractmethod讲解

在Python中，@abstractmethod是一个装饰器，用于标记抽象基类中的抽象方法。如果一个类含有抽象方法，那么这个类就不能被直接实例化。换言之，任何尝试实例化这个类的行为都将引发TypeError。

以下是一个例子：

from abc import ABC, abstractmethod

class AbstractClass(ABC):

    @abstractmethod
    def do_something(self):
        pass


# 下面这行代码会抛出 TypeError
# my_abstract_class = AbstractClass()

AbstractClass是一个抽象基类，它定义了一个抽象方法do_something，由于抽象方法必须在子类中被实现，所以尝试直接实例化抽象基类AbstractClass就会抛出TypeError。

@abstractmethod装饰器在抽象基类中定义抽象方法时是必须使用的，因为它告诉Python解释器该方法必须在任何子类中实现。如果子类没有实现这些抽象方法，那么尝试实例化这个子类的时候就会抛出TypeError。

总结一下，@abstractmethod装饰器的主要作用就是定义抽象方法，让抽象基类不能被实例化，并强制子类实现这些方法。

Java中类似实现

在Java中，抽象基类的概念被实现为抽象类（abstract class）和接口（interface）。与Python中的抽象基类类似，Java的抽象类和接口都不能被实例化，它们只能被其他类继承或实现。

下面是一个Java抽象类的例子：

public abstract class AbstractClass {
    public abstract void doSomething();
}

和一个实现该抽象类的子类：

public class SubClass extends AbstractClass {
    public void doSomething() {
         System.out.println("子类实现了抽象方法");
    }
}

在这个例子中，AbstractClass是抽象类，定义了一个没有实现的抽象方法doSomething。SubClass是AbstractClass的子类，它实现了doSomething方法。

同样的，在Java中，接口（Interface）也提供了类似于抽象类的功能：

public interface MyInterface {
     void doSomething();
 }
 
public class SubClass implements MyInterface {
     public void doSomething() {
          System.out.println("子类实现了接口方法");
     }
 }

在这个例子中，MyInterface是一个接口，它定义了一个需要被实现的方法 doSomething。然后，SubClass 实现了这个接口，提供了 doSomething 方法的具体实现。

所以，Java中的抽象类和接口提供的功能与Python的ABCMeta元类非常相似，都是定义一种模板，强制继承或实现它的类必须有特定的方法。

Python中的抽象基类及元类插图