Comment implémenter un modèle singleton en python

Comment implémenter un modèle singleton en python ? Voici sept méthodes différentes pour vous :

Une : staticmethod

Le code est le suivant :

class Singleton(object):
    instance = None
    def __init__(self):
        raise SyntaxError('can not instance, please use get_instance')
    def get_instance():
        if Singleton.instance is None:
            Singleton.instance = object.__new__(Singleton)
        return Singleton.instance
a = Singleton.get_instance()
b = Singleton.get_instance()
print('a id=', id(a))
print('b id=', id(b))

Cette méthode Le point clé est de lever une exception dans __init__, d'interdire l'instanciation via les classes et d'obtenir des instances uniquement via la fonction statique get_instance ; comme elle ne peut pas être instanciée via les classes, la fonction statique get_instance peut être obtenue via l'objet de classe parent.__new__ Instancier.

Deux : classmethod

Similaire à la première méthode, code :

class Singleton(object):
    instance = None
    def __init__(self):
        raise SyntaxError('can not instance, please use get_instance')
    def get_instance(cls):
        if Singleton.instance is None:
            Singleton.instance = object.__new__(Singleton)
        return Singleton.instance
a = Singleton.get_instance()
b = Singleton.get_instance()
print('a id=', id(a))
print('b id=', id(b))

Le point principal de cette méthode est de lever une exception dans __init__ et d'interdire passage Pour instancier une classe, l'instance ne peut être obtenue que via la fonction statique get_instance ; car elle ne peut pas être instanciée via une classe, la fonction statique get_instance peut être instanciée via l'objet de classe parent.__new__.

Trois : la méthode d'attribut de classe

est similaire à la première méthode, code :

class Singleton(object):
    instance = None
    def __init__(self):
        raise SyntaxError('can not instance, please use get_instance')
    def get_instance():
        if Singleton.instance is None:
            Singleton.instance = object.__new__(Singleton)
        return Singleton.instance
a = Singleton.get_instance()
b = Singleton.get_instance()
print(id(a))
print(id(b))

Le point principal de cette méthode est de lever une exception dans __init__, Il est interdit d'instancier via une classe, et l'instance ne peut être obtenue que via la fonction statique get_instance ; car elle ne peut pas être instanciée via une classe, la fonction statique get_instance peut être instanciée via l'objet de classe parent.__new__.

Quatre : __new__

Méthodes courantes, le code est le suivant :

class Singleton(object):
    instance = None
    def __new__(cls, *args, **kw):
        if not cls.instance:
            # cls.instance = object.__new__(cls, *args)
            cls.instance = super(Singleton, cls).__new__(cls, *args, **kw)
        return cls.instance
a = Singleton()
b = Singleton()
print(id(a))
print(id(b))

Recommandations associées : "Tutoriel vidéo Python "

Cinq : Décorateur

Le code est le suivant :

def Singleton(cls):
    instances = {}
    def getinstance():
        if cls not in instances:
            instances[cls] = cls()
        return instances[cls]
    return getinstance
class MyClass:
    pass
a = MyClass()
b = MyClass()
c = MyClass()
print(id(a))
print(id(b))
print(id(c))

Six : Métaclasse

Version Python2 :

class Singleton(type):
    def __init__(cls, name, bases, dct):
        super(Singleton, cls).__init__(name, bases, dct)
        cls.instance = None
    def __call__(cls, *args):
        if cls.instance is None:
            cls.instance = super(Singleton, cls).__call__(*args)
        return cls.instance
class MyClass(object):
    __metaclass__ = Singleton
a = MyClass()
b = MyClass()
c = MyClass()
print(id(a))
print(id(b))
print(id(c))
print(a is b)
print(a is c)

ou :

class Singleton(type):
    def __new__(cls, name, bases, attrs):
        attrs["_instance"] = None
        return super(Singleton, cls).__new__(cls, name, bases, attrs)
    def __call__(cls, *args, **kwargs):
        if cls._instance is None:
            cls._instance = super(Singleton, cls).__call__(*args, **kwargs)
        return cls._instance
class Foo(object):
    __metaclass__ = Singleton
x = Foo()
y = Foo()
print(id(x))
print(id(y))

Version Python3 :

class Singleton(type):
    def __new__(cls, name, bases, attrs):
        attrs['instance'] = None
        return super(Singleton, cls).__new__(cls, name, bases, attrs)
    def __call__(cls, *args, **kwargs):
        if cls.instance is None:
            cls.instance = super(Singleton, cls).__call__(*args, **kwargs)
        return cls.instance
class Foo(metaclass=Singleton):
    pass
x = Foo()
y = Foo()
print(id(x))
print(id(y))

Seven : Couverture de noms

Le code est le suivant :

class Singleton(object):
    def foo(self):
        print('foo')
    def __call__(self):
        return self
Singleton = Singleton()
Singleton.foo()
a = Singleton()
b = Singleton()
print(id(a))
print(id(b))

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!