只有在基础类型提供了执行此操作的机制(例如 fp.seek(0))的情况下。

没有。Python 的迭代器协议非常简单，只提供一个方法(.next()或 __next__()) ，通常不提供重置迭代器的方法。

通常的模式是再次使用相同的过程创建一个新的迭代器。

如果您想“保存”迭代器，以便可以回到它的开始，您也可以使用 itertools.tee分叉迭代器

如果你有一个名为“ blah.csv”的 csv 文件

a,b,c,d
1,2,3,4
2,3,4,5
3,4,5,6

您知道可以打开文件进行读取，并使用

blah = open('blah.csv', 'r')
reader= csv.DictReader(blah)

然后，您将能够使用 reader.next()获得下一行，它应该输出

{'a':1,'b':2,'c':3,'d':4}

再次使用会产生

{'a':2,'b':3,'c':4,'d':5}

但是，在这一点上，如果你使用 blah.seek(0)，下次你调用 reader.next()你会得到什么

{'a':1,'b':2,'c':3,'d':4}

再来一次。

这似乎就是您要寻找的功能。然而，我确信与这种方法相关的一些技巧是我没有意识到的。@ Brian 建议简单地创建另一个 DictReader。如果您的第一个读取器已经读取了文件的一半，那么这种方法将不起作用，因为您的新读取器将拥有来自文件中任何位置的意想不到的键和值。

虽然没有迭代器重置，但是 python 2.6(以及更高版本)中的“ itertools”模块提供了一些实用工具，可以在这方面提供帮助。 其中之一是“ tee”，它可以创建迭代器的多个副本，并缓存前面运行的副本的结果，以便在副本上使用这些结果。我会实现你的目的:

>>> def printiter(n):
...   for i in xrange(n):
...     print "iterating value %d" % i
...     yield i


>>> from itertools import tee
>>> a, b = tee(printiter(5), 2)
>>> list(a)
iterating value 0
iterating value 1
iterating value 2
iterating value 3
iterating value 4
[0, 1, 2, 3, 4]
>>> list(b)
[0, 1, 2, 3, 4]

我看到许多答案暗示 Itertools.tee，但这忽略了文档中关于 Itertools.tee的一个重要警告:

这个迭代工具可能需要 辅助储存(视乎如何储存) 许多临时数据需要 一般来说，如果一个迭代器 之前使用大部分或全部数据 另一个迭代器启动，它会更快 使用 list()而不是 tee()。

基本上，tee是为这样的情况设计的: 一个迭代器的两个(或多个)克隆，虽然彼此“不同步”，但不同步 差很多——相反，他们说在相同的“附近”(一些项目在彼此之后或之前)。不适合 OP 的“从头重做”问题。

另一方面，L = list(DictReader(...))是完全适合的，只要字母表能够舒适地放在记忆中。一个新的“从开始迭代器”(非常轻量级和低开销)可以在任何时候与 iter(L)一起使用，部分或全部使用而不影响新的或现有的; 其他访问模式也很容易获得。

正如一些答案正确地指出的那样，在特定的 csv情况下，您还可以使用底层文件对象 .seek(0)(一个相当特殊的情况)。我不确定这是否有文档记录和保证，尽管它目前确实有效; 它可能只值得考虑真正巨大的 csv 文件，其中我推荐的 list作为一般方法将有太大的内存占用。

正如上面 Alex Martelli 和 WilDuck 所提倡的那样，使用 .seek(0)存在一个 bug，即下一次对 .next()的调用将以 {key1:key1, key2:key2, ...}的形式提供头行的字典。解决的方法是在 file.seek(0)之后调用 reader.next()来删除标题行。

所以你的代码应该是这样的:

f_in = open('myfile.csv','r')
reader = csv.DictReader(f_in)


for record in reader:
if some_condition:
# reset reader to first row of data on 2nd line of file
f_in.seek(0)
reader.next()
continue
do_something(record)

是 ，如果使用 numpy.nditer构建迭代器。

>>> lst = [1,2,3,4,5]
>>> itr = numpy.nditer([lst])
>>> itr.next()
1
>>> itr.next()
2
>>> itr.finished
False
>>> itr.reset()
>>> itr.next()
1

对于 DictReader:

f = open(filename, "rb")
d = csv.DictReader(f, delimiter=",")


f.seek(0)
d.__init__(f, delimiter=",")

口述记录员:

f = open(filename, "rb+")
d = csv.DictWriter(f, fieldnames=fields, delimiter=",")


f.seek(0)
f.truncate(0)
d.__init__(f, fieldnames=fields, delimiter=",")
d.writeheader()
f.flush()

这可能与最初的问题是正交的，但是可以将迭代器包装在返回迭代器的函数中。

def get_iter():
return iterator

要重置迭代器，只需再次调用该函数。 当函数没有参数时，这当然是微不足道的。

在函数需要一些参数的情况下，使用 funtools.part 创建一个可以代替原始迭代器传递的闭包。

def get_iter(arg1, arg2):
return iterator
from functools import partial
iter_clos = partial(get_iter, a1, a2)

这似乎避免了 tee (n 拷贝)或 list (1拷贝)所需的缓存

list(generator())返回生成器的所有剩余值，如果没有循环，则有效地重置它。

对于小文件，您可以考虑使用 more_itertools.seekable-一个提供重置迭代器的第三方工具。

演示

import csv


import more_itertools as mit




filename = "data/iris.csv"
with open(filename, "r") as f:
reader = csv.DictReader(f)
iterable = mit.seekable(reader)                    # 1
print(next(iterable))                              # 2
print(next(iterable))
print(next(iterable))


print("\nReset iterable\n--------------")
iterable.seek(0)                                   # 3
print(next(iterable))
print(next(iterable))
print(next(iterable))

输出

{'Sepal width': '3.5', 'Petal width': '0.2', 'Petal length': '1.4', 'Sepal length': '5.1', 'Species': 'Iris-setosa'}
{'Sepal width': '3', 'Petal width': '0.2', 'Petal length': '1.4', 'Sepal length': '4.9', 'Species': 'Iris-setosa'}
{'Sepal width': '3.2', 'Petal width': '0.2', 'Petal length': '1.3', 'Sepal length': '4.7', 'Species': 'Iris-setosa'}


Reset iterable
--------------
{'Sepal width': '3.5', 'Petal width': '0.2', 'Petal length': '1.4', 'Sepal length': '5.1', 'Species': 'Iris-setosa'}
{'Sepal width': '3', 'Petal width': '0.2', 'Petal length': '1.4', 'Sepal length': '4.9', 'Species': 'Iris-setosa'}
{'Sepal width': '3.2', 'Petal width': '0.2', 'Petal length': '1.3', 'Sepal length': '4.7', 'Species': 'Iris-setosa'}

在这里，DictReader被包装在 seekable对象(1)和 Advanced (2)中。seek()方法用于将迭代器重置/倒带到第0位置(3)。

注意: 内存消耗随着迭代而增长，因此要谨慎地将此工具应用于大文件，如 在文件中指出。

问题

我以前也遇到过同样的问题。在分析了我的代码之后，我意识到尝试在循环中重置迭代器会略微增加时间复杂度，而且还会使代码有点难看。

解决方案

打开文件并将行保存到内存中的一个变量。

# initialize list of rows
rows = []


# open the file and temporarily name it as 'my_file'
with open('myfile.csv', 'rb') as my_file:


# set up the reader using the opened file
myfilereader = csv.DictReader(my_file)


# loop through each row of the reader
for row in myfilereader:
# add the row to the list of rows
rows.append(row)

现在您可以在作用域中的任何地方循环 一排排，而不需要处理迭代器。

一种可能的选择是使用 itertools.cycle()，它允许您无限期地迭代，而不需要使用任何类似于 .seek(0)的技巧。

iterDic = itertools.cycle(csv.DictReader(open('file.csv')))

我也遇到了同样的问题——虽然我喜欢 tee()解决方案，但是我不知道我的文件会有多大，而且关于先消耗一个文件再消耗另一个文件的内存警告使我不愿意采用这种方法。

相反，我使用 iter()语句创建了一对迭代器，并在最初的运行中使用第一个，然后在最后的运行中切换到第二个。

因此，在字典阅读器的情况下，如果阅读器的定义是使用:

d = csv.DictReader(f, delimiter=",")

我可以从这个“规范”中创建一对迭代器-使用:

d1, d2 = iter(d), iter(d)

然后，我可以对 d1运行我的第一遍代码，安全地知道第二个迭代器 d2已经从相同的根规范中定义。

我还没有详尽地测试过这个，但它似乎可以使用虚拟数据。

在‘ iter ()’调用的最后一次迭代中返回一个新创建的迭代器

class ResetIter:
def __init__(self, num):
self.num = num
self.i = -1


def __iter__(self):
if self.i == self.num-1: # here, return the new object
return self.__class__(self.num)
return self


def __next__(self):
if self.i == self.num-1:
raise StopIteration


if self.i <= self.num-1:
self.i += 1
return self.i




reset_iter = ResetRange(10)
for i in reset_iter:
print(i, end=' ')
print()


for i in reset_iter:
print(i, end=' ')
print()


for i in reset_iter:
print(i, end=' ')

产出:

0 1 2 3 4 5 6 7 8 9
0 1 2 3 4 5 6 7 8 9
0 1 2 3 4 5 6 7 8 9

最简单的解决方案是: 使用 Deepcopy

from copy import deepcopy
iterator = your_iterator


# Start iteration
iterator_altered = deepcopy(iterator)
for _ in range(2):
a = next(iter(iterator_altered))


# Your iterator is still unaltered.

我认为这是最简单的方法。