Thanks for your reply, Nick. My first thought was "Ahhh, now I see. That's
slick!", but after playing with this a bit...
>>> class Foo:
... def __getattr__(self, attr):
... def intercepted(*args):
... print "%s%s" % (attr, args)
... return intercepted
...
>>> f = Foo()
>>> f
__repr__()
Traceback (most recent call last):
File "<stdin>", line 1, in ?
TypeError: __repr__ returned non-string (type NoneType)
my thought is "Oooooh... that is some nasty voodoo there!" Especially
if one wants to also preserve the basic functionality of __getattr__ so that
it still works to just get an attribute where no arguments were given.
I was thinking it would be clean to maintain an interface where you
could call things like f.set_Spam('ham') and implement that as self.Spam =
'ham' without actually having to define all the set_XXX methods for all the
different things I would want to set on my object (as opposed to just making
an attribute assignment), but I am starting to think that is probably an
idea I should just simply abandon.
I guess I don't quite follow the error above though. Can you explain
exactly what happens with just the evaluation of f?
Thanks,
-ej
"Nick Smallbone" <[EMAIL PROTECTED]> wrote in message
news:[EMAIL PROTECTED]
> Erik Johnson wrote:
> > Maybe I just don't know the right special function, but what I am
wanting to
> > do is write something akin to a __getattr__ function so that when you
try to
> > call an object method that doesn't exist, it get's intercepted *along
with
> > it's argument*, in the same manner as __getattr__ intercepts attributes
> > references for attributes that don't exist.
> >
> >
> > This doesn't quite work:
> >
> > >>> class Foo:
> > ... def __getattr__(self, att_name, *args):
> > ... print "%s%s" % (att_name, str(tuple(*args)))
> > ...
> > >>> f = Foo()
>
> The problem is that the call to f.bar happens in two stages: the
> interpreter calls getattr(f, "foo") to get a function, and then it
> calls that function. When __getattr__ is called, you can't tell what
> the parameters of the function call will be, or even if it'll be called
> at all - someone could have run "print f.bar".
>
> Instead, you can make __getattr__ return a function. Then *that*
> function will be called as f.bar, and you can print out its arguments
> there:
>
> class Foo:
> def __getattr__(self, attr):
> def intercepted(*args):
> print "%s%s" % (attr, args)
> return intercepted
>
--
http://mail.python.org/mailman/listinfo/python-list
