Python ABC(抽象基类)及 应用场景

文章介绍了Python中的抽象基类(ABC)的概念和作用,包括如何定义抽象方法,以及使用`@abstractmethod`装饰器。它允许子类继承并实现必要的方法,提供了一种定义接口的方式。文章还提到了`six`模块在Python2和3兼容性方面的帮助,以及`add_metaclass`装饰器的应用。通过示例展示了如何创建抽象基类,子类继承并实现方法,以及注册虚拟子类。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

ABC,Abstract Base Class(抽象基类),主要定义了基本类和最基本的抽象方法,可以为子类定义共有的API,不需要具体实现。相当于是Java中的接口或者是抽象类。

抽象基类可以不实现具体的方法(当然也可以实现,只不过子类如果想调用抽象基类中定义的方法需要使用super())而是将其留给派生类实现。

抽象基类提供了逻辑和实现解耦的能力,即在不同的模块中通过抽象基类来调用,可以用最精简的方式展示出代码之间的逻辑关系,让模块之间的依赖清晰简单。同时,一个抽象类可以有多个实现,让系统的运转更加灵活。而针对抽象类的编程,让每个人可以关注当前抽象类,只关注其方法和描述,而不需要考虑过多的其他逻辑,这对协同开发有很大意义。极简版的抽象类实现,也让代码可读性更高。

抽象基类的使用:

1:直接继承:直接继承抽象基类的子类就没有这么灵活,抽象基类中可以声明”抽象方法“和“抽象属性”,只有完全覆写(实现)了抽象基类中的“抽象”内容后,才能被实例化,而虚拟子类则不受此影响。

2:虚拟子类

将其他的类”注册“到抽象基类下当虚拟子类(调用register方法),虚拟子类的好处是你实现的第三方子类不需要直接继承自基类,可以实现抽象基类中的部分API接口,也可以根本不实现,但是issubclass(), issubinstance()进行判断时仍然返回真值。

Python 对于ABC的支持模块是abc模块,定义了一个特殊的metaclass:ABCMeta 还有一些装饰器:@abstractmethod 和 @abstractproperty 。abc.ABCMeta 用于在Python程序中创建抽象基类。而抽象基类如果想要声明“抽象方法”,可以使用 @abstractmethod ,如果想声明“抽象属性”,可以使用 @abstractproperty 。

为了解决Python2&3的兼容问题,需要引入six模块,该模块中有一个针对类的装饰器 @six.add_metaclass(MetaClass) 可以为两个版本的Python类方便地添加metaclass

通用做法。

@six.add_metaclass(MetaClass) 的作用是在不同版本的Python之间提供一个优雅的声明类的metaclass的手段,事实上不用它也可以,只是使用了它代码更为整洁明了。

实例:

import abc
import six
@six.add_metaclass(abc.ABCMeta)
class BaseClass(object):
    @abc.abstractmethod
    def func_a(self, data):
        """
        an abstract method need to be implemented
        """
    @abc.abstractmethod
    def func_b(self, data):
        """
        another abstract method need to be implemented
        """
class SubclassImpl(BaseClass):
    def func_a(self, data):
        print("Overriding func_a, " + str(data))
    @staticmethod
    def func_d(self, data):
        print(type(self) + str(data))
class RegisteredImpl(object):
    @staticmethod
    def func_c(data):
        print("Method in third-party class, " + str(data))
BaseClass.register(RegisteredImpl)
if __name__ == '__main__':
    for subclass in BaseClass.__subclasses__():
        print("subclass of BaseClass: " + subclass.__name__)
    print("subclass do not contains RegisteredImpl")
    print("-----------------------------------------------")
    print("RegisteredImpl is subclass: " + str(issubclass(RegisteredImpl, BaseClass)))
    print("RegisteredImpl object  is instance: " + str(isinstance(RegisteredImpl(), BaseClass)))
    print("SubclassImpl is subclass: " + str(issubclass(SubclassImpl, BaseClass)))
    print("-----------------------------------------------")
    obj1 = RegisteredImpl()
    obj1.func_c("RegisteredImpl new object OK!")
    print("-----------------------------------------------")
    obj2 = SubclassImpl()  #由于没有实例化所有的方法,所以这里会报错 Can't instantiate abstract class SubclassImpl with abstract methods func_b
    obj2.func_a("It's right!")

结果如下:

subclass of BaseClass: SubclassImpl
subclass do not contains RegisteredImpl
-----------------------------------------------
RegisteredImpl is subclass: True
RegisteredImpl object  is instance: True
SubclassImpl is subclass: True
-----------------------------------------------
Method in third-party class, RegisteredImpl new object OK!
-----------------------------------------------
Traceback (most recent call last):
  File "/Users/bytedance/codes/repos37/adhoc/pytorch_test/pytorch_test3.py", line 38, in <module>
    obj2 = SubclassImpl()  #由于没有实例化所有的方法,所以这里会报错 Can't instantiate abstract class SubclassImpl with abstract methods func_b
TypeError: Can't instantiate abstract class SubclassImpl with abstract methods func_b

1. #我们去检查某个类是否有某种方法

import abc
import six

class Company(object):
    def __init__(self, employee_list):
        self.employee = employee_list
    def __len__(self):
        return len(self.employee)
com = Company(["bobby1","bobby2"])
print(hasattr(com, "__len__"))
class A:
    pass
class B:
    pass

2. #我们在某些情况之下希望判定某个对象的类型

from collections.abc import Sized
isinstance(com, Sized)
b = B()
print(isinstance(b, A))
# print(len(com))

3.

import abc
import six

#我们需要强制某个子类必须实现某些方法
#实现了一个web框架,集成cache(redis, cache, memorychache)
#需要设计一个抽象基类, 指定子类必须实现某些方法
#如何去模拟一个抽象基类
import abc
from collections.abc import *

class CacheBase(metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def get(self, key):
        raise NotImplementedError
    @abc.abstractmethod
    def set(self, key, value):
        raise NotImplementedError

#以下直接register可以
class RedisCache(object):
    def set(self, key, value):
        print('set key={} value={}'.format(key, value))

CacheBase.register(RedisCache)
redis_cache = RedisCache()
redis_cache.set("key", "value")

#以下继续就废了:
class RedisCache1(CacheBase):
    def set(self, key, value):
        print('set key={} value={}'.format(key, value))
redis_cache1 = RedisCache1()
redis_cache1.set("key", "value")

# 报错: TypeError: Can't instantiate abstract class RedisCache1 with abstract methods get

————————————————

版权声明:本文为优快云博主「hurt--」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。

原文链接:https://blog.youkuaiyun.com/weixin_40907382/article/details/80277170

### Python 抽象基类 (ABC) 的概念 抽象基类是在面向对象编程中定义接口的一种方式。在 Python 中,`abc` 模块提供了实现抽象基类的支持[^1]。 #### 定义抽象基类 要创建一个抽象基类,需导入 `abc` 模块并使用 `ABC` 类作为基类之一,在其中声明至少一个带有装饰器 `@abstractmethod` 的方法。这使得该类无法被实例化除非其所有抽象方法都被重写[^2]。 ```python from abc import ABC, abstractmethod class MyAbstractClass(ABC): @abstractmethod def my_abstract_method(self): """这是一个必须由子类实现的方法""" pass ``` #### 继承自抽象基类 当有具体类继承于上述抽象基类时,则它要么实现了所有的抽象方法,要么本身也标记为抽象类。如果未覆盖这些方法而尝试实例化此类会抛出错误。 ```python class ConcreteClass(MyAbstractClass): def my_abstract_method(self): print("Concrete implementation of the method.") obj = ConcreteClass() # 这是可以正常工作的 obj.my_abstract_method() ``` #### 虚拟子类机制 除了传统的继承关系外,还可以利用 `register()` 方法来注册其他类型的对象成为某个特定抽象基类的“虚拟子类”。这种方式并不强制要求实际继承结构上的关联,而是基于协议或约定的形式来进行类型检查和行为确认[^4]。 ```python import collections.abc collections.abc.Sequence.register(tuple) print(isinstance((1, 2), collections.abc.Sequence)) # True ```
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值