Оптимизация кода

import json
from typing import Optional
 
 
class RecordingSystem:
    filename: str
 
    def __init__(self, file: str):
        self.points = []
        self.filename = file
        self.json_old_data = self.load_data()
        self.json_data_write = []
        self.template_dictionary = {}
 
    def load_data(self) -> None:
        try:
            print(self.filename)
            with open(self.filename, 'r') as file:
                data = json.load(file)
        except FileNotFoundError:
            raise FileNotFoundError("Enter the correct file path")
        return data
 
    def enter_users_data(self, first_name: str, last_name: str, name_of_faculty: str, name_of_specialization: str,
                         token: str) -> dict[str, str | dict[str, int]]:
 
        self.template_dictionary = {"first_name": first_name,
                                    "last_name": last_name,
                                    "name_of_faculty": name_of_faculty,
                                    "specialization_name": name_of_specialization,
                                    "token": token
                                    }
        grades_by_semester = {}
        print("Enter grades for the exam, if you have not already entered this course, enter 0.")
        for course in range(1, 5):
            grades_by_semester[f"Course{course}"] = {}
            for semester_num in range(1, 3):
                semester_name = f"Semester{semester_num}"
                grades_by_semester[f"Course{course}"][semester_name] = {}
                grades_by_semester[f"Course{course}"][semester_name]["FirstExam"] = int(
                    input(f"Grade for the first exam {course} course, {semester_name}: "))
                grades_by_semester[f"Course{course}"][semester_name]["SecondExam"] = int(
                    input(f"Grade for the second exam {course} course, {semester_name}: "))
                grades_by_semester[f"Course{course}"][semester_name]["ThirdExam"] = int(
                    input(f"Grade for the third exam {course} course, {semester_name}: "))
 
        self.template_dictionary["grades_by_semester"] = grades_by_semester
 
        return self.template_dictionary
 
    def end_of_recording(self) -> list:
        self.json_data_write.append(self.json_old_data)
        self.json_data_write.append(self.template_dictionary)
        return self.json_data_write
 
    def json_write(self) -> None:
        with open('Dataset_for_coursework.json', 'w') as file:
            json.dump(self.json_data_write, file, indent=4, ensure_ascii=False)
 
 
class EqualSystem(RecordingSystem):
    filename: str
 
    def __init__(self, file: str):
        super().__init__(file)
        self.filename = file
        self.data = self.load_data()
 
    def load_data(self):
        try:
            with open(self.filename, 'r') as file:
                self.data = json.load(file)
        except FileNotFoundError:
            print("Enter the correct file path")
        return self.data
 
    def get_student_by_token(self, token: str) -> Optional[dict]:
        for student in self.data:
            if student["token"] == token:
                return student
        return None
 
    def filter_students_by_faculty(self, faculty: str) -> list[str]:
        students = []
        for student in self.data:
            if student['name_of_faculty'] == faculty:
                students.append(f"имя: {student['first_name']}, фамилия: {student['last_name']}, номер зачётки: "
                                f"{student['token']}")
        return students
 
    def filter_students_by_specialization(self, specialization: str) -> list[str]:
        students = []
        for student in self.data:
            if student['specialization_name'] == specialization:
                students.append(f"имя: {student['first_name']}, фамилия: {student['last_name']}, номер зачётки: "
                                f"{student['token']}")
        return students
 
    def get_students_with_good_grades(self) -> list[str]:
        result = set()
        for student in self.data:
            for course, semesters in student["grades_by_semester"].items():
                for semester, exams in semesters.items():
                    for exam, grade in exams.items():
                        if grade > 0 and grade >= 4:
                            result.add(f"имя: {student['first_name']}, фамилия: {student['last_name']}, номер зачётки: "
                                       f"{student['token']}")
        return list(result)
 
    def get_average_grade_by_faculty(self) -> dict[str, float]:
        average_grades_for_faculty = {}
        for student in self.data:
            faculty = student["name_of_faculty"]
            total_grade = 0
            num_courses = 0
            
            for course, semesters in student["grades_by_semester"].items():
                for semester, exams in semesters.items():
                    for exam, grade in exams.items():
                        if grade > 0:
                            total_grade += grade
                            num_courses += 1
            
            if num_courses > 0:
                average_grade_for_faculty = total_grade / num_courses
                if faculty in average_grades_for_faculty:
                    average_grades_for_faculty[faculty].append(average_grade_for_faculty)
                else:
                    average_grades_for_faculty[faculty] = [average_grade_for_faculty]
                    
        for faculty, grades in average_grades_for_faculty.items():
            average_grade_for_faculty = sum(grades) / len(grades)
            average_grades_for_faculty[faculty] = average_grade_for_faculty
        return average_grades_for_faculty
 
    def get_average_grade_by_specialization(self) -> dict[str, float]:
        average_grades_for_specialization = {}
        for student in self.data:
            specialization = student["specialization_name"]
            total_grade = 0
            num_courses = 0
            
            for course, semesters in student["grades_by_semester"].items():
                for semester, exams in semesters.items():
                    for exam, grade in exams.items():
                        if grade > 0:
                            total_grade += grade
                            num_courses += 1
            
            if num_courses > 0:
                average_grade_for_specialization = total_grade / num_courses
                if specialization in average_grades_for_specialization:
                    average_grades_for_specialization[specialization].append(average_grade_for_specialization)
                else:
                    average_grades_for_specialization[specialization] = [average_grade_for_specialization]
 
        for specialization, grades in average_grades_for_specialization.items():
            average_grade_for_specialization = sum(grades) / len(grades)
            average_grades_for_specialization[specialization] = average_grade_for_specialization
 
        return average_grades_for_specialization
 
 
file = 'C:\\Users\\Lenovo\\PycharmProjects\\pythonProject1\\Dataset_for_coursework.json'
# file = str(input())
 
record = RecordingSystem(file)
ec_sys = EqualSystem(record.filename)
 
while True:
    print('Enter name of function(\033[1;35mEnter\033[0m - enter data, '
          '\033[1;35mRecording\033[0m - recording in json-file, \033[1;35mHandling\033[0m - data handling):')
 
    choose = input()
    match choose:
        case 'Enter':
            ec_sys.load_data()
            first_name = input("Input name of student: ")
            last_name = input("Input surname of student: ")
            name_of_faculty = input("Input name of faculty(Abbreviations remain in your language): ")
            name_of_specialization = input("Input name of specialization: ")
            token = str(input("Enter the student identification number (ID) of your record book: "))
 
            ec_sys.enter_users_data(first_name, last_name, name_of_specialization, name_of_faculty, token)
            ec_sys.end_of_recording()
 
        case 'Recording':
            ec_sys.json_write()
        case 'Handling':
            method_of_grouping = str(input())
            ec_sys.load_data()
            match method_of_grouping:
                case 'Filter by token':
                    token = str(input())
                    print(ec_sys.get_student_by_token(token))
                case 'Filter by faculty':
                    faculty = str(input())
                    print(ec_sys.filter_students_by_faculty(faculty))
                case 'Filter by specialization':
                    specialization = str(input())
                    print(ec_sys.filter_students_by_specialization(specialization))
                case 'Filter by good grade':
                    print(ec_sys.get_students_with_good_grades())
                case 'Average grade by specialization':
                    average_grades_f_s = ec_sys.get_average_grade_by_specialization()
                    for specialization, average_grade in average_grades_f_s.items():
                        print(f"Specialization: {specialization}, average grade: {average_grade}")
                case 'Average grade by faculty':
                    average_grade_f_f = ec_sys.get_average_grade_by_faculty()
                    for faculty, average_grade in average_grade_f_f.items():
                        print(f"Faculty: {faculty}, average grade: {average_grade_f_f}")
                case other:
                    print("Wrong choice")
 
        case other:
            print("Wrong choice")

def __init__(self, file: str):
        super().__init__(file)
        self.filename = file
        self.data = self.load_data() # вот в этой строчке
 
    def load_data(self): # в этой
        try:
            with open(self.filename, 'r') as file:
                self.data = json.load(file) # и вот в этой
        except FileNotFoundError:
            print("Enter the correct file path")
        return self.data