2

我有以下代码：

class EntityBase (object) :
    __entity__ = None

    def __init__ (self) :
        pass

def entity (name) :
    class Entity (EntityBase) :
        __entity__ = name

        def __init__ (self) :
            pass

    return Entity

class Smth (entity ("SMTH")) :
    def __init__ (self, a, b) :
        self.a = a
        self.b = b

# added after few comments -->
def factory (tag) :
    for entity in EntityBase.__subclasses__ () :
        if entity.__entity__ == tag :
            return entity.__subclasses__ ()[0]

    raise FactoryError (tag, "Unknown entity")

s = factory ("SMTH") (1, 2)
print (s.a, s.b)
# <--

现在在工厂中，我可以获得 EntityBase 的所有子类，找到“SMTH”的具体子类并创建它。

这是有效的方法，还是我被误解并做错了什么？

4

4 回答 4

9

我会用装饰器来做这个。此外，将实体 -> 子类映射存储在字典中可以让您用字典查找替换线性扫描。

class EntityBase(object):
    _entity_ = None
    _entities_ = {}

    @classmethod
    def factory(cls, entity):
        try:
            return cls._entities_[entity]
        except KeyError:
            raise FactoryError(tag, "Unknown entity")

    @classmethod
    def register(cls, entity):
        def decorator(subclass):
            cls._entities_[entity] = subclass
            subclass._entity_ = entity
            return subclass
        return decorator

 factory = EntityBase.factory
 register = EntityBase.register

 @register('Smith')
 class Smith(EntityBase):
     def __init__(self, a, b):
         self.a = a
         self.b = b

 s = factory('Smith')(1, 2)

__entity__如果您只是使用它来实现线性扫描，我不确定该属性是否真的对您有用。我把它留在里面，但如果你把它拿出来，那么与实体关联的类甚至不需要继承EntityBase，你可以将它重命名为Registry. 这使您的继承树变浅，并打开了在不通过共同血统相关的类上使用的可能性。

根据您的用例，更好的方法可能是

factory = {}

class Smith(object):
    def __init__(self, a, b):
        self.a = a
        self.b = b
factory['Smith'] = Smith

class Jones(object):
    def __init__(self, c, d):
         self.c = c
         self.d = d
factory['Jones'] = Jones

s = factory['Smith'](1, 2)
j = factory['Jones'](3, 4)

装饰者更漂亮，让我们对自己感觉很好，很喜欢，但字典很简单，很有用，而且切中要害。这很容易理解，也很难出错。除非你真的需要做一些魔法，否则我认为这就是要走的路。无论如何，您为什么要这样做？

于 2010-09-24T12:25:35.703 回答
5

我认为这是少数需要 Python元类的情况之一：

class Entity(object):
    class __metaclass__(type):
        ENTITIES = {}

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

    @classmethod
    def factory(cls, name):
        return cls.__metaclass__.ENTITIES[name]

class Smth(Entity):
    _entity_ = 'SMTH'

    def __init__(self, a, b):
        self.a = a
        self.b = b

s = Entity.factory("SMTH")(1, 2)
print (s.a, s.b)

与您的代码有一些更细微的区别：

  • 无需使用您的entity()工厂函数创建子类，然后对该子类进行子类化。这种方法不仅创建了不必要的子类，而且还会使您的代码无法工作，因为EntityBase.__subclasses__()不包含Smth该类。
  • 开头和结尾的标识符__都是为 Python 保留的，所以我使用_entity_属性而不是__entity__.
于 2010-09-24T12:39:56.427 回答
3

元类可以跟踪定义的类。在定义Register.__init__具有此元类的类时调用。我们可以将名称和对象添加到元类中的注册表字典中。这样以后就可以直接查了。

registry = {} # dict of subclasses

def get_entity( name ):
    return registry[name]    

class Register(type):
    def __init__(cls, name, bases, dict):
        registry[name] = cls
        type.__init__(cls,name, bases, dict)

class EntityBase(object):
    __metaclass__ = Register

class OneThing(EntityBase):
    pass

class OtherThing(OneThing):
    pass

print registry # dict with Entitybase, OneThing, OtherThing
print get_entity("OtherThing") # <class '__main__.OtherThing'>

顺便说一句，工厂实例化类，因此该名称不适合仅返回类的函数。

于 2010-09-24T13:03:49.000 回答
-1

这种有效的方法还是我误解了一些东西并且做错了？

有用。所以在某种意义上它是“有效的”。

这完全是对代码的浪费。所以在某种意义上它不是“有效的”。

这种构造没有任何用例。现在您已经构建了它，您可以继续解决实际问题。

于 2010-09-24T12:18:36.460 回答