Design Patterns

An dieser Stelle sollen einige hilfreiche Entwurfsmuster („Design Patterns“) und ihre Implementierungen in Python3 vorgestellt werden. [1] Derartige Entwicklungsmuster kann man als „Entwicklungshilfen“ ansehen, da sie bewährte Code-Strukturen für bestimmte Problem-Typen bieten.bestimmte Problem-Typen bieten.

Erzeugungsmuster

Als Erzeugungsmuster („Creational Patterns“) werden Entwurfsprinzipien bezeichnet, die für das Erstellen neuer Objekte hilfreich sein können.

Factory

Als „Factories“ werden Hilfsobjekte bezeichnet, deren Aufgabe es ist, die Erzeugung eines Objekts von seiner Verwendung zu trennen. Man unterscheidet im Allgemeinen zwischen der „Factory Method“ und der „Factory Class“ als zwei verschiedenen Möglichkeiten, dieses Prinzip zu implementieren.

Factory Method

Bei einer „Factory Method“ wird ein neues Objekt durch den Aufruf einer Funktion erzeugt und von dieser als Ergebnis zurückgegeben. Die erzeugende Funktion erstellt das neue Objekt dabei in Abhängigkeit vom Kontext. Beispielsweise kann nach diesem Prinzip eine Funktion read_file() ein Datei-Reader-Objekt in Abhängigkeit vom Dateityp bzw. der Datei-Endung des angegebenen Pfads generieren:

# Factory-Method-Beispiel

class CSV_Reader():

    def __init__(self, path):
        pass

def file_reader(path):

    # Todo: Check if file exists

    if path.endswith(".csv"):
        return CSV_READER(path)
    else:
        return None

csv_reader = file_reader('test.csv')

Soll durch eine Factory Method eine direkte Instanziierung einer Klasse verhindert werden, so kann die Definition dieser Klasse auch innerhalb der Funktionsdefinition erfolgen.

Factory Class

Bei einer „Factory Class“ wird eine Factory-Methode (oder mehrere davon) zu einer Klasse zusammengefasst. Bei Verwendung dieses Patterns kann man beispielsweise eine Klasse names ConnectionCreator mit einer Methode build_connection(connection_type) erstellen, die je nach angegebenem Protokoll-Typ eine SSH- oder FTP-Verbindung zu einem Webserver aufbaut. Strukturell könnte der Code dann folgendermaßen aussehen:

# Factory-Class-Beispiel

# Connection-Klassen:

class SSH_Connection():

    def __init__(self, path):
        pass

class FTP_Connection():

    def __init__(self, path):
        pass


# Factory-Klasse:

class ConnectionCreator():

    def __init__(self, path):
        self.path == path

    def build_connection(self, connection_type, path):

        if connection_type == "HTML":
            return HTML_Connection(path)

        elif connection_type == "SSH":
            return SSH_Connection(path)

        else:
              return None

Nach dem gleichen Prinzip denkbar wäre beispielsweise auch eine DatabaseConnection-Klasse, die eine Verbindung zu einer bestehenden Datenbank herstellen kann, oder gegebenenfalls auch eine neue Datenbank anlegen kann.

Abstract Factory

In der Programmierung werden bisweilen „abstrakte“ Klassen definiert. Diese geben zwar bereits strukturelle Prinzipien vor, es können allerdings noch keine Instanzen einer solchen Klasse erzeugt werden, da konkrete Ausprägungen noch nicht festgelegt sind. Beispielsweise könnte eine abstrakte Klasse ein „Kraftfahrzeug“ sein, das ganz allgemein Methoden wie „Motor starten“ oder „Bremse betätigen“ bereit stellt. Jeder reelle Kraftfahrzeug-Typ, der auf dieser Klasse via Vererbung aufbaut, implementiert diese Funktionen, allerdings konkretisiert auf die konkrete Ausprägung.

Bei Verwendung einer „Abstract Factory“ wird entsprechend ein Factory-Typ mit strukturellen Prinzipien vorgegeben, aus dem wiederum konkrete Factory-Klassen (mittels Vererbung) hervorgehen können. [2] Dieses Pattern kann beispielsweise für ein Computer-Strategiespiel wie 0.A.D genutzt werden, so dass „Gebäude-Typ“ je nach Kultur und Entwicklungsstufe zwar ähnliche, aber nicht komplett identische Objekte generieren kann.

Builder

Das „Builder“-Pattern kann verwendet werden, wenn ein Objekt schrittweise aus einzelnen Komponenten zusammengestellt werden muss. Die einzelnen Komponenten werden dabei durch Factory-Methoden einer (oder mehrerer) „Builder“-Klassen erzeugt. Die Builder-Methoden werden wiederum von einem „Director“-Objekt in der gewünschten Reihenfolge aufgerufen.

Das gewünschte Objekt als Ganzes wird also über den Direktor in Auftrag gegeben, der die Anfrage an den passenden Builder weiter reicht. Ist das Objekt erstellt, kann der Director es wiederum beim Builder abholen und als Ergebnis zurückgeben. Während die einzelnen Builder wiederum „Factories“ darstellen, ist der Director ein steuerndes Element, das kontext-bezogen den relevanten Builder auswählt und gewissermaßen „nach Rezept“ nacheinander dessen Methoden aktiviert.

Prototype

Mittels eines „Prototyps“ kann ein neues Objekt erstellt werden, indem ein bestehendes Objekt als Startpunkt verwendet wird. Um einen Prototypen zu erzeugen, muss also zunächst eine exakte Kopie eines bestehenden Objekts erzeugt werden.

In Python ist dies einfach mittels der Funktion deepcopy() aus dem Paket copy der Standard-Library möglich.

Singleton

Als Singleton bezeichnet man ein Objekt, das innerhalb eines laufenden Programms nur in einer Ausprägung („Instanz“) existieren darf; beispielsweise ist bei jedem Betriebsystem mit grafischer Oberfläche genau ein Window-Manager in Betrieb. Zugleich muss das Singleton-Objekt unter Umständen für viele Stellen zugriffsbereit sein.

Singletons stellen also eine Art von klar definierten „Access Points“ dar, auf die von mehreren Clienten aus zugegriffen werden kann. Ein solches Objekt könnte zwar prinzipiell auch mittels einer globalen Variable initiiert werden, jedoch könnten dabei immer noch mehrere Instanzen des Objekts existieren – man hätte dann zwar das gleiche, aber nicht das selbe Objekt. Zudem soll die Klasse des Grundobjekts durch die Erstellung von Unterklassen erweiterbar sein.

Singleton-Klasse

In Python kann eine Singleton-Klasse folgendermaßen als Klasse implementiert werden:

class Singleton(object):
    def __new__(cls):
        if not hasattr(cls, 'instance'):
            cls.instance = super().__new__(cls)
        return cls.instance

Wird ein solches Objekt initiiert, so wird es nur dann eine neue Instanz des Objekts erzeugt, falls noch keine solche existiert; andernfalls gibt die Initiierung die bereits existierende Instanz als Ergebnis zurück. Auf diese Weise kann man von beliebiger Stelle aus auf das Singleton zugreifen, indem man eine neue Instanz des Singletons erzeugt:

# Ein neues Singleton erzeugen:
singleton_1 = Singleton()

# Das existierende Singleton an anderer Stelle nutzen:
singleton_2 = Singleton()

Jedes Objekt, das ein Singleton darstellen soll, kann damit der obigen Implementierung als Unterklasse eines Singletons definiert werden:

class Any_Singleton_Object(Singleton):
    """
    A Class for a Singleton Object.
    """

    # Class methods and attributes..

Bei der Initiierung eines solchen Objekts wird aufgrund der geerbten __new__()-Funktion nur dann ein neues Objekt (mit allen „Standardeinstellungen“) erstellt, falls ein solches noch nicht existiert. Ansonsten wird dieses mit all seinen Methoden und Attributen genutzt.

Singleton-Module

Die Initiierung eines Objekts ist stets mit etwas Rechenaufwand verbunden. Soll auf ein Singleton häufig und möglichst schnell zugegriffen werden und ist keine Aufgliederung des Singletons in mehrere mögliche Unterklassen nötig, so kann anstatt der oben beschriebenen Klasse auch ein Singleton-Modul erzeugt werden. Dieses Modul, das den Namen des Singletons (in Kleinbuchstaben) als Dateinamen (mit Endung .py) trägt, bekommt „Methoden“ als Funktionen und „Attribute“ als Variablen auf Modulebene zugewiesen – d.h. in diesem Modul werden keine Klassen angelegt.

Da Module nach erstmaligem Importieren durch import modulname stets nur in Form einer Referenz genutzt werden, kann auf die gewünschten Singleton-Methoden unmittelbar mittels modul.funktionsname() und die gewünschten Attribute mittels modul.variable zugegriffen werden.

Strukturmuster

Als Strukturmuster („Structural Patterns“) werden Entwurfsprinzipien bezeichnet, die für das Zusammenwirken mehrerer Objekte im Programm nützlich sein können.

Adapter

Composite

Facade

Ein Facade-Pattern kann genutzt werden, um einem Benutzer ein einfaches, intuitiv nutzbares Interface zu bieten, so dass sich dieser nicht mit den Schnittstellen der einzelnen Klassen eines Programms auseinander setzen muss. In einer solchen „Fassade“ eines Programms sollen also keine neuen Funktionen hinzu kommen, es soll vielmehr der Zugriff auf die eigentlichen Programm-Funktionen erleichtert werden.

Model-View-Controller

Das Prinzip „Model-View-Controller“ soll dabei helfen, die eigentliche Logik des Programms (das „Modell“) von der Datenausgabe (dem „View“) zu trennen.

Der „Controller“ vermittelt als Schnittstelle zwischen diesen Ebenen:

  • Er soll die Eingabe des Benutzers, die ebenfalls in der View-Ebene erfolgt, entgegennehmen und an das Modell weiterleiten.
  • Er soll, nachdem die Eingabe in der Modell-Ebene verarbeitet wurde, die resultierende Ausgabe wieder an die View-Ebene weiterleiten.
Der Controller wirkt wie ein „Kleber“ zwischen der Modell- und der View-Schicht; man sagt entsprechend, der Kontroller solle „dünn“ sein, also nur die für die Vermittlung absolut nötigen Funktionen beinhalten.
Die Modell-Ebene hingegen soll „schlau“ sein, an dieser Stelle sollte also die eigentliche Programm-Logik liegen.
Die View-Ebene wiederum soll „dumm“ sein, also nur die zur Entgegennahme des Inputs und zur Darstellung der Ausgabe nötigen Funktionen (und keine weitere Logik) beinhalten; beispielsweise sollte aus der View-Ebene heraus kein Zugriff auf eine Datenbank erfolgen.

Der Vorteil dieses Entwicklungs-Musters liegt darin, dass das eigentliche Programm von der Benutzeroberfläche abstrahiert wird. Etliche Linux-Programme, aber beispielsweise auch den Python-Interpreter Ipython, gibt es dadurch sowohl als text-basierte Anwendungen für die Shell wie auch als Variante mit einer eigenen graphischen Bedienoberfläche.

Verhaltensmuster

Observer

Das Observer-Muster besteht darin, dass ein bestimmtes Objekt als „Subjekt“ deklariert wird, dass von anderen Objekten „beobachtet“ wird. Das Subjekt verwaltet dabei eine Liste aller Objekte, die es beobachten. Ändert sich eine bestimmte Eigenschaft des Subjekts, dann benachrichtigt es darüber alle Beobachter-Objekte, indem es eine deren Methoden aufruft.

Visitor

… to be continued …