在Python中定义和使用 抽象类及抽象方法 抽象属性
2016-09-06 13:50
911 查看
原文链接:http://www.jb51.net/article/87710.htm
本文根据自己的理解和思考,对原文略有改动。。。
Python中我们可以使用abc模块来构建抽象类。在讲抽象类之前,先说下抽象方法的实现。
抽象方法是基类中定义的方法,但却没有任何实现。在python中实现一个抽象方法的简单的方法是:
但这种实现方法有个缺点:定义的子类只有调用那个方法时才会抛错。
这里有个简单方法可以在类被实例化时触发它:使用python提供的abc模块。
因此,通过定义抽象类,可以定义子类的共同method(强制其实现)。
如何使用抽象类:
注册具体类:
但是副作用是可以通过基类找出所有的具体类。。。。。
使用__subclasshook__ :
使用__subclasshook__后只要具体类定义了与抽象类相同的方法就认为是他的子类。
具体类中使用抽象基类:
base class reading data
subclass sorting data
['line one', 'line three', 'line two']
可以使用super来重用抽象基类中的罗辑, 但会迫使子类提供覆盖方法。
抽象属性:
<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.
定义抽象的读写属性:
运行结果:
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相同。如果只覆盖其中一个将不会工作。
使用装饰器语法来实现读写的抽象属性, 读和写的方法名应该相同。
default
hello
(完)
本文根据自己的理解和思考,对原文略有改动。。。
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可以使用继承抽象类的方法来实现具体类,这样可以避免使用register。
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
但是副作用是可以通过基类找出所有的具体类。。。。。
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
(完)
相关文章推荐
- 在Python中定义和使用抽象类的方法
- 在Python中定义和使用抽象类的方法
- Java关键字static,abstract,instanceof使用(静态属性,静态方法,抽象类抽象方法的学习)
- python 之浅谈接口的定义和抽象类以及抽象方法
- 在Python中定义和使用抽象类的方法
- 使用Spring替换properties文件定义属性的方法
- Python类的定义、继承及类对象使用方法简明教程
- C#第2次试验(1).创建一个抽象类A,该类中包含一个求两个数之和抽象方法。创建一个子类B,在B中重写求和方法,且使用方法重载使得方法可以分别计算整数、双精度、字符串。
- javascript笔记07:使用Object类为实例定义方法和属性
- 建立抽象类Student,添加属性学号,姓名,平均分,添加方法show()显示学生的个人信息(学号,姓名),添加抽象方法average()计算学生的平均成绩。建立Student的子类studentIT
- 抽象类、抽象方法的特点及使用
- python基础教程之类class定义使用方法
- 抽象类的抽象方法及使用
- 关于Python中如何使用静态、类、抽象方法的权威指南
- python 抽象类、抽象方法的实现
- 抽象类、抽象方法的特点及使用
- 使用VISIO中的UML图表达C++语言中抽象类或抽象方法
- PHP __get()和__set()的使用方法(存取或者调用未定义的属性变量)
- 2.创建一个抽象类A,该类中包含一个求两个数之和抽象方法。创建一个子类B,在B中重写求和方法,且使用方法重载使得方法可以分别计算整数、双精度、字符串
- 如何在C#中使用get及set方法定义属性