【Python】面向对象

面向对象

1.概述:

​ 编程思想, 对象为基础, 基于面向过程.

三大思想特点:

1. 把复杂的事情简单化

2. 把人们(程序员)从执行者变成指挥者.

3. 更符合人们的思考习惯.

   总结

   1.万物皆对象

   2.概述,特点,举例,总结四个方向描述什么是面向对象

2.三大特征 :封装,继承,多态

封装: 隐藏对象的属性和实现细节(方法), 仅对外提供公共的访问方式.

​ 通过私有化方式隐藏,公共的访问方式操作,因为函数也是封装,所以封装不单指的是私有

​ 封装保证了代码的安全性和复用性,但是增加了代码量

​ 格式:

__属性名
__方法名()
# 特点:只能在本类内部直接访问, 外界无法直接访问.必须通过 公共的访问方式实现.

继承:实际开发中, 我们发现多个类中的内容是相似的或者相同的, 每次写很麻烦, 针对于这种情况, 我们可以把这些相似的或者相同的内容抽取出来, 单独的放到1个类中(父类), 然后让那多个类(子类)和这个类产生关系, 这个关系就叫: 继承.

格式:

# 单继承
class 子类名(父类名):
	pass
#多继承
class 子类名(父类名1,父类名2):
	pass

好处是提升了代码的复用性和可维护性,缺点是会增加耦合性

开发原则:高内聚, 低耦合.(能自己搞定的事儿, 就不要从别的类中继承.)

方法重写:
​ 子类出现和父母一模一样的 属性 或者 方法时, 称之为: 重写, 也叫覆盖.

子类重写父类方法后, 如何访问父类的成员?

​ 1:父类名.父类方法名(self)

​ 2: super().父类方法名() (这种方式更适用于单继承,因为只能选中第一个继承的类)

多态:同一个事物, 在不同时刻 表现出来的不同形态, 状态. 如:水, 高温, 常温, 低温…

python因为是弱类型语言,所以多态是伪多态

好处是提高了代码的可维护性, 实现了 调用者 和 业务(被调用者)的分离.弊端是无法直接访问子类的特有成员.

前提:继承并方法重写,父类引用指向子类对象

父类型可以充当方法的形参类型, 这样可以接受其任意的子类对象,
实现 传入不同的子类, 达到不同的效果.

3.相关名词:

1.类:属性和行为的集合, 是一个抽象的概念, ,看不见, 摸不着.

2.对象:类的具体体现, 实现.

3.属性:名词, 描述事物的外在特征的.举例: 姓名, 年龄, 性别…

4.行为:动词, 表示事物能够做什么.举例: 吃饭, 睡觉, 学习…

4.基本格式:

class 类名:
    #属性
    .....
    #行为

如何调用类中的成员:

类内self.的方式

类外对象名.属性名/方法名

self 函数内有1个self变量, 谁调用函数, self就代表谁.Python内置的1个属性, 可以直接拿来用.

5.魔法方法:

__init__()
__str__()
__del__()

6.综合案例

1.手机类 2.电脑类

class phone:  # 定义一个名为phone的类，表示手机
   def open(self):  # 定义一个方法，模拟打开手机
       print("opening the phone")  # 输出打开手机的信息
 
   def close(self):  # 定义一个方法，模拟关闭手机
       print("closing the phone")  # 输出关闭手机的信息
 
   def take_photos(self):  # 定义一个方法，模拟用手机拍照
       print("take photo")  # 输出拍照的信息
 
   def all(self):  # 定义一个方法，执行打开手机、拍照和关闭手机的一系列操作
       self.open()  # 调用open方法
       self.take_photos()  # 调用take_photos方法
       self.close()  # 调用close方法
 
class computers:  # 定义一个名为computers的类，表示电脑
   def __init__(self, brand=None, price=None):  # 构造函数，初始化电脑的品牌和价格
       self.brand = brand  # 电脑的品牌
       self.price = price  # 电脑的价格
 
   def __str__(self):  # 定义对象的字符串表示
       return f"Computer: {self.brand}, Price: {self.price}"  # 返回电脑的品牌和价格信息
 
   def coding(self):  # 定义一个方法，模拟编程
       print("Coding...")  # 输出编程中的信息
 
   def see_video(self):  # 定义一个方法，模拟观看视频
       print("Seeing videos...")  # 输出观看视频的信息
 
   def all(self):  # 定义一个方法，执行编程和观看视频的一系列操作
       self.coding()  # 调用coding方法
       self.see_video()  # 调用see_video方法
 
# 主程序入口
if __name__ == "__main__":
   phone1 = phone()  # 创建一个phone实例
   phone1.all()  # 执行手机的所有操作
   phone1.open()  # 打开手机
   phone1.take_photos()  # 拍照
   phone1.close()  # 关闭手机
   print("--------------------")  # 输出分隔线
   print(phone1)  # 打印phone1对象的字符串表示（此处没有定义__str__方法，所以会打印对象的内存地址）
   computer1 = computers("Apple", 10000)  # 创建一个computers实例，品牌为Apple，价格为10000
   computer1.all()  # 执行电脑的所有操作
   print(computer1)  # 打印电脑的品牌和价格信息

3.减肥案例

class student:  # 定义一个名为student的类，表示学生
   def __init__(self, name, weight):  # 构造函数，初始化学生的姓名和体重
       self.name = name  # 学生的姓名
       self.weight = weight  # 学生的体重
 
   def run(self):  # 定义一个方法，模拟学生跑步
       self.weight -= 0.5  # 跑步后体重减少0.5kg
       print(f'{self.name} 跑步一次体重减少0.5kg')  # 输出跑步后的状态
 
   def eat(self):  # 定义一个方法，模拟学生吃大餐
       self.weight += 2  # 吃大餐后体重增加2kg
       print(f'{self.name} 吃大餐一次体重增加2kg')  # 输出吃大餐后的状态
 
   def __str__(self):  # 定义对象的字符串表示
       return f'{self.name} 的体重是 {self.weight}kg'  # 返回学生的姓名和体重
 
# 主程序入口
if __name__ == '__main__':
   xm = student('小明', 100)  # 创建一个student实例，小明，体重100kg
   print(xm)  # 打印小明的体重信息
   xm.run()  # 小明跑步一次
   xm.run()  # 小明再跑步一次
   print(xm)  # 打印小明跑步后的体重信息
   xm.eat()  # 小明吃大餐一次
   print(xm)  # 打印小明吃大餐后的体重信息

4.烤地瓜案例

class hot_potato:  # 定义一个名为hot_potato的类，模拟烤土豆的过程
   def __init__(self):  # 初始化函数
       # 定义事件,状态,香料
       self.cook_time = 0  # 烤土豆的累计时间
       self.cook_state = '生的'  # 烤土豆的当前状态
       self.cook_spices = []  # 添加的香料列表
 
   def hot_time(self, time):  # 定义一个方法，模拟烤土豆的过程
       if time <= 0:  # 如果输入的时间不正确
           print('输入错误')  # 输出错误信息
           return  # 结束函数
       self.cook_time += time  # 累加烤土豆的时间
       my_time = self.cook_time  # 获取当前烤土豆的总时间
       if 0 <= my_time < 3:  # 根据烤土豆的时间判断状态
           self.cook_state = '生的'  # 时间在0到3分钟内，土豆是生的
       elif 3 <= my_time < 7:
           self.cook_state = '半生不熟'  # 时间在3到7分钟内，土豆半生不熟
       elif 7 <= my_time < 12:
           self.cook_state = '熟了'  # 时间在7到12分钟内，土豆熟了
       elif 12 <= my_time:
           self.cook_state = '烤焦了'  # 时间超过12分钟，土豆烤焦了
       else:
           print('输入错误')  # 不应该执行到这里，如果执行到则输出错误
 
   def add_spices(self, spices_name):  # 定义一个方法，用于添加香料
       self.cook_spices.append(spices_name)  # 将香料添加到香料列表中
 
   def __str__(self):  # 定义对象的字符串表示
       return f'烤制状态:{self.cook_state},香料有:{self.cook_spices}'  # 返回土豆的烤制状态和添加的香料
 
# 主程序入口
if __name__ == '__main__':
   hp1 = hot_potato()  # 创建一个hot_potato实例
   hp1.hot_time(5)  # 给土豆加热5分钟
   print(hp1)  # 打印土豆的状态
   hp1.add_spices('黑胡椒')  # 添加黑胡椒香料
   hp1.add_spices('盐')  # 添加盐香料
   hp1.add_spices('冰激凌')  # 错误操作：添加冰激凌
   print(hp1)  # 再次打印土豆的状态
   hp1.hot_time(3)  # 再次给土豆加热3分钟
   print(hp1)  # 打印土豆的状态
   hp1.hot_time(-1)  # 错误操作：输入无效时间

5.动物类,继承示例

class Animal(object):
    # 父类animal
    def run(self):
        print('跑起来...')

class Horse(Animal):
    # 继承Animal, 子类horse
    def eat(self):
        print('吃东西...')

    def run(self):
        print('迈着矫健的步伐跑起来!!')


class SwiftHorse(Horse):
    # 继承Horse, 子类swift_horse
    def __init__(self):
        self.name = '千里马'

    def eat(self):
        print('一天可以吃一石粮食')


class Person(object):
    # person类
    # 私有变量类数量
    __cnt = 0
    # 私有方法, 类方法, 静态方法
    @staticmethod
    def cnt_change(num):
        Person.__cnt += num

    @staticmethod
    def get_cnt():
        return Person.__cnt

    def __init__(self, name=None, age=0):

        self.name = name
        self.age = age
        self.cnt_change(1)

    def show_info(self):

        print('这是一个Person类,谢谢查看')

    def study(self):
        print(f'我叫{self.name},我要好好学习')

    def __str__(self):
        return f'我的名字是{self.name},年龄是{self.age}'

    def __del__(self):
        self.cnt_change(-1)

if __name__ == '__main__':
    #创建对象测试
    H1 = Horse()
    H1.run()
    H1.eat()
    print('-' * 30)
    SH = SwiftHorse()
    print(SH.name)
    SH.run()
    SH.eat()
    print('-' * 30)
    p1 = Person('张三', 18)
    p2 = Person('李四', 28)
    print(Person.get_cnt())
    print(p1)
    print(p2)
    print()
    p1.study()
    p2.study()
    p1.__del__()
    print(Person.get_cnt())

6 飞机类,多态示例

class my_flight(object):
    # 我的飞机
    def __init__(self):
        self.power = 60


class e_flight(object):
    #  敌人飞机
    def __init__(self):
        self.power = 70


class my_flight_pls(my_flight):
    # 我的飞机pls
    def __init__(self):
        my_flight.__init__(self)
        self.power = 80


def object_play(p1, p2):
    # 对战平台
    if p1.power >= p2.power:
        print('玩家胜利')
    else:
        print('敌人胜利')


if __name__ == '__main__':
    #创建对象测试
    p1 = my_flight()
    p2 = e_flight()
    p3 = my_flight_pls()
    object_play(p1, p2)
    object_play(p3, p2)

7空调类,抽象类多态示例

class printer:
    # 抽象父类printer
    def Black_white_printing(self):
        pass
    def color_printing(self):
        pass

class hp(printer):
    # 继承自printer并实现Black_white_printing和color_printing方法
    def Black_white_printing(self):
        print('hp黑白')
    def color_printing(self):
        print('hp彩色')

class xm(printer):
    # 继承自printer并实现Black_white_printing和color_printing方法
    def Black_white_printing(self):
        print('xm黑白')

    def color_printing(self):
        print('xm彩色')
class canon(printer):
    # 继承自printer并实现Black_white_printing和color_printing方法
    def Black_white_printing(self):
        print('canon黑白')

    def color_printing(self):
        print('canon彩色')
def make_test_printing(myp:printer):
    # 调用printer的Black_white_printing和color_printing方法
    myp.Black_white_printing()
    myp.color_printing()

if __name__ == '__main__':
    # 实例化hp, xm, canon并测试make_test_printing方法
    hp1 = hp()
    xm1 = xm()
    canon1 = canon()
    make_test_printing(hp1)
    make_test_printing(xm1)
    make_test_printing(canon1)