"self" inside plain function?

Question

I've got a bunch of functions (outside of any class) where I've set attributes on them, like funcname.fields = 'xxx'. I was hoping I could then access these variables from inside the function with self.fields, but of course it tells me:

global name 'self' is not defined

So... what can I do? Is there some magic variable I can access? Like __this__.fields?

---

A few people have asked "why?". You will probably disagree with my reasoning, but I have a set of functions that all must share the same signature (accept only one argument). For the most part, this one argument is enough to do the required computation. However, in a few limited cases, some additional information is needed. Rather than forcing every function to accept a long list of mostly unused variables, I've decided to just set them on the function so that they can easily be ignored.

Although, it occurs to me now that you could just use **kwargs as the last argument if you don't care about the additional args. Oh well...

Edit: Actually, some of the functions I didn't write, and would rather not modify to accept the extra args. By "passing in" the additional args as attributes, my code can work both with my custom functions that take advantage of the extra args, and with third party code that don't require the extra args.

Thanks for the speedy answers :)

Answer 1

self isn't a keyword in python, its just a normal variable name. When creating instance methods, you can name the first parameter whatever you want, self is just a convention.

You should almost always prefer passing arguments to functions over setting properties for input, but if you must, you can do so using the actual functions name to access variables within it:

def a:
    if a.foo:
        #blah

a.foo = false
a()

see python function attributes - uses and abuses for when this comes in handy. :D

Answer 2

def foo():
    print(foo.fields)
foo.fields=[1,2,3]

foo()
# [1, 2, 3]

There is nothing wrong with adding attributes to functions. Many memoizers use this to cache results in the function itself.

For example, notice the use of func.cache:

from decorator import decorator
@decorator
def memoize(func, *args, **kw):
    # Author: Michele Simoniato
    # Source: http://pypi.python.org/pypi/decorator
    if not hasattr(func, 'cache'):
        func.cache = {}
    if kw: # frozenset is used to ensure hashability
        key = args, frozenset(kw.iteritems())
    else:
        key = args
    cache = func.cache # attribute added by memoize
    if key in cache:
        return cache[key]
    else:
        cache[key] = result = func(*args, **kw)
        return result