字变量：在代码中，被写下来的固定的值
字符串：python中用双引号包裹起来的都是字符串
"""
本代码演示了
-各类字变量的写法
-通过print语句输出各类字变量
"""
# 写一个整数字变量
666
# 写一个浮点数字变量
13.14
# 写一个字符串字变量
"你不困我困"
print(666)
print(13.14)
print("你不困我困")
#单行注释
“”“注释内容”“” 多行注释
在程序运行时，能存储计算结果或能表示值的抽象概念，用来积记录数据
在print语句中，直接输出类型信息
print(type(666))
用变量存储type()的结果
string_type=type("你不困我困")
可以查看字变量和变量的类型
变量无类型，但是它存储的数据有
# 方式1：使用print语句直接输出类型信息
print(type(666))
# 方式2：使用变量存储type()语句的结果
string_type = "你不困我困"
print(type(string_type))
# 方式3：使用type()语句，查看变量中存储的数据类型信息
name = "你不困我困"
print(type(name))
| 语句（函数） | 说明 |
|---|---|
| int(x) | 将x转化为一个整数 |
| float(x) | 将x转换为一个浮点数 |
| str(x) | 将x转换为字符串 |
在python中，可以给很多东西取标识符
是用户在编程的时候所使用的一系列名字，用于给变量、类、方法等命名
Python中，标识符命名的规则
变量的命名
# 将数字类型转换为字符串
num_str = str(11)
print(type(num_str), num_str)
float_str = str(11.345)
print(type(float_str), float_str)
# 将字符串转换为数字
num = int("11")
print(type(num), num)
num2 = float("11.345")
print(type(num2), num2)
# 整数转浮点数
float_num = float(11)
print(type(float_num), float_num)
# 浮点数转整数 会丢失精度
int_num = int(11.34)
print(type(int_num), int_num)
# 算术运算符
print("1+1= ", 1+1)
print("1-1= ", 1-1)
print("1*2= ", 1*1)
print("2/1= ", 2/1)
print("21//2= ", 21//2) # 整除
print("2**2 = ", 2**2)
# 赋值运算符
num = 1+2*3
print("num=", num)
# 复合赋值运算符
num2 = 1
print("num2 =", num2)
num2 += 1
print("num2+1 =", num2)
字符串的三种定义方式
1.单引号定义法：name='你不困我困'
2.双引号定义法：name="你不困我困"
3.三引号定义法：name="""你不困我困""" # 不用变量接收就是注释
字符串拼接
# 字符串字变量之间的拼接
print("1.你不困" + "我困")
# 字符串字变量和字符串变量的拼接,必须是两个字符串间拼接
name = "我困"
tel = "111111"
print("2.你不困" + name + "，我的电话是：" + tel)
字符串格式化
# 通过占位的形式，完成拼接
name = "翻斗花园"
message = "3.胡图图住在:%s" % name
print(message)
# 通过占位的形式，完成数字和字符串的拼接
class_num = 57
avg_salary = 9989
message = "4.胡英俊的工号是%d,工资是%d" % (class_num, avg_salary)
print(message)
字符串格式化的精度控制
可以使用辅助符号m.n 来控制数据的宽度和精度
m，控制宽度，要求数字（很少使用），设置的宽度小于数字自生，不生效
.n，控制小数点精度，要求是数字，会进行小数的四舍五入
num1 = 11
num2 = 11.2345678
print("数字11宽度限制5，结果是：%5d" % num1)
print("数字11宽度限制1，结果是：%1d" % num1)
print("数字11.2345678宽度限制7，小数精度2，结果是：%7.2f" % num2)
print("数字11.2345678小数精度2，结果是：%.2f" % num2)
字符串格式化2
f"{变量}…"
name = "翻斗花园"
address = 112
mam = "张小丽"
print(f"胡图图住在{name}{address}室，妈妈是{mam}")
对表达式进行格式化
if 要判断的条件：
条件成立时，要做的事
range(num)
获取一个从0开始，到num结束的数字序列（不含num本身）
range(num1,num2)
获取一个从num1开始，到num2结束的数字序列（不包含num2本身）
range(num1,num2,step)
获取一个从num1开始，到num2结束的数字序列（不包含num2本身）
数字之间的步长，以step为准，默认是1
# 无限次机会，每次猜不着会提示，猜中数字后会提示猜了几次
import random
num = random.randint(1, 100)
# 通过一个布尔类型的变量，做循环是否继续的标记
flag = True
# 定义一个变量，记录总共猜测了几次
count = 0
while flag:
guess_num = int(input("请输入您猜测的数字："))
count += 1
if guess_num == num:
print("猜中了！")
# 设置flag就是循环终止的条件
flag = False
else:
if guess_num > num:
print("您猜测的数据较大！")
else:
print("您猜测的数据较小！")
print(f"您总共猜测了{count}次")
# i = 0
# while i < 10:
# print("你不困")
# i += 1
# 通过while循环，计算1累加到100的和
i = 1
sum_i = 0
while i <= 100:
sum_i += i
i += 1
print(f"1到100的累加和为：{sum_i}")
i = 1
while i <= 10:
print(f"今天是表白的第{i}天，")
j = 1
while j <= 3:
print(f"送第{j}只玫瑰")
j += 1
print("tutu I love you")
i += 1
i -= 1
print(f"坚持到第{i}天，表白成功")
i = 1
while i <= 9:
j = 1
while j <= i:
# 内层循环的print语句，不要换行
# 通过\t制表符来对齐
print(f"{j}*{i}={j*i}\t", end='')
j += 1
i += 1
# print()就是换行
print()
name = "nibukunwokun"
# 将name中的内容，挨个输出赋予x变量
# 就可以在循环体中对x进行处理
for x in name:
print(x, end='')
# for 变量 in 待处理数据集
# 同while循环不同，for循环无法定义循环条件
# 统计如下字符串有多少个u
name = "nibukunwokun"
count = 0
for x in name:
if x == "u":
count += 1
print(f"{name}中有{count}个u")
# 打印九九乘法表
# 通过外层循环控制行数
for i in range(1, 10):
# 通过内存循环控制每一行的输出
for j in range(1, i+1):
print(f"{j}*{i}={j*i}\t", end='')
# 外层循环可以通过print输出一个回车符
print()
# for x in range(10):
# print(x, end='')
# print()
#
# for x in range(2, 5):
# print(x, end='')
# print()
#
# for x in range(2, 10, 2):
# print(x, end='')
for x in range(10):
print("送玫瑰花")
# 演示循环中断语句continue
# for i in range(1, 6):
# print("语句1")
# continue # 结束本次循环，开始下次循环
# print("语句2") # 不会执行
# 演示continue的嵌套应用
# for i in range(1,6):
# print("语句1")
# for j in range(1, 6):
# print("语句2")
# continue
# print("语句3")
# print("语句4")
# 演示循环中断语句 break
# for i in range(1, 100):
# print("语句1")
# break # 循环直接终止
# print("语句3")
# print("语句2")
# 演示break的嵌套应用
for i in range(1, 6):
print("语句1")
for j in range(1, 6):
print("语句2")
break
print("语句3")
print("语句4")
函数：是组织好的，可重复使用的，用来实现特定功能的代码段
# 统计字符串的长度，不使用内置函数len()
str1 = "nibukun"
str2 = "wokun"
str3 = "hututu"
# count = 0
# for i in str1:
# count += 1
# print(f"字符串 {str1} 的长度是： {count}")
# 可以使用函数来优化整个过程
def my_len(data):
count = 0
for i in data:
count += 1
print(f"字符串 {data} 的长度是{count}")
my_len(str1)
my_len(str2)
my_len(str3)
为了得到一个针对特定需求，可供重复利用的代码段，提高程序的复用性，减少重复性代码，提高开发效率
def 函数名(传入参数):
函数体
return 返回值
传入参数的功能：在函数进行计算的时候，接受外部提供的数据
# 定义两数相加的函数，通过参数接收被计算的两个数字
def my_add(x, y):
result = x + y
print(f"{x}+{y}的计算结果是:{result}")
# 调用函数，传入被计算的两个数字
my_add(1, 2)
掌握函数返回值的作用
掌握函数返回值的定义语法
def 函数(参数...):
函数体
return 返回值
变量 = 函数(参数)
函数返回字
函数在执行完成后，返回给调用者的结果
返回值的应用语法：
使用关键字：return 来返回结果
注意
函数体在遇到return后就结束了，所以写在return后的代码不会执行
无返回值的函数，实际上就是返回了：None这个字变量
变量作用域指的是变量的作用范围（变量在哪里可以使用，在哪里不可以使用）
主要可以分为两类：局部变量和全局变量
局部变量：定义在函数体内部的变量，只在函数体内部生效
作用：子啊函数体内部，临时保存数据，当函数调用完成后，立刻销毁局部变量
全局变量：在函数体内，外都可以生效的变量
使用global关键字，可以将函数内部变量声明为全局变量
什么是数据容器
一个可以容纳多份数据的数据类型，容纳的每一份数据称之为一个元素，每一个元素可以是任意类型的数据
数据容器根据其特点的不同，可以分为：
分为5类：列表，元组，字符串，集合，字典
# 字变量
[元素1,元素2,元素3,.....]
# 定义变量
变量名称 = [元素1,元素2,元素3,.....]
# 定义空列表
变量名称 = []
变量名称 = list
以[]作为标识
列表内每个元素用逗号隔开
使用下标索引，取出特定位置的数据（下标从0开始，依次递增/或者逆序，从下标-1开始）
列表除了可以
还提供了一系列的功能（列表的方法）
函数是一个封装的代码单元，可以提供特定功能，在Python中，如果将函数定义为class（类）的成员，那么函数会称之为方法
class 方法名:
函数
# Student方法
class Student:
def add(self,x,y):
return x+y
# 方法的使用
student = Student()
num = student.add(1,2)
查询某元素的下标
功能：查找指定元素在列表的下标，如果找不到，就会报错ValueError
列表.index(元素) # index就是列表对象（变量）内置的方法（函数）
修改特定位置（索引）的元素值
列表[下标] = 值 # 直接对指定下标（正向、反向下标均可）的值进行重新赋值
插入元素
列表.insert(下标，元素) # 在指定的下标位置，插入指定的元素
追加元素
列表.append(元素)，将指定元素，追加到列表的尾部 # 追加单个元素
列表.extend(其他数据容器) # 将其他数据容器的内容取出，依次追加到列表尾部
删除元素
del列表[下标]
列表.pop(下标) # 可将删除元素进行记录
删除某元素在列表中的第一个匹配项
列表.remove(元素)
清空列表
列表.clear()
统计某元素在列表中的数量
列表.count(元素)
统计列表内，有多少元素
len(列表)
列表的特点
将容器内的元素依次取出进行处理的行为，称之为遍历或者迭代
while循环
def list_while_func():
my_list = ["胡图图", "张小丽", "胡英俊"]
"""
循环控制变量通过下标索引来控制，默认0
每一次循环将下标索引+1
循环条件：下标索引变量<列表的元素数量
"""
# 定义一个变量用来标记列表的下标
index = 0
while index < len(my_list):
element = my_list[index]
print(f"列表的元素：{element}")
index += 1
list_while_func()
for循环
for 临时变量 in 数据容器:
对临时变量进行处理
表示，从容器中，依次取出元素并赋值到临时变量上，在每一次的循环中，我们可以对临时变量进行处理
def list_for_func():
my_list = [1, 2, 3, 4, 5]
for element in my_list:
print(f"列表的元素：{element}")
list_for_func()
while循环适用于任何想要循环的场景
for循环适用于，遍历数据容器的场景和简单的固定次数循环场景
元组和列表一样，都可以封装多个，不同类型的元素在内，但是最大的不同点在于：元组一旦定义完成，就不可再被修改
# 定义元素字变量
(元素，元素....元素)
# 定义元组变量
变量名称 = (元素，元素....元素)
# 定义空元组
变量名称 = ()
变量名称 = tuple()
注意：元组中只有一个数据，这个数据后面要添加括号
元组的相关操作
| 编号 | 方法 | 作用 |
|---|---|---|
| 1 | index() | 查找某个数据，如果数据存在返回对应的下标，否则报错 |
| 2 | count() | 统计某个数据在当前元组中出现的次数 |
| 3 | len(元组) | 统计元组内的元素个数 |
元组的元素不可以变，但是如果元组的元素包括list，可变list中的内容
同元组一样，不可修改
字符串的相关操作
| 方法 | 作用 |
|---|---|
| 字符串.index(字符串) | 查找特定字符串的下标索引值 |
| 字符串.replace(字符串1,字符串2) | 将字符串中全部字符串1替换为字符串2（不是修改字符串本身，而是得到一个新字符串） |
| 字符串.split(分隔符字符串) | 按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中（字符串本身不变，而是得到了一个列表对象） |
| 字符串.strip() | 去除前后的空格 |
| 字符串.strip(字符串) | 去除前后指定字符串 |
序列：内容连续，有序，可使用下标索引的一类数据容器
列表，元组，字符串均可视为序列
切片：从一个序列中，取出一个子序列
# 从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列
# 步长为负数表示反向标记
# 对序列进行切片操作不会影响序列本身，而是得到一个新的序列
序列[起始下标:结束下标:步长]
# 对list进行切片，从1开始，4结束，步长1
my_list = [0, 1, 2, 3, 4, 5, 6]
result1 = my_list[1:4:1]
print(f"结果1：{result1}")
# 对tuple切片，从头开始，到最后结束，步长1
my_tuple = (0, 1, 2, 3, 4, 5, 6)
result2 = my_tuple[:] # 起始和结束可以默认不写表示从头到尾，步长1可以省略
print(f"结果2:{result2}")
# 对str进行切片，从头开始，到最后结束，步长2
my_str = "01234567"
result3 = my_str[::2]
print(f"结果3:{result3}")
# 对str进行切片，从头开始，到最后结束，步长-1
result4 = my_str[::-1] # 等同于将序列反转
print(f"结果4:{result4}")
# 对列表进行切片，从3开始到1结束，步长-1
my_list = [0, 1, 2, 3, 4, 5, 6]
result5 = my_list[3:1:-1]
print(f"结果5：{result5}")
# 对元组进行切片，从头开始，到最后结束，步长-2
result6 = my_tuple[::-2]
print(f"结果6：{result6}")
基本定义语法
# 定义集合字变量
{元素,元素......元素}
# 定义集合变量
变量名称 = {元素,元素......元素}
# 定义空集合
变量名称 = set()
集合是无序的，所以集合不支持下标索引访问，但是集合和列表一样，允许修改
集合的相关操作
| 方法 | 作用 |
|---|---|
| 集合.add(元素) | 将指定元素，添加到集合内 |
| 集合.remove(元素) | 将指定元素，从集合内移除 |
| 集合.pop() | 从集合中随机取出一个元素 |
| 集合1.difference(集合2) | 取出集合1和集合2的差集（集合1但是集合2没有的），得到一个新集合，集合1，2 不变 |
| 集合1.difference_update(集合2) | 对比集合1和集合2，在集合1内，删除和集合2相同的元素，集合1被修改，集合2不变 |
| 集合1.union(集合2) | 将集合1和集合2组成新集合，得到新集合，集合1，2 保持不变 |
| len(集合) | 得到一个整数，记录了集合的元素数量 |
字典的定义
存储的是键值对
# 定义字典字变量
{key:value,key:value......key:value}
# 定义字典变量
my_dict = {key:value,key:value......key:value}
# 定义空字典
my_dict = {}
my_dict = dict()
key和value可以是任意数据类型，但是key不能为字典
字典是可以嵌套的
字典的相关操作
| 方法 | 作用 |
|---|---|
| dict[key] = value | 字典被修改，新增了元素 |
| dict[key] = value | 字典key不可以重复，若对已经存在的key执行，相当于更新value值 |
| dict.pop(key) | 获取指定key的value，同时字典被修改，指定key的数据被删除 |
| dict.keys() | 得到字典的全部key |
# 演示使用多个变量，接收多个返回值
def test_return():
return 1, "hello", True
x, y, z = test_return()
print(x)
print(y)
print(z)
函数参数种类
使用方式的不同，常见4中参数的使用方式：
位置参数、关键字参数、缺省参数、不定长参数
位置参数：调用函数时，根据函数定义的参数位置来传递函数【注意：传递的参数和定义的参数的顺序及个数必须一致】
关键字参数：函数调用时通过”键 = 值“形式传递参数
作用：可以让函数更加清晰，容易使用，同时也消除了参数的顺序要求【注意：函数调用时，如果有位置参数时，位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序】
缺省参数：也叫默认参数，用于定义函数，为参数提供默认值，调用函数时可不传该默认参数的值【注意：所有位置参数必须出现在默认参数前，包括函数定义和调用】
作用：当调用函数时没有传递参数，就会使用默认缺省参数对应的值
不定长参数：也叫可变参数，用于不确定调用时会传递多少个参数的场景
作用：当调用函数时不确定参数个数时，可以使用不定长参数
def user_info(name, age, gender):
print(f"姓名是：{name}，年龄是：{age}，性别是：{gender}")
# 位置参数（默认使用形式）
user_info("胡图图", 20, "男")
# 关键字参数
user_info(name="胡英俊", gender='男', age=40)
# 缺省参数
def user_info2(name, age, gender='男'):
print(f"姓名是：{name}，年龄是：{age}，性别是：{gender}")
user_info2('牛爷爷', 70)
# 不定长 - 位置不定长，*号
# 不定长定义的形参会作为元组存在，接收不定长数量的参数传入
def user_info3(*args):
print(f"args参数的类型是：{type(args)},内容是：{args}")
user_info3(1, 2, 3, 4, '小美')
# 不定长 - 关键字不定长，**号
def user_info4(**kwargs):
print(f"kwargs参数的类型是：{type(kwargs)},内容是：{kwargs}")
user_info4(name="胡图图", age=10)
编码技术：即翻译的规则，记录了如何将内容翻译成二进制，以及如何将二进制翻译回可识别内容
常用编码：UTF-8， GBK，Big5
不同编码翻译内容不一样
| 方法 | 解释 |
|---|---|
| open() | 可以打开或者创建一个新文件 |
| 文件对象.read(num) | 表示从文件中读取的数据的长度（单位是字节），如果没有传入num，则读全部 |
| 文件对象.readlines() | 按照行的形式八整个文件中的内容进行一次性读取，并且返回的是一个列表，其中每一行的数据为一个元素 |
| 文件对象.readline() | 一次读取一行内容 |
| 文件对象.close() | 关闭文件对象，也就是关闭对文件的使用 |
| with open 语法 | 可以在操作完成后自动关闭文件，避免遗忘close方法 |
"""
name:要打开的目标文件名的字符串（可以包含文件所在的具体路径）
mode:设置打开文件的模式（访问模式）：只读、写入、追加等
encoding:编码格式（一般使用UTF-8）
"""
open(name,mode,encoding)
"""
mode =
r:以只读方式打开文件，文件的指针将会放在文件的开头，这是默认方式
w:打开一个文件只用于写入，如果该文件已存在则打开文件，并从开头开始编辑，原有内容会被删除，如果文件不存在，则创建新文件
a:打开一个文件用于追加，如果该文件已经存在，新内容会被写入已有内容之后，如果文件不存在，创建新文件并写入
"""
# 打开文件
f = open("D:/桌面/python/test.txt", "r", encoding="UTF-8")
print(type(f))
# 读取文件 read()
print(f"读取10个字节的结果：{f.read(10)}")
print(f"读取全部内容的结果：{f.read()}") # 多次调用read会在上一次调用基础上调用
# 读取文件 readLines() 读取文件的全部行，封装到列表中
lines = f.readlines()
print(f"lines对象的类型：{type(lines)}")
print(f"lines对象的内容是：{lines}")
# 读取文件 readLine()
line1 = f.readline()
line2 = f.readline()
line3 = f.readline()
print(f"第一行数据是{line1}")
print(f"第二行数据是{line2}")
print(f"第三行数据是{line3}")
# for循环读取文件行
for line in f:
print(f"每一行数据：{line}")
# 文件的关闭
f.close()
# with open 语法操作文件
with open("D:/桌面/python/test.txt", "r", encoding="UTF-8") as f:
for line in f:
print(f"每一行的数据{line}")
f.open("文件路径", "w")
f.write()
# 内容刷新
f.flush()
f.open("文件路径", "a")
f.write()
# 内容刷新
f.flush()
所谓异常就是BUG
捕获异常的作用：提前假设某处出现异常，做好提前准备，当真的出现异常的时候，可以有后续手段
捕获常规异常：
try:
可能发生错误的代码
except:
如果出现异常执行的代码
捕获指定的异常：
try:
print(name)
except NameError as e:
print('name变量名称未定义错误')
捕获多个异常：
try:
print(1/0)
except (NameError,AeroDivisionError):
print("")
异常else：
try:
print(1)
except Exception as e:
print(e)
else
print("我是else，是没有出现异常时执行的代码")
异常的finally:
try:
...
except Exception as e:
....
else:
...
finally:
....
异常具有传递性
# 定义一个出现异常的方法
def func1():
print("func1 开始执行")
num = 1 / 0 # 除0 肯定有异常
print("func1 结束执行")
# 定义一个无异常的方法，调用上面的方法
def func2():
print("func2 开始执行")
func1()
print("func2 结束执行")
# 定义一个方法，调用前面的方法
def main():
try:
func2()
except Exception as e:
print(f"出现异常，异常信息是：{e}")
main()
Python模块，是一个python文件，以.py结尾，模块能定义函数，类和变量，模块里也能包含可执行的代码
模块的作用：
模块的导入方式：
[from 模块名] import [模块|类 | 变量 | 函数 | *][as 别名]
自定义模块
从物理上来看，包就是一个包含了一个init.py 文件的文件夹，该文件夹可以用于包含多个模块文件，从逻辑上来看，包的本质依旧是模块
导入包
import 包名.模块名
包名.模块名.目标
pip install 包
pip install -i 镜像网站 包
JSON是一种轻量级的数据交互格式，可以按照JSON指定的格式去组织和封装数据
JSON本质上是一个带有特定格式的字符串
在Python JSON要么是一个单独的字典或者内部元素都是字典的列表
主要功能
各个编程语言存储数据的容器不尽相同，例如：在Python中有字典dict这样的数据类型而在其他语言中可能没有对应的字典。
可以使用JSON数据格式作为数据中转站
json格式的数据要求很严格（字典）
# 实例
{"name":"admin", "age":18}
python数据和json数据的互相转换
# 导入json模块
import json
# 准备符合格式json要求的python数据
data = [{"name": "wang", "age":19},{"name": "li", "age":79}]
# 通过json.dumps(data)方法把python数据转化为了json数据
data = json.dumps(data)
# 通过json.loads(data)方法把json数据转化为了python数据
data = json.loads(data)
导入
# 显示虚拟环境
conda env list
# 进入虚拟环境
conda activate 环境名
# 安装
pip install pyecharts
pyecharts入门：基础折线图
# 导包，导入line功能构建折线图兑现
from pyecharts.charts import Line
# 得到折线图对象
line = Line()
# 添加x轴数据
line.add_xaxis(["中国", "美国", "日本"])
# 添加y轴数据
line.add_yaxis("GDP",[30, 20 ,10])
# 生成图表
line.render()
pyecharts模块中有很对的配置选项，常用到2个类别的选项
全局配置选项
全局配置通过set_global_opts方法来进行配置，相应的选项
| TitleOpts | 设置标题 |
| LegendOpts | 图例配置项 |
| ToolboxOpts | 工具箱配置项 |
| VisualMapOpts | 视觉映射配置项 |
| TooltipOpts | 提示框配置项 |
| DataZoomOpts | 区域缩放配置项 |
系列配置选项
网站：ab173.com 查看json数据
import json
f_us = open("D:/桌面/折线图数据/美国.txt", "r", encoding="UTF-8")
us_data = f_us.read() # 美国的全部内容
# 去掉不和JSON规范的开头
us_data = us_data.replace("jsonp_1629344292311_69436(", "")
# 去掉和JSON规范的结尾
us_data = us_data[:-2] # 使用切片去除最后一个不和规范的数据
us_dict = json.loads(us_data)
# 获取trend key
us_trend_data = us_dict['data'][0]['trend']
# 获取日期数据，用于x轴，取2020年(到314结束)
us_x_data = us_trend_data['updateDate'][:314]
# 获取确认数据，用于y轴，取2020年(到314结束)
us_y_data = us_trend_data['list'][0]['data'][:314]
line = Line() # 获取折线图对象
line.add_xaxis(us_x_data) # x轴是公用的，所以使用一个国家的数据即可
# label_opts=LabelOpts(is_show=False) 局部设置，数据不显示
line.add_yaxis("美国确诊人数", us_y_data, label_opts=LabelOpts(is_show=False))
# 调用render方法
line.render()
# 关闭文件对象
f_us.close()
f_jp.close()
f_in.close()
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(is_show=True)
)
import json
from pyecharts.charts import Line
from pyecharts.options import TitleOpts, LabelOpts, LegendOpts, ToolboxOpts, VisualMapOpts
# 处理数据
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)
# print(type(us_dict))
# print(us_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']
# print(type(trend_data))
# print(trend_data)
# 获取日期数据，用于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]
# print(x_data)
# 获取确认数据，用于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轴数据
# label_opts=LabelOpts(is_show=False) 局部设置，数据不显示
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%"),
legend_opts=LegendOpts(is_show=True),
toolbox_opts=ToolboxOpts(is_show=True),
visualmap_opts=VisualMapOpts(is_show=True)
)
# 调用render方法生成图表
line.render()
# 关闭文件对象
f_us.close()
f_jp.close()
f_in.close()
通过Bar构建基础柱状图
Timeline() 时间线
柱状图描述的是分类数据，回答的是每一个分类中有多少这个问题，这是柱状图的主要特点，同时柱状图很难动态的描述一个趋势性的数据，pyecharts提供了一种解决方案- 时间线
如果说Bar,Line对象是一张图标，时间线就是创建一个一维的x轴，轴上的每个点就是一个图表对象
# 导包
from pyecharts.charts import Timeline
timeline = TimeLine()
# 自动播放设置
timeline.add_schema(
play_interval=1000, # 自动播放的时间间隔，单位是毫秒
is_timeline_show=True, # 是否自动播放的时候显示时间线
is_auto_play=True, # 是否自动播放
is_loop_play=True # 是否循环自动播放
)
timeline = Timeline({"theme": ThemeType.ROMANTIC})
列表的sort方法
列表.sort(key = 选择排序依据的函数, reverse = True|False)
from pyecharts.charts import Bar, Timeline
from pyecharts.options import *
from pyecharts.globals import ThemeType
# 读取数据
f = open("D:/桌面/python/资料/可视化案例数据/动态柱状图数据/1960-2019全球GDP数据.csv", "r", encoding="GB2312")
# .readlines() 打开是一个列表
data_lines = f.readlines()
# 关闭文件
f.close()
# 删除第一条数据
data_lines.pop(0)
# 将数据转化为字典存储
# 定义一个字典对象
# 格式为：{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数据
# 数据格式化
try:
data_dict[year].append([country, gdp])
# 如果没有key， 就捕获异常，新建一个列表
except KeyError:
data_dict[year] = []
data_dict[year].append([country, gdp])
# print(data_dict)
# 创建时间线对象
# 设置颜色格式
timeline = Timeline({"theme": ThemeType.LIGHT})
# 排序年份
sorted_year_list = sorted(data_dict.keys())
for year in sorted_year_list:
# 通过gdp进行排序
data_dict[year].sort(key=lambda element: element[1], reverse=True)
# 取出本年份前8名的国家
year_data = data_dict[year][0:8]
x_data = []
y_data = []
# for循环每一年的数据，基于每一年的数据，创建每一年的bar对象
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和y轴数据完成从大到小
x_data.reverse()
y_data.reverse()
bar.add_xaxis(x_data)
# 设置数值标签在右侧 label_opts=LabelOpts(position="right")
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}年全球前八GDP数据")
)
# 在for中，将每一年的bar对象添加到时间线中
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")
在程序中是可以做到和生活中那样，设计表格、生产表格、填写表格的组织形式的
在程序中设计表格，称之为：设计类(class)
class Sudent:
name = None # 记录学生姓名
在程序中打印生产表格，称之为：创建对象
stu_1 = Student() # 基于类创建对象
在程序中填写表格，称之为：对象属性赋值
stu_1.name = "胡图图" # 为学生1对象赋予名称属性值
class 类名称:
类的属性
类的行为
创建类对象的语法
对象 = 类名称()
在类中定义成员方法和定义函数基本一致
def 方法名(self, 形参1, ....形参n):
方法体
self关键字是成员方法定义的时候，必须填写的
# 定义一个带有成员方法的类
class Student:
name = None # 学生姓名
def say_hi(self):
print(f"大家好啊，我是{self.name}，初次见面，请多关照")
def say_hi2(self, msg):
print(f"大家好，我是{self.name},{msg}") # 想要访问成员属性，必须使用self关键字，外部传入参数则不需要
stu_1 = Student()
stu_1.name = "胡图图"
stu_1.say_hi()
stu_1.say_hi2("我的耳朵很大")
stu_2 = Student()
stu_2.name = "小美"
stu_2.say_hi()
stu_2.say_hi2("我最爱漂亮")
# 设计一个闹钟类
class Clock:
id = None
price = None
def ring(self):
import winsound
winsound.Beep(2000, 3000)
# 构建两个闹钟对象并使其工作
clock1 = Clock()
clock1.id = "2023"
clock1.price = 888
print(f"闹钟ID：{clock1.id}， 价格是：{clock1.price}")
clock1.ring()
clock2 = Clock()
clock2.id = "2024"
clock2.price = 888
print(f"闹钟ID：{clock2.id}， 价格是：{clock2.price}")
clock2.ring()
Python类可是使用
__init__(self,...) # 构造方法
可以实现
class Student:
# # 可以省略
# name = None
# age = None
# tel = None
def __init__(self, name, age, tel):
self.name = name
self.age = age
self.tel = tel
print("Student类创建了一个类对象")
stu = Student("胡图图", 6, "1111111111")
print(stu.name)
print(stu.age)
print(stu.tel)
内置的类方法，各自有其特殊的功能，称之为魔术方法
| 方法 | 作用 |
|---|---|
| init | 构造方法，可用于构建类对象的时候设置初始化行为 |
| str | 字符串方法，用于实现类对象转化字符串的行为 |
| lt | 用于两个类对象小于，大于符号比较 |
| le | 用于两个类对象小于等于，大于等于符号比较 |
| eq | 用于两个类对象== 符号比较 |
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
stu1 = Student("胡图图", 6)
stu2 = Student("壮壮", 8)
stu3 = Student("小美", 6)
# __str__, 如果没有该方法，则输出内存地址
print(stu1)
print(str(stu1))
# __lt__，直接对两个对象进行比较是不可以的，但是在类中实现__lt__方法
# 即可同时完成：小于符号和大于符号两种比较
print(stu1 < stu2)
print(stu1 > stu2)
# __le__
print(stu1 <= stu3)
# __eq__
print(stu1 == stu3)
封装：将现实世界事物在类中描述为属性和方法，即为封装
面向对象包含三大特性：
私有成员：现实世界有部分属性和行为不公开对使用者开放，同样在类中描述属性和方法的时候也需要达到这个要求，就需要定义私有成员了
类中提供了私有成员的形式来支持
定义私有成员的方式：
# 私有成员变量
__变量名
# 私有成员方法
def __方法名:
私有成员的访问权限
# 设计一个类，用来描述手机
class Phone:
# 提供私有成员变量：__is_5g_enable
__is_5g_enable = True # 5g状态
# 提供私有成员方法：__check_5g()
def __check_5g(self):
if self.__is_5g_enable:
print("5g开启")
else:
print("5g关闭，使用4g网络")
# 提供公开成员方法:call_by_5g()
def call_by_5g(self):
self.__check_5g()
print("正在通话中")
phone = Phone()
phone.call_by_5g()
class 类名(父类名):
类内容体
继承可以分为单继承和多继承
多继承：
Python的类之间也支持多继承，即一个类，可以继承多个父类
class 类名(父类1,父类2....父类N):
类内容体
多个父类中，如果有同名的成员，那么默认以继承顺序（从左到右）为优先级
即：先继承的保留，后继承的被覆盖
pass关键字：占位语句，补全代码，无实义
复写：子类继承父类的成员方法后，如果对其不满意，可以进行复写
即：在子类中重新定义同名的属性或方法即可
class Phone:
IMEI = None
producer = "hututu"
def call_by_5g(self):
print("使用5g通话")
# 定义子类，复写父类成员
class MyPhone(Phone):
producer = "xiaomei" # 复写父类的成员属性
def call_by_5g(self):
print("开启CPU单核模式，确保通话的时候省电")
print("使用5g网络进行通话")
print("关闭CPU单核模式，确保性能畅通")
phone = MyPhone()
phone.call_by_5g()
print(phone.producer)
调用父类同名成员
一旦复写父类成员，那么类对象调用成员的时候，就会调用复写后的新成员，如果需要使用被复写的父类的成员，需要特殊的调用方法：
# 调用父类成员
父类名.成员变量
父类名.成员方法(self)
# 使用super()调用父类成员
super().成员变量
super().成员方法()
Python在3.5版本的时候就引入了类型注解，以方便静态类型检查工具，IDE等第三方工具
**类型注解：**在代码中设计数据交互的地方，提供数据类型的注解
主要功能：
支持：
变量注解的语法：
变量:类型
#type:类型
# 基本数据类型注解
import json
import random
from typing import List, Tuple, Dict
var_1: int = 10
var_2: str = "hututu"
var_3: bool = True
# 类对象类型注解
class Student:
pass
stu: Student = Student()
# 基本容器类型注解
my_list: list = [1, 2, 3]
my_tuple: tuple = (1, 2, 3)
my_dict: dict = {"胡图图": 99}
# 容器类型详细注解
my_list1: List[int] = [1, 2, 3]
my_tuple1: Tuple[int, str, bool] = (1, "hututu", True)
my_dict1: Dict[str, int] = {"胡图图": 99}
# 在注释中进行类型注解
# alt+enter 自动导包
var_11 = random.randint(1, 10) # type: int
var_12 = json.loads('{"name": "胡图图"}') # type: dict[str, str]
def fun():
return 10
var_13 = fun() # type: int
函数（方法）的类型注解-形参注解语法：
def 函数方法名(形参名:类型,形参名:类型....):
pass
函数方法的类型注解-返回值注解语法：
def 函数方法名(形参名:类型,形参名:类型....) ->返回值类型:
pass
# 对形参进行类型注解
def add(x: int, y: int):
return x + y
add(1, 2)
# 对返回值进行类型注解
def fun(data: list) -> list:
return data
fun([1, 2, 3])
可以定义联合类型注解
Union[类型,....,类型]
# 使用Union必须先导包
from typing import Union, List
my_list: List[Union[int, str]] = [1, 2, "hututu", "xiaomei"]
def func(data: Union[int, str]) -> Union[int, str]:
pass
多态：多种状态，即完成某个行为时，使用不同的对象会得到不同的状态
即：同样的行为（函数），传入不同的对象，得到不同的状态
多态常用于继承关系上
抽象类（接口）：含有抽象方法（方法体是空实现的[pass]）的类
抽象类相当于定义一个标准，包含了一些抽象的方法，要求子类必须实现
抽象类的作用：做顶层实际标准，以便子类做具体实现，也是对子类的一种软性约束，要求子类必须复写父类的一些方法，并配合多态使用，获得不同的工作状态。
# 演示抽象类
class AC:
def cool_wind(self):
"""制冷"""
pass
def hot_wind(self):
"""制热"""
pass
def swing_l_r(self):
"""左右摆风"""
pass
# 子类
class Midea_AC(AC):
def cool_wind(self):
print("美的空调制冷的具体实现")
def hot_wind(self):
print("美的空调制热的具体实现")
def swing_l_r(self):
print("美的空调左右摆风的具体实现")
# 具体类的实现
class GREE_AC(AC):
def cool_wind(self):
print("格力空调制冷的具体实现")
def hot_wind(self):
print("格力空调制热的具体实现")
def swing_l_r(self):
print("格力空调左右摆风的具体实现")
def make_cool(ac: AC):
ac.cool_wind()
midea_ac = Midea_AC()
gree_ac = GREE_AC()
make_cool(midea_ac)
make_cool(gree_ac)
data_define.py
"""
数据定义的类
"""
class Record:
def __init__(self, data, order_id, money, province):
self.data = data # 订单日期
self.order_id = order_id # 订单ID
self.money = money # 订单金额
self.province = province # 销售省份
# 控制输出为字符串而不是内存地址
def __str__(self):
return f"{self.data}, {self.order_id}, {self.money}, {self.province}"
file_define.py
"""
和文件相关的类定义
"""
import json
from typing import List
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
# print(line)
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():
# 将json数据类型转化为字典数据类型
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("D:/桌面/python/资料/2011年1月销售数据.txt")
json_file_reader = JsonFileReader("D:/桌面/2011年2月销售数据JSON.txt")
# text_file_reader.read_data()
list2 = json_file_reader.read_data()
for l in list2:
print(l)
main.py
"""实现步骤：
1. 设计一个类，可以完成数据的封装
2. 设计一个抽象类，定义文件读取的相关功能，并使用子类实现具体功能
3. 读取文件，生产数据对象
4. 进行数据需求的逻辑计算（计算每一天的销售额）
5. 通过PyEcharts进行图形绘制
"""
from typing import List
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("D:/桌面/python/资料/2011年1月销售数据.txt")
json_file_reader = JsonFileReader("D:/桌面/2011年2月销售数据JSON.txt")
jan_data: List[Record] = text_file_reader.read_data()
feb_data: List[Record] = json_file_reader.read_data()
# 将2个月份的数据合并为1个list来存储
all_data: List[Record] = jan_data + feb_data
# 开始进行数据计算
# key:日期， value:当天营业额
data_dict = {}
for record in all_data:
if record.data in data_dict.keys():
# 当前日期已经有记录了，所以和老记录累加即可
data_dict[record.data] += record.money
else:
data_dict[record.data] = record.money
# print(data_dict)
# 可视化图表开发
bar = Bar(init_opts=InitOpts(theme=ThemeType.LIGHT))
bar.add_xaxis(list(data_dict.keys())) # 添加x轴数据
# label_opts=LabelOpts(is_show=False) 不显示数据
bar.add_yaxis("销售额", list(data_dict.values()), label_opts=LabelOpts(is_show=False)) # 添加y轴数据
bar.set_global_opts(
title_opts=TitleOpts(title="每日销售额")
)
bar.render("每日销售额柱状图.html")
SQL：结构化查询语言，用于访问和处理数据库的标准计算机语言
由于数据库管理系统的功能非常多，不仅仅是存储数据，还要包含：数据的管理、表的管理、库的管理、账户管理、权限管理
SQL分为以下几类
| 名称 | 作用 |
|---|---|
| DDL（数据定义语言） | 库的创建删除、表的创建删除 |
| DML（数据操纵语言） | 新增数据、删除数据、修改数据 |
| DCL（数据控制语言） | 新增用户、删除用户、密码修改、权限管理 |
| DQL（数据查询语言） | 基于需求查询和计算数据 |
SQL特点
大小写不敏感
以; 作为结束
支持注释
--单行注释
# 单行注释
/*多行
注释*/
DDL-库管理
| 要求 | 语句 |
|---|---|
| 查看数据库 | show databases; |
| 使用数据库 | use 数据库名称; |
| 创建数据库 | create database 数据库名称 [charset UTF-8]; |
| 删除数据库 | drop database 数据库名称; |
| 查看当前使用的数据库 | select database(); |
DDL-表管理
| 要求 | 语句 |
|---|---|
| 查看哪些表 | show tables; |
| 删除表 | drop table if exists 表名称; |
| 创建表 | create table 表名称( 列名称 列类型;…); |
-- 列类型有
int
float
varchar
date
timestamp
| 关键字 | 作用 |
|---|---|
| insert | 插入 |
| delete | 删除 |
| update | 更新 |
数据插入insert
insert into 表[(列1, 列2.....,列N)]
values[(值1,.....值N),
(值1,.....值N),
......]
数据删除delete
delete from 表名称
where 条件判断
数据更行update
update 表名
set 值 = 列
where 判断语句
在SQL中，通过select关键字开头的SQL语句，进行数据的查询
select 字段列表
from 表
select 字段|聚合函数
from 表
where 判断条件
group by 列
| 函数名 | 作用 |
|---|---|
| sum(列) | 求和 |
| avg(列) | 求平均值 |
| min(列) | 求最小值 |
| max(列) | 求最大值 |
| count(列|*) | 求数量 |
结果排序
select 列|聚合函数|*
from 表
where 判断语句
group by
order by [ASC,DESC]
结果分页限制：使用limit关键字，对查询结果进行数量限制或者分页显示
select 列|聚合函数|*
from 表
where 判断语句
group by
order by [ASC,DESC]
limit n[,m]
安装第三方库
pip install pymysql
from pymysql import Connection
# 创建到mysql数据库的链接
conn = Connection(
host="localhost", # 主机名(IP)
port=3306, # 端口
user="root", # 账户
password="******" # 密码
)
# 关闭链接
conn.close()
# 执行非查询性质SQL
cursor = conn.cursor() # 获取到游标对象
# 选择数据库
conn.select_db("test")
# 执行sql
cursor.execute("create table test_pymysql(id int);")
# 执行查询性质SQL
cursor = conn.cursor() # 获取到游标对象
# 选择数据库
conn.select_db("world")
# 执行sql
cursor.execute("select * from student")
results = cursor.fetchall() # 返回一个大元组
for r in results:
print(r)
手动commit
from pymysql import Connection
# 构建到Mysql数据库的链接
conn = Connection(
host="localhost",
port=3306,
user="root",
password="******"
)
# 执行非查询性质的SQL
# 获取到游标对象
cursor = conn.cursor()
# 选择数据库
conn.select_db("world")
# 执行sql语句
cursor.execute("insert into student values(7,'牛爷爷',79)")
# 通过commit确认
conn.commit()
# 关闭链接
conn.close()
自动commit
# 构建到Mysql数据库的链接
conn = Connection(
host="localhost",
port=3306,
user="root",
password="******",
autocommit=True
)
DDL定义
本次需要新建一个数据库来使用，数据库名称：py_sql
create database py_sql charset utf8;
基于数据结构，得到建表语句
create table orders(
order_date date,
order_id Varchar(255),
money int,
province varchar(10)
);
实现
# 构建MySQL链接对象
conn = Connection(
host="localhost",
port=3306,
user="root",
password="******",
autocommit=True
)
# 获得游标对象
cursor = conn.cursor()
# 选择数据库
conn.select_db("py_sql")
# 组织SQL语句
for record in all_data:
sql = f"insert into orders(order_date,order_id,money,province) " \
f"values('{record.data}', '{record.order_id}', {record.money},'{record.province}')"
# print(sql)
# 执行sql语句
cursor.execute(sql)
# 关闭链接对象
conn.close()