基于神经网络的学生学习情况分析系统-hadoop+django
- 开发语言：Python
- 框架：django
- Python版本：python3.8
- 数据库：mysql 5.7
- 数据库工具：Navicat12
- 开发软件：PyCharm
系统展示
管理员登录
管理员功能界面
用户管理
学习数据
期末成绩预测
看板展示
摘要
系统基于B/S开发模式，采用Python语言进行开发，借助Django框架搭建系统架构，保证了系统的稳定性和可扩展性。同时，运用长短期记忆网络（LSTM）算法，对学生学习数据进行深入分析和挖掘。系统功能多样，管理员能够对用户信息进行全面管理，包括用户的注册、登录和权限设置等。可以对学生的学习数据进行收集、整理和分析，涵盖课堂表现、作业完成情况等。并且能够通过LSTM模型对学生的期末成绩进行科学预测，为教学决策提供有力支持。该系统的应用，对教育教学有着多方面的积极意义。它能帮助教师更精准地了解学生的学习状态，从而制定更具针对性的教学方案，提高教学质量。对于学生而言，能清晰认识自己的学习情况，合理调整学习计划。系统的自动化管理功能有效减轻了学校教学管理的负担，提高了管理效率，促进教育资源的优化配置，推动教育向智能化、个性化方向发展。
研究背景
长短期记忆网络（LSTM）作为一种特殊的循环神经网络，能够有效处理时间序列数据，在学习情况分析中具有独特的优势。它可以捕捉学生学习过程中的长期依赖关系，如学习习惯的养成和知识的积累过程，从而更准确地预测学生的学习成绩和发展趋势。基于浏览器/服务器（B/S）的开发模式具有部署方便、易于维护、跨平台性强等优点，使得系统可以在不同设备上方便地访问和使用。Python语言以其简洁高效、丰富的库和框架，成为开发此类系统的理想选择。Django框架作为Python的一个强大的Web开发框架，提供了完善的数据库管理、用户认证、路由等功能，能够大大提高系统的开发效率和稳定性。
关键技术
Python是解释型的脚本语言，在运行过程中，把程序转换为字节码和机器语言，说明性语言的程序在运行之前不必进行编译，而是一个专用的解释器，当被执行时，它都会被翻译，与之对应的还有编译性语言。
同时，这也是一种用于电脑编程的跨平台语言，这是一门将编译、交互和面向对象相结合的脚本语言（script language）。
Django用Python编写，属于开源Web应用程序框架。采用（模型M、视图V和模板t）的框架模式。该框架以比利时吉普赛爵士吉他手詹戈·莱因哈特命名。该架构的主要组件如下：
1.用于创建模型的对象关系映射。
2.最终目标是为用户设计一个完美的管理界面。
3.是目前最流行的URL设计解决方案。
4.模板语言对设计师来说是最友好的。
5.缓存系统。
Vue是一款流行的开源JavaScript框架，用于构建用户界面和单页面应用程序。Vue的核心库只关注视图层，易于上手并且可以与其他库或现有项目轻松整合。
MYSQL数据库运行速度快，安全性能也很高，而且对使用的平台没有任何的限制，所以被广泛应运到系统的开发中。MySQL是一个开源和多线程的关系管理数据库系统，MySQL是开放源代码的数据库，具有跨平台性。
B/S（浏览器/服务器）结构是目前主流的网络化的结构模式，它能够把系统核心功能集中在服务器上面，可以帮助系统开发人员简化操作，便于维护和使用。
系统分析
对系统的可行性分析以及对所有功能需求进行详细的分析，来查看该系统是否具有开发的可能。
系统设计
功能模块设计和数据库设计这两部分内容都有专门的表格和图片表示。
系统实现
后台管理员主要分为多个模块，分别是系统首页、个人中心、用户、学习数据、期末成绩预测、系统管理等。个人中心用于管理员管理自身账号信息，如修改密码、查看操作日志等，保障账号安全和操作可追溯。用户模块中，管理员可对系统内各类用户（如学生、教师等）进行全面管理，包括用户注册审核、权限分配、信息编辑与删除等操作，确保用户信息准确和权限合理。学习数据模块负责收集、整理和维护学生学习过程中的各类数据，为后续分析和预测提供数据基础。期末成绩预测模块运用 LSTM 等算法，基于学习数据对学生期末成绩进行预测，辅助教学决策。系统管理模块涵盖系统配置、服务器管理、数据备份与恢复等功能，保障系统稳定、安全运行。
代码实现
#coding:utf-8
pd.options.mode.chained_assignment = None # default='warn'
#获取当前文件路径的根目录
parent_directory = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
dbtype, host, port, user, passwd, dbName, charset,hasHadoop = config_read(os.path.join(parent_directory,"config.ini"))
#MySQL连接配置
mysql_config = {
'host': host,
'user':user,
'password': passwd,
'database': dbName,
'port':port
}
def auto_figsize(x_data, base_width=8, base_height=6, width_per_point=0.2):
"""根据数据点数量自动调整画布宽度"""
num_points = len(x_data)
dynamic_width = base_width + width_per_point * num_points
return (dynamic_width, base_height)
#获取预测可视化图表接口
def learningdataforecast_forecastimgs(request):
if request.method in ["POST", "GET"]:
msg = {'code': normal_code, 'message': 'success'}
# 指定目录
directory = os.path.join(parent_directory, "templates", "upload", "learningdataforecast")
# 获取目录下的所有文件和文件夹名称
all_items = os.listdir(directory)
# 过滤出文件（排除文件夹）
files = [f'upload/learningdataforecast/{item}' for item in all_items if os.path.isfile(os.path.join(directory, item))]
msg["data"] = files
fontlist=[]
for font in fm.fontManager.ttflist:
fontlist.append(font.name)
msg["message"]=fontlist
return JsonResponse(msg, encoder=CustomJsonEncoder)
# 定义函数创建时间序列数据集
def create_dataset(data, time_step=1):
X, Y = [], []
for i in range(len(data) - time_step - 1):
a = data[i:(i + time_step), :]
X.append(a)
Y.append(data[i + time_step, :])
return np.array(X), np.array(Y)
def learningdataforecast_forecast(request):
if request.method in ["POST", "GET"]:
msg = {'code': normal_code, "msg": mes.normal_code}
#1.获取数据集
connection = pymysql.connect(**mysql_config)
query = "SELECT date, student,subject,regulargrade,midtermresults,learningattitude,finalgrade FROM learningdata ORDER BY date ASC"
#2.处理缺失值
data = pd.read_sql(query, connection).dropna()
# 转换日期格式为datetime
date_format = data['date'].iloc[0]
if isinstance(date_format, (datetime.date, datetime.datetime)):
date_format=''
elif "年" in date_format and "月" in date_format and "日" in date_format:
date_format='%Y年%m月%d日'
elif "年" in date_format and "月" in date_format:
date_format='%Y年%m月'
elif "年" in date_format:
date_format='%Y年'
else:
date_format=''
if date_format=="" or date_format==None:
data['date'] = pd.to_datetime(data['date'])
else:
data['date'] = pd.to_datetime(data['date'], format=date_format)
data.set_index('date', inplace=True)
student_encoder = LabelEncoder()
data['student'] = student_encoder.fit_transform(data['student'])
subject_encoder = LabelEncoder()
data['subject'] = subject_encoder.fit_transform(data['subject'])
learningattitude_encoder = LabelEncoder()
data['learningattitude'] = learningattitude_encoder.fit_transform(data['learningattitude'])
#只选择需要的列
data = data[[
'student',
'subject',
'regulargrade',
'midtermresults',
'learningattitude',
'finalgrade',
]]
# 归一化处理（为了LSTM的训练）
scaler = MinMaxScaler(feature_range=(0, 1))
scaled_data = scaler.fit_transform(data)
#设置时间步长
time_step = int(len(data)/10)# 使用过去30的数据
if time_step>30:
time_step=30
if time_step<=0:
time_step=1
X, y = create_dataset(scaled_data, time_step)
#划分训练集和测试集
train_size = int(len(X) * 0.8) # 80%的数据用于训练
X_train, X_test = X[:train_size], X[train_size:]
y_train, y_test = y[:train_size], y[train_size:]
# 查看训练数据集的形状
print(f'X_train shape: {X_train.shape}, y_train shape: {y_train.shape}')
# 创建 LSTM 模型
model = Sequential()
model.add(LSTM(50, return_sequences=True, input_shape=(X_train.shape[1], X_train.shape[2])))
model.add(Dropout(0.2)) # 防止过拟合
model.add(LSTM(50, return_sequences=False))
model.add(Dropout(0.2))
model.add(Dense(len(data.columns), activation='relu')) # 输出层，预测
#编译模型
model.compile(optimizer='adam', loss='mean_squared_error')
#训练模型
model.fit(X_train, y_train, epochs=100, batch_size=32, verbose=1)
#进行预测
train_predict = model.predict(X_train)
test_predict = model.predict(X_test)
#将预测结果反归一化
train_predict = scaler.inverse_transform(train_predict)
test_predict = scaler.inverse_transform(test_predict)
#绘制预测结果
plt.rcParams['font.sans-serif'] = ['SimHei'] # 使用黑体 SimHei
plt.rcParams['axes.unicode_minus'] = False # 解决负号 '-' 显示为方块的问题
plt.figure(figsize=(12, 6),dpi=80)
plt.plot(data.index[:len(train_predict)], train_predict[:, 1 -1], label='训练student预测',
color='blue')
plt.plot(data.index[len(train_predict) + time_step + 1:], test_predict[:, 1 -1],
label='测试student预测', color='red')
plt.plot(data.index, data['student'], label='实际student', color='green')
plt.title('student预测')
plt.xlabel('Date')
plt.ylabel('student')
plt.legend()
directory =os.path.join(parent_directory,"templates","upload","learningdataforecast","student_prediction.png")
os.makedirs(os.path.dirname(directory), exist_ok=True)
plt.savefig(directory)
plt.clf()
plt.close()
plt.figure(figsize=(12, 6),dpi=80)
plt.plot(data.index[:len(train_predict)], train_predict[:, 2 -1], label='训练subject预测',
color='blue')
plt.plot(data.index[len(train_predict) + time_step + 1:], test_predict[:, 2 -1],
label='测试subject预测', color='red')
plt.plot(data.index, data['subject'], label='实际subject', color='green')
plt.title('subject预测')
plt.xlabel('Date')
plt.ylabel('subject')
plt.legend()
directory =os.path.join(parent_directory,"templates","upload","learningdataforecast","subject_prediction.png")
os.makedirs(os.path.dirname(directory), exist_ok=True)
plt.savefig(directory)
plt.clf()
plt.close()
plt.figure(figsize=(12, 6),dpi=80)
plt.plot(data.index[:len(train_predict)], train_predict[:, 3 -1], label='训练regulargrade预测',
color='blue')
plt.plot(data.index[len(train_predict) + time_step + 1:], test_predict[:, 3 -1],
label='测试regulargrade预测', color='red')
plt.plot(data.index, data['regulargrade'], label='实际regulargrade', color='green')
plt.title('regulargrade预测')
plt.xlabel('Date')
plt.ylabel('regulargrade')
plt.legend()
directory =os.path.join(parent_directory,"templates","upload","learningdataforecast","regulargrade_prediction.png")
os.makedirs(os.path.dirname(directory), exist_ok=True)
plt.savefig(directory)
plt.clf()
plt.close()
plt.figure(figsize=(12, 6),dpi=80)
plt.plot(data.index[:len(train_predict)], train_predict[:, 4 -1], label='训练midtermresults预测',
color='blue')
plt.plot(data.index[len(train_predict) + time_step + 1:], test_predict[:, 4 -1],
label='测试midtermresults预测', color='red')
plt.plot(data.index, data['midtermresults'], label='实际midtermresults', color='green')
plt.title('midtermresults预测')
plt.xlabel('Date')
plt.ylabel('midtermresults')
plt.legend()
directory =os.path.join(parent_directory,"templates","upload","learningdataforecast","midtermresults_prediction.png")
os.makedirs(os.path.dirname(directory), exist_ok=True)
plt.savefig(directory)
plt.clf()
plt.close()
plt.figure(figsize=(12, 6),dpi=80)
plt.plot(data.index[:len(train_predict)], train_predict[:, 5 -1], label='训练learningattitude预测',
color='blue')
plt.plot(data.index[len(train_predict) + time_step + 1:], test_predict[:, 5 -1],
label='测试learningattitude预测', color='red')
plt.plot(data.index, data['learningattitude'], label='实际learningattitude', color='green')
plt.title('learningattitude预测')
plt.xlabel('Date')
plt.ylabel('learningattitude')
plt.legend()
directory =os.path.join(parent_directory,"templates","upload","learningdataforecast","learningattitude_prediction.png")
os.makedirs(os.path.dirname(directory), exist_ok=True)
plt.savefig(directory)
plt.clf()
plt.close()
plt.figure(figsize=(12, 6),dpi=80)
plt.plot(data.index[:len(train_predict)], train_predict[:, 6 -1], label='训练finalgrade预测',
color='blue')
plt.plot(data.index[len(train_predict) + time_step + 1:], test_predict[:, 6 -1],
label='测试finalgrade预测', color='red')
plt.plot(data.index, data['finalgrade'], label='实际finalgrade', color='green')
plt.title('finalgrade预测')
plt.xlabel('Date')
plt.ylabel('finalgrade')
plt.legend()
directory =os.path.join(parent_directory,"templates","upload","learningdataforecast","finalgrade_prediction.png")
os.makedirs(os.path.dirname(directory), exist_ok=True)
plt.savefig(directory)
plt.clf()
plt.close()
#准备未来3的输入数据
last_data_days = scaled_data[-time_step:] #取最后time_step的数据
future_predictions = []
for _ in range(3): # 预测未来3
last_data_days = last_data_days.reshape((1, time_step, len(data.columns))) # 重塑数据
prediction = model.predict(last_data_days)
future_predictions.append(prediction[0])
last_data_days = np.append(last_data_days[:, 1:, :], [prediction], axis=1) # 更新输入数据
#转换为原始数据
future_predictions = scaler.inverse_transform(future_predictions)
#获取当前日期
last_date = data.index[-1] # 数据集中最后一个日期
future_dates = [last_date + datetime.timedelta(days=31*i) for i in range(1, 3+1)] # 生成未来3月的日期
df = pd.DataFrame(columns=[
'date',
'student',
'subject',
'regulargrade',
'midtermresults',
'learningattitude',
'finalgrade',
])
df['date'] = [str(date.year)+"-"+str(date.month) for date in future_dates]
df['student'] = future_predictions[:, 1 -1]
df['subject'] = future_predictions[:, 2 -1]
df['regulargrade'] = future_predictions[:, 3 -1]
df['midtermresults'] = future_predictions[:, 4 -1]
df['learningattitude'] = future_predictions[:, 5 -1]
df['finalgrade'] = future_predictions[:, 6 -1]
df['student']=df['student'].astype(int)
df['student'] = student_encoder.inverse_transform(df['student'])
df['subject']=df['subject'].astype(int)
df['subject'] = subject_encoder.inverse_transform(df['subject'])
df['regulargrade']=df['regulargrade'].astype(int)
df['midtermresults']=df['midtermresults'].astype(int)
df['finalgrade']=df['finalgrade'].astype(int)
df['learningattitude']=df['learningattitude'].astype(int)
df['learningattitude'] = learningattitude_encoder.inverse_transform(df['learningattitude'])
#9.创建数据库连接,将DataFrame 插入数据库
connection_string = f"mysql+pymysql://{mysql_config['user']}:{mysql_config['password']}@{mysql_config['host']}:{mysql_config['port']}/{mysql_config['database']}"
engine = create_engine(connection_string)
try:
df.to_sql('learningdataforecast', con=engine, if_exists='append', index=False)
print("数据更新成功！")
except Exception as e:
print(f"发生错误: {e}")
finally:
engine.dispose() # 关闭数据库连接
return JsonResponse(msg, encoder=CustomJsonEncoder)
def learningdataforecast_register(request):
if request.method in ["POST", "GET"]:
msg = {'code': normal_code, "msg": mes.normal_code}
req_dict = request.session.get("req_dict")
error = learningdataforecast.createbyreq(learningdataforecast, learningdataforecast, req_dict)
if error is Exception or (type(error) is str and "Exception" in error):
msg['code'] = crud_error_code
msg['msg'] = "用户已存在,请勿重复注册!"
else:
msg['data'] = error
return JsonResponse(msg, encoder=CustomJsonEncoder)
def learningdataforecast_login(request):
if request.method in ["POST", "GET"]:
msg = {'code': normal_code, "msg": mes.normal_code}
req_dict = request.session.get("req_dict")
datas = learningdataforecast.getbyparams(learningdataforecast, learningdataforecast, req_dict)
if not datas:
msg['code'] = password_error_code
msg['msg'] = mes.password_error_code
return JsonResponse(msg, encoder=CustomJsonEncoder)
try:
__sfsh__= learningdataforecast.__sfsh__
except:
__sfsh__=None
if __sfsh__=='是':
if datas[0].get('sfsh')!='是':
msg['code']=other_code
msg['msg'] = "账号已锁定，请联系管理员审核!"
return JsonResponse(msg, encoder=CustomJsonEncoder)
req_dict['id'] = datas[0].get('id')
return Auth.authenticate(Auth, learningdataforecast, req_dict)
def learningdataforecast_logout(request):
if request.method in ["POST", "GET"]:
msg = {
"msg": "登出成功",
"code": 0
}
return JsonResponse(msg, encoder=CustomJsonEncoder)
def learningdataforecast_resetPass(request):
'''
'''
if request.method in ["POST", "GET"]:
msg = {"code": normal_code, "msg": mes.normal_code}
req_dict = request.session.get("req_dict")
columns= learningdataforecast.getallcolumn( learningdataforecast, learningdataforecast)
try:
__loginUserColumn__= learningdataforecast.__loginUserColumn__
except:
__loginUserColumn__=None
username=req_dict.get(list(req_dict.keys())[0])
if __loginUserColumn__:
username_str=__loginUserColumn__
else:
username_str=username
if 'mima' in columns:
password_str='mima'
else:
password_str='password'
init_pwd = '123456'
recordsParam = {}
recordsParam[username_str] = req_dict.get("username")
records=learningdataforecast.getbyparams(learningdataforecast, learningdataforecast, recordsParam)
if len(records)<1:
msg['code'] = 400
msg['msg'] = '用户不存在'
return JsonResponse(msg, encoder=CustomJsonEncoder)
eval('''learningdataforecast.objects.filter({}='{}').update({}='{}')'''.format(username_str,username,password_str,init_pwd))
return JsonResponse(msg, encoder=CustomJsonEncoder)
def learningdataforecast_session(request):
'''
'''
if request.method in ["POST", "GET"]:
msg = {"code": normal_code,"msg": mes.normal_code, "data": {}}
req_dict={"id":request.session.get('params').get("id")}
msg['data'] = learningdataforecast.getbyparams(learningdataforecast, learningdataforecast, req_dict)[0]
return JsonResponse(msg, encoder=CustomJsonEncoder)
def learningdataforecast_default(request):
if request.method in ["POST", "GET"]:
msg = {"code": normal_code,"msg": mes.normal_code, "data": {}}
req_dict = request.session.get("req_dict")
req_dict.update({"isdefault":"是"})
data=learningdataforecast.getbyparams(learningdataforecast, learningdataforecast, req_dict)
if len(data)>0:
msg['data'] = data[0]
else:
msg['data'] = {}
return JsonResponse(msg, encoder=CustomJsonEncoder)
def learningdataforecast_page(request):
'''
'''
if request.method in ["POST", "GET"]:
msg = {"code": normal_code, "msg": mes.normal_code, "data":{"currPage":1,"totalPage":1,"total":1,"pageSize":10,"list":[]}}
req_dict = request.session.get("req_dict")
global learningdataforecast
#当前登录用户信息
tablename = request.session.get("tablename")
msg['data']['list'], msg['data']['currPage'], msg['data']['totalPage'], msg['data']['total'], \
msg['data']['pageSize'] =learningdataforecast.page(learningdataforecast, learningdataforecast, req_dict, request)
return JsonResponse(msg, encoder=CustomJsonEncoder)
def learningdataforecast_autoSort(request):
'''
．智能推荐功能(表属性：[intelRecom（是/否）],新增clicktime[前端不显示该字段]字段（调用info/detail接口的时候更新），按clicktime排序查询)
主要信息列表（如商品列表，新闻列表）中使用，显示最近点击的或最新添加的5条记录就行
'''
if request.method in ["POST", "GET"]:
msg = {"code": normal_code, "msg": mes.normal_code, "data":{"currPage":1,"totalPage":1,"total":1,"pageSize":10,"list":[]}}
req_dict = request.session.get("req_dict")
if "clicknum" in learningdataforecast.getallcolumn(learningdataforecast,learningdataforecast):
req_dict['sort']='clicknum'
elif "browseduration" in learningdataforecast.getallcolumn(learningdataforecast,learningdataforecast):
req_dict['sort']='browseduration'
else:
req_dict['sort']='clicktime'
req_dict['order']='desc'
msg['data']['list'], msg['data']['currPage'], msg['data']['totalPage'], msg['data']['total'], \
msg['data']['pageSize'] = learningdataforecast.page(learningdataforecast,learningdataforecast, req_dict)
return JsonResponse(msg, encoder=CustomJsonEncoder)
#分类列表
def learningdataforecast_lists(request):
if request.method in ["POST", "GET"]:
msg = {"code": normal_code, "msg": mes.normal_code, "data":[]}
msg['data'],_,_,_,_ = learningdataforecast.page(learningdataforecast, learningdataforecast, {})
return JsonResponse(msg, encoder=CustomJsonEncoder)
def learningdataforecast_query(request):
'''
'''
if request.method in ["POST", "GET"]:
msg = {"code": normal_code, "msg": mes.normal_code, "data": {}}
try:
query_result = learningdataforecast.objects.filter(**request.session.get("req_dict")).values()
msg['data'] = query_result[0]
except Exception as e:
msg['code'] = crud_error_code
msg['msg'] = f"发生错误：{e}"
return JsonResponse(msg, encoder=CustomJsonEncoder)
def learningdataforecast_list(request):
'''
前台分页
'''
if request.method in ["POST", "GET"]:
msg = {"code": normal_code, "msg": mes.normal_code, "data":{"currPage":1,"totalPage":1,"total":1,"pageSize":10,"list":[]}}
req_dict = request.session.get("req_dict")
#获取全部列名
columns= learningdataforecast.getallcolumn( learningdataforecast, learningdataforecast)
if "vipread" in req_dict and "vipread" not in columns:
del req_dict["vipread"]
#表属性[foreEndList]前台list:和后台默认的list列表页相似,只是摆在前台,否:指没有此页,是:表示有此页(不需要登陆即可查看),前要登:表示有此页且需要登陆后才能查看
try:
__foreEndList__=learningdataforecast.__foreEndList__
except:
__foreEndList__=None
try:
__foreEndListAuth__=learningdataforecast.__foreEndListAuth__
except:
__foreEndListAuth__=None
#authSeparate
try:
__authSeparate__=learningdataforecast.__authSeparate__
except:
__authSeparate__=None
if __foreEndListAuth__ =="是" and __authSeparate__=="是":
tablename=request.session.get("tablename")
if tablename!="users" and request.session.get("params") is not None:
req_dict['userid']=request.session.get("params").get("id")
tablename = request.session.get("tablename")
if tablename == "users" and req_dict.get("userid") != None:#判断是否存在userid列名
del req_dict["userid"]
else:
__isAdmin__ = None
allModels = apps.get_app_config('main').get_models()
for m in allModels:
if m.__tablename__==tablename:
try:
__isAdmin__ = m.__isAdmin__
except:
__isAdmin__ = None
break
if __isAdmin__ == "是":
if req_dict.get("userid"):
# del req_dict["userid"]
pass
else:
#非管理员权限的表,判断当前表字段名是否有userid
if "userid" in columns:
try:
pass
except:
pass
#当列属性authTable有值(某个用户表)[该列的列名必须和该用户表的登陆字段名一致]，则对应的表有个隐藏属性authTable为”是”，那么该用户查看该表信息时，只能查看自己的
try:
__authTables__=learningdataforecast.__authTables__
except:
__authTables__=None
if __authTables__!=None and __authTables__!={} and __foreEndListAuth__=="是":
for authColumn,authTable in __authTables__.items():
if authTable==tablename:
try:
del req_dict['userid']
except:
pass
params = request.session.get("params")
req_dict[authColumn]=params.get(authColumn)
username=params.get(authColumn)
break
if learningdataforecast.__tablename__[:7]=="discuss":
try:
del req_dict['userid']
except:
pass
q = Q()
msg['data']['list'], msg['data']['currPage'], msg['data']['totalPage'], msg['data']['total'], \
msg['data']['pageSize'] = learningdataforecast.page(learningdataforecast, learningdataforecast, req_dict, request, q)
return JsonResponse(msg, encoder=CustomJsonEncoder)
def learningdataforecast_save(request):
'''
后台新增
'''
if request.method in ["POST", "GET"]:
msg = {"code": normal_code, "msg": mes.normal_code, "data": {}}
req_dict = request.session.get("req_dict")
if 'clicktime' in req_dict.keys():
del req_dict['clicktime']
tablename=request.session.get("tablename")
__isAdmin__ = None
allModels = apps.get_app_config('main').get_models()
for m in allModels:
if m.__tablename__==tablename:
try:
__isAdmin__ = m.__isAdmin__
except:
__isAdmin__ = None
break
#获取全部列名
columns= learningdataforecast.getallcolumn( learningdataforecast, learningdataforecast)
if tablename!='users' and req_dict.get("userid")==None and 'userid' in columns and __isAdmin__!='是':
params=request.session.get("params")
req_dict['userid']=params.get('id')
if 'addtime' in req_dict.keys():
del req_dict['addtime']
idOrErr= learningdataforecast.createbyreq(learningdataforecast,learningdataforecast, req_dict)
if idOrErr is Exception:
msg['code'] = crud_error_code
msg['msg'] = idOrErr
else:
msg['data'] = idOrErr
return JsonResponse(msg, encoder=CustomJsonEncoder)
def learningdataforecast_add(request):
'''
前台新增
'''
if request.method in ["POST", "GET"]:
msg = {"code": normal_code, "msg": mes.normal_code, "data": {}}
req_dict = request.session.get("req_dict")
tablename=request.session.get("tablename")
#获取全部列名
columns= learningdataforecast.getallcolumn( learningdataforecast, learningdataforecast)
try:
__authSeparate__=learningdataforecast.__authSeparate__
except:
__authSeparate__=None
if __authSeparate__=="是":
tablename=request.session.get("tablename")
if tablename!="users" and 'userid' in columns:
try:
req_dict['userid']=request.session.get("params").get("id")
except:
pass
try:
__foreEndListAuth__=learningdataforecast.__foreEndListAuth__
except:
__foreEndListAuth__=None
if __foreEndListAuth__ and __foreEndListAuth__!="否":
tablename=request.session.get("tablename")
if tablename!="users":
req_dict['userid']=request.session.get("params").get("id")
if 'addtime' in req_dict.keys():
del req_dict['addtime']
error= learningdataforecast.createbyreq(learningdataforecast,learningdataforecast, req_dict)
if error is Exception:
msg['code'] = crud_error_code
msg['msg'] = error
else:
msg['data'] = error
return JsonResponse(msg, encoder=CustomJsonEncoder)
def learningdataforecast_thumbsup(request,id_):
'''
点赞：表属性thumbsUp[是/否]，刷表新增thumbsupnum赞和crazilynum踩字段，
'''
if request.method in ["POST", "GET"]:
msg = {"code": normal_code, "msg": mes.normal_code, "data": {}}
req_dict = request.session.get("req_dict")
id_=int(id_)
type_=int(req_dict.get("type",0))
rets=learningdataforecast.getbyid(learningdataforecast,learningdataforecast,id_)
update_dict={
"id":id_,
}
if type_==1:#赞
update_dict["thumbsupnum"]=int(rets[0].get('thumbsupnum'))+1
elif type_==2:#踩
update_dict["crazilynum"]=int(rets[0].get('crazilynum'))+1
error = learningdataforecast.updatebyparams(learningdataforecast,learningdataforecast, update_dict)
if error!=None:
msg['code'] = crud_error_code
msg['msg'] = error
return JsonResponse(msg, encoder=CustomJsonEncoder)
def learningdataforecast_info(request,id_):
'''
'''
if request.method in ["POST", "GET"]:
msg = {"code": normal_code, "msg": mes.normal_code, "data": {}}
data = learningdataforecast.getbyid(learningdataforecast,learningdataforecast, int(id_))
if len(data)>0:
msg['data']=data[0]
if msg['data'].__contains__("reversetime"):
if isinstance(msg['data']['reversetime'], datetime.datetime):
msg['data']['reversetime'] = msg['data']['reversetime'].strftime("%Y-%m-%d %H:%M:%S")
else:
if msg['data']['reversetime'] != None:
reversetime = datetime.datetime.strptime(msg['data']['reversetime'], '%Y-%m-%d %H:%M:%S')
msg['data']['reversetime'] = reversetime.strftime("%Y-%m-%d %H:%M:%S")
#浏览点击次数
try:
__browseClick__= learningdataforecast.__browseClick__
except:
__browseClick__=None
if __browseClick__=="是" and "clicknum" in learningdataforecast.getallcolumn(learningdataforecast,learningdataforecast):
try:
clicknum=int(data[0].get("clicknum",0))+1
except:
clicknum=0+1
click_dict={"id":int(id_),"clicknum":clicknum,"clicktime":datetime.datetime.now()}
ret=learningdataforecast.updatebyparams(learningdataforecast,learningdataforecast,click_dict)
if ret!=None:
msg['code'] = crud_error_code
msg['msg'] = ret
return JsonResponse(msg, encoder=CustomJsonEncoder)
def learningdataforecast_detail(request,id_):
'''
'''
if request.method in ["POST", "GET"]:
msg = {"code": normal_code, "msg": mes.normal_code, "data": {}}
data =learningdataforecast.getbyid(learningdataforecast,learningdataforecast, int(id_))
if len(data)>0:
msg['data']=data[0]
if msg['data'].__contains__("reversetime"):
if isinstance(msg['data']['reversetime'], datetime.datetime):
msg['data']['reversetime'] = msg['data']['reversetime'].strftime("%Y-%m-%d %H:%M:%S")
else:
if msg['data']['reversetime'] != None:
reversetime = datetime.datetime.strptime(msg['data']['reversetime'], '%Y-%m-%d %H:%M:%S')
msg['data']['reversetime'] = reversetime.strftime("%Y-%m-%d %H:%M:%S")
#浏览点击次数
try:
__browseClick__= learningdataforecast.__browseClick__
except:
__browseClick__=None
if __browseClick__=="是" and "clicknum" in learningdataforecast.getallcolumn(learningdataforecast,learningdataforecast):
try:
clicknum=int(data[0].get("clicknum",0))+1
except:
clicknum=0+1
click_dict={"id":int(id_),"clicknum":clicknum,"clicktime":datetime.datetime.now()}
ret=learningdataforecast.updatebyparams(learningdataforecast,learningdataforecast,click_dict)
if ret!=None:
msg['code'] = crud_error_code
msg['msg'] = ret
return JsonResponse(msg, encoder=CustomJsonEncoder)
def learningdataforecast_update(request):
'''
'''
if request.method in ["POST", "GET"]:
msg = {"code": normal_code, "msg": mes.normal_code, "data": {}}
req_dict = request.session.get("req_dict")
if 'clicktime' in req_dict.keys() and req_dict['clicktime']=="None":
del req_dict['clicktime']
if req_dict.get("mima") and "mima" not in learningdataforecast.getallcolumn(learningdataforecast,learningdataforecast) :
del req_dict["mima"]
if req_dict.get("password") and "password" not in learningdataforecast.getallcolumn(learningdataforecast,learningdataforecast) :
del req_dict["password"]
try:
del req_dict["clicknum"]
except:
pass
error = learningdataforecast.updatebyparams(learningdataforecast, learningdataforecast, req_dict)
if error!=None:
msg['code'] = crud_error_code
msg['msg'] = error
return JsonResponse(msg)
def learningdataforecast_delete(request):
'''
批量删除
'''
if request.method in ["POST", "GET"]:
msg = {"code": normal_code, "msg": mes.normal_code, "data": {}}
req_dict = request.session.get("req_dict")
error=learningdataforecast.deletes(learningdataforecast,
learningdataforecast,
req_dict.get("ids")
)
if error!=None:
msg['code'] = crud_error_code
msg['msg'] = error
return JsonResponse(msg)
def learningdataforecast_vote(request,id_):
'''
浏览点击次数（表属性[browseClick:是/否]，点击字段（clicknum），调用info/detail接口的时候后端自动+1）、投票功能（表属性[vote:是/否]，投票字段（votenum）,调用vote接口后端votenum+1）
统计商品或新闻的点击次数；提供新闻的投票功能
'''
if request.method in ["POST", "GET"]:
msg = {"code": normal_code, "msg": mes.normal_code}
data= learningdataforecast.getbyid(learningdataforecast, learningdataforecast, int(id_))
for i in data:
votenum=i.get('votenum')
if votenum!=None:
params={"id":int(id_),"votenum":votenum+1}
error=learningdataforecast.updatebyparams(learningdataforecast,learningdataforecast,params)
if error!=None:
msg['code'] = crud_error_code
msg['msg'] = error
return JsonResponse(msg)
def learningdataforecast_importExcel(request):
if request.method in ["POST", "GET"]:
msg = {"code": normal_code, "msg": "成功", "data": {}}
excel_file = request.FILES.get("file", "")
if excel_file.size > 100 * 1024 * 1024: # 限制为 100MB
msg['code'] = 400
msg["msg"] = '文件大小不能超过100MB'
return JsonResponse(msg)
file_type = excel_file.name.split('.')[1]
if file_type in ['xlsx', 'xls']:
data = xlrd.open_workbook(filename=None, file_contents=excel_file.read())
table = data.sheets()[0]
rows = table.nrows
try:
for row in range(1, rows):
row_values = table.row_values(row)
req_dict = {}
learningdataforecast.createbyreq(learningdataforecast, learningdataforecast, req_dict)
except:
pass
else:
msg = {
"msg": "文件类型错误",
"code": 500
}
return JsonResponse(msg)
def learningdataforecast_autoSort2(request):
return JsonResponse({"code": 0, "msg": '', "data":{}})
系统测试
软件测试是一个至关重要的环节，旨在核实系统是否圆满达成了项目初期所规划的各项功能目标。本章内容聚焦于依据系统功能性需求，对用户端与管理员端两大核心界面展开详尽的测试活动。这一过程不仅要求全面覆盖系统设计的每一个功能点，还强调了对这些功能点的用例进行深入细致的分析。在用户端测试方面，我们着重检验了用户界面的友好性、交互逻辑的流畅性以及各项功能的实用性，确保用户能够轻松上手并高效利用系统完成各项操作。同时，管理员端测试则更加侧重于权限管理、数据监控以及后台配置等高级功能的验证，以保障系统管理的便捷性和安全性。
结论
在教育信息化浪潮的推动下，我们完成了基于神经网络的学生学习情况分析系统的相关研究与开发工作。从系统构建来看，我们借助Python语言的灵活性与丰富库资源，结合Django框架高效搭建Web架构，利用MySQL数据库实现数据的有序存储与管理。LSTM算法在挖掘学生学习时间序列数据规律、预测期末成绩等方面发挥关键作用，Echarts则让数据以直观可视化形式呈现。这些技术的有机融合，赋予了系统强大的功能。
© 版权声明
文章版权归作者所有，未经允许请勿转载。
