how to dispatch objects depending on their class

[Curzio Basso]

Hi all.

I have a couple of question regarding the following situation:

class A(object):
def __init__(self):
pass

class B(object):
def __init__(self):
A.__init__(self )

def func(object):
if isinstance(obje ct, A):
do_something_wi th_A(object)
elif isinstance(obje ct, B):
do_something_wi th_B(object)

Note that in my real problem I cannot move the logic of func to the
class A and B because I will have a hierarchy also for func. Then I need
a way to dispatch the object to the right function. I thought about
using a dictionary, like:

FUNC = {"<class '__main__.A'>": do_something_wi th_A,
"<class '__main__.B'>": do_something_wi th_B}

def func(object):
FUNC[type(object)](object)

But: (1) I am not sure of what the type(object) function return. In this
case A and B are in the __main__ namespace (assuming this is how is
called), but if they are in a module; (2) I am not sure if it is
efficient; and finally (3): probably there is a better way to do it
(this is always a safe assumption).

I hope my problem is clear, and excuse me if I am asking about something
that is common knowledge, but I don't even know what to google for...

thanks, curzio

[Peter Otten]

Curzio Basso wrote:

FUNC = {"<class '__main__.A'>": do_something_wi th_A,
"<class '__main__.B'>": do_something_wi th_B}

def func(object):
FUNC[type(object)](object)
You'll have to modify that slightly for it to work. It will be very
efficient, too.

func_dict = {A: do_something_wi th_A,
B: do_something_wi th_B}
def func(obj):
func_dict[obj.__class__](obj)

Using classes as keys avoids the ambiguity you fear. The overhead will be
one dictionary lookup and a function call. The main drawback of this simple
approach is that it does not search the inheritance tree but insists on an
exact class match.
I hope my problem is clear, and excuse me if I am asking about something
that is common knowledge, but I don't even know what to google for...

Maybe

python generic dispatch

Peter

[Casey Duncan]

It should not be a problem to use the actual class object as keys in the
dict and the functions as values. No need to convert the class to
strings.

So why can't they be static methods of the classes exactly? That would
be simpler, however the dict will work efficiently.

-Casey

On Tue, 10 Aug 2004 16:35:48 +0200
Curzio Basso <cu**********@u nibas.ch> wrote:

Hi all.

I have a couple of question regarding the following situation:

class A(object):
def __init__(self):
pass

class B(object):
def __init__(self):
A.__init__(self )

def func(object):
if isinstance(obje ct, A):
do_something_wi th_A(object)
elif isinstance(obje ct, B):
do_something_wi th_B(object)

Note that in my real problem I cannot move the logic of func to the
class A and B because I will have a hierarchy also for func. Then I
need a way to dispatch the object to the right function. I thought
about using a dictionary, like:

FUNC = {"<class '__main__.A'>": do_something_wi th_A,
"<class '__main__.B'>": do_something_wi th_B}

def func(object):
FUNC[type(object)](object)

But: (1) I am not sure of what the type(object) function return. In
this case A and B are in the __main__ namespace (assuming this is how
is called), but if they are in a module; (2) I am not sure if it is
efficient; and finally (3): probably there is a better way to do it
(this is always a safe assumption).

I hope my problem is clear, and excuse me if I am asking about
something that is common knowledge, but I don't even know what to
google for...

thanks, curzio
--
http://mail.python.org/mailman/listinfo/python-list

[Bruno Desthuilliers]

Curzio Basso wrote:

Hi all.

I have a couple of question regarding the following situation:

class A(object):
def __init__(self):
pass

class B(object):
def __init__(self):
A.__init__(self )

def func(object):
if isinstance(obje ct, A):
do_something_wi th_A(object)
elif isinstance(obje ct, B):
do_something_wi th_B(object)

Note that in my real problem I cannot move the logic of func to the
class A and B because I will have a hierarchy also for func. Then I need
a way to dispatch the object to the right function.

I saw something like a multi-methods implementation in Python somewhere,
this may interest you.
http://www-106.ibm.com/developerwork.../l-pydisp.html

Visitor Pattern?

[Peter Abel]

Curzio Basso <cu**********@u nibas.ch> wrote in message news:<41******* *@maser.urz.uni bas.ch>...

Hi all.

I have a couple of question regarding the following situation:

class A(object):
def __init__(self):
pass

class B(object):
def __init__(self):
A.__init__(self )

def func(object):
if isinstance(obje ct, A):
do_something_wi th_A(object)
elif isinstance(obje ct, B):
do_something_wi th_B(object)

Note that in my real problem I cannot move the logic of func to the
class A and B because I will have a hierarchy also for func. Then I need
a way to dispatch the object to the right function. I thought about
using a dictionary, like:

FUNC = {"<class '__main__.A'>": do_something_wi th_A,
"<class '__main__.B'>": do_something_wi th_B}

def func(object):
FUNC[type(object)](object)

But: (1) I am not sure of what the type(object) function return. In this
case A and B are in the __main__ namespace (assuming this is how is
called), but if they are in a module; (2) I am not sure if it is
efficient; and finally (3): probably there is a better way to do it
(this is always a safe assumption).

I hope my problem is clear, and excuse me if I am asking about something
that is common knowledge, but I don't even know what to google for...

thanks, curzio

At my opinion you try to do something outside a class which should
be a basic task of OOP. Why not let the instances do their class-specific
things:

class A(object):
def __init__(self):
pass
def do_something(se lf):
""" Do A-specific things """
pass

class B(object):
def __init__(self):
A.__init__(self )
def do_something(se lf):
""" Do B-specific things """
pass

a=A()
b=B()
a.do_something( )
b.do_something( )

Regards
Peter

[Curzio Basso]

Peter Abel wrote:

At my opinion you try to do something outside a class which should
be a basic task of OOP. Why not let the instances do their class-specific
things:

I know that this situation would be typically handled by putting the
logic in the class hierarchy, but as I wrote I don't want this. In fact,
as cm******@hotmai l.com pointed out, at the end what I want to implement
is a visitor pattern (maybe I should have simply mentioned this). In C++
then the right implementations are chosen at compile time because of the
function overloading, but in Python I have to find a different way to
implement this.

cheers, curzio

[Curzio Basso]

Curzio Basso wrote:

class B(object):
def __init__(self):
A.__init__(self )

typo. this should be:

class B(A):
def __init__(self):
A.__init__(self )

[Curzio Basso]

cm******@hotmai l.com wrote:

Visitor Pattern?

Actually, I thought what I was describing was a visitor pattern but I am
probably wrong.

Is it correct that in the visitor pattern the dispatching would be
delegated to the classes, like with:

class A(object):
def __init__(self):
pass
def accept(self, visitor)
visitor.do_some thing_with_A(se lf)

class B(A):
def __init__(self):
A.__init__(self )
def accept(self, visitor)
visitor.do_some thing_with_B(se lf)

class Visitor(object) :
def __init__(self):
pass
def do_something_wi th_A(self, object):
pass
def do_something_wi th_B(self, object):
pass

Then I would call

a = A()
b = B()
v = Visitor()
a.accept(v)
b.accept(v)

Is this correct?

thanks, curzio

[Curzio Basso]

Bruno Desthuilliers wrote:

I saw something like a multi-methods implementation in Python somewhere,
this may interest you.
http://www-106.ibm.com/developerwork.../l-pydisp.html

looks interesting. thanks for the link, I'll post some comment if I find
it useful for my problem.

cheers, curzio