Assign a dynamic variable to a dictionary in Python

Question

I'm trying to do the following:

class DoSomething:
   def something(self, number, name)
      self.main_dict = {}
      setattr(self,name,['anything'])
      self.main_dict[number] = getattr(self,name) 

The above passes the attribute (reference by value) to the dictionary. Not the behavior I need.

I want to pass the reference of the dynamic variable to the dictionary, not the attribute. Further on I modify the dynamic variable and I want it to be reflected in the dictionary.

Is it possible do so such thing?

---

Edit:

Why?

1) To learn how to do such thing and have one more tool in the toolbox. The answers provided refer to using a "reference / container" class and creating an instance for each value needed. Perfect.

2) Because this problem was created by another fixable problem (didn't see at first). Note I further modify the dynamically created variable. To do so, it needs to be dynamically called by (setattr, vars, __dict__, etc). It was not being modified, it was being assigned a new value which changes the reference, not reflecting back to the dict.

I would like to point to this about assignment/reference: How do I pass a variable by reference?

3) The intent is maintenance. By referencing at the beginning the dict-variable, the programmer would know any changes made to the variable would reflect into the dictionary.

4) I mentioned in the comments about using lambda. This would only work if the name is never modified, otherwise lambda would use the last assigned value to name.

Answer 1

I think you are looking for something like this:

class DoSomething(object):
   def something(self, number, name):
      self.main_dict = {}
      setattr(self, name, ['anything'])
      setattr(self, number, getattr(self, name))

setattr can set an attribute whose name is given by the value of name. getattr will return the value of the attribute whose name is given by the value of number.

As an example of the above in use:

In [33]: s = DoSomething()

In [34]: s.something('x', 'alpha')

In [35]: s.x
Out[35]: ['anything']

In [36]: s.alpha
Out[36]: ['anything']

Answer 2

Yes. This will work.

But, dynamically setting properties on classes isn't a good idea because it become difficult to keep track of what is available and what is not depending on when an object is instantiated, or accessed.

class Thing(object):
   def setP(self,name,value):
       setattr(self,name,value)
   def getP(self,name):
       return getattr(self,name)

foo = Thing()
foo.setP('bar','baz')
print foo.bar

Gives:

> baz

However, one of the advantages of a class is that (ideally) it puts forth a public contract regarding public members and functions. If you can't be reasonably certain that an object will have a property at any given time, or that two instantiations of the same class won't have the same properties - (all credit to furkle for this)

In the above code this will not work:

foo = Thing()
print foo.bar

And will raise an exception, so the removal of one line outside of the class has made a call to access an object property fail.

Likewise:

foo = Thing()
goh = Thing()
foo.setP('bar','baz')
print foo.bar
print goh.bar

This will also throw an exception. Dynamically assigning attributes to obejcts makes it difficult to known when certain objects are available.

Answer 3

You can do this by defining a mutable object that holds the values you want. The class dict and main_dict point to this object and it holds a value you can change dynamically.

class DynValue(object):

    __slots__ = 'val'

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

    def __str__(self):
        return str(self.val)

    def __repr__(self):
        return 'DynValue{%s}' % repo(self.val)



class DoSomething:
    def something(self, number, name):
        self.main_dict = {}
        val = DynValue(['anything'])
        setattr(self,name,val)
        self.main_dict[number] = val

    def sometimelater(self, name):
        getattr(self, name).val = ['somethingelse']


d=DoSomething()
d.something(1, 'fred')
print d.main_dict[1]
d.sometimelater('fred')
print d.main_dict[1]

Its also common to have one container hold the value and have the other containers refer back to it. So, if you store the value directly on self, you'd store the name in main_dict and lookup every time.

class DoSomething:
   def something(self, number, name)
      self.main_dict = {}
      setattr(self,name,['anything'])
      self.main_dict[number] = name

   def get_by_number(self, number):
      return getattr(self, self.main_dict[number])

   def set_by_number(self, number, newval):
      setattr(self, self.main_dict[number], newval)

   def set_by_name(self, name newval):
      setattr(self, name, newval)