How can a function access its own attributes?
attributes, closures, function, python, scope
Solution
Solution
Make one of the function's default arguments be a reference to the function itself.
def f(self):
return self.x
f.func_defaults = (f,)
Example usage:
>>> f.x = 17
>>> b = f
>>> del f
>>> b()
17
Explanation
The original poster wanted a solution that does not require a global name lookup. The simple solution
def f():
return f.x
performs a lookup of the global variable `f` on each call, which does not meet the requirements. If `f` is deleted, then the function fails. The more complicated `inspect` proposal fails in the same way.
What we want is to perform early binding and store the bound reference within the object itself. The following is conceptually what we are doing:
def f(self=f):
return self.x
In the above, `self` is a local variable, so no global lookup is performed. However, we can't write the code as-is, because `f` is not yet defined when we try to bind the default value of `self` to it. Instead, we set the default value after `f` is defined.
Decorator
Here's a simple decorator to do this for you. Note that the `self` argument must come last, unlike methods, where `self` comes first. This also means that you must give a default value if any of your other arguments take a default value.
def self_reference(f):
f.func_defaults = f.func_defaults[:-1] + (f,)
return f
@self_reference
def foo(verb, adverb='swiftly', self=None):
return '%s %s %s' % (self.subject, verb, adverb)
Example:
>>> foo.subject = 'Fred'
>>> bar = foo
>>> del foo
>>> bar('runs')
'Fred runs swiftly'
Problem
is it possible to access the python function object attributes from within the function scope? e.g. let's have ``` def f(): return SOMETHING f._x = "foo" f() # -> "foo" ``` now, what SOMETHING has to be, if we want to have the _x attribute content "foo" returned? if it's even possible (simply) thanks UPDATE: i'd like the following work also: ``` g = f del f g() # -> "foo" ``` UPDATE 2: Statement that it is not possible (if it is the case), and why, is more satisfying than providing a way how to fake it e.g. with a different object than a function