Velocity Reviews - Computer Hardware Reviews

Velocity Reviews > Newsgroups > Programming > Python > Calling every method of an object from __init__

Reply
Thread Tools

Calling every method of an object from __init__

 
 
Rob Cowie
Guest
Posts: n/a
 
      06-19-2006
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

 
Reply With Quote
 
 
 
 
K.S.Sreeram
Guest
Posts: n/a
 
      06-19-2006
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-----

 
Reply With Quote
 
 
 
 
Tim Chase
Guest
Posts: n/a
 
      06-19-2006
> 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




 
Reply With Quote
 
George Sakkis
Guest
Posts: n/a
 
      06-19-2006
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

 
Reply With Quote
 
John Machin
Guest
Posts: n/a
 
      06-19-2006
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
 
Reply With Quote
 
Ten
Guest
Posts: n/a
 
      06-20-2006
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.
 
Reply With Quote
 
bruno at modulix
Guest
Posts: n/a
 
      06-20-2006
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 '(E-Mail Removed)'.split('@')])"
 
Reply With Quote
 
 
 
Reply

Thread Tools

Posting Rules
You may not post new threads
You may not post replies
You may not post attachments
You may not edit your posts

BB code is On
Smilies are On
[IMG] code is On
HTML code is Off
Trackbacks are On
Pingbacks are On
Refbacks are Off


Similar Threads
Thread Thread Starter Forum Replies Last Post
Should one always add super().__init__() to the __init__? Ramchandra Apte Python 17 09-30-2012 12:04 PM
problem calling parent's __init__ method Ryan Krauss Python 2 08-07-2008 03:57 PM
Error when calling superclass __init__ method Maese Fernando Python 1 05-18-2008 12:11 PM
super(...).__init__() vs Base.__init__(self) Kent Johnson Python 7 02-12-2006 08:59 PM
__new__ does not call __init__ as described in descrintro.html (WAS:Can __new__ prevent __init__ from being called?) Steven Bethard Python 2 02-16-2005 06:50 AM



Advertisments