提起java的抽象类大家都比较熟悉,python中我们可以使用abc模块来构建抽象类,这里就为大家讲解在python中定义和使用抽象类的方法
像java一样python也可以定义一个抽象类。
在讲抽象类之前，先说下抽象方法的实现。
抽象方法是基类中定义的方法，但却没有任何实现。在java中，可以把方法申明成一个接口。而在python中实现一个抽象方法的简单的方法是：
class sheep（object）：
def get_size(self):
raise notimplementederror
任何从sheep继承下来的子类必须实现get_size方法。否则就会产生一个错误。但这种实现方法有个缺点。定义的子类只有调用那个方法时才会抛错。这里有个简单方法可以在类被实例化后触发它。使用python提供的abc模块。
import abc
class sheep(object):
__metaclass__ = abc.abcmeta
@abc.absractmethod
def get_size(self):
return
这里实例化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装饰器来表明抽象方法
注册具体类
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
从抽象类注册一个具体的类
子类化实现
class c(a):
def load(self, input):
return input.read()
def save(self, output, data):
return output.write(data)
if __name__ == '__main__':
print issubclass(c, a) # print true
print isinstance(c(), a) # print true
可以使用继承抽象类的方法来实现具体类这样可以避免使用register. 但是副作用是可以通过基类找出所有的具体类
for sc in a.__subclasses__():
print sc.__name__
# print c
如果使用继承的方式会找出所有的具体类，如果使用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 nottmplementd
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
不完整的实现
class d(a):
def save(self, output, data):
return output.write(data)
if __name__ == '__main__':
print issubclass(d, a) # print true
print isinstance(d(), a) # raise typeerror
如果构建不完整的具体类会抛出d不能实例化抽象类和抽象方法
具体类中使用抽象基类
import abc
from cstringio import stringio
class a(object):
__metaclass__ = abc.abcmeta
@abc.abstractmethod
def retrieve_values(self, input):
pirnt '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 two', 'line three']
可以使用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()
print 'a.value', a.value
except exception, err:
print 'error: ', str(err)
b = b()
print 'b.value', b.value
打印结果,a不能被实例化，因为只有一个抽象的property getter method.
error: ...
print concrete property
定义抽象的读写属性
import abc
class a(object):
__metaclass__ = abc.abcmeta
def value_getter(self):
return 'should never see this.'
def value_setter(self, value):
return
value = abc.abstractproperty(value_getter, value_setter)
class b(a):
@abc.abstractproperty
def value(self):
return 'read-only'
class c(a):
_value = 'default value'
def value_getter(self):
return self._value
def value_setter(self, value):
self._value = value
value = property(value_getter, value_setter)
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
c.value = 'hello'
print c.value
打印结果, 定义具体类的property时必须与抽象的abstract property相同。如果只覆盖其中一个将不会工作.
error: ...
error: ...
print 'default value'
print 'hello'
使用装饰器语法来实现读写的抽象属性, 读和写的方法应该相同.
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 # print 'default'
b.value = 'hello'
print b.value # print 'hello'
更多python中定义和使用抽象类。