How to make a class property

Question

In python I can add a method to a class with the  classmethod decorator   Is there a similar decorator to add a property to a class   I can better show what I m talking about   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   Is the syntax I ve used above possible or would it require something more   The reason I want class properties is so I can lazy load class attributes  which seems reasonable enough

User · Answer

I think you may be able to do this with the metaclass. Since the metaclass can be like a class for the class (if that makes sense). I know you can assign a __call__() method to the metaclass to override calling the class, MyClass(). I wonder if using the property decorator on the metaclass operates similarly. (I haven't tried this before, but now I'm curious...)

[update:]

Wow, it does work:

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

Note: This is in Python 2.7. Python 3+ uses a different technique to declare a metaclass. Use: class MyClass(metaclass=MetaClass):, remove __metaclass__, and the rest is the same.

User · Answer

If you only need lazy loading  then you could just have a class initialisation method   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   But the metaclass approach seems cleaner  and with more predictable behavior   Perhaps what you re looking for is the Singleton design pattern  There s a nice SO QA about implementing shared state in Python

User · Answer

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  bar   Bar   assert Bar bar  1 Bar bar 2 assert bar bar  2 nbar   Bar   assert nbar bar  2

User · Answer

If you use Django  it has a built in  classproperty decorator   from django utils decorators import classproperty

User · Answer

Here s how I would do this   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   The setter didn t work at the time we call  Bar bar  because we are calling TypeOfBar bar   set    which is not Bar bar   set     Adding a metaclass definition solves this   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    Now all will be fine

User · Answer

answer written based on python 3 4  the metaclass syntax differs in 2 but I think the technique will still work   You can do this with a metaclass   mostly  Dappawit s almost works  but I think it has a flaw   class MetaFoo type        property     def thingy cls           return cls  thingy  class Foo object  metaclass MetaFoo        thingy   23   This gets you a classproperty on Foo  but there s a problem     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        What the hell is going on here  Why can t I reach the class property from an instance   I was beating my head on this for quite a while before finding what I believe is the answer  Python  properties are a subset of descriptors  and  from the descriptor documentation  emphasis mine       The default behavior for attribute access is to get  set  or delete the   attribute from an object   s dictionary  For instance  a x has a lookup chain   starting with a   dict    x    then type a    dict    x    and continuing    through the base classes of type a  excluding metaclasses    So the method resolution order doesn t include our class properties  or anything else defined in the metaclass   It is possible to make a subclass of the built-in property decorator that behaves differently  but  citation needed  I ve gotten the impression googling that the developers had a good reason  which I do not understand  for doing it that way   That doesn t mean we re out of luck  we can access the properties on the class itself just fine   and we can get the class from type self  within the instance  which we can use to make  property dispatchers   class Foo object  metaclass MetaFoo        thingy   23       property     def thingy self           return type self  thingy   Now Foo   thingy works as intended for both the class and the instances  It will also continue to do the right thing if a derived class replaces its underlying  thingy  which is the use case that got me on this hunt originally    This isn t 100  satisfying to me -- having to do setup in both the metaclass and object class feels like it violates the DRY principle  But the latter is just a one-line dispatcher  I m mostly okay with it existing  and you could probably compact it down to a lambda or something if you really wanted

User · Answer

As far as I can tell  there is no way to write a setter for a class property without creating a new metaclass   I have found that the following method works  Define a metaclass with all of the class properties and setters you want  IE  I wanted a class with a title property with a setter  Here s what I wrote   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      Now make the actual class you want as normal  except have it use the metaclass you created above     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      It s a bit weird to define this metaclass as we did above if we ll only ever use it on the single class  In that case  if you re using the Python 2 style  you can actually define the metaclass inside the class body  That way it s not defined in the module scope

User · Answer

If you define classproperty as follows  then your example works exactly as you requested   class classproperty object       def   init   self  f           self f   f     def   get   self  obj  owner           return self f owner    The caveat is that you can t use this for writable properties   While e I   20 will raise an AttributeError  Example I   20 will overwrite the property object itself

User · Answer

I happened to come up with a solution very similar to  Andrew  only 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   This has the best of all answers   The  metaproperty  is added to the class  so that it will still be a property of the instance   Don t need to redefine thingy in any of the classes The property works as a  class property  in for both instance and class You have the flexibility to customize how  thingy is inherited   In my case  I actually customized  thingy to be different for every child  without defining it in each class  and without a default value  by      def   new   mc1  name  bases  nmspc          nmspc update   thingy   MetaFoo services    thingy   None          return super MetaFoo  mc1    new   mc1  name  bases  nmspc

[python] How to make a class property?

Examples related to python

Examples related to properties

Examples related to class-method