如何在Python中同时运行3个计数器？

Question

I'd like to run simultaneously 3 different counters following a very specific pattern:

• counter_3 displays the number of iteration from 0 to 2144
• counter_1 increases by 1 every 65 iterations
• counter_2 goes from 1 to 65, then starts back from 2 to 65, then from 3 to 65 ...

The result should look like this:

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

I know how to run these counters separately.

For counter_1 and counter_3 (refered below as 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)

For counter_2 (refered below as e ):

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

QUESTION: How can i run these 3 counters simultaneously ?

Answer 1

You have the right general idea: determine when you have to fiddle with the counters. However, note that coutner1 is a value you can derive simply from counter3 with integer division. Just worry about counter2 , and you're fine. Here's a solution more at your level of coding:

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

Third counter is just the index and first counter is index/65. Only the middle counter is a little less trivial, so I'd use that one to drive this.

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

And an itertools version:

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

Answer 3

Not looking for the simplest or slickest specific answer to your question, I wanted to offer a pattern that might be applied more broadly.

You could use a generator to provide each of the series of numbers that you want, then combine them. This means that you could test them independently. It also means that you could parameterise each of them to allow for smaller numbers during testing. Here, for instance, Counter_1 is parameterised so with the number of repetitions allowed before its behaviour changes.

Counter_2 is almost certainly more complicated than it needs to be. My brain is in a fog.

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

Another iterative approach using generator functions (in Python 3).

Code

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()))

Demo

# 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))

Sample Output

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  

---

Details

• counter1 : an infinite generator; yields a value for over a range of numbers. Repeat for incremented values recursively.
• counter2 : an infinite generator; for every iteration, yield a value from a range. Repeat for incremented counters recursively.
• counter3 : a finite generator; a simple iteration over a range() .

The resulting counters are zipped together, exhausted after the termination of the finite counter3 .

This example is Python 2 compatible after transforming yield from statements to for loops, eg

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