oop_homework_4.py

[anton216216]

class Student:
def init(self, name, surname, gender):
self.name = name
self.surname = surname
self.gender = gender
self.finished_courses = []
self.courses_in_progress = []
self.grades = {}

def rate_lecture(self, lecturer, course, grade):
    if not isinstance(lecturer, Lecturer):
        return "Ошибка: можно оценивать только лекторов"
    
    if course not in self.courses_in_progress:
        return "Ошибка: студент не записан на этот курс"
    
    if course not in lecturer.courses_attached:
        return "Ошибка: лектор не ведет этот курс"
    
    if not (0 <= grade <= 10):
        return "Ошибка: оценка должна быть от 0 до 10"
    
    if course not in lecturer.grades:
        lecturer.grades[course] = []
    lecturer.grades[course].append(grade)
    return None

def get_average_grade(self):
    if not self.grades:
        return 0
    all_grades = []
    for course_grades in self.grades.values():
        all_grades.extend(course_grades)
    return sum(all_grades) / len(all_grades)

def get_average_grade_by_course(self, course):
    if course not in self.grades or not self.grades[course]:
        return 0
    return sum(self.grades[course]) / len(self.grades[course])

def __str__(self):
    courses_in_progress_str = ', '.join(self.courses_in_progress) if self.courses_in_progress else 'Нет курсов'
    finished_courses_str = ', '.join(self.finished_courses) if self.finished_courses else 'Нет завершенных курсов'
    avg_grade = self.get_average_grade()
    return (f"Имя: {self.name}\n"
            f"Фамилия: {self.surname}\n"
            f"Средняя оценка за домашние задания: {avg_grade:.1f}\n"
            f"Курсы в процессе изучения: {courses_in_progress_str}\n"
            f"Завершенные курсы: {finished_courses_str}")

def __lt__(self, other):
    if not isinstance(other, Student):
        return NotImplemented
    return self.get_average_grade() < other.get_average_grade()

def __le__(self, other):
    if not isinstance(other, Student):
        return NotImplemented
    return self.get_average_grade() <= other.get_average_grade()

def __eq__(self, other):
    if not isinstance(other, Student):
        return NotImplemented
    return self.get_average_grade() == other.get_average_grade()

def __ne__(self, other):
    if not isinstance(other, Student):
        return NotImplemented
    return self.get_average_grade() != other.get_average_grade()

def __gt__(self, other):
    if not isinstance(other, Student):
        return NotImplemented
    return self.get_average_grade() > other.get_average_grade()

def __ge__(self, other):
    if not isinstance(other, Student):
        return NotImplemented
    return self.get_average_grade() >= other.get_average_grade()

class Mentor:
def init(self, name, surname):
self.name = name
self.surname = surname
self.courses_attached = []

class Lecturer(Mentor):
def init(self, name, surname):
super().init(name, surname)
self.grades = {}

def get_average_grade(self):
    if not self.grades:
        return 0
    all_grades = []
    for course_grades in self.grades.values():
        all_grades.extend(course_grades)
    return sum(all_grades) / len(all_grades)

def get_average_grade_by_course(self, course):
    if course not in self.grades or not self.grades[course]:
        return 0
    return sum(self.grades[course]) / len(self.grades[course])

def __str__(self):
    avg_grade = self.get_average_grade()
    return (f"Имя: {self.name}\n"
            f"Фамилия: {self.surname}\n"
            f"Средняя оценка за лекции: {avg_grade:.1f}")

def __lt__(self, other):
    if not isinstance(other, Lecturer):
        return NotImplemented
    return self.get_average_grade() < other.get_average_grade()

def __le__(self, other):
    if not isinstance(other, Lecturer):
        return NotImplemented
    return self.get_average_grade() <= other.get_average_grade()

def __eq__(self, other):
    if not isinstance(other, Lecturer):
        return NotImplemented
    return self.get_average_grade() == other.get_average_grade()

def __ne__(self, other):
    if not isinstance(other, Lecturer):
        return NotImplemented
    return self.get_average_grade() != other.get_average_grade()

def __gt__(self, other):
    if not isinstance(other, Lecturer):
        return NotImplemented
    return self.get_average_grade() > other.get_average_grade()

def __ge__(self, other):
    if not isinstance(other, Lecturer):
        return NotImplemented
    return self.get_average_grade() >= other.get_average_grade()

class Reviewer(Mentor):
def init(self, name, surname):
super().init(name, surname)

def rate_hw(self, student, course, grade):
    if course not in self.courses_attached:
        return "Ошибка: ревьюер не прикреплен к этому курсу"
    
    if course not in student.courses_in_progress:
        return "Ошибка: студент не изучает этот курс"
    
    if course not in student.grades:
        student.grades[course] = []
    student.grades[course].append(grade)
    return None

def __str__(self):
    return f"Имя: {self.name}\nФамилия: {self.surname}"

Функции для подсчета средних оценок

def calculate_average_hw_grade(students, course):
"""Подсчет средней оценки за домашние задания по всем студентам в рамках конкретного курса"""
total_grades = []
for student in students:
if course in student.grades:
total_grades.extend(student.grades[course])

if not total_grades:
    return 0
return sum(total_grades) / len(total_grades)

def calculate_average_lecture_grade(lecturers, course):
"""Подсчет средней оценки за лекции всех лекторов в рамках курса"""
total_grades = []
for lecturer in lecturers:
if course in lecturer.grades:
total_grades.extend(lecturer.grades[course])

if not total_grades:
    return 0
return sum(total_grades) / len(total_grades)

Создание экземпляров

Лекторы

lecturer1 = Lecturer('Иван', 'Иванов')
lecturer2 = Lecturer('Петр', 'Петров')

Ревьюеры

reviewer1 = Reviewer('Сергей', 'Сергеев')
reviewer2 = Reviewer('Анна', 'Аннова')

Студенты

student1 = Student('Ольга', 'Алёхина', 'Ж')
student2 = Student('Алексей', 'Смирнов', 'М')

Настройка курсов

student1.courses_in_progress = ['Python', 'Git', 'Java']
student1.finished_courses = ['Введение в программирование']

student2.courses_in_progress = ['Python', 'C++', 'Git']
student2.finished_courses = ['Основы алгоритмов']

lecturer1.courses_attached = ['Python', 'Git']
lecturer2.courses_attached = ['Python', 'Java', 'C++']

reviewer1.courses_attached = ['Python', 'Git']
reviewer2.courses_attached = ['Java', 'C++']

Вызов методов

print("=== ВЫСТАВЛЕНИЕ ОЦЕНОК СТУДЕНТАМ ===")
print(reviewer1.rate_hw(student1, 'Python', 9))
print(reviewer1.rate_hw(student1, 'Python', 8))
print(reviewer1.rate_hw(student1, 'Git', 10))
print(reviewer1.rate_hw(student2, 'Python', 7))
print(reviewer1.rate_hw(student2, 'Git', 9))

print(reviewer2.rate_hw(student1, 'Java', 8))
print(reviewer2.rate_hw(student2, 'C++', 6))
print(reviewer2.rate_hw(student1, 'C++', 7)) # Ошибка: студент не изучает курс

print("\n=== ВЫСТАВЛЕНИЕ ОЦЕНОК ЛЕКТОРАМ ===")
print(student1.rate_lecture(lecturer1, 'Python', 9))
print(student1.rate_lecture(lecturer1, 'Python', 10))
print(student1.rate_lecture(lecturer1, 'Git', 8))
print(student1.rate_lecture(lecturer2, 'Java', 9))

print(student2.rate_lecture(lecturer1, 'Python', 8))
print(student2.rate_lecture(lecturer2, 'Python', 7))
print(student2.rate_lecture(lecturer2, 'C++', 9))
print(student2.rate_lecture(lecturer1, 'Java', 8)) # Ошибка: лектор не ведет курс

Вывод информации о всех участниках

print("\n" + "="*50)
print("ИНФОРМАЦИЯ О ВСЕХ УЧАСТНИКАХ")
print("="*50)

print("\n=== РЕВЬЮЕРЫ ===")
print("Reviewer 1:")
print(reviewer1)
print("\nReviewer 2:")
print(reviewer2)

print("\n=== ЛЕКТОРЫ ===")
print("Lecturer 1:")
print(lecturer1)
print("\nLecturer 2:")
print(lecturer2)

print("\n=== СТУДЕНТЫ ===")
print("Student 1:")
print(student1)
print("\nStudent 2:")
print(student2)

Сравнение

print("\n" + "="*50)
print("СРАВНЕНИЕ")
print("="*50)

print(f"lecturer1 > lecturer2: {lecturer1 > lecturer2}")
print(f"lecturer1 < lecturer2: {lecturer1 < lecturer2}")
print(f"student1 == student2: {student1 == student2}")
print(f"student1 >= student2: {student1 >= student2}")

Подсчет средних оценок по курсам

print("\n" + "="*50)
print("СРЕДНИЕ ОЦЕНКИ ПО КУРСАМ")
print("="*50)

students_list = [student1, student2]
lecturers_list = [lecturer1, lecturer2]

courses = ['Python', 'Git', 'Java', 'C++']

for course in courses:
avg_hw = calculate_average_hw_grade(students_list, course)
avg_lecture = calculate_average_lecture_grade(lecturers_list, course)
print(f"\nКурс: {course}")
print(f"Средняя оценка за домашние задания: {avg_hw:.2f}")
print(f"Средняя оценка за лекции: {avg_lecture:.2f}")

Дополнительная проверка методов

print("\n" + "="*50)
print("ДОПОЛНИТЕЛЬНАЯ ПРОВЕРКА")
print("="*50)

print(f"Средняя оценка студента1 по Python: {student1.get_average_grade_by_course('Python'):.2f}")
print(f"Средняя оценка лектора1 по Python: {lecturer1.get_average_grade_by_course('Python'):.2f}")