task3.py - master - kristinkaandreeva2002/py-homeworks-basic

task3.py
230 строк9 KB
kristinkaandreeva2002
update task3.py
19 янв 2026, 14:58
19 янв 2026, 14:58966030d
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 _calculate_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 rate_lecture(self, lecturer, course, grade):
        if (isinstance(lecturer, Lecturer) and 
            course in self.courses_in_progress and 
            course in lecturer.courses_attached and
            1 <= grade <= 10):
            
            if hasattr(lecturer, 'grades'):
                if course in lecturer.grades:
                    lecturer.grades[course] += [grade]
                else:
                    lecturer.grades[course] = [grade]
            else:
                lecturer.grades = {course: [grade]}
            
            return None
        else:
            return 'Ошибка'
    
    def __str__(self):
        avg_grade = self._calculate_average_grade()
        courses_in_progress = ', '.join(self.courses_in_progress) if self.courses_in_progress else 'Нет курсов'
        finished_courses = ', '.join(self.finished_courses) if self.finished_courses else 'Нет курсов'
        
        return (f"Имя: {self.name}\n"
                f"Фамилия: {self.surname}\n"
                f"Средняя оценка за домашние задания: {avg_grade:.1f}\n"
                f"Курсы в процессе изучения: {courses_in_progress}\n"
                f"Завершенные курсы: {finished_courses}")
    
    def __lt__(self, other):
        if not isinstance(other, Student):
            return NotImplemented
        return self._calculate_average_grade() < other._calculate_average_grade()
    
    def __le__(self, other):
        if not isinstance(other, Student):
            return NotImplemented
        return self._calculate_average_grade() <= other._calculate_average_grade()
    
    def __eq__(self, other):
        if not isinstance(other, Student):
            return NotImplemented
        return self._calculate_average_grade() == other._calculate_average_grade()
    
    def __ne__(self, other):
        if not isinstance(other, Student):
            return NotImplemented
        return self._calculate_average_grade() != other._calculate_average_grade()
    
    def __gt__(self, other):
        if not isinstance(other, Student):
            return NotImplemented
        return self._calculate_average_grade() > other._calculate_average_grade()
    
    def __ge__(self, other):
        if not isinstance(other, Student):
            return NotImplemented
        return self._calculate_average_grade() >= other._calculate_average_grade()


class Mentor:
    def __init__(self, name, surname):
        self.name = name
        self.surname = surname
        self.courses_attached = []
    
    def __str__(self):
        return f"Имя: {self.name}\nФамилия: {self.surname}"


class Lecturer(Mentor):
    def __init__(self, name, surname):
        super().__init__(name, surname)
        self.grades = {}
    
    def _calculate_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 __str__(self):
        avg_grade = self._calculate_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._calculate_average_grade() < other._calculate_average_grade()
    
    def __le__(self, other):
        if not isinstance(other, Lecturer):
            return NotImplemented
        return self._calculate_average_grade() <= other._calculate_average_grade()
    
    def __eq__(self, other):
        if not isinstance(other, Lecturer):
            return NotImplemented
        return self._calculate_average_grade() == other._calculate_average_grade()
    
    def __ne__(self, other):
        if not isinstance(other, Lecturer):
            return NotImplemented
        return self._calculate_average_grade() != other._calculate_average_grade()
    
    def __gt__(self, other):
        if not isinstance(other, Lecturer):
            return NotImplemented
        return self._calculate_average_grade() > other._calculate_average_grade()
    
    def __ge__(self, other):
        if not isinstance(other, Lecturer):
            return NotImplemented
        return self._calculate_average_grade() >= other._calculate_average_grade()


class Reviewer(Mentor):
    def __init__(self, name, surname):
        super().__init__(name, surname)
    
    def rate_hw(self, student, course, grade):
        if (isinstance(student, Student) and 
            course in self.courses_attached and 
            course in student.courses_in_progress):
            
            if course in student.grades:
                student.grades[course] += [grade]
            else:
                student.grades[course] = [grade]
            
            return None
        else:
            return 'Ошибка'
    
    def __str__(self):
        return super().__str__()  # Используем реализацию из родительского класса


# Создаем объекты
reviewer = Reviewer('Some', 'Buddy')
lecturer = Lecturer('Иван', 'Иванов')
student1 = Student('Ruoy', 'Eman', 'male')
student2 = Student('Ольга', 'Алёхина', 'female')

# Настраиваем курсы
student1.courses_in_progress = ['Python', 'Git']
student1.finished_courses = ['Введение в программирование']
student2.courses_in_progress = ['Python', 'Java']
student2.finished_courses = ['Основы программирования']

lecturer.courses_attached = ['Python']
reviewer.courses_attached = ['Python']

# Выставляем оценки
reviewer.rate_hw(student1, 'Python', 10)
reviewer.rate_hw(student1, 'Python', 9)
reviewer.rate_hw(student1, 'Python', 8)

reviewer.rate_hw(student2, 'Python', 7)
reviewer.rate_hw(student2, 'Python', 6)
reviewer.rate_hw(student2, 'Python', 5)

student1.rate_lecture(lecturer, 'Python', 10)
student1.rate_lecture(lecturer, 'Python', 9)
student2.rate_lecture(lecturer, 'Python', 8)
student2.rate_lecture(lecturer, 'Python', 7)

print("\n1. Вывод информации о Reviewer:")
print(reviewer)

print("\n2. Вывод информации о Lecturer:")
print(lecturer)

print("\n3. Вывод информации о Student 1:")
print(student1)

print("\n4. Вывод информации о Student 2:")
print(student2)

print("\n5. Сравнение лекторов по средней оценке:")
lecturer2 = Lecturer('Петр', 'Петров')
lecturer2.grades = {'Python': [5, 6, 7]}
print(f"Лектор 1 средняя: {lecturer._calculate_average_grade():.1f}")
print(f"Лектор 2 средняя: {lecturer2._calculate_average_grade():.1f}")
print(f"Лектор 1 > Лектор 2: {lecturer > lecturer2}")
print(f"Лектор 1 < Лектор 2: {lecturer < lecturer2}")
print(f"Лектор 1 == Лектор 2: {lecturer == lecturer2}")

print("\n6. Сравнение студентов по средней оценке:")
print(f"Студент 1 средняя: {student1._calculate_average_grade():.1f}")
print(f"Студент 2 средняя: {student2._calculate_average_grade():.1f}")
print(f"Студент 1 > Студент 2: {student1 > student2}")
print(f"Студент 1 < Студент 2: {student1 < student2}")
print(f"Студент 1 == Студент 2: {student1 == student2}")

print("\n7. Другие операторы сравнения:")
print(f"Студент 1 >= Студент 2: {student1 >= student2}")
print(f"Студент 1 <= Студент 2: {student1 <= student2}")
print(f"Студент 1 != Студент 2: {student1 != student2}")

print("\n8. Попытка сравнить разные типы:")
# Используем try-except для корректного отображения ошибки
try:
    result = student1 > lecturer
    print(f"Студент > Лектор: {result}")
except TypeError as e:
    print(f"Студент > Лектор: TypeError - {e}")