Class factory in Python

I think using a function is fine.

The more interesting question is how do you determine which registrar to load? One option is to have an abstract base Registrar class which concrete implementations subclass, then iterate over its __subclasses__() calling an is_registrar_for() class method:

class Registrar(object):  def __init__(self, domain):    self.domain = domainclass 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 ValueErrorprint Domain('foo.com')print Domain('bar.com')

This will let you transparently add new Registrars and delegate the decision of which domains each supports, to them.

Assuming you need separate classes for different registrars (though it's not obvious in your example) your solution looks okay, though RegistrarA and RegistrarB probably share functionality and could be derived from an Abstract Base Class.

As an alternative to your factory function, you could specify a dict, mapping to your registrar classes:

Registrar = {'test.com': RegistrarA, 'test.biz': RegistrarB}

Then:

registrar = Registrar['test.com'](domain)

One quibble: You're not really doing a Class Factory here as you're returning instances rather than classes.

In Python you can change the actual class directly:

class Domain(object):  def __init__(self, domain):    self.domain = domain    if ...:      self.__class__ = RegistrarA    else:      self.__class__ = RegistrarB

And then following will work.

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

I'm using this approach successfully.