在每行之后迭代两个列表切换方向的更多pythonic方式？

Question

I am writing some code that loops through two lists in a bit of an odd fashion. My goal is to iterate through all of list a , using index i , then loop through b using index j and alternate back and forth. Ie I want to iterate through pairs in the order:

(0,0),...,(n,0),(0,1)...(0,m),(1,1)...,(n,1),(1,2)...,(1,m),(2,2),...,(n,m)

My current code is written like this:

while i+j < len(a) + len(b) -2:
    #do stuff
    if direction_toggle:
        if i + 1 > len(a):
            direction_toggle = not direction_toggle
            i = j
        else:
            i += 1
    else:
        if j + 1 > len(b):
            direction_toggle = not direction_toggle
            j = i + 1
        else:
            j += 1

However, I would like to be a bit more pythonic, and follow the maxim of

Flat is better than nested.

What I want to write something that looks more like this:

while i+j < len(a) + len(b) -2:
    #do stuff
    if direction_toggle:
        var, length = i, len(a)
    else:
        var, length = j, len(b)
    if var + 1 > length:
        direction_toggle = not direction_toggle
    else:
        var += 1

So my question is: is there a way to accomplish the same goal but be less repetitive, and remove a layer of nesting? Broadly, my code is pretty simple but it seems that there's no way to avoid repeating myself in two different ways, am I missing something, or is my implementation in fact the bast way to accomplish this?

PS I hope this isn't a duplicate, I couldn't find any other questions addressing this theme.

EDIT FOR CLARITY: My specific requirement is that I process (i, j-1) , (i-1, j) and (i-1, j-1) before hitting (i, j) . Any possible path of iteration satisfying this requirement will work. In case you're interested, this is because I am trying to implement a DTW algorithm, where each value assigned in a matrix depends on previous adjacent values.

Answer 1

If you lay out the numbers in an n-row by m-column grid, you can obtain your solution by walking down the first column, then across the first row (starting at column 1), then down the second column (starting at row 1), then across the second row (starting at column 2), then down the third column (starting at row 2), etc. This simply implements that.

def gen_tuples(n_rows, n_cols):
    row = col = 0
    while row <= n_rows and col <= n_cols:
        for i in range(row, n_rows + 1):
            yield (i, col)

        for j in range(col + 1, n_cols + 1):
            yield (row, j)

        row += 1
        col += 1


list(gen_tuples(5, 3))

[(0, 0), (1, 0), (2, 0), (3, 0), (4, 0), (5, 0),
 (0, 1), (0, 2), (0, 3),
 (1, 1), (2, 1), (3, 1), (4, 1), (5, 1),
 (1, 2), (1, 3),
 (2, 2), (3, 2), (4, 2), (5, 2),
 (2, 3),
 (3, 3), (4, 3), (5, 3)]

Answer 2

Per your "EDIT FOR CLARITY"

My specific requirement is that I process (i, j-1), (i-1, j) and (i-1, j-1) before hitting (i, j).

That can just be done by

for i in range(n + 1):
    for j in range(m + 1):
         do_stuff()

---

If I understand correctly this time, if this was a 5 x 4 (n = 4, m = 3) matrix you basically want the below order:

 0 5  6  7
 1 8  12 13
 2 9  14 17
 3 10 15 18
 4 11 16 19

You should be able to solve this recursively.

def stripes(r, c, r0=0, c0=0, flip=False):
    for row in range(r0, r + 1):
        yield (row, c0) if not flip else (c0, row)
    if r0 <= r:
        yield from stripes(c, r, r0=c0 + 1, c0=r0, flip=not flip)

And then:

>>> list(stripes(4, 3))
[(0, 0), (1, 0), (2, 0), (3, 0), (4, 0),
 (0, 1), (0, 2), (0, 3),
 (1, 1), (2, 1), (3, 1), (4, 1),
 (1, 2), (1, 3),
 (2, 2), (3, 2), (4, 2),
 (2, 3),
 (3, 3), (4, 3)]

or for your specific use case:

cache = {}
for r, c in stripes(R, C):
    inputs = (r - 1, c), (r - 1, c - 1), (r, c - 1)
    a, b, c = (cache.get((x, y)) for x, y in inputs)
    cache[(r, c)] = do_stuff(a, b, c)