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

Question

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

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

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

Answer 1

使用其他状态变量(例如索引变量(通常在C或PHP等语言中使用))被认为是非pythonic.

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

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函数通过隐藏索引的会计,并将迭代封装到另一个迭代(一个enumerate对象)中来减少视觉混乱,该迭代产生索引的两项元组和原始迭代将提供的项.看起来像这样:

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

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

总有另一种方式

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

Answer 6

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

这是一个简单的方法：

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

Answer 7

老式的方式:

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 8

在Python 2.7中访问循环中列表索引的最快方法是使用范围方法用于小型列表,并枚举方法用于中型和大型列表.

请参阅不同的方法可用于遍历列表和访问索引值和它们的性能指标(我想是对您有用)下面的代码样本:

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个项目.对于大小> 10 000项的列表enumerate是赢家.

添加以下一些有用的链接:

• Python 2.X中range和xrange函数有什么区别？

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

• range(len(list))或enumerate(list)？

Answer 9

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

for x in range(0, 5):

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

获取索引使用的值

list[index]

Answer 10

根据这个讨论:http://bytes.com/topic/python/answers/464012-objects-list-index

循环计数器迭代

循环索引的当前习惯使用内置的"范围"函数:

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

循环使用元素和索引可以通过旧的习语或使用新的"zip"内置函数[2]来实现:

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

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

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 12

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

Answer 13

这个问题的最佳解决方案是使用枚举内置的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 14

您可以使用以下index方法：

\n

ints = [8, 23, 45, 12, 78]\ninds = [ints.index(i) for i in ints]\n

\n

注释中强调指出，如果ints. 下面的方法应该适用于 中的任何值ints：

\n

ints = [8, 8, 8, 23, 45, 12, 78]\ninds = [tup[0] for tup in enumerate(ints)]\n

\n

或者也可以

\n

ints = [8, 8, 8, 23, 45, 12, 78]\ninds = [tup for tup in enumerate(ints)]\n

\n

ints如果您想以元组列表的形式获取索引和值。

\n

enumerate它在该问题的选定答案中使用 的方法，但具有列表理解，从而以更少的代码实现更快的速度。

\n

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

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

Answer 17

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

如果列表中没有重复值:

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

否则使用__CODE__.

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

或使用以下:

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

Answer 19

这是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 20

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

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

Answer 21

在 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()。list.index()然而，我们也可以在 while 循环中使用该方法来搜索 2 的索引；如前所述，在每次迭代中，我们从上一次迭代中停止的位置开始索引搜索。

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()效率更高，因为获取不会像 in 那样使用的索引会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();

Answer 22

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

但是，列表的索引从零开始。因此，那么我们需要知道您真正想要的是列表中每个项目的索引和项目，还是您真正想要的是从1开始的数字。幸运的是，在Python中，轻松执行这两个操作或两者都很容易。

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

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

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

上面的输出是

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 1
1 2
2 3
3 4
4 5

这给我们带来了start=n的开关enumerate()。这只是使索引偏移，您可以等效地在循环内向索引简单地添加一个数字。

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

其输出是

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