enumerate() 是什么意思？-IT科技

摘要：问题描述：for row_number, row in enumerate(cursor):在 Python 中做什么？在这种情况下是什么enumerate意思？解决方案 1：该enumerate()函数向可迭代对象添加一个计数器。因此，对于中的每个元素cursor，都会用生成一个元组(counter, ...

问题描述：

for row_number, row in enumerate(cursor):在 Python 中做什么？

在这种情况下是什么enumerate意思？

解决方案 1：

该enumerate()函数向可迭代对象添加一个计数器。

因此，对于中的每个元素cursor，都会用生成一个元组(counter, element)；for循环分别将其绑定到row_number和row。

演示：

>>> elements = ('foo', 'bar', 'baz')
>>> for elem in elements:
...     print elem
... 
foo
bar
baz
>>> for count, elem in enumerate(elements):
...     print count, elem
... 
0 foo
1 bar
2 baz

默认情况下，enumerate()开始计数，0但如果你给它第二个整数参数，它将从该数字开始：

>>> for count, elem in enumerate(elements, 42):
...     print count, elem
... 
42 foo
43 bar
44 baz

如果你要enumerate()在 Python 中重新实现，这里有两种实现方法；一种用于itertools.count()进行计数，另一种在生成器函数中手动计数：

from itertools import count

def enumerate(it, start=0):
    # return an iterator that adds a counter to each element of it
    return zip(count(start), it)

和

def enumerate(it, start=0):
    count = start
    for elem in it:
        yield (count, elem)
        count += 1

C 中的实际实现更接近后者，通过优化对常见的for i, ...解包情况重用单个元组对象，并使用标准 C 整数值作为计数器，直到计数器变得太大而无法避免使用 Python 整数对象（无界）。

解决方案 2：

它是一个内置函数，返回一个可以迭代的对象。请参阅文档。

简而言之，它循环遍历可迭代对象（如列表）的元素以及索引号，并组合成一个元组：

for item in enumerate(["a", "b", "c"]):
    print item

印刷

(0, "a")
(1, "b")
(2, "c")

如果您想要循环遍历一个序列（或其他可迭代对象），并且还想要一个可用的索引计数器，那么它会很有帮助。如果您希望计数器从其他值（通常为 1）开始，则可以将其作为第二个参数传递给enumerate。

解决方案 3：

我正在读 Brett Slatkin 的一本书 ( Effective Python )，他展示了另一种遍历列表的方法，并且还知道列表中当前项目的索引，但他建议最好不要使用它，而是使用enumerate。我知道你问过枚举是什么意思，但是当我理解了下面的内容后，我也明白了如何enumerate在知道当前项目的索引的情况下更容易（也更易读）地遍历列表。

list_of_letters = ['a', 'b', 'c']
for i in range(len(list_of_letters)):
    letter = list_of_letters[i]
    print (i, letter)

输出为：

0 a
1 b
2 c

在我了解这个功能之前，我也曾经做过一些更愚蠢的事情enumerate。

i = 0
for n in list_of_letters:
    print (i, n)
    i += 1

它产生相同的输出。

但enumerate我只需要写：

list_of_letters = ['a', 'b', 'c']
for i, letter in enumerate(list_of_letters):
    print (i, letter)

解决方案 4：

正如其他用户提到的，enumerate是一个在可迭代的每个项目旁边添加增量索引的生成器。

因此，如果您有一个列表l = ["test_1", "test_2", "test_3"]，则list(enumerate(l))会给您类似这样的内容：[(0, 'test_1'), (1, 'test_2'), (2, 'test_3')]。

那么，什么时候这有用呢？一个可能的用例是当您想要迭代项目时，您想要跳过一个特定的项目，您只知道它在列表中的索引，但不知道它的值（因为当时不知道它的值）。

for index, value in enumerate(joint_values):
   if index == 3:
       continue

   # Do something with the other `value`

因此，您的代码读起来更好，因为您也可以使用常规的 for 循环range，然后访问需要对它们进行索引的项目（即joint_values[i]）。

enumerate尽管另一个用户提到了使用的实现zip，但我认为不使用的更纯粹（但稍微复杂）的方式itertools如下：

def enumerate(l, start=0):
    return zip(range(start, len(l) + start), l)

例子：

l = ["test_1", "test_2", "test_3"]
enumerate(l)
enumerate(l, 10)

输出：

[(0，'测试_1'), (1，'测试_2'), (2，'测试_3')]
[(10，'测试_1')，(11，'测试_2')，(12，'测试_3')]

正如评论中所提到的，这种范围方法不能像原始enumerate函数那样对任意可迭代对象起作用。

解决方案 5：

枚举函数的工作原理如下：

doc = """I like movie. But I don't like the cast. The story is very nice"""
doc1 = doc.split('.')
for i in enumerate(doc1):
     print(i)

输出为

(0, 'I like movie')
(1, " But I don't like the cast")
(2, ' The story is very nice')

解决方案 6：

我假设您知道如何迭代某些列表中的元素：

for el in my_list:
    # do something

现在有时你不仅需要迭代元素，还需要每次迭代的索引。一种方法是：

i = 0
for el in my_list:
    # do somethings, and use value of "i" somehow
    i += 1

然而，更好的方法是使用函数“enumerate”。enumerate 的作用是接收一个列表，并返回一个类似列表的对象（可以迭代的可迭代对象），但这个新列表的每个元素本身包含 2 个元素：索引和来自原始输入列表的值：所以如果你有

arr = ['a', 'b', 'c']

然后命令
enumerate(arr)
返回类似这样的内容：

[(0,'a'), (1,'b'), (2,'c')]

现在，如果您遍历一个列表（或可迭代对象），其中每个元素本身都有 2 个子元素，那么您可以在循环中捕获这两个子元素，for如下所示：

for index, value in enumerate(arr):
    print(index,value)

这将打印出枚举输出的子元素。

一般来说，您基本上可以将列表中的多个项目“解包”到多个变量中，如下所示：

idx,value = (2,'c')
print(idx)
print(value)

这将打印

2
c

这是在该循环的每次迭代中发生的可迭代的分配类型enumerate(arr)。

解决方案 7：

枚举函数同时计算元素索引和元素值。我相信下面的代码将有助于解释发生了什么。

for i,item in enumerate(initial_config):
     print(f'index{i} value{item}')

解决方案 8：

枚举函数用于计数迭代次数。它接受两个参数：一个可迭代对象和一个起始索引，如下所示：enumerate(iterable, start=1)

如果未指定起始索引，则默认从 0 开始。它返回可迭代对象中的索引和相应元素。请考虑以下示例：

for i, j in enumerate(range(5)):
    print(i,'=',j)

输出将是：