使用generator函数生成迭代器。

def foo_gen():
    n = 0
    while True:
        n+=1
        yield n

然后像这样使用它

foo = foo_gen().next
for i in range(0,10):
    print foo()

如果你想要一个上限:

def foo_gen(limit=100000):
    n = 0
    while n < limit:
       n+=1
       yield n

如果迭代器终止(如上面的例子)，您也可以直接遍历它，如

for i in foo_gen(20):
    print i

当然，在这些简单的情况下，最好使用xrange:)

这是yield statement的文档。

_counter = 0
def foo():
   global _counter
   _counter += 1
   print 'counter is', _counter

Python习惯上使用下划线来表示私有变量。在C语言中，在函数内部声明静态变量的唯一原因是将它隐藏在函数之外，这并不是真正的Python惯用方法。

使用函数的属性作为静态变量有一些潜在的缺点:

每次要访问变量时，都必须写出函数的全名。 外部代码可以很容易地访问该变量并打乱值。

第二个问题的惯用python可能会用前导下划线来命名变量，以表明它不应该被访问，同时在事后保持它的可访问性。

使用闭包

另一种选择是使用词法闭包的模式，python 3中的nonlocal关键字支持这种模式。

def make_counter():
    i = 0
    def counter():
        nonlocal i
        i = i + 1
        return i
    return counter
counter = make_counter()

遗憾的是，我不知道如何将这个解决方案封装到装饰器中。

使用内部状态参数

另一种选择可能是使用未记录的参数作为可变值容器。

def counter(*, _i=[0]):
    _i[0] += 1
    return _i[0]

这是可行的，因为默认参数是在定义函数时计算的，而不是在调用函数时计算的。

更清洁的方法可能是使用容器类型而不是列表，例如:

def counter(*, _i = Mutable(0)):
    _i.value += 1
    return _i.value

但我不知道内置类型，清楚地传达的目的。

使用generator函数生成迭代器。

def foo_gen():
    n = 0
    while True:
        n+=1
        yield n

然后像这样使用它

foo = foo_gen().next
for i in range(0,10):
    print foo()

如果你想要一个上限:

def foo_gen(limit=100000):
    n = 0
    while n < limit:
       n+=1
       yield n

如果迭代器终止(如上面的例子)，您也可以直接遍历它，如

for i in foo_gen(20):
    print i

当然，在这些简单的情况下，最好使用xrange:)

这是yield statement的文档。

Python没有静态变量，但你可以通过定义一个可调用的类对象，然后将其用作函数来伪装它。也可以看看这个答案。

class Foo(object):
  # Class variable, shared by all instances of this class
  counter = 0

  def __call__(self):
    Foo.counter += 1
    print Foo.counter

# Create an object instance of class "Foo," called "foo"
foo = Foo()

# Make calls to the "__call__" method, via the object's name itself
foo() #prints 1
foo() #prints 2
foo() #prints 3

注意，__call__使类(对象)的实例可以通过自己的名称调用。这就是为什么上面调用foo()会调用类的__call__方法。从文档中可以看到:

任意类的实例都可以通过在类中定义__call__()方法来实现可调用。

这个回答建立在@claudiu的回答之上。

我发现我的代码变得越来越不清晰，而我一直都很清楚 当我要访问静态变量时，可以在函数名前面加上。

也就是说，在我的函数代码中，我更喜欢这样写:

print(statics.foo)

而不是

print(my_function_name.foo)

所以，我的解决方案是:

向函数中添加静态属性 在函数作用域中，添加一个局部变量statics作为my_function.statics的别名

from bunch import *

def static_vars(**kwargs):
    def decorate(func):
        statics = Bunch(**kwargs)
        setattr(func, "statics", statics)
        return func
    return decorate

@static_vars(name = "Martin")
def my_function():
    statics = my_function.statics
    print("Hello, {0}".format(statics.name))

备注

我的方法使用一个名为Bunch的类，它是一个字典，支持 属性风格的访问，一种JavaScript(参见2000年左右关于它的原始文章)

它可以通过pip install bunch安装

也可以这样手写:

class Bunch(dict):
    def __init__(self, **kw):
        dict.__init__(self,kw)
        self.__dict__ = self