Python 中 iter 函数的第二个参数是什么？

让我们考虑一个文件：

$ echo -e """This is a foo bar sentence .\nAnd this is the first txtfile in the corpus .""" > test.txt
$ cat test.txt 
This is a foo bar sentence .
And this is the first txtfile in the corpus .

当我想按字符读取文件时，我可以这样做https://stackoverflow.com/a/25071590/610569 https://stackoverflow.com/a/25071590/610569:

>>> fin = open('test.txt')
>>> while fin.read(1):
...     fin.seek(-1,1)
...     print fin.read(1),
... 
T h i s   i s   a   f o o   b a r   s e n t e n c e   . 
A n d   t h i s   i s   t h e   f i r s t   t x t f i l e   i n   t h e   c o r p u s   .

但是使用 while 循环可能看起来有点不符合 Python 风格。当我使用时fin.read(1)检查 EOF，然后回溯以读取当前字节。所以我可以做这样的事情如何在Python中一次读取一个文件中的一个字符？ https://stackoverflow.com/q/2988211/610569:

>>> import functools
>>> fin = open('test.txt')
>>> fin_1byte = iter(functools.partial(fin.read, 1), '')
>>> for c in fin_1byte:
...     print c,
... 
T h i s   i s   a   f o o   b a r   s e n t e n c e   . 
A n d   t h i s   i s   t h e   f i r s t   t x t f i l e   i n   t h e   c o r p u s   .

但是当我在没有第二个参数的情况下尝试它时，它会抛出一个TypeError:

>>> fin = open('test.txt')
>>> fin_1byte = functools.partial(fin.read, 1)
>>> for c in iter(fin_1byte):
...     print c,
... 
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'functools.partial' object is not iterable

第二个参数是什么iter?文档也没有说太多：https://docs.python.org/2/library/functions.html#iter https://docs.python.org/2/library/functions.html#iter and https://docs.python.org/3.6/library/functions.html#iter https://docs.python.org/3.6/library/functions.html#iter

根据文档：

返回一个迭代器对象。根据第二个参数的存在，第一个参数的解释非常不同。如果没有第二个参数，object 必须是支持迭代协议的集合对象（iter() 方法），或者必须支持序列协议（getitem() 方法，整数参数从 0 开始）。如果它不支持这些协议中的任何一个，则会引发 TypeError。如果给出第二个参数哨兵，则对象必须是可调用对象。在这种情况下创建的迭代器将在每次调用对象时调用不带参数的对象next（） 方法;如果返回的值等于sentinel，则将引发StopIteration，否则将返回该值。

我猜文档需要一些“解密”：

• 如果没有第二个参数，object 必须是支持迭代协议的集合对象（iter（） 方法）

这是否意味着它需要来自collections？或者说只要该物体有一个__iter__()， 没关系？

• ，或者它必须支持序列协议（getitem() 方法，整数参数从 0 开始）

那就比较隐晦了。那么这是否意味着它会尝试查看序列是否已建立索引并因此可查询，并且索引必须从 0 开始？这是否也意味着索引需要是连续的，即 0、1、2、3...，而不是 0、2、8、13... 之类的？

• 如果它不支持这些协议中的任何一个，则会引发 TypeError。

是的，这部分我明白=）

• 如果给出第二个参数哨兵，则对象必须是可调用对象。

好吧，现在这有点科幻了。将某物称为“a”只是 Python 中的一个术语吗？sentinel？什么是sentinel意思是Python方式吗？和“可调用对象”一样，它是一个函数而不是类型对象？

• 在这种情况下创建的迭代器将在每次调用其 next() 方法时调用不带参数的对象；

这部分我不太明白，也许一个例子会有所帮助。

• 如果返回的值等于sentinel，则将引发StopIteration，否则将返回该值。

可以，然后呢sentinel这里指的是一些突破标准？

有人可以帮助破译/澄清上述几点的含义吗iter?

只要有一个论点，iter必须给出一个具有以下特征的对象__iter__特殊方法，or __getitem__特殊方法。如果它们都不存在，iter will提出错误

>>> iter(None)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'NoneType' object is not iterable

有 2 个迭代协议。旧协议依赖于调用__getitem__对于从 0 到 1 的连续整数IndexError。新协议依赖于从返回的迭代器__iter__.

在Python 2中，str甚至没有__iter__特殊方法：

Python 2.7.12+ (default, Sep 17 2016, 12:08:02) 
[GCC 6.2.0 20160914] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> 'abc'.__iter__
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'str' object has no attribute '__iter__'

但它仍然是可迭代的：

>>> iter('abc')
<iterator object at 0x7fcee9e89390>

为了使您的自定义类可迭代，您需要either __iter__ or __getitem__这引发了IndexError对于不存在的项目：

class Foo:
    def __iter__(self):
        return iter(range(5))

class Bar:
    def __getitem__(self, i):
        if i >= 5:
            raise IndexError
        return i

使用这些：

>>> list(iter(Foo()))
[0, 1, 2, 3, 4]
>>> list(iter(Bar()))
[0, 1, 2, 3, 4]

通常是明确的iter不需要，因为for期望的循环和方法可迭代对象将隐式创建一个迭代器：

>>> list(Foo())
[0, 1, 2, 3, 4]
>>> for i in Bar():
0
1
2
3
4

对于 2 参数形式，第一个参数必须是实现__call__。第一个参数在没有参数的情况下被调用；返回值是从迭代器产生的。当该迭代中函数调用返回的值等于给定值时，迭代停止sentinel值，就好像：

value = func()
if value == sentinel:
    return
else:
    yield value

例如，获取骰子上的值before我们扔 6 个，

>>> import random
>>> throw = lambda: random.randint(1, 6)
>>> list(iter(throw, 6))
[3, 2, 4, 5, 5]
>>> list(iter(throw, 6))
[1, 3, 1, 3, 5, 1, 4]

为了进一步澄清，给定的函数（或给定的对象）__call__特殊方法）在每次调用时不带参数next()用在迭代器上：

>>> def throw_die():
...     die = random.randint(1, 6)
...     print("returning {}".format(die))
...     return die
...
>>> throws = iter(throw_die, 6)
>>> next(throws)
returning 2
2
>>> next(throws)
returning 4
4
>>> next(throws)
returning 6
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

(i.e. throw被称为throw()如果返回值不等于 6，则返回）。

或者在以下情况下

>>> fin_1byte = iter(functools.partial(fin.read, 1), '')
>>> for c in fin_1byte:
...     print c,

从文件末尾读取文件返回空字符串（如果是二进制文件，则为空字节）：

>>> from io import StringIO
>>> fin = StringIO(u'ab')
>>> fin.read(1)
u'a'
>>> fin.read(1)
u'b'
>>> fin.read(1)
u''

如果尚未到达文件末尾，则返回一个字符。

这也可用于通过重复的函数调用创建无限迭代器：

>>> dice = iter(throw, 7)

由于返回的值永远不可能等于 7，因此迭代器将永远运行。一个常见的习惯用法是使用匿名object确保对于任何可以想象的值，比较都不会成功

>>> dice = iter(throw, object())

Because

>>> object() != object()
True

注意，这个词sentinel通常用于在某些数据中用作结束标记的值，并且该值不会在数据中自然出现，如这个Java答案 https://stackoverflow.com/questions/21666508/can-someone-explain-to-me-what-a-sentinel-does-in-java-or-how-it-works.