Python(乱学)

 

 

字典在转化为其他类型时，会出现是否舍弃value的操作，只有在转化为字符串的时候才不会舍弃value

注释的快捷键是ctrl+/

字符串无法与整数，浮点数，等用加号完成拼接

5不入？？？

还有一种格式化的方法

不限制类型，不做精度的控制

type()

判断的条件应是bool类型

仅仅是空格则不行

想要规范一些，就要遵循一些格式

必须在赋值之前声明为全局变量

del仅仅完成删除的操作

像append,extend都是不可以用的，因为元组不可以修改

传入的’12‘会被划分为两个小字符串’1‘’2‘

集合没有下表索引，故.pop不能指定下标来进行取出，而列表可以

集合不支持下标索引

字典不允许Key 的重复

list,tuple,setstring是没有办法去转化成字典的，但字典是可以转换成别的容器的,转换成字符串字典不会丢失value，转换成其他类型，字典会丢失value

容器的通用排序功能

排序的结果会变成列表对象

python函数进阶

（1）函数的多返回值

（3）匿名函数

2.函数的多种传参方式

（1）掌握位置参数

（2）关键字参数

（3）不定长参数

（4）缺省参数

位置参数与其他传参进行混用时，需要写在最前面，不然就会出现语法错误

默认参数必须定义在最后面

位置传递

kw指keyword

匿名函数

1.函数作为参数传递

实际上传入的是代码的执行逻辑

2.lambda匿名函数

默认直接return ,不用写return语句

并且没有办法进行回车换行写多行

python文件操作

了解编码

了解文件的操作

encoding参数在函数定义中并不是第3位，所以要使用关键字传参

f是对文本文件进行操作功能的对象

w:覆盖写入

read()得到的类型是字符串

这里的strip是为了去除换行符

文件的追加操作

应先换行再进行追加

文件操作案例：实现文件的备份操作

Python异常，模块与包

except(),这个括号是元组

所以的异常都是基于这个顶级的异常Exception

当捕获Exception时，所有的异常都可以捕获到

finally和exception都是可选的

异常的传递

故捕获异常时并不需要从真正出现异常的那一行开始捕获

python模块

模块的导入

[ ]表示的都是可选的意思

例：from time import *相较于直接import time的不同在于

前者可以直接使用内部的函数sleep()，而后者需要time.sleep()

“.”是用于确定层级关系的

给导入的功能设置一个别名

自定义模块

模块名要符合标识符的命名规则

这种定义函数的写法应再了解一下

右键run 的时候内置函数__name__就会被标记为__main__,故if语句成立，执行

python文件都存在__name__的这个内置变量

当以from的模块导入运行的时候，模块内部的__name__不会被标记为__main__

上图在主函数只能够使用test_A(),而不能使用test_B()，__all__指向列表

但可以自行导入未包含在__all__内的函数，

但是__all__不会限制你直接导，from my_module import pr1,就可以使用pr1

python包

（1）自定义包

（2）如何安装第三方包

只有__init__.py文件存在于文件夹当中，那么这个文件夹就是python包，否则就是一个普通的文件夹

可以直接深入到对应的模块函数

安装第三方包

json数据格式

什么是json

如何使用json进行数据转化

json如果是列表的话，要求其元素一定是字典

如果为true，中文就会转化为unicode字符了

注：

pyecharts模块介绍

https://05x-docs.pyecharts.org/#/zh-cn/

https://gallery.pyecharts.org/#/README

pyecharts快速入门

构建一个基础的折线图

使用全局配置项设置属性

构建基础的折线图

使用全局配置项设置属性

数据处理

通过json模块对数据进行处理

import json 
f_us = open("D:/美国.txt","r",encoding="UTF-8")
f_us_data = f_us.read()#读取数据成字符串
 
f_us_data = f_us_data.replace("jsonp_1629344292311_69436(","")#删除开头不需要的部分
f_us_data = f_us_data[:-2]#删除结尾的部分
f_us_dict = json.loads(f_us_data)#转换为字典
 
trend_data = f_us_dict["data"][0]["trend"]#将范围缩小到“trend”
 
x_data = trend_data["updateDate"][:314]#拿到日期数据
y_data = trend_data["list"][0]["data"][:314]#拿到“确诊”数据

创建折线图

import json 
from pyecharts.charts import Line
from pyecharts.options import TitleOpts,LabelOpts
f_us = open("D:/美国.txt","r",encoding="UTF-8")
f_jp = open("D:/日本.txt","r",encoding="UTF-8")
f_in = open("D:/印度.txt","r",encoding="UTF-8")
 
f_us_data = f_us.read()#读取数据成字符串
f_jp_data = f_jp.read()
f_in_data = f_in.read()
 
f_us_data = f_us_data.replace("jsonp_1629344292311_69436(","")#删除开头不需要的部分
f_jp_data = f_jp_data.replace("jsonp_1629350871167_29498(","")
f_in_data = f_in_data.replace("jsonp_1629350745930_63180(","")
 
f_us_data = f_us_data[:-2]#删除结尾的部分
f_jp_data = f_jp_data[:-2]
f_in_data = f_in_data[:-2]
 
f_us_dict = json.loads(f_us_data)#转换为字典
f_jp_dict = json.loads(f_jp_data)
f_in_dict = json.loads(f_in_data)
 
us_trend_data = f_us_dict["data"][0]["trend"]#将范围缩小到“trend”key
jp_trend_data = f_jp_dict["data"][0]["trend"]
in_trend_data = f_in_dict["data"][0]["trend"]
 
us_x_data = us_trend_data["updateDate"][:314]#拿到日期数据,并取到2020年的12月31号
jp_x_data = jp_trend_data["updateDate"][:314]
in_x_data = in_trend_data["updateDate"][:314]
 
us_y_data = us_trend_data["list"][0]["data"][:314]#拿到“确诊”数据
jp_y_data = jp_trend_data["list"][0]["data"][:314]
in_y_data = in_trend_data["list"][0]["data"][:314]
 
line = Line()
 
line.add_xaxis(us_x_data)
 
line.add_yaxis("美国确诊人数",us_y_data,label_opts=LabelOpts(is_show=False))
line.add_yaxis("日本确诊人数",jp_y_data,label_opts=LabelOpts(is_show=False))
line.add_yaxis("印度确诊人数",in_y_data,label_opts=LabelOpts(is_show=False))
line.set_global_opts(
    title_opts=TitleOpts(title="2020年美印日三国的确诊人数对比折线图",pos_left="center",pos_bottom="1%")#设置标题居中朝下
)
 
line.render()#生成图表
 
f_us.close()
f_in.close()
f_jp.close()

地图可视化

基础地图使用

from pyecharts.charts import Map
from pyecharts.options import VisualMapOpts
map = Map()
data = [
    ('北京市', 99),
    ('上海市', 199),
    ('重庆市', 200),
    ('四川省', 399),
    ('广东省', 499)
]
 
map.add("地图",data,"china")#添加数据
 
#设置全局选项
map.set_global_opts(
    visualmap_opts=VisualMapOpts(
        is_show=True,
        is_piecewise=True,
        pieces=[
            {"min":1,"max":9,"label":"1-9","color":"#CCFFFF"},
            {"min":10,"max":99,"label":"10-99","color":"#FF6666"},
            {"min":100,"max":500,"label":"100-500","color":"#990033"}
        ]
    )
 
)
map.render()#生成地图数据

疫情地图-国内疫情地图

import json
from pyecharts.charts import Map
from pyecharts.options import VisualMapOpts
map = Map()
f = open("D:/疫情.txt","r",encoding="UTF-8")
data_str = f.read()#读取全部数据
f.close()
data_dict = json.loads(data_str)#将json转化为字典
province_list = data_dict["areaTree"][0]["children"]#将每个省的数据都封装入列表中
data_list = []#设定数据列表
for province_data in province_list:
    province_name = province_data["name"]#省份名称
    province_confrm = province_data["total"]["confirm"]#每个省份的确诊人数
    data_list.append((province_name,province_confrm))#将数据压入到数据列表中
print(data_list)
 
map.add("地图",data_list,"china")#添加数据
 
#设置全局选项
#注意现在的pyechats显示地图数据需要写省份的全名，不然不会显示数据，这里由于省份数量过多，就不进行添加了
map.set_global_opts(
    visualmap_opts=VisualMapOpts(
        is_show=True,
        is_piecewise=True,
        pieces=[
            {"min":1,"max":9,"label":"1-9","color":"#CCFFFF"},
            {"min":100,"max":999,"label":"100-999","color":"#FFFF99"},
            {"min":1000,"max":4999,"label":"1000-4999","color":"#FF9966"},
            {"min":5000,"max":9999,"label":"5000-9999","color":"#FF6666"},
            {"min":10000,"max":99999,"label":"10000-99999","color":"#CC3333"},
            {"min":100000,"label":"100000+","color":"#990033"}
        ]
    )
)
map.render("全国疫情地图数据.html")#生成地图数据

疫情地图-省级疫情地图

import json
from pyecharts.charts import Map
from pyecharts.options import VisualMapOpts,TitleOpts
f = open("D:/疫情.txt","r",encoding = "UTF-8")
data = f.read()
data_dict = json.loads(data)
henan_data = data_dict["areaTree"][0]["children"][3]["children"]
area_list = []
area_list.append(("济源市",5))
for area_data in henan_data:
    area_name = area_data["name"]+"市"
    area_confirm = area_data["total"]["confirm"]    
    area_list.append((area_name,area_confirm))
map = Map()
map.add("河南",area_list,"河南")
map.set_global_opts(
    title_opts=TitleOpts(title="河南省疫情地图",pos_bottom="1%",pos_left="center"),
    visualmap_opts=VisualMapOpts(
        is_show=True,
        is_piecewise=True,
        pieces=[
            {"min":1,"max":99,"label":"1-99","color":"#CCFFFF"},
            {"min":100,"max":999,"label":"100-999","color":"#FFFF99"},
            {"min":1000,"max":4999,"label":"1000-4999","color":"#FF9966"},
            {"min":5000,"max":9999,"label":"5000-9999","color":"#FF6666"},
            {"min":10000,"max":99999,"label":"10000-99999","color":"#CC3333"},
            {"min":100000,"label":"100000+","color":"#990033"}
        ]
    )
)
map.render("河南省疫情分布图.html")

动态柱状图

基础柱状图

from pyecharts.charts import Bar
from pyecharts.options import LabelOpts
bar = Bar()
bar.add_xaxis(["Akebi","Komichi","Hobert"])
bar.add_yaxis("age",[15,15,19],label_opts=LabelOpts(position = "right"))#将Y轴的数据标签显示在最右侧
bar.reversal_axis()#反转XY轴，从左往右显示
bar.render()

基础时间线柱状图

基础时间线配置动态图表

主题更改颜色样式

from pyecharts.charts import Bar,Timeline
from pyecharts.options import LabelOpts
from pyecharts.globals import ThemeType
bar1 = Bar()
bar1.add_xaxis(["Akebi","Komichi","Hobert"])
bar1.add_yaxis("age",[15,15,19],label_opts=LabelOpts(position = "right"))#将Y轴的数据标签显示在最右侧
bar1.reversal_axis()#反转XY轴，从左往右显示
 
bar2 = Bar()
bar2.add_xaxis(["Akebi","Komichi","Hobert"])
bar2.add_yaxis("age",[20,20,25],label_opts=LabelOpts(position = "right"))#将Y轴的数据标签显示在最右侧
bar2.reversal_axis()#反转XY轴，从左往右显示
 
bar3 = Bar()
bar3.add_xaxis(["Akebi","Komichi","Hobert"])
bar3.add_yaxis("age",[23,23,28],label_opts=LabelOpts(position = "right"))#将Y轴的数据标签显示在最右侧
bar3.reversal_axis()#反转XY轴，从左往右显示
 
timeline = Timeline({"theme":ThemeType.LIGHT})#设置主题颜色
 
timeline.add(bar1,"点1")
timeline.add(bar2,"点2")
timeline.add(bar3,"点3")
 
#自动播放设置
timeline.add_schema(
    play_interval=1000,         #自动播放的时间间隔
    is_timeline_show=True,      #是否显示时间线
    is_auto_play = True,         #是否自动播放
    is_loop_play=True          #循环
)
 
 
 
timeline.render()#改用时间线进行绘图

GDP动态柱状图

 
"""
定义lambda函数的形式
"""
list1 = [["Akebi",15],["Komichi",13],["Hobert",19]]
list1.sort(key = lambda x:x[1],reverse=False)#设置排序的依据为导入的列表元素的下标为1的元素
print(list1)
 
 
"""
普通定义函数的形式
"""
list1 = [["Akebi",15],["Komichi",13],["Hobert",19]]
def fuc(x):
    return x[1]#将下标1返回按照数字进行排序
list1.sort(key = fuc,reverse=False)#函数传参，只需传入函数名即可
print(list1)

导入csv格式的数据

ANSI表示WINDOWS模式下的默认编码格式，即表示跟随操作系统的语言版本变化的

win11是中文，那么默认的中文编码就是GB2312

字典中的key如果不存在，对其调用就会报错

from pyecharts.charts import Bar,Timeline
from pyecharts.options import *
from pyecharts.globals import *
f = open("D:/1960-2019全球GDP数据.csv","r",encoding = "GB2312")
data_lines = f.readlines()
data_lines.pop(0)#要注意使用pop方法的格式
data_dict = {}
 
for line in data_lines:
    year = int(line.split(",")[0])#要将年份转换为整型
    country = line.split(",")[1]
    GDP = float(line.split(",")[2])#可以将科学计数法的数用float进行转换
    try:
        data_dict[year].append([country,GDP])
    except Exception:#由于字典中如果没有对应的key，却进行了调用，程序会报错，利用捕获，就可以判断是否有key，并进行赋值操作
        data_dict[year] = []
        data_dict[year].append([country,GDP])
sort_year_list = sorted(data_dict.keys())
timeline = Timeline({"theme":ThemeType.LIGHT})
 
for year in sort_year_list:
    data_dict[year].sort(key=lambda x:x[1],reverse = True)
    x_data = []
    y_data = []
    for country_gdp in data_dict[year][0:8]:
        x_data.append(country_gdp[0])
        y_data.append(country_gdp[1]/100000000)#单位为亿
    x_data.reverse()
    y_data.reverse()
    bar = Bar()
    bar.add_xaxis(x_data)
    bar.add_yaxis("GDP(亿)",y_data,label_opts=LabelOpts(position="right"))
    bar.reversal_axis()
    bar.set_global_opts(#设置标题
        title_opts=TitleOpts(title=f"{year}年世界前8GDP数据")
    )
    timeline.add(bar,str(year))
 
#设置自动播放
timeline.add_schema(
    play_interval=1000,
    is_auto_play=True,
    is_loop_play=True,
    is_timeline_show=True
     
)
timeline.render()
 
    
 
 
 
 

初识对象

成员方法

函数是写在类的外面的

而方法是定义在类的里面的函数

类和对象

面向对象，简单来说，就是让对象按命令去干活

构造方法

其他内置方法（魔术方法）

将类对象变成字符串

在def __str_的“return”可以修改输出字符串的类型

">"和"<",不能直接比较两个类对象

other 表示的是另一个用于比较的对象

lt不支持小于等于和大于等于

"=="该符号默认比较内存地址

而"__eq__"则可以实现成员变量间的比较

封装

将现实世界的事物封装到了程序的内部

私有成员可以通过运行其他成员而执行

私有成员和方法是没有办法被类对象直接使用的

但在创建类的时候，却可以进行使用

继承

继承的基础语法

pass关键字用于补全语法，保证定义的完整性

在子类调用父类的成员

复写和使用父类成员

self相当于C++中的this指针

super其实是指父类的意思

运用场景：

父类拥有部分功能，子类在父类的基础上拓展了相应的功能，但要沿用父类的一些功能可以直接调用父类成员，不用重写

类型注解

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

函数（方法）的类型注解

形参注解

返回值注解

 

alt+回车=导入函数包

json.loads可以将字符串格式转变为字典格式

注解写错并不会产生运行的问题

Union类型

需要先进行导包

多态

同一种行为，不同的运行状态

 以标准来约束某些行为

抽象类用于顶层设计 ，以便子类做具体的实现。

也是对子类的一种软性约束，要求子类必须复写（实现）父类的一些方法

有了标准后，真正工作的是其子类

这里在定义好类后，一定要记得创建子类的对象，然后用子类创建的对象进行传参

定义函数的类型注解的是父类对象，实际上传入的是子类对象（由于子类将父类的方法进行了复写）

综合案例

在本案例的实现过程中，我犯了很多经典错误，导致浪费了大量的时间

我用python的内置类型名list作为变量名，导致出错，自定义类无法正常调用

源码文件

data_save.py

class Record:
    def __init__(self,time,date,name):
        self.time = time
        self.date = date
        self.name = name
    def __str__(self):
        return f"{self.time},{self.date},{self.name}"
    # def __call__(self, *args, **kwargs):
    #     return f"{self.time},{self.date},{self.name}"
    
#利用__str__将print(record)的数据转换为自定义类型

 file_def.py

from date_save import Record
import json 
class AC :#定义抽象类，实现顶层设计
    def readFile(self):#读取文件数据，读到的每一条数据都转换为Record对象，将他们都封装到list返回即可
        pass
class File1(AC):
    def __init__(self,path):    #定义成员变量记录文件的路径
        self.path = path
    def readFile(self):
        f1 = open(self.path,"r",encoding="UTF-8")
        
        record_list = []
        for i in f1.readlines():  #括号里不需要加内容
            i = i.strip()#消除每一行读取到的\n
            i_list = i.split(",")
            record = Record(i_list[0],int(i_list[1]),i_list[2])
            record_list.append(record)
        f1.close
        return record_list
class File2(AC):
    def __init__(self,path):
        self.path = path
    def readFile(self):
        f1 = open(self.path,"r",encoding="UTF-8")
        record_list = []
        for i in f1.readlines():
            data_dict = json.loads(i)#读取一行就转换一行
            record = Record(data_dict["time"],int(data_dict["data"]),data_dict["name"])
            record_list.append(record) 
        f1.close()
        return record_list
if __name__ == '__main__':
    file1 = File1("D:/Akebi.txt")
    file2 = File2("D:/Komichi.txt")
    list1 = file1.readFile()
    list2 = file2.readFile()#json的数据格式一定检查，str在json数据中一定要用" "，可以写成字典的形式
    for l in list1:
        print(l)
    for l in list2:
        print(l)
    # print(list1)
    # print(list2)

main.py

from file_def import File1,File2
from date_save import Record
from pyecharts.charts import Bar
from pyecharts.options import *
from pyecharts.globals import ThemeType
file1 = File1("D:/Akebi.txt")
file2 = File2("D:/Komichi.txt")
list1 = file1.readFile()
list2 = file2.readFile()
all_list: list[Record] = list1+list2
data_dict = {}
for record in all_list:
    if record.time in data_dict.keys():
        data_dict[record.time] +=record.date
    else:
        data_dict[record.time] = record.date
# print(list(data_dict.keys()))
# dict = {"Akebi":14,"Komichi":13}
# print(data_dict.keys())
# print(data_dict.values())
print(data_dict)
print(data_dict.keys())
print(list(data_dict.keys()))
bar = Bar()
bar.add_xaxis(list(data_dict.keys()))
bar.add_yaxis("爆金币",list(data_dict.values()),label_opts=LabelOpts(is_show=False))
bar.render("爆金币的柱状图.html")

SQL

数据库介绍

MySQL安装

MySQL的使用

ｓｈｏｗ　ｄａｔａｂａｓｅｓ　；

8.0.36版本的要在分号前加个空格 

前三个数据库是供MySQL内部使用的，ｄｂｅａｖｅｒ为防止误操作，将前三个库进行了隐藏

SQL基础与DDL

 DML插入，删除，更新的语法

［　］表示的意思是可选，即可写可不写

DQL 

基础查询

＊一般代表通配符的意思

分组聚合

 

前面字段（非聚合函数）写了其他的列会报错 

ｃｏｕｎｔ（＊）：按性别来分，有几行就数几行

排序分页 

ASC表示升序，默认的升序可以不写 

limit 10,5 :表示跳过前面的十条直接从第十一条开始，往后取5条

python操作数据库 

基础使用

非查询性质的SQL语句 

 

执行查询性质的SQL语句 

 

数据插入

 综合案例 

main.py

from pymysql import Connection
from file_def import File1,File2
from date_save import Record
from pyecharts.charts import Bar
from pyecharts.options import *
from pyecharts.globals import ThemeType
file1 = File1("D:/Akebi.txt")
file2 = File2("D:/Komichi.txt")
list1 = file1.readFile()
list2 = file2.readFile()
all_list: list[Record] = list1+list2
conn = Connection(
    host = "localhost",
    port = 3306,
    user = "root",
    password = "5549186862XHBabc",
    autocommit = True
)
cursor = conn.cursor()#获取游标对象
conn.select_db("Komichi")#选择数据库
for record in all_list:#组织sql语句
    sql = f"insert into orders(my_time,my_data,name) values ('{record.time}',{record.date},'{record.name}')"
    cursor.execute(sql)#执行sql语句
conn.close()

data_save.py

file_def.py

(这两个代码文件可以到上一个综合案例来看)