Fredrik Tolf wrote: > However, since I can't do that in Python, I ended up using an extra > local variable instead, like this: > > f = getattr(self, "cmd_" + name) > f2 = getattr(self, "cmdv_" + name) > if callable(f): > # Do something with f > elif callable(f2): > # Do something with f2
If 'do something' is the same thing: for prefix in ('cmd_', 'cmdv_'): f = getattr(self, prefix+name) if callable(f): # do something with f break If 'do something' is different each time, put each block into a method: def do_cmd(self, f): ... def do_cmdv(self, f): ... ... for prefix, action in (('cmd_', self.do_cmd), ('cmdv_', self.do_cmdv)): f = getattr(self, prefix+name) if callable(f): action(f) break > > Another common problem for me are while loops. I would often like to do > this: > while (pos = somestring.find("/")) != -1: > part = somestring[:pos] > somestring = somestring[pos + 1:] > # Handle part for part in somestring.split("/")[:-1]: # handle part Are you sure you didn't want to process the last part of the string as well? I would have thought that to be more common, and rather harder to write using your original structure. > > Which is quite ugly. This might have been a bad example, since > somestring.split() could be used instead, but it's still valid for other > situations. > Not really. Your original loop refactors quite nicely by calling a method or function which returns a sequence of results. The same pattern in will always be refactorable in the same way. If the appropriate 'split' function doesn't already exist then you can write it. A very common way to rewrite this sort of loop these days is to write a generator. It is usually beneficial to factor out the complex part of the loop logic in this way as then you only have to write it once no matter how many loops you have with the same structure. -- http://mail.python.org/mailman/listinfo/python-list