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

Question

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

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

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

Answer 1

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

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

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

查看PEP 279了解更多信息。

Answer 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 function通过隐藏索引的会计，并将iterable封装到另一个可迭代（一个enumerate对象）中来减少视觉混乱，该迭代产生一个两项元组。 index和原始iterable将提供的项目。看起来像这样：

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

这个代码示例相当不错canonical示例，它是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和第一个项'a'得到元组：

(0, 'a')

我们可以使用所谓的＆＃34; sequence unpacking＆＃34;从这个二元组中提取元素：

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

当我们检查index时，我们发现它引用了第一个索引0，item引用了第一个项'a'。

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

结论

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

这样做：

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

Answer 3

从1以外的0启动它非常简单：

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

注意

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

Answer 4

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

Answer 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。它比其他示例更好地处理嵌套循环。

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

Answer 7

在 Python 2.7 中循环访问列表索引的最快方法是将range method用于小型列表，将enumerate method用于中型和大型列表。

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

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;的列表10 000项enumerate是赢家。

在下面添加一些有用的链接：

• What is the difference between range and xrange functions in Python 2.X?

• What is faster for loop using enumerate or for loop using xrange in Python?

• range(len(list)) or enumerate(list)?

Answer 8

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

for x in range(0, 5):

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

要获取索引的值，请使用

list[index]

Answer 9

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

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

Answer 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/

Answer 11

此问题的最佳解决方案是使用枚举 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)

Answer 12

在for循环中访问索引时，您将获得以下内容：

  

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

  

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

  

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

希望这会有所帮助。

Answer 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(1, l + 1):
    print(i, nums[i])

Answer 14

如果列表中没有重复值：

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

Answer 15

你也可以试试这个：

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

Answer 16

使用While循环的简单答案：

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

输出：

Answer 17

在您的问题中，您编写“如何访问循环索引，在这种情况下，从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的{​​{1}}开关。这只是使索引偏移，您可以等效地在循环内向索引简单地添加一个数字。

enumerate()

为其输出的

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

Answer 18

你可以简单地使用 count 变量来计算列表中元素的数量

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

Answer 19

您可以使用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的方法，但是使用列表理解，使用更少的代码使其更快。

Answer 20

使用<link href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap.min.css" rel="stylesheet"/> <div class="container-fluid"> <div class="row contact-bar"> <div class="col-xs-12 col-lg-6 col-md-6 col-sm-6 contact-top"> <p><i class="fa fa-phone"></i><span> </span><i class="fa fa-whatsapp"></i> +2347033501657</p> </div> <div class="col-xs-12 col-lg-6 col-md-6 col-sm-6 contact-top"> <p><i class="fa fa-envelope"></i> allamit@gmail.com</p> </div> </div> </div>循环打印列表推导中的（索引，值）元组：

@PrepareForTest(ApplicationBackgroundUtils.class)

输出：

for

Answer 21

这足以达到目的：

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

Answer 22

使用 enumerate 遍历列表

ints = [8, 23, 45, 12, 78]
for idx,val in enumerate(ints):
    print('item #{} = {}'.format(idx+1, val))

输出：

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

Answer 23

您可以使用 enumerate 遍历列表并以索引 start=1 开始，默认情况下它将以 0 开始

for index,val in enumerate(ints,start=1):
     print(f"item #{index} = {val}")

此外，使用 f" " 字符串是获得请求输出的快速方法，并且更具可读性，因为您可以将 index 和 val 直接传递给 {} 占位符。

输出：

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