基础语法
# 单行注释
"""多行注释"""
name = "joffee"
tel = 11
price = 11.23
print("名字: %s,电话 %d,价格: %f" % (name, tel, price))
#类型
print(type(tel))
# %5.2代表宽带5,小数点的精度为2，宽度不够前填空格，小于数字宽度失效
price = 11.2333
print("名字: %s,电话 %3d,价格: %5.3f" % (name, price, price))
# 字符串格式化
print(f"名字: {name},电话 {price},价格: {price}")
name = input("请输入你的名字")
判断语句
# 1. 构建一个随机的数字变量
import random
num = random.randint(1, 10)
guess_num = int(input("输入你要猜测的数字："))
# 2. 通过if判断语句进行数字的猜测
if guess_num == num:
print("恭喜，第一次就猜中了")
else:
if guess_num > num:
print("你猜测的数字大了")
else:
print("你猜测的数字小了")
guess_num = int(input("再次输入你要猜测的数字："))
if guess_num == num:
print("恭喜，第二次猜中了")
else:
if guess_num > num:
print("你猜测的数字大了")
else:
print("你猜测的数字小了")
guess_num = int(input("第三次输入你要猜测的数字："))
if guess_num == num:
print("第三次猜中了")
else:
print("三次机会用完了，没有猜中。")
循环
while 条件1:
条件成立重复执行的代码1
条件成立重复执行的代码2
......
while 条件:
条件成立重复执行的代码1
条件成立重复执行的代码2
......
continue:跳过当前循环，然后继续进行下一轮循环。
break:直接结束所在循环
#for逐个取出
for x in 字符串|列表|元组|字典|集合(数据集合)：
代码块
1.range语法1 range(num)
#从0开始，到10结束（不包含10本身）的一个数字序列，数字之间间隔是1
for x in range(10):
print(x)#0,1,2,3,4,5,6,7,8,9
2.range 语法2 range(num1, num2)
for x in range(5, 10):
# 从5开始，到10结束（不包含10本身）的一个数字序列，数字之间间隔是1
print(x)#5，6，7，8，9
3.range 语法3 range(num1, num2, step)
for x in range(5, 10, 2):
# 从5开始，到10结束（不包含10本身）的一个数字序列，数字之间的间隔是2
print(x)#5，7，9
函数
作用:降低编程难度和代码复用
def <函数名>(<参数(0个或多个,逗号,隔开)>):
<函数体>
return <返回值>
def function1(a,b,c)
res = a + b + c
return res
function1(1,2,3)#调用函数
数据容器
数据容器：容纳多个数据元素的数据类型，每个元素可以是不同类型，比如：数字，布尔，字符串等等
分类：列表(list) 元组(tuple) 字符串(str) 集合(set) 字典(dict)
1.是否支持下标索引
支持:列表、元组、字符串–序列类型
不支持:集合、字典–非序列类型
2.是否支持重复元素:
支持:列表、元组、字符串–序列类型
不支持:集合、字典–非序列类型
3.是否可以修改
支持:列表、集合、字典。
不支持:元组、字符串
用途：
列表：可修改、可重复的一批数据记录场景
元组：不可修改、可重复的一批数据记录场景
字符串：一串字符的记录场景
集合：不可重复的数据记录场景
字典：以Key检索Value的数据记录场景(二个数据共存)
容器的转换list(),tuple(),str(),set()不可以转为字典，因为value没有,但是字典可以转其他，值丢失
list1 = [10, 20, 30, 40, 50]
print(tuple(list1))# list转为元组(10, 20, 30, 40, 50)
排序方法sorted(序列,True)#True表示降序
sorted(list1)
list
下标索引正向0，1，2，3... 反向-1,-2,-3,-4...
元素可以是不同类型，支持嵌套
list1 = [true,"string",11,[1,2,3],[6,7,8]]
取第一个元素
data1 = list1[0] #true
获取内层第一个list的第一个值
inner_data = list1[3][0] #正向 return 1下面一样
inner_data = list1[-2][-3]#反向
inner_data = list1[-2][0]#反正向
inner_data = list1[3][-3] #正反向
查照11元素下标
index11 = list1.index(11) //结果为2 找不到报错ValueError
修改列表第一个值
list1[0] = false #[false ,"string",11,[1,2,3],[6,7,8]]
插入元素
list1.insert(1,"insert2") //[true,"insert2","string",11,[1,2,3],[6,7,8]]
list2 = [1,2,3,4]
追加元素
list2.append(5) # [1,2,3,4,5]
list2.append([1,2]) [1,2,3,4,[1,2]]
追加容器，把容器里的元素挨个取出，追加到列表尾部
list2.extend([1,2]) [1,2,3,4,1,2]
删除元素
1.del list2[0] #[2,3,4]
2.value = list2.pop(0) #[2,3,4] 返回被删除元素的值
删除第一个匹配的值
list3 = [1,2,3,2,3]
list3.remove(2) #[1,3,2,3]
清空列表元素
list3.clear() #[]
统计某一个元素的数量
list3.count(3) #return 2
统计列表元素的个数
len(list3) #return 5
总结：
允许数据重复，有索引的有序存储，可以存多种类型数据，可以修改，
遍历
index = 0
while index < len(list3):
print(f"{list3[index]}")
index++ #一定要加
for item in list3:
print(f"{item}")
结果:
1
2
3
2
3
元组（tuple）(相当于不可以修改的list)
元组:数据一旦确定，不可以修改(list可以修改),支持嵌套,但是元组里面可以加入一个list，list支持修改(1,[1,2])
t1 = (1,2,true)
t2 = (1,) #当只有一个元素时，后面必须加一个逗号，否则不是元组类型，而是字符串类型
value = t1[1] #return 2
index1 = t1.index(1) #return 0
len(t1) #return 3
t1.count(1) #return 1
总结:允许数据重复，不支持修改，有索引的有序存储，可以存储多种类型数据(不限制数据类型)
str(字符串)
字符串是一个无法修改的容器，只能得到一个新的字符串，旧的无法修改
str1 = "wanqiaohui"
查找元素下标
str1.index(hui)#return 7
new_str1 = str1.replace("hui","fei")#将hui替换为fei，产生新字符串，旧的无法修改 return wanqiaofei
字符串分割：将字符串分割为多个字符串存入list列表，字符串本身不变，只是得到一个字符串列表
str2 = "我,爱,中,国"
str_list = str2.split(",")#return ["我","爱","中","国"]
字符串的规整:去前后空格，也可去除二端指定的字符
str3 = " 12我,爱,中,国21 "
去除二端12，相当于二端"1"和"2"都会移除,是按照单个字符
str3.strip() #return "12我,爱,中,国21"
str3.strip("12") #return "我,爱,中,国"
str4 = "12wa12n122121"
print(str4.strip("12")) #return wa12n
计算某个字符出现的次数
str4.count("1") #return 5
字符串的长度
len(str4)#return 13
总结:只能存储字符串类型，不支持修改，有索引的有序存储，
序列（切片）
序列：内容连续、有序，有索引的数据容器
列表，元组，字符串都可以视为序列
序列切片语法： 序列[起始下标:结束下标(不含):步长] [start:end:step]
start不写默认0开始 end不写默认到尾 start和end的正负代表位置
step不写默认为1，正负代表方向，逆向开始还是正向开始
步长为1:一个接一个的取元素
步长为2:跳过一个取元素
步长为n:跳过n-1个取
步长为负数,逆向取，起始下标和结束下标都要反向标记
序列切片不会影响序列本身，而且会得到一个新的序列(list，元组tuple,字符串str)
list1 = [1,2,3,4]
new_list1 = list1[1:3]#步长默认为1,不包括结束下标 return [2,3]
new_list1 = list1[:]#从头开始，到尾结束，步长为1 return [1,2,3,4]
new_list1 = list1[::2]#从头开始，到尾结束，步长为2 return [1,3]
new_list1 = list1[::-1]#从尾到头，步长为1 return [4,3,2,1]
new_list1 = list1[-1::]#从-1开始,到最后一个，步长为1(为正) return [4]
new_list1 = list1[1::-1]#1开始，-1代表逆向每次取一个 return [2, 1]
new_list1 = list1[1::1]#1开始，1代表正向每次取一个 return [2,3,4]
new_list1 = list1[:-1:]#0开始，-1结束下标每次取一个 return [1,2,3]
list2 = [1,2,3,4,5]
new_list1 = list1[:1:-2]#1为结束位置，逆向开始跳一个取一个 return [5,3]
集合(set)去重
集合：不支持元素重复(自带去重，元素不重复，重复的自动去重) 而且元素无序(去重且无序)
因为无序，所以不支持下标访问，集合本身可以被修改，由于集合没有索引，不能用while循环，只能用for循环
集合元素不能是列表(list)、集合(set)、字典，会报TypeError
set1 = {1,"wan","qiao",1,2,(1,2),False}
set1.add("hui")#return {False, 1, 2, (1, 2), 'wan', 'qiao', 'hui'}自动去重，顺序错乱
移除元素1,集合本身被修改
set1.remove(1) #return {False, 2, (1, 2), 'hui', 'wan', 'qiao'}
随机删除一个元素，并返回元素的值
del_value = set1.pop()#return False
清空集合
set1.clear() #return None
取差集，去掉集合set2中的——>set2和set3共有元素
set2 = {1,3,4}
set3 = {1,5,6}
print(set2.difference(set3)) #return {3, 4} 不会改变原来集合2，3，而是得到一个新的集合
在集合2中删除共有元素，并保存，集合2被修改，集合3不变
set2.difference_update(set3)
print(set2) #return {3, 4}
合并二个集合
print(set2.union(set3))#return {1, 3, 4, 5, 6}
总结：不允许数据重复，无序存储，可以存储多种类型数据，可以修改
字典(dict)
字典：就是键值对，二个数据一一对应，key唯一，value不唯一 {key:value,key:value,...,key:value}
通过唯一的key找到对应的值
通过key获取值(内容)
dict1 = {"张三":{"语文":66,"数学":66,"英语":77},"李四":{"语文":33,"数学":99,"英语":88}}
print(dict1["张三"]) #return {'语文': 66, '数学': 66, '英语': 77}
print(dict1["张三"]["语文"]) # return 66
总结：字典支持下标索引，不能用while循环，而是通过key找到对应的值，key唯一，value随意，key和value可以为任意类型，
但是key不能为字典类型
更新和添加元素(有则更新value的值，无则增加key和value)
dict2 = {"张三":77,"李四":88}
dict2["王五"] = 77 #return {'张三': 77, '李四': 88, '王五': 77}
pop(key)删除指定的key,并返回元素的值
value = dict2.pop("张三") #value为77 删除后{'李四': 88}
获取所有的key，返回一个list集合
keys = dict2.keys()
print(keys) #return dict_keys(['张三', '李四'])
总结：支持多种类型，key唯一且对应一个value，value随意，不支持索引，所以不能用while循环遍历，支持修改，
函数进阶
1.函数多返回值
def fun1(x,y):
return x,y,x+y #逗号隔开多个返回值
x,y,z = fun1(1,2)
print(f"x:{x}y:{y}z:{z}")
2.函数的多种传参方式：位置参数(上述一就是位置参数，传递的参数和参数位置必须对应)，
关键字参数(键值对,sex = "女")，缺省参数，不定长参数
①位置参数
x,y,z = fun1(1,2)
②关键字参数
x,y,z = fun1(x=1,y=2)
③缺省参数：设置默认值参数必须在(没默认值参数)后面，否则报SyntaxError(语法错误)
def fun1(x,y = 1):
return x,y,x+y #逗号隔开多个返回值
x,y,z = fun1(1)
④不定长参数：参数的个数不确定
参数类型：位置传递，关键字传递
法一:位置传参
def fun1(*args):
print(f"{args} 类型:{type(args)} 数据1: {args[0]}")
fun1(1,2,3)#(1, 2, 3) 类型:<class 'tuple'> 数据1: 1 自动将数据变为元组类型
法二:关键字传参,数据自动转为字典，必须是键值对keyword arguments
def fun1(**kwargs):
print(f"{kwargs} 类型:{type(kwargs)} 数据1:{kwargs['one']}")
fun1(one = 1,two = 2,three = 3)#{'one': 1, 'two': 2, 'three': 3} 类型:<class 'dict'> 数据1:1
3.匿名函数
第一种:函数作为参数,不知道函数的内部实现，函数只提供数据即可(只知道传递的参数)
def fun1(compute):
result = compute(1,2)
print(result)
def compute(x,y):
return x+y
fun1(compute)#return 3
第二种:lambda匿名函数 lambda 传入参数(,隔开):函数体(一行代码)
def fun1(compute):
result = compute(1,2)
print(result)
fun1(lambda x,y:x+y)#return 3 传递lambda匿名函数，注意只能写一行代码
文件操作
编码：编码是一种规则，内容和二进制进行转换的逻辑
文件操作步骤：
1.打开文件
open(name,model,encoding) :返回一个文件对象
name:文件路径，包括文件名的路径字符串
model:模式 r(只读,不会创建文件) w(写入，原有内容被覆盖，文件不存在，自动创建文件) a(追加，文件不存在，自动创建文件)
encoding:编码格式，encoding = "UTF-8"
2.读写文件
2.1读文件
f = open("D:/测试.txt", "r", encoding="UTF-8")
f.read()#读取全部内容
lines = f.readlines() # 读取文件的全部行，封装到列表中
line1 = f.readline()# 读取文件的一行数据
for循环读取文件行
for line in f:
line = line.strip() # 去除开头和结尾的空格以及换行符
print(f"每一行数据是:{line}")
2.2写文件
f = open("D:/test.txt", "w", encoding="UTF-8")#文件不存在，会自动创建文件
# write写入
f.write("Hello World!!!") # 内容写入到内存中
f.flush() # flush刷新将内存中积攒的内容，写入到硬盘的文件中
f.close() # close方法，内置了flush的功能的
2.3追加
f = open("D:/test.txt", "a", encoding="UTF-8")
3.关闭文件(资源)
"""
演示文件操作综合案例：文件备份
"""
# 打开文件得到文件对象，准备读取
fr = open("D:/bill.txt", "r", encoding="UTF-8")
# 打开文件得到文件对象，准备写入
fw = open("D:/bill.txt.bak", "w", encoding="UTF-8")
# for循环读取文件
for line in fr:
line = line.strip()
# 判断内容，将满足的内容写出
if line.split(",")[4] == "测试":
continue # continue进入下一次循环，这一次后面的内容就跳过了
# 将内容写出去
fw.write(line)
# 由于前面对内容进行了strip()的操作，所以要手动的写出换行符
fw.write("\n")
# close2个文件对象
fr.close()
fw.close() # 写出文件调用close()会自动flush()
异常模块和包
异常
异常具有传递性:所以我们捕获异常，可以在最终处(最高级)捕获异常即可
try:
f = open("D:/123.txt", "r", encoding="UTF-8")#可能发生异常代码
except Exception as e: #发生异常执行的代码
print("出现异常了")
f = open("D:/123.txt", "w", encoding="UTF-8")#文件不存在，改为写入，自动创建文件
else: #没有发生异常执行的代码
print("好高兴，没有异常。")
finally: #一定会执行的代码
print("我是finally，有没有异常我都要执行")
f.close()
模块(Module)和包(package)
[]中括号代表里面的内容可有可无
[from 模块名] import [模块|类|函数|变量|*] [as 别名]
只导入模块，要通过模块名. 去调用函数
# 使用import导入time模块使用sleep功能（函数）
import time # 导入Python内置的time模块（time.py这个代码文件）
time.sleep(5) # 通过. 就可以使用模块内部的全部功能（类、函数、变量）
导入函数，可以直接调用
from time import sleep as sl
sl(5)#调用函数，5秒后执行后面内容
自定义模块：就是创建python文件
def add(x,y):
return x+y
if __name__ == '__main__':#只有文件被直接执行时才会进入
print(add(1,2))
变量'_all_' 控制 import *那些功能被导入
_init_.py:标记此为包，而不是普通文件夹
安装第三方包:打开控制台 pip install 包名称 #速度很慢
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple 包名称 #连接国内网站进行安装，速度快
数据可视化
json数据格式
"""
json数据就是字符串
演示JSON数据和Python字典的相互转换
"""
import json
# 1.准备列表，列表内每一个元素都是字典，将其转换为JSON
data = [{"name": "张大山", "age": 11}, {"name": "王大锤", "age": 13}, {"name": "赵小虎", "age": 16}]
json_str = json.dumps(data, ensure_ascii=False)#ensure_ascii=False解决乱码
print(type(json_str))#str
print(json_str)
# 2.准备字典，将字典转换为JSON 就是变成字符串
d = {"name":"周杰轮", "addr":"台北"}
json_str = json.dumps(d, ensure_ascii=False)
print(type(json_str))
print(json_str)
# 将JSON字符串转换为Python数据类型[{k: v, k: v}, {k: v, k: v}] 列表[{字典},{字典},{字典}...{字典}]]
s = '[{"name": "张大山", "age": 11}, {"name": "王大锤", "age": 13}, {"name": "赵小虎", "age": 16}]'
l = json.loads(s)# 将JSON字符串转换为Python数据类型
print(type(l))
print(l)
# 将JSON字符串转换为Python数据类型{k: v, k: v}
s = '{"name": "周杰轮", "addr": "台北"}'
d = json.loads(s)
print(type(d))
print(d)
pyecharts
官方画廊 https://gallery.pyecharts.org/#/README
折线图
做一个图的步骤：
1.导包
2.创建一个图对象
3.添加数据
4.设置全局配置项
5.通过render方法将代码生成图像
# 使用 ab173懒人程序员工具做json数据分析
# 1.导包
from pyecharts.charts import Line
# TitleOpts：控制图标题的模块 设置全局选项时需要引用的模块
from pyecharts.options import TitleOpts, LegendOpts, ToolboxOpts, VisualMapOpts
# 2.创建一个折线图对象
line = Line()
# 3.给折线图对象添加x轴的数据
line.add_xaxis(['中国', '美国', '英国'])
# 4.给折线图对象添加y轴对象
line.add_yaxis('GDP', [30, 20, 10])
# 5.设置全局配置项，通过 line.set_global_opts 来设置
line.set_global_opts(
# 标题配置
# 参数列表：title：标题，pos_left：x轴横向位置，pos_bottom：y轴竖向位置
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)
)
# 6.通过render方法，将代码生成图像
line.render('折线图.html')
"""
演示可视化需求1：折线图开发
"""
import json
from pyecharts.charts import Line
from pyecharts.options import TitleOpts, LabelOpts
# 处理数据
f_us = open("D:/美国.txt", "r", encoding="UTF-8")
us_data = f_us.read() # 美国的全部内容
f_jp = open("D:/日本.txt", "r", encoding="UTF-8")
jp_data = f_jp.read() # 日本的全部内容
f_in = open("D:/印度.txt", "r", encoding="UTF-8")
in_data = f_in.read() # 印度的全部内容
# 去掉不合JSON规范的开头
us_data = us_data.replace("jsonp_1629344292311_69436(", "")
jp_data = jp_data.replace("jsonp_1629350871167_29498(", "")
in_data = in_data.replace("jsonp_1629350745930_63180(", "")
# 去掉不合JSON规范的结尾
us_data = us_data[:-2]
jp_data = jp_data[:-2]
in_data = in_data[:-2]
# JSON转Python字典
us_dict = json.loads(us_data)
jp_dict = json.loads(jp_data)
in_dict = json.loads(in_data)
# 获取trend key
us_trend_data = us_dict['data'][0]['trend']
jp_trend_data = jp_dict['data'][0]['trend']
in_trend_data = in_dict['data'][0]['trend']
# 获取日期数据，用于x轴，取2020年（到314下标结束）
us_x_data = us_trend_data['updateDate'][:314]
jp_x_data = jp_trend_data['updateDate'][:314]
in_x_data = in_trend_data['updateDate'][:314]
# 获取确认数据，用于y轴，取2020年（到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() # 构建折线图对象
# 添加x轴数据
line.add_xaxis(us_x_data) # x轴是公用的，所以使用一个国家的数据即可
# 添加y轴数据
line.add_yaxis("美国确诊人数", us_y_data, label_opts=LabelOpts(is_show=False)) # 添加美国的y轴数据
line.add_yaxis("日本确诊人数", jp_y_data, label_opts=LabelOpts(is_show=False)) # 添加日本的y轴数据
line.add_yaxis("印度确诊人数", in_y_data, label_opts=LabelOpts(is_show=False)) # 添加印度的y轴数据
# 设置全局选项
line.set_global_opts(
# 标题设置
title_opts=TitleOpts(title="2020年美日印三国确诊人数对比折线图", pos_left="center", pos_bottom="1%")
)
# 调用render方法，生成图表
line.render()
# 关闭文件对象
f_us.close()
f_jp.close()
f_in.close()
地图
# 1.导包
from pyecharts.charts import Map
from pyecharts.options import VisualMapOpts
# 2.准备地图对象
map = Map()
# 3.准备数据，所用数据都是列表嵌套元组
data = [
("北京", 99),
("上海", 199),
("湖南", 299),
("广东", 399),
("台湾", 499),
]
# 4.添加数据
map.add("测试地图", data, "china")
# 5.设置全局选项
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": 299, "label": "10-299", "color": "#CC6666"},
{"min": 300, "max": 500, "label": "300-500", "color": "#990033"}
]
)
)
# 6.绘图
map.render("中国部分地图.html")
"""
演示河南省疫情地图开发
"""
import json
from pyecharts.charts import Map
from pyecharts.options import *
# 读取文件
f = open("D:/疫情.txt", "r", encoding="UTF-8")
data = f.read()
# 关闭文件
f.close()
# 获取河南省数据
# json数据转换为python字典
data_dict = json.loads(data)
# 取到河南省数据
cities_data = data_dict["areaTree"][0]["children"][3]["children"]
# 准备数据为元组并放入list
data_list = []
for city_data in cities_data:
city_name = city_data["name"] + "市"
city_confirm = city_data["total"]["confirm"]
data_list.append((city_name, city_confirm))
# 手动添加济源市的数据
data_list.append(("济源市", 5))
# 构建地图
map = Map()
map.add("河南省疫情分布", data_list, "河南")
# 设置全局选项
map.set_global_opts(
title_opts=TitleOpts(title="河南省疫情地图"),
visualmap_opts=VisualMapOpts(
is_show=True, # 是否显示
is_piecewise=True, # 是否分段
pieces=[
{"min": 1, "max": 99, "lable": "1~99人", "color": "#CCFFFF"},
{"min": 100, "max": 999, "lable": "100~9999人", "color": "#FFFF99"},
{"min": 1000, "max": 4999, "lable": "1000~4999人", "color": "#FF9966"},
{"min": 5000, "max": 9999, "lable": "5000~99999人", "color": "#FF6666"},
{"min": 10000, "max": 99999, "lable": "10000~99999人", "color": "#CC3333"},
{"min": 100000, "lable": "100000+", "color": "#990033"},
]
)
)
# 绘图
map.render("河南省疫情地图.html")
柱状图
# 1.导包
from pyecharts.charts import Bar
from pyecharts.options import LabelOpts
# 2.创建对象
bar = Bar()
# 3.添加数据
bar.add_xaxis(['中国', '美国', '英国'])
bar.add_yaxis("GDP", [30, 20, 10], label_opts=LabelOpts(position="right")) # position可以设置参数位置，10，20，30放到左边
# 反转x和y轴
bar.reversal_axis()
# 4.绘图
bar.render('基础柱状图.html')
基础时间线柱状图
# 1.导包
from pyecharts.charts import Bar, Timeline # 导入时间模块
from pyecharts.options import LabelOpts
from pyecharts.globals import ThemeType # 导入时间线主题
# 2.创建对象
bar1 = Bar()
# 3.添加数据
bar1.add_xaxis(['中国', '美国', '英国'])
bar1.add_yaxis("GDP", [30, 20, 10], label_opts=LabelOpts(position="right")) # position可以设置参数位置
bar1.reversal_axis()
bar2 = Bar()
bar2.add_xaxis(['中国', '美国', '英国'])
bar2.add_yaxis("GDP", [50, 30, 20], label_opts=LabelOpts(position="right")) # position可以设置参数位置
bar2.reversal_axis()
bar3 = Bar()
bar3.add_xaxis(['中国', '美国', '英国'])
bar3.add_yaxis("GDP", [70, 50, 30], label_opts=LabelOpts(position="right")) # position可以设置参数位置
bar3.reversal_axis()
# 创建时间线对象，传入一个字典设置主题
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 # 是否循环自动播放
)
# 4.绘图是使用时间线绘图，而不是bar对象
timeline.render("基础时间线柱状图.html")
"""
演示第三个图表：GDP动态柱状图开发
"""
from pyecharts.charts import Bar, Timeline
from pyecharts.options import *
from pyecharts.globals import ThemeType
# 读取数据
f = open("D:/1960-2019全球GDP数据.csv", "r", encoding="GB2312")
data_lines = f.readlines()
# 关闭文件
f.close()
# 删除第一条数据
data_lines.pop(0)
# 将数据转换为字典存储，格式为：
# { 年份: [ [国家, gdp], [国家,gdp], ...... ], 年份: [ [国家, gdp], [国家,gdp], ...... ], ...... }
# { 1960: [ [美国, 123], [中国,321], ...... ], 1961: [ [美国, 123], [中国,321], ...... ], ...... }
# 先定义一个字典对象
data_dict = {}
for line in data_lines:
year = int(line.split(",")[0]) # 年份
country = line.split(",")[1] # 国家
gdp = float(line.split(",")[2]) # gdp数据
# 如何判断字典里面有没有指定的key呢？
try:
data_dict[year].append([country, gdp])
except KeyError:
data_dict[year] = []
data_dict[year].append([country, gdp])
# print(data_dict[1960])
# 创建时间线对象
timeline = Timeline({"theme": ThemeType.LIGHT})
# 排序年份
sorted_year_list = sorted(data_dict.keys())
for year in sorted_year_list:
data_dict[year].sort(key=lambda element: element[1], reverse=True)
# 取出本年份前8名的国家
year_data = data_dict[year][0:8]
x_data = []
y_data = []
for country_gdp in year_data:
x_data.append(country_gdp[0]) # x轴添加国家
y_data.append(country_gdp[1] / 100000000) # y轴添加gdp数据
# 构建柱状图
bar = Bar()
x_data.reverse()
y_data.reverse()
bar.add_xaxis(x_data)
bar.add_yaxis("GDP(亿)", y_data, label_opts=LabelOpts(position="right"))
# 反转x轴和y轴
bar.reversal_axis()
# 设置每一年的图表的标题
bar.set_global_opts(
title_opts=TitleOpts(title=f"{year}年全球前8GDP数据")
)
timeline.add(bar, str(year))
# for循环每一年的数据，基于每一年的数据，创建每一年的bar对象
# 在for中，将每一年的bar对象添加到时间线中
# 设置时间线自动播放
timeline.add_schema(
play_interval=1000,
is_timeline_show=True,
is_auto_play=True,
is_loop_play=False
)
# 绘图
timeline.render("1960-2019全球GDP前8国家.html")
扩展列表的sort方法
"""
扩展列表的sort方法
在学习了将函数作为参数传递后，我们可以学习列表的sort方法来对列表进行自定义排序
"""
# 准备列表
my_list = [["a", 33], ["b", 55], ["c", 11]]
# 排序，基于带名函数
# def choose_sort_key(element):
# return element[1]
#
# my_list.sort(key=choose_sort_key, reverse=True)
# 排序，基于lambda匿名函数
my_list.sort(key=lambda element: element[1], reverse=True)#reverse=True代表降序
print(my_list)
面向对象
(构造方法)初始化方法_ _init _ _()
类中成员方法:
def methed(self,形参1,...,形参n):
print(f"{self.name}")
方法体
self:表示自身类对象(this),当使用类对象调用方法，self会自动传入,访问类的成员变量，必须使用self
_ _str _ _()字符串方法
_ _name 代表使用成员，只能类内部调用
继承
多继承
class phone(phone1,phone2,phone3,...,phonen)
复写：对同名属性,或者方法进行复写
调用父类：父类名. super().
类型注解: var_1: int = 10
返回值注解：
def methed(self,形参1,...,形参n) -> 返回值类型:
pass#不实现
Union联合注解:就是包括多种类型 union[str,int]
多态
同样的行为，传入不同的对象，得到不同的状态，常用父类对象接子类
抽象类：顶层设计，就是标准，不管下面子类的实现方式
python&mysql
pip install pymysql
1075
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
