面向对象(二、基础语法)

面相对象的基础语法

---

01. dir内置函数

---

其实Pyhton中变量、数据、函数等都是对象，两个方法验证： 1、在该 标识符 后输入一个 . ，看PyCharm会不会提示有方法，或者在iPython中按下Tab键，是否提示有方法 2、使用内置函数dir传入该 标识符，可以查看对象内所有属性及方法
提示 __方法名__ 格式的方法是 Python 提供的 内置方法 / 属性，稍后会给大家介绍一些常用的 内置方法 / 属性

序号	方法名	类型	作用
01	__new__	方法	创建对象时，会被 自动 调用
02	__init__	方法	对象被初始化时，会被 自动 调用
03	__del__	方法	对象被从内存中销毁前，会被 自动 调用
04	__str__	方法	返回对象的描述信息，print 函数输出使用

面向对象是一个更大的封装，在一个类中封装多个方法，这样通过这个类创建出来的对象，就可以直接调用这些方法了

• 定义只包含方法的类

定义类(与Java类似)
​
class 类名：
​
    def 方法1(self,参数列表):
​
        pass
    
    def 方法2(self,参数列表):
        pass

• 方法的定义格式和之前的函数几乎一样
• 区别就是第一个参数必须是self

1.1 创建对象

• 对象名=类名()

案例

• 需求：小猫爱吃鱼，小猫在喝水

class Cat:
    """定义一个猫类"""
    
    def eat(self):
        print("小猫爱吃鱼")
        
    def drink(self):
        print("小猫在喝水")
​
tom = Cat()
tom.eat()
tom.drink()

面向对象中的引用概念

Python中使用类创建对象之后，对象名指向的是对象在内存中的地址，即对象名指向了对象的地址 如果使用print函数输出对象名，可以看到该对象名引用的对象来自于哪一个类，以及在内存中的地址（十六进制） %d可以以十进制输出数字；%x可以以十六进制输出数字

方法中的self参数 给对象设置属性，可以直接 对象名.属性=“值” （但是不推荐使用，作为了解；因为属性最好包含在类的内部） self指的是当前这个对象，要访问该对象的属性，可以 self.属性；要访问该对象的属性，可以 self.方法

class Cat:
​
    def eat(self):
        print("%s 爱吃鱼" % self.name)
​
tom = Cat()
tom.name = "Tom"
tom.eat()

之前代码存在的问题 —— 在类的外部给对象增加属性

• 将案例代码进行调整，先调用方法 再设置属性，观察一下执行效果

tom = Cat()
tom.drink()
tom.eat()
tom.name = "Tom"
print(tom)

• 程序执行报错如下：

AttributeError: 'Cat' object has no attribute 'name'
属性错误：'Cat' 对象没有 'name' 属性

提示

• 在日常开发中，不推荐在类的外部给对象增加属性
  • 如果在运行时，没有找到属性，程序会报错
• 对象应该包含有哪些属性，应该 封装在类的内部

1.2 初始化方法

• 当使用类名()创建对象时，会自动执行以下操作：
  1. 为对象在内存中 分配空间 —— 创建对象
  2. 为对象的属性 设置初始值 —— 初始化方法(init)
• 这个 初始化方法 就是 __init__ 方法，__init__ 是对象的内置方法

__init__ 方法是 专门 用来定义一个类 具有哪些属性的方法！

在 Cat 中增加 __init__ 方法，验证该方法在创建对象时会被自动调用

class Cat:
    """这是一个猫类"""
​
    def __init__(self):
        print("初始化方法")

1.3 在初始化方法内部定义属性

• 在 __init__ 方法内部使用 self.属性名 = 属性的初始值 就可以 定义属性
• 定义属性之后，再使用 Cat 类创建的对象，都会拥有该属性

class Cat:
​
    def __init__(self):
​
        print("这是一个初始化方法")
        
        # 定义用 Cat 类创建的猫对象都有一个 name 的属性
        self.name = "Tom"
​
    def eat(self):
        print("%s 爱吃鱼" % self.name)
​
# 使用类名()创建对象的时候，会自动调用初始化方法 __init__
tom = Cat()
​
tom.eat()

1.4 改造初始化方法 —— 初始化的同时设置初始值

• 在开发中，如果希望在创建对象的同时，就设置对象的属性，可以对__init__方法进行改造
  1. 把希望设置的属性值，定义成 __init__ 方法的参数
  2. 在方法内部使用 self.属性 = 形参 接收外部传递的参数
  3. 在创建对象时，使用 类名(属性1, 属性2...) 调用

class Cat:
​
    def __init__(self, name):
        print("初始化方法 %s" % name)
        self.name = name
    ...
    
tom = Cat("Tom")
...
​
lazy_cat = Cat("大懒猫")
...

02. 内置方法和属性

---

序号	方法名	类型	作用
01	__del__	方法	对象被从内存中销毁前，会被 自动 调用
02	__str__	方法	返回对象的描述信息，print 函数输出使用

2.1 __del__ 方法（知道）

• 在 Python 中
  • 当使用 类名() 创建对象时，为对象 分配完空间后，自动 调用 __init__ 方法
  • 当一个 对象被从内存中销毁 前，会 自动 调用 __del__ 方法
• 应用场景
  • __init__ 改造初始化方法，可以让创建对象更加灵活
  • __del__ 如果希望在对象被销毁前，再做一些事情，可以考虑一下 __del__ 方法
• 生命周期
  • 一个对象从调用 类名() 创建，生命周期开始
  • 一个对象的 __del__ 方法一旦被调用，生命周期结束
  • 在对象的生命周期内，可以访问对象属性，或者让对象调用方法

class Cat:
​
    def __init__(self, new_name):
​
        self.name = new_name
​
        print("%s 来了" % self.name)
​
    def __del__(self):
​
        print("%s 去了" % self.name)
​
# tom 是一个全局变量
tom = Cat("Tom")
print(tom.name)
​
# del 关键字可以删除一个对象
del tom
​
print("-" * 50)

2.2 __str__ 方法

• 在 Python 中，使用 print 输出 对象变量，默认情况下，会输出这个变量 引用的对象 是 由哪一个类创建的对象，以及 在内存中的地址（十六进制表示）
• 如果在开发中，希望使用 print 输出 对象变量 时，能够打印 自定义的内容，就可以利用 __str__ 这个内置方法了

注意：__str__ 方法必须返回一个字符串

• 案例

class Cat:
​
    def __init__(self, new_name):
​
        self.name = new_name
​
        print("%s 来了" % self.name)
​
    def __del__(self):
​
        print("%s 去了" % self.name)
​
    def __str__(self):
        return "我是小猫：%s" % self.name
​
tom = Cat("Tom")
print(tom)

注意：str方法需要返回字符串

03. 面向对象封装

---

封装

1. 封装 是面向对象编程的一大特点
2. 面向对象编程的 第一步 —— 将 属性 和 方法 封装 到一个抽象的 类 中
3. 外界 使用 类 创建 对象，然后 让对象调用方法
4. 对象方法的细节 都被 封装 在 类的内部

案例1

---

小明爱跑步

需求

1. 小明 体重 75.0 公斤
2. 小明每次 跑步 会减肥 0.5 公斤
3. 小明每次 吃东西 体重增加 1 公斤
   

提示：在 对象的方法内部，是可以 直接访问对象的属性 的！

• 代码实现：

class Person:
    """人类"""
​
    def __init__(self, name, weight):
​
        self.name = name
        self.weight = weight
​
    def __str__(self):
​
        return "我的名字叫 %s 体重 %.2f 公斤" % (self.name, self.weight)
​
    def run(self):
        """跑步"""
​
        print("%s 爱跑步，跑步锻炼身体" % self.name)
        self.weight -= 0.5
​
    def eat(self):
        """吃东西"""
​
        print("%s 是吃货，吃完这顿再减肥" % self.name)
        self.weight += 1
​
​
xiaoming = Person("小明", 75)
​
xiaoming.run()
xiaoming.eat()
xiaoming.eat()
​
print(xiaoming)

案例2

---

摆放家具

需求

• 房子(House)有户型、总面积和家具名称列表
  1. 新房子没有任何的家具
• 家具(HouseItem)有名字和占地面积，其中
  1. 席梦思(bed) 占地 4 平米
  2. 衣柜(chest) 占地 2 平米
  3. 餐桌(table) 占地 2.5 平米
• 将以上三件 家具 添加 到 房子 中
• 打印房子时，要求输出：户型、总面积、剩余面积、家具名称列表
  

剩余面积

1. 在创建房子对象时，定义一个 剩余面积的属性，初始值和总面积相等
2. 当调用 add_item 方法，向房间 添加家具 时，让 剩余面积 -= 家具面积

实现过程：

1、创建家具

class HouseItem:
​
    def __init__(self, name, area):
        """
​
        :param name: 家具名称
        :param area: 占地面积
        """
        self.name = name
        self.area = area
​
    def __str__(self):
        return "[%s] 占地面积 %.2f" % (self.name, self.area)
​
​
# 1. 创建家具
bed = HouseItem("席梦思", 4)
chest = HouseItem("衣柜", 2)
table = HouseItem("餐桌", 1.5)
​
print(bed)
print(chest)
print(table)

小结

1. 创建了一个 家具类，使用到 __init__ 和 __str__ 两个内置方法
2. 使用 家具类 创建了 三个家具对象，并且 输出家具信息

2、创建房间

class House:
​
    def __init__(self, house_type, area):
        """
​
        :param house_type: 户型
        :param area: 总面积
        """
        self.house_type = house_type
        self.area = area
        
        # 剩余面积默认和总面积一致
        self.free_area = area
        # 默认没有任何的家具
        self.item_list = []
​
    def __str__(self):
​
        # Python 能够自动的将一对括号内部的代码连接在一起
        return ("户型：%s\n总面积：%.2f[剩余：%.2f]\n家具：%s"
                % (self.house_type, self.area,
                   self.free_area, self.item_list))
​
    def add_item(self, item):
​
        print("要添加 %s" % item)
​
...
​
# 2. 创建房子对象
my_home = House("两室一厅", 60)
​
my_home.add_item(bed)
my_home.add_item(chest)
my_home.add_item(table)
​
print(my_home)

小结

1. 创建了一个 房子类，使用到 __init__ 和 __str__ 两个内置方法
2. 准备了一个 add_item 方法 准备添加家具
3. 使用 房子类 创建了 一个房子对象
4. 让 房子对象 调用了三次 add_item 方法，将 三件家具 以实参传递到 add_item 内部

3、添加家具
需求

• 1> 判断 家具的面积 是否 超过剩余面积，如果超过，提示不能添加这件家具
• 2> 将 家具的名称 追加到 家具名称列表 中
• 3> 用 房子的剩余面积 - 家具面积

 def add_item(self, item):
​
        print("要添加 %s" % item)
        # 1. 判断家具面积是否大于剩余面积
        if item.area > self.free_area:
            print("%s 的面积太大，不能添加到房子中" % item.name)
​
            return
​
        # 2. 将家具的名称追加到名称列表中
        self.item_list.append(item.name)
​
        # 3. 计算剩余面积
        self.free_area -= item.area

小结

• 主程序只负责创建 房子 对象和 家具 对象
• 让 房子 对象调用 add_item 方法 将家具添加到房子中
• 面积计算、剩余面积、家具列表 等处理都被 封装 到 房子类的内部

感谢各位读者的观看，要是觉得写的不错请多给点赞哈，增加一点动力后期会加快更新内容的速度