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

在迭代时使用enumerate获取包含元素的索引：

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

请注意，Python的索引从零开始，所以你会得到0到4与上述。 如果你想要计数，1到5，这样做:

count = 0 # in case items is empty and you need it after the loop
for count, item in enumerate(items, start=1):
    print(count, item)

单向控制流程

你所要求的是下面的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

或者有时更常见（但unidiomatically）在Python中找到:

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

使用枚举函数

Python的enumerate函数通过隐藏索引的会计来减少视觉混乱，并将iterable封装到另一个iterable（一个enumerate对象）中，该对象生成索引的两项元组和原始iterable将提供的项。 看起来像这样：

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

此代码示例是规范的示例，说明Python惯用代码与非惯用代码之间的区别。 惯用代码是复杂的（但并不复杂）Python，以其预期使用的方式编写。 惯用代码是语言设计者所期望的，这意味着通常这些代码不仅更具可读性，而且更有效率。

数数

即使你不需要索引，但你需要迭代的计数（有时需要），你可以从1开始，最终的数字将是你的计数。

count = 0 # in case items is empty
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，创建一个enumerate对象:

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索引从零开始
• 若要在迭代时从可迭代对象获取这些索引，请使用enumerate函数
• 以惯用的方式使用枚举（以及元组解包）创建更具可读性和可维护性的代码:

所以这样做:

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

从0以外的0开始非常简单：

for index, item in enumerate(iterable, start=1):
   print index, item  # Used to print in python<3.x
   print(index, item) # Mirate print() after 3.x+
   

for i in range(len(ints)):
   print(i, ints[i]) # print updated to print() in Python 3.x+ 

正如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. 总有另一种方式

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

老式的方式:

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

访问索引和方法的性能基准

在Python3.7中，访问list within loop索引的最快方法是对小型，中型和大型列表使用枚举方法。

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

# 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方法是迭代最快的方法。

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

• Python2中的range和xrange函数有什么区别。X？

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

• range(len(list))还是enumerate(list)?

您可以使用enumerate并在字符串文字中嵌入表达式来获得解决方案。

这是一个简单的方法:

a=[4,5,6,8]
for b, val in enumerate(a):
    print('item #{} = {}'.format(b+1, val))

当你在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

首先，索引将从0到4。 编程语言从0开始计数;不要忘记这一点，否则你会遇到一个索引越界异常。 所有你需要在for循环是一个变量计数从0到4这样:

for x in range(0, 5):

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

要获取索引的值，请使用

list[index]

你可以用这个代码来做:

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

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

在你的问题中，你写"如何访问循环索引，在这种情况下从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

如果我要迭代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])

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

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

你也可以试试这个:

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

使用While循环的简单答案:

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

输出:

<img alt="在这里输入图像描述"src="https://i.stack.imgur.com/Ucu0o.png缧/>

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

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

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

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

在格式化字符串时，将一个"计数器"变量设置为一个参数的初始值 ，作为项目编号。 for循环访问列表中的"listos"变量。 当我们通过"i"访问列表时，"i"被格式化为项目价格{或它是什么}。

listos = [8,23,45,12,78]
counter = 1
for i in listos :
    print('Item #{} = {}'.format(counter,i))
    counter += 1


output:
Item #1 = 8
Item #2 = 23
Item #3 = 45
Item #4 = 12
Item #5 = 78

这是很好的服务:

list2 = [11, 'sumit', 43.21, 'sharma', '44', 'test', 2]
for x in list1:
    print( 'index: ', list2.index(x), 'value:', x )