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)
    
     

来自为知笔记(Wiz)