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
/
comprehensions.html
374 lines (318 loc) · 27.2 KB
/
comprehensions.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
<!DOCTYPE html>
<meta charset=utf-8>
<title>解析 - 深入Python 3</title>
<!--[if IE]><script src=j/html5.js></script><![endif]-->
<link rel=stylesheet href="dip3.css">
<style>
body{counter-reset:h1 3}
</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'>
<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=root value=Search></div></form>
<p>您在这里: <a href="index.html">主页</a> <span class=u>‣</span> <a href="table-of-contents.html#comprehensions">深入Python 3</a> <span class=u>‣</span>
<p id=level>难度等级： <span class=u title=beginner>♦♦♢♢♢</span>
<h1>解析</h1>
<blockquote class=q>
<p><span class=u>❝</span> Our imagination is stretched to the utmost, not, as in fiction, to imagine things which are not really there, but just to comprehend those things which are. <span class=u>❞</span><br>— <a href=http://en.wikiquote.org/wiki/Richard_Feynman>Richard Feynman</a>
</blockquote>
<p id=toc>
<h2 id=divingin>深入</h2>
<p class=f>这一章节将围绕一个非常强大的技术向你介绍列表解析，字典解析和集合解析这三个概念。但是，我要先打个岔介绍两个帮助你浏览本地文件系统的模块。
<p class=a>⁂
<h2 id=os>处理文件和目录</h2>
<p>Python 3 带有一个模块叫做 <code>os</code>，代表 “操作系统(operating system)。” <a href=http://docs.python.org/3.1/library/os.html><code>os</code> 模块</a> 包含非常多的函数用于获取(和修改)本地目录、文件进程、环境变量等的信息。Python 尽最大的努力在<a href="installing-python.html">所有支持的操作系统</a>上提供一个统一的<abbr>API</abbr>， 这样你就可以在保证程序能够在任何的计算机上运行的同时尽量少的包含平台特定的代码。
<h3 id=getcwd>当前工作目录</h3>
<p>当你刚刚开始学习Python的时候， 你将花大量的时间在 <a href="installing-python.html#idle">Python Shell</a>上。 在整本书中，你将一直看见类似下面的例子:
<ol>
<li>在<a href="http://woodpecker.org.cn/diveintopython3/examples/"><code>examples</code> 目录导入某一个模块</a>
<li>调用模块的某一个函数
<li>解释输出结果
</ol>
<aside>总是有一个当前工作目录</aside>
<p>如果你不知道当前工作目录， 第一步很可能会得到一个<code>ImportError</code>。 为什么? 因为 Python 将在<a href="your-first-python-program.html#importsearchpath">导入搜索路径</a>中查找示例模块， 但是由于<code>examples</code> 目录没有包含在搜索路径中，查找将失败。 你可以通过下面两个方法之一来解决这个问题:
<ol>
<li>将<code>examples</code>目录加入到导入搜索路径中
<li>将当前工作目录切换到<code>examples</code>目录
</ol>
<p>Python在任何时候都在暗地里记住了当前工作目录这个属性。无论你是在Python Shell 中，还是在命令行运行你自己的Python 脚本，抑或是在Web 服务器上运行Python <abbr>CGI</abbr> 脚本，当前工作目录总是存在。
<p><code>os</code> 模块提供了两个函数处理当前工作目录
<pre class=screen>
<a><samp class=p>>>> </samp><kbd class=pp>import os</kbd> <span class=u>①</span></a>
<a><samp class=p>>>> </samp><kbd class=pp>print(os.getcwd())</kbd> <span class=u>②</span></a>
<samp>C:\Python31</samp>
<a><samp class=p>>>> </samp><kbd class=pp>os.chdir('/Users/pilgrim/diveintopython3/examples')</kbd> <span class=u>③</span></a>
<a><samp class=p>>>> </samp><kbd class=pp>print(os.getcwd())</kbd> <span class=u>④</span></a>
<samp>C:\Users\pilgrim\diveintopython3\examples</samp></pre>
<ol>
<li><code>os</code> 是Python 自带的; 你可以在任何时间，任何地方导入它。
<li>使用<code>os.getcwd()</code> 函数获得当前工作目录。当你运行一个图形化的Python Shell 时，当前工作目录默认将是Python Shell的可执行文件所在的目录。在Windows 上， 这个目录取决于你将Python安装在哪里; 默认位置是 <code>c:\Python31</code>。如果你通过命令行运行Python Shell，当前工作目录是你运行<code>python3</code>时所在的目录。
<li>使用<code>os.chdir()</code>函数改变当前工作目录
<li>运行<code>os.chdir()</code>函数时，即使在Windows上，我也总是使用Linux风格的路径(正斜杠，没有盘符)。这就是Python 尝试隐藏操作系统差异的一个地方。
</ol>
<h3 id=ospath>处理文件名和目录名</h3>
<p>既然我们说到了目录，我得指出 <code>os.path</code> 模块。<code>os.path</code> 模块包含了操作文件名和目录名的函数.
<pre class=screen>
<samp class=p>>>> </samp><kbd class=pp>import os</kbd>
<a><samp class=p>>>> </samp><kbd class=pp>print(os.path.join('/Users/pilgrim/diveintopython3/examples/', 'humansize.py'))</kbd> <span class=u>①</span></a>
<samp>/Users/pilgrim/diveintopython3/examples/humansize.py</samp>
<a><samp class=p>>>> </samp><kbd class=pp>print(os.path.join('/Users/pilgrim/diveintopython3/examples', 'humansize.py'))</kbd> <span class=u>②</span></a>
<samp>/Users/pilgrim/diveintopython3/examples\humansize.py</samp>
<a><samp class=p>>>> </samp><kbd class=pp>print(os.path.expanduser('~'))</kbd> <span class=u>③</span></a>
<samp>c:\Users\pilgrim</samp>
<a><samp class=p>>>> </samp><kbd class=pp>print(os.path.join(os.path.expanduser('~'), 'diveintopython3', 'examples', 'humansize.py'))</kbd> <span class=u>④</span></a>
<samp>c:\Users\pilgrim\diveintopython3\examples\humansize.py</samp></pre>
<ol>
<li> <code>os.path.join()</code> 函数从一个或多个路径片段中构造一个路径名。 在这个例子中， 它仅仅是简单的拼接字符串.
<li>这个例子稍微复杂一点， 在和文件名拼接前，<code>join</code>函数给路径名添加一个额外的斜杠。由于我在Windows 上写这个例子， 这个斜杠是一个反斜杠而不是正斜杠。如果你在Linux 或者Mac OS X上重现这个例子， 你将会看见正斜杠. 无论你使用哪种形式的斜杠，Python 都可以访问到文件。
<li><code>os.path.expanduser()</code> 用来将包含<code>~</code>符号（表示当前用户Home目录）的路径扩展为完整的路径。在任何有Home 目录概念的操作系统上(包括Linux，Mac OS X 和Windows)，这个函数都能工作。返回的路径不以斜杠结尾，但是<code>os.path.join()</code>并不介意这一点。
<li>结合这些技术，你可以很方便的构造出用户Home 目录下的文件和目录的路径。 <code>os.path.join()</code>可以接受任何数量的参数。当我发现这一点时我大喜过望， 因为在一门新的语言中构造我的工具箱时，<code>addSlashIfNecessary()</code>总是我不得不写的愚蠢的小函数之一。<em>不要</em> 在Python 中写这个愚蠢的小函数，聪明的人们已经帮你考虑过这个问题了。
</ol>
<p><code>os.path</code> 也包含用于分割完整路径名，目录名和文件名的函数
<pre class=screen>
<samp class=p>>>> </samp><kbd class=pp>pathname = '/Users/pilgrim/diveintopython3/examples/humansize.py'</kbd>
<a><samp class=p>>>> </samp><kbd class=pp>os.path.split(pathname)</kbd> <span class=u>①</span></a>
<samp class=pp>('/Users/pilgrim/diveintopython3/examples', 'humansize.py')</samp>
<a><samp class=p>>>> </samp><kbd class=pp>(dirname, filename) = os.path.split(pathname)</kbd> <span class=u>②</span></a>
<a><samp class=p>>>> </samp><kbd class=pp>dirname</kbd> <span class=u>③</span></a>
<samp class=pp>'/Users/pilgrim/diveintopython3/examples'</samp>
<a><samp class=p>>>> </samp><kbd class=pp>filename</kbd> <span class=u>④</span></a>
<samp class=pp>'humansize.py'</samp>
<a><samp class=p>>>> </samp><kbd class=pp>(shortname, extension) = os.path.splitext(filename)</kbd> <span class=u>⑤</span></a>
<samp class=p>>>> </samp><kbd class=pp>shortname</kbd>
<samp class=pp>'humansize'</samp>
<samp class=p>>>> </samp><kbd class=pp>extension</kbd>
<samp class=pp>'.py'</samp></pre>
<ol>
<li><code>split</code> 函数分割一个完整路径并返回目录和文件名。
<li>还记得我说过在函数返回多个值时应该使用<a href="native-datatypes.html#multivar">多变量赋值</a> 吗 ? <code>os.path.split()</code> 函数正是这样做的。 将<code>split</code>函数的返回值赋值给一个二元组。每个变量获得了返回元组中的对应元素的值。
<li>第一个变量<var>dirname</var>，获得了<code>os.path.split()</code> 函数返回元组中的第一个元素，文件所在的目录。
<li>第二个变量<var>filename</var>，获得了<code>os.path.split()</code> 函数返回元组中的第二个元素，文件名。
<li><code>os.path</code> 也包含<code>os.path.splitext()</code> 函数，它分割一个文件名并返回短文件名和扩展名。可以使用同样的技术将它们的值赋值给不同的变量。
</ol>
<h3 id=glob>罗列目录内容</h3>
<p><code>glob</code> 模块是Python标准库中的另一个工具，它可以通过编程的方法获得一个目录的内容，并且它使用熟悉的命令行下的通配符。
<aside><code>glob</code> 模块使用shell风格的通配符。</aside>
<pre class=screen>
<samp class=p>>>> </samp><kbd class=pp>os.chdir('/Users/pilgrim/diveintopython3/')</kbd>
<samp class=p>>>> </samp><kbd class=pp>import glob</kbd>
<a><samp class=p>>>> </samp><kbd class=pp>glob.glob('examples/*.xml')</kbd> <span class=u>①</span></a>
<samp class=pp>['examples\\feed-broken.xml',
'examples\\feed-ns0.xml',
'examples\\feed.xml']</samp>
<a><samp class=p>>>> </samp><kbd class=pp>os.chdir('examples/')</kbd> <span class=u>②</span></a>
<a><samp class=p>>>> </samp><kbd class=pp>glob.glob('*test*.py')</kbd> <span class=u>③</span></a>
<samp class=pp>['alphameticstest.py',
'pluraltest1.py',
'pluraltest2.py',
'pluraltest3.py',
'pluraltest4.py',
'pluraltest5.py',
'pluraltest6.py',
'romantest1.py',
'romantest10.py',
'romantest2.py',
'romantest3.py',
'romantest4.py',
'romantest5.py',
'romantest6.py',
'romantest7.py',
'romantest8.py',
'romantest9.py']</samp></pre>
<ol>
<li><code>glob</code> 模块接受一个通配符并返回所有匹配的文件和目录的路径。在这个例子中，通配符是一个目录名加上 “<code>*.xml</code>”， 它匹配<code>examples</code>子目录下的所有<code>.xml</code> 文件。
<li>现在我们将当前工作目录切换到<code>examples</code> 目录。 <code>os.chdir()</code> 可以接受相对路径.
<li>在glob模式中你可以使用多个通配符。这个例子在当前工作目录中找出所有扩展名为<code>.py</code>并且在文件名中包含单词<code>test</code> 的文件。
</ol>
<h3 id=osstat>获取文件元信息</h3>
<p>每一个现代文件系统都对文件存储了元信息: 创建时间，最后修改时间，文件大小等等。Python 单独提供了一个的<abbr>API</abbr> 用于访问这些元信息。 你不需要打开文件。知道文件名就足够了。
<pre class=screen>
<samp class=p>>>> </samp><kbd class=pp>import os</kbd>
<a><samp class=p>>>> </samp><kbd class=pp>print(os.getcwd())</kbd> <span class=u>①</span></a>
<samp class=pp>c:\Users\pilgrim\diveintopython3\examples</samp>
<a><samp class=p>>>> </samp><kbd class=pp>metadata = os.stat('feed.xml')</kbd> <span class=u>②</span></a>
<a><samp class=p>>>> </samp><kbd class=pp>metadata.st_mtime</kbd> <span class=u>③</span></a>
<samp class=pp>1247520344.9537716</samp>
<a><samp class=p>>>> </samp><kbd class=pp>import time</kbd> <span class=u>④</span></a>
<a><samp class=p>>>> </samp><kbd class=pp>time.localtime(metadata.st_mtime)</kbd> <span class=u>⑤</span></a>
<samp class=pp>time.struct_time(tm_year=2009, tm_mon=7, tm_mday=13, tm_hour=17,
tm_min=25, tm_sec=44, tm_wday=0, tm_yday=194, tm_isdst=1)</samp>
</pre>
<ol>
<li>当前工作目录是<code>examples</code> 文件夹。
<li><code>feed.xml</code>是<code>examples</code> 文件夹中的一个文件。 调用<code>os.stat()</code> 函数返回一个包含多种文件元信息的对象。
<li><code>st_mtime</code> 是最后修改时间，它的格式不是很有用。(技术上讲，它是从纪元，也就是1970年1月1号的第一秒钟，到现在的秒数)
<li><code>time</code> 模块是Python标准库的一部分。 它包含用于在不同时间格式中转换，将时间格式化成字符串以及处理时区的函数。
<li><code>time.localtime()</code> 函数将从纪元到现在的秒数这个格式表示的时间(<code>os.stat()</code>函数返回值的<code>st_mtime</code> 属性)转换成更有用的包含年、月、日、小时、分钟、秒的结构体。这个文件的最后修改时间是2009年7月13日下午5:25。
</ol>
<pre class=screen>
# continued from the previous example
<a><samp class=p>>>> </samp><kbd class=pp>metadata.st_size</kbd> <span class=u>①</span></a>
<samp class=pp>3070</samp>
<samp class=p>>>> </samp><kbd class=pp>import humansize</kbd>
<a><samp class=p>>>> </samp><kbd class=pp>humansize.approximate_size(metadata.st_size)</kbd> <span class=u>②</span></a>
<samp class=pp>'3.0 KiB'</samp></pre>
<ol>
<li> <code>os.stat()</code> 函数也通过<code>st_size</code> 属性返回文件大小。文件<code>feed.xml</code> 的大小是 <code>3070</code> 字节。
<li>你可以将<code>st_size</code> 属性作为参数传给<a href="your-first-python-program.html#divingin"><code>approximate_size()</code> 函数</a>。
</ol>
<h3 id=abspath>构造绝对路径</h3>
<p>在<a href="comprehensions.html#osstat">前一节中</a>，<code>glob.glob()</code> 函数返回一个相对路径的列表。第一个例子的路径类似<code>'examples\feed.xml'</code>，而第二个例子的路径<code>'romantest1.py'</code>更短。只要你保持在当前工作目录中，你就可以使用这些相对路径来打开文件或者获得文件的元信息。但是当你希望构造一个从根目录开始或者是包含盘符的绝对路径时，你就需要用到<code>os.path.realpath()</code>函数了。
<pre class=screen>
<samp class=p>>>> </samp><kbd class=pp>import os</kbd>
<samp class=p>>>> </samp><kbd class=pp>print(os.getcwd())</kbd>
<samp class=pp>c:\Users\pilgrim\diveintopython3\examples</samp>
<samp class=p>>>> </samp><kbd class=pp>print(os.path.realpath('feed.xml'))</kbd>
<samp class=pp>c:\Users\pilgrim\diveintopython3\examples\feed.xml</samp></pre>
<p class=a>⁂
<h2 id=listcomprehension>列表解析</h2>
<aside>你可以在列表解析中使用任何的Python表达式。</aside>
<p><dfn>列表解析</dfn>提供了一种紧凑的方式，实现了通过对列表中每一个元素应用一个函数的方法来将一个列表映射到另一个列表.
<pre class=screen>
<samp class=p>>>> </samp><kbd class=pp>a_list = [1, 9, 8, 4]</kbd>
<a><samp class=p>>>> </samp><kbd class=pp>[elem * 2 for elem in a_list]</kbd> <span class=u>①</span></a>
<samp class=pp>[2, 18, 16, 8]</samp>
<a><samp class=p>>>> </samp><kbd class=pp>a_list</kbd> <span class=u>②</span></a>
<samp class=pp>[1, 9, 8, 4]</samp>
<a><samp class=p>>>> </samp><kbd class=pp>a_list = [elem * 2 for elem in a_list]</kbd> <span class=u>③</span></a>
<samp class=p>>>> </samp><kbd>a_list</kbd>
<samp class=pp>[2, 18, 16, 8]</samp></pre>
<ol>
<li>为了理解这一点，请从右向左看。 <var>a_list</var>是你要映射的列表。Python解释器逐个访问<var>a_list</var>的元素，并临时将元素赋值给变量<var>elem</var>。 然后Python 对元素应用函数<code><var>elem</var> * 2</code>并且将结果添加到返回列表中。
<li>列表解析创造一个新的列表而不改变原列表。
<li>可以安全的将列表解析的结果赋值给被映射的变量。Python会在内存中构造新的列表，在列表解析完成后将结果赋值给原来的变量。
</ol>
<p>你可以在列表解析中使用任何的Python表达式， 包括<code>os</code> 模块中用于操作文件和目录的函数。
<pre class=screen>
<samp class=p>>>> </samp><kbd class=pp>import os, glob</kbd>
<a><samp class=p>>>> </samp><kbd class=pp>glob.glob('*.xml')</kbd> <span class=u>①</span></a>
<samp class=pp>['feed-broken.xml', 'feed-ns0.xml', 'feed.xml']</samp>
<a><samp class=p>>>> </samp><kbd class=pp>[os.path.realpath(f) for f in glob.glob('*.xml')]</kbd> <span class=u>②</span></a>
<samp class=pp>['c:\\Users\\pilgrim\\diveintopython3\\examples\\feed-broken.xml',
'c:\\Users\\pilgrim\\diveintopython3\\examples\\feed-ns0.xml',
'c:\\Users\\pilgrim\\diveintopython3\\examples\\feed.xml']</samp>
</pre>
<ol>
<li>这里返回当前目录下的所有<code>.xml</code> 文件。
<li>列表解析接受<code>.xml</code> 文件列表并将其转化成全路径的列表。
</ol>
<p>列表解析也可以过滤列表，生成比原列表短的结果列表。
<pre class=screen>
<samp class=p>>>> </samp><kbd class=pp>import os, glob</kbd>
<a><samp class=p>>>> </samp><kbd class=pp>[f for f in glob.glob('*.py') if os.stat(f).st_size > 6000]</kbd> <span class=u>①</span></a>
<samp class=pp>['pluraltest6.py',
'romantest10.py',
'romantest6.py',
'romantest7.py',
'romantest8.py',
'romantest9.py']</samp>
</pre>
<ol>
<li>你可以在列表解析的最后加入<code>if</code>子句来过滤列表。对于列表中每一个元素<code>if</code> 关键字后面的表达式都会被计算。如果表达式的计算结果为<code>True</code>，那么这个元素将会被包含在输出中。这个列表解析在当前目录查找所有<code>.py</code> 文件，而 <code>if</code> 表达式通过测试文件大小是否大于<code>6000</code>字节对列表进行过滤。有6个符合条件的文件，所以这个列表解析返回包含六个文件名的列表。
</ol>
<p>到目前为止的例子中的列表解析都只是用了一些简单的表达式， 乘以一个常数、调用一个函数或者是在过滤后返回原始元素。 然而列表解析并不限制表达式的复杂程度。
<pre class=screen>
<samp class=p>>>> </samp><kbd class=pp>import os, glob</kbd>
<a><samp class=p>>>> </samp><kbd class=pp>[(os.stat(f).st_size, os.path.realpath(f)) for f in glob.glob('*.xml')]</kbd> <span class=u>①</span></a>
<samp class=pp>[(3074, 'c:\\Users\\pilgrim\\diveintopython3\\examples\\feed-broken.xml'),
(3386, 'c:\\Users\\pilgrim\\diveintopython3\\examples\\feed-ns0.xml'),
(3070, 'c:\\Users\\pilgrim\\diveintopython3\\examples\\feed.xml')]</samp>
<samp class=p>>>> </samp><kbd class=pp>import humansize</kbd>
<a><samp class=p>>>> </samp><kbd class=pp>[(humansize.approximate_size(os.stat(f).st_size), f) for f in glob.glob('*.xml')]</kbd> <span class=u>②</span></a>
<samp class=pp>[('3.0 KiB', 'feed-broken.xml'),
('3.3 KiB', 'feed-ns0.xml'),
('3.0 KiB', 'feed.xml')]</samp></pre>
<ol>
<li>这个列表解析找到当前工作目录下的所有<code>.xml</code>文件， 对于每一个文件构造一个包含文件大小(通过调用<code>os.stat()</code>获得)和绝对路径(通过调用<code>os.path.realpath()</code>)的元组。
<li>这个列表解析在前一个的基础上对每一个<code>.xml</code>文件的大小应用<a href="your-first-python-program.html#divingin"><code>approximate_size()</code>函数</a>。
</ol>
<p class=a>⁂
<h2 id=dictionarycomprehension>字典解析</h2>
<p><dfn>字典解析</dfn>和列表解析类似，只不过它生成字典而不是列表。
<pre class=screen>
<samp class=p>>>> </samp><kbd class=pp>import os, glob</kbd>
<a><samp class=p>>>> </samp><kbd class=pp>metadata = [(f, os.stat(f)) for f in glob.glob('*test*.py')]</kbd> <span class=u>①</span></a>
<a><samp class=p>>>> </samp><kbd class=pp>metadata[0]</kbd> <span class=u>②</span></a>
<samp class=pp>('alphameticstest.py', nt.stat_result(st_mode=33206, st_ino=0, st_dev=0,
st_nlink=0, st_uid=0, st_gid=0, st_size=2509, st_atime=1247520344,
st_mtime=1247520344, st_ctime=1247520344))</samp>
<a><samp class=p>>>> </samp><kbd class=pp>metadata_dict = {f:os.stat(f) for f in glob.glob('*test*.py')}</kbd> <span class=u>③</span></a>
<a><samp class=p>>>> </samp><kbd class=pp>type(metadata_dict)</kbd> <span class=u>④</span></a>
<samp><class 'dict'></samp>
<a><samp class=p>>>> </samp><kbd class=pp>list(metadata_dict.keys())</kbd> <span class=u>⑤</span></a>
<samp class=pp>['romantest8.py', 'pluraltest1.py', 'pluraltest2.py', 'pluraltest5.py',
'pluraltest6.py', 'romantest7.py', 'romantest10.py', 'romantest4.py',
'romantest9.py', 'pluraltest3.py', 'romantest1.py', 'romantest2.py',
'romantest3.py', 'romantest5.py', 'romantest6.py', 'alphameticstest.py',
'pluraltest4.py']</samp>
<a><samp class=p>>>> </samp><kbd class=pp>metadata_dict['alphameticstest.py'].st_size</kbd> <span class=u>⑥</span></a>
<samp class=pp>2509</samp></pre>
<ol>
<li>这不是字典解析; 而是<a href="comprehensions.html#listcomprehension">列表解析</a>。它找到所有名称中包含<code>test</code>的<code>.py</code>文件，然后构造包含文件名和文件元信息(通过调用<code>os.stat()</code>函数得到)的元组。
<li>结果列表的每一个元素是元组。
<li>这是一个字典解析。 除了两点以外，它的语法同列表解析很类似。首先，它被花括号而不是方括号包围; 第二，对于每一个元素它包含由冒号分隔的两个表达式，而不是列表解析的一个。冒号前的表达式(在这个例子中是<code>f</code>)是字典的键;冒号后面的表达式(在这个例子中是<code>os.stat(f)</code>)是值。
<li>字典解析返回结果是字典。
<li>这个字典的键很简单，就是<code>glob.glob('*test*.py')</code>调用返回的文件名。
<li>每一个键对应的值是<code>os.stat()</code>函数的返回值。这意味着我们可以在字典中通过文件名查找到它的文件元信息。元信息的一个部分是文件大小<code>st_size</code>。这个文件<code>alphameticstest.py</code> 的大小是<code>2509</code>字节。
</ol>
<p>同列表解析一样，你可以在字典解析中包含<code>if</code>字句来过滤输入序列，对于每一个元素字句中的表达式都会被求值。
<pre class=screen>
<samp class=p>>>> </samp><kbd class=pp>import os, glob, humansize</kbd>
<a><samp class=p>>>> </samp><kbd class=pp>metadata_dict = {f:os.stat(f) for f in glob.glob('*')}</kbd> <span class=u>①</span></a>
<a><samp class=p>>>> </samp><kbd class=pp>humansize_dict = {os.path.splitext(f)[0]:humansize.approximate_size(meta.st_size) \ </kbd>
<samp class=p>... </samp><kbd class=pp> for f, meta in metadata_dict.items() if meta.st_size > 6000}</kbd> <span class=u>②</span></a>
<a><samp class=p>>>> </samp><kbd class=pp>list(humansize_dict.keys())</kbd> <span class=u>③</span></a>
<samp class=pp>['romantest9', 'romantest8', 'romantest7', 'romantest6', 'romantest10', 'pluraltest6']</samp>
<a><samp class=p>>>> </samp><kbd class=pp>humansize_dict['romantest9']</kbd> <span class=u>④</span></a>
<samp class=pp>'6.5 KiB'</samp></pre>
<ol>
<li>这个字典解析获得当前目录下所有的文件的列表(<code>glob.glob('*')</code>)，通过<code>os.stat(f)</code>获得每一个文件的元信息， 然后构造一个键是文件名，值是文件元信息的字典。
<li>这个字典解析在前一个基础上过滤掉文件小于<code>6000</code>字节的文件(<code>if meta.st_size > 6000</code>)， 并用过滤出的列表构造字典， 字典的键是文件名去掉扩展名的部分(<code>os.path.splitext(f)[0]</code>) ，字典的值是每个文件的人类可读的近似大小(<code>humansize.approximate_size(meta.st_size)</code>)。
<li>正如你在前一个例子中所看见的，有6个这样的文件，所以字典中有6个元素。
<li>每一个键对应的值是<code>approximate_size()</code>函数返回的字符串。
</ol>
<h3 id=stupiddicttricks>其他同字典解析有关的小技巧</h3>
<p>这里是一个可能有用的通过字典解析实现的小技巧: 交换字典的键和值。
<pre class=screen>
<samp class=p>>>> </samp><kbd class=pp>a_dict = {'a': 1, 'b': 2, 'c': 3}</kbd>
<samp class=p>>>> </samp><kbd class=pp>{value:key for key, value in a_dict.items()}</kbd>
<samp class=pp>{1: 'a', 2: 'b', 3: 'c'}</samp></pre>
<p class=a>⁂
<h2 id=setcomprehension>集合解析</h2>
<p>同样,集合也有自己的集合解析的语法。它和字典解析的非常相似，唯一的不同是集合只有值而没有键:值对。
<pre class=screen>
<samp class=p>>>> </samp><kbd class=pp>a_set = set(range(10))</kbd>
<samp class=p>>>> </samp><kbd class=pp>a_set</kbd>
<samp class=pp>{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}</samp>
<a><samp class=p>>>> </samp><kbd class=pp>{x ** 2 for x in a_set}</kbd> <span class=u>①</span></a>
<samp class=pp>{0, 1, 4, 81, 64, 9, 16, 49, 25, 36}</samp>
<a><samp class=p>>>> </samp><kbd class=pp>{x for x in a_set if x % 2 == 0}</kbd> <span class=u>②</span></a>
<samp class=pp>{0, 8, 2, 4, 6}</samp>
<a><samp class=p>>>> </samp><kbd class=pp>{2**x for x in range(10)}</kbd> <span class=u>③</span></a>
<samp class=pp>{32, 1, 2, 4, 8, 64, 128, 256, 16, 512}</samp>
</pre>
<ol>
<li>集合解析可以接受一个集合作为参数。这个集合解析计算数字0-<code>9</code>这个集合的的平方。
<li>同列表解析和字典解析一样， 集合解析也可以包含<code>if</code> 字句来在将元素放入结果集合前进行过滤。
<li>集合解析的输入并不一定要是集合; 可以是任何序列。
</ol>
<p class=a>⁂
<h2 id=furtherreading>进一步阅读</h2>
<ul>
<li><a href=http://docs.python.org/3.1/library/os.html><code>os</code> module</a>
<li><a href=http://www.doughellmann.com/PyMOTW/os/><code>os</code> — Portable access to operating system specific features</a>
<li><a href=http://docs.python.org/3.1/library/os.path.html><code>os.path</code> module</a>
<li><a href=http://www.doughellmann.com/PyMOTW/ospath/><code>os.path</code> — Platform-independent manipulation of file names</a>
<li><a href=http://docs.python.org/3.1/library/glob.html><code>glob</code> module</a>
<li><a href=http://www.doughellmann.com/PyMOTW/glob/><code>glob</code> — Filename pattern matching</a>
<li><a href=http://docs.python.org/3.1/library/time.html><code>time</code> module</a>
<li><a href=http://www.doughellmann.com/PyMOTW/time/><code>time</code> — Functions for manipulating clock time</a>
<li><a href=http://docs.python.org/3.1/tutorial/datastructures.html#list-comprehensions>List comprehensions</a>
<li><a href=http://docs.python.org/3.1/tutorial/datastructures.html#nested-list-comprehensions>Nested list comprehensions</a>
<li><a href=http://docs.python.org/3.1/tutorial/datastructures.html#looping-techniques>Looping techniques</a>
</ul>
<p class=v><a href="native-datatypes.html" rel=prev title='back to “Native Datatypes”'><span class=u>☜</span></a> <a href="strings.html" rel=next title='onward to “Strings”'><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>