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

如果我的理解是正确的，为了消除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 2

或者您可以使用下一个（生成器）功能。

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

然后

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

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

Answer 3

如果要在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

我可以在python中使用全局变量而不将其声明为全局变量吗？

3 个答案: