Singleton-Muster in Python

Singleton-Modus

Singleton-Modus Pattern) ist ein häufig verwendetes Software-Designmuster. Der Hauptzweck dieses Musters besteht darin, sicherzustellen, dass nur eine Instanz einer bestimmten Klasse vorhanden ist. Singleton-Objekte sind praktisch, wenn Sie möchten, dass nur eine Instanz einer bestimmten Klasse im gesamten System angezeigt wird.

Zum Beispiel werden die Konfigurationsinformationen eines Serverprogramms in einer Datei gespeichert und der Client übergibt eine AppConfig Klasse zum Lesen von Konfigurationsdateiinformationen. Wenn der Inhalt der Konfigurationsdatei während der Ausführung des Programms an vielen Stellen verwendet werden muss, muss AppConfig an vielen Stellen erstellt werden. Objektinstanz, was zur Existenz mehrerer AppConfig-Instanzobjekte im System führt, was zu einer erheblichen Verschwendung von Speicherressourcen führt, insbesondere wenn die Konfigurationsdatei viel Inhalt enthält. Tatsächlich so etwas wie AppConfig Für eine solche Klasse hoffen wir, dass während der Ausführung des Programms nur ein Instanzobjekt vorhanden ist.

In Python können wir verschiedene Methoden verwenden, um das Singleton-Muster zu implementieren:

• Verwenden Sie Module

• Verwenden Sie _ _new__

• Dekorator verwenden

• Metaklasse verwenden

Module verwenden

Tatsächlich handelt es sich bei Python-Modulen um einen natürlichen Singleton-Modus, da beim ersten Import des Moduls .pyc generiert wird Wenn Sie die Datei zum zweiten Mal importieren, wird .pyc direkt geladen Datei ohne erneute Ausführung des Modulcodes. Daher müssen wir nur die relevanten Funktionen und Daten in einem Modul definieren, um ein Singleton-Objekt zu erhalten. Wenn wir wirklich eine Singleton-Klasse wollen, sollten Sie Folgendes in Betracht ziehen:

# 
mysingleton.py
class My_Singleton(object):
    def foo(self):
        pass
 
my_singleton = My_Singleton()

Speichern Sie den obigen Code in der Datei mysingleton.py und verwenden Sie ihn wie folgt:

from 
mysingleton import my_singleton
 
my_singleton.foo()

Verwenden __new__

Um nur eine Instanz der Klasse erscheinen zu lassen, können wir __new__ verwenden, um den Erstellungsprozess der Instanz zu steuern. Der Code lautet wie folgt:

class Singleton(object):
    _instance = None
    def __new__(cls, *args, **kw):
        if not cls._instance:
            cls._instance = super(Singleton, cls).__new__(cls, *args, **kw)  
        return cls._instance  
 
class MyClass(Singleton):  
    a = 1

oben Im Code verknüpfen wir die Instanz der Klasse mit einer Klassenvariablen _instance. Wenn cls._instance None ist, erstellen Sie eine Instanz, andernfalls kehren Sie direkt zurück cls._instance.

Die Ausführung ist wie folgt:

>>> one = MyClass()
>>> two = MyClass()
>>> one == two
True
>>> one is two
True
>>> id(one), id(two)
(4303862608, 4303862608)

Verwendung eines Dekorateurs

Wir wissen, dass ein Dekorateur eine Klasse oder Funktion dynamisch ändern kann. Hier können wir auch einen Dekorator verwenden, um eine Klasse so zu dekorieren, dass sie nur eine Instanz generieren kann. Der Code lautet wie folgt:

from 
functools import wraps
 
def singleton(cls):
    instances = {}
    @wraps(cls)
    def getinstance(*args, **kw):
        if cls not in instances:
            instances[cls] = cls(*args, **kw)
        return instances[cls]
    return getinstance
 
@singleton
class MyClass(object):
    a = 1

Oben haben wir einen Dekorator-Singleton definiert, der eine interne Funktion getinstance zurückgibt Diese Funktion bestimmt, ob eine bestimmte Klasse in den Wörterbuchinstanzen enthalten ist , wenn es nicht existiert, wird cls als Schlüssel verwendet und cls(*args, **kw) wird als Wert in Instanzen gespeichert, andernfalls wird es direkt zurückgegeben. Instanzen[cls].

Metaklasse verwenden

Metaklasse kann den Erstellungsprozess einer Klasse steuern. Sie erledigt hauptsächlich drei Dinge:

• Erstellung von Abfangklasse

• Ändern Sie die Definition der Klasse

• Geänderte Klasse zurückgeben

Der Code Die Implementierung des Singleton-Musters mithilfe von Metaklassen erfolgt wie folgt:

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(object):
    __metaclass__ = Singleton
 
# 
Python3
# 
class MyClass(metaclass=Singleton):
#    pass

Zusammenfassung

Python-Module sind natürliche Singleton-Muster, die In den meisten Fällen sollte dies ausreichen. Natürlich können wir auch Methoden wie Dekoratoren und Metaklassen verwenden.

Das Obige ist das Singleton-Muster in Python. Für weitere verwandte Inhalte zahlen Sie bitte Achtung auf die chinesische PHP-Website (www.php.cn)!