Question

How does one build a function that can set an arbitrary value within a dictionary or object? Or in other words, a function that can set any value passed into it.

For example, suppose you have a dictionary like this:

my_dict = {
  'foo' : 'bar', 
  'subdict':{
    'sub1' : 1,
    'sub2' : 2
  }
}

I would like to create a setter function to be used like this:

x = 'x'
# I want to be able to set normal dictionary items
setter(lambda val: val['foo'], my_dict, x)

# And also set subdictionary items
setter(lambda val: val['subdict']['sub1'], my_dict, x)

# Setting items that don't exist would be great too
setter(lambda val: val['new_item'], my_dict, x)

# If my_dict was a class, I'd like to use the same function, like this
setter(lambda val: val.myproperty, my_dict, x)

# Would also be cool if it worked with lists
my_list = [1, 2]
setter(lambda val: val[1], my_list, x)

I don’t seen an obvious way to do this. The naive way below clearly does not work:

def setter(get_attr_func, param, x):
  # This doesn't work, but I'd like something like it
  get_attr_func(param) = x

I could use the setattr to build something that works for attributes on classes. I could build something else that works for items in dictionaries. But I have no idea how you would do it for sub-dictionaries or sub-objects.

The answer does not have to be in this exact form. Rather, I just want to write a function that sets an arbitrary attribute/item within an object hierarchy.

Answer 1

I decided this was an interesting problem. Primarily, this class collects item or attribute names when you try to get items or attributes from it. It can then use those collected operations to get or set the corresponding value on an object hierarchy. It also has a couple of convenience methods for making a set_to_x function like the one in your example.

The class:

class LocationProxy(object):
    def __init__(self, ops = None):
        self.ops = ops or []
    def __getitem__(self, item):
        self.ops.append((True, item))
        return self
    def __getattr__(self, attr):
        self.ops.append((False, attr))
        return self
    @staticmethod
    def iterativeget(obj, ops):
        for isitem, key in ops:
            obj = obj[key] if isitem else getattr(obj, key)
        return obj
    def get(self, obj):
        return self.iterativeget(obj, self.ops)
    def set(self, obj, value):
        isitem, key = self.ops[-1]
        obj = self.iterativeget(obj, self.ops[:-1])
        if isitem:
            obj[key] = value
        else:
            setattr(obj, key, value)
    def set_from_object(self, obj):
        return lambda value: self.set(obj, value)
    def set_to_value(self, value):
        return lambda obj: self.set(obj, value)
    @staticmethod
    def object_value_setter(obj, value):
        return lambda location: location.set(obj, value)
    @staticmethod
    def object_setter(obj):
        return lambda location, value: location.set(obj, value)
    @staticmethod
    def value_setter(value):
        return lambda location, obj: location.set(obj, value)

Let’s prepare some data and make some setter functions:

# since you can't set attributes on a normal dict, use a subclass
class MyDict(dict): pass

my_dict = MyDict({
  'foo' : 'bar',
  'subdict':{
    'sub1' : 1,
    'sub2' : 2
  }
})

my_list = [1, 2]

x = 'x'

# we're going to set multiple things in my_dict to x, let's not repeat ourselves
set_my_dict_to_x = LocationProxy.object_value_setter(my_dict, x)

# we'll use set_to_x as you used it later on my_list
set_to_x = LocationProxy.value_setter(x)

Now let’s test them:

# you can assign a name to a setter to use multiple times
foosetter = LocationProxy()['foo']

# set normal dictionary items
set_my_dict_to_x(foosetter)

# And also set subdictionary items
set_my_dict_to_x(LocationProxy()['subdict']['sub1'])

# Set items that don't exist
set_my_dict_to_x(LocationProxy()['new_item'])

print 'my_dict', my_dict

# my_dict is a class, use the same function
set_my_dict_to_x(LocationProxy().myproperty)

print 'myproperty', my_dict.myproperty

# it works with lists
set_to_x(LocationProxy()[1], my_list)

print 'my_list', my_list