python进阶 面向对象初阶
1.面向对象的初始
-
概述:
- 属性: 名词, 用来描述事物的外在特征的, 例如: 姓名, 性别, 年龄, 身高, 体重…
- 行为: 动词, 表示事物能够做什么, 例如: 学习, 吃, 睡…
- 类: 抽象的概念, 看不见, 摸不着. 类 = 属性 + 行为
- 对象: 类的具体体现, 实现.
-
定义类的格式:
class 类名:
#属性 与以前定义变量一样
#行为 与以前定义函数一样,第一个形参要写self
-
类中成员的使用
-
- 创建该类的对象
对象名 = 类名()
- 创建该类的对象
-
- 通过 对象名. 方式来调用.
对象名.属性
对象名.行为()
- 通过 对象名. 方式来调用.
-
案例
# 需求: 定义1个汽车类, 然后具有跑的功能, 并调用.
# 1. 定义汽车类.
class Car():
# 属性, 先不写.
# 行为, 和以前定义的函数一样, 只不过第一个形参要写self.
def run(self):
print('汽车会跑!...')
# 在main方法中测试调用.
if __name__ == '__main__':
# 2. 创建汽车类对象.
c1 = Car() # 大白话: 根据图纸制造了1辆汽车, 汽车名叫: c1
c2 = Car() # 大白话: 根据图纸制造了1辆汽车, 汽车名叫: c2
# 3. 调用 汽车类的 功能.md
# 3.1 调用 属性
# 3.2 调用 行为.
c1.run()
c2.run()
1.2 self 关键字
-
概述:是python内置的一个属性,代表:本类当前对象的引用.
-
大白话解释:谁调用函数,函数内的self就代表谁(对象).
-
作用:
用于区分不同的对象,看看是谁调用的
案例
# 1. 定义汽车类.
class Car:
# 汽车类内部, 定义: 行为(函数), 表示具有: 跑的功能.
def run(self):
print('汽车具有 跑 的功能!')
# 通过self关键字, 可以实现: 在函数内区分 到底是哪个对象 调用的该函数.
print(f'当前对象为: {self}')
# 在main函数中, 测试调用.
if __name__ == '__main__':
# 2. 创建汽车类的对象.
c1 = Car()
c2 = Car()
# 3. 调用Car类的 run()函数, 简写注释为: 调用 Car#run()
c1.run()
print('-' * 21)
c2.run()
print('-' * 21)
# 4. 打印地址值.
print(f'c1: {c1}')
print(f'c2: {c2}')
1.3在类的内部用类中的函数
-
调用的格式:
类外:对象名. 方式调用
类内:self. 方式调用 -
注意:
- 函数内有self ,表示:谁调用这个函数,self就是哪个函数
- self = 本类的对象
- 函数只有被调用才会执行
<案例:继续来开汽车了.
class Car:
# 定义函数, 表示: 跑的功能.
def run(self):
print('汽车会跑!...')
# 2. 测试在类中访问本类的函数.
def work(self):
# 2.1 打印1句话, 提示用.
print('我是 work() 函数!')
# 2.2 调用 run()函数.
self.run()
# 在main函数中测试.
if __name__ == '__main__':
# 3. 测试在 类外 访问 类的函数.
# 3.1 创建汽车类对象
c1 = Car()
# 3.2 调用汽车类, 跑的功能.
c1.run()
print('-' * 21)
# 4. 调用work()函数.
c1.work()
2.属性的定义和调用
-
属性介绍:
- 概述:
属性 = 名词, 即: 描述事物的外在特征的. 例如: 姓名, 年龄, 性别…
- 概述:
-
定义属性的格式:
- 类外: 对象名.属性名 = 属性值
- 类内: 要结合 init() 魔法方法一起使用.
-
调用属性的格式:
- 类外: 对象名.属性名
- 类内: self.属性名
-
遇到的问题: 在main函数中, 通过 对象名.属性名 = 属性值的方式 给c1对象设置属性值了, 但是 c2对象没有属性值.
-
产生的原因: 在类外设置属性, 只能给当前对象设置, 不能给本类的其它对象设置.
-
解决方案: 通过 init()魔法方法在类内给该类的对象设置属性值, 则该类所有的对象默认都有这些属性值.
案例:给车设置颜色为红色,4个轮胎,且获取属性并输出.
注:在类内定义show()方法,获取属性值.即:类内获取属性值.
class Car:
# 2. 在类内定义show()方法, 获取属性值. 即: 类内获取属性值
def show(self):
# self = 本类当前对象的引用.
print(f'颜色: {self.color}, 轮胎数: {self.num}')
# 在main函数中测试调用.
if __name__ == '__main__':
# 3. 创建对象.
c1 = Car()
# 4. 给c1对象设置属性值. 类外设置属性
c1.color = '红色'
c1.num = 4
# 5. 打印c1对象的属性值. 类外获取属性值.
print(f'颜色: {c1.color}, 轮胎数: {c1.num}')
# 6. 调用show()方法, 获取属性值.
c1.show()
print('-' * 21)
3.魔法方法
-
概述
属性 = 名词,即:描述事物的外在特征.例如姓名,年龄,性别等. -
定义属性的格式:
- 类外:对象名.属性名 = 属性值
- 类内:要结init 魔法方法来使用
-
调用的属性格式:
- 类外: 对象名.属性名
- 类内:self.属性名
-
注意:
-
遇到的问题: 在main函数中, 通过 对象名.属性名 = 属性值的方式 给c1对象设置属性值了, 但是 c2对象没有属性值.
-
产生的原因: 在类外设置属性, 只能给当前对象设置, 不能给本类的其它对象设置.
-
解决方案: 通过 init()魔法方法在类内给该类的对象设置属性值, 则该类所有的对象默认都有这些属性值.
-
魔法方法介绍:
概述:是python 内置的一些函数,主要用于对类的功能增强的 -
格式:在特定场景下,会自动调用无需用户手动调用
__方法名__()
- 常用魔法方法:
__init__() # 创建对象是,被自动调用,用于给对象初始化一些属性值
__str__()
__del__()
案例
# 需求: 给车这个对象默认设置 颜色 color=黑色, 轮胎数 number=3
# 1. 定义汽车类.
class Car():
# 2. 通过 魔法方法 init, 初始化 汽车对象的属性值, 即: 所有汽车类对象, 默认都有这个属性值.
def __init__(self): # 无参数的 init函数.
print('我是init函数, 我被调用了!')
# 具体的设置属性值的动作.
self.color = '黑色'
self.number = 3
# 3. 定义函数show(), 在类内调用 属性.
def show(self):
print(f'颜色: {self.color}, 轮胎数: {self.number}')
# 在main函数中测试.
if __name__ == '__main__':
# 4. 创建汽车类对象.
c1 = Car()
# c2 = Car()
# # print('-' * 21)
# #
# # # 扩展: 修改c1的属性值.
# # c1.color = '霞光紫'
# # c1.number = 10
#
# # # 5. 调用show()函数, 打印属性值.
c1.show()
# print('-' * 21)
# c2.show()
# print('-' * 21)
#
# # 6. 扩展, 在类外调用属性.
# print(c1.color, c1.number)
# print(c2.color, c2.number)
3.1 带参数的魔法方法
-
回顾上述:
-
init 魔法方法中的属性值是固定的. 思考这些参数能不能通过外部参数的方式对其进行赋值.
-
即:可通过代参数的init函数来解决.
# 需求: 通过外部传参的方式, 给汽车对象设置属性值, 例如: 褐色, 6个轮胎.
# 1. 定义汽车类.
class Car():
# 2. 通过 魔法方法 init, 初始化 汽车对象的属性值, 即: 所有汽车类对象, 默认都有这个属性值.
def __init__(self, color, number): # 带参数的 init函数.
# 具体的设置属性值的动作.
self.color = color
self.number = number
# 3. 定义函数show(), 在类内调用 属性.
def show(self):
print(f'颜色: {self.color}, 轮胎数: {self.number}')
# 在main函数中测试.
if __name__ == '__main__':
# 4. 创建汽车类对象.
c1 = Car('黑色', 6) # 因为init函数带参, 所以需要传参.
c2 = Car('银色',8)
print('-' * 21)
#
# # 扩展: 修改c1的属性值.
# c1.color = '霞光紫'
# c1.number = 10
# # 5. 调用show()函数, 打印属性值.
c1.show()
print('-' * 21)
c2.show()
print('-' * 21)
# 6. 扩展, 在类外调用属性.
# print(c1.color, c1.number)
# print(c2.color, c2.number)
3.2 魔法方法 str 和 del
- 常用的魔法方法
- init() 在创建对象的时候, 会被自动调用, 一般用于给对象初始化一些属性值. 即: 对象名 = 类名() 就会自动调用该魔法方法.
- str() 当输出语句直接打印对象的时候, 会自动调用该魔法方法, 默认打印的是地址值, 无意义, 一般会改为: 打印该对象的各个属性值.
- del() 当手动删除对象时 或者 文件执行结束后, 该函数会被自动调用.
- 大白话解释
init 魔法方法 创建一个对象 = 调用一次
str 魔法方法 打印一次对象 = 调用一次
del 魔法方法 只要删除1个该类的对象 = 调用一次
案例
# 1. 定义汽车类, 属性: 品牌, 价格.
class Car():
# 定义init, 初始化属性.
def __init__(self, brand, price):
self.brand = brand # 品牌
self.price = price # 价格
# 行为
def run(self):
print('汽车会跑!')
# 魔法方法, str
def __str__(self):
# return '我是str魔法方法'
return f'品牌: {self.brand}, 价格: {self.price}'
# 魔法方法, del
def __del__(self):
print(f'对象 {self} 被删除了!')
# 在main函数中测试调用.
if __name__ == '__main__':
# 2. 创建汽车类对象.
c1 = Car('小米Su7', 239999) # 创建对象时, 自动调用了: init魔法方法
# 3. 直接打印c1对象
print(c1) # 默认调用了 __str__() 魔法方法.
# 4. 删除c1对象, 看看结果.
# del c1
4.综合案例
4.1减肥
"""案例:
小明同学当前的体重为100Kg, 每跑步一次体重减少0.5Kg, 每大吃大喝一次, 体重增加2Kg, 尝试用面向对象思维解决该问题.
目的:
考察 魔法方法, 类, 对象等的内容的使用.
"""
# 1. 定义学生类, 小明 => 学生对象.
class Student():
# 2. 定义属性, 表示小明当前的体重.
def __init__(self,weight):
# 表示: 当前体重.
self.current_weight = weight
# 3. 每跑步一次体重减少0.5Kg
def run(self):
# 修改体重.
# self.current_weight = self.current_weight - 0.5
self.current_weight -= 0.5
# 具体的跑步动作.
print('跑步一次, 体重减少 0.5Kg!')
# 4. 每大吃大喝一次, 体重增加2Kg
def eat(self):
# 修改体重.
self.current_weight += 2
# 具体的大吃大喝动作.
print('大吃大喝一次, 体重增加 2Kg!')
# 调用 str 用于打印: 学生对象的信息.
def __str__(self):
return f'小明同学当前的体重为: {xm.current_weight} Kg!'
# 在main函数中测试调用.
if __name__ == '__main__':
# 5. 创建学生类对象, 即: 小明.
xm = Student(100)
# 6. 打印小明当前的体重.
print(xm) # 100Kg
# 7. 小明跑步 2 次.
xm.run()
xm.run()
# 8. 打印小明当前的体重.
print(xm) # 99Kg
# 9. 小明大吃大喝一次.
xm.eat() # 101Kg
# 10. 打印小明当前的体重.
print(xm)
4.2 烤地瓜
"""
案例: 烤地瓜
烘烤时间 对应的地瓜状态
0 ~ 3分钟 生的 0 < time <= 3
3 ~ 7分钟 半生不熟 3 < time <= 7
7 ~ 12分钟 熟了 7 < time <= 12
超过12分钟 已烤焦, 糊了 time > 12
分析:
名词: 写到 init()魔法方法中
地瓜被烤的时间 cook_time
地瓜的生熟状态 cook_state
添加的调料 condiments
动词: 定义成 函数
烤(地瓜) cook()
添加(调料) add_condiment()
"""
# 1. 定义1个地瓜类.
class SweetPotato(): # 类名命名遵循: 大驼峰命名法, 即: 每个单词的首字母都是大写的, 其它小写, 例如: HelloWorld
# 2. 定义init函数, 初始化属性.
def __init__(self):
self.cook_time = 0 # 地瓜被烤的时间
self.cook_state = '生的' # 地瓜的生熟状态
self. condiments = [] # 添加的调料
# 3. 定义一个cook()函数, 让地瓜开始烤.
def cook(self, time):
"""
具体的烤地瓜的动作
:param time: 烤地瓜的时间
:return: 无
"""
# 3.1 非法值校验.
if time <= 0:
print('时间非法, 请录入正确的烘烤时间!')
return # 结束函数
# 3.2 修改地瓜的烘烤时间
self.cook_time += time
# 3.3 根据时间, 更新地瓜的生熟状态.
if 0 <= self.cook_time <= 3:
self.cook_state = '生的'
elif 3 < self.cook_time <= 7:
self.cook_state = '半生不熟的'
elif 7 < self.cook_time <= 12:
self.cook_state = '熟的'
else:
self.cook_state = '焦的'
# 4. 定义函数, 表示 添加调料.
def add_condiment(self, condiment):
"""
具体的添加调料的动作
:param condiment: 要添加的调料
:return: 无
"""
self.condiments.append(condiment)
print(f'添加 {condiment} 调料成功!')
# 5. 打印地瓜的状态.
def __str__(self):
return f'地瓜的生熟状态为: {self.cook_state}, 烤了 {self.cook_time} 分钟, 添加的调料有: {self.condiments}'
# 在main中测试
if __name__ == '__main__':
# 6. 创建地瓜对象.
digua = SweetPotato()
# 7.具体的烘烤动作.
digua.cook(-5) # 给一个非法值.
digua.cook(2)
digua.cook(5)
digua.cook(3)
# 8. 添加调料.
digua.add_condiment('辣椒')
digua.add_condiment('芝士')
# 9. 打印地瓜的状态.
print(digua)
总结
持续更新中~~~
589
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
