Python基础语法第一阶段

Dying.Light

已于 2024-03-13 08:49:26 修改

阅读量131

点赞数 3

文章标签： python

于 2024-03-03 22:11:28 首次发布

本文链接：https://blog.csdn.net/weixin_68718700/article/details/136439374

版权

# print("Hello World!!!")
# # print(50-10)
# money = 50
# money -= 10
# print(money)
# print(type(money))
# print(type("小黑"))
# print(type(13.14))
# ty = type(money)
# print(ty)
# # 使用type可以查看变量或者数据的类型
# print("小黑记事本", money)
# # 整数和浮点数是无法直接进行拼接操作的
# print("小黑记事本%s" % (money))
# # %f 浮点数  %d 整数  %s 字符串  占位符
#
#
#
# name = "小黑"
# year = 2002
# price = 10.3
# print(f"我是{name},我出生于{year},今天的股价是{price}")
#
# print("1+1=%s" % (1+1))
#
# age = 18
# if age >= 20:
#     print("成年了")
# else:
#     print("未成年")
#
# age = int(input("请输入年龄\n"))
# if age >= 18:
#     print("您已经成年了，需要补票")
# else:
#     print("您是儿童，不需要补票")
#
# height =  int(input("请输入您的身高(cm)"))
# if height > 120:
#     print("您的身高超过120，需要买票，10元")
# else:
#     print("您的身高低于120，可以免费游玩")

# import random
#
# num = random.randint(1, 10)
# while True:
#     print(num)
#     num1 = int(input("请输入数字"))
#     if num1 == num:
#         print("恭喜猜对了")
#         break
#     elif num1 >= num:
#         print("猜大了")
#     else:
#         print("猜小了")
# 计算1+2+3+。。。+100
# i = 1
# sum = 0
# while i<=100:
#     sum = sum + i
#     i+=1
#
# print(sum)
# 循环嵌套
# i = 1
# while i <= 100:
#     print(f"今天是第{i}天")
#     j = 1
#     while j <= 10:
#         print(f"{i}天送的第{j}朵花")
#         j += 1
#     i += 1
# print(f"表白了{i-1}天，表白成功")
# 九九乘法表
# i = 1
# while i<10:
#     j = 1
#     while j <= i:
#         print(f"{j}*{i}={i*j}\t",end='')
#         j+=1
#     print()
#     i +=1
# for循环

# name = "wangjunwei"
# for i in name:
#     print(i)
# name = "itheima is a brand of itcast"
# count = 0
# for i in name:
#     if i == 'a':
#         count += 1
# print(count)
# for i in range(5,10,2):
#     print(i)
# print(i)
# 规范上，这里无法访问到for循环里面的临时变量，但其实，在这里可以访问到循环里的临时变量

# for i  in range(1,10):
#     for j in range(1,i+1):
#         print(f"{j}*{i}={i*j}\t",end="")
#     print()
# 发工资案例
# import random
# money = 10000
# for i in range(1,21):
#     number = random.randint(1, 10)
#     print(f"员工{i}号,绩效为{number}")
#     if number <= 5:
#         print(f"员工{i}号,绩效为{number},不发工资")
#         continue
#     else:
#         if money >= 1000:
#             money -= 1000

#             print(f"员工{i}号,发出工资1000元,还剩{money}元")
#         else:
#             print("余额不足,请下个月再来")
#             break
# 函数
# 自己定义一个函数
# def my_len(data):
#     count = 0
#     for i in data:
#         count +=1
#     print(f"字符串{data},的长度为{count}")
# my_len("aaaa")
# my_len("aaaab")
# my_len("aaa")
# 函数的定义
# def say_hi():
#     print("Hi 我是小黑,我在学习python开发")
#
# say_hi()
# 自定义函数,求两个数的和
# def add(x, y):
#     result = x + y
#     print(result)
# add(4,8)

# 带有返回值的函数
# def add(a,b):
#     return a+b
# num = add(1,2)
# print(num)

# 当函数不写return返回值的时候,默认也是有返回值的,此时返回的是字面量None
# 使用type函数来查询类型的时候,会显示是 NoneType
# 也可以自己主动返回一个Node  使用return None
# 在if语句中,None代表的是False
# None也可以用来对定义的变量进行赋值,对于暂时不需要的变量有具体的值,可以使用None来代替
# 感觉None类似于Java的null

# def func(x,y):
#     """
#     下面是自动生成的
#     函数说明
#     :param x:
#     :param y:
#     :return:
#     """

# 定义一个全局变量
# num = 100
# def func():
#     global num
#     num = 200
#     global name
#     name = "小黑"
#     print(f"函数体内部的num={num}")
# func()
# print(f"函数体外的num={num}")
# print(name)
# 使用global可以将函数体内的局部变量和函数体外的全局变量进行联系起来,
# 使用global可以让变量变成全局变量
# 列表
# my_list = ["itheima","itcast"]
# print(my_list)  ['itheima', 'itcast']
# print(type(my_list))  <class 'list'>
# 列表里面可以放任意类型的数据，也可以使用嵌套，类似于Java或C语言的数组
# 可以使用列表元素下标来把数据取出来，正向是从0开始自增，反向是从-1开始
# 查询下标
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]
# print(my_list.index(3))
# 如果查询的元素不存在，就会报错
# 修改对应下标的值
# my_list[3] = 100
# print(my_list)
# 在指定元素下标插入元素
# 列表.insert(下标，元素)
# my_list.insert(1,90)
# print(my_list)
# 列表追加元素  只能在最后追加  只能追加一个元素
# my_list.append("itheima")
# print(my_list)
# 追加多个元素，可以将一个数据容器中的元素追加到另一个列表的元素中
# num = [11,22,33,44]
# my_list.extend(num)
# print(my_list)
# 删除元素
# 第一种方法  使用del
# del my_list[2]
# print(my_list) # [1, 2, 4, 5, 6, 7, 8, 9]
# 第二种方法 pop
# i = my_list.pop(2) # 函数返回被取出来的值
# print(my_list) # [1, 2, 4, 5, 6, 7, 8, 9]
# print(i) # 3
# 通过remove可以删除列表中的第一个相匹配的元素
# 同时，remove也是通过元素内容进行删除的
# my_list.remove(2)
# print(my_list)
# 清空列表
# my_list.clear()
# print(my_list)
# 查看列表中有几个对应的元素
# my_list = [1,2,3,4,5,6,2,8,9]
# num = my_list.count(2)
# print(num)
# 查询列表中元素的数量
# num = len(my_list)
# print(num)
# list列表的遍历
# 可以使用while循环，也可以使用for循环进行遍历
# 1-10中的偶数和奇数分开放
# ou = []
# ji = []
# for i in range(1,11):
#     if i % 2 == 0:
#         ou.append(i)
#     else:
#         ji.append(i)
# print(ou)
# print(ji)


# 元组
# 不能被修改  可以理解成只读的list
# 元组使用小括号定义
# 变量名 = ()
# 变量名 = tuple()
# 如果元组的内容只有一个元素，那么在第一个元素的后面需要加上一个逗号
# 元组也可以使用元组的嵌套
# 元组想要取出某个坐标的值也可以像列表那样使用元组下标进行取出
# 原则只能使用三个方法  index()  count()  len(元组)
# 因为元组里面的值在元组创建出来的时候就不允许再修改了
# 元组的遍历while 和for
# 特例：  由于元组里面可以嵌套list列表，元组无法修改，但是列表是可以修改的，所以，
# 如果元组里面放了列表,那么这个列表是可以修改的
# 字符串:
#   替换:replace
#   分割:
# mystr = "hello python itheima itcast"
# mystrlist = mystr.split(" ")   ['hello', 'python', 'itheima', 'itcast']
# print(mystrlist)
# 字符串.strip()  将首位的空格符号去掉
# 字符串.strip(字符串) 可以将首位的字符串去掉  把形参里的字符串当成一个个的字符,分别去除掉
# 字符串.count("字符串1")   统计字符串1在字符串中出现的次数
# 数据容器的切片     列表/元组[起始:截止:步长]   当步长为-1的时候反向


# 集合:  {}   集合是不允许重复元素,  type(集合)  => set集合
# 并且,集合中数据的访问是无序的,因此不能使用集合元素下标进行访问
# 集合允许修改其中的元素
# 添加元素:add   删除元素:remove
# 随机取出元素   集合.pop()   因为集合是无序的,所以,pop是随机取出一个,取出后数据在集合中不存在
# 清空集合
# 集合.clear()
# 取出两个集合的差集
# set1 = {1,2,3}
# set2 = {1,5,6}
# set3 = set1.difference(set2)  {2, 3}
# print(set3)
# 取出来后,原来的set1和set2不会改变
# 消除差集,在集合1中删除和集合2相同的元素
# set1 = {1,2,3}
# set2 = {1,5,6}
# set1.difference_update(set2)
# print(set1)  {2, 3}
# print(set2){1, 5, 6}
# set1发生改变  set2不变
# 合并集合
# set1 = {1,2,3}
# set2 = {1,5,6}
# set3 = set1.union(set2)
# print(set3)  {1, 2, 3, 5, 6}
# 去重,然后合并,顺序不确定   不会修改原有集合,得到一个新的集合
# 统计集合的元素个数   len()
# 集合的遍历
# 只能使用for循环
# 定义一个空集合
# set = set()

# 字典
# 定义字典: 冒号加逗号   key:value   key不允许重复
# {"王力宏":99,"小黑":98,"小马":97}
# 定义空字典   mydict = {}   mydict = dict()
# 可以通过key来获取value value = 字典名[key值]  从而通过key来获取到value
"""
    字典的key和value可以是任意的数据类型(key不可以为字典)
    那么,就表明,字典是可以嵌套的
"""
# score = {
#     "王力宏": {"语文": 77, "数学": 66, "英语": 33},
#     "周杰伦": {"语文": 88, "数学": 86, "英语": 55},
#     "林俊杰": {"语文": 99, "数学": 96, "英语": 66}
# }
# print(score)
# 从嵌套的字典里面获取信息
# print(score["周杰伦"]["语文"])
# 字典的常用操作
# 新增元素
# 字典[key] = value
# 字典中,如果key已经存在了,那么就是更新元素,如果key不存在,就是新增元素
# 删除元素
# num = 字典.pop(key)
# 通过pop方法进行删除key对应的哪一项,然后可以返回当前key对应的value值
# 清空元素
# 字典.clear()
# 获取全部key
# 字典.keys()  返回字典中所有的key值
# num = score.keys()
# print(num)
# 遍历字典
# 方式1:通过上面获取到所有的key值,然后可以使用对应的key对字典进行遍历
# 方式2:直接对字典进行for循环,每一次循环得到的值都是字典里面的一个key
# 字典不支持下标索引,所以,不能用while循环
# 统计字典内的数量
# len函数来统计字典内的元素数量
# 课后小练习
# sc = {
#     "王力宏":{"部门":"科技部","工资":3000,"级别":1},
#     "周杰伦":{"部门":"市场部","工资":5000,"级别":2},
#     "林俊杰":{"部门":"市场部","工资":7000,"级别":3},
#     "张学友":{"部门":"科技部","工资":4000,"级别":1},
#     "刘德华":{"部门":"市场部","工资":6000,"级别":2},
# }
# for key in sc:
#     if sc[key]["级别"] == 1:
#         sc[key]["级别"] = 2
#         sc[key]["工资"] += 1000
#     # print("'"+key,end="':")
#     # print(sc[key])
#     print("'"+key+"' :",sc[key])
# # print(sc)

# 使用len()函数可以获得列表,元组,字符串,集合,字典 中元素的个数
# 使用max()函数可以获得列表,元组,字符串,集合,字典 中最大的元素
# 使用min()函数可以获得列表,元组,字符串,集合,字典 中最小的元素
# 字典中是根据key值进行比较
# 可以使用list(容器) 将给定的容器转成列表
#       字符串转列表会将字符串中的每个字符变成列表中的一项
#       字典转列表会将字典中的value舍弃,只保留了key
# sty(容器) 将给定的容器转成字符串
#       字典在转字符串的时候会保留key和value,各自成为一个字符串
# 可以使用tuple(容器) 将给定的容器转成元组
#       字符串转元组会将字符串中的每个字符变成列表中的一项
#       字典转元组会将字典中的value舍弃,只保留了key
# 可以使用set(容器) 将给定的容器转成集合
#       字典转集合  value也会丢失 并且由于集合的无序性,所以,顺序也乱了
# 控制容器中元素的排序
# sorted(容器,[reverse=True])   第二个默认值为reverse = False 是正序
# 排序结果都变成了列表  字典的排序会丢失value
# 默认是正序,第二个参数传递True会变成倒序

# 函数进阶  多返回值
# def 函数名():
#     return 返回值1，返回值2   中间逗号分隔
# def hand(name,age,score):
#     print(name, age, score)
#     return 1
#
#
# print(hand( age=20,name="张三", score=100))
# 函数默认参数   设置默认值的那个形参要放在最后
# def hand(name="张三"):
#     print(name)
#     return
# hand()   不传递参数时，形参会采用默认值
# 多参数传递
# 位置传递
# def 函数名(*args):
#     print(args)
# 传递的多个参数会放到一个元组tuple中
# 关键字传递
# def 函数名(**kwargs):
#     print(kwargs)
# 传递的值需要是：键=值的形式，被接收后组成一个字典
# 匿名函数
# 函数作为参数传递
# def add(x,y):
#     return x+y
# def test(add):
#     res = add(1,2)
#     return res
#
# # 这样做，不再是传递数据，而是传递函数，
# # 数据不变，而数据运算的逻辑可以改变
# # 如果下面想使用乘法，则只需要将乘法的逻辑包装成函数并且作为参数传递即可
# print(test(add))
# lambda表达式
# def 创建的函数带有名称，可以重复使用
# 使用lambda创建的函数是匿名函数，无法实现重复调用
# 语法：
# lambda 传入参数：函数体（一行代码）
# def test(add):
#     res = add(2,2)
#     return res
# print(test(lambda x, y: x + y))
# python的文件编码
# 文件的读取操作
# f = open("E://a.txt","r",encoding="utf-8")
# print(f.readline())
# f.read(num)  通过这个方法可以读取num个字节的数据，并且，f只想num个字节的下一个数据
# f.read()  不传递参数就是读取这个文件的所有数据
# print(f.readlines()) # 读取数据的全部行  文件中有回车就会显示  \n 然后放到一个列表中
# print(f.readline())   一次读取一行数据
# 使用完关闭文件
# f.close()
# with open("E://a.txt","r",encoding="utf-8") as f:
#     for line in f:
#         print(line)
# 这种方法会自动关闭文件的连接
# 文件的写入操作
# 语法:
# r: 只读
# w:写入
# a:追加
# f = open('python.txt','w')
# # 打开文件
# f.write("hello world")
# # 文件写入  写入内存中,这是并不会真正写入到硬盘中
# f.flush()
# # 内容刷新  在这里才会写入到硬盘中  这样做是为了避免频繁对硬盘进行写入操作
# f.close()   # 这个方法也会内置flush方法
# 文件不存在的时候,会创建文件然后写入
# 文件存在的时候,会清空整个文件,然后重新写入

# f = open('python.txt','a')
# # 追加   不会清空原有内容   换行符号:\n
# f.write("hello world!!!")
# f.flush()
# line.strip()可以将头尾的空格回车符号清除掉
# 了解异常
# 异常的捕获方法
# 语法:
# try:
#     可能发生错误的代码
# except:
#     如果出翔异常而执行的代码
# try:
#     f = open('test.txt','r')
# except:
#     print("文件打开异常")
# 捕获指定异常
# try:
#     发生异常的代码
# except 异常的名字(例如:NameError as e):
#     异常处理结果
# 捕获多个异常
# try:
#     发生异常的代码
# except (异常的名字):    使用元组,把多个异常捕获
#     异常处理结果
# 最下面的捕获所有的异常
# try:
#     异常
# except Exception as e:
#     处理
# 没有异常
# try:
#     异常
# except:
#     处理异常
# else:
#     如果没异常怎么做
# finally:
#     不过有没有异常都会执行的代码
# 异常的传递
# def fun1():
#     1/0
#     print("fun1结束")
# def fun2():
#     print("fun2开始")
#     fun1()
#     print("fun2结束")
#
# def main():
#     try:
#         fun2()
#     except Exception as e:
#         print(e)
# main()
# 这种说明,异常具有传递性
# python模块
# 导入模块的方式:
#     [from 模块名] import [模块|类|变量|函数|*] [as 别名]
# import time  # 导入Python中的模块,也就是一个.py文件
# time.sleep(2)
# print("123")
# 导入time中的某个功能
# from time import sleep
# from time import sleep
# sleep(3)
# print("你好 Python")
# from time import *   这里使用* 号,表示导入这个包下全部的方法
# sleep(3)
# print("你好 Python")
# import time as t   起别名,后面可以使用 t.xxx进行调用方法
# 自定义模块
# import my_module1
# my_module1.test(1,2)
# from my_module1 import test
# 当导入的模块(以这种方式from my_module1 import test)中有相同的方法时,
# 会根据后导入的模块中的函数为准  后面的会把前面的覆盖
# __all__变量
# 当我们导入*的时候,默认将模块中的所有的方法导入,但是如果在模块中配置了__all__的时候
# 这时候的* 就是__all__里面代表的内容被导入了
# from my_module1 import *
# testA(1,2)
# python包
# 自定义Python包
# 导包: 创建python包  import 包名.模块名   也可以使用from ... import ..  也有__all__
# 安装第三方包
# json就是python中的字典（列表中嵌套了字典）

# import json
"""
    将python字典或者列表里面嵌套字典转换成对应的json
            使用  json.dumps(要转换的元素,是否使用ASCII进行编码)
    将json字符串转成对应的字典或者列表里面嵌套字典的形式  使用 json.loads()
"""
# data = [{"name":"张大山","age":11},{"name":"王大锤","age":13},{"name":"赵小虎","age":16}]
# json_str = json.dumps(data,ensure_ascii=False)  #  这样可以转换成JSON字符串
# print(json_str)
# # ,ensure_ascii=False 这个表示不适用ASCII来转化
# # 将字典转换成JSON字符串
# d = {"name":"周杰伦","addr":"台北"}
# d1 = json.dumps(d,ensure_ascii=False)
import json
# 将json字符串转回python列表
# s = '[{"name": "张大山", "age": 11}, {"name": "王大锤", "age": 13}, {"name": "赵小虎", "age": 16}]'
# l = json.loads(s)
# print(l)
# pyecharts  可视化图标

__all__ = ['testA']
def testA(a, b):
    print(a + b)
def testB(a, b):
    print(a + b)


if __name__ == '__main__':
    """
        我们会发现,我们写好模块后,在这里调用测试后
        在其他模块中导入这个模块后,会自动执行这里的test(1,2)
        可是我们导入这个模块并不想让里面的方法执行,所以
        我们这里使用:if __name__ == '__main__':
        来进行判断处理,这样,在其他模块中导入这个模块的时候就不会执行
        这个test(1,2)了
    """
    # test(1,2)

# 使用pyecharts
# 1.导包
from pyecharts.charts import Line
from pyecharts.options import  TitleOpts,LegendOpts,ToolboxOpts,VisualMapOpts
                        # 表题的控制选项 ,图例,工具箱,视觉映射
# 创建一个折线图对象
line = Line()
# 给折线图对象添加X轴的数据
line.add_xaxis(["中国","美国","英国"])
# 给折线图对象添加Y轴的数据
line.add_yaxis("GDP",[30,20,10])
# 设置全局配置项  set_global_opts
line.set_global_opts(
    # 设置表头
    title_opts=TitleOpts(title="GDP展示",pos_left="center",pos_bottom="2%"),
#     控制图例
    legend_opts=LegendOpts(is_show=True),
    toolbox_opts=ToolboxOpts(is_show=True),
#     视觉映射
    visualmap_opts=VisualMapOpts(is_show=True)

)

# 通过render方法，将代码生成为图像
line.render()  # 会生成一个网页文件（.html文件）


import json
from pyecharts.charts import Line
from pyecharts.options import TitleOpts,LabelOpts


f_us = open("F://python//anli//美国.txt","r",encoding="utf-8")
us_data = f_us.read()

f_jp = open("F://python//anli//日本.txt","r",encoding="utf-8")
jp_data = f_jp.read()

f_in = open("F://python//anli//印度.txt","r",encoding="utf-8")
in_data = f_in.read()

us_data = us_data.replace("jsonp_1629344292311_69436(","")  # 去掉头部内容
us_data = us_data[:-2]  #去掉尾部多余内容

jp_data = jp_data.replace("jsonp_1629350871167_29498(","")
jp_data = jp_data[:-2]

in_data = in_data.replace("jsonp_1629350745930_63180(","")
in_data = in_data[:-2]

# json转字典
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轴数据，也到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)
# 添加Y轴的数据
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="2%")
)

line.render()
f_us.close()
f_jp.close()
f_in.close()


from pyecharts.charts import Map
from pyecharts.options import VisualMapOpts

map = Map()
data = [
    ('北京市',99),
    ('上海市',199),
    ('湖南省',299),
    ('台湾省',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-90","color":"#FF6666"},
            {"min":100,"max":500,"label":"100-500","color":"#990033"},
        ]
    )
)

# 绘图
map.render()


import json
from pyecharts.charts import Map
from pyecharts.options import *

f = open("F://python//anli//疫情.txt","r",encoding="utf-8")

data = f.read()
f.close()

data_dict = json.loads(data)
province_data_list = data_dict["areaTree"][0]["children"]
data_list = []
for province_data in province_data_list:
    province_name = province_data["name"]
    province_confirm = province_data["total"]["confirm"]
    data_list.append((province_name+"省",province_confirm))
# print(data_list)

map = Map()
map.add("各省份确诊人数",data_list,"china")
map.set_global_opts(
    title_opts=TitleOpts(title="全国疫情地图"),
    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-9999人","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 *

f = open("F://python//anli//疫情.txt","r",encoding="utf-8")

data = f.read()
f.close()

data_dict = json.loads(data)
cities_data = data_dict["areaTree"][0]["children"][3]["children"]
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))
# print(data_list)
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,"label":"1-99人","color":"#CCFFFF"},
            {"min":100,"max":999,"label":"100-9999人","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,Timeline
from pyecharts.options import *

bar = Bar()
# 添加X轴数据
bar.add_xaxis(["中国","美国","英国"])
# 添加Y轴数据
bar.add_yaxis("GDP",[30,20,10],label_opts=LabelOpts(
    position="right" # 让数值到柱状图的右边显示
))

# 这样显示出来的是上下结构的
# 我们需要反转X和Y轴
bar.reversal_axis()
# 绘图
# bar.render("基础柱状图.html")

my_list = [["a",33],["b",53],["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)
print(my_list)


from pyecharts.charts import Bar,Timeline
from pyecharts.options import *
# 导入主题
from pyecharts.globals import ThemeType

bar1 = Bar()
# 添加X轴数据
bar1.add_xaxis(["中国","美国","英国"])
# 添加Y轴数据
bar1.add_yaxis("GDP",[30,20,10],label_opts=LabelOpts(
    position="right" # 让数值到柱状图的右边显示
))

# 这样显示出来的是上下结构的
# 我们需要反转X和Y轴
bar1.reversal_axis()

bar2 = Bar()
# 添加X轴数据
bar2.add_xaxis(["中国","美国","英国"])
# 添加Y轴数据
bar2.add_yaxis("GDP",[100,50,40],label_opts=LabelOpts(
    position="right" # 让数值到柱状图的右边显示
))

# 这样显示出来的是上下结构的
# 我们需要反转X和Y轴
bar2.reversal_axis()

bar3 = Bar()
# 添加X轴数据
bar3.add_xaxis(["中国","美国","英国"])
# 添加Y轴数据
bar3.add_yaxis("GDP",[200,100,70],label_opts=LabelOpts(
    position="right" # 让数值到柱状图的右边显示
))

# 这样显示出来的是上下结构的
# 我们需要反转X和Y轴
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  # 是否循环自动播放
)


timeline.render("柱状图第二节.html")
# 绘图

GDP案例


import json
from pyecharts.charts import Bar,Timeline
from pyecharts.options import *
from pyecharts.globals import ThemeType

f = open("F://python//anli//1960-2019全球GDP数据.csv","r",encoding="GB2312")
data_lines = f.readlines()
f.close()
data_lines.pop(0)  # 删除第一条数据
# 先定义一个字典对象
data_dict = {}
for line in data_lines:
    year = int(line.split(",")[0])
    country = line.split(",")[1]
    # 由于有的数据太大，在文件中以科学计数法的形式进行了存储，
    # 所以，我们使用float进行强转一下，变成正常的数据
    gdp = float(line.split(",")[2])
    """
        根据  data_dict[year]  这个是否抛出 keyError异常来决定年份是否已经添加进去了
        如果没有抛出异常，说明这个年份已经存在于这个字典中了
        如果抛出了异常，说明这个年份在字典中不存在，需要添加这个年份到字典中
    """
    try:
        data_dict[year].append([country,gdp])
    except KeyError:
        data_dict[year] = []
        data_dict[year].append([country, gdp])

# 创建时间线对象
timeline = Timeline(
    {"theme":ThemeType.LIGHT}
)

# print(data_dict)
# 因为直接for循环会导致字典中的顺序打乱，所以，我们先获取所有的年份，然后使用sorted进行排序
sorted_year_list = sorted(data_dict.keys())
# print(sorted_year)
for year in sorted_year_list:
    data_dict[year].sort(key=lambda element:element[1],reverse=True)
#     先按照GDP进行排序
    year_data = data_dict[year][0:8]  # 取出0-7这8个国家
    x_data = []
    y_data = []
    for country_gdp in year_data:
        x_data.append(country_gdp[0])
        y_data.append(country_gdp[1]/100000000)
#         以亿为单位，所以要除一亿

#     构建柱状图
    bar = Bar()
    # 大的数据在上面，小的数据在下面
    x_data.reverse()
    y_data.reverse()
    bar.add_xaxis(x_data)
    bar.add_yaxis("GDP(亿)",y_data,label_opts=LabelOpts(position="right"))
#                               起名字   数据                 数字放在右边
#     设置标题
    bar.set_global_opts(
        title_opts=TitleOpts(title=f"{year}年全球前八GDP数据")
    )
#     反转xY轴
    bar.reversal_axis()
    timeline.add(bar,str(year))

timeline.add_schema(
    play_interval=1000,
    is_timeline_show=True,
    is_auto_play=True,
    is_loop_play=False
)
# 绘制
timeline.render("1960-2019全球GDP前八.html")