python 自动化之路 day 面向对象基础

1.面向對象基础概述

  • 面向过程:
  • 根据业务逻辑从上到下垒代码(如果程序修改，对于依赖的过程都需要进行修改。)
  • 函数式:
  • 将某功能代码封装到函数中，如后便无需重复编写，仅需要调用函数即可
  • 面向对象:
  • 世界万物，皆可分类。
  • 世界万物，皆为对象。
  • 只要是对象，就肯定属于某种品类。
  • 只要是对象，就肯定有属性(名称或功能)
  • 对函数进行分类和封装,让开发"更快、更好、更强"

无论用什么形式来编程，我们都要明确记住以下原则: 
1.写重复代码是非常低级的行为 
2.你写的代码需要经常变更

1.面向对象编程方式实现监控报警(最容易被初学者接受):

 
  1. whileTrue：
  2.   if cpu利用率>90%:
  3.     #发送邮件提醒
  4. 　　连接邮箱服务器
  5. 　　发送邮件
  6. 　　关闭连接
  8.   if硬盘使用空间>90%:
  9.     #发送邮件提醒
  10. 　　连接邮箱服务器
  11. 　　发送邮件
  12. 　　关闭连接
  14.   if内存占用>80%:
  15. 　　#发送邮件提醒
  16. 　　连接邮箱服务器
  17. 　　发送邮件
  18. 　　关闭连接

2.随着时间的推移，开始使用了函数式编程，增强代码的重用性和可读性

 
  1. def发送邮件(内容)
  2. 　　#发送邮件提醒
  3. 　　连接邮箱服务器
  4. 　　发送邮件
  5. 　　关闭连接
  7. whileTrue：
  9.   if cpu利用率>90%:
  10. 　　发送邮件('CPU报警')
  12.   if硬盘使用空间>90%:
  13. 　　发送邮件('硬盘报警')
  15. 　if内存占用>80%:
  16. 　　发送邮件('内存报警')

3.今天我们来使用面向对象编程(OOP面向对象程序设计)

 

1.1创建类和对象

面向对象编程是一种编程方式,此变成方式和落地需要使用"类(class)"和"对象(object)"来实现,所以,面向对象编程其实就是对"类"和"对象"的使用。

  • 类就是一个模板，模板里可以包含多个函数，函数里实现具体功能(把一个类变成具体的过程叫做实例化。)
  • 对象则是根据模板创建的实例,通过实例对象可以执行类中的函数
 
  1. #class:关键字,表示要创建类
  2. #F1:类的名称
  3. #self:形式参数(必填)
  5. # 创建类
  6. class F1:
  8.     # 创建类中的函数
  9.     def bar(self):
  10.         print("bar")#可以是功能模块
  12. # 根据类F1创建对象obj
  13. obj = F1()#创建对象,类名称后加括号即可

这么说可能有一些抽象,我们来看一个具体的例子:

 
  1. # 创建类
  2. class F1:
  4.     def bar(self):
  5.         print("bar")
  7.     def Hello(self, name):
  8.         self.name = name
  9.         print("i am %s"%self.name)
  11. # 根据类F1创建对象obj
  12. obj = F1()
  13. obj.bar()#执行bar方法
  14. obj.Hello("xuliangwei")#执行hello方法

你在这里是不是有疑问了？使用函数式编程和面向对象编程方式来执行一个“方法”时函数要比面向对象简便

面向对象:【创建对象】【通过对象执行方法】 
函数编程:【执行函数】 
观察上述对比答案则是肯定的，然后并非绝对，场景的不同适合其的编程方式也不同。 
总结：函数式的应用场景 -->各个函数之间是独立且无共用的数据

 

1.2面向对象三大特征

面向对象的三大特性：封装、继承、多态。

 

1.2.1封装

在类中对数据的赋值，内部调用对外部用户是透明的，这使类变成了一个胶囊或容器，里面包含着类的数据和方法。

1.封装

 
  1. # 创建类
  2. class F2:
  4. #init构造函数,在实例化时做一些类的初始化的工作
  5. def __init__(self, name, age):
  6. self.name = name
  7. self.age = age
  10. # 根据类F2创建对象
  11. # 自动执行F2类的__init__方法
  12. obj1 = F2('xulaingwei',18)
  13. #将xuliangwei和18分别封装到obj1和self的name、age属性中
  15. # 根据类F2创建对象
  16. # 自动执行F2类的__init__方法
  17. obj2 = F2('jack',58)
  18. #将Jack和58分别封装到obj2和self的name、age属性中

2.调用封装的内容时，有两种调用情况：

  • 1.通过对想直接调用
 
  1. # 创建类
  2. class F2:
  3. def __init__(self, name, age):
  4. self.name = name
  5. self.age = age
  8. obj1 = F2('xulaingwei',18)
  9. print(obj1.name,obj1.age)#直接调用obj1对象的name age属性
  12. obj2 = F2('jack',58)
  13. print(obj2.name,obj2.age)#直接调用obj2对象的name age属性
  • 2.通过self间接调用 
    执行类中的方法时，需要通过self间接调用被封装的内容
 
  1. # 创建类
  2. class F2():
  3. def __init__(self,name,age):
  4. self.name = name
  5. self.age = age
  8. def detail(self):
  9. print(self.name)
  10. print(self.age)
  12. obj1 = F2('xuliangwei',18)
  14. obj1.detail()# Python默认会将obj1传给self参数，即:obj1.detail(obj1)，所以，此时方法内部的 self ＝ obj1，即:self.name 是 xuliangwei ；self.age 是 18
  16. obj2 = F2('jack',58)
  17. obj2.detail()# Python默认会将obj2传给self参数，即:obj2.detail(obj2)，所以，此时方法内部的 self ＝ obj2，即:self.name 是 jack ；self.age 是 58

综上所述，对于面向对象的封装来说,其实就是使用构造方法将内容封装到对象中，然后通过对象直接或者self间接获取被封装的内容。

练习题:在终端输出如下信息

 
  1. 小明，10岁，男，上山去砍柴
  2. 小明，10岁，男，开车去东北
  3. 小明，10岁，男，最爱大保健
  5. 老李，90岁，男，上山去砍柴
  6. 老李，90岁，男，开车去东北
  7. 老李，90岁，男，最爱大保健

函数式编程方法:

 
  1. def kanchai (name, age, gender):
  2. print("%s,%s岁,%s,上山砍柴"%(name,age,gender))
  4. def qudongbei(name, age, gender):
  5. print("%s,%s岁,%s,开车去东北"%(name, age, gender))
  8. def dabaojian(name, age, gender):
  9. print("%s,%s岁,%s,最爱大保健"%(name, age, gender))
  11. kanchai('小明',10,'男')
  12. qudongbei('小明',10,'男')
  13. dabaojian('小明',10,'男')
  15. kanchai('老李',90,'男')
  16. qudongbei('老李',90,'男')
  17. dabaojian('老李',90,'男')

面向对象编程方法:

 
  1. #!/usr/bin/env python
  2. # Author:xuliangwei
  4. class F1:
  5. #init构造函数
  6. #在实例化时做一些类的初始化的工作
  7. def __init__(self,name,age,gender):
  8. self.name = name
  9. self.age = age
  10. self.gender = gender
  12. def kanchai(self):
  13. print("%s,%s岁,%s,上山砍柴"%(self.name,self.age,self.gender))
  14. def qudongbei(self):
  15. print("%s,%s岁,%s,开车去东北"%(self.name,self.age,self.gender))
  16. def dabaojian(self):
  17. print("%s,%s岁,%s,最爱大保健"%(self.name,self.age,self.gender))
  20. obj1 = F1('小明',10,'男')
  21. obj1.kanchai()
  22. obj1.qudongbei()
  23. obj1.dabaojian()
  25. obj2 = F1('老李',90,'男')
  26. obj2.kanchai()
  27. obj2.qudongbei()
  28. obj2.dabaojian()
  30. #上述对比可以看出，如果使用函数式编程，需要在每次执行函数时传入相同的参数，如果参数多的话，又需要粘贴复制了... ；而对于面向对象只需要在创建对象时，将所有需要的参数封装到当前对象中，之后再次使用时，通过self间接去当前对象中取值即可。
 

1.2.2继承

一个类可以派生出子类，在这个父类里定义的属性、方法自动被子类继承。 
例如： 
　　猫可以：喵喵叫、吃、喝、拉、撒 
　　狗可以：汪汪叫、吃、喝、拉、撒

 
  1. class mao:
  2. def喵喵叫(self):
  3. print("喵喵叫")
  4. def吃(self):
  5. print("吃")
  6. def喝(self):
  7. print("喝")
  8. def拉(self):
  9. print("拉")
  10. def撒(self):
  11. print("撒")
  14. class gou:
  15. def汪汪叫(self):
  16. print("汪汪叫")
  17. def吃(self):
  18. print("吃")
  19. def喝(self):
  20. print("喝")
  21. def拉(self):
  22. print("拉")
  23. def撒(self):
  24. print("撒")

上述代码不难看出，吃、喝、拉、撒是猫和狗都具有的功能，而我们却分别的猫和狗的类中编写了两次。 
如果使用”继承“的思想，如下实现： 
　　 动物：吃、喝、拉、撒 
　　 猫：喵喵叫（猫继承动物的功能） 
　　 狗：汪汪叫（狗继承动物的功能）

 
  1. classAnimal:
  2. def eat(self):
  3. print("%s 吃 "%(self.name))
  5. def drink(self):
  6. print("%s 喝 "%(self.name))
  8. def shit(self):
  9. print("%s 拉 "%(self.name))
  11. def pee(self):
  12. print("%s 撒 "%(self.name))
  15. classCat(Animal):
  16. def __init__(self, name):
  17. self.name = name
  18. self.breed ='猫'
  20. def cry(self):
  21. print('%s 喵喵叫-->%s'%(self.name,self.breed))
  24. classDog(Animal):
  25. def __init__(self, name):
  26. self.name = name
  27. self.breed ='狗'
  29. def cry(self):
  30. print('%s 汪汪叫-->%s'%(self.name,self.breed))
  33. # ######### 执行 #########
  35. c1 =Cat('小黑猫')
  36. c1.cry()
  37. c1.eat()
  38. c1.drink()
  41. d1 =Dog('小瘦狗')
  42. d1.cry()
  43. d1.eat()
  44. d1.drink()
  45. d1.pee()
  47. ##对于面向对象性继承来说,其实就是将多个类共有的方法提取到父类中，子类仅需继承父类而不必一一实现每个方法.(避免重复造轮子)
  49. 注：除了子类和父类的称谓，你可能看到过派生类和基类，他们与子类和父类只是叫法不同而已。
 

1.2.3多级继承

1.Python的类可以继承多个类，Java和C#中则只能继承一个类 
2.Python的类如果继承了多个类，那么其寻找方法的方式有两种，分别是：深度优先和广度优先 
深度优先以及广度优先

python2经典类，按深度优先来继承的。 
python2新式类，按广度有限来继承的。 
python3经典类,新式类 是按广度优先来继承的。

  • 经典类(深度优先) 
    当类是经典类时，多继承情况下，会按照深度优先方式查找
 
  1. #经典类写法
  2. class A1:
  3. pass
  5. class A2(A1):
  6. pass

经典类,实践测试

 
  1. class D:
  3. def bar(self):
  4. print('D.bar')
  7. class C(D):
  9. def bar(self):
  10. print('C.bar')
  13. class B(D):
  15. def bar(self):
  16. print('B.bar')
  19. class A(B, C):
  21. def bar(self):
  22. print('A.bar')
  24. a = A()
  25. a.bar()
  27. # 执行bar方法时
  28. # 首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去D类中找，如果D类中么有，则继续去C类中找，如果还是未找到，则报错
  29. # 所以，查找顺序：A --> B --> D --> C
  30. # 在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了
  • 新式类(广度优先) 
    当类是新式类时，多继承情况下，会按照广度优先方式查找
 
  1. #新式类写法
  2. class N1(object):
  3. pass
  5. class N2(N1):
  6. pass

新式类,实践测试

 
  1. class D(object):
  3. def bar(self):
  4. print('D.bar')
  7. class C(D):
  9. def bar(self):
  10. print('C.bar')
  13. class B(D):
  15. def bar(self):
  16. print('B.bar')
  19. class A(B, C):
  21. def bar(self):
  22. print('A.bar')
  24. a = A()
  25. a.bar()
  27. # 执行bar方法时
  28. # 首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去C类中找，如果C类中么有，则继续去D类中找，如果还是未找到，则报错
  29. # 所以，查找顺序：A --> B --> C --> D
  30. # 在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了

经典类：首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去D类中找，如果D类中么有，则继续去C类中找，如果还是未找到，则报错

新式类：首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去C类中找，如果C类中么有，则继续去D类中找，如果还是未找到，则报错

 

1.2.4广度优先和深度优先

下图，其深度优先遍历顺序为 1->2->4->8->5->3->6->7 
广度优先 
下图，其广度优先算法的遍历顺序为：1->2->3->4->5->6->7->8 
深度优先

 

1.2.5多态

多态是面向对象的重要特性，简单点说:一个接口，多种实现。

 
  1. class F1:
  2. pass
  4. class S1(F1):
  6. def show(self):
  7. print('S1.show')
  10. class S2(F1):
  12. def show(self):
  13. print('S2.show')
  15. defFunc(obj):
  16. print(obj.show())
  18. s1_obj = S1()
  19. Func(s1_obj)
  21. s2_obj = S2()
  22. Func(s2_obj)
     





posted @ 2016-09-09 16:44  杨小愚  阅读(313)  评论(0)    收藏  举报