使用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的文档。

你也可以考虑:

def foo():
    try:
        foo.counter += 1
    except AttributeError:
        foo.counter = 1

推理:

非常python化(“请求原谅而不是允许”) 使用异常(只抛出一次)而不是if分支(考虑StopIteration异常)

您可以向函数添加属性，并将其用作静态变量。

def myfunc():
  myfunc.counter += 1
  print myfunc.counter

# attribute must be initialized
myfunc.counter = 0

或者，如果你不想在函数外部设置变量，你可以使用hasattr()来避免AttributeError异常:

def myfunc():
  if not hasattr(myfunc, "counter"):
     myfunc.counter = 0  # it doesn't exist yet, so initialize it
  myfunc.counter += 1

无论如何，静态变量是相当罕见的，您应该为这个变量找到一个更好的位置，最有可能是在类中。

根据丹尼尔的回答(补充):

class Foo(object): 
    counter = 0  

def __call__(self, inc_value=0):
    Foo.counter += inc_value
    return Foo.counter

foo = Foo()

def use_foo(x,y):
    if(x==5):
        foo(2)
    elif(y==7):
        foo(3)
    if(foo() == 10):
        print("yello")


use_foo(5,1)
use_foo(5,1)
use_foo(1,7)
use_foo(1,7)
use_foo(1,1)

我想添加这一部分的原因是，静态变量不仅用于增加某个值，而且还用于检查静态变量是否等于某个值，作为一个现实生活中的例子。

静态变量仍然受到保护，并且仅在函数use_foo()的作用域内使用。

在这个例子中，调用foo()函数完全是(相对于相应的c++等效函数):

stat_c +=9; // in c++
foo(9)  #python equiv

if(stat_c==10){ //do something}  // c++

if(foo() == 10):      # python equiv
  #add code here      # python equiv       

Output :
yello
yello

如果类Foo被严格定义为一个单例类，那将是理想的。这将使它更加python化。

许多人已经建议测试“hasattr”，但有一个更简单的答案:

def func():
    func.counter = getattr(func, 'counter', 0) + 1

没有try/except，没有测试hasattr，只有默认的getattr。

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

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

第二个问题的惯用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

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