Python面向对象

成员方法

"""
面向对象类中的成员方法定义和使用
self表示类对象本身的意思
只有通过self，成员方法才能访问类的成员变量     (类的属性)
"""
 
# 定义一个带有成员方法的类
class Student:
    name = None     # 学生的姓名
 
    def say_hi(self):
        print(f"大家好呀，我是{self.name}，欢迎大家多多关照")
 
    def say_hi2(self, msg):
        print(f"大家好，我是：{self.name}，{msg}")
 
stu = Student()
stu.name = "周杰轮"
stu.say_hi()        # 大家好呀，我是周杰轮，欢迎大家多多关照
stu.say_hi2("哎哟不错哟")    # 大家好，我是：周杰轮，哎哟不错哟
 
stu2 = Student()
stu2.name = "林俊节"
stu2.say_hi2("小伙子我看好你")    # 大家好，我是：林俊节，小伙子我看好你

类和对象（面向对象的编程思想）

# 设计一个闹钟类
class Clock:
    id = None       # 序列化
    price = None    # 价格
 
    def ring(self):
        import winsound
        winsound.Beep(2000, 3000)   # 前一个是频率，后一个是持续时间
 
# 构建2个闹钟对象并让其工作
clock1 = Clock()
clock1.id = "003032"
clock1.price = 19.99
print(f"闹钟ID：{clock1.id}，价格：{clock1.price}")
# clock1.ring()
 
clock2 = Clock()
clock2.id = "003033"
clock2.price = 21.99
print(f"闹钟ID：{clock2.id}，价格：{clock2.price}")
clock2.ring()

类的构造方法

使用构造方法对成员变量进行赋值

class Student:
 
    def __init__(self, name, age, tel):     
        # 这个方法会自动执行，将传入参数自动传递给__init__方法使用
        self.name = name
        self.age = age
        self.tel = tel
        print("Student类创建了一个类对象")
 
stu = Student("周杰轮", 31, "18500006666")
# 首先会输出 Student类创建了一个类对象
print(stu.name)
print(stu.age)
print(stu.tel)

Python内置的各类魔术方法

class Student:
    def __init__(self, name, age):
        self.name = name        # 学生姓名
        self.age = age          # 学生年龄
 
    # __str__魔术方法       控制类对象转换为字符串的行为，如果没这个方法，会输出内存地址,所以需要该内置方法转为字符串
    def __str__(self):
        return f"Student类对象，name:{self.name}, age:{self.age}"
 
    # __lt__魔术方法        直接对两个对象进行比较是不可以的
    def __lt__(self, other):
        return self.age < other.age
 
    # __le__魔术方法
    def __le__(self, other):
        return self.age <= other.age
 
    # __eq__魔术方法
    def __eq__(self, other):
        return self.age == other.age
 
 
stu1 = Student("周杰轮", 31)
print(stu1)
print(str(stu1))
 
stu2 = Student("林俊节", 36)
print(stu1 < stu2)  # True
 
print(stu1 == stu2)  # 如果没有__eq__魔术方法定义，则默认比较内存地址

封装（将现实世界事物在类中描述为属性和方法）

class Phone:
    __current_voltage = 0.5        # 当前手机运行电压
    # 定义私有成员变量和私有成员方法，均可以__开头
    # 私有方法无法直接被类对象使用，但是可以被其他方法调用
    # 私有变量无法通过构建对象再次赋值，也无法获取值
 
    def __keep_single_core(self):
        print("让CPU以单核模式运行")
 
    def call_by_5g(self):
        if self.__current_voltage >= 1:
            print("5g通话已开启")
        else:
            self.__keep_single_core()
            print("电量不足，无法使用5g通话，并已设置为单核运行进行省电。")
 
 
phone = Phone()
phone.call_by_5g()

继承

单继承

class Phone:
    IMEI = None     # 序列号
    producer = "ITCAST"  # 厂商
 
    def call_by_4g(self):
        print("4g通话")
 
 
class Phone2022(Phone):
    face_id = "10001"       # 面部识别ID
 
    def call_by_5g(self):
        print("2022年新功能：5g通话")
 
 
phone = Phone2022()
print(phone.producer)       # ITCAST
phone.call_by_4g()      # 4g通话
phone.call_by_5g()      # 2022年新功能：5g通话

多继承

class NFCReader:
    nfc_type = "第五代"
    producer = "HM"
 
    def read_card(self):
        print("NFC读卡")
 
    def write_card(self):
        print("NFC写卡")
 
 
class RemoteControl:
    rc_type = "红外遥控"
 
    def control(self):
        print("红外遥控开启了")
 
 
class MyPhone(Phone, NFCReader, RemoteControl):
    # 如果父类中有同名方法或属性，先继承的优先级高于后继承
    pass    # 表示无内容，空的意思
 
 
phone = MyPhone()
phone.call_by_4g()    # 4g通话
phone.read_card()
phone.write_card()
phone.control()
 
print(phone.producer)    # ITCAST

继承中对父类成员的复写和调用

子类中，调用父类成员

class Phone:
    IMEI = None             # 序列号
    producer = "ITCAST"     # 厂商
 
    def call_by_5g(self):
        print("使用5g网络进行通话")
 
 
# 定义子类，复写父类成员
class MyPhone(Phone):
    producer = "ITHEIMA"        # 复写父类的成员属性
 
    def call_by_5g(self):
        print("开启CPU单核模式，确保通话的时候省电")
        # 方式1
        # print(f"父类的厂商是：{Phone.producer}")
        # Phone.call_by_5g(self)
        # 方式2
        print(f"父类的厂商是：{super().producer}")
        super().call_by_5g()
        print("关闭CPU单核模式，确保性能")
 
phone = MyPhone()
phone.call_by_5g()
print(phone.producer)