如何在Python中同時運行3個計數器？

Question

我想按照一個非常特定的模式同時運行3個不同的計數器：

• counter_3顯示從0到2144的迭代次數
• counter_1每65次迭代增加1
• counter_2從1到65，然后從2到65，然后從3到65 ...

結果應如下所示：

counter_1   counter_2   counter_3

    0          1            0
    0          2            1
    0          3            2
    0          4            3
    0          5            4
    ...        ...          ...
    0          65           64
    1          2            65
    1          3            66
    1          4            67
    ...        ...          ...
    1          65           128
    1          3            129
    2          4            130
    2          5            131
    ...        ...          ...
    32         64           2142
    32         65           2143
    32         65           2144

我知道如何分別運行這些計數器。

對於counter_1和counter_3 （以下稱為i ）：

counter_1 = 0

for i, e in enumerate(range(2145)):
        if i > 1 and i % 65 == 0:
            counter_1 += 1
        print(counter_1, i)

對於counter_2 （以下稱為e ）：

n = 0
g = 1
while n <= 2145:
    for e in np.arange(g, 66):
        print(e)   
    g += 1
    n += 1

問題：如何同時運行這三個計數器？

Answer 1

您有正確的總體思路：確定何時必須擺弄櫃台。 但是，請注意， coutner1是您可以簡單地從具有整數除法的counter3派生的值。 只需擔心counter2 ，您就可以了。 以下是您所編碼級別的解決方案：

c2 = 65
c2_new = 0   # Track where to start counter2 next time

for c3 in range(2145):

    if c2 == 65:
        c2 = c2_new
        c2_new += 1

    c2 += 1
    c1 = c3 // 65   # Simple division gets the c1 value

    print c1, c2, c3

Answer 2

第三個計數器只是索引，第一個計數器是index / 65。 只有中間的計數器不那么瑣碎，所以我會用那個計數器來驅動它。

for c, b in enumerate(b for start in range(1, 66) for b in range(start, 66)):
    print c / 65, b, c

和itertools版本：

for c, (_, b) in enumerate(combinations(range(66), 2)):
    print c / 65, b, c

Answer 3

我不想為您的問題尋找最簡單或最巧妙的答案，我想提供一種可以更廣泛地應用的模式。

您可以使用生成器來提供所需的每個數字系列，然后將它們組合。 這意味着您可以獨立測試它們。 這也意味着您可以對每個參數進行參數設置，以在測試過程中使用較小的數字。 例如，在這里，對Counter_1進行了參數設置，以使其行為發生改變之前允許的重復次數。

Counter_2幾乎肯定比需要的要復雜。 我的大腦迷霧了。

def Counter_1(rep=65):
    n = -1
    while True:
        n += 1
        k = n//rep
        yield k

def Counter_2(rep=65):
    n = 0
    inc = 0
    while True:
        n += 1
        if n==rep:
            k = n//rep
            yield n
            inc += 1
            n = inc
        else:
            yield n

counter_1 = Counter_1()
counter_2 = Counter_2()

for counter_3 in range(2145):
    c_1 = next(counter_1)
    c_2 = next(counter_2)
    print (c_1, c_2, counter_3)

    if counter_3>10:
        break

Answer 4

另一種使用生成器函數的迭代方法（在Python 3中）。

碼

import itertools as it


def counter1(item=0):
    """Yield increments every 65 iterations."""
    for _ in range(1, 66):
        yield item
    yield from counter1(item+1)


def counter2(item=1, stop=66):
    """Yield `item` to 65, incrementing `item` after `stop-1`."""
    yield from range(item, stop)
    if item != stop:
        yield from counter2(item+1)


def counter3(stop=2150-5):
    """Yield numbers 0 to `stop`."""
    for item in range(stop):
        yield item


cts = list(zip(counter1(), counter2(), counter3()))

演示版

# Sample results (see OP results)
counters = it.chain(cts[:5], cts[63:68], cts[128:132], cts[-3:])
for iteration in counters:
    print("{:<10} {:<10} {:<10}".format(*iteration))

樣本輸出

0          1          0         
0          2          1         
0          3          2         
0          4          3         
0          5          4         
0          64         63        
0          65         64        
1          2          65        
1          3          66        
1          4          67        
1          65         128       
1          3          129       
2          4          130       
2          5          131       
32         64         2142      
32         65         2143      
32         65         2144  

---

細節

• counter1 ： 無限生成器； 產生一個數字范圍內的值。 遞歸地重復遞增的值。
• counter2 ： 無限生成器； 對於每次迭代，請產生一個范圍內的值。 遞歸重復遞增計數器。
• counter3 ： 有限生成器； 在range()的簡單迭代。

所得的計數器將壓縮在一起，在有限counter3終止后將其耗盡。

在將yield from語句轉換for循環后，此示例與Python 2兼容，例如

for i in range(x, stop):
    yield i