访问“ for”循环中的索引？

ints = [8, 23, 45, 12, 78]
for i in ints:
    print('item #{} = {}'.format(???, i))

 item #1 = 8
item #2 = 23
item #3 = 45
item #4 = 12
item #5 = 78
 

#1 楼

使用其他状态变量，例如索引变量（通常在C或PHP等语言中使用），被认为是非pythonic的。

更好的选择是使用内置的函数enumerate()，在Python 2和3中都可用。

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

请查看PEP 279了解更多信息。

#2 楼

使用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函数通过隐藏索引的记帐并封装可迭代对象来减少视觉混乱另一个可迭代项（一个enumerate对象），它产生索引和原始可迭代项将提供的项目的两个项目元组。看起来像这样：

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

这个代码示例很好地说明了Python的惯用代码与非Python的代码之间的差异的典范示例。惯用代码是复杂的（但不复杂）Python，以预期使用的方式编写。语言的设计者希望使用惯用代码，这意味着通常该代码不仅更具可读性，而且效率更高。

获取计数

即使您不需要索引，但是您需要计数迭代次数（有时是理想的），您可以从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']

现在我们将这个可迭代对象传递给枚举，创建一个枚举对象：

enumerate_object = enumerate(items) # the enumerate object

我们可以使用next函数从循环中提取第一个项目：

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

我们看到我们得到了第一个索引0和第一个项'a'的元组：

(0, 'a')

我们可以使用从这两个元组中提取元素的所谓“序列拆包”：

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

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

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

结论


Python索引从零开始
要在迭代过程中从迭代器中获取这些索引，请使用枚举函数
以惯用方式使用枚举（al并使用元组解包）创建的代码更具可读性和可维护性：

这样做：

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

#3 楼

从1之外的0开始非常简单：

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

#4 楼

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

#5 楼

按照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一起使用。它比其他示例更好地处理嵌套循环。

#6 楼

老式的方法：

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

#7 楼

访问索引和方法的性能基准测试
在Python 3.7中访问循环内列表索引的最快方法是对小型，中型和大型列表使用枚举方法。
请参阅可以使用的不同方法在下面的代码示例中遍历列表和访问索引值及其性能指标（我认为这对您有用）：

# Using range
def range_loop(iterable):
    for i in range(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("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 speed for list with 1000 items
measure(range(1000))
# range:  1.161622366
# enumerate:  0.5661940879999996
# manual_indexing:  0.610455682

# Measure speed for list with 100000 items
measure(range(10000))
# range:  11.794482958
# enumerate:  6.197628574000001
# manual_indexing:  6.935181098000001

# Measure speed for list with 10000000 items
measure(range(10000000), number=100)
# range:  121.416859069
# enumerate:  62.718909123
# manual_indexing:  69.59575057400002

结果，使用enumerate方法是需要索引时最快的迭代方法。
在下面添加一些有用的链接：


range和之间有什么区别？ Python 2.X中的xrange函数？


在Python中使用枚举进行循环或使用xrange进行循环的速度更快？


range（len （列表））还是枚举（列表）？

#8 楼

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

for x in range(0, 5):

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

要获取索引的值，请使用

list[index]

#9 楼

在for循环中访问索引时，会得到以下结果：

for i in enumerate(items): print(i)

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

for i in enumerate(items):
    print("index/value", i)

结果：

# index/value (0, 8)
# index/value (1, 23)
# index/value (2, 45)
# index/value (3, 12)
# index/value (4, 78)

for i, val in enumerate(items): print(i, val)

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

for i, val in enumerate(items):
    print("index", i, "for value", val)

结果：

# index 0 for value 8
# index 1 for value 23
# index 2 for value 45
# index 3 for value 12
# index 4 for value 78

for i, val in enumerate(items): print(i)

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

for i, val in enumerate(items):
    print("index", i)

结果：

# index 0
# index 1
# index 2
# index 3
# index 4

#10 楼

根据此讨论：http://bytes.com/topic/python/answers/464012-objects-list-index

循环计数器迭代

当前用于循环的习惯用法在索引上利用内置的range函数：

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

通过旧的成语或使用新的zip可以实现对元素和索引的循环内置函数：

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 /

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

解决此问题的最佳方法是使用枚举内置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 楼

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

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

，或者将长度取为l = len(nums)

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

#14 楼

在您的问题中，您写道：“在这种情况下，我如何访问循环索引，从1到5？”

但是，列表的索引从零开始。因此，那么我们需要知道您真正想要的是列表中每个项目的索引和项目，还是您真正想要的是从1开始的数字。幸运的是，在Python中，执行这一项或两项都很容易。 />
首先，要弄清楚，enumerate函数迭代地返回列表中每个项目的索引和对应的项目。

alist = [1, 2, 3, 4, 5]

for n, a in enumerate(alist):
    print("%d %d" % (n, a))

上述输出然后，

 0 1
1 2
2 3
3 4
4 5
 

请注意，索引从0开始运行。这种索引是在包括Python和C在内的现代编程语言中很常见。

如果希望循环遍历列表的一部分，则可以将标准Python语法用于列表的一部分。例如，要从列表中的第二个项目循环到最后一个但不包括最后一个项目，可以使用

for n, a in enumerate(alist[1:-1]):
    print("%d %d" % (n, a))

请注意，输出索引再次运行从0开始，

 0 2
1 3
2 4
 

这使我们进入了start=n的enumerate()开关。这只是偏移索引，您可以等效地在循环内部简单地在索引中添加一个数字。

for n, a in enumerate(alist, start=1):
    print("%d %d" % (n, a))

输出的结果是

 1 1
2 2
3 3
4 4
5 5
 

#15 楼

如果列表中没有重复的值：

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

#16 楼

您也可以尝试以下方法：

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']

#17 楼

您可以使用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的方法，但是具有列表理解功能，因此用更少的代码就能更快地实现。

#18 楼

使用While循环的简单答案：

arr = [8, 23, 45, 12, 78]
i = 0
while i < len(arr):
    print("Item ", i + 1, " = ", arr[i])
    i += 1

输出：

#19 楼

要使用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)]

#20 楼

这足以满足以下目的：

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