Tabla de contenido
Capítulo 1 Diseño general del sistema
1.1 Antecedentes e importancia del proyecto
1.2 Contenido del diseño del sistema
Capítulo 2 Análisis de la demanda
2.1 Requisitos comerciales del sistema
2.2 Requisitos de datos del sistema
3.1 Diseño de estructura funcional
3.2 Diseño de la estructura conceptual de la base de datos
3.3 Diseño de la estructura lógica de la base de datos
3.4 Diseño físico de la base de datos
Capítulo 4 Implementación del sistema
4.2 Funciones principales y códigos de programa
Capítulo 1 Diseño general del sistema
Cada escuela necesita realizar un análisis estadístico de los puntajes de las pruebas al final del período, y estas tareas deben completarse dentro de una semana después de la prueba. Si el trabajo estadístico de una gran cantidad de datos de rendimiento se realiza manualmente, requerirá mucho tiempo, mucha mano de obra y será propenso a errores. Con el rápido desarrollo de la tecnología informática aleatoria y la rápida popularización de las computadoras en las aplicaciones de gestión diaria, es imperativo utilizar las computadoras para gestionar el rendimiento de los estudiantes. Por lo tanto, es necesario desarrollar un sistema de administración de calificaciones completamente funcional, seguro, confiable, rápido y conveniente que satisfaga las necesidades de la escuela para el ingreso, consulta y modificación de calificaciones.
1.2.1 Propósito del diseño del sistema
Desarrolle un sistema de gestión del desempeño de los estudiantes que sea fácil de operar, de interfaz amigable, flexible y práctico, seguro y confiable. El desarrollo del sistema está dirigido a maestros y servicios estudiantiles. Puede mejorar la eficiencia del análisis estadístico de las calificaciones de los estudiantes, reducir la carga de los administradores educativos sobre la gestión y las estadísticas del desempeño de los estudiantes, y mejorar la gestión estandarizada del desempeño de los estudiantes de la escuela.
El sistema de calificaciones puede recopilar y organizar las calificaciones de los estudiantes de manera oportuna, de modo que los departamentos relevantes de la escuela puedan obtener información confiable sobre las calificaciones de los estudiantes de manera oportuna, lo cual es conveniente para la administración. Es conveniente que los docentes registren y cuenten las calificaciones de los estudiantes en las clases que dirigen, mejoren la eficiencia del trabajo, reduzcan las cargas y mejoren la calidad de la enseñanza. Realice el procesamiento rápido y conveniente de una gran cantidad de información de datos de calificaciones y complete los requisitos de procesamiento de ingreso, modificación, eliminación, consulta, etc. de calificaciones. Es conveniente que los estudiantes verifiquen sus calificaciones en varias materias.
1.2.2 Resumen del sistema
Este sistema permite a los estudiantes seleccionar cursos en línea y verificar sus calificaciones. Usando el método de python+flask+mysql, sin implementación de servidor, se puede probar y ejecutar en una sola máquina
El front-end toma prestada la plantilla de página de front-end que se encuentra en Internet y la modifica sobre esta base. La tecnología principal es html+css+js. El front-end y el back-end se desarrollan por separado, y herramientas como cartero se utilizan para las pruebas de interfaz.
1.2.3 Requisitos de funcionamiento del sistema
- El sistema se divide en tres tipos de usuarios: administradores, profesores y estudiantes, y los diferentes usuarios tienen diferentes permisos.
- Los estudiantes pueden iniciar sesión para verificar su información personal, verificar sus calificaciones y cambiar sus contraseñas.
- Los profesores pueden iniciar sesión para ver información personal, administrar cursos, recopilar estadísticas de rendimiento de los estudiantes y modificar las contraseñas de inicio de sesión.
- Los administradores pueden agregar, eliminar, modificar y verificar información sobre estudiantes, profesores, cursos, especializaciones e información de selección de cursos de especialización.
- sistema operativo windows10
- Edición de la comunidad de PyCharm 2022.1.1
- mysql 8.0
Capítulo 2 Análisis de la demanda
2.1 Requisitos comerciales del sistema
Este sistema desarrollará un sistema de gestión del desempeño de los estudiantes. Al evaluar la situación de aprendizaje de los estudiantes, los maestros enseñan
De acuerdo con la situación, se analizan las calificaciones de los estudiantes y se determina que el sistema de gestión de calificaciones de los estudiantes tiene principalmente tres tipos de roles de usuario: estudiantes,
maestros, administradores. Sus respectivas necesidades principales de procesamiento de información son las siguientes:
usuario administrador
- Añadir, eliminar, modificar y consultar la información del profesor. La información del maestro incluye el número de maestro, el nombre, el sexo y el año de nacimiento.
- Mantener la información básica de los estudiantes, realizar la adición, eliminación, modificación y consulta de la información personal de los estudiantes.La información del estudiante incluye número de estudiante, nombre, sexo, año de nacimiento, lugar de origen, año de admisión, número de carrera y nombre.
- Mantener la información básica de cursos, realizar la adición, eliminación, modificación y consulta de información de cursos,
La información del curso incluye el número del curso, el nombre del curso, los créditos, el año académico, el semestre, el número y el nombre del maestro.
- Administre la información profesional para realizar la adición, eliminación, modificación y consulta de carreras, donde las carreras incluyen el número de carrera, el nombre de la carrera y el número de estudiantes.
- Mantenga la información básica de la selección de cursos principales, agregue, elimine, modifique y consulte la información de selección de cursos. La información de selección de cursos incluye el número principal, el nombre principal, el número del curso y el nombre del curso.
Usuario estudiante:
- Consultar información personal.
- Los estudiantes pueden ver la información del curso seleccionado y la información de calificación de los cursos seleccionados previamente.
- Los alumnos pueden consultar a los profesores correspondientes a los cursos.
- Cambiar contraseña de inicio de sesión
Usuario profesor:
- Consultar información personal.
- Ver información sobre los cursos impartidos y los alumnos que han realizado los cursos.
- Modifique las calificaciones de los estudiantes y vea las estadísticas del curso.
2.2 Requisitos de datos del sistema
Las principales fuentes de datos involucradas en el sistema incluyen datos de estudiantes , datos de maestros y datos de administradores , y se generan varios formularios, como la tabla de información del curso , la tabla de información profesional y la tabla de selección de cursos profesionales . Combinado con los requisitos de procesamiento comercial, el diagrama de flujo de datos del sistema se muestra en la figura.
Figura 2-1 Descripción de la entidad
Figura 2-2 Descripción del flujo de datos
3.1 Diseño de estructura funcional
De acuerdo con los requisitos comerciales y los requisitos de datos obtenidos del análisis de requisitos, se puede definir el diagrama de estructura funcional del sistema, como se muestra en la Figura 3-1.
Figura 3-1 Estructura Funcional del Sistema de Gestión del Desempeño Estudiantil
Las funciones detalladas de cada módulo son las siguientes:
3.1.1 Módulo de Estudiante
- Los estudiantes pasan su propio número de estudiante y la contraseña inicial es el número de estudiante;
- Consultar la información del curso de cada materia, el profesor del curso, y consultar las notas del curso;
- Modificación de contraseña personal: modifique la contraseña actual y dos contraseñas nuevas después de la verificación de entrada;
3.1.2 Módulo de Profesor
(1) El maestro inicia sesión a través del número de maestro y la contraseña inicial es el número de maestro;
(2) Gestión del plan de estudios: los profesores registran y modifican las calificaciones de los cursos impartidos y cuentan el número de estudiantes en diferentes grados;
(3) Para modificar la contraseña de la cuenta personal, se ingresan y verifican la contraseña anterior y dos contraseñas nuevas para modificar la contraseña;
3.1.3 Módulo de administrador
- Inicio de sesión del administrador, el nombre de usuario es admin, la contraseña es asdfg13579;
- Ver la información del estudiante y agregarla, modificarla y eliminarla;
- Ver la información del maestro y agregarla, modificarla y eliminarla;
- Ver información del curso y agregarla, modificarla y eliminarla;
- Ver información profesional, agregarla, modificarla y eliminarla;
- Verifique la información de selección de cursos principales y agréguela, modifíquela y elimínela;
3.2 Diseño de la estructura conceptual de la base de datos
3.2.1 Estructura conceptual
Los requisitos de aplicación obtenidos en la etapa de análisis de requisitos deben abstraerse primero en la estructura del mundo de la información, de modo que estos requisitos puedan cumplirse mejor y con mayor precisión con un determinado DBMS.
Características principales de la estructura conceptual:
- Puede reflejar verdadera y completamente el mundo de la pantalla, incluida la conexión entre cosas y cosas, y satisfacer a los usuarios.
Los requisitos de procesamiento de datos son solo un modelo del mundo real;
- Es fácil de entender, por lo que puede utilizarse para intercambiar ideas con usuarios que no están familiarizados con las computadoras y la participación activa de los usuarios.
Y es la clave para el éxito del diseño de bases de datos.
- Fácil de cambiar, cuando el entorno de la aplicación y los requisitos de la aplicación cambian, es fácil modificar y expandir el modelo conceptual;
- Fácil de convertir a varios modelos de datos, como relacionales, de red y jerárquicos;
La estructura conceptual es la base común de varios modelos de datos, es más independiente de la máquina y más abstracta que el modelo de datos, por lo que es más estable.
3.2.2 Diseño de la estructura conceptual del sistema de gestión del desempeño de los estudiantes
Ahora analice más a fondo los requisitos del sistema diseñado y genere el modelo ER del diseño de la estructura conceptual. Dado que el sistema no es complejo, se puede utilizar un enfoque de diseño de arriba hacia abajo. La clave del diseño de arriba hacia abajo es identificar las actividades centrales del sistema. La llamada actividad central significa que otras actividades en el sistema deben girar en torno a esta actividad, o están estrechamente relacionadas con esta actividad. Una vez que se identifican las actividades centrales, el sistema tiene espacio para expandirse.
3.2.3 modelo ER
El sistema involucra principalmente a tres entidades: estudiantes, maestros y administradores. Los estudiantes y los maestros establecen contacto a través de la enseñanza. Un estudiante aprende varios cursos y un maestro puede enseñar a varios estudiantes; los administradores establecen contactos con estudiantes y maestros a través de la gestión; existen entidades tales como cursos, especializaciones, selección de cursos de especialización y calificaciones; analice y defina los atributos de cada entidad, y establezca el diagrama ER del modelo de conexión de entidad como se muestra a continuación.
Figura 3-4 Diagrama ER del Sistema de Gestión del Desempeño Estudiantil
3.3 Diseño de la estructura lógica de la base de datos
Esquema de relación:
Transforme el modelo conceptual de la base de datos en los siguientes esquemas relacionales básicos: los atributos se marcan claves primarias y los marcados como claves externas;
Estudiante ( número de estudiante ,nombre, género, año de nacimiento, lugar de nacimiento, año de inscripción, número de carrera ,contraseña)
Profesor ( número de profesor , nombre, sexo, año de nacimiento, contraseña)
Curso ( ID del curso , nombre del curso, año académico, semestre, créditos, ID de la facultad )
Mayor ( número profesional , nombre profesional)
Selección de cursos por estudiantes ( número de estudiante, número de curso , calificaciones)
Selección de cursos principales ( código profesional, código de curso )
Administrador ( usuario , contraseña)
3.4 Diseño físico de la base de datos
3.4.1 Estructura de la tabla de la base de datos
La base de datos incluye 5 tablas relacionales, de las cuales la Tabla 3-5 ~ 3-10 muestra la estructura de la tabla.
- estudiante tabla de estudiantes:
| campo |
describir |
Descripción del valor |
Observación |
| Identificación del Estudiante |
número de estudiante, clave principal |
carácter(10), número |
Clave primaria |
| nombre del estudiante |
nombre del estudiante |
varchar(20), chino |
no nulo |
| sexo |
género |
char(2), masculino|femenino |
|
| Año de nacimiento |
año de nacimiento |
carácter(4), número |
|
| provincia |
Provincia de origen |
varchar(20), chino |
|
| ingrese_año |
Año de inicio |
carácter(4), número |
no nulo |
| mayor_id |
Número de especialidad, clave externa |
carácter(3), número |
clave foránea, no nula |
| contraseña |
contraseña encriptada |
varchar(128) |
no nulo |
Tabla 3-5 Estructura de la tabla de estudiantes
- tabla de profesores:
| campo |
describir |
Descripción del valor |
Observación |
| profesor_id |
número de profesor |
carácter(5), número |
Clave primaria |
| Nombre del maestro |
Nombre del maestro |
varchar(20), chino |
no nulo |
| sexo |
género |
char(2), masculino|femenino |
|
| Año de nacimiento |
año de nacimiento |
carácter(4), número |
|
| contraseña |
contraseña encriptada |
varchar(128) |
no nulo |
Tabla 3-6 Estructura de la mesa del profesor
(3) horario del curso
| campo |
describir |
Descripción del valor |
Observación |
| id_del_curso |
Número de curso |
carácter(5), número |
Clave primaria |
| Nombre del curso |
Título del curso |
varchar(20), chino |
no nulo |
| año |
Año de establecimiento |
carácter(4), número |
no nulo |
| semestre |
semestre abierto |
char(2), Otoño|Primavera |
no nulo |
| profesor_id |
número de profesor |
carácter(5), número |
clave foránea, no nula |
| crédito |
crédito |
minúsculo int, sin firmar, 0 ~ 10 |
no nulo |
Tabla 3-7 Estructura del plan de estudios
(4) tabla de selección de cursos para estudiantes student_course
| campo |
describir |
Descripción del valor |
Observación |
| Identificación del Estudiante |
número de estudiante |
carácter(10) , número |
clave primaria conjunta, clave externa |
| id_del_curso |
Número de curso |
carácter(5) , número |
clave primaria conjunta, clave externa |
| calificación |
puntaje |
minúsculo int , sin firmar, 0~100 |
Tabla 3-8 Estructura de la tabla de selección de cursos
- major_course tabla de selección de cursos principales
| campo |
describir |
Descripción del valor |
Observación |
| mayor_id |
número profesional |
carácter(3), número |
clave primaria conjunta, clave externa |
| id_del_curso |
Número de curso |
carácter(5), número |
clave primaria conjunta, clave externa |
Tabla 3-9 Estructura de la tabla de selección de cursos principales
(6) tabla de administrador administrador
| campo |
describir |
Descripción del valor |
Observación |
| nombre_administrador |
nombre de usuario |
carcter(15) |
Clave primaria |
| contraseña |
contraseña |
caract(128) |
no nulo |
Tabla 3-10 Estructura de la tabla del administrador
3.4.2 Código de creación de tabla de base de datos
1. Crea una base de datos
create database grade_manage_system;2. Entrar en la base de datos
use grade_manage_system3. Crea una tabla de estudiantes
create table student
(
student_id char(10) primary key,
student_name varchar(20) not null,
sex char(2),
birth_year char(4),
province varchar(20),
enter_year char(4) not null,
major_id char(3) not null,
password varchar(128) not null
);4. Crear tabla de profesores
create table teacher
(
teacher_id char(5) primary key,
teacher_name varchar(20) not null,
sex char(2),
birth_year char(4),
password varchar(128) not null
);5. Crea un horario de clases
create table course
(
course_id char(5) primary key,
course_name varchar(20) not null,
year char(4) not null,
semester char(2) not null,
teacher_id char(5) not null,
credit tinyint unsigned not null
);6. Crea una mesa profesional
create table major
(
major_id char(3) primary key,
major_name varchar(20) not null unique
);7. Crea una lista de selección de cursos profesionales
create table major_course
(
major_id char(3),
course_id char(5)
);8. Cree una boleta de calificaciones de selección de cursos para estudiantes
create table student_course
(
student_id char(10),
course_id char(5),
grade tinyint unsigned
);- Crear tabla de administración
create table admin
(
admin_name char(15) primary key,
password varchar(128) not null
);Capítulo 4 Implementación del sistema
4.1 Diseño de la interfaz
La página del sistema de gestión del rendimiento de los estudiantes está hecha por la biblioteca de matraces de programación de Python. La página se divide principalmente en cuatro módulos, a saber: módulo de página de inicio de sesión, módulo de usuario estudiante, módulo de usuario profesor y módulo de usuario administrador. La página de destino está hecha con tecnología html+css+js y se interconecta mediante el uso de herramientas como cartero. Y hay varios módulos pequeños debajo de los otros tres módulos, cada uno con varias páginas. El diseño detallado de la interfaz es el siguiente.
4.1.1 Diseño de la página de inicio de sesión
El sistema de gestión del rendimiento de los estudiantes es iniciar sesión seleccionando la identidad de inicio de sesión e ingresando la contraseña de la cuenta. El administrador usa admin como nombre de usuario y la contraseña es un valor fijo que no se puede modificar. El maestro usa el número de maestro como nombre de usuario y la contraseña predeterminada es el número de maestro, que se puede modificar. El estudiante usa el número de estudiante como nombre de usuario, y la contraseña predeterminada es el número de estudiante, que se puede modificar. La interfaz de inicio de sesión es la siguiente:
4.1.2 Módulo de Estudiante
4.1.3 Módulo de Profesor
4.1.4 Módulo de administrador
El administrador inicia sesión con el nombre de usuario admin y la contraseña asdfg13579,
Después de que el administrador inicie sesión correctamente, hay varias interfaces funcionales para ver toda la información de los estudiantes, agregar estudiantes, ver toda la información de los maestros, agregar maestros, ver toda la información del curso, agregar cursos, ver toda la información principal, agregar carreras, ver la información de selección de cursos principales , y agregando una selección de cursos principales
4.2 Funciones principales y códigos de programa
4.2.1 数据库搭建
学生成绩管理系统的实现，共需要在 MySQL 上创建一个数据库，七个表，分别
是学生表（student）、教师表（teacher）、课程表（course）、专业表
（major）、管理员表（admin）、学生选课表（student_course）、专业选课表（major_course）。
（1）创建并使用数据库
create database grade_manage_system;//
use grade_manage_system（2）创建专业表
create table major(major_id char(3) primary key, major_name varchar(20) not null unique);//（3）创建学生表
create table student(
student_id char(10) primary key, student_name varchar(20) not null,
sex char(2),
birth_year char(4), province varchar(20), enter_year char(4) not null,
major_id char(3) not null, password varchar(128) not null);//
alter table student add foreign key (major_id) references major (major_id) on delete cascade;//（4）创建教师表
create table teacher(
teacher_id char(5) primary key, teacher_name varchar(20) not null,
sex char(2),
birth_year char(4), password varchar(128) not null);//（5）创建课程表
create table course(
course_id char(5) primary key, course_name varchar(20) not null,
year char(4) not null, semester char(2) not null,
teacher_id char(5) not null,
credit tinyint unsigned not null);//
alter table course add foreign key (teacher_id) references teacher (teacher_id) on delete cascade;//（6）创建专业选课表
create table major_course(
major_id char(3), course_id char(5));//
alter table major_course add primary key (major_id, course_id);//
alter table major_course add foreign key (major_id) references major (major_id)
on delete cascade;//
alter table major_course add foreign key (course_id) references course (course_id) on delete cascade;//（7）创建学生选课表
create table student_course(
student_id char(10), course_id char(5), grade tinyint unsigned);//
alter table student_course add primary key (student_id, course_id);//（8）创建添加专业选课
create trigger trigger_insert_1 after insert on major_course for each row
begin
insert into student_course (
select student_id, new.course_id, null
from student
where major_id = new.major_id
);
end//（9）创建删除专业选课
create trigger trigger_delete_1 after delete on major_course for each row
begin
delete from student_course
where student_id in (
select student_id
from student
where major_id = old.major_id
) and course_id = old.course_id;
end//（10）创建添加学生
create trigger trigger_insert_2 after insert on student for each row
begin
insert into student_course (
select new.student_id, course_id, null
from major_course
where major_id = new.major_id
);
end//（11）创建删除学生
create trigger tigger_delete_2 after delete on student for each row
begin
delete from student_course
where course_id in (
select course_id
from major_course
where major_id = old.major_id
) and student_id = old.student_id;
end//
delimiter ;4.2.2 数据库的连接
功能：使得数据库与客户端进行数据传输
代码：
-
if __name__ == '__main__': app.config['DEBUG'] = True app.config['SECRET_KEY'] = '123456' app.config['DATABASE_USER'] = 'root' app.config['DATABASE_PASSWORD'] = '1234
4.2.3 登录模块
功能：验证账号密码和对应的权限，以及跳转进入对应主页面
代码：
-
from flask import Flask from flask_login import LoginManager from app.models.session import LoginChecker from werkzeug.utils import redirect from flask_login import login_required login_manager = LoginManager() @login_manager.user_loader def load_user(user_id): if 'student' in user_id: return LoginChecker('load', 'student', user_id[7:], 'default') if 'teacher' in user_id: return LoginChecker('load', 'teacher', user_id[7:], 'default') if 'admin' in user_id: return LoginChecker('load', 'admin', user_id[5:], 'default') return None app = Flask(__name__) login_manager.init_app(app) from app.web.student import web app.register_blueprint(web) @app.route('/') def bare(): return redirect('/static/Login.html') @app.route('/static/Login.html') def html_login(): return app.send_static_file('Login.html') @app.route('/static/Student_Info.html') @login_required def html_student_info(): return app.send_static_file('Student_Info.html') @app.route('/static/Student_Scores.html') @login_required def html_student_scores(): return app.send_static_file('Student_Scores.html') @app.route('/static/Student_ChangePassword.html') @login_required def html_student_change_password(): return app.send_static_file('Student_ChangePassword.html') @app.route('/static/Teacher_Info.html') @login_required def html_teacher_info(): return app.send_static_file('Teacher_Info.html') @app.route('/static/Teacher_Courses.html') @login_required def html_teacher_courses(): return app.send_static_file('Teacher_Courses.html') @app.route('/static/Teacher_CourseInfo.html') @login_required def html_course_info(): return app.send_static_file('Teacher_CourseInfo.html') @app.route('/static/Teacher_ChangePassword.html') @login_required def html_teacher_change_password(): return app.send_static_file('Teacher_ChangePassword.html') @app.route('/static/Teacher_Statistics.html') @login_required def html_teacher_statistics(): return app.send_static_file('Teacher_Statistics.html')
4.2.4 学生菜单模块
功能：在学生页面进行不同功能页面的切换
各个功能代码如下：
- 学生登录菜单
-
from app.models.general import connect_to_sql class StudentReader: def __init__(self, student_id): self.data = read_base_information(student_id) if self.data.get('error'): return self.data = dict(self.data, **read_total_credits(student_id)) if self.data.get('error'): return self.data = dict(self.data, **read_number_of_courses(student_id)) if self.data.get('error'): return self.data = dict(self.data, **read_average_grade(student_id)) class StudentCoursesReader: def __init__(self, student_id): self.data = read_selected_courses(student_id)
- 学生查看个人信息
-
def read_base_information(student_id): connection = connect_to_sql() data = {} try: with connection.cursor() as cursor: # 查询学生基本信息 sql = 'select student_id, student_name, sex, birth_year, province, enter_year, major_name, s.major_id ' \ 'from student as s, major as m ' \ 'where s.student_id = %s and s.major_id = m.major_id;' % student_id cursor.execute(sql) result = cursor.fetchone() if result: data['student_id'] = result[0] data['student_name'] = result[1] data['sex'] = result[2] data['birth_year'] = result[3] data['province'] = result[4] data['enter_year'] = result[5] data['major_name'] = result[6] data['major_id'] = result[7] else: data['error'] = 'student id ' + student_id + ' not found in database' except Exception as e: data['error'] = str(e) finally: connection.close() return data
- 学生查看课程信息及成绩
-
def read_total_credits(student_id): connection = connect_to_sql() data = {} try: with connection.cursor() as cursor: sql = 'select if(sum(credit) is null, 0, sum(credit)) from student as s, course as c, student_course as sc ' \ 'where s.student_id = %s and s.student_id = sc.student_id ' \ 'and c.course_id = sc.course_id and grade >= 60;' % student_id cursor.execute(sql) result = cursor.fetchone() if result: data['credits'] = int(result[0]) else: data['credits'] = 0 except Exception as e: data['error'] = str(e) finally: connection.close() return data def read_number_of_courses(student_id): connection = connect_to_sql() data = {} try: with connection.cursor() as cursor: sql = 'select count(course_id) from student_course ' \ 'where student_id = %s;' % student_id cursor.execute(sql) result = cursor.fetchone() if result: data['number_of_courses'] = int(result[0]) else: data['number_of_courses'] = 0 except Exception as e: data['error'] = str(e) finally: connection.close() return data def read_average_grade(student_id): connection = connect_to_sql() data = {} try: with connection.cursor() as cursor: sql = 'select credit, grade from student_course as sc, course as c ' \ 'where sc.student_id = %s and sc.course_id = c.course_id ' \ 'and grade is not null;' % student_id cursor.execute(sql) result = cursor.fetchall() if result: total_credit = 0 total_grade = 0 for row in result: total_credit += row[0] total_grade += row[0] * row[1] data['average_grade'] = round(float(1.0*total_grade/total_credit), 2) else: data['average_grade'] = 0 except Exception as e: data['error'] = str(e) finally: connection.close() return data def read_selected_courses(student_id): connection = connect_to_sql() data = {} try: with connection.cursor() as cursor: sql = 'select c.course_id, c.course_name, c.year, c.semester, t.teacher_name, c.credit, sc.grade ' \ 'from course as c, student_course as sc, teacher as t ' \ 'where sc.student_id = %s and sc.course_id = c.course_id ' \ 'and t.teacher_id = c.teacher_id;' % student_id cursor.execute(sql) result = cursor.fetchall() data['courses'] = [] for row in result: tmp = {'course_id': row[0], 'course_name': row[1], 'year': row[2], 'semester': row[3], 'teacher_name': row[4], 'credit': row[5], 'grade': row[6]} data['courses'].append(tmp) except Exception as e: data['error'] = str(e) finally: connection.close() return data
4.2.5 教师菜单模块
功能：在教师页面进行不同功能页面的切换
- 教师登录页面
-
from app.models.general import connect_to_sql class TeacherReader: def __init__(self, teacher_id): self.data = read_base_information(teacher_id) if self.data.get('error'): return self.data = dict(self.data, **read_number_of_courses(teacher_id)) class TeacherCoursesReader: def __init__(self, teacher_id): self.data = read_taught_courses(teacher_id) class TeacherCourseStudentReader: def __init__(self, course_id): self.data = read_selected_students(course_id) class TeacherGradeUpdater: def __init__(self, course_id, student_id, grade): self.data = update_student_grade(course_id, student_id, grade) class CourseStatisticReader: def __init__(self, course_id): self.data = read_course_statistic(course_id)
- 教师查看个人信息
-
def read_number_of_courses(teacher_id): connection = connect_to_sql() data = {} try: with connection.cursor() as cursor: # 查询教师所授课程数量 sql = 'select count(course_id) from course ' \ 'where teacher_id = %s;' % teacher_id cursor.execute(sql) result = cursor.fetchone() if result: data['number_of_courses'] = int(result[0]) else: data['number_of_courses'] = 0 except Exception as e: data['error'] = str(e) finally: connection.close() return data
（3）教师查看授课信息
-
def read_taught_courses(teacher_id): connection = connect_to_sql() data = {} try: with connection.cursor() as cursor: # 查询教师授课列表 sql = 'select course_id, course_name, year, semester, credit ' \ 'from course ' \ 'where teacher_id = %s ' % teacher_id cursor.execute(sql) result = cursor.fetchall() data['courses'] = [] if result: for row in result: tmp = {'course_id': row[0], 'course_name': row[1], 'year': row[2], 'semester': row[3], 'credit': row[4]} data['courses'].append(tmp) except Exception as e: data['error'] = str(e) finally: connection.close() return data
（4）教师查看选课学生
-
def read_selected_students(course_id): connection = connect_to_sql() data = {} try: with connection.cursor() as cursor: # 查询选课学生列表 sql = 'select s.student_id, s.student_name, s.sex, m.major_name, sc.grade ' \ 'from student_course as sc, student as s, major as m ' \ 'where sc.student_id = s.student_id and s.major_id = m.major_id ' \ 'and course_id = %s ' % course_id cursor.execute(sql) result = cursor.fetchall() data['students'] = [] if result: for row in result: tmp = {'student_id': row[0], 'student_name': row[1], 'sex': row[2], 'major_name': row[3], 'grade': row[4]} data['students'].append(tmp) except Exception as e: data['error'] = str(e) finally: connection.close() return data
（5）教师查看课程统计信息
-
def read_course_statistic(course_id): connection = connect_to_sql() data = {} try: with connection.cursor() as cursor: # 查询某课程统计信息 sql = 'select ' \ 'count(case when grade between 0 and 59 then grade end) as \'0-59\',' \ 'count(case when grade between 60 and 69 then grade end) as \'60-69\',' \ 'count(case when grade between 70 and 79 then grade end) as \'70-79\',' \ 'count(case when grade between 80 and 89 then grade end) as \'80-89\',' \ 'count(case when grade between 90 and 100 then grade end) as \'90-100\' ' \ 'from student_course ' \ 'where course_id = %s;' % course_id cursor.execute(sql) result = cursor.fetchone() if result: data['0-59'] = int(result[0]) data['60-69'] = int(result[1]) data['70-79'] = int(result[2]) data['80-89'] = int(result[3]) data['90-100'] = int(result[4]) else: data['error'] = 'course_id ' + course_id + ' not found in database' except Exception as e: data['error'] = str(e) finally: connection.close() return data
（6）教师修改学生成绩
-
def update_student_grade(course_id, student_id, grade): connection = connect_to_sql() data = {} try: with connection.cursor() as cursor: # 更新学生某课程成绩 sql = 'update student_course ' \ 'set grade = %s ' \ 'where course_id = \'%s\' and student_id = \'%s\';' % (grade, course_id, student_id) cursor.execute(sql) connection.commit() except Exception as e: data['error'] = str(e) connection.rollback() finally: connection.close() return data
4.2.6 管理员模块
功能：在管理员页面进行不同功能页面的切换
- 管理员管理学生模块
- 管理学生菜单
-
from app.models.general import connect_to_sql from app.models.student import StudentReader from werkzeug.security import generate_password_hash class StudentListReader: def __init__(self): data = read_student_id_list() if data.get('error'): return student_id_list = data['student_id'] self.data = {'students': []} for student_id in student_id_list: tmp = StudentReader(student_id) if tmp.data.get('error'): self.data['error'] = tmp.data['error'] return self.data['students'].append(tmp.data) class StudentUpdater: def __init__(self, student_id, student_name, sex, birth_year, province, enter_year, major_id): self.data = update_student(student_id, student_name, sex, birth_year, province, enter_year, major_id) class StudentInserter: def __init__(self, student_name, sex, birth_year, province, enter_year, major_id): self.data = insert_student(student_name, sex, birth_year, province, enter_year, major_id) class StudentDeleter: def __init__(self, student_id): self.data = delete_student(student_id)
- 删除学生信息
-
def delete_student(student_id): connection = connect_to_sql() data = {} try: with connection.cursor() as cursor: sql = 'delete from student where student_id = \'%s\'; ' % student_id cursor.execute(sql) connection.commit() except Exception as e: data['error'] = str(e) connection.rollback() finally: connection.close() return data
- 添加学生信息
-
def insert_student(student_name, sex, birth_year, province, enter_year, major_id): connection = connect_to_sql() data = {} try: with connection.cursor() as cursor: student_id = get_new_student_id(enter_year, major_id) password = generate_password_hash(student_id['student_id']) sql = 'insert into student values ' \ '(\'%s\', \'%s\', \'%s\', \'%s\', \'%s\', \'%s\', \'%s\', \'%s\'); ' \ % (student_id['student_id'], student_name, sex, birth_year, province, enter_year, major_id, password) cursor.execute(sql) connection.commit() except Exception as e: data['error'] = str(e) connection.rollback() finally: connection.close() return data
- 查看学生信息表
-
def read_student_id_list(): connection = connect_to_sql() data = {} try: with connection.cursor() as cursor: sql = 'select student_id from student order by student_id;' cursor.execute(sql) data['student_id'] = cursor.fetchall() except Exception as e: data['error'] = str(e) finally: connection.close() return data
- 修改学生信息
-
def update_student(student_id, student_name, sex, birth_year, province, enter_year, major_id): connection = connect_to_sql() data = {} try: with connection.cursor() as cursor: sql = 'update student set student_name = \'%s\', sex = \'%s\', birth_year = \'%s\', ' \ 'province = \'%s\', enter_year = \'%s\', major_id = \'%s\' where student_id = \'%s\'; ' % \ (student_name, sex, birth_year, province, enter_year, major_id, student_id) cursor.execute(sql) connection.commit() except Exception as e: data['error'] = str(e) connection.rollback() finally: connection.close() return data
- 管理员管理教师模块
- 管理教师菜单
-
from werkzeug.security import generate_password_hash from app.models.general import connect_to_sql class TeacherListReader: def __init__(self): self.data = read_teacher_list() class TeacherIdReader: def __init__(self): self.data = read_teacher_id() class TeacherUpdater: def __init__(self, teacher_id, teacher_name, sex, birth_year): self.data = update_teacher(teacher_id, teacher_name, sex, birth_year) class TeacherInserter: def __init__(self, teacher_name, sex, birth_year): self.data = insert_teacher(teacher_name, sex, birth_year) class TeacherDeleter: def __init__(self, teacher_id): self.data = delete_teacher(teacher_id)
- 查看教师信息
-
def read_teacher_list(): connection = connect_to_sql() data = {} try: with connection.cursor() as cursor: sql = 'select t.teacher_id, teacher_name, sex, birth_year, count(course_id) as number_of_courses ' \ 'from teacher as t left outer join course as c ' \ 'on c.teacher_id = t.teacher_id ' \ 'group by t.teacher_id ' \ 'order by t.teacher_id;' cursor.execute(sql) result = cursor.fetchall() data['teachers'] = [] for row in result: tmp = {'teacher_id': row[0], 'teacher_name': row[1], 'sex': row[2], 'birth_year': row[3], 'number_of_courses': row[4]} data['teachers'].append(tmp) except Exception as e: data['error'] = str(e) finally: connection.close() return data
- 删除教师信息
-
def delete_teacher(teacher_id): connection = connect_to_sql() data = {} try: with connection.cursor() as cursor: sql = 'delete from teacher where teacher_id = \'%s\'; ' % teacher_id cursor.execute(sql) connection.commit() except Exception as e: data['error'] = str(e) connection.rollback() finally: connection.close() return data
- 添加教师信息
-
def insert_teacher(teacher_name, sex, birth_year): connection = connect_to_sql() data = {} try: with connection.cursor() as cursor: teacher_id = get_new_teacher_id() password = generate_password_hash(teacher_id['teacher_id']) if teacher_id.get('error'): data['error'] = teacher_id['error'] return data sql = 'insert into teacher values(\'%s\', \'%s\', \'%s\', \'%s\', \'%s\');' \ % (teacher_id['teacher_id'], teacher_name, sex, birth_year, password) cursor.execute(sql) connection.commit() except Exception as e: data['error'] = str(e) connection.rollback() finally: connection.close() return data
- 修改教师信息
-
def update_teacher(teacher_id, teacher_name, sex, birth_year): connection = connect_to_sql() data = {} try: with connection.cursor() as cursor: sql = 'update teacher set teacher_name = \'%s\', sex = \'%s\', birth_year = \'%s\' ' \ 'where teacher_id = \'%s\'; ' % \ (teacher_name, sex, birth_year, teacher_id) cursor.execute(sql) connection.commit() except Exception as e: data['error'] = str(e) connection.rollback() finally: connection.close() return data
- 管理员管理课程模块
- 管理课程菜单
-
from app.models.general import connect_to_sql class CourseReader: def __init__(self): self.data = read_course() class SingleCourseReader: def __init__(self, course_id): self.data = read_single_course(course_id) class CourseDeleter: def __init__(self, course_id): self.data = delete_course(course_id) class CourseInserter: def __init__(self, course_name, year, semester, teacher_id, credit): self.data = insert_course(course_name, year, semester, teacher_id, credit) class CourseUpdater: def __init__(self, course_id, course_name, year, semester, teacher_id, credit): self.data = update_course(course_id, course_name, year, semester, teacher_id, credit) class CourseTeacherReader: def __init__(self, course_id): self.data = get_teacher_of_course(course_id)
- 查看课程信息
-
def read_course(): connection = connect_to_sql() data = {} try: with connection.cursor() as cursor: sql = 'select tmp.course_id, tmp.course_name, tmp.year, tmp.semester, tmp.teacher_id, ' \ 'tmp.credit, tmp.number_of_students, tmp.average_grade, t.teacher_name from ( ' \ 'select c.course_id, course_name, year, semester, teacher_id, credit, count(student_id), avg(grade) ' \ 'from course as c left outer join student_course as sc ' \ 'on c.course_id = sc.course_id ' \ 'group by c.course_id ' \ ') as tmp(course_id, course_name, year, semester, teacher_id, ' \ 'credit, number_of_students, average_grade), teacher as t ' \ 'where tmp.teacher_id = t.teacher_id ' \ 'order by tmp.course_id; ' cursor.execute(sql) result = cursor.fetchall() data['courses'] = [] for row in result: average_grade = row[7] if average_grade is None: average_grade = 0 tmp = {'course_id': row[0], 'course_name': row[1], 'year': row[2], 'semester': row[3], 'teacher_id': row[4], 'credit': row[5], 'number_of_students': row[6], 'average_grade': round(float(average_grade), 2), 'teacher_name': row[8]} data['courses'].append(tmp) except Exception as e: data['error'] = str(e) finally: connection.close() return data
- 添加课程信息
-
def insert_course(course_name, year, semester, teacher_id, credit): connection = connect_to_sql() data = {} try: with connection.cursor() as cursor: course_id = get_new_course_id() if course_id.get('error'): data['error'] = course_id['error'] return data sql = 'insert into course values(\'%s\', \'%s\', \'%s\', \'%s\', \'%s\', %d);' \ % (course_id['course_id'], course_name, year, semester, teacher_id, credit) cursor.execute(sql) connection.commit() except Exception as e: data['error'] = str(e) connection.rollback() finally: connection.close() return data
- 删除课程信息
-
def delete_course(course_id): connection = connect_to_sql() data = {} try: with connection.cursor() as cursor: sql = 'delete from course where course_id = \'%s\'; ' % course_id cursor.execute(sql) connection.commit() except Exception as e: data['error'] = str(e) finally: connection.close() return data
- 修改课程信息
-
def update_course(course_id, course_name, year, semester, teacher_id, credit): connection = connect_to_sql() data = {} try: with connection.cursor() as cursor: sql = 'update course set course_name = \'%s\', year = \'%s\', semester = \'%s\',' \ 'teacher_id = \'%s\', credit = %d where course_id = \'%s\';' \ % (course_name, year, semester, teacher_id, credit, course_id) cursor.execute(sql) connection.commit() except Exception as e: data['error'] = str(e) connection.rollback() finally: connection.close() return data
- 管理员管理专业模块
- 管理专业菜单
-
from app.models.general import connect_to_sql class MajorIdReader: def __init__(self): self.data = read_major_id() class MajorReader: def __init__(self): self.data = read_major() class SingleMajorReader: def __init__(self, major_id): self.data = read_single_major(major_id) class MajorUpdater: def __init__(self, major_id, major_name): self.data = update_major(major_id, major_name) class MajorInserter: def __init__(self, major_name): self.data = insert_major(major_name) class MajorDeleter: def __init__(self, major_id): self.data = delete_major(major_id)
- 管理员查看专业
-
def read_major(): connection = connect_to_sql() data = {} try: with connection.cursor() as cursor: sql = 'select m.major_id, major_name, count(student_id) as number_of_students ' \ 'from major as m left outer join student as s ' \ 'on m.major_id = s.major_id ' \ 'group by m.major_id ' \ 'order by m.major_id;' cursor.execute(sql) result = cursor.fetchall() data['majors'] = [] for row in result: tmp = {'major_id': row[0], 'major_name': row[1], 'number_of_students': row[2]} data['majors'].append(tmp) except Exception as e: data['error'] = str(e) finally: connection.close() return data
- 管理员添加专业
-
def insert_major(major_name): connection = connect_to_sql() data = {} try: with connection.cursor() as cursor: major_id = get_new_major_id() if major_id.get('error'): data['error'] = major_id['error'] return data sql = 'insert into major values(\'%s\', \'%s\');' % (major_id['major_id'], major_name) cursor.execute(sql) connection.commit() except Exception as e: data['error'] = str(e) connection.rollback() finally: connection.close() return data
- 管理员修改专业
-
def update_major(major_id, major_name): connection = connect_to_sql() data = {} try: with connection.cursor() as cursor: sql = 'update major set major_name = \'%s\' where major_id = \'%s\';' % (major_name, major_id) cursor.execute(sql) connection.commit() except Exception as e: data['error'] = str(e) connection.rollback() finally: connection.close() return data
- 管理员删除专业
-
def insert_major_course(major_id, course_id): connection = connect_to_sql() data = {} try: with connection.cursor() as cursor: sql = 'insert into major_course values(\'%s\', \'%s\');' % (major_id, course_id) cursor.execute(sql) """ sql = 'insert into student_course ( select student_id, \'%s\', ' \ 'null from student where major_id = \'%s\');' % (course_id, major_id) cursor.execute(sql) """ connection.commit() except Exception as e: data['error'] = str(e) connection.rollback() finally: connection.close() return data
- 管理员管理专业选课
- 管理选课菜单
-
def insert_major_course(major_id, course_id): connection = connect_to_sql() data = {} try: with connection.cursor() as cursor: sql = 'insert into major_course values(\'%s\', \'%s\');' % (major_id, course_id) cursor.execute(sql) """ sql = 'insert into student_course ( select student_id, \'%s\', ' \ 'null from student where major_id = \'%s\');' % (course_id, major_id) cursor.execute(sql) """ connection.commit() except Exception as e: data['error'] = str(e) connection.rollback() finally: connection.close() return data
- 管理员添加专业选课
-
def insert_major_course(major_id, course_id): connection = connect_to_sql() data = {} try: with connection.cursor() as cursor: sql = 'insert into major_course values(\'%s\', \'%s\');' % (major_id, course_id) cursor.execute(sql) """ sql = 'insert into student_course ( select student_id, \'%s\', ' \ 'null from student where major_id = \'%s\');' % (course_id, major_id) cursor.execute(sql) """ connection.commit() except Exception as e: data['error'] = str(e) connection.rollback() finally: connection.close() return data
- 管理员删除专业选课
-
def delete_major_course(major_id, course_id): connection = connect_to_sql() data = {} try: with connection.cursor() as cursor: """ sql = 'delete from student_course ' \ 'where student_id in ( ' \ 'select student_id ' \ 'from student ' \ 'where major_id = \'%s\') ' \ 'and course_id = \'%s\'; ' % (major_id, course_id) cursor.execute(sql) """ sql = 'delete from major_course ' \ 'where major_id = \'%s\' and course_id = \'%s\' ' % (major_id, course_id) cursor.execute(sql) connection.commit() except Exception as e: data['error'] = str(e) connection.rollback() finally: connection.close() return data
- 管理员查看专业选课
-
def read_major_course(): connection = connect_to_sql() data = {} try: with connection.cursor() as cursor: sql = 'select m.major_id, major_name, c.course_id, course_name ' \ 'from major_course as mc, major as m, course as c ' \ 'where mc.major_id = m.major_id and mc.course_id = c.course_id ' \ 'order by m.major_id, c.course_id;' cursor.execute(sql) result = cursor.fetchall() data['major_courses'] = [] for row in result: tmp = {'major_id': row[0], 'major_name': row[1], 'course_id': row[2], 'course_name': row[3]} data['major_courses'].append(tmp) except Exception as e: data['error'] = str(e) finally: connection.close() return data
第五章 测试与总结
5.1 测试
通过调试，对各个模块的功能进行测试；
5.2 总结
本次实验我是在windows操作系统平台下完成的，应用了MySQL数据库建表，触发，删除插入.......；Python语言中的GUI图形用户界面、通过html+css+js技术进行网站搭建，使用postman等工具进行接口测试，与数据库连接〔jdbc〕等技术。较好的在规定时间内完成了老师安排给我们的任务，实验过程中尽管遇到了不少问题，但最后经过与同伴互相探讨，借阅资料,上网查阅等都使问题得到了解决。总的来说感觉数据库、flask、python语言等编程技术应用起来灵活，容易理解。历尽一个多月课程设计让我对python语言等编程技术产生了浓厚的兴趣，更重要的是增强了我学习的自信心。
我们做的题目是《学生成绩管理系统》按照老师的安排，我们先进行系统需求和系统功能设计，在确定了我们要做的学生成绩管理系统应具有哪些功能后利用visio汇出了管理系统的流程图，并且进一步利用visio的强大功能画出ER图继而生成了物理模型图以及数据库，完成了数据库设计阶段。〔包括需求分析和概要设计〕；在剩下来的几天里我们主要把精力集中在应用程序的调试及课程设计报告的书写上。通过网络、书籍等查找所需的资料。数据库局部的书写〔包括数据库、表、触发器、索引、存储过程等的创立〕以及完成ER图，物理模型图的设计转换局部。
心得与体会：
通过本次课程设计我深切的体会到学习与实践的重要性。第一、在实验的过程中我一边学习一边上机动手操作，才发现自己不懂的太多太多，以前的自己太渺小，我需要不断的在学习中成长。同时也深刻体会到自己需要在动手操作方面努力改良提高。第二、记得老师和学长们总是教导我们要学会请教别人，告诉我们请教别人能在走出社会以后更是显得尤为重要，之前我还有点不以为然，过分的相信自己。通过本次为期一个多月的课程设计我对老师和学长的话坚信不移，最后较好的完成了任务，也从中学到了不少东西。我笃信在以后的学习和成长过程中我会更加注重与他人协作，互助。
参考文献
[1]蒋睿.MySQL数据库安全研究[J].电脑知识与技术,2020,16(09):3-4+21.
[2]王珊.数据库技术与应用［M].北京:清华大学出版社，2005.
[3]贺卉珍.基于配置管理数据库的高可用架构风险发现[J].中国金融电脑
,2020(03):68-74.
[4]郑智方,李彬,刘世坤,李鹏.探究mysql的运用实例-对数据库的宏观把握[J].科技风,2020(06):129.
[5]梁相栋,郭小燕,许亮,郑鑫伟.班级文化信息管理系统的建设与开发[J].甘肃科技,2020,36(04):25-27+39.
[6]杨琳,昌明权.基于MySQL的高校党支部信息管理系统数据库设计[J].电脑知识与技术,2020,16(05):276-277+284.
[7] 洪锦魁 .Python GUI 设计：tkinter 菜鸟编程. 清华大学出版社，2019.
[8] 张晓博.基于 Python 的 SQL Server 海量数据转移的研究与实现[J].铁路计算机应用，2012.
[9]萨师煊 , 王珊 . 数据库系统概论 [M]. 北京 : 高等教育出版社 ,2002.
[10] 乔晶 . 高校学生成绩管理系统设计与实现 [J]. 电脑编程技巧与维护 ,2015(23:59-60.
[11]周文艳.谈学生成绩管理系统中的数据库设计[J].沧州师范专科学校学报, 2006, 6, 22 (2) :65-67