python基础-超详细-基本涵盖所有基础知识点
·
python
目录
c.标识符不能用数字开头，会出错，同时大小写也可以区分不同的标识符
e.在写函数的时候，如果没有提示的话，就意味着该函数不在这个库里代表着出错
a. 查看数据类型使用type语句，同时可以用变量来存储变量的类型
c.七个运算符及复合赋值运算符；除法得到的结果是浮点型，保证精度
d.三引号定义；使用变量接收，就成了定义，如果不用变量接受，就成了多行注释
a.如果想要字符串内包含双引号，可以再单引号内包含双引号，反之可包含双引号；还可以使用转义字符来把引号的效用效果取消
d.在定义函数之后可以解释函数参数的作用，使用""" """三对引号
f.在定义其他函数的时候，想要引用其他函数，可以通过加入参数来影响函数的执行结果
1.重要的小细节
a.使用#注释的时候要空一格，保证代码的规范性
b.单行注释使用#，多行注释使用""" 三队 """
c.标识符不能用数字开头，会出错，同时大小写也可以区分不同的标识符
d. \t 相当于tab键
print("hello\tworld")
print ("查询余额\t[1]")
print ("查询\t\t[1]")
print ("查余额\t[1]")
# 当相差的数字距离很远的时候可以选择多加一个/t来保证对齐
e.在写函数的时候，如果没有提示的话，就意味着该函数不在这个库里代表着出错
#### f. 输出方式
"""
b:输出整数的二进制方式
c:输出整数对应的 Unicode 字符,
d:输出整数的十进制方式。
o:输出整数的八进制方式
x:输出整数的小写十六进制方式
X:输出整数的大写十六进制方式
"""
s = "asweqweqeq"
d = "sdasdas"
print("'{1:30}{0:^30}'".format(s, d)) # 0,1是参数的位置
print("{0:o}{0:X}".format(123))#支持多种类型
print("{:>15s}:{:<8.2f}".format("length", 23.12431))
print("{0:*^40}".format(1))
"""
e:输出浮点数对应的小写字母e的指数形式
E:输出浮点数对应的大写字母E的指数形式
f:输出浮点数的标准浮点形式。
%:输出浮点数的百分形式。
浮点数输出时尽量使用<.精度>表示小数部分的宽度，有助于更好控制输出格式
"""
print("{0:.2e},{0:.2E},{0:.2f},{0:.2%}".format(3.14))
2.基础知识点
1.运算符与type
a. 查看数据类型使用type语句，同时可以用变量来存储变量的类型
name = "黑马程序员" name_type = type(name) # 查看变量的类型 print(name_type)
b.类型装换，将浮点数转成整数会掉精度
num_str = str(11) print(type(num_str),num_str) float_str = str(11.345) print(type(float_str),float_str)
c.七个运算符及复合赋值运算符；除法得到的结果是浮点型，保证精度
d.三引号定义；使用变量接收，就成了定义，如果不用变量接受，就成了多行注释
name = """你好 ，我很好 """
2.字符串
a.如果想要字符串内包含双引号，可以再单引号内包含双引号，反之可包含双引号；还可以使用转义字符来把引号的效用效果取消
name = "\" 小王八蛋 "#可输出一个单引号
b.字符串的拼接
name = "宇璠"
address = "燕山"
num_1 = 100
print("xxx"+name+"xxx"+address)
# 简单的拼接，但是这个只可以字符串的拼接
message = "Python大数据学科，%s,你好%s" % (class_num, num_1)
print(message)
# 也可以使用%d，%f来占位，这样不改变数据类型
# %5.2f,表示将宽度控制为5，将小数点精度控制在两位小数
"""
还可以使用f{}来快速格式化
"""
print(f"我是{name},我成长于：{address},我的是：{num_1}")
#输出不换行！
print("hello", end = '')
print("world") # 使用一个接一行
c.字符串格式化表达式
print("1 * 1的结果是：%d" % (1 * 1))
print(f"1 * 1的结果是：{1 * 1}")
print("字符串在python的中类型是：%s" % type('字符串'))
for x in range(1, 10):
for j in range(1, x+1):
print(f"%d * %d = {x * j}\t" % (j, x), end='')
print()
#九九乘法表
d.字符串的替代,分割，查找，指定输出
my_str = "ni hao wo shi xiao shu"
# 输出倒数的第十个元素
value_2 = my_str[::-1][1: 2] # 倒序输出第二个字符
# index方法
value =my_str.index("wo")
print(f"在字符串{my_str}中查找and，其起始下标是:{value}")
# replace方法
new_my_str = my_str,replace("wo"，"程序")
print(f"将字符串{my_str}，进行替换后得到:{new_my_str}")
e.字符串的分割
# 语法:字符串.split(分隔符字符串)
# 功能:按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中注意:字符串本身不变，而是得到了一个列表对象
my_str = "hello python itheima itcast"
my_str_list = my_str.split(" ")
print(f"将字符串{my_str}进行split切分后得到：{my_str_list},类型是:{type(my_str_list)}")
f.字符串的规整操作
g.总结字符串函数的使用
#作为数据容器，字符串有如下特点 """ 只可以存储字符串 长度任意(取决于内存大小) 支持下表索引 允许重复字符串存在 不可以修改(增加或删除元素) 支持for循环，遍历取出字符串 """
h. format的使用
3.布尔类型 True or False
a.布尔类型的简单说明
result = "itcast" == "itheima"
print(f"字符串itcast是否和itheima相等，结果是：{result}，类型是：{type(result)}")
# 定义布尔类型
bool_1 = True
bool_2 = False
print(f"bool_1变量的内容是：{bool_1},类型是：{type(bool_1)}")
# 可以在print语句中使用{}直接格式化表达式， {num1 == num2},会返回True 或者 Flase
b.六类运算符
4.判断语句
a.使用if的时候要记得缩进和冒号
age = int(input("请输入你的年龄："))
if age > 19 : # 冒号
# 缩进
elif age < 10 :
print("小王八别打人")
else :
print("小王八")
# 自上而下运行，一定只有一个被执行
if int(input("请输入你的年龄：")) > 19 : # 冒号
# 缩进
# 这样写就不用一直输入多个数，而是一个一个判断
import random # 随机取数
num = random.randint(1,10)
print(num)
5.循环语句
a. while循环
i = 0
while i < 100 :
print("小王八")
i += 1
#循环一百次
b. for循环
# for循环处理字符串
for x in name :
print(name) # 可以逐步打印出字符串
# range的基本用法
"""
range(0,10,2)前面两个是范围，后面一个是步长；
范围是左闭右开
默认从0开始range(10);步长为 1
千万别忘记打冒号！
"""
for x in range(0,10,1) ：
print(x)
6.函数的使用
a.函数的使用需要调用
def say_hi() :
print("你好")
say_hi()
b.函数的返回值可以通过变量去接收
def add_up(a,b) :
result = a + b
return result
r = add(5,6)
print(r)
c.函数如果没有加return，也会返回None
def xiaowangba() :
print("xiaowangba")
return None
#在if判断中，None表示False的意思
def check_age(age):
if age > 18 :
return "SUCCESS"
else :
return None
result = check_age(16)
if not result:
print("未成年，不可以进入")
else is result:
print(f"您是成年人，可以自由玩游戏！{result}{check_age(18)}")
d.在定义函数之后可以解释函数参数的作用，使用""" """三对引号
def add_up(age,weight):
"""
函数说明
：param age.....
: parem weight...
: return: ...
"""
print("nihao")
return None
e.在函数内部修改全局变量
num = 500
def text():
global num # 设置内部定义的变量为全局变量
num = 100
print(f"{num}")
# 记得定义函数之后要记得执行
f.在定义其他函数的时候，想要引用其他函数，可以通过加入参数来影响函数的执行结果
def text(shou_header):
if shou_header :
print("------xiao---------")
print("xxx")
def guess():
print("xxx")
text(False)
#这样可以选择性的使用text函数的内容
h. return的返回;可无限返回input
def text():
if input("请输入数字:") == 1:
return input("请输入数字哦:")
while True :
text()
7.数据容器入门
a.列表可以一次存储多个数据，且都可以为不同的数据类型，支持嵌套
my_list = ["itheima","itcast","python"] print(my_list) # 会将所有的内容打印出来 list_1 = [[1,2,3],[2,3,4]，"你好"] # 可以嵌套使用 print(type(my_list)) # 打印类型 print(my_list[0]) """ 第一个元素是0，从后向前也可以，最后一个是-1，以此类推 双层嵌套 使用下标索引的时候不要超出范围 """ print(list_1[0][2]) # 将会是3
b.查找索引
my_list = ["iao",2,4,67]
index = mylist.index("67")
print(f"67在列表中的下标位置是{index}")
c.修改列表
my_list = ["iao",2,4,67] my_list[1] = 6 print(my_list) # 列表的内容发生改变 # 反向下标 check_num = my_list[-2] # 4
d.插入数据,追加数据
my_list = [2,4,67]
my_list.insert(1,"best")
my_list.insert(2,2)
my_list.append("nihao")
print(f"列表在追加了元素后，结果是：{my_list}")
#添加一批元素
list_2 = [1,2,4,7]
list_2.extend([4,3,2])
print(list_2)
e.删除下标
mylist = [1,2,45,6]
del mylist[2]
print(f"列表删除元素之后的结果是：{mylist}")
###
mylist.pop(2)
element = mylist.pop(1) # 可以使用变量来接收删除的元素
print(mylist)
"""
通过查找内容来删除元素
"""
list_3 = [56,7,1,5,3,2,1,5,"sdas"]
list_3.remove(1)
#一次只能去除一个值
list_3.remove("sdas")
print(list_3)
f.清空列表，统计列表，统计列表中元素的全部数量
# 清空列表 list_4 = [2,5,7,3,7,4] list_4.clear() print(list_4) # 统计列表 count = list_4.count(7) print(count) # 统计列表中元素的全部数量 print(len(list_4)) receive = len(list_4) print(receive)
g.元组定义：
定义元组使用小括号，且使用逗号隔开各个数据，数据可以是不同的数据类型
#定义空元组
#定义元组
t1=(1,"Hello", True)
变量名称 = () # 方式1
变量名称 = tuple() # 方式2
# ！# 定义单个元素时要在后面加上“,”号
t = ("hello",)
#根据下标(索引)取出数据
t1=(1,2,'hello')
print(t1[2]) #结果:"he11o
# 根据indexO)，查找特定元素的第一个匹配项
t1=(1,2,'hello',3,4,'hello')
print(t1.index('hello')) # 结果:2
# 统计某个数据在元组内出现的次数
t1=(1,2,'hello',3,4,'hello')
print(t1.count('hello')) # 结果:2
# 统计元组内的元素个数
t1=(1,2,3)
print(len(t1)) # 结果 3
h.序列
# 对list进行切片，从1开始，4结束，步长1
my_list = [0,1,2,3,4,5,6]
result1 = my_list[1:4] # 步长默认是一，可以省略
print(f"结果1：{result1}，类型是{type(result1)}")
print(f"{result1[2]}")
# 对tuple 进行切片，从头开始，到最后结束，步长1
my_tuple = (0,1,2,3,4,5,6)
result2 = my_tuple[:]
# 起始和结束不写表示从头到尾，步长为一可以省略
print(f"结果2：{result2}")
# 对str进行切片，从头开始，到最后结束，
my_str = "1234567"
result3 = my_str[::2]
print(f"结果3：{result3}")
#对str进行切片，从头开始，到最后结束，步长-1
my_str = "1234567"
result4 = my_str[::-1]
#将序列反转
print(f"结果4：{result4}")
#可以注意我们对于不同的类型有不同的处理方法
#省略的东西不同；序列反转是一个很好的东西
i.集合：{元素, 元素, }去重，顺序改变
my_set_empyt = set() # 定义空集合
my_set = {'as',"sdasd"}
print(f"my_set的内容是：{my_set},类型是：{type(my_set)}")
# 添加新元素
my_set.add("Python")
print(my_set)
# 移除元素
my_set.remove("as")
print(f"移除后的结果是：{my_set}")
# 随机去除一个元素，集合内容发生改变
element = my_set.pop()
print(f"集合被取出元素是：{element},取出元素后：{my_set}")
# 清空集合
my_set.clear()
print(f"集合被清空，结果是：{my_set}")
#取两个集合的差集
set1 = {1,2,3}
set2 = {1,4,6}
set3 = set1.difference(set2)
print(f"set1的结果是：{set1}")
print(f"set2的结果是：{set2}")
print(f"set3的结果是：{set3}")
#消除两个集合的差集
#对比集合1和集合2，在集合1内，删除和集合2相同的元素
#结果：集合1被修改，集合2不变
set4 = {23,24,14,235,52}
set5 = {23,235,4,1,41,13,4}
set4.difference_update(set5)
print(f"set4的结果是：{set4}")
print(f"set5的结果是：{set5}")
#将集合合并，将集合1和集合2组成新集合
setx1 = {1,2,45}
setx2 = {1,3,5,23}
setx3 = setx1.union(setx2)
print(f"集合setx1和集合setx2合并的结果是：{setx3}")
#统计元素数量
number = len(setx2)
print(number)
#集合的遍历，不能用while循环
set6 = {123,35,12,3123,21,3}
for element in set6:
print(f"集合的元素有：{element},类型是：{type(element)}")
j.字典
# 定义字典
my_dict1 = {"小王八":99,"炸裂":98,"钉钉":98}
# 定义空字典
my_dict2 = {}
my_dict3 = dict()
print(f"字典1的内容是：{my_dict2},类型：{type(my_dict2)}")
print(f"字典1的内容是：{my_dict3},类型：{type(my_dict3)}")
# 不能重复，新的会把老的覆盖
score = my_dict1["小王八"]
print(f"小王八的考试分数是：{score}")
# 字典的嵌套
stu_score_dict = {
"小王八":{
"语文":99,
"数学":100,
"英语":100,
},#不要忘记这还有一个符号
"小明" :{
"语文":99,
"数学":100,
"英语":100,
}
}
print(f"小王八的成绩是：{stu_score_dict["小王八"]}")
print(f"小王八的语文成绩是：{stu_score_dict["小王八"]["语文"]}")
k.字典的常用操作
# 字典的常用操作
my_dict1 = {"小王八":99,"炸裂":98,"钉钉":98}
# 新增元素
my_dict1["张信哲"] = 66
print(f"字典经过新增元素后，结果是：{my_dict1}")
# 更新元素
my_dict1["小王八"] = 100
print(f"字典经过更新后，结果是：{my_dict1}")
#删除元素
score = my_dict1.pop("张信哲")
print(f"字典中被移除了一个元素，结果：{my_dict1},张信哲的考试分数是：{score}")
#清空元素
my_dict1.clear()
print(f"字典被清空了，内容是：{my_dict1}")
my_dict1 = {"小王八":99,"炸裂":98,"钉钉":98}
keys = my_dict1.keys()
print(f"字典的全部keys是：{keys}")
#字典的遍历
for key in keys : #可以换成my_dict1
print(f"字典的key是：{key}")
print(f"字典的value是：{my_dict1[key]}")
#字典元素数量，用len（字典）
l. max与min，类型转换
print(f"比较大小：{'be' > 'c'}")
my_str = "asdad "
my_str = max(my_str)
print(f"my_str的排序之后的结果是:{my_str}")
my_str = list(my_str)
print(f"将my_str转换成元组类型:{my_str},类型是：{type(my_str)}")
###################
my_list =[1,2,3,4,5]
my_tuple =(1,2,3,4,5)
my_str = "abcdefg"
my_set ={1,2,3,4,5}
my_dict ={"key1":1,"key2":2,"key3":3,"key4":4,"key5": 5}
#len元素个数
print(f"列表 元素个数有:{len(my_list)}")
print(f"元组 元素个数有:{len(my_tuple)}")
print(f"字符串元素个数有:{len(my_str)}")
print(f"集合 元素个数有:{len(my_set)}")
print(f"字典 元素个数有:{len(my_dict)}")
#max最大元素
print(f"列表 最大的元素是:{max(my_list)}")
print(f"元组 最大的元素是:{max(my_tuple)}")
print(f"字符串最大的元素是:{max(my_str)}")
print(f"集合 最大的元素是:{max(my_set)}")
print(f"字典 最大的元素是:{max(my_dict)}")
#min最小元素
print(f"列表 最小的元素是:{min(my_list)}")
print(f"元组 最小的元素是:{min(my_tuple)}")
print(f"字符串最小的元素是:{min(my_str)}")
print(f"集合 最小的元素是:{min(my_set)}")
print(f"字典 最小的元素是:{min(my_dict)}")
#类型转换:容器转列表
print(f"列表转列表的结果是:{list(my_list)}")
print(f"元组转列表的结果是:{list(my_tuple)}")
print(f"字符串转列表结果是:{list(my_str)}")
print(f"集合转列表的结果是:{list(my_set)}")
print(f"字典转列表的结果是:{list(my_dict)}")
#其他的类型也是这样转，但是不可以转成字典，因为不符合字典的书写规范
m.总结
3.函数的进阶使用
a.接收函数的多返回值
# 接收函数的多返回值
def text_return():
return 1, "hello", True
x, y, z = text_return()
print(x)
print(y)
print(z)
# 位置参数
def user_info(name, age, gender):
print(f"你的名字是{name}，年龄是{age}，性别是{gender}")
user_info("TOM", 19, "男")
b.函数作为参数传递
# 函数的传入
def text_func(compute):
result = compute(3, 2) # 确定compute是函数
print(f"compute参数类型是：{type(compute)}")
print(f"计算结果是：{result}")
def compute(x, y):
return x + y
# 调用，并传入函数
text_func(compute)
c.匿名函数使用lambda关键字进行定义
"""
注意事项：
匿名函数用于临时构建一个函数，只用一次的场景
匿名函数的定义中，函数体只能写一行代码，如果函数体要写多行代码，不可用lambda匿名函数，应使用def定义带名函数
"""
def test_func(compute):
result = compute(1,2)
print(f"结果是：{result}")
# 通过lambda匿名函数的形式，将匿名函数作为参数传入
test_func(lambda x, y: x + y)
test_func(lambda x, y: x + y)
# 再次使用需要重新定义，自带return
d. random函数的使用
e. 函数date time
4.文件
a.文件的编码
#编码就是一种规则集合，记录了内容和二进制间进行相互转换的逻辑，最常用的是UTF-8编码
b. open()打开函数
"""
使用open函数，可以打开一个已经存在的文件，或者创建一个新文件
open(name,mode.encoding)
name:是要打开的目标文件名的字符串(可以包含文件所在的具体路径)
mode:设置打开文件的模式(访问模式):只读、写入、追加等
encoding:编码格式(推荐使用UTF-8)
注意:此时的'f'是'open'函数的文件对象，对象是Python中一种特殊的数据类型，拥有属性和方法，可以使用对象.属性或对象,方法对其进行访问
r:以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
w:打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，原有内容会被删除。如果该文件不存在，创建新文件。
a:打开一个文件用于追加。如果该文件已存在，新的内容将会被写入到已有内容之后如果该文件不存在，创建新文件进行写入。
read(num):num表示要从文件中读取的数据的长度(单位是字节)，如果没有传入num，那么就表示读取文件中所有的数据。
readlines():可以按照行的方式把整个文件中的内容进行一次性读取，并且返回的是一个列表，其中每一行的数据为一个元素。
"""
f = open(r"D:\software\pycharm\text.txt", 'r', encoding="UTF-8")
print(type(f))
print(f"读取十个字节的结果：{f.read(10)}")
print(f"read方法读取全部内容的结果是：{f.read()}")
# 使用read之后的光标不会回到原来的位置，所以前面的内容不会被再次读取
print("{0:*^40}".format(1))
# readlines()的使用
lines = f.readlines() # 读取全部文件，封装到列表中
print(f"lines对象的类型是：{type(lines)}")
print(f"lines的内容：{lines}")
# readline一次读取一行
# for循环读取文件行
for line in f:
print(f"每一行的数据是：{line}")
# 文件的关闭
f.close()
# with open as f:
with open(r"D:\software\pycharm\text.txt", 'r', encoding="UTF-8") as f:
for line in f:
print(f"每一行数据是：{line}")
c.文件的使用
"""
直接调用write，内容并未真正写入文件，而是会积攒在程序的内存中，称之为缓冲区
当调用flush的时候，内容会真正写入文件
这样做是避免频繁的操作硬盘，导致效率下降(攒一堆，一次性写磁盘)
"""
with open(r"D:\software\pycharm\text1.txt", "w", encoding="UTF-8") as f:
f.write("Hello world!!")
f.flush()
# close自带flush（）操作
# 打开文件得到文件对象，准备读取
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()
5.异常捕获
1.格式
try:
#写正文
except：
print("error")
#也可以在except后面加上错误，指定异常
except NameError as e:
print(e)#能将异常打出来
#捕获多个异常
except (NameError,xxx...) as e:
# 捕获所有异常
try:
print(name)
except Exception as e:
print("出现异常")
print(e)
else:
print("没有出现异常，执行该代码")
finally:
# 无论如何都会执行的代码
print("nihao")
# 关闭文件
# 异常传递具有传递性
2. import，创建一个包
from random import random #里面的函数直接用，不需要加点缀 """ 引入自己的模块的时候，直接把名字引入就ok 如果自己模块的东西有的你不想执行 在上面加上 if __name__=='__main__': 这句话在源文件中可以执行，但是引用过去之后就不可以 __all__ = [, "", ""] 该语句作用是仅指定作用的函数可以使用 """ """ python包 包就是就是一个文件夹，在该文件夹下包含了一个__init__.py（没有就是一个普通的文件夹）文件，该文件夹可用于包含多个模块文件，本质上依然是模块 """ #简单来说，这个就是大包包小包，然后只引用大包就可以用小包 __all__ :控制 import *能够导入的内容
3. j s o n
import json
# json数据可视化
# json数据与python数据的相互转换
data = [{"name": "张", "age": 16}, {"name": "zhang", "age": 20}]
data_str = json.dumps(data, ensure_ascii=False)
print(type(data_str))
# 如果想显示中文，需要加入ensure_ascii=False,不是用ascii码表来显示
print(data_str)
# json转python
data = json.loads(data_str)
print(type(data))
print(data)
6. p ye charts 的基础入门
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])
# 生成图像
# line.render()
# 全局配置选项
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),
)
line.render()
2.数据处理成折线图
import json
from pyecharts.charts import Line
from pyecharts.options import *
# 打开文件
f_us = open("D:/software/pycharm/docx/美国.txt", "r", encoding="Utf-8")
f_jp = open("D:/software/pycharm/docx/日本.txt", "r", encoding="Utf-8")
f_yd = open("D:/software/pycharm/docx/印度.txt", "r", encoding="Utf-8")
us_data = f_us.read() # 读取所有文件
jp_data = f_jp.read() # 读取所有文件
in_data = f_yd.read() # 读取所有文件
us_data = us_data.replace("jsonp_1629344292311_69436(", "")
jp_data = jp_data.replace("jsonp_1629350871167_29498(", "")
in_data = in_data.replace("jsonp_1629350745930_63180(", "")
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年(到315下标结束)
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年(到315下标结束)
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(False))
line.add_yaxis("日本确诊人数", jp_y_data, label_opts=LabelOpts(False))
line.add_yaxis("印度确诊人数", in_y_data, label_opts=LabelOpts(False))
# 设置全局选项
line.set_global_opts(
title_opts=TitleOpts(title="2020年疫情三国数据", pos_left="center", pos_bottom="1%"),
legend_opts=LegendOpts(is_show=True),
toolbox_opts=ToolboxOpts(is_show=True),
visualmap_opts=VisualMapOpts(True)
)
# 生成图表
line.render()
f_us.close()
f_jp.close()
f_yd.close()
3.简单的地图表
from pyecharts.charts import *
from pyecharts.options import VisualMapOpts
# 准备地图对象
map = Map()
# 准备数据
data = [
("北京市", 99),
("上海市", 199),
("湖南省", 299),
("台湾省", 399),
("广东省", 499)
]
# 添加数据
map.add("测试地图", data, "china")
map.add("测试地图", data, "china", layout_size=100)
# 设置全局选项
map.set_global_opts(
visualmap_opts=VisualMapOpts(
is_show=True,
is_piecewise=True,
max_=1000
# pieces=[
# {"min": 1, "max": 9, "label": "1-9", "color": "white"}, # #CCFFFF}
# {"min": 2, "max": 99, "label": "10-99", "color": "black"},
# {"min": 3, "max": 500, "label": "100-500", "color": "#990033"}
# ]
)
)
map.render()
4.全国疫情图
# 记得加省，加自治区，加市，不然没用，而且max_和pieces不能混用
import json
from pyecharts.charts import *
from pyecharts.options import *
# 读取文件
f = open("D:/software/pycharm/docx/疫情.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))
# 造一个对象
map = Map()
map.add("各省份确诊人数", data_list, "china")
# 配置全局选项
map.set_global_opts(
title_opts=TitleOpts(title="全国疫情图"),
visualmap_opts=VisualMapOpts(
is_show=True,
is_piecewise=True,
max_=100000
)
)
# 绘图
map.render("全国疫情地图.html")
5.河南省疫情地图
import json
from pyecharts.charts import *
from pyecharts.options import *
f = open("D:/software/pycharm/docx/疫情.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))
data_list.append(("济源市", 9))
map=Map()
map.add("河南省疫情分布", data_list, "河南")
map.set_global_opts(
title_opts=TitleOpts(title="全国疫情图"),
toolbox_opts=ToolboxOpts(is_show=True),
visualmap_opts=VisualMapOpts(
is_show=True,
is_piecewise=True,
max_=300
)
)
map.render("河南省疫情地图.html")
6.横向柱状图
from pyecharts.charts import Bar
from pyecharts.options import *
# 使用Bar构建基础柱状图
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")
7.动态时间线示意图
# 有时间线的柱状图开发
from pyecharts.globals import ThemeType
from pyecharts.charts import *
from pyecharts.options import *
# 修改颜色,创立时间线对象
timeline = Timeline(
{"theme": ThemeType.ESSOS}
)
d = [[30, 20, 10], [50, 40, 60], [30, 89, 76]] # 贮存数据
range_color = ['#FFC0CB', '#FFFF00', '#008000'] # 颜色变化
for i in range(3):
bar = Bar()
bar.add_xaxis(["中国", "美国", "英国"])
bar.add_yaxis("GDP", d[i], label_opts=LabelOpts(position="right"))
bar.reversal_axis()
bar.set_global_opts(
title_opts=TitleOpts(title="GDP柱状图"), # 加名称
visualmap_opts=VisualMapOpts( # 加范围显示
is_show=True,
dimension=0, # 加上这个就欧克了，映射维度
range_color=range_color, # 这个厉害，可以改变你的颜色，然后动态显示
# max_=100
)
)
timeline.add(bar, f"点{i}")
# 设置自动循环
timeline.add_schema(
play_interval=1000, # 1000ms
is_timeline_show=True,
is_auto_play=True,
is_loop_play=True
)
# 绘图是用时间线对象绘图，而不是bar对象
timeline.render("基础时间线柱状图.html")
8.扇形图
import matplotlib.pyplot as plt
# 扇形图的标签
labels = ['A', 'B', 'C', 'D']
# 每个扇形的大小
sizes = [15, 30, 45, 10]
# 每个扇形的颜色
colors = ['gold', 'yellowgreen', 'lightcoral', 'lightskyblue']
# 突出显示的扇形
explode = (0.2, 0, 0, 0)
# 生成扇形图
plt.pie(sizes,
explode=explode,
labels=labels, colors=colors,
autopct='%1.1f%%',
shadow=True,
startangle=140
)
# 保持纵横比相等
plt.axis('equal')
# 显示图形
plt.show()
9.动态GDP柱状图绘制
from pyecharts.charts import Bar, Timeline
from pyecharts.options import *
from pyecharts.globals import ThemeType
# 读取文件
f = open("D:/software/pycharm/docx/第1-12章资料/资料/资料/可视化案例数据/动态柱状图数据/1960-2019全球GDP数据.csv", "r", encoding="ANSI")
data_lines = f.readlines()
# 关闭文件
f.close()
# 删除第一行数据
data_lines.pop(0)
# 将数据转为字典存储，格式为：
# { 年份:[[国家, gdp]，[国家, gdp]，...... ]，年份:[[国家,gdp]，[国家, gdp]，.....], ...... }，比如：
# { 1960:[[美国, 123]，[中国, 231]，...... ]，1961:[[美国,124]，[中国, 234]，.....], ...... }
# 先定义一个字典
data_dict = {}
for line in data_lines:
year = int(line.split(",")[0]) # 年份
country = line.split(",")[1] # 省份
GDP = float(line.split(",")[2]) # 因为美国的GDP是科学计数法，所以用float强制转回来
# 如何判断字典里面有没有制定的key呢？
try:
data_dict[year].append([country, GDP])
except KeyError:
data_dict[year] = []
data_dict[year].append([country, GDP])
# 排序年份
sorted_year_list = sorted(data_dict.keys())
timeline = Timeline({"theme": ThemeType.LIGHT}) # 创建时间线对象
for year in sorted_year_list:
data_dict[year].sort(key=lambda element: element[1], reverse=True)
# 取出本年份前八名的国家
year_data = data_dict[year][: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()
range_color = ['#FFC0CB', '#FFFF00', '#008000']
# 设置每一年的图表标题
bar.set_global_opts(
title_opts=TitleOpts(title=f"{year}年全球GDP前八数据"),
visualmap_opts=VisualMapOpts( # 加范围显示
is_show=True,
dimension=0, # 加上这个就欧克了，映射维度
range_color=range_color, # 这个厉害，可以改变你的颜色，然后动态显示
max_=10000
)
)
# 创建时间线对象
timeline.add(bar, str(year))
# 设置时间为自动播放
timeline.add_schema(
play_interval=1000, # 时间间隔
is_timeline_show=True, # 是否显示时间
is_loop_play=True, # 是否循环
is_auto_play=True # 是否自动播放
)
# 绘图
timeline.render("1960——2019全球GDP前八国家.html")
7.类
1.初始对象--变量
# 设计一个类
class Student:
name = None
gender = None
nationality = None
native_place = None
age = None
stu_1 = Student()
stu_1.name = "小王八"
stu_1.gender = "女"
stu_1.nationality = "中国"
stu_1.native_place = "邯郸"
stu_1.age = 19
print(stu_1.name)
print(stu_1.gender)
print(stu_1.native_place)
2.成员方法--def
class Student:
name = None
def say_hi(self): # self不占变量数量，但得有
print(f"大家好，我是{self.name},请大家多多关照")
def say_hi2(self, msg):
print(f"大家好，我是：{self.name},{msg}") # 使用类里面得变量
stu = Student()
stu.name = "小王八"
stu.say_hi()
stu.say_hi2("咋，你想咋")
stu_1 = Student()
stu_1.name = "树"
stu_1.say_hi()
stu_1.say_hi2("哎哟哟")
腾讯云面向开发者汇聚海量精品云计算使用和开发经验，营造开放的云计算技术生态圈。
更多推荐
26
0- 0
已为社区贡献1条内容
所有评论(0)