"""
细节:
1.如下定义的类的几种写法 并无任何区别 最终效果都一样 只是写法不同
2.所有的类都直接或间接继承自object 它是所有类的父类
定义类的格式
格式1
class 类名:
pass
格式2
class 类名():
pass
格式3
class 类名(父类名):
pass
"""
python
# 需求: 通过上述的三种写法 定义一个学生类
class Student:
pass
class Student():
pass
class Student(object):
pass"""
继承介绍:
概述:
Pyhton中的继承是指子类继承父类的属性和方法
现实中是子承父业
格式
class 类A(类B):
pass
叫法:
类A: 子类 派生类
类B: 父类 基类 超类
好处:
1.提高代码的复用性
2.让类与类之间产生关系 是多态的前提
弊端:
类与类之间的耦合性增强了 父类不好的成员 子类想没有都不行
开发原则:
高内聚 低耦合
内聚 = 类自己独立处理问题的能力
耦合 = 类之间的关系
细节: 所有的类都直接或间接继承自object 它是所有类的父类(也叫 顶类 基类)
"""
python
# 案例 定义父类Father 默认性别 男 爱好:散步
# 定义子类Son 尝试调用父类的成员
class Father:
def __init__(self):
self.gender = '男'
def walk(self):
print('饭后走一走 能活九十九')
class Son(Father):
pass
if __name__ == '__main__':
s1 = Son()
print(s1.gender)
s1.walk()"""
单继承解释:
指的是1个子类 只能继承自1个父类
该子类会从父类中继承过来 属性 或者方法
故事1:
一个摊煎饼的老师傅，在煎饼果子界摸爬滚打多年，研发了一套精湛的摊煎饼技术， 师父要把这套技术传授给他的唯一的最得意的徒弟。
分析:
师傅类: Master, 父类
属性: kongfu = '古法摊煎饼配方'
行为: make_cake(), 具体的摊煎饼动作.
徒弟类: Prentice, 子类
继承父类即可.
"""
python
class Master():
def __init__(self):
self.congfu = '[古法摊煎饼配方]'
def make_cake(self):
print(f'使用{self.congfu} 制做煎饼果子')
# 徒弟类
class Prentice(Master):
pass
if __name__ == '__main__':
p = Prentice()
print(p.congfu)
p.make_cake()"""
故事2:
小明是个爱学习的孩子, 想学习更多的摊煎饼果子配方, 于是来到了新东方学校, 报班学习摊煎饼果子技术.
细节:
-
Python中是支持多继承 和 单继承的.
-
子类可以从多个父类中继承属性 和 行为.
-
如果多个父类有重名的属性 或者 行为时, 默认会按照: 从左往右的顺序继承, 即: 只会继承左边父类的成员.
-
Python中内置有mro(Method Resolution Order, 方法解析顺序)机制, 可以查看继承的解析顺序.
-
Python中多继承的写法为:
class 子类名(父类名1, 父类名2...):
pass
"""
python
class Master():
def __init__(self):
self.congfu = '[古法摊煎饼配方]'
def make_cake(self):
print('我是老师傅')
print(f'使用{self.congfu} 制做煎饼果子')
class School():
def __init__(self):
self.congfu = '[新东方顶级煎饼果子配方]'
def make_cake(self):
print('我是新东方')
print(f'使用{self.congfu} 制做煎饼果子')
# 徒弟类
class Prentice(School, Master):
pass
if __name__ == '__main__':
p = Prentice()
print(p.congfu)
p.make_cake()"""
故事3:
小明掌握了老师傅和新东方的技术后, 自己潜心钻研出一套自己的 独门配方的全新摊煎饼果子技术.
方法重写解释:
概述:
方法重写也叫方法覆写, 指的是: 子类出现和父类重名的(一模一样)的方法时, 称为: 方法重写.
应用场景:
当子类需要沿袭父类的功能主体, 而功能主体又有自己独有需求(功能)的时候, 就可以考虑从父类继承过来函数,
并重写, 做优化升级.
"""
python
class Master():
def __init__(self):
self.congfu = '[古法摊煎饼配方]'
def make_cake(self):
print('我是老师傅')
print(f'使用{self.congfu} 制做煎饼果子')
class School():
def __init__(self):
self.congfu = '[新东方顶级煎饼果子配方]'
def make_cake(self):
print('我是新东方')
print(f'使用{self.congfu} 制做煎饼果子')
# 徒弟类
class Prentice(School, Master):
def __init__(self):
self.congfu = '[独创的煎饼果子秘料]'
def make_cake(self):
print('我是徒弟 -> Prentice类')
print(f'使用 {self.congfu} 制作煎饼果子.')
if __name__ == '__main__':
p = Prentice()
print(p.congfu)
p.make_cake()"""
故事4:
很多顾客希望既能迟到徒弟独创配方的煎饼果子, 还希望吃到新东方配方以及老师傅配方的煎饼果子.
目的: 演示子类中如何访问父类的成员.
方式1: 父类名.方法名(self)
特点: 可以精准访问, 如果有多个父类的情况下, 想用哪个父类的, 就用哪个父类的.
方式2: super().方法名()
特点: 只能初始化最左边那个父类的成员.
"""
python
class Master():
def __init__(self):
self.congfu = '[古法摊煎饼配方]'
def make_cake(self):
print('我是老师傅')
print(f'使用{self.congfu} 制做煎饼果子')
class School():
def __init__(self):
self.congfu = '[新东方顶级煎饼果子配方]'
def make_cake(self):
print('我是新东方')
print(f'使用{self.congfu} 制做煎饼果子')
# 徒弟类
class Prentice(School, Master):
def __init__(self):
self.congfu = '[独创的煎饼果子秘料]'
def make_cake(self):
print('我是徒弟 -> Prentice类')
print(f'使用 {self.congfu} 制作煎饼果子.')
# 需求: 子类中如何访问父类的成员?
# 方式1: 父类名.方法名(self) -> 精准访问.
def make_master_cake(self):
Master.__init__(self)
Master.make_cake(self)
def make_school_cake(self):
School.__init__(self)
School.make_cake(self)
# 方式2: super().方法名() -> 只能初始化最左边那个父类的成员.
def make_old_cake(self):
super().__init__()
super().make_cake()
if __name__ == '__main__':
p = Prentice()
print(p.congfu)
p.make_cake()
print('-' * 22)
# 访问父类的成员.
p.make_master_cake()
print('-' * 22)
p.make_school_cake()
p.make_old_cake()"""
多层继承:
概述:
类之间的继承是有传递性的, 类A继承类B, 类B继承类C, 这就是: 多层继承.
易混淆:
多层继承: 类A -> 继承类B, 类B -> 继承类C
多继承: 类A -> 类B, 类C...
故事6:
N年后, 小明把他的独创配方 和 新东方配方, 传给了他的徒弟.
"""
python
class Master:
def __init__(self):
self.congfu = '[古法摊煎饼果子配方]'
def make_cake(self):
print(f'运用 {self.congfu} 制作煎饼果子')
class School:
def __init__(self):
self.congfu = '[新东方摊煎饼果子配方]'
def make_cake(self):
print(f'运用 {self.congfu} 制作煎饼果子')
class Prentice(School, Master):
def __init__(self):
self.congfu = '[独创摊煎饼果子配方]'
def make_cake(self):
print(f'运用 {self.congfu} 制作煎饼果子')
# 演示: 子类访问父类的成员.
def make_old_cake(self):
super().__init__()
super().make_cake()
class TuSun(Prentice): # MRO: TuSun -> Prentice -> School -> Master -> object -> 报错
pass
if __name__ == '__main__':
# 创建徒孙类对象.
ts = TuSun()
# 调用函数.
print(ts.congfu) # 独创
ts.make_cake() # 独创
ts.make_old_cake() # 运用 [新东方摊煎饼果子配方] 制作煎饼果子"""
封装介绍:
概述:
Python中的封装 = 隐藏对象的属性和实现细节, 仅对外提供公共的访问方式.
现实世界的封装 = 插板, 电脑, 手机...
名词解释:
怎么隐藏?
答: 通过 __ 实现, 例如: __属性名, __方法名()
私有后, 如何访问私有内容呢?
答:
类内: 直接使用, 无所谓.
类外: 不能直接调用, 必须通过 类提供的 公共的访问方式来调用.
注意: 这里的公共的访问方式 = get_xxx() 和 set_xxx()函数.
get_xxx() 和 set_xxx()函数必须成对出现吗?
答: 不一定, 看需求. 只获取就用 getXxx(), 只设置就用setXxx(), 如果需求不明确, 建议都写.
故事7:
小明把技术传给徒弟的同时, 不想把自己的私房钱 5000000 继承给徒弟, 请用所学, 模拟这个知识点.
"""
python
class Prentice:
def __init__(self):
self.congfu = '[独创摊煎饼果子配方]'
self.__money = 5000000
def make_cake(self):
print(f'运用{self.congfu}制作煎饼果子')
def get_money(self):
return self.__money
def set_money(self, money):
self.__money = money
class TuSun(Prentice):
pass
if __name__ == '__main__':
ts = TuSun()
print(ts.congfu)
ts.make_cake()
print('-' * 22)
# print(ts.money) # 报错
# print(ts.__money) # 报错
# 设置值
# ts.set_money(-100)
ts.set_money(100) # 合法值
# 获取值
print(ts.get_money())昨日知识考察题:
python
# （1）举例说明生活中的案例：分别以面向过程、面向对象方式思考
# 举例:
# 1.比如租房子
# 面向过程: 需要自己去小区内各个楼层去寻找招租信息,需要想业主调查有没有出租房屋的需求,统计房源信息,然后与房东协商租金等费用问题
# 面向对象: 找一个中介,中介会把这些事情处理好,我们只需要和中介对接就行
# （2）说一说类和对象是什么？
# 类是一类事物的集合,由属性和方法组成,属性代表事物的特征.自带的特点, 行为表示此类事物可以执行的操作
# 对象就是类下的具体的一个事物,可以使用类的属性和行为
# （3）尝试使用思维导图总结今天的知识
# 见文件外
# 实操题
# （1）定义一个手机类，能开机、能关机、可以拍照。
# class Phone():
# def open(self):
# print('我能开机')
#
# def clsoe(self):
# print('我能关机')
#
# def photo(self):
# print('我能拍照')
#
#
# if __name__ == '__main__':
# p = Phone()
# p.open()
# p.clsoe()
# p.photo()
# （2）定义一个电脑类，并给电脑添加品牌、价格等属性，同时电脑能用于编程、看视频。
# class Computer():
# def __init__(self, brand, price):
# self.brand = brand
# self.price = price
#
# def program(self):
# print('我能编程')
#
# def movie(self):
# print('我能看视频')
#
# def __str__(self):
# return f'一台: {self.brand} 电脑的价格为: {self.price}'
#
#
# if __name__ == '__main__':
# c1 = Computer('Mac', 99999)
# print(c1)
# c1.movie()
# c1.program()
# （3）尝试定义一个算法工程师类，同时使用`__init__()`初始化岗位名称、薪资金额等属性，工作内容是每天码代码，同时使用`__str__()`展示对象所拥有的所有信息。
# class Algorithm():
# def __init__(self, post, salary):
# self.post = post
# self.salary = salary
#
# def code(self):
# print('我每天都在努力的写代码')
#
# def __str__(self):
# return f'我的岗位是: {self.post} 薪资为: {self.salary}'
#
# if __name__ == '__main__':
# a1 = Algorithm('算法岗', 999999)
# print(a1)
# a1.code()
# （4）独立编写一遍课堂案例：减肥案例
# class Sport():
# def __init__(self,weight):
# self.current_weight = weight
#
# def eat(self):
# self.current_weight += 2
# print(f'大餐后现在体重是: {self.current_weight}')
#
# def run(self):
# self.current_weight -= 0.5
# print(f'运动后现在体重是: {self.current_weight}')
#
# def __str__(self):
# return f'当前体重是: {self.current_weight}'
#
#
# if __name__ == '__main__':
# s1 = Sport(100)
# s1.run()
# s1.eat()
# s1.run()
# s1.eat()
# print(s1)（5）独立编写一遍课堂案例：烤地瓜案例
"""
需求:
已知地瓜类(SweetPotato), 属性: 烘烤时间, 生熟状态, 调料, 行为: 烘烤动作, 不同烘烤时间, 地瓜的状态不同, 请用所学, 模拟该知识点.
地瓜烘烤时间及生熟状态:
烘烤时间(包左不包右, 前闭后开) 生熟状态
0 ~ 3 生的
3 ~ 7 半生不熟
7 ~ 12 熟了
超过12分钟 已烤焦, 糊了
"""
python
class SweetPotato():
def __init__(self):
self.cook_time = 0
self.state = '生的'
self.condiments = []
def cook(self, time):
if time < 0:
print('请输入正确烘烤时间')
else:
self.cook_time += time
if 0 <= self.cook_time < 3:
self.state = '生的'
elif 3 <= self.cook_time < 7:
self.state = '半生不熟'
elif 7 <= self.cook_time <= 12:
self.state = '熟了'
else:
self.state = '已烤焦,糊了'
def cond(self, *args):
self.condiments.extend(args)
# self.condiments.append(args)
def __str__(self):
return f'烘烤时间为: {self.cook_time} 烧烤状态为: {self.state} 添加的调料为; {self.condiments}'
if __name__ == '__main__':
s1 = SweetPotato()
print(s1)
s1.cook(10)
s1.cond('番茄酱', '芝士', '奶油')
print(s1)坚持分享 共同进步 手敲 如有错误 欢迎指出