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

[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'

class Foo(object): .... 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..."
.... x = Foo()

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

[K.S.Sreeram]

Rob Cowie wrote:

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

iD8DBQFElwaQrgn0plK5qqURAoYMAJ41MX9UPa3Z7fzB9OLTyA fOnYf3HACfeMIU
5f6EIPWjVXzhsJbCXdMMXcs=
=Tsd9
-----END PGP SIGNATURE-----

[George Sakkis]

Rob Cowie wrote:

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]

On 20/06/2006 5:55 AM, Rob Cowie wrote:

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.variablenumberofargsohbuggerbacktothedrawingbo ard 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]

On Monday 19 June 2006 20:55, Rob Cowie wrote:

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?
--
There are 10 types of people in this world,
those who understand binary, and those who don't.

[bruno at modulix]

Tim Chase wrote:
(snip)

class Foo(object):

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

if not method.startswith('_'):

--
bruno desthuilliers
python -c "print '@'.join(['.'.join([w[::-1] for w in p.split('.')]) for
p in 'o****@xiludom.gro'.split('@')])"