Remplacement des méthodes de jeu en Python

Question

Je souhaite créer un jeu personnalisé qui convertira automatiquement les objets en un formulaire différent pour le stockage dans le jeu (voir Utiliser un dictionnaire Python en tant que clé non imbriquée ) pour l’arrière-plan.

Si je remplace add , remove , __ contient __ , __ str __ , update , __ iter __ , cela suffira-t-il pour que les autres opérations se comportent correctement ou dois-je remplacer quelque chose d'autre?

Answer 1

Travailler à partir des classes abstraites de collections , comme @ kaizer.se le suggère, est la solution appropriée pour la version 2.6 (vous ne savez pas pourquoi vous voulez appeler super - quelles fonctionnalités essayez-vous de déléguer ne peut-on pas mieux faire en confinant plutôt qu'en héritage?!).

Il est vrai que vous n'obtenez pas update - en fournissant les méthodes abstraites, vous obtenez __ le__, __lt__, __eq__, __ne__, __gt__, __ge__, __et__, __ou__ __sub__, __xor__ et isdisjoint (à partir de collections.Set ) plus effacer, pop, supprimer, __ior__, __iand__, __ixor__ et __isub __ (à partir de collections. MutableSet ), qui est bien plus que ce que vous obtiendriez de la sous-classe set (où vous auriez à remplacer la chaque méthode qui vous intéresse). Vous devrez simplement fournir d'autres méthodes de jeu que vous désirez.

Notez que les classes de base abstraites telles que collections.Set sont assez différentes des classes concrètes, y compris des éléments intégrés tels que set et (en 2.6) un bon vieux sets.Set , obsolète mais toujours présent (supprimé dans Python 3). Les ABC sont censés hériter de (et peuvent ensuite synthétiser certaines méthodes une fois que vous avez implémenté toutes les méthodes abstraites, comme vous le devez) et ensuite "enregistrer" les classes avec alors elles ont l’impression d’en hériter même quand elles n’en ont pas (pour rendre isinstance plus utilisable et utile).

Voici un exemple pratique pour Python 3.1 et 2.6 (aucune bonne raison d’utiliser la version 3.0, car la version 3.1 n’a que des avantages par rapport à celle-ci, aucun inconvénient):

import collections

class LowercasingSet(collections.MutableSet):
  def __init__(self, initvalue=()):
    self._theset = set()
    for x in initvalue: self.add(x)
  def add(self, item):
    self._theset.add(item.lower())
  def discard(self, item):
    self._theset.discard(item.lower())
  def __iter__(self):
    return iter(self._theset)
  def __len__(self):
    return len(self._theset)
  def __contains__(self, item):
    try:
      return item.lower() in self._theset
    except AttributeError:
      return False

Answer 2

En Python 2.6:

import collections
print collections.MutableSet.__abstractmethods__
# prints:
# frozenset(['discard', 'add', '__iter__', '__len__', '__contains__'])

sous-classe collections.MutableSet et remplacez les méthodes de la liste ci-dessus.

la méthode de mise à jour elle-même est très facile, étant donné que le minimum ci-dessus est implémenté

def update(self, iterable):
    for x in iterable:
        self.add(x)