在'for'循环中访问索引？

我如何在下面这样的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

当我使用 "for "循环遍历它时，我如何访问循环索引，在本例中从1到5？

Aaron Hall
已编辑的问题 20日 九月 2019 в 12:19
编程
python list loops
6日 二月 2009 в 10:47
31 种观点
对该问题的评论 (1)
解决办法

使用一个额外的状态变量，如索引变量（你通常会在C或PHP等语言中使用），被视为非pythonic。

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

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

查看 PEP 279 了解更多。

评论(2)

&gt.＃使用for循环，在这种情况下，如何访问循环索引，从1到5？

使用for循环，如何访问循环索引，在本例中从1到5？

使用 "enumerate "来获取元素的索引。

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

并且注意，Python'的索引从0开始，所以用上面的方法会得到0到4。 如果你想得到1到5的计数，可以这样做。

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

单向控制流程

你要求的是下面的Pythonic等价物，这是大多数低级语言的程序员会使用的算法。

index = 0 # Python'的索引从零开始。

for item in items.# Python的for循环是一个"for each"。

Python'的for循环是一个"for each&quot。

循环，是一个"for each"。

print(index, item) &gt.index += 1 index += 1

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

index = 0

而index < len( items):

print(index, items[index]) &gt.index += 1 index += 1

或有时在Python中更常见(但单义)。

for index in range(len( items)): &gt.net; for index in range(len(items)): &gt.net print(index, items[index])

使用Enumerate函数

Python'的[enumerate函数][1]通过隐藏索引的核算，减少了视觉上的杂乱，并将其封装到另一个可迭代的对象（enumerate对象）中，产生一个索引和原始可迭代的项目的两个元组。 这看起来像这样。

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

这段代码样本是相当好的 [canonical][2] 的例子，它说明了 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']

现在我们将这个iterable传递给枚举，创建一个枚举对象。

enumerate_object = enumerate(items) # the enumerate object

我们可以用 "next "函数从这个迭代表中取出我们在循环中会得到的第一个项目。

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

我们看到我们得到了一个元组0，第一个索引，和&#39;a&#39;，第一个项目。

(0, 'a')

我们可以使用所谓的"[序列解包][3]&quot。 来提取这个二元组中的元素。

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

而当我们检查index时，发现它指的是第一个索引，0，而item指的是第一个项目，&#39;a&#39;。

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

结论

  • Python索引从零开始
  • 要在迭代时从一个可迭代对象中获取这些索引，可以使用枚举函数
  • 以习惯的方式使用枚举（以及元组解包）可以创建更易读和维护的代码。

所以要这样做。

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

[1]: https://docs.python.org/2/library/functions.html#enumerate [2]: http://python.net/~goodger/projects/pycon/2007/idiomatic/handout.html#index-item-2-enumerate。 [3]: https://docs.python.org/2/tutorial/datastructures.html#tuples-and-sequences

评论(0)

除了 "0 "之外，从 "1 "开始也很简单。

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

注

重要的提示，虽然有点误导，因为index在这里是一个tuple(idx, item)`。 可以了。

A.J.
编辑本段答案25日 七月 2018 в 10:55
评论(3)
for i in range(len(ints)):
   print i, ints[i]
评论(7)

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

  1. 使用枚举法(被认为是最习惯的)

for index, element in enumerate(lst):

在这里做需要做的事情

在我看来，这也是最安全的选择，因为已经消除了进入无限递归的机会。 项和它的索引都保存在变量中，不需要再写任何代码了 来访问该项目。

  1. 创建一个变量来保存索引（使用for）。

for index in range(len(lst)):

或 xrange

＃你将不得不写额外的代码来获取元素

  1. 创建一个变量来保存索引（使用while）。

指数=0 而index < len(lst):

你将不得不写额外的代码来获取元素

index += 1 #逃避无限递归

  1. 总有另一种方式

    如前所述，还有其他一些方法没有在此说明，它们甚至可能更适用于其他情况。 例如使用itertools.chain与for。 它比其他例子更能处理嵌套循环。

评论(0)

老式的方法。

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)
>>>
评论(3)

在Python 2.7中，在循环内访问list的索引最快的方法是对小型list使用[range方法][1]，对中型和大型list使用[enumerate方法][2]。

请在下面的代码示例中看到不同的方法，可以用来迭代列表和访问索引值，以及它们的性能指标（我想对你有用）。

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个项目的列表。 对于大小为&gt.的列表，"enumerate "是赢家。 10,000个项目时，enumerate是赢家。

下面补充一些有用的链接。

[1]: https://docs.python.org/2/library/functions.html#range [2]: https://docs.python.org/2/library/functions.html#enumerate

评论(2)

首先，索引将从0到4。 编程语言从0开始计数。 不要忘了这一点，否则你会遇到一个index out of bounds异常。 在for循环中，你所需要的只是一个从0到4的变量，就像这样。

for x in range(0, 5):

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

要获得一个索引的值，使用

list[index]
评论(0)

根据这个讨论。 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/

Georgy
编辑本段答案22日 五月 2019 в 2:29
评论(3)

你可以用这个代码来实现。

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
评论(0)

解决这个问题的最好办法是使用enumerate内置的python函数。
enumerate返回tuple
。 enumerate返回tuple
第一个值是index
第二个值是element
第二个值是该索引处数组的元素。

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)
评论(0)

当你在 "for "循环中访问index时，你会得到什么？

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

[！[在此输入图像描述][1]][1]

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

[！[在此输入图像描述][2]][2]

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

[！[在此输入图像描述][3]][3]

希望对大家有所帮助。

[1]: https://i.stack.imgur.com/2Vke5.png [2]: https://i.stack.imgur.com/BeRBP.png [3]: https://i.stack.imgur.com/b1gka.png

评论(0)

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

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

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

for i in range(1, l + 1):
    print(i, nums[i])
Georgy
编辑本段答案22日 五月 2019 в 2:58
评论(0)

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

for i in ints:
    indx = ints.index(i)
    print(i, indx)
Georgy
编辑本段答案22日 五月 2019 в 3:02
评论(2)

你也可以试试这个。

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']
评论(0)

在你的问题中，你写道 *"在这种情况下，我如何访问循环索引，从1到5？

然而，一个列表的索引是从0开始运行的。 所以，我们就需要知道你真正想要的是列表中每个项目的索引和项目，还是你真的想要从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

这就涉及到enumerate()的start=n开关。 这只是简单的偏移了索引，你可以在循环中简单的给索引添加一个数字。

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

产量为

1 1
2 2
3 3
4 4
5 5
Georgy
编辑本段答案22日 五月 2019 в 3:10
评论(0)

您可以使用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中的索引和值，作为一个tuple的列表。

它使用了本问题选定答案中的 "enumerate "方法，但带有列表理解功能，使其以较少的代码变得更快。

PyRsquared
编辑本段答案31日 五月 2018 в 6:09
评论(0)

在列表理解中使用 "for "循环打印(index, value)的元组。

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)]
评论(0)

这样做的目的已经很好了。

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