python抽象方法与普通方法

有什么不同？

Python中的抽象方法与普通方法不同之处在于，抽象方法是没有具体实现的方法，仅仅是定义了方法名字、参数列表和返回值类型，而没有具体的方法实现。抽象方法在定义类的时候可以用来定义接口，而普通方法则是具有具体实现的方法。如果一个类中有抽象方法，那么这个类就必须是一个抽象类，而抽象类不能被实例化。子类必须实现抽象父类中的抽象方法才能被实例化。

相关问题

python普通类中抽象方法

在Python中，普通类中的抽象方法是通过使用`abc`模块中的`ABC`类和`abstractmethod`装饰器来实现的。`ABC`类是一个抽象基类，用于定义抽象方法和抽象属性。

要创建一个包含抽象方法的普通类，需要按照以下步骤进行操作：

1. 导入`abc`模块：`from abc import ABC, abstractmethod`
2. 创建一个继承自`ABC`类的普通类，并在类定义前加上`@abstractmethod`装饰器。
3. 在类中定义抽象方法，使用`@abstractmethod`装饰器进行修饰。

下面是一个示例代码，展示了如何在Python普通类中定义抽象方法：

from abc import ABC, abstractmethod

class AbstractClass(ABC):
    @abstractmethod
    def abstract_method(self):
        pass

class ConcreteClass(AbstractClass):
    def abstract_method(self):
        print("Implementation of abstract_method")

# 创建实例并调用抽象方法
obj = ConcreteClass()
obj.abstract_method()

在上面的示例中，`AbstractClass`是一个包含抽象方法的普通类，其中的`abstract_method`方法被声明为抽象方法。`ConcreteClass`是`AbstractClass`的子类，必须实现父类中的抽象方法。在创建`ConcreteClass`的实例并调用`abstract_method`时，会输出"Implementation of abstract_method"。

需要注意的是，如果一个类中包含抽象方法，那么该类本身也必须被声明为抽象类，即需要继承自`ABC`类。抽象类不能被实例化，只能被用作其他类的基类。

Python抽象基类中__subclasshook__方法的使用并实现自己的虚拟子类

Python中的抽象基类（Abstract Base Class，简称ABC）是一种特殊的类，它定义了一组抽象方法，这些方法必须在子类中实现。ABC的一个主要用途是为了检查子类是否符合某个接口的规范。

在ABC中，可以使用`__subclasshook__`方法来判断一个类是否是该ABC的虚拟子类。具体来说，如果一个类没有直接继承该ABC，但是它的基类中有`__subclasshook__`方法，而且该方法返回True，则该类就被视为该ABC的虚拟子类。

下面是一个例子，我们定义了一个ABC `MyABC`，其中定义了一个抽象方法`my_method`。然后定义了一个普通类`MyClass`，它继承自`object`，并且实现了`my_method`方法。最后，我们在`MyClass`中定义了`__subclasshook__`方法，它判断一个类是否实现了`my_method`方法。

from abc import ABC, abstractmethod


class MyABC(ABC):
    @abstractmethod
    def my_method(self):
        pass


class MyClass(object):
    def my_method(self):
        print("MyClass.my_method() is called")

    @classmethod
    def __subclasshook__(cls, C):
        if cls is MyABC:
            if hasattr(C, 'my_method'):
                return True
        return NotImplemented


print(issubclass(MyClass, MyABC))  # True

在上面的代码中，我们使用`issubclass`函数来检查`MyClass`是否是`MyABC`的子类。由于`MyClass`实现了`my_method`方法，而且定义了`__subclasshook__`方法，因此`issubclass(MyClass, MyABC)`返回True。

接下来我们实现一个自己的虚拟子类。我们定义一个普通类`MyClass2`，它没有直接继承自`MyABC`，但是它的基类中定义了`__subclasshook__`方法，该方法判断一个类是否实现了`my_method`方法。然后我们通过`register`方法将`MyClass2`注册为`MyABC`的虚拟子类。

class MyClass2(object):
    def my_method(self):
        print("MyClass2.my_method() is called")

    @classmethod
    def __subclasshook__(cls, C):
        if cls is MyABC:
            if hasattr(C, 'my_method'):
                return True
        return NotImplemented


MyABC.register(MyClass2)

print(issubclass(MyClass2, MyABC))  # True

在上面的代码中，我们使用`register`方法将`MyClass2`注册为`MyABC`的虚拟子类。然后我们再次使用`issubclass`函数来检查`MyClass2`是否是`MyABC`的子类。由于`MyClass2`实现了`my_method`方法，并且已经被注册为`MyABC`的虚拟子类，因此`issubclass(MyClass2, MyABC)`返回True。

总之，`__subclasshook__`方法是ABC中的一个重要方法，它可以让我们方便地判断一个类是否符合某个接口的规范。同时，我们也可以通过`register`方法将一个普通类注册为ABC的虚拟子类。