在python中，我可以使用@classmethod装饰器向类添加方法。是否有类似的装饰器向类中添加属性？我可以更好地展示我在说什么。
class Example(object):
the_I = 10
def __init__( self ):
self.an_i = 20
@property
def i( self ):
return self.an_i
def inc_i( self ):
self.an_i += 1
# is this even possible?
@classproperty
def I( cls ):
return cls.the_I
@classmethod
def inc_I( cls ):
cls.the_I += 1
e = Example()
assert e.i == 20
e.inc_i()
assert e.i == 21
assert Example.I == 10
Example.inc_I()
assert Example.I == 11
我上面使用的语法是否可行，还是需要更多内容？
我想要类属性的原因是我可以延迟加载类属性，这似乎足够合理。
答案 0 :(得分：70)
以下是我将如何做到这一点：
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.bar时，设定者没有工作，因为我们正在打电话
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)
现在一切都会好的。
答案 1 :(得分：33)
如果按如下方式定义classproperty，那么您的示例将完全按照您的要求运行。
class classproperty(object):
def __init__(self, f):
self.f = f
def __get__(self, obj, owner):
return self.f(owner)
需要注意的是，您不能将其用于可写属性。虽然e.I = 20会引发AttributeError，但Example.I = 20会覆盖属性对象本身。
答案 2 :(得分：24)
我认为你可以用元类做到这一点。因为元类可以像类的类（如果有意义的话）。我知道您可以为元类分配__call__()方法来覆盖调用类MyClass()。我想知道在元类上使用property装饰器的操作是否类似。 （我之前没试过，但现在我好奇......）
[更新：]
哇，确实有效：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__，其余内容相同。
答案 3 :(得分：17)
[基于python 3.4编写的答案;元类语法在2中有所不同，但我认为该技术仍然有效]
你可以用元类来做这件事......大多数情况下。 Dappawit几乎可以工作，但我认为它有一个缺陷：
class MetaFoo(type):
@property
def thingy(cls):
return cls._thingy
class Foo(object, metaclass=MetaFoo):
_thingy = 23
这会让你获得Foo的课堂资格，但是有一个问题......
print("Foo.thingy is {}".format(Foo.thingy))
# Foo.thingy is 23
# Yay, the classmethod-property is working as intended!
foo = Foo()
if hasattr(foo, "thingy"):
print("Foo().thingy is {}".format(foo.thingy))
else:
print("Foo instance has no attribute 'thingy'")
# Foo instance has no attribute 'thingy'
# Wha....?
这到底是怎么回事？为什么我无法从实例到达类属性？
在找到我认为的答案之前，我在这方面打了很长时间。 Python @properties是描述符的子集，并且来自descriptor documentation（强调我的）：
属性访问的默认行为是获取，设置或删除 来自对象字典的属性。例如，
a.x有一个查找链 从a.__dict__['x']开始，然后是type(a).__dict__['x']，然后继续 通过type(a)的基类除了元类。
因此，方法解析顺序不包括我们的类属性（或元类中定义的任何其他内容）。它是可能使内置属性装饰器的子类行为不同，但是（需要引用）我已经得到了开发人员有充分理由（我做的）的印象这样做是不明白的。
这并不意味着我们运气不好;我们可以很好地访问类本身的属性......我们可以从实例中的type(self)获取类，我们可以使用它来创建@property调度程序：
class Foo(object, metaclass=MetaFoo):
_thingy = 23
@property
def thingy(self):
return type(self).thingy
现在Foo().thingy按预期用于类和实例！如果派生类替换了它的基础_thingy（这是最初让我进行此搜索的用例），它也将继续做正确的事。
这并不是100％令我满意 - 不得不在元类和对象类中进行设置，感觉它违反了DRY原则。但后者只是一个单线调度员;我现在大部分都可以，如果你真的想要的话，你可以将它压缩成lambda或其他东西。
答案 4 :(得分：4)
据我所知，在没有创建新元类的情况下，没有办法为类属性编写setter。
我发现以下方法有效。使用所需的所有类属性和设置器定义元类。 IE，我想要一个带有title属性的类和一个setter。这是我写的：
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...
如上所述，如果我们只在单个类上使用它，那么定义这个元类有点奇怪。在这种情况下，如果您使用的是Python 2样式，则可以在类主体中实际定义元类。这样，它就没有在模块范围内定义。
答案 5 :(得分：1)
如果您只需要延迟加载，那么您可以使用类初始化方法。
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
但是元类方法似乎更清晰，行为更可预测。
也许您正在寻找的是Singleton设计模式。关于在Python中实现共享状态有a nice SO QA。
答案 6 :(得分：1)
如果您使用的是Django，则它具有内置的@classproperty装饰器。
答案 7 :(得分：0)
我碰巧想出了一个与@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以使其有所不同，而没有通过以下方式在每个类中（也没有默认值）对其进行定义：
def __new__(mc1, name, bases, nmspc):
nmspc.update({'thingy': MetaFoo.services, '_thingy': None})
return super(MetaFoo, mc1).__new__(mc1, name, bases, nmspc)
答案 8 :(得分：0)
def _create_type(meta, name, attrs):
type_name = f'{name}Type'
type_attrs = {}
for k, v in attrs.items():
if type(v) is _ClassPropertyDescriptor:
type_attrs[k] = v
return type(type_name, (meta,), type_attrs)
class ClassPropertyType(type):
def __new__(meta, name, bases, attrs):
Type = _create_type(meta, name, attrs)
cls = super().__new__(meta, name, bases, attrs)
cls.__class__ = Type
return cls
class _ClassPropertyDescriptor(object):
def __init__(self, fget, fset=None):
self.fget = fget
self.fset = fset
def __get__(self, obj, owner):
if self in obj.__dict__.values():
return self.fget(obj)
return self.fget(owner)
def __set__(self, obj, value):
if not self.fset:
raise AttributeError("can't set attribute")
return self.fset(obj, value)
def setter(self, func):
self.fset = func
return self
def classproperty(func):
return _ClassPropertyDescriptor(func)
class Bar(metaclass=ClassPropertyType):
__bar = 1
@classproperty
def bar(cls):
return cls.__bar
@bar.setter
def bar(cls, value):
cls.__bar = value