A bit reversed, but this should work:

def foo():
    foo.counter += 1
    print "Counter is %d" % foo.counter
foo.counter = 0

If you want the counter initialization code at the top instead of the bottom, you can create a decorator:

def static_vars(**kwargs):
    def decorate(func):
        for k in kwargs:
            setattr(func, k, kwargs[k])
        return func
    return decorate

Then use the code like this:

@static_vars(counter=0)
def foo():
    foo.counter += 1
    print "Counter is %d" % foo.counter

It'll still require you to use the foo. prefix, unfortunately.

^{(Credit: @ony)}

Assuming what you want is "a variable that is initialised only once on first function call", there's no such thing in Python syntax. But there are ways to get a similar result:

1 - Use a global. Note that in Python, 'global' really means 'global to the module', not 'global to the process':

_number_of_times = 0

def yourfunc(x, y):
    global _number_of_times
    for i in range(x):
        for j in range(y):
            _number_of_times += 1

2 - Wrap you code in a class and use a class attribute (ie: an attribute that is shared by all instances). :

class Foo(object):
    _number_of_times = 0

    @classmethod
    def yourfunc(cls, x, y):
        for i in range(x):
            for j in range(y):
                cls._number_of_times += 1

Note that I used a classmethod since this code snippet doesn't need anything from an instance

3 - Wrap you code in a class, use an instance attribute and provide a shortcut for the method:

class Foo(object):
    def __init__(self):
         self._number_of_times = 0

    def yourfunc(self, x, y):
        for i in range(x):
            for j in range(y):
                self._number_of_times += 1

yourfunc = Foo().yourfunc

4 - Write a callable class and provide a shortcut:

class Foo(object):
    def __init__(self):
         self._number_of_times = 0

    def __call__(self, x, y):
        for i in range(x):
            for j in range(y):
                self._number_of_times += 1


yourfunc = Foo()

4 bis - use a class attribute and a metaclass

class Callable(type):
    def __call__(self, *args, **kw):
        return self._call(*args, **kw)

class yourfunc(object):
    __metaclass__ = Callable

    _numer_of_times = 0

    @classmethod
    def _call(cls, x, y):
        for i in range(x):
            for j in range(y):                 
                cls._number_of_time += 1

5 - Make a "creative" use of function's default arguments being instantiated only once on module import:

def yourfunc(x, y, _hack=[0]):
    for i in range(x):
        for j in range(y):
            _hack[0] += 1

There are still some other possible solutions / hacks, but I think you get the big picture now.

EDIT: given the op's clarifications, ie "Lets say you have a recursive function with default parameter but if someone actually tries to give one more argument to your function it could be catastrophic", it looks like what the OP really wants is something like:

# private recursive function using a default param the caller shouldn't set
def _walk(tree, callback, level=0):
    callback(tree, level)
    for child in tree.children:
        _walk(child, callback, level+1):

# public wrapper without the default param
def walk(tree, callback):
    _walk(tree, callback)

Which, BTW, prove we really had Yet Another XY Problem...

Absolutely, you should create a static (or class) variable as you pointed out.

class Example:
    name = "Example"  #  usually called a class-variable

    @staticmethod
    def static(newName=None):
        if newName is not None:
            Example.name = newName

        print ("%s static() called" % Example.name)



    @classmethod
    def cls_static(cls, newName=None):
        if newName is not None:
            cls.name = newName

        print ("%s static() called" % cls.name)

Example.static()
Example.static("john")

Example.cls_static()
Example.cls_static("bob")

Depending on your preferences, you can use either one or the other. I let you read this link for more information: http://radek.io/2011/07/21/static-variables-and-methods-in-python/

• I really don't think Value is a help here.
  Whilst I can see the allure of only assigning x to static.x. This just looks like a smart, but not exactly good, work around to get default values.

  You can just have with_statics take keyword arguments as the defaults.

  def with_statics(**defaults):
      statics = Statics(defaults)  # Implementation left to imagination
      def inner(f):
          @wraps(f)
          def wrapper(*args, **kwargs):
              return f(statics, *args, **kwargs)
          return wrapper
      return inner
  

• Defining Value inside of two other classes is not great. You can just move it to the global scope and change the isinstance check to not need to use indexing.

  If you still want the class on the other classes then you can just assign it as a class attribute.

  class Current:
      Value = Value
  
      ...
  

• I think I'm fairly well versed in the magical Python arts. However your code is just confusing.

• Your code looks like it's a hack when a hack isn't needed.

  To highlight this I will convert your doctests to not use your code.

def counter():
    counter.val += 1
    return counter.val


counter.val = 0
print(counter(), counter(), counter())


def get_string():
    print("Getting string")
    return ""


def record(text):
    if record.recorded is None:
        record.recorded = get_string()
    record.recorded += text
    return record.recorded


record.recorded = None
print(record("Hello"))
print(record(", world!"))

Yes it works. However, honestly, why would you want this?