How to add property to a class dynamically

Question

The goal is to create a mock class which behaves like a db resultset   So for example  if a database query returns  using a dict expression    ab  100   cd  200   then I would like to see     gt  gt  gt  dummy ab 100   At first I thought maybe I could do it this way   ks     ab    cd   vs    12  34  class C dict       def   init   self  ks  vs           for i  k in enumerate ks               self k    vs i              setattr self  k  property lambda x  vs i   self fn readyonly        def fn readonly self  v          raise  It is ready only   if   name         main         c   C ks  vs      print c ab   but c ab returns a property object instead   Replacing the setattr line with k   property lambda x  vs i   is of no use at all   So what is the right way to create an instance property at runtime   P S  I am aware of an alternative presented in How is the   getattribute   method used

User · Answer

To answer the main thrust of your question, you want a read-only attribute from a dict as an immutable datasource:

The goal is to create a mock class which behaves like a db resultset.

So for example, if a database query returns, using a dict expression, {'ab':100, 'cd':200}, then I would to see
>>> dummy.ab
100

I'll demonstrate how to use a namedtuple from the collections module to accomplish just this:

import collections

data = {'ab':100, 'cd':200}

def maketuple(d):
    '''given a dict, return a namedtuple'''
    Tup = collections.namedtuple('TupName', d.keys()) # iterkeys in Python2
    return Tup(**d)

dummy = maketuple(data)
dummy.ab

returns 100

User · Answer

Something that works for me is this   class C      def   init   self           self  x None      def g self           return self  x      def s self  x           self  x   x      def d self           del self  x      def s2 self x           self  x x x      x property g s d    c   C   c x  a  print c x   C x property C g  C s2  C x C x deleter C d  c2   C   c2 x  a  print c2 x      Output  a aa

User · Answer

How to add property to a python class dynamically   Say you have an object that you want to add a property to  Typically  I want to use properties when I need to begin managing access to an attribute in code that has downstream usage  so that I can maintain a consistent API  Now I will typically add them to the source code where the object is defined  but let s assume you don t have that access  or you need to truly dynamically choose your functions programmatically  Create a class Using an example based on the documentation for property  let s create a class of object with a  quot hidden quot  attribute and create an instance of it  class C object          basic class         x   None  o   C    In Python  we expect there to be one obvious way of doing things  However  in this case  I m going to show two ways  with decorator notation  and without   First  without decorator notation  This may be more useful for the dynamic assignment of getters  setters  or deleters  Dynamic  a k a  Monkey Patching  Let s create some for our class  def getx self       return self  x  def setx self  value       self  x   value  def delx self       del self  x  And now we assign these to the property  Note that we could choose our functions programmatically here  answering the dynamic question  C x   property getx  setx  delx   quot I m the  x  property  quot    And usage   gt  gt  gt  o x    foo   gt  gt  gt  o x  foo   gt  gt  gt  del o x  gt  gt  gt  print o x  None  gt  gt  gt  help C x  Help on property       I m the  x  property   Decorators We could do the same as we did above with decorator notation  but in this case  we must name the methods all the same name  and I d recommend keeping it the same as the attribute   so programmatic assignment is not so trivial as it is using the above method   property def x self          I m the  x  property         return self  x   x setter def x self  value       self  x   value   x deleter def x self       del self  x  And assign the property object with its provisioned setters and deleters to the class  C x   x  And usage   gt  gt  gt  help C x  Help on property       I m the  x  property    gt  gt  gt  o x  gt  gt  gt  o x    foo   gt  gt  gt  o x  foo   gt  gt  gt  del o x  gt  gt  gt  print o x  None

User · Answer

This seems to work but see below    class data dict object       def   init   self  args   argd           dict   init   self  args   argd          self   dict   update self      def   setattr   self name value           raise AttributeError  Attribute   s  of   s  object cannot be set   name self   class     name        def   delattr   self name           raise AttributeError  Attribute   s  of   s  object cannot be deleted   name self   class     name      If you need more complex behavior  feel free to edit your answer   edit  The following would probably be more memory-efficient for large datasets   class data dict object       def   init   self  args   argd           dict   init   self  args   argd      def   getattr   self name           return self name      def   setattr   self name value           raise AttributeError  Attribute   s  of   s  object cannot be set   name self   class     name        def   delattr   self name           raise AttributeError  Attribute   s  of   s  object cannot be deleted   name self   class     name

User · Answer

class atdict dict     def   init   self  value    kwargs       super     init     kwargs      self   dict   value    def   getattr   self  name       for key in self   dict        if type self   dict key   is list          for idx  item in enumerate self   dict key              if type item  is dict              self   dict key  idx    atdict item        if type self   dict key   is dict          self   dict key    atdict self   dict key       return self   dict name     d1   atdict   a      b      c   1   2      print d1 a b 0  c    And the output is    gt  gt  1

User · Answer

Only way to dynamically attach a property is to create a new class and its instance with your new property     class Holder  p   property lambda x  vs i   self fn readonly  setattr self  k  Holder   p

User · Answer

The goal is to create a mock class which behaves like a db resultset    So what you want is a dictionary where you can spell a  b   as a b   That s easy   class atdict dict         getattr    dict   getitem         setattr    dict   setitem         delattr    dict   delitem

User · Answer

I asked a similary question on this Stack Overflow post to create a class factory which created simple types  The outcome was this answer which had a working version of the class factory  Here is a snippet of the answer   def Struct  args    kwargs       def init self   iargs    ikwargs           for k v in kwargs items                setattr self  k  v          for i in range len iargs                setattr self  args i   iargs i           for k v in ikwargs items                setattr self  k  v       name   kwargs pop  name    MyStruct       kwargs update dict  k  None  for k in args       return type name   object        init     init     slots     kwargs keys       gt  gt  gt  Person   Struct  fname    age    gt  gt  gt  person1   Person  Kevin   25   gt  gt  gt  person2   Person age 42  fname  Terry    gt  gt  gt  person1 age    10  gt  gt  gt  person2 age -  10  gt  gt  gt  person1 fname  person1 age  person2 fname  person2 age   Kevin   35   Terry   32   gt  gt  gt    You could use some variation of this to create default values which is your goal  there is also an answer in that question which deals with this

User · Answer

Here is the simple example to create property object programmatically      usr bin python3  class Counter      def   init   self           cls   self   class           self  count   0         cls count   self count ref        def count get self           print f count get   self  count            return self  count      def count set self  value           self  count   value         print f count set   self  count         def count del self           print f count del   self  count         def count ref self           cls   self   class           return property fget cls count get  fset cls count set  fdel cls count del   counter   Counter    counter count for i in range 5       counter count   i del counter count      output        count get  0 count set  0 count set  1 count set  2 count set  3 count set  4 count del  4

User · Answer

You can use the following code to update class attributes using a dictionary object   class ExampleClass        def   init   self  argv           for key  val in argv items                self   dict   key    val  if   name         main         argv     intro    Hello World        instance   ExampleClass argv      print instance intro

User · Answer

You don t need to use a property for that  Just override   setattr   to make them read only   class C object       def   init   self  keys  values           for  key  value  in zip keys  values               self   dict   key    value      def   setattr   self  name  value           raise Exception  It is read only      Tada    gt  gt  gt  c   C  abc    1 2 3    gt  gt  gt  c a 1  gt  gt  gt  c b 2  gt  gt  gt  c c 3  gt  gt  gt  c d Traceback  most recent call last     File   lt stdin gt    line 1  in  lt module gt  AttributeError   C  object has no attribute  d   gt  gt  gt  c d   42 Traceback  most recent call last     File   lt stdin gt    line 1  in  lt module gt    File   lt stdin gt    line 6  in   setattr   Exception  It is read only   gt  gt  gt  c a    blah  Traceback  most recent call last     File   lt stdin gt    line 1  in  lt module gt    File   lt stdin gt    line 6  in   setattr   Exception  It is read only

User · Answer

Here is a solution that    Allows specifying property names as strings  so they can come from some outside data source instead of all being listed in your program  Adds the properties when the class is defined  instead of every time an object is created    After the class has been defined  you just do this to add a property to it dynamically   setattr SomeClass   propertyName   property getter  setter     Here is a complete example  tested in Python 3      usr bin env python3  class Foo      pass  def get x self     return 3  def set x self  value     print  set x on  s to  d     self  value    setattr Foo   x   property get x  set x    foo1   Foo   foo1 x   12 print foo1 x

User · Answer

Although many answers are given  I couldn t find one I am happy with  I figured out my own solution which makes property work for the dynamic case  The source to answer the original question      usr local bin python3  INITS      ab   100   cd   200    class DP dict     def   init   self       super     init         for k v in INITS items            self k    v   def  dict set dp  key  value     dp key    value  for item in INITS keys      setattr      DP      item      lambda key  property        lambda self  self key   lambda self  value   dict set self  key  value        item       a   DP   print a       ab   100   cd   200  a ab    ab100  a cd   False print a ab  a cd    ab100 False

User · Answer

This is a little different than what OP wanted  but I rattled my brain until I got a working solution  so I m putting here for the next guy gal  I needed a way to specify dynamic setters and getters   class X      def   init   self  a 0  b 0  c 0           self a   a         self b   b         self c   c       classmethod     def  make properties cls  field name  inc            inc   inc          def  get properties self               if not hasattr self     s inc    field name                   setattr self     s inc    field name   inc                  inc    inc             else                  inc   getattr self     s inc    field name               return getattr self  field name    inc          def  set properties self  value               setattr self     s inc    field name  value           return property  get properties   set properties    I know my fields ahead of time so im going to create my properties  NOTE  you cannot do this PER instance  these properties will exist on the class     for inc  field in enumerate   a    b    c         setattr X    s summed    field  X  make properties field  inc     Let s test it all now    x   X   assert x a    0 assert x b    0 assert x c    0  assert x a summed    0    enumerate   set inc to 0   0   0 assert x b summed    1    enumerate   set inc to 1   0   1 assert x c summed    2    enumerate   set inc to 2   0   2    we set the variables to something x a   1 x b   2 x c   3  assert x a summed    1    enumerate   set inc to 0   1   1 assert x b summed    3    enumerate   set inc to 1   2   3 assert x c summed    5    enumerate   set inc to 2   3   5    we re changing the inc now x a summed   1  x b summed   3  x c summed   5  assert x a summed    2    we set inc to 1   the property was 1   2 assert x b summed    5    we set inc to 3   the property was 2   5 assert x c summed    8    we set inc to 5   the property was 3   8   Is it confusing  Yes  sorry I couldn t come up with any meaningful real world examples  Also  this is not for the light hearted

User · Answer

Extending the idea from kjfletch    This is my humble contribution  extending the idea to serialize   data from and to tuples  comparison operations and allowing functions   as default values   def Struct  args    kwargs       FUNCTIONS    types BuiltinFunctionType  types BuiltinMethodType                     types FunctionType  types MethodType      def init self   iargs    ikwargs              Asume that unamed args are placed in the same order than         astuple   yields  currently alphabetic order                      kw   list self   slots               set the unnamed args         for i in range len iargs                k   kw pop 0              setattr self  k  iargs i              set the named args         for k  v in ikwargs items                setattr self  k  v              kw remove k             set default values         for k in kw              v   kwargs k              if isinstance v  FUNCTIONS                   v   v               setattr self  k  v       def astuple self           return tuple  getattr self  k  for k in self   slots          def   str   self           data            format k  getattr self  k   for k in self   slots            return   lt        gt   format self   class     name         join data        def   repr   self           return str self       def   eq   self  other           return self astuple      other astuple        name   kwargs pop    name      MyStruct       slots   list args      slots extend kwargs keys          set non-specific default values to None     kwargs update dict  k  None  for k in args        return type name   object                 init     init             slots     tuple slots            astuple   astuple             str       str               repr       repr               eq       eq             Event   Struct  user    cmd                     arg1    arg2                     date time time                     name    Event    aa   Event  pepe   77  print aa  raw   aa astuple    bb   Event  raw  print bb   if aa    bb      print  Are equals    cc   Event cmd  foo   print cc    Output    lt Event  user pepe  cmd 77  arg1 None  arg2 None  date 1550051398 3651814 gt   lt Event  user pepe  cmd 77  arg1 None  arg2 None  date 1550051398 3651814 gt  Are equals  lt Event  user None  cmd foo  arg1 None  arg2 None  date 1550051403 7938335 gt

User · Answer

I suppose I should expand this answer  now that I m older and wiser and know what s going on   Better late than never  You can add a property to a class dynamically   But that s the catch  you have to add it to the class   gt  gt  gt  class Foo object           pass       gt  gt  gt  foo   Foo    gt  gt  gt  foo a   3  gt  gt  gt  Foo b   property lambda self  self a   1   gt  gt  gt  foo b 4  A property is actually a simple implementation of a thing called a descriptor   It s an object that provides custom handling for a given attribute  on a given class   Kinda like a way to factor a huge if tree out of   getattribute    When I ask for foo b in the example above  Python sees that the b defined on the class implements the descriptor protocol   which just means it s an object with a   get      set    or   delete   method   The descriptor claims responsibility for handling that attribute  so Python calls Foo b   get   foo  Foo   and the return value is passed back to you as the value of the attribute   In the case of property  each of these methods just calls the fget  fset  or fdel you passed to the property constructor  Descriptors are really Python s way of exposing the plumbing of its entire OO implementation   In fact  there s another type of descriptor even more common than property   gt  gt  gt  class Foo object           def bar self               pass       gt  gt  gt  Foo   bar  lt bound method Foo bar of  lt   main   Foo object at 0x7f2a439d5dd0 gt  gt   gt  gt  gt  Foo   bar   get    lt method-wrapper    get    of instancemethod object at 0x7f2a43a8a5a0 gt   The humble method is just another kind of descriptor   Its   get   tacks on the calling instance as the first argument  in effect  it does this  def   get   self  instance  owner       return functools partial self function  instance   Anyway  I suspect this is why descriptors only work on classes  they re a formalization of the stuff that powers classes in the first place   They re even the exception to the rule  you can obviously assign descriptors to a class  and classes are themselves instances of type   In fact  trying to read Foo bar still calls property   get    it s just idiomatic for descriptors to return themselves when accessed as class attributes  I think it s pretty cool that virtually all of Python s OO system can be expressed in Python      Oh  and I wrote a wordy blog post about descriptors a while back if you re interested

User · Answer

Not sure if I completely understand the question  but you can modify instance properties at runtime with the built-in   dict   of your class   class C object       def   init   self  ks  vs           self   dict     dict zip ks  vs     if   name         main         ks     ab    cd       vs    12  34      c   C ks  vs      print c ab    12

User · Answer

I recently ran into a similar problem  the solution that I came up with uses   getattr   and   setattr   for the properties that I want it to handle  everything else gets passed on to the originals   class C object       def   init   self  properties           self existing    Still Here          self properties   properties      def   getattr   self  name           if  properties  in self   dict   and name in self properties              return self properties name    Or call a function  etc         return self   dict   name       def   setattr   self  name  value           if  properties  in self   dict   and name in self properties              self properties name    value         else              self   dict   name    value  if   name         main         my properties     a  1   b  2   c  3      c   C my properties      assert c a    1     assert c existing     Still Here      c b   10     assert c properties  b      10

User · Answer

For those coming from search engines  here are the two things I was looking for when talking about dynamic properties   class Foo      def   init   self             we can dynamically have access to the properties dict using   dict           self   dict    foo      bar   assert Foo   foo     bar      or we can use   getattr   and   setattr   to execute code on set get class Bar      def   init   self           self  data          def   getattr   self  key           return self  data key      def   setattr   self  key  value           self  data key    value  bar   Bar   bar foo    bar  assert bar foo     bar      dict   is good if you want to put dynamically created properties    getattr   is good to only do something when the value is needed  like query a database  The set get combo is good to simplify the access to data stored in the class  like in the example above    If you only want one dynamic property  have a look at the property   built-in function

User · Answer

It seems you could solve this problem much more simply with a namedtuple  since you know the entire list of fields ahead of time   from collections import namedtuple  Foo   namedtuple  Foo     bar    quux     foo   Foo bar 13  quux 74  print foo bar  foo quux  foo2   Foo      error   If you absolutely need to write your own setter  you ll have to do the metaprogramming at the class level  property   doesn t work on instances

User · Answer

A lot of the supplied answers require so many lines per property  ie   and   or - what I d consider an ugly or tedious implementation because of repetitiveness required for multiple properties  etc  I prefer keeping boiling things down   simplifying them until they can t be simplified anymore or until it doesn t serve much purpose to do so   In short  in completed works  if I repeat 2 lines of code  I typically convert it into a single line helper function  and so on    I simplify math or odd arguments such as   start x  start y  end x  end y   to   x  y  w  h   ie x  y  x   w  y   h   sometimes requiring min   max or if w   h are negative and the implementation doesn t like it  I ll subtract from x   y and abs w   h  etc       Overriding the internal getters   setters is an ok way to go  but the problem is you need to do that for every class  or parent the class to that base    This doesn t work for me as I d prefer to be free to choose the children   parents for inheritance  child nodes  etc   I have created a solution which answers the question without using a Dict data-type to supply the data as I find that to be tedious to enter the data  etc     My solution requires you to add 2 extra lines above your class to create a base class for the class you want to add the properties to  then 1 line per and you have the option to add callbacks to control the data  inform you when data changes  restrict the data which can be set based on value and   or data-type  and much more   You also have the option to use  object x   object x   value   object GetX      object SetX  value   and they are handled equivalently   Additionally  the values are the only non-static data which are assigned to the class instance  but the actual property is assigned to the class meaning the things you don t want to repeat  don t need to be repeated    You can assign a default value so the getter doesn t need it each time  although there is an option to override the default default value  and there is another option so the getter returns the raw stored value by overriding default returns   note  this method means the raw value is only assigned when a value is assigned  otherwise it is None - when the value is Reset  then it assigns None  etc      There are many helper functions too - the first property which gets added adds 2 or so helpers to the class for referencing the instance values    They are ResetAccessors   key       varargs repeated   all can be repeated using the first named args   and SetAccessors   key   value   with the option of more being added to the main class to aide in efficiency - the ones planned are  a way to group accessors together  so if you tend to reset a few at a time  every time  you can assign them to a group and reset the group instead of repeating the named keys each time  and more   The instance   raw stored value is stored at class   the   class  references the Accessor Class which holds static vars   values   functions for the property   class  is the property itself which is called when accessed via the instance class during setting   getting  etc   The Accessor  class    points to the class  but because it is internal it needs to be assigned in the class which is why I opted to use   Name   AccessorFunc        to assign it  a single line per property with many optional arguments to use   using keyed varargs because they re easier and more efficient to identify and maintain       I also create a lot of functions  as mentioned  some of which use  accessor function information so it doesn t need to be called   as it is a bit inconvenient at the moment - right now you need to use  class  FunctionName   class instance  args   - I got around using the stack   trace to grab the instance reference to grab the value by adding the functions which either run this bit marathon  or by adding the accessors to the object and using self   named this to point out they re for the instance and to retain access to self  the AccessorFunc class reference  and other information from within the function definitions     It isn t quite done  but it is a fantastic foot-hold  Note  If you do not use   Name   AccessorFunc        to create the properties  you won t have access to the    key even though I define it within the init function  If you do  then there are no issues   Also  Note that Name and Key are different    Name is  formal   used in Function Name Creation  and the key is for data storage and access  ie  class x where lowercase x is key  the name would be uppercase X so that GetX    is the function instead of Getx    which looks a little odd  this allows self x to work and look appropriate  but also allow GetX    and look appropriate   I have an example class set up with key   name identical  and different to show  a lot of helper functions created in order to output the data   Note  Not all of this is complete   so you can see what is going on   The current list of functions using key  x  name  X outputs as   This is by no means a comprehensive list - there are a few which haven t made it on this at the time of posting      instance SetAccessors   key   value      key   value                          Instance Class Helper Function  Allows assigning many keys   values on a single line - useful for initial setup  or to minimize lines     In short  Calls this Set lt Name gt    value   for each  key    value pairing   instance ResetAccessors   key      key                                        Instance Class Helper Function  Allows resetting many key stored values to None on a single line                                            In short  Calls this Reset lt Name gt    for each name provided    Note  Functions below may list self Get   Set   Name   args   - self is meant as the class instance reference in the cases below - coded as this in AccessorFuncBase Class   this GetX   default override   None   ignore defaults   False                   GET             Returns    IF ISSET  STORED VALUE    IF IGNORE DEFAULTS  None     IF PROVIDED  DEFAULT OVERRIDE ELSE  DEFAULT VALUE       100 this GetXRaw                                                                    RAW             Returns    STORED VALUE                                                                                                     100 this IsXSet                                                                     ISSET           Returns      STORED VALUE    None                                                                                           True  this GetXToString                                                               GETSTR          Returns    str  GET                                                                                                         100 this GetXLen   default override   None   ignore defaults   False                LEN             Returns    len  GET                                                                                                         3 this GetXLenToString   default override   None   ignore defaults   False        LENSTR          Returns    str  len  GET                                                                                                    3 this GetXDefaultValue                                                           DEFAULT         Returns    DEFAULT VALUE                                                                                                    1111  this GetXAccessor                                                               ACCESSOR        Returns    ACCESSOR REF   self    lt key gt                                                                                         AccessorFuncBase   Key  x   Class ID  2231452344344   self ID  2231448283848        Default  1111       Allowed Types     lt class  int  gt      lt class  type  gt      lt class  float  gt      lt class  type  gt        Allowed Values  None this GetXAllowedTypes                                                           ALLOWED TYPES   Returns    Allowed Data-Types                                                                                                  lt class  int  gt      lt class  type  gt      lt class  float  gt      lt class  type  gt    this GetXAllowedValues                                                          ALLOWED VALUES  Returns    Allowed Values                                                                                                   None  this GetXHelpers                                                                HELPERS         Returns    Helper Functions String List - ie what you re reading now                                                        THESE ROWS OF TEXT this GetXKeyOutput                                                              Returns information about this Name   Key                                                                                                   ROWS OF TEXT this GetXGetterOutput                                                           Returns information about this Name   Key                                                                                                   ROWS OF TEXT  this SetX   value                                                               SET             STORED VALUE Setter - ie Redirect to    lt Key gt  Set                                                                            N   A this ResetX                                                                     RESET           Resets STORED VALUE to None                                                                                                 N   A  this HasXGetterPrefix                                                           Returns Whether or Not this key has a Getter Prefix                                                                                         True this GetXGetterPrefix                                                           Returns Getter Prefix                                                                                                                       Get  this GetXName                                                                   Returns Accessor Name - Typically Formal   Title-Case                                                                                       X this GetXKey                                                                    Returns Accessor Property Key - Typically Lower-Case                                                                                        x this GetXAccessorKey                                                            Returns Accessor Key - This is to access internal functions  and static data                                                                  x this GetXDataKey                                                                Returns Accessor Data-Storage Key - This is the location where the class instance value is stored                                            x   Some of the data being output is   This is for a brand new class created using the Demo class without any data assigned other than the name   so it can be output   which is  foo  the variable name I used      foo         --- MyClass  ---- id  this   class      2231452349064      id  this    2231448475016      Key       Getter Value          Raw Key   Raw   Stored Value         Get Default Value             Default Value              Get Allowed Types             Allowed Types                                                                Get Allowed Values            Allowed Values                                                                                                                                                                                                                          Name       foo                   Name      foo                         Name DefaultValue           AccessorFuncDemoClass        Name GetAllowedTypes         lt class  str  gt                                                                   Name GetAllowedValues       Saved Value Restrictions Levied by Data-Type                                                                                                                                                                                           x         1111                   x        None                         x DefaultValue              1111                         x GetAllowedTypes             lt class  int  gt    lt class  float  gt                                                 x GetAllowedValues          Saved Value Restrictions Levied by Data-Type                                                                                                                                                                                           y         2222                   y        None                         y DefaultValue              2222                         y GetAllowedTypes             lt class  int  gt    lt class  float  gt                                                 y GetAllowedValues          Saved Value Restrictions Levied by Data-Type                                                                                                                                                                                           z         3333                   z        None                         z DefaultValue              3333                         z GetAllowedTypes             lt class  int  gt    lt class  float  gt                                                 z GetAllowedValues          Saved Value Restrictions Levied by Data-Type                                                                                                                                                                                           Blah       lt class  int  gt           Blah     None                         Blah DefaultValue            lt class  int  gt                 Blah GetAllowedTypes         lt class  str  gt                                                                   Blah GetAllowedValues       Saved Value Restrictions Levied by Data-Type                                                                                                                                                                                           Width     1                      Width    None                         Width DefaultValue          1                            Width GetAllowedTypes         lt class  int  gt    lt class  bool  gt                                                  Width GetAllowedValues      Saved Value Restrictions Levied by Data-Type                                                                                                                                                                                           Height    0                      Height   None                         Height DefaultValue         0                            Height GetAllowedTypes       lt class  int  gt                                                                   Height GetAllowedValues      0  1  2  3  4  5  6  7  8  9                                                                                                                                                                                                          Depth     2                      Depth    None                         Depth DefaultValue          2                            Depth GetAllowedTypes       Saved Value Restricted to Authorized Values ONLY                               Depth GetAllowedValues       0  1  2  3  4  5  6  7  8  9                                                                                                                                                                                                        this IsNameSet        True      this GetName          foo                     this GetNameRaw         foo                     this GetNameDefaultValue        AccessorFuncDemoClass    this GetNameLen        4    this HasNameGetterPrefix         lt class  str  gt                                 this GetNameGetterPrefix        None this IsXSet           False     this GetX            1111                     this GetXRaw           None                     this GetXDefaultValue           1111                     this GetXLen           4    this HasXGetterPrefix             lt class  int  gt    lt class  float  gt               this GetXGetterPrefix           None this IsYSet           False     this GetY            2222                     this GetYRaw           None                     this GetYDefaultValue           2222                     this GetYLen           4    this HasYGetterPrefix             lt class  int  gt    lt class  float  gt               this GetYGetterPrefix           None this IsZSet           False     this GetZ            3333                     this GetZRaw           None                     this GetZDefaultValue           3333                     this GetZLen           4    this HasZGetterPrefix             lt class  int  gt    lt class  float  gt               this GetZGetterPrefix           None this IsBlahSet        False     this GetBlah          lt class  int  gt             this GetBlahRaw        None                     this GetBlahDefaultValue         lt class  int  gt             this GetBlahLen        13   this HasBlahGetterPrefix         lt class  str  gt                                 this GetBlahGetterPrefix        None this IsWidthSet       False     this GetWidth        1                        this GetWidthRaw       None                     this GetWidthDefaultValue       1                        this GetWidthLen       1    this HasWidthGetterPrefix         lt class  int  gt    lt class  bool  gt                this GetWidthGetterPrefix       None this IsDepthSet       False     this GetDepth        2                        this GetDepthRaw       None                     this GetDepthDefaultValue       2                        this GetDepthLen       1    this HasDepthGetterPrefix       None                                         this GetDepthGetterPrefix        0  1  2  3  4  5  6  7  8  9  this IsHeightSet      False     this GetHeight       0                        this GetHeightRaw      None                     this GetHeightDefaultValue      0                        this GetHeightLen      1    this HasHeightGetterPrefix       lt class  int  gt                                 this GetHeightGetterPrefix       0  1  2  3  4  5  6  7  8  9    And this is after assigning all of  foo properties   except the name   the following values in the same order   string    1 0  True  9  10  False  this IsNameSet        True      this GetName          foo                     this GetNameRaw         foo                     this GetNameDefaultValue        AccessorFuncDemoClass    this GetNameLen        4    this HasNameGetterPrefix         lt class  str  gt                                 this GetNameGetterPrefix        None this IsXSet           True      this GetX            10                       this GetXRaw           10                       this GetXDefaultValue           1111                     this GetXLen           2    this HasXGetterPrefix             lt class  int  gt    lt class  float  gt               this GetXGetterPrefix           None this IsYSet           True      this GetY            10                       this GetYRaw           10                       this GetYDefaultValue           2222                     this GetYLen           2    this HasYGetterPrefix             lt class  int  gt    lt class  float  gt               this GetYGetterPrefix           None this IsZSet           True      this GetZ            10                       this GetZRaw           10                       this GetZDefaultValue           3333                     this GetZLen           2    this HasZGetterPrefix             lt class  int  gt    lt class  float  gt               this GetZGetterPrefix           None this IsBlahSet        True      this GetBlah         string Blah              this GetBlahRaw        string Blah              this GetBlahDefaultValue         lt class  int  gt             this GetBlahLen        11   this HasBlahGetterPrefix         lt class  str  gt                                 this GetBlahGetterPrefix        None this IsWidthSet       True      this GetWidth        False                    this GetWidthRaw       False                    this GetWidthDefaultValue       1                        this GetWidthLen       5    this HasWidthGetterPrefix         lt class  int  gt    lt class  bool  gt                this GetWidthGetterPrefix       None this IsDepthSet       True      this GetDepth        9                        this GetDepthRaw       9                        this GetDepthDefaultValue       2                        this GetDepthLen       1    this HasDepthGetterPrefix       None                                         this GetDepthGetterPrefix        0  1  2  3  4  5  6  7  8  9  this IsHeightSet      True      this GetHeight       9                        this GetHeightRaw      9                        this GetHeightDefaultValue      0                        this GetHeightLen      1    this HasHeightGetterPrefix       lt class  int  gt                                 this GetHeightGetterPrefix       0  1  2  3  4  5  6  7  8  9    foo         --- MyClass  ---- id  this   class      2231452349064      id  this    2231448475016      Key       Getter Value          Raw Key   Raw   Stored Value         Get Default Value             Default Value              Get Allowed Types             Allowed Types                                                                Get Allowed Values            Allowed Values                                                                                                                                                                                                                          Name       foo                   Name      foo                         Name DefaultValue           AccessorFuncDemoClass        Name GetAllowedTypes         lt class  str  gt                                                                   Name GetAllowedValues       Saved Value Restrictions Levied by Data-Type                                                                                                                                                                                           x         10                     x        10                           x DefaultValue              1111                         x GetAllowedTypes             lt class  int  gt    lt class  float  gt                                                 x GetAllowedValues          Saved Value Restrictions Levied by Data-Type                                                                                                                                                                                           y         10                     y        10                           y DefaultValue              2222                         y GetAllowedTypes             lt class  int  gt    lt class  float  gt                                                 y GetAllowedValues          Saved Value Restrictions Levied by Data-Type                                                                                                                                                                                           z         10                     z        10                           z DefaultValue              3333                         z GetAllowedTypes             lt class  int  gt    lt class  float  gt                                                 z GetAllowedValues          Saved Value Restrictions Levied by Data-Type                                                                                                                                                                                           Blah      string Blah            Blah     string Blah                  Blah DefaultValue            lt class  int  gt                 Blah GetAllowedTypes         lt class  str  gt                                                                   Blah GetAllowedValues       Saved Value Restrictions Levied by Data-Type                                                                                                                                                                                           Width     False                  Width    False                        Width DefaultValue          1                            Width GetAllowedTypes         lt class  int  gt    lt class  bool  gt                                                  Width GetAllowedValues      Saved Value Restrictions Levied by Data-Type                                                                                                                                                                                           Height    9                      Height   9                            Height DefaultValue         0                            Height GetAllowedTypes       lt class  int  gt                                                                   Height GetAllowedValues      0  1  2  3  4  5  6  7  8  9                                                                                                                                                                                                          Depth     9                      Depth    9                            Depth DefaultValue          2                            Depth GetAllowedTypes       Saved Value Restricted to Authorized Values ONLY                               Depth GetAllowedValues       0  1  2  3  4  5  6  7  8  9                                                                                                                                                                                                        Note that because of restricted data-types or value restrictions  some data wasn t assigned - this is by design  The setter prohibits bad data-types or values from being assigned  even from being assigned as a default value    unless you override the default value protection behavior    The code hasn t been posted here because I didn t have room after the examples and explanations    Also because it will change   Please Note  at the time of this posting  the file is messy - this will change  But  if you run it in Sublime Text and compile it  or run it from Python  it will compile and spit out a ton of information - the AccessorDB portion isn t done   which will be used to update the Print Getters and GetKeyOutput helper functions along with being changed to an Instance function  probably put into a single function and renamed - look for it      Next  Not everything is required for it to run - a lot of the commented stuff at the bottom is for more information used for debugging - it may not be there when you download it  If it is  you should be able to uncomment and recompile to get more information   I am looking for a work-around to needing MyClassBase  pass  MyClass  MyClassBase        - if you know of a solution - post it   The only thing necessary in the class are the    lines - the str is for debugging as is the init - they can be removed from the Demo Class but you will need to comment out or remove some of the lines below    foo   2   3      The String  Dict  and Util classes at the top are a part of my Python library - they are not complete  I copied over a few things I needed from the library  and I created a few new ones  The full code will link to the complete library and will include it along with providing updated calls and removing the code   actually  the only code left will be the Demo Class and the print statements - the AccessorFunc system will be moved to the library       Part of file         MyClass Test AccessorFunc Implementation for Dynamic 1-line Parameters    class AccessorFuncDemoClassBase         pass class AccessorFuncDemoClass  AccessorFuncDemoClassBase          Name        AccessorFuncBase  parent   AccessorFuncDemoClassBase  name    Name        default    AccessorFuncDemoClass    allowed types     TYPE STRING                       allowed values   VALUE ANY                  documentation    Name Docs          getter prefix    Get    key    Name         allow erroneous default   False     options               x           AccessorFuncBase  parent   AccessorFuncDemoClassBase  name    X           default   1111                      allowed types     TYPE INTEGER  TYPE FLOAT          allowed values   VALUE ANY                  documentation    X Docs             getter prefix    Get    key    x            allow erroneous default   False     options               Height      AccessorFuncBase  parent   AccessorFuncDemoClassBase  name    Height      default   0                         allowed types   TYPE INTEGER                        allowed values   VALUE SINGLE DIGITS        documentation    Height Docs        getter prefix    Get    key    Height       allow erroneous default   False     options           This beauty makes it incredibly easy to create new classes with dynamically added properties with AccessorFuncs   callbacks   data-type   value enforcement  etc   For now  the link is at   This link should reflect changes to the document     https   www dropbox com s 6gzi44i7dh58v61 dynamic properties accessorfuncs and more py dl 0  Also  If you don t use Sublime Text  I recommend it over Notepad    Atom  Visual Code  and others because of proper threading implementations making it much  much faster to use    I am also working on an IDE-like code mapping system for it - take a look at  https   bitbucket org Acecool acecoolcodemappingsystem src master    Add Repo in Package Manager first  then Install Plugin - when version 1 0 0 is ready  I ll add it to the main plugin list       I hope this solution helps    and  as always   Just because it works  doesn t make it right - Josh  Acecool  Moser

User · Answer

You cannot add a new property   to an instance at runtime  because properties are data descriptors   Instead you must dynamically create a new class  or overload   getattribute   in order to process data descriptors on instances

User · Answer

Just another example how to achieve desired effect  class Foo object         bar   None       property     def bar self           return self  bar       bar setter     def bar self  value           self  bar   value      def   init   self  dyn property name           setattr Foo  dyn property name  Foo bar    So now we can do stuff like    gt  gt  gt  foo   Foo  baz    gt  gt  gt  foo baz   5  gt  gt  gt  foo bar 5  gt  gt  gt  foo baz 5

User · Answer

The best way to achieve is by defining   slots    That way your instances can t have new attributes   ks     ab    cd   vs    12  34   class C dict         slots            def   init   self  ks  vs   self update zip ks  vs       def   getattr   self  key   return self key   if   name         main         c   C ks  vs      print c ab   That prints 12      c ab   33   That gives  AttributeError   C  object has no attribute  ab

[python] How to add property to a class dynamically?

Examples related to python

Examples related to properties

Examples related to runtime

Examples related to monkeypatching