【深度学习入门】深度学习四板斧其一 -- Python入门学习笔记3

茗小丧帅

已于 2023-06-30 16:57:48 修改

阅读量95

点赞数

文章标签： python 深度学习

于 2023-06-29 11:25:57 首次发布

本文链接：https://blog.csdn.net/qq_45891093/article/details/131452849

版权

十、面向对象

-面向对象编程：#设计类，基于类创建对象，由对象做具体的工作
-初始对象：#类可以看作是模板，对象则是对类的一次具体实现
设计一张表格：设计类（class）
打印该表格：创建对象
填写该表格：对象属性赋值
-类的成员方法：

class fruit:
    name = None
    def print_fruit(self):
        print(f"您购买的水果是：{self.name}")
f = fruit()
f.name = "苹果"
f.print_fruit()
#输出：您购买的水果是：苹果

-构造方法：#__ init __()
在构造类时，构造方法会自动执行，并且将传入参数自动传递给构造方法使用。

class fruit:
    name = None
    price = None
    num = None
    def __init__(self,name,price,num):
        self.name = name
        self.price = price
        self.num = num
        print(f"您购买的水果是：{self.name}，价格为{self.price}，数量为{self.num}")
f = fruit("苹果",5,1)
#输出：您购买的水果是：苹果，价格为5，数量为1

-魔术方法：

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

s1 = Student("小王",18)
print(s1)
#输出：Student对象，name:小王，age:18
s2 = Student("小张",20)
print(s1 < s2)
#输出：True
print(s1 <= s2)
#输出：True
s3 = Student("小刘",18)
print(s1 == s3)
#输出：True

-封装：#面向对象的三大特性：封装、继承、多态
封装可以理解为如何把现实世界中的事物，描述为我们程序中的类。
私有成员和方法，仅限于类的内部使用。
-继承：
继承就是一个类，继承另一个类的成员变量和成员方法。
在多继承中，如果父亲有同名方法或属性，先继承的优先级高于后继承。
pass关键字，pass是普通的占位语句，用来保证类定义的完整性，表示无内容，空的意思。

class MyPhone(Phone,NFCReader,RemoteControl)
    pass

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

#方法1
父类名.成员变量
父类名.成员方法(self)
#方法2
super().成员变量
super().成员方法()

-类型注解：
可以给开发工具对代码做类型推断做代码提示、开发者自身做类型的备注，
类型注解只是提示性的，并非决定性的，数据类型和注解类型无法对应不会导致错误。

import random
# 基础容器类型注解
my_list:list = [1,2,3]
# 容器类型详细注解
my_list:list[int] = [1,2,3]
# 在注释中进行类型注解
var = random.randint(1,10)   #type:int
#对形参进行类型注解
def add(x:int,y:int):
    return x + y
#对返回值进行类型注解
def func(data:list) -> list:
    return data
#使用Uoion类型进行类型注解
from typing import Union
my_list:list[Union[int,str]] = [1,2,"apple","banana"]

-多态：
多态指的是，同一个行为，使用不同的对象获得不同的状态。
包含抽象方法的类，称之为抽象类；抽象方法指的是没有具体实现的方法（pass）。
抽象类多用于顶层设计，以便于子类做具体实现；也是对子类的一种软性约束，要求子类必须复写（实现）父类的一些方法。
-面向对象实例：

#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_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__':
    text_file_reader = TextFileReader("2011年1月销售数据.txt")
    json_file_reader = JsonFileReader("2011年2月销售数据JSON.txt")
    list1 = text_file_reader.read_data()
    list2 = json_file_reader.read_data()

    for l in list1:
        print(l)
    for l in list2:
        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("2011年1月销售数据.txt")
json_file_reader = JsonFileReader("2011年2月销售数据JSON.txt")
jan_data:list[Record] = text_file_reader.read_data()
feb_data:list[Record] = json_file_reader.read_data()
#将两个月份数据合并为一个
all_data:list[Record] = jan_data + feb_data

#进行数据计算
#{"2011-01-01":1234,......}
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()))
bar.add_yaxis("销售额",list(data_dict.values()),
              label_opts=LabelOpts(is_show=False))
bar.set_global_opts(
    title_opts=TitleOpts(title="每日销售额"),
    toolbox_opts=ToolboxOpts(is_show=True)
)
bar.render("每日销售额柱状图.html")