摘要：问题描述：如何在使用循环遍历序列时访问索引for？xs = [8, 23, 45] for x in xs: print("item #{} = {}".format(index, x)) 期望输出：item #1 = 8 item #2 = 23 item #3 = 45 解决...

问题描述：

如何在使用循环遍历序列时访问索引for？

xs = [8, 23, 45]

for x in xs:
    print("item #{} = {}".format(index, x))

期望输出：

item #1 = 8
item #2 = 23
item #3 = 45

解决方案 1：

使用内置函数enumerate()：

for idx, x in enumerate(xs):
    print(idx, x)

通过手动索引或手动管理附加状态变量是不符合 Python 规范的。for i in range(len(xs)): x = xs[i]

查看PEP 279了解更多。

解决方案 2：

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

或者有时在 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，以预期使用的方式编写。惯用代码是语言设计者所期望的，这意味着这种代码通常不仅更易读，而且更高效。

获得计数

即使您不需要索引，但您需要对迭代次数进行计数（有时是可取的），您可以从此开始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']

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

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 索引从零开始
要在迭代过程中从迭代器中获取这些索引，请使用枚举函数
以惯用的方式使用枚举（以及元组解包）可以创建更易读和更易于维护的代码：

所以这样做：

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  # Used to print in python<3.x
   print(index, item) # Migrate to print() after 3.x+

解决方案 4：

在 Python 3.12 上测试

以下 12 个示例展示了如何使用for 循环、while 循环和一些循环函数访问索引及其对应的数组元素。请注意，默认情况下数组索引始终从零开始（请参阅example 4以更改此设置）。

1. 使用计数器和`+=`运算符循环元素。

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

for value in items:
    print(counter, value)
    counter += 1

Result:

#    0 8
#    1 23
#    2 45
#    3 12
#    4 78

`enumerate()`2. 使用内置函数迭代元素。

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

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

Result:

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

3.分别获取列表的元素及其索引。

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

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

Result:

#    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

4. 您可以将`index`值更改为任意增量。

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

for i, item in enumerate(items, start=100):
    print(i, item)

Result:

#    100 8
#    101 23
#    102 45
#    103 12
#    104 78

5. 使用方法自动增加计数器`range(len(...))`。

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

for i in range(len(items)):
    print("Index:", i, "Value:", items[i])

Result:

#    ('Index:', 0, 'Value:', 8)
#    ('Index:', 1, 'Value:', 23)
#    ('Index:', 2, 'Value:', 45)
#    ('Index:', 3, 'Value:', 12)
#    ('Index:', 4, 'Value:', 78)

6. 在函数中使用`for`循环。

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

def enum(items, start=0):
    counter = start

    for value in items:
        print(counter, value)
        counter += 1
    
enum(items)

Result:

#    0 8
#    1 23
#    2 45
#    3 12
#    4 78

7.当然，我们不能忘记`while`循环。

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

while counter < len(items):
    print(counter, items[counter])
    counter += 1

Result:

#    0 8
#    1 23
#    2 45
#    3 12
#    4 78

8.`yield`语句返回一个生成器对象。

def createGenerator():        
    items = [8, 23, 45, 12, 78]

    for (j, k) in enumerate(items):
        yield (j, k)
        

generator = createGenerator()

for i in generator:
    print(i)

Result:

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

`for`9. 带循环和的内联表达式`lambda`。

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

xerox = lambda upperBound: [(i, items[i]) for i in range(0, upperBound)]
print(xerox(5))

Result:

#    [(0, 8), (1, 23), (2, 45), (3, 12), (4, 78)]

10. 使用 Python 的函数一次迭代两个列表`zip()`。

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

for index in range(len(items)):
    indices.append(index)

for item, index in zip(items, indices):
    print("{}: {}".format(index, item))

Result:

#    0: 8
#    1: 23
#    2: 45
#    3: 12
#    4: 78

`while`11. 使用循环和`iter()`&方法循环遍历 2 个列表`next()`。

items = [8, 23, 45, 12, 78]
indices = range(len(items))

iterator1 = iter(indices)
iterator2 = iter(items)
  
try:
    while True:
        i = next(iterator1)
        element = next(iterator2)
        print(i, element)
except StopIteration:
    pass

12. 另外，在类内部迭代列表的元素也是很好的`Static Method`。

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

class ElementPlus:
    @staticmethod                            # decorator
    def indexForEachOfMy(iterable):
        for pair in enumerate(iterable):
            print pair

ElementPlus.indexForEachOfMy(items)

Result:

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

解决方案 5：

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

解决方案 6：

与 Python 中的常态一样，有几种方法可以实现这一点。在所有示例中，假设：lst = [1, 2, 3, 4, 5]

使用枚举（被认为是最惯用的）

for index, element in enumerate(lst):
    # Do the things that need doing here

在我看来这也是最安全的选择，因为进入无限递归的可能性已被消除。项目及其索引都保存在变量中，无需编写任何其他代码来访问该项目。

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

for index in range(len(lst)):   # or xrange
    # you will have to write extra code to get the element

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

index = 0
while index < len(lst):
    # You will have to write extra code to get the element
    index += 1  # escape infinite recursion

总会有其他方法

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

解决方案 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当需要索引时，使用方法是最快的迭代方法。

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

Python 2.X 中的 range 和 xrange 函数有什么区别？
在 Python 中，使用枚举的循环和使用 xrange 的循环哪个更快？
范围（len（列表））还是枚举（列表）？

解决方案 8：

老式方法：

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

解决方案 9：

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

这是一个简单的方法：

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

解决方案 10：

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

for x in range(0, 5):

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

要获取索引的值，请使用

list[index]

解决方案 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：

根据这个讨论：对象的列表索引

循环计数器迭代

当前循环索引的习惯用法利用了内置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

通过PEP 212 – 循环计数器迭代。

解决方案 13：

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

但是，列表的索引从零开始。因此，我们需要知道您真正想要的是列表中每个项目的索引和项目，还是真正想要从 1 开始的数字。幸运的是，在 Python 中，很容易实现其中一种或两种。

首先，需要澄清的是，该enumerate函数迭代地返回列表中每个项目的索引和对应的项目。

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

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

上述输出为，

请注意，索引从 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=nswitch for enumerate()。这只是偏移索引，您可以等效地在循环内简单地将一个数字添加到索引。

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

输出为

解决方案 14：

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

解决方案 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']

解决方案 16：

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

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

解决方案 17：

在 for 循环中运行计数器的另一种方法是使用itertools.count。

from itertools import count

my_list = ['a', 'b', 'a']
for i, item in zip(count(), my_list):
    print(i, item)

如果您希望计数器为小数，这尤其有用。在下面的例子中，“索引”从 1.0 开始，每次迭代增加 0.5。

my_list = ['a', 'b', 'a']

for i, item in zip(count(start=1., step=0.5), my_list):
    print(f"loc={i}, item={item}")
    
# loc=1.0, item=a
# loc=1.5, item=b
# loc=2.0, item=a

另一种方法是在循环内使用list.index()。但是，与本页上提到此方法的其他答案（1、2、3）不同，必须将索引搜索的起点（即第二个参数）传递给该list.index()方法。这可以让你实现两件事：（1）不会再从头开始循环列表；（2）可以找到所有值的索引，甚至重复值。

my_list = ['a', 'b', 'a']
idx = -1
for item in my_list:
    idx = my_list.index(item, idx+1)
    #                         ^^^^^   <---- start the search from the next index
    print(f"index={idx}, item={item}")
    
# index=0, item=a
# index=1, item=b
# index=2, item=a

就性能而言，如果您想要所有/大多数索引，enumerate()这是最快的选择。如果您只寻找特定索引，那么list.index()可能会更list.index()有效。以下是两个更有效的示例。

示例 1：特定值的索引

假设您想要查找列表中出现特定值（例如最高值）的所有索引。例如，在以下情况下，我们想要查找出现 2 的所有索引。这是使用的一行代码enumerate()。但是，我们也可以在 while 循环中使用方法来搜索 2 的索引list.index()；如前所述，在每次迭代中，我们从上一次迭代中断的位置开始索引搜索。

lst = [0, 2, 1, 2]
target = 2

result = []
pos = -1
while True:
    try:
        pos = lst.index(target, pos+1)
        result.append(pos)
    except ValueError:
        break
        
print(result)      # [1, 3]

事实上，在某些情况下，它比enumerate()产生相同输出的选项要快得多，特别是当列表很长时。

示例 2：小于目标的第一个数字的索引

另一个经常需要在循环中使用索引的常见练习是查找列表中满足某些条件（例如大于/小于某个目标值）的第一个项目的索引。在下面的例子中，我们想要查找第一个超过 2.5 的值的索引。这是一个一行代码的使用enumerate()，但使用list.index()效率更高，因为获取不会使用的索引是enumerate()有成本的（list.index()不会产生）。

my_list = [1, 2, 3, 4]
target = 2.5

for item in my_list:
    if item > target:
        idx = my_list.index(item)
        break

或者一行代码：

idx = next(my_list.index(item) for item in my_list if item > target)

用于生成运行速度比图的代码：

import random
import matplotlib.pyplot as plt
import perfplot


def enumerate_1(lst, target=3):
    return [i for i, v in enumerate(lst) if v == target]


def list_index_1(lst, target=3):
    result = []
    pos = -1
    while True:
        try:
            pos = lst.index(target, pos+1)
            result.append(pos)
        except ValueError:
            break
    return result


def list_index_2(lst, target):
    for item in lst:
        if item > target:
            return lst.index(item)


def enumerate_2(lst, target):
    return next(i for i, item in enumerate(lst) if item > target)


setups = [lambda n: [random.randint(1, 10) for _ in range(n)], 
          lambda n: (list(range(n)), n-1.5)]
kernels_list = [[enumerate_1, list_index_1], [enumerate_2, list_index_2]]
titles = ['Get indices of a value', 'Get index that satisfies a condition']
n_range = [2**k for k in range(1,21)]
labels = ['enumerate', 'list.index']
xlabel = 'list length'

fig, axs = plt.subplots(1, 2, figsize=(10, 5), facecolor='white', dpi=60)
for i, (ax, su, ks, t) in enumerate(zip(axs, setups, kernels_list, titles)):
    plt.sca(ax)
    perfplot.plot(ks, n_range, su, None, labels, xlabel, t, relative_to=1)
    ax.xaxis.set_tick_params(labelsize=13)
plt.setp(axs, ylim=(0.7, 2.4), yticks=[i*0.25 + 0.75 for i in range(7)], 
         xlim=(1, 1100000), xscale='log', xticks=[1, 100, 10000, 1000000])
fig.tight_layout();

解决方案 18：

使用while循环的简单答案：

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

输出：

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

解决方案 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它使用了该问题所选答案中的方法，但结合列表理解，从而能够使用更少的代码实现更快的运行速度。

解决方案 20：

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

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

解决方案 21：

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

解决方案 22：

单行爱好者：

[index for index, datum in enumerate(data) if 'a' in datum]

解释：

>>> data = ['a','ab','bb','ba','alskdhkjl','hkjferht','lal']
>>> data
['a', 'ab', 'bb', 'ba', 'alskdhkjl', 'hkjferht', 'lal']
>>> [index for index, datum in enumerate(data) if 'a' in datum]
[0, 1, 3, 4, 6]
>>> [index for index, datum in enumerate(data) if 'b' in datum]
[1, 2, 3]
>>>

注意事项：

Pythonlist不提供索引；如果你使用for
如果你enumerate它将list返回你另一个list
- 但该列表将有不同的类型
- 它将用索引包装每个元素，如下所示tuple
- 我们可以将元组作为变量访问，用逗号分隔（,）

谢谢。请为我祈祷。

解决方案 23：

除了上述所有出色的答案之外，这里还有一个使用 pandas Series 对象时解决此问题的方法。在许多情况下，pandas Series 具有无法通过函数访问的自定义/唯一索引（例如，唯一标识符字符串）enumerate()。

xs = pd.Series([8, 23, 45])

xs.index = ['G923002', 'G923004', 'G923005']

print(xs)

输出：

#    G923002     8
#    G923004    23
#    G923005    45
#    dtype: int64

我们可以从下面看到，这enumerate()并没有给我们想要的结果：

for id, x in enumerate(xs):
    print("id #{} = {}".format(id, x))

输出：

#    id #0 = 8
#    id #1 = 23
#    id #2 = 45

我们可以使用以下方法在 for 循环中访问 pandas 系列的索引.items()：

for id, x in xs.items():
    print("id #{} = {}".format(id, x))

输出：

#    id #G923002 = 8
#    id #G923004 = 23
#    id #G923005 = 45

解决方案 24：

您可以使用range(len(some_list))然后像这样查找索引

xs = [8, 23, 45]
for i in range(len(xs)):
    print("item #{} = {}".format(i + 1, xs[i]))

或者使用 Python 的内置enumerate函数，该函数允许您循环遍历列表并检索列表中每个项目的索引和值

xs = [8, 23, 45]
for idx, val in enumerate(xs, start=1):
    print("item #{} = {}".format(idx, val))

解决方案 25：

可以通过如下代码实现：

xs = [8, 23, 45]
for x, n in zip(xs, range(1, len(xs)+1)):
    print("item #{} = {}".format(n, x))

这里，range(1, len(xs)+1);如果你希望输出从 1 开始而不是从 0 开始，则需要从 1 开始范围，并将 1 加到估算的总长度，因为 python 默认从 0 开始索引数字。

Final Output:
item #1 = 8
item #2 = 23
item #3 = 45

解决方案 26：

一个循环，其中的“计数器”变量设置为初始化器，在格式化字符串时，它将作为一个参数，作为项目编号。

for循环访问“listos”变量，即列表。当我们通过“i”访问列表时，“i”被格式化为商品价格（或其他任何价格）。

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

输出：

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

解决方案 27：

这已经足够达到目的了：

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