====== 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