Modèle singleton en Python

Mode Singleton

Mode Singleton Pattern) est un modèle de conception de logiciel couramment utilisé. L'objectif principal de ce modèle est de garantir qu'une seule instance d'une certaine classe existe. Les objets Singleton sont utiles lorsque vous souhaitez qu'une seule instance d'une certaine classe apparaisse dans l'ensemble du système.

Par exemple, les informations de configuration d'un programme serveur sont stockées dans un fichier et le client passe un AppConfig Classe pour lire les informations du fichier de configuration. S'il existe de nombreux endroits où le contenu du fichier de configuration doit être utilisé lors de l'exécution du programme, c'est-à-dire qu'AppConfig doit être créé à de nombreux endroits. Instance d'objet, qui entraîne l'existence de plusieurs objets d'instance AppConfig dans le système, ce qui gaspillera sérieusement les ressources mémoire, en particulier lorsque le fichier de configuration contient beaucoup de contenu. En fait, quelque chose comme AppConfig Pour une telle classe, nous espérons qu’un seul objet instance existera lors de l’exécution du programme.

En Python, nous pouvons utiliser diverses méthodes pour implémenter le modèle singleton :

• Utiliser des modules

• Utiliser _ _new__

• Utiliser le décorateur

• Utiliser la métaclasse

Utiliser les modules

En fait, les modules Python sont en mode singleton naturel, car lorsque le module est importé pour la première fois, .pyc sera généré fichier, lors de l'importation pour la deuxième fois, .pyc sera chargé directement fichier sans exécuter à nouveau le code du module. Par conséquent, il nous suffit de définir les fonctions et les données pertinentes dans un module pour obtenir un objet singleton. Si nous voulons vraiment une classe singleton, pensez à faire ceci :

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

Enregistrez le code ci-dessus dans le fichier mysingleton.py et utilisez-le comme ceci :

from 
mysingleton import my_singleton
 
my_singleton.foo()

Utiliser __new__

Afin que la classe n'ait qu'une seule instance, nous pouvons utiliser __new__ pour contrôler le processus de création d'instance, le code est le suivant :

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

ci-dessus Dans le code, on associe l'instance de la classe à une variable de classe _instance. Si cls._instance vaut None, créons une instance, sinon retournons directement. cls._instance.

L'exécution est la suivante :

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

Utiliser un décorateur

On sait qu'un décorateur peut modifier dynamiquement une classe ou une fonction. Ici, on peut également utiliser un décorateur pour décorer une classe afin qu'elle ne puisse générer qu'une seule instance. Le code est le suivant :

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

Ci-dessus, nous avons défini un singleton de décorateur, qui renvoie une fonction interne getinstance. , cette fonction déterminera si une certaine classe est dans les instances du dictionnaire , s'il n'existe pas, cls sera utilisé comme clé et cls(*args, **kw) sera stocké comme valeur dans les instances. Sinon, il sera renvoyé directement. instances[cls].

Utiliser la métaclasse

La métaclasse peut contrôler le processus de création d'une classe. Elle fait principalement trois choses :

• Création de. classe d'interception

• Modifier la définition de la classe

• Renvoyer la classe modifiée

Le code pour implémenter le modèle singleton à l'aide de métaclasses est la suivante :

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

Résumé

Les modules Python sont des modèles singletons naturels, qui devrait être suffisant dans la plupart des cas. Bien sûr, nous pouvons également utiliser des méthodes telles que les décorateurs et les métaclasses

Ce qui précède est le modèle singleton en Python. Pour plus de contenu connexe, veuillez payer. attention au site PHP chinois (www.php.cn) !