1.今日内容大纲
一. 之前的知识点的回顾 1. 函数. def 函数名(形参): 函数体 函数名(实参) ()表示调用 实参必须和形参对的上. 2. 变量: 程序运行过程中产生的值. 供后面的程序使用. a = 10086 二. 今日主要内容 一. 面向对象思想 1. 面向过程. 重点在"过程". 按照实物的发展流程. 先干嘛,后干嘛, 最后干嘛.... 优点: 简单. 流水线式的工作 缺点: 可扩展性差. 2. 面向对象. 什么是对象? 对象是属性和动作的集合体. 对象是一个抽象的概念. 重点在"对象" : 属性和动作.类似上帝式的思维 优点: 可扩展性强(多态) 缺点: 编写相对比较复杂. 上手比较难. 面向对象和面向过程各有千秋. 各有各的好. 二. 面向对象如何编写 在代码中定义一个类,就相当于画图纸 class 类名: pass 创建对象: 类名() 1. 构造方法: def __init__(self, 属性): self.属性 = 属性 2. 普通方法 def 方法名(self, 参数列表): pass self: 表示当前类的对象. 当前正在执行这个动作的对象. 对象.方法() 类名.方法(对象, 参数) 三. 面向对象和面向过程的对比(代码, 思想). 结论: 根据不同的业务逻辑, 来决定用那种思想. 四. 面向对象的三个特征(记下来). 1. 封装: 把具有相同属性和功能的内容封装在一个对象中 2. 继承: 子类可以自动拥有父类中除了私有属性外的其他所有内容 3. 多态: 同一个对象. 可以拥有多种形态. python原生自带多态性 明天预习: 成员
2.面向对象引入
# 定义一辆车
class Car:
# 出厂设置.(__init__) 构造方法
def __init__(self, color, pai, pailiang, own): # self 表示当前类的对象
# print("我在造车")
# print(self)
# 绑定属性.
self.color = color
self.pai = pai
self.pailiang = pailiang
self.own = own
# 车能跑. 跑是一个动作. 要写函数(方法)
def run(self): # self: 当前类的对象
print("%s颜色的车在疯狂的跑" % self.color) # self就是你当前正在执行这个动作的对象.
print(self)
def tiaogao(self):
print("有一台%s色的车在疯狂跳高" % self.color)
c1 = Car("红", "京A66666", "2.0T", "alex") # 自动的调用__init__函数(方法)
c1.run() # 对象.方法()
c1.tiaogao()
print(c1)
# print(c1.__dict__)
# c1.color = "绿色"
# 字典.
# print(c1.color)
c2 = Car("黑色", "京B22222", "1.5L", "小猪佩奇") # 没有参数
c2.run()
print(c2)
# print(c2.color) # ????
# # 创造一辆车
# c = Car() # 类名()
#
# c.color = "黑色" # 对象.属性
# c.pai = "京A66666"
# c.pailiang = "2.0t"
# c.own = "alex"
# print(c.pai)
#
# c1 = Car() # 创建新对象. 又叫做实例化 # 类是一个概念. 对象:具体的实例
# c1.color = "白色"
# c1.pai = "京B22222"
# c1.pailiang = "1.6T"
# c1.own = "小猪佩奇"
# print(id(c), id(c1))
# print(c1.pai)
# print(c.own)
# print(type(c))
3.面向对象练习
'''
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, password):
# self.username = username
# self.password = password
#
# def login(self):
# if self.username == "alex" and self.password == '123':
# return True
# else:
# return False
#
# acc = Account("alex", "1234")
# print(acc.login())
4.面向对象PK面向过程
# 装大象, 脚本
# print("打开冰箱门")
# print("装大象")
# print("关上冰箱门")
# 函数式编程
# def kaimen():
# print("打开冰箱门")
# def zhuangdaxiang():
# print("装大象")
# def guanmen():
# print("关门")
# kaimen()
# zhuangdaxiang()
# guanmen()
# 面向对象
# class Elphant:
#
# def open(self):
# print("大象会开门")
# def zhuang(self):
# print("把自己装进去")
# def close(self):
# print("把门关上")
#
# # 创建大象
# e = Elphant()
# 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()
# 平手. 当属性和方法非常多的时候, 才能感觉到面向对象的好.
# 你要知道. 面向对象和面向过程都是思想. 用哪一个取决于业务逻辑.
5.继承关系
# class Foo:
# def play(self):
# print("Foo中的play")
# def func(self):
# print("我是爹")
#
# class Foo2:
# def money(self):
# print("干爹给钱")
#
# def play(self):
# print("Foo2中的play")
#
# class Bar(Foo, Foo2): # 继承 子类, MRO算法. C3算法
# pass
#
# obj = Bar()
# # obj.money()
# # obj.func()
# obj.play()
# class Pet:
# def __init__(self, name):
# self.name = name
#
# def chi(self):
# print("吃,.....")
# def sleep(self):
# print("睡")
#
# class Cat(Pet):
# def catchMouse(self):
# print("%s喜欢抓老鼠" % self.name)
#
# class Dog(Pet):
# def chaijia(self):
# print("狗会拆家")
#
# class Snake(Pet): # 蛇是一种宠物, x是一种y的时候. x继承y
# pass
# c = Cat("佩奇")
# c.chi()
# c.sleep()
# c.catchMouse()
# class Car:
# def run(self):
# print("车会跑")
#
#
# class BMWCar(Car):
# pass
# class Animal:
# def dong(self):
# pass
#
# class Cat(Animal):
# def catchMaouse(self):
# pass
#
#
# # 变量 = 类名()
# c = Cat() # 猫类型的
# c.catchMaouse()
# c.dong()
#
# c = "alex"
# 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 Elphant(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)