FazBrowse GitHub Viewer
|
Trending
|
URL:
|
Home
Tools:
[Download Repo ZIP]
[View Raw Code]
[Original HTTPS Page]
python-docs-zh-tw/howto/pyporting.po at library/string · python/python-docs-zh-tw · GitHub
python
python-docs-zh-tw
Repository navigation
Code
Issues
33
(33)
Pull requests
12
(12)
Discussions
Actions
Wiki
Security and quality
Insights
Expand file tree
Breadcrumbs
python-docs-zh-tw
/
howto
/
pyporting.po
Copy path
More file actions
More file actions
Latest commit
History
History
History
639 lines (545 loc) · 23.2 KB
Breadcrumbs
python-docs-zh-tw
/
howto
/
pyporting.po
Copy path
File metadata and controls
639 lines (545 loc) · 23.2 KB
Raw
Copy raw file
Download raw file
Open symbols panel
Edit and raw actions
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
#
SOME DESCRIPTIVE TITLE.
#
Copyright (C) 2001-2022, Python Software Foundation
#
This file is distributed under the same license as the Python package.
#
#
Translators:
#
jerrychen <jerrychen.ee@gmail.com>, 2016
msgid ""
msgstr ""
"
Project-Id-Version
:
Python 3.12\n
"
"
Report-Msgid-Bugs-To
:
\n
"
"
POT-Creation-Date
:
2023-08-25 00:03+0000\n
"
"
PO-Revision-Date
:
2018-05-23 14:37+0000\n
"
"
Last-Translator
:
Adrian Liaw <adrianliaw2000@gmail.com>\n
"
"
Language-Team
:
Chinese - TAIWAN (https://github.com/python/python-docs-zh-
"
"
tw)\n
"
"
Language
:
zh_TW\n
"
"
MIME-Version
:
1.0\n
"
"
Content-Type
:
text/plain; charset=UTF-8\n
"
"
Content-Transfer-Encoding
:
8bit\n
"
"
Plural-Forms
:
nplurals=1; plural=0;\n
"
#:
../../howto/pyporting.rst:5
msgid
"How to port Python 2 Code to Python 3"
msgstr
"如何將 Python 2 的程式碼移植到 Python 3"
#:
../../howto/pyporting.rst:0
msgid
"author"
msgstr
"作者"
#:
../../howto/pyporting.rst:7
msgid
"Brett Cannon"
msgstr
"Brett Cannon"
#:
../../howto/pyporting.rst:
-1
msgid
"Abstract"
msgstr
"摘要"
#:
../../howto/pyporting.rst:11
msgid
""
"Python 2 reached its official end-of-life at the start of 2020. This means "
"that no new bug reports, fixes, or changes will be made to Python 2 - it's "
"no longer supported."
msgstr
""
#:
../../howto/pyporting.rst:15
msgid
""
"This guide is intended to provide you with a path to Python 3 for your code, "
"that includes compatibility with Python 2 as a first step."
msgstr
""
#:
../../howto/pyporting.rst:18
msgid
""
"If you are looking to port an extension module instead of pure Python code, "
"please see :ref:`cporting-howto`."
msgstr
""
#:
../../howto/pyporting.rst:21
msgid
""
"The archived python-porting_ mailing list may contain some useful guidance."
msgstr
""
#:
../../howto/pyporting.rst:25
msgid
"The Short Explanation"
msgstr
"簡短的說明"
#:
../../howto/pyporting.rst:27
msgid
""
"To achieve Python 2/3 compatibility in a single code base, the basic steps "
"are:"
msgstr
""
#:
../../howto/pyporting.rst:30
msgid
"Only worry about supporting Python 2.7"
msgstr
""
#:
../../howto/pyporting.rst:31
msgid
""
"Make sure you have good test coverage (coverage.py_ can help; ``python -m "
"pip install coverage``)"
msgstr
""
#:
../../howto/pyporting.rst:33
msgid
"Learn the differences between Python 2 and 3"
msgstr
"瞭解 Python 2 & 3 的差異"
#:
../../howto/pyporting.rst:34
msgid
""
"Use Futurize_ (or Modernize_) to update your code (e.g. ``python -m pip "
"install future``)"
msgstr
""
#:
../../howto/pyporting.rst:35
msgid
""
"Use Pylint_ to help make sure you don't regress on your Python 3 support "
"(``python -m pip install pylint``)"
msgstr
""
#:
../../howto/pyporting.rst:37
msgid
""
"Use caniusepython3_ to find out which of your dependencies are blocking your "
"use of Python 3 (``python -m pip install caniusepython3``)"
msgstr
""
#:
../../howto/pyporting.rst:39
msgid
""
"Once your dependencies are no longer blocking you, use continuous "
"integration to make sure you stay compatible with Python 2 and 3 (tox_ can "
"help test against multiple versions of Python; ``python -m pip install tox``)"
msgstr
""
#:
../../howto/pyporting.rst:42
msgid
""
"Consider using optional static type checking to make sure your type usage "
"works in both Python 2 and 3 (e.g. use mypy_ to check your typing under both "
"Python 2 and Python 3; ``python -m pip install mypy``)."
msgstr
""
#:
../../howto/pyporting.rst:48
msgid
""
"Note: Using ``python -m pip install`` guarantees that the ``pip`` you invoke "
"is the one installed for the Python currently in use, whether it be a system-"
"wide ``pip`` or one installed within a :ref:`virtual environment <tut-venv>`."
msgstr
""
#:
../../howto/pyporting.rst:54
msgid
"Details"
msgstr
"詳細的"
#:
../../howto/pyporting.rst:56
msgid
""
"Even if other factors - say, dependencies over which you have no control - "
"still require you to support Python 2, that does not prevent you taking the "
"step of including Python 3 support."
msgstr
""
#:
../../howto/pyporting.rst:60
msgid
""
"Most changes required to support Python 3 lead to cleaner code using newer "
"practices even in Python 2 code."
msgstr
""
#:
../../howto/pyporting.rst:65
msgid
"Different versions of Python 2"
msgstr
""
#:
../../howto/pyporting.rst:67
msgid
""
"Ideally, your code should be compatible with Python 2.7, which was the last "
"supported version of Python 2."
msgstr
""
#:
../../howto/pyporting.rst:70
msgid
""
"Some of the tools mentioned in this guide will not work with Python 2.6."
msgstr
""
#:
../../howto/pyporting.rst:72
msgid
""
"If absolutely necessary, the six_ project can help you support Python 2.5 "
"and 3 simultaneously. Do realize, though, that nearly all the projects "
"listed in this guide will not be available to you."
msgstr
""
#:
../../howto/pyporting.rst:76
msgid
""
"If you are able to skip Python 2.5 and older, the required changes to your "
"code will be minimal. At worst you will have to use a function instead of a "
"method in some instances or have to import a function instead of using a "
"built-in one."
msgstr
""
#:
../../howto/pyporting.rst:83
msgid
""
"Make sure you specify the proper version support in your ``setup.py`` file"
msgstr
""
#:
../../howto/pyporting.rst:85
msgid
""
"In your ``setup.py`` file you should have the proper `trove classifier`_ "
"specifying what versions of Python you support. As your project does not "
"support Python 3 yet you should at least have ``Programming Language :: "
"Python :: 2 :: Only`` specified. Ideally you should also specify each major/"
"minor version of Python that you do support, e.g. ``Programming Language :: "
"Python :: 2.7``."
msgstr
""
#:
../../howto/pyporting.rst:94
msgid
"Have good test coverage"
msgstr
"有好的測試覆蓋率"
#:
../../howto/pyporting.rst:96
msgid
""
"Once you have your code supporting the oldest version of Python 2 you want "
"it to, you will want to make sure your test suite has good coverage. A good "
"rule of thumb is that if you want to be confident enough in your test suite "
"that any failures that appear after having tools rewrite your code are "
"actual bugs in the tools and not in your code. If you want a number to aim "
"for, try to get over 80% coverage (and don't feel bad if you find it hard to "
"get better than 90% coverage). If you don't already have a tool to measure "
"test coverage then coverage.py_ is recommended."
msgstr
""
#:
../../howto/pyporting.rst:107
msgid
"Be aware of the differences between Python 2 and 3"
msgstr
"注意 Python 2 & 3 的差異"
#:
../../howto/pyporting.rst:109
msgid
""
"Once you have your code well-tested you are ready to begin porting your code "
"to Python 3! But to fully understand how your code is going to change and "
"what you want to look out for while you code, you will want to learn what "
"changes Python 3 makes in terms of Python 2."
msgstr
""
#:
../../howto/pyporting.rst:114
msgid
""
"Some resources for understanding the differences and their implications for "
"you code:"
msgstr
""
#:
../../howto/pyporting.rst:117
msgid
""
"the :ref:`
\"
What's New
\"
<whatsnew-index>` doc for each release of Python 3"
msgstr
""
#:
../../howto/pyporting.rst:118
msgid
"the `Porting to Python 3`_ book (which is free online)"
msgstr
""
#:
../../howto/pyporting.rst:119
msgid
"the handy `cheat sheet`_ from the Python-Future project."
msgstr
""
#:
../../howto/pyporting.rst:123
msgid
"Update your code"
msgstr
"更新你的程式碼"
#:
../../howto/pyporting.rst:125
msgid
"There are tools available that can port your code automatically."
msgstr
""
#:
../../howto/pyporting.rst:127
msgid
""
"Futurize_ does its best to make Python 3 idioms and practices exist in "
"Python 2, e.g. backporting the ``bytes`` type from Python 3 so that you have "
"semantic parity between the major versions of Python. This is the better "
"approach for most cases."
msgstr
""
#:
../../howto/pyporting.rst:132
msgid
""
"Modernize_, on the other hand, is more conservative and targets a Python 2/3 "
"subset of Python, directly relying on six_ to help provide compatibility."
msgstr
""
#:
../../howto/pyporting.rst:135
msgid
""
"A good approach is to run the tool over your test suite first and visually "
"inspect the diff to make sure the transformation is accurate. After you have "
"transformed your test suite and verified that all the tests still pass as "
"expected, then you can transform your application code knowing that any "
"tests which fail is a translation failure."
msgstr
""
#:
../../howto/pyporting.rst:141
msgid
""
"Unfortunately the tools can't automate everything to make your code work "
"under Python 3, and you will also need to read the tools' documentation in "
"case some options you need are turned off by default."
msgstr
""
#:
../../howto/pyporting.rst:145
msgid
"Key issues to be aware of and check for:"
msgstr
""
#:
../../howto/pyporting.rst:148
msgid
"Division"
msgstr
""
#:
../../howto/pyporting.rst:150
msgid
""
"In Python 3, ``5 / 2 == 2.5`` and not ``2`` as it was in Python 2; all "
"division between ``int`` values result in a ``float``. This change has "
"actually been planned since Python 2.2 which was released in 2002. Since "
"then users have been encouraged to add ``from __future__ import division`` "
"to any and all files which use the ``/`` and ``//`` operators or to be "
"running the interpreter with the ``-Q`` flag. If you have not been doing "
"this then you will need to go through your code and do two things:"
msgstr
""
#:
../../howto/pyporting.rst:158
msgid
"Add ``from __future__ import division`` to your files"
msgstr
""
#:
../../howto/pyporting.rst:159
msgid
""
"Update any division operator as necessary to either use ``//`` to use floor "
"division or continue using ``/`` and expect a float"
msgstr
""
#:
../../howto/pyporting.rst:162
msgid
""
"The reason that ``/`` isn't simply translated to ``//`` automatically is "
"that if an object defines a ``__truediv__`` method but not ``__floordiv__`` "
"then your code would begin to fail (e.g. a user-defined class that uses ``/"
"`` to signify some operation but not ``//`` for the same thing or at all)."
msgstr
""
#:
../../howto/pyporting.rst:169
msgid
"Text versus binary data"
msgstr
""
#:
../../howto/pyporting.rst:171
msgid
""
"In Python 2 you could use the ``str`` type for both text and binary data. "
"Unfortunately this confluence of two different concepts could lead to "
"brittle code which sometimes worked for either kind of data, sometimes not. "
"It also could lead to confusing APIs if people didn't explicitly state that "
"something that accepted ``str`` accepted either text or binary data instead "
"of one specific type. This complicated the situation especially for anyone "
"supporting multiple languages as APIs wouldn't bother explicitly supporting "
"``unicode`` when they claimed text data support."
msgstr
""
#:
../../howto/pyporting.rst:180
msgid
""
"Python 3 made text and binary data distinct types that cannot simply be "
"mixed together. For any code that deals only with text or only binary data, "
"this separation doesn't pose an issue. But for code that has to deal with "
"both, it does mean you might have to now care about when you are using text "
"compared to binary data, which is why this cannot be entirely automated."
msgstr
""
#:
../../howto/pyporting.rst:186
msgid
""
"Decide which APIs take text and which take binary (it is **highly** "
"recommended you don't design APIs that can take both due to the difficulty "
"of keeping the code working; as stated earlier it is difficult to do well). "
"In Python 2 this means making sure the APIs that take text can work with "
"``unicode`` and those that work with binary data work with the ``bytes`` "
"type from Python 3 (which is a subset of ``str`` in Python 2 and acts as an "
"alias for ``bytes`` type in Python 2). Usually the biggest issue is "
"realizing which methods exist on which types in Python 2 and 3 "
"simultaneously (for text that's ``unicode`` in Python 2 and ``str`` in "
"Python 3, for binary that's ``str``/``bytes`` in Python 2 and ``bytes`` in "
"Python 3)."
msgstr
""
#:
../../howto/pyporting.rst:197
msgid
""
"The following table lists the **unique** methods of each data type across "
"Python 2 and 3 (e.g., the ``decode()`` method is usable on the equivalent "
"binary data type in either Python 2 or 3, but it can't be used by the "
"textual data type consistently between Python 2 and 3 because ``str`` in "
"Python 3 doesn't have the method). Do note that as of Python 3.5 the "
"``__mod__`` method was added to the bytes type."
msgstr
""
#:
../../howto/pyporting.rst:205
msgid
"**Text data**"
msgstr
""
#:
../../howto/pyporting.rst:205
msgid
"**Binary data**"
msgstr
""
#:
../../howto/pyporting.rst:207
msgid
"
\\
"
msgstr
"
\\
"
#:
../../howto/pyporting.rst:207
msgid
"decode"
msgstr
""
#:
../../howto/pyporting.rst:209
msgid
"encode"
msgstr
""
#:
../../howto/pyporting.rst:211
msgid
"format"
msgstr
""
#:
../../howto/pyporting.rst:213
msgid
"isdecimal"
msgstr
"isdecimal"
#:
../../howto/pyporting.rst:215
msgid
"isnumeric"
msgstr
"isnumeric"
#:
../../howto/pyporting.rst:218
msgid
""
"Making the distinction easier to handle can be accomplished by encoding and "
"decoding between binary data and text at the edge of your code. This means "
"that when you receive text in binary data, you should immediately decode it. "
"And if your code needs to send text as binary data then encode it as late as "
"possible. This allows your code to work with only text internally and thus "
"eliminates having to keep track of what type of data you are working with."
msgstr
""
#:
../../howto/pyporting.rst:225
msgid
""
"The next issue is making sure you know whether the string literals in your "
"code represent text or binary data. You should add a ``b`` prefix to any "
"literal that presents binary data. For text you should add a ``u`` prefix to "
"the text literal. (There is a :mod:`__future__` import to force all "
"unspecified literals to be Unicode, but usage has shown it isn't as "
"effective as adding a ``b`` or ``u`` prefix to all literals explicitly)"
msgstr
""
#:
../../howto/pyporting.rst:232
msgid
""
"You also need to be careful about opening files. Possibly you have not "
"always bothered to add the ``b`` mode when opening a binary file (e.g., "
"``rb`` for binary reading). Under Python 3, binary files and text files are "
"clearly distinct and mutually incompatible; see the :mod:`io` module for "
"details. Therefore, you **must** make a decision of whether a file will be "
"used for binary access (allowing binary data to be read and/or written) or "
"textual access (allowing text data to be read and/or written). You should "
"also use :func:`io.open` for opening files instead of the built-in :func:"
"`open` function as the :mod:`io` module is consistent from Python 2 to 3 "
"while the built-in :func:`open` function is not (in Python 3 it's actually :"
"func:`io.open`). Do not bother with the outdated practice of using :func:"
"`codecs.open` as that's only necessary for keeping compatibility with Python "
"2.5."
msgstr
""
#:
../../howto/pyporting.rst:245
msgid
""
"The constructors of both ``str`` and ``bytes`` have different semantics for "
"the same arguments between Python 2 and 3. Passing an integer to ``bytes`` "
"in Python 2 will give you the string representation of the integer: "
"``bytes(3) == '3'``. But in Python 3, an integer argument to ``bytes`` will "
"give you a bytes object as long as the integer specified, filled with null "
"bytes: ``bytes(3) == b'
\\
x00
\\
x00
\\
x00'``. A similar worry is necessary when "
"passing a bytes object to ``str``. In Python 2 you just get the bytes object "
"back: ``str(b'3') == b'3'``. But in Python 3 you get the string "
"representation of the bytes object: ``str(b'3') ==
\"
b'3'
\"
``."
msgstr
""
#:
../../howto/pyporting.rst:255
msgid
""
"Finally, the indexing of binary data requires careful handling (slicing does "
"**not** require any special handling). In Python 2, ``b'123'[1] == b'2'`` "
"while in Python 3 ``b'123'[1] == 50``. Because binary data is simply a "
"collection of binary numbers, Python 3 returns the integer value for the "
"byte you index on. But in Python 2 because ``bytes == str``, indexing "
"returns a one-item slice of bytes. The six_ project has a function named "
"``six.indexbytes()`` which will return an integer like in Python 3: ``six."
"indexbytes(b'123', 1)``."
msgstr
""
#:
../../howto/pyporting.rst:264
msgid
"To summarize:"
msgstr
""
#:
../../howto/pyporting.rst:266
msgid
"Decide which of your APIs take text and which take binary data"
msgstr
""
#:
../../howto/pyporting.rst:267
msgid
""
"Make sure that your code that works with text also works with ``unicode`` "
"and code for binary data works with ``bytes`` in Python 2 (see the table "
"above for what methods you cannot use for each type)"
msgstr
""
#:
../../howto/pyporting.rst:270
msgid
""
"Mark all binary literals with a ``b`` prefix, textual literals with a ``u`` "
"prefix"
msgstr
""
#:
../../howto/pyporting.rst:272
msgid
""
"Decode binary data to text as soon as possible, encode text as binary data "
"as late as possible"
msgstr
""
#:
../../howto/pyporting.rst:274
msgid
""
"Open files using :func:`io.open` and make sure to specify the ``b`` mode "
"when appropriate"
msgstr
""
#:
../../howto/pyporting.rst:276
msgid
"Be careful when indexing into binary data"
msgstr
""
#:
../../howto/pyporting.rst:280
msgid
"Use feature detection instead of version detection"
msgstr
""
#:
../../howto/pyporting.rst:282
msgid
""
"Inevitably you will have code that has to choose what to do based on what "
"version of Python is running. The best way to do this is with feature "
"detection of whether the version of Python you're running under supports "
"what you need. If for some reason that doesn't work then you should make the "
"version check be against Python 2 and not Python 3. To help explain this, "
"let's look at an example."
msgstr
""
#:
../../howto/pyporting.rst:289
msgid
""
"Let's pretend that you need access to a feature of :mod:`importlib` that is "
"available in Python's standard library since Python 3.3 and available for "
"Python 2 through importlib2_ on PyPI. You might be tempted to write code to "
"access e.g. the :mod:`importlib.abc` module by doing the following::"
msgstr
""
#:
../../howto/pyporting.rst:301
msgid
""
"The problem with this code is what happens when Python 4 comes out? It would "
"be better to treat Python 2 as the exceptional case instead of Python 3 and "
"assume that future Python versions will be more compatible with Python 3 "
"than Python 2::"
msgstr
""
#:
../../howto/pyporting.rst:313
msgid
""
"The best solution, though, is to do no version detection at all and instead "
"rely on feature detection. That avoids any potential issues of getting the "
"version detection wrong and helps keep you future-compatible::"
msgstr
""
#:
../../howto/pyporting.rst:324
msgid
"Prevent compatibility regressions"
msgstr
""
#:
../../howto/pyporting.rst:326
msgid
""
"Once you have fully translated your code to be compatible with Python 3, you "
"will want to make sure your code doesn't regress and stop working under "
"Python 3. This is especially true if you have a dependency which is blocking "
"you from actually running under Python 3 at the moment."
msgstr
""
#:
../../howto/pyporting.rst:331
msgid
""
"To help with staying compatible, any new modules you create should have at "
"least the following block of code at the top of it::"
msgstr
""
#:
../../howto/pyporting.rst:338
msgid
""
"You can also run Python 2 with the ``-3`` flag to be warned about various "
"compatibility issues your code triggers during execution. If you turn "
"warnings into errors with ``-Werror`` then you can make sure that you don't "
"accidentally miss a warning."
msgstr
""
#:
../../howto/pyporting.rst:343
msgid
""
"You can also use the Pylint_ project and its ``--py3k`` flag to lint your "
"code to receive warnings when your code begins to deviate from Python 3 "
"compatibility. This also prevents you from having to run Modernize_ or "
"Futurize_ over your code regularly to catch compatibility regressions. This "
"does require you only support Python 2.7 and Python 3.4 or newer as that is "
"Pylint's minimum Python version support."
msgstr
""
#:
../../howto/pyporting.rst:352
msgid
"Check which dependencies block your transition"
msgstr
""
#:
../../howto/pyporting.rst:354
msgid
""
"**After** you have made your code compatible with Python 3 you should begin "
"to care about whether your dependencies have also been ported. The "
"caniusepython3_ project was created to help you determine which projects -- "
"directly or indirectly -- are blocking you from supporting Python 3. There "
"is both a command-line tool as well as a web interface at https://"
"caniusepython3.com."
msgstr
""
#:
../../howto/pyporting.rst:361
msgid
""
"The project also provides code which you can integrate into your test suite "
"so that you will have a failing test when you no longer have dependencies "
"blocking you from using Python 3. This allows you to avoid having to "
"manually check your dependencies and to be notified quickly when you can "
"start running on Python 3."
msgstr
""
#:
../../howto/pyporting.rst:368
msgid
"Update your ``setup.py`` file to denote Python 3 compatibility"
msgstr
""
#:
../../howto/pyporting.rst:370
msgid
""
"Once your code works under Python 3, you should update the classifiers in "
"your ``setup.py`` to contain ``Programming Language :: Python :: 3`` and to "
"not specify sole Python 2 support. This will tell anyone using your code "
"that you support Python 2 **and** 3. Ideally you will also want to add "
"classifiers for each major/minor version of Python you now support."
msgstr
""
#:
../../howto/pyporting.rst:378
msgid
"Use continuous integration to stay compatible"
msgstr
""
#:
../../howto/pyporting.rst:380
msgid
""
"Once you are able to fully run under Python 3 you will want to make sure "
"your code always works under both Python 2 and 3. Probably the best tool for "
"running your tests under multiple Python interpreters is tox_. You can then "
"integrate tox with your continuous integration system so that you never "
"accidentally break Python 2 or 3 support."
msgstr
""
#:
../../howto/pyporting.rst:386
msgid
""
"You may also want to use the ``-bb`` flag with the Python 3 interpreter to "
"trigger an exception when you are comparing bytes to strings or bytes to an "
"int (the latter is available starting in Python 3.5). By default type-"
"differing comparisons simply return ``False``, but if you made a mistake in "
"your separation of text/binary data handling or indexing on bytes you "
"wouldn't easily find the mistake. This flag will raise an exception when "
"these kinds of comparisons occur, making the mistake much easier to track "
"down."
msgstr
""
#:
../../howto/pyporting.rst:396
msgid
"Consider using optional static type checking"
msgstr
""
#:
../../howto/pyporting.rst:398
msgid
""
"Another way to help port your code is to use a static type checker like "
"mypy_ or pytype_ on your code. These tools can be used to analyze your code "
"as if it's being run under Python 2, then you can run the tool a second time "
"as if your code is running under Python 3. By running a static type checker "
"twice like this you can discover if you're e.g. misusing binary data type in "
"one version of Python compared to another. If you add optional type hints to "
"your code you can also explicitly state whether your APIs use textual or "
"binary data, helping to make sure everything functions as expected in both "
"versions of Python."
msgstr
""
Back
|
FazBrowse Home
|
New Git URL