python abstractmethod|极客教程

python abstractmethod

1. 引言

在Python中，我们经常会遇到需要定义一些基类（父类）的情况。而在这些基类中，有时我们会定义一些方法，这些方法并没有具体的实现，只是给出一个方法的名字和参数列表，我们称之为抽象方法。抽象方法不能被直接调用，只能被子类重写实现。

在本文中，我们将详细讨论Python中抽象方法的概念、用法以及相关内容。

2. 抽象方法的定义与特点

在Python中，我们通过abc模块来定义和使用抽象方法。abc是Abstract Base Classes的缩写，即抽象基类。抽象基类是不能直接实例化的，只能被子类继承。而抽象方法是在抽象基类中定义的方法，只给出方法的声明而没有具体的实现，由子类来实现。

我们可以通过继承abc模块中的ABC类来定义一个抽象基类，然后通过@abstractmethod装饰器来定义一个抽象方法。例如，下面是一个简单的示例代码：

from abc import ABC, abstractmethod

class Animal(ABC):
    @abstractmethod
    def sound(self):
        pass

class Dog(Animal):
    def sound(self):
        return "Woof"

class Cat(Animal):
    def sound(self):
        return "Meow"

在上面的代码中，我们定义了一个Animal抽象基类，并在其中定义了一个抽象方法sound。这个抽象方法没有具体的实现，只是给出了方法名和参数列表。然后，我们分别定义了Dog和Cat两个子类，并在子类中实现了sound方法。

需要注意的是，如果一个类继承了抽象基类，但没有实现其中的抽象方法，那么这个子类也会被认为是抽象类，无法被实例化。在上面的代码中，如果我们定义一个Bird类继承自Animal，但没有实现sound方法，那么Bird类也将成为抽象类。

3. 抽象方法的作用

抽象方法的作用主要有以下几个方面：

1) 规范化子类的行为

通过在抽象基类中定义抽象方法，可以规范子类的行为。子类必须实现抽象基类中定义的所有抽象方法，否则将会引发TypeError异常。这种方式可以确保子类具有相同的行为，提高代码的可维护性。

2) 强制子类实现某些方法

有时候，我们希望子类必须实现某些方法，否则就会编译错误。通过定义抽象方法，我们可以确保子类在继承基类时，必须实现这些抽象方法。

3) 提供基类的默认实现

抽象基类中的抽象方法没有具体的实现，而是由子类来实现。这为基类提供了一种默认的行为。如果子类没有重写抽象方法，那么将使用基类中的默认实现。

4. 抽象方法的使用

在上一节中，我们已经展示了一个简单的抽象方法的示例。接下来，我们将更进一步讨论抽象方法的使用。

4.1 抽象方法的调用

我们知道，抽象方法不能被直接调用，只能被子类重写实现。例如，在上面的代码示例中，我们可以通过实例化Dog和Cat的对象，然后调用其sound方法来得到对应的声音：

dog = Dog()
cat = Cat()

print(dog.sound())  # Output: Woof
print(cat.sound())  # Output: Meow

在上面的代码中，我们创建了一个Dog对象和一个Cat对象，然后分别调用其sound方法，得到了对应的声音。需要注意的是，由于我们在Animal抽象基类中定义了sound方法，所以这里才能调用这个方法。如果我们尝试实例化Animal，那么将引发TypeError异常。

4.2 抽象方法的重写

子类继承抽象基类时，必须实现抽象基类中的抽象方法。如果子类没有实现所有的抽象方法，依然会引发TypeError异常。

例如，在上面的代码示例中，我们定义了Dog和Cat两个子类去继承Animal抽象基类，并分别实现了sound方法。如果我们尝试定义一个Bird类继承自Animal，但没有实现sound方法，那么将引发TypeError异常。

class Bird(Animal):
    pass

bird = Bird()  # Output: TypeError: Can't instantiate abstract class Bird with abstract methods sound

在上面的代码中，我们定义了Bird类继承自Animal，但没有实现sound方法，因此会引发TypeError异常。

4.3 抽象基类的实例化

我们知道，抽象基类是不能直接实例化的，只能被子类继承。如果我们尝试实例化一个抽象基类，那么也会引发TypeError异常。

例如，在上面的代码示例中，如果我们尝试实例化Animal，就会引发TypeError异常：

animal = Animal()  # Output: TypeError: Can't instantiate abstract class Animal with abstract methods sound

在上面的代码中，我们实例化了一个Animal对象，但是Animal是抽象基类，所以会引发TypeError异常。

5. 抽象方法的示例应用

抽象方法是一种非常有用的工具，在实际开发中有广泛的应用。接下来，我们通过一个简单的示例来展示抽象方法的一些应用。

假设我们正在制作一个游戏，需要定义一些角色的行为。我们可以定义一个Character抽象基类，其中包含一些必须由每个角色实现的抽象方法，例如attack和defense。然后，我们可以定义一些具体的角色子类，例如Warrior（战士）和Mage（法师），并在子类中实现这些抽象方法。

下面是示例代码：

from abc import ABC, abstractmethod

class Character(ABC):
    @abstractmethod
    def attack(self):
        pass

    @abstractmethod
    def defense(self):
        pass

class Warrior(Character):
    def attack(self):
        return "Warrior attacks with a sword"

    def defense(self):
        return "Warrior defends with a shield"

class Mage(Character):
    def attack(self):
        return "Mage attacks with magic spells"

    def defense(self):
        return "Mage defends with magical barriers"

warrior = Warrior()
mage = Mage()

print(warrior.attack())  # Output: Warrior attacks with a sword
print(warrior.defense())  # Output: Warrior defends with a shield

print(mage.attack())  # Output: Mage attacks with magic spells
print(mage.defense())  # Output: Mage defends with magical barriers

在上面的代码中，我们定义了一个Character抽象基类，并在其中定义了attack和defense两个抽象方法。然后，我们定义了Warrior和Mage两个具体的角色子类，并在子类中分别实现了这两个抽象方法。

通过实例化Warrior和Mage的对象，我们可以调用其attack和defense方法，得到对应角色的攻击和防御行为。

使用抽象方法可以确保每个角色都具有相同的方法，并在子类中实现了自己独特的行为，提高了代码的可维护性和扩展性。