Zum Inhalt

Model-View-Controller in Python

Model-View-Controller (MVC) ist ein Architekturmuster in der Softwareentwicklung, das verwendet wird, um Anwendungen in drei Hauptkomponenten zu strukturieren: das Modell, die Ansicht und den Controller.

graph LR
    Controller -- "Anfrage über Datenänderung" ---> Model
    Controller -- "Auswahl der View" ---> View
    Model -- "Übermittlung der Daten" ---> Controller

Das MVC-Design

Dieses Muster zielt darauf ab, die interne Darstellung von Informationen von den Arten, wie diese Informationen präsentiert und akzeptiert werden, zu trennen. Dadurch wird die Wartbarkeit und Skalierbarkeit der Anwendung verbessert, indem eine klare Trennung der Zuständigkeiten erreicht wird.

graph TB
    User((Nutzer)) -- "Interaktion" --> Controller
    Controller -- "Datenänderung" --> Model
    Controller -- "View-Auswahl" --> View
    Model -- "Datenübermittlung" --> Controller
    View -- "Präsentation" --> User
    Model <--> DB[(Datenbank)]
    style Model stroke:#f83,stroke-width:4px

Das Modell repräsentiert die Daten und die Geschäftslogik der Anwendung. Es hält die Daten des Anwendungsdomäns, die Regeln zur Änderung dieser Daten, die Logik zur Verarbeitung von Benutzerbefehlen und manchmal auch die Funktionalität zur Persistenz dieser Daten.

graph TB
    User((Nutzer)) -- "Interaktion" --> Controller
    Controller -- "Datenänderung" --> Model
    Controller -- "View-Auswahl" --> View
    Model -- "Datenübermittlung" --> Controller
    View -- "Präsentation" --> User
    Model <--> DB[(Datenbank)]
    style View stroke:#f83,stroke-width:4px

Die Ansicht ist verantwortlich für die Darstellung der Daten (des Modells) an den Benutzer. In der Regel gibt es verschiedene Ansichten, um dieselben Daten auf unterschiedliche Weise zu präsentieren. Die Ansicht ändert das Modell nicht direkt, sondern kann eine Aktualisierung anfordern, basierend auf Benutzeraktionen.

graph TB
    User((Nutzer)) -- "Interaktion" --> Controller
    Controller -- "Datenänderung" --> Model
    Controller -- "View-Auswahl" --> View
    Model -- "Datenübermittlung" --> Controller
    View -- "Präsentation" --> User
    Model <--> DB[(Datenbank)]
    style Controller stroke:#f83,stroke-width:4px

Der Controller akzeptiert Eingaben vom Benutzer und führt die erforderlichen Operationen mit diesen Daten aus, indem er das Modell manipuliert oder eine passende Ansicht auswählt, um das Ergebnis der Operation zu präsentieren. Er fungiert als Vermittler zwischen Modell und Ansicht, verarbeitet die Eingaben des Benutzers, manipuliert Daten im Modell und wählt die Ansicht aus, die dem Benutzer angezeigt wird.

MVC fördert die Idee der Wiederverwendung von Code, was die Entwicklung, das Testen und die Wartung von Anwendungen erleichtert. Es ist ein weit verbreitetes Muster und wird in vielen Web- und Desktop-Anwendungen sowie in verschiedenen Programmiersprachen und Frameworks eingesetzt.

Beispiel mit Python

Um das Model-View-Controller Design Pattern in Python umzusetzen, kann man sich entweder reiner Python-Codestrukturen bedienen oder auf Web-Frameworks zurückgreifen, die dieses Design-Pattern unterstützen.

Bei der Implementierung von MVC in reinem Python ohne spezifische Frameworks definieren Sie Klassen für Models, Views und Controller, die miteinander interagieren.

Hier ist ein einfaches Beispiel:

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

class PersonView:
    def display(self, person):
        print(f"Name: {person.name}, Age: {person.age}")

class PersonController:
    def __init__(self, model, view):
        self.model = model
        self.view = view

    def set_person_name(self, name):
        self.model.name = name

    def get_person_name(self):
        return self.model.name

    def set_person_age(self, age):
        self.model.age = age

    def get_person_age(self):
        return self.model.age

    def update_view(self):
        self.view.display(self.model)

Verwendung

model = Person("John Doe", 30)
view = PersonView()
controller = PersonController(model, view)

controller.update_view()

controller.set_person_name("Jane Doe")
controller.set_person_age(25)

controller.update_view()

Web-Frameworks

Für Web-Anwendungen gibt es mehrere Python-Frameworks, die das MVC-Pattern (oder Variationen davon) unterstützen. Zwei beliebte Frameworks sind Django und Flask:

Django

Django folgt einem etwas abgewandelten Design Pattern namens Model-View-Template (MVT), das dem MVC-Konzept ähnelt. Hier repräsentieren Modelle die Datenstruktur, Views1 handhaben die Geschäftslogik und Templates sind für die Präsentation zuständig. Django kümmert sich um die Controller-Logik intern.

Flask

Flask ist ein mikro Web-Framework, das Entwicklern mehr Freiheiten lässt, wie sie ihre Anwendung strukturieren. Es unterstützt MVC durch die Aufteilung der Anwendung in separate Dateien oder Module für Modelle, Ansichten (mit Jinja2 Templates) und Controller (in Flask meist als "routes" bezeichnet).

In beiden Frameworks können Sie das MVC-Design-Pattern nutzen, um sauberen, wartbaren und skalierbaren Code zu schreiben. Die Entscheidung für ein Framework hängt von den spezifischen Anforderungen Ihres Projekts ab.

  1. In der Django-Entwicklung kann die Bezeichnung views.py für Neulinge verwirrend sein, besonders für diejenigen, die mit dem MVC-Design vertraut sind. In Django wird der Begriff "View" anders verwendet als im klassischen MVC-Sinn. Eine Django-View ist verantwortlich für die Entgegennahme von Webanfragen und die Rückgabe von Webantworten. Die Views übernehmen eine Rolle, die eher einem Controller in einem traditionellen MVC-Framework ähnelt, indem sie zwischen den Modellen (Datenbankobjekten) und den Templates (der Präsentationsschicht) vermitteln. Die tatsächliche "Ansicht" im Sinne der Präsentationsschicht wird in Django durch Templates realisiert. Deshalb sollte der Inhalt von views.py in einem Django-Projekt nicht als direkte Entsprechung zu den "Views" im MVC-Pattern interpretiert werden, sondern eher als die Logikschicht, die entscheidet, welche Daten dem Benutzer präsentiert werden und wie auf Benutzeraktionen reagiert wird. ↩