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

news2024/11/28 10:51:16

版本说明

当前版本号[20230806]。

版本修改说明
20230806初版

目录

文章目录

  • 版本说明
  • 目录
  • 知识总览图
  • 面向对象
    • 初识对象
      • 生活中数据的组织
      • 程序中数据的组织
      • 使用对象组织数据
    • 成员方法
      • 类的定义和使用
      • 成员变量和成员方法
      • 成员方法的定义语法
      • 注意事项
    • 类和对象
      • 现实世界的事物和类
      • 使用类和对象描述现实事物
      • 在程序中通过类来描述
      • 基于类创建对象
    • 构造方法
      • 属性（成员变量）的赋值
      • 构造方法注意事项
      • 练习：学生信息录入
    • 其它内置方法
      • 魔术方法
      • `__str__ `字符串方法
      • `__lt__`小于符号比较方法
      • `__le__`小于等于比较符号方法
      • 总结：常用魔术方法
    • 封装
      • 面向对象的三大特性
      • 对用户隐藏的属性和行为
      • 私有成员
      • 使用私有成员
      • 练习：设计带有私有成员的手机
    • 继承
      • 继承的基础语法
        • 继承的引出
        • 单继承
        • 多继承
        • 多继承注意事项
      • 复写和使用父类成员
        • 复写
        • 调用父类同名成员
    • 类型注解
      • 变量的类型注解
        • 为什么需要类型注解
        • 类型注解
        • 类型注解的语法
        • 类型注解的限制
      • 函数（方法）的类型注解
        • 函数（方法）的类型注解 - 形参注解
        • 函数（方法）的类型注解 - 返回值注解
      • Union类型
    • 多态
      • 抽象类（接口）
    • 综合案例
      • 数据分析案例
      • 数据内容
      • 需求分析
      • 案例参考代码

知识总览图

面向对象

面向对象

初识对象

生活中数据的组织

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

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

程序中数据的组织

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

image-20230718160201886

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

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

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

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

使用对象组织数据

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

  1. 在程序中设计表格，我们称之为：设计类（class）
#设计一个对象（类比在生活中，设计一张登记表）
class student:
    name = None              #记录学生姓名
    gender = None            #记录学生性别
    nationality = None       #记录学生国籍
    native_place = None    #记录学生籍贯
    age = None                  #记录学生年龄
  1. 在程序中打印生产表格，我们称之为：创建对象
#创建一个对象（类比在生活中，打印一张登记表）
stu_1 = student()
  1. 在程序中填写表格，我们称之为：对象属性赋值
#对象属性进行赋值（类比在生活中填写表单）
stu_1.name = "皮卡丘"
stu_1.gender = "男"
stu_1.nationality = "中国"
stu_1.native_place = "山东省"
stu_1.age = 31

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

image-20230718160554388

成员方法

类的定义和使用

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

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

image-20230718162823630

创建类对象的语法：

对象 = 类名称（）

类所包括：

image-20230718162908719

成员变量和成员方法

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

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

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

可以看出，类中：

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

其中：

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

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

所以在以后的学习中：

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

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

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

成员方法的定义语法

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

image-20230718163453938

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

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

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

image-20230718163502778

完整来说为：

image-20230718163815682

注意事项

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

如：

image-20230718163633629

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

类和对象

现实世界的事物和类

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

image-20230718165156026

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

image-20230718165216974

基于类创建对象的语法:

对象名 = 类名称（）

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

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

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

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

image-20230718165422955

在程序中通过类来描述

image-20230718172230425

基于类创建对象

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

image-20230718172325851

完整代码：

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}")

输出如下：

image-20230718172410965

构造方法

属性（成员变量）的赋值

image-20230718173206099

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

思考：

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

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

构造方法

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

可以实现：

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

image-20230718173403691

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

构造方法注意事项

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

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

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

    image-20230718173524551

  • 这是因为：变量是定义在构造方法内部，如果要成为成员变量，需要用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)

演示如下：

image-20230718173901031

练习：学生信息录入

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

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

请实现：

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

输出结果参考如下：

image-20230718174016808

参考代码如下：

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}")

演示如下：

image-20230718175452015

其它内置方法

魔术方法

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

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

image-20230718181004427

__str__ 字符串方法

image-20230718181040940

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

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

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

image-20230718181132592

__lt__小于符号比较方法

image-20230718181217465

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

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

image-20230718181334797

__le__小于等于比较符号方法

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

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

image-20230718181808087

总结：常用魔术方法

image-20230718181836660

参考代码：

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)

结果如下：

image-20230718183912045

封装

面向对象的三大特性

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

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

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

  • 封装
  • 继承
  • 多态

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

•属性

•行为

封装到类中，描述为：

•成员变量

•成员方法

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

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

image-20230719103639488

对用户隐藏的属性和行为

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

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

image-20230719103826124

私有成员

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

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

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

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

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

即可完成私有成员的设置

image-20230719103929988

使用私有成员

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

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

image-20230719104049164

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

image-20230719104142091

演示代码如下：

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()

演示结果如下：

image-20230719110118098

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

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

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

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

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

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

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

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

•打印输出：正在通话中

运行结果：

image-20230719114039730

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

•对用户公开的，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)

演示结果如下：

image-20230719114229072

继承

继承的基础语法

继承的引出

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

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

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

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

1.从头写一个新的类

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

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

image-20230720144230743

单继承

image-20230720144323646

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

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

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

image-20230720144425845

单继承演示代码：

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()

演示结果如下：

image-20230720145546173

多继承

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

image-20230720144518950

image-20230720144547657

image-20230720144559925

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()

演示结果如下：

image-20230720145954372

多继承注意事项

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

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

image-20230720144803999

复写和使用父类成员

复写

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

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

image-20230720151545135

调用父类同名成员

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

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

方式1：

•调用父类成员

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

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

方式2：

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

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

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

注：

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

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

image-20230720151709441

演示代码：

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()

演示结果：

image-20230720152154537

类型注解

变量的类型注解

为什么需要类型注解

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

image-20230720155433651

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

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

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

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

同样，我们换一份代码：

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

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

image-20230720155628470

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

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

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

image-20230720155710693

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

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

类型注解

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

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

主要功能：

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

支持：

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

类型注解的语法

为变量设置类型注解

基础语法： 变量: 类型

image-20230720160056720

image-20230720160120612

注意：

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

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

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

语法：

# type: 类型

image-20230720160240791

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

image-20230720160302769

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

image-20230720160308841

类型注解的限制

类型注解主要功能在于：

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

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

image-20230720160447401

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

函数（方法）的类型注解

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

image-20230720160927904

如图所示：

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

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

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

image-20230720160957139

image-20230720161020566

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

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

语法如下：

image-20230720161231155

Union类型

image-20230720161639571

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

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

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

image-20230720161702939

多态

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

如何理解？

image-20230720162135353

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

image-20230720162219038

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

比如

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

即:

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

演示代码：

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)

演示结果：

image-20230720164039619

抽象类（接口）

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

image-20230720164147961

这种设计的含义是：

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

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

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

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

为什么要使用抽象类呢？

image-20230720164245178

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

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

配合多态，完成

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

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

抽象类的作用：

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

演示代码：

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)

输出结果：

image-20230720165049796

综合案例

数据分析案例

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

image-20230720211533164

数据内容

image-20230720211611246

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

需求分析

image-20230720211659320

案例参考代码

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")

数据分析结果如下图：

image-20230720212133295

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/843817.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Netty：ChannelInitializer添加到ChannelPipeline完成任务以后会自动删除自己

Netty：ChannelInitializer添加到ChannelPipeline完成任务以后会自动删除自己

说明 io.netty.channel.ChannelInitializer是一个特殊的ChannelInboundHandler。它的主要作用是向 Channel对应的ChannelPipeline中增加ChannelHandler。执行完ChannelInitializer的initChannel(C ch)函数以后&#xff0c;ChannelInitializer就会从ChannelPipeline自动删除自己…
阅读更多...
sklearn中使用决策树

sklearn中使用决策树

1.示例 criterion可以是信息熵&#xff0c;entropy&#xff0c;可以是基尼系数gini # -*-coding:utf-8-*- from sklearn import tree from sklearn.datasets import load_wine from sklearn.model_selection import train_test_split wineload_wine()# print ( wine.feature_…
阅读更多...
Vue3 第四节 自定义hook函数以及组合式API

Vue3 第四节 自定义hook函数以及组合式API

1.自定义hook函数 2.toRef和toRefs 3.shallowRef和shallowReactive 4.readonly和shallowReadonly 5.toRaw和markRaw 6.customref 一.自定义hook函数 ① 本质是一个函数&#xff0c;把setup函数中使用的Composition API 进行了封装,类似于vue2.x中的mixin 自定义hook函数…
阅读更多...
Maven介绍-下载-安装-使用-基础知识

Maven介绍-下载-安装-使用-基础知识

Maven介绍-下载-安装-使用-基础知识 Maven的进阶高级用法可查看这篇文章&#xff1a; Maven分模块-继承-聚合-私服的高级用法 文章目录 Maven介绍-下载-安装-使用-基础知识01. Maven1.1 初识Maven1.1.1 什么是Maven1.1.2 Maven的作用 02. Maven概述2.1 Maven介绍2.2 Maven模型…
阅读更多...
F5 LTM 知识点和实验 12-使用规则和本地流量策略定制应用程序交付

F5 LTM 知识点和实验 12-使用规则和本地流量策略定制应用程序交付

第十一章：iapp（忽略） 第十二章:使用规则和本地流量策略定制应用程序交付 用最简单的术语来说，iRule是在网络流量通过BIGIP系统时对其执行的脚本。其思想非常简单:规则使您能够编写简单的网络感知代码片段，这些代码以各种方式影响您的网络流量。无论您是希望以BIG-IP内置…
阅读更多...
SpringBoot 自动配置--常用配置

SpringBoot 自动配置--常用配置

&#x1f600;前言 本篇博文是关于SpringBoot 自动配置的一些分享&#xff0c;希望能够帮助到您&#x1f60a; &#x1f3e0;个人主页&#xff1a;晨犀主页 &#x1f9d1;个人简介&#xff1a;大家好&#xff0c;我是晨犀&#xff0c;希望我的文章可以帮助到大家&#xff0c;您…
阅读更多...
分布式任务调度平台——XXL-JOB

分布式任务调度平台——XXL-JOB

1、为什么需要任务调度平台 1.1、传统的定时任务实现方案不足 在Java中&#xff0c;传统的定时任务实现方案&#xff0c;比如Timer&#xff0c;Quartz等都或多或少存在一些问题&#xff1a; 不支持集群、不支持统计、没有管理平台、没有失败报警、没有监控等。在现在分布式的…
阅读更多...
如何快速掌握水土保持方案编制

如何快速掌握水土保持方案编制

1、熟悉水土保持常用的主要法律法规、部委规章、规范性文件及技术规范与标准&#xff1b; 2、了解水土保持方案、监测及验收工作开展的流程&#xff1b; 3、熟悉水土保持方案、监测及验收工作需要收集的资料、现场踏勘注意事项&#xff1b; 4、熟悉常见水土保持工程施工工艺…
阅读更多...
JavaSE_2.1——数组【概念、创建、内存分配】

JavaSE_2.1——数组【概念、创建、内存分配】

今天是练习数组的第一天&#xff0c;后续继续 1、数组的定义以及声明 1.数组的定义&#xff1a;一组能够存储相同数据类型值的变量的集合 2.数组的赋值方式&#xff1a; New关键字:表示创建一个数组&#xff1b; &#xff08;1&#xff09;使用默认的初始值来初始化数组中…
阅读更多...
我的Python教程：Tkinter组件布局管理的3种方式

我的Python教程：Tkinter组件布局管理的3种方式

**Tkinter组件布局管理可以使用pack()方法、grid()方法和place()方法。**pack()方法将组件放置在窗口中&#xff0c;grid()方法将组件放置在网格布局中&#xff0c;place()方法将组件放置在指定位置。 01使用pack()方法布局&#xff1a; 在Tkinter中&#xff0c;pack方法用于将…
阅读更多...
【双指针_快乐数_C++】

【双指针_快乐数_C++】

题目解析 快乐数 算法原理 快慢双指针1、定义快慢指针 2、慢指针每次向后移动一步&#xff0c;快指针每次向后移动两步。 3、判断相遇的时候的值 编写代码 class Solution { public:int num_sum(int n){int sum 0;while(n!0){int t n%10;sumt*t;n n/10;}return sum;}bool…
阅读更多...
Visio Studio Code 搭建Vue开发环境

Visio Studio Code 搭建Vue开发环境

一、安装Visual Studio Code 使用 Visual Studio Code&#xff08;VS Code&#xff09;开发 Vue.js 应用是一种常见的做法&#xff0c;以下是简要的步骤&#xff1a; 安装 VS Code&#xff1a; 如果您尚未安装 Visual Studio Code&#xff0c;您可以从官方网站&#xff08;htt…
阅读更多...
作为一名软件测试工程师，需要具备哪些能力？

作为一名软件测试工程师，需要具备哪些能力？

软件测试工程师是个神奇的职业&#xff0c;他是开发人员与老板之间的传话筒&#xff0c;也是开发人员与老板的好帮手。他不仅需要有销售的沟通能力&#xff0c;也需要具备编辑人员的文档撰写技巧。如此一个面面俱到的岗位&#xff0c;他需要具备的技能到底有哪些呢&#xff1f;…
阅读更多...
互联网智能3D导诊系统源码支持微信小程序、APP

互联网智能3D导诊系统源码支持微信小程序、APP

通过智能导诊&#xff0c;进行自助问询及挂号服务&#xff0c;减轻导诊台护士压力&#xff0c;挂号更加方便快捷。 系统技术架构&#xff1a;springbootredismybatis plusmysqlRocketMQ 一、智慧导诊系统开发原理 导诊系统从原理上大致可分为基于规则模板和基于数据模型两类…
阅读更多...
人工智能进入到制造业后，可以带来哪些方面的新改变？

人工智能进入到制造业后，可以带来哪些方面的新改变？

随着人工智能&#xff08;AI&#xff09;进入制造业&#xff0c;它有可能带来重大变化和改进。以下是人工智能可以给制造业带来的一些关键变化&#xff1a; 1.提高效率和生产力&#xff1a;人工智能可以通过分析大量数据并识别低效率来优化生产流程。它可以帮助简化制造运营、…
阅读更多...
【100天精通python】Day28：文件与IO操作_JSON文件处理

【100天精通python】Day28：文件与IO操作_JSON文件处理

目录 专栏导读 1. JSON数据格式简介 1.1 示例JSON数据 1.2 JSON文件的特点 2 json模块的常用操作 2.1 读写JSON文件的示例 2.2 解析JSON字符串 2.3 修改JSON数据 2.4 查询和操作嵌套数据 2.5 处理包含特殊字符的JSON文件 2.6 处理日期和时间 2.7 处理大型JSON文…
阅读更多...
【web逆向】全报文加密及其登录流程的分析案例

【web逆向】全报文加密及其登录流程的分析案例

aHR0cHM6Ly9oZWFsdGguZWxkZXIuY2NiLmNvbS9zaWduX2luLw 涉及加密库jsencrypt 定位加密点 先看加密的请求和响应&#xff1a; 全局搜索加密字段jsondata&#xff0c;这种非特定参数的一般一搜一个准&#xff0c;搜到就是断点。起初下的断点没停住&#xff0c;转而从调用栈单步…
阅读更多...
MySQL—— 基础语法大全

MySQL—— 基础语法大全

MySQL—— 基础 一、MySQL概述1.1 、数据库相关概念1.2 、MySQL 客户端连接1.3 、数据模型 二、SQL2.1、SQL通用语法2.2、SQL分类2.3、DDL2.4、DML2.5、DQL2.6、DCL 三、函数四、约束五、多表查询六、事务 一、MySQL概述 1.1 、数据库相关概念 数据库、数据库管理系统、SQL&a…
阅读更多...
谈谈DNS是什么？它的作用以及工作流程

谈谈DNS是什么？它的作用以及工作流程

作者&#xff1a;Insist-- 个人主页&#xff1a;insist--个人主页 作者会持续更新网络知识和python基础知识&#xff0c;期待你的关注 目录 一、DNS是什么&#xff1f; 二、DNS的作用 三、DNS查询流程 1、查看浏览器缓存 2、查看系统缓存 3、查看路由器缓存 4、查看ISP …
阅读更多...
arcgis栅格数据之最佳路径分析

arcgis栅格数据之最佳路径分析

1、打开arcmap&#xff0c;加载数据&#xff0c;需要对影像进行监督分类&#xff0c;如下&#xff1a; 这里任选一种监督分类的方法&#xff08;最大似然法&#xff09;&#xff0c;如下&#xff1a; 这里会先生成一个.ecd文件&#xff0c;然后再利用.ecd文件对影像进行分类。如…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023