blocks|key|1529617|text|半个解决方案，类上的__set__仍然不能工作。解决方案是同时实现属性和静态方法自定义属性类|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1529618|class+ClassProperty(object):
++++def+__init__(self,+fget,+fset):
++++++++self.fget+=+fget
++++++++self.fset+=+fset

++++def+__get__(self,+instance,+owner):
++++++++return+self.fget()

++++def+__set__(self,+instance,+value):
++++++++self.fset(value)

class+Foo(object):
++++_bar+=+1
++++def+get_bar():
++++++++print+'getting'
++++++++return+Foo._bar

++++def+set_bar(value):
++++++++print+'setting'
++++++++Foo._bar+=+value

++++bar+=+ClassProperty(get_bar,+set_bar)

f+=+Foo()
#__get__+works
f.bar
Foo.bar

f.bar+=+2
Foo.bar+=+3+#__set__+does+not|code-block|syntax|javascript|1529619|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Half a solution, __set__ on the class does not work, still. The solution is a custom property class implementing both a property and a staticmethod

<pre><code>class ClassProperty(object):
 def __init__(self, fget, fset):
 self.fget = fget
 self.fset = fset

 def __get__(self, instance, owner):
 return self.fget()

 def __set__(self, instance, value):
 self.fset(value)

class Foo(object):
 _bar = 1
 def get_bar():
 print 'getting'
 return Foo._bar

 def set_bar(value):
 print 'setting'
 Foo._bar = value

 bar = ClassProperty(get_bar, set_bar)

f = Foo()
#__get__ works
f.bar
Foo.bar

f.bar = 2
Foo.bar = 3 #__set__ does not
</code></pre>

blocks|key|1529682|text|试一试，它可以在不更改/添加大量现有代码的情况下完成工作。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1529683|>>>+class+foo(object):
...+++++_var+=+5
...+++++def+getvar(cls):
...+++++++++return+cls._var
...+++++getvar+=+classmethod(getvar)
...+++++def+setvar(cls,+value):
...+++++++++cls._var+=+value
...+++++setvar+=+classmethod(setvar)
...+++++var+=+property(lambda+self:+self.getvar(),+lambda+self,+val:+self.setvar(val))
...
>>>+f+=+foo()
>>>+f.var
5
>>>+f.var+=+3
>>>+f.var
3|code-block|syntax|javascript|1529684|property函数需要两个callable参数。给它们提供lambda包装器(它将实例作为第一个参数传递)，一切都很好。|offset|length|style|CODE|1529685|entityMap^0|0|0|0|8|E|8|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]|$I|T|J|U|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|N|$]]

Give this a try, it gets the job done without having to change/add a lot of existing code.

<pre><code>&gt;&gt;&gt; class foo(object):
... _var = 5
... def getvar(cls):
... return cls._var
... getvar = classmethod(getvar)
... def setvar(cls, value):
... cls._var = value
... setvar = classmethod(setvar)
... var = property(lambda self: self.getvar(), lambda self, val: self.setvar(val))
...
&gt;&gt;&gt; f = foo()
&gt;&gt;&gt; f.var
5
&gt;&gt;&gt; f.var = 3
&gt;&gt;&gt; f.var
3
</code></pre>

The <code>property</code> function needs two <code>callable</code> arguments. give them lambda wrappers (which it passes the instance as its first argument) and all is well.

blocks|key|1529730|text|Python+>=+3.9|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1529731|只需同时使用两个装饰器即可。参见this+answer。|offset|length|1529732|Python+<+3.9|1529733|属性是在类上创建的，但会影响实例。因此，如果您需要一个classmethod属性，请在元类上创建该属性。|1529734|>>>+class+foo(object):
...+++++_var+=+5
...+++++class+__metaclass__(type):++#+Python+2+syntax+for+metaclasses
...+++++++++pass
...+++++@classmethod
...+++++def+getvar(cls):
...+++++++++return+cls._var
...+++++@classmethod
...+++++def+setvar(cls,+value):
...+++++++++cls._var+=+value
...+++++
>>>+foo.__metaclass__.var+=+property(foo.getvar.im_func,+foo.setvar.im_func)
>>>+foo.var
5
>>>+foo.var+=+3
>>>+foo.var
3|code-block|syntax|javascript|1529735|但是既然你正在使用一个元类，如果你只是把类方法移到其中，它会读起来更好。|1529736|>>>+class+foo(object):
...+++++_var+=+5
...+++++class+__metaclass__(type):++#+Python+2+syntax+for+metaclasses
...+++++++++@property
...+++++++++def+var(cls):
...+++++++++++++return+cls._var
...+++++++++@var.setter
...+++++++++def+var(cls,+value):
...+++++++++++++cls._var+=+value
...+
>>>+foo.var
5
>>>+foo.var+=+3
>>>+foo.var
3|1529737|或者，使用Python3的metaclass=...语法，在foo类主体外部定义的元类，以及负责设置_var的初始值的元类|style|CODE|1529738|>>>+class+foo_meta(type):
...+++++def+__init__(cls,+*args,+**kwargs):
...+++++++++cls._var+=+5
...+++++@property
...+++++def+var(cls):
...+++++++++return+cls._var
...+++++@var.setter
...+++++def+var(cls,+value):
...+++++++++cls._var+=+value
...
>>>+class+foo(metaclass=foo_meta):
...+++++pass
...
>>>+foo.var
5
>>>+foo.var+=+3
>>>+foo.var
3|1529739|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/64738850/674039^0|0|G|B|0|0|0|0|0|0|0|D|D|U|3|1E|4|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|17|8|@]|9|@$D|18|E|19|1|1A]]|A|$]]|$1|F|3|G|5|6|7|1B|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|1C|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|1D|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|1E|8|@]|9|@]|A|$]]|$1|Q|3|R|5|L|7|1F|8|@]|9|@]|A|$M|N]]|$1|S|3|T|5|6|7|1G|8|@$D|1H|E|1I|U|V]|$D|1J|E|1K|U|V]|$D|1L|E|1M|U|V]]|9|@]|A|$]]|$1|W|3|X|5|L|7|1N|8|@]|9|@]|A|$M|N]]|$1|Y|3|-4|5|6|7|1O|8|@]|9|@]|A|$]]]|Z|$10|$5|11|12|13|A|$14|15]]]]

<h3>Python &gt;= 3.9</h3>
Just use both decorators together. See <a href="https://stackoverflow.com/a/64738850/674039">this answer</a>.
<h3>Python &lt; 3.9</h3>
A property is created on a class but affects an instance. So if you want a classmethod property, create the property on the metaclass.
<pre><code>&gt;&gt;&gt; class foo(object):
... _var = 5
... class __metaclass__(type): # Python 2 syntax for metaclasses
... pass
... @classmethod
... def getvar(cls):
... return cls._var
... @classmethod
... def setvar(cls, value):
... cls._var = value
... 
&gt;&gt;&gt; foo.__metaclass__.var = property(foo.getvar.im_func, foo.setvar.im_func)
&gt;&gt;&gt; foo.var
5
&gt;&gt;&gt; foo.var = 3
&gt;&gt;&gt; foo.var
3
</code></pre>
But since you're using a metaclass anyway, it will read better if you just move the classmethods in there.
<pre><code>&gt;&gt;&gt; class foo(object):
... _var = 5
... class __metaclass__(type): # Python 2 syntax for metaclasses
... @property
... def var(cls):
... return cls._var
... @var.setter
... def var(cls, value):
... cls._var = value
... 
&gt;&gt;&gt; foo.var
5
&gt;&gt;&gt; foo.var = 3
&gt;&gt;&gt; foo.var
3
</code></pre>
or, using Python 3's <code>metaclass=...</code> syntax, and the metaclass defined outside of the <code>foo</code> class body, and the metaclass responsible for setting the initial value of <code>_var</code>:
<pre><code>&gt;&gt;&gt; class foo_meta(type):
... def __init__(cls, *args, **kwargs):
... cls._var = 5
... @property
... def var(cls):
... return cls._var
... @var.setter
... def var(cls, value):
... cls._var = value
...
&gt;&gt;&gt; class foo(metaclass=foo_meta):
... pass
...
&gt;&gt;&gt; foo.var
5
&gt;&gt;&gt; foo.var = 3
&gt;&gt;&gt; foo.var
3
</code></pre>

blocks|key|1529800|text|如果你想通过实例化的对象访问class属性，那么只在meta类上设置它是没有帮助的，在这种情况下，你还需要在对象上安装一个普通属性(它会分派给class属性)。我认为下面的内容会更清楚一些：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1529801|#!/usr/bin/python

class+classproperty(property):
++++def+__get__(self,+obj,+type_):
++++++++return+self.fget.__get__(None,+type_)()

++++def+__set__(self,+obj,+value):
++++++++cls+=+type(obj)
++++++++return+self.fset.__get__(None,+cls)(value)

class+A+(object):

++++_foo+=+1

++++@classproperty
++++@classmethod
++++def+foo(cls):
++++++++return+cls._foo

++++@foo.setter
++++@classmethod
++++def+foo(cls,+value):
++++++++cls.foo+=+value

a+=+A()

print+a.foo

b+=+A()

print+b.foo

b.foo+=+5

print+a.foo

A.foo+=+10

print+b.foo

print+A.foo|code-block|syntax|javascript|1529802|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Setting it only on the meta class doesn't help if you want to access the class property via an instantiated object, in this case you need to install a normal property on the object as well (which dispatches to the class property). I think the following is a bit more clear:

<pre><code>#!/usr/bin/python

class classproperty(property):
 def __get__(self, obj, type_):
 return self.fget.__get__(None, type_)()

 def __set__(self, obj, value):
 cls = type(obj)
 return self.fset.__get__(None, cls)(value)

class A (object):

 _foo = 1

 @classproperty
 @classmethod
 def foo(cls):
 return cls._foo

 @foo.setter
 @classmethod
 def foo(cls, value):
 cls.foo = value

a = A()

print a.foo

b = A()

print b.foo

b.foo = 5

print a.foo

A.foo = 10

print b.foo

print A.foo
</code></pre>

blocks|key|1744754|text|我希望这个非常简单的只读@classproperty装饰器能帮助寻找类属性的人。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1744755|class+classproperty(object):

++++def+__init__(self,+fget):
++++++++self.fget+=+fget

++++def+__get__(self,+owner_self,+owner_cls):
++++++++return+self.fget(owner_cls)

class+C(object):

++++@classproperty
++++def+x(cls):
++++++++return+1

assert+C.x+==+1
assert+C().x+==+1|code-block|syntax|javascript|1744756|entityMap^0|C|E|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

I hope this dead-simple read-only <code>@classproperty</code> decorator would help somebody looking for classproperties.

<pre><code>class classproperty(object):

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

 def __get__(self, owner_self, owner_cls):
 return self.fget(owner_cls)

class C(object):

 @classproperty
 def x(cls):
 return 1

assert C.x == 1
assert C().x == 1
</code></pre>

blocks|key|1529894|text|这里有一个解决方案，既可以通过类进行访问，也可以通过使用元类的实例进行访问。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1529895|In+[1]:+class+ClassPropertyMeta(type):
+++...:+++++@property
+++...:+++++def+prop(cls):
+++...:+++++++++return+cls._prop
+++...:+++++def+__new__(cls,+name,+parents,+dct):
+++...:+++++++++#+This+makes+overriding+__getattr__+and+__setattr__+in+the+class+impossible,+but+should+be+fixable
+++...:+++++++++dct['__getattr__']+=+classmethod(lambda+cls,+attr:+getattr(cls,+attr))
+++...:+++++++++dct['__setattr__']+=+classmethod(lambda+cls,+attr,+val:+setattr(cls,+attr,+val))
+++...:+++++++++return+super(ClassPropertyMeta,+cls).__new__(cls,+name,+parents,+dct)
+++...:

In+[2]:+class+ClassProperty(object):
+++...:+++++__metaclass__+=+ClassPropertyMeta
+++...:+++++_prop+=+42
+++...:+++++def+__getattr__(self,+attr):
+++...:+++++++++raise+Exception('Never+gets+called')
+++...:

In+[3]:+ClassProperty.prop
Out[3]:+42

In+[4]:+ClassProperty.prop+=+1
---------------------------------------------------------------------------
AttributeError++++++++++++++++++++++++++++Traceback+(most+recent+call+last)
<ipython-input-4-e2e8b423818a>+in+<module>()
---->+1+ClassProperty.prop+=+1

AttributeError:+can't+set+attribute

In+[5]:+cp+=+ClassProperty()

In+[6]:+cp.prop
Out[6]:+42

In+[7]:+cp.prop+=+1
---------------------------------------------------------------------------
AttributeError++++++++++++++++++++++++++++Traceback+(most+recent+call+last)
<ipython-input-7-e8284a3ee950>+in+<module>()
---->+1+cp.prop+=+1

<ipython-input-1-16b7c320d521>+in+<lambda>(cls,+attr,+val)
++++++6+++++++++#+This+makes+overriding+__getattr__+and+__setattr__+in+the+class+impossible,+but+should+be+fixable
++++++7+++++++++dct['__getattr__']+=+classmethod(lambda+cls,+attr:+getattr(cls,+attr))
---->+8+++++++++dct['__setattr__']+=+classmethod(lambda+cls,+attr,+val:+setattr(cls,+attr,+val))
++++++9+++++++++return+super(ClassPropertyMeta,+cls).__new__(cls,+name,+parents,+dct)

AttributeError:+can't+set+attribute|code-block|syntax|javascript|1529896|这也适用于在元类中定义的setter。|1529897|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Here's a solution which should work for both access via the class and access via an instance which uses a metaclass.

<pre><code>In [1]: class ClassPropertyMeta(type):
 ...: @property
 ...: def prop(cls):
 ...: return cls._prop
 ...: def __new__(cls, name, parents, dct):
 ...: # This makes overriding __getattr__ and __setattr__ in the class impossible, but should be fixable
 ...: dct['__getattr__'] = classmethod(lambda cls, attr: getattr(cls, attr))
 ...: dct['__setattr__'] = classmethod(lambda cls, attr, val: setattr(cls, attr, val))
 ...: return super(ClassPropertyMeta, cls).__new__(cls, name, parents, dct)
 ...:

In [2]: class ClassProperty(object):
 ...: __metaclass__ = ClassPropertyMeta
 ...: _prop = 42
 ...: def __getattr__(self, attr):
 ...: raise Exception('Never gets called')
 ...:

In [3]: ClassProperty.prop
Out[3]: 42

In [4]: ClassProperty.prop = 1
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
&lt;ipython-input-4-e2e8b423818a&gt; in &lt;module&gt;()
----&gt; 1 ClassProperty.prop = 1

AttributeError: can't set attribute

In [5]: cp = ClassProperty()

In [6]: cp.prop
Out[6]: 42

In [7]: cp.prop = 1
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
&lt;ipython-input-7-e8284a3ee950&gt; in &lt;module&gt;()
----&gt; 1 cp.prop = 1

&lt;ipython-input-1-16b7c320d521&gt; in &lt;lambda&gt;(cls, attr, val)
 6 # This makes overriding __getattr__ and __setattr__ in the class impossible, but should be fixable
 7 dct['__getattr__'] = classmethod(lambda cls, attr: getattr(cls, attr))
----&gt; 8 dct['__setattr__'] = classmethod(lambda cls, attr, val: setattr(cls, attr, val))
 9 return super(ClassPropertyMeta, cls).__new__(cls, name, parents, dct)

AttributeError: can't set attribute
</code></pre>

This also works with a setter defined in the metaclass.

blocks|key|1744855|text|在搜索了不同的位置后，我找到了一种方法来定义一个在Python2和3中有效的类属性。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1744856|from+future.utils+import+with_metaclass

class+BuilderMetaClass(type):
++++@property
++++def+load_namespaces(self):
++++++++return+(self.__sourcepath__)

class+BuilderMixin(with_metaclass(BuilderMetaClass,+object)):
++++__sourcepath__+=+'sp'++++++++

print(BuilderMixin.load_namespaces)|code-block|syntax|javascript|1744857|希望这能帮助到一些人:)|1744858|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

After searching different places, I found a method to define a classproperty
valid with Python 2 and 3.

<pre><code>from future.utils import with_metaclass

class BuilderMetaClass(type):
 @property
 def load_namespaces(self):
 return (self.__sourcepath__)

class BuilderMixin(with_metaclass(BuilderMetaClass, object)):
 __sourcepath__ = 'sp' 

print(BuilderMixin.load_namespaces)
</code></pre>

Hope this can help somebody :)

blocks|key|1744904|text|下面是我的解决方案，它也缓存类属性|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1744905|class+class_property(object):
++++#+this+caches+the+result+of+the+function+call+for+fn+with+cls+input
++++#+use+this+as+a+decorator+on+function+methods+that+you+want+converted
++++#+into+cached+properties

++++def+__init__(self,+fn):
++++++++self._fn_name+=+fn.__name__
++++++++if+not+isinstance(fn,+(classmethod,+staticmethod)):
++++++++++++fn+=+classmethod(fn)
++++++++self._fn+=+fn

++++def+__get__(self,+obj,+cls=None):
++++++++if+cls+is+None:
++++++++++++cls+=+type(obj)
++++++++if+(
++++++++++++self._fn_name+in+vars(cls)+and
++++++++++++type(vars(cls)[self._fn_name]).__name__+!=+"class_property"
++++++++):
++++++++++++return+vars(cls)[self._fn_name]
++++++++else:
++++++++++++value+=+self._fn.__get__(obj,+cls)()
++++++++++++setattr(cls,+self._fn_name,+value)
++++++++++++return+value|code-block|syntax|javascript|1744906|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here is my solution that also caches the class property
<pre><code>class class_property(object):
 # this caches the result of the function call for fn with cls input
 # use this as a decorator on function methods that you want converted
 # into cached properties

 def __init__(self, fn):
 self._fn_name = fn.__name__
 if not isinstance(fn, (classmethod, staticmethod)):
 fn = classmethod(fn)
 self._fn = fn

 def __get__(self, obj, cls=None):
 if cls is None:
 cls = type(obj)
 if (
 self._fn_name in vars(cls) and
 type(vars(cls)[self._fn_name]).__name__ != &quot;class_property&quot;
 ):
 return vars(cls)[self._fn_name]
 else:
 value = self._fn.__get__(obj, cls)()
 setattr(cls, self._fn_name, value)
 return value
</code></pre>

blocks|key|1530011|text|基于https://stackoverflow.com/a/1800999/2290820|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1530012|class+MetaProperty(type):

++++def+__init__(cls,+*args,+**kwargs):
++++++++super()

++++@property
++++def+praparty(cls):
++++++++return+cls._var

++++@praparty.setter
++++def+praparty(cls,+val):
++++++++cls._var+=+val


class+A(metaclass=MetaProperty):
++++_var+=+5


print(A.praparty)
A.praparty+=+6
print(A.praparty)|code-block|syntax|javascript|1530013|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/1800999/2290820^0|2|17|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

Based on <a href="https://stackoverflow.com/a/1800999/2290820">https://stackoverflow.com/a/1800999/2290820</a>
<pre class="lang-py prettyprint-override"><code>
class MetaProperty(type):

 def __init__(cls, *args, **kwargs):
 super()

 @property
 def praparty(cls):
 return cls._var

 @praparty.setter
 def praparty(cls, val):
 cls._var = val


class A(metaclass=MetaProperty):
 _var = 5


print(A.praparty)
A.praparty = 6
print(A.praparty)
</code></pre>

blocks|key|1745000|text|对于Python+3.9之前的函数式方法，您可以使用以下命令：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1745001|def+classproperty(fget):
++return+type(
++++++'classproperty',
++++++(),
++++++{'__get__':+lambda+self,+_,+cls:+fget(cls),+'__module__':+None}
++)()
++
class+Item:
++a+=+47

++@classproperty
++def+x(cls):
++++return+cls.a

Item.x|code-block|syntax|javascript|1745002|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

For a functional approach pre Python 3.9 you can use this:
<pre><code>def classproperty(fget):
 return type(
 'classproperty',
 (),
 {'__get__': lambda self, _, cls: fget(cls), '__module__': None}
 )()
 
class Item:
 a = 47

 @classproperty
 def x(cls):
 return cls.a

Item.x
</code></pre>

I have a class with two class methods (using the <code>classmethod()</code> function) for getting and setting what is essentially a static variable. I tried to use the <code>property()</code> function with these, but it results in an error. I was able to reproduce the error with the following in the interpreter:
<pre><code>class Foo(object):
 _var = 5
 @classmethod
 def getvar(cls):
 return cls._var
 @classmethod
 def setvar(cls, value):
 cls._var = value
 var = property(getvar, setvar)
</code></pre>
I can demonstrate the class methods, but they don't work as properties:
<pre><code>&gt;&gt;&gt; f = Foo()
&gt;&gt;&gt; f.getvar()
5
&gt;&gt;&gt; f.setvar(4)
&gt;&gt;&gt; f.getvar()
4
&gt;&gt;&gt; f.var
Traceback (most recent call last):
 File &quot;&lt;stdin&gt;&quot;, line 1, in ?
TypeError: 'classmethod' object is not callable
&gt;&gt;&gt; f.var=5
Traceback (most recent call last):
 File &quot;&lt;stdin&gt;&quot;, line 1, in ?
TypeError: 'classmethod' object is not callable
</code></pre>
Is it possible to use the <code>property()</code> function with <code>@classmethod</code> decorated functions?

Using property() on classmethods

解释器

Python

我有一个包含两个类方法的类(使用classmethod()函数)，用于获取和设置本质上是静态变量的内容。我试图对这些函数使用property()函数，但它导致了一个错误。我能够在解释器中使用以下代码重现错误：class Foo(object):    _var = 5    @classmethod    def ge...

问在类方法上使用property()
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在类方法上使用property()EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在类方法上使用property()
EN