====== LU11.L01 - Schulverwaltung ====== Musterlösung zu [[..:aufgaben:school|LU11.A01 - Schulverwaltung]] (Repository [[https://github.com/templates-python/m450-lu11-a01-school|m450-lu11-a01-school]]). Bei Test Driven Development gibt es nicht **die** eine Lösung. Diese Musterlösung zeigt eine mögliche Umsetzung: zu jeder Klasse zuerst die Tests (Konstruktor zuerst), danach der Produktivcode. Abhängigkeiten zu anderen Klassen werden in den Tests durch einfache Mock-Klassen ersetzt (siehe [[..:mock|LU11b - Mock]]). ===== Hinweise zur Umsetzung ===== * Im Repository heisst die Klasse ''StudentReport'' aus dem Klassendiagramm ''ClassReport'' (Datei ''classreport.py''). Die Lösung behält den Namen aus dem Repository. * Die Methoden ''show_...'' liefern gemäss Klassendiagramm einen **String** zurück. Die Vorlage ''main.py'' ruft noch ''print_student_list()'', ''print_student_report()'' und ''print_details()'' auf. In der Lösung ist ''main.py'' an das Klassendiagramm angepasst und gibt die Strings mit ''print'' aus. * Die Multiplizitäten aus dem Klassendiagramm werden geprüft: höchstens 20 Lernende pro Klasse und höchstens 4 Noten pro Fach. Wird die Grenze überschritten, löst die Methode einen ''IndexError'' aus. * ''Grade'' ist eine ''@dataclass''. Die Prüfung des Werts (1 bis 6) und die Umwandlung des Datums aus einem String erfolgen in ''%%__setattr__%%'', damit sie sowohl im Konstruktor als auch beim späteren Setzen greifen. ===== Ergebnis ===== $ pytest -q ............................... 31 passed $ python _run_pylint.py Your code has been rated at 10.00/10 ===== Code ===== ==== grade.py ==== """ Eine Note mit Wert und Datum """ from dataclasses import dataclass from datetime import datetime @dataclass class Grade: """ Eine Note zwischen 1.0 und 6.0 mit dem Datum der Prüfung :raises ValueError: wenn der Wert ausserhalb von 1 bis 6 liegt oder das Datum ungültig ist """ value: float = -1.0 date: datetime = None def __setattr__(self, name, value): if name == 'value': if not 1.0 <= value <= 6.0: raise ValueError('Die Note muss zwischen 1 und 6 liegen') if name == 'date' and isinstance(value, str): value = datetime.strptime(value, '%d.%m.%y') super().__setattr__(name, value) ==== test_grade.py ==== """ Unit Tests für Grade """ from datetime import datetime import pytest from grade import Grade def test_init(): """ Konstruktor mit Datum als Text """ grade = Grade(4.5, '1.2.25') assert grade.value == 4.5 assert grade.date == datetime(2025, 2, 1) def test_init_datetime(): """ Konstruktor mit Datum als datetime """ grade = Grade(6.0, datetime(2025, 3, 1)) assert grade.date == datetime(2025, 3, 1) @pytest.mark.parametrize('value', [1.0, 6.0]) def test_value_limits(value): """ Grenzwerte 1.0 und 6.0 sind gültig """ assert Grade(value, '1.1.25').value == value @pytest.mark.parametrize('value', [0.9, 6.1]) def test_value_invalid(value): """ Werte ausserhalb von 1 bis 6 werden abgelehnt """ with pytest.raises(ValueError): Grade(value, '1.1.25') def test_set_value_invalid(): """ Auch der Setter prüft den Wert """ grade = Grade(4.0, '1.1.25') with pytest.raises(ValueError): grade.value = 7.0 assert grade.value == 4.0 def test_date_invalid(): """ Ein ungültiges Datum wird abgelehnt """ with pytest.raises(ValueError): Grade(4.0, '31.2.25') ==== subject.py ==== """ Ein Schulfach mit seinen Noten """ class Subject: """ Ein Fach mit höchstens 4 Noten """ MAX_GRADES = 4 def __init__(self, name): self._name = name self._grades = [] def add_grade(self, grade): """ Fügt eine Note hinzu :param grade: die Note :raises IndexError: wenn das Fach bereits 4 Noten hat """ if len(self._grades) >= self.MAX_GRADES: raise IndexError('Ein Fach hat höchstens 4 Noten') self._grades.append(grade) def take_grade(self, index): """ Liefert die Note an der Position index :param index: die Position :return: die Note """ return self._grades[index] def count_grades(self): """ Liefert die Anzahl Noten """ return len(self._grades) @property def average(self): """ Der Durchschnitt aller Noten, 0.0 wenn keine Note vorhanden ist """ if not self._grades: return 0.0 total = 0.0 for grade in self._grades: total += grade.value return total / len(self._grades) @property def name(self): """ Der Name des Fachs """ return self._name ==== test_subject.py ==== """ Unit Tests für Subject – Grade wird durch einen Mock ersetzt """ import pytest from subject import Subject class GradeMock: # pylint: disable=too-few-public-methods """ Mock für Grade: nur der Wert wird gebraucht """ def __init__(self, value): self.value = value @pytest.fixture(name='subject') def fixture_subject(): """ Ein Fach ohne Noten """ return Subject('Mathe') def test_init(subject): """ Konstruktor """ assert subject.name == 'Mathe' assert subject.count_grades() == 0 def test_add_take_grade(subject): """ Noten hinzufügen und wieder lesen """ first = GradeMock(4.0) second = GradeMock(5.5) subject.add_grade(first) subject.add_grade(second) assert subject.count_grades() == 2 assert subject.take_grade(1) is second def test_add_grade_too_many(subject): """ Ein Fach hat höchstens 4 Noten """ for value in [4.0, 4.5, 5.0, 5.5]: subject.add_grade(GradeMock(value)) with pytest.raises(IndexError): subject.add_grade(GradeMock(6.0)) assert subject.count_grades() == 4 def test_take_grade_invalid(subject): """ Eine Position ohne Note """ with pytest.raises(IndexError): subject.take_grade(0) def test_average(subject): """ Durchschnitt mehrerer Noten """ for value in [4.0, 4.5, 5.5]: subject.add_grade(GradeMock(value)) assert subject.average == pytest.approx(4.6667, abs=0.0001) def test_average_empty(subject): """ Ohne Noten ist der Durchschnitt 0.0 """ assert subject.average == 0.0 ==== classreport.py ==== """ Das Zeugnis eines Lernenden (im Klassendiagramm: StudentReport) """ class ClassReport: """ Ein Zeugnis mit den Fächern eines Lernenden """ def __init__(self): self._subjects = [] self._student = None def show_overview(self): """ Liefert das Zeugnis mit allen Fächern und dem Notenschnitt :return: das Zeugnis als Text """ lines = [] for subject in self._subjects: lines.append(f'{subject.name:<10}{subject.average:4.1f}') return '\n'.join(lines) def show_details(self): """ Liefert alle Fächer mit den einzelnen Noten :return: die Noten als Text """ lines = [] for subject in self._subjects: grades = [] for index in range(subject.count_grades()): grades.append(f'{subject.take_grade(index).value:3.1f}') separator = ' ' lines.append(f'{subject.name:<10}{separator.join(grades)}') return '\n'.join(lines) def add_subject(self, subject): """ Fügt ein Fach hinzu """ self._subjects.append(subject) def take_subject(self, index): """ Liefert das Fach an der Position index """ return self._subjects[index] def count_subjects(self): """ Liefert die Anzahl Fächer """ return len(self._subjects) @property def student(self): """ Der Lernende, dem das Zeugnis gehört """ return self._student @student.setter def student(self, student): self._student = student ==== test_classreport.py ==== """ Unit Tests für ClassReport – Subject und Student werden durch Mocks ersetzt """ import pytest from classreport import ClassReport class GradeMock: # pylint: disable=too-few-public-methods """ Mock für Grade """ def __init__(self, value): self.value = value class SubjectMock: """ Mock für Subject mit fixen Noten """ def __init__(self, name, values): self.name = name self.grades = [GradeMock(value) for value in values] self.average = sum(values) / len(values) def count_grades(self): """ Anzahl Noten """ return len(self.grades) def take_grade(self, index): """ Note an der Position index """ return self.grades[index] @pytest.fixture(name='report') def fixture_report(): """ Ein Zeugnis mit zwei Fächern """ report = ClassReport() report.add_subject(SubjectMock('Mathe', [4.0, 5.0])) report.add_subject(SubjectMock('Deutsch', [5.5, 6.0])) return report def test_init(): """ Konstruktor: leeres Zeugnis ohne Lernenden """ report = ClassReport() assert report.count_subjects() == 0 assert report.student is None def test_add_take_subject(report): """ Fächer hinzufügen und lesen """ assert report.count_subjects() == 2 assert report.take_subject(1).name == 'Deutsch' def test_take_subject_invalid(report): """ Eine Position ohne Fach """ with pytest.raises(IndexError): report.take_subject(2) def test_student(report): """ Setter und Getter für den Lernenden """ student = object() report.student = student assert report.student is student def test_show_overview(report): """ Übersicht mit Fach und Schnitt """ assert report.show_overview() == 'Mathe 4.5\nDeutsch 5.8' def test_show_details(report): """ Details mit allen Noten """ assert report.show_details() == 'Mathe 4.0 5.0\nDeutsch 5.5 6.0' ==== student.py ==== """ Ein Lernender mit seinem Zeugnis """ class Student: """ Ein Lernender gehört zu einer Klasse und hat ein Zeugnis """ def __init__(self, name, report): self._name = name self._school_class = None self._report = report report.student = self def show_report(self): """ Liefert die Übersicht des Zeugnisses """ return self._report.show_overview() @property def name(self): """ Der Name des Lernenden """ return self._name @property def school_class(self): """ Die Klasse des Lernenden """ return self._school_class @school_class.setter def school_class(self, school_class): self._school_class = school_class @property def report(self): """ Das Zeugnis des Lernenden """ return self._report ==== test_student.py ==== """ Unit Tests für Student – das Zeugnis wird durch einen Mock ersetzt """ import pytest from student import Student class ReportMock: # pylint: disable=too-few-public-methods """ Mock für ClassReport """ def __init__(self): self.student = None def show_overview(self): """ Liefert immer denselben Text """ return 'Übersicht' @pytest.fixture(name='report') def fixture_report(): """ Ein leeres Zeugnis """ return ReportMock() def test_init(report): """ Konstruktor: Name, Zeugnis, noch keine Klasse """ student = Student('Pia', report) assert student.name == 'Pia' assert student.report is report assert student.school_class is None def test_init_links_report(report): """ Das Zeugnis kennt danach seinen Lernenden """ student = Student('Pia', report) assert report.student is student def test_school_class(report): """ Setter und Getter für die Klasse """ student = Student('Pia', report) school_class = object() student.school_class = school_class assert student.school_class is school_class def test_show_report(report): """ show_report liefert die Übersicht des Zeugnisses """ assert Student('Pia', report).show_report() == 'Übersicht' ==== school_class.py ==== """ Eine Schulklasse mit ihren Lernenden """ class SchoolClass: """ Eine Klasse mit höchstens 20 Lernenden """ MAX_STUDENTS = 20 def __init__(self, designation): self._designation = designation self._students = [] def add_student(self, student): """ Nimmt einen Lernenden in die Klasse auf :param student: der Lernende :raises IndexError: wenn die Klasse bereits 20 Lernende hat """ if len(self._students) >= self.MAX_STUDENTS: raise IndexError('Eine Klasse hat höchstens 20 Lernende') self._students.append(student) student.school_class = self def take_student(self, index): """ Liefert den Lernenden an der Position index """ return self._students[index] def count_students(self): """ Liefert die Anzahl Lernende """ return len(self._students) def show_student_list(self): """ Liefert die Klassenliste: die Bezeichnung und alle Namen """ lines = [f'Klasse {self._designation}'] for student in self._students: lines.append(student.name) return '\n'.join(lines) def show_student_report(self, name): """ Liefert das Zeugnis eines Lernenden :param name: der Name des Lernenden :return: das Zeugnis oder eine Meldung, wenn der Name unbekannt ist """ for student in self._students: if student.name == name: return student.show_report() return f'{name} ist nicht in der Klasse {self._designation}' @property def designation(self): """ Die Bezeichnung der Klasse """ return self._designation ==== test_school_class.py ==== """ Unit Tests für SchoolClass – Student wird durch einen Mock ersetzt """ import pytest from school_class import SchoolClass class StudentMock: # pylint: disable=too-few-public-methods """ Mock für Student """ def __init__(self, name): self.name = name self.school_class = None def show_report(self): """ Liefert einen Text mit dem Namen """ return f'Zeugnis {self.name}' @pytest.fixture(name='school_class') def fixture_school_class(): """ Eine Klasse mit zwei Lernenden """ school_class = SchoolClass('IM25a') school_class.add_student(StudentMock('Max')) school_class.add_student(StudentMock('Pia')) return school_class def test_init(): """ Konstruktor: Bezeichnung, keine Lernenden """ school_class = SchoolClass('IM25a') assert school_class.designation == 'IM25a' assert school_class.count_students() == 0 def test_add_take_student(school_class): """ Lernende hinzufügen und lesen """ assert school_class.count_students() == 2 assert school_class.take_student(1).name == 'Pia' def test_add_student_sets_class(school_class): """ Der Lernende kennt danach seine Klasse """ assert school_class.take_student(0).school_class is school_class def test_add_student_full(): """ Eine Klasse hat höchstens 20 Lernende """ school_class = SchoolClass('IM25a') for number in range(20): school_class.add_student(StudentMock(f'S{number}')) with pytest.raises(IndexError): school_class.add_student(StudentMock('Zuviel')) assert school_class.count_students() == 20 def test_show_student_list(school_class): """ Klassenliste mit Bezeichnung und Namen """ assert school_class.show_student_list() == 'Klasse IM25a\nMax\nPia' def test_show_student_report(school_class): """ Zeugnis eines bekannten Lernenden """ assert school_class.show_student_report('Pia') == 'Zeugnis Pia' def test_show_student_report_unknown(school_class): """ Unbekannter Name """ assert school_class.show_student_report('Theo') == 'Theo ist nicht in der Klasse IM25a' ==== main.py ==== """ Zeigt, wie die Klassen der Schulverwaltung zusammenspielen """ from classreport import ClassReport from student import Student from school_class import SchoolClass from subject import Subject from grade import Grade def create_subject_list(actual_report): """ Fügt einem Zeugnis die drei Fächer hinzu """ actual_report.add_subject(Subject('Mathe')) actual_report.add_subject(Subject('Deutsch')) actual_report.add_subject(Subject('Turnen')) def add_grades(report, values): """ Fügt die Noten pro Fach hinzu: values ist eine Liste mit einer Liste pro Fach """ for index, subject_values in enumerate(values): for value in subject_values: report.take_subject(index).add_grade(Grade(value, '1.1.25')) def main(): """ Erstellt eine Klasse mit drei Lernenden und gibt die Zeugnisse aus """ the_class = SchoolClass('IM993a') reports = {} for name in ['Max', 'Pia', 'Cem']: reports[name] = ClassReport() create_subject_list(reports[name]) the_class.add_student(Student(name, reports[name])) print(the_class.show_student_list()) add_grades(reports['Max'], [[4.0, 4.5], [4.0, 6.0, 5.0], [4.5, 5.0, 5.0, 5.5]]) add_grades(reports['Pia'], [[5.5, 5.5], [4.5, 6.0, 5.5], [4.0, 5.5, 6.0, 5.5]]) add_grades(reports['Cem'], [[5.0, 3.5], [5.5, 6.0, 5.0], [4.5, 6.0, 6.0, 5.5]]) for name in ['Max', 'Pia', 'Cem', 'Theo']: print(the_class.show_student_report(name)) print(reports['Cem'].show_details()) if __name__ == '__main__': main() ---- {{tag>M450-LU11 M450-C2I M450-C1A}} [[https://creativecommons.org/licenses/by-nc-sa/4.0/|{{https://i.creativecommons.org/l/by-nc-sa/4.0/88x31.png}}]] Marcel Suter