2022年 11月 4日

Python多态的两种实现形式

说明：仅供学习使用，请勿用于非法用途，若有侵权，请联系博主删除

作者：zhu6201976

博客：https://blog.csdn.net/zhu6201976

一、Python多态

1.对象多态

对象多态：在继承体系中，定义时的类型和运行时的类型不一样，此时就构成多态

以下是Python伪代码实现Java或C的多态：

  1. class A(object):
  2.     def test(self):
  3.         print('A test')
  4.  
  5.  
  6. class B(A):
  7.     def test(self):
  8.         print('B test')
  9.  
  10.  
  11. class C(A):
  12.     def test(self):
  13.         print('C test')
  14.  
  15.  
  16. def go(a):
  17.     """
  18.     接收A类或其子类实例
  19.     :param a:
  20.     :return:
  21.     """
  22.     a.test()
  23.  
  24.  
  25. if __name__ == '__main__':
  26.     go(A())
  27.     go(B())
  28.     go(C())

执行结果：

由此可见，go函数接收A类或其子类对象，无论是传递A类对象、B类对象、C类对象，方法都可以正常执行， 此时便构成了对象的多态。

2.类多态

类多态：指通过@classmethod形式多态地构造对象，而不是使用Python默认的__init__构造器

需求：实现一套MapReduce流程，用于统计目录下所有文件的总行数，代码如下：

  1. """
  2. 知识要点:
  3.     1.接口 抽象 继承
  4.     2.生成器
  5.     3.map reduce
  6.     4.多线程
  7.     5.通过@classmethod形式批量创建对象
  8. """
  9. import os
  10. import threading
  11.  
  12.  
  13. class GenericInputData(object):
  14.     """
  15.     通用输入抽象类 抽象方法由子类实现
  16.     """
  17.     def read(self):
  18.         raise NotImplementedError
  19.  
  20.     @classmethod
  21.     def generate_inputs(cls, config):
  22.         raise NotImplementedError
  23.  
  24.  
  25. class FileInputData(GenericInputData):
  26.     """
  27.     文件输入类
  28.     """
  29.     def __init__(self, path):
  30.         super().__init__()
  31.         self.path = path
  32.  
  33.     def read(self):
  34.         return open(self.path, 'r', encoding='utf-8').read()
  35.  
  36.     @classmethod
  37.     def generate_inputs(cls, config):
  38.         dir_path = config['dir_path']
  39.         for file_name in os.listdir(dir_path):
  40.             yield cls(os.path.join(dir_path, file_name))
  41.  
  42.  
  43. class GenericWorker(object):
  44.     """
  45.     通用Worker抽象类 抽象方法由子类实现
  46.     """
  47.     def __init__(self, input_data):
  48.         self.input_data = input_data
  49.         self.result = None
  50.  
  51.     def map(self):
  52.         raise NotImplementedError
  53.  
  54.     def reduce(self, other):
  55.         raise NotImplementedError
  56.  
  57.     @classmethod
  58.     def generate_workers(cls, input_class, config):
  59.         for input_data in input_class.generate_inputs(config):
  60.             yield cls(input_data)
  61.  
  62.  
  63. class LineCountWorker(GenericWorker):
  64.     """
  65.     统计文件换行符Worker类
  66.     """
  67.     def map(self):
  68.         content = self.input_data.read()
  69.         self.result = content.count('\n')
  70.  
  71.     def reduce(self, other):
  72.         self.result += other.result
  73.  
  74.  
  75. def execute(workers):
  76.     threads = [threading.Thread(target=w.map) for w in workers]
  77.     for thread in threads:
  78.         thread.start()
  79.         thread.join()
  80.  
  81.     first, rest = workers[0], workers[1:]
  82.     for other in rest:
  83.         first.reduce(other)
  84.  
  85.     return first.result
  86.  
  87.  
  88. def map_reduce(input_class, worker_class, config):
  89.     gen_workers = worker_class.generate_workers(input_class, config)
  90.     workers = list(gen_workers)
  91.     return execute(workers)
  92.  
  93.  
  94. if __name__ == '__main__':
  95.     result = map_reduce(FileInputData, LineCountWorker, {'dir_path': 'temp'})
  96.     print(result)

由此可见，在Python中，不仅可以通过__init__构造器创建对象，也可以通过@classmethod形式多态地构建对象。