如何进行创建Python 多重继承

开发 后端
过程式编程通常是初学的开发人员的最自然编程风格,并且对于许多问题来说也是高度有效的。另一方面,对于创建抽象从而创建可重用的代码来说。

Python 多重继承可能是非常有用的方法。然而,当项目达到某种程度的复杂性之后,过程代码通常会暴露出其根本缺陷。下面让我们直接进入上一个示例的面向对象版本,并看看这样有何变化。

  1. #!/usr/bin/env python  
  2.  
  3. from subprocess import Popen, PIPE  
  4. import re  
  5.  
  6. class DiskMonitor():  
  7.     """Disk Monitoring Class"""  
  8.     def __init__(self,  
  9.                 pattern="2[0-9]%",  
  10.                 message="CAPACITY WARNING",  
  11.                 cmd = "df -h"):  
  12.         self.pattern = pattern  
  13.         self.message = message  
  14.         self.cmd = cmd  
  15.  
  16.     def disk_space(self):  
  17.         """Disk space capacity flag method"""  
  18.         ps = Popen(self.cmd, shell=True,stdout=PIPE,stderr=PIPE)  
  19.         output_lines = ps.stdout.readlines()  
  20.         for line in output_lines:  
  21.             lineline = line.strip()  
  22.             if re.search(self.pattern,line):  
  23.                 print "%s %s" % (self.message,line)  
  24.  
  25. class MyDiskMonitor(DiskMonitor):  
  26.     """Customized Disk Monitoring Class"""  
  27.  
  28.     def disk_space(self):  
  29.         ps = Popen(self.cmd, shell=True,stdout=PIPE,stderr=PIPE)  
  30.         print "RAW DISK REPORT:"  
  31.         print ps.stdout.read()  
  32.  
  33. if __name__ == "__main__":  
  34.     d = MyDiskMonitor()  
  35.     d.disk_space()           

查看该代码的面向对象版本,可以看到代码变得更加抽象。有时,太多的抽象会导致设计问题,但是在此例中,它允许您将问题分离为更多可重用的部分。DiskMonitor 类具有 __init__ method,您可以在其中定义新的参数,并且 disk_space 函数现在是该类中的一个方法。

使用这种新的样式,您无需更改原始代码即可容易地重用和自定义各个部分,而使用过程代码时则通常必须更改原始代码。Python 多重继承面向对象的设计的一个更加功能强大、通常也被过度使用的方面是继承。继承允许您在新的类中重用和自定义现有的代码。让我们在下一个示例中看看继承可能像什么样子。

此输出与前面带标记的版本区别非常大,因为它只是使用顶部注入的 print 语句来打印的未经筛选的 df –h 命令结果。通过重写 MyDiskMonitor 类中的方法,您能够完全改变 disk_space 方法的意图。 #t#

允许您重用其他类中的属性的 Python 多重继承是这个“MyDiskMonitor(DiskMonitor)”语句。您只需在定义新类的名称时,将先前的类的名称放在括号内。一旦完成此步骤,您立即可以访问其他类属性来做自己希望的事情。但是乐趣不仅于此。通过添加另一个通过电子邮件来发送标记消息的方法。

也许是将其命名为 disk_alert(self),这样就可以进一步自定义新类。这是面向对象的设计的美妙之处;它允许有经验的开发人员不断重用已编写的代码,从而节省大量的时间。 遗憾的是,面向对象的编程也有其不利的一面。所有这些抽象都是以复杂性为代价的,如果抽象过度,可能会彻底地弄巧成拙。

由于 Python 多重继承,抽象可以达到相当有害的复杂程度。您是否能够想象只是为了编写一个方法也要查看多个文件的情况?无论相信与否,这种情况的确会发生,并且代表了面向对象编程的不幸现实。

责任编辑:chenqingxiang 来源: 博客园
相关推荐

2021-05-17 14:02:38

Swift 多重排序

2009-12-08 11:34:40

WCF Windows

2010-01-20 09:32:30

C++类

2010-02-22 16:05:40

Python配置

2010-02-01 10:21:36

Python编码转换

2010-02-03 13:55:51

Python 代码

2010-02-01 14:48:43

2010-02-01 17:33:24

Python主线程

2010-03-15 15:11:50

Python列表

2010-02-02 16:47:12

Python主线程

2010-03-11 17:38:20

Python中文

2011-08-16 17:19:59

linux加密分区

2010-02-22 17:12:34

Python对象

2010-03-01 16:32:36

Python语言

2010-03-09 18:14:55

Python sock

2010-03-15 15:45:15

Python编程语言

2010-03-01 11:06:52

Python 调试器

2010-02-01 16:22:36

Python字符串操作

2021-05-24 12:10:54

PythonSpaceX代码

2010-03-12 19:29:15

python svn脚
点赞
收藏

51CTO技术栈公众号