关于python：在”for”循环中访问索引？


Accessing the index in 'for' loops?

对于如下列表，如何访问索引本身？

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

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

相关讨论

使用一个额外的可变状态，这样一个可变指数(这一点，你将在这样一个languages normally使用C或php)，也被视为非pythonic。 P / < >

更好的选项是使用"建在enumerate()可用两种功能，在Python的2和3： P / < >

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

看看PEP 279更多。 P / < >

相关讨论

Using a for loop, how do I access the loop index, from 1 to 5 in this case?

使用enumerate得到的指数与iterate：当你走了 P / < >

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

和音符，Python的indexes开始在零，所以你会得到0到4与以上。如果你想算，1至5，这样做： P / < >

1
2
for count, item in enumerate(items, start=1):
    print(count, item)

unidiomatic流量控制

什么是你的要求，为的pythonic konizit之以下，这就是"现在"的算法programmers较低层次的languages会使用： P / < >

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

或在languages，做的不是我在对每一个环： P / < >

1
2
3
4
index = 0
while index < len(items):
    print(index, items[index])
    index += 1

或有时更多的commonly(但unidiomatically)发现在Python的： P / < >

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

使用"enumerate功能

Python的enumerate功能reduces的视觉杂波通过隐藏的会计为indexes，和encapsulating的iterable到另一个iterable(一个enumerate对象)，yields两tuple item的指数和item，原有的iterable会提供。那看起来像这样： P / < >

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

这个代码的样本是公平的好的例子中，都canonical之间的代码，idiomatic的Python代码，和女人。idiomatic代码也sophisticated(但不是一个复杂的Python)的，在笔试的方式，它被用于去用。idiomatic代码也expected由designers英语语言，这意味着，usually这个代码也不只是readable更多，但也更高效。 P / < > 得到的计数

即使如果你不需要indexes当你走了，但你需要的count"的iterations(有时desirable)，你就可以开始与1和最终数将是你的计数。 P / < >

1
2
3
4
for count, item in enumerate(items, start=1):   # default is zero
    print(item)

print('there were {0} items printed'.format(count))

"count似乎更多的是什么，你问到intend(AS opposed到指数)，当你说你会不会从1到5。 P / < > 打破它下来在一步一步的解释

要打破这些examples下来，说我们有一个列表的项目，我们想iterate结束与一个指数： P / < >

1
items = ['a', 'b', 'c', 'd', 'e']

现在我们通过这iterable到enumerate，creating an enumerate对象： P / < >

1
enumerate_object = enumerate(items) # the enumerate object

我们可以拉出来的，这个项目的第一iterable，我们会得到在环与next功能： P / < >

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

我们看到的和我们得到的tuple of 0，第一指数，和'a'，第一是正确的： P / < >

1
(0, 'a')

我们可以用什么可以称为"序列unpacking提取物"到"元素从这两个tuple： P / < >

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

当我们inspect index，我们发现它指的是第一指数，0，和item指的是文档的第一个项目，'a'。 P / < >

1
2
3
4
>>> print(index)
0
>>> print(item)
a

结论

  • Python的indexes开始在零
  • 得到这些indexes从一个iterable你iterate过来的，使用的enumerate功能
  • 用enumerate在idiomatic方式(沿与tuple unpacking)creates code，更多的readable和maintainable：

所以这样做： P / < >

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

这是很简单的开始它从1超过0： P / < >

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

音符

重要的提示，虽然小misleading由于index将在tuple(idx, item)睾丸。 好去。 P / < >

相关讨论

1
2
for i in range(len(ints)):
   print i, ints[i]
相关讨论

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

1。使用枚举(被认为是最惯用的)

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

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

2。创建保存索引的变量(使用for)

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

三。创建保存索引的变量(使用while)

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

相关讨论

老式的方式： P / < >

1
2
for ix in range(len(ints)):
    print ints[ix]

comprehension列表： P / < >

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
[ (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)
>>>
相关讨论

我不知道如果英镑也pythonic或不，但它的功能和用途的Python enumerate打印的指数和价值。 P / < >

1
2
3
int_list = [8, 23, 45, 12, 78]
for index, value in enumerate(int_list):
   print(index, value)

输出： P / < >

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

在python 2.7中，在循环中访问列表索引的最快方法是对小列表使用range方法，对大中型列表使用enumerate方法。

请在下面的代码示例中查看可用于遍历列表和访问索引值及其性能指标(我认为这对您很有用)的不同方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
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

请参见下面每个方法的性能指标：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
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个项目的最快方法。对于尺寸大于10000个项目的列表，1(2)是获胜者。

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

  • 在python 2.x中，range和x range函数有什么区别？

  • 在python中，使用enumerate的循环或使用xrange的循环更快些？

  • 范围(len(list))还是枚举(list)？

相关讨论

1
2
3
4
ints = [9, 23, 45, 12, 78]
ints.extend([1,2,3,4,5,6,7,8])
for idx, val in enumerate(ints):
    print(idx,val)

这样就可以扩展列表。扩展意味着您可以一次添加多个值。

要附加此列表，您必须编写下面给出的代码：

1
2
3
4
ints = [9, 23, 45, 12, 78]
ints.append([1])
for idx, val in enumerate(ints):
    print(idx,val)

这样，您可以一次添加一个值。如果编写ints.append([1])，这将为此元素创建一个子列表。

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

1
for x in range(0, 5):

请记住，我写的是0到5，因为循环会在最大值之前停止一个数字：()

要获取索引值，请使用

1
list[index]

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

1
2
3
4
5
6
ints = [8, 23, 45, 12, 78]
index = 0

for value in (ints):
    index +=1
    print index, value

如果需要在循环结束时重置索引值，请使用此代码：

1
2
3
4
5
6
7
8
ints = [8, 23, 45, 12, 78]
index = 0

for value in (ints):
    index +=1
    print index, value
    if index >= len(ints)-1:
        index = 0

根据这discussion：/ / / / / bytes.com topic Python的回答/ 464012 -物体的列表中指数 P / < >

反iteration环 P / < >

"当前idiom为looping结束的indices使用英语，建在"范围"功能： P / < >

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

looping在两种元素和indices可以，无论是由旧的idiom或通过使用纽约"拉链"建在功能(2)： P / < >

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

或 P / < >

1
2
for i, e in zip(range(len(sequence)), sequence):
    # work with index i and element e

通过HTTP：/ / / / / www.python.org开发peps PEP / 0212 P / < >

相关讨论

这个问题的最佳解决方案是在build python函数中使用enumerate。枚举返回元组第一个值是索引第二个值是该索引处数组的元素

1
2
3
4
5
6
7
8
9
10
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)

如果列表中没有重复值：

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

否则使用enumerate。

1
2
for counter, value in enumerate(ints):
    print(counter, value)

或以下使用：

1
2
for counter in range(len(ints)):
    print(counter, ints[counter])
相关讨论

以下是访问for循环中的索引时得到的结果：

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

enter image description here

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

enter image description here

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

enter image description here

希望这有帮助。

您也可以尝试以下操作：

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

输出是

1
2
3
4
0 ['itemA', 'ABC']
1 ['itemB', 'defg']
2 ['itemC', 'drug']
3 ['itemD', 'ashok']

如果我要迭代nums=[1,2,3,4,5]我愿意

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

或者将长度取为l=len(nums)

1
2
for i in range(1, l + 1):
    print(i, nums[i])
相关讨论

在您的问题中，您会写"在本例中，如何访问从1到5的循环索引？"

但是，列表的索引从零开始运行。所以，我们需要知道您真正想要的是列表中每个项目的索引和项目，还是您真正想要从1开始的数字。幸运的是，在Python中，这两者都很容易做到。

首先，为了澄清，枚举函数迭代地返回列表中每个项的索引和对应项。

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

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

上述输出为，

1
2
3
4
5
0 1
1 2
2 3
3 4
4 5

请注意，索引从0开始运行。这种索引在现代编程语言(包括python和c)中很常见。

如果希望循环跨越列表的一部分，可以对列表的一部分使用标准的python语法。例如，要从列表中的第二个项循环到但不包括最后一个项，可以使用

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

请注意，输出索引再次从0开始运行，

1
2
3
0 2
1 3
2 4

这使我们进入了开始=n开关枚举()。这只需偏移索引，就可以在循环中简单地向索引添加一个数字。

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

其输出为

1
2
3
4
5
1 1
2 2
3 3
4 4
5 5

您可以使用index方法

1
2
ints = [8, 23, 45, 12, 78]
inds = [ints.index(i) for i in ints]

编辑在注释中强调，如果ints中存在重复项，则此方法不起作用，下面的方法应适用于ints中的任何值：

1
2
ints = [8, 8, 8, 23, 45, 12, 78]
inds = [tup[0] for tup in enumerate(ints)]

或者

1
2
ints = [8, 8, 8, 23, 45, 12, 78]
inds = [tup for tup in enumerate(ints)]

如果您想同时获得ints中的索引和值作为元组列表。

它在这个问题的选定答案中使用了enumerate的方法，但是有了列表理解，用更少的代码使它更快。

相关讨论

使用for循环打印列表理解中(索引、值)的元组：

1
2
ints = [8, 23, 45, 12, 78]
print [(i,ints[i]) for i in range(len(ints))]

输出：

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

也可以使用index()方法

1
2
for i in ints:
   print(ints.index(i), i)

在这里，索引从0开始。但如果您需要从1开始，只需将1添加到index()方法中，如下所示

1
2
for i in int:
   print(int.index(i) + 1, i)
相关讨论

您已经收到了许多解释enumerate的答案，但是如果您只需要索引来访问两个列表中的匹配条目，那么在python 3中还有另一种更简单更干净的方法：zip。

例如，如果使用索引为列表中的数字提取相应的名称，可以这样做：

1
2
3
4
ints = [8, 23, 45, 12, 78]
names = ["John","Sue","Johannes","Patel","Ian"]
for int, name = zip(ints, names):
    print("{} - {}".format(name, int)

会产生

1
2
3
4
5
8 - John
23 - Sue
45 - Johannes
12 - Patel
78 - Ian
相关讨论

这充分发挥了作用：

1
2
3
list1 = [10, 'sumit', 43.21, 'kumar', '43', 'test', 3]
for x in list1:
    print('index:', list1.index(x), 'value:', x)
相关讨论