我认为您可以通过元类来实现这一点。因为元类可以像类的类(如果有意义的话)。我知道你可以给元类赋一个__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__，其余部分相同。

我认为您可以通过元类来实现这一点。因为元类可以像类的类(如果有意义的话)。我知道你可以给元类赋一个__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__，其余部分相同。

如果你只需要惰性加载，那么你可以只需要一个类初始化方法。

EXAMPLE_SET = False
class Example(object):
   @classmethod 
   def initclass(cls):
       global EXAMPLE_SET 
       if EXAMPLE_SET: return
       cls.the_I = 'ok'
       EXAMPLE_SET = True

   def __init__( self ):
      Example.initclass()
      self.an_i = 20

try:
    print Example.the_I
except AttributeError:
    print 'ok class not "loaded"'
foo = Example()
print foo.the_I
print Example.the_I

但是元类方法看起来更简洁，行为更可预测。

也许您正在寻找的是单例设计模式。关于在Python中实现共享状态，有一个很好的SO QA。

以下是我的做法:

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)

现在一切都会好起来的。

如果您按如下方式定义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将覆盖属性对象本身。

据我所知，如果不创建一个新的元类，就无法为类属性编写setter。

我发现下面的方法是有效的。定义一个具有所需的所有类属性和setter的元类。IE，我需要一个带有setter的title属性的类。以下是我所写的:

class TitleMeta(type):
    @property
    def title(self):
        return getattr(self, '_title', 'Default Title')

    @title.setter
    def title(self, title):
        self._title = title
        # Do whatever else you want when the title is set...

现在让您想要的实际类正常，除了让它使用您上面创建的元类。

# Python 2 style:
class ClassWithTitle(object):
    __metaclass__ = TitleMeta
    # The rest of your class definition...

# Python 3 style:
class ClassWithTitle(object, metaclass = TitleMeta):
    # Your class definition...

如果我们只在单个类上使用这个元类，那么像上面那样定义它就有点奇怪了。在这种情况下，如果您使用的是python2风格，您实际上可以在类主体中定义元类。这样它就不在模块范围内定义。