学习目标:
- 了解面向过程和面向对象的区别
- 知道类是由方法(函数)和属性(变量)构成
- 掌握类和对象的使用,例如:定义类、创建对象、对象调用方法,对象添加和使用属性
- 知道方法中 self 参数的作用
- 知道魔法方法的特点和使用
- 知道烤地瓜案例的需求和实现思路
- 知道搬家具案例的需求和实现思路
01_面向对象编程
学习目标:
- 了解面向过程和面向对象的区别
1.1 面向过程
-
把编程任务划分成一个一个的步骤,然后按照步骤分别去执行。
- 以 小明起床上学 为例,面向过程则做了如下 4 件事:起床、穿衣、洗漱、上学,这 4 个过程的顺序很重要,须一个一个地实现。
-
对于面向过程的思想: 需要实现一个功能的时候,看重的是开发的步骤和过程,每一个步骤都需要自己亲力亲为。
- 以 吃饭 举例:买菜、洗菜、煮饭、切菜……
-
面向过程编程适合开发中小型项目
1.2 面向对象
- 把构成问题事务分解成各个对象,建立对象的目的不是为了完成一个步骤,而是为了描述某个事物在整个解决问题步骤中的行为。
- 以 小明起床上学 为例,我们关心的是小明这个对象,而不是 起床、穿衣、洗漱、上学 这 4 个过程,这 4 个过程是小明这个对象的一部分,只是其中的一种行为,而且对于行为的顺序没有强制要求。
-
对于面向对象的思想:当需要实现一个功能的时候,看重的并不是过程和步骤,而是关心的是对象,对象能做啥
- 以 吃饭 举例:找 饭馆 对象,饭馆提供菜和饭,不关心做菜和煮饭的内部过程
-
面向对象编程适合开发大型项目
02_类和对象
学习目标:
- 知道类和对象的关系
2.1 类
- 很多事物存在 相同的属性和行为(也叫方法),比如人有姓名年龄,能吃饭睡觉等等。
- 描述 具有共同特征的事物的 抽象,称为 类 (class)。
- 类包含两个组成部分:
- 属性:比如姓名,年龄,身高,肤色等
- 方法:比如吃饭,睡觉,飞行,歌唱等
2.2 对象
- 对象 是 类 的实例,是具体的实体
2.3 类和对象的关系
- 类是对象的模板(不占内存空间),对象是类的实例(占内存空间)。
- 类相当于图纸,对象相当于根据图纸制造的实物。
- 每个对象必须有一个对应的类。
03_定义类
学习目标:
- 知道如何定义类和方法
3.1 定义类
定义一个类,格式如下:
#class 类名:
#class 类名(): # 前2个旧式写法(经典类),不推荐
class 类名(object):
方法列表(不是真的是列表,只是多个函数的定义)
说明:
- 定义类时有 2 种形式:经典类和新式类,前两行注释部分则为经典类,推荐写新式类
- object 是Python 里所有类的最顶级父类
- 类名 的命名规则按照 大驼峰命名法
3.2 定义方法
定义方法(方法也叫实例方法)格式为:
class 类名(object):
def 方法名(self):
...
- 方法的格式和函数类似,也可以设置参数和返回值,但是 需要设置第一个参数为
self
- 编辑器一般会自动生成
self
,后面会讲解self
的作用
示例代码:
class Dog(object):
# self自动添加的,后面有讲解
# 定义在类里面的函数,叫方法
def eat(self):
print('吃骨头')
def drink(self):
print('喝水')
04_创建对象和调用方法
学习目标:
- 知道如何创建实例对象和调用方法
4.1 创建对象
-
Python中,可以根据已经定义的类去创建实例对象。
-
创建对象的格式为:
对象变量名 = 类名()
示例代码:
# 定义类型
class Dog(object):
# 定义在类里面的函数,叫方法
def eat(self):
print('吃骨头')
def drink(self):
print('喝水')
# 创建对象格式:实例对象变量名 = 类名()
dog1 = Dog()
4.2 调用方法
调用方法的格式为:
对象变量名.方法名()
- 注意:虽然定义方法时设置第一个参数
self
,但是 调用方法时不要传递对应self
的参数,解释器自动处理
示例代码:
class Dog(object):
# 定义在类里面的函数,叫方法
def eat(self):
print('吃骨头')
def drink(self):
print('喝水')
# 创建对象格式:实例对象变量名 = 类名()
dog1 = Dog()
# 对象变量.方法名字(), self不用处理
dog1.eat()
dog1.drink()
4.3 创建多个对象
- 类作为对象的模具,根据类可以创建多个对象
class Dog(object):
# 定义在类里面的函数,叫方法
def eat(self):
print('吃骨头')
def drink(self):
print('喝水')
# 对象1 = 类名()
# 对象2 = 类名()
# 对象1
dog1 = Dog()
dog1.eat()
dog1.drink()
# 对象2
dog2 = Dog()
dog2.eat()
dog2.drink()
05_添加和使用属性
学习目标:
- 知道如何给对象添加属性和使用属性
- 对象既然有实例方法,也有自己的属性。
-
定义/添加属性格式:
对象变量名.属性名 = 数据
- 属性和变量类似,首次赋值时会定义属性,再次赋值改变属性
示例代码:
class Dog(object):
# 定义在类里面的函数,叫方法
def eat(self):
print('吃骨头')
def drink(self):
print('喝水')
# 1. 创建对象变量
dog1 = Dog()
# 2. 对象变量.属性 = 数值
dog1.age = 3
# 打印属性
print(dog1.age)
# 修改属性
dog1.age = 2
print(dog1.age)
06_self的作用
学习目标:
- 知道方法中 self 参数的作用
6.1 self是什么
- 在Python类中规定,实现方法的第一个参数是实例对象本身,并且约定俗成,把其名字写为self。
- 某个对象调用其方法时,Python解释器会自动把这个对象作为第一个参数传递给方法
- 通俗理解:哪个对象调用方法,方法中self就是这个对象
示例代码:
# 定义类
class Dog(object):
def print_info(self):
print('测试self', id(self))
# 创建对象1
dog1 = Dog()
# 打印dog1的id
print("调用方法前", id(dog1))
# dog1调用print_info, print_info的self就是dog1
# 底层调用:print_info(dog1), 解释器自动把dog1传给方法中的self
dog1.print_info()
print("调用方法后", id(dog1))
print('='*30)
# 创建对象2
dog2 = Dog()
print("调用方法前", id(dog2))
dog2.print_info()
print("调用方法后", id(dog2))
运行结果:
调用方法前 4400762352
测试self 4400762352
调用方法后 4400762352
==============================
调用方法前 4400762544
测试self 4400762544
调用方法后 4400762544
6.2 self的作用
-
在方法中使用
self
,可以获取到调用当前方法的对象,进而获取到该对象的属性和方法 -
self作用:为了区分不同对象的属性和方法
# 定义类
class Dog(object):
def print_info(self):
print(self.type)
# 创建对象,实例化对象
dog1 = Dog()
# 添加属性
dog1.type = '大黄狗'
# 直接调用方法
dog1.print_info()
print('='*30)
dog2 = Dog()
dog2.type = '旺财'
dog2.print_info()
07_魔法方法:__init__()
学习目标:
- 知道
__init__
方法的作用和特点 - 知道如何定义不带参数和带参数的
__init__
方法
7.1 魔法方法
- 在Python中,所有以
__
双下划线包起来的方法,都统称为 Magic Method ,中文称 魔法方法 - 魔法方法是系统提供好的方法名字,用户需重新实现它
- 魔法方法一般情况下无需手动调用,在合适时候自动会调用
7.2 __init__()
基本使用
__init__()
方法叫做 对象的初始化方法,在 创建一个对象后会被自动调用,不需要手动调用__init__()
方法的作用:添加属性
示例代码:
"""
__init__方法:
1. 作用:添加属性
2. 特点:创建对象的时候,实例化对象,自动调用__init__方法
"""
class Dog(object):
def __init__(self):
"""初始化函数,添加属性"""
self.type = '大黄狗'
print('init方法调用了')
def print_info(self):
"""打印实例属性"""
print(self.type)
# 1. 创建对象,实例化对象,自动调用__init__方法
# 2. 尽管是自动调用方法,也是dog1自动调用方法,所以,self就是dog1
dog1 = Dog()
# 手动调用实例方法
dog1.print_info()
运行结果:
init方法调用了
大黄狗
7.3 __init__()
自定义参数
-
__init__(self)
除了默认参数self
,还可以设置任意个数的自定义参数,例如:__init__(self,x,y,z)
-
init方法 设置的自定义参数必须和创建对象时传递的参数保持一致,例如:
对象变量名 = 类名(x,y,z)
-
开发者可以 设置自定义参数,为对象的默认属性提供 不同的初始值
示例代码:
class Dog(object):
def __init__(self, _type):
"""初始化函数,添加属性"""
self.type = _type
print('init方法调用了')
def print_info(self):
"""打印实例属性"""
print(self.type)
# 创建对象,实例化对象,自动调用__init__方法
# '旺财'传递给 _type 形参
dog1 = Dog('旺财')
# 直接调用方法
dog1.print_info()
print('='*30)
dog2 = Dog('来福')
dog2.print_info()
运行结果:
init方法调用了
旺财
==============================
init方法调用了
来福
08_魔法方法:__str__()
学习目标:
- 知道
__str__
方法的作用
__str__()方法的使用
- 如果直接 print 打印对象,会看到创建出来的对象在内存中的地址
-
当使用
print(对象变量名)
输出对象的时候,只要类中定义了__str__()
方法,就会打印__str__()
方法返回值 __str__()
方法作用主要返回对象属性信息,print(对象变量名)
输出对象时直接输出__str__()
方法返回的描述信息__str__()
方法的返回值必须是 字符串类型
示例代码:
"""
__str__方法:
1. 返回值必须是字符串类型
2. print(对象变量名) 对象变量名的位置替换为__str__()方法返回值的内容
"""
class Dog(object):
# 添加属性,type, age
def __init__(self, _type, _age):
self.type = _type
self.age = _age
# 测试有定义 __str__ 方法,和没有定义,print(对象)的区别
def __str__(self):
return "类型:%s, 年龄:%d" % (self.type, self.age)
# 创建对象
dog1 = Dog('大白狗', 3)
# 如果有__str__ 方法,dog1的位置替换为__str__()方法返回值的内容
print(dog1)
print('对象描述信息为:', dog1)
运行结果:
类型:大白狗, 年龄:3
对象描述信息为: 类型:大白狗, 年龄:3
09_魔法方法:__del__()
学习目标:
- 知道对象销毁时会自动调用
__del__
方法
__del__()方法的使用
- 在对象的生命周期结束(对象销毁)时,
__del__()
方法会自动被调用,做一些清理工作
class Dog(object):
def __del__(self):
print('我悄悄地离开了')
# 设计一个函数,在函数内容创建对象
# 函数调用完毕,里面创建的对象,生命周期结束,自动调用__del__方法
def func():
dog1 = Dog()
print('函数调用前')
# 调用函数
func()
print('函数调用后')
运行结果:
函数调用前
我悄悄地离开了
函数调用后
10_应用:烤地瓜
学习目标:
- 知道烤地瓜案例的需求和实现思路
10.1 需求说明
烤地瓜规则:
-
地瓜有自己的状态,默认是生的,地瓜可以进行烧烤
-
地瓜有自己烧烤的总时间,由每次烧烤的时间累加得出
-
地瓜烧烤时,需要提供本次烧烤的时间
-
地瓜烧烤时,地瓜状态随着烧烤总时间的变化而改变:[0, 3) 生的、[3, 6) 半生不熟、[6, 8) 熟了、>=8 烤糊了
-
输出地瓜信息时,可以显示地瓜的状态和烧烤的总时间
10.2 面向对象设计
类图
10.2.1 地瓜类
(1) 使用 SweetPotato
类可以创建 地瓜对象
(2) 地瓜有两个属性:
- 状态 state:字符串
- 烧烤总时间 cooked_time:整数
(3) 定义 cook
方法, 提供参数 time
设置 本次烧烤的时间
- 使用 本次烧烤时间 对 烧烤总时间 进行 累加
- 根据 烧烤总时间, 设置地瓜的状态:
- [0, 3) -> 生的
-
[3, 6) -> 半生不熟
-
[6, 8) -> 熟了
-
大于等于8 -> 烤糊了
10.2.2 主程序逻辑
- 创建 地瓜对象
- 分多次 烧烤地瓜
- 每烧烤一次,输出地瓜信息
10.2.3 示例代码
(1) 步骤流程
"""
# SweetPotato 类的设计
地瓜有两个属性:
状态 state:字符串
烧烤总时间 cooked_time:整数
# 1. 定义__init__方法,添加2个属性
# 1.1 默认状态state是生的
# 1.2 默认时间cooked_time是0
# 2. 定义__str__方法
# 2.1 返回地瓜状态,烧烤总时间
# 3. 定义 cook 方法, 提供参数 time 设置 本次烧烤的时间
# 3.1 使用 本次烧烤时间 对 烧烤总时间 进行 累加
# 3.2 根据 烧烤总时间, 设置地瓜的状态:
[0, 3) -> 生的
[3, 6) -> 半生不熟
[6, 8) -> 熟了
大于等于8 -> 烤糊了
# 4. 主逻辑程序
# 4.1 创建 地瓜对象
# 4.2 分多次烧烤地瓜
# 4.3 每烧烤一次,输出地瓜信息
"""
(2) 定义地瓜类、通过__init__()方法
添加属性
class SweetPotato(object):
"""地瓜类"""
# 1. 定义__init__方法,添加2个属性
def __init__(self):
# 1.1 默认状态state是生的
self.state = '生的'
# 1.2 默认时间cooked_time是0
self.cooked_time = 0
(3) 定义__str__()
方法
# 2. 定义__str__方法
def __str__(self):
# 2.1 返回地瓜状态,烧烤总时间
return f'地瓜状态为:{self.state}, 烧烤总时间为:{self.cooked_time} 分钟'
(4) 定义"烤地瓜"方法
# 3. 定义 cook 方法, 提供参数 time 设置 本次烧烤的时间
def cook(self, time):
# 3.1 使用 本次烧烤时间 对 烧烤总时间 进行 累加
self.cooked_time += time
# 3.2 根据 烧烤总时间, 设置地瓜的状态:
if 0 <= self.cooked_time < 3:
self.state = '生的'
elif 3 <= self.cooked_time < 6:
self.state = '半生不熟'
elif 6 <= self.cooked_time < 8:
self.state = '熟了'
else:
self.state = '烤糊了'
(5) 测试代码
把上面 3 块代码合并为一个程序后,在代码的下面添加以下代码进行测试:
# 4.1 创建 地瓜对象
sp = SweetPotato()
print(sp) # 输出地瓜信息
# 4.2 分多次烧烤地瓜
sp.cook(2)
print(sp) # 4.3 每烧烤一次,输出地瓜信息
sp.cook(5)
print(sp)
sp.cook(2)
print(sp)
运行结果:
地瓜状态为:生的, 烧烤总时间为:0 分钟
地瓜状态为:生的, 烧烤总时间为:2 分钟
地瓜状态为:熟了, 烧烤总时间为:7 分钟
地瓜状态为:烤糊了, 烧烤总时间为:9 分钟
10.3 拓展功能
10.3.1 烤地瓜需求拓展
-
地瓜可以添加佐料,如 盐、孜然、辣酱等
-
输出地瓜信息时,可以显示地瓜的状态、烧烤总时间、以及添加过的所有佐料
10.3.2 需求分析
- 每个地瓜记录自己的佐料,定义属性来记录
- 地瓜可以添加多个佐料,应该定义 容器类型属性 来记录添加的佐料
- 地瓜类 应该 定义方法来实现添加佐料的功能
10.3.3 示例代码
(1) 步骤流程
# 5. 拓展功能
# 5.1 添加属性 condiments, 列表类型,默认为空列表
# 5.2 修改 __str__ 返回信息,返回增加已添加的佐料信息
# 5.3 定义 add_condiments(self, temp), temp为添加什么佐料的参数
# 5.3.1 佐料列表追加元素
# 5.4 再次测试代码,添加佐料,重新打印信息
(2) 添加 condiments
属性
# 1. 定义__init__方法,添加3个属性
def __init__(self):
# 1.1 默认状态state是生的
self.state = '生的'
# 1.2 默认时间cooked_time是0
self.cooked_time = 0
# 5.1 添加属性 condiments, 列表类型,默认为空列表
self.condiments = []
(3) 修改__str__()
方法,在方法中使用condiments
属性显示已添加的佐料
# 2. 定义__str__方法
def __str__(self):
# 2.1 返回地瓜状态,烧烤总时间
# 5.2 修改 __str__ 返回信息,返回增加已添加的佐料信息
return f'地瓜状态为:{self.state}, 烧烤总时间为:{self.cooked_time} 分钟,包括的佐料为:{self.condiments}'
(4) 定义add_condiments()
方法
# 5.3 定义 add_condiments(self, temp), temp为添加什么佐料的参数
def add_condiment(self, temp):
# 5.3.1 佐料列表追加元素
self.condiments.append(temp)
(5) 再次测试
# 4.1 创建 地瓜对象
sp = SweetPotato()
print(sp) # 输出地瓜信息
# 4.2 分多次烧烤地瓜
sp.cook(2)
# 添加佐料
sp.add_condiment('番茄酱')
print(sp) # 4.3 每烧烤一次,输出地瓜信息
sp.cook(5)
sp.add_condiment('孜然')
print(sp)
sp.cook(2)
sp.add_condiment('烤肉')
print(sp)
运行结果:
地瓜状态为:生的, 烧烤总时间为:0 分钟,包括的佐料为:[]
地瓜状态为:生的, 烧烤总时间为:2 分钟,包括的佐料为:['番茄酱']
地瓜状态为:熟了, 烧烤总时间为:7 分钟,包括的佐料为:['番茄酱', '孜然']
地瓜状态为:烤糊了, 烧烤总时间为:9 分钟,包括的佐料为:['番茄酱', '孜然', '烤肉']
11_应用: 搬家具
学习目标:
- 知道搬家具案例的需求和实现思路
11.1 需求说明
搬家具规则:
-
家具分不同的类型,并占用不同的面积
-
输出家具信息时,显示家具的类型和家具占用的面积
-
房子有自己的地址和占用的面积
-
房子可以添加家具,如果房子的剩余面积可以容纳家具,则提示家具添加成功;否则提示添加失败
-
输出房子信息时,可以显示房子的地址、占地面积、剩余面积
11.2 面向对象设计
类图
11.2.1 家具类
- 使用
Item
类可以创建 家具对象 - 家具有两个属性:
- 家具类型 type:字符串
- 家具面积 area:整数
- 实现
__str__
方法- 显示家具的 type 和 area 属性
11.2.2 房子类
- 使用
Home
类可以创建 房子对象 - 房子有三个属性:
- 地址 address:字符串
- 房子面积 area:整数
- 房子剩余面积 free_area:整数,默认为房子的面积
- 实现
__str__
方法- 显示房子的 address 、area、free_area 属性
- 实现
add_item
方法,提供item
参数来添加家具- 如果 可以容纳家具:
- 打印添加家具的类型和面积
- 剩余面积 减少
- 如果 不能容纳家具: 提示家具添加失败
- 如果 可以容纳家具:
11.2.3 主程序逻辑
-
创建 家具对象, 输出 家具信息
-
创建 房子对象, 输出 房子信息
-
房子添加家具, 输出 房子信息
11.2.4. 示例代码
"""
家具类 Item
# 1. 定义__init__方法,添加2个属性,需要2个形参 _type, _area
# 1.1 家具类型 type
# 1.2 家具面积 area
# 2. 实现__str__方法
# 2.1 返回家具类型和家具面积
房子类 Home
# 1. 定义__init__方法,添加3个属性,需要3个形参
# 1.1 地址 address
# 1.2 房子面积 area
# 1.3 房子剩余面积 free_area,默认为房子的面积
# 2. 实现__str__方法
# 2.1 返回房子地址、面积、剩余面积信息
# 3. 实现add_item方法,提供item参数来添加家具,item是对象
# 3.1 如果 房间的剩余面积 >= 家具的面积,可以容纳家具:
# 3.1.1 打印添加家具的类型和面积
# 3.1.2 剩余面积 减少
# 3.2 否则 不能容纳家具:提示家具添加失败
主程序逻辑:
# 1. 创建 家具对象, 输出 家具信息
# 2. 创建 房子对象, 输出 房子信息
# 3. 房子添加家具, 输出 房子信息
"""
class Item(object):
"""家具类"""
# 1. 定义__init__方法,添加2个属性,需要2个形参 _type, _area
def __init__(self, _type, _area):
# 1.1 地址 address
self.type = _type
# 1.2 家具面积 area
self.area = _area
# 2. 实现__str__方法
def __str__(self):
# 2.1 返回房子地址、面积、剩余面积信息
return f'家具类型为:{self.type}, 家具面积为:{self.area}'
class House(object):
"""房子类"""
# 1. 定义__init__方法,添加3个属性,需要3个形参
def __init__(self, _addr, _area, _free_area):
# 1.1 地址 address
self.address = _addr
# 1.2 房子面积 area
self.area = _area
# 1.3 房子剩余面积 free_area,默认为房子的面积
self.free_area = _free_area
# 2. 实现__str__方法
def __str__(self):
# 2.1 返回房子地址、面积、剩余面积信息
return f'房子地址:{self.address}, 房子面积:{self.area}, 房子剩余面积:{self.free_area}'
# 3. 实现add_item方法,提供item参数来添加家具,item是家具对象
def add_item(self, item):
# 3.1 如果 房间的剩余面积 >= 家具的面积,可以容纳家具:
if self.free_area > item.area:
# 3.1.1 打印添加家具的类型和面积
print(f'添加{item.type}成功了,家具占用面积为:{item.area}')
# 3.1.2 剩余面积 减少
self.free_area -= item.area
# 3.2 否则 不能容纳家具: 提示家具添加失败
else:
print('家具添加失败')
# 1. 创建 家具对象, 输出 家具信息
# 2. 创建 房子对象, 输出 房子信息
# 3. 房子添加家具, 输出 房子信息
h = House('兴东地铁站', 70, 70) # 创建房间对象h
print(h) # 打印房子对象,获取House中__str__返回的信息
tv = Item('超大电视', 10) # 创建家具1
print(tv) # 打印家具对象,输出Item中__str__返回的信息
h.add_item(tv) # 房子添加家具
print(h) # 打印房子对象,获取House中__str__返回的信息
bed = Item('超大床', 20) # 创建家具2
print(bed) # 打印家具对象,输出Item中__str__返回的信息
h.add_item(bed) # 房子添加家具
print(h)
运行结果:
房子地址:兴东地铁站, 房子面积:70, 房子剩余面积:70
家具类型为:超大电视, 家具面积为:10
添加超大电视成功了,家具占用面积为:10
房子地址:兴东地铁站, 房子面积:70, 房子剩余面积:60
家具类型为:超大床, 家具面积为:20
添加超大床成功了,家具占用面积为:20
房子地址:兴东地铁站, 房子面积:70, 房子剩余面积:40
11.3 拓展功能
需求:输出房子时,显示包含的所有家具的类型
-
Home
类中添加item_type_list
属性(家具类型列表),用于记录所有家具对象 -
Home
类的add_item
方法中, 将添加成功的 家具类型 添加到item_type_list
中 -
Home
类的__str__
方法中, 打印家具的类型
示例代码:
class Item(object):
"""家具类"""
# 1. 定义__init__方法,添加2个属性,需要2个形参 _type, _area
def __init__(self, _type, _area):
# 1.1 地址 address
self.type = _type
# 1.2 家具面积 area
self.area = _area
# 2. 实现__str__方法
def __str__(self):
# 2.1 返回房子地址、面积、剩余面积信息
return f'家具类型为:{self.type}, 家具面积为:{self.area}'
class House(object):
"""房子类"""
# 1. 定义__init__方法,添加3个属性,需要3个形参
def __init__(self, _addr, _area, _free_area):
# 1.1 地址 address
self.address = _addr
# 1.2 房子面积 area
self.area = _area
# 1.3 房子剩余面积 free_area,默认为房子的面积
self.free_area = _free_area
# a. Home类中添加 item_type_list 属性(家具类型列表),用于记录所有家具类型
self.item_type_list = [] # 默认空列表
# 2. 实现__str__方法
def __str__(self):
# 2.1 返回房子地址、面积、剩余面积信息
# c. Home类的 __str__ 方法中, 打印家具的类型列表
return f'房子地址:{self.address}, 房子面积:{self.area}, 房子剩余面积:{self.free_area}, 添加家具情况为:{self.item_type_list}'
# 3. 实现add_item方法,提供item参数来添加家具,item是家具对象
def add_item(self, item):
# 3.1 如果 房间的剩余面积 >= 家具的面积,可以容纳家具:
if self.free_area > item.area:
# 3.1.1 打印添加家具的类型和面积
print(f'添加{item.type}成功了,家具占用面积为:{item.area}')
# b. Home类的 add_item 方法中, 将添加成功的 家具类型 添加到 item_type_list 中
self.item_type_list.append(item.type)
# 3.1.2 剩余面积 减少
self.free_area -= item.area
# 3.2 否则 不能容纳家具: 提示家具添加失败
else:
print('家具添加失败')
# 1. 创建 家具对象, 输出 家具信息
# 2. 创建 房子对象, 输出 房子信息
# 3. 房子添加家具, 输出 房子信息
h = House('兴东地铁站', 70, 70) # 创建房间对象h
print(h) # 打印房子对象,获取House中__str__返回的信息
tv = Item('超大电视', 10) # 创建家具1
print(tv) # 打印家具对象,输出Item中__str__返回的信息
h.add_item(tv) # 房子添加家具
print(h) # 打印房子对象,获取House中__str__返回的信息
bed = Item('超大床', 20) # 创建家具2
print(bed) # 打印家具对象,输出Item中__str__返回的信息
h.add_item(bed) # 房子添加家具
print(h)
运行结果:
房子地址:兴东地铁站, 房子面积:70, 房子剩余面积:70, 添加家具情况为:[]
家具类型为:超大电视, 家具面积为:10
添加超大电视成功了,家具占用面积为:10
房子地址:兴东地铁站, 房子面积:70, 房子剩余面积:60, 添加家具情况为:['超大电视']
家具类型为:超大床, 家具面积为:20
添加超大床成功了,家具占用面积为:20
房子地址:兴东地铁站, 房子面积:70, 房子剩余面积:40, 添加家具情况为:['超大电视', '超大床']
面向对象(上)——练习题
能力目标
- 知道类是由方法(函数)和属性(变量)构成
- 知道使用class关键字定义一个类
- 能够说出调用对象中的方法的语法格式
- 能够给对象添加属性
- 知道方法的self参数的作用
- 知道__init__方法的作用
- 知道如何定义带参数和不带参数的__init__方法
- 知道__str__方法的作用
- 知道烤地瓜案例的需求和实现思路
关卡一:综合题
1. 设计一个程序:
-
定义一个star类(明星类), 通过明星类创建一个zhou_xing_chi对象
使用__init__方法给对象添加属性
定义方法playing(),打印“xxx出演了yyy,非常好看”
答案
class Star(object):
def __init__(self,_name,_movie):
self.name = _name
self.movie = _movie
def playing(self):
print(f'{self.name}出演了{self.movie},非常好看')
zhouxingchi = Star('周星驰','功夫')
zhouxingchi.playing()
2. 设计一个程序:
-
定义一个star类(明星类), 通过明星类创建一个zhou_xing_chi对象
使用init方法给对象添加属性
print输出对象时打印"xxx是我的偶像,我非常喜欢他的电影yyy"
xxx为明星姓名,yyy是电影的名字
答案
class Star(object):
def __init__(self,_name,_movie):
self.name = _name
self.movie = _movie
def __str__(self):
return f'{self.name}是我的偶像,我非常喜欢他的电影{self.movie}'
zhouxingchi = Star('周星驰','功夫')
print(zhouxingchi)
3. 设计一个程序:
-
定义一个汽车类
-
在类中定义一个move方法打印'汽车在移动'
-
分别创建BMW_X9、AUDI_A9对象
-
并添加颜色、型号等属性,然后打印出属性值
-
使用__init__方法, 以达到在创建对象的同时,就为对象添加对应的属性的目的
-
添加__str__方法,以实现当直接打印对象时,能打印出可读性较高的信息。例如:我的颜色是 红色,型号是 X9
-
答案
class Car(object):
def move(self):
print('汽车在移动')
def __init__(self,_color,_model):
self.color = _color
self.model = _model
def __str__(self):
return f'我的颜色是{self.color},型号是{self.model}'
BMW_X9 = Car('白色','X9')
AUDI_A9 = Car('黑色','X9')
print(BMW_X9)
print(AUDI_A9)
4. 设计一个程序
-
定义动物类,
-
使用
__init__
方法,在创建对象时接收参数,为其添加name、age、color,food等属性,如“熊猫”,5, “黑白”,“竹子” -
为动物类定义一个run方法,调用run方法时打印相关信息。如打印出“熊猫正在奔跑”
-
为动物类定义一个get_age方法,调用get_age方法时打印相关信息。如打印出“这只熊猫今年5岁了"
-
为动物类定义一个eat方法,调用eat方法时打印相关信息。如打印出“熊猫正在吃竹子”
-
通过动物类分别创建出2只不同的动物,分别调用它们的方法,让他们跑起来,吃起来
-
直接打印对象的时候,返回动物的所有信息
-
答案
class Animal(object):
def __init__(self,_name,_age,_color,_food):
self.name = _name
self.age = _age
self.color = _color
self.food = _food
def run(self):
print(f'{self.name}正在奔跑')
def get_age(self):
print(f'这只{self.name}今年{self.age}岁了')
def eat(self):
print(f'{self.name}正在吃{self.food}')
def __str__(self):
return f'你好呀,我是一只{self.name},我今年{self.age}岁了,我的颜色是{self.color},我喜欢吃{self.food}'
xm = Animal('熊猫',5,'黑白','竹子')
print(xm)
xm.run()
xm.get_age()
xm.eat()
sz = Animal('狮子',3,'黄色','肉肉')
print(sz)
sz.run()
sz.get_age()
sz.eat()