Python-面向对象：面向对象、成员方法 、类和对象、构造方法、魔术方法、封装、继承、类型注解、多态（抽象类（接口））

版本说明

当前版本号[20230806]。

版本	修改说明
20230806	初版

目录

知识总览图

面向对象

初识对象

生活中数据的组织

学校开学，要求学生填写自己的基础信息，一人发一张白纸，让学生自己填，易出现内容混乱

但当改为登记表，打印出来让学生自行填写，就会整洁明了

程序中数据的组织

在程序中简单使用变量来记录学生信息，是比较的混乱、不统一

使用变量记录数据太乱了。

如果程序中也和生活中一样

• 可以设计表格
• 可以将设计的表格打印出来
• 可以将打印好的表格供人填写内容

那么数据的组织就非常方便了。

使用对象组织数据

在程序中是可以做到和生活中那样，设计表格、生产表格、填写表格的组织形式的。

1. 在程序中设计表格，我们称之为：设计类（class）

#设计一个对象（类比在生活中，设计一张登记表）
class student:
    name = None              #记录学生姓名
    gender = None            #记录学生性别
    nationality = None       #记录学生国籍
    native_place = None    #记录学生籍贯
    age = None                  #记录学生年龄

2. 在程序中打印生产表格，我们称之为：创建对象

#创建一个对象（类比在生活中，打印一张登记表）
stu_1 = student()

3. 在程序中填写表格，我们称之为：对象属性赋值

#对象属性进行赋值（类比在生活中填写表单）
stu_1.name = "皮卡丘"
stu_1.gender = "男"
stu_1.nationality = "中国"
stu_1.native_place = "山东省"
stu_1.age = 31

具体设计过程可以以下面流程进行参考：

成员方法

类的定义和使用

在上一节中，我们简单了解到可以使用类去封装属性，并基于类创建出一个个的对象来使用。

现在我们来看看类的使用语法：

创建类对象的语法：

对象 = 类名称（）

类所包括：

成员变量和成员方法

那么，什么是类的行为（方法）呢？

class student:
    name = None    #记录学生姓名

    def say_hi(self):
        print(f"hi，我是{self.name},你好哇")
        
#创建一个对象
stu_1 = student()
stu_1.name = "小叮当"
stu_1.say_hi()

可以看出，类中：

• 不仅可以定义属性用来记录数据
• 也可以定义函数，用来记录行为

其中：

• 类中定义的属性（变量），我们称之为：成员变量

• 类中定义的行为（函数），我们称之为：成员方法

所以在以后的学习中：

在类中定义的行为（函数），我们称之为：成员方法

在类外定义的行为（函数），我们称之为：函数

注意：函数是写在类外的，定义在类内部，我们都称之为方法哦

成员方法的定义语法

在类中定义成员方法和定义函数基本一致，但仍有细微区别：

可以看到，在方法定义的参数列表中，有一个：self关键字

self关键字是成员方法定义的时候，必须填写的。【系统有时也会自动补齐】

• 它用来表示类对象自身的意思
• 当我们使用类对象调用方法的是，self会自动被python传入
• 在方法内部，想要访问类的成员变量，必须使用self

完整来说为：

注意事项

self关键字，尽管在参数列表中，但是传参的时候可以忽略它。

如：

可以看到，在传入参数的时候，self是透明的，可以不用理会它。

类和对象

现实世界的事物和类

现实世界的事物也有属性和行为，类也有属性和行为。

使用程序中的类，可以完美的描述现实世界的事物

基于类创建对象的语法:

对象名 = 类名称（）

Q：为什么非要创建对象才能使用呢？

类只是一种程序内的“设计图纸”，需要基于图纸生产实体（对象），才能正常工作这种套路，称之为：面向对象编程

使用类和对象描述现实事物

在现实中，生产事物需要有设计图纸，才能有生成实体得以生产出来。

在程序中通过类来描述

基于类创建对象

这就是面向对象编程：设计类，基于类创建对象，由对象做具体的工作

完整代码：

class Clock:
    id = None       #序列化
    price = None    #价格

    def ring(self):
        import winsound
        winsound.Beep(2000, 3000) #2000表示响铃的频率，3000表示响铃的时间

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

clock2 = Clock()
clock2.id = "001234"
clock2.price = 24.99
clock2.ring()
print(f"闹钟ID：{clock2.id}, 价格：{clock2.price}")

输出如下：

构造方法

属性（成员变量）的赋值

上方代码中，为对象的属性赋值需要依次进行，略显繁琐。有没有更加高效的方式，能够一行代码就完成呢？

思考：

student（）这个括号，能否像函数（方法）那样，通过传参的形式对属性赋值呢？

可以，需要使用构造方法：__init__()

构造方法

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

可以实现：

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

• 构建类时传入的参数会自动提供给__init__方法
• 构建类的时候__init__方法会自动执行

构造方法注意事项

• 重要的事情说三遍，构造方法名称：init init init ， 千万不要忘记init前后都有2个下划线

• 构造方法也是成员方法，不要忘记在参数列表中提供：self

• 在构造方法内定义成员变量，需要使用self关键字

  

• 这是因为：变量是定义在构造方法内部，如果要成为成员变量，需要用self来表示。

参考代码：

class Clock:
    id = None       #序列化     	可以忽略
    price = None    #价格		  可以忽略

    def __init__(self, id, price):
        self.id = id
        self.price =price

clock01 = Clock("000717", 77.99)
print(clock01.id)
print(clock01.price)

演示如下：

练习：学生信息录入

开学了有一批学生信息需要录入系统，请设计一个类，记录学生的：

姓名、年龄、地址，这3类信息

请实现：

• 通过for循环，配合input输入语句，并使用构造方法，完成学生信息的键盘录入
• 输入完成后，使用print语句，完成信息的输出

输出结果参考如下：

参考代码如下：

class Student:
    name = None         #名字
    age = None          #年龄
    address = None      #地址

    def __init__(self, name, age, address):
        self.name = name
        self.age =age
        self.address = address

print("当前录入第1位学生信息，总共需要录入2位学生信息")

stu1 = Student(
    input("请输入学生姓名："),
    input("请输入学生年龄："),
    input("请输入学生地址：")
)

print(f"学生1信息录入完成，信息为：【学生姓名：{stu1.name}, 年龄:{stu1.age}, 地址：{stu1.address}")
print("当前录入第2位学生信息，总共需要录入2位学生信息")

stu2 = Student(
    input("请输入学生姓名："),
    input("请输入学生年龄："),
    input("请输入学生地址：")
)
print(f"学生1信息录入完成，信息为：【学生姓名：{stu2.name}, 年龄:{stu2.age}, 地址：{stu2.address}")

演示如下：

其它内置方法

魔术方法

上文学习的__init__ 构造方法，是Python类内置的方法之一。

这些内置的类方法，各自有各自特殊的功能，这些内置方法我们称之为：魔术方法

__str__ 字符串方法

当类对象需要被转换为字符串之时，会输出如上结果（内存地址）

• 方法名：__str__
• 返回值：字符串
• 内容：自行定义

内存地址没有多大作用，我们可以通过__str__方法，控制类转换为字符串的行为。

__lt__小于符号比较方法

​ 直接对2个对象进行比较是不可以的，但是在类中实现__lt__方法，即可同时完成：小于符号 和 大于符号 2种比较

• 方法名：__lt__
• 传入参数：other，另一个类对象
• 返回值：True 或 False
• 内容：自行定义

__le__小于等于比较符号方法

魔术方法：__le__可用于：<=、>=两种比较运算符上。【默认情况下是小于等于，如改成大于等于则所有结果都要变化】

• 方法名：__le__
• 传入参数：other，另一个类对象
• 返回值：True或False
• 内容：自行定义

总结：常用魔术方法

参考代码：

class Student:
    name = None         #名字
    age = None          #年龄

    def __le__(self, other):
        return self.age <= other.age


    def __str__(self):
        return f"在student类对象中，姓名为：{self.name}, 年龄为: {self.age}"

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

student01 = Student("银狼", 18)
student02 = Student("姬子", 28)
print(student01)
print(student02)
print(student01 >= student02)

结果如下：

封装

面向对象的三大特性

面向对象编程，是许多编程语言都支持的一种编程思想。

简单理解是：基于模板（类）去创建实体（对象），使用对象完成功能开发。

面向对象包含3大主要特性：

• 封装
• 继承
• 多态

封装表示的是，将现实世界事物的：

•属性

•行为

封装到类中，描述为：

•成员变量

•成员方法

从而完成程序对现实世界事物的描述

简单来说，将现实世界事物在类中描述为属性和方法，即为封装。

对用户隐藏的属性和行为

现实世界中的事物，有属性和行为。

但是不代表这些属性和行为都是开放给用户使用的。

私有成员

既然现实事物有不公开的属性和行为，那么作为现实事物在程序中映射的类，也应该支持。

类中提供了私有成员的形式来支持。

• 私有成员变量
• 私有成员方法

定义私有成员的方式非常简单，只需要：

• 私有成员变量：变量名以__开头（2个下划线）
• 私有成员方法：方法名以__开头（2个下划线）

即可完成私有成员的设置

使用私有成员

1、私有方法无法直接被类对象使用

2、私有变量无法赋值，也无法获取值

3、私有成员无法被类对象使用，但是可以被其它的成员使用。

演示代码如下：

class Student:
    name = None         #名字
    authority = None    #权限
    def __look_score(self):
        print("你的权限大于等于1，可以查看班级成绩！")

    def register(self):
        print("你已成功登录教务系统！")
        if self.authority >= 1:
            self.__look_score()
            print("查看班级成绩结束！")

        else:
            print("你的权限小于1，不可以查看班级成绩！")

student01 = Student()
student01.name = "小吴"
student01.authority = 2
student01.register()

演示结果如下：

练习：设计带有私有成员的手机

设计一个手机类，内部包含：

•私有成员变量：__is_5g_enable，类型bool，True表示开启5g，False表示关闭5g

•私有成员方法：__check_5g()，会判断私有成员__is_5g_enable的值

•若为True，打印输出：5g开启

•若为False，打印输出：5g关闭，使用4g网络

•公开成员方法：call_by_5g()，调用它会执行

•调用私有成员方法：__check_5g()，判断5g网络状态

•打印输出：正在通话中

运行结果：

通过完成这个类的设计和使用，体会封装中私有成员的作用

•对用户公开的，call_by_5g()方法

•对用户隐藏的，__is_5g_enable私有变量和__check_5g私有成员

参考代码：

class Phone:
    __is_5g_enable = None         #ture为开启，false为关闭
    def __check_5g(self):
        if self.__is_5g_enable == True:
            print("5g开启")

        else:
            print("5g关闭，使用4g网络")

    def call_by_5g(self, msg):
        self.__check_5g()
        print("正在通话中")

phone01 = Phone()
phone01.call_by_5g(True)

演示结果如下：

继承

继承的基础语法

继承的引出

如果你是设计师，你会如何选择？

1.每一代新款手机，都从零开始出设计图

2.基于老款的设计图，修修改改

那如果构建Phone2022类，你会选择：

1.从头写一个新的类

2.基于已有的Phone类进行修改

==> 我们可以使用继承，来完成此需求

单继承

继承分为：单继承和多继承

使用如图语法，可以完成类的单继承。

继承表示：将从父类那里继承（复制）来成员变量和成员方法（不含私有）

单继承演示代码：

class Phone:
    number = None
    cpu = None

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

class Phone2023(Phone):
    ability = None

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

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

演示结果如下：

多继承

Python的类之间也支持多继承，即一个类，可以继承多个父类

Q：pass关键字的作用是什么

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

多继承演示代码：

class Phone:
    number = None
    cpu = None

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

class door:
    door_id = None

    def call_for_door(self):
        print("智能门锁已开启！")

class infraredray:
    infrared_ray = None

    def call_infrared_ray(self):
        print("红外线功能已开启！")

class Phone2023(Phone, door, infraredray):
   pass

phone = Phone2023()
phone.call_by_4g()
phone.call_for_door()
phone.call_infrared_ray()

演示结果如下：

多继承注意事项

多个父类中，如果有同名的成员，那么默认以**继承顺序（从左到右）**为优先级。

即：先继承的保留，后继承的被覆盖

复写和使用父类成员

复写

子类继承父类的成员属性和成员方法后，如果对其“不满意”，那么可以进行复写。

即：在子类中重新定义同名的属性或方法即可。

调用父类同名成员

一旦复写父类成员，那么类对象调用成员的时候，就会调用复写后的新成员

如果需要使用被复写的父类的成员，需要特殊的调用方式:

方式1：

•调用父类成员

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

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

方式2：

•使用super()调用父类成员

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

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

注：

只能在子类内调用父类的同名成员。

子类的类对象直接调用会调用子类复写的成员

演示代码：

class Phone:
    number = 13.7
    cpu = None

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

class Phone2023(Phone):
   number = 14.1
   def call_by_4g(self):
       print("开启4G通话！")
       Phone.call_by_4g(self) #调用父类同名成员第一种方式
       super().call_by_4g() #调用父类同名成员第二种方式
       print("如有需要，可在后台为你开启5G通话！")

phone = Phone2023()
phone.call_by_4g()

演示结果：

类型注解

变量的类型注解

为什么需要类型注解

在PyCharm中编写代码，我们经常能够见到如下提示：

这便是：自动提示可用方法

Q:思考，为什么PyCharm工具能够做到这一点？

它是如何知道这个对象有append方法？

因为：PyCharm确定这个对象，是list类型

同样，我们换一份代码：

定义一个函数func，接收一个参数data

你会发现，PyCharm不会在做出任何提示了

Q;思考，为什么PyCharm工具无法提示了？

因为：PyCharm不确定这个对象是什么类型

又或者当我们调用方法，进行传参的时候（快捷键ctrl + p弹出提示）：

Q:为什么内置模块random的方法可以提示类型自己定义的就不可以？

因为PyCharm无法通过代码，确定应传入什么类型，我们需要使用类型注解

类型注解

Python在3.5版本的时候引入了类型注解，以方便静态类型检查工具，IDE等第三方工具。

类型注解：在代码中涉及数据交互的地方，提供数据类型的注解（显式的说明）。

主要功能：

• 帮助第三方IDE工具（如PyCharm）对代码进行类型推断，协助做代码提示
• 帮助开发者自身对变量进行类型注释

支持：

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

类型注解的语法

为变量设置类型注解

基础语法： 变量: 类型

注意：

•元组类型设置类型详细注解，需要将每一个元素都标记出来

•字典类型设置类型详细注解，需要2个类型，第一个是key第二个是value

除了使用 变量: 类型， 这种语法做注解外，也可以在注释中进行类型注解。

语法：

# type: 类型

为变量设置注解，显示的变量定义，一般无需注解：

如图，就算不写注解，也明确的知晓变量的类型，一般无法直接看出变量类型之时会添加变量的类型注解

类型注解的限制

类型注解主要功能在于：

• 帮助第三方IDE工具（如PyCharm）对代码进行类型推断，协助做代码提示
• 帮助开发者自身对变量进行类型注释（备注），并不会真正的对类型做验证和判断。

也就是，类型注解仅仅是提示性的，不是决定性的

如图代码，是不会报错的哦。

函数（方法）的类型注解

函数（方法）的类型注解 - 形参注解

如图所示：

• 在编写函数（方法），使用形参data的时候，工具没有任何提示
• 在调用函数（方法），传入参数的时候，工具无法提示参数类型

这些都是因为，我们在定义函数（方法）的时候，没有给形参进行注解

函数和方法的形参类型注解语法：

函数（方法）的类型注解 - 返回值注解

同时，函数（方法）的返回值也是可以添加类型注解的。

语法如下：

Union类型

使用Union[类型, ......, 类型] 可以定义联合类型注解

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

Union联合类型注解，在变量注解、函数（方法）形参和返回值注解中，均可使用。

多态

多态，指的是：多种状态，即完成某个行为时，使用不同的对象会得到不同的状态。

如何理解？

​ 同样的行为（函数），传入不同的对象，得到不同的状态.

多态常作用在继承关系上.

比如

• 函数(方法)形参声明接收父类对象
• 实际传入父类的子类对象进行工作

即:

• 以父类做定义声明
• 以子类做实际工作
• 用以获得同一行为, 不同状态

演示代码：

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)

演示结果：

抽象类（接口）

细心的同学可能发现了，父类Animal的speak方法，是空实现

这种设计的含义是：

• 父类用来确定有哪些方法
• 具体的方法实现，由子类自行决定

这种写法，就叫做抽象类（也可以称之为接口）

抽象类：含有抽象方法的类称之为抽象类

抽象方法：方法体是空实现的（pass）称之为抽象方法

为什么要使用抽象类呢？

​ 提出标准后，不同的厂家各自实现标准的要求。

抽象类就好比定义一个标准，包含了一些抽象的方法，要求子类必须实现。

配合多态，完成

•抽象的父类设计（设计标准）

•具体的子类实现（实现标准）

抽象类的作用：

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

演示代码：

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 chui_lengfeng(ac : AC):
    ac.cool_wind()

gree_ac = GREE_AC()
midea_ac = Midea_AC()
chui_lengfeng(gree_ac)
chui_lengfeng(midea_ac)

输出结果：

综合案例

数据分析案例

某公司，有2份数据文件，现需要对其进行分析处理，计算每日的销售额并以柱状图表的形式进行展示。

数据内容

• 1月份数据是普通文本，使用逗号分割数据记录，从前到后分别是（日期，订单id，销售额，销售省份）
• 2月份数据是JSON数据，同样包含（日期，订单id，销售额，销售省份）

需求分析

案例参考代码

data_define.py 代码：

#数据定义的类
class Record:

    def __init__(self, date, order_id, money, province):
        self.date = date             #订单日期
        self.order_id = order_id     #订单ID
        self.money = money           #订单金额
        self.province = province     #销售省份

    def __str__(self):
        return f"{self.date}, {self.order_id}, {self.money}, { self.province}"

file_define.py 代码：

#和文件相关的类定义
import json
from data_define import Record

#先定义一个抽象类用来做顶层设计，确定有哪些功能需要实现
class FileReader:

    def read_data(self) -> list[Record]:
    #读取文件的数据，读取的每一条数据都转换为Record对象，将它们都封装到list返回
        pass

class TextFileReader(FileReader):
    def __init__(self, path):
        self.path = path    #定义成员变量记录文件的路径（构造方法，用来构造要读取的数据的目录）

    #复写（实现抽象方法）父类的方法
    def read_data(self) -> list[Record]:
        f = open(self.path, "r", encoding="UTF-8")

        record_list: list[Record] = []
        for line in f.readlines():
            line = line.strip() #消除读取到的每一行数据中的\n
            data_list = line.split(",")
            record = Record(data_list[0], data_list[1], int(data_list[2]), data_list[3])
            record_list.append(record)

            f.close()
            return record_list

class JsonFileReader(FileReader):

    def __init__(self, path): #定义成员变量记录文件的路径
        self.path = path

    def read_data(self) -> list[Record]:
        f = open(self.path, "r", encoding="UTF-8")

        record_list: list[Record] = []
        for line in f.readlines():
            data_list = json.loads(line)#把字符串转变为python内部的数据
            record = Record(data_list["date"], data_list["order_id"], data_list["money"], data_list["province"])
            record_list.append(record)

        f.close()
        return record_list


#以下为测试，不会对程序导包时产生影响
if __name__ == '__main__':    
    text_file_reader = TextFileReader("F:/2011年1月销售数据.txt")
    json_file_reader = JsonFileReader("F:/2011年2月销售数据JSON.txt")
    l1 = text_file_reader.read_data()
    l2 = json_file_reader.read_data()

    for l in l2:
        print(l)

main.py 代码：

#主类
#面向对象，进行数据分析
#1、设计一个类，完成数据的封装
#2、设计一个抽象类，定义文件读取的相关功能，并使用子类实现具体功能
#3、读取文件，生产数据对象
#4、进行数据需求的逻辑计算（计算好每一天的销售额）
#5、使用pyecharts进行图形绘制

from  file_define import FileReader, TextFileReader, JsonFileReader
from data_define import Record
from pyecharts.charts import Bar
from pyecharts.options import *
from  pyecharts.globals import ThemeType

text_file_reader = TextFileReader("F:/2011年1月销售数据.txt")
json_file_reader = JsonFileReader("F:/2011年2月销售数据JSON.txt")

jan_data: list[Record] = text_file_reader.read_data()
feb_data: list[Record] = json_file_reader.read_data()
#将两个月的数据合并为1个list
all_data = jan_data + feb_data

#开始数据计算
data_dict = {}
for record in all_data:
    if record.date in data_dict.keys():
        #当前日期已经有记录了，所以和老记录做累加即可
        data_dict[record.date] += record.money
    else:
        data_dict[record.date] = record.money

#可视化图表开发
bar = Bar(init_opts=InitOpts(theme=ThemeType.LIGHT))
bar.add_xaxis(list(data_dict.keys())) #添加x轴的数据
bar.add_yaxis("销售额", list(data_dict.values()), label_opts=LabelOpts(is_show=False)) #添加y轴的数据
bar.set_global_opts(
    title_opts=TitleOpts(title="每日销售额")
)
bar.render("每日销售额柱状图.html")

数据分析结果如下图：