python switch by class name?

Question

I am currently doing this, to do different things based on an object's type:

    actions = {
        SomeClass: lambda: obj.name
        AnotherClass: lambda: self.normalize(obj.identifier)
        ...[5 more of these]...
    }

    for a in actions.keys():
        if isinstance(obj, a):
            return actions[a]()

Is it possible to cut out the for loop, and do something like this?

actions[something to do with obj]()

Answer 1

What about

actions[obj.__class__]()

Answer 2

actions[type(obj)]()

Answer 3

actions[obj.__class__]()

works if obj is really an instance of (say) SomeClass and not of a subclass -- so if that can be the case, the result will be different from your current way of handling it. Also note that this might raise a KeyError if the class has no corresponding action. To handle this case the same way you do now (i.e. do nothing), you could use

actions.get(obj.__class__, lambda: None)

to have a default value returned.

Oh, and listen to S.Lott's comment on your question. In many cases, there are better ways to achieve something like this. You could, for example, have all your classes define a do_whatever(self) and just call obj.do_whatever().

Answer 4

results = [func() for cls, func in actions.iteritems() if isinstance(obj, cls)]

There will be zero or more results, if your object isinstance of zero or more of the class-keys.

Using type(obj) as key will only work if your object is of that type. If it's further down the inheritance tree, you'll miss it.

Answer 5

class SomeClass( object ):
....
    def action( self ):
        return self.name

class AnotherClass( object ):
....
    def action( self ):
        return self.normalize( self.identifier )

[5 more classes like the above two]

a.action()

Simpler. Clearer. More extensible. Less Magic. No dictionary. No loop.

Answer 6

I assume you have a parent class for all of those, or at least a mixin. Put a default return function in the parent or mixin, and then override it in those that are different... It's the only proper way of doing it.

Sure, it makes extra code, but at least it's encapsulated, and scalable. Say you wanna add support for five more classes. Instead of altering that code up there, just add the correct code to the new classes. By the looks of it, it's two lines per class (function definition and return line). That's not bad, is it?

If obj isn't a class which contains a return function, then an exception is raised, which you could catch and ignore with a clean conscience.

class MyMixin:
  def my_return(self, *args):
    return self.name
  ... possibly other things...

class SomeClass(MyMixin):
  ... no alteration to the default ...

class AnotherClass(MyParent, MyMixin):
  def my_return(self, *args):
    return args[0].normalize(self.identifier)
  ... blabla


# now, this is in the caller object...
try:
  rval = obj.my_return(self) # this is the caller object 'self', not the 'self' in the 'obj'
  #dosomething with rval
except Exception:
  pass #no rval for this object type, skipping it...