Modèle de conception Singleton en Python

1. Utilisez les décorateurs pour implémenter le modèle de conception Singleton en Python
2. Utiliser une classe de base pour implémenter le modèle de conception Singleton en Python
3. Utiliser une métaclasse pour implémenter le modèle de conception Singleton en Python
4. Utiliser un module pour implémenter le modèle de conception Singleton en Python

Les modèles de conception peuvent représenter du code pour résoudre un problème. Singleton est l’un de ces modèles de conception, et nous pouvons créer différents objets d’une classe en Python.

Ce modèle restreint un seul objet d’une classe donnée. Il existe plusieurs méthodes pour simuler ce modèle en Python.

Utilisez les décorateurs pour implémenter le modèle de conception Singleton en Python

Les décorateurs en Python sont des fonctions qui peuvent prendre d’autres fonctions et objets comme arguments et modifier leur comportement. Pour utiliser des décorateurs, nous utilisons le signe @.

Nous pouvons les utiliser pour implémenter le modèle de conception Singleton.

Voir l’exemple suivant,

def singleton_dec(class_):
    instances = {}

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

    return getinstance


@singleton_dec
class Sample:
    def __init__(self):
        print("Object created.")


x = Sample()
y = Sample()
print(x, y)

Production :

Object created.
<__main__.Sample object at 0x0000015E72D3CA48> <__main__.Sample object at 0x0000015E72D3CA48>

Dans l’exemple ci-dessus, nous avons créé un décorateur qui prend la classe entière comme argument. Ce décorateur nous permet d’implémenter des objets Singleton, ce qui peut être confirmé par l’emplacement de x et y.

L’inconvénient de l’utilisation de décorateurs pour Singleton est que la classe finale Sample devient une fonction, nous ne pouvons donc pas utiliser de méthodes de classe.

Utiliser une classe de base pour implémenter le modèle de conception Singleton en Python

Une classe de base est une classe spéciale à partir de laquelle nous dérivons d’autres classes. Aucune instance de cette classe de base n’est créée.

Nous pouvons utiliser une classe de base pour fournir la structure de Singleton en Python.

Par exemple,

class Singleton_base(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 Sample1(Singleton_base):
    def __init__(self):
        print("Object created.")


x = Sample1()
y = Sample1()
print(x, y)

Production :

Object created.
Object created.
<__main__.Sample object at 0x0000015E72D3F388> <__main__.Sample object at 0x0000015E72D3F388>

C’est une méthode efficace; cependant, il peut y avoir des erreurs lorsque plusieurs classes sont impliquées en raison d’héritages multiples.

Utiliser une métaclasse pour implémenter le modèle de conception Singleton en Python

Une métaclasse est une fonctionnalité très intéressante de Python puisqu’elle peut définir le comportement des objets d’une classe. On peut dire que c’est une classe pour une classe.

En Python 2, on ajoute l’attribut __metaclass__ dans une classe. En Python 3, nous pouvons l’ajouter comme argument dans la classe.

Nous pouvons utiliser cette fonctionnalité pour implémenter la conception Singleton en Python.

Par exemple,

class Singleton_meta(type):
    _instances = {}

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


class Sample(metaclass=Singleton_meta):
    def __init__(self):
        print("Object created.")


x = Sample()
y = Sample()
print(x, y)

Production :

Object created.
<__main__.Sample object at 0x0000015E72D3FF88> <__main__.Sample object at 0x0000015E72D3FF88>

Il s’agit d’une application appropriée de la métaclasse et réalise l’héritage automatique.

Utiliser un module pour implémenter le modèle de conception Singleton en Python

L’implémentation la plus simple et la plus basique de Singletons en Python consiste probablement à utiliser un module.

Nous savons que nous pouvons créer des modules en Python. Un module qui ne contient que des fonctions peut servir de Singleton, et c’est parce qu’il liera toutes ces fonctions au module.