概述：
面向过程：按照业务逻辑从上到下写代码
函数式：将某功能封装到函数中，以后不需要重复编写，直接调用函数即可。
面向对象：对函数进行分类和封装
一：什么是面向对象？
面向对象编程是一种编程方式，此编程方式需要使用‘类’和‘对象’来实现。所以，面向对象编程就是对“类”和“对象”的使用。
类：类就是一个模板，模板里包含多个函数，函数里实现一些功能
对象：对象则是根据模板创建的实例，通过实例对象可以执行类中的函数
#创建类 class Foo: #class 关键字，表示类。 Foo 类名称 #创建类中的函数 def Bar(self) #self 特殊参数，必须存在的 #根据类Foo创建对象obj obj = Foo() #创建对象，类名称后加括号即可
二：函数式编程和面向对象的对比
#a, round 1 ；请开发一个消息提醒的功能（邮件、短信、微信） #函数版 def email(em,text): """ 发送邮件 :return """ print(em,text) def msg(tel,text): """ 发送短信 :return """ print(tel,text) def wechat(num,text): """ 发送微信 :return """ print(num,text) #编写功能：假设用户购买课程，然后给Alex发送提醒 if 1==1： msg = ('18866667777','张金购买一个学生课’) email = （‘[email protected]’,'张金购买了学生课'） wechat = ('xxxx','张金购买了一个学生课') #面向对象版： class Message： def email(self,em,text): """ 发送邮件 ：return """ print(em,text) def msg (self,tel,text): """ 发送短信 :return """ print(tel,text) def wechat(self,num,text): "" 发送微信 ：return """ print(num,text) #编写功能：假设用户购买课程，然后给阿里小二发送提醒； if 1==1： obj = Message() obj.email('[email protected]','张金购买了一个学位课') obj.msg('18866667777','张金购买了一个学位课‘’) obj.wechat('xxxx','张金购买了一个学位课') 对比: #函数:定义简单/调用简单 #面向对象:定义复杂/调用复杂 好处:归类,将某些类似的函数写在一起 总结: #1. 函数式编程可能会比面向对象好. #2. Python中支持两种编程方式. #3. 面向对象方式格式: #定义： class类名： --定义了一个类 def 函数名（self） --在类中编写了一个"方法" pass #调用： x1 = 类名（） --创建了一个对象、实例化对象 x1.函数名（） --通过对象调用其中一个方法。
b. round 2 打印 # """ # 完成以下功能: #老狗/20岁/男/上山去砍柴 # 老狗/20岁/男/开车去东北 # 老狗/20岁/男/喜欢大宝剑 # """ # # # ##################### 函数版本 ######################### # """ # def kc(name,age,gender): # data = "%s,性别%s,今年%s岁,喜欢上山砍柴" %(name,gender,age) # print(data) # # def db(name,age,gender): # data = "%s,性别%s,今年%s岁,喜欢开车去东北" %(name,gender,age) # print(data) # # def bj(name,age,gender): # data = "%s,性别%s,今年%s岁,喜欢大宝剑" %(name,gender,age) # print(data) # # # kc('老狗',20,'男') # kc('老狗',20,'男') # db('老狗',20,'男') # bj('老狗',20,'男') # """ # # ##################### 面向对象 ######################### # class LaoGou: # # def __init__(self,name,age,gender): # 特殊的方法,如果 类名() ,则该方法会被自动执行 (构造方法) # self.n1 = name # self.n2 = age # self.n3 = gender # # def kc(self): # data = "%s,性别%s,今年%s岁,喜欢上山砍柴" %(self.n1,self.n3,self.n2) # print(data) # # def db(self): # data = "%s,性别%s,今年%s岁,喜欢开车去东北" %(self.n1,self.n3,self.n2) # print(data) # # def bj(self): # data = "%s,性别%s,今年%s岁,喜欢大宝剑" %(self.n1,self.n3,self.n2) # print(data) # # obj = LaoGou('老狗',20,'男') # obj.kc() # obj.db() # obj.bj() # # # 总结: # 1. 构造方法 # 示例一: # class Foo: # # def __init__(self,name): 构造方法,目的进行数据初始化. # self.name = name # self.age = 18 # # obj = Foo('侯明魏') # # 通过构造方法,可以将数据进行打包,以后使用时,去其中获取即可. # # 示例二: # class Bar: # pass # obj = Bar() # # 2. 应用 # a. 将数据封装到对象中,以供自己在方法中调用 # class FileHandler: # def __init__(self,file_path): # self.file_path = file_path # self.f = open(self.file_path, 'rb') # # def read_first(self): # # self.f.read() # # ... # pass # # def read_last(self): # # self.f.read() # # ... # pass # # def read_second(self): # # self.f... # # ... # pass # # obj = FileHandler('C:/xx/xx.log') # obj.read_first() # obj.read_last() # obj.read_second() # obj.f.close() # # b. 将数据封装到对象中,以供其他函数调用 # def new_func(arg): # arg.k1 # arg.k2 # arg.k6 # # class Foo: # def __init__(self,k1,k2,k6): # self.k1 = k1 # self.k2 = k2 # self.k6 = k6 # # obj = Foo(111,22,333) # new_func(obj)
总结：场景的不同适合其的编程方式也不同
函数式的应用场景---》各个函数之间是独立且无公用的数据
三：面向对象如何编写
a.规则
class Foo: def __init__(self,name): self.name = name def detail(self,msg): print(self.name,msg) obj = Foo() obj.detail()
b.什么时候写？如何写？
#方式 一：归类+提取公共值 归类： class File: def file_read(self,file_path): pass def file_update(self,file_path): pass def file_delete(self,file_path): pass def file_add(self,file_path): pass class Excel: def excel_read(self,file_path): pass def excel_update(self,file_path): pass def excel_delete(self,file_path): pass
# 提取公共值: class File: def __init__(self,file_path): self.file_path = file_path def file_read(self): pass def file_update(self): pass def file_delete(self): pass def file_add(self): pass class Excel: def __init__(self,file_path): self.file_path = file_path def excel_read(self): pass def excel_update(self): pass def excel_delete(self): pass def excel_add(self): pass
# 方式二:在指定类中编写和当前类相关的所有代码 + 提取公共值 class Message: def email(self): pass class Person: def __init__(self,na, gen, age, fig) self.name = na self.gender = gen self.age = age self.fight =fig def grassland(self): self.fight = self.fight - 10 def practice(self): self.fight = self.fight + 90 def incest(self): self.fight = self.fight - 666 cang = Person('苍井井', '女', 18, 1000) # 创建苍井井角色 dong = Person('东尼木木', '男', 20, 1800) # 创建东尼木木角色 bo = Person('波多多', '女', 19, 2500) # 创建波多多角色 dong.grassland()
四：面向对象的三大特性：封装/继承/多态
继承：面向对象中的继承和现实生活中的继承相同 即：子可以继承父的内容
class SuperBase: def f3(self): print('f3') class Base(SuperBase): # 父类,基类 def f2(self): print('f2') class Foo(Base): # 子类,派生类 def f1(self): print('f1') obj = Foo() obj.f1() obj.f2() obj.f3() # 原则:现在自己类中找,么有就去父类
封装：
将相关功能封装到一个类中：
扫描二维码关注公众号，回复：
2903823 查看本文章
class Message: def emile(self):pass def msg(self):pass def wechat(self):pass
将数据封装到一个类中：
class Person: def__init__(self,name,age,gender): self.name = name self.age = age self.gender = gender obj = Person('青青'，19，‘女’)
多态：多种形态多种状态，
# 由于python原生支持多态,所以没有特殊性. """ class Foo1: def f1(self): pass class Foo2: def f1(self): pass class Foo3: def f1(self): pass def func(arg): arg.f1() obj = Foo1() # obj= Foo2() obj = Foo3() func(obj) """ java class Son(list): pass class Son1(list): pass # 以后传参时,arg可以是:list类的对象/list任何子类的对象 public void func(list arg){ print(arg) } # obj = list() # obj = Son() obj = Son1() func(obj)