面向对象

  • 一、理解面向对象
  • 二、类+对象
  • 2.1 理解类和对象
  • 2.1.1 类
  • 2.1.2 对象
  • 2.2 面向对象实现方法
  • 2.2.1 定义类
  • 2.2.2 创建对象
  • 2.2.3 self
  • 三、添加和获取对象属性
  • 3.1 类外面添加对象属性
  • 3.2 类外面获取对象属性
  • 3.3 类里面获取对象属性
  • 四、魔法方法
  • 4.1 `__init__()`
  • 4.1.1 体验 `__init__()`
  • 4.1.2 带参数的 `__init__()`
  • 4.2 __str__()
  • 4.3 __del__()
  • 五、综合应用
  • 5.1 烤地瓜
  • 5.1.1 需求
  • 5.1.2 步骤分析
  • 5.1.2.1 定义类
  • 5.1.3 代码实现
  • 5.1.3.1 定义类
  • 5.1.3.2 定义烤地瓜方法
  • 5.1.3.3 书写str魔法方法，用于输出对象状态
  • 5.1.3.4 创建对象，测试实例属性和实例方法
  • 5.1.3.5 定义添加调料方法，并调用该实例方法
  • 5.2 搬家具
  • 5.2.1 需求
  • 5.2.2 步骤分析
  • 5.2.2.1 定义类
  • 5.2.2.2 创建对象并调用相关方法
  • 5.2.3 代码实现
  • 5.2.3.1 定义类


一、理解面向对象

面向对象是一种抽象化的编程思想，很多编程语言中都有的一种思想。

面向对象是将编程当成是一个事物，对外界来说，事物是直接使用的，不用去管他内部的情况。而编程就是设置事物能够做什么事。

二、类+对象

思考：洗衣机洗衣服描述过程中，洗衣机其实就是一个事物，即对象，洗衣机对象哪来的呢？
答：洗衣机是由工厂工人制作出来
思考：工厂工人怎么制作出的洗衣机？
答：工人根据设计师设计的功能图纸制作洗衣机
总结：图纸→洗衣机→洗衣服

在面向对象编程过程中，有2个重要组成部分：类+对象
类和对象的关系：用类去创建一个对象

2.1 理解类和对象

2.1.1 类

类是对一系列具有相同特征和行为的事物的统称，是一个抽象的概念，不是真实存在的事物。

  • 特征即是属性
  • 行为即是方法

类比如是制造洗衣机时，要用到的图纸，也就是说，类是用来创建对象。

2.1.2 对象

对象是类创建出来的真实存在的事物，例如：洗衣机。

注意：开发中，先有类，后有对象。

2.2 面向对象实现方法

2.2.1 定义类

Python2中类分为 经典类+新式类

  • 语法
class 类名（）：
    代码
    ......

注意：类名要满足标识符命名规则，同时遵循大驼峰命名习惯。

2.2.2 创建对象

对象，又名 实例。

  • 语法
对象名 = 类名（）
  • 体验
# 需求：洗衣机 功能：能洗衣服
# 1. 定义洗衣机类
"""
class 类名（）：
    代码
"""


class Washer():
    def wash(self):
        print('能洗衣服')


# 2. 创建对象
# 对象名 =  类名（）
haier = Washer()

# 3. 成果
# 打印haier对象
print(haier)

# 使用wash功能 -- 实例方法/对象方法 -- 对象名.Wash()
haier.wash()

2.2.3 self

self 指的是调用该函数的对象。

# 类：洗衣机  功能：洗衣服
class Washer():
    def wash(self):
        print('洗衣服')
        print(self)

haier = Washer()
print(haier)

haier.wash()

# 总结：由于打印对象和打印self得到的内存地址相同，所以self指的是调用该函数的对象

体验

# 1. 一个类可以创建多个对象
# 2. 多个对象都调用函数的时候，self地址是否相同  --- 不相同

class Washer():
    def wash(self):
        print('洗衣服')
        print(self)


haier1 = Washer()  # <__main__.Washer object at 0x000001E010E48E10>
haier1.wash()

haier2 = Washer()
haier2.wash()

三、添加和获取对象属性

属性即是特征，比如：洗衣机的宽度、高度、重量…
对象属性既可以在类外面添加和获取，也能在类里面添加和获取。

3.1 类外面添加对象属性

  • 语法
对象名.属性名 = 值
  • 体验
class Washer():
    def wash(self):
        print('洗衣服')


haier1 = Washer()

# 添加对象属性   对象名.属性名 = 值
haier1.width = 400
haier1.height = 500

3.2 类外面获取对象属性

语法

对象名.属性名

体验

class Washer():
    def wash(self):
        print('洗衣服')


haier1 = Washer()

# 添加对象属性   对象名.属性名 = 值
haier1.width = 400
haier1.height = 500

# 获取对象属性---语法： 对象名.属性名
print(f'洗衣机的宽度是{haier1.width}')
print(f'洗衣机的高度是{haier1.height}')

3.3 类里面获取对象属性

语法

self.属性名

体验

class Washer():
    def wash(self):
        print('洗衣服')
     # 获取对象属性
    def print_info(self):
         # self.属性名
         # print(self.width)
         print(f'洗衣机的宽度是{self.width}')
         print(f'洗衣机的高度是{self.height}')

haier1 = Washer()

# 添加对象属性   对象名.属性名 = 值
haier1.width = 400
haier1.height = 500
# 对象调用方法
haier1.print_info()

四、魔法方法

在Python中，__xx__()的函数叫做魔法方法，指的是具有特殊功能的函数。

4.1 __init__()

4.1.1 体验 __init__()

思考：洗衣机的宽度高度是与生俱来的属性，可不可以再生产过程中就赋予这些属性呢？
答：理应如此
__init__()方法的作用：初始化对象

注意

  1. __init__() 方法，在创建一个对象时，默认被调用，不需要手动调用
  2. __init__(self) 中的self参数，不需要开发者传递，python解释器会自动把当前的对象引用传递过去。
  3. __init__() 此语法中，每部分各2个下划线

体验

# 目标：定义init魔法方法，设置初始化属性，并访问调用
"""
1.定义类
   init魔法方法：width 和 height
   添加实例方法：访问实例属性
2.创建对象
3.验证成果
   调用实例方法
"""

class Washer():
    def __init__(self):
        # 添加实例属性
        self.width = 500
        self.height = 800
    def print_info(self):
         print(f'洗衣机的宽度是{self.width}')
         print(f'洗衣机的高度是{self.height}')

haier = Washer()
haier.print_info()

4.1.2 带参数的 __init__()

思考：一个类可以创建多个对象，如何对不同的对象设置不同的初始化属性呢？
答：传参数

# 1. 定义类：带参数的init：宽度和高度     实例方法:调用实例属性
class Washer():
    def __init__(self, width, height):
        self.width = width
        self.height = height
    def print_info(self):
        print(f'洗衣机的宽度是{self.width},洗衣机的高度是{self.height}')

# 2. 创建对象：创建多个对象且保证属性值不同，调用实例方法
haier1 = Washer(10, 20)
haier1.print_info()

haier2 = Washer(100, 200)
haier2.print_info()

4.2 str()

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

class Washer():
    def __init__(self):
        self.width = 300

    def __str__(self):
        return '解释说明；类的说明或对象状态的说明'

haier = Washer()
print(haier)

4.3 del()

当删除对象时，python解释器也会默认调用__del__()方法

class Washer():
    def __init__(self):
        self.width = 300

    def __del__(self):
        print('对象已经删除')

haier = Washer()

五、综合应用

5.1 烤地瓜

5.1.1 需求

需求主线：
1.被烤的时间和对应的地瓜状态：
0-3分钟 生的
3-5分钟 半生不熟的
5-8分钟 熟的
超过8分钟 烤糊了

2.添加的调料
用户可以按自己的意愿添加调料

5.1.2 步骤分析

需求涉及一个事物：地瓜，
因此案例涉及一个类：地瓜类

5.1.2.1 定义类
  1. 地瓜的属性
    被烤的时间
    地瓜的状态
    添加的调料
  2. 地瓜的方法
    被烤
    用户根据意愿设定每次烤地瓜的时间
    判断地瓜被烤的总时间是在哪个区间，修改地瓜的状态
    添加调料
    用户根据意愿设定添加的调料
    将用户添加的调料存储
  3. 显示对象信息

5.1.3 代码实现

5.1.3.1 定义类

地瓜属性
定义地瓜初始化属性，后期根据程序推进更新实例属性

5.1.3.2 定义烤地瓜方法
5.1.3.3 书写str魔法方法，用于输出对象状态
5.1.3.4 创建对象，测试实例属性和实例方法
5.1.3.5 定义添加调料方法，并调用该实例方法
# 1. 定义类：初始化属性，被烤和添加调料的方法，显示对象信息的str
class SweetPotato():
    def __init__(self):
        # 被烤时间
        self.cook_time = 0
        # 烤的状态
        self.cook_state = '生的'
        # 调料列表
        self.condiments = []
    def cook(self, time):
        """烤地瓜方法"""
        # 1. 先计算地瓜整体烤过的时间
        self.cook_time += time
        # 2. 用整体烤过的时间再判断地瓜的状态
        if 0 <= self.cook_time < 3:
            # 生的
            self.cook_state = '生的'
        elif 3 <= self.cook_time < 5:
            # 半生不熟
            self.cook_state = '半生不熟'
        elif 5 <= self.cook_time < 8:
            # 熟了
            self.cook_state = '熟了'
        elif self.cook_time >= 8:
            # 烤糊了
            self.cook_state = '烤糊了'
    def add_condiments(self,condiment):
        # 用户意愿的调料，追加到调料列表
        self.condiments.append(condiment)
    def __str__(self):
        return f'这个地瓜的被烤过的时间是{self.cook_time},状态是{self.cook_state},调料有{self.condiments}'
# 2. 创建对象并调用对应的实例方法
digua1 = SweetPotato()
print(digua1)
digua1.cook(2)
digua1.add_condiments('辣椒面儿')
print(digua1)

digua1.cook(2)
digua1.add_condiments('酱油')
print(digua1)

# 这个地瓜的被烤过的时间是0,状态是生的,调料有[]
这个地瓜的被烤过的时间是2,状态是生的,调料有['辣椒面儿']
这个地瓜的被烤过的时间是4,状态是半生不熟,调料有['辣椒面儿', '酱油']

5.2 搬家具

5.2.1 需求

将小于房子剩余面积的家具摆放到房子中

5.2.2 步骤分析

需求涉及两个事物：房子+家具，
因此案例涉及两个类：房子类+家具类

5.2.2.1 定义类
  1. 房子类

a.实例属性
1 房子地理位置
2 房子占地面积
3 房子剩余面积
4 房子内家具列表

b.实例方法
1 容纳家具

c. 显示房屋信息

  1. 家具类
    家具名称
    家具占地面积
5.2.2.2 创建对象并调用相关方法

5.2.3 代码实现

5.2.3.1 定义类

家具类

class Furniture():
    def __init__(self, name, area):
        self.name = name
        self.area = area

# 双人床 占地面积 6
bed = Furniture('双人床', 6)
sofa = Furniture('沙发', 10)

房子类

class Furniture():
    def __init__(self, name, area):
        self.name = name
        self.area = area

class Home():
    def __init__(self, address, area):
        # 地理位置
        self.address = address
        # 房屋面积
        self.area = area
        # 剩余面积
        self.free_area = area
        # 家具列表
        self.furniture = []
    def __str__(self):
        return f'房子地理位置在{self.address}, 房屋面积是{self.area}，剩余面积是{self.free_area}, 家具有{self.furniture}'
    def add_furniture(self, item):
        """"容纳家具"""
        # 如果 家具占地面积 <= 房子的剩余面积 可以搬入（家具列表添加家具名字数据并房子剩余面积更新：
        # 房屋剩余面积 - 该家具的占地面积
        # 否则：提示用户家具太大，剩余面积不足，无法容纳）
        if item.area <= self.free_area:
            self.furniture.append(item.name)
            self.free_area -= item.area
        else:
            print('提示用户家具太大，剩余面积不足，无法容纳')



# 双人床 占地面积 6
bed = Furniture('双人床', 6)
sofa = Furniture('沙发', 10)

# 房子1：北京， 1000
jia1 = Home('北京', 1000)
print(jia1)

jia1.add_furniture(bed)
print(jia1)

ball = Furniture('篮球场', 2000)
jia1.add_furniture(ball)
print(jia1)

# 运行结果
# 房子地理位置在北京, 房屋面积是1000，剩余面积是1000, 家具有[]
房子地理位置在北京, 房屋面积是1000，剩余面积是994, 家具有['双人床']
提示用户家具太大，剩余面积不足，无法容纳
房子地理位置在北京, 房屋面积是1000，剩余面积是994, 家具有['双人床']