Calling every method of an object from __init__

[Rob Cowie]

Hi all,

Is there a simple way to call every method of an object from its
__init__()?

For example, given the following class, what would I replace the
comment line in __init__() with to result in both methods being called?
I understand that I could just call each method by name but I'm looking
for a mechanism to avoid this.

class Foo(object):
def __init__(self):
#call all methods here
def test(self):
print 'The test method'
def hello(self):
print 'Hello user'

Thanks,

Rob C

 

[K.S.Sreeram]

class Foo(object):
def __init__(self):
#call all methods here
def test(self):
print 'The test method'
def hello(self):
print 'Hello user'

class Foo(object):
def __init__(self):
for k in dir(self) :
if not k.startswith('__') :
v = getattr( self, k )
v()
def test(self):
print 'The test method'
def hello(self):
print 'Hello user'


you can also add a test for 'if callable(v) :' to the for loop if you
have data fields in Foo.

Regards
Sreeram


-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.2.2 (MingW32)
Comment: Using GnuPG with Mozilla - http://enigmail.mozdev.org

iD8DBQFElwaQrgn0plK5qqURAoYMAJ41MX9UPa3Z7fzB9OLTyAfOnYf3HACfeMIU
5f6EIPWjVXzhsJbCXdMMXcs=
=Tsd9
-----END PGP SIGNATURE-----

 

[Tim Chase]

Is there a simple way to call every method of an object from its

__init__()?

For example, given the following class, what would I replace the
comment line in __init__() with to result in both methods being called?
I understand that I could just call each method by name but I'm looking
for a mechanism to avoid this.

class Foo(object):
def __init__(self):
#call all methods here
def test(self):
print 'The test method'
def hello(self):
print 'Hello user'

.... def __init__(self):
.... for method in dir(self):
.... if method == method.strip("_"):
.... f = getattr(self, method)
.... if callable(f): f()
.... def test(self):
.... print "in test..."
.... def hello(self):
.... print "in hello..."
....in hello...
in test...


This does assume that the method's signature takes no parameters
and that you don't want to try and call "special" methods such as
__add__ or "private" methods (usually indicated by leading
underscores too) while you're going through the available methods.

-tkc

 

[George Sakkis]

Hi all,

Is there a simple way to call every method of an object from its
__init__()?

For example, given the following class, what would I replace the
comment line in __init__() with to result in both methods being called?
I understand that I could just call each method by name but I'm looking
for a mechanism to avoid this.

class Foo(object):
def __init__(self):
#call all methods here
def test(self):
print 'The test method'
def hello(self):
print 'Hello user'

Thanks,

Rob C

First off, calling *every* method of an object is most likely a bad
idea. A class has special methods defined automatically and you
probably don't intend calling those. The way to go is have a naming
convention for the methods you want to call, e.g. methods starting with
"dump_". In this case you could use the inspect module to pick the
object's methods and filter out the irrelevant methods:

import inspect

class Foo(object):
def __init__(self):
for name,method in inspect.getmembers(self,inspect.ismethod):
if name.startswith('dump_'):
method()
def dump_f(self):
print 'The test method'
def dump_g(self):
print 'Hello user'

if __name__ == '__main__':
Foo()


George

 

[John Machin]

Hi all,

Is there a simple way to call every method of an object from its
__init__()?

For example, given the following class, what would I replace the
comment line in __init__() with to result in both methods being called?
I understand that I could just call each method by name but I'm looking
for a mechanism to avoid this.

class Foo(object):
def __init__(self):
#call all methods here
def test(self):
print 'The test method'
def hello(self):
print 'Hello user'

=== question ===

Why? What is the use case for a class *all* of whose methods can be
called blindly from the __init__()?

=== code ===

class Foo(object):
def __init__(self):
#call all methods here
for x in dir(self):
if not x.startswith("__"):
method = getattr(self, x)
if callable(method):
print x, type(method), repr(method)
method()
def test(self):
print 'The test method'
def hello(self):
print 'Hello user'
def variablenumberofargsohbuggerbacktothedrawingboard(self, arg1,
arg2):
print 'The unseen message'

obj = Foo()

=== output ===

hello <type 'instancemethod'> <bound method Foo.hello of <__main__.Foo
object at 0x00AE2B70>>
Hello user
test <type 'instancemethod'> <bound method Foo.test of <__main__.Foo
object at 0x00AE2B70>>
The test method
variablenumberofargsohbuggerbacktothedrawingboard <type
'instancemethod'> <bound method
Foo.variablenumberofargsohbuggerbacktothedrawingboard of <__main__.Foo
object at 0x00AE2B70>>
Traceback (most recent call last):
File "C:\junk\cowie.py", line 17, in ?
obj = Foo()
File "C:\junk\cowie.py", line 9, in __init__
method()
TypeError: variablenumberofargsohbuggerbacktothedrawingboard() takes
exactly 3 arguments (1 given)

Cheers,
John

 

[Ten]

Hi all,

Is there a simple way to call every method of an object from its
__init__()?

For example, given the following class, what would I replace the
comment line in __init__() with to result in both methods being called?
I understand that I could just call each method by name but I'm looking
for a mechanism to avoid this.

class Foo(object):
def __init__(self):
#call all methods here
def test(self):
print 'The test method'
def hello(self):
print 'Hello user'

Thanks,

Rob C

May I ask what the intended application is?

Calling *everything* callable in an instance is pretty much guaranteed to cause a problem,
and a reusable external function might be better in any case.

The code posted kinda-sorta implies that you're looking to call only *your created* methods,
is that what you mean?

If so, you probably need to bite the bullet and stick to a naming convention
which excludes __class__, __init__, __call__ and so on, ie: no leading underscores a la public
methods, as well as making sure your methods actually support being called with no args.

Assuming all that, let me be the first in this thread to pointlessly use a list comprehension:


class bork(object):
def __init__(self):
#in __init__ method as requested...
[self.__getattribute__(i)() for i in dir(self) if not i.startswith('__') and callable(self.__getattribute__(i))]
def hello(self):
print 'hello'
def testyflops(self):
print 'breasts'

x=bork()
hello
breasts

or, nicer, you could have:

def callall(x):
[x.__getattribute__(i)() for i in dir(x) if not i.startswith('__') and callable(x.__getattribute__(i))]

then use:

class bink(object):
def __init__(self):
callall(self)
def hatstand(self):
print 'Argh!'
def jackbenimble(self):
print 'Freud!'

y=bink()
Argh!
Freud!

as well as being able to

callall(anInstanceOfSomeOtherClass)

....with other objects if you're just so wild and rebellious that you don't care about errors, and laugh in the face of
arguments.

HTH,

Ten

PS: Just out of curiosity, would you mind saying what this is for?

 

[bruno at modulix]

Tim Chase wrote:
(snip)

... def __init__(self):
... for method in dir(self):
... if method == method.strip("_"):

if not method.startswith('_'):