[Python] Class 类_python 美的空调-CSDN博客

本文链接：https://blog.csdn.net/Ression/article/details/131311177

1. 对象

class Student:  # 1.设计类
    name = None
    gender = None
    nationality = None
    native_place = None
    age = None


# 2.基于类创建对象
stu_1 = Student()
stu_2 = Student()

stu_1.name = '周华'  # 3.为学生1对象赋予名称属性值
stu_1.age = 15
stu_2.name = '李明'

# 4.获取对象中记录的信息
print(stu_1.age)

2. 类的成员方法

class Student:  # 1.设计类
    name = None
    gender = None
    nationality = None
    native_place = None
    age = None

    def say_hi(self):
        print(f"大家好，我是{self.name}")

    def say_hi2(self, msg):
        print(f"大家好，我是：{self.name},{msg}")


# 2.基于类创建对象-
stu_1 = Student()
stu_2 = Student()

stu_1.name = '周华'  # 3.为学生1对象赋予名称属性值
stu_1.age = 15
stu_2.name = '李明'

# 4.获取对象中记录的信息
print(stu_1.age)

stu_1.say_hi()
stu_2.say_hi2("你吃了吗")

1. 类的组成

类的属性：成员变量
类的行为：成员方法

attention：函数是写在类外的，方法则是定义在类内部

2. 类和成员方法的定义语法

class 类名称:
    成员变量

    def 成员方法(self, 参数列表):
        成员方法体

对象 = 类名称()

3. self的作用

表示类对象本身的意思
只有通过self，成员方法才能访问类的成员变量
self出现在形参列表中，但不占用参数位置

3. 类和对象

"""
类和对象的关系，即面向对象的编程思想
"""
import winsound


# 设计一个闹钟类
class Clock:
    id = None  # 序列化
    price = None  # 价格

    def ring(self):
        winsound.Beep(2000, 3000)


# 构建两个闹钟对象并让其工作
clock1 = Clock()
clock1.id = "00019"
clock1.price = 19.9
print(f"闹钟ID:{clock1.id},价格:{clock1.price}")
clock1.ring()

clock2 = Clock()
clock2.id = "00020"
clock2.price = 29.9
print(f"闹钟ID:{clock2.id},价格:{clock2.price}")
clock2.ring()

1. 现实世界的事物由属性和行为组成。类也可以包含属性和行为。

2. 类和对象的关系

类是程序中的“设计图纸”
对象是基于图纸生产的具体实体

3. 面向对象编程

即使用对象进行编程：设计类，基于类创建对象，并使用对象来完成具体的工作。

4. 构造方法

Python类可以使用：__init__()方法，称之为构造方法。

可以实现：

在创建类对象（构造类）的时候，会自动执行。
在创建类对象（构造类）的时候，将传入参数自动传递给__init__方法使用。

"""
类的构造方法:__init__
"""


class Student:
    name = None    # 可省略
    age = None
    tel = None

    def __init__(self, name, age, tel):
        self.name = name    # 即可赋值，又能定义
        self.age = age
        self.tel = tel
        print("Student类创建了一个类对象")


stu = Student("李华", 18, 15859643320)
print(stu.name)

attention:

构造方法也是成员方法，需要在参数列表中提供：self
在构造方法内定义成员变量，需要使用self关键字。因为变量是定义在构造方法内部。如果要成为成员变量，需要用self表示。

5. 类的内置函数

"""
类的内置方法
"""


class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __str__(self):
        '''
        控制类转换为字符串的行为
        :return: 字符串
        '''
        return f"Student类对象，name:{self.name},age:{self.age}"

    def __lt__(self, other):
        """
        小于符号比较方法
        :param other: 另一个类对象
        :return: True/False
        """
        return self.age < other.age

    def __le__(self, other):
        """
        小于等于符号比较方法  <= , >=
        :param other: 另一个类对象
        :return: True/False
        """
        return self.age <= other.age

    def __eq__(self, other):
        """
        等于符号比较方法  <= , >=
        :param other: 另一个类对象
        :return: True/False
        """
        return self.age == other.age


stu1 = Student("李华", 18)
print(stu1)
print(str(stu1))

stu2 = Student("林杰", 22)
print(stu1 < stu2)
print(stu1 > stu2)

print(stu1 <= stu2)
print(stu1 >= stu2)

stu1 = Student("李华", 18)
stu2 = Student("林杰", 18)
print(stu1 == stu2)

方法	功能
__init__	构造方法，可用于创建类对象的时候设置初始化行为
__str__	用于实现类对象转字符串的行为
__lt__	用于两个类对象进行小于或大于比较
__le__	用于两个类对象进行小于等于或大于等于比较
__eq__	用于两个类对象进行相等比较

6. 封装

"""
封装，包含私有成员变量和私有成员方法
"""


# 定义一个类，内含私有成员变量和私有成员方法
class Phone:
    __current_voltag = 0.2  # 手机运行电压

    def __keep_single_core(self):
        print("让CPU以单核模式运行。")

    def call_by_5g(self):
        if self.__current_voltag >= 1:
            print("5g通话已开启。")
        else:
            self.__keep_single_core()
            print("电量不足，无法使用，开启省电模式。")


phone = Phone()
# phone.__keep_single_core()  # AttributeError: 'Phone' object has no attribute '__keep_single_core'
# print(phone.__current_voltag)  # AttributeError: 'Phone' object has no attribute '__current_voltag'
phone.call_by_5g()

1. 封装：将现实世界事物在类中描述为属性和方法。

2. 现实事物有部分属性和行为是不公开对使用者开放的。同样在类中描述属性和方法的时候也需要达到这个要求，所以需要定义私有成员。

3. 定义私有成员：成员变量和成员方法的命名均以__作为开头即可。

4. 私有成员的访问限制：

类对象无法访问私有成员
类中的其他成员可以访问私有成员

7. 继承

"""
继承
"""


# 单继承
class Phone:
    IMEI = None
    producer = "HM"

    def call_by_4g(self):
        print("4G通话")


class Phone2023(Phone):
    face_id = "100101"

    def call_by_5g(self):
        print("5G通话")


phone = Phone2023()
print(phone.producer)
phone.call_by_4g()
phone.call_by_5g()


# 多继承
class NFCReader:
    nfc_type = "第五代"
    producer = "HW"

    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  # 补全语法


myphone = MyPhone()
myphone.call_by_4g()
myphone.control()

1. 继承：一个类，继承另一个类的成员变量和成员方法

语法：

class 类(父类[, 父类2, ... , 父类N]):
    类内容体

子类构建的类对象，可以

有自己的成员变量和成员方法
使用父类二点成员变量和成员方法

2. 单继承和多继承

单继承：一个类继承另一个类

多继承：一个类继承多个类，按照顺序从左到右依次继承

多继承中，如果父类有同名方法或属性，先继承的优先级高于后继承

3. pass关键字

pass是占位语句，用于保证函数（方法）或类定义的完整性，表示无内容，空的意思。

7.1 复写和使用父类成员

"""
复写
"""


class Phone:
    IMEI = None
    producer = "HM"

    def call_by_5g(self):
        print("5G通话")


# 定义子类，复写父类成员
class Phone2023(Phone):
    # face_id = "100101"
    producer = "NVIDIA"

    def call_by_5g(self):
        print("开启CPU单核")
        # print("5G通话")
        # 方法1
        print(f"父类的厂商是{Phone.producer}")
        Phone.call_by_5g(self)
        # 法2
        print(f"父类的厂商是{super().producer}")
        super().call_by_5g()
        print("关闭CPU单核")


phone = Phone2023()
print(phone.producer)
phone.call_by_5g()

1. 复写表示：对父类的成员属性或成员方法进行重新定义
2. 复写的语法：在子类中重新实现同名成员方法或成员属性即可
3. 在子类中，如何调用父类成员：

方法1：调用父类成员（适用于多继承）

使用成员变量：父类名.成员变量

使用成员方法：父类名.成员方法(self)

方法2：使用super()调用父类成员（适用于单继承）

使用成员变量：super().成员变量

使用成员方法：super().成员方法()

attention：只可以在子类内部调用父类的同名成员，子类的实体类对象调用默认是调用子类复写的。

8. 类型注解

8.1 变量的类型注解

"""
# 变量的类型注解
"""

# 基础数据类型注解
import json
import random

var_1: int = 10
var_2: str = 'nihao'
var_3: bool = True


# 类对象类型注解
class Student:
    pass


stu: Student = Student()

# 基础容器类型注解
my_list: list = [1, 2, 3]
my_tuple: tuple = (1, 2, 3)
my_dict: dict = {"id": 112}

# 容器类型详细注解
# my_list: list[int] = [2, 5, 3]
# my_tuple: tuple[int, str, bool] = (1, "nihaom", True)
# my_dict: dict[str, int] = {"id": 112}

# 在注释中进行类型注解
var_4 = random.randint(1, 10)  # type:int
var_5 = json.loads('{"name":"Lina"}')  # type:dict[str,str]


def func():
    return 10


var_6 = func()  # type:int

# 类型注解的限制

1. 什么是类型注解，有什么作用?
在代码中涉及数据交互之时，对数据类型进行显式的说明，可以帮助:

PyCharm等开发工具对代码做类型推断协助做代码提示
开发者自身做类型的备注

2. 类型注解支持:

变量的类型注解
函数（方法)的形参和返回值的类型注解

3. 变量的类型注解语法

语法1: 变量:类型
语法2: 在注释中，# type:类型

4. 注意事项

类型注解只是提示性的，并非决定性的。数据类型和注解类型无法对应也不会导致错误

8.2 函数和方法类型注解

"""
函数方法的类型注解
"""


# 对形参进行类型注解
def add(x: int, y: int):
    return x + y


# 对返回值进行类型注解
def func(data: list) -> list:
    return data


print(func([1, 4, 65]))

8.3 Union联合类型注解

"""
Union联合类型注解
"""
from typing import Union, List

my_list: List[Union[int, str]] = [1, 2, "union"]


def func(data: Union[int, str]) -> Union[int, str]:
    return data

9. 多态

"""
多态
"""


class Animal:
    def speak(self):
        pass


class Dog(Animal):
    def speak(self):
        print("汪汪汪")


class Cat(Animal):
    def speak(self):
        print("喵喵喵")


def make_noise(animal: Animal):
    animal.speak()


dog = Dog()
cat = Cat()

make_noise(dog)
make_noise(cat)


# 抽象类
class AC:
    def cool_wind(self):
        # 制冷
        pass

    def hot_wind(self):
        # 制热
        pass

    def swing_l_r(self):
        # 左右摆风
        pass


class Midea_AC(AC):
    def cool_wind(self):
        print("美的空调制冷")

    def hot_wind(self):
        print("美的空调制热")

    def swing_l_r(self):
        print("美的空调左右摆风")


class GREE_AC(AC):
    def cool_wind(self):
        print("格力空调制冷")

    def hot_wind(self):
        print("格力空调制热")

    def swing_l_r(self):
        print("格力空调左右摆风")


def make_cool(ac: AC):
    ac.cool_wind()


midea_ac = Midea_AC()
gree_ac = GREE_AC()

midea_ac.cool_wind()
gree_ac.cool_wind()

1. 什么是多态?
多态指的是，同一个行为，使用不同的对象获得不同的状态。
如，定义函数（方法)，通过类型注解声明需要父类对象，实际传入子类对象进行工作，从而获得不同的工作状态
2. 什么是抽象类（接口)
包含抽象方法的类，称之为抽象类。抽象方法是指:没有具体实现的方法（(pass)称之为抽象方法
3. 抽象类的作用
多用于做顶层设计（设计标准)，以便子类做具体实现。
也是对子类的一种软性约束，要求子类必须复写（实现）父类的一些方法
并配合多态使用，获得不同的工作状态。