Python 遍历列表并使用其他列表的LTEM

现在，当我迭代l时，在第一次迭代中，我想先对一个函数使用a[0]和b[0]，然后对同一个函数使用a[1]和b[1]

在l的第二次迭代中，我想先对函数使用a[2]和b[2]，然后对同一个函数使用a[3]和b[3]

>>> l = ['hello','hi']
>>> a=[1,2,3,4]
>>> b=[4,5,6,7]
>>> for i, val in enumerate(l):
...     print '---iteration', i
...     print 'l:', val
...     print 'a:', a[2*i], ', b:', b[2*i]
...     print 'a:', a[2*i+1], ' b:', b[2*i+1]
...
---iteration 0
l: hello
a: 1 , b: 4
a: 2  b: 5
---iteration 1
l: hi
a: 3 , b: 6
a: 4  b: 7

---

如果您有任何建议，我们将不胜感激。

您可以使用index方法查找您正在迭代的列表元素的索引。使用该索引，可以从要传递给函数的列表中找到元素

l = ['hello','hi']
a=[1,2,3,4]
b=[4,5,6,7]
for i in l:
 func(x=a[index],y=b[index])

>>> l = ['hello','hi']
>>> a=[1,2,3,4]
>>> b=[4,5,6,7]
>>> for i, val in enumerate(l):
...     print '---iteration', i
...     print 'l:', val
...     print 'a:', a[2*i], ', b:', b[2*i]
...     print 'a:', a[2*i+1], ' b:', b[2*i+1]
...
---iteration 0
l: hello
a: 1 , b: 4
a: 2  b: 5
---iteration 1
l: hi
a: 3 , b: 6
a: 4  b: 7

---

在调用

demo（）

之前，我宁愿先计算

a

和

b

的索引，而不是计算它们的索引。因为，每次计算的复杂度都是O（1），如果我在调用

demo

（即，如果我在做

demo（x=a[2*（l.index（I））]，y=b[2*（l.index（I））]）

，那么我会计算两次索引，结果复杂度是

O（2）

。同样，我访问列表

l

两次，这也增加了复杂性计算的开销。因此，预先计算索引，访问列表

l

一次，并将每次调用

demo

的复杂性降低2倍，从而降低4倍。

在迭代l时，您想对函数使用a和b的第一个索引是什么意思？