在Python中使用2个索引变量进行迭代

是否有更好或更干净的方法来实现以下结果？我有4个条件，代码的一半用“while循环”填充，I+=1，j+=1

i = 0
j = 0
limit1 = 2
limit2 = 4

while (i < limit1 and j < limit2):
    lists.append ('First index: %d, Second index: %d' % (i, j))
    j += 1
    lists.append ('First index: %d, Second index: %d' % (i, j))
    i += 1
    j += 1

for i in lists:
    print (i)

list=['如果j//2

列出范围（limit2）内j的['第一个索引：%d，第二个索引%d%'（j//2，j），如果j//2

列出范围（limit2）内j的['第一个索引：%d，第二个索引%d%'（j//2，j），如果j//2

列出范围（limit2）内j的['第一个索引：%d，第二个索引%d%'（j//2，j），如果j//2

从

i

计算

j

非常简单：

for i in xrange(limit1):
    l.append('First index: %d, Second index: %d' % (i, 2*i))
    l.append('First index: %d, Second index: %d' % (i, 2*i+1))

for j in xrange(min(limit2, limit1*2)):
    l.append('First index: %d, Second index: %d' % (j//2, j))

这假设

limit2

是

limit1

的两倍。如果情况并非总是如此，您可以添加额外的检查：

for i in xrange(limit1):
    if 2*i >= limit2:
        break
    l.append('First index: %d, Second index: %d' % (i, 2*i))
    l.append('First index: %d, Second index: %d' % (i, 2*i+1))

或者预先计算要使用的限制：

for i in xrange(min(limit1, (limit2 + 1)//2)):

尽管如您所见，极限计算可能容易出错

请注意，如果

limit2

不是2的倍数，您的代码可能会发出

j==limit2

的条目：

>>> lists = []
>>> i = 0
>>> j = 0
>>> limit1 = 2
>>> limit2 = 3
>>> while (i < limit1 and j < limit2):
...     lists.append ('First index: %d, Second index: %d' % (i, j))
...     j += 1
...     lists.append ('First index: %d, Second index: %d' % (i, j))
...     i += 1
...     j += 1
...
>>> for i in lists:
...     print (i)
...
First index: 0, Second index: 0
First index: 0, Second index: 1
First index: 1, Second index: 2
First index: 1, Second index: 3

---

从

i

计算

j

非常简单：

for i in xrange(limit1):
    l.append('First index: %d, Second index: %d' % (i, 2*i))
    l.append('First index: %d, Second index: %d' % (i, 2*i+1))

for j in xrange(min(limit2, limit1*2)):
    l.append('First index: %d, Second index: %d' % (j//2, j))

这假设

limit2

是

limit1

的两倍。如果情况并非总是如此，您可以添加额外的检查：

for i in xrange(limit1):
    if 2*i >= limit2:
        break
    l.append('First index: %d, Second index: %d' % (i, 2*i))
    l.append('First index: %d, Second index: %d' % (i, 2*i+1))

或者预先计算要使用的限制：

for i in xrange(min(limit1, (limit2 + 1)//2)):

尽管如您所见，极限计算可能容易出错

请注意，如果

limit2

不是2的倍数，您的代码可能会发出

j==limit2

的条目：

>>> lists = []
>>> i = 0
>>> j = 0
>>> limit1 = 2
>>> limit2 = 3
>>> while (i < limit1 and j < limit2):
...     lists.append ('First index: %d, Second index: %d' % (i, j))
...     j += 1
...     lists.append ('First index: %d, Second index: %d' % (i, j))
...     i += 1
...     j += 1
...
>>> for i in lists:
...     print (i)
...
First index: 0, Second index: 0
First index: 0, Second index: 1
First index: 1, Second index: 2
First index: 1, Second index: 3

---

从

i

计算

j

非常简单：

for i in xrange(limit1):
    l.append('First index: %d, Second index: %d' % (i, 2*i))
    l.append('First index: %d, Second index: %d' % (i, 2*i+1))

for j in xrange(min(limit2, limit1*2)):
    l.append('First index: %d, Second index: %d' % (j//2, j))

这假设

limit2

是

limit1

的两倍。如果情况并非总是如此，您可以添加额外的检查：

for i in xrange(limit1):
    if 2*i >= limit2:
        break
    l.append('First index: %d, Second index: %d' % (i, 2*i))
    l.append('First index: %d, Second index: %d' % (i, 2*i+1))

或者预先计算要使用的限制：

for i in xrange(min(limit1, (limit2 + 1)//2)):

尽管如您所见，极限计算可能容易出错

请注意，如果

limit2

不是2的倍数，您的代码可能会发出

j==limit2

的条目：

>>> lists = []
>>> i = 0
>>> j = 0
>>> limit1 = 2
>>> limit2 = 3
>>> while (i < limit1 and j < limit2):
...     lists.append ('First index: %d, Second index: %d' % (i, j))
...     j += 1
...     lists.append ('First index: %d, Second index: %d' % (i, j))
...     i += 1
...     j += 1
...
>>> for i in lists:
...     print (i)
...
First index: 0, Second index: 0
First index: 0, Second index: 1
First index: 1, Second index: 2
First index: 1, Second index: 3

---

从

i

计算

j

非常简单：

for i in xrange(limit1):
    l.append('First index: %d, Second index: %d' % (i, 2*i))
    l.append('First index: %d, Second index: %d' % (i, 2*i+1))

for j in xrange(min(limit2, limit1*2)):
    l.append('First index: %d, Second index: %d' % (j//2, j))

这假设

limit2

是

limit1

的两倍。如果情况并非总是如此，您可以添加额外的检查：

for i in xrange(limit1):
    if 2*i >= limit2:
        break
    l.append('First index: %d, Second index: %d' % (i, 2*i))
    l.append('First index: %d, Second index: %d' % (i, 2*i+1))

或者预先计算要使用的限制：

for i in xrange(min(limit1, (limit2 + 1)//2)):

尽管如您所见，极限计算可能容易出错

请注意，如果

limit2

不是2的倍数，您的代码可能会发出

j==limit2

的条目：

>>> lists = []
>>> i = 0
>>> j = 0
>>> limit1 = 2
>>> limit2 = 3
>>> while (i < limit1 and j < limit2):
...     lists.append ('First index: %d, Second index: %d' % (i, j))
...     j += 1
...     lists.append ('First index: %d, Second index: %d' % (i, j))
...     i += 1
...     j += 1
...
>>> for i in lists:
...     print (i)
...
First index: 0, Second index: 0
First index: 0, Second index: 1
First index: 1, Second index: 2
First index: 1, Second index: 3

---

---

这和你想要的完全不同，你说得对。我想我不知道为什么我想要的是想要的，但我会编辑我的答案。更好。需要注意的是，如果

limit2

不是2的倍数，则此代码不会发出

j==limit2

的条目，而问题的代码通常会发出。这是否是原始代码中的错误，只有提问者才能告诉我们。这与期望的完全不同。你是对的。我想我不知道为什么我想要的是想要的，但我会编辑我的答案。更好。需要注意的是，如果

limit2

不是2的倍数，则此代码不会发出

j==limit2

的条目，而问题的代码通常会发出。这是否是原始代码中的错误，只有提问者才能告诉我们。这与期望的完全不同。你是对的。我想我不知道为什么我想要的是想要的，但我会编辑我的答案。更好。需要注意的是，如果

limit2

不是2的倍数，则此代码不会发出

j==limit2

的条目，而问题的代码通常会发出。这是否是原始代码中的错误，只有提问者才能告诉我们。这与期望的完全不同。你是对的。我想我不知道为什么我想要的是想要的，但我会编辑我的答案。更好。需要注意的是，如果

limit2

不是2的倍数，则此代码不会发出

j==limit2

的条目，而问题的代码通常会发出。只有提问者才能告诉我们这是否是原始代码中的错误。名称

list

表示该变量由多个列表组成，但事实并非如此。这只是一个整数列表。使用不同的名称可能是个好主意。@user2357112嗯，这是一个字符串列表，可能被描述为“列表”。哎呀，字符串列表，而不是整数列表。无论如何，调用字符串列表是个坏主意；它们不是列表，它们的行为与列表非常不同。名称

list

表示该变量由多个列表组成，但它不是。这只是一个整数列表。使用不同的名称可能是个好主意。@user2357112嗯，这是一个字符串列表，可能被描述为“列表”。哎呀，字符串列表，而不是整数列表。无论如何，调用字符串列表是个坏主意；它们不是列表，它们的行为与列表非常不同。名称

list

表示该变量由多个列表组成，但它不是。这只是一个整数列表。使用不同的名称可能是个好主意。@user2357112嗯，这是一个字符串列表，可能被描述为“列表”。哎呀，字符串列表，而不是整数列表。无论如何，调用字符串列表是个坏主意；它们不是列表，它们的行为与列表非常不同。名称

list

表示该变量由多个列表组成，但它不是。这只是一个整数列表。使用不同的名称可能是个好主意。@user2357112嗯，这是一个字符串列表，可能被描述为“列表”。哎呀，字符串列表，而不是整数列表。无论如何，调用字符串列表是个坏主意；它们不是列表，它们的行为与列表非常不同。当j大于limit2时，这并不一定会中断。@DTing:确实如此。它假定

limit2==2*limit1

。我可以明确这个假设，加上一个v