字符串

单个变量进行拼接

name = “字符串拼接”
message = “字符串拼接占位符 %s” % name

多个变量进行拼接

name1 = “字符串拼接”
name2 = “多个变量进行字符串拼接”
message = “字符串拼接占位符 %s” % (name1,name2)
%s为字符串占位(将内容转换成字符串)
%d为整数占位(将内容转换为整数)
%f为浮点型占位(将内容转换为浮点型)
//多个变量进行拼接需要按占位顺序来

数字精度控制

m控制宽度
.n控制小数点精度
%5d:整数占位5位
%5.2f:浮点数占位5位宽度,同时四舍五入精确小数点两位
%.2f:浮点数四舍五入保留后两位

while循环

1
2
3
4
5
6
7
sum = 0
i = 1
while i <= 100:
print(f"当前i的值{i}")
sum +=i #定义一个变量存储累计加的值
i+=1 #i进行自增
print(sum)

案例

猜数字

1.无限次机会
2.提供猜了几次
3.提示大了还是小了

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import random
num = random.randint(1,10)
s= 0
flag = True
while flag:
guess_num = int(input("输入你猜的数字"))
if num == guess_num:
print("你猜对了,一共猜了%d次" % s)
flag = False
elif num > guess_num:
print("你猜小了")
else:
print("你猜的数字大了")
s+=1

乘法表

1
2
3
4
5
6
7
8
9
10
11
12
13
#1.9x9乘法表
#1.第一行1个第二行2个
#1x1 =1
#1x2 2 2x2 =4
i = 1
while i<=9:
j = 1
#内层循环控制输出每行有多少
while j <= i:
print(f"i*j={i*j}\t",end='')
j += 1
i +=1
print()#控制行,循环一行就结束
1
2
3
4
5
#for循环写乘法表
for i in range(1,10):
for j in range(1,i+1):
print(f"{j}*{i}={j*i}\t",end='')
print()

发工资案例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#发工资案例
#员工编号从1开始,每人领取1000元
#如果员工绩效为5以下不发
import random
all = 10000
for i in range(1,21):#20位需要领取工资的员工
cum = random.randint(1,10)#随机生成绩效
if cum <= 5:
print(f"编号{i}绩效为{cum},由于绩效低于5不发工资")
continue
elif all == 0:
print("账户余额不够了,发不起工资了")
break
else:
all -=1000
print(f"编号{i}绩效为{cum},发工资1000元,账户余额还剩{all}元")

存取款案例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
# 存取款功能
# 1.主菜单分为·查询余额·存款·取款·退出
# 查询余额
# 存取款

#定义全局变量
money = 50000
name = None
# 要求输入姓名
name =input("请输入你的姓名:")

# 查询余额函数
def query(show_header):
if show_header:#判断输出需要标头不True输出标头False不需要标头
print("-------查询余额-------")
print(f"{name},你好,您的余额剩余:{money}元")

#存款函数
def saving(num):
global money #在函数内部定义为全局变量
money+=num
print(f"成功存款{num}元")
query(False)

#取款函数
def get_money(num):
global money
money -=num
print(f"成功取款{num}元")
query(False)
#菜单函数
def menu():
print("-----主菜单-----")
print("查询余额 [1]")
print("存款 [2]")
print("取款 [3]")
print("退出 [4]")
return input("请输入你的选择")
while True:
keyboard_input = menu()
if keyboard_input == "1":
query(True)
continue #通过continue继续下一次循环,一进来就是回到了主菜单
elif keyboard_input == "2":
num = int(input("您想要存入多少钱"))
saving(num)
continue
elif keyboard_input == "3":
num = int(input("您想要取多少钱"))
get_money(num)
continue
else:
print("程序退出了")
break

数据容器

分为5类分别是
列表(list)、元组(tuple)、字符串(str)、集合(set)、字典(dict)、

列表常用操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#定义列表
list[元素1,元素2,元素3,元素4]
mylist =["元素1""元素2","元素3","元素4"]

mylist.index(元素)
#查找某元素的下标

mylist.insert(下标,元素)
#在列表中插入元素

mylist.append(元素)
#在列表末尾插入元素

mylist.extend(其他数据容器)
#将其他的数据容器的内容取出依次插入到列表末尾

del.mylist[下标]
#删除列表指定下标元素

mylist.pop(下标)
#删除指定下标元素,指定变量会返回删除的内容

mylist.remove(元素)
#如果列表有相同元素就只删除第一个元素

mylist.clear()
#清空整个列表

mylist.count(元素)
#统计某元素在列表内的数量

提取列表中的偶数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#取出列表中的偶数
mylist = [1,2,3,4,5,6,7,8,9,10]#定义列表
def while_list():#定义函数
index = 0#定义起始值
mylist_num=[]#定义一个新的列表
while index < len(mylist):
if mylist[index]%2 == 0:
#%2取余计算==0为偶数不等于0为奇数
mylist_num.append(mylist[index])
index+=1
print(mylist_num)
while_list()
def list_for():#for循环进行偶数取出
mylist_num = []
for i in mylist:
if i%2 == 0:
mylist_num.append(i)
print(f"偶数有{mylist_num}")
list_for()

元组的操作

元组一旦定义完成就不可以修改了
如果只有一个数据要加,号,否则是错误的不是元组

但是元组里面嵌套的可修改的列表就可以修改
1
2
3
4
5
6
7
8
9
10
11
12
13
14
#定义方法一
变量名称 = ()
变量名称 = tuple()

#t1是被定义的元组变量名称

t1.index(数据)
#查找某个下元素的下标,如果没有就报错

t1.count(数据)
#统计某个数据在元组中出现的次数

len(元组)
统计元组的元素个数

字符串

和元组一样不能修改,如果修改了是得到一个新的字符串

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
字符串.index(元素)
#查找字符串中某元素的位置

字符串.replace(字符1,字符2)
#字符串替换
#是得到一个新的字符串

字符串.split(分割字符串)
#按照指定的分割符号进行字符串分割
#字符串本身不变,而是得到了一个列表对象

字符串.strip()
#字符串规整操作
#去除前后指定字符串

字符串.count()
#统计字符串内的数量

列表切片

1
2
3
4
5
6
7
8
9
10
11
mylist[起始:结束:步长]

#序列切片操作
string ="万过薪月,员序程马黑来,nohtyP学"
#反向索引切片
string_o=string[::-1]
#正向索引切片
print(string_o[9:14])
#使用split分割符和替换符
result3 = string.split(",")[1].replace("来","")[::-1]
print(result3)

集合

不可以重复,且无法重复
是无序的,不支持下标进行访问

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#集合定义使用的是{}
my_set = {"元素1","元素2","元素3"}

my_set.add(元素)
#增加新元素

my_set.remove(元素)
#移除指定元素,集合会被修改

my_set.pop(元素)
#从集合中随机取出一个元素,同时集合本身会被修改

my_set.clear()
#清空集合

字典

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
#字典的每个键值 key=>value 
#对用冒号 : 分割,每个对之间用逗号(,)分割
#整个字典包括在花括号 {} 中
dic = {}

dic.pop(key)
#获得指定key的value,同时字典被修改,指定key的值被删除
dic.clear()
#字典被修改,所以元素被清空

dic.keys()
#获取字典中的全部key

dic ={"周杰伦":"帅","张杰":"中","胡汉三":"超级帅"}
keys = dic.keys()
#通过循环进行编列字典
#dic.keys()取出字典的键

-------------------------------------------------------

for value in keys:#把keys取出的键存储到value上
print(f"字典key有{value}")
print(f"字典的value{dic[value]}")#通过字典的键取出值#第一个循环为dic[周杰伦]显示值

info_dict = {
"王力宏":{
"部门":"科技部",
"工资":3000,
"级别":1
},
"周杰伦": {
"部门": "市场部",
"工资": 5000,
"级别": 2
},
"林俊杰": {
"部门": "市场部",
"工资": 7000,
"级别": 3
},
"张学友": {
"部门": "科技部",
"工资": 4000,
"级别": 1
},
"刘德华": {
"部门": "市场部",
"工资": 6000,
"级别": 2
}
}
print(f"{info_dict}",end="\n")
#for循环遍历字典
for name in info_dict:
#if判断符号条件员工
if info_dict[name]["级别"] == 1:
#升职加薪操作
#获取到员工信息
info_dic = info_dict[name]
#修改员工信息
info_dic["级别"] = 2 #级别+1
info_dic["工资"] += 1000 #工资+1000
info_dict[name] = info_dic
print(info_dict)

数据容器通用操作

1
2
3
4
sorted(容器,reverse=True)
#加reverse为反向排序

#进行排序操作,放入列表中。字典会丢失value

函数的多种参数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
def user_info(name,age,gender):
print(f"{name},{age},{gander}")
user_info("胡汉三",20,男)
#这是直接传参

user_info(name,age,gender):
print(f"{name},{age},{gander}")
user_info(name="胡汉三",age=20,gender=男)

#这是通过关键字传参
#可以让函数更加清晰、容易使用,同时也清除了参数的顺序要求

user_info(name,age,gender="男"):
print(f"{name},{age},{gander}")
user_info(name="胡汉三",age=20)
#缺省参数
#也叫默认函数,给参数设置一个默认值。然后进行传参的时候没有给参数提供值就会调用默认值

user_info(*args):#一个*号
print(args)
user_info()
#不定参数
#传进去的所以参数都会被args变量收集,会根据传进去的参数位置合并为一个元组

user_info(**kwargs):#两个*号
print(kwargs)
user_info()
#关键字传参
#参数是“键=值”形式,所有的“键=值”都会被kwargs接受,同时根据位置形成字典

函数

1
2
3
4
5
6
7
8
9
10
11
12
13
#函数当做参数进行调用
传入计算逻辑,而非传入数据
#定义一个数据,这个数据不确定
def test_func(compute):
re = compute(2,6)#确定compute是函数
print(re)
#为什么不先写compute因为它还没有定义这一个函数就无法执行。
#就跳过执行,然后执行下一个函数。下一个函数是计算逻辑,计算compute相加
#功能就是可以使用不同函数进行调用逻辑计算
#定义一个计算逻辑
def compute(x,y):
return x**y
test_func(compute)#调用函数compute传入

匿名函数

有名称的函数,可以基于名称重复使用
匿名函数,只能使用一次

1
2
定义语法
lambda 传入参数:函数体(一行代码)

文件操作部分

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
open(name,mode,encoding)
#nama:打开的文件名称
#mode:打开文件的模式
#encoding:编码格式

文件对象.read(num)
#num表示读取的字节,不填写就全部读取
#多次调用read,就会从上次读取到的地方开始读取
readlines()
#可以按照行的方式把整个文件的内容一次性读取,并返回一个列表
readline()
#一次读取一行

f.write()
#文件写入
f.flush()
#文件刷新

with open(name,mode,encoding) as f:
for line in f:
print(f"每一行数据是{line}")
#执行完之后自动关闭文件

#统计字符串出现的次数
with open("test.txt","r",encoding="UTF-8") as f:
string = f.read()
string.count("itheima")

#统计字符串出现的次数
f = open("test.txt","r",encoding="UTF-8")
count = 0#使用count变量统计出现次数
for line in f:
line.strip()#去除开头和结尾的换行符
words = line.split(" ")
for word in words:
print(word)
if word == "itheima":
count+=1
print(count)

#把test文件里面的内容备份到test.txt.bak

f_r = open("test.txt","r",encoding="UTF-8")#r只读模式打开
f_w = open("test.txt.bak", "w", encoding="UTF-8")
for line in f_r:#循环每一行的内容
list = line.strip()#去除字符串末尾的空格和换行符
list = list.split(",")[-1]
#显示['周杰伦','2023/10/23','10020','消费','正式']
#头转不过来没想到下标就是-1傻傻用list双层下标
if list == "测试":#判断是否相等
print("不写入")
continue
else:
f_w.write(line)
print("写入成功")
f_w.close()

异常捕获

try:
没有异常执行的
except (name1,name2,name3) as e:
出现异常执行的

JSON数据转换

1
2
3
4
5
6
7
8
#导入json模块
import json
data = [{"name":"张三","age":"18"},{"name":"李四","age":"20"}]
#json数据
data = json.dumps(data)
#通过json.dumps(data)方法将python数据转化为json数据
data = json.loads(data)
##通过json.loads(data)方法将json数据转化为python数据

pyecharts

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
import json
#导入json模块
from pyecharts.charts import Line
#导入pyecharts模块
#打开里面所有数据
#读取里面所有数据

f_us = open("美国.txt","r",encoding="UTF-8")
us_data = f_us.read()

f_jp = open("日本.txt","r",encoding="UTF-8")
jp_data = f_jp.read()

f_in = open("印度.txt","r",encoding="UTF-8")
in_data = f_in.read()



#利用replace进行替换开头不需要的数据
#去掉不符合json规范的结尾
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转换为python数据
us_dict = json.loads(us_data)
jp_dict = json.loads(jp_data)
in_dict = json.loads(in_data)

#获取trend的key
#获取日期数据
trend_data_us = us_dict['data'][0]['trend']
trend_data_jp = jp_dict['data'][0]['trend']
trend_data_in = in_dict['data'][0]['trend']

us_x_data = trend_data_us["updateDate"][:314]
us_y_data = trend_data_us["list"][0]["data"][:314]

jp_x_data = trend_data_jp["updateDate"][:314]
jp_y_data = trend_data_jp["list"][0]["data"][:314]

in_x_data = trend_data_in["updateDate"][:314]
in_y_data = trend_data_in["list"][0]["data"][:314]
#获取确认数据inline = Line()
line = Line()
#构建实例化
line.add_xaxis(us_x_data)
#增加x轴
line.add_yaxis("美国确诊人数",us_y_data)
line.add_yaxis("日本确诊人数",jp_y_data)
line.add_yaxis("印度确诊人数",in_y_data)

line.render()#生成图像
f_in.close()
f_jp.close()
f_us.close()

面向对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#构造方法
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("周杰伦","30","185000111")
print(stu.name)
print(stu.age)
print(stu.tel)

#学生信息录入
class Student:
def __init__(self,num,name,age,addes):
self.num = num
self.name = name
self.age = age
self.addes =addes
print(f"第{num}位学生,姓名为{name},年龄为{age},地址为{addes}")

for i in range(1,10):
print(f"当前录入第{i}位学生信息,共有10位")
name = input(f"请输入学生的姓名")
age = input(f"请输入学生的年龄")
addes = input(f"请输入学生的地址")
Student(i,name,age,addes)

魔术方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#学生信息录入
class Student:
def __init__(self,name,age,):
self.name = name
self.age = age
def __str__(self):#字符串
return f"Student类对象,name:{self.name},年龄:{self.age}"
def __lt__(self, other):#大于小于比较返回True和False
return self.age < other.age
def __le__(self, other):#大于等于和小于等于比较
return self.age <= other.age
def __eq__(self, other):#判断两个对象是相等
return self.age == other.age

stu = Student("周杰伦",81)
stu1 =Student("林俊杰",31)

封装

就是将现实世界事物在类中描述属性和方法,既为封装

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
#私有成员变量就是加__
#私有成员方法也是加__
class Phone:
#定义私有变量
__current_voltage = None#当前手机运行电压
def __keep_single_core(self):
print("让CPU保持单核模式运行")
phone = Phone()
phone.__keep_single_core()#报错无法调用
print(phone.__keep_single_core)#也无法使用

class Phone:
__current_voltage = 0.5
def __keep_single_core(self):
print("让CPU以单核模式运行")
def call_by_5g(self):
if self.__current_voltage >= 1:
print("5G通话已开启")
else:
self.__keep_single_core()
print("电量不足,无法使用5G通话,并设置为单核运行进行省电模式")
phone = Phone()
phone.call_by_5g()

class Phone:
#提供私有成员变量
__is_5g_enable = False
#提供私有成员方法
def __check_5g(self):
if self.__is_5g_enable == True:
print("5g通话开启")
else:
print("5g通话关闭,开启4g通话")
#提供公有成员方法
def call_by_5g(self):
self.__check_5g()
print("正在通话中")
phone = Phone()
phone.call_by_5g()

继承

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
单继承
class 类名(父类名):
类内容体

多继承
#演示单继承
class Phone:
IMEI = None#序列号
producer = "Hu"

def call_by_4g(self):
print("4g通话")
class Phone2022(Phone):
face_id = True#面部识别
def call_by_5g(self):
print("2022年新功能:5g通话")
# phone = Phone2022()
# print(phone.producer)
# phone.call_by_4g()
# phone.call_by_5g()

#多继承
类变量同名多继承谁先来,谁的权大
class 类名称(父类):
类内容体
class NFCreader:
nfc_type = "第五代"
producer = "HM"
def read_card(self):
print("NFC读卡")
def write_card(self):
print("NFC写卡")
class RemoteControl:
rc_type = "红外遥控"
def control(self):
print("红外遥控开启")
class MyPhone(Phone,NFCreader,RemoteControl):
pass
phone = MyPhone()
phone.call_by_4g()
phone.read_card()
phone.write_card()
phone.control()

复习父类属性

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class Phone:
IMEI = None
producer = "ITCAST"
def call_by_5g(self):
print("使用5G网络进行通话")
#定义子类,复习父类成员
class Myphone(Phone):
producer = "ITheima"
def call_by_5g(self):
print("开启CPU单核模式,确保通话时省电")
#方式1调用
# print(f"父类的厂商是{Phone.producer}")
# Phone.call_by_5g(self)#self不能忘记
#方式2
print(f"父类的厂商是{super().producer}")
super().call_by_5g()

print("关闭Cpu单核模式,确保性能")
phone = Myphone()
phone.producer
phone.call_by_5g()
#一旦复习父类,那么类对象调用成员的时候,就会调用复习后的新成员
#在子类中调用父类成员

类型注解

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
简单注解
变量:类型 = "内容"
my_list:list = [1,2,3]
详细注解
my_tuple:tuple[str,int,bool] = ["str",20,True]

基础数据类型
var_1:int = 10
类对象
class Student
pass
stu:Student = Student()
数据容器
my_list:list = [1,2,3]
详细注解
my_tuple:tuple[str,int,bool] = ["str",20,True]

from typing import Union
union定义联合类型注解
my_list:list[Union[str,int]]
def fun(data:Union[str,int]) -> Union[str,int]

多态

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
同样的行为,传入不同的对象,得到不同的状态
class Animal:
def speak(self):
pass
class Dog(Animal):
def speak(self):
print("狗叫")
class Cat(Animal):
def speak(self):
print("猫叫")
def make_noise(animal:Animal):
animal.speak()
dog = Dog()
cat = Cat()
make_noise(dog)
make_noise(cat)
#抽象类
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 cool_hot(self):
print("美的空调制热")
def swing_l_r(self):
print("美的空调左右摆风")
class GREE_AC(AC):
def cool_wind(self):
print("格力空调省电制冷")
def cool_hot(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)

综合案例

1.有两份数据,一份是text格式
2.一份是Json格式的数据
3.对其进行数据分析并制成图表

新建一个data_define.py

主要进行数据的封装

1
2
3
4
5
6
7
8
9
10
#数据封装
class Record:
#构建函数
def __init__(self,data,order_id,money,province):
self.data = data
self.order_id = order_id
self.money = money
self.provincce = province
def __str__(self):
return f"{self.data},{self.order_id},{self.money},{self.provincce}"

file_define.py

对文件进行处理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
from data_define import Record
import json
#使用抽象方法
class FileReader:
def read_data(self) -> list[Record]:
pass

#定义一个Text的读取格式
class Textread(FileReader):
#构建成员变量
def __init__(self, path):
self.path = path
#构建成员方法
def read_data(self) -> list[Record]:
f = open(self.path,"r",encoding="UTF-8")
record_list = []#存储需要返回的数据
for line in f.readlines():#遍历打开文件中的每一行
line = line.strip()#去掉末尾的空格
data_list = line.split(",")#用,分割字符串,并且封装成为列表
record = Record(data_list[0],data_list[1],int(data_list[2]),data_list[3])#赋值给record,并给Record方法
record_list.append(record)#添加到record_list
f.close()#关闭文件
return record_list

class JsonRead(FileReader):
def __init__(self,path):
self.path = path
#复写父类
def read_data(self) -> list[Record]:

f = open(self.path,"r",encoding="UTF-8")
record_list = []
for line in f.readlines():
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 = Textread("2011年1月销售数据.txt")
list1=text_file.read_data()
json_file = JsonRead("2011年2月销售数据JSON.txt")
list2 = json_file.read_data()
for i in list1:
print(i)
for j in list2:
print(j)

main.py主体部分

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
"""
面向对象,数据分析案例。主业务逻辑代码
实现步骤:
1.设计一个类,可以完成数据的封装
2.设计一个抽象类,定义文件读取相关功能,并使用子类实现具体功能
3.进行数据需求的逻辑计算(计算每一天的销售额)
4.通过pyecharts进行图形绘制
"""
from file_define import FileReader,TextFileReader,JsonFileRead
from data_define import Record
from pyecharts.charts import Bar
from pyecharts.options import *
from pyecharts.globals import ThemeType

text_file = TextFileReader("2011年1月销售数据.txt")
json_file = JsonFileRead("2011年2月销售数据JSON.txt")

jan_data:list[Record] = text_file.read_data()
feb_data:list[Record] = json_file.read_data()
#将两个月份的数据合并一个
all_data:list[Record] = jan_data + feb_data
#开始进行数据计算
#{“2011-01-01”:1234}
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

#进行可视化开发
bar = Bar(init_opts=InitOpts(theme=ThemeType.LIGHT))

bar.add_xaxis(list(data_dict.keys()))#添加x轴数据
bar.add_yaxis("销售额",list(data_dict.values()),label_opts=LabelOpts(is_show=False))
bar.set_global_opts(
title_opts=TitleOpts(title="每日销售额")

)
bar.render()

SQL

层级关系 库—>表—>数据
进入数据库mysql -uroot -p
查看所有数据库
show databases;
使用数据库
use databases;
查看数据表
show tables;

1、DDL数据的定义

对库的操作

查看数据库 show databases;
使用数据库 use 数据库名;
创建数据库 ** CREARE DATABASE 数据库名 [CHAREST UTF-8];**
删除数据库 DROP DATABASE 数据库名;
查看当前使用的数据库** SELECT DATASE();**

对表的操作

查看有哪些表 ** show tables; **
删除表 ** drop table 表名称 **
** drop table if EXISTS 表名称 **
创建表CREATE TABLE 表名称(
列名称 列类型,
列名称 列类型,
)
列类型有
int –整数 float –浮点数 varchar(长度) –文本,长度为数字 date –日期 timestamp –时间戳类型

DML 数据插入

INSERT INTO 表() values()
插入数据
insert into student(id,name,age) values (5,’张三’,18),(6,’李四’,28);
删除数据
delete from student where age = 18
where后面为条件判断
更新表
update student set name = ‘张学友’ where id = 1

DQL 数据查询

SELECT 字段列表|* FROM 表
基础查询
SELECT id,name from student;
SELECT * from student where age > 20;

分组聚合

SELECT 字段|集合函数 FROM 表 [where 条件] GROUP BY 列

select gender,avg(age) from student group by gender;

select gender,avg(age),min(age),max(age),count(age) from student group by gender;

聚合函数有
-SUM(列)求和 -AVG()求平均值 -MIN最小值 -MAX最大值 -COUNT(列|* )求数量

结果排序

SELECT 列|聚合函数|* FROM 表 where order by age asc|desc

查询数据库student的年龄小于18的按照升序排序
select * from student where age < 18 order by AGE ASC;

查询student跳过前10条
select * from student limit 10,5;

select age,count( * ) from student where age > 20 group by age order by age limit 5;

Python操作mysql

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
from pymysql import Connection

conn = Connection(
host='localhost',#主机号
port=3306,#端口号
user='root',
password='root'
)
cursor = conn.cursor()#获取游标对象
conn.select_db('test')#选择数据库
#cursor.execute('create table test_pymysql(id int)')#创建数据表
cursor.execute('select * from student')
rest:tuple = cursor.fetchall()
print(rest)
# for i in rest:
# print(i)
conn.close()