On Wed, 15 Aug 2012 23:17:41 +0200, Thomas Bach wrote:
> Hi list,
>
> I'm confronted with a strang problem I cannot find a clean solution for.
> I want a class that determines on instantiating its base classes
> dynamically. Consider the following two use cases
Some comments:
1) What you show are not "use cases", but "examples". A use-case is a
description of an actual real-world problem that needs to be solved. A
couple of asserts is not a use-case.
2) You stated that you have a "strange problem", but you haven't told us
what that problem is, you went directly to what you think is the
solution: "a class that determines on instantiating its base classes
dynamically".
How about you tell us the problem, and we'll suggest a solution?
I'm pretty sure it isn't going to be what you asked for, because that
goes completely against the fundamentals of object-oriented design.
Consider your two examples:
a = Foo(['a', 'list'])
b = Foo({'blah': 8})
According to your design:
a is a Foo
b is a Foo
therefore a and b are the same type
So far so good: this is perfectly normal object-oriented design.
But you also have
a is a list, but not a dict
b is a dict, but not a list
therefore a and b are different types
So you contradict yourself: at the same time, a and b are both the same
and different types.
So now you see why you shouldn't do what you ask for. Now let me tell you
why you *can't* do what you ask for: Python's classes don't work like
that. You can't set the base classes of an instance individually. All
instances of a class share the same base classes.
I think that the right solution here is not inheritance, but composition
and delegation. You're already on the right track when you give your Foo
instances an attribute _obj and then operate on that, but you are wrong
to focus on inheritance.
Instead, Foo should implement only the shared operations, and everything
else should be delegated to _obj.
Automatic delegation is trivially easy (except see below):
http://code.activestate.com/recipes/52295
This is a *really old* recipe, from ancient days before you could inherit
from built-in types like list, dict etc., so the description of the
problem is no longer accurate. But the technique is still good, with
unfortunately one complication:
If you inherit from builtins, you cannot use automatic delegation on the
magic "double-underscore" (dunder) methods like __eq__, __len__, etc.
See this thread here for one possible solution:
http://www.velocityreviews.com/forums/t732798-automatic-delegation-in-python-3-a.html
--
Steven
--
http://mail.python.org/mailman/listinfo/python-list
