sont définis par l'utilisateur classes mutable

Classes de l'utilisateur sont considérées comme mutables. Python n'a pas (absolument) privé attributs, de sorte que vous pouvez toujours changer d'une classe d'intervenir dans le fonctionnement interne.

Pour l'utilisation de votre classe comme une clé dans une dict ou de les stocker dans un set, vous pouvez définir un .__hash__() méthode et un .__eq__() méthode, une promesse que votre classe est immuable. Vous, en général, de la conception de votre classe de l'API de ne pas la mutation de l'état interne après la création dans de tels cas.

Par exemple, si vos moteurs sont uniquement définis par leur id, vous pouvez l'utiliser comme base de votre hash:

class Engine(object):
    def __init__(self, id):
        self.id = id

    def __hash__(self):
        return hash(self.id)

    def __eq__(self, other):
        if isinstance(other, self.__class__):
            return self.id == other.id
        return NotImplemented

Maintenant, vous pouvez utiliser des instances de la classe Moteur par sous-ensembles:

>>> eng1 = Engine(1)
>>> eng2 = Engine(2)
>>> eng1 == eng2
False
>>> eng1 == eng1
True
>>> eng1 == Engine(1)
True
>>> engines = set([eng1, eng2])
>>> engines
set([<__main__.Engine object at 0x105ebef10>, <__main__.Engine object at 0x105ebef90>])
>>> engines.add(Engine(1))
>>> engines
set([<__main__.Engine object at 0x105ebef10>, <__main__.Engine object at 0x105ebef90>])

Dans l'exemple ci-dessus-je ajouter un autre Engine(1) exemple à l'ensemble, mais il est reconnu comme étant déjà présent, et le jeu n'a pas changé.

Remarque que dans la mesure où les listes sont concernés, le .__eq__() mise en œuvre est le plus important; les listes ne m'inquiète pas si un objet est mutable ou pas, mais avec le .__eq__() méthode en place, vous pouvez tester si un moteur est déjà dans une liste:

>>> Engine(1) in [eng1, eng2]
True

OriginalL'auteur Martijn Pieters

Je pense que vous êtes confus mutabilité avec la façon python garde références -- Considérer:

class Foo(object):
    pass

t = (1,2,Foo())  # t is a tuple, :. t is immutable
b = a[2]  # b is an instance of Foo
b.foo = "Hello"  # b is mutable.  (I just changed it)
print (hash(b))  # b is hashable -- although the default hash isn't very useful
d = {b : 3}      # since b is hashable, it can be used as a key in a dictionary (or set).
c = t            # even though t is immutable, we can create multiple references to it.
a = [t]          # here we add another reference to t in a list.

Maintenant à votre question sur l'obtention d'/stocker une liste de moteurs de l'échelle, Il ya quelques façons de le faire, en voici une:

class Engine(object):
     def __init__(self, make, model):
        self.make = make
        self.model = model

class EngineFactory(object):
    def __init__(self,**kwargs):
        self._engines = kwargs

    def all_engines(self):
        return self._engines.values()

    def __call__(self,make, model):
    """ Return the same object every for each make,model combination requested """
       if (make,model) in _engines:
           return self._engines[(make,model)]
       else:
           a = self._engines[(make,model)] = Engine(make,model)
           return a   

 engine_factory = EngineFactory()

 engine1 = engine_factory('cool_engine',1.0)           
 engine2 = engine_factory('cool_engine',1.0)
 engine1 is engine2 #True !!!  They're the same engine.  Changing engine1 changes engine2

L'exemple ci-dessus pourrait être un peu améliorée, en ayant la EngineFactory._engines dict magasin weakref.ref objets au lieu de les stocker des références à des objets. Dans ce cas, vous devriez vérifier pour s'assurer que la référence est encore en vie (n'a pas été nettoyée) avant de retourner une nouvelle référence à l'objet.

OriginalL'auteur mgilson