0

每当我定义一个其实例创建其他类的对象的类时，我喜欢将那些其他对象的类型定义为类成员：

class Foo(object):
    DICT_TYPE = dict  # just a trivial example
    def __init__(self):
        self.mydict = self.DICT_TYPE()

class Bar(Foo):
    DICT_TYPE = OrderedDict  # no need to override __init__ now

这个想法是允许潜在的子类轻松覆盖它。

我刚刚发现这个习惯有问题，当我使用的“类型”不是真正的类型，而是工厂函数时。例如，RLock令人困惑的是不是一个类：

def RLock(*args, **kwargs):
    return _RLock(*args, **kwargs)

因此以同样的方式使用它是不好的：

class Foo(object):
    LOCK_TYPE = threading.RLock  # alas, RLock() is a function...
    def __init__(self):
        self.lock = self.LOCK_TYPE()

这里的问题是，因为RLock是一个函数，所以self.LOCK_TYPE绑定到self，导致绑定方法，从而导致错误。

以下是使用函数而不是类时出现问题的快速演示（对于比RLock上面更简单的情况）：

def dict_factory():
    return {}

class Foo(object):
    DICT_TYPE1 = dict
    DICT_TYPE2 = dict_factory

f = Foo()
f.DICT_TYPE1()
=> {}
f.DICT_TYPE2()
=> TypeError: dict_factory() takes no arguments (1 given)

有人对这个问题有很好的解决方案吗？我定义这些班级成员的习惯从根本上是错误的吗？

我想我可以用工厂方法替换它。那会是更好的方法吗？

class Foo(object);
    def __init__(self):
        self.lock = self._make_lock()
    def _make_lock(self):
        return threading.RLock()
4

2 回答 2

2

你可以使用 staticmethod 装饰器来确保你的类不会被传入

>>> class Foo(object):
...     DICT_TYPE = staticmethod(my_dict)
...
>>> f = Foo()
>>> f.DICT_TYPE()
{}
于 2014-07-26T19:15:33.140 回答
0

可以通过使用classproperty（例如在此答案中定义）绕过该问题：

class Foo(object):
    @classproperty
    def DICT_TYPE(cls):
        return dict_factory
于 2014-07-29T05:49:54.800 回答