如果你使用Django，它有一个内置的@classproperty装饰器。

from django.utils.decorators import classproperty

对于Django 4，使用:

from django.utils.functional import classproperty

如果你使用Django，它有一个内置的@classproperty装饰器。

from django.utils.decorators import classproperty

对于Django 4，使用:

from django.utils.functional import classproperty

我碰巧想出了一个与@Andrew非常相似的解决方案，只是DRY

class MetaFoo(type):

    def __new__(mc1, name, bases, nmspc):
        nmspc.update({'thingy': MetaFoo.thingy})
        return super(MetaFoo, mc1).__new__(mc1, name, bases, nmspc)

    @property
    def thingy(cls):
        if not inspect.isclass(cls):
            cls = type(cls)
        return cls._thingy

    @thingy.setter
    def thingy(cls, value):
        if not inspect.isclass(cls):
            cls = type(cls)
        cls._thingy = value

class Foo(metaclass=MetaFoo):
    _thingy = 23

class Bar(Foo)
    _thingy = 12

这是最好的答案:

“元属性”被添加到类中，因此它仍然是实例的属性

不需要在任何类中重新定义东西 该属性在实例和类中都作为“类属性”工作 您可以灵活地自定义_thingy的继承方式

在我的例子中，我实际上为每个子定制了_thingy，没有在每个类中定义它(并且没有默认值):

   def __new__(mc1, name, bases, nmspc):
       nmspc.update({'thingy': MetaFoo.services, '_thingy': None})
       return super(MetaFoo, mc1).__new__(mc1, name, bases, nmspc)

我认为您可以通过元类来实现这一点。因为元类可以像类的类(如果有意义的话)。我知道你可以给元类赋一个__call__()方法来覆盖调用类MyClass()。我想知道在元类上使用属性装饰器的操作是否类似。

哇，真管用:

class MetaClass(type):    
    def getfoo(self):
        return self._foo
    foo = property(getfoo)
    
    @property
    def bar(self):
        return self._bar
    
class MyClass(object):
    __metaclass__ = MetaClass
    _foo = 'abc'
    _bar = 'def'
    
print MyClass.foo
print MyClass.bar

注意:这是在Python 2.7中。Python 3+使用不同的技术来声明元类。使用:class MyClass(metaclass= metaclass):，删除__metaclass__，其余部分相同。

如果您按如下方式定义classproperty，那么您的示例将完全按照您的要求工作。

class classproperty(object):
    def __init__(self, f):
        self.f = f
    def __get__(self, obj, owner):
        return self.f(owner)

需要注意的是，您不能将此用于可写属性。While . i = 20将引发AttributeError, Example。I = 20将覆盖属性对象本身。

以下是我的做法:

class ClassPropertyDescriptor(object):

    def __init__(self, fget, fset=None):
        self.fget = fget
        self.fset = fset

    def __get__(self, obj, klass=None):
        if klass is None:
            klass = type(obj)
        return self.fget.__get__(obj, klass)()

    def __set__(self, obj, value):
        if not self.fset:
            raise AttributeError("can't set attribute")
        type_ = type(obj)
        return self.fset.__get__(obj, type_)(value)

    def setter(self, func):
        if not isinstance(func, (classmethod, staticmethod)):
            func = classmethod(func)
        self.fset = func
        return self

def classproperty(func):
    if not isinstance(func, (classmethod, staticmethod)):
        func = classmethod(func)

    return ClassPropertyDescriptor(func)


class Bar(object):

    _bar = 1

    @classproperty
    def bar(cls):
        return cls._bar

    @bar.setter
    def bar(cls, value):
        cls._bar = value


# test instance instantiation
foo = Bar()
assert foo.bar == 1

baz = Bar()
assert baz.bar == 1

# test static variable
baz.bar = 5
assert foo.bar == 5

# test setting variable on the class
Bar.bar = 50
assert baz.bar == 50
assert foo.bar == 50

当我们调用Bar时，setter没有工作。酒吧，因为我们在打电话 TypeOfBar.bar。__set__，不是Bar.bar.__set__。

添加元类定义可以解决这个问题:

class ClassPropertyMetaClass(type):
    def __setattr__(self, key, value):
        if key in self.__dict__:
            obj = self.__dict__.get(key)
        if obj and type(obj) is ClassPropertyDescriptor:
            return obj.__set__(self, value)

        return super(ClassPropertyMetaClass, self).__setattr__(key, value)

# and update class define:
#     class Bar(object):
#        __metaclass__ = ClassPropertyMetaClass
#        _bar = 1

# and update ClassPropertyDescriptor.__set__
#    def __set__(self, obj, value):
#       if not self.fset:
#           raise AttributeError("can't set attribute")
#       if inspect.isclass(obj):
#           type_ = obj
#           obj = None
#       else:
#           type_ = type(obj)
#       return self.fset.__get__(obj, type_)(value)

现在一切都会好起来的。