> I've a function that needs to maintain an ordered sequence between
> calls.
>
> In C or C++, I'd declare the pointer (or collection object) static at
> the function scope.
>
> What's the Pythonic way to do this?
>
> Is there a better solution than putting the sequence at module scope?
Yes, there is; it's called "object oriented programming". In general,
whenever you find that one or more functions have to access a context
that is not passed in explicitly as arguments, the proper (pythonic and
non-pythonic) way is to define them as a method in a class that stores
this context.
class Foo(object):
def __init__(self):
self._context = # something
def method(self):
x = self._context
# do stuff
self._context.update()
Another solution is function/method attributes. This is handy if OO
seems an overkill for a single function, or in case of methods, if you
don't want to pollute the instance namespace with something used by a
single method:
def foo():
# foo.x is like a C static
try: foo.x +=1
except AttributeError:
foo.x = 1
return foo.x
for i in xrange(10): print foo()
if foo() is a method, it becomes a little more cumbersome, first
because you have to refer to the class name and (less obviously)
because user defined attributes are not allowed in instance methods (I
wonder why); you have to refer to the wrapped function:
class Foo(object):
def foo(self):
try: Foo.foo.im_func.x += 1
except AttributeError:
Foo.foo.im_func.x = 1
return Foo.foo.x
foo = Foo().foo
for i in xrange(10): print foo()
Hope this helps,
George
--
http://mail.python.org/mailman/listinfo/python-list
