基于 LSTM 神经网络的学生学习情况分析系统

关键技术

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)):
            pass
        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:
            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 则让数据以直观可视化形式呈现。这些技术的有机融合，赋予了系统强大的功能。