Was ist der beste Weg, einen Singleton in Python zu implementieren?

Der beste Weg, einen Singleton in Python zu implementieren

Obwohl die Vor- und Nachteile des Singleton-Entwurfsmusters nicht im Mittelpunkt dieses Artikels stehen, wird in diesem Artikel untersucht, wie um den Singleton bestmöglich in Python zu implementieren. Implementieren Sie dieses Muster auf pythonische Weise. „am pythonischsten“ bedeutet hier, dem „Prinzip der geringsten Überraschung“ zu folgen.

Implementierungsmethode

Methode 1: Dekorateur

def singleton(class_):
    instances = {}

    def getinstance(*args, **kwargs):
        if class_ not in instances:
            instances[class_] = class_(*args, **kwargs)
        return instances[class_]

    return getinstance

@singleton
class MyClass(BaseClass):
    pass

Vorteile:

• Der Dekorateur hat zusätzliches Geschlecht, intuitiver als Mehrfachvererbung.

Nachteile:

• Das mit MyClass() erstellte Objekt ist ein echtes Singleton-Objekt, aber MyClass selbst ist eine Funktion, keine Klasse. Daher können Klassenmethoden nicht aufgerufen werden.

Methode 2: Basisklasse

class Singleton(object):
    _instance = None

    def __new__(class_, *args, **kwargs):
        if not isinstance(class_._instance, class_):
            class_._instance = object.__new__(class_, *args, **kwargs)
        return class_._instance

class MyClass(Singleton, BaseClass):
    pass

Vorteile:

• Es ist eine echte Klasse.

Nachteile:

• Mehrfachvererbung, unangenehm. Beim Erben von einer zweiten Basisklasse kann __new__ überschrieben werden.

Methode 3: Metaklasse

class Singleton(type):
    _instances = {}

    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
        return cls._instances[cls]

# Python2
class MyClass(BaseClass):
    __metaclass__ = Singleton

# Python3
class MyClass(BaseClass, metaclass=Singleton):
    pass

Vorteile:

• Es ist eine echte Klasse.
• Die Erbschaft ist automatisch abgedeckt.
• Verwenden Sie __metaclass__ richtig (und machen Sie es mir verständlich).

Nachteile:

• Keine Nachteile.

Methode 4: Geben Sie den Dekorateur der Klasse mit demselben Namen zurück

def singleton(class_):
    class class_w(class_):
        _instance = None

        def __new__(class_, *args, **kwargs):
            if class_w._instance is None:
                class_w._instance = super(class_w, class_).__new__(class_, *args, **kwargs)
                class_w._instance._sealed = False
            return class_w._instance

        def __init__(self, *args, **kwargs):
            if self._sealed:
                return
            super(class_w, self).__init__(*args, **kwargs)
            self._sealed = True

    class_w.__name__ = class_.__name__
    return class_w

@singleton
class MyClass(BaseClass):
    pass

Vorteile:

• Das ist es eine echte Klasse.
• Die Erbschaft ist automatisch abgedeckt.

Nachteile:

• Ist das Erstellen von zwei Klassen für jede Klasse, aus der Sie ein Singleton werden möchten, mit einem Mehraufwand verbunden? Obwohl dies in meinem Fall gut funktioniert, befürchte ich, dass es möglicherweise nicht skaliert werden kann. Was ist der Zweck des Attributs
• _sealed?
• Sie können super() nicht verwenden, um Methoden mit demselben Namen in einer Basisklasse aufzurufen, da diese rekursiv wären. Dies bedeutet, dass __new__ weder angepasst werden kann, noch kann eine Klasse, die den Aufruf von __init__ erfordert, in eine Unterklasse unterteilt werden.

Methode 5: Modul

Singleton-Modul singleton.py.

Vorteile:

• Einfach ist besser als komplex.

Nachteile:

• Keine verzögerte Instanziierung.

Empfohlene Methode

Ich empfehle die Verwendung von Methode 2, aber es ist besser, Metaklassen anstelle von Basisklassen zu verwenden. Hier ist eine Beispielimplementierung:

class Singleton(type):
    _instances = {}

    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
        return cls._instances[cls]

class Logger(object):
    __metaclass__ = Singleton

Oder in Python3:

class Logger(metaclass=Singleton):
    pass

Wenn Sie möchten, dass __init__ jedes Mal ausgeführt wird, wenn eine Klasse aufgerufen wird, fügen Sie den folgenden Code zu Singleton.__call__ In hinzu die if-Anweisung:

def singleton(class_):
    instances = {}

    def getinstance(*args, **kwargs):
        if class_ not in instances:
            instances[class_] = class_(*args, **kwargs)
        return instances[class_]

    return getinstance

@singleton
class MyClass(BaseClass):
    pass

Die Rolle der Metaklasse

Eine Metaklasse ist eine Klasse von Klassen, das heißt, eine Klasse ist eine Instanz ihrer Metaklasse. Die Metaklasse eines Objekts in Python kann über type(obj) gefunden werden. Normale neue Klassen sind vom Typ type. Der obige Logger wird vom Typ Klasse „your_module.Singleton“ sein, genau wie die (einzige) Instanz von Logger vom Typ Klasse „your_module.Logger“ sein wird. Wenn ein Logger mit Logger() aufgerufen wird, fragt Python zunächst die Metaklasse Singleton des Loggers, was sie tun soll, um eine präventive Instanzerstellung zu ermöglichen. Der Vorgang ähnelt der Art und Weise, wie Python eine Klasse fragt, was sie mit ihren Attributen tun soll, indem sie __getattr__ aufruft, und Sie auf ihre Attribute verweisen, indem Sie myclass.attribute ausführen.

Metaklassen bestimmen im Wesentlichen, was die aufrufende Klasse bedeutet und wie diese Bedeutung implementiert wird. Siehe z. B. http://code.activestate.com/recipes/498149/, das Metaklassen verwendet, um im Wesentlichen Strukturen im C-Stil in Python neu zu erstellen. Diskussionsthread [Was sind die spezifischen Anwendungsfälle für Metaklassen? ](https://codereview.stackexchange.com/questions/82786/what-are-some-concrete-use-cases-for-metaclasses) bietet auch einige Beispiele, die sich im Allgemeinen auf die deklarative Programmierung beziehen, insbesondere in ORM, das in verwendet wird .

Wenn Sie in diesem Fall Ihre Methode 2 verwenden und eine Unterklasse eine __new__-Methode definiert, wird diese jedes Mal ausgeführt, wenn SubClassOfSingleton() aufgerufen wird, da sie für den Aufruf von Methoden verantwortlich ist Gespeicherte Instanzen zurückgeben. Bei Metaklassen wird es nur einmal ausgeführt, wenn die eindeutige Instanz erstellt wird. Sie müssen die Definition der aufrufenden Klasse anpassen, die durch ihren Typ bestimmt wird.

Im Allgemeinen ist es sinnvoll, Metaklassen zur Implementierung von Singletons zu verwenden. Ein Singleton ist etwas Besonderes, da seine Instanz nur einmal erstellt wird, während eine Metaklasse eine benutzerdefinierte Implementierung einer erstellten Klasse ist, die dafür sorgt, dass sie sich anders verhält als eine normale Klasse. Durch die Verwendung von Metaklassen erhalten Sie mehr Kontrolle, wenn Sie andernfalls Ihre Singleton-Klassendefinition anpassen müssten.

Natürlich

Ihr Singleton benötigt keine Mehrfachvererbung (da die Metaklasse keine Basisklasse ist), aber damit die Vererbung eine Unterklasse einer Klasse erstellen kann, müssen Sie sicherstellen, dass der Singleton vorhanden ist Klasse ist die erste/ Die Metaklasse ganz links definiert __call__ neu. Es ist unwahrscheinlich, dass dies ein Problem darstellt. Das Instanzwörterbuch befindet sich nicht im Namensraum der Instanz und kann daher nicht versehentlich überschrieben werden.

Sie werden auch hören, dass das Singleton-Muster gegen das „Prinzip der Einzelverantwortung“ verstößt, was bedeutet, dass jede Klasse nur eine Sache tun sollte. Auf diese Weise müssen Sie sich keine Sorgen darüber machen, dass eine Funktion des Codes beschädigt wird, wenn Sie einen anderen Code ändern müssen, da diese unabhängig und gekapselt sind. Die Metaklassenimplementierung besteht diesen Test. Metaklassen sind dafür verantwortlich, das Muster durchzusetzen und Klassen und Unterklassen zu erstellen, die nicht wissen müssen, dass es sich um Singletons handelt. Methode 1 besteht diesen Test nicht, wie Sie mit „MyClass selbst ist eine Funktion, keine Klasse, daher können Klassenmethoden nicht aufgerufen werden“ betont haben.

Mit Python 2 und 3 kompatible Versionen

Das Schreiben von Code in Python 2 und 3 erfordert ein etwas komplizierteres Schema. Da Metaklassen normalerweise Unterklassen des Typs „Klasse“ sind, können Sie eine Metaklasse verwenden, um zur Laufzeit dynamisch eine Zwischenbasisklasse mit ihr als Metaklasse zu erstellen und diese Basisklasse dann als Basisklasse für eine öffentliche Singleton-Basisklasse zu verwenden. Das ist leichter gesagt als getan:

def singleton(class_):
    instances = {}

    def getinstance(*args, **kwargs):
        if class_ not in instances:
            instances[class_] = class_(*args, **kwargs)
        return instances[class_]

    return getinstance

@singleton
class MyClass(BaseClass):
    pass

Eine Ironie dieses Ansatzes besteht darin, dass er Unterklassen verwendet, um Metaklassen zu implementieren. Ein möglicher Vorteil besteht darin, dass isinstance(inst, Singleton) im Gegensatz zu einer reinen Metaklasse True zurückgibt.

Korrektur

Was ein anderes Thema betrifft, ist Ihnen vielleicht aufgefallen, dass die Basisklassenimplementierung in Ihrem ursprünglichen Beitrag falsch war. Um innerhalb einer Klasse auf _instances zu verweisen, müssen Sie super() oder eine statische Methode der Klassenmethode verwenden, da die eigentliche Klasse zum Zeitpunkt des Aufrufs noch nicht erstellt wurde. All dies gilt auch für Metaklassenimplementierungen.

class Singleton(object):
    _instance = None

    def __new__(class_, *args, **kwargs):
        if not isinstance(class_._instance, class_):
            class_._instance = object.__new__(class_, *args, **kwargs)
        return class_._instance

class MyClass(Singleton, BaseClass):
    pass

Das obige ist der detaillierte Inhalt vonWas ist der beste Weg, einen Singleton in Python zu implementieren?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!