2.5.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2025, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
# Translators:
# Osamu NAKAMURA, 2021
# mollinaca, 2021
# yaakiyu, 2022
# Arihiro TAKASE, 2023
# tomo, 2023
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.13\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2025-02-07 14:17+0000\n"
"PO-Revision-Date: 2021-06-28 01:51+0000\n"
"Last-Translator: tomo, 2023\n"
"Language-Team: Japanese (https://app.transifex.com/python-doc/teams/5390/"
"ja/)\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Language: ja\n"
"Plural-Forms: nplurals=1; plural=0;\n"

#: ../../whatsnew/2.5.rst:3
msgid "What's New in Python 2.5"
msgstr "What's New in Python 2.5"

#: ../../whatsnew/2.5.rst:0
msgid "Author"
msgstr "著者"

#: ../../whatsnew/2.5.rst:5
msgid "A.M. Kuchling"
msgstr "A.M. Kuchling"

#: ../../whatsnew/2.5.rst:12
msgid ""
"This article explains the new features in Python 2.5.  The final release of "
"Python 2.5 is scheduled for August 2006; :pep:`356` describes the planned "
"release schedule.  Python 2.5 was released on September 19, 2006."
msgstr ""

#: ../../whatsnew/2.5.rst:16
msgid ""
"The changes in Python 2.5 are an interesting mix of language and library "
"improvements. The library enhancements will be more important to Python's "
"user community, I think, because several widely useful packages were added.  "
"New modules include ElementTree for XML processing (:mod:`xml.etree`), the "
"SQLite database module (:mod:`sqlite`), and the :mod:`ctypes` module for "
"calling C functions."
msgstr ""

#: ../../whatsnew/2.5.rst:23
msgid ""
"The language changes are of middling significance.  Some pleasant new "
"features were added, but most of them aren't features that you'll use every "
"day. Conditional expressions were finally added to the language using a "
"novel syntax; see section :ref:`pep-308`.  The new ':keyword:`with`' "
"statement will make writing cleanup code easier (section :ref:`pep-343`).  "
"Values can now be passed into generators (section :ref:`pep-342`).  Imports "
"are now visible as either absolute or relative (section :ref:`pep-328`).  "
"Some corner cases of exception handling are handled better (section :ref:"
"`pep-341`).  All these improvements are worthwhile, but they're improvements "
"to one specific language feature or another; none of them are broad "
"modifications to Python's semantics."
msgstr ""
"言語の変更の意義は、中程度のものです。いくつかの心地よい機能が入りましたが、"
"そのほとんどの機能は毎日使うというものでもありません。条件式(conditional "
"expressions)がついに言語に追加されました。ちょっと変わった文法です。 :ref:"
"`pep-308` のセクションを参照してください。新しい ':keyword:`with`' 文は後始末"
"のコードを書くのを簡単にします(:ref:`pep-343` セクション)。ジェネレータに値を"
"返すことが出来るようになりました(:ref:`pep-342` セクション)。インポートが、絶"
"対パス、相対パスのどちらかで可視に出来るようになりました(:ref:`pep-328` セク"
"ション)。例外ハンドリングのいくつかの境界のケースで、より良いハンドリングを行"
"えるようになりました(:ref:`pep-341` セクション)。これらのどの改善も価値が高い"
"ですが、それらは言語機能を限定的に改善するものであって、いずれも Python のセ"
"マンティクスを広範に修正するものではありません。"

#: ../../whatsnew/2.5.rst:34
msgid ""
"As well as the language and library additions, other improvements and "
"bugfixes were made throughout the source tree.  A search through the SVN "
"change logs finds there were 353 patches applied and 458 bugs fixed between "
"Python 2.4 and 2.5.  (Both figures are likely to be underestimates.)"
msgstr ""
"言語とライブラリの追加と同様に、ほかの改善とバグフィックスもソースツリー全体"
"に渡っています。SVN 変更ログを検索すると、Python 2.4 から 2.5 の間で適用され"
"たパッチは 353、フィックスされたバグは 458 ありました(ともに少なく見積もって"
"です)。"

#: ../../whatsnew/2.5.rst:39
msgid ""
"This article doesn't try to be a complete specification of the new features; "
"instead changes are briefly introduced using helpful examples.  For full "
"details, you should always refer to the documentation for Python 2.5 at "
"https://docs.python.org. If you want to understand the complete "
"implementation and design rationale, refer to the PEP for a particular new "
"feature."
msgstr ""
"このドキュメントは新機能の完全な詳細を提供するのではなくて、変更について、役"
"に立つ実例を使った簡易な概要を提供することを目的にしています。完全な詳細が知"
"りたければ常に、 https://docs.python.org の Python 2.6 のドキュメントを参照す"
"べきです。設計と実装の根拠を理解したい場合は、新機能に関する PEP を参照してく"
"ださい。可能な限り、 \"What’s New in Python\" は各変更の bug や patch に対し"
"てリンクしています。"

#: ../../whatsnew/2.5.rst:45
msgid ""
"Comments, suggestions, and error reports for this document are welcome; "
"please e-mail them to the author or open a bug in the Python bug tracker."
msgstr ""
"このドキュメントについてのコメント、提案と誤りの報告は歓迎です。著者に電子"
"メールを送るか、または Python バグトラッカーにバグをあげてください。"

#: ../../whatsnew/2.5.rst:54
msgid "PEP 308: Conditional Expressions"
msgstr "PEP 308: 条件式 (Conditional Expressions)"

#: ../../whatsnew/2.5.rst:56
msgid ""
"For a long time, people have been requesting a way to write conditional "
"expressions, which are expressions that return value A or value B depending "
"on whether a Boolean value is true or false.  A conditional expression lets "
"you write a single assignment statement that has the same effect as the "
"following::"
msgstr ""
"もう長いことずっと、人々は条件式を書くための手段を要望し続けてきました。それ"
"は Boolean 値が真か偽かによって値 A または B を返す式です。条件式により以下と"
"同じ効果を持つ単一行代入式を書くことが出来ます::"

#: ../../whatsnew/2.5.rst:61
msgid ""
"if condition:\n"
"    x = true_value\n"
"else:\n"
"    x = false_value"
msgstr ""

#: ../../whatsnew/2.5.rst:66
msgid ""
"There have been endless tedious discussions of syntax on both python-dev and "
"comp.lang.python.  A vote was even held that found the majority of voters "
"wanted conditional expressions in some form, but there was no syntax that "
"was preferred by a clear majority. Candidates included C's ``cond ? true_v : "
"false_v``, ``if cond then true_v else false_v``, and 16 other variations."
msgstr ""
"構文についての退屈で終わりのない議論が python-dev と comp.lang.python の両方"
"で続いてきました。投票では、大半は何らかの形で条件式を望んでいることを示して"
"いましたが、明らかな過半数によって支持される構文はありませんでした。候補には "
"C の ``cond ? true_v : false_v`` や ``if cond then true_v else false_v`` を含"
"む、ほか 16 のバリエーションがありました。"

#: ../../whatsnew/2.5.rst:72
msgid "Guido van Rossum eventually chose a surprising syntax::"
msgstr "Guido van Rossum は結果として意外な構文を選択しました::"

#: ../../whatsnew/2.5.rst:74
msgid "x = true_value if condition else false_value"
msgstr ""

#: ../../whatsnew/2.5.rst:76
msgid ""
"Evaluation is still lazy as in existing Boolean expressions, so the order of "
"evaluation jumps around a bit.  The *condition* expression in the middle is "
"evaluated first, and the *true_value* expression is evaluated only if the "
"condition was true.  Similarly, the *false_value* expression is only "
"evaluated when the condition is false."
msgstr ""
"評価はこれでも既存の Boolean 式のように遅延的であり、評価順は少々前後します。"
"真ん中の *condition* はまさに最初に評価されるのであって、 *true_value* 式はそ"
"の *condition* が真の場合にのみ評価されます。同じように *false_value* は "
"*condition* が偽の場合にのみ評価されるのです。"

#: ../../whatsnew/2.5.rst:82
msgid ""
"This syntax may seem strange and backwards; why does the condition go in the "
"*middle* of the expression, and not in the front as in C's ``c ? x : y``?  "
"The decision was checked by applying the new syntax to the modules in the "
"standard library and seeing how the resulting code read.  In many cases "
"where a conditional expression is used, one value seems to be the 'common "
"case' and one value is an 'exceptional case', used only on rarer occasions "
"when the condition isn't met.  The conditional syntax makes this pattern a "
"bit more obvious::"
msgstr ""
"この構文は奇妙で退行しているようにも思えます; どうして condition が *真ん中* "
"にあって C の ``c ? x : y`` のように前にないのでしょう? この決定は、標準ライ"
"ブラリ内のモジュールにその新構文を適用し、結果のコードをどう読むかを見ること"
"でチェックされました。条件式が使われる多くの場合で、一つの値はどうやら「一般"
"の場合」で一つの値は「例外的な場合」のようで、条件を満たさないことが稀な場合"
"にのみ使われていました。条件の構文はこのパターンで少しばかり明快さを増しま"
"す::"

#: ../../whatsnew/2.5.rst:90
msgid "contents = ((doc + '\\n') if doc else '')"
msgstr ""

#: ../../whatsnew/2.5.rst:92
msgid ""
"I read the above statement as meaning \"here *contents* is  usually assigned "
"a value of ``doc+'\\n'``; sometimes  *doc* is empty, in which special case "
"an empty string is returned.\"   I doubt I will use conditional expressions "
"very often where there  isn't a clear common and uncommon case."
msgstr ""
"私には上記ステートメントはこう読めます。「 *contents* は普通は ``doc+'\\n'`` "
"の値に代入される。ただし時々 *doc* が空になる。その特別な場合には空の値が代入"
"されるのだ」。私は普通と普通でないのが明らかでない場合に頻繁に条件式を使うと"
"は思いません。"

#: ../../whatsnew/2.5.rst:97
msgid ""
"There was some discussion of whether the language should require surrounding "
"conditional expressions with parentheses.  The decision was made to *not* "
"require parentheses in the Python language's grammar, but as a matter of "
"style I think you should always use them. Consider these two statements::"
msgstr ""
"言語が条件式に括弧を必要とすべきかどうかに関していくつか議論がありました。決"
"定は Python 言語文法として括弧は *必要ない* とされましたが、スタイルの問題と"
"しては私は常に括弧を付けるべきと思います。以下 2 つの例を考えてみてください::"

#: ../../whatsnew/2.5.rst:102
msgid ""
"# First version -- no parens\n"
"level = 1 if logging else 0\n"
"\n"
"# Second version -- with parens\n"
"level = (1 if logging else 0)"
msgstr ""

#: ../../whatsnew/2.5.rst:108
msgid ""
"In the first version, I think a reader's eye might group the statement into "
"'level = 1', 'if logging', 'else 0', and think that the condition decides "
"whether the assignment to *level* is performed.  The second version reads "
"better, in my opinion, because it makes it clear that the assignment is "
"always performed and the choice is being made between two values."
msgstr ""
"最初の版の場合、私は読者の目はおそらくステートメントを「level = 1」「if "
"logging」「else 0」にグループ化すると思います。そして condition は *level* へ"
"の代入が行われるのかどうかを決めるのだ、と考えるであろうと。後者の版は読みや"
"すいです、少なくとも私の意見では。代入はいつでも行われることも、選択が 2 つの"
"値の間で起こることもはっきりしますから。"

#: ../../whatsnew/2.5.rst:114
msgid ""
"Another reason for including the brackets: a few odd combinations of list "
"comprehensions and lambdas could look like incorrect conditional "
"expressions. See :pep:`308` for some examples.  If you put parentheses "
"around your conditional expressions, you won't run into this case."
msgstr ""
"括弧を含めるもう一つの理由があります: 少し奇妙なリスト内包とラムダの組合せ"
"が、不完全な条件式になることがあります。 :pep:`308` にいくつかの例があるので"
"見てください。条件式の周りをいつでも括弧で囲むなら、このケースにぶち当たるこ"
"ともありません。"

#: ../../whatsnew/2.5.rst:122
msgid ":pep:`308` - Conditional Expressions"
msgstr ":pep:`308` - 条件式 (Conditional Expressions)"

#: ../../whatsnew/2.5.rst:123
msgid ""
"PEP written by Guido van Rossum and Raymond D. Hettinger; implemented by "
"Thomas Wouters."
msgstr "PEP 著 Guido van Rossum と Raymond D. Hettinger; 実装 Thomas Wouters."

#: ../../whatsnew/2.5.rst:132
msgid "PEP 309: Partial Function Application"
msgstr "PEP 309: 関数の部分適用"

#: ../../whatsnew/2.5.rst:134
msgid ""
"The :mod:`functools` module is intended to contain tools for functional-"
"style programming."
msgstr ""
":mod:`functools` モジュールは、関数型スタイルのプログラミングのためのツールを"
"含むことを意図したものです。"

#: ../../whatsnew/2.5.rst:137
msgid ""
"One useful tool in this module is the :func:`partial` function. For programs "
"written in a functional style, you'll sometimes want to construct variants "
"of existing functions that have some of the parameters filled in.  Consider "
"a Python function ``f(a, b, c)``; you could create a new function ``g(b, "
"c)`` that was equivalent to ``f(1, b, c)``.  This is called \"partial "
"function application\"."
msgstr ""
"このモジュールには一つの有用なツールとして、 :func:`partial` 関数があります。"
"関数型スタイルでプログラムを書くのに、あなたはときおり、いくつかのパラメータ"
"を持つ関数に一部パラメータを埋めたものを作りたくなります。Python 関数 ``f(a, "
"b, c)`` を考えてみましょう; ``f(1, b, c)`` と等価な ``g(b, c)`` を作れたら、"
"と思うわけです。これは「関数の部分適用」と呼ばれています。"

#: ../../whatsnew/2.5.rst:144
msgid ""
":func:`partial` takes the arguments ``(function, arg1, arg2, ... "
"kwarg1=value1, kwarg2=value2)``.  The resulting object is callable, so you "
"can just call it to invoke *function* with the filled-in arguments."
msgstr ""
":func:`partial` は ``(function, arg1, arg2, ... kwarg1=value1, "
"kwarg2=value2)`` という引数を取ります。できあがったオブジェクトは呼び出し可能"
"オブジェクトですので、それを呼べば、引数の埋まった *function* を実行したのと"
"同じことになります。"

#: ../../whatsnew/2.5.rst:148
msgid "Here's a small but realistic example::"
msgstr "以下にあるのは、小さいけれども現実的な一つの例です::"

#: ../../whatsnew/2.5.rst:150
msgid ""
"import functools\n"
"\n"
"def log (message, subsystem):\n"
"    \"Write the contents of 'message' to the specified subsystem.\"\n"
"    print '%s: %s' % (subsystem, message)\n"
"    ...\n"
"\n"
"server_log = functools.partial(log, subsystem='server')\n"
"server_log('Unable to open socket')"
msgstr ""

#: ../../whatsnew/2.5.rst:160
msgid ""
"Here's another example, from a program that uses PyGTK.  Here a context-"
"sensitive pop-up menu is being constructed dynamically.  The callback "
"provided for the menu option is a partially applied version of the :meth:"
"`open_item` method, where the first argument has been provided. ::"
msgstr ""
"もうひとつ、PyGTK を使うプログラムからの例をみてみましょう。いま、「コンテキ"
"スト依存」のポップアップメニューを動的に構築しようとしています。そのメニュー"
"オプションから提供されるコールバックは、 :meth:`open_item` メソッドの部分適用"
"版で、その最初の引数が適用済みです::"

#: ../../whatsnew/2.5.rst:165
msgid ""
"...\n"
"class Application:\n"
"    def open_item(self, path):\n"
"       ...\n"
"    def init (self):\n"
"        open_func = functools.partial(self.open_item, item_path)\n"
"        popup_menu.append( (\"Open\", open_func, 1) )"
msgstr ""

#: ../../whatsnew/2.5.rst:173
msgid ""
"Another function in the :mod:`functools` module is the "
"``update_wrapper(wrapper, wrapped)`` function that helps you write well-"
"behaved decorators.  :func:`update_wrapper` copies the name, module, and "
"docstring attribute to a wrapper function so that tracebacks inside the "
"wrapped function are easier to understand.  For example, you might write::"
msgstr ""
":mod:`functools` モジュールのもう一つの関数は ``update_wrapper(wrapper, "
"wrapped)`` で、より良く振舞うデコレータを書くのに役立ちます。 :func:"
"`update_wrapper` は包まれるほうの名前、モジュール、ドキュメンテーション文字列"
"属性をラッパー関数にコピーすることで、トレースバックを理解しやすくします。た"
"とえばこう書けます::"

#: ../../whatsnew/2.5.rst:179
msgid ""
"def my_decorator(f):\n"
"    def wrapper(*args, **kwds):\n"
"        print 'Calling decorated function'\n"
"        return f(*args, **kwds)\n"
"    functools.update_wrapper(wrapper, f)\n"
"    return wrapper"
msgstr ""

#: ../../whatsnew/2.5.rst:186
msgid ""
":func:`wraps` is a decorator that can be used inside your own decorators to "
"copy the wrapped function's information.  An alternate  version of the "
"previous example would be::"
msgstr ""
":func:`wraps` は、ラップされる関数についての情報をコピーするために、あなた自"
"身のデコレータ内で使えるデコレータです。先の例はこのようにも書けます::"

#: ../../whatsnew/2.5.rst:190
msgid ""
"def my_decorator(f):\n"
"    @functools.wraps(f)\n"
"    def wrapper(*args, **kwds):\n"
"        print 'Calling decorated function'\n"
"        return f(*args, **kwds)\n"
"    return wrapper"
msgstr ""

#: ../../whatsnew/2.5.rst:200
msgid ":pep:`309` - Partial Function Application"
msgstr ":pep:`309` - 関数の部分適用"

#: ../../whatsnew/2.5.rst:201
msgid ""
"PEP proposed and written by Peter Harris; implemented by Hye-Shik Chang and "
"Nick Coghlan, with adaptations by Raymond Hettinger."
msgstr ""
"PEP の提案と著:  Peter Harris; 実装: Hye-Shik Chang と Nick Coghlan, また、適"
"応物が Raymond Hettinger により。 (---訳注: この PEP のタイトルに違和感を憶え"
"る人は多いと思います。functools のテリトリが「関数型スタイルのサポート」にあ"
"るのに。部分引数サポートのためのパッチが最終的に関数型スタイルに行き着いた "
"(正確には、「partial のような高階関数を置く場所として functools という場所を"
"使いましょう、partial から始めましょう」というのが提案の趣旨)、という経緯がこ"
"のタイトルに反映しています。---)"

#: ../../whatsnew/2.5.rst:210
msgid "PEP 314: Metadata for Python Software Packages v1.1"
msgstr "PEP 314: Metadata for Python Software Packages v1.1"

#: ../../whatsnew/2.5.rst:212
msgid ""
"Some simple dependency support was added to Distutils.  The :func:`setup` "
"function now has ``requires``, ``provides``, and ``obsoletes`` keyword "
"parameters.  When you build a source distribution using the ``sdist`` "
"command, the dependency information will be recorded in the :file:`PKG-INFO` "
"file."
msgstr ""
"Distutils にいくつかの単純な依存性解決サポートが追加されました。 :func:"
"`setup` 関数に ``requires``, ``provides``,  ``obsoletes`` キーワードパラメー"
"タが追加されています。 ``sdist`` コマンドでソース配布物をビルドする際に、依存"
"性についての情報が :file:`PKG-INFO` ファイルに記録されます。"

#: ../../whatsnew/2.5.rst:217
msgid ""
"Another new keyword parameter is ``download_url``, which should be set to a "
"URL for the package's source code.  This means it's now possible to look up "
"an entry in the package index, determine the dependencies for a package, and "
"download the required packages. ::"
msgstr ""
"もう一つ追加されたキーワードパラメータ ``download_url`` は、パッケージのソー"
"スコードの URL をセットします。これによりパッケージインデクス内のエントリを探"
"し出すことが出来、パッケージの依存性を決めることが出来、必要パッケージをダウ"
"ンロード出来ます::"

#: ../../whatsnew/2.5.rst:222
msgid ""
"VERSION = '1.0'\n"
"setup(name='PyPackage',\n"
"      version=VERSION,\n"
"      requires=['numarray', 'zlib (>=1.1.4)'],\n"
"      obsoletes=['OldPackage']\n"
"      download_url=('http://www.example.com/pypackage/dist/pkg-%s.tar.gz'\n"
"                    % VERSION),\n"
"     )"
msgstr ""

#: ../../whatsnew/2.5.rst:231
msgid ""
"Another new enhancement to the Python package index at https://pypi.org is "
"storing source and binary archives for a package.  The new :command:`upload` "
"Distutils command will upload a package to the repository."
msgstr ""
"Python Package Index (https://pypi.org) へのもう一つの新たな拡張は、パッケー"
"ジについてのソースコードとバイナリアーカイブの保存についてです。新たな "
"Distutils コマンド :command:`upload` は、レポジトリへパッケージをアップロード"
"します。"

#: ../../whatsnew/2.5.rst:236
msgid ""
"Before a package can be uploaded, you must be able to build a distribution "
"using the :command:`sdist` Distutils command.  Once that works, you can run "
"``python setup.py upload`` to add your package to the PyPI archive.  "
"Optionally you can GPG-sign the package by supplying the :option:`!--sign` "
"and :option:`!--identity` options."
msgstr ""
"パッケージがアップロードされる前には、Distutils :command:`sdist` コマンドを"
"使って配布物をビルド可能でなければなりません。それさえ出来ていれば、 "
"``python setup.py upload`` がパッケージを PyPI アーカイブに追加してくれます。"
"追加で、パッケージに GPG 署名出来ます。これには :option:`!--sign` オプション"
"と :option:`!--identity` オプションを使います。"

#: ../../whatsnew/2.5.rst:242
msgid ""
"Package uploading was implemented by Martin von Löwis and Richard Jones."
msgstr ""
"パッケージのアップロードは Martin von Löwis と Richard Jones により実装されま"
"した。"

#: ../../whatsnew/2.5.rst:247
msgid ":pep:`314` - Metadata for Python Software Packages v1.1"
msgstr ":pep:`314` - Metadata for Python Software Packages v1.1"

#: ../../whatsnew/2.5.rst:248
msgid ""
"PEP proposed and written by A.M. Kuchling, Richard Jones, and Fred Drake; "
"implemented by Richard Jones and Fred Drake."
msgstr ""
"PEP 提案と著 A.M. Kuchling、 Richard Jones、 Fred Drake; 実装 Richard Jones "
"と Fred Drake."

#: ../../whatsnew/2.5.rst:257
msgid "PEP 328: Absolute and Relative Imports"
msgstr "PEP 328: 絶対インポート、相対インポート"

#: ../../whatsnew/2.5.rst:259
msgid ""
"The simpler part of :pep:`328` was implemented in Python 2.4: parentheses "
"could now be used to enclose the names imported from a module using the "
"``from ... import ...`` statement, making it easier to import many different "
"names."
msgstr ""

#: ../../whatsnew/2.5.rst:263
msgid ""
"The more complicated part has been implemented in Python 2.5: importing a "
"module can be specified to use absolute or package-relative imports.  The "
"plan is to move toward making absolute imports the default in future "
"versions of Python."
msgstr ""
"より複雑なほうは Python 2.5 で実装されました: モジュールのインポートにおい"
"て、それが絶対インポートなのかパッケージ相対のインポートなのかを指定出来るよ"
"うにする、というものです。将来のバージョンの Python では絶対インポートをデ"
"フォルトにする方向に向かう予定です。"

#: ../../whatsnew/2.5.rst:267
msgid "Let's say you have a package directory like this::"
msgstr "いま、あなたは以下のようなパッケージディレクトリを持っているとします::"

#: ../../whatsnew/2.5.rst:269
msgid ""
"pkg/\n"
"pkg/__init__.py\n"
"pkg/main.py\n"
"pkg/string.py"
msgstr ""

#: ../../whatsnew/2.5.rst:274
msgid ""
"This defines a package named :mod:`pkg` containing the :mod:`pkg.main` and :"
"mod:`pkg.string` submodules."
msgstr ""
":mod:`pkg` パッケージがモジュール :mod:`pkg.main` とサブモジュール :mod:`pkg."
"string` を持っています。"

#: ../../whatsnew/2.5.rst:277
msgid ""
"Consider the code in the :file:`main.py` module.  What happens if it "
"executes the statement ``import string``?  In Python 2.4 and earlier, it "
"will first look in the package's directory to perform a relative import, "
"finds :file:`pkg/string.py`, imports the contents of that file as the :mod:"
"`pkg.string` module, and that module is bound to the name ``string`` in the :"
"mod:`pkg.main` module's namespace."
msgstr ""
":file:`main.py` のなかの人、になってみましょう。 ``import string`` 文を実行す"
"ると、何が起こるでしょうか? Python 2.4 とそれ以前のバージョンでは、相対イン"
"ポートとして実行するためにパッケージのディレクトリ内のものを最初に探し、 :"
"file:`pkg/string.py` を発見してそのファイル内容を :mod:`pkg.string` モジュー"
"ルであるとしてインポートし、そのモジュールは :mod:`pkg.main` モジュール内の名"
"前空間で、名前 ``string`` に束縛されます。"

#: ../../whatsnew/2.5.rst:284
msgid ""
"That's fine if :mod:`pkg.string` was what you wanted.  But what if you "
"wanted Python's standard :mod:`string` module?  There's no clean way to "
"ignore :mod:`pkg.string` and look for the standard module; generally you had "
"to look at the contents of ``sys.modules``, which is slightly unclean.    "
"Holger Krekel's :mod:`py.std` package provides a tidier way to perform "
"imports from the standard library, ``import py; py.std.string.join()``, but "
"that package isn't available on all Python installations."
msgstr ""
"よろしいでしょう。欲しいものが :mod:`pkg.string` であるならば。ですが欲しいの"
"は Python 標準ライブラリモジュールの :mod:`string` なのだとしたら? :mod:`pkg."
"string` を無視して標準モジュールを探す綺麗な方法はありません; 一般的に、 "
"``sys.modules`` の中身から探す必要がありました。これはちょっとばかり美しくあ"
"りません。Holger Krekel の :mod:`py.std` パッケージは標準ライブラリからモ"
"ジュールをインポートするのに ``import py; py.std.string.join()`` と、よりこぎ"
"れいな方法を与えてくれますが、そのパッケージは全ての Python インストレーショ"
"ンでの利用が可能にはなっていません。"

#: ../../whatsnew/2.5.rst:292
msgid ""
"Reading code which relies on relative imports is also less clear, because a "
"reader may be confused about which module, :mod:`string` or :mod:`pkg."
"string`, is intended to be used.  Python users soon learned not to duplicate "
"the names of standard library modules in the names of their packages' "
"submodules, but you can't protect against having your submodule's name being "
"used for a new module added in a future version of Python."
msgstr ""
"相対インポートに頼ったコードを読むことは、より不明瞭でもあります。読者は :"
"mod:`string` と :mod:`pkg.string` のどちらを使おうとしているのかについて、混"
"乱するだろうからです。Python ユーザはすぐに、彼らのパッケージのサブモジュール"
"名が標準ライブラリモジュールの名前と被らないようにすることを学びますが、あな"
"たのサブモジュール名が将来のバージョンの Python に追加される新しいモジュール"
"で使われる名前にならないようにすることは出来ません。"

#: ../../whatsnew/2.5.rst:299
msgid ""
"In Python 2.5, you can switch :keyword:`import`'s behaviour to  absolute "
"imports using a ``from __future__ import absolute_import`` directive.  This "
"absolute-import behaviour will become the default in a future version "
"(probably Python 2.7).  Once absolute imports  are the default, ``import "
"string`` will always find the standard library's version. It's suggested "
"that users should begin using absolute imports as much as possible, so it's "
"preferable to begin writing ``from pkg import string`` in your code."
msgstr ""
"Python 2.5 では :keyword:`import` の振る舞いを、 ``from __future__ import "
"absolute_import`` ディレクティブを使うことによって絶対インポートに切り替えら"
"れます。この絶対インポートの振る舞いは将来バージョンの Python でデフォルトに"
"なります(おそらく Python 2.7 で)。(訳注: ご承知のとおり Python 2.7 でもこれは"
"デフォルトとはなっていません。Python 3.x への移行のためにも 2.5 - 2.7 では "
"``from __future__ import absolute_import`` を使うべきです。) 絶対インポートを"
"デフォルトにしてしまえば、 ``import string`` はいつでも標準ライブラリ版を見つ"
"けます。ユーザは可能な限り絶対インポートを使い始めるべきで、あなたのコードで"
"は ``from pkg import string`` と書き始めることが望まれます。"

#: ../../whatsnew/2.5.rst:307
msgid ""
"Relative imports are still possible by adding a leading period  to the "
"module name when using the ``from ... import`` form::"
msgstr ""
"相対インポートは、 ``from ... import`` 形式を使う際にモジュール名の前にピリオ"
"ドを付ければまだ可能です::"

#: ../../whatsnew/2.5.rst:310
msgid ""
"# Import names from pkg.string\n"
"from .string import name1, name2\n"
"# Import pkg.string\n"
"from . import string"
msgstr ""

#: ../../whatsnew/2.5.rst:315
msgid ""
"This imports the :mod:`string` module relative to the current package, so "
"in :mod:`pkg.main` this will import *name1* and *name2* from :mod:`pkg."
"string`. Additional leading periods perform the relative import starting "
"from the parent of the current package.  For example, code in the :mod:`A.B."
"C` module can do::"
msgstr ""
"これは現在のパッケージからの相対で :mod:`string` モジュールをインポートします"
"ので、 :mod:`pkg.main` 内ではこれは、 *name1* と *name2* を :mod:`pkg."
"string` からインポートするでしょう。加えて、先行する複数ピリオドは、現在の"
"パッケージの親からの相対インポートを実行します。例えば、 :mod:`A.B.C` モ"
"ジュール内のコードはこのように出来ます::"

#: ../../whatsnew/2.5.rst:320
msgid ""
"from . import D                 # Imports A.B.D\n"
"from .. import E                # Imports A.E\n"
"from ..F import G               # Imports A.F.G"
msgstr ""

#: ../../whatsnew/2.5.rst:324
msgid ""
"Leading periods cannot be used with the ``import modname``  form of the "
"import statement, only the ``from ... import`` form."
msgstr ""
"このピリオドによる書き方は ``import modname`` 形式のインポート文では使えず、 "
"``from ... import`` 形式でのみ使えます。"

#: ../../whatsnew/2.5.rst:330
msgid ":pep:`328` - Imports: Multi-Line and Absolute/Relative"
msgstr ":pep:`328` - マルチラインインポートと、絶対/相対インポート"

#: ../../whatsnew/2.5.rst:331
msgid "PEP written by Aahz; implemented by Thomas Wouters."
msgstr "PEP 著 Aahz; 実装 Thomas Wouters。"

#: ../../whatsnew/2.5.rst:333
msgid "https://pylib.readthedocs.io/"
msgstr ""

#: ../../whatsnew/2.5.rst:334
msgid ""
"The py library by Holger Krekel, which contains the :mod:`py.std` package."
msgstr ""
"Holger Krekel による py ライブラリで、 :mod:`py.std` パッケージを含みます。"

#: ../../whatsnew/2.5.rst:342
msgid "PEP 338: Executing Modules as Scripts"
msgstr "PEP 338 - モジュールをスクリプトとして実行する"

#: ../../whatsnew/2.5.rst:344
msgid ""
"The :option:`-m` switch added in Python 2.4 to execute a module as a script "
"gained a few more abilities.  Instead of being implemented in C code inside "
"the Python interpreter, the switch now uses an implementation in a new "
"module, :mod:`runpy`."
msgstr ""
"Python 2.4 で追加されたモジュールをスクリプトとして実行するための :option:`-"
"m` スイッチが、少し能力を高めました。Python インタプリタ内での C 実装に代わ"
"り、これの実現には新しいモジュール :mod:`runpy` を使うようになっています。"

#: ../../whatsnew/2.5.rst:349
msgid ""
"The :mod:`runpy` module implements a more sophisticated import mechanism so "
"that it's now possible to run modules in a package such as :mod:`pychecker."
"checker`. The module also supports alternative import mechanisms such as "
"the :mod:`zipimport` module.  This means you can add a .zip archive's path "
"to ``sys.path`` and then use the :option:`-m` switch to execute code from "
"the archive."
msgstr ""
":mod:`runpy` モジュールはインポートのメカニズムをより洗練された方法で実装して"
"いるので、今では :mod:`pychecker.checker` のようにパッケージ内のモジュールも"
"実行出来ます。このモジュールは異なるインポートメカニズム、例えば :mod:"
"`zipimport` モジュールもサポートします。このことにより、 ``sys.path`` に ."
"zip アーカイブのパスを追加して、 :option:`-m` スイッチでアーカイブ内のコード"
"を実行する、といったことも出来ます。"

#: ../../whatsnew/2.5.rst:359
msgid ":pep:`338` - Executing modules as scripts"
msgstr ":pep:`338` - モジュールをスクリプトとして実行する"

#: ../../whatsnew/2.5.rst:360
msgid "PEP written and  implemented by Nick Coghlan."
msgstr "PEP 著と実装 Nick Coghlan."

#: ../../whatsnew/2.5.rst:368
msgid "PEP 341: Unified try/except/finally"
msgstr "PEP 341: try/except/finally の一体化"

#: ../../whatsnew/2.5.rst:370
msgid ""
"Until Python 2.5, the :keyword:`try` statement came in two flavours. You "
"could use a :keyword:`finally` block to ensure that code is always executed, "
"or one or more :keyword:`except` blocks to catch  specific exceptions.  You "
"couldn't combine both :keyword:`!except` blocks and a :keyword:`!finally` "
"block, because generating the right bytecode for the combined version was "
"complicated and it wasn't clear what the semantics of the combined statement "
"should be."
msgstr ""

#: ../../whatsnew/2.5.rst:377
msgid ""
"Guido van Rossum spent some time working with Java, which does support the "
"equivalent of combining :keyword:`except` blocks and a :keyword:`finally` "
"block, and this clarified what the statement should mean.  In Python 2.5, "
"you can now write::"
msgstr ""
"Guido van Rossum はいくらかの時間 Java での作業に時間を割きました。それは :"
"keyword:`except` ブロックと :keyword:`finally` ブロックを組み合わせるのと等価"
"なものをサポートしています。そしてこの作業が、このステートメントがどういう意"
"味であるべきかを明らかにしたのです。Python 2.5 では、あなたは今ではこう書くこ"
"とが出来ます::"

#: ../../whatsnew/2.5.rst:382
msgid ""
"try:\n"
"    block-1 ...\n"
"except Exception1:\n"
"    handler-1 ...\n"
"except Exception2:\n"
"    handler-2 ...\n"
"else:\n"
"    else-block\n"
"finally:\n"
"    final-block"
msgstr ""

#: ../../whatsnew/2.5.rst:393
msgid ""
"The code in *block-1* is executed.  If the code raises an exception, the "
"various :keyword:`except` blocks are tested: if the exception is of class :"
"class:`Exception1`, *handler-1* is executed; otherwise if it's of class :"
"class:`Exception2`, *handler-2* is executed, and so forth.  If no exception "
"is raised, the *else-block* is executed."
msgstr ""
"*block-1* 内のコードが実行されます。そのコードが例外を投げた場合、個々の :"
"keyword:`except` ブロックがテストされます: その例外が :class:`Exception1` ク"
"ラスであれば、 *handler-1* が実行されます; そうでない場合で :class:"
"`Exception2` クラスであれば、 *handler-2* が実行されます、以下同文。例外が起"
"こらなければ、 *else-block* が実行されます。"

#: ../../whatsnew/2.5.rst:399
msgid ""
"No matter what happened previously, the *final-block* is executed once the "
"code block is complete and any raised exceptions handled. Even if there's an "
"error in an exception handler or the *else-block* and a new exception is "
"raised, the code in the *final-block* is still run."
msgstr ""
"以前に何が起こったのかに拠らず、コードブロック完了時やどれかの例外が処理され"
"れば *final-block* が実行されます。例外ハンドラ内や *else-block* でエラーが起"
"こったり、 新しく例外を投げる場合でさえ、 *final-block* 内のコードはそれでも"
"実行されます。"

#: ../../whatsnew/2.5.rst:407
msgid ":pep:`341` - Unifying try-except and try-finally"
msgstr ":pep:`341` - try-except と try-finally を一体化する"

#: ../../whatsnew/2.5.rst:408
msgid "PEP written by Georg Brandl;  implementation by Thomas Lee."
msgstr "PEP 著 Georg Brandl; 実装 Thomas Lee。"

#: ../../whatsnew/2.5.rst:416
msgid "PEP 342: New Generator Features"
msgstr "PEP 342: ジェネレータの新機能"

#: ../../whatsnew/2.5.rst:418
msgid ""
"Python 2.5 adds a simple way to pass values *into* a generator. As "
"introduced in Python 2.3, generators only produce output; once a generator's "
"code was invoked to create an iterator, there was no way to pass any new "
"information into the function when its execution is resumed.  Sometimes the "
"ability to pass in some information would be useful.  Hackish solutions to "
"this include making the generator's code look at a global variable and then "
"changing the global variable's value, or passing in some mutable object that "
"callers then modify."
msgstr ""
"Python 2.5 は、ジェネレータ *に向けて* 値を渡すための単純な手段を追加しまし"
"た。Python 2.3 でジェネレータが導入された時点ではジェネレータが出来たのは出力"
"だけでした。いったんジェネレータのコードが呼び出されてイテレータが作られたあ"
"とは、新しい情報をそのジェネレータ関数の再開位置に渡す手段はありませんでし"
"た。ヤクザな解決法としては、ジェネレータがグローバル変数を見るようにしたり、"
"ミュータブルなオブジェクトを渡しておいて呼び出し元であとからそれを変更した"
"り、といったものがありました。"

#: ../../whatsnew/2.5.rst:426
msgid "To refresh your memory of basic generators, here's a simple example::"
msgstr ""
"基本的なジェネレータについて思い出してもらいましょう、単純な例はこんなです:"

#: ../../whatsnew/2.5.rst:428
msgid ""
"def counter (maximum):\n"
"    i = 0\n"
"    while i < maximum:\n"
"        yield i\n"
"        i += 1"
msgstr ""

#: ../../whatsnew/2.5.rst:434
msgid ""
"When you call ``counter(10)``, the result is an iterator that returns the "
"values from 0 up to 9.  On encountering the :keyword:`yield` statement, the "
"iterator returns the provided value and suspends the function's execution, "
"preserving the local variables. Execution resumes on the following call to "
"the iterator's :meth:`next` method, picking up after the :keyword:`!yield` "
"statement."
msgstr ""

#: ../../whatsnew/2.5.rst:440
msgid ""
"In Python 2.3, :keyword:`yield` was a statement; it didn't return any "
"value.  In 2.5, :keyword:`!yield` is now an expression, returning a value "
"that can be assigned to a variable or otherwise operated on::"
msgstr ""

#: ../../whatsnew/2.5.rst:444
msgid "val = (yield i)"
msgstr ""

#: ../../whatsnew/2.5.rst:446
msgid ""
"I recommend that you always put parentheses around a :keyword:`yield` "
"expression when you're doing something with the returned value, as in the "
"above example. The parentheses aren't always necessary, but it's easier to "
"always add them instead of having to remember when they're needed."
msgstr ""
"戻り値に何かする際は、 :keyword:`yield` 式の周りには括弧は付けておいたほうが"
"いいと思います、この例でのように。括弧はべつに必要はないのですが、どんな場合"
"に必要かを憶えるよりは、いつでも付けるのが簡単でしょう。"

#: ../../whatsnew/2.5.rst:451
msgid ""
"(:pep:`342` explains the exact rules, which are that a :keyword:`yield`\\ -"
"expression must always be parenthesized except when it occurs at the top-"
"level expression on the right-hand side of an assignment.  This means you "
"can write ``val = yield i`` but have to use parentheses when there's an "
"operation, as in ``val = (yield i) + 12``.)"
msgstr ""
"(:pep:`342` がその規則を正確に説明していますが、それによると :keyword:"
"`yield` 式は、代入式で右辺のトップレベルにあるとき以外はいつも括弧を付ける必"
"要があります。つまり ``val = yield i`` とは書けますが、 ``val = (yield i) + "
"12`` のように演算子があるときは括弧を使わなくてはいけません。)"

#: ../../whatsnew/2.5.rst:458
msgid ""
"Values are sent into a generator by calling its ``send(value)`` method.  The "
"generator's code is then resumed and the :keyword:`yield` expression returns "
"the specified *value*.  If the regular :meth:`next` method is called, the :"
"keyword:`!yield` returns :const:`None`."
msgstr ""

#: ../../whatsnew/2.5.rst:463
msgid ""
"Here's the previous example, modified to allow changing the value of the "
"internal counter. ::"
msgstr "以下は前のと同じ例ですが、内部カウンタの値の変更を許す修正をしました::"

#: ../../whatsnew/2.5.rst:466
msgid ""
"def counter (maximum):\n"
"    i = 0\n"
"    while i < maximum:\n"
"        val = (yield i)\n"
"        # If value provided, change counter\n"
"        if val is not None:\n"
"            i = val\n"
"        else:\n"
"            i += 1"
msgstr ""

#: ../../whatsnew/2.5.rst:476
msgid "And here's an example of changing the counter::"
msgstr "そしてカウンタ変更の例がこちらです::"

#: ../../whatsnew/2.5.rst:478
msgid ""
">>> it = counter(10)\n"
">>> print it.next()\n"
"0\n"
">>> print it.next()\n"
"1\n"
">>> print it.send(8)\n"
"8\n"
">>> print it.next()\n"
"9\n"
">>> print it.next()\n"
"Traceback (most recent call last):\n"
"  File \"t.py\", line 15, in ?\n"
"    print it.next()\n"
"StopIteration"
msgstr ""

#: ../../whatsnew/2.5.rst:493
msgid ""
":keyword:`yield` will usually return :const:`None`, so you should always "
"check for this case.  Don't just use its value in expressions unless you're "
"sure that the :meth:`send` method will be the only method used to resume "
"your generator function."
msgstr ""
":keyword:`yield` が :const:`None` を返すことはよくあるのですから、そうなって"
"いないかどうか必ずチェックしておくべきです。ジェネレータ関数を再開するために"
"使うメソッドが :meth:`send` しかないのだと確信してるのでない限り、式の値をそ"
"のまま使ってはいけません。"

#: ../../whatsnew/2.5.rst:498
msgid ""
"In addition to :meth:`send`, there are two other new methods on generators:"
msgstr "ジェネレータには、 :meth:`send` のほかにも新しいメソッドが二つあります"

#: ../../whatsnew/2.5.rst:500
msgid ""
"``throw(type, value=None, traceback=None)`` is used to raise an exception "
"inside the generator; the exception is raised by the :keyword:`yield` "
"expression where the generator's execution is paused."
msgstr ""
"``throw(type, value=None, traceback=None)`` はジェネレータ内で例外を投げるた"
"めに使います; その例外はジェネレータの実行が停止したところの :keyword:"
"`yield` 式によって投げられます。"

#: ../../whatsnew/2.5.rst:504
msgid ""
":meth:`close` raises a new :exc:`GeneratorExit` exception inside the "
"generator to terminate the iteration.  On receiving this exception, the "
"generator's code must either raise :exc:`GeneratorExit` or :exc:"
"`StopIteration`.  Catching the :exc:`GeneratorExit` exception and returning "
"a value is illegal and will trigger a :exc:`RuntimeError`; if the function "
"raises some other exception, that exception is propagated to the caller.  :"
"meth:`close` will also be called by Python's garbage collector when the "
"generator is garbage-collected."
msgstr ""
":meth:`close` はジェネレータ内で :exc:`GeneratorExit` 例外を投げてイテレート"
"を終了させます。この例外を受け取ったジェネレータのコードは :exc:"
"`GeneratorExit` か :exc:`StopIteration` を投げなくてはいけません; この例外を"
"捕捉して何かほかのことをしようとするのは規則違反であり、 :exc:`RuntimeError` "
"を引き起こします; 関数が何かほかの例外を投げると、その例外は呼び出し元に伝播"
"します。 :meth:`close` はジェネレータのガーベージコレクトによっても呼ばれま"
"す。"

#: ../../whatsnew/2.5.rst:512
msgid ""
"If you need to run cleanup code when a :exc:`GeneratorExit` occurs, I "
"suggest using a ``try: ... finally:`` suite instead of  catching :exc:"
"`GeneratorExit`."
msgstr ""
":exc:`GeneratorExit` が起こったときにクリーンアップ作業をする必要があるな"
"ら、 :exc:`GeneratorExit` を捕捉するのではなく ``try: ... finaly:`` するよう"
"お勧めします。"

#: ../../whatsnew/2.5.rst:515
msgid ""
"The cumulative effect of these changes is to turn generators from one-way "
"producers of information into both producers and consumers."
msgstr ""
"これらの変更の合わせ技で、ジェネレータは情報の一方的な生産者から、生産者かつ"
"消費者という存在に変貌を遂げたのです。"

#: ../../whatsnew/2.5.rst:518
msgid ""
"Generators also become *coroutines*, a more generalized form of subroutines. "
"Subroutines are entered at one point and exited at another point (the top of "
"the function, and a :keyword:`return` statement), but coroutines can be "
"entered, exited, and resumed at many different points (the :keyword:`yield` "
"statements). We'll have to figure out patterns for using coroutines "
"effectively in Python."
msgstr ""
"ジェネレータは *コルーチン* という、より一般化された形式のサブルーチンにもな"
"ります。サブルーチンは一カ所 (関数の冒頭) から入って別の一カ所 (:keyword:"
"`return` 文) から出るだけですが、コルーチンはいろいろな場所 (:keyword:"
"`yield` 文) から入ったり出たり再開したりできるのです。わたしたちは Python で"
"コルーチンを効果的に使うためのパターンを理解する必要があります。"

#: ../../whatsnew/2.5.rst:524
msgid ""
"The addition of the :meth:`close` method has one side effect that isn't "
"obvious. :meth:`close` is called when a generator is garbage-collected, so "
"this means the generator's code gets one last chance to run before the "
"generator is destroyed. This last chance means that ``try...finally`` "
"statements in generators can now be guaranteed to work; the :keyword:"
"`finally` clause will now always get a chance to run.  The syntactic "
"restriction that you couldn't mix :keyword:`yield` statements with a ``try..."
"finally`` suite has therefore been removed.  This seems like a minor bit of "
"language trivia, but using generators and ``try...finally`` is actually "
"necessary in order to implement the :keyword:`with` statement described by :"
"pep:`343`.  I'll look at this new statement in the following  section."
msgstr ""

#: ../../whatsnew/2.5.rst:536
msgid ""
"Another even more esoteric effect of this change: previously, the :attr:"
"`gi_frame` attribute of a generator was always a frame object. It's now "
"possible for :attr:`gi_frame` to be ``None`` once the generator has been "
"exhausted."
msgstr ""
"もう一つさらに深遠なこの変更の効果: 以前はジェネレータの :attr:`gi_frame` 属"
"性は常にフレームオブジェクトでした。今では :attr:`gi_frame` は、ジェネレータ"
"が使い果たされた場合に ``None`` になります。"

#: ../../whatsnew/2.5.rst:544
msgid ":pep:`342` - Coroutines via Enhanced Generators"
msgstr ":pep:`342` - 拡張されたジェネレータを用いたコルーチン"

#: ../../whatsnew/2.5.rst:545
msgid ""
"PEP written by  Guido van Rossum and Phillip J. Eby; implemented by Phillip "
"J. Eby.  Includes examples of  some fancier uses of generators as coroutines."
msgstr ""
"PEP は Guido van Rossum と Phillip J. Eby によって書かれ、Phillip J. Eby に"
"よって実装されました。コルーチンとしてのジェネレータの用法のいくつかの手が込"
"んだ例が含まれています。"

#: ../../whatsnew/2.5.rst:548
msgid ""
"Earlier versions of these features were proposed in  :pep:`288` by Raymond "
"Hettinger and :pep:`325` by Samuele Pedroni."
msgstr ""
"この機能の初期バージョンは Raymond Hettinger による :pep:`288` と Samuele "
"Pedroni による :pep:`325` で提案されました。"

#: ../../whatsnew/2.5.rst:551
msgid "https://en.wikipedia.org/wiki/Coroutine"
msgstr "https://en.wikipedia.org/wiki/Coroutine"

#: ../../whatsnew/2.5.rst:552
msgid "The Wikipedia entry for  coroutines."
msgstr "コルーチンに関する WikiPedia エントリ。"

#: ../../whatsnew/2.5.rst:554
msgid ""
"https://web.archive.org/web/20160321211320/http://www.sidhe.org/~dan/blog/"
"archives/000178.html"
msgstr ""

#: ../../whatsnew/2.5.rst:555
msgid ""
"An explanation of coroutines from a Perl point of view, written by Dan "
"Sugalski."
msgstr "Dan Sugalski による、Perl の視点からみたコルーチンの説明です。"

#: ../../whatsnew/2.5.rst:563
msgid "PEP 343: The 'with' statement"
msgstr "PEP 343: \"with\" ステートメント"

#: ../../whatsnew/2.5.rst:565
msgid ""
"The ':keyword:`with`' statement clarifies code that previously would use "
"``try...finally`` blocks to ensure that clean-up code is executed.  In this "
"section, I'll discuss the statement as it will commonly be used.  In the "
"next section, I'll examine the implementation details and show how to write "
"objects for use with this statement."
msgstr ""
"':keyword:`with`' ステートメントは、以前なら後片付けが実行されるのを確実にす"
"るために ``try...finally`` ブロックを使ったであろうようなコードを、より単純明"
"快にします。このセクションでは、このステートメントの普通の使い方を説明しま"
"す。続くセクションでは実装の詳細を調べ、このステートメントとともに使うために"
"オブジェクトをどうやって書けば良いかをお見せします。"

#: ../../whatsnew/2.5.rst:571
msgid ""
"The ':keyword:`with`' statement is a new control-flow structure whose basic "
"structure is::"
msgstr ""
"':keyword:`with`' ステートメントは基本構造が以下となる新しい制御フロー構造で"
"す::"

#: ../../whatsnew/2.5.rst:574
msgid ""
"with expression [as variable]:\n"
"    with-block"
msgstr ""

#: ../../whatsnew/2.5.rst:577
msgid ""
"The expression is evaluated, and it should result in an object that supports "
"the context management protocol (that is, has :meth:`~object.__enter__` and :"
"meth:`~object.__exit__` methods."
msgstr ""

#: ../../whatsnew/2.5.rst:581
msgid ""
"The object's :meth:`~object.__enter__` is called before *with-block* is "
"executed and therefore can run set-up code. It also may return a value that "
"is bound to the name *variable*, if given.  (Note carefully that *variable* "
"is *not* assigned the result of *expression*.)"
msgstr ""

#: ../../whatsnew/2.5.rst:586
msgid ""
"After execution of the *with-block* is finished, the object's :meth:`~object."
"__exit__` method is called, even if the block raised an exception, and can "
"therefore run clean-up code."
msgstr ""

#: ../../whatsnew/2.5.rst:590
msgid ""
"To enable the statement in Python 2.5, you need to add the following "
"directive to your module::"
msgstr ""
"Python 2.5 でこのステートメントを有効にするには、以下のディレクティブをあなた"
"のモジュールに追加する必要があります::"

#: ../../whatsnew/2.5.rst:593
msgid "from __future__ import with_statement"
msgstr ""

#: ../../whatsnew/2.5.rst:595
msgid "The statement will always be enabled in Python 2.6."
msgstr "Python 2.6 ではこれは常に有効になります。"

#: ../../whatsnew/2.5.rst:597
msgid ""
"Some standard Python objects now support the context management protocol and "
"can be used with the ':keyword:`with`' statement. File objects are one "
"example::"
msgstr ""
"いくつかの Python 標準オブジェクトが既にコンテキスト管理プロトコルをサポート"
"していて、 ':keyword:`with`' とともに使えます。ファイルオブジェクトがその一例"
"です::"

#: ../../whatsnew/2.5.rst:600
msgid ""
"with open('/etc/passwd', 'r') as f:\n"
"    for line in f:\n"
"        print line\n"
"        ... more processing code ..."
msgstr ""

#: ../../whatsnew/2.5.rst:605
msgid ""
"After this statement has executed, the file object in *f* will have been "
"automatically closed, even if the :keyword:`for` loop raised an exception "
"part-way through the block."
msgstr ""
"このステートメントが実行し終わったあかつきには、 *f* のファイルオブジェクト"
"は、たとえ :keyword:`for` ループが道半ばにして例外と成り果てても、自動的にク"
"ローズされます。"

#: ../../whatsnew/2.5.rst:611
msgid ""
"In this case, *f* is the same object created by :func:`open`, because :meth:"
"`~object.__enter__` returns *self*."
msgstr ""

#: ../../whatsnew/2.5.rst:614
msgid ""
"The :mod:`threading` module's locks and condition variables  also support "
"the ':keyword:`with`' statement::"
msgstr ""
":mod:`threading` モジュールのロック・条件変数でも ':keyword:`with`' ステート"
"メントの恩恵にあずかれます::"

#: ../../whatsnew/2.5.rst:617
msgid ""
"lock = threading.Lock()\n"
"with lock:\n"
"    # Critical section of code\n"
"    ..."
msgstr ""

#: ../../whatsnew/2.5.rst:622
msgid ""
"The lock is acquired before the block is executed and always released once  "
"the block is complete."
msgstr ""
"ブロックが実行される前にロックが獲得されて、ブロックが完了するやいなや必ず解"
"放されます。"

#: ../../whatsnew/2.5.rst:625
msgid ""
"The new :func:`localcontext` function in the :mod:`decimal` module makes it "
"easy to save and restore the current decimal context, which encapsulates the "
"desired precision and rounding characteristics for computations::"
msgstr ""
":mod:`decimal` モジュール内の新しい :func:`localcontext` 関数は現在の "
"decimal のコンテキスト (計算の望みの精度と丸め特性をカプセル化しています) を"
"保存しておいてあとで元に戻すのを簡単にしてくれます::"

#: ../../whatsnew/2.5.rst:629
msgid ""
"from decimal import Decimal, Context, localcontext\n"
"\n"
"# Displays with default precision of 28 digits\n"
"v = Decimal('578')\n"
"print v.sqrt()\n"
"\n"
"with localcontext(Context(prec=16)):\n"
"    # All code in this block uses a precision of 16 digits.\n"
"    # The original context is restored on exiting the block.\n"
"    print v.sqrt()"
msgstr ""

#: ../../whatsnew/2.5.rst:644
msgid "Writing Context Managers"
msgstr "コンテキストマネージャを書く"

#: ../../whatsnew/2.5.rst:646
msgid ""
"Under the hood, the ':keyword:`with`' statement is fairly complicated. Most "
"people will only use ':keyword:`!with`' in company with existing objects and "
"don't need to know these details, so you can skip the rest of this section "
"if you like.  Authors of new objects will need to understand the details of "
"the underlying implementation and should keep reading."
msgstr ""
"中身を紐解いてみれば、 ':keyword:`with`' ステートメントはけっこう入り組んでい"
"ます。ほとんどの人にとっては、既存のオブジェクトを ':keyword:`!with`' ととも"
"に使うだけのことでその詳細を知る必要は無いので、それで良いならこのセクション"
"の残りの部分は読み飛ばして結構です。新しいオブジェクトの作者は基礎となる実装"
"の詳細について知る必要があるので、このまま読み進めるべきです。"

#: ../../whatsnew/2.5.rst:652
msgid "A high-level explanation of the context management protocol is:"
msgstr "コンテキスト管理プロトコルの高度な説明はこんなです:"

#: ../../whatsnew/2.5.rst:654
msgid ""
"The expression is evaluated and should result in an object called a "
"\"context manager\".  The context manager must have :meth:`~object."
"__enter__` and :meth:`~object.__exit__` methods."
msgstr ""

#: ../../whatsnew/2.5.rst:658
msgid ""
"The context manager's :meth:`~object.__enter__` method is called.  The value "
"returned is assigned to *VAR*.  If no ``'as VAR'`` clause is present, the "
"value is simply discarded."
msgstr ""

#: ../../whatsnew/2.5.rst:662
msgid "The code in *BLOCK* is executed."
msgstr "*BLOCK* 内のコードが実行されます。"

#: ../../whatsnew/2.5.rst:664
msgid ""
"If *BLOCK* raises an exception, the ``__exit__(type, value, traceback)`` is "
"called with the exception details, the same values returned by :func:`sys."
"exc_info`.  The method's return value controls whether the exception is re-"
"raised: any false value re-raises the exception, and ``True`` will result in "
"suppressing it.  You'll only rarely want to suppress the exception, because "
"if you do the author of the code containing the ':keyword:`with`' statement "
"will never realize anything went wrong."
msgstr ""
"*BLOCK* が例外を起こした場合、コンテキストマネージャの ``__exit__`` メソッド"
"が 3 つの引数とともに呼び出されます。これは例外の詳細です (``type, value, "
"traceback``, これは :func:`sys.exc_info` が返す値と同じで、例外が起こらなけれ"
"ば ``None`` です)。そのメソッドの戻り値は例外を再送出するかどうかを制御しま"
"す: 全ての偽の値ではその例外が再送出され、 ``True`` では揉み消します。例外を"
"揉み消すなど滅多なことでは欲しいと思わないでしょう。もしそうしてしまったら、 "
"':keyword:`with`' ステートメントを含んだコードの作者は何か間違ったことが起"
"こったことに決して気付かないですから。"

#: ../../whatsnew/2.5.rst:672
msgid ""
"If *BLOCK* didn't raise an exception,  the :meth:`~object.__exit__` method "
"is still called, but *type*, *value*, and *traceback* are all ``None``."
msgstr ""

#: ../../whatsnew/2.5.rst:675
msgid ""
"Let's think through an example.  I won't present detailed code but will only "
"sketch the methods necessary for a database that supports transactions."
msgstr ""
"例を通じて考えましょう。枝葉末節を含んだ完璧なコードを提示しようとは思いませ"
"んが、データベースのためにトランザクションをサポートするのに必要となるメソッ"
"ドの書き方についてスケッチしてみようと思います。"

#: ../../whatsnew/2.5.rst:678
msgid ""
"(For people unfamiliar with database terminology: a set of changes to the "
"database are grouped into a transaction.  Transactions can be either "
"committed, meaning that all the changes are written into the database, or "
"rolled back, meaning that the changes are all discarded and the database is "
"unchanged.  See any database textbook for more information.)"
msgstr ""
"(データベース用語に不慣れな方へ:データベースへの変更のセットは、トランザク"
"ションという単位でグループ化されています。トランザクションは「コミット」され"
"る、その意味は、全ての変更がデータベースに書き込まれることです、もしくは"
"「ロールバック」される、この場合全ての変更が捨てられてデータベースが変更され"
"ません、この 2 つのいずれかになりえます。詳しくはなにかデータベースの著述を読"
"んで下さい。)"

#: ../../whatsnew/2.5.rst:684
msgid ""
"Let's assume there's an object representing a database connection. Our goal "
"will be to let the user write code like this::"
msgstr ""
"データベース接続を表現するオブジェクトがあると仮定しましょう。私たちの目標"
"は、そのオブジェクトのユーザがこのように書けるようになることです::"

#: ../../whatsnew/2.5.rst:687
msgid ""
"db_connection = DatabaseConnection()\n"
"with db_connection as cursor:\n"
"    cursor.execute('insert into ...')\n"
"    cursor.execute('delete from ...')\n"
"    # ... more operations ..."
msgstr ""

#: ../../whatsnew/2.5.rst:693
msgid ""
"The transaction should be committed if the code in the block runs flawlessly "
"or rolled back if there's an exception. Here's the basic interface for :"
"class:`DatabaseConnection` that I'll assume::"
msgstr ""
"トランザクションはブロック内のコードがつつがなく終了すればコミットし、例外が"
"発生すればロールバックすべきです。私が思い描いている :class:"
"`DatabaseConnection` の基本的なインターフェイスはこんなです::"

#: ../../whatsnew/2.5.rst:697
msgid ""
"class DatabaseConnection:\n"
"    # Database interface\n"
"    def cursor (self):\n"
"        \"Returns a cursor object and starts a new transaction\"\n"
"    def commit (self):\n"
"        \"Commits current transaction\"\n"
"    def rollback (self):\n"
"        \"Rolls back current transaction\""
msgstr ""

#: ../../whatsnew/2.5.rst:706
msgid ""
"The :meth:`~object.__enter__` method is pretty easy, having only to start a "
"new transaction.  For this application the resulting cursor object would be "
"a useful result, so the method will return it.  The user can then add ``as "
"cursor`` to their ':keyword:`with`' statement to bind the cursor to a "
"variable name. ::"
msgstr ""

#: ../../whatsnew/2.5.rst:711
msgid ""
"class DatabaseConnection:\n"
"    ...\n"
"    def __enter__ (self):\n"
"        # Code to start a new transaction\n"
"        cursor = self.cursor()\n"
"        return cursor"
msgstr ""

#: ../../whatsnew/2.5.rst:718
msgid ""
"The :meth:`~object.__exit__` method is the most complicated because it's "
"where most of the work has to be done.  The method has to check if an "
"exception occurred.  If there was no exception, the transaction is "
"committed.  The transaction is rolled back if there was an exception."
msgstr ""

#: ../../whatsnew/2.5.rst:723
msgid ""
"In the code below, execution will just fall off the end of the function, "
"returning the default value of ``None``.  ``None`` is false, so the "
"exception will be re-raised automatically.  If you wished, you could be more "
"explicit and add a :keyword:`return` statement at the marked location. ::"
msgstr ""
"下記のコード内では実行がメソッドの末尾まで落ちていって、なのでデフォルトの "
"``None`` 返却になります。 ``None`` は偽なので、例外は自動的に再送出されます。"
"望むならもっと明示的に、コメントでマークした部分で :keyword:`return` 文を書い"
"てもよろしいです::"

#: ../../whatsnew/2.5.rst:728
msgid ""
"class DatabaseConnection:\n"
"    ...\n"
"    def __exit__ (self, type, value, tb):\n"
"        if tb is None:\n"
"            # No exception, so commit\n"
"            self.commit()\n"
"        else:\n"
"            # Exception occurred, so rollback.\n"
"            self.rollback()\n"
"            # return False"
msgstr ""

#: ../../whatsnew/2.5.rst:743
msgid "The contextlib module"
msgstr "contextlib モジュール"

#: ../../whatsnew/2.5.rst:745
msgid ""
"The new :mod:`contextlib` module provides some functions and a decorator "
"that are useful for writing objects for use with the ':keyword:`with`' "
"statement."
msgstr ""
"新しい :mod:`contextlib` モジュールは、 ':keyword:`with`' ステートメントで使"
"えるオブジェクトを書く際に便利ないくつかの関数とデコレータを提供しています。"

#: ../../whatsnew/2.5.rst:748
msgid ""
"The decorator is called :func:`contextmanager`, and lets you write a single "
"generator function instead of defining a new class.  The generator should "
"yield exactly one value.  The code up to the :keyword:`yield` will be "
"executed as the :meth:`~object.__enter__` method, and the value yielded will "
"be the method's return value that will get bound to the variable in the ':"
"keyword:`with`' statement's :keyword:`!as` clause, if any.  The code after "
"the :keyword:`yield` will be executed in the :meth:`~object.__exit__` "
"method.  Any exception raised in the block will be raised by the :keyword:`!"
"yield` statement."
msgstr ""

#: ../../whatsnew/2.5.rst:757
msgid ""
"Our database example from the previous section could be written  using this "
"decorator as::"
msgstr ""
"このデコレータを使って、前セクションの私たちのデータベースの例はこのように書"
"けます::"

#: ../../whatsnew/2.5.rst:760
msgid ""
"from contextlib import contextmanager\n"
"\n"
"@contextmanager\n"
"def db_transaction (connection):\n"
"    cursor = connection.cursor()\n"
"    try:\n"
"        yield cursor\n"
"    except:\n"
"        connection.rollback()\n"
"        raise\n"
"    else:\n"
"        connection.commit()\n"
"\n"
"db = DatabaseConnection()\n"
"with db_transaction(db) as cursor:\n"
"    ..."
msgstr ""

#: ../../whatsnew/2.5.rst:777
msgid ""
"The :mod:`contextlib` module also has a ``nested(mgr1, mgr2, ...)`` function "
"that combines a number of context managers so you don't need to write nested "
"':keyword:`with`' statements.  In this example, the single ':keyword:`!"
"with`' statement both starts a database transaction and acquires a thread "
"lock::"
msgstr ""
":mod:`contextlib` モジュールには ``nested(mgr1, mgr2, ...)`` 関数もあり、この"
"関数はたくさんのコンテキストマネージャを組み合わせることができて、入れ子の ':"
"keyword:`with`' を書く必要性をなくしてくれます。この例では、単一の ':keyword:"
"`!with`' でデータベーストランザクション開始とスレッドのロック獲得の両方をやっ"
"てのけています::"

#: ../../whatsnew/2.5.rst:782
msgid ""
"lock = threading.Lock()\n"
"with nested (db_transaction(db), lock) as (cursor, locked):\n"
"    ..."
msgstr ""

#: ../../whatsnew/2.5.rst:786
msgid ""
"Finally, the ``closing(object)`` function returns *object* so that it can be "
"bound to a variable, and calls ``object.close`` at the end of the block. ::"
msgstr ""
"最後になりますが、 ``closing(object)`` 関数は *object* をそのまま返して変数に"
"束縛出来るようにし、かつブロックの終了で、与えた引数が持つ ``object.close`` "
"を呼び出します::"

#: ../../whatsnew/2.5.rst:789
msgid ""
"import urllib, sys\n"
"from contextlib import closing\n"
"\n"
"with closing(urllib.urlopen('http://www.yahoo.com')) as f:\n"
"    for line in f:\n"
"        sys.stdout.write(line)"
msgstr ""

#: ../../whatsnew/2.5.rst:799
msgid ":pep:`343` - The \"with\" statement"
msgstr ":pep:`343` - \"with\" ステートメント"

#: ../../whatsnew/2.5.rst:800
msgid ""
"PEP written by Guido van Rossum and Nick Coghlan; implemented by Mike Bland, "
"Guido van Rossum, and Neal Norwitz.  The PEP shows the code generated for a "
"':keyword:`with`' statement, which can be helpful in learning how the "
"statement works."
msgstr ""
"PEP は Guido van Rossum と Nick Coghlan によって書かれ、Mike Bland、 Guido "
"van Rossum、Neal Norwitz により実装されました。この PEP は ':keyword:`with`' "
"ステートメントによって生成されるコードを見せてくれるので、このステートメント"
"がどうやって動作するのかを知るのに役立ちます。"

#: ../../whatsnew/2.5.rst:805
msgid "The documentation  for the :mod:`contextlib` module."
msgstr ":mod:`contextlib` モジュールについてのドキュメント。"

#: ../../whatsnew/2.5.rst:813
msgid "PEP 352: Exceptions as New-Style Classes"
msgstr "PEP 352: 例外の新スタイルクラス化"

#: ../../whatsnew/2.5.rst:815
msgid ""
"Exception classes can now be new-style classes, not just classic classes, "
"and the built-in :exc:`Exception` class and all the standard built-in "
"exceptions (:exc:`NameError`, :exc:`ValueError`, etc.) are now new-style "
"classes."
msgstr ""
"例外クラスは、今では旧スタイルクラスだけではなく新スタイルクラスになれます。"
"組み込みの :exc:`Exception` クラスと全ての標準組み込み例外 (:exc:"
"`NameError`, :exc:`ValueError`, など) が今では新スタイルクラスです。"

#: ../../whatsnew/2.5.rst:819
msgid ""
"The inheritance hierarchy for exceptions has been rearranged a bit. In 2.5, "
"the inheritance relationships are::"
msgstr ""
"例外の継承階層が少し再編成されました。2.5 では継承関係はこのようになっていま"
"す (---訳注: 2.6 ではさらに GeneratorExit が Exception ではなく "
"BaseExceotion の直接の子になり、これは 3.x でも引き継がれています。---)::"

#: ../../whatsnew/2.5.rst:822
msgid ""
"BaseException       # New in Python 2.5\n"
"|- KeyboardInterrupt\n"
"|- SystemExit\n"
"|- Exception\n"
"   |- (all other current built-in exceptions)"
msgstr ""

#: ../../whatsnew/2.5.rst:828
msgid ""
"This rearrangement was done because people often want to catch all "
"exceptions that indicate program errors.  :exc:`KeyboardInterrupt` and :exc:"
"`SystemExit` aren't errors, though, and usually represent an explicit action "
"such as the user hitting :kbd:`Control-C` or code calling :func:`sys.exit`.  "
"A bare ``except:`` will catch all exceptions, so you commonly need to list :"
"exc:`KeyboardInterrupt` and :exc:`SystemExit` in order to re-raise them.  "
"The usual pattern is::"
msgstr ""
"この再編成が行われたのは、人々がしばしばプログラムのエラーを示す例外すべてを"
"捕捉したがるからです。 :exc:`KeyboardInterrupt` と :exc:`SystemExit` はエラー"
"ではありませんが、普通は :kbd:`Control-C` をユーザが叩いたか、コードが :func:"
"`sys.exit` を呼び出したかのような明示的なアクションを表します。剥き出しの "
"``except:`` はまさに全ての例外を捕捉しますから、一般に、再送出のために :exc:"
"`KeyboardInterrupt` と :exc:`SystemExit` はリストする必要があります。お決まり"
"のパターンはこんなです::"

#: ../../whatsnew/2.5.rst:835
msgid ""
"try:\n"
"    ...\n"
"except (KeyboardInterrupt, SystemExit):\n"
"    raise\n"
"except:\n"
"    # Log error...\n"
"    # Continue running program..."
msgstr ""

#: ../../whatsnew/2.5.rst:843
msgid ""
"In Python 2.5, you can now write ``except Exception`` to achieve the same "
"result, catching all the exceptions that usually indicate errors  but "
"leaving :exc:`KeyboardInterrupt` and :exc:`SystemExit` alone.  As in "
"previous versions, a bare ``except:`` still catches all exceptions."
msgstr ""
"Python 2.5 では同じ結果を得るのにもう ``except Exception`` と書いても良いで"
"す。これは普通はエラーを示す例外全てを捕捉しつつも :exc:`KeyboardInterrupt` "
"と :exc:`SystemExit` は置き去りにします。無論かつてまでのバージョン同様、剥き"
"身の ``except:`` は全例外を捕捉します。"

#: ../../whatsnew/2.5.rst:848
msgid ""
"The goal for Python 3.0 is to require any class raised as an exception to "
"derive from :exc:`BaseException` or some descendant of :exc:`BaseException`, "
"and future releases in the Python 2.x series may begin to enforce this "
"constraint. Therefore, I suggest you begin making all your exception classes "
"derive from :exc:`Exception` now.  It's been suggested that the bare "
"``except:`` form should be removed in Python 3.0, but Guido van Rossum "
"hasn't decided whether to do this or not."
msgstr ""
"Python 3.0 での目標は、例外として raise される全てのクラスが :exc:"
"`BaseException` からの、もしくは :exc:`BaseException`  のある子孫であることを"
"要求することであり、Python 2.x シリーズの将来のリリースにおいてはこの制約の強"
"制を始めるかもしれません。ですからあなたの全ての例外は、今からすぐに :exc:"
"`Exception` 派生にするのが肝要です。捕捉例外を特定しない ``except:`` は "
"Python 3.0 から取り除かれるべきであることが提案されていますが、Guido van "
"Rossum はこれをどうするかまだ決めていません。 (---訳注: 2.7 では raise は「新"
"スタイルクラスであれば」 :exc:`BaseException` 派生であることを要求されます"
"が、旧スタイルクラスであればなんでも許されてしまう点ではあまり変わっていませ"
"ん。これについての警告は :option:`!-3` などで受けることが出来ます。Python "
"3.0 でようやく全ての例外が :exc:`BaseException` 派生であることが強制されるよ"
"うになりました。 また、 ``except:`` は 3.4 でも残っています。---)"

#: ../../whatsnew/2.5.rst:856
msgid ""
"Raising of strings as exceptions, as in the statement ``raise \"Error "
"occurred\"``, is deprecated in Python 2.5 and will trigger a warning.  The "
"aim is to be able to remove the string-exception feature in a few releases."
msgstr ""
"例外として文字列を ``raise \"Error occurred\"`` として raise することは "
"Python 2.5 では非推奨であり警告を引き起こします。その目的は、あと少しのリリー"
"スで文字列例外を削除することです。 (---訳注: 2.6 以降の What's New では明示的"
"に書かれてはいませんが、2.7 では警告ではなくエラーです。---)"

#: ../../whatsnew/2.5.rst:863
msgid ":pep:`352` - Required Superclass for Exceptions"
msgstr ":pep:`352` - 例外のためのスーパークラス"

#: ../../whatsnew/2.5.rst:864
msgid ""
"PEP written by  Brett Cannon and Guido van Rossum; implemented by Brett "
"Cannon."
msgstr "PEP 著: Brett Cannon と Guido van Rossum; 実装: Brett Cannon."

#: ../../whatsnew/2.5.rst:872
msgid "PEP 353: Using ssize_t as the index type"
msgstr "PEP 353: 添え字型に ssize_t を使う"

#: ../../whatsnew/2.5.rst:874
msgid ""
"A wide-ranging change to Python's C API, using a new  :c:type:`Py_ssize_t` "
"type definition instead of :c:expr:`int`,  will permit the interpreter to "
"handle more data on 64-bit platforms. This change doesn't affect Python's "
"capacity on 32-bit platforms."
msgstr ""

#: ../../whatsnew/2.5.rst:879
msgid ""
"Various pieces of the Python interpreter used C's :c:expr:`int` type to "
"store sizes or counts; for example, the number of items in a list or tuple "
"were stored in an :c:expr:`int`.  The C compilers for most 64-bit platforms "
"still define :c:expr:`int` as a 32-bit type, so that meant that lists could "
"only hold up to ``2**31 - 1`` = 2147483647 items. (There are actually a few "
"different programming models that 64-bit C compilers can use -- see https://"
"unix.org/version2/whatsnew/lp64_wp.html for a discussion -- but the most "
"commonly available model leaves :c:expr:`int` as 32 bits.)"
msgstr ""

#: ../../whatsnew/2.5.rst:888
msgid ""
"A limit of 2147483647 items doesn't really matter on a 32-bit platform "
"because you'll run out of memory before hitting the length limit. Each list "
"item requires space for a pointer, which is 4 bytes, plus space for a :c:"
"type:`PyObject` representing the item.  2147483647\\*4 is already more bytes "
"than a 32-bit address space can contain."
msgstr ""
"2147483647 に要素数が制限されることは 32 ビットプラットフォームではあまり重大"
"でもありません。その長さ制限を喰らう前にメモリを使い果たすでしょうから。それ"
"ぞれのリストアイテムは、ポインタのための領域 (4 バイト) をアイテムを表現す"
"る :c:type:`PyObject` に余分に必要とします。2147483647\\*4 は既に 32 ビットの"
"アドレス空間が含められるバイト数を超えています。(---訳注: 意味不明。何か誤解"
"があるような…? 4 バイトは 2147483647 (符号付きとして 2^31 - 1) でしょう。4 を"
"掛ける説明なんかここでまったくされていない。なぜ掛ける? それと要素のインデク"
"シングとアイテムの必要領域は議論には無関係なのでは?---)"

#: ../../whatsnew/2.5.rst:894
msgid ""
"It's possible to address that much memory on a 64-bit platform, however.  "
"The pointers for a list that size would only require 16 GiB of space, so "
"it's not unreasonable that Python programmers might construct lists that "
"large. Therefore, the Python interpreter had to be changed to use some type "
"other than :c:expr:`int`, and this will be a 64-bit type on 64-bit "
"platforms.  The change will cause incompatibilities on 64-bit machines, so "
"it was deemed worth making the transition now, while the number of 64-bit "
"users is still relatively small. (In 5 or 10 years, we may *all* be on 64-"
"bit machines, and the transition would be more painful then.)"
msgstr ""

#: ../../whatsnew/2.5.rst:904
msgid ""
"This change most strongly affects authors of C extension modules.   Python "
"strings and container types such as lists and tuples  now use :c:type:"
"`Py_ssize_t` to store their size.   Functions such as :c:func:`PyList_Size`  "
"now return :c:type:`Py_ssize_t`.  Code in extension modules may therefore "
"need to have some variables changed to :c:type:`Py_ssize_t`."
msgstr ""
"この変更は C 拡張モジュールの著者に大変大きく影響します。Python 文字列とリス"
"トやタプルのようなコンテナ型は、そのサイズを表すのに :c:type:`Py_ssize_t` を"
"使うようになっています。 :c:func:`PyList_Size` のような関数は :c:type:"
"`Py_ssize_t` を返します。拡張モジュール内のコードでは、ですので、ある程度の変"
"数の :c:type:`Py_ssize_t` への変更が必要でしょう。"

#: ../../whatsnew/2.5.rst:910
msgid ""
"The :c:func:`PyArg_ParseTuple` and :c:func:`Py_BuildValue` functions have a "
"new conversion code, ``n``, for :c:type:`Py_ssize_t`.   :c:func:"
"`PyArg_ParseTuple`'s ``s#`` and ``t#`` still output :c:expr:`int` by "
"default, but you can define the macro  :c:macro:`PY_SSIZE_T_CLEAN` before "
"including :file:`Python.h`  to make them return :c:type:`Py_ssize_t`."
msgstr ""

#: ../../whatsnew/2.5.rst:916
msgid ""
":pep:`353` has a section on conversion guidelines that  extension authors "
"should read to learn about supporting 64-bit platforms."
msgstr ""
":pep:`353` には、拡張の著者が読んで学ぶべき 64 ビットプラットフォームサポート"
"についてのセクションがあります。"

#: ../../whatsnew/2.5.rst:922
msgid ":pep:`353` - Using ssize_t as the index type"
msgstr ":pep:`353` - 添え字型に ssize_t を使う"

#: ../../whatsnew/2.5.rst:923
msgid "PEP written and implemented by Martin von Löwis."
msgstr "PEP 著と実装 Martin von Löwis."

#: ../../whatsnew/2.5.rst:931
msgid "PEP 357: The '__index__' method"
msgstr "PEP 357: '__index__' メソッド"

#: ../../whatsnew/2.5.rst:933
msgid ""
"The NumPy developers had a problem that could only be solved by adding a new "
"special method, :meth:`__index__`.  When using slice notation, as in "
"``[start:stop:step]``, the values of the *start*, *stop*, and *step* indexes "
"must all be either integers or long integers.  NumPy defines a variety of "
"specialized integer types corresponding to unsigned and signed integers of "
"8, 16, 32, and 64 bits, but there was no way to signal that these types "
"could be used as slice indexes."
msgstr ""
"NumPy 開発者たちは、新しい特殊メソッド、 :meth:`__index__` を追加することに"
"よってしか解決できない問題を抱えていました。スライスの表現 ``[start:stop:"
"step]`` を使う際、 *start*, *stop*, *step* は全て整数か長整数でなければなりま"
"せん。NumPy は様々な特殊化された整数型を持っていて、符号なし、符号付きの 8、"
"16、32、64 ビットに対応していますが、それらをスライスの添え字に使う手段はあり"
"ませんでした。"

#: ../../whatsnew/2.5.rst:941
msgid ""
"Slicing can't just use the existing :meth:`__int__` method because that "
"method is also used to implement coercion to integers.  If slicing used :"
"meth:`__int__`, floating-point numbers would also become legal slice indexes "
"and that's clearly an undesirable behaviour."
msgstr ""
"スライシングに既存の :meth:`__int__` メソッドをそのまま使うことは出来ません。"
"それらは整数への型変換を実装するのにも使われるからです。スライシングが :meth:"
"`__int__` を使ったとすれば、浮動小数点数でさえスライスの添え字として使うこと"
"が合法になりますが、それは明らかに望む振る舞いではありません。"

#: ../../whatsnew/2.5.rst:946
msgid ""
"Instead, a new special method called :meth:`__index__` was added.  It takes "
"no arguments and returns an integer giving the slice index to use.  For "
"example::"
msgstr ""
"その代わりに新しい特殊メソッド :meth:`__index__` が追加されました。これは引数"
"を取らずに、スライスの添え字として使われる整数を返します。例えば::"

#: ../../whatsnew/2.5.rst:949
msgid ""
"class C:\n"
"    def __index__ (self):\n"
"        return self.value"
msgstr ""

#: ../../whatsnew/2.5.rst:953
msgid ""
"The return value must be either a Python integer or long integer. The "
"interpreter will check that the type returned is correct, and raises a :exc:"
"`TypeError` if this requirement isn't met."
msgstr ""
"戻り値は Python 整数または長整数でなければなりません。インタプリタは戻り値が"
"正しいかどうかをチェックし、要求に合わない場合に :exc:`TypeError` を送出しま"
"す。"

#: ../../whatsnew/2.5.rst:957
msgid ""
"A corresponding :c:member:`~PyNumberMethods.nb_index` slot was added to the "
"C-level :c:type:`PyNumberMethods` structure to let C extensions implement "
"this protocol. ``PyNumber_Index(obj)`` can be used in extension code to call "
"the :meth:`__index__` function and retrieve its result."
msgstr ""

#: ../../whatsnew/2.5.rst:965
msgid ":pep:`357` - Allowing Any Object to be Used for Slicing"
msgstr ":pep:`357` - スライシングのために任意のオブジェクトを使えるようにする"

#: ../../whatsnew/2.5.rst:966
msgid "PEP written  and implemented by Travis Oliphant."
msgstr "PEP 著と実装 Travis Oliphant."

#: ../../whatsnew/2.5.rst:974
msgid "Other Language Changes"
msgstr "その他の言語変更"

#: ../../whatsnew/2.5.rst:976
msgid ""
"Here are all of the changes that Python 2.5 makes to the core Python "
"language."
msgstr "以下が、Python 2.5 言語コアに加えられた全ての変更点です。"

#: ../../whatsnew/2.5.rst:978
msgid ""
"The :class:`dict` type has a new hook for letting subclasses provide a "
"default value when a key isn't contained in the dictionary. When a key isn't "
"found, the dictionary's ``__missing__(key)`` method will be called.  This "
"hook is used to implement the new :class:`defaultdict` class in the :mod:"
"`collections` module.  The following example defines a dictionary  that "
"returns zero for any missing key::"
msgstr ""
":class:`dict` 型に新たなフックが追加されています。サブクラスが、辞書に含まれ"
"ないキーに対してデフォルトを提供出来るようにするものです。キーが見つからない"
"場合、辞書の ``__missing__(key)`` メソッドが呼ばれます。このフックは :mod:"
"`collections` モジュール内の新しいクラス :class:`defaultdict` で使われていま"
"す。続く例は存在しないキーに対してゼロを返す辞書を定義しています::"

#: ../../whatsnew/2.5.rst:985
msgid ""
"class zerodict (dict):\n"
"    def __missing__ (self, key):\n"
"        return 0\n"
"\n"
"d = zerodict({1:1, 2:2})\n"
"print d[1], d[2]   # Prints 1, 2\n"
"print d[3], d[4]   # Prints 0, 0"
msgstr ""

#: ../../whatsnew/2.5.rst:993
msgid ""
"Both 8-bit and Unicode strings have new ``partition(sep)``  and "
"``rpartition(sep)`` methods that simplify a common use case."
msgstr ""
"8 ビット文字列、Unicode ともに、ありがちなユースケースを単純化する  "
"``partition(sep)`` と ``rpartition(sep)`` が追加されました。"

#: ../../whatsnew/2.5.rst:996
msgid ""
"The ``find(S)`` method is often used to get an index which is then used to "
"slice the string and obtain the pieces that are before and after the "
"separator. ``partition(sep)`` condenses this pattern into a single method "
"call that returns a 3-tuple containing the substring before the separator, "
"the separator itself, and the substring after the separator.  If the "
"separator isn't found, the first element of the tuple is the entire string "
"and the other two elements are empty.  ``rpartition(sep)`` also returns a 3-"
"tuple but starts searching from the end of the string; the ``r`` stands for "
"'reverse'."
msgstr ""
"文字列のスライスに使うために ``find(S)`` メソッドを使ってインデクスを得るのだ"
"けれども、やりたいのはそのセパレータ(S)の前後の部分文字列を得ることだ、といっ"
"たことはしょっちゅう必要になります。``partition(sep)`` はこのパターンのコード"
"を、一撃、に圧縮してくれます。これはセパレータ前の部分文字列、セパレータ自"
"身、セパレータ後の部分文字列の 3 要素タプルを返します。セパレータが含まれない"
"場合は、返却値の最初の要素に文字列全体が、残り2つは空文字列で返ります。"
"``rpartition(sep)`` もほぼ同じことをしますがセパレータの検索をお尻から始めま"
"す。 ``r`` は逆順('reverse')を表します。"

#: ../../whatsnew/2.5.rst:1005
msgid "Some examples::"
msgstr "いくつかの例です::"

#: ../../whatsnew/2.5.rst:1007
msgid ""
">>> ('http://www.python.org').partition('://')\n"
"('http', '://', 'www.python.org')\n"
">>> ('file:/usr/share/doc/index.html').partition('://')\n"
"('file:/usr/share/doc/index.html', '', '')\n"
">>> (u'Subject: a quick question').partition(':')\n"
"(u'Subject', u':', u' a quick question')\n"
">>> 'www.python.org'.rpartition('.')\n"
"('www.python', '.', 'org')\n"
">>> 'www.python.org'.rpartition(':')\n"
"('', '', 'www.python.org')"
msgstr ""

#: ../../whatsnew/2.5.rst:1018
msgid ""
"(Implemented by Fredrik Lundh following a suggestion by Raymond Hettinger.)"
msgstr ""
"(Implemented by Fredrik Lundh following a suggestion by Raymond Hettinger.)"

#: ../../whatsnew/2.5.rst:1020
msgid ""
"The :meth:`startswith` and :meth:`endswith` methods of string types now "
"accept tuples of strings to check for. ::"
msgstr ""
"文字列型の :meth:`startswith` と :meth:`endswith` メソッドが、チェックされる"
"文字列のタプルを受け容れるようになりました::"

#: ../../whatsnew/2.5.rst:1023
msgid ""
"def is_image_file (filename):\n"
"    return filename.endswith(('.gif', '.jpg', '.tiff'))"
msgstr ""

#: ../../whatsnew/2.5.rst:1026
msgid "(Implemented by Georg Brandl following a suggestion by Tom Lynn.)"
msgstr "(Implemented by Georg Brandl following a suggestion by Tom Lynn.)"

#: ../../whatsnew/2.5.rst:1030
msgid ""
"The :func:`min` and :func:`max` built-in functions gained a ``key`` keyword "
"parameter analogous to the ``key`` argument for :meth:`sort`.  This "
"parameter supplies a function that takes a single argument and is called for "
"every value in the list; :func:`min`/:func:`max` will return the element "
"with the smallest/largest return value from this function. For example, to "
"find the longest string in a list, you can do::"
msgstr ""
"ビルトイン関数 :func:`min` と :func:`max` に、 :meth:`sort` における ``key`` "
"に似たキーワード引数 ``key`` が追加されました。このパラメータには関数を与えま"
"す。これは一つの引数を取り、リスト内の全ての値に対して呼び出されます; :func:"
"`min`/:func:`max` はこの関数を全要素に適用したもののなかでの最小値/最大値を返"
"します。例えば、リスト中の最長の文字列を探すにはこのように出来ます::"

#: ../../whatsnew/2.5.rst:1037
msgid ""
"L = ['medium', 'longest', 'short']\n"
"# Prints 'longest'\n"
"print max(L, key=len)\n"
"# Prints 'short', because lexicographically 'short' has the largest value\n"
"print max(L)"
msgstr ""

#: ../../whatsnew/2.5.rst:1043
msgid "(Contributed by Steven Bethard and Raymond Hettinger.)"
msgstr "(Contributed by Steven Bethard and Raymond Hettinger.)"

#: ../../whatsnew/2.5.rst:1045
msgid ""
"Two new built-in functions, :func:`any` and :func:`all`, evaluate whether an "
"iterator contains any true or false values.  :func:`any` returns :const:"
"`True` if any value returned by the iterator is true; otherwise it will "
"return :const:`False`.  :func:`all` returns :const:`True` only if all of the "
"values returned by the iterator evaluate as true. (Suggested by Guido van "
"Rossum, and implemented by Raymond Hettinger.)"
msgstr ""
"2 つの新たなビルトイン関数 :func:`any` と :func:`all` は、イテレータがいくつ"
"か真を含むかどうかを評価します。 :func:`any` はイテレータのいずれかが返す値が"
"真と評価される場合に :const:`True` を返し、そうでなければ :const:`False` を返"
"します。 :func:`all` はイテレータが返す値の評価が真のみの場合に :const:"
"`True` を返します。 (Suggested by Guido van Rossum, and implemented by "
"Raymond Hettinger.)"

#: ../../whatsnew/2.5.rst:1052
msgid ""
"The result of a class's :meth:`__hash__` method can now be either a long "
"integer or a regular integer.  If a long integer is returned, the hash of "
"that value is taken.  In earlier versions the hash value was required to be "
"a regular integer, but in 2.5 the :func:`id` built-in was changed to always "
"return non-negative numbers, and users often seem to use ``id(self)`` in :"
"meth:`__hash__` methods (though this is discouraged)."
msgstr ""
"クラスの :meth:`__hash__` メソッドが返す値として、長整数と整数のどちらでも良"
"くなりました。長整数が返されれば、その値のハッシュから取られます。以前のバー"
"ジョンではこれは普通の整数であることが要求されていましたが、2.5 ではビルトイ"
"ン関数 :func:`id` が変更されて常に非負数が返り、ユーザはしばしば :meth:"
"`__hash__` 内で ``id(self)`` を使うようです (これはお奨めしませんが)。 (---訳"
"注: 不思議な論法で意味がわかりません。id が非負を返すとなぜユーザは __hash__ "
"の実装に使おうとするのか? ユーザがそれをしてしまうのは単にデフォルト実装がそ"
"うだから、というだけではないかと思います。__cmp__, __eq__ が「身元」以外の意"
"味を使って比較を行うならば、 __cmp__ で id を使うのはシンプルに「ダメ」でしょ"
"う。--)"

#: ../../whatsnew/2.5.rst:1061
msgid ""
"ASCII is now the default encoding for modules.  It's now  a syntax error if "
"a module contains string literals with 8-bit characters but doesn't have an "
"encoding declaration.  In Python 2.4 this triggered a warning, not a syntax "
"error.  See :pep:`263`  for how to declare a module's encoding; for example, "
"you might add  a line like this near the top of the source file::"
msgstr ""
"モジュールのデフォルトエンコーディングが ASCII になりました(訳注: Python 3 か"
"らはデフォルトは utf-8 (PEP 3120))。8 ビット文字を含んでいるのにエンコーディ"
"ング宣言がないモジュールが構文エラーになるようになりました。Python 2.4 では構"
"文エラーとはならず警告でした。モジュールのエンコーディングをする方法について"
"は :pep:`263` を参照してください; 例えば、ソースコードの先頭付近にこのような"
"行を追加することで出来ます::"

#: ../../whatsnew/2.5.rst:1067
msgid "# -*- coding: latin1 -*-"
msgstr ""

#: ../../whatsnew/2.5.rst:1069
msgid ""
"A new warning, :class:`UnicodeWarning`, is triggered when  you attempt to "
"compare a Unicode string and an 8-bit string  that can't be converted to "
"Unicode using the default ASCII encoding.   The result of the comparison is "
"false::"
msgstr ""
"Unicode 文字列とデフォルトの ASCII エンコーディングで Unicode に変換出来ない "
"8 ビット文字列との比較を試みると、新しい警告 :class:`UnicodeWarning` が引き起"
"こされるようになっています。比較結果は偽です::"

#: ../../whatsnew/2.5.rst:1073
msgid ""
">>> chr(128) == unichr(128)   # Can't convert chr(128) to Unicode\n"
"__main__:1: UnicodeWarning: Unicode equal comparison failed\n"
"  to convert both arguments to Unicode - interpreting them\n"
"  as being unequal\n"
"False\n"
">>> chr(127) == unichr(127)   # chr(127) can be converted\n"
"True"
msgstr ""

#: ../../whatsnew/2.5.rst:1081
msgid ""
"Previously this would raise a :class:`UnicodeDecodeError` exception, but in "
"2.5 this could result in puzzling problems when accessing a dictionary.  If "
"you looked up ``unichr(128)`` and ``chr(128)`` was being used as a key, "
"you'd get a :class:`UnicodeDecodeError` exception.  Other changes in 2.5 "
"resulted in this exception being raised instead of suppressed by the code "
"in :file:`dictobject.c` that implements dictionaries."
msgstr ""
"以前はこれは :class:`UnicodeDecodeError` を起こしていましたので、2.5 でのこれ"
"は辞書のアクセス時に悩ましい問題をもたらしました。キーとして使われている "
"``unichr(128)`` や ``chr(128)`` を探そうとすると :class:`UnicodeDecodeError` "
"例外が起こっていたでしょう。2.5 での、 辞書を実装している :file:`dictobject."
"c` のほかの変更により、これは揉み消すのではなく、引き続き例外を起こします(訳"
"注: 原文では this exception といっているので :class:`UnicodeDecodeError` が起"
"こるように読めるのですが、2.5 時点での振る舞いは確認出来ていませんが 2.7 で"
"は :class:`UnicodeWarning` とともに :exc:`KeyError` が発生する、のようになる"
"はずです。2.6 以降の What's New でのこれに関する言及はありませんが変更があっ"
"たのかもしれません)。"

#: ../../whatsnew/2.5.rst:1088
msgid ""
"Raising an exception for such a comparison is strictly correct, but the "
"change might have broken code, so instead  :class:`UnicodeWarning` was "
"introduced."
msgstr ""
"この種の比較で例外を起こすのは完全に正しいことではあるものの、その変更はコー"
"ドを破壊するかもしれないので、必要に応じて警告に出来るよう導入されたのが :"
"class:`UnicodeWarning` です。"

#: ../../whatsnew/2.5.rst:1091
msgid "(Implemented by Marc-André Lemburg.)"
msgstr "(Implemented by Marc-André Lemburg.)"

#: ../../whatsnew/2.5.rst:1093
msgid ""
"One error that Python programmers sometimes make is forgetting to include "
"an :file:`__init__.py` module in a package directory. Debugging this mistake "
"can be confusing, and usually requires running Python with the :option:`-v` "
"switch to log all the paths searched. In Python 2.5, a new :exc:"
"`ImportWarning` warning is triggered when an import would have picked up a "
"directory as a package but no :file:`__init__.py` was found.  This warning "
"is silently ignored by default; provide the :option:`-Wd <-W>` option when "
"running the Python executable to display the warning message. (Implemented "
"by Thomas Wouters.)"
msgstr ""
"Python プログラマがよくしでかす間違いとして、パッケージディレクトリに :file:"
"`__init__.py` を入れ忘れる、というものがあります。この間違いのデバッグはやや"
"こしく、大抵 Python を :option:`-v` スイッチ付きで起動して、パス検索全てをロ"
"グ出力するハメになります。Python 2.5 ではパッケージディレクトリに :file:"
"`__init__.py` がないことが検出されると新たに :exc:`ImportWarning` 警告を出す"
"ようになりました。デフォルトではこの警告は黙って無視されます; これを出したけ"
"れば、 :option:`-Wd <-W>` スイッチをつけて Python を起動してください。"
"(Implemented by Thomas Wouters.)"

#: ../../whatsnew/2.5.rst:1102
msgid ""
"The list of base classes in a class definition can now be empty.   As an "
"example, this is now legal::"
msgstr ""
"クラス定義において、基底クラスのリストを空リストに出来るようになっています(訳"
"注: object を派生しないので結果として旧スタイルクラスになります)。例えば以下"
"は今や合法です::"

#: ../../whatsnew/2.5.rst:1105
msgid ""
"class C():\n"
"    pass"
msgstr ""

#: ../../whatsnew/2.5.rst:1108
msgid "(Implemented by Brett Cannon.)"
msgstr "(Implemented by Brett Cannon.)"

#: ../../whatsnew/2.5.rst:1116
msgid "Interactive Interpreter Changes"
msgstr "対話的なインタプリタの変更"

#: ../../whatsnew/2.5.rst:1118
msgid ""
"In the interactive interpreter, ``quit`` and ``exit``  have long been "
"strings so that new users get a somewhat helpful message when they try to "
"quit::"
msgstr ""
"対話的なインタプリタ内では、 ``quit`` と ``exit``  はずっと、立ち去ろうと"
"(quit しようと)試みてそうタイプしてしまうユーザにとってある種有用な文字列に"
"なっていました::"

#: ../../whatsnew/2.5.rst:1121
msgid ""
">>> quit\n"
"'Use Ctrl-D (i.e. EOF) to exit.'"
msgstr ""

#: ../../whatsnew/2.5.rst:1124
msgid ""
"In Python 2.5, ``quit`` and ``exit`` are now objects that still produce "
"string representations of themselves, but are also callable. Newbies who try "
"``quit()`` or ``exit()`` will now exit the interpreter as they expect.  "
"(Implemented by Georg Brandl.)"
msgstr ""
"Python 2.5 でも ``quit`` と ``exit`` はそれ自身そのような文字列を生成はします"
"が、同時に「呼び出す」ことが出来るオブジェクトになっています。初心者が思わず "
"``quit()`` や ``exit()`` してしまった場合、今では彼らが期待する通りにインタプ"
"リタが終了します。  (Implemented by Georg Brandl.)"

#: ../../whatsnew/2.5.rst:1129
msgid ""
"The Python executable now accepts the standard long options  :option:`--"
"help` and :option:`--version`; on Windows,  it also accepts the :option:`/? "
"<-?>` option for displaying a help message. (Implemented by Georg Brandl.)"
msgstr ""
"Python 実行形式ファイルが標準的な長い形式の :option:`--help` と :option:`--"
"version` を受け付けるようになりました。Windows の場合はヘルプメッセージを出力"
"するのに :option:`/? <-?>` オプションも受け付けます。(Implemented by Georg "
"Brandl.)"

#: ../../whatsnew/2.5.rst:1139
msgid "Optimizations"
msgstr "最適化"

#: ../../whatsnew/2.5.rst:1141
msgid ""
"Several of the optimizations were developed at the NeedForSpeed sprint, an "
"event held in Reykjavik, Iceland, from May 21--28 2006. The sprint focused "
"on speed enhancements to the CPython implementation and was funded by EWT "
"LLC with local support from CCP Games.  Those optimizations added at this "
"sprint are specially marked in the following list."
msgstr ""
"この最適化のいくつかは、2006年5月21日から28日にかけてアイスランドのレイキャビ"
"クで開催されたイベント、NeedForSpeed sprintで開発されました。このスプリントは"
"CPythonの実装のスピードアップに焦点を当て、EWT LLCが資金を提供し、CCP Gamesが"
"現地でサポートしました。 このスプリントで追加された最適化については、以下のリ"
"ストで特別にマークしています。"

#: ../../whatsnew/2.5.rst:1147
msgid ""
"When they were introduced  in Python 2.4, the built-in :class:`set` and :"
"class:`frozenset` types were built on top of Python's dictionary type.   In "
"2.5 the internal data structure has been customized for implementing sets, "
"and as a result sets will use a third less memory and are somewhat faster. "
"(Implemented by Raymond Hettinger.)"
msgstr ""
"Python 2.4 が導入されたとき、組み込みの :class:`set` と :class:`frozenset` 型"
"は Python の辞書型の上に構築されたものでした。 Python 2.5 では、内部データ構"
"造がセットを実装するためにカスタマイズされ、その結果、セットのメモリ使用量は3"
"分の1になり、多少高速化されました。(Raymond Hettinger による実装。)"

#: ../../whatsnew/2.5.rst:1153
msgid ""
"The speed of some Unicode operations, such as finding substrings, string "
"splitting, and character map encoding and decoding, has been improved. "
"(Substring search and splitting improvements were added by Fredrik Lundh and "
"Andrew Dalke at the NeedForSpeed sprint. Character maps were improved by "
"Walter Dörwald and Martin von Löwis.)"
msgstr ""
"部分文字列の検索、文字列の分割、文字マップのエンコードとデコードなど、いくつ"
"かの Unicode 操作の速度が改善されました。 (部分文字列の検索と分割は、"
"NeedForSpeed スプリントで Fredrik Lundh と Andrew Dalke が追加しました。部分"
"文字列の検索と分割の改良は、NeedForSpeed sprintでFredrik LundhとAndrew Dalke"
"によって追加されました。文字マップは Walter Dörwald と Martin von Löwis に"
"よって改善されました。)"

#: ../../whatsnew/2.5.rst:1161
msgid ""
"The ``long(str, base)`` function is now faster on long digit strings because "
"fewer intermediate results are calculated.  The peak is for strings of "
"around 800--1000 digits where  the function is 6 times faster. (Contributed "
"by Alan McIntyre and committed at the NeedForSpeed sprint.)"
msgstr ""

#: ../../whatsnew/2.5.rst:1168
msgid ""
"It's now illegal to mix iterating over a file  with ``for line in file`` and "
"calling  the file object's :meth:`read`/:meth:`readline`/:meth:`readlines` "
"methods.  Iteration uses an internal buffer and the  :meth:`!read\\*` "
"methods don't use that buffer.   Instead they would return the data "
"following the buffer, causing the data to appear out of order.  Mixing "
"iteration and these methods will now trigger a :exc:`ValueError` from the :"
"meth:`!read\\*` method. (Implemented by Thomas Wouters.)"
msgstr ""

#: ../../whatsnew/2.5.rst:1178
msgid ""
"The :mod:`struct` module now compiles structure format  strings into an "
"internal representation and caches this representation, yielding a 20% "
"speedup. (Contributed by Bob Ippolito at the NeedForSpeed sprint.)"
msgstr ""

#: ../../whatsnew/2.5.rst:1182
msgid ""
"The :mod:`re` module got a 1 or 2% speedup by switching to  Python's "
"allocator functions instead of the system's  :c:func:`malloc` and :c:func:"
"`free`. (Contributed by Jack Diederich at the NeedForSpeed sprint.)"
msgstr ""
":mod:`re` モジュールは、システムの :c:func:`malloc` と :c:func:`free` の代わ"
"りに Python のアロケータ関数に切り替えることで、1～2%のスピードアップを達成し"
"ました。(NeedForSpeed sprintにてJack Diederichによるコントリビュート)"

#: ../../whatsnew/2.5.rst:1186
msgid ""
"The code generator's peephole optimizer now performs simple constant folding "
"in expressions.  If you write something like ``a = 2+3``, the code generator "
"will do the arithmetic and produce code corresponding to ``a = 5``.  "
"(Proposed and implemented  by Raymond Hettinger.)"
msgstr ""
"コードジェネレータの peephole オプティマイザは式の中で簡単な定数の折りたたみ"
"を実行するようになりました。 ``a = 2+3`` のように書くと、コードジェネレータは"
"算術演算を行い、 ``a = 5`` に対応するコードを生成します。 (Raymond Hettinger "
"による提案と実装。)"

#: ../../whatsnew/2.5.rst:1191
msgid ""
"Function calls are now faster because code objects now keep  the most "
"recently finished frame (a \"zombie frame\") in an internal field of the "
"code object, reusing it the next time the code object is invoked.  (Original "
"patch by Michael Hudson, modified by Armin Rigo and Richard Jones; committed "
"at the NeedForSpeed sprint.)  Frame objects are also slightly smaller, which "
"may improve cache locality and reduce memory usage a bit.  (Contributed by "
"Neal Norwitz.)"
msgstr ""

#: ../../whatsnew/2.5.rst:1201
msgid ""
"Python's built-in exceptions are now new-style classes, a change that speeds "
"up instantiation considerably.  Exception handling in Python 2.5 is "
"therefore about 30% faster than in 2.4. (Contributed by Richard Jones, Georg "
"Brandl and Sean Reifschneider at the NeedForSpeed sprint.)"
msgstr ""

#: ../../whatsnew/2.5.rst:1206
msgid ""
"Importing now caches the paths tried, recording whether  they exist or not "
"so that the interpreter makes fewer  :c:func:`open` and :c:func:`stat` calls "
"on startup. (Contributed by Martin von Löwis and Georg Brandl.)"
msgstr ""

#: ../../whatsnew/2.5.rst:1218
msgid "New, Improved, and Removed Modules"
msgstr "新たなモジュール、改良されたモジュール、削除されたモジュール"

#: ../../whatsnew/2.5.rst:1220
msgid ""
"The standard library received many enhancements and bug fixes in Python 2.5. "
"Here's a partial list of the most notable changes, sorted alphabetically by "
"module name. Consult the :file:`Misc/NEWS` file in the source tree for a "
"more complete list of changes, or look through the SVN logs for all the "
"details."
msgstr ""
"標準ライブラリは Python 2.5 で数多くの拡張とバグフィックスを行っています。こ"
"こでは注目に値する変更をモジュール名の辞書順で列挙します。変更についてのもっ"
"と完全なリストが見たければソースツリーの :file:`Misc/NEWS` を調べるか、全ての"
"詳細について SVN ログに目を通してみてください。"

#: ../../whatsnew/2.5.rst:1225
msgid ""
"The :mod:`!audioop` module now supports the a-LAW encoding, and the code for "
"u-LAW encoding has been improved.  (Contributed by Lars Immisch.)"
msgstr ""

#: ../../whatsnew/2.5.rst:1228
msgid ""
"The :mod:`codecs` module gained support for incremental codecs.  The :func:"
"`codec.lookup` function now returns a :class:`CodecInfo` instance instead of "
"a tuple. :class:`CodecInfo` instances behave like a 4-tuple to preserve "
"backward compatibility but also have the attributes :attr:`encode`, :attr:"
"`decode`, :attr:`incrementalencoder`, :attr:`incrementaldecoder`, :attr:"
"`streamwriter`, and :attr:`streamreader`.  Incremental codecs  can receive "
"input and produce output in multiple chunks; the output is the same as if "
"the entire input was fed to the non-incremental codec. See the :mod:`codecs` "
"module documentation for details. (Designed and implemented by Walter "
"Dörwald.)"
msgstr ""
":mod:`codecs` モジュールに漸増的コーデックのサポートが追加されています。 :"
"func:`codec.lookup` 関数がタプルではなく :class:`CodecInfo` を返すようになっ"
"ています。 :class:`CodecInfo` のインスタンスは後方互換性を維持するために 4 要"
"素タプルのように振舞うだけでなく、属性 :attr:`encode`, :attr:`decode`, :attr:"
"`incrementalencoder`, :attr:`incrementaldecoder`, :attr:`streamwriter`, :"
"attr:`streamreader` を持ちます。漸増的コーデックは入力を受け取って出力するの"
"を複数チャンクに分けて行えます; 出力は非漸増的コーデックに一回で入力全体を渡"
"したものと同じになります。詳細は :mod:`codecs` モジュールのドキュメントを参照"
"して下さい。 (Designed and implemented by Walter Dörwald.)"

#: ../../whatsnew/2.5.rst:1240
msgid ""
"The :mod:`collections` module gained a new type, :class:`defaultdict`, that "
"subclasses the standard :class:`dict` type.  The new type mostly behaves "
"like a dictionary but constructs a default value when a key isn't present, "
"automatically adding it to the dictionary for the requested key value."
msgstr ""
":mod:`collections` モジュールに新たに追加された :class:`defaultdict` 型は、標"
"準 :class:`dict` のサブクラスです。この新しい型はほとんど辞書と同じに振る舞"
"い、ただし、キーを要求された際にそのキーが存在していなかった場合に、自動的に"
"辞書にデフォルト値を追加します。"

#: ../../whatsnew/2.5.rst:1245
msgid ""
"The first argument to :class:`defaultdict`'s constructor is a factory "
"function that gets called whenever a key is requested but not found. This "
"factory function receives no arguments, so you can use built-in type "
"constructors such as :func:`list` or :func:`int`.  For example,  you can "
"make an index of words based on their initial letter like this::"
msgstr ""
":class:`defaultdict` のコンストラクタの最初の引数は、キーが要求されて存在しな"
"い場合に呼び出されるファクトリ関数です。ファクトリ関数は引数を取りません。つ"
"まりこれに該当する :func:`list` や :func:`int` のようなビルトイン型のコンスト"
"ラクタも使えます。例えば、その頭文字を基準に語の索引をこのように作ることが出"
"来ます::"

#: ../../whatsnew/2.5.rst:1251
msgid ""
"words = \"\"\"Nel mezzo del cammin di nostra vita\n"
"mi ritrovai per una selva oscura\n"
"che la diritta via era smarrita\"\"\".lower().split()\n"
"\n"
"index = defaultdict(list)\n"
"\n"
"for w in words:\n"
"    init_letter = w[0]\n"
"    index[init_letter].append(w)"
msgstr ""

#: ../../whatsnew/2.5.rst:1261
msgid "Printing ``index`` results in the following output::"
msgstr "``index`` を出力するとこんな具合です::"

#: ../../whatsnew/2.5.rst:1263
msgid ""
"defaultdict(<type 'list'>, {'c': ['cammin', 'che'], 'e': ['era'],\n"
"        'd': ['del', 'di', 'diritta'], 'm': ['mezzo', 'mi'],\n"
"        'l': ['la'], 'o': ['oscura'], 'n': ['nel', 'nostra'],\n"
"        'p': ['per'], 's': ['selva', 'smarrita'],\n"
"        'r': ['ritrovai'], 'u': ['una'], 'v': ['vita', 'via']}"
msgstr ""

#: ../../whatsnew/2.5.rst:1269
msgid "(Contributed by Guido van Rossum.)"
msgstr "(Contributed by Guido van Rossum.)"

#: ../../whatsnew/2.5.rst:1271
msgid ""
"The :class:`deque` double-ended queue type supplied by the :mod:"
"`collections` module now has a ``remove(value)`` method that removes the "
"first occurrence of *value* in the queue, raising :exc:`ValueError` if the "
"value isn't found. (Contributed by Raymond Hettinger.)"
msgstr ""
":mod:`collections` モジュールで提供されている両端キュー (double-ended queue) "
"型 :class:`deque` に、キュー内で最初に現れる *value* を削除するメソッド "
"``remove(value)`` メソッドが追加されています。 *value* が見つからなければ :"
"exc:`ValueError` が送出されます。 (Contributed by Raymond Hettinger.)"

#: ../../whatsnew/2.5.rst:1276
msgid ""
"New module: The :mod:`contextlib` module contains helper functions for use "
"with the new ':keyword:`with`' statement.  See section :ref:`contextlibmod` "
"for more about this module."
msgstr ""
"新規モジュール: :mod:`contextlib` モジュールには ':keyword:`with`' ステートメ"
"ントで使えるヘルパ関数が含まれています。詳細は :ref:`contextlibmod` をみてく"
"ださい。"

#: ../../whatsnew/2.5.rst:1280
msgid ""
"New module: The :mod:`cProfile` module is a C implementation of  the "
"existing :mod:`profile` module that has much lower overhead. The module's "
"interface is the same as :mod:`profile`: you run ``cProfile.run('main()')`` "
"to profile a function, can save profile data to a file, etc.  It's not yet "
"known if the Hotshot profiler, which is also written in C but doesn't match "
"the :mod:`profile` module's interface, will continue to be maintained in "
"future versions of Python.  (Contributed by Armin Rigo.)"
msgstr ""
"新規モジュール: :mod:`cProfile` モジュールは既存の :mod:`profile` モジュール"
"の C 実装で、遥かに小さなオーバヘッドで実行出来ます。モジュールのインターフェ"
"イスは :mod:`profile` と同じです: 関数をプロファイルするのには ``cProfile."
"run('main()')`` と実行し、プロファイル結果をファイルに書き出すなど出来ます。"
"これは Hotshot プロファイラとして知られるものではないですが (これも C で書か"
"れてますが :mod:`profile` モジュールのインターフェイスとは別物です)、将来バー"
"ジョンの Python で保守が続けられる予定です。(Contributed by Armin Rigo.)"

#: ../../whatsnew/2.5.rst:1288
msgid ""
"Also, the :mod:`pstats` module for analyzing the data measured by the "
"profiler now supports directing the output to any file object by supplying a "
"*stream* argument to the :class:`Stats` constructor. (Contributed by Skip "
"Montanaro.)"
msgstr ""
"また、プロファイラによる計測データの解析のための :mod:`pstats` モジュール"
"が、 :class:`Stats` コンストラクタの *stream* 引数による直接ファイル出力に対"
"応しました。 (Contributed by Skip Montanaro.)"

#: ../../whatsnew/2.5.rst:1292
msgid ""
"The :mod:`csv` module, which parses files in comma-separated value format, "
"received several enhancements and a number of bugfixes.  You can now set the "
"maximum size in bytes of a field by calling the ``csv."
"field_size_limit(new_limit)`` function; omitting the *new_limit* argument "
"will return the currently set limit.  The :class:`reader` class now has a :"
"attr:`line_num` attribute that counts the number of physical lines read from "
"the source; records can span multiple physical lines, so :attr:`line_num` is "
"not the same as the number of records read."
msgstr ""

#: ../../whatsnew/2.5.rst:1301
msgid ""
"The CSV parser is now stricter about multi-line quoted fields. Previously, "
"if a line ended within a quoted field without a terminating newline "
"character, a newline would be inserted into the returned field. This "
"behavior caused problems when reading files that contained carriage return "
"characters within fields, so the code was changed to return the field "
"without inserting newlines. As a consequence, if newlines embedded within "
"fields are important, the input should be split into lines in a manner that "
"preserves the newline characters."
msgstr ""
"CSV パーサは引用符内のマルチラインをより厳密に扱うようになっています。以前"
"は、引用符で囲まれたフィールドが改行文字(newline)で終了することなく終端する"
"と、改行文字が返却フィールドに追加されていました。この振る舞いはフィールドに"
"復帰文字(carriage return)を含んだファイルを読み込む際に問題だったため、改行文"
"字を挿入することなくフィールドを返すように変更されました。このことにより、"
"フィールド内に埋め込まれた改行文字が重要な場合、入力は改行文字が保存される方"
"法で行分割されるはずです。(---訳注: リファレンスも含めこの説明の表現がわかり"
"にくいです。行指向で読み込む場合改行コードのモード(NL, CR NL, CR)依存で「物理"
"行が終了した」とみなされるわけですが、このモード依存(CR 時)の振る舞いがなく"
"なった、ということです。---)"

#: ../../whatsnew/2.5.rst:1309
msgid "(Contributed by Skip Montanaro and Andrew McNamara.)"
msgstr "(Contributed by Skip Montanaro and Andrew McNamara.)"

#: ../../whatsnew/2.5.rst:1311
msgid ""
"The :class:`~datetime.datetime` class in the :mod:`datetime`  module now has "
"a ``strptime(string, format)``  method for parsing date strings, contributed "
"by Josh Spoerri. It uses the same format characters as :func:`time.strptime` "
"and :func:`time.strftime`::"
msgstr ""

#: ../../whatsnew/2.5.rst:1316
msgid ""
"from datetime import datetime\n"
"\n"
"ts = datetime.strptime('10:13:15 2006-03-07',\n"
"                       '%H:%M:%S %Y-%m-%d')"
msgstr ""

#: ../../whatsnew/2.5.rst:1321
msgid ""
"The :meth:`SequenceMatcher.get_matching_blocks` method in the :mod:`difflib` "
"module now guarantees to return a minimal list of blocks describing matching "
"subsequences.  Previously, the algorithm would occasionally break a block of "
"matching elements into two list entries. (Enhancement by Tim Peters.)"
msgstr ""
":mod:`difflib` モジュールのメソッド :meth:`SequenceMatcher."
"get_matching_blocks` が、合致するサブシーケンスを記述するブロックについて、最"
"小範囲リストを返すよう保障するようになりました。以前は時折 2 つのリストエント"
"リに合致要素ブロックが分割されることがありました。(Enhancement by Tim "
"Peters.)"

#: ../../whatsnew/2.5.rst:1326
msgid ""
"The :mod:`doctest` module gained a ``SKIP`` option that keeps an example "
"from being executed at all.  This is intended for code snippets that are "
"usage examples intended for the reader and aren't actually test cases."
msgstr ""
":mod:`doctest` モジュールに、実行されるべきものから例を守る ``SKIP`` オプショ"
"ンが追加されています。これは、読者のための使用例として意図しているけれども実"
"際のテストケースとして意図していないようなコードスニペットのために用意されま"
"した。"

#: ../../whatsnew/2.5.rst:1330
msgid ""
"An *encoding* parameter was added to the :func:`testfile` function and the :"
"class:`DocFileSuite` class to specify the file's encoding.  This makes it "
"easier to use non-ASCII characters in  tests contained within a docstring. "
"(Contributed by Bjorn Tillenius.)"
msgstr ""
":func:`testfile` 関数と :class:`DocFileSuite` にファイルのエンコーディングを"
"指定するための *encoding* パラメータが追加されました。これにより docstring 内"
"に非 ASCII 文字列を含むテストが簡単になります。(Contributed by Bjorn "
"Tillenius.)"

#: ../../whatsnew/2.5.rst:1337
msgid ""
"The :mod:`email` package has been updated to version 4.0. (Contributed by "
"Barry Warsaw.)"
msgstr ""
":mod:`email` パッケージがバージョン 4.0 にアップデートされました "
"(Contributed by Barry Warsaw.)"

#: ../../whatsnew/2.5.rst:1345
msgid ""
"The :mod:`fileinput` module was made more flexible. Unicode filenames are "
"now supported, and a *mode* parameter that defaults to ``\"r\"`` was added "
"to the :func:`input` function to allow opening files in binary or :term:"
"`universal newlines` mode.  Another new parameter, *openhook*, lets you use "
"a function other than :func:`open`  to open the input files.  Once you're "
"iterating over the set of files, the :class:`FileInput` object's new :meth:"
"`~fileinput.fileno` returns the file descriptor for the currently opened "
"file. (Contributed by Georg Brandl.)"
msgstr ""

#: ../../whatsnew/2.5.rst:1354
msgid ""
"In the :mod:`gc` module, the new :func:`get_count` function returns a 3-"
"tuple containing the current collection counts for the three GC "
"generations.  This is accounting information for the garbage collector; when "
"these counts reach a specified threshold, a garbage collection sweep will be "
"made.  The existing :func:`gc.collect` function now takes an optional "
"*generation* argument of 0, 1, or 2 to specify which generation to collect. "
"(Contributed by Barry Warsaw.)"
msgstr ""
":mod:`gc` モジュールに、新しい関数 :func:`get_count` が追加されています。これ"
"は GC 3 世代についての現在の検出を含む 3 要素タプルを返します。これはガーベー"
"ジコレクタの決算情報です; これらの数が指定された閾値に到達すると、ガーベージ"
"コレクトのスイープが起こります。既存の :func:`gc.collect` 関数は省略可能な "
"*generation* 引数を取るようになっていて、これはどの世代を検出するかを指定す"
"る 0、1、2 です。 (Contributed by Barry Warsaw.)"

#: ../../whatsnew/2.5.rst:1361
msgid ""
"The :func:`nsmallest` and  :func:`nlargest` functions in the :mod:`heapq` "
"module  now support a ``key`` keyword parameter similar to the one provided "
"by the :func:`min`/:func:`max` functions and the :meth:`sort` methods.  For "
"example::"
msgstr ""
":mod:`heapq` モジュールの :func:`nsmallest` 関数と :func:`nlargest` 関数が"
"キーワードパラメータ ``key`` をサポートするようになっています。これは :func:"
"`min`/:func:`max` 関数と :meth:`sort` メソッドで提供されているものと似たもの"
"です。例えば::"

#: ../../whatsnew/2.5.rst:1366
msgid ""
">>> import heapq\n"
">>> L = [\"short\", 'medium', 'longest', 'longer still']\n"
">>> heapq.nsmallest(2, L)  # Return two lowest elements, lexicographically\n"
"['longer still', 'longest']\n"
">>> heapq.nsmallest(2, L, key=len)   # Return two shortest elements\n"
"['short', 'medium']"
msgstr ""

#: ../../whatsnew/2.5.rst:1373 ../../whatsnew/2.5.rst:1382
msgid "(Contributed by Raymond Hettinger.)"
msgstr "(Contributed by Raymond Hettinger.)"

#: ../../whatsnew/2.5.rst:1375
msgid ""
"The :func:`itertools.islice` function now accepts ``None`` for the start and "
"step arguments.  This makes it more compatible with the attributes of slice "
"objects, so that you can now write the following::"
msgstr ""
":func:`itertools.islice` 関数が start と step として ``None`` を受け付けるよ"
"うになっています。これは slice オブジェクトとの互換性を高めるもので、つまり以"
"下のように書くことが出来ます::"

#: ../../whatsnew/2.5.rst:1379
msgid ""
"s = slice(5)     # Create slice object\n"
"itertools.islice(iterable, s.start, s.stop, s.step)"
msgstr ""

#: ../../whatsnew/2.5.rst:1384
msgid ""
"The :func:`format` function in the :mod:`locale` module has been modified "
"and two new functions were added, :func:`format_string` and :func:`currency`."
msgstr ""
":mod:`locale` モジュールの :func:`format` 関数が更新され、2 つの関数 :func:"
"`format_string` と :func:`currency` が追加されました。"

#: ../../whatsnew/2.5.rst:1387
msgid ""
"The :func:`format` function's *val* parameter could previously be a string "
"as long as no more than one %char specifier appeared; now the parameter must "
"be exactly one %char specifier with no surrounding text.  An optional "
"*monetary* parameter was also added which, if ``True``, will use the "
"locale's rules for formatting currency in placing a separator between groups "
"of three digits."
msgstr ""
":func:`format` 関数の *val* パラメータは以前は一つ以上の %文字指定子が現れる"
"文字列が許されていました; 今はこのパラメータは正確に一つの %文字指定子を含"
"む、周りに囲むテキストのない文字列でなければなりません。省略可能な "
"*monetary* パラメータも追加されています。これが ``True`` の場合、通貨の書式化"
"の 3 桁ごとに区切るセパレータに、ロケールのルールを使います。"

#: ../../whatsnew/2.5.rst:1393
msgid ""
"To format strings with multiple %char specifiers, use the new :func:"
"`format_string` function that works like :func:`format` but also supports "
"mixing %char specifiers with arbitrary text."
msgstr ""
"複数 %文字指定子を含む文字列をフォーマットするには、 :func:`format` のように"
"働き、任意のテキストと %文字指定子を混ぜた文字列をサポートする新しい :func:"
"`format_string` 関数を使ってください。"

#: ../../whatsnew/2.5.rst:1397
msgid ""
"A new :func:`currency` function was also added that formats a number "
"according to the current locale's settings."
msgstr ""
"現在ロケール設定に関連した数字を書式化する :func:`currency` 関数も追加されて"
"います。"

#: ../../whatsnew/2.5.rst:1400
msgid "(Contributed by Georg Brandl.)"
msgstr "(Contributed by Georg Brandl.)"

#: ../../whatsnew/2.5.rst:1404
msgid ""
"The :mod:`mailbox` module underwent a massive rewrite to add the capability "
"to modify mailboxes in addition to reading them.  A new set of classes that "
"include :class:`mbox`, :class:`MH`, and :class:`Maildir` are used to read "
"mailboxes, and have an ``add(message)`` method to add messages, "
"``remove(key)`` to remove messages, and :meth:`lock`/:meth:`unlock` to lock/"
"unlock the mailbox. The following example converts a maildir-format mailbox "
"into an mbox-format one::"
msgstr ""
":mod:`mailbox` モジュールでは、メールボックスについてそれを読むことに加えて修"
"正出来る能力を追加するための、大々的な書き換えが行われています。 :class:"
"`mbox`, :class:`MH`, :class:`Maildir` を含む新しいクラス群はメールボックス読"
"み込みに使われますが、メッセージ追加のための ``add(message)`` 、削除の "
"``remove(key)`` 、ロック/アンロックのための :meth:`lock`/:meth:`unlock` も"
"持っています。続く例は maildir 形式から mbox 形式に変換する例です::"

#: ../../whatsnew/2.5.rst:1412
msgid ""
"import mailbox\n"
"\n"
"# 'factory=None' uses email.Message.Message as the class representing\n"
"# individual messages.\n"
"src = mailbox.Maildir('maildir', factory=None)\n"
"dest = mailbox.mbox('/tmp/mbox')\n"
"\n"
"for msg in src:\n"
"    dest.add(msg)"
msgstr ""

#: ../../whatsnew/2.5.rst:1422
msgid ""
"(Contributed by Gregory K. Johnson.  Funding was provided by Google's 2005 "
"Summer of Code.)"
msgstr ""
"(Contributed by Gregory K. Johnson.  Funding was provided by Google's 2005 "
"Summer of Code.)"

#: ../../whatsnew/2.5.rst:1425
msgid ""
"New module: the :mod:`!msilib` module allows creating Microsoft Installer :"
"file:`.msi` files and CAB files.  Some support for reading the :file:`.msi` "
"database is also included. (Contributed by Martin von Löwis.)"
msgstr ""

#: ../../whatsnew/2.5.rst:1429
msgid ""
"The :mod:`!nis` module now supports accessing domains other than the system "
"default domain by supplying a *domain* argument to the :func:`!nis.match` "
"and :func:`!nis.maps` functions. (Contributed by Ben Bell.)"
msgstr ""

#: ../../whatsnew/2.5.rst:1433
msgid ""
"The :mod:`operator` module's :func:`itemgetter`  and :func:`attrgetter` "
"functions now support multiple fields.   A call such as ``operator."
"attrgetter('a', 'b')`` will return a function  that retrieves the :attr:`a` "
"and :attr:`b` attributes.  Combining  this new feature with the :meth:`sort` "
"method's ``key`` parameter  lets you easily sort lists using multiple "
"fields. (Contributed by Raymond Hettinger.)"
msgstr ""
":mod:`operator` モジュールの :func:`itemgetter` 関数と :func:`attrgetter` 関"
"数が複数フィールドをサポートするようになりました。 ``operator."
"attrgetter('a', 'b')`` のように呼び出すと、 :attr:`a` と :attr:`b` 属性を取り"
"出す関数を返します。この新機能と :meth:`sort` メソッドの ``key`` パラメータを"
"組み合わせると、複数フィールドでのリストのソートが簡単になります。"

#: ../../whatsnew/2.5.rst:1440
msgid ""
"The :mod:`optparse` module was updated to version 1.5.1 of the Optik "
"library. The :class:`OptionParser` class gained an :attr:`epilog` attribute, "
"a string that will be printed after the help message, and a :meth:`destroy` "
"method to break reference cycles created by the object. (Contributed by Greg "
"Ward.)"
msgstr ""
":mod:`optparse` モジュールが Optik ライブラリのバージョン 1.5.1 に更新されま"
"した。 :class:`OptionParser` クラスに :attr:`epilog` 属性と :meth:`destroy` "
"メソッドが追加されています。前者はヘルプメッセージのあとに出力される文字列で"
"す。後者はオブジェクトによって作られた循環参照を破棄します。 (Contributed by "
"Greg Ward.)"

#: ../../whatsnew/2.5.rst:1445
msgid ""
"The :mod:`os` module underwent several changes.  The :attr:"
"`stat_float_times` variable now defaults to true, meaning that :func:`os."
"stat` will now return time values as floats.  (This doesn't necessarily mean "
"that :func:`os.stat` will return times that are precise to fractions of a "
"second; not all systems support such precision.)"
msgstr ""
":mod:`os` モジュールに多数の変更がありました。 :attr:`stat_float_times` 値の"
"デフォルトが真となっていて、これはつまり :func:`os.stat` が時刻の値を浮動小数"
"点数で返すということです。(ただし必ずしも :func:`os.stat` が秒の端数が正確な"
"値を返すという意味ではありません; 全てのシステムがそのような精度をサポートし"
"てはいません。)"

#: ../../whatsnew/2.5.rst:1451
msgid ""
"Constants named :const:`os.SEEK_SET`, :const:`os.SEEK_CUR`, and :const:`os."
"SEEK_END` have been added; these are the parameters to the :func:`os.lseek` "
"function.  Two new constants for locking are :const:`os.O_SHLOCK` and :const:"
"`os.O_EXLOCK`."
msgstr ""

#: ../../whatsnew/2.5.rst:1456
msgid ""
"Two new functions, :func:`wait3` and :func:`wait4`, were added.  They're "
"similar the :func:`waitpid` function which waits for a child process to exit "
"and returns a tuple of the process ID and its exit status, but :func:`wait3` "
"and :func:`wait4` return additional information.  :func:`wait3` doesn't take "
"a process ID as input, so it waits for any child process to exit and returns "
"a 3-tuple of *process-id*, *exit-status*, *resource-usage* as returned from "
"the :func:`resource.getrusage` function. ``wait4(pid)`` does take a process "
"ID. (Contributed by Chad J. Schroeder.)"
msgstr ""
"2 つの新しい関数 :func:`wait3` と :func:`wait4` が追加されています。これら"
"は :func:`waitpid` 関数に似ています。これは子プロセスが終了するのを待ってプロ"
"セス ID とその終了コードを返しますが、 :func:`wait3` と :func:`wait4` は追加"
"の情報を返します。 :func:`wait3` はプロセス ID を入力に取りませんので任意の子"
"プロセス終了を待ち、 :func:`resource.getrusage` 関数から返る *process-id*, "
"*exit-status*, *resource-usage* の 3 要素タプルを返します。 ``wait4(pid)`` は"
"プロセス ID を取ります。 (Contributed by Chad J. Schroeder.)"

#: ../../whatsnew/2.5.rst:1465
msgid ""
"On FreeBSD, the :func:`os.stat` function now returns  times with nanosecond "
"resolution, and the returned object now has :attr:`st_gen` and :attr:"
"`st_birthtime`. The :attr:`st_flags` attribute is also available, if the "
"platform supports it. (Contributed by Antti Louko and  Diego Pettenò.)"
msgstr ""
"FreeBSD では、 :func:`os.stat` 関数がナノ秒精度の時刻を返し、また、返却オブ"
"ジェクトが :attr:`st_gen` と :attr:`st_birthtime` を持つようになっていま"
"す。 :attr:`st_flags` 属性も、プラットフォームがサポートされている場合には利"
"用可能です。 (Contributed by Antti Louko and Diego Pettenò.)"

#: ../../whatsnew/2.5.rst:1472
msgid ""
"The Python debugger provided by the :mod:`pdb` module can now store lists of "
"commands to execute when a breakpoint is reached and execution stops.  Once "
"breakpoint #1 has been created, enter ``commands 1`` and enter a series of "
"commands to be executed, finishing the list with ``end``.  The command list "
"can include commands that resume execution, such as ``continue`` or "
"``next``. (Contributed by Grégoire Dooms.)"
msgstr ""
":mod:`pdb` モジュールで提供される Python デバッガが、ブレイクポイントに到達し"
"て実行が停止する際に実行するコマンドのリストを記憶するようになりました。ブレ"
"イクポイント #1 を作ったら、 ``commands 1`` を入力し、実行するコマンド群を入"
"力し、 ``end`` でリストを終えます。コマンドリストには ``continue`` や "
"``next`` のような実行再開コマンドを含めることが出来ます。 (Contributed by "
"Grégoire Dooms.)"

#: ../../whatsnew/2.5.rst:1481
msgid ""
"The :mod:`pickle` and :mod:`!cPickle` modules no longer accept a return "
"value of ``None`` from the :meth:`~object.__reduce__` method; the method "
"must return a tuple of arguments instead.  The ability to return ``None`` "
"was deprecated in Python 2.4, so this completes the removal of the feature."
msgstr ""

#: ../../whatsnew/2.5.rst:1486
msgid ""
"The :mod:`pkgutil` module, containing various utility functions for finding "
"packages, was enhanced to support :pep:`302`'s import hooks and now also "
"works for packages stored in ZIP-format archives. (Contributed by Phillip J. "
"Eby.)"
msgstr ""

#: ../../whatsnew/2.5.rst:1490
msgid ""
"The pybench benchmark suite by Marc-André Lemburg is now included in the :"
"file:`Tools/pybench` directory.  The pybench suite is an improvement on the "
"commonly used :file:`pystone.py` program because pybench provides a more "
"detailed measurement of the interpreter's speed.  It times particular "
"operations such as function calls, tuple slicing, method lookups, and "
"numeric operations, instead of performing many different operations and "
"reducing the result to a single number as :file:`pystone.py` does."
msgstr ""
"Marc-André Lemburg による pybench ベンチマークスイートが :file:`Tools/"
"pybench` ディレクトリに含まれるようになりました。pybench スイートは、広く使わ"
"れている :file:`pystone.py` プログラムの改善版で、インタプリタの速度について"
"のより詳しい計測を行います。 :file:`pystone.py` のように多くの異なる演算を実"
"行したり単独の数字に縮退する代わりに、これは関数コール、タプルのスライス、メ"
"ソッドの検索、数値演算のような特定の演算を計測します。 (---訳注: Tools につい"
"ての言及すべてに共通することですが、原則として Tools は「全て」を入手する手段"
"はソースコード配布を利用することだけです。インストールされるものはプラット"
"フォーム依存や linux であればディストリビュータによっても変わります。顕著なの"
"は Windows で、Tools 配下のものはごく限られたものだけがインストールされます。"
"pybench もソースコード配布物にのみ含まれ、Windows 公式インストーラではインス"
"トールされません。なお、 :file:`pystone.py` は Lib/test 内にあります。---)"

#: ../../whatsnew/2.5.rst:1498
msgid ""
"The :mod:`pyexpat` module now uses version 2.0 of the Expat parser. "
"(Contributed by Trent Mick.)"
msgstr ""
":mod:`pyexpat` モジュールが使う Expat パーサをバージョン 2.0 にしました。 "
"(Contributed by Trent Mick.)"

#: ../../whatsnew/2.5.rst:1501
msgid ""
"The :class:`~queue.Queue` class provided by the :mod:`Queue` module gained "
"two new methods.  :meth:`join` blocks until all items in the queue have been "
"retrieved and all processing work on the items  have been completed.  Worker "
"threads call the other new method,  :meth:`task_done`, to signal that "
"processing for an item has been completed.  (Contributed by Raymond "
"Hettinger.)"
msgstr ""

#: ../../whatsnew/2.5.rst:1507
msgid ""
"The old :mod:`regex` and :mod:`regsub` modules, which have been  deprecated "
"ever since Python 2.0, have finally been deleted.   Other deleted modules: :"
"mod:`statcache`, :mod:`tzparse`, :mod:`whrandom`."
msgstr ""
"古い :mod:`regex`, :mod:`regsub` モジュール、これは Python 2.0 からずっと非推"
"奨になっていましたが、ついに削除されました。ほかにも、 :mod:`statcache`, :"
"mod:`tzparse`, :mod:`whrandom` が削除されています。"

#: ../../whatsnew/2.5.rst:1511
msgid ""
"Also deleted: the :file:`lib-old` directory, which includes ancient modules "
"such as :mod:`dircmp` and :mod:`ni`, was removed.  :file:`lib-old` wasn't on "
"the default ``sys.path``, so unless your programs explicitly added the "
"directory to ``sys.path``, this removal shouldn't affect your code."
msgstr ""
":mod:`dircmp` や :mod:`ni` といった石器時代のモジュールを大事にしまっていた :"
"file:`lib-old` ディレクトリも削除されました。  :file:`lib-old` がデフォルト"
"で ``sys.path`` に含まれることはなかったので、あなたが明示的にそれを ``sys."
"path`` に入れてこなかった限り、この削除はあなたには関係ないでしょう。"

#: ../../whatsnew/2.5.rst:1516
msgid ""
"The :mod:`rlcompleter` module is no longer  dependent on importing the :mod:"
"`readline` module and therefore now works on non-Unix platforms. (Patch from "
"Robert Kiendl.)"
msgstr ""
":mod:`rlcompleter` モジュールが :mod:`readline` モジュールのインポートに依存"
"しないようになりました。これにより非 Unix プラットフォームで動作するようにな"
"りました。 (Patch from Robert Kiendl.)"

#: ../../whatsnew/2.5.rst:1522
msgid ""
"The :mod:`SimpleXMLRPCServer <xmlrpc.server>` and :mod:`DocXMLRPCServer "
"<xmlrpc.server>`  classes now have a :attr:`rpc_paths` attribute that "
"constrains XML-RPC operations to a limited set of URL paths; the default is "
"to allow only ``'/'`` and ``'/RPC2'``.  Setting :attr:`rpc_paths` to "
"``None`` or an empty tuple disables  this path checking."
msgstr ""

#: ../../whatsnew/2.5.rst:1529
msgid ""
"The :mod:`socket` module now supports :const:`AF_NETLINK` sockets on Linux, "
"thanks to a patch from Philippe Biondi.   Netlink sockets are a Linux-"
"specific mechanism for communications between a user-space process and "
"kernel code; an introductory  article about them is at https://www."
"linuxjournal.com/article/7356. In Python code, netlink addresses are "
"represented as a tuple of 2 integers, ``(pid, group_mask)``."
msgstr ""

#: ../../whatsnew/2.5.rst:1536
msgid ""
"Two new methods on socket objects, ``recv_into(buffer)`` and "
"``recvfrom_into(buffer)``, store the received data in an object  that "
"supports the buffer protocol instead of returning the data as a string.  "
"This means you can put the data directly into an array or a memory-mapped "
"file."
msgstr ""
"ソケットオブジェクトの 2 つの新たなメソッド、 ``recv_into(buffer)``, "
"``recvfrom_into(buffer)`` は、受信データを、文字列データとして返す代わりに"
"バッファプロトコルをサポートするオブジェクトに書き込みます。このことにより、"
"受信データを直接 array やメモリマップドファイルに置けます。"

#: ../../whatsnew/2.5.rst:1541
msgid ""
"Socket objects also gained :meth:`getfamily`, :meth:`gettype`, and :meth:"
"`getproto` accessor methods to retrieve the family, type, and protocol "
"values for the socket."
msgstr ""
"ソケットオブジェクトには :meth:`getfamily`, :meth:`gettype`, :meth:"
"`getproto` アクセッサメソッドも追加されています。それぞれソケットについてのア"
"ドレスファミリ、タイプ、プロトコルを取得します。"

#: ../../whatsnew/2.5.rst:1545
msgid ""
"New module: the :mod:`!spwd` module provides functions for accessing the "
"shadow password database on systems that support  shadow passwords."
msgstr ""

#: ../../whatsnew/2.5.rst:1548
msgid ""
"The :mod:`struct` is now faster because it  compiles format strings into :"
"class:`Struct` objects with :meth:`pack` and :meth:`unpack` methods.  This "
"is similar to how the :mod:`re` module lets you create compiled regular "
"expression objects.  You can still use the module-level  :func:`pack` and :"
"func:`unpack` functions; they'll create  :class:`Struct` objects and cache "
"them.  Or you can use  :class:`Struct` instances directly::"
msgstr ""
":meth:`pack`, :meth:`unpack` メソッドでフォーマット文字列を :class:`Struct` "
"オブジェクトにコンパイルすることで、 :mod:`struct` がより高速になっています。"
"これは :mod:`re` モジュールでコンパイル済み正規表現オブジェクトを作れるのに似"
"ています。モジュールレベルの :func:`pack`, :func:`unpack` 関数もそのまま使え"
"ます; それらは :class:`Struct` オブジェクトを作ってキャッシュします。あるい"
"は :class:`Struct` インスタンスを直接使えます::"

#: ../../whatsnew/2.5.rst:1555
msgid ""
"s = struct.Struct('ih3s')\n"
"\n"
"data = s.pack(1972, 187, 'abc')\n"
"year, number, name = s.unpack(data)"
msgstr ""

#: ../../whatsnew/2.5.rst:1560
msgid ""
"You can also pack and unpack data to and from buffer objects directly using "
"the ``pack_into(buffer, offset, v1, v2, ...)`` and ``unpack_from(buffer, "
"offset)`` methods.  This lets you store data directly into an array or a "
"memory-mapped file."
msgstr ""

#: ../../whatsnew/2.5.rst:1565
msgid ""
"(:class:`Struct` objects were implemented by Bob Ippolito at the "
"NeedForSpeed sprint.  Support for buffer objects was added by Martin Blais, "
"also at the NeedForSpeed sprint.)"
msgstr ""
"(:class:`Struct` objects were implemented by Bob Ippolito at the "
"NeedForSpeed sprint.  Support for buffer objects was added by Martin Blais, "
"also at the NeedForSpeed sprint.)"

#: ../../whatsnew/2.5.rst:1569
msgid ""
"The Python developers switched from CVS to Subversion during the 2.5 "
"development process.  Information about the exact build version is available "
"as the ``sys.subversion`` variable, a 3-tuple of ``(interpreter-name, branch-"
"name, revision-range)``.  For example, at the time of writing my copy of 2.5 "
"was reporting ``('CPython', 'trunk', '45313:45315')``."
msgstr ""
"Python デベロッパは 2.5 開発プロセスの間で CVS から Subversion に移行しまし"
"た。ビルドバージョンについての正確な情報は ``sys.subversion`` により取得可能"
"で、これは 3 要素タプル ``(interpreter-name, branch-name, revision-range)`` "
"です。例えば執筆時点では 2.5 で ``('CPython', 'trunk', '45313:45315')`` を返"
"します。 (---訳注: Python 3.2 から 3.3 にかけて、開発が Mercurial に移行して"
"いて、これは 2.7 メンテナンスリリースの間にあたります。今(3.6 dev 時点)では全"
"て Mercurial に移行しており、 ``sys.subversion`` は今では意味のある値は返しま"
"せん。3.3 からは既に ``sys.subversion`` は削除されています。---)"

#: ../../whatsnew/2.5.rst:1575
msgid ""
"This information is also available to C extensions via the :c:func:"
"`Py_GetBuildInfo` function that returns a  string of build information like "
"this: ``\"trunk:45355:45356M, Apr 13 2006, 07:42:19\"``.   (Contributed by "
"Barry Warsaw.)"
msgstr ""
"この情報は C 拡張から :c:func:`Py_GetBuildInfo` 関数を使っても得ることが出来"
"ます。これはビルド情報についての文字列を返し、例えば ``\"trunk:45355:45356M, "
"Apr 13 2006, 07:42:19\"`` のような値です。 (Contributed by Barry Warsaw.)"

#: ../../whatsnew/2.5.rst:1580
msgid ""
"Another new function, :func:`sys._current_frames`, returns the current stack "
"frames for all running threads as a dictionary mapping thread identifiers to "
"the topmost stack frame currently active in that thread at the time the "
"function is called.  (Contributed by Tim Peters.)"
msgstr ""
"もう一つの新規関数 :func:`sys._current_frames` は、実行スレッドについての現在"
"スタックフレームを、各スレッドの識別子がキーの辞書として返します。辞書の値"
"は、関数が呼ばれた時点のそのスレッドで現在アクティブになっているスタックフ"
"レームの一番上です。(Contributed by Tim Peters.)"

#: ../../whatsnew/2.5.rst:1585
msgid ""
"The :class:`TarFile` class in the :mod:`tarfile` module now has an :meth:"
"`extractall` method that extracts all members from the archive into the "
"current working directory.  It's also possible to set a different directory "
"as the extraction target, and to unpack only a subset of the archive's "
"members."
msgstr ""
":mod:`tarfile` モジュールの :class:`TarFile` クラスに :meth:`extractall` メ"
"ソッドが追加されました。アーカイブから全てのメンバをカレントディレクトリに抽"
"出します。抽出ターゲットとして別のディレクトリも指定できますし、アーカイブメ"
"ンバのサブセットのみ解凍することも出来ます。"

#: ../../whatsnew/2.5.rst:1590
msgid ""
"The compression used for a tarfile opened in stream mode can now be "
"autodetected using the mode ``'r|*'``. (Contributed by Lars Gustäbel.)"
msgstr ""
"ストリームモードで開く tarfile に使われる圧縮を、モード ``'r|*'`` を使って自"
"動で検出出来るようになっています。 (Contributed by Lars Gustäbel.)"

#: ../../whatsnew/2.5.rst:1595
msgid ""
"The :mod:`threading` module now lets you set the stack size used when new "
"threads are created. The ``stack_size([*size*])`` function returns the "
"currently configured stack size, and supplying the optional *size* parameter "
"sets a new value.  Not all platforms support changing the stack size, but "
"Windows, POSIX threading, and OS/2 all do. (Contributed by Andrew MacIntyre.)"
msgstr ""
":mod:`threading` モジュールで、新しいスレッドを作る際に使われるスタックサイズ"
"を設定出来るようになりました。 ``stack_size([*size*])`` 関数は現在構成されて"
"いるスタックサイズを返し、省略可能引数 *size* パラメータを与えると新しい値を"
"設定します。全てのプラットフォームがスタックサイズ変更をサポートしているわけ"
"ではなく、Windows、POSIX スレッド、OS/2 で可能です。 (Contributed by Andrew "
"MacIntyre.)"

#: ../../whatsnew/2.5.rst:1603
msgid ""
"The :mod:`unicodedata` module has been updated to use version 4.1.0 of the "
"Unicode character database.  Version 3.2.0 is required  by some "
"specifications, so it's still available as  :data:`unicodedata.ucd_3_2_0`."
msgstr ""

#: ../../whatsnew/2.5.rst:1607
msgid ""
"New module: the  :mod:`uuid` module generates  universally unique "
"identifiers (UUIDs) according to :rfc:`4122`.  The RFC defines several "
"different UUID versions that are generated from a starting string, from "
"system properties, or purely randomly.  This module contains a :class:`UUID` "
"class and  functions named :func:`uuid1`, :func:`uuid3`, :func:`uuid4`,  "
"and  :func:`uuid5` to generate different versions of UUID.  (Version 2 "
"UUIDs  are not specified in :rfc:`4122` and are not supported by this "
"module.) ::"
msgstr ""
"新モジュール: :mod:`uuid` モジュールは :rfc:`4122` による UUID (universally "
"unique identifiers) を生成します。その RFC ではいくつかの異なる UUID のバー"
"ジョンを定義しており、文字列から生成するもの、システム特性から生成するもの、"
"純粋に乱数から生成するものがあります。このモジュールでは :class:`UUID` クラス"
"と :func:`uuid1`, :func:`uuid3`, :func:`uuid4`, :func:`uuid5` 関数を持ってい"
"て、それら異なったバージョンの UUID を生成します。(UUID バージョン 2 は :rfc:"
"`4122` にありませんのでこのモジュールにもないです) ::"

#: ../../whatsnew/2.5.rst:1615
msgid ""
">>> import uuid\n"
">>> # make a UUID based on the host ID and current time\n"
">>> uuid.uuid1()\n"
"UUID('a8098c1a-f86e-11da-bd1a-00112444be1e')\n"
"\n"
">>> # make a UUID using an MD5 hash of a namespace UUID and a name\n"
">>> uuid.uuid3(uuid.NAMESPACE_DNS, 'python.org')\n"
"UUID('6fa459ea-ee8a-3ca4-894e-db77e160355e')\n"
"\n"
">>> # make a random UUID\n"
">>> uuid.uuid4()\n"
"UUID('16fd2706-8baf-433b-82eb-8c7fada847da')\n"
"\n"
">>> # make a UUID using a SHA-1 hash of a namespace UUID and a name\n"
">>> uuid.uuid5(uuid.NAMESPACE_DNS, 'python.org')\n"
"UUID('886313e1-3b8a-5372-9b90-0c9aee199e5d')"
msgstr ""

#: ../../whatsnew/2.5.rst:1632
msgid "(Contributed by Ka-Ping Yee.)"
msgstr "(Contributed by Ka-Ping Yee.)"

#: ../../whatsnew/2.5.rst:1634
msgid ""
"The :mod:`weakref` module's :class:`WeakKeyDictionary` and :class:"
"`WeakValueDictionary` types gained new methods for iterating over the weak "
"references contained in the dictionary.  :meth:`iterkeyrefs` and :meth:"
"`keyrefs` methods were added to :class:`WeakKeyDictionary`, and :meth:"
"`itervaluerefs` and :meth:`valuerefs` were added to :class:"
"`WeakValueDictionary`.  (Contributed by Fred L. Drake, Jr.)"
msgstr ""
":mod:`weakref` モジュールの :class:`WeakKeyDictionary` 型と :class:"
"`WeakValueDictionary` 型に、辞書内に含まれる弱参照を巡回する新たなメソッドが"
"追加されています。 :meth:`iterkeyrefs` と :meth:`keyrefs` が :class:"
"`WeakKeyDictionary` に追加され、 :meth:`itervaluerefs` と :meth:`valuerefs` "
"が :class:`WeakValueDictionary` に追加されました。(Contributed by Fred L. "
"Drake, Jr.)"

#: ../../whatsnew/2.5.rst:1641
msgid ""
"The :mod:`webbrowser` module received a number of enhancements. It's now "
"usable as a script with ``python -m webbrowser``, taking a URL as the "
"argument; there are a number of switches  to control the behaviour (:option:"
"`!-n` for a new browser window,  :option:`!-t` for a new tab).  New module-"
"level functions, :func:`open_new` and :func:`open_new_tab`, were added  to "
"support this.  The module's :func:`open` function supports an additional "
"feature, an *autoraise* parameter that signals whether to raise the open "
"window when possible. A number of additional browsers were added to the "
"supported list such as Firefox, Opera, Konqueror, and elinks.  (Contributed "
"by Oleg Broytmann and Georg Brandl.)"
msgstr ""

#: ../../whatsnew/2.5.rst:1653
msgid ""
"The :mod:`xmlrpclib <xmlrpc.client>` module now supports returning  :class:"
"`~datetime.datetime` objects for the XML-RPC date type.  Supply  "
"``use_datetime=True`` to the :func:`~xmlrpc.client.loads` function or the :"
"class:`!Unmarshaller` class to enable this feature. (Contributed by Skip "
"Montanaro.)"
msgstr ""

#: ../../whatsnew/2.5.rst:1660
msgid ""
"The :mod:`zipfile` module now supports the ZIP64 version of the  format, "
"meaning that a .zip archive can now be larger than 4 GiB and can contain "
"individual files larger than 4 GiB.  (Contributed by Ronald Oussoren.)"
msgstr ""
":mod:`zipfile` モジュールが ZIP64 バージョンのフォーマットをサポートしまし"
"た。これで 4GiB を超える zip 書庫を作れ、4GiB を超えるファイルを書庫に含める"
"ことが出来ます。 (Contributed by Ronald Oussoren.)"

#: ../../whatsnew/2.5.rst:1666
msgid ""
"The :mod:`zlib` module's :class:`Compress` and :class:`Decompress` objects "
"now support a :meth:`copy` method that makes a copy of the  object's "
"internal state and returns a new  :class:`Compress` or :class:`Decompress` "
"object. (Contributed by Chris AtLee.)"
msgstr ""
":mod:`zlib` モジュールの :class:`Compress` , :class:`Decompress` オブジェクト"
"が :meth:`copy` メソッドをサポートするようになりました。オブジェクトの内部状"
"態を複製して新しい :class:`Compress` あるいは :class:`Decompress` オブジェク"
"トを返します。 (Contributed by Chris AtLee.)"

#: ../../whatsnew/2.5.rst:1679
msgid "The ctypes package"
msgstr "ctypes パッケージ"

#: ../../whatsnew/2.5.rst:1681
msgid ""
"The :mod:`ctypes` package, written by Thomas Heller, has been added  to the "
"standard library.  :mod:`ctypes` lets you call arbitrary functions  in "
"shared libraries or DLLs.  Long-time users may remember the :mod:`!dl` "
"module, which provides functions for loading shared libraries and calling "
"functions in them. The :mod:`ctypes` package is much fancier."
msgstr ""

#: ../../whatsnew/2.5.rst:1687
msgid ""
"To load a shared library or DLL, you must create an instance of the :class:"
"`CDLL` class and provide the name or path of the shared library or DLL. Once "
"that's done, you can call arbitrary functions by accessing them as "
"attributes of the :class:`CDLL` object.   ::"
msgstr ""
"シェアドライブラリや DLL をロードするには、 :class:`CDLL` クラスのインスタン"
"スを、その名前かパスを渡して構築します。構築したら、 :class:`CDLL` オブジェク"
"トの属性にアクセスすることで任意の関数呼び出しが出来ます::"

#: ../../whatsnew/2.5.rst:1692
msgid ""
"import ctypes\n"
"\n"
"libc = ctypes.CDLL('libc.so.6')\n"
"result = libc.printf(\"Line of output\\n\")"
msgstr ""

#: ../../whatsnew/2.5.rst:1697
msgid ""
"Type constructors for the various C types are provided: :func:`c_int`, :func:"
"`c_float`, :func:`c_double`, :func:`c_char_p` (equivalent to :c:expr:`char "
"\\*`), and so forth.  Unlike Python's types, the C versions are all mutable; "
"you can assign to their :attr:`value` attribute to change the wrapped "
"value.  Python integers and strings will be automatically converted to the "
"corresponding C types, but for other types you  must call the correct type "
"constructor.  (And I mean *must*;  getting it wrong will often result in the "
"interpreter crashing with a segmentation fault.)"
msgstr ""

#: ../../whatsnew/2.5.rst:1706
msgid ""
"You shouldn't use :func:`c_char_p` with a Python string when the C function "
"will be modifying the memory area, because Python strings are  supposed to "
"be immutable; breaking this rule will cause puzzling bugs.  When you need a "
"modifiable memory area, use :func:`create_string_buffer`::"
msgstr ""
"C 関数がメモリ領域を更新するものである場合、Python 文字列に :func:`c_char_p` "
"を使うべきではありません。 Python 文字列は :term:`immutable` であることを前提"
"としているからです; この規則を犯すことは頭を掻き毟るバグを引き起こすでしょ"
"う。更新可能なメモリ領域が必要な場合は :func:`create_string_buffer` を使いま"
"す::"

#: ../../whatsnew/2.5.rst:1711
msgid ""
"s = \"this is a string\"\n"
"buf = ctypes.create_string_buffer(s)\n"
"libc.strfry(buf)"
msgstr ""

#: ../../whatsnew/2.5.rst:1715
msgid ""
"C functions are assumed to return integers, but you can set the :attr:"
"`restype` attribute of the function object to  change this::"
msgstr ""
"C 関数はデフォルトでは整数を返すと仮定されますが、関数オブジェクトの :attr:"
"`restype` 属性をセットすることでこれを変更出来ます::"

#: ../../whatsnew/2.5.rst:1718
msgid ""
">>> libc.atof('2.71828')\n"
"-1783957616\n"
">>> libc.atof.restype = ctypes.c_double\n"
">>> libc.atof('2.71828')\n"
"2.71828"
msgstr ""

#: ../../whatsnew/2.5.rst:1724
msgid ""
":mod:`ctypes` also provides a wrapper for Python's C API  as the ``ctypes."
"pythonapi`` object.  This object does *not*  release the global interpreter "
"lock before calling a function, because the lock must be held when calling "
"into the interpreter's code.   There's a :class:`~ctypes.py_object` type "
"constructor that will create a  :c:expr:`PyObject *` pointer.  A simple "
"usage::"
msgstr ""

#: ../../whatsnew/2.5.rst:1730
msgid ""
"import ctypes\n"
"\n"
"d = {}\n"
"ctypes.pythonapi.PyObject_SetItem(ctypes.py_object(d),\n"
"          ctypes.py_object(\"abc\"),  ctypes.py_object(1))\n"
"# d is now {'abc', 1}."
msgstr ""

#: ../../whatsnew/2.5.rst:1737
msgid ""
"Don't forget to use :func:`~ctypes.py_object`; if it's omitted you end  up "
"with a segmentation fault."
msgstr ""

#: ../../whatsnew/2.5.rst:1740
msgid ""
":mod:`ctypes` has been around for a while, but people still write  and "
"distribution hand-coded extension modules because you can't rely on :mod:"
"`ctypes` being present. Perhaps developers will begin to write  Python "
"wrappers atop a library accessed through :mod:`ctypes` instead of extension "
"modules, now that :mod:`ctypes` is included with core Python."
msgstr ""
":mod:`ctypes` が周辺ライブラリとして登場してしばらく経ちますが、:mod:"
"`ctypes` が存在していることに依存できないとなれば人々はまだハードコードされた"
"拡張モジュールを書いて配布します。 :mod:`ctypes` が Python 中核に含められた"
"今、おそらく開発者たちは、拡張モジュールの代わりに :mod:`ctypes` を介してアク"
"セスするライブラリの上に Python ラッパーを書き始めるでしょう,"

#: ../../whatsnew/2.5.rst:1749
msgid ""
"https://web.archive.org/web/20180410025338/http://starship.python.net/crew/"
"theller/ctypes/"
msgstr ""

#: ../../whatsnew/2.5.rst:1750
msgid "The pre-stdlib ctypes web page, with a tutorial, reference, and FAQ."
msgstr ""

#: ../../whatsnew/2.5.rst:1752
msgid "The documentation  for the :mod:`ctypes` module."
msgstr ":mod:`ctypes` モジュールについてのドキュメント。"

#: ../../whatsnew/2.5.rst:1760
msgid "The ElementTree package"
msgstr "ElementTree パッケージ"

#: ../../whatsnew/2.5.rst:1762
msgid ""
"A subset of Fredrik Lundh's ElementTree library for processing XML has been "
"added to the standard library as :mod:`xml.etree`.  The available modules "
"are :mod:`ElementTree`, :mod:`ElementPath`, and :mod:`ElementInclude` from "
"ElementTree 1.2.6.    The :mod:`cElementTree` accelerator module is also "
"included."
msgstr ""
"XML 処理のための、Fredrik Lundh の ElementTree ライブラリのサブセットが、標準"
"ライブラリに :mod:`xml.etree` として追加されました。利用可能なモジュールは "
"ElementTree 1.2.6 よりの :mod:`ElementTree`, :mod:`ElementPath`, :mod:"
"`ElementInclude` です。 C 実装 :mod:`cElementTree` モジュールも含まれていま"
"す。"

#: ../../whatsnew/2.5.rst:1768
msgid ""
"The rest of this section will provide a brief overview of using ElementTree. "
"Full documentation for ElementTree is available at https://web.archive.org/"
"web/20201124024954/http://effbot.org/zone/element-index.htm."
msgstr ""

#: ../../whatsnew/2.5.rst:1772
msgid ""
"ElementTree represents an XML document as a tree of element nodes. The text "
"content of the document is stored as the :attr:`text` and :attr:`tail` "
"attributes of  (This is one of the major differences between ElementTree and "
"the Document Object Model; in the DOM there are many different types of "
"node, including :class:`TextNode`.)"
msgstr ""
"ElementTree は XML ドキュメントを、要素ノードのツリーとして表現します。ドキュ"
"メントのテキストコンテントは :attr:`text` 属性と :attr:`tail` 属性に格納され"
"ます (これが ElementTree と Document Object Model (DOM) との一番大きな違いで"
"す; DOM 内ではノードの数多くの型があります。 :class:`TextNode` はその一つで"
"す。)"

#: ../../whatsnew/2.5.rst:1778
msgid ""
"The most commonly used parsing function is :func:`parse`, that takes either "
"a string (assumed to contain a filename) or a file-like object and returns "
"an :class:`ElementTree` instance::"
msgstr ""
"最も一般的に使う解析関数は :func:`parse` です。これは (ファイル名が含まれると"
"みなされる) 文字列またはファイルのようなオブジェクトを受け取って、 :class:"
"`ElementTree` インスタンスを返します::"

#: ../../whatsnew/2.5.rst:1782
msgid ""
"from xml.etree import ElementTree as ET\n"
"\n"
"tree = ET.parse('ex-1.xml')\n"
"\n"
"feed = urllib.urlopen(\n"
"          'http://planet.python.org/rss10.xml')\n"
"tree = ET.parse(feed)"
msgstr ""

#: ../../whatsnew/2.5.rst:1790
msgid ""
"Once you have an :class:`ElementTree` instance, you can call its :meth:"
"`getroot` method to get the root :class:`Element` node."
msgstr ""
":class:`ElementTree` インスタンスを手にしてしまえば、あとはルートの :class:"
"`Element` ノードを得るために :meth:`getroot` を呼び出せます。"

#: ../../whatsnew/2.5.rst:1793
msgid ""
"There's also an :func:`XML` function that takes a string literal and returns "
"an :class:`Element` node (not an :class:`ElementTree`).   This function "
"provides a tidy way to incorporate XML fragments, approaching the "
"convenience of an XML literal::"
msgstr ""
"文字列リテラルを受け取って (:class:`ElementTree` ではなく) :class:`Element` "
"ノードを返す :func:`XML` 関数 もあります。この関数を使えば、簡単に XML リテラ"
"ルを使って XML 断片からツリーを組み上げることが綺麗に出来ます::"

#: ../../whatsnew/2.5.rst:1798
msgid ""
"svg = ET.XML(\"\"\"<svg width=\"10px\" version=\"1.0\">\n"
"             </svg>\"\"\")\n"
"svg.set('height', '320px')\n"
"svg.append(elem1)"
msgstr ""

#: ../../whatsnew/2.5.rst:1803
msgid ""
"Each XML element supports some dictionary-like and some list-like access "
"methods.  Dictionary-like operations are used to access attribute values, "
"and list-like operations are used to access child nodes."
msgstr ""
"個々の XML 要素はいくつかの辞書のような、いくつかのリストのようなメソッドをサ"
"ポートしています。辞書的な操作は属性値のアクセスに使い、リスト的な操作は子"
"ノードのアクセスに使います。"

#: ../../whatsnew/2.5.rst:1808
msgid "Operation"
msgstr "演算"

#: ../../whatsnew/2.5.rst:1808
msgid "Result"
msgstr "結果"

#: ../../whatsnew/2.5.rst:1810
msgid "``elem[n]``"
msgstr "``elem[n]``"

#: ../../whatsnew/2.5.rst:1810
msgid "Returns n'th child element."
msgstr "n 番目の子要素を返す。"

#: ../../whatsnew/2.5.rst:1812
msgid "``elem[m:n]``"
msgstr "``elem[m:n]``"

#: ../../whatsnew/2.5.rst:1812
msgid "Returns list of m'th through n'th child elements."
msgstr "m 番目から n 番目までの子要素を返す(---訳注: n は含まない---)。"

#: ../../whatsnew/2.5.rst:1815
msgid "``len(elem)``"
msgstr "``len(elem)``"

#: ../../whatsnew/2.5.rst:1815
msgid "Returns number of child elements."
msgstr "子要素数を返す。"

#: ../../whatsnew/2.5.rst:1817
msgid "``list(elem)``"
msgstr "``list(elem)``"

#: ../../whatsnew/2.5.rst:1817
msgid "Returns list of child elements."
msgstr "子要素のリストを返す。"

#: ../../whatsnew/2.5.rst:1819
msgid "``elem.append(elem2)``"
msgstr "``elem.append(elem2)``"

#: ../../whatsnew/2.5.rst:1819
msgid "Adds *elem2* as a child."
msgstr "*elem2* を子として追加する。"

#: ../../whatsnew/2.5.rst:1821
msgid "``elem.insert(index, elem2)``"
msgstr "``elem.insert(index, elem2)``"

#: ../../whatsnew/2.5.rst:1821
msgid "Inserts *elem2* at the specified location."
msgstr "指定された位置に *elem2* を挿入する。"

#: ../../whatsnew/2.5.rst:1823
msgid "``del elem[n]``"
msgstr "``del elem[n]``"

#: ../../whatsnew/2.5.rst:1823
msgid "Deletes n'th child element."
msgstr "n 番目の子要素を削除する。"

#: ../../whatsnew/2.5.rst:1825
msgid "``elem.keys()``"
msgstr "``elem.keys()``"

#: ../../whatsnew/2.5.rst:1825
msgid "Returns list of attribute names."
msgstr "属性名のリストを返す。"

#: ../../whatsnew/2.5.rst:1827
msgid "``elem.get(name)``"
msgstr "``elem.get(name)``"

#: ../../whatsnew/2.5.rst:1827
msgid "Returns value of attribute *name*."
msgstr "属性 *name* の値を返す。"

#: ../../whatsnew/2.5.rst:1829
msgid "``elem.set(name, value)``"
msgstr "``elem.set(name, value)``"

#: ../../whatsnew/2.5.rst:1829
msgid "Sets new value for attribute *name*."
msgstr "属性 *name* に新しい値をセットする。"

#: ../../whatsnew/2.5.rst:1831
msgid "``elem.attrib``"
msgstr "``elem.attrib``"

#: ../../whatsnew/2.5.rst:1831
msgid "Retrieves the dictionary containing attributes."
msgstr "属性を含んだ辞書を取り出す。"

#: ../../whatsnew/2.5.rst:1834
msgid "``del elem.attrib[name]``"
msgstr "``del elem.attrib[name]``"

#: ../../whatsnew/2.5.rst:1834
msgid "Deletes attribute *name*."
msgstr "属性 *name* を削除する。"

#: ../../whatsnew/2.5.rst:1837
msgid ""
"Comments and processing instructions are also represented as :class:"
"`Element` nodes.  To check if a node is a comment or processing "
"instructions::"
msgstr ""
"コメントと処理命令 (processing instruction=PI) も、 :class:`Element` ノードで"
"表現されます。ノードがコメントあるいは処理命令であるかをチェックするにはこの"
"ようにします::"

#: ../../whatsnew/2.5.rst:1840
msgid ""
"if elem.tag is ET.Comment:\n"
"    ...\n"
"elif elem.tag is ET.ProcessingInstruction:\n"
"    ..."
msgstr ""

#: ../../whatsnew/2.5.rst:1845
msgid ""
"To generate XML output, you should call the :meth:`ElementTree.write` "
"method. Like :func:`parse`, it can take either a string or a file-like "
"object::"
msgstr ""
"XML 出力を生成するには :meth:`ElementTree.write` メソッドを呼び出す必要があり"
"ます。 :func:`parse` のように、文字列もしくはファイルのようなオブジェクトを渡"
"せます::"

#: ../../whatsnew/2.5.rst:1848
msgid ""
"# Encoding is US-ASCII\n"
"tree.write('output.xml')\n"
"\n"
"# Encoding is UTF-8\n"
"f = open('output.xml', 'w')\n"
"tree.write(f, encoding='utf-8')"
msgstr ""

#: ../../whatsnew/2.5.rst:1855
msgid ""
"(Caution: the default encoding used for output is ASCII.  For general XML "
"work, where an element's name may contain arbitrary Unicode characters, "
"ASCII isn't a very useful encoding because it will raise an exception if an "
"element's name contains any characters with values greater than 127.  "
"Therefore, it's best to specify a different encoding such as UTF-8 that can "
"handle any Unicode character.)"
msgstr ""
"(警告: 出力に使われるデフォルトエンコーディングは ASCII です。一般的な XML で"
"の作業では要素名に任意の Unicode 文字を含められるので、ASCII エンコーディング"
"はあまり役に立ちません。要素名に 127 より大きなどんな文字が含まれても例外とな"
"りますので。ですから任意の Unicode 文字を扱うために UTF-8 のようなエンコー"
"ディングを指定するのが吉です。)"

#: ../../whatsnew/2.5.rst:1862
msgid ""
"This section is only a partial description of the ElementTree interfaces. "
"Please read the package's official documentation for more details."
msgstr ""
"このセクションでは  ElementTree インターフェイスのほんの一部しか記載していま"
"せん。さらに詳しい情報については、パッケージの公式ドキュメントを参照して下さ"
"い。"

#: ../../whatsnew/2.5.rst:1868
msgid ""
"https://web.archive.org/web/20201124024954/http://effbot.org/zone/element-"
"index.htm"
msgstr ""

#: ../../whatsnew/2.5.rst:1869
msgid "Official documentation for ElementTree."
msgstr "ElementTree の公式ドキュメント"

#: ../../whatsnew/2.5.rst:1877
msgid "The hashlib package"
msgstr "hashlib パッケージ"

#: ../../whatsnew/2.5.rst:1879
msgid ""
"A new :mod:`hashlib` module, written by Gregory P. Smith,  has been added to "
"replace the :mod:`!md5` and :mod:`!sha` modules.  :mod:`hashlib` adds "
"support for additional secure hashes (SHA-224, SHA-256, SHA-384, and "
"SHA-512). When available, the module uses OpenSSL for fast platform "
"optimized implementations of algorithms."
msgstr ""

#: ../../whatsnew/2.5.rst:1885
msgid ""
"The old :mod:`!md5` and :mod:`!sha` modules still exist as wrappers around "
"hashlib to preserve backwards compatibility.  The new module's interface is "
"very close to that of the old modules, but not identical. The most "
"significant difference is that the constructor functions for creating new "
"hashing objects are named differently. ::"
msgstr ""

#: ../../whatsnew/2.5.rst:1891
msgid ""
"# Old versions\n"
"h = md5.md5()\n"
"h = md5.new()\n"
"\n"
"# New version\n"
"h = hashlib.md5()\n"
"\n"
"# Old versions\n"
"h = sha.sha()\n"
"h = sha.new()\n"
"\n"
"# New version\n"
"h = hashlib.sha1()\n"
"\n"
"# Hash that weren't previously available\n"
"h = hashlib.sha224()\n"
"h = hashlib.sha256()\n"
"h = hashlib.sha384()\n"
"h = hashlib.sha512()\n"
"\n"
"# Alternative form\n"
"h = hashlib.new('md5')          # Provide algorithm as a string"
msgstr ""

#: ../../whatsnew/2.5.rst:1914
msgid ""
"Once a hash object has been created, its methods are the same as before: "
"``update(string)`` hashes the specified string into the  current digest "
"state, :meth:`digest` and :meth:`hexdigest` return the digest value as a "
"binary string or a string of hex digits, and :meth:`copy` returns a new "
"hashing object with the same digest state."
msgstr ""
"ハッシュオブジェクトを作ってしまえばあとはそのメソッドは以前と同じです: "
"``update(string)`` は指定された文字列を現在のダイジェスト状態にハッシュ更新"
"し、 :meth:`digest` と :meth:`hexdigest` は結果のダイジェスト値をバイナリ文字"
"列・16進数表記文字列として返し、 :meth:`copy` はダイジェスト状態を複製して新"
"たなハッシュオブジェクトを作ります。"

#: ../../whatsnew/2.5.rst:1923
msgid "The documentation  for the :mod:`hashlib` module."
msgstr ":mod:`hashlib` モジュールについてのドキュメント。"

#: ../../whatsnew/2.5.rst:1931
msgid "The sqlite3 package"
msgstr "sqlite3 パッケージ"

#: ../../whatsnew/2.5.rst:1933
msgid ""
"The pysqlite module (https://www.pysqlite.org), a wrapper for the SQLite "
"embedded database, has been added to the standard library under the package "
"name :mod:`sqlite3`."
msgstr ""

#: ../../whatsnew/2.5.rst:1937
msgid ""
"SQLite is a C library that provides a lightweight disk-based database that "
"doesn't require a separate server process and allows accessing the database "
"using a nonstandard variant of the SQL query language. Some applications can "
"use SQLite for internal data storage.  It's also possible to prototype an "
"application using SQLite and then port the code to a larger database such as "
"PostgreSQL or Oracle."
msgstr ""
"SQLite は、軽量なディスク上のデータベースを提供する C ライブラリです。別の"
"サーバプロセスを用意する必要なく、 SQL クエリー言語の非標準的な一種を使用して"
"データベースにアクセスできます。一部のアプリケーションは内部データ保存に "
"SQLite を使えます。また、SQLite を使ってアプリケーションのプロトタイプを作"
"り、その後そのコードを PostgreSQL や Oracle のような大規模データベースに移植"
"するということも可能です。"

#: ../../whatsnew/2.5.rst:1944
msgid ""
"pysqlite was written by Gerhard Häring and provides a SQL interface "
"compliant with the DB-API 2.0 specification described by :pep:`249`."
msgstr ""
"pysqlite  は Gerhard Häring によって書かれ、 :pep:`249` に記述された DB-API "
"2.0 仕様に準拠した SQL インターフェースを提供するものです。"

#: ../../whatsnew/2.5.rst:1947
msgid ""
"If you're compiling the Python source yourself, note that the source tree "
"doesn't include the SQLite code, only the wrapper module. You'll need to "
"have the SQLite libraries and headers installed before compiling Python, and "
"the build process will compile the module when the necessary headers are "
"available."
msgstr ""
"ソースコードから Python をビルドする場合は注意してください。Python ソースツ"
"リーは SQLite コードを含まずラッパーモジュールのみを含んでいます。Python ビル"
"ド前に SQLite ライブラリとヘッダをインストールする必要があります。必要ヘッダ"
"が利用可能となっていればモジュールはビルドされます。"

#: ../../whatsnew/2.5.rst:1952
msgid ""
"To use the module, you must first create a :class:`Connection` object that "
"represents the database.  Here the data will be stored in the :file:`/tmp/"
"example` file::"
msgstr ""
"このモジュールを使うには、最初にデータベースを表す :class:`Connection` オブ"
"ジェクトを作ります。ここではデータはファイル :file:`/tmp/example` に格納され"
"ているものとします。 ::"

#: ../../whatsnew/2.5.rst:1956
msgid "conn = sqlite3.connect('/tmp/example')"
msgstr ""

#: ../../whatsnew/2.5.rst:1958
msgid ""
"You can also supply the special name ``:memory:`` to create a database in "
"RAM."
msgstr ""
"特別な名前である ``:memory:`` を使うと RAM 上にデータベースを作ることもできま"
"す。"

#: ../../whatsnew/2.5.rst:1960
msgid ""
"Once you have a :class:`Connection`, you can create a :class:`Cursor`  "
"object and call its :meth:`execute` method to perform SQL commands::"
msgstr ""
":class:`Connection` があれば、 :class:`Cursor` オブジェクトを作りその :meth:"
"`~Cursor.execute` メソッドを呼んで SQL コマンドを実行することができます::"

#: ../../whatsnew/2.5.rst:1963
msgid ""
"c = conn.cursor()\n"
"\n"
"# Create table\n"
"c.execute('''create table stocks\n"
"(date text, trans text, symbol text,\n"
" qty real, price real)''')\n"
"\n"
"# Insert a row of data\n"
"c.execute(\"\"\"insert into stocks\n"
"          values ('2006-01-05','BUY','RHAT',100,35.14)\"\"\")"
msgstr ""

#: ../../whatsnew/2.5.rst:1974
msgid ""
"Usually your SQL operations will need to use values from Python variables.  "
"You shouldn't assemble your query using Python's string operations because "
"doing so is insecure; it makes your program vulnerable to an SQL injection "
"attack."
msgstr ""
"たいてい、SQL 操作は Python 変数の値を使う必要があります。この時、クエリーを "
"Python の文字列操作を使って構築することは、安全とは言えないので、すべきではあ"
"りません。そのようなことをするとプログラムが SQL インジェクション攻撃に対し脆"
"弱になりかねません。"

#: ../../whatsnew/2.5.rst:1978
msgid ""
"Instead, use the DB-API's parameter substitution.  Put ``?`` as a "
"placeholder wherever you want to use a value, and then provide a tuple of "
"values as the second argument to the cursor's :meth:`execute` method.  "
"(Other database modules may use a different placeholder, such as ``%s`` or "
"``:1``.) For example::"
msgstr ""
"代わりに、DB-API のパラメータ割り当てを使います。 ``?`` を変数の値を使いたい"
"ところに埋めておきます。その上で、値のタプルをカーソルの :meth:`~Cursor."
"execute` メソッドの第2引数として引き渡します。(他のデータベースモジュールでは"
"変数の場所を示すのに ``%s`` や ``:1`` などの異なった表記を用いることがありま"
"す。) 例を示します::"

#: ../../whatsnew/2.5.rst:1983
msgid ""
"# Never do this -- insecure!\n"
"symbol = 'IBM'\n"
"c.execute(\"... where symbol = '%s'\" % symbol)\n"
"\n"
"# Do this instead\n"
"t = (symbol,)\n"
"c.execute('select * from stocks where symbol=?', t)\n"
"\n"
"# Larger example\n"
"for t in (('2006-03-28', 'BUY', 'IBM', 1000, 45.00),\n"
"          ('2006-04-05', 'BUY', 'MSOFT', 1000, 72.00),\n"
"          ('2006-04-06', 'SELL', 'IBM', 500, 53.00),\n"
"         ):\n"
"    c.execute('insert into stocks values (?,?,?,?,?)', t)"
msgstr ""

#: ../../whatsnew/2.5.rst:1998
msgid ""
"To retrieve data after executing a SELECT statement, you can either  treat "
"the cursor as an iterator, call the cursor's :meth:`fetchone` method to "
"retrieve a single matching row,  or call :meth:`fetchall` to get a list of "
"the matching rows."
msgstr ""
"SELECT 文を実行した後データを取得する方法は3つありどれを使っても構いません。"
"一つはカーソルをイテレータ (:term:`iterator`) として扱う、一つはカーソルの :"
"meth:`~Cursor.fetchone` メソッドを呼んで一致した内の一行を取得する、もう一つ"
"は :meth:`~Cursor.fetchall` メソッドを呼んで一致した全ての行のリストとして受"
"け取る、という3つです。"

#: ../../whatsnew/2.5.rst:2003
msgid "This example uses the iterator form::"
msgstr "以下の例ではイテレータの形を使います::"

#: ../../whatsnew/2.5.rst:2005
msgid ""
">>> c = conn.cursor()\n"
">>> c.execute('select * from stocks order by price')\n"
">>> for row in c:\n"
"...    print row\n"
"...\n"
"(u'2006-01-05', u'BUY', u'RHAT', 100, 35.140000000000001)\n"
"(u'2006-03-28', u'BUY', u'IBM', 1000, 45.0)\n"
"(u'2006-04-06', u'SELL', u'IBM', 500, 53.0)\n"
"(u'2006-04-05', u'BUY', u'MSOFT', 1000, 72.0)\n"
">>>"
msgstr ""

#: ../../whatsnew/2.5.rst:2016
msgid ""
"For more information about the SQL dialect supported by SQLite, see https://"
"www.sqlite.org."
msgstr ""
"SQLite でサポートされる SQL 方言についてもっと詳しく知りたければ、 http://"
"www.sqlite.org を参照して下さい。"

#: ../../whatsnew/2.5.rst:2022
msgid "https://www.pysqlite.org"
msgstr ""

#: ../../whatsnew/2.5.rst:2023
msgid "The pysqlite web page."
msgstr "pysqlite のウェブページ。"

#: ../../whatsnew/2.5.rst:2025
msgid "https://www.sqlite.org"
msgstr "https://www.sqlite.org"

#: ../../whatsnew/2.5.rst:2026
msgid ""
"The SQLite web page; the documentation describes the syntax and the "
"available data types for the supported SQL dialect."
msgstr ""
"SQLite のウェブページ。ここの文書ではサポートされる SQL 方言の文法と使える"
"データ型を説明しています。"

#: ../../whatsnew/2.5.rst:2029
msgid "The documentation  for the :mod:`sqlite3` module."
msgstr ":mod:`sqlite3` モジュールについてのドキュメント。"

#: ../../whatsnew/2.5.rst:2031
msgid ":pep:`249` - Database API Specification 2.0"
msgstr ":pep:`249` - Database API Specification 2.0"

#: ../../whatsnew/2.5.rst:2032
msgid "PEP written by Marc-André Lemburg."
msgstr "Marc-Andre Lemburg により書かれた PEP。"

#: ../../whatsnew/2.5.rst:2040
msgid "The wsgiref package"
msgstr "wsgiref パッケージ"

#: ../../whatsnew/2.5.rst:2042
msgid ""
"The Web Server Gateway Interface (WSGI) v1.0 defines a standard interface "
"between web servers and Python web applications and is described in :pep:"
"`333`. The :mod:`wsgiref` package is a reference implementation of the WSGI "
"specification."
msgstr ""
"Web Server Gateway Interface (WSGI) v1.0 は、 Web サーバと Python で記述され"
"た Web アプリケーションとの標準インターフェースであり、 :pep:`333` で定義され"
"ています。  :mod:`wsgiref` パッケージは WSGI 仕様のリファレンス実装です。"

#: ../../whatsnew/2.5.rst:2049
msgid ""
"The package includes a basic HTTP server that will run a WSGI application; "
"this server is useful for debugging but isn't intended for  production use.  "
"Setting up a server takes only a few lines of code::"
msgstr ""
"パッケージには WSGI アプリケーションとして動作する基礎的な HTTP サーバが含ま"
"れています; このサーバは製品ユースではないデバッグ目的に有用です。サーバを"
"セットアップするには僅か数行で済みます::"

#: ../../whatsnew/2.5.rst:2053
msgid ""
"from wsgiref import simple_server\n"
"\n"
"wsgi_app = ...\n"
"\n"
"host = ''\n"
"port = 8000\n"
"httpd = simple_server.make_server(host, port, wsgi_app)\n"
"httpd.serve_forever()"
msgstr ""

#: ../../whatsnew/2.5.rst:2068
msgid ""
"https://web.archive.org/web/20160331090247/http://wsgi.readthedocs.org/en/"
"latest/"
msgstr ""

#: ../../whatsnew/2.5.rst:2069
msgid "A central web site for WSGI-related resources."
msgstr "WSGI 関連のリソースについて集約しているウェブサイト。"

#: ../../whatsnew/2.5.rst:2071
msgid ":pep:`333` - Python Web Server Gateway Interface v1.0"
msgstr ":pep:`333` - Python Web Server Gateway Interface v1.0"

#: ../../whatsnew/2.5.rst:2072
msgid "PEP written by Phillip J. Eby."
msgstr "PEP 著 Phillip J. Eby."

#: ../../whatsnew/2.5.rst:2080
msgid "Build and C API Changes"
msgstr "ビルドならびに C API の変更"

#: ../../whatsnew/2.5.rst:2082
msgid "Changes to Python's build process and to the C API include:"
msgstr "Python のビルド過程と C API の変更は以下の通りです:"

#: ../../whatsnew/2.5.rst:2084
msgid ""
"The Python source tree was converted from CVS to Subversion,  in a complex "
"migration procedure that was supervised and flawlessly carried out by Martin "
"von Löwis.  The procedure was developed as :pep:`347`."
msgstr ""
"Python ソースツリーは CVS から Subversion に変換されました。この複雑な移行手"
"続きは Martin von Löwis によって指揮されつつがなく遂行されました。この手続き"
"は :pep:`347` にて開発されました。"

#: ../../whatsnew/2.5.rst:2088
msgid ""
"Coverity, a company that markets a source code analysis tool called Prevent, "
"provided the results of their examination of the Python source code.  The "
"analysis found about 60 bugs that  were quickly fixed.  Many of the bugs "
"were refcounting problems, often occurring in error-handling code.  See "
"https://scan.coverity.com for the statistics."
msgstr ""

#: ../../whatsnew/2.5.rst:2094
msgid ""
"The largest change to the C API came from :pep:`353`, which modifies the "
"interpreter to use a :c:type:`Py_ssize_t` type definition instead of :c:expr:"
"`int`.  See the earlier section :ref:`pep-353` for a discussion of this "
"change."
msgstr ""

#: ../../whatsnew/2.5.rst:2099
msgid ""
"The design of the bytecode compiler has changed a great deal,  no longer "
"generating bytecode by traversing the parse tree.  Instead the parse tree is "
"converted to an abstract syntax tree (or AST), and it is  the abstract "
"syntax tree that's traversed to produce the bytecode."
msgstr ""

#: ../../whatsnew/2.5.rst:2104
msgid ""
"It's possible for Python code to obtain AST objects by using the :func:"
"`compile` built-in and specifying ``_ast.PyCF_ONLY_AST`` as the value of "
"the  *flags* parameter::"
msgstr ""

#: ../../whatsnew/2.5.rst:2108
msgid ""
"from _ast import PyCF_ONLY_AST\n"
"ast = compile(\"\"\"a=0\n"
"for i in range(10):\n"
"    a += i\n"
"\"\"\", \"<string>\", 'exec', PyCF_ONLY_AST)\n"
"\n"
"assignment = ast.body[0]\n"
"for_loop = ast.body[1]"
msgstr ""

#: ../../whatsnew/2.5.rst:2117
msgid ""
"No official documentation has been written for the AST code yet, but :pep:"
"`339` discusses the design.  To start learning about the code, read the "
"definition of the various AST nodes in :file:`Parser/Python.asdl`.  A Python "
"script reads this file and generates a set of C structure definitions in :"
"file:`Include/Python-ast.h`.  The :c:func:`PyParser_ASTFromString` and :c:"
"func:`!PyParser_ASTFromFile`, defined in :file:`Include/pythonrun.h`, take "
"Python source as input and return the root of an AST representing the "
"contents. This AST can then be turned into a code object by :c:func:`!"
"PyAST_Compile`.  For more information, read the source code, and then ask "
"questions on python-dev."
msgstr ""

#: ../../whatsnew/2.5.rst:2127
msgid ""
"The AST code was developed under Jeremy Hylton's management, and implemented "
"by (in alphabetical order) Brett Cannon, Nick Coghlan, Grant Edwards, John "
"Ehresman, Kurt Kaiser, Neal Norwitz, Tim Peters, Armin Rigo, and Neil "
"Schemenauer, plus the participants in a number of AST sprints at conferences "
"such as PyCon."
msgstr ""

#: ../../whatsnew/2.5.rst:2136
msgid ""
"Evan Jones's patch to obmalloc, first described in a talk at PyCon DC 2005, "
"was applied.  Python 2.4 allocated small objects in 256K-sized arenas, but "
"never freed arenas.  With this patch, Python will free arenas when they're "
"empty.  The net effect is that on some platforms, when you allocate many "
"objects, Python's memory usage may actually drop when you delete them and "
"the memory may be returned to the operating system.  (Implemented by Evan "
"Jones, and reworked by Tim Peters.)"
msgstr ""

#: ../../whatsnew/2.5.rst:2144
msgid ""
"Note that this change means extension modules must be more careful when "
"allocating memory.  Python's API has many different functions for allocating "
"memory that are grouped into families.  For example, :c:func:"
"`PyMem_Malloc`, :c:func:`PyMem_Realloc`, and :c:func:`PyMem_Free` are one "
"family that allocates raw memory, while :c:func:`PyObject_Malloc`, :c:func:"
"`PyObject_Realloc`, and :c:func:`PyObject_Free` are another family that's "
"supposed to be used for creating Python objects."
msgstr ""

#: ../../whatsnew/2.5.rst:2152
msgid ""
"Previously these different families all reduced to the platform's :c:func:"
"`malloc` and :c:func:`free` functions.  This meant  it didn't matter if you "
"got things wrong and allocated memory with the ``PyMem`` function but freed "
"it with the ``PyObject`` function.  With 2.5's changes to obmalloc, these "
"families now do different things and mismatches will probably result in a "
"segfault.  You should carefully test your C extension modules with Python "
"2.5."
msgstr ""

#: ../../whatsnew/2.5.rst:2159
msgid ""
"The built-in set types now have an official C API.  Call :c:func:`PySet_New` "
"and :c:func:`PyFrozenSet_New` to create a new set, :c:func:`PySet_Add` and :"
"c:func:`PySet_Discard` to add and remove elements, and :c:func:"
"`PySet_Contains` and :c:func:`PySet_Size` to examine the set's state. "
"(Contributed by Raymond Hettinger.)"
msgstr ""
"ビルトインの集合型のために公式の C API が作られました。新しく作るのには :c:"
"func:`PySet_New` か :c:func:`PyFrozenSet_New` を、要素の追加には :c:func:"
"`PySet_Add` 、削除には :c:func:`PySet_Discard` 、 :c:func:`PySet_Contains` "
"と :c:func:`PySet_Size` で集合オブジェクトの状態を調べます。 (Contributed by "
"Raymond Hettinger.)"

#: ../../whatsnew/2.5.rst:2165
msgid ""
"C code can now obtain information about the exact revision of the Python "
"interpreter by calling the  :c:func:`Py_GetBuildInfo` function that returns "
"a string of build information like this: ``\"trunk:45355:45356M, Apr 13 "
"2006, 07:42:19\"``.   (Contributed by Barry Warsaw.)"
msgstr ""
"C コードから Python インタプリタの正確なリビジョンについての情報を取得出来る"
"ようになりました。 :c:func:`Py_GetBuildInfo` 関数を呼び出すことでビルド情報に"
"ついての文字列が ``\"trunk:45355:45356M, Apr 13 2006, 07:42:19\"`` のように返"
"ります。 (Contributed by Barry Warsaw.)"

#: ../../whatsnew/2.5.rst:2170
msgid ""
"Two new macros can be used to indicate C functions that are local to the "
"current file so that a faster calling convention can be used. "
"``Py_LOCAL(type)`` declares the function as returning a value of the "
"specified *type* and uses a fast-calling qualifier. "
"``Py_LOCAL_INLINE(type)`` does the same thing and also requests the function "
"be inlined.  If macro :c:macro:`!PY_LOCAL_AGGRESSIVE` is defined before :"
"file:`python.h` is included, a set of more aggressive optimizations are "
"enabled for the module; you should benchmark the results to find out if "
"these optimizations actually make the code faster.  (Contributed by Fredrik "
"Lundh at the NeedForSpeed sprint.)"
msgstr ""

#: ../../whatsnew/2.5.rst:2181
msgid ""
"``PyErr_NewException(name, base, dict)`` can now accept a tuple of base "
"classes as its *base* argument.  (Contributed by Georg Brandl.)"
msgstr ""
"``PyErr_NewException(name, base, dict)`` が *base* 引数としてベースクラスのタ"
"プルを受け付けるようになりました。 (Contributed by Georg Brandl.)"

#: ../../whatsnew/2.5.rst:2184
msgid ""
"The :c:func:`!PyErr_Warn` function for issuing warnings is now deprecated in "
"favour of ``PyErr_WarnEx(category, message, stacklevel)`` which lets you "
"specify the number of stack frames separating this function and the caller.  "
"A *stacklevel* of 1 is the function calling :c:func:`PyErr_WarnEx`, 2 is the "
"function above that, and so forth.  (Added by Neal Norwitz.)"
msgstr ""

#: ../../whatsnew/2.5.rst:2190
msgid ""
"The CPython interpreter is still written in C, but  the code can now be "
"compiled with a C++ compiler without errors.   (Implemented by Anthony "
"Baxter, Martin von Löwis, Skip Montanaro.)"
msgstr ""
"CPython は今でも C で書かれていますが、コードは C++ コンパイラでもエラーなし"
"でコンパイル出来るようになりました。   (Implemented by Anthony Baxter, "
"Martin von Löwis, Skip Montanaro.)"

#: ../../whatsnew/2.5.rst:2194
msgid ""
"The :c:func:`!PyRange_New` function was removed.  It was never documented, "
"never used in the core code, and had dangerously lax error checking.  In the "
"unlikely case that your extensions were using it, you can replace it by "
"something like the following::"
msgstr ""

#: ../../whatsnew/2.5.rst:2199
msgid ""
"range = PyObject_CallFunction((PyObject*) &PyRange_Type, \"lll\",\n"
"                              start, stop, step);"
msgstr ""

#: ../../whatsnew/2.5.rst:2208
msgid "Port-Specific Changes"
msgstr "ポート特有の変更"

#: ../../whatsnew/2.5.rst:2210
msgid ""
"MacOS X (10.3 and higher): dynamic loading of modules now uses the :c:func:"
"`dlopen` function instead of MacOS-specific functions."
msgstr ""
"MacOS X (10.3 以上): モジュールの動的ロードに、MacOS 固有の関数ではなく :c:"
"func:`dlopen` 関数を使うようになりました。"

#: ../../whatsnew/2.5.rst:2213
msgid ""
"MacOS X: an :option:`!--enable-universalsdk` switch was added to the :"
"program:`configure` script that compiles the interpreter as a universal "
"binary able to run on both PowerPC and Intel processors. (Contributed by "
"Ronald Oussoren; :issue:`2573`.)"
msgstr ""

#: ../../whatsnew/2.5.rst:2218
msgid ""
"Windows: :file:`.dll` is no longer supported as a filename extension for "
"extension modules.  :file:`.pyd` is now the only filename extension that "
"will be searched for."
msgstr ""
"Windows: :file:`.dll` はもはや拡張モジュールのファイル拡張子としてはサポート"
"されません。これからは :file:`.pyd` だけが拡張モジュールとして検索されるファ"
"イル拡張子です。"

#: ../../whatsnew/2.5.rst:2228
msgid "Porting to Python 2.5"
msgstr "Python 2.5 への移植"

#: ../../whatsnew/2.5.rst:2230
msgid ""
"This section lists previously described changes that may require changes to "
"your code:"
msgstr ""
"このセクションでは前述の変更により必要となるかもしれないコードの変更を列挙し"
"ます:"

#: ../../whatsnew/2.5.rst:2233
msgid ""
"ASCII is now the default encoding for modules.  It's now  a syntax error if "
"a module contains string literals with 8-bit characters but doesn't have an "
"encoding declaration.  In Python 2.4 this triggered a warning, not a syntax "
"error."
msgstr ""
"ASCII がモジュールのデフォルトエンコーディングになっています(訳注: Python 3 "
"からはデフォルトは utf-8 (PEP 3120))。8 ビット文字を含んでいるのにエンコー"
"ディング宣言がないモジュールが構文エラーになるようになりました。Python 2.4 で"
"は構文エラーとはならず警告でした。"

#: ../../whatsnew/2.5.rst:2238
msgid ""
"Previously, the :attr:`gi_frame` attribute of a generator was always a frame "
"object.  Because of the :pep:`342` changes described in section :ref:"
"`pep-342`, it's now possible for :attr:`gi_frame` to be ``None``."
msgstr ""
"以前はジェネレータの :attr:`gi_frame` 属性は常にフレームオブジェクトでした"
"が、 :ref:`pep-342` で説明した :pep:`342` での変更により、 :attr:`gi_frame` "
"は ``None`` になりえます。"

#: ../../whatsnew/2.5.rst:2242
msgid ""
"A new warning, :class:`UnicodeWarning`, is triggered when  you attempt to "
"compare a Unicode string and an 8-bit string that can't be converted to "
"Unicode using the default ASCII encoding.  Previously such comparisons would "
"raise a :class:`UnicodeDecodeError` exception."
msgstr ""
"Unicode 文字列とデフォルトの ASCII エンコーディングで Unicode に変換出来ない "
"8 ビット文字列との比較を試みると、新しい警告 :class:`UnicodeWarning` が引き起"
"こされるようになっています。以前はそのような比較では :class:"
"`UnicodeDecodeError` 例外を起こしていました。"

#: ../../whatsnew/2.5.rst:2247
msgid ""
"Library: the :mod:`csv` module is now stricter about multi-line quoted "
"fields. If your files contain newlines embedded within fields, the input "
"should be split into lines in a manner which preserves the newline "
"characters."
msgstr ""
"ライブラリ: :mod:`csv` モジュールは引用符内のマルチラインをより厳密に扱うよう"
"になっています。フィールド内に改行を埋め込んでいるファイルがある場合は、その"
"入力は改行文字を残すやり方で行分解されるはずです。"

#: ../../whatsnew/2.5.rst:2251
msgid ""
"Library: the :mod:`locale` module's  :func:`format` function's would "
"previously  accept any string as long as no more than one %char specifier "
"appeared.  In Python 2.5, the argument must be exactly one %char specifier "
"with no surrounding text."
msgstr ""
"ライブラリ: :mod:`locale` モジュールの :func:`format` 関数は、以前は %文字指"
"定子が一つを超えてさえいなければ任意の文字列を受け付けていたかもしれません"
"が、Python 2.5 からは正確に一つの、ほかに周りをテキストで囲まれていない %文字"
"指定子でなければなりません。"

#: ../../whatsnew/2.5.rst:2256
msgid ""
"Library: The :mod:`pickle` and :mod:`!cPickle` modules no longer accept a "
"return value of ``None`` from the :meth:`~object.__reduce__` method; the "
"method must return a tuple of arguments instead.  The modules also no longer "
"accept the deprecated *bin* keyword parameter."
msgstr ""

#: ../../whatsnew/2.5.rst:2261
msgid ""
"Library: The :mod:`SimpleXMLRPCServer <xmlrpc.server>` and :mod:"
"`DocXMLRPCServer <xmlrpc.server>`  classes now have a :attr:`rpc_paths` "
"attribute that constrains XML-RPC operations to a limited set of URL paths; "
"the default is to allow only ``'/'`` and ``'/RPC2'``. Setting  :attr:"
"`rpc_paths` to ``None`` or an empty tuple disables  this path checking."
msgstr ""

#: ../../whatsnew/2.5.rst:2267
msgid ""
"C API: Many functions now use :c:type:`Py_ssize_t`  instead of :c:expr:`int` "
"to allow processing more data on 64-bit machines.  Extension code may need "
"to make the same change to avoid warnings and to support 64-bit machines.  "
"See the earlier section :ref:`pep-353` for a discussion of this change."
msgstr ""

#: ../../whatsnew/2.5.rst:2272
msgid ""
"C API:  The obmalloc changes mean that  you must be careful to not mix usage "
"of the ``PyMem_*`` and ``PyObject_*`` families of functions. Memory "
"allocated with  one family's ``*_Malloc`` must be  freed with the "
"corresponding family's ``*_Free`` function."
msgstr ""

#: ../../whatsnew/2.5.rst:2281
msgid "Acknowledgements"
msgstr "謝辞"

#: ../../whatsnew/2.5.rst:2283
msgid ""
"The author would like to thank the following people for offering "
"suggestions, corrections and assistance with various drafts of this article: "
"Georg Brandl, Nick Coghlan, Phillip J. Eby, Lars Gustäbel, Raymond "
"Hettinger, Ralf W. Grosse-Kunstleve, Kent Johnson, Iain Lowe, Martin von "
"Löwis, Fredrik Lundh, Andrew McNamara, Skip Montanaro, Gustavo Niemeyer, "
"Paul Prescod, James Pryor, Mike Rovner, Scott Weikart, Barry Warsaw, Thomas "
"Wouters."
msgstr ""

#: ../../whatsnew/2.5.rst:1342
msgid "universal newlines"
msgstr "universal newlines"

#: ../../whatsnew/2.5.rst:1342
msgid "What's new"
msgstr ""