Change behaviour of existing objects

Question

I have a program that generates a dictionary of objects that are referring to each other. The data in the objects and the references are read from a csv file. Everytime a reference to a new object is encuntered, a new object is generated. Depending on the some attributes, the objects can have slightly different behaviour. The most logical way to account for the difference in behaviour by using different subclasses for each type of behaviour.

My problems is that when a first reference to an object is encountered in the csv file, the desired subclass is not yet known. Creating a temporary object until the final type is known and copying all attributes to a new object will not work since this invalidates all existing references to the object.

I can solve this in two ways:

class A:
    fun(self.x):
        pass

fun1(self, x):
    print("fun1: ", x)

fun2(self, x):
    print("fun2: ", x)

a = A()
if <some condition>:
    a.fun = fun1
else:
    a.fun = fun2

In this case the relation between the class and the behaviour of the instance is lost, which might not be nice when debugging. My other solution is on the one hand more elegant, but feels like bad programming habits:

class A:
   pass

class B(A):
    def fun(self, x):
        print("B: ", x)

class C(A):
    def fun(self, x):
        print("C: ", x)

a = A()
if <some condition>:
    a.__class__ = B
else:
    a.__class__ = C

If think most of the objections to assignment to __class__ mentioned in this How dangerous is setting self.__class__ to something else? thread are not valid. Nevertheless, it does not feel good.

I prefer not to include all variants of the method of interest in a single class and call one of these, depending on some data attribute. That would results in objects having methods that are invalid for them.

Does anybody have another, clean, solution?

what is `` based on? Also what about making [proxy objects](http://stackoverflow.com/questions/26091833/proxy-object-in-python)? — Tadhg McDonald-Jensen, Mar 11 '17 at 22:34
^ specifically at what point do you know which class/ behaviour is correct and based on what info? — Tadhg McDonald-Jensen, Mar 11 '17 at 22:39
@Goyo With a reference I mean something like: a.references=[b, c], with a,b and c objects of the same (or very similar) class. — Martijn, Mar 11 '17 at 22:47
@Tadhg McDonald-Jensen: some condition will refer to a data attribute of an object that can be read from the csv file long after the object has been created when a first reference to it was encountered. — Martijn, Mar 11 '17 at 22:50
so the different behaviours are dictated by "data attribute" that come along with the reference to an object? So if you refer to a new data attribute it could completely change the behaviour of the object? That would worry me more then _"result[ing] in objects having methods that are invalid for them."_ Why isn't there some data about the behaviour in these references? — Tadhg McDonald-Jensen, Mar 11 '17 at 23:03
You can avoid the problem by deferring the creation of objects until the whole data has been read. — Stop harming Monica, Mar 11 '17 at 23:13

score 0 · Answer 1 · answered Mar 11 '17 at 23:55

You can refer to the objects indirectly through some intermediate data structure, e.g.:

objs = []

class Base(object):
    def __init__(self, name):
        self.name = name
        self.id = len(objs)
        objs.append(self)
        self._refs = []

    def link(self, obj):
        self._refs.append(obj.id)

    @property
    def refs(self):
        return [objs[r] for r in self._refs]

    @classmethod
    def replace(cls, obj):
        new_obj = cls(obj.name)
        objs[obj.id] = new_obj
        new_obj.id = obj.id
        return new_obj

    def __repr__(self):
        return '%s(%r)' % (self.__class__.__name__, self.name)

class A(Base):
    pass

class B(Base):
    pass

a1 = A('a1')
a2 = A('a2')
a1.link(a2)
print(a1.refs)  # [A('a2')]
B.replace(a2)
print(a1.refs)  # [B('a2')]

Change behaviour of existing objects

1 Answers1