python中抽象类和抽象方法_在Python中定义和使用 抽象类及抽象方法 抽象属性

原文链接：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': , ...}

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方法，因此，类Ｄ仍然是抽象类，不可实例化

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运行结果：

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

(完)