Calling a function dynamically

[Paradox]

I would like to call a function whose name I supply at runtime.
Something like this but it didn't work

functionName = 'run'
instance = ClassDef()
args = [1, 2]

#want the dynamic equivalant of
#instance.run(* args)

#This didn't work cause there was no __call__ attribute. Why?
value = instance.__call __[functionName](*args)


Thanks Joey

[Eric Brunel]

Paradox wrote:

I would like to call a function whose name I supply at runtime.
Something like this but it didn't work

functionName = 'run'
instance = ClassDef()
args = [1, 2]

#want the dynamic equivalant of
#instance.run(* args)

#This didn't work cause there was no __call__ attribute. Why?
value = instance.__call __[functionName](*args)

The "function" is in fact a method on the instance, that is handled like a
regular attribute. So using getattr should do what you want:

value = getattr(instanc e, functionName)(* args)

__call__ is for a completely different purpose, which is to define instances
that behave like functions:

class Spammer: .... def __call__(self):
.... print 'spam'
.... o = Spammer()
o()

spam
HTH
--
- Eric Brunel <eric dot brunel at pragmadev dot com> -
PragmaDev : Real Time Software Development Tools - http://www.pragmadev.com

[anton muhin]

Paradox wrote:

I would like to call a function whose name I supply at runtime.
Something like this but it didn't work

functionName = 'run'
instance = ClassDef()
args = [1, 2]

#want the dynamic equivalant of
#instance.run(* args)

#This didn't work cause there was no __call__ attribute. Why?
value = instance.__call __[functionName](*args)


Thanks Joey

This should work:
getattr(instanc e, functionName)(* args)

regards,
anton.

[Peter Otten]

Paradox wrote:

I would like to call a function whose name I supply at runtime.
Something like this but it didn't work

functionName = 'run'
instance = ClassDef()
args = [1, 2]

#want the dynamic equivalant of
#instance.run(* args)

#This didn't work cause there was no __call__ attribute. Why?
value = instance.__call __[functionName](*args)

The __call__() method is implicitly invoked when you write

value = instance(some, args)

Here's a way to abuse the [] operator (implemented by __getitem__()) to
dynamically select a method:

class Test: .... def __getitem__(sel f, name):
.... return getattr(self, name)
.... def run(self, *args):
.... print "run%s" % (args,)
.... t = Test()
t["run"] <bound method Test.run of <__main__.Tes t instance at 0x40295b0c>>

"bound method" means that both instance and method are stored, so that
for the actual call you need not provide an explicit self parameter:
t["run"]("alpha", "beta", "gamma")

run('alpha', 'beta', 'gamma')
Peter

[Dave Benjamin]

In article <bt************ *@news.t-online.com>, Peter Otten wrote:

Paradox wrote:

I would like to call a function whose name I supply at runtime.
[snip]

Here's a way to abuse the [] operator (implemented by __getitem__()) to
dynamically select a method...

t["run"]("alpha", "beta", "gamma")

run('alpha', 'beta', 'gamma')

I wouldn't necessarily consider this abuse. This behavior (where
square-bracket- and dot-syntax are functionally equivalent) is the normal
behavior of JavaScript, and it makes dynamic lookup of method names a snap.
Python is more flexible in giving you the option to have separate namespaces
for items and attributes, but if it makes more sense for an object to merge
the two, I see nothing wrong with it.

--
..:[ dave benjamin (ramenboy) -:- www.ramenfest.com -:- www.3dex.com ]:.
: d r i n k i n g l i f e o u t o f t h e c o n t a i n e r :

[Paradox]

Thanks to all. The getattr was exactly what I need and the __getitem__
override is a nice touch.
Dave Benjamin <ra***@lackingt alent.com> wrote in message news:<slrnbvr5h b.seu.ra***@lac kingtalent.com> ...

In article <bt************ *@news.t-online.com>, Peter Otten wrote:

Paradox wrote:

I would like to call a function whose name I supply at runtime.
[snip]

Here's a way to abuse the [] operator (implemented by __getitem__()) to
dynamically select a method...

> t["run"]("alpha", "beta", "gamma")

run('alpha', 'beta', 'gamma')

I wouldn't necessarily consider this abuse. This behavior (where
square-bracket- and dot-syntax are functionally equivalent) is the normal
behavior of JavaScript, and it makes dynamic lookup of method names a snap.
Python is more flexible in giving you the option to have separate namespaces
for items and attributes, but if it makes more sense for an object to merge
the two, I see nothing wrong with it.