Python 访问'中的索引；对于'；循环？

如何访问

for

循环中的索引，如下所示

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

我希望获得以下输出：

项目#1=8
项目#2=23
第3项=45
项目#4=12
第5项=78

当我使用

for

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

老式方式：

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

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

---

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

更好的选择是使用内置函数，该函数在Python 2和Python 3中都可用：

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

---

查看更多信息。

根据本讨论：

循环计数器迭代

当前在索引上循环的习惯用法使用了内置的

范围

函数：

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

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

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

可以使用旧的习惯用法或使用新的

zip

内置函数实现元素和索引的循环：

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

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

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

或

---

通过从

1

而不是

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+
   

对于索引，枚举中的项（iterable，start=1）：
打印索引，项目#用于在python中打印
使用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)

单向控制流
您需要的是以下Pythonic等价物，这是大多数低级语言程序员会使用的算法：

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

使用枚举函数
Python通过隐藏索引的说明，并将iterable封装到另一个iterable（一个
枚举
对象）中，从而产生索引的两项元组和原始iterable将提供的项，从而减少了视觉混乱。看起来是这样的：

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

这个代码示例很好地说明了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，创建enumerate对象：

enumerate_object = enumerate(items) # the enumerate object

我们可以使用
next
函数从这个iterable中提取第一项：

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

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

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

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

(0, 'a')

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

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

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

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

结论

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

这样做：

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

首先，索引将从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

访问索引和方法的性能基准
在Python3.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
方法是迭代的最快方法

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








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

1.使用枚举（被认为是最惯用的）
在我看来，这也是最安全的选择，因为进入无限递归的机会已经被消除。项目及其索引都保存在变量中，无需编写任何进一步的代码
以访问该项目

2.创建用于保存索引的变量（使用
for
）
3.创建用于保存索引的变量（使用
而
）
index=0
当指数

4.总有另一种方法
如前所述，还有其他方法没有在这里解释，它们甚至可能在其他情况下应用得更多。e、 g使用
itertools.chain
和for。它比其他示例更好地处理嵌套循环。
这是
index = 0
while index < len(lst):
    # you will have to write extra code to get the element
    index += 1  # escape infinite recursion

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)

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

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

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

ints = [8, 23, 45, 12, 78]
inds = [ints.index(i) for i in 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)]

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

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

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

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

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

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

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

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)

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

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

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

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

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

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

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