在Python中定义和使用 抽象类及抽象

2023-01-31 02:01:52 抽象 定义 抽象类

原文链接:Http://www.jb51.net/article/87710.htm

本文根据自己的理解和思考,对原文略有改动。。。

python中我们可以使用abc模块来构建抽象类。在讲抽象类之前,先说下抽象方法的实现。

抽象方法是基类中定义的方法,但却没有任何实现。在Python中实现一个抽象方法的简单的方法是:

class Sheep(object):
    def __init__(self):
        print '__init__ is called!'
    def get_size(self):
        raise NotImplementedError
s=Sheep()#生成一个实例。注意实例化时,并没有抛出错误
s.get_size()#只有调用该方法时才会抛出错误
任何从Sheep继承下来的子类必须实现(重写)get_size方法,否则就会抛出一个错误。
但这种实现方法有个缺点:定义的子类只有调用那个方法时才会抛错。
这里有个简单方法可以在类被实例化时触发它:使用python提供的abc模块。

import abc
class Sheep(object):
    __metaclass__ = abc.ABCMeta
    @abc.abstractmethod
    def get_size(self):
        return
    
class sheepson(Sheep):
    def __init__(self):
        print 'sheepson.__init__ is called!'
    
s1=Sheep()   #报错,不能实例化抽象类
s2=sheepson()#报错,不能实例化抽象类
这里实例化Sheep类或实例化任意从其继承的子类(未实现get_size)时候都会抛出异常。
因此,通过定义抽象类,可以定义子类的共同method(强制其实现)。
如何使用抽象类:

import abc 
class A(object):
    __metaclass__ = abc.ABCMeta
    @abc.abstractmethod
    def load(self, input):
        return
    @abc.abstractmethod
    def save(self, output, data):
        return
通过ABCMeta元类来创建一个抽象类, 使用abstractmethod装饰器来表明抽象方法
注册具体类:

import abc 
class A(object):
    __metaclass__ = abc.ABCMeta
    @abc.abstractmethod
    def load(self, input):
        return
    @abc.abstractmethod
    def save(self, output, data):
        return

class B(object):
    def load(self, input):
        return input.read()
    def save(self, output, data):
        return output.write(data)

A.reGISter(B)#从抽象类注册一个具体的类
 
if __name__ == '__main__':
    print issubclass(B, A)    # print True
    print isinstance(B(), A)  # print True
使用继承抽象类的方法来实现具体类:

import abc 
class A(object):
    __metaclass__ = abc.ABCMeta
    @abc.abstractmethod
    def load(self, input):
        return
    @abc.abstractmethod
    def save(self, output, data):
        return

class B(A):
    def load(self, input):
        return input.read()
    def save(self, output, data):
        return output.write(data)

class C(A):
    def load(self, input):
        return input.read()
    def save(self, output, data):
        return output.write(data)

if __name__ == '__main__':
    print issubclass(B, A)    # print True
    print isinstance(B(), A)  # print True
    print issubclass(C, A)    # print True
    print isinstance(C(), A)  # print True
可以使用继承抽象类的方法来实现具体类,这样可以避免使用register。
但是副作用是可以通过基类找出所有的具体类。。。。。

print A.__subclasses__()
for subclass in A.__subclasses__():
    print subclass.__name__
使用继承的方式会找出所有的具体类,但如果使用register的方式则不会被找出。。。
使用__subclasshook__ :
使用__subclasshook__后只要具体类定义了与抽象类相同的方法就认为是他的子类。

import abc
class A(object):
    __metaclass__ = abc.ABCMeta
    @abc.abstractmethod
    def say(self):
        return 'say yeah'
    @claSSMethod
    def __subclasshook__(cls, C):
        if cls is A:
            if any("say" in B.__dict__ for B in C.__mro__):
                return True
        return NotImplemented
 
class B(object):
    def say(self):
        return 'hello'
 
print issubclass(B, A)    # True
print isinstance(B(), A)  # True
print B.__dict__      # {'say': <function say at 0x7f...>, ...}
print A.__subclasshook__(B) # True
不完整的实现:

import abc 
class A(object):
    __metaclass__ = abc.ABCMeta
    @abc.abstractmethod
    def load(self, input):
        return
    @abc.abstractmethod
    def save(self, output, data):
        return
    
class D(A):#类D继承了类A,重写了save方法,但没有重写load方法,因此,类D仍然是抽象类,不可实例化
    def save(self, output, data):
        return output.write(data)
 
if __name__ == '__main__':
    print issubclass(D, A)    # print True
    print isinstance(D(), A)  # raise TypeError
构建不完整的具体类,实际上仍然是抽象类,仍然不可实例化。。。
具体类中使用抽象基类:

import abc 
from cStringIO import StringIO
class A(object):#包含抽象方法的类称为抽象类,抽象类不可实例化
    __metaclass__ = abc.ABCMeta
    @abc.abstractmethod
    def retrieve_values(self, input):
        print 'base class reading data'
        return input.read()

class B(A):
    def retrieve_values(self, input):
        base_data = super(B, self).retrieve_values(input)
        print 'subclass sorting data'
        response = sorted(base_data.splitlines())
        return response

input = StringIO("""line one
line two
line three
""")
reader = B()
print reader.retrieve_values(input)
运行结果:
base class reading data
subclass sorting data
['line one', 'line three', 'line two']
可以使用super来重用抽象基类中的罗辑, 但会迫使子类提供覆盖方法。
抽象属性:

import abc
class A(object):
    __metaclass__ = abc.ABCMeta
    @abc.abstractproperty
    def value(self):
        return 'should never get here.'
 
class B(A):
    @property
    def value(self):
        return 'concrete property.'
    
try:
    a = A()#Can't instantiate abstract class A with abstract methods value
    print 'A.value', a.value
except TypeError, err:
    print type(err)
    print err
    print str(err)
    print 'TypeError: ', str(err)
 
b = B()
print 'B.value:', b.value
运行结果:
<type 'exceptions.TypeError'>
Can't instantiate abstract class A with abstract methods value
Can't instantiate abstract class A with abstract methods value
TypeError:  Can't instantiate abstract class A with abstract methods value
B.value: concrete property.
定义抽象的读写属性:

import abc  
class A(object):  
    __metaclass__ = abc.ABCMeta  
    def get_value(self):  
        return 'Should never see this.'  
    def set_value(self, value):  
        return  
    value = abc.abstractproperty(get_value, set_value)#value是 抽象的读写属性。 
   
class B(A):  
    @abc.abstractproperty  
    def value(self):#重写value方法,但依然是抽象属性。
        return 'read-only'  

class C(A):  
    _value = 'default value' #类的属性,所有实例可以共享  
    def get_value(self):  
        return self._value  
    def set_value(self, value):  
        self._value = value  
    #定义具体类的property时必须与抽象类的abstract property相同。如果只覆盖其中一个将不会工作。。  
    value = property(get_value,set_value)#此时的value是 具体的读写属性。

try:  
    a = A()  
    print a.value  
except Exception, err:  
    print str(err)  

try:  
    b = B()  
    print b.value  
except Exception, err:  
    print str(err)  
   
c = C()  
print C._value #通过类名 访问类的属性  
print c.value #访问实例c自己的_value属性,但此时,实例c自己没有_value属性,因此实际访问的是类的 _value属性  
c.value = 'hello' #为实例c添加一个_value属性,赋初值为'hello'  
print c.value #访问实例c自己的_value属性  
print C._value #访问类的_value属性  

运行结果:
Can't instantiate abstract class A with abstract methods value
Can't instantiate abstract class B with abstract methods value
default value
default value
hello
default value
注意:定义具体类的property时必须与抽象的abstract property相同。如果只覆盖其中一个将不会工作。
使用装饰器语法来实现读写的抽象属性, 读和写的方法名应该相同。

import abc
class A(object):
    __metaclass__ = abc.ABCMeta
    @abc.abstractproperty
    def value(self):
        return 'should never see this.'
    @value.setter
    def value(self, _value):
        return
 
class B(A):
    _value = 'default'
    @property
    def value(self):
        return self._value
    @value.setter
    def value(self, _value):
        self._value = _value
 
b = B()
print b.value    #尝试访问实例b的_value属性,但b自己没有该属性,因此访问的是类的_value属性。
b.value = 'hello'#为实例b添加_value属性,初始值为'hello'
print b.value    #访问实例b自己的_value属性
运行结果:
default
hello

(完)


相关文章