[Python-ideas] Access to function objects
steve at pearwood.info
Sun Aug 7 07:36:05 CEST 2011
Eric Snow wrote:
> Of the three code blocks, functions are the only ones for whom the
"Whom" is for people. You want "which".
(I don't normally correct people's grammar, but to me, this error broke
the flow of the sentence like being hit in the face with a sock with
half a brick in it.)
> resulting object and the execution of the code block are separate. So
> a code object could be executing for the original function or a
> different one that is sharing the code object.
Fairly unusual, but I grant it could happen. I've done it myself :)
> Why not bind the called function-object to the frame locals, rather
> than the one for which the code object was created, perhaps as
I'm afraid I can't interpret this (which may be my ignorance rather than
your fault). The only guess I can make is based on what you say later:
"One new implicit name in locals().
so I presume you mean that the function should see a local variable
(perhaps called "me", or "this"?) that is bound to itself.
Presumably if a function wants to use that same name as a local, nothing
bad will happen, since the local assignment will just override the
implicit assignment. But what about code that expects to see a nonlocal
or global with the same name?
What happens when two functions, sharing the same code object, get
called from two threads at the same time? Are their locals independent?
For most uses, standard recursion via the name is good enough, it's only
a few corner cases where self-reflection (as I call it) is needed. And I
say that as somebody who does want a way for functions to know
themselves. I don't think that use-case is so important that it should
be implicitly added to every function, on the off-chance it is needed,
rather than explicitly on demand.
> To finish things off, bind to every new code object
> the function for which it was created, perhaps as "co_func". That way
> you will always know what function object was called and which one the
> code object came from originally.
What benefit will this give? Have you ever looked at a code object and
said, "I need a way of knowing which function this is from?" If so, I'd
love to know what problem you were trying to solve at the time!
Code objects don't always get created as part of a function. They can be
returned by compile. What should co_func be set to then?
Finally, if the function has a reference to the code object, and the
code object has a reference to the function, you have a reference cycle.
That's not the end of the world now as it used to be, in early Python
before the garbage collector was added, but still, there better be a
really good use-case to justify it.
(Perhaps a weak reference might be more appropriate?)
More information about the Python-ideas