今日主要内容
一. 面向对象思想
1. 面向过程. 重点在'过程'. 按照事物迭代发展流程.
优点: 简单,流水线式的操作
缺点: 可扩展性差.可维护性差.
2. 面向对象. 对象是属性和动作的集合体.对象是一个抽象概念
重点在'对象':属性和动作.
(先创建一个大象,然后让大象进冰箱就可以了,具体大象如何进的冰箱由大象来完成.)
类似上帝式思维.
优点: 可扩展性强(多态)
缺点: 编写相对比较复杂. 上手比较难.
面向对象和面向过程各有千秋
二. 面向对象如何编写
在代码中定义一个类,相当于画图纸
class 类名: #驼峰,类名首字母大写
pass
创建对象: 类名()
1. 构造方法:
def __init__(self, 属性):
self.属性 = 属性
2. 普通方法
def 方法名(self, 参数列表):
pass
self: 表示当前类的对象. 当前正在执行这个动作的对象.
对象.方法()
类名.方法(对象,参数)
e.g.
#定义一辆车
class Car:
#出厂设置 (__init__) 构造方法,所有方法的第一个参数不用给
def __init__(self, colour, pai, pailiang, own) #self 表示当前类的对象
print('我在造车')
print(self)
#绑定属性.
# self.colour = '红色'
# self.pai = '京A66666'
self.colour = colour
self.pai = pai
self.pailiang = pailiang
self.own = own
c = Car('黑色', '黑B88888', '2.0t', 'alex')
c1 = Car() 系统会自动调用__init__方法.并将Car()传给self
c2 = Car() 自动调用__init__函数(方法)
#创造一辆车,创建对象
c= Car() #类名()
print(type(c)) #<class '__main__.Car'>
c1 = Car() #创建新对象,又叫做实例化 #类是一个概念. 对象:具体的实例
c1.colour = '白色'
c1.pai = '京B22222'
c1.pailiang = '1.6t'
c1.own = '小猪佩奇'
print(id(c), id(c1))
print(c1.pai)
print(c.own)
#函数(方法)
class Car():
def __init__(self, colour, pai, pailiang, own):
self.colour = colour
self.pai = pai
self.pailiang = pailiang
self.own = own
#车能跑,跑是一个动作,要写函数(方法)
def run(self): #self: 当前类的对象
print('%s颜色的车在疯狂的跑' % self.colour)
print(self)
c1 = Car('红','京A11111', '1.5L', '小猪佩奇')
c1.run() #对象,方法() 用谁访问,self就是谁
--------------------------------------
class House:
pass
h = House()
h.colour = '红色'
h.size = '500平米'
h.floor = '两层'
h.owner = 'Sara'
print(type(h))
h1 = House()
h1.colour = '白色'
h1.size = '250平米'
h1.floor = '1层'
h1.owner = 'John'
print(id(h), id(h1))
print(h1.colour)
print(h.colour)
--------------------------------------------
class Meal:
def __init__(self):
self.food = '米饭'
self.dish = '鱼香肉丝'
self.drink = '可乐'
m = Meal()
print(m.food)
m.dish = '宫保鸡丁'
print(m.dish)
m1 = Meal()
print(m1.dish)
---------------------------------------------
class House:
def __init__(self, colour, size, floor, owner):
self.colour = colour
self.size = size
self.floor = floor
self.owner = owner
H1 = House('红色', '1000平米', '4层', '王尔德')
print(H1)
print(H1.colour)
print(H1.size)
H2 = House('米黄', '500平米', '2层', '布莱曼')
print(H2.colour)
print(H2.size)
print(H2)
class HaoHan: # 驼峰. 类名首字母大写. def __init__(self, name, waihao, jineng): self.name = name self.waihao = waihao self.jineng = jineng def ganLaoHu(self): print("%s, %s 在干老虎" % (self.waihao, self.name)) def shaSaoZi(self): print("%s, %s 在杀嫂子" % (self.waihao, self.name)) def tiTianXingDao(self): print("%s, %s 在替天行道" % (self.waihao, self.name)) wusong = HaoHan("武松", "行者", "喝酒") wusong.ganLaoHu() wusong.shaSaoZi() wusong.tiTianXingDao()
class HeShang: def __init__(self, fahao, mingzi, age, miao): self.fahao = fahao self.mingzi = mingzi self.age = age self.miao = miao def nianjing(self): print("%s在念经" % self.fahao) def quxifu(self, xifu): print("%s取了个媳妇:%s" % (self.fahao, xifu)) hs = HeShang("秃驴", "alex", 38, "路飞庙") hs.nianjing() hs.quxifu("wusir")
class Account: def __init__(self, username, pwd): self.username = username self.pwd = pwd def login(self): if self.username == 'alex' and self.pwd == '123': return True else: return False acc = Account('alex', '123') print(acc.login())
三. 面向对象和面向过程的对比(代码,思想)
结论: 根据不同的业务逻辑, 来决定用哪种思想.
面向对象PK面向过程
装大象, 脚本 print("打开冰箱门") print("装大象") print("关上冰箱门") 函数式编程 def kaimen(): print("打开冰箱门") def zhuangdaxiang(): print("装大象") def guanmen(): print("关门") kaimen() zhuangdaxiang() guanmen() 面向对象 class Elephant: def open(self): print("大象会开门") def zhuang(self): print("把自己装进去") def close(self): print("把门关上") # 创建大象 e = Elephant() e.open() e.zhuang() e.close() # 第一回合. 面向过程赢
# 第二回合. 小猪佩奇(name, age, 技能)大战奥特曼, 蜘蛛侠, 蝙蝠侠 # 函数式 def da_ao_te_man(name, age, jineng): print("%s, %s岁了, 用技能%s 打奥特曼" % (name, age, jineng)) def da_zhi_zhu_xia(name, age, jineng): print("%s, %s岁了, 用技能%s 打蜘蛛侠" % (name, age, jineng)) def da_bian_fu_xia(name, age, jineng): print("%s, %s岁了, 用技能%s 打蝙蝠侠" % (name, age, jineng)) da_ao_te_man("小猪佩奇", 40, "嘴巴嘟嘟") da_zhi_zhu_xia("小猪佩奇", 40, "嘴巴嘟嘟") da_bian_fu_xia("小猪佩奇", 40, "嘴巴嘟嘟") # 面向对象 class Pig: def __init__(self, name, age, jineng): self.name = name self.age = age self.jineng = jineng def da_ao_te_man(self): print("%s, %s岁了, 用技能%s 打奥特曼" % (self.name, self.age, self.jineng)) def da_zhi_zhu_xia(self): print("%s, %s岁了, 用技能%s 打蜘蛛侠" % (self.name, self.age, self.jineng)) def da_bian_fu_xia(self): print("%s, %s岁了, 用技能%s 打蝙蝠侠" % (self.name, self.age, self.jineng)) peiqi = Pig("小猪佩奇", 40, "嘴巴嘟嘟") # 把这三个属性封装到了一个对象里. peiqi.da_ao_te_man() peiqi.da_zhi_zhu_xia() peiqi.da_bian_fu_xia() # 平手. 当属性和方法非常多的时候, 才能感觉到面向对象的好. # 你要知道. 面向对象和面向过程都是思想. 用哪一个取决于业务逻辑.
四. 面向对象的三个特征(记下来)
1. 封装: 把具有相同属性和功能的内容封装在一个对象中
2. 继承: 子类可以自动拥有父类中 除了私有属性外的其他所有内容. 好处:两个类具有相同的功能或特征时,可以避免写很多重复的功能和代码.
3. 多态: 同一类的对象. 可以拥有多种形态,本质是子类通过重写父类的方法,使得对同一类对象调用同一个方法,产生不同结果. python原生自带多态性. e.g.父类中定义了eat方法,子类中又重新定义了eat方法.
继承
class Fa: def play(self): print('Fa中的play') def func(self): print('我是一号') class Fa2: def play(self): print('Fa2中的play') def tool(self): print('我是2号') class Son(Fa, Fa2): #可以从多个类中继承,调用顺序先找自己,再从左到右按顺序继承 pass s = Son() s.func() s.tool() s.play()
class Pet: def __init__(self, name): self.name = name def eat(self): print('吃') def sleep(self): print('睡') class Cat(Pet): def catch_mouse(self): print('%s喜欢抓老鼠' % self.name) class Dog(Pet): def chaijia(self): print('%s喜欢拆家' % self.name) c = Cat('Tom') c.catch_mouse() c.eat() c.sleep() d = Dog('John') d.chaijia() d.eat() d.sleep()
多态
# # 变量 = 类名() # c = Cat() # 猫类型的 # python本来就是多态. 里面没有所谓的类型. class Animal: def chi(self): print("所有的动物都会吃") class Haski(Animal): def chi(self): print("疯了一样的吃") class Monkey(Animal): def chi(self): print("龇牙咧嘴的吃") class Tiger(Animal): def chi(self): print("跟猫一样的吃") class Elephant(Animal): def chi(self): print("大象用鼻子卷着吃") class YingWu(Animal): def chi(self): print("xxxxx") class SiYangYuan: def wei(self, ani): # 多态性. 超强的可扩展性. 不论传递进来的是什么. 都统一当成动物来对待. ani.chi() syy = SiYangYuan() # 造动物 hou = Monkey() ha = Haski() lao = Tiger() yw = YingWu() syy.wei(ha) syy.wei(hou) syy.wei(lao) syy.wei(yw)
class Car: def run(self, speed): print("车能跑%s迈" % speed) c = Car() # 实例化一个对象 Car.run(c, 50) c.run(50)