我如何在下面这样的for
循环中访问索引?
ints = [8, 23, 45, 12, 78]
for i in ints:
print('item #{} = {}'.format(???, i))
我想得到这样的输出。
item #1 = 8
item #2 = 23
item #3 = 45
item #4 = 12
item #5 = 78
当我使用 "for "循环遍历它时,我如何访问循环索引,在本例中从1到5?
使用一个额外的状态变量,如索引变量(你通常会在C或PHP等语言中使用),被视为非pythonic。
更好的选择是使用内置函数 enumerate()
,在 Python 2 和 3 中都可以使用。
for idx, val in enumerate(ints):
print(idx, val)
查看 PEP 279 了解更多。
>.#使用for循环,在这种情况下,如何访问循环索引,从1到5?
使用 "enumerate "来获取元素的索引。
for index, item in enumerate(items):
print(index, item)
并且注意,Python'的索引从0开始,所以用上面的方法会得到0到4。 如果你想得到1到5的计数,可以这样做。
for count, item in enumerate(items, start=1):
print(count, item)
你要求的是下面的Pythonic等价物,这是大多数低级语言的程序员会使用的算法。
index = 0 # Python'的索引从零开始。
for item in items.# Python的for循环是一个"for each"。
Python'的for循环是一个"for each"。
循环,是一个"for each"。
print(index, item) >.index += 1 index += 1
或者在没有for-each循环的语言中。
index = 0
而index < len( items):
print(index, items[index]) >.index += 1 index += 1
或有时在Python中更常见(但单义)。
for index in range(len( items)): >.net; for index in range(len(items)): >.net print(index, items[index])
Python'的[enumerate
函数][1]通过隐藏索引的核算,减少了视觉上的杂乱,并将其封装到另一个可迭代的对象(enumerate
对象)中,产生一个索引和原始可迭代的项目的两个元组。
这看起来像这样。
for index, item in enumerate(items, start=0): # default is zero
print(index, item)
这段代码样本是相当好的 [canonical][2] 的例子,它说明了 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')
我们可以使用所谓的"[序列解包][3]"。 来提取这个二元组中的元素。
index, item = iteration
# 0, 'a' = (0, 'a') # essentially this.
而当我们检查index
时,发现它指的是第一个索引,0,而item
指的是第一个项目,'a'
。
>>> print(index)
0
>>> print(item)
a
所以要这样做。
for index, item in enumerate(items, start=0): # Python indexes start at zero
print(index, item)
[1]: https://docs.python.org/2/library/functions.html#enumerate [2]: http://python.net/~goodger/projects/pycon/2007/idiomatic/handout.html#index-item-2-enumerate。 [3]: https://docs.python.org/2/tutorial/datastructures.html#tuples-and-sequences
在Python中,有几种方法可以做到这一点。
在所有的例子中,假设
lst = [1, 2, 3, 4, 5]
。
for index, element in enumerate(lst):
在我看来,这也是最安全的选择,因为已经消除了进入无限递归的机会。 项和它的索引都保存在变量中,不需要再写任何代码了 来访问该项目。
for
)。for index in range(len(lst)):
while
)。指数=0 而index < len(lst):
index += 1 #逃避无限递归
如前所述,还有其他一些方法没有在此说明,它们甚至可能更适用于其他情况。
例如使用itertools.chain
与for。
它比其他例子更能处理嵌套循环。
老式的方法。
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)
>>>
在Python 2.7中,在循环内访问list的索引最快的方法是对小型list使用[range方法][1],对中型和大型list使用[enumerate方法][2]。
请在下面的代码示例中看到不同的方法,可以用来迭代列表和访问索引值,以及它们的性能指标(我想对你有用)。
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个项目的列表。
对于大小为>.的列表,"enumerate "是赢家。
10,000个项目时,enumerate
是赢家。
下面补充一些有用的链接。
[1]: https://docs.python.org/2/library/functions.html#range [2]: https://docs.python.org/2/library/functions.html#enumerate
根据这个讨论。 http://bytes.com/topic/python/answers/464012-objects-list-index
循环计数器迭代
目前循环处理指数的习惯使用了内置的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
通过http://www.python.org/dev/peps/pep-0212/
解决这个问题的最好办法是使用enumerate内置的python函数。
enumerate返回tuple
。
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)
for i in enumerate( items): print(i)
[![在此输入图像描述][1]][1]
for i, val in enumerate( items): print(i, val)
[![在此输入图像描述][2]][2]
for i, val in enumerate( items): print(i)
[![在此输入图像描述][3]][3]
希望对大家有所帮助。
[1]: https://i.stack.imgur.com/2Vke5.png [2]: https://i.stack.imgur.com/BeRBP.png [3]: https://i.stack.imgur.com/b1gka.png
如果我要迭代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])
你也可以试试这个。
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']
在你的问题中,你写道 *"在这种情况下,我如何访问循环索引,从1到5?
然而,一个列表的索引是从0开始运行的。 所以,我们就需要知道你真正想要的是列表中每个项目的索引和项目,还是你真的想要从1开始的数字。 幸运的是,在Python中,我们可以很容易地做到两者之一。
首先,要说明的是,enumerate
函数迭代地返回列表中每个项的索引和对应的项。
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
您可以使用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
中的索引和值,作为一个tuple的列表。
它使用了本问题选定答案中的 "enumerate "方法,但带有列表理解功能,使其以较少的代码变得更快。