文章目录
- 前言
- MySQL部分
- 1. 导入数据
- 2. 演示说明
- Python部分
- 1. 连接数据库
- 2. 登录界面
- 3. 注册
- 4. 主界面
- 5. 查询用户信息
- 6. 修改密码
- 7. 梅西生涯数据分析
- 8. 主函数
- 尾声
前言
用 Python + MySQL 实现简单的数据分析系统，一起来看看吧！
本篇博客主要分为两大部分，一部分主要是对数据库的操作，另一部分主要是使用Python进行一些程序设计与数据分析。在进行数据分析之前，一定要记得先下载梅西的生涯数据表哦：点击下载
MySQL部分
1. 导入数据
以下是MySQL创建表的语句，创建一个用户信息表，用于保存注册信息
-- ----------------------------
-- Table structure for `users`
-- ----------------------------
CREATE TABLE `users` (
`username` varchar(20),
`passwords` varchar(20),
PRIMARY KEY(username)
)ENGINE=InnoDB DEFAULT CHARSET=utf8;
-- ----------------------------
-- Records of users
-- ----------------------------
INSERT INTO users VALUES ('user01', '123');
2. 演示说明
我用的数据库是navicat，下面具体演示一下如何导入数据
- 创建一个名为admins的数据库，字符集选择"utf8"。
- 打开刚才创建的数据库admins，点击"查询"，再点击"新建查询"
- 输入上面的MySQL语句点击"运行"，再点击左边的表，会发现成功创建了一个"users"表
Python部分
1. 连接数据库
程序设计
import pymysql
Username=""
def conn():#连接数据库
db = pymysql.connect(host="localhost", user="root", database="admins", charset='utf8')
return db
def update(sql,*values):#shift键，单tab
db1=conn()
cursor1 = db1.cursor()
try:
cursor1.execute(sql,values)
db1.commit()
return 1
except:
db1.rollback()
return 0
finally:
cursor1.close()
db1.close()
def update2(sql):#shift键，单tab
db1=conn()
cursor1 = db1.cursor()
try:
cursor1.execute(sql)
db1.commit()
return 1
except:
db1.rollback()
return 0
finally:
cursor1.close()
db1.close()
def query(sql,*keys):
db2=conn()
cursor2=db2.cursor()
cursor2.execute(sql,keys)
rs=cursor2.fetchall()
cursor2.close()
db2.close()
return rs
def query2(sql):
db3=conn()
cursor3=db3.cursor()
cursor3.execute(sql)
rs=cursor3.fetchall()
row=cursor3.rowcount
cursor3.close()
db3.close()
return rs,row
程序分析
这段代码是一个Python脚本，用于连接MySQL数据库、更新数据库、查询数据库。它用了Python的pymysql库来操作数据库。其中，需要提供MySQL数据库的用户名和密码才能连接到该数据库。
conn()函数用于连接数据库，如果连接成功，则返回一个数据库对象db。update()函数用于执行更新数据库操作。如果更新成功则返回1，否则返回0。update2()函数与update()函数类似，只是没有传入值。query()函数用于执行查询操作，它需要传入一个sql语句以及查询参数，如果查询成功，则返回一个结果集rs。query2()函数与query()函数类似，只是没有传入查询参数，并且返回结果集rs以及查询结果的行数row。
这段代码使用了数据库的事务操作。如果数据库更新操作执行失败，则使用db1.rollback()方法将事务回滚到之前的状态，确保数据库数据的一致性。具有容错性。
2. 登录界面
效果
程序设计
import tkinter as tk
import tkinter.messagebox
import db
import mainWin
import register
#登录界面
class Login():
def __init__(self):
self.root2=tk.Tk()
self.root2.title("登陆")
self.screenwidth = self.root2.winfo_screenwidth()
self.screenheight = self.root2.winfo_screenheight()
self.root2.geometry('%dx%d+%d+%d' % (400, 200, (self.screenwidth - 400) / 2, (self.screenheight - 200) / 2))
self.label=tk.Label(self.root2,text='登录系统',font=("黑体",25))
self.label.place(x=125,y=10)
self.userlabel=tk.Label(self.root2,text="用户名:",font=("黑体",15))
self.userlabel.place(x=80,y=60)
self.userentry=tk.Entry(self.root2)
self.userentry.place(x=160,y=62)
self.pwdlabel=tk.Label(self.root2,text="密 码:",font=("黑体",15))
self.pwdlabel.place(x=80,y=100)
self.pwdentry=tk.Entry(self.root2,width=20,show='*')
self.pwdentry.place(x=160,y=102)
self.userentry.insert(0,'user01')
self.pwdentry.insert(0,'123')
self.okbutton=tk.Button(self.root2,text='提交',font=10,command=self.openMain)
self.okbutton.place(x=70,y=140)
self.cancelbutton=tk.Button(self.root2,text='取消',font=10,command=self.root2.destroy)
self.cancelbutton.place(x=170,y=140)
self.addbutton = tk.Button(self.root2, text='注册', font=10, command=self.adduser)
self.addbutton.place(x=270,y=140)
self.root2.mainloop()
def openMain(self):
username2=self.userentry.get()
userpwd2=self.pwdentry.get()
if username2.strip()=="" or userpwd2.strip()=="":
tk.messagebox.showerror("登录失败","用户名或密码不能为空")
return False
else:
try:
rs = db.query("select * from users where username = %s and passwords = %s", username2, userpwd2)
if len(rs)>0:
tk.messagebox.showinfo("提示","登陆成功！")
db.Username=username2
self.root2.destroy()
mainWin.MainWin()
else:
tk.messagebox.showinfo("ee", "你输入的信息不正确，请重新输入")
except Exception as e:
print("登陆异常")
print(e)
def adduser(self):
self.root2.destroy()
register.Register()
程序分析
这段代码是一个基于Tkinter库实现的简单图形用户界面，包括了一个用户登录界面和一个用户注册界面。其中，Login类为用户登录界面，Register为用户注册界面。程序依赖db.py文件来操作数据库。
Login类的构造函数定义了一个Tkinter窗口，包括了用户名、密码输入框、提交、取消、注册按钮和一些文本标签。openMain()方法用于检查用户输入的用户名和密码是否正确，如果正确，则关闭登录窗口，打开主界面MainWin，否则弹出一个提示框，并停留在当前登录窗口等待用户重新输入。adduser()方法用于关闭登录窗口，打开注册界面Register。
Register类的构造函数定义了一个Tkinter窗口，包括了一些文本标签、用户名、密码、确认密码输入框以及一个提交、取消按钮。其中提交按钮用于将用户输入的用户名和密码写入到数据库中，取消按钮用于关闭当前窗口。在用户名和密码输入框中提前插入了一个默认的用户名和密码方便用户体验。
整个程序的主入口位于main.py文件中，用于启动用户登录界面Login。如果用户成功登陆，则打开主界面MainWin，否则停留在登录界面。程序结构简单清晰，易于理解和扩展。
3. 注册
效果
程序设计
import tkinter as tk
import tkinter.messagebox
import db
import login
class Register():
def __init__(self):
self.root1=tk.Tk()
self.root1.title("新用户注册")
self.screenwidth=self.root1.winfo_screenwidth()
self.screenheight = self.root1.winfo_screenheight()
self.root1.geometry('%dx%d+%d+%d'%(400,200,(self.screenwidth-400)/2,(self.screenheight-200)/2))
self.label=tk.Label(self.root1,text='注册系统',font=("黑体",25))
self.label.place(x=125,y=10)
self.userlabel=tk.Label(self.root1,text="用户名:",font=("黑体",15))
self.userlabel.place(x=80,y=60)
self.userentry=tk.Entry(self.root1)
self.userentry.place(x=160,y=62)
self.pwdlabel=tk.Label(self.root1,text="密 码:",font=("黑体",15))
self.pwdlabel.place(x=80,y=100)
self.pwdentry=tk.Entry(self.root1,width=20,show='*')
self.pwdentry.place(x=160,y=102)
self.okbutton=tk.Button(self.root1,text='提交',font=("黑体",15),command=self.addUser)
self.okbutton.place(x=70,y=140)
self.cancelbutton = tk.Button(self.root1,text='取消',font=("黑体",15),command=self.root1.destroy)
self.cancelbutton.place(x=170,y=140)
self.loginbutton = tk.Button(self.root1, text='登陆', font=("黑体",15), command=self.loginUser)
self.loginbutton.place(x=270,y=140)
self.root1.mainloop()
def addUser(self):
username1 = self.userentry.get()
userpwd1 = self.pwdentry.get()
if username1.strip() == "" or userpwd1.strip() == "":
tk.messagebox.showerror("警告", "用户名或密码不能为空")
return False
else:
rs1=db.query('select * from users where username=%s',username1)
if len(rs1)>0:
tk.messagebox.showinfo("注册失败","该用户名已经存在")
self.userentry.delete(0)
self.pwdentry.delete(0)
else:
rs = db.update("insert into users(username,passwords) values(%s,%s)",username1,userpwd1)
if rs > 0:
tk.messagebox.showinfo("用户", "注册成功！")
else:
self.userentry.delete(0)
self.pwdentry.delete(0)
def loginUser(self):
self.root1.destroy()
login.Login()
程序分析
这段代码是一个基于Tkinter库实现的用户注册界面。其中，Register类为用户注册窗口，定义了一个Tkinter窗口，包括了用户名、密码输入框、提交、取消按钮以及一个登陆按钮。程序依赖db.py文件来操作数据库。
addUser()方法用于将用户输入的用户名和密码写入到数据库中，如果用户名已经存在，则弹出警告框并清空已输入的用户名和密码。如果用户名不存在，则将用户名和密码插入到数据库中，并弹出一个提示框。同时，也提供了一个取消按钮用于关闭当前窗口。loginUser()方法用于关闭当前窗口并打开用户登录界面Login。
整个程序的主入口位于main.py文件中，用于启动用户登录界面Login。如果用户点击了注册按钮，就关闭登录窗口，并打开注册界面Register。如果用户在注册界面成功注册后，则可以使用相同的账户和密码登陆系统。程序结构简单清晰，易于理解和扩展。
4. 主界面
效果
程序设计
import tkinter as tk
import register
import selUser
import login
import manage
import updPwd
class MainWin():
def __init__(self):
self.root3=tk.Tk()
self.root3.title("数据分析")
self.screenwidth = self.root3.winfo_screenwidth()
self.screenheight = self.root3.winfo_screenheight()
self.root3.geometry('%dx%d+%d+%d' % (500, 300, (self.screenwidth - 500) / 2, (self.screenheight - 300) / 2))
menu1=tk.Menu(self.root3)
menu1_2 = tk.Menu(menu1, tearoff=False)#创建二级菜单
menu1.add_cascade(label="用户管理",menu=menu1_2)#创建级联菜单
menu1_2.add_command(label='用户注册',command=self.adduser)
menu1_2.add_command(label='密码修改',command=self.updPwd)
menu1_2.add_command(label='查询用户信息',command=self.seluser)
menu1_2.add_command(label='重新登录', command=self.loginuser)
menu1.add_command(label='退出系统',command=self.root3.quit)
self.root3.config(menu=menu1_2)
self.root3.config(menu=menu1)#显示菜单
self.finds=tk.Label(self.root3,text='数据分析',font=("黑体",20))
self.finds.place(x=180,y=10)
self.find_sgrade=tk.Button(self.root3, text='上场时间', font=("黑体",15),command=self.time)
self.find_sgrade.place(x=190,y=70)
self.find_cgrade=tk.Button(self.root3, text='进球数', font=("黑体",15),command=self.goal)
self.find_cgrade.place(x=200,y=120)
self.find_sgrade = tk.Button(self.root3, text='助攻数', font=("黑体", 15), command=self.helps)
self.find_sgrade.place(x=200, y=170)
self.find_cgrade = tk.Button(self.root3, text='得牌数', font=("黑体", 15), command=self.warn)
self.find_cgrade.place(x=200, y=220)
def adduser(self):
register.Register()
def loginuser(self):
self.root3.destroy()
login.Login()
def seluser(self):
selUser.SelUser()
def updPwd(self):
updPwd.UpdPWD()
def time(self):
manage.Time()
def goal(self):
manage.Goal()
def helps(self):
manage.Help()
def warn(self):
manage.Warn()
程序分析
这段代码是一个基于Tkinter库实现的主界面，包括了一个菜单栏和几个按钮。程序依赖了register.py、selUser.py、login.py、manage.py和updPwd.py等模块。
MainWin类的构造函数定义了一个Tkinter窗口，并创建了一个菜单栏，其中“用户管理”是一个二级菜单，包括了用户注册、密码修改、查询用户信息和重新登陆。同时创建了4个按钮，分别代表对球员数据的不同属性进行统计和分析，例如上场时间、进球数、助攻数和得牌数。当用户单击按钮时，就会调用不同的统计分析功能。点击菜单栏中的操作，也会打开对应的操作界面。
整个程序的主入口位于main.py文件中，用于启动用户登录界面Login。如果用户成功登陆，则打开主界面MainWin。主界面包括了菜单栏和4个按钮，分别代表了不同的球员数据分析操作。如果用户在菜单栏中选择了某个操作，则打开相应的操作界面。程序结构简单清晰，易于理解和扩展。
5. 查询用户信息
效果
程序设计
import tkinter as tk
import tkinter.ttk as ttk
import db
class SelUser():
def __init__(self):
self.root4 = tk.Tk()#创建根窗口
self.root4.title("查询用户信息")#设置窗口标题
self.screenwidth=self.root4.winfo_screenwidth()
self.screenheight = self.root4.winfo_screenheight()
self.root4.geometry('%dx%d+%d+%d'%(400,250,(self.screenwidth-400)/2,(self.screenheight-250)/2))
self.create_gui()#调用窗口组件函数
self.root4.mainloop()#让程序继续执行，直到窗口关闭
def create_gui(self):#定义图形用户界面函数
self.create_top_right_labelframe()#查询条件组件设置
self.create_records_treeview()#查询结果树形菜单组件设置
def create_top_right_labelframe(self):#查询条件组件界面
labelframe1 = tk.LabelFrame(self.root4, text='用户信息', width=400)#标签框架组件
labelframe1.grid(row=0, column=1, sticky='ew', padx=8, pady=8)
tk.Label(labelframe1, text=' 账号:').grid(row=1, column=1, sticky='w', pady=2)#账号标签
self.namefield = tk.Entry(labelframe1)#账号输入框
self.namefield.grid(row=1, column=2, sticky='w', padx=5, pady=2)
tk.Label(labelframe1, text=' 密码:').grid(row=2, column=1, sticky='w', pady=2)
self.numfield = tk.Entry(labelframe1)
self.numfield.grid(row=2, column=2, sticky='w', padx=5, pady=2)
tk.Button(labelframe1, text='查询', command=self.seluser).grid(row=3, column=1, sticky='e', padx=5, pady=2)
def create_records_treeview(self):#显示记录信息
treeview_columns = ['userId', 'userName', 'userPwd']
self.record_treeview = ttk.Treeview(self.root4, show='headings', height=5, columns=treeview_columns)
self.record_treeview.grid(row=4, column=0, columnspan=3)
self.record_treeview.heading('userId', text='序号')
self.record_treeview.heading('userName', text='用户名')
self.record_treeview.heading('userPwd', text='密码')#, anchor='center'
self.record_treeview.column('userId', width=100)
self.record_treeview.column('userName', width=120)
self.record_treeview.column('userPwd', width=220)
def seluser(self):
username3=self.namefield.get()
userpwd3=self.numfield.get()
if username3.strip() == "" or userpwd3.strip() == "":
tk.messagebox.showerror("警告", "用户名或密码不能为空")
return False
else:
rs,row = db.query2("select * from users where username like '%"+username3+"%' and passwords like '%"+userpwd3+"%'")
if row==0:
tk.messagebox.showerror("警告", "该用户不存在！")
return False
else:
for i in range(row):
self.record_treeview.insert("",'end',values=rs[i])
程序分析
这是一个简单的Python GUI程序，使用了tkinter和ttk库来实现。该程序提供了查询用户信息的功能。
程序运行时会创建一个窗口，并包含两个组件，一个查询条件的Labelframe和一个查询结果的Treeview。
在查询条件中，有两个标签，一个输入账号，一个输入密码。用户可以在这里输入查询条件，并点击查询按钮。当查询按钮被点击时，程序会从数据库中查询匹配的用户信息，并将结果显示在Treeview中。
在查询过程中，程序还对输入的用户名和密码进行了非空验证，如果为空会弹出警告提示框。如果未查询到匹配的用户信息，程序也会弹出提示框告知用户。如果查询成功，程序会将查询结果逐行插入Treeview中。
以上就是该Python GUI程序的基本功能和实现方式。
6. 修改密码
效果
程序设计
import tkinter as tk
import tkinter.messagebox
import db
import mainWin
class UpdPWD():
def __init__(self):
self.aa = db.Username
self.root6=tk.Tk()
self.screenwidth=self.root6.winfo_screenwidth()
self.screenheight = self.root6.winfo_screenheight()
self.root6.geometry('%dx%d+%d+%d'%(400,200,(self.screenwidth-400)/2,(self.screenheight-200)/2))
self.root6.title("密码修改窗口")
self.namelabel=tk.Label(self.root6,text='账号：',font=("黑体",15))
self.namelabel.place(x=80,y=20)
self.nametxt=tk.Entry(self.root6)
self.nametxt.place(x=140,y=22)
self.nametxt.insert(0,self.aa)
self.labelpwd1=tk.Label(self.root6,text='修改密码：',font=("黑体",12))
self.labelpwd1.place(x=60,y=60)
self.pwd1=tk.Entry(self.root6)
self.pwd1.place(x=140,y=62)
self.labelpwd2=tk.Label(self.root6,text='确认密码：',font=("黑体",12))
self.labelpwd2.place(x=60,y=100)
self.pwd2 = tk.Entry(self.root6)
self.pwd2.place(x=140,y=102)
self.button=tk.Button(self.root6,text="确定",font=("黑体",15),command=self.updpwd)
self.button.place(x=100,y=140)
self.button2 = tk.Button(self.root6, text="主窗口",font=("黑体",15),command=self.returnwin)
self.button2.place(x=200,y=140)
self.root6.mainloop()
def updpwd(self):
bb=self.pwd1.get()
aa=self.aa
print(aa)
print(bb)
rs = db.update2("update users set passwords='"+bb+"' where username='"+aa+"'")
print(rs)
if rs>0:
tk.messagebox.showinfo("提示消息","密码修改成功")
else:
tk.messagebox.showinfo("提示消息", "修改失败")
self.pwd1.delete(0)
self.pwd2.delete(0)
def returnwin(self):
self.root6.destroy()
mainWin.MainWin()
程序分析
这是一个用Tkinter库编写的密码修改窗口程序，包括账号、修改密码、确认密码和两个按钮（“确定”和“主窗口”）。用户在程序中输入账号、新密码和确认新密码，点击“确定”按钮时，程序会连接数据库并执行对应的SQL语句将用户的密码修改为新密码，然后根据数据库返回的影响行数判断密码是否修改成功并弹出提示消息。如果修改成功，则显示“密码修改成功”提示消息；如果修改失败，则显示“修改失败”提示消息并清空新密码输入框和确认新密码输入框。当用户点击“主窗口”按钮时，程序会关闭当前密码修改窗口并重新打开主窗口，让用户可以继续进行其他操作。
7. 梅西生涯数据分析
梅西生涯数据表：点击下载
效果
程序设计
import tkinter as tk
import numpy as np # 导入numpy库
import xlrd # 导入xlrd库
import matplotlib.pyplot as plt # 导入matplotlib库
import matplotlib
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
from matplotlib.figure import Figure
plt.rcParams['font.sans-serif']=['SimHei']
plt.rcParams['axes.unicode_minus'] = False
class Time():
def __init__(self):
matplotlib.use("TkAgg")
self.root5=tk.Tk()
self.root5.title("梅西上场时间分析")
self.screenwidth=self.root5.winfo_screenwidth()
self.screenheight = self.root5.winfo_screenheight()
self.root5.geometry('%dx%d+%d+%d'%(900,750,(self.screenwidth-900)/2,(self.screenheight-750)/2-50))
with xlrd.open_workbook("data.xls") as wb: # 打开梅西生涯数据的excel表格
sheet = wb.sheet_by_index(0) # 获取excel表格第一个表格，并对其进行操作
d = sheet.col_values(1)[2:171] # 获取日期
y1 = sheet.col_values(7)[2:171] # 获取上场时间
y2 = sheet.col_values(8)[2:171] # 获取进球数
y3 = sheet.col_values(9)[2:171] # 获取助攻数
y4 = sheet.col_values(10)[2:171] # 获取得牌数
fig = Figure(figsize=(9,9), dpi=80) # 设置画布大小
ax1 = fig.add_subplot(111) # 设置子图，操作子图1 #子图1表示梅西整个生涯的上场时间与时间的关系
ax1.set_xlabel('时间', fontsize=12) # y轴标签
ax1.set_ylabel('上场时间', fontsize=12) # x轴标签
x = range(0, len(y1))
ax1.plot(x, y1, marker=',', c='blue',label='上场时间') # 画生涯上场时间与时间关系的折线图
ax1.set_xticks(range(0, 170, 10), d[0:170:10], rotation=45)
ax1.set_title('梅西上场时间折线图', fontsize=30) # 标题
i_min1, Min1 = np.argmin(y1), np.min(y1) # 最小值
i_max1, Max1 = np.argmax(y1), np.max(y1) # 最大值
plt.text(i_max1 - 40, Max1, '最多上场时间：' + str(Max1), color='red', fontsize=12) # 获取最多上场时间
plt.text(i_min1, Min1 - 0.2, '最少上场时间：' + str(Min1), color='red', fontsize=12) # 获取最少上场时间
ax1.legend()
canvas = FigureCanvasTkAgg(fig,self.root5)
canvas.draw()
canvas.get_tk_widget().pack()
canvas._tkcanvas.pack()
self.root5.mainloop()
class Goal():
def __init__(self):
matplotlib.use("TkAgg")
self.root5 = tk.Tk()
self.root5.title("梅西进球分析")
self.screenwidth = self.root5.winfo_screenwidth()
self.screenheight = self.root5.winfo_screenheight()
self.root5.geometry('%dx%d+%d+%d' % (900, 750, (self.screenwidth - 900) / 2, (self.screenheight - 750) / 2 - 50))
with xlrd.open_workbook("data.xls") as wb: # 打开梅西生涯数据的excel表格
sheet = wb.sheet_by_index(0) # 获取excel表格第一个表格，并对其进行操作
d = sheet.col_values(1)[2:171] # 获取日期
y1 = sheet.col_values(7)[2:171] # 获取上场时间
y2 = sheet.col_values(8)[2:171] # 获取进球数
y3 = sheet.col_values(9)[2:171] # 获取助攻数
y4 = sheet.col_values(10)[2:171] # 获取得牌数
fig = plt.figure(figsize=(9,9), dpi=80) # 设置画布大小
ax2 = fig.add_subplot(111) # 操作子图2，操作方法同子图1
ax2.set_xlabel('时间', fontsize=12) # 子图2表示梅西整个生涯的进球数与时间的关系
ax2.set_ylabel('进球数', fontsize=12)
x = range(0, len(y2))
ax2.bar(x, y2, width=2, color='orange',label='进球数')
ax2.set_xticks(range(0, 170, 10), d[0:170:10], rotation=45)
ax2.set_title('梅西进球数条形图', fontsize=30)
i_min2, Min2 = np.argmin(y2), np.min(y2)
i_max2, Max2 = np.argmax(y2), np.max(y2)
plt.text(i_max2 - 40, Max2, '最多进球数：' + str(Max2), color='blue', fontsize=12)
plt.text(i_min2, Min2 +0.2, '最少进球数：' + str(Min2), color='blue', fontsize=12)
ax2.legend(loc='upper left')
canvas = FigureCanvasTkAgg(fig,self.root5)
canvas.draw()
canvas.get_tk_widget().pack()
canvas._tkcanvas.pack()
self.root5.mainloop()
class Help():
def __init__(self):
matplotlib.use("TkAgg")
self.root5 = tk.Tk()
self.root5.title("梅西助攻分析")
self.screenwidth = self.root5.winfo_screenwidth()
self.screenheight = self.root5.winfo_screenheight()
self.root5.geometry('%dx%d+%d+%d' % (900, 750, (self.screenwidth - 900) / 2, (self.screenheight - 750) / 2 - 50))
with xlrd.open_workbook("data.xls") as wb: # 打开梅西生涯数据的excel表格
sheet = wb.sheet_by_index(0) # 获取excel表格第一个表格，并对其进行操作
d = sheet.col_values(1)[2:171] # 获取日期
y1 = sheet.col_values(7)[2:171] # 获取上场时间
y2 = sheet.col_values(8)[2:171] # 获取进球数
y3 = sheet.col_values(9)[2:171] # 获取助攻数
y4 = sheet.col_values(10)[2:171] # 获取得牌数
fig = plt.figure(figsize=(9,9), dpi=80) # 设置画布大小
ax3 = fig.add_subplot(111) # 操作子图3，操作方法同子图1
ax3.set_ylabel('时间', fontsize=12) # 子图3表示梅西整个生涯的助攻数与时间的关系
ax3.set_xlabel('助攻数', fontsize=12)
x = range(0, len(y3))
ax3.barh(x, y3, height=2, color='green',label='助攻数')
ax3.set_yticks(range(0, 170, 10), d[0:170:10])
ax3.set_title('梅西助攻数条形图', fontsize=30)
i_min3, Min3 = np.argmin(y3), np.min(y3)
i_max3, Max3 = np.argmax(y3), np.max(y3)
plt.text(Max3-0.5, i_max3 + 2.5, '最多助攻数：' + str(Max3), color='blue', fontsize=12)
plt.text(Min3,i_min3-2, '最少助攻数：' + str(Min3), color='blue', fontsize=12)
ax3.legend()
canvas = FigureCanvasTkAgg(fig,self.root5)
canvas.draw()
canvas.get_tk_widget().pack()
canvas._tkcanvas.pack()
self.root5.mainloop()
class Warn():
def __init__(self):
matplotlib.use("TkAgg")
self.root5 = tk.Tk()
self.root5.title("梅西得牌分析")
self.screenwidth = self.root5.winfo_screenwidth()
self.screenheight = self.root5.winfo_screenheight()
self.root5.geometry('%dx%d+%d+%d' % (900, 750, (self.screenwidth - 900) / 2, (self.screenheight - 750) / 2 - 50))
with xlrd.open_workbook("data.xls") as wb: # 打开梅西生涯数据的excel表格
sheet = wb.sheet_by_index(0) # 获取excel表格第一个表格，并对其进行操作
d = sheet.col_values(1)[2:171] # 获取日期
y1 = sheet.col_values(7)[2:171] # 获取上场时间
y2 = sheet.col_values(8)[2:171] # 获取进球数
y3 = sheet.col_values(9)[2:171] # 获取助攻数
y4 = sheet.col_values(10)[2:171] # 获取得牌数
fig = Figure(figsize=(9,9), dpi=80) # 设置画布大小
ax4 = fig.add_subplot(111) # 操作子图4，操作方法同子图1
ax4.set_xlabel('时间', fontsize=12) # 子图4表示梅西整个生涯的得牌数与时间的关系
ax4.set_ylabel('得牌数', fontsize=12)
x = range(0, len(y4))
ax4.scatter(x, y4, marker='o', c='r',label='得牌数')
ax4.set_xticks(range(0, 170, 10), d[0:170:10], rotation=45)
ax4.set_title('梅西得牌数散点图', fontsize=30)
i_min4, Min4 = np.argmin(y4), np.min(y4)
i_max4, Max4 = np.argmax(y4), np.max(y4)
plt.text(i_max4, Max4 - 0.05, '最多得牌数：' + str(Max4), color='b', fontsize=12)
plt.text(i_min4, Min4 + 0.05, '最少得牌数：' + str(Min4), color='b', fontsize=12)
ax4.legend()
canvas = FigureCanvasTkAgg(fig,self.root5)
canvas.draw()
canvas.get_tk_widget().pack()
canvas._tkcanvas.pack()
self.root5.mainloop()
程序分析
这是一个用Tkinter库和Matplotlib库画图的程序，主要目的是分析足球运动员梅西的上场时间，进球数，助攻数以及得牌数与时间的关系。该程序读取了一个Excel表格中的数据，包括日期、上场时间、进球数、助攻数、得牌数等信息，然后根据数据绘制出梅西整个生涯的上场时间与时间的关系的折线图，进球数于时间的关系的条形图，助攻数与时间的关系的条形图以及得牌数与时间的关系的散点图，并在图上标出最多和最少上场时间，进球数，助攻数以及得牌数对应的日期和数据。程序最终通过Tkinter的画布将绘制的图形展示出来，供用户观看和分析。
8. 主函数
import login
if __name__ == "__main__":
login.Login()
尾声
该梅西生涯数据管理系统需要有一些Python程序设计、Python数据分析以及MySQL数据库的基础，相信小伙伴们在亲自完成了这个小项目后，一定都获益匪浅吧！
