面向对象1

1.函数式编程和面向对象的对比

　　开发一个消息提醒的功能(邮件/短信/微信)

函数:

 1 def mail(em,text):
 2     """
 3     发送邮件
 4     :return:
 5     """
 6     print(em,text)
 7 
 8 def msg(tel,text):
 9     """
10     发送短信
11     :return:
12     """
13     print(tel,text)
14 
15 def wechat(num,text):
16     """
17     发送微信
18     :return:
19     """
20     print(num,text)
21 
22 编写功能:
23     if 条件:
24         email('xxx','xxx')
25         msg('xxx','xxx')
26         wechat('xxx','xxx')

面向对象:

 1 class Message:
 2     def mail(self,em,text):
 3         """
 4         发送邮件
 5         :return:
 6         """
 7         print(em,text)
 8 
 9     def msg(self,tel,text):
10         """
11         发送短信
12         :return:
13         """ 
14         print(tel,text)
15 
16     def wechat(self,num,text):
17         """
18         发送微信
19         :return:
20         """
21         print(num,text)
22 
23 编写功能:
24     if 条件:
25         obj = Message()
26         obj.email('xxx','xxx')
27         obj.msg('xxx','xxx')
28         obj.wechat('xxx','xxx')

对比:

　　函数:定义简单/调用简单

　　面向对象:定义复杂/调用复杂　　好处:可以将某些类似的函数写在一起

总结:

　　1.函数式编程可能会比面向对象好

　　2.Python中支持两种编程方式

　　3.面向对象方式的格式:

　　　　定义:

　　　　　　class 类名:

　　　　　　　　def 函数名(self):

　　　　　　　　　　pass

　　　　调用:

　　　　　　x = 类名()

　　　　　　x.函数名()

　　　　示例:

 1 class Account:
 2     def login(self):
 3         user = input("请输入用户名:")
 4         pwd = input("请输入密码:")
 5         if user == 'abc' and pwd = '123':
 6             print("登录成功")
 7         else:
 8             print("登录失败")
 9 obj = Account()
10 obj.login()

　　4.构造方法:

1 class Foo:
2     def __init__(self,name):#构造方法,目的进行数据初始化
3         self.name = name
4         self.age = 18
5 obj = Foo('abc') 
6 
7 #通过构造方法,可以将数据进行打包,以后使用时,去其中获取即可 
8

　　5.应用:

　　　　a.将数据封装到对象中,以供自己在方法中调用

 1 class FileHandler:
 2     def __init__(self,file_path):
 3         self.file_path = file_path
 4         self.f = open(self.file_path,"rb")
 5 
 6     def read_first(self):
 7         self.f.read()
 8         ...
 9         
10     def read_last(self):
11         self.read()
12         ...
13 
14 obj = FileHandler(path)
15 obj.read_first()
16 obj.read_last()

　　　　b.将数据封装到对象中,以供其他函数调用

 1 def new_func(arg):
 2     arg.k1
 3     arg.k2
 4     arg.k3
 5 
 6 class Foo:
 7     def __init__(self,k1,k2,k3):
 8         self.k1 = k1
 9         self.k2 = k2
10         self.k3 = k3
11 
12 obj = Foo(11,22,33)
13 new_func(obj)

2.面向对象代码如何编写

　　1.规则

1 class Foo:
2     def __init__(self,name):
3         self.name = name
4     
5     def detail(self,name):
6         print(self.name)
7 
8 obj = Foo()
9 obj.detail()

　　2.什么时候写,如何写

　　　　a.归类+提取公共值

　　　　　　归类:

 1 class File:
 2     def file_read(self,file_path):
 3         pass
 4     
 5     def file_update(self,file_path):
 6         pass
 7     
 8     def file_delete(self,file_path):
 9         pass
10 
11 class Excel:
12     def excel_read(self,file_path):
13         pass
14     
15     def excel_update(self,file_path):
16         pass
17 
18     def excel_delete(self,file_path):
19         pass
20     
21     def excel_add(self,file_path):
22         pass

　　　　提取公共值:

 1 class File:
 2     def __init__(self,file_path):
 3         self.file_path = file_path
 4     
 5     def file_read(self):
 6         pass
 7 
 8     def file_update(self):
 9         pass
10 
11     def file_delete(self):
12         pass
13 
14     def file_add(self):
15         pass
16 
17 class Excel:
18     def __init__(self,file_path):
19         self.file_path = file_path
20 
21     def excel_read(self):
22         pass
23     
24     def excel_update(self):
25         pass
26 
27     def excel_delete(self):
28         pass
29 
30     def excel_add(self):
31         pass

　　　　b.在指定类中编写和当前类相关的所有代码 + 提取公共值

 1 class Person:
 2     def __init__(self,na,gen,age,fig):
 3         self.name = na
 4         self.gender = gen
 5         self.age = age
 6         self.fight = fig
 7 
 8     def grassland(self):
 9         self.fight = self.fight -10
10        
11     def practice(self):
12         self.fight = self.fight + 90
13         
14     def incest(self):
15         self.fight = self.fight  - 100
16 
17 a = Person('abc','男',18,1000)
18 d = Person('def','女',20,1000)
19 q = Person('qwe','男',22,1000)
20 
21 d.grassland()

3.面向对象的三大特性:封装/继承/多态

　　封装:将相关功能封装到一个类中

1 class Message:
2     def email(self):pass
3     def msg(self):pass
4     def wechat(self):pass

　　将数据封装到一个对象中:

1 class Person:
2     def __init__(self,name,age,gender):
3         self.name = name
4         self.age = age
5         self.gender = gender
6 
7 obj = Person("abc",18,"男")

　　继承:

 1 def SuperBase:
 2     def f3(self):
 3         print('f3')
 4 
 5     class Base(SuperBase):
 6         def f2(self):
 7             print("f2")
 8     class Foo(Base):
 9         def f1(self):
10             print("f1")
11 
12 obj = Foo()
13 obj.f1()
14 obj.f2()
15 obj.f3()
16 
17 #原则:先在自己类中找,诶呦就去父类找

总结:

　　1.继承编写

　　2.支持多继承(先找左,再找右)

　　3.为什么要有多继承?提供代码重用性

　　多态:多种形态。在面向对象语言中，接口的多种不同的实现方式即为多态。