-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy path3.1.html
More file actions
674 lines (644 loc) · 61.9 KB
/
3.1.html
File metadata and controls
674 lines (644 loc) · 61.9 KB
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
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" lang="zh_TW">
<head>
<meta http-equiv="X-UA-Compatible" content="IE=Edge" />
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>What’s New In Python 3.1 — Python 3.7.0 說明文件</title>
<link rel="stylesheet" href="../_static/pydoctheme.css" type="text/css" />
<link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
<script type="text/javascript" id="documentation_options" data-url_root="../" src="../_static/documentation_options.js"></script>
<script type="text/javascript" src="../_static/jquery.js"></script>
<script type="text/javascript" src="../_static/underscore.js"></script>
<script type="text/javascript" src="../_static/doctools.js"></script>
<script type="text/javascript" src="../_static/translations.js"></script>
<script type="text/javascript" src="../_static/sidebar.js"></script>
<link rel="search" type="application/opensearchdescription+xml"
title="在 Python 3.7.0 說明文件 中搜尋"
href="../_static/opensearch.xml"/>
<link rel="author" title="關於這些文件" href="../about.html" />
<link rel="index" title="索引" href="../genindex.html" />
<link rel="search" title="搜尋" href="../search.html" />
<link rel="copyright" title="Copyright" href="../copyright.html" />
<link rel="next" title="What’s New In Python 3.0" href="3.0.html" />
<link rel="prev" title="What’s New In Python 3.2" href="3.2.html" />
<link rel="shortcut icon" type="image/png" href="../_static/py.png" />
<link rel="canonical" href="https://docs.python.org/3/whatsnew/3.1.html" />
<script type="text/javascript" src="../_static/copybutton.js"></script>
<script type="text/javascript" src="../_static/switchers.js"></script>
</head><body>
<div class="related" role="navigation" aria-label="related navigation">
<h3>瀏覽</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="../genindex.html" title="General Index"
accesskey="I">索引</a></li>
<li class="right" >
<a href="../py-modindex.html" title="Python 模組索引"
>模組</a> |</li>
<li class="right" >
<a href="3.0.html" title="What’s New In Python 3.0"
accesskey="N">下一頁</a> |</li>
<li class="right" >
<a href="3.2.html" title="What’s New In Python 3.2"
accesskey="P">上一頁</a> |</li>
<li><img src="../_static/py.png" alt=""
style="vertical-align: middle; margin-top: -1px"/></li>
<li><a href="https://www.python.org/">Python</a> »</li>
<li>
<span class="language_switcher_placeholder">zh_TW</span>
<span class="version_switcher_placeholder">3.7.0</span>
<a href="../index.html">Documentation </a> »
</li>
<li class="nav-item nav-item-1"><a href="index.html" accesskey="U">Python 有什麼新功能？</a> »</li>
<li class="right">
<div class="inline-search" style="display: none" role="search">
<form class="inline-search" action="../search.html" method="get">
<input placeholder="Quick search" type="text" name="q" />
<input type="submit" value="Go" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form>
</div>
<script type="text/javascript">$('.inline-search').show(0);</script>
|
</li>
</ul>
</div>
<div class="document">
<div class="documentwrapper">
<div class="bodywrapper">
<div class="body" role="main">
<div class="section" id="what-s-new-in-python-3-1">
<h1>What’s New In Python 3.1<a class="headerlink" href="#what-s-new-in-python-3-1" title="本標題的永久連結">¶</a></h1>
<table class="docutils field-list" frame="void" rules="none">
<col class="field-name" />
<col class="field-body" />
<tbody valign="top">
<tr class="field-odd field"><th class="field-name">Author:</th><td class="field-body">Raymond Hettinger</td>
</tr>
</tbody>
</table>
<p>This article explains the new features in Python 3.1, compared to 3.0.</p>
<div class="section" id="pep-372-ordered-dictionaries">
<h2>PEP 372: Ordered Dictionaries<a class="headerlink" href="#pep-372-ordered-dictionaries" title="本標題的永久連結">¶</a></h2>
<p>Regular Python dictionaries iterate over key/value pairs in arbitrary order.
Over the years, a number of authors have written alternative implementations
that remember the order that the keys were originally inserted. Based on
the experiences from those implementations, a new
<a class="reference internal" href="../library/collections.html#collections.OrderedDict" title="collections.OrderedDict"><code class="xref py py-class docutils literal notranslate"><span class="pre">collections.OrderedDict</span></code></a> class has been introduced.</p>
<p>The OrderedDict API is substantially the same as regular dictionaries
but will iterate over keys and values in a guaranteed order depending on
when a key was first inserted. If a new entry overwrites an existing entry,
the original insertion position is left unchanged. Deleting an entry and
reinserting it will move it to the end.</p>
<p>The standard library now supports use of ordered dictionaries in several
modules. The <a class="reference internal" href="../library/configparser.html#module-configparser" title="configparser: Configuration file parser."><code class="xref py py-mod docutils literal notranslate"><span class="pre">configparser</span></code></a> module uses them by default. This lets
configuration files be read, modified, and then written back in their original
order. The <em>_asdict()</em> method for <a class="reference internal" href="../library/collections.html#collections.namedtuple" title="collections.namedtuple"><code class="xref py py-func docutils literal notranslate"><span class="pre">collections.namedtuple()</span></code></a> now
returns an ordered dictionary with the values appearing in the same order as
the underlying tuple indices. The <a class="reference internal" href="../library/json.html#module-json" title="json: Encode and decode the JSON format."><code class="xref py py-mod docutils literal notranslate"><span class="pre">json</span></code></a> module is being built-out with
an <em>object_pairs_hook</em> to allow OrderedDicts to be built by the decoder.
Support was also added for third-party tools like <a class="reference external" href="http://pyyaml.org/">PyYAML</a>.</p>
<div class="admonition seealso">
<p class="first admonition-title">也參考</p>
<dl class="last docutils">
<dt><span class="target" id="index-0"></span><a class="pep reference external" href="https://www.python.org/dev/peps/pep-0372"><strong>PEP 372</strong></a> - Ordered Dictionaries</dt>
<dd>PEP written by Armin Ronacher and Raymond Hettinger. Implementation
written by Raymond Hettinger.</dd>
</dl>
</div>
</div>
<div class="section" id="pep-378-format-specifier-for-thousands-separator">
<h2>PEP 378: Format Specifier for Thousands Separator<a class="headerlink" href="#pep-378-format-specifier-for-thousands-separator" title="本標題的永久連結">¶</a></h2>
<p>The built-in <a class="reference internal" href="../library/functions.html#format" title="format"><code class="xref py py-func docutils literal notranslate"><span class="pre">format()</span></code></a> function and the <a class="reference internal" href="../library/stdtypes.html#str.format" title="str.format"><code class="xref py py-meth docutils literal notranslate"><span class="pre">str.format()</span></code></a> method use
a mini-language that now includes a simple, non-locale aware way to format
a number with a thousands separator. That provides a way to humanize a
program’s output, improving its professional appearance and readability:</p>
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">format</span><span class="p">(</span><span class="mi">1234567</span><span class="p">,</span> <span class="s1">',d'</span><span class="p">)</span>
<span class="go">'1,234,567'</span>
<span class="gp">>>> </span><span class="nb">format</span><span class="p">(</span><span class="mf">1234567.89</span><span class="p">,</span> <span class="s1">',.2f'</span><span class="p">)</span>
<span class="go">'1,234,567.89'</span>
<span class="gp">>>> </span><span class="nb">format</span><span class="p">(</span><span class="mf">12345.6</span> <span class="o">+</span> <span class="mf">8901234.12</span><span class="n">j</span><span class="p">,</span> <span class="s1">',f'</span><span class="p">)</span>
<span class="go">'12,345.600000+8,901,234.120000j'</span>
<span class="gp">>>> </span><span class="nb">format</span><span class="p">(</span><span class="n">Decimal</span><span class="p">(</span><span class="s1">'1234567.89'</span><span class="p">),</span> <span class="s1">',f'</span><span class="p">)</span>
<span class="go">'1,234,567.89'</span>
</pre></div>
</div>
<p>The supported types are <a class="reference internal" href="../library/functions.html#int" title="int"><code class="xref py py-class docutils literal notranslate"><span class="pre">int</span></code></a>, <a class="reference internal" href="../library/functions.html#float" title="float"><code class="xref py py-class docutils literal notranslate"><span class="pre">float</span></code></a>, <a class="reference internal" href="../library/functions.html#complex" title="complex"><code class="xref py py-class docutils literal notranslate"><span class="pre">complex</span></code></a>
and <a class="reference internal" href="../library/decimal.html#decimal.Decimal" title="decimal.Decimal"><code class="xref py py-class docutils literal notranslate"><span class="pre">decimal.Decimal</span></code></a>.</p>
<p>Discussions are underway about how to specify alternative separators
like dots, spaces, apostrophes, or underscores. Locale-aware applications
should use the existing <em>n</em> format specifier which already has some support
for thousands separators.</p>
<div class="admonition seealso">
<p class="first admonition-title">也參考</p>
<dl class="last docutils">
<dt><span class="target" id="index-1"></span><a class="pep reference external" href="https://www.python.org/dev/peps/pep-0378"><strong>PEP 378</strong></a> - Format Specifier for Thousands Separator</dt>
<dd>PEP written by Raymond Hettinger and implemented by Eric Smith and
Mark Dickinson.</dd>
</dl>
</div>
</div>
<div class="section" id="other-language-changes">
<h2>Other Language Changes<a class="headerlink" href="#other-language-changes" title="本標題的永久連結">¶</a></h2>
<p>Some smaller changes made to the core Python language are:</p>
<ul>
<li><p class="first">Directories and zip archives containing a <code class="file docutils literal notranslate"><span class="pre">__main__.py</span></code>
file can now be executed directly by passing their name to the
interpreter. The directory/zipfile is automatically inserted as the
first entry in sys.path. (Suggestion and initial patch by Andy Chu;
revised patch by Phillip J. Eby and Nick Coghlan; <a class="reference external" href="https://bugs.python.org/issue1739468">bpo-1739468</a>.)</p>
</li>
<li><p class="first">The <a class="reference internal" href="../library/functions.html#int" title="int"><code class="xref py py-func docutils literal notranslate"><span class="pre">int()</span></code></a> type gained a <code class="docutils literal notranslate"><span class="pre">bit_length</span></code> method that returns the
number of bits necessary to represent its argument in binary:</p>
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">n</span> <span class="o">=</span> <span class="mi">37</span>
<span class="gp">>>> </span><span class="nb">bin</span><span class="p">(</span><span class="mi">37</span><span class="p">)</span>
<span class="go">'0b100101'</span>
<span class="gp">>>> </span><span class="n">n</span><span class="o">.</span><span class="n">bit_length</span><span class="p">()</span>
<span class="go">6</span>
<span class="gp">>>> </span><span class="n">n</span> <span class="o">=</span> <span class="mi">2</span><span class="o">**</span><span class="mi">123</span><span class="o">-</span><span class="mi">1</span>
<span class="gp">>>> </span><span class="n">n</span><span class="o">.</span><span class="n">bit_length</span><span class="p">()</span>
<span class="go">123</span>
<span class="gp">>>> </span><span class="p">(</span><span class="n">n</span><span class="o">+</span><span class="mi">1</span><span class="p">)</span><span class="o">.</span><span class="n">bit_length</span><span class="p">()</span>
<span class="go">124</span>
</pre></div>
</div>
<p>(Contributed by Fredrik Johansson, Victor Stinner, Raymond Hettinger,
and Mark Dickinson; <a class="reference external" href="https://bugs.python.org/issue3439">bpo-3439</a>.)</p>
</li>
<li><p class="first">The fields in <a class="reference internal" href="../library/functions.html#format" title="format"><code class="xref py py-func docutils literal notranslate"><span class="pre">format()</span></code></a> strings can now be automatically
numbered:</p>
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="s1">'Sir </span><span class="si">{}</span><span class="s1"> of </span><span class="si">{}</span><span class="s1">'</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="s1">'Gallahad'</span><span class="p">,</span> <span class="s1">'Camelot'</span><span class="p">)</span>
<span class="go">'Sir Gallahad of Camelot'</span>
</pre></div>
</div>
<p>Formerly, the string would have required numbered fields such as:
<code class="docutils literal notranslate"><span class="pre">'Sir</span> <span class="pre">{0}</span> <span class="pre">of</span> <span class="pre">{1}'</span></code>.</p>
<p>(Contributed by Eric Smith; <a class="reference external" href="https://bugs.python.org/issue5237">bpo-5237</a>.)</p>
</li>
<li><p class="first">The <code class="xref py py-func docutils literal notranslate"><span class="pre">string.maketrans()</span></code> function is deprecated and is replaced by new
static methods, <a class="reference internal" href="../library/stdtypes.html#bytes.maketrans" title="bytes.maketrans"><code class="xref py py-meth docutils literal notranslate"><span class="pre">bytes.maketrans()</span></code></a> and <a class="reference internal" href="../library/stdtypes.html#bytearray.maketrans" title="bytearray.maketrans"><code class="xref py py-meth docutils literal notranslate"><span class="pre">bytearray.maketrans()</span></code></a>.
This change solves the confusion around which types were supported by the
<a class="reference internal" href="../library/string.html#module-string" title="string: Common string operations."><code class="xref py py-mod docutils literal notranslate"><span class="pre">string</span></code></a> module. Now, <a class="reference internal" href="../library/stdtypes.html#str" title="str"><code class="xref py py-class docutils literal notranslate"><span class="pre">str</span></code></a>, <a class="reference internal" href="../library/stdtypes.html#bytes" title="bytes"><code class="xref py py-class docutils literal notranslate"><span class="pre">bytes</span></code></a>, and
<a class="reference internal" href="../library/stdtypes.html#bytearray" title="bytearray"><code class="xref py py-class docutils literal notranslate"><span class="pre">bytearray</span></code></a> each have their own <strong>maketrans</strong> and <strong>translate</strong>
methods with intermediate translation tables of the appropriate type.</p>
<p>(Contributed by Georg Brandl; <a class="reference external" href="https://bugs.python.org/issue5675">bpo-5675</a>.)</p>
</li>
<li><p class="first">The syntax of the <a class="reference internal" href="../reference/compound_stmts.html#with"><code class="xref std std-keyword docutils literal notranslate"><span class="pre">with</span></code></a> statement now allows multiple context
managers in a single statement:</p>
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="k">with</span> <span class="nb">open</span><span class="p">(</span><span class="s1">'mylog.txt'</span><span class="p">)</span> <span class="k">as</span> <span class="n">infile</span><span class="p">,</span> <span class="nb">open</span><span class="p">(</span><span class="s1">'a.out'</span><span class="p">,</span> <span class="s1">'w'</span><span class="p">)</span> <span class="k">as</span> <span class="n">outfile</span><span class="p">:</span>
<span class="gp">... </span> <span class="k">for</span> <span class="n">line</span> <span class="ow">in</span> <span class="n">infile</span><span class="p">:</span>
<span class="gp">... </span> <span class="k">if</span> <span class="s1">'<critical>'</span> <span class="ow">in</span> <span class="n">line</span><span class="p">:</span>
<span class="gp">... </span> <span class="n">outfile</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="n">line</span><span class="p">)</span>
</pre></div>
</div>
<p>With the new syntax, the <code class="xref py py-func docutils literal notranslate"><span class="pre">contextlib.nested()</span></code> function is no longer
needed and is now deprecated.</p>
<p>(Contributed by Georg Brandl and Mattias Brändström;
<a class="reference external" href="https://codereview.appspot.com/53094">appspot issue 53094</a>.)</p>
</li>
<li><p class="first"><code class="docutils literal notranslate"><span class="pre">round(x,</span> <span class="pre">n)</span></code> now returns an integer if <em>x</em> is an integer.
Previously it returned a float:</p>
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="nb">round</span><span class="p">(</span><span class="mi">1123</span><span class="p">,</span> <span class="o">-</span><span class="mi">2</span><span class="p">)</span>
<span class="go">1100</span>
</pre></div>
</div>
<p>(Contributed by Mark Dickinson; <a class="reference external" href="https://bugs.python.org/issue4707">bpo-4707</a>.)</p>
</li>
<li><p class="first">Python now uses David Gay’s algorithm for finding the shortest floating
point representation that doesn’t change its value. This should help
mitigate some of the confusion surrounding binary floating point
numbers.</p>
<p>The significance is easily seen with a number like <code class="docutils literal notranslate"><span class="pre">1.1</span></code> which does not
have an exact equivalent in binary floating point. Since there is no exact
equivalent, an expression like <code class="docutils literal notranslate"><span class="pre">float('1.1')</span></code> evaluates to the nearest
representable value which is <code class="docutils literal notranslate"><span class="pre">0x1.199999999999ap+0</span></code> in hex or
<code class="docutils literal notranslate"><span class="pre">1.100000000000000088817841970012523233890533447265625</span></code> in decimal. That
nearest value was and still is used in subsequent floating point
calculations.</p>
<p>What is new is how the number gets displayed. Formerly, Python used a
simple approach. The value of <code class="docutils literal notranslate"><span class="pre">repr(1.1)</span></code> was computed as <code class="docutils literal notranslate"><span class="pre">format(1.1,</span>
<span class="pre">'.17g')</span></code> which evaluated to <code class="docutils literal notranslate"><span class="pre">'1.1000000000000001'</span></code>. The advantage of
using 17 digits was that it relied on IEEE-754 guarantees to assure that
<code class="docutils literal notranslate"><span class="pre">eval(repr(1.1))</span></code> would round-trip exactly to its original value. The
disadvantage is that many people found the output to be confusing (mistaking
intrinsic limitations of binary floating point representation as being a
problem with Python itself).</p>
<p>The new algorithm for <code class="docutils literal notranslate"><span class="pre">repr(1.1)</span></code> is smarter and returns <code class="docutils literal notranslate"><span class="pre">'1.1'</span></code>.
Effectively, it searches all equivalent string representations (ones that
get stored with the same underlying float value) and returns the shortest
representation.</p>
<p>The new algorithm tends to emit cleaner representations when possible, but
it does not change the underlying values. So, it is still the case that
<code class="docutils literal notranslate"><span class="pre">1.1</span> <span class="pre">+</span> <span class="pre">2.2</span> <span class="pre">!=</span> <span class="pre">3.3</span></code> even though the representations may suggest otherwise.</p>
<p>The new algorithm depends on certain features in the underlying floating
point implementation. If the required features are not found, the old
algorithm will continue to be used. Also, the text pickle protocols
assure cross-platform portability by using the old algorithm.</p>
<p>(Contributed by Eric Smith and Mark Dickinson; <a class="reference external" href="https://bugs.python.org/issue1580">bpo-1580</a>)</p>
</li>
</ul>
</div>
<div class="section" id="new-improved-and-deprecated-modules">
<h2>New, Improved, and Deprecated Modules<a class="headerlink" href="#new-improved-and-deprecated-modules" title="本標題的永久連結">¶</a></h2>
<ul>
<li><p class="first">Added a <a class="reference internal" href="../library/collections.html#collections.Counter" title="collections.Counter"><code class="xref py py-class docutils literal notranslate"><span class="pre">collections.Counter</span></code></a> class to support convenient
counting of unique items in a sequence or iterable:</p>
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">Counter</span><span class="p">([</span><span class="s1">'red'</span><span class="p">,</span> <span class="s1">'blue'</span><span class="p">,</span> <span class="s1">'red'</span><span class="p">,</span> <span class="s1">'green'</span><span class="p">,</span> <span class="s1">'blue'</span><span class="p">,</span> <span class="s1">'blue'</span><span class="p">])</span>
<span class="go">Counter({'blue': 3, 'red': 2, 'green': 1})</span>
</pre></div>
</div>
<p>(Contributed by Raymond Hettinger; <a class="reference external" href="https://bugs.python.org/issue1696199">bpo-1696199</a>.)</p>
</li>
<li><p class="first">Added a new module, <a class="reference internal" href="../library/tkinter.ttk.html#module-tkinter.ttk" title="tkinter.ttk: Tk themed widget set"><code class="xref py py-mod docutils literal notranslate"><span class="pre">tkinter.ttk</span></code></a> for access to the Tk themed widget set.
The basic idea of ttk is to separate, to the extent possible, the code
implementing a widget’s behavior from the code implementing its appearance.</p>
<p>(Contributed by Guilherme Polo; <a class="reference external" href="https://bugs.python.org/issue2983">bpo-2983</a>.)</p>
</li>
<li><p class="first">The <a class="reference internal" href="../library/gzip.html#gzip.GzipFile" title="gzip.GzipFile"><code class="xref py py-class docutils literal notranslate"><span class="pre">gzip.GzipFile</span></code></a> and <a class="reference internal" href="../library/bz2.html#bz2.BZ2File" title="bz2.BZ2File"><code class="xref py py-class docutils literal notranslate"><span class="pre">bz2.BZ2File</span></code></a> classes now support
the context management protocol:</p>
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="c1"># Automatically close file after writing</span>
<span class="gp">>>> </span><span class="k">with</span> <span class="n">gzip</span><span class="o">.</span><span class="n">GzipFile</span><span class="p">(</span><span class="n">filename</span><span class="p">,</span> <span class="s2">"wb"</span><span class="p">)</span> <span class="k">as</span> <span class="n">f</span><span class="p">:</span>
<span class="gp">... </span> <span class="n">f</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="sa">b</span><span class="s2">"xxx"</span><span class="p">)</span>
</pre></div>
</div>
<p>(Contributed by Antoine Pitrou.)</p>
</li>
<li><p class="first">The <a class="reference internal" href="../library/decimal.html#module-decimal" title="decimal: Implementation of the General Decimal Arithmetic Specification."><code class="xref py py-mod docutils literal notranslate"><span class="pre">decimal</span></code></a> module now supports methods for creating a
decimal object from a binary <a class="reference internal" href="../library/functions.html#float" title="float"><code class="xref py py-class docutils literal notranslate"><span class="pre">float</span></code></a>. The conversion is
exact but can sometimes be surprising:</p>
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">Decimal</span><span class="o">.</span><span class="n">from_float</span><span class="p">(</span><span class="mf">1.1</span><span class="p">)</span>
<span class="go">Decimal('1.100000000000000088817841970012523233890533447265625')</span>
</pre></div>
</div>
<p>The long decimal result shows the actual binary fraction being
stored for <em>1.1</em>. The fraction has many digits because <em>1.1</em> cannot
be exactly represented in binary.</p>
<p>(Contributed by Raymond Hettinger and Mark Dickinson.)</p>
</li>
<li><p class="first">The <a class="reference internal" href="../library/itertools.html#module-itertools" title="itertools: Functions creating iterators for efficient looping."><code class="xref py py-mod docutils literal notranslate"><span class="pre">itertools</span></code></a> module grew two new functions. The
<a class="reference internal" href="../library/itertools.html#itertools.combinations_with_replacement" title="itertools.combinations_with_replacement"><code class="xref py py-func docutils literal notranslate"><span class="pre">itertools.combinations_with_replacement()</span></code></a> function is one of
four for generating combinatorics including permutations and Cartesian
products. The <a class="reference internal" href="../library/itertools.html#itertools.compress" title="itertools.compress"><code class="xref py py-func docutils literal notranslate"><span class="pre">itertools.compress()</span></code></a> function mimics its namesake
from APL. Also, the existing <a class="reference internal" href="../library/itertools.html#itertools.count" title="itertools.count"><code class="xref py py-func docutils literal notranslate"><span class="pre">itertools.count()</span></code></a> function now has
an optional <em>step</em> argument and can accept any type of counting
sequence including <a class="reference internal" href="../library/fractions.html#fractions.Fraction" title="fractions.Fraction"><code class="xref py py-class docutils literal notranslate"><span class="pre">fractions.Fraction</span></code></a> and
<a class="reference internal" href="../library/decimal.html#decimal.Decimal" title="decimal.Decimal"><code class="xref py py-class docutils literal notranslate"><span class="pre">decimal.Decimal</span></code></a>:</p>
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="p">[</span><span class="n">p</span><span class="o">+</span><span class="n">q</span> <span class="k">for</span> <span class="n">p</span><span class="p">,</span><span class="n">q</span> <span class="ow">in</span> <span class="n">combinations_with_replacement</span><span class="p">(</span><span class="s1">'LOVE'</span><span class="p">,</span> <span class="mi">2</span><span class="p">)]</span>
<span class="go">['LL', 'LO', 'LV', 'LE', 'OO', 'OV', 'OE', 'VV', 'VE', 'EE']</span>
<span class="gp">>>> </span><span class="nb">list</span><span class="p">(</span><span class="n">compress</span><span class="p">(</span><span class="n">data</span><span class="o">=</span><span class="nb">range</span><span class="p">(</span><span class="mi">10</span><span class="p">),</span> <span class="n">selectors</span><span class="o">=</span><span class="p">[</span><span class="mi">0</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="mi">0</span><span class="p">]))</span>
<span class="go">[2, 3, 5, 7]</span>
<span class="gp">>>> </span><span class="n">c</span> <span class="o">=</span> <span class="n">count</span><span class="p">(</span><span class="n">start</span><span class="o">=</span><span class="n">Fraction</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">),</span> <span class="n">step</span><span class="o">=</span><span class="n">Fraction</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="mi">6</span><span class="p">))</span>
<span class="gp">>>> </span><span class="p">[</span><span class="nb">next</span><span class="p">(</span><span class="n">c</span><span class="p">),</span> <span class="nb">next</span><span class="p">(</span><span class="n">c</span><span class="p">),</span> <span class="nb">next</span><span class="p">(</span><span class="n">c</span><span class="p">),</span> <span class="nb">next</span><span class="p">(</span><span class="n">c</span><span class="p">)]</span>
<span class="go">[Fraction(1, 2), Fraction(2, 3), Fraction(5, 6), Fraction(1, 1)]</span>
</pre></div>
</div>
<p>(Contributed by Raymond Hettinger.)</p>
</li>
<li><p class="first"><a class="reference internal" href="../library/collections.html#collections.namedtuple" title="collections.namedtuple"><code class="xref py py-func docutils literal notranslate"><span class="pre">collections.namedtuple()</span></code></a> now supports a keyword argument
<em>rename</em> which lets invalid fieldnames be automatically converted to
positional names in the form _0, _1, etc. This is useful when
the field names are being created by an external source such as a
CSV header, SQL field list, or user input:</p>
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">query</span> <span class="o">=</span> <span class="nb">input</span><span class="p">()</span>
<span class="go">SELECT region, dept, count(*) FROM main GROUPBY region, dept</span>
<span class="gp">>>> </span><span class="n">cursor</span><span class="o">.</span><span class="n">execute</span><span class="p">(</span><span class="n">query</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">query_fields</span> <span class="o">=</span> <span class="p">[</span><span class="n">desc</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="k">for</span> <span class="n">desc</span> <span class="ow">in</span> <span class="n">cursor</span><span class="o">.</span><span class="n">description</span><span class="p">]</span>
<span class="gp">>>> </span><span class="n">UserQuery</span> <span class="o">=</span> <span class="n">namedtuple</span><span class="p">(</span><span class="s1">'UserQuery'</span><span class="p">,</span> <span class="n">query_fields</span><span class="p">,</span> <span class="n">rename</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">pprint</span><span class="o">.</span><span class="n">pprint</span><span class="p">([</span><span class="n">UserQuery</span><span class="p">(</span><span class="o">*</span><span class="n">row</span><span class="p">)</span> <span class="k">for</span> <span class="n">row</span> <span class="ow">in</span> <span class="n">cursor</span><span class="p">])</span>
<span class="go">[UserQuery(region='South', dept='Shipping', _2=185),</span>
<span class="go"> UserQuery(region='North', dept='Accounting', _2=37),</span>
<span class="go"> UserQuery(region='West', dept='Sales', _2=419)]</span>
</pre></div>
</div>
<p>(Contributed by Raymond Hettinger; <a class="reference external" href="https://bugs.python.org/issue1818">bpo-1818</a>.)</p>
</li>
<li><p class="first">The <a class="reference internal" href="../library/re.html#re.sub" title="re.sub"><code class="xref py py-func docutils literal notranslate"><span class="pre">re.sub()</span></code></a>, <a class="reference internal" href="../library/re.html#re.subn" title="re.subn"><code class="xref py py-func docutils literal notranslate"><span class="pre">re.subn()</span></code></a> and <a class="reference internal" href="../library/re.html#re.split" title="re.split"><code class="xref py py-func docutils literal notranslate"><span class="pre">re.split()</span></code></a> functions now
accept a flags parameter.</p>
<p>(Contributed by Gregory Smith.)</p>
</li>
<li><p class="first">The <a class="reference internal" href="../library/logging.html#module-logging" title="logging: Flexible event logging system for applications."><code class="xref py py-mod docutils literal notranslate"><span class="pre">logging</span></code></a> module now implements a simple <a class="reference internal" href="../library/logging.handlers.html#logging.NullHandler" title="logging.NullHandler"><code class="xref py py-class docutils literal notranslate"><span class="pre">logging.NullHandler</span></code></a>
class for applications that are not using logging but are calling
library code that does. Setting-up a null handler will suppress
spurious warnings such as 「No handlers could be found for logger foo」:</p>
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">h</span> <span class="o">=</span> <span class="n">logging</span><span class="o">.</span><span class="n">NullHandler</span><span class="p">()</span>
<span class="gp">>>> </span><span class="n">logging</span><span class="o">.</span><span class="n">getLogger</span><span class="p">(</span><span class="s2">"foo"</span><span class="p">)</span><span class="o">.</span><span class="n">addHandler</span><span class="p">(</span><span class="n">h</span><span class="p">)</span>
</pre></div>
</div>
<p>(Contributed by Vinay Sajip; <a class="reference external" href="https://bugs.python.org/issue4384">bpo-4384</a>).</p>
</li>
<li><p class="first">The <a class="reference internal" href="../library/runpy.html#module-runpy" title="runpy: Locate and run Python modules without importing them first."><code class="xref py py-mod docutils literal notranslate"><span class="pre">runpy</span></code></a> module which supports the <code class="docutils literal notranslate"><span class="pre">-m</span></code> command line switch
now supports the execution of packages by looking for and executing
a <code class="docutils literal notranslate"><span class="pre">__main__</span></code> submodule when a package name is supplied.</p>
<p>(Contributed by Andi Vajda; <a class="reference external" href="https://bugs.python.org/issue4195">bpo-4195</a>.)</p>
</li>
<li><p class="first">The <a class="reference internal" href="../library/pdb.html#module-pdb" title="pdb: The Python debugger for interactive interpreters."><code class="xref py py-mod docutils literal notranslate"><span class="pre">pdb</span></code></a> module can now access and display source code loaded via
<a class="reference internal" href="../library/zipimport.html#module-zipimport" title="zipimport: support for importing Python modules from ZIP archives."><code class="xref py py-mod docutils literal notranslate"><span class="pre">zipimport</span></code></a> (or any other conformant <span class="target" id="index-2"></span><a class="pep reference external" href="https://www.python.org/dev/peps/pep-0302"><strong>PEP 302</strong></a> loader).</p>
<p>(Contributed by Alexander Belopolsky; <a class="reference external" href="https://bugs.python.org/issue4201">bpo-4201</a>.)</p>
</li>
<li><p class="first"><a class="reference internal" href="../library/functools.html#functools.partial" title="functools.partial"><code class="xref py py-class docutils literal notranslate"><span class="pre">functools.partial</span></code></a> objects can now be pickled.</p>
</li>
</ul>
<blockquote>
<div>(Suggested by Antoine Pitrou and Jesse Noller. Implemented by
Jack Diederich; <a class="reference external" href="https://bugs.python.org/issue5228">bpo-5228</a>.)</div></blockquote>
<ul>
<li><p class="first">Add <a class="reference internal" href="../library/pydoc.html#module-pydoc" title="pydoc: Documentation generator and online help system."><code class="xref py py-mod docutils literal notranslate"><span class="pre">pydoc</span></code></a> help topics for symbols so that <code class="docutils literal notranslate"><span class="pre">help('@')</span></code>
works as expected in the interactive environment.</p>
<p>(Contributed by David Laban; <a class="reference external" href="https://bugs.python.org/issue4739">bpo-4739</a>.)</p>
</li>
<li><p class="first">The <a class="reference internal" href="../library/unittest.html#module-unittest" title="unittest: Unit testing framework for Python."><code class="xref py py-mod docutils literal notranslate"><span class="pre">unittest</span></code></a> module now supports skipping individual tests or classes
of tests. And it supports marking a test as an expected failure, a test that
is known to be broken, but shouldn’t be counted as a failure on a
TestResult:</p>
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="k">class</span> <span class="nc">TestGizmo</span><span class="p">(</span><span class="n">unittest</span><span class="o">.</span><span class="n">TestCase</span><span class="p">):</span>
<span class="nd">@unittest</span><span class="o">.</span><span class="n">skipUnless</span><span class="p">(</span><span class="n">sys</span><span class="o">.</span><span class="n">platform</span><span class="o">.</span><span class="n">startswith</span><span class="p">(</span><span class="s2">"win"</span><span class="p">),</span> <span class="s2">"requires Windows"</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">test_gizmo_on_windows</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="o">...</span>
<span class="nd">@unittest</span><span class="o">.</span><span class="n">expectedFailure</span>
<span class="k">def</span> <span class="nf">test_gimzo_without_required_library</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="o">...</span>
</pre></div>
</div>
<p>Also, tests for exceptions have been builtout to work with context managers
using the <a class="reference internal" href="../reference/compound_stmts.html#with"><code class="xref std std-keyword docutils literal notranslate"><span class="pre">with</span></code></a> statement:</p>
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">test_division_by_zero</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="k">with</span> <span class="bp">self</span><span class="o">.</span><span class="n">assertRaises</span><span class="p">(</span><span class="ne">ZeroDivisionError</span><span class="p">):</span>
<span class="n">x</span> <span class="o">/</span> <span class="mi">0</span>
</pre></div>
</div>
<p>In addition, several new assertion methods were added including
<code class="xref py py-func docutils literal notranslate"><span class="pre">assertSetEqual()</span></code>, <code class="xref py py-func docutils literal notranslate"><span class="pre">assertDictEqual()</span></code>,
<code class="xref py py-func docutils literal notranslate"><span class="pre">assertDictContainsSubset()</span></code>, <code class="xref py py-func docutils literal notranslate"><span class="pre">assertListEqual()</span></code>,
<code class="xref py py-func docutils literal notranslate"><span class="pre">assertTupleEqual()</span></code>, <code class="xref py py-func docutils literal notranslate"><span class="pre">assertSequenceEqual()</span></code>,
<code class="xref py py-func docutils literal notranslate"><span class="pre">assertRaisesRegexp()</span></code>, <code class="xref py py-func docutils literal notranslate"><span class="pre">assertIsNone()</span></code>,
and <code class="xref py py-func docutils literal notranslate"><span class="pre">assertIsNotNone()</span></code>.</p>
<p>(Contributed by Benjamin Peterson and Antoine Pitrou.)</p>
</li>
<li><p class="first">The <a class="reference internal" href="../library/io.html#module-io" title="io: Core tools for working with streams."><code class="xref py py-mod docutils literal notranslate"><span class="pre">io</span></code></a> module has three new constants for the <code class="xref py py-meth docutils literal notranslate"><span class="pre">seek()</span></code>
method <code class="xref py py-data docutils literal notranslate"><span class="pre">SEEK_SET</span></code>, <code class="xref py py-data docutils literal notranslate"><span class="pre">SEEK_CUR</span></code>, and <code class="xref py py-data docutils literal notranslate"><span class="pre">SEEK_END</span></code>.</p>
</li>
<li><p class="first">The <a class="reference internal" href="../library/sys.html#sys.version_info" title="sys.version_info"><code class="xref py py-attr docutils literal notranslate"><span class="pre">sys.version_info</span></code></a> tuple is now a named tuple:</p>
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">sys</span><span class="o">.</span><span class="n">version_info</span>
<span class="go">sys.version_info(major=3, minor=1, micro=0, releaselevel='alpha', serial=2)</span>
</pre></div>
</div>
<p>(Contributed by Ross Light; <a class="reference external" href="https://bugs.python.org/issue4285">bpo-4285</a>.)</p>
</li>
<li><p class="first">The <a class="reference internal" href="../library/nntplib.html#module-nntplib" title="nntplib: NNTP protocol client (requires sockets)."><code class="xref py py-mod docutils literal notranslate"><span class="pre">nntplib</span></code></a> and <a class="reference internal" href="../library/imaplib.html#module-imaplib" title="imaplib: IMAP4 protocol client (requires sockets)."><code class="xref py py-mod docutils literal notranslate"><span class="pre">imaplib</span></code></a> modules now support IPv6.</p>
<p>(Contributed by Derek Morr; <a class="reference external" href="https://bugs.python.org/issue1655">bpo-1655</a> and <a class="reference external" href="https://bugs.python.org/issue1664">bpo-1664</a>.)</p>
</li>
<li><p class="first">The <a class="reference internal" href="../library/pickle.html#module-pickle" title="pickle: Convert Python objects to streams of bytes and back."><code class="xref py py-mod docutils literal notranslate"><span class="pre">pickle</span></code></a> module has been adapted for better interoperability with
Python 2.x when used with protocol 2 or lower. The reorganization of the
standard library changed the formal reference for many objects. For
example, <code class="docutils literal notranslate"><span class="pre">__builtin__.set</span></code> in Python 2 is called <code class="docutils literal notranslate"><span class="pre">builtins.set</span></code> in Python
3. This change confounded efforts to share data between different versions of
Python. But now when protocol 2 or lower is selected, the pickler will
automatically use the old Python 2 names for both loading and dumping. This
remapping is turned-on by default but can be disabled with the <em>fix_imports</em>
option:</p>
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">s</span> <span class="o">=</span> <span class="p">{</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">}</span>
<span class="gp">>>> </span><span class="n">pickle</span><span class="o">.</span><span class="n">dumps</span><span class="p">(</span><span class="n">s</span><span class="p">,</span> <span class="n">protocol</span><span class="o">=</span><span class="mi">0</span><span class="p">)</span>
<span class="go">b'c__builtin__\nset\np0\n((lp1\nL1L\naL2L\naL3L\natp2\nRp3\n.'</span>
<span class="gp">>>> </span><span class="n">pickle</span><span class="o">.</span><span class="n">dumps</span><span class="p">(</span><span class="n">s</span><span class="p">,</span> <span class="n">protocol</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">fix_imports</span><span class="o">=</span><span class="kc">False</span><span class="p">)</span>
<span class="go">b'cbuiltins\nset\np0\n((lp1\nL1L\naL2L\naL3L\natp2\nRp3\n.'</span>
</pre></div>
</div>
<p>An unfortunate but unavoidable side-effect of this change is that protocol 2
pickles produced by Python 3.1 won’t be readable with Python 3.0. The latest
pickle protocol, protocol 3, should be used when migrating data between
Python 3.x implementations, as it doesn’t attempt to remain compatible with
Python 2.x.</p>
<p>(Contributed by Alexandre Vassalotti and Antoine Pitrou, <a class="reference external" href="https://bugs.python.org/issue6137">bpo-6137</a>.)</p>
</li>
<li><p class="first">A new module, <a class="reference internal" href="../library/importlib.html#module-importlib" title="importlib: The implementation of the import machinery."><code class="xref py py-mod docutils literal notranslate"><span class="pre">importlib</span></code></a> was added. It provides a complete, portable,
pure Python reference implementation of the <a class="reference internal" href="../reference/simple_stmts.html#import"><code class="xref std std-keyword docutils literal notranslate"><span class="pre">import</span></code></a> statement and its
counterpart, the <a class="reference internal" href="../library/functions.html#__import__" title="__import__"><code class="xref py py-func docutils literal notranslate"><span class="pre">__import__()</span></code></a> function. It represents a substantial
step forward in documenting and defining the actions that take place during
imports.</p>
<p>(Contributed by Brett Cannon.)</p>
</li>
</ul>
</div>
<div class="section" id="optimizations">
<h2>Optimizations<a class="headerlink" href="#optimizations" title="本標題的永久連結">¶</a></h2>
<p>Major performance enhancements have been added:</p>
<ul>
<li><p class="first">The new I/O library (as defined in <span class="target" id="index-3"></span><a class="pep reference external" href="https://www.python.org/dev/peps/pep-3116"><strong>PEP 3116</strong></a>) was mostly written in
Python and quickly proved to be a problematic bottleneck in Python 3.0.
In Python 3.1, the I/O library has been entirely rewritten in C and is
2 to 20 times faster depending on the task at hand. The pure Python
version is still available for experimentation purposes through
the <code class="docutils literal notranslate"><span class="pre">_pyio</span></code> module.</p>
<p>(Contributed by Amaury Forgeot d’Arc and Antoine Pitrou.)</p>
</li>
<li><p class="first">Added a heuristic so that tuples and dicts containing only untrackable objects
are not tracked by the garbage collector. This can reduce the size of
collections and therefore the garbage collection overhead on long-running
programs, depending on their particular use of datatypes.</p>
<p>(Contributed by Antoine Pitrou, <a class="reference external" href="https://bugs.python.org/issue4688">bpo-4688</a>.)</p>
</li>
<li><p class="first">Enabling a configure option named <code class="docutils literal notranslate"><span class="pre">--with-computed-gotos</span></code>
on compilers that support it (notably: gcc, SunPro, icc), the bytecode
evaluation loop is compiled with a new dispatch mechanism which gives
speedups of up to 20%, depending on the system, the compiler, and
the benchmark.</p>
<p>(Contributed by Antoine Pitrou along with a number of other participants,
<a class="reference external" href="https://bugs.python.org/issue4753">bpo-4753</a>).</p>
</li>
<li><p class="first">The decoding of UTF-8, UTF-16 and LATIN-1 is now two to four times
faster.</p>
<p>(Contributed by Antoine Pitrou and Amaury Forgeot d’Arc, <a class="reference external" href="https://bugs.python.org/issue4868">bpo-4868</a>.)</p>
</li>
<li><p class="first">The <a class="reference internal" href="../library/json.html#module-json" title="json: Encode and decode the JSON format."><code class="xref py py-mod docutils literal notranslate"><span class="pre">json</span></code></a> module now has a C extension to substantially improve
its performance. In addition, the API was modified so that json works
only with <a class="reference internal" href="../library/stdtypes.html#str" title="str"><code class="xref py py-class docutils literal notranslate"><span class="pre">str</span></code></a>, not with <a class="reference internal" href="../library/stdtypes.html#bytes" title="bytes"><code class="xref py py-class docutils literal notranslate"><span class="pre">bytes</span></code></a>. That change makes the
module closely match the <a class="reference external" href="http://json.org/">JSON specification</a>
which is defined in terms of Unicode.</p>
<p>(Contributed by Bob Ippolito and converted to Py3.1 by Antoine Pitrou
and Benjamin Peterson; <a class="reference external" href="https://bugs.python.org/issue4136">bpo-4136</a>.)</p>
</li>
<li><p class="first">Unpickling now interns the attribute names of pickled objects. This saves
memory and allows pickles to be smaller.</p>
<p>(Contributed by Jake McGuire and Antoine Pitrou; <a class="reference external" href="https://bugs.python.org/issue5084">bpo-5084</a>.)</p>
</li>
</ul>
</div>
<div class="section" id="idle">
<h2>IDLE<a class="headerlink" href="#idle" title="本標題的永久連結">¶</a></h2>
<ul>
<li><p class="first">IDLE’s format menu now provides an option to strip trailing whitespace
from a source file.</p>
<p>(Contributed by Roger D. Serwy; <a class="reference external" href="https://bugs.python.org/issue5150">bpo-5150</a>.)</p>
</li>
</ul>
</div>
<div class="section" id="build-and-c-api-changes">
<h2>Build and C API Changes<a class="headerlink" href="#build-and-c-api-changes" title="本標題的永久連結">¶</a></h2>
<p>Changes to Python’s build process and to the C API include:</p>
<ul>
<li><p class="first">Integers are now stored internally either in base 2**15 or in base
2**30, the base being determined at build time. Previously, they
were always stored in base 2**15. Using base 2**30 gives
significant performance improvements on 64-bit machines, but
benchmark results on 32-bit machines have been mixed. Therefore,
the default is to use base 2**30 on 64-bit machines and base 2**15
on 32-bit machines; on Unix, there’s a new configure option
<code class="docutils literal notranslate"><span class="pre">--enable-big-digits</span></code> that can be used to override this default.</p>
<p>Apart from the performance improvements this change should be invisible to
end users, with one exception: for testing and debugging purposes there’s a
new <a class="reference internal" href="../library/sys.html#sys.int_info" title="sys.int_info"><code class="xref py py-attr docutils literal notranslate"><span class="pre">sys.int_info</span></code></a> that provides information about the
internal format, giving the number of bits per digit and the size in bytes
of the C type used to store each digit:</p>
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="kn">import</span> <span class="nn">sys</span>
<span class="gp">>>> </span><span class="n">sys</span><span class="o">.</span><span class="n">int_info</span>
<span class="go">sys.int_info(bits_per_digit=30, sizeof_digit=4)</span>
</pre></div>
</div>
<p>(Contributed by Mark Dickinson; <a class="reference external" href="https://bugs.python.org/issue4258">bpo-4258</a>.)</p>
</li>
<li><p class="first">The <a class="reference internal" href="../c-api/long.html#c.PyLong_AsUnsignedLongLong" title="PyLong_AsUnsignedLongLong"><code class="xref c c-func docutils literal notranslate"><span class="pre">PyLong_AsUnsignedLongLong()</span></code></a> function now handles a negative
<em>pylong</em> by raising <a class="reference internal" href="../library/exceptions.html#OverflowError" title="OverflowError"><code class="xref py py-exc docutils literal notranslate"><span class="pre">OverflowError</span></code></a> instead of <a class="reference internal" href="../library/exceptions.html#TypeError" title="TypeError"><code class="xref py py-exc docutils literal notranslate"><span class="pre">TypeError</span></code></a>.</p>
<p>(Contributed by Mark Dickinson and Lisandro Dalcrin; <a class="reference external" href="https://bugs.python.org/issue5175">bpo-5175</a>.)</p>
</li>
<li><p class="first">Deprecated <code class="xref c c-func docutils literal notranslate"><span class="pre">PyNumber_Int()</span></code>. Use <a class="reference internal" href="../c-api/number.html#c.PyNumber_Long" title="PyNumber_Long"><code class="xref c c-func docutils literal notranslate"><span class="pre">PyNumber_Long()</span></code></a> instead.</p>
<p>(Contributed by Mark Dickinson; <a class="reference external" href="https://bugs.python.org/issue4910">bpo-4910</a>.)</p>
</li>
<li><p class="first">Added a new <a class="reference internal" href="../c-api/conversion.html#c.PyOS_string_to_double" title="PyOS_string_to_double"><code class="xref c c-func docutils literal notranslate"><span class="pre">PyOS_string_to_double()</span></code></a> function to replace the
deprecated functions <code class="xref c c-func docutils literal notranslate"><span class="pre">PyOS_ascii_strtod()</span></code> and <code class="xref c c-func docutils literal notranslate"><span class="pre">PyOS_ascii_atof()</span></code>.</p>
<p>(Contributed by Mark Dickinson; <a class="reference external" href="https://bugs.python.org/issue5914">bpo-5914</a>.)</p>
</li>
<li><p class="first">Added <a class="reference internal" href="../c-api/capsule.html#c.PyCapsule" title="PyCapsule"><code class="xref c c-type docutils literal notranslate"><span class="pre">PyCapsule</span></code></a> as a replacement for the <code class="xref c c-type docutils literal notranslate"><span class="pre">PyCObject</span></code> API.
The principal difference is that the new type has a well defined interface
for passing typing safety information and a less complicated signature
for calling a destructor. The old type had a problematic API and is now
deprecated.</p>
<p>(Contributed by Larry Hastings; <a class="reference external" href="https://bugs.python.org/issue5630">bpo-5630</a>.)</p>
</li>
</ul>
</div>
<div class="section" id="porting-to-python-3-1">
<h2>Porting to Python 3.1<a class="headerlink" href="#porting-to-python-3-1" title="本標題的永久連結">¶</a></h2>
<p>This section lists previously described changes and other bugfixes
that may require changes to your code:</p>
<ul>
<li><p class="first">The new floating point string representations can break existing doctests.
For example:</p>
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">e</span><span class="p">():</span>
<span class="sd">'''Compute the base of natural logarithms.</span>
<span class="sd"> >>> e()</span>
<span class="sd"> 2.7182818284590451</span>
<span class="sd"> '''</span>
<span class="k">return</span> <span class="nb">sum</span><span class="p">(</span><span class="mi">1</span><span class="o">/</span><span class="n">math</span><span class="o">.</span><span class="n">factorial</span><span class="p">(</span><span class="n">x</span><span class="p">)</span> <span class="k">for</span> <span class="n">x</span> <span class="ow">in</span> <span class="nb">reversed</span><span class="p">(</span><span class="nb">range</span><span class="p">(</span><span class="mi">30</span><span class="p">)))</span>
<span class="n">doctest</span><span class="o">.</span><span class="n">testmod</span><span class="p">()</span>
<span class="o">**********************************************************************</span>
<span class="n">Failed</span> <span class="n">example</span><span class="p">:</span>
<span class="n">e</span><span class="p">()</span>
<span class="n">Expected</span><span class="p">:</span>
<span class="mf">2.7182818284590451</span>
<span class="n">Got</span><span class="p">:</span>
<span class="mf">2.718281828459045</span>
<span class="o">**********************************************************************</span>
</pre></div>
</div>
</li>
<li><p class="first">The automatic name remapping in the pickle module for protocol 2 or lower can
make Python 3.1 pickles unreadable in Python 3.0. One solution is to use
protocol 3. Another solution is to set the <em>fix_imports</em> option to <code class="docutils literal notranslate"><span class="pre">False</span></code>.
See the discussion above for more details.</p>
</li>
</ul>
</div>
</div>
</div>
</div>
</div>
<div class="sphinxsidebar" role="navigation" aria-label="main navigation">
<div class="sphinxsidebarwrapper">
<h3><a href="../contents.html">目錄</a></h3>
<ul>
<li><a class="reference internal" href="#">What’s New In Python 3.1</a><ul>
<li><a class="reference internal" href="#pep-372-ordered-dictionaries">PEP 372: Ordered Dictionaries</a></li>
<li><a class="reference internal" href="#pep-378-format-specifier-for-thousands-separator">PEP 378: Format Specifier for Thousands Separator</a></li>
<li><a class="reference internal" href="#other-language-changes">Other Language Changes</a></li>
<li><a class="reference internal" href="#new-improved-and-deprecated-modules">New, Improved, and Deprecated Modules</a></li>
<li><a class="reference internal" href="#optimizations">Optimizations</a></li>
<li><a class="reference internal" href="#idle">IDLE</a></li>
<li><a class="reference internal" href="#build-and-c-api-changes">Build and C API Changes</a></li>
<li><a class="reference internal" href="#porting-to-python-3-1">Porting to Python 3.1</a></li>
</ul>
</li>
</ul>
<h4>上個主題</h4>
<p class="topless"><a href="3.2.html"
title="上一章">What’s New In Python 3.2</a></p>
<h4>下個主題</h4>
<p class="topless"><a href="3.0.html"
title="下一章">What’s New In Python 3.0</a></p>
<div role="note" aria-label="source link">
<h3>This Page</h3>
<ul class="this-page-menu">
<li><a href="../bugs.html">Report a Bug</a></li>
<li>
<a href="https://github.com/python/cpython/blob/3.7/Doc/whatsnew/3.1.rst"
rel="nofollow">Show Source
</a>
</li>
</ul>
</div>
</div>
</div>
<div class="clearer"></div>
</div>
<div class="related" role="navigation" aria-label="related navigation">
<h3>瀏覽</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="../genindex.html" title="General Index"
>索引</a></li>
<li class="right" >
<a href="../py-modindex.html" title="Python 模組索引"
>模組</a> |</li>
<li class="right" >
<a href="3.0.html" title="What’s New In Python 3.0"
>下一頁</a> |</li>
<li class="right" >
<a href="3.2.html" title="What’s New In Python 3.2"
>上一頁</a> |</li>
<li><img src="../_static/py.png" alt=""
style="vertical-align: middle; margin-top: -1px"/></li>
<li><a href="https://www.python.org/">Python</a> »</li>
<li>
<span class="language_switcher_placeholder">zh_TW</span>
<span class="version_switcher_placeholder">3.7.0</span>
<a href="../index.html">Documentation </a> »
</li>
<li class="nav-item nav-item-1"><a href="index.html" >Python 有什麼新功能？</a> »</li>
<li class="right">
<div class="inline-search" style="display: none" role="search">
<form class="inline-search" action="../search.html" method="get">
<input placeholder="Quick search" type="text" name="q" />
<input type="submit" value="Go" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form>
</div>
<script type="text/javascript">$('.inline-search').show(0);</script>
|
</li>
</ul>
</div>
<div class="footer">
© <a href="../copyright.html">Copyright</a> 2001-2018, Python Software Foundation.
<br />
The Python Software Foundation is a non-profit corporation.
<a href="https://www.python.org/psf/donations/">Please donate.</a>
<br />
Last updated on 8月 22, 2018.
<a href="../bugs.html">Found a bug</a>?
<br />
Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.7.7.
</div>
</body>
</html>