热门标签:
Q:

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

如何在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?

原网址
A:

使用额外的状态变量,例如索引变量(通常在C或PHP等语言中使用)被认为是非pythonic的。

更好的选择是使用内置函数enumerate(),在Python2和3中都可用:

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

查看PEP279了解更多。

所有回答

共 21 条

author avatar

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

或者有时更常见(但unidiomatically)在Python中找到:

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

使用枚举函数

Python的enumerate函数通过隐藏索引的会计来减少视觉混乱,并将iterable封装到另一个iterable(一个enumerate对象)中,该对象生成索引的两项元组和原始iterable将提供的项。 看起来像这样:

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

现在我们将这个iterable传递给enumerate,创建一个enumerate对象:

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索引从零开始
  • 若要在迭代时从可迭代对象获取这些索引,请使用enumerate函数
  • 以惯用的方式使用枚举(以及元组解包)创建更具可读性和可维护性的代码:

所以这样做:

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

0以外的0开始非常简单:

for index, item in enumerate(iterable, start=1):
   print index, item  # Used to print in python<3.x
   print(index, item) # Mirate print() after 3.x+
   
author avatar
for i in range(len(ints)):
   print(i, ints[i]) # print updated to print() in Python 3.x+ 
author avatar

正如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

4. 总有另一种方式

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

author avatar

老式的方式:

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

访问索引和方法的性能基准

Python3.7中,访问list within loop索引的最快方法是对小型,中型和大型列表使用枚举方法

请参阅下面的代码示例中的不同的方法,这些方法可用于迭代列表和访问索引值以及它们的性能指标(我认为这对您有用):

# 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方法是迭代最快的方法。

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

author avatar

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

这是一个简单的方法:

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

当你在for循环中访问索引时,你会得到这样的结果:

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

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

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

结果:

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

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

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

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

结果:

# 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

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

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

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

结果:

# index 0
# index 1
# index 2
# index 3
# index 4
author avatar

首先,索引将从0到4。 编程语言从0开始计数;不要忘记这一点,否则你会遇到一个索引越界异常。 所有你需要在for循环是一个变量计数从0到4这样:

for x in range(0, 5):

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

要获取索引的值,请使用

list[index]
author avatar

你可以用这个代码来做:

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
author avatar

根据这个讨论: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/

author avatar

在你的问题中,你写"如何访问循环索引,在这种情况下从1到5?"

但是,列表的索引从零开始运行。 所以,那么我们需要知道你真正想要的是列表中每个项目的索引和项目,或者你是否真的想要从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

这将我们带到start=n开关为enumerate()。 这简单地抵消了索引,你可以等价地简单地在循环内的索引中添加一个数字。

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

对于其输出是

1 1
2 2
3 3
4 4
5 5
author avatar

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

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

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

你也可以试试这个:

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

使用While循环的简单答案:

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

输出:

<img alt="在这里输入图像描述"src="https://i.stack.imgur.com/Ucu0o.png缧/>

author avatar

可以使用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的方法,但具有列表理解,使其更快,代码更少。

author avatar

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

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

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

在格式化字符串时,将一个"计数器"变量设置为一个参数的初始值 ,作为项目编号。 for循环访问列表中的"listos"变量。 当我们通过"i"访问列表时,"i"被格式化为项目价格{或它是什么}。

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


output:
Item #1 = 8
Item #2 = 23
Item #3 = 45
Item #4 = 12
Item #5 = 78
author avatar

这是很好的服务:

list2 = [11, 'sumit', 43.21, 'sharma', '44', 'test', 2]
for x in list1:
    print( 'index: ', list2.index(x), 'value:', x )

相似问题