5 gängige Methoden zum Erstellen von Singleton-Mustern in Python

Der sogenannte Singleton bedeutet, dass eine Instanz einer Klasse von Anfang bis Ende nur einmal erstellt werden kann.

Methode 1

Wenn Sie möchten, dass eine Klasse von Anfang bis Ende höchstens eine Instanz hat, ist es sehr einfach, die Methode __new__ zu verwenden. Klassen in Python erstellen Instanzen durch __new__:

class Singleton(object):
    def __new__(cls,*args,**kwargs):
        if not hasattr(cls,'_inst'):
            cls._inst=super(Singleton,cls).__new__(cls,*args,**kwargs)
        return cls._inst
if __name__=='__main__':
    class A(Singleton):
        def __init__(self,s):
            self.s=s      
    a=A('apple')   
    b=A('banana')
    print id(a),a.s
    print id(b),b.s

Ergebnis:

29922256 Banana

29922256 Banana

Verwenden Sie die Methode __new__, um die Instanz der Klasse beim Erstellen an das Klassenattribut _inst zu binden. Wenn cls._inst None ist, bedeutet dies, dass die Klasse noch nicht instanziiert wurde und die Instanz an cls._inst gebunden wird. Die durch die erste Instanziierung erstellte Instanz wird bei jeder zukünftigen Instanziierung zurückgegeben. Beachten Sie, dass beim Ableiten einer Unterklasse von Singleton __new__ nicht überladen werden darf.

Methode 2:

Manchmal ist es uns egal, ob die generierten Instanzen dieselbe ID haben, sondern wir kümmern uns nur um deren Status und Verhalten. Wir können die Erstellung vieler Instanzen zulassen, aber alle

class Borg(object):
    _shared_state={}
    def __new__(cls,*args,**kwargs):
        obj=super(Borg,cls).__new__(cls,*args,**kwargs)
        obj.__dict__=cls._shared_state
        return obj

verweisen das __dict__ aller Instanzen auf dasselbe Wörterbuch, sodass die Instanzen dasselbe verwenden Methoden und Eigenschaften. Die Einstellung des Namensattributs einer Instanz, unabhängig davon, ob sie in __init__ oder direkt geändert wurde, wirkt sich auf alle Instanzen aus. Die Instanz-IDs sind jedoch unterschiedlich. Um sicherzustellen, dass Klasseninstanzen Attribute gemeinsam nutzen können, jedoch nicht mit Unterklassen, verwenden Sie unbedingt cls._shared_state anstelle von Borg._shared_state.

Da die Instanzen unterschiedliche IDs haben, kann jede Instanz als Wörterbuchschlüssel verwendet werden:

if __name__=='__main__':
    class Example(Borg):
        pass
    a=Example()
    b=Example()
    c=Example()
    adict={}
    j=0
    for i in a,b,c:
        adict[i]=j
        j+=1
    for i in a,b,c:
        print adict[i]

Ergebnis:

0

1

2

Wenn dieses Verhalten nicht Ihren Wünschen entspricht, können Sie der Borg-Klasse die Methoden __eq__ und __hash__ hinzufügen, um das Verhalten näher an Singleton zu bringen Muster:

class Borg(object):
    _shared_state={}
    def __new__(cls,*args,**kwargs):
        obj=super(Borg,cls).__new__(cls,*args,**kwargs)
        obj.__dict__=cls._shared_state
        return obj
    def __hash__(self):
        return 1
    def __eq__(self,other):
        try:
            return self.__dict__ is other.__dict__
        except:
            return False
if __name__=='__main__':
    class Example(Borg):
        pass
    a=Example()
    b=Example()
    c=Example()
    adict={}
    j=0
    for i in a,b,c:
        adict[i]=j
        j+=1
    for i in a,b,c:
        print adict[i]

Ergebnis:

2

2

2

Alle Instanzen können als Schlüssel verwendet werden.

Methode 3

Wenn Sie eine Klasse schreiben, verwendet ein Mechanismus den Klassennamen, das Basisklassentupel und das Klassenwörterbuch, um ein Klassenobjekt zu erstellen. Dieser Mechanismus in neuen Klassen ist standardmäßig typ, und dieser Mechanismus ist programmierbar und heißt Metaklasse __metaclass__.

class Singleton(type):
    def __init__(self,name,bases,class_dict):
        super(Singleton,self).__init__(name,bases,class_dict)
        self._instance=None
    def __call__(self,*args,**kwargs):
        if self._instance is None:
            self._instance=super(Singleton,self).__call__(*args,**kwargs)
        return self._instance
if __name__=='__main__':
    class A(object):
        __metaclass__=Singleton       
    a=A()
    b=A()
    print id(a),id(b)

Ergebnis:

34248016 34248016

ID ist gleich.

Im Beispiel erstellen wir eine Singleton-Metaklasse und verwenden die Methode __call__, um das Verhalten der Funktion zu simulieren. Wenn Sie Klasse A erstellen, setzen Sie deren Metaklasse auf Singleton. Wenn Sie dann Klassenobjekt A erstellen, tritt das Verhalten wie folgt auf:

A=Singleton(name, bases, class_dict), A ist tatsächlich eine Instanz der Singleton-Klasse .

Beim Erstellen einer Instanz von A gilt A()=Singleton(name,bases,class_dict)()=Singleton(name,bases,class_dict).__call__(), wodurch alle Instanzen von A auf Bezug genommen werden Attribut _instance von A, diese Methode ist tatsächlich dieselbe wie Methode 1.

Methode 4

Das Modulmodul in Python wird nur einmal im Programm geladen und ist selbst ein Singleton. Sie können ein Modul direkt schreiben und die im Modul benötigten Methoden und Attribute als Funktionen und globale Variablen im Modulbereich schreiben. Es ist überhaupt nicht erforderlich, eine Klasse zu schreiben.

Und es gibt einige Möglichkeiten, die Vorteile von Modulen und Klassen zu kombinieren:

class _singleton(object):
    class ConstError(TypeError):
        pass
    def __setattr__(self,name,value):
        if name in self.__dict__:
            raise self.ConstError
        self.__dict__[name]=value
    def __delattr__(self,name):
        if name in self.__dict__:
            raise self.ConstError
        raise NameError
import sys
sys.modules[__name__]=_singleton()

Python überprüft sys.modules nicht, um sicherzustellen Da es sich um Modulobjekte handelt, verwenden wir dies, um das Modul an ein Klassenobjekt zu binden, und es wird in Zukunft an dasselbe Objekt gebunden.

Speichern Sie den Code in single.py:

>>> import single
>>> single.a=1
>>> single.a=2

ConstError

>>> del single.a

ConstError

Methode 5

Die einfachste Methode:

class singleton(object):
    pass
singleton=singleton()

Binden Sie den Namen Singleton an die Instanz. Der Singleton ist das einzige Objekt seiner eigenen Klasse.