Python-基础语法五-数据可视化、对象、类、多态、继承、封装、抽象类

可视化图表

一、JSON数据格式

（1）JSON是一种轻量级的数据交互格式。可以按照JSON指定的格式去组织和封装数据

（2）JSON本质上是一个带有特定格式的字符串

（3）主要功能:

json就是一种在各个编程语言中流通的数据格式，负责不同编程语言中的数据传递和交互

（4）JSON ---Python中的列表（嵌套字典）[ {"":,..}]/字典 {"":,..}

2.Python数据和JSON数据的相互转换

（1）导入JSON模块

import json

（2）# 准备符合格式json格式要求的python数据

data = [{"name":"老王","age": 16},{"name":"张三","age":20}]

（3）# 通过 json.dumps(data)方法把python数据转化为了json数据 data=json.dumps(data，ensure_ascii=False)

（4）# 通过 json.loads(data)方法把json数据转化为了 python数据 data=json.loads(data)

from pyecharts.charts import Line
from pyecharts.options import TitleOpts, LegendOpts, ToolboxOpts, VisualMapOpts

# 1.得到折线图对象
line=Line()
# 2.添加X轴数据
line.add_xaxis(["中国","美国","英国"])
# 3.添加Y轴数据
line.add_yaxis("GDP",[30,20,10])
# 4.1 设置全局配置项set_global_opts
line.set_global_opts(
    title_opts=TitleOpts(title="GDP展示",pos_left="center",pos_bottom="1%"),
    legend_opts=LegendOpts(is_show=True),
    toolbox_opts=ToolboxOpts(is_show=True), # 工具箱
    visualmap_opts=VisualMapOpts(is_show=True), # 视觉映射
)

# 5.生成图表
line.render()

二、pyecharts（数据分析与可视化）

1.pyecharts模块：可以做出数据可视化效果图

2.Echarts是由百度开源的数据可视化

3.pyecharts模块的配置选项：

（1）全局配置选项 set_global_opts

（2）系列配置选项

4.数据处理

（1）data_define

"""
数据相关类
"""
class Record:
    """
    以构造方法的形式定义成员变量
    """
    def __init__(self,date,order_id,money,province):
        self.date = date
        self.order_id = order_id
        self.money = money
        self.province = province
    def __str__(self):
        return  f"{self.date},{self.order_id},{self.money},{self.province}"

（2）file_define

"""
文件相关类定义
"""
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=[]
        for line in f.readlines():
            line=line.strip()  # 消除回车符
            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


# 实现JSON格式的读取
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=[]
        for line in f.readlines():
            data_dict=json.loads(line)
            record=Record(data_dict["date"],data_dict["order_id"],int(data_dict["money"]),data_dict["province"])
            record_list.append(record)

        f.close()
        return record_list


# 测试
if __name__ == '__main__':
    # try1=TextFileReader(r"D:\test_file\python_write.txt")
    # try1.read_data()
    try2=JsonFileReader(r"D:\test_file\2011年2月销售数据JSON.txt")
    list2=try2.read_data()
    for record in list2:
        print(record)

（3）main.py

# 面向对象 -数据分析-主业务逻辑代码

"""
实现步骤:
1.设计一个类，可以完成数据的封装
设计一个抽象类，定义文件读取的相关功能，并使用子类实现具体功能
读取文件，生产数据对象
进行数据需求的逻辑计算(计算每一天的销售额)
通过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(r"D:\test_file\2011年1月销售数据.txt")
json_file_reader=JsonFileReader(r"D:\test_file\2011年2月销售数据JSON.txt")
jan_data:list[Record]=text_file_reader.read_data()
feb_data:list[Record]=json_file_reader.read_data()
# 将两个月份的数据合并成一个list存储
all_data=jan_data+feb_data
#进行数据计算 计算每一天的销售额 --字典 key value
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()
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")
print(data_dict)

对象

一、

1.使用对象组织数据

（1）设计类class

class Student:

name=None

（2）创建对象

stu_1=Student()

（3）对象属性赋值

stu_1.name="jack"

2.类的定义与使用

（1）class 类名称：

类的属性 定义在类中的变量/属性（成员变量）

类的行为 定义在类中的函数/行为（成员方法）

（2）创建类对象的语法：

对象=类名称（）

（3）成员方法的定义语法：

def 方法名（self,形参1，...，形参N）：

方法体

（4）self关键字：用于成员方法定义，表示类对象自身；使用类对象调用方法时，self会自动被Python传入；在方法内部，想要访问类的成员变量，必须使用self

class Student:
    name=None
    age=None

    # 在方法内部，想要访问类的成员变量，必须使用self
    def say_hi(self,msg):
        print(f"hi，我是{self.name},{msg}")

stu1=Student()
stu1.name="try1"
stu1.age=23
print(stu1.name)
print(stu1.age)
stu1.say_hi("好吧好吧")

3.类和对象

（1）面向对象：设计类，基于类创建对象，由对象做具体的工作

# 面向对象
class Clock:
    id=None
    price=None

    def ring(self):
        import winsound
        winsound.Beep(2000,3000)  #发出声音 2000表示频率，3000表示持续时间

# 构建两个闹钟
clock1=Clock()
clock1.id="003201"
clock1.price=19,23
clock1.ring()

4.构造方法

（1）_ init _()方法，称为够构造方法

（2）它可以实现：

在创建类对象（构造类）的时候，自动执行

，将传入参数自动传递给_ init _方法使用

（3）class Student:

name = None

age = None

tel = None ---可以省略

def__init__(self, name, age, tel):

self.name = name

self.age = age

self.tel = te]

print("Student类创建了一个对象")

stStudent（"aaa",31,"111111"）

（4）使用构造方法对 对象进行赋值：

student=Student(name,age,address)

# 构造方法 __init__()

class Student():
    def __init__(self, name, age, tel):
        self.name = name
        self.age = age
        self.tel = tel
        print("-----")

stu=Student("aaa",23,"999999")
print(stu.name)
print(stu.age)
print(stu.tel)

5.其它内置方法

（1）内置方法：如__init__()，这些内置方法，各自有各自特殊的功能，将这些内置方法称为：魔术方法

（2）init 构造方法

（3）str 字符串方法

控制类（的内存地址）转换为字符串

（在类内部）

def str(self):

return f"Student类对象，name:{self.name}"

（4）__lt __ 小于、大于符号比较

def lt(self,other): # other:另一个类的对象

return self.age<other.age 返回值是bool

（5）le 小于等于、大于等于符号比较

（6）eq ==符号比较

若不实现eq 默认比较内存地址

# 内置方法 __str__

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

    # 字符串
    def __str__(self):
        return f"Student {self.name} {self.age}"

    # 大于小于 lt
    def __lt__(self,other): # other:表示其它的类的对象
        return self.age < other.age

    # 大于等于 小于等于 le

    # 比较内容是否相等 eq   --若不实现eq 默认比较内存地址

stu=Student("AAAA",13)
stu2=Student("BBBB",14)
print(stu>stu2)
print(stu)

6.面向对象 --封装

（1）面向对象编程：基于模版（类）去创建实体（对象），使用对象完成功能开发

（2）面向对象三大特性：封装、继承、多态

（3）封装：将现实世界事物的属性、行为，封装到类中，描述成 成员变量、成员方法

（4）类中提供：私有成员的形式 --类的对象无法使用

私有成员变量 变量名以__（两个下划线）开头

私有成员方法 方法名以__开头

（5）使用私有成员：

私有成员不能被类对象使用，但是可以被类的其它的成员使用

（6）私有成员的实际意义：在类中提供仅供内部使用的属性，而不对外开放（类的对象无法使用）

# 私有成员（变量和方法）不能被雷的对象使用，但可以被类的其它成员使用

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("电量不足，手机自动进入单核运行模式")

p1=Phone()
p1.call_by_5g()

class Phone:
    # 私有成员变量
    __is_5g_enable=True

    # 私有成员方法
    def __check_5g(self):
        if self.__is_5g_enable:
            print("5G开启")
        else:
            print("5G关闭，使用4G网络")

    # 公开成员方法
    def call_by_5g(self):
        self.__check_5g()
        print("正在通话中...")

p1=Phone()
p1.call_by_5g()

7.面向对象--继承

（1）class Phone:

IMEI=None

producer=None

def ...

class Phone2(Phone):

face_id=True

...

（2）class 类名 （父类名）：

类内容体

（3）继承分为：单继承和多继承

（4）继承表示：继承父类的成员变量和成员方法（不含私有）

（5）多继承

class 类名（父类1，...，父类N）：

类内容体

（6）pass 关键字 表示当前没有功能，如一个类继承多个类时，类内部可以使用pass

pass 表示空操作，用来占位，表示"什么都不用做，但是语法上需要有代码"，可以用在任何需要代码块的地方

（7）当继承多个类，有重复属性（如producer），输出同名成员属性时，输出最先继承的

即多继承时，继承的顺序为优先级（降序） --先继承的优先级最高

# 面向对象------单继承
class Phone:
    IMEI=None
    price=None
    prodecer="AI"

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

class Phone_new(Phone):
    face_id="10001"  #面别识别id

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

phone_new=Phone_new()
phone_new.call_by_4g()
phone_new.call_by_5g()
print(phone_new.IMEI)

# 多继承
class NFCReader:
    nfc_type="No.5"
    producer="HM"

    def read_card(self):
        print("NFC读卡")

    def write_card(self):
        print("NFC写卡")

class RemoteControll:
    rc_type="红外遥控"
    def control(self):
        print("红外遥控开启")

class MyPhone(Phone,RemoteControll,NFCReader):
    pass  # pass关键字表示空操作，"什么都不用做，但是语法上需要有代码"

phone=MyPhone()
phone.control()

# 当继承多个类，有重复属性（如producer）  先继承，优先级最高

8.面向对象--继承--重写

（1）重写：在子类中重新定义同名的属性或方法

java中是方法重写（属性不能被重写，只能覆盖，即还是可以通过super.name等访问到父类的name）

（2）当复写父类成员后，对象默认调用复写后的新成员

（3）调用被复写的父类的成员：

A.调用父类成员：

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

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

Phone.call_by_5g(self)

B.使用super()调用父类成员

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

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

class Phone:
    IMEI=None
    price=None
    prodecer=None

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

class MyPhone(Phone):
    def call_by_5g(self):
        print("开启单核CPU，...")
        super().call_by_5g()
        print("关闭CPU单核模式，...")

my_phone=MyPhone()
my_phone.call_by_5g()

phone=Phone()
phone.call_by_5g()

9.类型注解

（1）类型注解：

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

（2）主要功能：

帮助第三方IDE工具，如PyCharm对代码进行类型推断，协助做代码提示

帮助开发者自身对变量进行类型注释

（3）支持：

变量的类型注解

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

（4）为变量设置类型注解：

基础数据类型注解：

变量：类型

var_1: int=10

类对象类型注解：

class Student:

pass

stu:Student=Student()

容器类型详细注解：

my_list:list[int]=[1,2,3]

my_tuple；tuple[str,int,bool]=("AAA",2,True)

基础容器类型注解：

my_list:list=[1,2,3]

"""
变量类型注解
"""
import json
from random import random

# 1.基础数据类型注解
var_1:int=11

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

# 3.容器类型基础注解
list1:list=[1,2,3,4]
# 4.容器类型详细注解
list2:list[int]=[5,6,7,8]
tuple1:tuple[int,str,bool,int]=(1,"NNN",True,4)
dict1:dict[str,int]={"CCC",4}

# 5.使用注释进行变量类型注解
var1=random.randint(1,9) # type:int
var2-json.loads('{"name":"zhangsan","age":18}"') # type:dict[str,str]

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

（6）除了使用 变量：类型 做注解，还可以在注释中惊醒类型注解

type:int

（7）显示定义，如 var1=10 一般不需要添加类型注解

一般在无法直接看出变量类型时，添加变量的类型注解

如var2:Student=func()

（8）类型注解仅仅是提示性的，如var3:int="jjjkk" 并不会报错

10.类型注解--函数和方法的类型注解（形参、返回值）

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

def 函数方法名（形参名：类型，形参名：类型，...）：

pass

（2）对返回值进行类型注解

def 函数方法名（形参：类型，形参名：类型，...）->返回值类型：

pas

"""
对函数/方法进行类型注解
类型注解只提示性
"""

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

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

11.类型注解 --Union类型 描述混合类型

（1）Union[]类型,...,类型] 定义联合类型注解

list1:list[Union[str,int]]=[1,2,"dd","cc"]

（2）

my_dict: dict[str,union[str,int]]={"name":"周"，"age": 31}

（3）对函数：

def func(dataUnion[int, str])->funion[int, str]:

pass

# Union 联合类型注解
from typing import Union

# 1.Uniion --用于变量类型注解
list1:list[Union[int,str]]=[1,2,"kko"]
# 2.Union --用于方法类型注解
def func(data:Union[int,str])->Union[int,str]:
    pass
func()

12.面向对象 --多态

（1）多态是指：多种状态，即完成某个行为时，使用/传入不同的对象会得到不同的状态

# 多态

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)

（2）多态常作用在继承关系上

函数/方法形参生命接收父类对象

实际传入父类的子类对象

即：

以父类做生命定义；以子类做实际工作；用以获得同一行为，不同状态

13.抽象类（接口）

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

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

（3）父类确定有哪些方法；具体的方法实现，由子类自行决定

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

gree=GREE_AC()
midea=Midea_AC()
make_cool(midea)
make_cool(gree)

二、总结