提问



如何访问索引本身以获取如下列表?


ints = [8, 23, 45, 12, 78]


当我使用for循环遍历它时,如何访问循环索引,在这种情况下从1到5?

最佳参考


使用附加的状态变量,例如索引变量(通常在C或PHP等语言中使用),被认为是非pythonic。


更好的选择是使用Python 2和3中都提供的内置函数enumerate():[87]


for idx, val in enumerate(ints):
    print(idx, val)


查看PEP 279了解更多信息。[88]

其它参考1



  

使用for循环,如何访问循环索引,在这种情况下从1到5?




在迭代时使用enumerate获取元素的索引:


for index, item in enumerate(items):
    print(index, item)


请注意,Python的索引从零开始,因此您可以使用上面的0到4。如果您想要计数,1到5,请执行以下操作:


for count, item in enumerate(items, start=1):
    print(count, item)


Unidiomatic控制流程



您要求的是Pythonic等效于以下内容,这是大多数低级语言程序员使用的算法:



index = 0            # Python's indexing starts at zero
for item in items:   # Python's for loops are a "for each" loop 
    print(index, item)
    index += 1



或者在没有for-each循环的语言中:



index = 0
while index < len(items):
    print(index, items[index])
    index += 1



或者有时在Python中更常见(但不常见):



for index in range(len(items)):
    print(index, items[index])



使用枚举功能



Python的enumerate函数通过隐藏索引的会计,并将iterable封装到另一个可迭代(一个enumerate对象)中来减少视觉混乱,该迭代产生索引和项目的两项元组最初的iterable将提供。看起来像这样:[89]


for index, item in enumerate(items, start=0):   # default is zero
    print(index, item)


这段代码示例相当于Python的惯用代码和非代码的代码之间差异的规范示例。惯用代码是复杂的(但并不复杂)Python,以其打算使用的方式编写。惯用语代码是该语言的设计者所期望的,这意味着通常这段代码不仅更具可读性,而且效率更高。[90]


计算



即使您不需要索引,但是您需要计算迭代次数(有时是可取的),您可以从1开始,最终的数字将是您的计数。


for count, item in enumerate(items, start=1):   # default is zero
    print(item)

print('there were {0} items printed'.format(count))


当你说你想从1到5时,计数似乎更符合你想要的(而不是索引)。





打破它 - 一步一步的解释



要打破这些示例,请说我们有一个我们想要使用索引迭代的项目列表:


items = ['a', 'b', 'c', 'd', 'e']


现在我们传递这个iterable来枚举,创建一个枚举对象:


enumerate_object = enumerate(items) # the enumerate object


我们可以从这个迭代中拉出第一个项目,我们将在next函数的循环中获得:


iteration = next(enumerate_object) # first iteration from enumerate
print(iteration)


我们看到我们得到0元组,第一个索引,'a',第一个项目:


(0, 'a')


我们可以使用所谓的序列解包来从这个二元组中提取元素:[91]


index, item = iteration
#   0,  'a' = (0, 'a') # essentially this.


当我们检查index时,我们发现它指的是第一个索引0,item指的是第一个项目'a'


>>> print(index)
0
>>> print(item)
a


结论




  • Python索引从零开始

  • 要在迭代时从迭代中获取这些索引,请使用枚举函数

  • 以惯用的方式使用enumerate(以及元组解包)创建更易读和可维护的代码:



这样做:


for index, item in enumerate(items, start=0):   # Python indexes start at zero
    print(index, item)

其它参考2


从除0以外的1开始它非常简单:


for index, item in enumerate(iterable, start=1):
   print index, item


注意



重要提示,虽然index有点误导,但这里tuple (idx, item)
很高兴去。

其它参考3


for i in range(len(ints)):
   print i, ints[i]

其它参考4


正如Python中的标准一样,有几种方法可以做到这一点。在所有例子中假设:lst = [1, 2, 3, 4, 5]


1。使用枚举(被认为是最惯用的)



for index, element in enumerate(lst):
    # do the things that need doing here


在我看来,这也是最安全的选择,因为已经消除了进入无限递归的可能性。项目及其索引都保存在变量中,无需编写任何其他代码
访问该项目。


2。创建一个变量来保存索引(使用for )



for index in range(len(lst)):   # or xrange
    # you will have to write extra code to get the element


3。创建一个变量来保存索引(使用while )



index = 0
while index < len(lst):
    # you will have to write extra code to get the element
    index += 1  # escape infinite recursion


4。

总有另一种方式

如前所述,还有其他方法可以做到这一点,这里没有解释,甚至可能在其他情况下应用更多。 例如使用itertools.chain for。它比其他示例更好地处理嵌套循环。

其它参考5


老式的方式:


for ix in range(len(ints)):
    print ints[ix]


列表理解:


[ (ix, ints[ix]) for ix in range(len(ints))]

>>> ints
[1, 2, 3, 4, 5]
>>> for ix in range(len(ints)): print ints[ix]
... 
1
2
3
4
5
>>> [ (ix, ints[ix]) for ix in range(len(ints))]
[(0, 1), (1, 2), (2, 3), (3, 4), (4, 5)]
>>> lc = [ (ix, ints[ix]) for ix in range(len(ints))]
>>> for tup in lc:
...     print tup
... 
(0, 1)
(1, 2)
(2, 3)
(3, 4)
(4, 5)
>>> 

其它参考6


Python 2.7 中访问循环中列表索引的最快方法是使用范围方法用于小型列表,并枚举方法用于中型和大型列表。[92] [93]


请参阅以下代码示例中的不同方法,这些方法可用于迭代列表和访问索引值以及其性能指标(我认为这对您有用):


from timeit import timeit

# Using range
def range_loop(iterable):
    for i in range(len(iterable)):
        1 + iterable[i]

# Using xrange
def xrange_loop(iterable):
    for i in xrange(len(iterable)):
        1 + iterable[i]

# Using enumerate
def enumerate_loop(iterable):
    for i, val in enumerate(iterable):
        1 + val

# Manual indexing
def manual_indexing_loop(iterable):
    index = 0
    for item in iterable:
        1 + item
        index += 1


请参阅以下每种方法的效果指标:


from timeit import timeit

def measure(l, number=10000):
print "Measure speed for list with %d items" % len(l)
print "xrange: ", timeit(lambda :xrange_loop(l), number=number)
print "range: ", timeit(lambda :range_loop(l), number=number)
print "enumerate: ", timeit(lambda :enumerate_loop(l), number=number)
print "manual_indexing: ", timeit(lambda :manual_indexing_loop(l), number=number)

measure(range(1000))
# Measure speed for list with 1000 items
# xrange:  0.758321046829
# range:  0.701184988022
# enumerate:  0.724966049194
# manual_indexing:  0.894635915756

measure(range(10000))
# Measure speed for list with 100000 items
# xrange:  81.4756360054
# range:  75.0172479153
# enumerate:  74.687623024
# manual_indexing:  91.6308541298

measure(range(10000000), number=100)
# Measure speed for list with 10000000 items
# xrange:  82.267786026
# range:  84.0493988991
# enumerate:  78.0344707966
# manual_indexing:  95.0491430759


结果,使用range方法是最快列出1000个项目的方法。对于大小> 10 000项的列表enumerate是赢家。


添加以下一些有用的链接:



  • Python 2.X中range和xrange函数有什么区别?

  • 在Python中使用枚举或循环使用xrange的循环更快?

  • 范围(len(列表))或枚举(列表)?


其它参考7


我不知道以下是否是pythonic,但它使用Python函数enumerate并打印索引和值。


int_list = [8, 23, 45, 12, 78]
for index, value in enumerate(int_list):
   print(index, value)


输出:


0 8
1 23
2 45
3 12
4 78

其它参考8


ints = [9, 23, 45, 12, 78]
ints.extend([1,2,3,4,5,6,7,8])
for idx, val in enumerate(ints):
    print(idx,val)


这样您就可以扩展列表。扩展意味着您可以一次添加多个值。


要附加此列表,您必须编写下面给出的代码:


ints = [9, 23, 45, 12, 78]
ints.append([1])
for idx, val in enumerate(ints):
    print(idx,val)


这样,您可以一次添加一个值。如果你写ints.append([1]),那么这将为这个元素创建一个子列表。

其它参考9


首先,索引将从0到4.编程语言从0开始计数;不要忘了,否则你会遇到索引超出范围的异常。在for循环中你需要的只是一个从0到4的变量,如下所示:


for x in range(0, 5):


请记住,我写了0到5,因为循环在最大值之前停止了一个数字。 :)


获取索引使用的值


list[index]

其它参考10


根据这个讨论:http://bytes.com/topic/python/answers/464012-objects-list-index [97]


循环计数器迭代


循环索引的当前习惯使用内置的范围函数:


for i in range(len(sequence)):
    # work with index i


循环使用元素和索引可以通过旧的习语或使用新的zip内置函数
for idx, val in enumerate(ints):
    print(idx, val)
来实现:


for i in range(len(sequence)):
    e = sequence[i]
    # work with index i and element e


要么


for i, e in zip(range(len(sequence)), sequence):
    # work with index i and element e


通过http://www.python.org/dev/peps/pep-0212/[98]

其它参考11


您可以使用以下代码执行此操作:


ints = [8, 23, 45, 12, 78]
index = 0

for value in (ints):
    index +=1
    print index, value


如果需要在循环结束时重置索引值,请使用此代码:


ints = [8, 23, 45, 12, 78]
index = 0

for value in (ints):
    index +=1
    print index, value
    if index >= len(ints)-1:
        index = 0

其它参考12


解决此问题的最佳方法是使用枚举 in-build python函数。点击
枚举返回元组

第一个值是索引

第二个值是该索引处的数组的元素


In [1]: ints = [8, 23, 45, 12, 78]

In [2]: for idx, val in enumerate(ints):
   ...:         print(idx, val)
   ...:     
(0, 8)
(1, 23)
(2, 45)
(3, 12)
(4, 78)

其它参考13


你也可以试试这个:


data = ['itemA.ABC', 'itemB.defg', 'itemC.drug', 'itemD.ashok']
x = []
for (i, item) in enumerate(data):
      a = (i, str(item).split('.'))
      x.append(a)
for index, value in x:
     print(index, value)


输出是


0 ['itemA', 'ABC']
1 ['itemB', 'defg']
2 ['itemC', 'drug']
3 ['itemD', 'ashok']

其它参考14


您可以使用index方法


ints = [8, 23, 45, 12, 78]
inds = [ints.index(i) for i in ints]


修改
如果ints中有重复项,则注释中突出显示此方法不起作用,下面的方法应适用于ints中的任何值:


ints = [8, 8, 8, 23, 45, 12, 78]
inds = [tup[0] for tup in enumerate(ints)]


或者


ints = [8, 8, 8, 23, 45, 12, 78]
inds = [tup for tup in enumerate(ints)]


如果你想得到ints中的索引和值作为元组列表。


它在这个问题的选定答案中使用enumerate的方法,但是使用列表理解,使用更少的代码使其更快。

其它参考15


如果我要迭代nums=[[1,2,3,4,5]]
我会做


for i, num in enumerate(nums, start = 1):
    print(i, num)


或者得到长度为l=len(nums)


for i, num in range(1, l + 1):
    print(i, nums[i])

其它参考16


如果列表中没有重复值:


for i in ints:
        indx=ints.index(i)
        print(i,indx)


而是使用enumerate.


for counter, value in enumerate(ints):
    print(counter, value)


或使用以下:


for counter in range(len(ints)):
    print(counter,ints[counter])

其它参考17


你已经收到了许多解释enumerate的答案,但是如果你只需要索引来访问两个列表中的匹配条目,那么在Python 3中还有另一种更简洁的方法:zip


例如,如果您使用索引为列表中的数字提取相应的名称,则可以这样做:


ints = [8, 23, 45, 12, 78]
names = ["John", "Sue", "Johannes", "Patel", "Ian"]
for int, name = zip(ints, names):
    print("{} - {}".format(name, int)


这会产生


8 - John
23 - Sue
45 - Johannes
12 - Patel
78 - Ian

其它参考18


要使用for循环打印列表推导中的(索引,值)元组:


ints = [8, 23, 45, 12, 78]
print [(i,ints[i]) for i in range(len(ints))]


输出:


[(0, 8), (1, 23), (2, 45), (3, 12), (4, 78)]

其它参考19


这很好地达到了目的:


list1 = [10, 'sumit', 43.21, 'kumar', '43', 'test', 3]
for x in list1:
    print('index:', list1.index(x), 'value:', x)