pyporting.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2021, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
# Translators:
# tomo, 2020
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.8\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2021-01-01 16:06+0000\n"
"PO-Revision-Date: 2020-05-30 11:54+0000\n"
"Last-Translator: tomo, 2020\n"
"Language-Team: Japanese (https://www.transifex.com/python-doc/teams/5390/"
"ja/)\n"
"Language: ja\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 "Porting Python 2 Code to Python 3"
msgstr "Python 2 から Python 3 への移植"

#: ../../howto/pyporting.rst:0
msgid "author"
msgstr "author"

#: ../../howto/pyporting.rst:7
msgid "Brett Cannon"
msgstr "Brett Cannon"

#: ../../howto/pyporting.rstNone
msgid "Abstract"
msgstr "概要"

#: ../../howto/pyporting.rst:11
msgid ""
"With Python 3 being the future of Python while Python 2 is still in active "
"use, it is good to have your project available for both major releases of "
"Python. This guide is meant to help you figure out how best to support both "
"Python 2 & 3 simultaneously."
msgstr ""
"現在は Python 3 が最新版の Python ですが、 Python 2 もまだ活発に利用されてい"
"ます。なのであなたのプロジェクトを両方のメジャーリリースにおいて動作可能にし"
"ておくのがよいでしょう。このガイドでは、 Python 2 と 3 を同時にサポートするに"
"はどうすればよいかを解説します。"

#: ../../howto/pyporting.rst:16
msgid ""
"If you are looking to port an extension module instead of pure Python code, "
"please see :ref:`cporting-howto`."
msgstr ""
"もしあなたが標準 Python ライブラリではなく拡張ライブラリでの移植手段を探して"
"いるならば :ref:`cporting-howto` を参照してください。"

#: ../../howto/pyporting.rst:19
msgid ""
"If you would like to read one core Python developer's take on why Python 3 "
"came into existence, you can read Nick Coghlan's `Python 3 Q & A`_ or Brett "
"Cannon's `Why Python 3 exists`_."
msgstr ""
"コア開発者の視点から Python3 が世に出てきたが理由を読みたい場合は、 Nick "
"Coghlan の `Python 3 Q & A`_ または `Brett Cannonによる `Why Python 3 "
"exists`_ がおすすめです。"

#: ../../howto/pyporting.rst:23
msgid ""
"For help with porting, you can email the python-porting_ mailing list with "
"questions."
msgstr ""
"移植にあたって助けが必要な場合は python-porting_ メーリングリストに質問を投稿"
"できます。"

#: ../../howto/pyporting.rst:27
msgid "The Short Explanation"
msgstr "短い説明"

#: ../../howto/pyporting.rst:29
msgid ""
"To make your project be single-source Python 2/3 compatible, the basic steps "
"are:"
msgstr ""
"あなたのプロジェクトを、単一ソースで Python 2/3 両方に対応させる基本的なス"
"テップは次のとおりです。"

#: ../../howto/pyporting.rst:32
msgid "Only worry about supporting Python 2.7"
msgstr "Python 2.7 だけをサポートすることに気を配ってください。"

#: ../../howto/pyporting.rst:33
msgid ""
"Make sure you have good test coverage (coverage.py_ can help; ``pip install "
"coverage``)"
msgstr ""
"良いテストカバレッジを確保してください。 (coverage.py_ が推奨されます; ``pip "
"install coverage``)"

#: ../../howto/pyporting.rst:35 ../../howto/pyporting.rst:116
msgid "Learn the differences between Python 2 & 3"
msgstr "Python 2 と 3 の違いを学びましょう。"

#: ../../howto/pyporting.rst:36
msgid ""
"Use Futurize_ (or Modernize_) to update your code (e.g. ``pip install "
"future``)"
msgstr ""
"Futurize_ (もしくは Modernize_) を使ってコードをアップデートしてください。 "
"(たとえば ``pip install future``)"

#: ../../howto/pyporting.rst:37
msgid ""
"Use Pylint_ to help make sure you don't regress on your Python 3 support "
"(``pip install pylint``)"
msgstr ""
"Python 3 サポートに関してデグレを防ぐために Pylint_ を使ってください。(``pip "
"install pylint``)"

#: ../../howto/pyporting.rst:39
msgid ""
"Use caniusepython3_ to find out which of your dependencies are blocking your "
"use of Python 3 (``pip install caniusepython3``)"
msgstr ""
"caniusepython3_ を使ってどの依存性があなたの Python 3 の使用を妨げているかを"
"検出できます。 (``pip install caniusepython3``)"

#: ../../howto/pyporting.rst:41
msgid ""
"Once your dependencies are no longer blocking you, use continuous "
"integration to make sure you stay compatible with Python 2 & 3 (tox_ can "
"help test against multiple versions of Python; ``pip install tox``)"
msgstr ""
"依存性があなたを邪魔しなくなってさえしまえば、Python 2 & 3 への互換性を保つの"
"を保障するために、継続的インテグレーションを使いましょう (tox_ が複数バージョ"
"ン Python 相手のテストの手助けをしてくれます; ``pip install tox``)"

#: ../../howto/pyporting.rst:44
msgid ""
"Consider using optional static type checking to make sure your type usage "
"works in both Python 2 & 3 (e.g. use mypy_ to check your typing under both "
"Python 2 & Python 3)."
msgstr ""
" Python 2 と 3 の両方で型の利用が正しく動作することを確認するために、任意の静"
"的型検査を使用することを検討してください。\n"
" (たとえば、python 2 と 3の両方で型を検査するのに mypy_ を利用します)"

#: ../../howto/pyporting.rst:50
msgid "Details"
msgstr "詳細"

#: ../../howto/pyporting.rst:52
msgid ""
"A key point about supporting Python 2 & 3 simultaneously is that you can "
"start **today**! Even if your dependencies are not supporting Python 3 yet "
"that does not mean you can't modernize your code **now** to support Python "
"3. Most changes required to support Python 3 lead to cleaner code using "
"newer practices even in Python 2 code."
msgstr ""
"Python 2 と 3 の同時サポートについてのキーポイントのひとつは、 **今日から** "
"開始出来る、というものです。たとえあなたが持っている依存物がまだ Python 3 を"
"サポートしていなくとも、それはあなたのコードを Python 3 サポートのために **今"
"すぐ** 現代化出来ないことを意味するのではありません。Python 3 サポートのため"
"に必要なほとんどの変更は、Python 2 コード内にあっても新しいプラクティスを伴う"
"明快なコードに導いてくれます。"

#: ../../howto/pyporting.rst:58
msgid ""
"Another key point is that modernizing your Python 2 code to also support "
"Python 3 is largely automated for you. While you might have to make some API "
"decisions thanks to Python 3 clarifying text data versus binary data, the "
"lower-level work is now mostly done for you and thus can at least benefit "
"from the automated changes immediately."
msgstr ""
"もうひとつのキーポイントは、あなたの Python 2 コードの Python 3 サポートを加"
"える現代化は、あなたのために大部分は自動化されているということです。Python 3 "
"によるテキストデータとバイナリデータの明確な区別のおかげで、あなたはいくつか"
"の API に決断をしなければならないかもしれない一方で、下位レベルの仕事は今やほ"
"とんど済んでいて、それゆえに最低でもその自動化された修正からの恩恵をすぐさま"
"受けることが出来ます。"

#: ../../howto/pyporting.rst:64
msgid ""
"Keep those key points in mind while you read on about the details of porting "
"your code to support Python 2 & 3 simultaneously."
msgstr ""
"Python 2 と 3 の同時サポートのために、あなたのコードを移植するための以降の詳"
"細を読む際には、これらのキーポイントを心に留めておいてください。"

#: ../../howto/pyporting.rst:69
msgid "Drop support for Python 2.6 and older"
msgstr "Python 2.6 とそれ以前のサポートを落とす"

#: ../../howto/pyporting.rst:71
msgid ""
"While you can make Python 2.5 work with Python 3, it is **much** easier if "
"you only have to work with Python 2.7. If dropping Python 2.5 is not an "
"option then the six_ project can help you support Python 2.5 & 3 "
"simultaneously (``pip install six``). Do realize, though, that nearly all "
"the projects listed in this HOWTO will not be available to you."
msgstr ""
"Python 2.5 と Python 3 で動くものは作れますが、Python 2.7 以上でのみ動くよう"
"にするほうが **とてつもなく** 簡単です。Python 2.5 サポートを落とせないなら"
"ば、 six_ プロジェクトがあなたの Python 2.5 と 3 同時サポートを手助けしてくれ"
"ます (``pip install six``)。だけれども悟ってください、この HOWTO でリストして"
"いるほとんど全てのプロジェクトはいずれあなたにとって入手不可能になるであろう"
"ことを。"

#: ../../howto/pyporting.rst:77
msgid ""
"If you are able to skip Python 2.5 and older, then the required changes to "
"your code should continue to look and feel like idiomatic Python code. 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, but otherwise "
"the overall transformation should not feel foreign to you."
msgstr ""
"Python 2.5 以下のサポートをスキップ出来るならば、あなたのコードに必要な変更"
"は Python の常套句のような外観と雰囲気を壊すべきではありません。最悪の場合あ"
"るインスタンス内のメソッドの代わりに関数を使う必要があったり、ビルトインを使"
"う代わりに関数をインポートする必要があるでしょうが、そうしないならば、全体通"
"した変換はあなたにとって異質に感じさせないものに違いありません。"

#: ../../howto/pyporting.rst:83
msgid ""
"But you should aim for only supporting Python 2.7. Python 2.6 is no longer "
"freely supported and thus is not receiving bugfixes. This means **you** will "
"have to work around any issues you come across with Python 2.6. There are "
"also some tools mentioned in this HOWTO which do not support Python 2.6 (e."
"g., Pylint_), and this will become more commonplace as time goes on. It will "
"simply be easier for you if you only support the versions of Python that you "
"have to support."
msgstr ""
"ですが、Python 2.6 以上と言わず Python 2.7 を目標にしてください。Python 2.6 "
"はもう積極的にはサポートされていません。これは **あなたが** Python 2.6 に関係"
"するあらゆる問題に取り組まなければならないことを意味します。この HOWTO で言及"
"しているいくつかのツールも Python 2.6 をサポートしていません (Pylint_ など)"
"し、時につれこのようなことはもっと当たり前になってくるでしょう。2.7 以上だけ"
"をサポートするということは、話をより簡単にしてくれます。"

#: ../../howto/pyporting.rst:92
msgid ""
"Make sure you specify the proper version support in your ``setup.py`` file"
msgstr ""
"あなたの ``setup.py`` ファイルに、相応しいサポートバージョンを明記することを"
"忘れないこと"

#: ../../howto/pyporting.rst:94
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 ""
"``setup.py`` ファイルに、あなたがサポートする Python バージョンを `Trove 分"
"類 <trove classifier>`_ で正しく明記すべきです。あなたのプロジェクトはまだ "
"Python 3 をサポートしていないので、少なくとも ``Programming Language :: "
"Python :: 2 :: Only`` と明記すべきです。理想的には Python のメジャー/マイナー"
"バージョンも指定すべきです。例えば ``Programming Language :: Python :: 2.7`` "
"のように。"

#: ../../howto/pyporting.rst:103
msgid "Have good test coverage"
msgstr "良いテストカバレッジを確保する。"

#: ../../howto/pyporting.rst:105
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 ""
"そうしたい一番古いバージョンの Python 2 をサポート出来ているならば、あなたの"
"テストスイートが十分な網羅性かを確認したいでしょう。あなたのコードをツールで"
"書き換えた後に現れるあらゆる失敗が実際にはツールのバグで、あなたのコードのバ"
"グではないとするのに十分なだけの確信をあなたのテストスイートに持ちたいなら"
"ば、良い経験則がこれです。目標とする数値で言えば、80% 以上の網羅性を目指して"
"みてください (そしてカバレッジ 90% を越えるのが難しかったとしても気に病む必要"
"はありません)。テストカバレッジの計測ツールを手持ちでないならば、 coverage."
"py_ がお奨めです。"

#: ../../howto/pyporting.rst:118
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. Typically the two best ways of "
"doing that is reading the :ref:`\"What's New\" <whatsnew-index>` doc for "
"each release of Python 3 and the `Porting to Python 3`_ book (which is free "
"online). There is also a handy `cheat sheet`_ from the Python-Future project."
msgstr ""

#: ../../howto/pyporting.rst:128
msgid "Update your code"
msgstr "コードをアップデートする。"

#: ../../howto/pyporting.rst:130
msgid ""
"Once you feel like you know what is different in Python 3 compared to Python "
"2, it's time to update your code! You have a choice between two tools in "
"porting your code automatically: Futurize_ and Modernize_. Which tool you "
"choose will depend on how much like Python 3 you want your code to be. "
"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. 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. As Python 3 is the "
"future, it might be best to consider Futurize to begin adjusting to any new "
"practices that Python 3 introduces which you are not accustomed to yet."
msgstr ""
"Python 2 と比較した Python 3 の違いがわかってきたら、いよいよあなたのコードを"
"更新するそのときです!\n"
"あなたのコードの移植の自動化ツールとしては 2 つの選択肢があります: Futurize_ "
"と Modernize_ です。\n"
"どちらのツールが良いかはあなたのコードをどのくらい Python 3 寄りに近付けたい"
"かによります。\n"
"Futurize_ は、例えば Python のメジャーバージョン間の意味論的な等価性を持つよ"
"うに Python 3 からバックポートされた ``bytes`` 型のように、Python 2 に取り込"
"まれた Python 3 のイディオムと慣例を積極的に使います。\n"
"他方 Modernize_ はより保守的で、互換性保持を six_ によって提供することで、 "
"Python 2/3 のサブセットであることを目標にします。\n"
"Python 3 は確実にやってくる未来なので、 Python 3 で導入された、まだ慣れていな"
"い新しい慣例に合わせ始めるためには Futurize を検討するのが最良かもしれませ"
"ん。"

#: ../../howto/pyporting.rst:142
msgid ""
"Regardless of which tool you choose, they will update your code to run under "
"Python 3 while staying compatible with the version of Python 2 you started "
"with. Depending on how conservative you want to be, you may want 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 ""
"どちらのツールを選ぶにせよ、それらはあなたのコードを、あなたが開始した "
"Python 2 バージョンへの互換性を保ったままで Python 3 で動作するように書き換え"
"ます。念には念を入れたければ、まずはテストスイートに対してツールを適用して、"
"変換が正しいものであることを確認するために差分を視覚的に点検しましょう。あな"
"たのテストスイートを変換して、テストがそれでもまだ期待通りにパスすることが検"
"証出来てしまえば、あなたのアプリケーションコードを、全ての失敗するテストは変"
"換の失敗を意味することがわかる状態で変換出来ます。"

#: ../../howto/pyporting.rst:150
msgid ""
"Unfortunately the tools can't automate everything to make your code work "
"under Python 3 and so there are a handful of things you will need to update "
"manually to get full Python 3 support (which of these steps are necessary "
"vary between the tools). Read the documentation for the tool you choose to "
"use to see what it fixes by default and what it can do optionally to know "
"what will (not) be fixed for you and what you may have to fix on your own (e."
"g. using ``io.open()`` over the built-in ``open()`` function is off by "
"default in Modernize). Luckily, though, there are only a couple of things to "
"watch out for which can be considered large issues that may be hard to debug "
"if not watched for."
msgstr ""
"悪い報せ。これらツールは Python 3 であなたのコードを動作させるために、全ての"
"自動化が出来ているわけではありませんので、Python 3 のフルサポートのためには手"
"動で更新しなければならないわずかばかりの事項があります(必要な手作業はツールに"
"よって違います)。選んだツールのドキュメントを読んで、デフォルトでは何が修正さ"
"れて、選択的に何を修正する(しない)を選べるのか、そして何を自身で修正する必要"
"があるのかを理解してください (例えばビルトインの ``open()`` ではなく ``io."
"open()`` を使う修正は、Modernize ではデフォルトでオフです)。良い報せ。です"
"が、注意深くみなければデバッグを困難にするような大きな問題として考えられる、"
"警戒するようなことは、2 つだけです。"

#: ../../howto/pyporting.rst:162
msgid "Division"
msgstr "除算"

#: ../../howto/pyporting.rst:164
msgid ""
"In Python 3, ``5 / 2 == 2.5`` and not ``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 ""
"Python 3 では、 ``5 / 2 == 2.5`` であり ``2`` ではありません; ``int`` 同士の"
"全ての除算は ``float`` の結果になります。この変更については実際のところ、 "
"2002 年にリリースされた Python 2.2 から計画されました。そのようなわけで、 ``/"
"``, ``//`` 演算子を使うどんなファイルにも ``from __future__ import "
"division`` を追加するか、あるいはインタプリタを ``-Q`` フラグとともに起動する"
"ことが推奨されていました。これをまだやったことがなければ、コードをくまなく調"
"べて対象箇所を見つけ、 2 つのことをします:"

#: ../../howto/pyporting.rst:172
msgid "Add ``from __future__ import division`` to your files"
msgstr "``from __future__ import division`` をあなたのファイルに追加します"

#: ../../howto/pyporting.rst:173
msgid ""
"Update any division operator as necessary to either use ``//`` to use floor "
"division or continue using ``/`` and expect a float"
msgstr ""
"floor division (訳注: float での結果に :func:`~math.floor` 適用したのと同じ振"
"る舞いをする除算) に対しては ``//`` を、浮動小数点数の演算を期待する箇所では"
"そのまま ``/`` を使うように、除算演算子を必要に応じて変更します。"

#: ../../howto/pyporting.rst:176
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 ""
"オブジェクトが自身の ``__truediv__`` メソッドを持っているのに "
"``__floordiv__`` を持っていない場合に壊れてしまうので、 ``/`` を ``//`` に単"
"純に自動的に変換することは出来ません(例えばユーザ定義クラスで ``/`` を何かの"
"演算に使っていて、 ``//`` は同じ事をしないか何もしないような場合)。"

#: ../../howto/pyporting.rst:183
msgid "Text versus binary data"
msgstr "テキスト対バイナリデータ"

#: ../../howto/pyporting.rst:185
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 ""
"Python 2 では ``str`` 型をテキストとバイナリデータのどちらにも使うことが出来"
"ていました。不幸なことにこれは、2 つの異なる概念を重ね合わせていて、両方の種"
"類のデータに対して、時々動作して時々はそうではない、といった傷つきやすいコー"
"ドに繋がりやすいものでした。人々が特定の一つの型の代わりに ``str`` を受け付け"
"る何かが、それが許容するのはテキストなのかバイナリデータなのかを名言しないと"
"きの、悩ましい API を生み出してしまう要因でもありました。これはとりわけマルチ"
"リンガルをサポートするための状況を、テキストデータをサポートしていると主張し"
"ているのに明示的に ``unicode`` をサポートすることに注意を払わない API、という"
"形で複雑にしていました。"

#: ../../howto/pyporting.rst:194
msgid ""
"To make the distinction between text and binary data clearer and more "
"pronounced, Python 3 did what most languages created in the age of the "
"internet have done and made text and binary data distinct types that cannot "
"blindly be mixed together (Python predates widespread access to the "
"internet). 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 ""
"テキストとバイナリデータの区別をより明快に、よりはっきり宣言するために、 "
"Python 3 はインターネット時代に作られたほとんどの言語がしたこと、すなわちテキ"
"ストとバイナリデータを区別できる別々の型とし、無分別にお互い混ぜこぜには出来"
"ないようにしました (Python はインターネットが広く普及する前からありました)。"
"テキストのみを取り扱うコード、バイナリデータのみを扱うコードのいずれにとって"
"も、この分離は問題を引き起こしません。ですが両方を処理するコードにとっては、"
"それはテキストとバイナリデータの比較をする際に新たな注意点が増えたことを意味"
"していて、これが完全には移行の自動化が出来ない理由なのです。"

#: ../../howto/pyporting.rst:203
msgid ""
"To start, you will need to 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 & "
"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). The following table lists the **unique** methods of each data "
"type across Python 2 & 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:220
msgid "**Text data**"
msgstr "**テキストデータ**"

#: ../../howto/pyporting.rst:220
msgid "**Binary data**"
msgstr "**バイナリデータ**"

#: ../../howto/pyporting.rst:222
msgid "\\"
msgstr "\\"

#: ../../howto/pyporting.rst:222
msgid "decode"
msgstr "decode"

#: ../../howto/pyporting.rst:224
msgid "encode"
msgstr "encode"

#: ../../howto/pyporting.rst:226
msgid "format"
msgstr "format"

#: ../../howto/pyporting.rst:228
msgid "isdecimal"
msgstr "isdecimal"

#: ../../howto/pyporting.rst:230
msgid "isnumeric"
msgstr "isnumeric"

#: ../../howto/pyporting.rst:233
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:240
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:247
msgid ""
"As part of this dichotomy you also need to be careful about opening files. "
"Unless you have been working on Windows, there is a chance 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:261
msgid ""
"The constructors of both ``str`` and ``bytes`` have different semantics for "
"the same arguments between Python 2 & 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 ""
"``str`` と ``bytes`` の両方のコンストラクタは同じ引数を与えても Python 2 と "
"3 で異なる意味を持ちます。Python 2 で ``bytes`` に数値を与えると、整数の文字"
"列表現を生成します: ``bytes(3) == '3'`` 。ですが Python 3 では、 ``bytes`` に"
"整数を与えると、整数値で与えたぶんの長さの、null バイトで埋められたバイト列を"
"生成します: ``bytes(3) == b'\\x00\\x00\\x00'`` 。似たような話はバイト列オブ"
"ジェクトを ``str`` に与える場合にも起こります。Python 2 ではバイト列が渡した"
"ものがそのまま戻ってきます: ``str(b'3') == b'3'`` 。対して Python 3 では、バ"
"イト列オブジェクトの文字列表現になって返ってきます: ``str(b'3') == "
"\"b'3'\"`` 。"

#: ../../howto/pyporting.rst:271
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 ""
"最後に、バイナリデータに対するインデクシングには取り扱いに注意が必要です(スラ"
"イシングには特別な取り扱いは **不要** です)。Python 2 では、 ``b'123'[1] == "
"b'2'`` ですが、Python 3 では ``b'123'[1] == 50`` です。バイナリデータはただの"
"バイナリ数値の羅列ですから、Python 3 では指示した位置のバイトの整数値を返しま"
"す。ですが Python 2 の場合、 ``bytes == str`` であるために、インデクシングは "
"bytes の要素一つを取り出すスライスとして振舞います。 six_ プロジェクトには "
"``six.indexbytes()`` と名付けられた関数があって、これは Python 3 がそうするよ"
"うに整数値を返します: ``six.indexbytes(b'123', 1)`` 。"

#: ../../howto/pyporting.rst:280
msgid "To summarize:"
msgstr "まとめると、以下のようになります:"

#: ../../howto/pyporting.rst:282
msgid "Decide which of your APIs take text and which take binary data"
msgstr ""
"どの API がテキストデータを受付け、どの API がバイナリデータを受け付けるのか"
"を決めてください。"

#: ../../howto/pyporting.rst:283
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 ""
"あなたのコードが Python 2 で確実に、テキストで動くものは ``unicode`` でも動く"
"ように、バイナリデータで動くものは ``bytes`` でも動くようにしてください(どの"
"メソッドがそれぞれの型で使えないのかを示した上記テーブルをみてください)。"

#: ../../howto/pyporting.rst:286
msgid ""
"Mark all binary literals with a ``b`` prefix, textual literals with a ``u`` "
"prefix"
msgstr ""

#: ../../howto/pyporting.rst:288
msgid ""
"Decode binary data to text as soon as possible, encode text as binary data "
"as late as possible"
msgstr ""
"バイナリデータをテキストにデコードするのは出来るだけ早く、テキストデータをバ"
"イナリデータにエンコードするのは出来るだけ遅く。"

#: ../../howto/pyporting.rst:290
msgid ""
"Open files using :func:`io.open` and make sure to specify the ``b`` mode "
"when appropriate"
msgstr ""
"ファイルは :func:`io.open` を使って開き、そうすべきときには必ず ``b`` モード"
"を指定してください。"

#: ../../howto/pyporting.rst:292
msgid "Be careful when indexing into binary data"
msgstr ""

#: ../../howto/pyporting.rst:296
msgid "Use feature detection instead of version detection"
msgstr "バージョン検出ではなく機能検出を使う"

#: ../../howto/pyporting.rst:298
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:305
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:317
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 ""
"このコードの問題は、 Python 4 が出たときに起きます。\n"
"Python 3 ではなく Python 2 を例外的なケースとして扱い、将来の Python のバー"
"ジョンは Python 2 よりも Python 3 と互換性があると仮定する方が良さそうです::"

#: ../../howto/pyporting.rst:329
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 ""
"ところが、最適解はバージョン検出を一切せずに、代わりに機能検出に頼ることで"
"す。\n"
"機能検出を使うことで、バージョン検出が上手く行かなくなる潜在的な問題を避けら"
"れ、機能の互換性を保つ助けになります::"

#: ../../howto/pyporting.rst:340
msgid "Prevent compatibility regressions"
msgstr "互換性オプション"

#: ../../howto/pyporting.rst:342
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 ""
"あなたのコードを完全に Python 3 互換に変換できたら、今度は Python 3 での動作"
"が退化したり止まってしまうことがないようにしたいでしょう。この時点ではまだ実"
"際に Python 3 で動作させられない阻害要因となる依存物を持っている場合に、これ"
"は特に当てはまります。"

#: ../../howto/pyporting.rst:347
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:354
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 ""
"実行時に種々の互換性問題を警告してもらうために Python 2 を ``-3`` フラグ付き"
"で実行することも出来ます。 ``-Werror`` にすれば警告ではなくエラーになるので、"
"うっかり警告を見逃すことがなくなります。"

#: ../../howto/pyporting.rst:359
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 ""
"Pylint_ プロジェクトとその ``--py3k`` フラグを使って、Python 3 互換性から乖離"
"し始めている際の警告を受け取ることも出来ます。これにより、 Modernize_ や "
"Futurize_ を普通に実行してみて互換性を失っていないかを確認する、という必要が"
"なくなります。この場合 Python 2.7 と Python 3.4 以上だけのサポートにすること"
"が必要になります。それが Pylint がサポートする最小の Python バージョンだから"
"です。"

#: ../../howto/pyporting.rst:368
msgid "Check which dependencies block your transition"
msgstr "どの依存性があなたの移行を阻んでいるのかチェックする"

#: ../../howto/pyporting.rst:370
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:377
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 ""
"このプロジェクトは同時にあなたのテストスイートに組み込むことが出来る、もう "
"Python 3 使用を妨げる依存物がなくなった時点で失敗するテストコードも提供してい"
"ます。これにより、Python 3 での動作を開始する際に、依存物を手動でチェックする"
"ことなく即座に気付くことが出来ます。"

#: ../../howto/pyporting.rst:384
msgid "Update your ``setup.py`` file to denote Python 3 compatibility"
msgstr "あなたの ``setup.py`` ファイルを更新して Python 3 互換を謳う"

#: ../../howto/pyporting.rst:386
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 ""
"あなたのコードが Python 3 で動作するようになったら、 ``setup.py`` の "
"classifiers を ``Programming Language :: Python :: 3`` を含めるように更新し"
"て、Python 2 だけのサポートではないことを明記すべきです。これによって、あなた"
"のコードを利用する人はあなたが Python 2 *と* 3 をサポートすることを知ることが"
"出来ます。理想的には、今サポートしている Python のメジャー/マイナーバージョン"
"も classifiers に追加したいでしょう。"

#: ../../howto/pyporting.rst:394
msgid "Use continuous integration to stay compatible"
msgstr "継続的インテグレーションを使って互換性を維持し続ける。"

#: ../../howto/pyporting.rst:396
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 & 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 ""
"Python 3 で完全に動作出来てしまったら、あなたのコードが Python 2、3 の両方で"
"いつでも動くことを保障したいでしょう。おそらく、複数バージョンの Python イン"
"タプリタでテストを実施するのに最良のツールは、 tox_ です。継続的インテグレー"
"ションシステムに tox を統合して、うっかり Python 2 か 3 のサポートを壊してし"
"まわないようにすることが出来ます。"

#: ../../howto/pyporting.rst:402
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 ""
"Python 3 インタプリタで ``-bb`` フラグを使って、 bytes と string 、もしくは "
"bytes と int を比較したときに例外を引き起こしたいと思うでしょう (後者は "
"Python 3.5 から使えます)。\n"
"デフォルトでは型の異なる比較は単純に ``False`` を返しますが、テキスト/バイナ"
"リデータ処理の分離を誤ったり、バイト列への添え字操作を誤ると、簡単には間違い"
"を見つけられません。\n"
"このフラグはそれが起こった場合に例外を起こすことで、その種のケースを追跡する"
"助けになります。"

#: ../../howto/pyporting.rst:410
msgid ""
"And that's mostly it! At this point your code base is compatible with both "
"Python 2 and 3 simultaneously. Your testing will also be set up so that you "
"don't accidentally break Python 2 or 3 compatibility regardless of which "
"version you typically run your tests under while developing."
msgstr ""
"そしてこれでほぼ全てです! 今の時点であなたのコードベースは Python 2 と 3 の両"
"方に対して同時に互換です。あなたのテストは、開発時点ではどちらのバージョンで"
"テストすることが多いのかによらずに、誤って Python 2 か 3 の互換性を破壊してし"
"まわないようにも組み立てられるでしょう。"

#: ../../howto/pyporting.rst:417
msgid "Consider using optional static type checking"
msgstr ""

#: ../../howto/pyporting.rst:419
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 ""