This repository has been archived by the owner on Dec 10, 2019. It is now read-only.
-
Notifications
You must be signed in to change notification settings - Fork 12
/
iterators.html
401 lines (321 loc) · 29.2 KB
/
iterators.html
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
<!DOCTYPE html>
<meta charset=utf-8>
<title>Classes & Iterators - Dive Into Python 3</title>
<!--[if IE]><script src=j/html5.js></script><![endif]-->
<link rel=stylesheet href="dip3.css">
<style>
body{counter-reset:h1 7}
</style>
<link rel=stylesheet media='only screen and (max-device-width: 480px)' href="http://woodpecker.org.cn/diveintopython3/mobile.css">
<link rel=stylesheet media=print href="http://woodpecker.org.cn/diveintopython3/print.css">
<meta name=viewport content='initial-scale=1.0'>
<meta name="translator" content="ablo zhou" />
<meta name="date" content="2009.11.1" />
<meta name="reply-to" content="[email protected]" />
<meta name="keywords" content="python3,class,iterator,类,迭代器" />
<form action=http://www.google.com/cse><div><input type=hidden name=cx value=014021643941856155761:l5eihuescdw><input type=hidden name=ie value=UTF-8> <input type=search name=q size=25 placeholder="powered by Google™"> <input type=submit name=sa value="搜索"></div></form>
<p>当前位置: <a href="index.html">首页</a><span class=u>‣</span> <a href="table-of-contents.html#installing-python">深入 Python 3</a><a href="table-of-contents.html#iterators"></a> <span class=u>‣</span>
<p id=level>难度级别: <span class=u title=intermediate>♦♦♦♢♢</span>
<h1>类<i class=baa>&</i>迭代器</h1>
<blockquote class=q>
<p><span class=u>❝</span> 东是东，西是西，东西不相及 <span class=u>❞</span><br>
— <a href=http://en.wikiquote.org/wiki/Rudyard_Kipling>拉迪亚德·吉卜林</a>
</blockquote>
<p id=toc>
<h2 id=divingin>深入</h2>
<p class=f>生成器是一类特殊<i> 迭代器</i>。 一个产生值的函数 <code>yield</code> 是一种产生一个迭代器却不需要构建迭代器的精密小巧的方法。 我会告诉你我是什么意思。
<p>记得 <a href="generators.html#a-fibonacci-generator">菲波拉稀生成器</a>吗？ 这里是一个从无到有的迭代器：
<p class=d>[<a href="examples/fibonacci2.py">下载 <code>fibonacci2.py</code></a>]
<pre class=pp><code>class Fib:
'''生成菲波拉稀数列的迭代器'''
def __init__(self, max):
self.max = max
def __iter__(self):
self.a = 0
self.b = 1
return self
def __next__(self):
fib = self.a
if fib > self.max:
raise StopIteration
self.a, self.b = self.b, self.a + self.b
return fib</code></pre>
<p>让我们一行一行来分析。
<pre class='nd pp'><code>class Fib:</code></pre>
<p> 类(class)？什么是类？
<p class=a>⁂
<h2 id=defining-classes>类的定义</h2>
<p>Python 是完全面向对象的：你可以定义自己的类，从你自己或系统自带的类继承，并生成实例。
<p>在Python里定义一个类非常简单。就像函数一样， 没有分开的接口定义。 只需定义类就开始编码。 Python类以保留字 <code>class</code> 开始， 后面跟类名。 技术上来说，只需要这么多就够了，因为一个类不是必须继承其他类。
<pre class=pp><code><a>class PapayaWhip: <span class=u>①</span></a>
<a> pass <span class=u>②</span></a></code></pre>
<ol>
<li>类名是 <code>PapayaWhip</code>， 没有从其他类继承。 类名通常是大写字母分隔， 如<code>EachWordLikeThis</code>， 但这只是个习惯，并非必须。
<li>你可能猜到，类内部的内容都需缩进，就像函数中的代码一样， <code>if</code> 语句， <code>for</code> 循环， 或其他代码块。第一行非缩进代码表示到了类外。
</ol>
<p> <code>PapayaWhip</code> 类没有定义任何方法和属性， 但依据句法，应该在定义中有东西，这就是 <code>pass</code> 语句。 这是Python 保留字，意思是“继续，这里看不到任何东西”。 这是一个什么都不做的语句，是一个很好的占位符，如果你的函数和类什么都不想做（删空函数或类）。
<blockquote class='note compare java'>
<p><span class=u>☞</span>Python中的<code>pass</code> 就像Java 或 C中的空大括号对 (<code>{}</code>) 。
</blockquote>
<p>很多类继承自其他类， 但这个类没有。 很多类有方法，这个类也没有。 Python 类不是必须有东西，除了一个名字。 特别是C++ 程序员发现 Python 类没有显式的构造和析构函数会觉得很古怪。 尽管不是必须， Python 类 <em>可以</em> 具有类似构造函数的东西： <code>__init__()</code> 方法。
<h3 id=init-method> <code>__init__()</code> 方法</h3>
<p>本示例展示 <code>Fib</code> 类使用 <code>__init__</code> 方法。
<pre class=pp><code>class Fib:
<a> '''生成菲波拉稀数列的迭代器''' <span class=u>①</span></a>
<a> def __init__(self, max): <span class=u>②</span></a></code></pre>
<ol>
<li>类同样可以 (而且应该) 具有<code>docstring</code>， 与模块和方法一样。
<li>类实例创建后，<code>__init__()</code> 方法被立即调用。很容易将其——但技术上来说不正确——称为该类的“构造函数” 。 很容易，因为它看起来很像 C++ 的构造函数（按约定，<code>__init__()</code> 是类中第一个被定义的方法），行为一致（是类的新实例中第一片被执行的代码）， 看起来完全一样。 错了， 因为<code>__init__()</code> 方法调用时，对象已经创建了，你已经有了一个合法类对象的引用。
</ol>
<p>每个方法的第一个参数，包括 <code>__init__()</code> 方法，永远指向当前的类对象。 习惯上，该参数叫 <var>self</var>。 该参数和<abbr>C++</abbr>或Java中 <code>this</code> 角色一样， 但 <var>self</var> 不是 Python的保留字， 仅仅是个命名习惯。 虽然如此，请不要取别的名字，只用 <var>self</var>； 这是一个很强的命名习惯。
<p>在 <code>__init__()</code> 方法中， <var>self</var> 指向新创建的对象； 在其他类对象中， 它指向方法所属的实例。尽管需在定义方法时显式指定<var>self</var> ，调用方法时并 <em>不</em> 必须明确指定。 Python 会自动添加。
<p class=a>⁂
<h2 id=instantiating-classes>实例化类</h2>
<p> Python 中实例化类很直接。 实例化类时就像调用函数一样简单，将 <code>__init__()</code> 方法需要的参数传入。 返回值就是新创建的对象。
<pre class=screen>
<samp class=p>>>> </samp><kbd class=pp>import fibonacci2</kbd>
<a><samp class=p>>>> </samp><kbd class=pp>fib = fibonacci2.Fib(100)</kbd> <span class=u>①</span></a>
<a><samp class=p>>>> </samp><kbd class=pp>fib</kbd> <span class=u>②</span></a>
<samp class=pp><fibonacci2.Fib object at 0x00DB8810></samp>
<a><samp class=p>>>> </samp><kbd class=pp>fib.__class__</kbd> <span class=u>③</span></a>
<samp class=pp><class 'fibonacci2.Fib'></samp>
<a><samp class=p>>>> </samp><kbd class=pp>fib.__doc__</kbd> <span class=u>④</span></a>
<samp class=pp>'<code><a>生成菲波拉稀数列的迭代器</a></code>'</samp></pre>
<ol>
<li>你正创建一个 <code>Fib</code> 类的实例（在<code>fibonacci2</code> 模块中定义） 将新创建的实例赋给变量<var>fib</var>。 你传入一个参数 <code>100</code>， 这是<code>Fib</code>的<code>__init__()</code>方法作为<var>max</var>参数传入的结束值。
<li><var>fib</var> 是 <code>Fib</code> 的实例。
<li>每个类实例具有一个内建属性， <code>__class__</code>， 它是该对象的类。 Java 程序员可能熟悉 <code>Class</code> 类， 包含方法如 <code>getName()</code> 和 <code>getSuperclass()</code> 获取对象相关元数据。 Python里面， 这类元数据由属性提供，但思想一致。
<li>你可访问对象的 <code>docstring</code> ，就像函数或模块中的一样。 类的所有实例共享一份 <code>docstring</code>。
</ol>
<blockquote class='note compare java'>
<p><span class=u>☞</span>Python里面， 和调用函数一样简单的调用一个类来创建该类的新实例。 与<abbr>C++</abbr> 或 Java不一样，没有显式的 <code>new</code> 操作符。
</blockquote>
<p class=a>⁂
<h2 id=instance-variables>实例变量</h2>
<p>继续下一行：
<pre class=pp><code>class Fib:
def __init__(self, max):
<a> self.max = max <span class=u>①</span></a></code></pre>
<ol>
<li> <var>self.max</var>是什么？ 它就是实例变量。 与作为参数传入 <code>__init__()</code> 方法的 <var>max</var>完全是两回事。 <var>self.max</var> 是实例内 “全局” 的。 这意味着可以在其他方法中访问它。
</ol>
<pre class=pp><code>class Fib:
def __init__(self, max):
<a> self.max = max <span class=u>①</span></a>
.
.
.
def __next__(self):
fib = self.a
<a> if fib > self.max: <span class=u>②</span></a></code></pre>
<ol>
<li><var>self.max</var> 在 <code>__init__()</code> 方法中定义……
<li>……在 <code>__next__()</code> 方法中引用。
</ol>
<p>实例变量特定于某个类的实例。 例如， 如果你创建 <code>Fib</code> 的两个具有不同最大值的实例， 每个实例会记住自己的值。
<pre class='nd screen'>
<samp class=p>>>> </samp><kbd class=pp>import fibonacci2</kbd>
<samp class=p>>>> </samp><kbd class=pp>fib1 = fibonacci2.Fib(100)</kbd>
<samp class=p>>>> </samp><kbd class=pp>fib2 = fibonacci2.Fib(200)</kbd>
<samp class=p>>>> </samp><kbd class=pp>fib1.max</kbd>
<samp class=pp>100</samp>
<samp class=p>>>> </samp><kbd class=pp>fib2.max</kbd>
<samp class=pp>200</samp></pre>
<p class=a>⁂
<h2 id=a-fibonacci-iterator>菲波拉稀迭代器</h2>
<p><em>现在</em> 你已经准备学习如何创建一个迭代器了。 迭代器就是一个定义了 <code>__iter__()</code> 方法的类。
<aside class=ots>
这些类的所有三种方法， <code>__init__</code>， <code>__iter__</code>， 和 <code>__next__</code>， 起始和结束均为一对下划线（<code>_</code>） 字符。 为什么这样？ 并无什么神奇之处， 只是通常表示这是“<dfn>特殊方法</dfn>。” 唯一“特殊”的地方，就是这些方法不是直接调用的； 当你使用类或实例的某些语法时，Python会自动调用他们。 <a href="special-method-names.html">更多关于特殊方法</a>。
</aside>
<p class=d>[<a href="examples/fibonacci2.py">下载 <code>fibonacci2.py</code></a>]
<pre class=pp><code><a>class Fib: <span class=u>①</span></a>
<a> def __init__(self, max): <span class=u>②</span></a>
self.max = max
<a> def __iter__(self): <span class=u>③</span></a>
self.a = 0
self.b = 1
return self
<a> def __next__(self): <span class=u>④</span></a>
fib = self.a
if fib > self.max:
<a> raise StopIteration <span class=u>⑤</span></a>
self.a, self.b = self.b, self.a + self.b
<a> return fib <span class=u>⑥</span></a></code></pre>
<ol>
<li>从无到有创建一个迭代器， <code>fib</code> 应是一个类，而不是一个函数。
<li>“调用” <code>Fib(max)</code> 会创建该类一个真实的实例，并以<var>max</var>做为参数调用<code>__init__()</code> 方法。 <code>__init__()</code> 方法以实例变量保存最大值，以便随后的其他方法可以引用。
<li>当有人调用<code>iter(fib)</code>的时候，<code>__iter__()</code>就会被调用。（正如你等下会看到的， <code>for</code> 循环会自动调用它， 你也可以自己手动调用。） 在完成迭代器初始化后，（在本例中， 重置我们两个计数器 <code>self.a</code> 和 <code>self.b</code>）， <code>__iter__()</code> 方法能返回任何实现了 <code>__next__()</code> 方法的对象。 在本例（甚至大多数例子）中， <code>__iter__()</code> 仅简单返回 <var>self</var>， 因为该类实现了自己的 <code>__next__()</code> 方法。
<li> 当有人在迭代器的实例中调用<code>next()</code>方法时，<code>__next__()</code> 会自动调用。 随后会有更多理解。
<li>当 <code>__next__()</code> 方法抛出 <code>StopIteration</code> 异常， 这是给调用者表示迭代用完了的信号。 和大多数异常不同， 这不是错误；它是正常情况，仅表示迭代器没有值可产生了。 如果调用者是 <code>for</code> 循环， 它会注意到该 <code>StopIteration</code> 异常并优雅的退出。 （换句话说，它会吞掉该异常。） 这点神奇之处就是使用 <code>for</code> 的关键。
<li>为了分离出下一个值， 迭代器的 <code>__next__()</code> 方法简单 <code>return</code>该值。 不要使用 <code>yield</code> ； 该语法上的小甜头仅用于你使用生成器的时候。 这里你从无到有创建迭代器，使用 <code>return</code> 代替。
</ol>
<p>完全晕了？ 太好了。 让我们看如何调用该迭代器：
<pre class='nd screen'>
<samp class=p>>>> </samp><kbd class=pp>from fibonacci2 import Fib</kbd>
<samp class=p>>>> </samp><kbd class=pp>for n in Fib(1000):</kbd>
<samp class=p>... </samp><kbd class=pp> print(n, end=' ')</kbd>
<samp class=pp>0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987</samp></pre>
<p>为什么？完全一模一样！ 一字节一字节的与你调用 <a href="generators.html#a-fibonacci-generator">Fibonacci-as-a-generator</a> （模块第一个字母大写）相同。但怎么做到的？
<p> <code>for</code> 循环内有魔力。下面是究竟发生了什么：
<ul>
<li>如你所见，<code>for</code> 循环调用 <code>Fib(1000)</code>。 这返回<code>Fib</code> 类的实例。 叫它 <var>fib_inst</var>。
<li>背地里，且十分聪明的， <code>for</code> 循环调用 <code>iter(fib_inst)</code>， 它返回迭代器。 叫它 <var>fib_iter</var>。 本例中， <var>fib_iter</var> == <var>fib_inst</var>， 因为 <code>__iter__()</code> 方法返回 <var>self</var>，但<code>for</code> 循环不知道（也不关心）那些。
<li>为“循环通过”迭代器， <code>for</code> 循环调用 <code>next(fib_iter)</code>， 它又调用 <code>fib_iter</code>对象的 <code>__next__()</code> 方法，产生下一个菲波拉稀计算并返回值。 <code>for</code> 拿到该值并赋给 <var>n</var>， 然后执行<var>n</var>值的 <code>for</code> 循环体。
<li><code>for</code>循环如何知道什么时候结束？很高兴你问到。 当<code>next(fib_iter)</code> 抛出 <code>StopIteration</code> 异常时， <code>for</code>循环将吞下该异常并优雅退出。 （其他异常将传过并如常抛出。） 在哪里你见过 <code>StopIteration</code> 异常？ 当然在 <code>__next__()</code> 方法。
</ul>
<p class=a>⁂
<h2 id=a-plural-rule-iterator>复数规则迭代器</h2>
<aside>iter(f) 调用 f.__iter__<br>
next(f) 调用 f.__next__</aside>
<p>现在到曲终的时候了。我们重写 <a href="generators.html">复数规则生成器</a> 为迭代器。
<p class=d>[<a href="examples/plural6.py">下载<code>plural6.py</code></a>]
<pre class=pp><code>class LazyRules:
rules_filename = 'plural6-rules.txt'
def __init__(self):
self.pattern_file = open(self.rules_filename, encoding='utf-8')
self.cache = []
def __iter__(self):
self.cache_index = 0
return self
def __next__(self):
self.cache_index += 1
if len(self.cache) >= self.cache_index:
return self.cache[self.cache_index - 1]
if self.pattern_file.closed:
raise StopIteration
line = self.pattern_file.readline()
if not line:
self.pattern_file.close()
raise StopIteration
pattern, search, replace = line.split(None, 3)
funcs = build_match_and_apply_functions(
pattern, search, replace)
self.cache.append(funcs)
return funcs
rules = LazyRules()</code></pre>
<p>因此这是一个实现了 <code>__iter__()</code> 和 <code>__next__()</code>的类。所以它可以 被用作迭代器。然后，你实例化它并将其赋给 <var>rules</var> 。这只发生一次，在import的时候。
<p>让我们一口一口来吃：
<pre class=pp><code>class LazyRules:
rules_filename = 'plural6-rules.txt'
def __init__(self):
<a> self.pattern_file = open(self.rules_filename, encoding='utf-8') <span class=u>①</span></a>
<a> self.cache = [] <span class=u>②</span></a></code></pre>
<ol>
<li>当我们实例化 <code>LazyRules</code> 类时， 打开模式文件，但不读取任何东西。 （随后再进行）
<li>打开模式文件之后，初始化缓存。 随后读取模式文件行的时候会用到它（在 <code>__next__()</code> 方法中） 。
</ol>
<p>我们继续之前，让我们近观 <var>rules_filename</var>。它没在 <code>__iter__()</code> 方法中定义。事实上，它没在任何方法中定义。它定义于类级别。它是 <i>类变量</i>， 尽管访问时和实例变量一样 （<var>self.rules_filename</var>）， <code>LazyRules</code> 类的所有实例共享该变量。
<pre class=screen>
<samp class=p>>>> </samp><kbd class=pp>import plural6</kbd>
<samp class=p>>>> </samp><kbd class=pp>r1 = plural6.LazyRules()</kbd>
<samp class=p>>>> </samp><kbd class=pp>r2 = plural6.LazyRules()</kbd>
<a><samp class=p>>>> </samp><kbd class=pp>r1.rules_filename</kbd> <span class=u>①</span></a>
<samp class=pp>'plural6-rules.txt'</samp>
<samp class=p>>>> </samp><kbd class=pp>r2.rules_filename</kbd>
<samp class=pp>'plural6-rules.txt'</samp>
<a><samp class=p>>>> </samp><kbd class=pp>r2.rules_filename = 'r2-override.txt'</kbd> <span class=u>②</span></a>
<samp class=p>>>> </samp><kbd class=pp>r2.rules_filename</kbd>
<samp class=pp>'r2-override.txt'</samp>
<samp class=p>>>> </samp><kbd class=pp>r1.rules_filename</kbd>
<samp class=pp>'plural6-rules.txt'</samp>
<a><samp class=p>>>> </samp><kbd class=pp>r2.__class__.rules_filename</kbd> <span class=u>③</span></a>
<samp class=pp>'plural6-rules.txt'</samp>
<a><samp class=p>>>> </samp><kbd class=pp>r2.__class__.rules_filename = 'papayawhip.txt'</kbd> <span class=u>④</span></a>
<samp class=p>>>> </samp><kbd class=pp>r1.rules_filename</kbd>
<samp class=pp>'papayawhip.txt'</samp>
<a><samp class=p>>>> </samp><kbd class=pp>r2.rules_filename</kbd> <span class=u>⑤</span></a>
<samp class=pp>'r2-overridetxt'</samp></pre>
<ol>
<li>类的每个实例继承了 <var>rules_filename</var> 属性及它在类中定义的值。
<li>修改一个实例属性的值不影响其他实例……
<li>……也不会修改类的属性。可以使用特殊的 <code>__class__</code> 属性来访问类属性（于此相对的是单独实例的属性）。
<li>如果修改类属性， 所有仍然继承该实例的值的实例 （如这里的<var>r1</var> ） 会受影响。
<li>已经覆盖（overridden）了该属性（如这里的 <var>r2</var> ）的所有实例 将不受影响。
</ol>
<p>现在回到我们的演示：
<pre class=pp><code><a> def __iter__(self): <span class=u>①</span></a>
self.cache_index = 0
<a> return self <span class=u>②</span></a>
</code></pre>
<ol>
<li>无论何时有人——如 <code>for</code> 循环——调用 <code>iter(rules)</code>的时候，<code>__iter__()</code> 方法都会被调用。
<li>每个<code>__iter__()</code> 方法都需要做的就是必须返回一个迭代器。 在本例中，返回 <var>self</var>，意味着该类定义了<code>__next__()</code> 方法，由它来关注整个迭代过程中的返回值。
</ol>
<pre class=pp><code><a> def __next__(self): <span class=u>①</span></a>
.
.
.
pattern, search, replace = line.split(None, 3)
<a> funcs = build_match_and_apply_functions( <span class=u>②</span></a>
pattern, search, replace)
<a> self.cache.append(funcs) <span class=u>③</span></a>
return funcs</code></pre>
<ol>
<li>无论何时有人——如 <code>for</code> 循环——调用 <code>__next__()</code> 方法， <code>next(rules)</code>都跟着被调用。 该方法仅在我们从后往前移动时比较好体会。所以我们就这么做。
<li>函数的最后一部分至少应该眼熟。 <code>build_match_and_apply_functions()</code> 函数还没修改；与它从前一样。
<li>唯一的不同是，在返回匹配和应用功能之前（保存在元组 <var>funcs</var>中），我们将其保存到 <code>self.cache</code>。
</ol>
<p>从后往前移动……
<pre class=pp><code> def __next__(self):
.
.
.
<a> line = self.pattern_file.readline() <span class=u>①</span></a>
<a> if not line: <span class=u>②</span></a>
self.pattern_file.close()
<a> raise StopIteration <span class=u>③</span></a>
.
.
.</code></pre>
<ol>
<li>这里有点高级文件操作的技巧。 <code>readline()</code> 方法 （注意：是单数，不是复数 <code>readlines()</code>） 从一个打开的文件中精确读取一行，即下一行。（<em>文件对象同样也是迭代器！ 它自始至终是迭代器……</em>）
<li>如果有一行 <code>readline()</code> 可以读， <var>line</var> 就不会是空字符串。 甚至文件包含一个空行， <var>line</var> 将会是一个字符的字符串 <code>'\n'</code> （回车换行符）。 如果 <var>line</var> 是真的空字符串， 就意味着文件已经没有行可读了。
<li>当我们到达文件尾时， 我们应关闭文件并抛出神奇的 <code>StopIteration</code> 异常。 记住，开门见山的说是因为我们需要为下一条规则找到一个匹配和应用功能。下一条规则从文件的下一行获取…… 但已经没有下一行了！ 所以，我们没有规则返回。 迭代器结束。 （<span class=u>♫</span> 派对结束 <span class=u>♫</span>）
</ol>
<p>由后往前直到 <code>__next__()</code>方法的开始……
<pre class=pp><code> def __next__(self):
self.cache_index += 1
if len(self.cache) >= self.cache_index:
<a> return self.cache[self.cache_index - 1] <span class=u>①</span></a>
if self.pattern_file.closed:
<a> raise StopIteration <span class=u>②</span></a>
.
.
.</code></pre>
<ol>
<li><code>self.cache</code> 将是一个我们匹配并应用单独规则的功能列表。 （至少<em>那个</em>应该看起来熟悉！） <code>self.cache_index</code> 记录我们下一步返回的缓存条目。 如果我们还没有耗尽缓存 （<i>举例</i> 如果 <code>self.cache</code> 的长度大于 <code>self.cache_index</code>），那么我们就会命中一条缓存！ 哇！ 我们可以从缓存中返回匹配和应用功能而不是从无到有创建。
<li>另一方面，如果我们没有从缓存中命中条目， <em>并且</em> 文件对象也已关闭（这会发生， 在本方法下面一点， 正如你从预览的代码片段中所看到的），那么我们什么都不能做。 如果文件被关闭，意味着我们已经用完了它——我们已经从头至尾读取了模式文件的每一行，而且已经对每个模式创建并缓存了匹配和应用功能。文件已经读完；缓存已经用完；我也快完了。等等，什么？坚持一下，我们几乎完成了。
</ol>
<p>放到一起，发生了什么事？ 当：
<ul>
<li>当模块引入时，创建了<code>LazyRules</code> 类的一个单一实例， 叫 <var>rules</var>， 它打开模式文件但并没有读取。
<li>当要求第一个匹配和应用功能时，检查缓存并发现缓存为空。 于是，从模式文件读取一行， 从模式中创建匹配和应用功能，并缓存之。
<li>假如，因为参数的缘故，正好是第一行匹配了。如果那样，不会有更多的匹配和应用会创建，也不会有更多的行会从模式文件中读取。
<li>更进一步， 因为参数的缘故，假设调用者<em>再次</em>调用 <code>plural()</code> 函数来让一个不同的单词变复数。 <code>plural()</code> 函数中的<code>for</code> 循环会调用<code>iter(rules)</code>，这会重置缓存索引但不会重置打开的文件对象。
<li>第一次遍历， <code>for</code>循环会从<var>rules</var>中索要一个值，该值会调用其<code>__next__()</code>方法。然而这一次， 缓存已经被装入了一个匹配和应用功能对， 与模式文件中第一行模式一致。 由于对前一个单词做复数变换时已经被创建和缓存，它们被从缓存中返回。 缓存索引递增，打开的文件无需访问。
<li>假如，因为参数的缘故，这一轮第一个规则 <em>不</em> 匹配。 所以 <code>for</code> 循环再次运转并从 <var>rules</var>请求一个值。 这会再次调用 <code>__next__()</code> 方法。 这一次， 缓存被用完了——它仅有一个条目，而我们被请求第二个——于是 <code>__next__()</code> 方法继续。 从打开的文件中读取下一行，从模式中创建匹配和应用功能，并缓存之。
<li>该“读取创建并缓存”过程一直持续直到我们从模式文件中读取的规则与我们想变复数的单词不匹配。 如果我们确实在文件结束前找到了一个匹配规则，我们仅需使用它并停止，文件还一直打开。文件指针会留在我们停止读取，等待下一个 <code>readline()</code> 命令的地方。现在，缓存已经有更多条目了，并且再次从头开始来将一个新单词变复数，在读取模式文件下一行之前，缓存中的每一个条目都将被尝试。
</ul>
<p>我们已经到达复数变换的极乐世界。
<ol>
<li><strong>最小化初始代价。</strong> 在 <code>import</code> 时发生的唯一的事就是实例化一个单一的类并打开一个文件（但并不读取）。
<li><strong>最大化性能</strong> 前述示例会在每次你想让一个单词变复数时，读遍文件并动态创建功能。本版本将在创建的同时缓存功能，在最坏情况下，仅需要读完一遍文件，无论你要让多少单词变复数。
<li><strong>将代码和数据分离。</strong> 所有模式被存在一个分开的文件。代码是代码，数据是数据，二者永远不会交织。
</ol>
<blockquote class=note>
<p><span class=u>☞</span>这真的是极乐世界？ 嗯，是或不是。 这里有一些<code>LazyRules</code> 示例需要细想的地方： 模式文件被打开（在 <code>__init__()</code>中），并持续打开直到读取最后一个规则。 当Python退出或最后一个<code>LazyRules</code> 类的实例销毁，Python 会最终关闭文件，但是那仍然可能会是一个<em>很长</em>的时间。如果该类是一个“长时间运行”的Python进程的一部分，Python可能从不退出， <code>LazyRules</code> 对象就可能一直不会释放。
<p>这种情况有解决办法。 不要在 <code>__init__()</code> 中打开文件并让其在一行一行读取规则时一直打开，你可以打开文件，读取所有规则，并立即关闭文件。或你可以打开文件，读取一条规则，用<a href="files.html#read"><code>tell()</code> 方法</a>保存文件位置，关闭文件，后面再次打开它，使用<a href="files.html#read"><code>seek()</code> 方法</a> 继续从你离开的地方读取。 或者你不需担心这些就让文件打开，如同本示例所做。 编程即是设计， 而设计牵扯到所有的权衡和限制。让一个文件一直打开太长时间可能是问题；让你代码太复杂也可能是问题。哪一个是更大的问题，依赖于你的开发团队，你的应用，和你的运行环境。
</blockquote>
<p class=a>⁂
<h2 id=furtherreading>深入阅读</h2>
<ul>
<li><a href=http://docs.python.org/3.1/library/stdtypes.html#iterator-types>迭代器类型</a>
<li><a href=http://www.python.org/dev/peps/pep-0234/>PEP 234: 迭代器（ Iterators ）</a>
<li><a href=http://www.python.org/dev/peps/pep-0255/>PEP 255:简单生成器（ Simple Generators ）</a>
<li>系统程序员的生成器诀窍（ Generator Tricks for Systems Programmers</a> ）
</ul>
<p class=v><a href="generators.html" rel=prev title='back to “Closures & Generators”'><span class=u>☜</span></a> <a href="advanced-iterators.html" rel=next title='onward to “Advanced Iterators”'><span class=u>☞</span></a>
<p class=c>© 2001–9 <a href="about.html">Mark Pilgrim</a>
<script src="j/jquery.js"></script>
<script src="j/prettify.js"></script>
<script src="j/dip3.js"></script>