Les méthodes magiques de Python

1 -> Méthode __new__(cls)

La méthode __new__ est appelée lorsqu'un nouvel objet est créé en Python. Il est responsable de créer et renvoyer la nouvelle instance de la classe. Cette méthode est généralement utilisée lorsque vous souhaitez personnaliser la création d'objets, comme pour les modèles singleton, la mise en cache ou la gestion de la mémoire.

Quand __new__ est-il appelé ?

La méthode __new__ est appelée avant __init__ et est utilisée pour créer le nouvel objet. Voici l'ordre typique des événements lorsque vous créez un nouvel objet :

1. __new__ : Crée l'objet (allocation de mémoire).
2. __init__ : Initialise l'objet (paramétrage des attributs).

Cas d'utilisation pour __new__ :

1. Modèle Singleton : Le modèle Singleton garantit qu’une seule instance d’une classe existe. Dans ce cas, __new__ vérifie si une instance existe déjà et la réutilise, au lieu d'en créer une nouvelle.

   class Singleton:
       _instance = None

       def __new__(cls):
           if cls._instance is None:
               cls._instance = super(Singleton, cls).__new__(cls)
           return cls._instance

   s1 = Singleton()
   s2 = Singleton()
   print(s1 is s2)  # True, both are the same instance

1. Mise en cache des objets : Si vous souhaitez mettre en cache des objets en fonction de certaines conditions, vous pouvez utiliser __new__ pour vérifier si un objet existe déjà (par exemple, dans un dictionnaire) avant d'en créer un nouveau. Cela peut aider à optimiser l’utilisation de la mémoire.

   class CachedObject:
       _cache = {}

       def __new__(cls, value):
           if value in cls._cache:
               return cls._cache[value]
           obj = super().__new__(cls)
           cls._cache[value] = obj
           return obj

   obj1 = CachedObject("hello")
   obj2 = CachedObject("hello")
   print(obj1 is obj2)  # True, the same object is reused

1. Gestion de la mémoire :
   Si vous souhaitez contrôler l'allocation de mémoire des objets (par exemple, pour optimiser l'utilisation de la mémoire ou gérer des objets volumineux), __new__ peut être utilisé pour personnaliser la façon dont les objets sont créés.

2. Objets immuables :
   __new__ est souvent utilisé avec des objets immuables comme des tuples et des chaînes. Par exemple, lorsque vous souhaitez créer un objet immuable personnalisé, vous remplacez __new__ pour vous assurer qu'il est correctement créé.
   

   class MyTuple(tuple):
       def __new__(cls, *args):
           return super().__new__(cls, args)

   t = MyTuple(1, 2, 3)
   print(t)  # (1, 2, 3)

En résumé:

• __new__ est appelé lors de la création d'un objet et est responsable du retour de l'instance de la classe.
• Il est utile pour optimiser la création d'objets, implémenter des modèles comme Singleton, gérer la mise en cache d'objets, ou encore personnaliser l'allocation de mémoire processus.

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!