我可以在python中拥有一个全局变量而不将其声明为全局吗?

Question

我想要某种保持当前数字的全局状态，以及生成下一个数字的函数。

我可以写一个生成器给我下一个数字。

 def gen(self, n):
    yield n
    yield n + 1

但是保持其状态的干净方法是什么呢?我不想简单地拥有一个全局变量。有更好的方法吗?或者这是我唯一的选择?

我试着创建一个这样的类:

class Count:
"""
Represents the counter which
generates variables
"""
def __init__(self, curr=0):
    """
    :param curr: the current integer
    """
    self.curr = curr
def gen(self):
    """
    A generator for the next
    number
    :return: generator
    """
    self.curr += 1
    yield self.curr
    yield self.curr + 1

，但这不会工作，因为每次我创建Count()，它会重置我的计数器，我不想要的。

Answer 1

如果您想要跨Count的多个实例维护状态，那么在类作用域中使用一个变量，并使用Count.前缀引用它，如下所示:

class Count:
    curr = 0
    def __init__(self, startWith = None):
        if startWith is not None: Count.curr = startWith - 1
    def gen(self):
        while True:
            Count.curr += 1
            yield Count.curr

注意，如果你想要保持状态，构造函数应该允许不重置计数器，但保持不变的可能性。

作为旁注，您可能对让生成器生成如上所示的永不结束的系列感兴趣。

下面是你如何使用上面的类:

# Get generator that starts with 2
gen = Count(2).gen();
print (next(gen)); # -> 2
print (next(gen)); # -> 3
print (next(gen)); # -> 4
# Get a generator that continues ...
gen2 = Count().gen();
print (next(gen2)); # -> 5
# We can still use the previous generator also:
print (next(gen)); # -> 6
# Start with 0:
gen3 = Count(0).gen();
print (next(gen3)); # -> 0
# Other generators follow suit:
print (next(gen)); # -> 1
print (next(gen2)); # -> 2

Answer 2

如果我的理解是正确的，为了消除global计数器，您可以为变量创建一个闭包并返回一个使其递增的函数。

原始函数counter只被调用一次，连续调用只是增加计数器:

def count(n):
    c = n
    def incr():
        nonlocal c
        c += 1
        print(c)
        return c
    return incr

count初始化为连续调用的状态n和incr引用:

>>> f = count(2)
>>> f()
3
>>> f()
4
>>> f()
5

Answer 3

或者您可以使用下一个(生成器)函数

def num_gen():
    n=1
    while n:
        yield n
        n += 1

然后

>>my_gen = num_gen()
>>next(my_gen)
1
>>next(my_gen)
2

等等。每当生成器产生一个值时，将存储生成器的状态，以便稍后继续执行。