Generic methods in python

Question

Is it possible to implement generic method handlers in python which allow for calling of non-existent functions? Something like this:

class FooBar:
  def __generic__method__handler__(.., methodName, ..):
    print methodName

fb = FooBar()
fb.helloThere()

-- output --
helloThere

This still leaves the question of why you would want to do this. — Chris Morgan, Jun 24 '11 at 12:45
@ChrisMorgan It might allow method names to automatically generated using regular expressions, so any method name that matched the regular expression could be used as an alias for one particular method. — Anderson Green, Aug 07 '13 at 22:25
@ChrisMorgan How about general decorator, holding an object and doing some decoration (logging, lazy initialization?) over all its methods? — Tregoreg, Jul 22 '14 at 01:36

score 15 · Accepted Answer · edited May 23 '17 at 12:17

The first thing to remember is that methods are attributes which happen to be callable.

>>> s = " hello "
>>> s.strip()
'hello'
>>> s.strip
<built-in method strip of str object at 0x000000000223B9E0>

So you can handle non-existent methods in the same way you would handle non-existent attributes.

This is usally done by defining a __getattr__ method.

Now you're going hit the additional complexity which is the difference between functions and method. Methods need to be bound to an object. You can take a look at this question for a discussion of this.

So I think you'll want something like this:

import types

class SomeClass(object):
    def __init__(self,label):
        self.label = label

    def __str__(self):
        return self.label

    def __getattr__(self, name):
        # If name begins with f create a method
        if name.startswith('f'):
            def myfunc(self):
                return "method " + name + " on SomeClass instance " + str(self)
            meth = types.MethodType(myfunc, self, SomeClass)
            return meth
        else:
            raise AttributeError()

Which gives:

>>> s = SomeClass("mytest")
>>> s.f2()
'method f2 on SomeClass instance mytest'
>>> s.f2
<bound method SomeClass.myfunc of <__main__.SomeClass object at 0x000000000233EC18>>

However, I'd probably recommend against using this. If you tell us the problem you're trying to solve I expect someone here can come up with a better solution.

Thanks a lot! I wanted to know this not only because I need this for a specific problem, but also to understand python better. — paweloque, Jun 24 '11 at 12:30
Does the "types.MethodType" call assign the function to the class permanently? — paweloque, Jun 27 '11 at 14:09
It does not. It just makes a new method, `meth`, which _is_ an instance method of `SomeClass` (bound to `self`), but it doesn't change `myfunc` at all. Same as with `l=[3,5]`, `t=tuple(l)` doesn't change l at all. — Veky, Jul 08 '15 at 09:48

score 6 · Answer 2 · answered Jun 24 '11 at 12:03

6

def __getattr__(self, name):
  #return your function here...

answered Jun 24 '11 at 12:03

Karoly Horvath

94,607
11
117
176

3

Methods are attributes that are callable. They are also looked up using getattr. – Noufal Ibrahim Jun 24 '11 at 12:08

score 4 · Answer 3 · answered Jun 24 '11 at 12:10

4

class FooBar:
    def __getattr__(self, name):
        def foo():
            print name
        return foo

a = FooBar()
a.helloThere()

answered Jun 24 '11 at 12:10

Andrey Sboev

7,454
1
20
37

Generic methods in python

3 Answers3

Linked