Python基础_07_面向对象1

最新推荐文章于 2024-08-26 18:56:03 发布
最新推荐文章于 2024-08-26 18:56:03 发布
阅读量239 收藏
点赞数
分类专栏： Python 文章标签： python 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_59939643/article/details/122710299
版权

python基础7_面向对象1

文章目录

一、面向对象：类和对象、魔法方法

1. 面向对象编程概述

1.1【了解】面向过程和面向对象的区别
  • 面向过程
    • 把编程任务划分成一个一个的步骤，然后按照步骤分别去执行，适合开发中小型项目
    • 以 吃饭 举例：买菜、洗菜、煮饭、切菜……
  • 面向对象
    • 把构成问题事务分解成各个对象，适合开发大型项目
    • 以 吃饭 举例：找 饭馆 对象，饭馆提供菜和饭，不关心做菜和煮饭的内部过程
1.2【知道】类和对象介绍
  • 类是对象的模板(不占内存空间)，对象是类的实例(占内存空间)。
  • 类相当于图纸，对象相当于根据图纸制造的实物。

2. 面向对象编程

2.1【重点】定义类和方法
class 类名(object):
  	def 方法名(self):
      	方法代码块...
  • 代码:
"""
# 1. 定义类，设计一个类型
格式：
#class 类名:
#class 类名(): # 前2个旧式写法，不推荐
class 类名(object):
    方法列表（不是真的是列表，只是多个函数的定义）

# object所有类的祖先
# 类名：大驼峰命名
"""


# 定义类
class Dog(object):
    # 定义类的方法
    def eat(self):
        print("啃骨头")

    def drink(self):
        print("喝汤")


print(Dog)

# a = 10
# print(type(a))
2.2【重点】创建对象和调用方法
  • 创建对象：对象变量名 = 类名()
  • 调用方法：对象变量名.方法名()
"""
1. 定义类，只是定义了一个类型
2. 根据类，创建对象（实例对象）， 通过设计图创建一个实物
    格式：  实例对象变量名 = 类名()
3. 类里面方法如何调用
    对象变量.方法名字()
"""


# 1. 定义类，只是定义了一个类型
class Dog(object):
    def eat(self):
        print("啃骨头")

    def drink(self):
        print("喝水")


# 创建对象格式：实例对象变量名 = 类名()
dog1 = Dog()
# 对象变量.方法名字(), self不用处理
dog1.eat()
dog1.drink()
  • 创建多个对象:

class Dog(object):
    def eat(self):
        print("啃骨头")

    def drink(self):
        print("喝水")


# 对象1 = 类名()
dog1 = Dog()
# 对象2 = 类名()
dog2 = Dog()
# 对象1
dog1.eat()
dog1.drink()
# 对象2
dog2.eat()
dog2.drink()
2.3【重点】添加和使⽤属性

定义/添加属性格式：

对象变量名.属性名 = 数据	# 第一次赋值是定义，第二次赋值是修改
  • 首次赋值时会定义属性，再次赋值改变属性
"""
给对象添加属性：
1. 创建对象变量
2. 对象变量.属性 = 数值
    # 第一次赋值是添加属性，再次赋值是修改

如果使用属性
对象变量.属性
"""


class Dog(object):

    def eat(self):
        print("啃骨头")

    def drink(self):
        print("喝肉汤")


# 1. 创建对象变量
dog1 = Dog()
# 2. 对象变量.属性 = 数值
dog1.name = "旺财"

# 打印属性
print(dog1.name)

# 修改属性
dog1.name = "二哈"
print(dog1.name)


dog2 = Dog()
dog2.name = "金毛"
print(dog2.name)
2.5【记忆】self是什么
  • 哪个对象调用方法，方法中self就是这个对象本身
"""
self是什么：哪个对象调用方法，方法中self就是这个对象
"""

class Dog(object):

    def print_info(self):
        print("测试代码: ", id(self))


dog1 = Dog()
print("调用方法前: ", id(dog1))

dog1.print_info()   # 解释器自动传递参数dog1, 相当于dog1.print_info(dog1)

print("调用方法后: ", id(dog1))

print("="*50)

dog2 = Dog()
print("调用方法前: ", id(dog2))

dog2.print_info()   # 解释器自动传递参数dog2, 相当于dog2.print_info(dog2)

print("调用方法后: ", id(dog2))
2.5【理解】self的作用

  • 为了区分不同对象，访问不同对象的属性和方法

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-F8FA5XVY-1643210268456)(assets/image-20200908171407342-9556447.png)]

"""
self作用：为了区分不同对象的属性和方法
"""


# 定义类
class Dog(object):
    def eat(self):
        # self作用：为了区分不同对象的属性和方法
        print("%s啃骨头" % (self.name))
				
        
# 创建对象，实例化对象
dog1 = Dog()

# 添加属性
dog1.name = "旺财"

# 直接调用方法
dog1.eat()		# 解释器自动转换成 dog1.eat(dog1) 


dog2 = Dog()

dog2.name = "二哈"

dog2.eat()		# 解释器自动转换成 dog2.eat(dog2)

3. 魔法方法

3.1【重点】__init__方法

  1. __init__方法的作用和特点

    • 作用：添加属性
    • 特点：创建对象的时候，实例化对象，自动调用__init__方法
    """
__init__方法：
    1. 作用：添加属性
    2. 特点：创建对象的时候，实例化对象，自动调用__init__方法
"""


class Dog(object):
    # 用两个下划线包裹的方法叫魔法方法,而且魔法方法的名字是有系统定义,由用户重新实现它.
    def __init__(self):
        # 使用类创建对象时,会自动调用__init__方法
        
        self.name = "大黄狗"  # __init__方法的作用是给对象添加属性, 
        # 上面一句相当于 dog1.name='大黄狗'
        print("init被调用了")

    def eat(self):
        print("%s 啃骨头" % self.name)

    def drink(self):
        print("%s 喝肉汤" % self.name)


# 1. 创建对象，实例化对象，自动调用__init__方法
dog1 = Dog()		# 自动调用__init__方法, __init__(dog1)

dog1.eat()
dog1.drink()

  2. 不带参数和带参数的__init__方法的使用

    # 不带参数
class 类名(object):
    def __init__(self):
        pass

# 实例化对象
对象名 = 类名()
######################################
# 带参数
class 类名(object):
    def __init__(self, 形参1， 形参2 ……):
        pass

# 实例化对象
对象名 = 类名(实参1， 实参2，……)
  • 代码:
"""
__init__方法：
    1. 作用：添加属性
    2. 特点：创建对象的时候，实例化对象，自动调用__init__方法
    3. 设置参数，创建对象时，除了self参数不用人为处理，其它参数需要和__init__参数匹配
        对象名 = 类名(实参1， 实参2) ====》 __init__(self, 形参1, 形参2)
"""


class Dog(object):
    # 用两个下划线包裹的方法叫魔法方法,而且魔法方法的名字是有系统定义,由用户重新实现它.
    def __init__(self, _name):
        # 使用类创建对象时,会自动调用__init__方法
        self.name = _name  # __init__方法的作用是给对象添加属性
        print("init被调用了")

    def eat(self):
        print("%s 啃骨头" % self.name)

    def drink(self):
        print("%s 喝肉汤" % self.name)


# 创建对象，实例化对象，自动调用__init__方法
dog1 = Dog("旺财")    # 自动调用__init__(dog1, "旺财")
dog1.eat()

dog2 = Dog("来福")    # 自动调用__init__(dog2, "来福")
dog2.eat()
3.2【重点】__str__方法
  • __str__方法的作用：
    • __str__()方法作用主要返回对象属性信息，print(对象变量名)输出对象时直接输出__str__()方法返回的描述信息
    • __str__()方法的返回值必须是 字符串类型
  • """
__str__方法:
    1. 返回值必须是字符串类型
    2. print(对象变量名)  对象变量名的位置替换为__str__()方法返回值的内容
"""


class Dog(object):

    def __init__(self, _type, _age):
        # 对象初始化魔法方法, 给对象添加属性使用的, 会在创建对象时被系统自动调用
        self.type = _type
        self.age = _age
        print("对象初始化方法被调用了")

    def __str__(self):
        # 返回对象描述信息的魔法方法,
        # 当使用print(对象)时, 系统会自动调用__str__方法获取对象描述, print打印对象描述信息
        # 格式化字符串
        # return "类型: %s 年龄: %d" % (self.type, self.age)
        return f"类型: {self.type} 年龄: {self.age}岁"


dog1 = Dog("基多", 2)

# <__main__.Dog object at 0x000001B81E6E5910>
# 类中没有实现__str__方法,返回对象地址信息
# print(dog1)

# 类型: 基多 年龄: 2
print(dog1)  # print(对象), 系统会自动打印 对象.__str__() 返回的描述信息

print("对象dog1描述: ", dog1)
3.3【了解】__del__方法
  • 对象销毁时会自动调用__del__方法
"""
在对象的生命周期结束(对象销毁)时, __del__()方法会自动被调用，做一些清理工作
"""


class Dog(object):

    def __del__(self):
        print("对象被销毁了,做清理动作")
        

# 设计一个函数，在函数内容创建对象
def foo():
    # 函数调用完毕，里面创建的对象会销毁，生命周期结束，自动调用__del__方法
    dog1 = Dog()


print("函数被调用前")
# 调用函数
foo()
print("函数被调用后")

  • 对象销毁[扩展]:

  • """
在对象的生命周期结束(对象销毁)时, __del__()方法会自动被调用，做一些清理工作
"""


class Dog(object):

    def __del__(self):
        print("对象被销毁了,做清理动作")


# 设计一个函数，在函数内容创建对象
def foo():
    # 函数调用完毕，里面创建的对象会销毁，生命周期结束，自动调用__del__方法
    dog1 = Dog()


print("函数被调用前")
# 1.调用函数: 函数调用结束,函数中创建对象会被销毁
foo()
print("函数被调用后")

print("创建对象前")
dog2 = Dog()
del dog2    # 2.del 对象, 销毁对象.
print("销毁对象后")

dog3 = Dog()    # 3.程序结束后,所有对象会被销毁

4.【应用】烤地瓜

4.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 每烧烤一次，输出地瓜信息
"""


# SweetPotato 类的设计
#     地瓜有两个属性：
#         状态 state：字符串
#         烧烤总时间 cooked_time：整数

class SweetPotato(object):
    # 1. 定义__init__方法，添加2个属性
    def __init__(self):
        # 1.1 默认状态state是生的
        self.state = "生的"
        # 1.2 默认时间cooked_time是0
        self.cooked_time = 0

    # 2. 定义__str__方法
    def __str__(self):
        # 2.1 返回地瓜状态，烧烤总时间
        return "地瓜状态: %s 地瓜烧烤总时间: %d" % (self.state, self.cooked_time)

    # 3. 定义 cook 方法, 提供参数 time 设置 本次烧烤的时间
    def cook(self, time):
        # 3.1 使用 本次烧烤时间 对 烧烤总时间 进行 累加
        self.cooked_time += time
        # 3.2 根据 烧烤总时间, 设置地瓜的状态：
        # if self.cooked_time >= 0 and self.cooked_time < 3:
        if 0 <= self.cooked_time < 3:
            #     [0, 3) -> 生的
            self.state = "生的"

        elif 3 <= self.cooked_time < 6:
            #     [3, 6) -> 半生不熟
            self.state = "半生不熟"

        elif 6 <= self.cooked_time < 8:
            #     [6, 8) -> 熟了
            self.state = "熟了"

        elif self.cooked_time >= 8:
            #     大于等于8 -> 烤糊了
            self.state = "烤糊了"


# 4. 主逻辑程序
# 4.1 创建 地瓜对象
sp1 = SweetPotato()
print(sp1)

# 4.2 分多次烧烤地瓜
sp1.cook(2)
# 4.3 每烧烤一次，输出地瓜信息
print(sp1)

# 4.2 分多次烧烤地瓜
sp1.cook(5)
# 4.3 每烧烤一次，输出地瓜信息
print(sp1)

# 4.2 分多次烧烤地瓜
sp1.cook(2)
# 4.3 每烧烤一次，输出地瓜信息
print(sp1)
4.2. 拓展版本

  • 烤地瓜案例的实现思路：

    """
# 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 每烧烤一次，输出地瓜信息

# 5. 拓展功能
# 5.1 添加属性 condiments， 列表类型，默认为空列表
# 5.2 修改 __str__ 返回信息，返回增加已添加的佐料信息
# 5.3 定义 add_condiments(self, temp), temp为添加什么佐料的参数
    # 5.3.1 佐料列表追加元素
# 5.4 再次测试代码，添加佐料，重新打印信息
"""

代码:

"""
# 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 每烧烤一次，输出地瓜信息

# 5. 拓展功能
# 5.1 添加属性 condiments， 列表类型，默认为空列表
# 5.2 修改 __str__ 返回信息，返回增加已添加的佐料信息
# 5.3 定义 add_condiments(self, temp), temp为添加什么佐料的参数
    # 5.3.1 佐料列表追加元素
# 5.4 再次测试代码，添加佐料，重新打印信息

"""

# SweetPotato 类的设计
#     地瓜有两个属性：
#         状态 state：字符串
#         烧烤总时间 cooked_time：整数


class SweetPotato(object):

    # 1. 定义__init__方法，添加2个属性
    def __init__(self):
        # 1.1 默认状态state是生的
        self.state = "生的"
        # 1.2 默认时间cooked_time是0
        self.cooked_time = 0
        # 5.1 添加属性 condiments， 列表类型，默认为空列表
        self.condiments = []

    # 2. 定义__str__方法
    def __str__(self):
        # 2.1 返回地瓜状态，烧烤总时间
        # 5.2 修改 __str__ 返回信息，返回增加已添加的佐料信息
        return f"地瓜状态: {self.state}, 烧烤总时间: {self.cooked_time} 分钟, 已添加的佐料信息: {self.condiments}"

    # 3. 定义 cook 方法, 提供参数 time 设置 本次烧烤的时间
    def cook(self, time):
        # 3.1 使用 本次烧烤时间 对 烧烤总时间 进行 累加
        self.cooked_time += time
        # 3.2 根据 烧烤总时间, 设置地瓜的状态：
        if 0 <= self.cooked_time < 3:
            #     [0, 3) -> 生的
            self.state = "生的"
        elif 3 <= self.cooked_time < 6:
            #     [3, 6) -> 半生不熟
            self.state = "半生不熟"
        elif 6 <= self.cooked_time < 8:
            #     [6, 8) -> 熟了
            self.state = "熟了"
        elif self.cooked_time >= 8:
            #     大于等于8 -> 烤糊了
            self.state = "烤糊了"

    # 5.3 定义 add_condiments(self, temp), temp为添加什么佐料的参数
    def add_condiments(self, temp):
        # 5.3.1 佐料列表追加元素
        self.condiments.append(temp)


# 5.4 再次测试代码，添加佐料，重新打印信息
sp = SweetPotato()
print(sp)

sp.cook(2)
sp.add_condiments("蜜糖")
print(sp)

sp.cook(3)
sp.add_condiments("孜然")
print(sp)

sp.cook(2)
sp.add_condiments("烧烤酱")
print(sp)

5.【应用】搬家具

5.1. 搬家具普通版本
  • """
家具类 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. 房子添加家具, 输出 房子信息
"""


# 家具类 Item
class Item(object):
    # 1. 定义__init__方法，添加2个属性，需要2个形参 _type, _area
    def __init__(self, _type, _area):
        # 1.1 家具类型 type
        self.type = _type
        # 1.2 家具面积 area
        self.area = _area

    # 2. 实现__str__方法
    def __str__(self):
        # 2.1 返回家具类型和家具面积
        return f"家具类型: {self.type} 家具面积: {self.area}"


# 房子类 Home
class Home(object):
    # 1. 定义__init__方法，添加3个属性，需要3个形参
    def __init__(self, _address, _area, _free_area):
        # 1.1 地址 address
        self.address = _address
        # 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("家具添加失败, 再买一个大的房子")


tv = Item("超大电视机", 20)
print(tv)

h = Home("北京一环四合院", 160, 160)
print(h)

h.add_item(tv)
print(h)
5.2. 搬家具拓展版本

  • 搬家具案例的实现思路：

    """
家具类 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. 房子添加家具, 输出 房子信息

输出房子时，显示包含的所有家具的类型
# a. Home类中添加 item_type_list 属性(家具类型列表)，用于记录所有家具类型
# b. Home类的 add_item 方法中, 将添加成功的 家具类型 添加到 item_type_list 中
# c. Home类的 __str__ 方法中, 打印家具的类型列表
"""

  • 代码

  • """
家具类 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. 房子添加家具, 输出 房子信息

输出房子时，显示包含的所有家具的类型
# a. Home类中添加 item_type_list 属性(家具类型列表)，用于记录所有家具类型
# b. Home类的 add_item 方法中, 将添加成功的 家具类型 添加到 item_type_list 中
# c. Home类的 __str__ 方法中, 打印家具的类型列表
"""


# 家具类 Item
class Item(object):
    # 1. 定义__init__方法，添加2个属性，需要2个形参 _type, _area
    def __init__(self, _type, _area):
        # 1.1 家具类型 type
        self.type = _type
        # 1.2 家具面积 area
        self.area = _area

    # 2. 实现__str__方法
    def __str__(self):
        # 2.1 返回家具类型和家具面积
        return f"家具类型: {self.type} 家具面积: {self.area}"


# 房子类 Home
class Home(object):
    # 1. 定义__init__方法，添加3个属性，需要3个形参
    def __init__(self, _address, _area, _free_area):
        # 1.1 地址 address
        self.address = _address
        # 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("家具添加失败, 再买一个大的房子")


tv = Item("超大电视机", 20)
print(tv)

h = Home("北京一环四合院", 160, 160)
print(h)

h.add_item(tv)
print(h)

i = Item("超级大床", 40)
print(i)

h.add_item(i)
print(h)
Sql_Boy_A_Liang
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python面向对象实验报告_Python 面向对象 | 菜鸟教程
weixin_33966205的博客
01-13 2729
Python 面向对象Python从设计之初就已经是一门面向对象的语言，正因为如此，在Python中创建一个类和对象是很容易的。本章节我们将详细介绍Python的面向对象编程。如果你以前没有接触过面向对象的编程语言，那你可能需要先了解一些面向对象语言的一些基本特征，在头脑里头形成一个基本的面向对象的概念，这样有助于你更容易的学习Python的面向对象编程。接下来我们先来简单的了解下面向对象的一些基...
python 面向对象全面详解
热门推荐
日入上万
01-12 5万+
目录   一、对面向对象的理解 1、面向对象的编程---object oriented programming 2、python面向对象的重要术语： 3、函数和面向对象编程的区别 二、封装、继承、多态 1、封装（Encapsulation） 2、继承（Inheritance） 3、多态（Polymorphism） 三、面向对象的各种方法 1、静态方法  (用这个装饰器来表示 ...
2021-02-13
m0_53644843的博客
02-13 131
类与对象相关案例烤地瓜即知识点注意事项 # 定义地瓜类:初始化属性，被考和添加调料的方法，显示对象信息的str魔法方法 class SweetPotato: # 遵循大驼峰原则，class 类名():类里面有特征属性和行为为方法类可以实例化对象 def __init__(self): # __init__(self):是魔法方法定义后不用专门调用self指代对象 self.time = 0 self.state = '生的'
编程思想
weixin_46072106的博客
11-24 279
1. 简介 1. 面向过程 顾名思义，关注过程，步骤，顺序 需求1：小明起床上学 思路： 起床，穿衣，洗漱，上学 有步骤，顺序，需要自己亲力亲为 需求2：吃饭 思路： 买菜，洗菜，煮饭，切菜，煮/炒菜，吃饭 有步骤，顺序，需要自己亲力亲为 1.1 定义 把编程任务划分成一个一个的步骤，然后按照步骤分别去执行。 以 小明起床上学 为例，面向过程则做了如下 4 件事：起床、穿衣、洗漱、上学，这 4 个过程的顺序很重要，须一个一个地实现。 1.2 特点 需要实现一个功能的时候，看重的是
面向对象综合案例（1）——烤地瓜
weixin_45440341的博客
07-02 323
'''' 5.1 烤地瓜 5.1.1需求 1.被烤时间和对应的地瓜状态 0-3分钟：生的 3-5分钟：半生不熟 5-8分钟：数的 超过8分钟：半生不熟 2.添加的调料 用户可以按照自己的意愿添加调料 ''' #1、定义地瓜类 ：初始化属性、被烤和添加调料的方法、显示对象信息的str class SweetPotato(): def __init__(self):#初始化 #
Python基础-面向对象编程之装饰器
hubing_hust的专栏
11-26 1万+
函数、方法或类定义的前面可以使用一个特殊的符号，称为装饰器，其目的是修改定义后面的行为。
Python基础—面向对象(超详版)
weixin_50804299的博客
03-14 1万+
面向对象是一种编程范式，它将程序中的数据和操作封装在一个对象中，从而使得程序更加模块化、可重用和易于维护。在面向对象编程中，对象是类的实例化，类是一种抽象的数据类型，它定义了一组属性和方法。面向对象编程的核心思想是封装继承和多态。封装是将数据和操作封装在一个对象中，隐藏对象的内部实现细节，只暴露必要的接口给外部访问。继承是通过继承父类的属性和方法，来创建一个新的子类，子类可以重写父类的属性和方法，从而实现更加灵活的功能。多态是指同一个方法可以根据不同对象的实现方式，实现不同的行为。
Python面向对象详解（非常详细）
ZTLJQ的博客
04-21 2万+
面向对象编程（Object-Oriented Programming，OOP）是一种常用的编程思想，它强调万物皆对象，因此在编程时我们可以将现实世界中的事物抽象成程序中的对象，从而更好实现软件的设计与开发。与传统的基于函数的编程不同，面向对象编程注重于将数据与行为封装在一起，即对象既包含数据状态，还包含可调用的行为方法。面向对象编程的特点在于，它具有封装、继承和多态三大特性。封装意味着将对象的状态和行为进行封装，使其对外只暴露必要的接口，从而提高了安全性和可维护性；
Python 面向对象编程详解
CSDN
08-04 6531
面向对象,OOP英文全称(Object-Oriented Programming)是一种高效的编程思路,面向对象技术已经成为当今软件设计和开发领域的主流技术,面向对象编程是一种编程方式,使用 "类" 和 "对象" 来实现,所以面向对象编程其实就是对 "类" 和 "对象" 的使用,类就是一个模板,模板里可以包含多个方法(函数),方法里实现各种各样的功能,对象则是根据模板创建的实例,通过实例对象可以执行类中的方法,每个对象都拥有相同的方法,但各自的数据可能不同.
Python面向对象编程基础之面向对象思想和特点、类和对象
master_hunter的博客
06-08 2219
面向对象是一种看待事物的思想，一种视觉角度，分析方式，我们可以把任意一个事物看成是一个对象，分析它身上具备的主要特征，这个就是面向对象思维；这样的思维方式很像数据库中的E-R图，将一种事物的特征、属性和行为给分离出来。我们一般写代码都是从开始到结束呈线性流程化模式写完整个程序，这种思想是典型的面向过程思想。而在写代码中面向对象编程，是将执行这些步骤时，把开发时要实现的功能提取出来，分成很多个小模块自定义函数去实现这些功能，而主体函数则去想使用这些自定义函数实现功能后如何运用。举个例子，就像我们打英雄联盟：面
面向对象编程基础_python面向对象_python教程_
09-29
下面我们将深入探讨Python中的面向对象编程基础。 一、类与对象 1. **类（Class）**：类是面向对象编程的基础，它是创建对象的模板。在Python中，我们通过定义class关键字来创建一个类。例如： ```python class...
01_Python基础_python课件_python基础_
09-30
【Python基础】是编程语言学习的入门阶段，Python因其语法简洁、易读性强而深受初学者喜爱。在Python课程中，通常会涵盖以下几个核心知识点： 1. **变量与数据类型**：Python支持多种数据类型，如整型（int）、浮点...
python基础05_python面向对象
08-18
面向对象是Python编程中的核心概念，它是一种编程范式，旨在通过模拟现实世界中的对象来组织和管理代码。在Python中，面向对象编程主要涉及类（Class）和对象（Object）的概念。 首先，Python支持三种主要的编程...
老齐零基础学python_python_python基础_
10-01
7. **面向对象编程**：解释面向对象编程的基本概念，如类、对象、继承、封装和多态，并给出实例演示如何创建和使用这些概念。 8. **文件操作**：如何打开、读取、写入和关闭文件，以及处理文件和目录的相关操作。 ...
【python计算机视觉编程——1.基本的图像操作和处理】
最新发布
m0_53694086的博客
08-26 782
参数sigma为标准差（σ），是高斯滤波器的一个重要参数，它控制滤波器的平滑程度。标准差越大，高斯函数的曲线越宽，滤波器的影响范围就越大。标准差较大: 高斯滤波器会在更大范围内进行平滑，使得图像变得更加模糊，细节和边缘特征会被更强地平滑掉。标准差较小: 高斯滤波器会产生较小范围的平滑效果，图像的细节保留更多。还可以给定转换矩阵，将RGB图像转换为CIE XYZ色彩空间。图像像素值被分成128个区间，用于计算每个区间的像素值频率。可以返回目录中所有jpg图像的列表。
Python优化算法09——黏菌优化算法(SMA)
weixin_46277779的博客
08-24 836
python黏菌优化算法代码和使用
【pip镜像设置】pip使用清华镜像源安装
前端探索者
08-21 2669
PyPI的镜像站点是用于加速Python包下载的服务器，它们提供了与官方PyPI相同的内容，但可能会因为地理位置更近而下载速度更快。进行python 的第三方库安装，但是，有时会出现。使用了清华大学的镜像网站。
【Python】Pydantic：快速上手
2303_80346267的博客
08-22 1118
Pydantic 是一个用于数据验证和设置管理的 Python 库，基于 Python 类型提示构建。它通过创建数据模型类并使用类型提示进行数据验证，使得数据的验证和解析变得简单而可靠，广泛应用于数据模型的定义和验证，特别是在构建 API 时。
python 基础 __
07-27
Python基础主要包括以下内容： 1. 数据类型：Python支持多种数据类型，包括整数、浮点数、字符串、布尔值、列表、元组、字典等。 2. 变量和赋值：在Python中，可以使用变量来存储数据，并通过赋值操作给变量赋值。 3. 运算符：Python提供了丰富的运算符，包括算术运算符、比较运算符、逻辑运算符等。 4. 条件语句：使用条件语句（如if语句）根据条件来执行不同的代码块。 5. 循环语句：使用循环语句（如for循环和while循环）来重复执行一段代码。 6. 函数：可以使用函数来封装一段可重用的代码，并通过函数名调用执行。 7. 模块和包：Python通过模块和包的方式组织代码，提高代码的可维护性和复用性。 8. 异常处理：可以使用异常处理机制来捕获和处理程序中出现的异常情况。 9. 文件操作：可以通过文件操作来读取和写入文件中的数据。 10. 面向对象编程：Python是一种面向对象的编程语言，支持类、对象、继承等概念。 这些是Python基础的主要内容，掌握这些知识可以进行基本的编程工作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值