程序员是要讲求生产力的,一天的练习,晚上再回顾一下.

类和对象*

1
2
3
4
5
6
7
8
9
10
11
12
13
# 定义类
class Washer():
    # 定义方法
    def wash(self):
        print("我会洗衣服")
        print(self)  # 相当于直接打印函数的地址

# 创建对象
haier1 = Washer()
# 打印函数在内存中的地址
print(haier1)
# 调用函数中的方法
haier1.wash()

添加和获取对象的属性

1
2
3
4
5
6
7
8
9
10
11
12
# 定义类
class Washer():
    # 定义方法
    def print_info(self):
        print(f"洗衣机的宽度是{self.width}")
        print(f"洗衣机的高度是{self.height}")

# 创建对象
haier = Washer()
haier.height=100
haier.width = 50
haier.print_info()

init 方法,初体验

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Washer():
    # 定义初始化功能的函数
    def __init__(self):
        self.width = 50
        self.height = 100

    def print_info(self):
        # 在类里面调用实例属性
        print(f"洗衣机的高度是{self.height},洗衣机的宽度是{self.width}")

# 创建对象
haier = Washer()
print(haier.height,haier.width)
haier.print_info()

带参数的init方法(动态传递参数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Washer():
    # 定义带参数的初始化方法
    def __init__(self, width, height):
        self.width = width
        self.height = height
    # 定义打印方法
    def print_info(self):
        # 打印传递的参数
        print(f"洗衣机的高度是{self.height}宽度是{self.width}")

# 定义对象
haier = Washer(50, 100)  # 也可以Washer(width = 50, height = 100)
# 调用方法
haier.print_info()

魔术方法

str()方法

当使用print输出对象的时候，默认打印对象的内存地址。
如果类定义了__str__方法，那么就会打印从在这个方法中 return 的数据。

1
2
3
4
5
6
7
8
9
10
11
12
class Washer():
    # 定义函数初始化功能的函数,方便动态传递参数
    def __init__(self, width, height):
        self.width = width
        self.height = height
    def __str__(self):
        return f"这是haier洗衣机的说明书: 高度{self.height} 宽度{self.width}"

# 定义对象
haier = Washer(50, 100)
# 打印对象的内存地址,这里因为使用了魔术方法str,所以会打印str方法中返回值
print(haier)

del()方法

1
2
3
4
5
6
7
8
9
10
class Washer():
    def __init__(self, width, height):
        self.width = width
        self.height = height
    def __del__(self):
        print(f"{self}方法已经删除")
# 定义对象
haier = Washer(50, 100)
# 删除方法
del haier

案例1 烤地瓜

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
class SweetPotato():
    # 定义烤地瓜的状态
    def __init__(self):
        # 烧烤的时间
        self.cook_time = 0
        # 地瓜的状态
        self.cook_static = '生的'
        # 调料列表(是用列表来存储要添加的调料
        self.condiments = []

    # 定义烤地瓜的方法
    def cook(self, time):
        self.cook_time += time
        if 0 <= self.cook_time < 3:
            self.cook_static = '生的'
        elif 3 <= self.cook_time < 5:
            self.cook_static = '半生不熟'
        elif 5 <= self.cook_time < 8:
            self.cook_static = '熟了'
        elif self.cook_time >= 8:
            self.cook_static = '烤糊了'

    # 定义_str_()魔术方法,自定义打印输出
    def __str__(self):
        return f"这个地瓜烤了{self.cook_time}分钟,状态是{self.cook_static},添加的调料有{self.condiments}"

    # 定义添加调料的方法
    def add_condiment(self,condiments1,condiments2):
        self.condiments.append(condiments1)
        self.condiments.append(condiments2)

# 创建对象
potato = SweetPotato()
# 打印对象的地址(有了魔术方法就直接打印魔术方法中的内容)
potato.cook(2)
potato.add_condiment("酱油", "辣椒面")
print(potato)

案例2 搬家具

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
class Furniture():
    # 定义带有动态传递参数的初始化功能函数
    def __init__(self, name, area):
        # 家具名字
        self.name = name
        # 家具占地面积
        self.area = area


class House():
    # 定义带有动态传递参数的初始化功能函数
    def __init__(self, location, area):
        # location = address
        # 地理位置
        self.location = location
        # 占地面积
        self.area = area
        # 剩余面积
        self.free_area = area
        # 家具列表
        self.furniture = []
    # 定义魔术方法,当调用对象的内存地址时候就会打印这里面的返回值
    def __str__(self):
        return f"房子的地理位置为{self.location},占地面积为{self.area},剩余面积为{self.free_area},家具列表为{self.furniture}"

    # 添加家具方法
    def add_furniture(self, item):
        # 判断家中的剩余面积是否大于家具所占面积,大于则能插入
        if self.free_area > item.area:
            self.furniture.append(item.name)
            self.free_area -= item.area
        else:
            print("家具太大,剩余面积不足,无法容纳!")

bed = Furniture('双人床', 6)
home = House('北京', 1200)
print(home)
home.add_furniture(bed)
print(home)