Python面向对象

初识对象

以表格为例：整张表格就好比一个对象，里面的信息就是对象的属性。

• 设计表格，称之为：设计类（class）
• 打印表格，称之为：创建对象
• 填写表格，称之为：对象属性赋值

class Student:
    name = None             # 姓名
    gender = None           # 性别
    nationality = None      # 国际
    native_place = None     # 籍贯
    age = None              # 年龄

# 创建一个对象
stu1 = Student()
# 给对象赋值
stu1.name = "富兰克林"
stu1.gender = "男"
stu1.nationality = "美国"
stu1.native_place = "洛圣都"
stu1.age = 31

# 获取对象中记录的信息
print(stu1.name)
print(stu1.gender)
print(stu1.nationality)
print(stu1.native_place)
print(stu1.age)

类的成员方法

类的组成部分：

• 类的属性，称之为：成员变量
• 类的行为，称之为：成员方法

类和成员方法的定义语法：

class 类名称：
    成员变量

    def say_hi(self, 参数1, 参数2, ...)：
        成员方法体

对象 = 类名称()

self作用：

• 表示类对象本身的意思
• 只有通过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()

stu2 = Student()
stu2.name = "周杰伦"
stu2.say_hi2("哎哟不错哟")

类和对象

类也可以包含属性和行为，所以使用类描述现实世界事物是非常合适的。
类和对象的关系:

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

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

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

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

# 构建两个闹钟对象并工作
clock1 = Clock()
clock1.id = "001001"
clock1.price = 19.99
print(f"闹钟ID：{clock1.id}，价格：{clock1.price}")
clock1.ring()

clock2 = Clock()
clock2.id = "001002"
clock2.price = 20.99
print(f"闹钟ID：{clock2.id}，价格：{clock2.price}")
clock2.ring()

构造方法

作用：

• 构建类对象的时候会自动运行
• 构建类对象的传参会传递给构造方法，借此特性可以给成员变量赋值

注意事项：

• 构造方法名称：__init__, 两边各两个下划线
• 构造方法也是成员方法，不要忘记在参数列表中提供：self
• 在构造方法内定义成员变量，需要使用self关键字,这是因为：变量是定义在构造方法内部，如果要成为成员变量，需要用self来表示。
• 必须是在定义了构造方法才可以省略，因为构造方法内部如果没有这个变量会自动定义加赋值
  

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("周杰伦", 31, "18566669999")
print(stu.name)
print(stu.age)
print(stu.tel)

# 结果
Student创建了一个类对象
周杰伦
31
18566669999

魔术方法

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

# stu = Student("富兰克林", 30)
# print(stu)
# print(str(stu))

stu1 = Student("麦克", 35)
stu2 = Student("富兰克林", 30)
print(stu1 < stu2)
print(stu1 > stu2)
print(stu1 >= stu2)
print(stu1 >= stu2)
print(stu1 == stu2) 

# 结果
False
True
True
True
False

封装

封装：将现实世界事物在类中描述为属性和方法，即为封装。
私有成员变量：对外不公开，只提供内部使用的变量称之为私有成员变量
私有成员变量定义方法：成员变量和成员方法的命名均以__作为开头即可
私有成员的访问限制：

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

# 定义一个类型包含私有变量和成员方法
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()

# 结果
让CPU以单核模式运行
电量不足，无法使用5g通话，并设置为单核运行进行省电

继承的基础语法

继承：继承就是一个类，继承另外一个类的成员变量和成员方法
语法：

# 单继承
class 类(父类)：
    结构体

# 多继承
class 类(父类1, 父类2, 父类3)：
    结构体

子类构建的类对象，可以有自己的成员变量和成员方法，使用父类的成员变量和成员方法

单继承和多继承：

• 单继承：一个类继承另一个类
• 多继承：一个类继承多个类，按照顺序从左向右依次继承。如果父类有同名方法或属性，先继承的优先级高于后继承

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

# 演示单继承
class Phone:
    IMEI = None  # 序列号
    producer = "APPLE"  # 厂商

    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)
phone.call_by_4g()
phone.call_by_5g()

# 演示多继承
class NFCReader:
    nfc_type = "第五代"
    producer = "XIAOMI"

    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()
phone.read_card()
phone.write_card()
phone.control()
# Phone，NFCReader都有该属性谁先继承谁的优先级高，方法也是
print(phone.producer)

# 结果
APPLE
4g通话
2022新功能：5g通话
4g通话
NFC读卡了
NFC写卡
红外遥控开启了
APPLE

复写父类成员和调用父类成员

复写：对父类的成员属性或成员方法进行重新定义
语法：在子类中重新实现同名成员方法或成员属性即可
子类调用父类成员：

• 方式一：父类名.成员变量、父类名.成员方法
• 方式二：super().成员变量、super().成员方法
  注意：只可以在子类内部调用父类的同名成员，子类的实体类对象调用默认是调用子类复写的

class Phone:
    IMEI = None         # 序列号
    producer = "APPLE"  # 厂商

    def call_by_5g(self):
        print("使用5g网络进行通话")

class MyPhone(Phone):
    producer = "HUAWEI"

    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()
print(phone.producer)
phone.call_by_5g()

# 结果
HUAWEI
开启CPU单核模式，确保通话的时候省点
父类的厂商是：APPLE
使用5g网络进行通话
关闭CPU单核模式

变量类型注解

类型注解：在代码中涉及数据交互之时，对数据类型进行显式的说明，可以帮助PyCharm等开发工具对代码做类型推断协助做代码提示，开发者自身做类型的备注。

类型注解支持：

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

变量的类型注解语法：

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

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

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

# var_1: int = 10
# var_2: str = "APPLE"
# var_3: bool = True
# var_4: float = 3.14

# 类对象类型注解
class Student:
    pass
stu: Student = Student()

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

# 容器类型详细注解
my_list_detail: list[int] = [1, 2, 3]
my_tuple_detail: tuple[int, str, bool] = (1, "HUAWEI", True)
my_dict_detail: dict[str, int] = {"name": 1}
my_set_detail: set[int] = {1, 2, 3}

# 在注释中进行类型注解
var_1 = random.randint(1, 10)       # type: int
var_2 = json.loads('{"name": "HUAWEI"}')    # type: dict
def func():
    return 10
var_3 = func()  # type: int

函数和方法类型注解

函数（方法）哪里添加注解：

• 形参的类型注解
• 返回值的类型注解

函数（方法）类型注解语法：

def 函数方法名(形参: 类型, ...) -> 返回值类型：
    pass

注意，返回值类型注解的符号使用： ->

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

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

Union联合类型注解

Union类型：使用Union可以定义联合类型注解
Union的使用方式：

• 导包：from typing import Union
• 使用：Union[类型, ......, 类型]

# 使用Union类型注解
from typing import Union

my_list: list[Union[str, int]] = [1, 2, "java", "python"]

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

多态

多态：多态指的是，同一个行为，使用不同的对象获得不同的状态。如，定义函数（方法），通过类型注解声明需要父类对象，实际传入子类对象进行工作，从而获得不同的工作状态。

抽象类（接口）：包含抽象方法的类，称之为抽象类。抽象方法是指：没有具体实现的方法（pass）称之为抽象方法。

抽象类的作用：多用于做顶层设计（设计标准），以便子类做具体实现。也是对子类的一种软性约束，要求子类必须复写（实现）父类的一些方法并配合多态使用，获得不同的工作状态。

# 演示多态
# 动物类（父类）
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()
make_cool(midea_ac)
make_cool(gree_ac)

# 结果
汪汪汪
喵喵喵
美的空调制冷
格力空调制冷