在'for'循环中访问索引？-Java 学习之路

2768

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

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

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

22 回答

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

回复于 2024-04-26T12:03:06+08:00

1
它也可以使用 index() 方法完成
```
for i in ints:
   print(ints.index(i), i)
```
这里的索引从0开始 . 但是如果你需要从1开始，只需在 index() 方法中加1，如下所示
```
for i in int:
   print(int.index(i) + 1, i)
```
回复于 2024-04-26T12:03:06+08:00
17
您可以使用 index 方法
```
ints = [8, 23, 45, 12, 78]
inds = [ints.index(i) for i in ints]
```
EDIT 注释中突出显示如果 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 的方法，但是使用列表理解，使用更少的代码使其更快 .
回复于 2024-04-26T12:03:06+08:00
9
使用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的索引从零开始
对于项目中的项目：#Python的for循环是“for each”循环
打印（索引，项目）
index = 1

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

index = 0
而index <len（items）：
print（索引，项目[索引]）
index = 1

或者有时在Python中更常见（但不常见）：

对于范围内的索引（len（items））：
print（索引，项目[索引]）

使用枚举功能

Python的enumerate function通过隐藏索引的会计来减少视觉混乱，并将迭代封装到另一个迭代（一个 enumerate 对象）中，该迭代产生索引的两项元组和原始迭代将提供的项 . 看起来像这样：
```
for index, item in enumerate(items, start=0):   # default is zero
    print(index, item)
```
这个代码示例相当不错canonical示例代码之间的区别是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')
```
我们可以使用所谓的“sequence unpacking”从这个二元组中提取元素：
```
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)
```
回复于 2024-04-26T12:03:06+08:00
16
根据这个讨论：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/
回复于 2024-04-26T12:03:06+08:00
11
使用附加的状态变量，例如索引变量（通常在C或PHP等语言中使用），被认为是非pythonic .

更好的选择是使用Python 2和3中提供的内置函数enumerate()：
```
for idx, val in enumerate(ints):
    print(idx, val)
```
查看PEP 279了解更多信息 .
回复于 2024-04-26T12:03:06+08:00
15
正如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.创建一个变量来保存索引（使用时）
```
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 with for . 它比其他示例更好地处理嵌套循环 .
回复于 2024-04-26T12:03:06+08:00

在 Python 2.7 中访问循环中列表索引的最快方法是将range method用于小型列表，将enumerate method用于中型和大型列表 .

请参阅下面的代码示例中的 different approaches ，它可用于迭代列表和访问索引值以及 their performance metrics （我认为这对您有用）：

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 是赢家 .

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

回复于 2024-04-26T12:03:06+08:00

for i in range(len(ints)):
   print i, ints[i]

回复于 2024-04-26T12:03:06+08:00

22
这个问题的最佳解决方案是使用 enumerate in-build python函数 .
enumerate 返回 tuple
第一个值是 index
第二个值是该索引处的数组 element
```
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)
```
回复于 2024-04-26T12:03:06+08:00

如果列表中没有重复值：

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

否则使用 enumerate .

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

或使用以下：

for counter in range(len(ints)):
    print(counter, ints[counter])

回复于 2024-04-26T12:03:06+08:00

你也可以试试这个：

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

回复于 2024-04-26T12:03:06+08:00

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

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

回复于 2024-04-26T12:03:06+08:00

9
如果我要迭代nums = [1,2,3,4,5]我会这样做
```
for i, num in enumerate(nums, start = 1):
    print(i, num)
```
或者得到长度为l = len（nums）
```
for i, num in range(1, l + 1):
    print(i, nums[i])
```
回复于 2024-04-26T12:03:06+08:00
574
在你的问题，你写"how do I access the loop index, from 1 to 5 in this case?"

但是，列表的索引从零开始 . 那么，我们需要知道你真正想要的是列表中每个项目的索引和项目，或者你是否真的想要从1开始的数字 . 幸运的是，在python中很容易做到其中一个或两个 .

首先，为了澄清，枚举函数迭代地返回列表中每个项的索引和对应项 .
```
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
```
这将我们带到enumerate（）的start = n开关 . 这只是简单地抵消索引，你可以等效地简单地在循环内的索引中添加一个数字 .
```
for n,a in enumerate(alist,start=1):
    print( "%d %d"%(n,a) )
```
输出为
```
1 1
2 2
3 3
4 4
5 5
```
回复于 2024-04-26T12:03:06+08:00
108
您收到了许多解释 enumerate 的答案，但是如果您只需要索引来访问两个列表中的匹配条目，那么Python 3中的's another way that'更简洁，更简单： zip .

例如，如果您使用索引为列表中的数字提取相应的名称，则可以这样做：
```
ints = [8, 23, 45, 12, 78]
names = ["John", "Sue", "Johannes", "Patel", "Ian"]
for int, name = zip(ints, names):
    print("{} - {}".format(name, int)
```
这会产生
```
8 - John
23 - Sue
45 - Johannes
12 - Patel
78 - Ian
```
回复于 2024-04-26T12:03:06+08:00

4804

老式的方式：

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

回复于 2024-04-26T12:03:06+08:00

8
从 1 开始它非常简单，而不是 0 ：
```
for index, item in enumerate(iterable, start=1):
   print index, item
```
注意

重要提示，虽然 index 之后有点误导，但这里会是 tuple (idx, item) . 很高兴去 .
回复于 2024-04-26T12:03:06+08:00
-1
我不知道以下是否是pythonic，但它使用Python函数 enumerate 并打印索引和值 .
```
int_list = [8, 23, 45, 12, 78]
for index, value in enumerate(int_list):
   print(index, value)
```
输出：
```
0 8
1 23
2 45
3 12
4 78
```
回复于 2024-04-26T12:03:06+08:00

这很好地达到了目的：

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

回复于 2024-04-26T12:03:06+08:00

-1
```
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)
```
这样您就可以扩展列表 . 扩展意味着您可以一次添加多个值 .

要附加此列表，您必须编写下面给出的代码：
```
ints = [9, 23, 45, 12, 78]
ints.append([1])
for idx, val in enumerate(ints):
    print(idx,val)
```
这样，您可以一次添加一个值 . 如果你写 ints.append([1]) 所以这将为这个元素创建一个子列表 .
回复于 2024-04-26T12:03:06+08:00
-1
首先，索引将从0到4.编程语言从0开始计数;不要忘记，否则你会遇到索引超出范围的异常 . for循环中所需要的只是一个从0到4的变量，如下所示：
```
for x in range(0, 5):
```
请记住，我写了0到5，因为循环在最大值之前停止了一个数字 . :)

获取索引使用的值
```
list[index]
```
回复于 2024-04-26T12:03:06+08:00

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

22 回答

Unidiomatic控制流程

使用枚举功能

得到一个数

打破它 - 一步一步解释

结论

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

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

3.创建一个变量来保存索引（使用时）

4.总有另一种方式

注意

相关问题