Fabrique de classe en Python

Je suis nouveau sur Python et besoin de quelques conseils de mise en œuvre le scénario ci-dessous.

J'ai deux classes pour la gestion de vos domaines à deux bureaux d'enregistrement. Les deux ont la même interface, par exemple

class RegistrarA(Object):
    def __init__(self, domain):
        self.domain = domain

    def lookup(self):
        ...

    def register(self, info):
        ...

class RegistrarB(object):
    def __init__(self, domain):
        self.domain = domain

    def lookup(self):
        ...

    def register(self, info):
        ...

Je voudrais créer un Domaine de classe, étant donné qu'un nom de domaine, les charges de la bonne greffier classe basée sur l'extension, par exemple

com = Domain('test.com') #load RegistrarA
com.lookup()

biz = Domain('test.biz') #load RegistrarB
biz.lookup()

Je sais que cela peut être accompli en utilisant une fonction de fabrication (voir ci-dessous), mais est-ce la meilleure façon de le faire, ou est-il une meilleure façon de la programmation orientée objet à l'aide de fonctionnalités?

def factory(domain):
  if ...:
    return RegistrarA(domain)
  else:
    return RegistrarB(domain)

InformationsquelleAutor | 2009-01-19

factory python

73

Je pense que l'utilisation d'une fonction est fine.

La question la plus intéressante est de savoir comment déterminer le greffier à charger? Une option est d'avoir un résumé de la base de Greffier de la classe qui des implémentations concrètes sous-classe, puis effectuer une itération sur son __subclasses__() de l'appel d'une is_registrar_for() méthode de classe:
```
class Registrar(object):
  def __init__(self, domain):
    self.domain = domain

class RegistrarA(Registrar):
  @classmethod
  def is_registrar_for(cls, domain):
    return domain == 'foo.com'

class RegistrarB(Registrar):
  @classmethod
  def is_registrar_for(cls, domain):
    return domain == 'bar.com'


def Domain(domain):
  for cls in Registrar.__subclasses__():
    if cls.is_registrar_for(domain):
      return cls(domain)
  raise ValueError


print Domain('foo.com')
print Domain('bar.com')
```
Cela vous permettra de manière transparente ajouter de nouveaux Registrars et délégué de la décision de domaines dont chacun prend en charge, pour eux.
- Salut @Alec. Dans ce cas particulier, sont les décorateurs (@classmethod) dans les classes nécessaires? Si oui, quel rôle jouent-ils dans ce contexte?
- Pas strictement nécessaire, non, mais sans eux, vous auriez à instancier chaque bureau d'enregistrement de la classe. La tendance générale est de ce qui est utile, l' @classmethod est juste un détail d'implémentation.
- peut avoir été légèrement meilleur à utiliser dans ce contexte, je pense
- Cette approche est dangereux à moins que le béton sous-classes " is_registrar_for() sont mutuellement exclusifs, et le restera à l'avenir. L'ordre des valeurs retournées par __subclasses__() est arbitraire. Et cet ordre, en général, les questions. Par conséquent, si quelque chose dans le code (peut-être comme mineur, comme l'ordre des définitions de classe) les modifications, vous pouvez vous retrouver avec un résultat différent. Le coût de ces bugs, OMI, est énorme, et l'emporte de loin sur les avantages de cette approche. Je voudrais aller avec l'approche de l'OP utilisé, où une seule fonction contient toute la logique de la sous-classe de la sélection.
- Si vous n'avez mutuellement exclusives, des tests, ou pour d'autres raisons de se sentir de cette approche est sûre, sachez que __subclasses__ renvoie seulement les sous-classes; donc multi-niveau de l'héritage aurait besoin d'un petit tweak pour être traitée correctement.
- Sachez également que __subclasses__ uniquement fonctionne pour les objets vivants. Si une classe n'est pas encore importé, il n'apparaît pas dans les résultats (car il n'a pas 'existe pas').
- Si chaque classe définie dans son propre fichier, alors il est évident que les classes dérivées de l'importation de la classe de base. Cela signifie que l'usine ne peut pas être défini dans le même fichier que la classe de base ou il y aura circulaire les importations, par conséquent, l'usine de la fonction doit être définie dans son propre fichier. (la fonction plutôt que @staticmethod en tant que méthode de classe de base)
- La fonction de capitalisation de Domain fait cette réponse un peu déroutant.
InformationsquelleAutor Alec Thomas
21

Si vous avez besoin de classes séparées pour les différents bureaux d'enregistrement (si ce n'est pas évident dans votre exemple) votre solution semble correct, bien que RegistrarA et RegistrarB probablement fonctionnalité de partage et pourrait être dérivée à partir d'une Classe De Base Abstraite.

Comme une alternative à votre factory fonction, vous pouvez spécifier un dict, de la cartographie de votre bureau d'enregistrement de classes:
```
Registrar = {'test.com': RegistrarA, 'test.biz': RegistrarB}
```
Alors:
```
registrar = Registrar['test.com'](domain)
```
Un bémol: Vous n'êtes pas vraiment en train de faire une Fabrique de Classe ici que vous êtes de retour instances plutôt que de classes.
- Dans le cas où vous avez besoin pour déterminer le greffier par regexp, vous pouvez utiliser la correspondance.groupdict() pour calculer la fente dans le registre dictionnaire ci-dessus: registrarRe = re.la compilation("(?P<A>.*\.com)|(?P<B>.*\.biz)")
InformationsquelleAutor Jeff Bauer
10

En Python, vous pouvez modifier la classe:
```
class Domain(object):
  def __init__(self, domain):
    self.domain = domain
    if ...:
      self.__class__ = RegistrarA
    else:
      self.__class__ = RegistrarB
```
Puis suit fonctionnera.
```
com = Domain('test.com') #load RegistrarA
com.lookup()
```
Je suis en utilisant cette approche avec succès.
- Voir les commentaires stackoverflow.com/a/9144059/336527 pour un avertissement (vous êtes en sécurité si tous les bureaux d'enregistrement ont la même classe de base et de ne pas utiliser des fentes).
- En fait, cette approche porte un beaucoup plus grave danger que j'ai réalisé: méthodes spéciales peuvent pas appelée correctement, etc. Je suis maintenant convaincu que cela ne devrait JAMAIS être fait, car le désordre de déterminer quels sont les problèmes que cela peut causer peut varier selon la version de Python, et est juste ne vaut pas les avantages que cela procure.
InformationsquelleAutor bialix
6

Vous pouvez créer un "wrapper" classe et la surcharge de ses __new__() méthode pour retourner des instances spécialisées sous-classes, par exemple:
```
class Registrar(object):
    def __new__(self, domain):
        if ...:
            return RegistrarA(domain)
        elif ...:
            return RegistrarB(domain)
        else:
            raise Exception()
```
En outre, afin de traiter les non mutuellement exclusifs conditions, une question qui a été soulevée dans d'autres réponses, la première question à se poser est de savoir si vous voulez que la classe wrapper, qui joue le rôle de répartiteur, pour régir les conditions, ou il va déléguer au cours spécialisés. Je peux suggérer partagé mécanisme, où les cours spécialisés définissent leurs propres conditions, mais l'enveloppe ne la validation, comme ceci (à condition que chaque classe spécialisée expose une méthode de classe qui permet de vérifier qu'il est un bureau d'enregistrement d'un domaine particulier, is_registrar_for(...) comme suggéré dans d'autres réponses):
```
class Registrar(object):
    registrars = [RegistrarA, RegistrarB]
    def __new__(self, domain):
        matched_registrars = [r for r in self.registrars if r.is_registrar_for(domain)]

        if len(matched_registrars) > 1:
            raise Exception('More than one registrar matched!')
        elif len(matched_registrars) < 1:
            raise Exception('No registrar was matched!')
        else:
            return matched_registrars[0](domain)
```
- Votre premier exemple est exactement ce que j'ai développé sur mon propre; cependant, c'est le seul endroit où je l'ai trouvé tout à fait de cette façon. Connaissez-vous des inconvénients à le faire comme ça?
- C'est difficile à dire. Si vous vérifiez la documentation de docs.python.org/2/reference/datamodel.html#object.__new__, il n'y a rien pour décourager ce type d'utilisation, mais pas beaucoup de soutien il soit.
- Bien qu'elle mentionne une implémentation typique, ainsi que ce qu'il avait prévu pour (c'est à dire principalement pour immuable classes), la possibilité de __new__ retour quelque chose de différent qu'une instance de cls est mentionné, trop, et parce que le renvoi None est pas explicitement interdit, il conduirait à la conclusion qu'une instance d'une classe différente, qui est autorisé à être retourné.
- Merci, Ion. J'ai fini par trouver un quelques autres exemples, si ce n'est pas toujours bien reçu.
InformationsquelleAutor Ion Lesan

J'ai ce problème tout le temps. Si vous avez les classes intégré dans votre application (et ses modules) alors vous pouvez utiliser une fonction; mais si vous charger des plugins de manière dynamique, vous avez besoin de quelque chose de plus dynamique -- enregistrer les classes d'une usine via metaclasses automatiquement.

Ici est un modèle que je suis sûr que j'ai levé de StackOverflow à l'origine, mais je n'ai pas encore le chemin vers le post original

_registry = {}

class PluginType(type):
    def __init__(cls, name, bases, attrs):
        _registry[name] = cls
        return super(PluginType, cls).__init__(name, bases, attrs)

class Plugin(object):
    __metaclass__  = PluginType # python <3.0 only 
    def __init__(self, *args):
        pass

def load_class(plugin_name, plugin_dir):
    plugin_file = plugin_name + ".py"
    for root, dirs, files in os.walk(plugin_dir) :
        if plugin_file in (s for s in files if s.endswith('.py')) :
            fp, pathname, description = imp.find_module(plugin_name, [root])
            try:
                mod = imp.load_module(plugin_name, fp, pathname, description)
            finally:
                if fp:
                    fp.close()
    return

def get_class(plugin_name) :
    t = None
    if plugin_name in _registry:
        t = _registry[plugin_name]
    return t

def get_instance(plugin_name, *args):
    return get_class(plugin_name)(*args)

InformationsquelleAutor Mayur Patel

comment au sujet de quelque chose comme

class Domain(object):
  registrars = []

  @classmethod
  def add_registrar( cls, reg ):
    registrars.append( reg )

  def __init__( self, domain ):
    self.domain = domain
    for reg in self.__class__.registrars:
       if reg.is_registrar_for( domain ):
          self.registrar = reg  
  def lookup( self ):
     return self.registrar.lookup()    

Domain.add_registrar( RegistrarA )
Domain.add_registrar( RegistrarB )

com = Domain('test.com')
com.lookup()

InformationsquelleAutor Coyo

Ici une métaclasse implicitement recueille des Registars Classes dans une ENTITÉS dict

class DomainMeta(type):
    ENTITIES = {}

    def __new__(cls, name, bases, attrs):
        cls = type.__new__(cls, name, bases, attrs)
        try:
            entity = attrs['domain']
            cls.ENTITIES[entity] = cls
        except KeyError:
            pass
        return cls

class Domain(metaclass=DomainMeta):
    @classmethod
    def factory(cls, domain):
        return DomainMeta.ENTITIES[domain]()

class RegistrarA(Domain):
    domain = 'test.com'
    def lookup(self):
        return 'Custom command for .com TLD'

class RegistrarB(Domain):
    domain = 'test.biz'
    def lookup(self):
        return 'Custom command for .biz TLD'


com = Domain.factory('test.com')
type(com)       # <class '__main__.RegistrarA'>
com.lookup()    # 'Custom command for .com TLD'

com = Domain.factory('test.biz')
type(com)       # <class '__main__.RegistrarB'>
com.lookup()    # 'Custom command for .biz TLD'

InformationsquelleAutor Christophe Morio

Vous devez vous connecter pour publier un commentaire.