Everyone is familiar with abstract classes in Java. In Python, we can use the abc module to build abstract classes. Here we will explain how to define and use abstract classes in Python
Like java, python You can also define an abstract class.
Before talking about abstract classes, let’s talk about the implementation of abstract methods.
Abstract methods are methods defined in the base class, but do not have any implementation. In java, you can declare a method as an interface. The simple way to implement an abstract method in python is:
class Sheep（object）：
def get_size(self):
raise NotImplementedErrorAny subclass inherited from Sheep must implement the get_size method. Otherwise an error will be generated. But this implementation method has a drawback. The defined subclass will only throw an error when that method is called. Here's a simple way to trigger it after the class is instantiated. Use the abc module provided by python.
import abc
class Sheep(object):
__metaclass__ = abc.ABCMeta
@abc.absractmethod
def get_size(self):
return
An exception will be thrown when instantiating the Sheep class or any subclass inherited from it (get_size is not implemented).
Therefore, by defining an abstract class, you can define a common method for subclasses (forcing its implementation).
How to use abstract classes
import abc
class A(object):
__metaclass__ = abc.ABCMeta
@abc.abstractmethod
def load(self, input):
return
@abc.abstractmethod
def save(self, output, data):
returnTo create an abstract class through the ABCMeta metaclass, use the abstractmethod decorator. Indicate abstract method
Register a concrete class
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 TrueRegister a concrete class from an abstract class
Subclassing implementation
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 TrueYou can use the method of inheriting abstract classes to implement concrete classes, which can avoid using register. But the side effects are You can find all concrete classes through the base class
for sc in A.__subclasses__(): print sc.__name__ # print C
If you use inheritance, you will find all concrete classes, but if you use register, you will not. Found out
Use __subclasshook__
After using __subclasshook__, as long as the concrete class defines the same method as the abstract class, it is considered to be his subclass
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) # TrueIncomplete implementation
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 TypeErrorD will be thrown if an incomplete concrete class is built Abstract classes and abstract methods cannot be instantiated
Use abstract base classes in concrete classes
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)Print results
base class reading data subclass sorting data ['line one', 'line two', 'line three']
You can use super to reuse logic in abstract base classes, but it will force subclasses to provide override methods.
Abstract attributes
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.valuePrint result, A cannot be instantiated because there is only one abstract property getter method.
Error: ... print concrete property
Define abstract read-write properties
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.valuePrint results, must be defined when defining the property of a specific class Same as abstract abstract property. If you only override one of them it will not work.
error: ... error: ... print 'default value' print 'hello'
Use decorator syntax to implement abstract properties for reading and writing. The methods for reading and writing should be the same.
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'For more articles related to defining and using abstract classes in Python, please pay attention to the PHP Chinese website!
![[Web front-end] Node.js quick start](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
