自学python 进击之路 - 面向对象

1 概念介绍

• 面向过程：注重的过程，实现的细节 （函数）
• 面向对象：关注的是结果

2.类和对象

类和对象，是面向对象中非常重要的两个概念

• 类 类是泛指的，指代多个，是由对的抽象来的 ，在代码中，是通过关键字Class定义的

• 对象 对象是特指的，指代一个，是具体存在的 ，在代码中，对象是由类创建的

3.类的定义

# 在python中，定义类使用关键字class ， 语法如下
"""
object 是所有的类基类 ，即最初始的类
类名： 遵循大驼峰的命名规范
class 类名（object）：
类中的代码
"""


# 定义方式一 ，推荐
class Dog(object):
    pass


# 定义方式二
class Dog1:  # 括号中的内容可以不写
    pass


# 定义方式三
class Dog3:  # 括号也可以不写
    pass


"""
新式类：直接或者简接object的类 ，在python3中，所有的类默认继承object类，即python3中所有的类都是新式类
旧式类（经典类）： 已经过时，不推荐使用
"""

4.创建对象

# 定义类
class Dog(object):
    # 在类中定义的函数，称为方法，函数所有知识都可以使用
    def play(self):
        print('小狗快乐的拆家中....')


# 创建对象 变量  = 类名（）
dog = Dog()  # 创建一个对象，dog
print(id(dog))

dog1 = Dog()  # 创建一个对象 dog1
print(id(dog1))


# 可以使用对象调用类型中的方法 对象方法名（）
dog.play()
dog1.play()

5.类外部添加和获取对象属性

class Dog(object):
    def play(self):
        print('小狗快乐的拆家中...')


#  创建对象
dog = Dog()
dog.play()

# 给对象添加属性   对象.属性名 = 属性值
dog.name = '大黄'  # 给dog对象添加name 属性，属性值是 大黄
dog.age = 2    # 给dog对象提age属性，属性值是2


# 获取对象的属性值 对象.属性名
print(dog.name)
print(dog.age)


# 修改属性值 和添加一样，存在就是修改，不存在，就是添加
dog.age = 3  # age 属性已经存在，所以是修改属性值
print(dog.age)


dog1 = Dog()  # 新创建一个对象  dog1
dog1.name = '小白'
print(dog1.name)

6.类内部的操作属性

class Dog(object):
    # self 作为类中方法的第一个形参，在通过对象调用方法的时候。不需要手动的传递实参值 ，是python 解释器
    # 自动将调用用该方法的对象传递给self，所以self 这个形参代表的是对象
    def play(self):
        print(f'self: {id(self)}')
        print(f'小狗 {self.name} 在快乐的拆家中....')


# 创建对象
dog = Dog()
dog.name = '大黄'
print(f'dog: {id(dog)}')
dog.play()
print('_' * 30)
dog1 = Dog()
dog1.name = '小白'
print(f'dog1: {id(dog1)}') 
dog1.play()

7.魔法方法

7.1 init（）

调用时机：在创建对象之后会立即调用。 作用：

1. 用来对象添加熟性，给对象属性一个初始值（构造函数）
2. 代码的业务需求，每创建一个对象，都需要执行的代码可以写在__init__中 注意点：如果__init__方法中，有出了self 之外的形参，那么在创建的对象的时候，需要给额外的形参传递参值类名（实参）

class Dog(object):
    def __init__(self):  # self 是对象
        print('我是__init__方法，我被调用了')
        # 对象.属性名 = 属性值
        self.name = '小狗'


# 创建对象
# Dog()
dog = Dog()
print(dog.name)
dog1 = Dog()
print(dog1.name)

7.2 __str__()

调用时机 ：

1. print(对象)， 会自动调用 __str__ 方法， 打印输出的结果是__str__方法的返回值
2. str(对象） 类型装换，将自定义对象转换字符串的时候，会自定调用 应用：
3. 打印对象的时候，输出一些属性信息 2.需要将对象转换为字符串类型的时候 注意点： 方法必须返回一个字符串, 只有self 一个参数

class Dog(object):
    def __init__(self, name, age):
        # 添加属性
        self.name = name
        self.age = age

    def __str__(self):
        print('我是__str__, 我被调用了...')
        # 必须返回一个字符串
        return f'小狗的名字是{self.name}, 年龄是{self.age}'


# 创建对象
dog = Dog('大黄', 2)
print(dog)  # 没有定义 __str__方法,print（对象）默认输出对象的引用地址

str_dog = str(dog)

7.3 __del__

析构函数 调用时机: 对象在内存中被销毁删除的时候(引用计数为 0)会自动调用 del 方法 1. 程序代码运行结束,在程序运行过程中,创建的所有对象和变量都会被删除销毁 2. 使用 del 变量 , 将这个对象的引用计数变为 0.会自动调用 del 方法 应用场景: 对象被删除销毁的时候,要书写的代码可以写在 __del__中.一般很少使用

引用计数: 是 python 内存管理的一种机制, 是指一块内存,有多少个变量在引用,

1. 当一个变量,引用一块内存的时候,引用计数加 1
2. 当删除一个变量,或者这个变量不再引用这块内存.引用计数减 1
3. 当内存的引用计数变为 0 的时候,这块内存被删除,内存中的数据被销毁

class Dog(object):
    def __init__(self, name, age):
        # 添加属性
        self.name = name
        self.age = age

    def __str__(self):
        # 必须返回一个字符串
        return f'小狗的名字{self.name}, 年龄是{self.age}'

    def __del__(self):
        print(f'我是__del__方法，我被调用了, {self.name}被销毁了.....')


# 创建一个对象
# dog = Dog('大黄', 2)
# print(dog)
# dog1 = Dog('小白', 1)
# print(dog1)


dog = Dog('小花', 3)
dog2 = dog
print('第一次删除之前')
del dog
print('第一次删除之后')
print('第二啊删除之前')
del dog2
print('第二次删除之后')

案例 - 烤地瓜

类名: 地瓜类 Potato 属性: 状态 status='生的' 烧烤总时间 total_time = 0 方法: def cook(self, 烧烤时间): 计算烧烤的总时间 修改地瓜的状态的 pass 输出信息 __str__() 定义属性 __init__()

class Potato(object):
    def __init__(self):
        self.status = '生的'
        self.total_time = 0

    def cook(self, time):
        # 计算时间
        self.total_time += time
        # 修改地瓜的状态
        if self.total_time < 3:
            self.status = '生的'
        elif self.total_time < 6:
            self.status = '半生不熟的'
        elif self.total_time < 8:
            self.status = '熟了'
        else:
            self.status = '烤糊了'

    def __str__(self):
        return f'地瓜的状态<<{self.status}>>, 烧烤总时间为<{self.total_time}>'


# 创建对象
potato = Potato()
print(potato)
potato.cook(4)
print(potato)

案例-烤地瓜调料板块

class Potato(object):
    def __init__(self):
        self.status = '生的'
        self.total_time = 0
        self.name_list = []

    def cook(self, time):
        # 计算总时间
        self.total_time += time
        # 修改地瓜的状态
        if self.total_time < 3:
            self.status = '生的'
        elif self.total_time < 6:
            self.status = '半生不熟的'
        elif self.total_time < 8:
            self.status = '熟了'
        else:
            self.status = '烤糊了'

    def __str__(self):
        buf = ','.join(self.name_list)
        if self.name_list:
            return f'地瓜的状态<<{self.status}>>, 烧烤总时间为<{self.total_time}>, 调料有:{buf}'
        else:
            return f'地瓜的状态<<{self.status}>>, 烧烤总时间<{self.total_time}>, 还没有添加调料'

    def add(self, name):
        self.name_list.append(name)


# 创建对象
potato = Potato()
print(potato)
potato.add('油')
potato.cook(4)
potato.add('辣椒面')
print(potato)
potato.cook(3)
potato.add('孜然')
print(potato)

案例-搬家具

# 定义家具类 Furniture 类
class Furniture(object):
    def __init__(self, name, area):
        # 类型
        self.name = name
        # 面积
        self.area = area

    def __str__(self):
        return f'家具的类型<{self.name}>, 占地面积<{self.area}>平'


# 定义房子类
class House(object):
    def __init__(self, address, area):
        self.address = address
        self.h_area = area
        self.furniture_list = []
        self.free_area = area  # 房子的剩余面积

    def add_furniture(self, obj_furniture):
        """ 添加家具 obj_furniture : 家具类的对象"""
        if self.free_area > obj_furniture.area:
            self.furniture_list.append(obj_furniture)
            # 修改剩余面积
            self.free_area -= obj_furniture.area
            print(f'家具<{obj_furniture.name}>添加成功')
        else:
            print('添加失败，换个大房子吧')

    def __str__(self):
        return f'房子的地址为<{self.address}>, 占地面积为<{self.h_area}>, 剩余面积为{self.free_area}'


# 创建家具对象
bed = Furniture('豪华双人床', 15)
print(bed)

# 创建一个房子类对象
house = House('意大利农场', 100)
print(house)
house.add_furniture(bed)
print(house)