2.3.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:
# Tetsuo Koyama <tkoyama010@gmail.com>, 2021
# Mikami Akiko, 2021
# Arihiro TAKASE, 2023
# tomo, 2023
# Taichi Haradaguchi, 2024
#
#, 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: Taichi Haradaguchi, 2024\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.3.rst:3
msgid "What's New in Python 2.3"
msgstr "What's New in Python 2.3"

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

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

#: ../../whatsnew/2.3.rst:11
msgid ""
"This article explains the new features in Python 2.3.  Python 2.3 was "
"released on July 29, 2003."
msgstr ""
"この文書は Python 2.3 の新機能について解説します。Python 2.3 は 2003 年 7 月 "
"29 日にリリースされました。"

#: ../../whatsnew/2.3.rst:14
msgid ""
"The main themes for Python 2.3 are polishing some of the features added in "
"2.2, adding various small but useful enhancements to the core language, and "
"expanding the standard library.  The new object model introduced in the "
"previous version has benefited from 18 months of bugfixes and from "
"optimization efforts that have improved the performance of new-style "
"classes.  A few new built-in functions have been added such as :func:`sum` "
"and :func:`enumerate`.  The :keyword:`in` operator can now be used for "
"substring searches (e.g. ``\"ab\" in \"abc\"`` returns :const:`True`)."
msgstr ""
"Python 2.3 の主要なテーマは、2.2 で追加されたいくつかの機能を磨くこと、言語中"
"核に小さいながらも有用な種々の拡張をすること、そして標準ライブラリの拡充で"
"す。ひとつ前のバージョンで導入された新しいオブジェクトモデルは、18 ヶ月に渡る"
"バグフィックスと新スタイルクラスの性能改善をもたらした最適化の努力の恩恵を受"
"けました。 :func:`sum`, :func:`enumerate` のような、新たなビルトイン関数が少"
"し追加されました。 :keyword:`in` 演算子がサブストリングの検索に使えるようにな"
"りました (例えば ``\"ab\" in \"abc\"`` は :const:`True` を返します)。"

#: ../../whatsnew/2.3.rst:23
msgid ""
"Some of the many new library features include Boolean, set, heap, and date/"
"time data types, the ability to import modules from ZIP-format archives, "
"metadata support for the long-awaited Python catalog, an updated version of "
"IDLE, and modules for logging messages, wrapping text, parsing CSV files, "
"processing command-line options, using BerkeleyDB databases...  the list of "
"new and enhanced modules is lengthy."
msgstr ""
"たくさんのライブラリ新機能…、Boolean、 set、 heap、 日付/時刻データ型、ZIP 形"
"式アーカイブからのモジュールインポート、待ち望まれていた Python カタログのた"
"めのメタデータサポート、更新されたバージョンの IDLE、ロギングメッセージのため"
"のモジュール、テキストの折り返し、CSV ファイルの解析、コマンドラインオプショ"
"ンの処理、BerkeleyDB データベースの使用…、新機能、強化機能のリストは長大にな"
"ります。"

#: ../../whatsnew/2.3.rst:30
msgid ""
"This article doesn't attempt to provide a complete specification of the new "
"features, but instead provides a convenient overview.  For full details, you "
"should refer to the documentation for Python 2.3, such as the Python Library "
"Reference and the Python Reference Manual.  If you want to understand the "
"complete implementation and design rationale, refer to the PEP for a "
"particular new feature."
msgstr ""
"このドキュメントは個々の新機能の完全な詳細を提供するのではなくて、簡易な概要"
"を提供することを目的にしています。完全な詳細が知りたければ、 Python ライブラ"
"リリファレンス、Python リファレンスマニュアルのような Python 2.4 のドキュメン"
"トを参照してください。設計と実装の根拠を理解したい場合は、新機能に関する PEP "
"を参照してください。"

#: ../../whatsnew/2.3.rst:41
msgid "PEP 218: A Standard Set Datatype"
msgstr "PEP 218: 標準の集合データ型"

#: ../../whatsnew/2.3.rst:43
msgid ""
"The new :mod:`!sets` module contains an implementation of a set datatype.  "
"The :class:`Set` class is for mutable sets, sets that can have members added "
"and removed.  The :class:`!ImmutableSet` class is for sets that can't be "
"modified, and instances of :class:`!ImmutableSet` can therefore be used as "
"dictionary keys. Sets are built on top of dictionaries, so the elements "
"within a set must be hashable."
msgstr ""
"(---訳注: イキナリですが、あなたが今これを「Python の歴史を知る」もしくは「初"
"登場時の熱量高い紹介」を読みたくて読んでいるのでない限りは、もしくは本当に今 "
"2.3 を使う必要があれば別ですが、このモジュールは 2.4 で既にビルトインで置き換"
"えられ、2.6 では非推奨となり、3.0 では削除されています。ので、集合型について"
"知りたければここよりも 2.4 のビルトインの方から読んだ方が良いです。---) --- "
"新しいモジュール :mod:`!sets` には、集合データ型の実装が含まれています。 :"
"class:`Set` クラスは :term:`mutable` の集合のためのクラスで、メンバの追加と削"
"除が出来ます。 :class:`!ImmutableSet` は変更できない集合のためのクラスなの"
"で、:class:`!ImmutableSet` のインスタンスを辞書のキーとして利用出来ます。集合"
"型は辞書の上に構築されているので、集合内の要素はハッシュ可能でなければなりま"
"せん。"

#: ../../whatsnew/2.3.rst:50
msgid "Here's a simple example::"
msgstr "単純な使用例です::"

#: ../../whatsnew/2.3.rst:52
msgid ""
">>> import sets\n"
">>> S = sets.Set([1,2,3])\n"
">>> S\n"
"Set([1, 2, 3])\n"
">>> 1 in S\n"
"True\n"
">>> 0 in S\n"
"False\n"
">>> S.add(5)\n"
">>> S.remove(3)\n"
">>> S\n"
"Set([1, 2, 5])\n"
">>>"
msgstr ""

#: ../../whatsnew/2.3.rst:66
msgid ""
"The union and intersection of sets can be computed with the :meth:"
"`~frozenset.union` and :meth:`~frozenset.intersection` methods; an "
"alternative notation uses the bitwise operators ``&`` and ``|``. Mutable "
"sets also have in-place versions of these methods, :meth:`!union_update` "
"and :meth:`~frozenset.intersection_update`. ::"
msgstr ""
"和集合 (union) と共通集合 (intersection) は :meth:`~frozenset.union` と :"
"meth:`~frozenset.intersection` メソッドで計算出来ます; 別の記法として、ビット"
"演算子 ``&`` と ``|`` も使えます。変更可能な集合ではこれらのインプレイス版 :"
"meth:`!union_update` と :meth:`~frozenset.intersection_update` も使えます::"

#: ../../whatsnew/2.3.rst:71
msgid ""
">>> S1 = sets.Set([1,2,3])\n"
">>> S2 = sets.Set([4,5,6])\n"
">>> S1.union(S2)\n"
"Set([1, 2, 3, 4, 5, 6])\n"
">>> S1 | S2                  # Alternative notation\n"
"Set([1, 2, 3, 4, 5, 6])\n"
">>> S1.intersection(S2)\n"
"Set([])\n"
">>> S1 & S2                  # Alternative notation\n"
"Set([])\n"
">>> S1.union_update(S2)\n"
">>> S1\n"
"Set([1, 2, 3, 4, 5, 6])\n"
">>>"
msgstr ""

#: ../../whatsnew/2.3.rst:86
msgid ""
"It's also possible to take the symmetric difference of two sets.  This is "
"the set of all elements in the union that aren't in the intersection.  "
"Another way of putting it is that the symmetric difference contains all "
"elements that are in exactly one set.  Again, there's an alternative "
"notation (``^``), and an in-place version with the ungainly name :meth:"
"`~frozenset.symmetric_difference_update`. ::"
msgstr ""
"2 つの集合の対称差 (symmetric difference) を取ることも出来ます。これは、"
"union から intersection を除いた全要素を取ります。別の言い方をすれば、対称差"
"とは、正確に一つの集合だけに含まれる全要素、ということです。ほかと同じくビッ"
"ト演算子の記法 (``^``) が使え、インプレイスバージョンは見苦しい名前の :meth:"
"`~frozenset.symmetric_difference_update` です::"

#: ../../whatsnew/2.3.rst:92
msgid ""
">>> S1 = sets.Set([1,2,3,4])\n"
">>> S2 = sets.Set([3,4,5,6])\n"
">>> S1.symmetric_difference(S2)\n"
"Set([1, 2, 5, 6])\n"
">>> S1 ^ S2\n"
"Set([1, 2, 5, 6])\n"
">>>"
msgstr ""

#: ../../whatsnew/2.3.rst:100
msgid ""
"There are also :meth:`!issubset` and :meth:`!issuperset` methods for "
"checking whether one set is a subset or superset of another::"
msgstr ""
":meth:`!issubset` と :meth:`!issuperset` メソッドも使えます。これはある集合が"
"部分集合、上位集合であるかとうかをチェックします::"

#: ../../whatsnew/2.3.rst:103
msgid ""
">>> S1 = sets.Set([1,2,3])\n"
">>> S2 = sets.Set([2,3])\n"
">>> S2.issubset(S1)\n"
"True\n"
">>> S1.issubset(S2)\n"
"False\n"
">>> S1.issuperset(S2)\n"
"True\n"
">>>"
msgstr ""

#: ../../whatsnew/2.3.rst:116
msgid ":pep:`218` - Adding a Built-In Set Object Type"
msgstr ":pep:`218` - 集合オブジェクト型をビルトインに追加する"

#: ../../whatsnew/2.3.rst:117
msgid ""
"PEP written by Greg V. Wilson. Implemented by Greg V. Wilson, Alex Martelli, "
"and GvR."
msgstr ""
"PEP 著 Greg V. Wilson. 実装: Greg V. Wilson, Alex Martelli, GvR. (---訳注: "
"PEPそのものは 2.4 のビルトイン型 set, frozenset の追加と同じものですが、2.3 "
"ではモジュールとして追加され、2.4 でビルトイン版が追加され、2.6 でモジュール"
"版が非推奨となった、という流れです。---)"

#: ../../whatsnew/2.3.rst:126
msgid "PEP 255: Simple Generators"
msgstr "PEP 255: 単純なジェネレータ"

#: ../../whatsnew/2.3.rst:128
msgid ""
"In Python 2.2, generators were added as an optional feature, to be enabled "
"by a ``from __future__ import generators`` directive.  In 2.3 generators no "
"longer need to be specially enabled, and are now always present; this means "
"that :keyword:`yield` is now always a keyword.  The rest of this section is "
"a copy of the description of generators from the \"What's New in Python "
"2.2\" document; if you read it back when Python 2.2 came out, you can skip "
"the rest of this section."
msgstr ""
"Python 2.2 では、ジェネレータが ``from __future__ import generators`` ディレ"
"クティブで有効に出来るオプションの機能として追加されました。2.3 ではジェネ"
"レータは特別に有効化する必要なく、もうキーワード :keyword:`yield` として、い"
"つでもそこにあります。このセクションの残りの部分は \"What's New in Python "
"2.2\" のジェネレータの記述からの丸々コピーですので、2.2 のときに読んだなら読"
"み飛ばしてもらって結構です。"

#: ../../whatsnew/2.3.rst:136
msgid ""
"You're doubtless familiar with how function calls work in Python or C. When "
"you call a function, it gets a private namespace where its local variables "
"are created.  When the function reaches a :keyword:`return` statement, the "
"local variables are destroyed and the resulting value is returned to the "
"caller.  A later call to the same function will get a fresh new set of local "
"variables. But, what if the local variables weren't thrown away on exiting a "
"function? What if you could later resume the function where it left off?  "
"This is what generators provide; they can be thought of as resumable "
"functions."
msgstr ""
"Python や C の標準的な関数コールについては、よくご存じに違いありません。関数"
"を呼ぶと、ローカル変数を作るプライベートな名前空間ができますね。その関数が :"
"keyword:`return` 文まで来ると、ローカル変数が破壊されてから、返り値が呼び出し"
"元に返ります。次に同じ関数をもう一度呼ぶと、新しいプライベート名前空間に新規"
"のローカル変数が作られるのです。しかし、関数を出るときにローカル変数を捨てな"
"ければどうなるでしょうか。その出ていったところから関数を続行できたとしたら、"
"どうでしょう。これこそジェネレータが提供する機能です; すなわち、ジェネレータ"
"は続行できる関数と考えることができます。"

#: ../../whatsnew/2.3.rst:145
msgid "Here's the simplest example of a generator function::"
msgstr "ジェネレータ関数の最も単純な例です::"

#: ../../whatsnew/2.3.rst:147
msgid ""
"def generate_ints(N):\n"
"    for i in range(N):\n"
"        yield i"
msgstr ""

#: ../../whatsnew/2.3.rst:151
msgid ""
"A new keyword, :keyword:`yield`, was introduced for generators.  Any "
"function containing a :keyword:`!yield` statement is a generator function; "
"this is detected by Python's bytecode compiler which compiles the function "
"specially as a result."
msgstr ""
"新しいキーワード :keyword:`yield` がジェネレータのために導入されました。 :"
"keyword:`!yield` ステートメントを含むどんな関数もジェネレータ関数です; "
"Python バイトコードコンパイラはこれを検知し、関数が特別に扱われるように翻訳し"
"ます。 (---訳注: Python 2.5 の PEP 342 も参照して下さい。この 2.2 で導入時点"
"の ``yield`` はステートメントではなく式に変更されています。---)"

#: ../../whatsnew/2.3.rst:156
msgid ""
"When you call a generator function, it doesn't return a single value; "
"instead it returns a generator object that supports the iterator protocol.  "
"On executing the :keyword:`yield` statement, the generator outputs the value "
"of ``i``, similar to a :keyword:`return` statement.  The big difference "
"between :keyword:`!yield` and a :keyword:`!return` statement is that on "
"reaching a :keyword:`!yield` the generator's state of execution is suspended "
"and local variables are preserved.  On the next call to the generator's ``."
"next()`` method, the function will resume executing immediately after the :"
"keyword:`!yield` statement.  (For complicated reasons, the :keyword:`!yield` "
"statement isn't allowed inside the :keyword:`try` block of a :keyword:`!"
"try`...\\ :keyword:`!finally` statement; read :pep:`255` for a full "
"explanation of the interaction between :keyword:`!yield` and exceptions.)"
msgstr ""
"ジェネレータ関数を呼び出すと、単一の値の代わりにイテレータプロトコルに対応し"
"たオブジェクトを返します。上の例で :keyword:`!yield` を実行したとき、ジェネ"
"レータは :keyword:`!return` 文のようにして ``i`` の値を生成します。 "
"``yield`` と ``return`` 文の大きな違いは、 ``yield`` に到達した段階でジェネ"
"レータの実行状態が一時停止になって、ローカル変数が保存される点です。次回その"
"ジェネレータの ``.next()`` メソッドを呼ぶと、 :keyword:`!yield` の直後から関"
"数が実行を再開します。(複雑な理由により、 :keyword:`!yield` は :keyword:`!"
"try`...\\ :keyword:`finally` の :keyword:`!try` ブロック内に含めることは許さ"
"れていません; :pep:`255` に :keyword:`!yield` と例外の相互作用についての詳細"
"説明がありますので参照して下さい。) --- (---訳注: Python 2.5 の PEP 342 で :"
"keyword:`try`...\\ :keyword:`finally` 内に置けないという制約はなくなりまし"
"た。また、 :keyword:`try`...\\ :keyword:`finally` の :keyword:`try` 、とここ"
"であえて特定しているのは、同じく 2.5 の PEP 341 によって try/except/finally "
"の一体化されるまでは、 ``finally`` の ``try`` と ``except`` の ``try`` が別物"
"だったからです。---)"

#: ../../whatsnew/2.3.rst:169
msgid "Here's a sample usage of the :func:`!generate_ints` generator::"
msgstr "上記の :func:`!generate_ints` ジェネレータはこんな具合に使います::"

#: ../../whatsnew/2.3.rst:171
msgid ""
">>> gen = generate_ints(3)\n"
">>> gen\n"
"<generator object at 0x8117f90>\n"
">>> gen.next()\n"
"0\n"
">>> gen.next()\n"
"1\n"
">>> gen.next()\n"
"2\n"
">>> gen.next()\n"
"Traceback (most recent call last):\n"
"  File \"stdin\", line 1, in ?\n"
"  File \"stdin\", line 2, in generate_ints\n"
"StopIteration"
msgstr ""

#: ../../whatsnew/2.3.rst:186
msgid ""
"You could equally write ``for i in generate_ints(5)``, or ``a,b,c = "
"generate_ints(3)``."
msgstr ""
"同じく ``for i in generate_ints(5)`` や ``a,b,c = generate_ints(3)`` といった"
"書き方もできます。"

#: ../../whatsnew/2.3.rst:189
msgid ""
"Inside a generator function, the :keyword:`return` statement can only be "
"used without a value, and signals the end of the procession of values; "
"afterwards the generator cannot return any further values. :keyword:`!"
"return` with a value, such as ``return 5``, is a syntax error inside a "
"generator function.  The end of the generator's results can also be "
"indicated by raising :exc:`StopIteration` manually, or by just letting the "
"flow of execution fall off the bottom of the function."
msgstr ""
"ジェネレータ関数内で :keyword:`return` 文は、引数を付けずに、処理の終わりを知"
"らせるためにだけ使うことができます; ``return`` を実行したあとは、もうそのジェ"
"ネレータが値を返すことはできません。ジェネレータ関数の中では、 ``return 5`` "
"などと値を付けた :keyword:`!return` は構文エラーです。ジェネレータの出力が終"
"わったことを示すには、ほかにも、手動で :exc:`StopIteration`  を投げてもいいで"
"すし、関数の最後まで実行するだけでも同じことになります。(---訳注: Python 2.7 "
"まではジェネレータ内での戻り値のある ``return 5`` は構文エラーになりますが、"
"少なくとも Python 3.4 で構文エラーとはなりません。単に無視されます。リファレ"
"ンスに言及されていない振舞いなので、何かの事故かもしれません。いずれにせよ"
"ジェネレータ内では Python 3 でも ``return`` で値は戻せません。---)"

#: ../../whatsnew/2.3.rst:197
msgid ""
"You could achieve the effect of generators manually by writing your own "
"class and storing all the local variables of the generator as instance "
"variables.  For example, returning a list of integers could be done by "
"setting ``self.count`` to 0, and having the :meth:`next` method increment "
"``self.count`` and return it. However, for a moderately complicated "
"generator, writing a corresponding class would be much messier. :file:`Lib/"
"test/test_generators.py` contains a number of more interesting examples.  "
"The simplest one implements an in-order traversal of a tree using generators "
"recursively. ::"
msgstr ""
"自分でクラスを書いて、ジェネレータで言うところのローカル変数をインスタンス変"
"数として全部保管しておけば、同じ効果を得ることは可能です。たとえば整数のリス"
"トを返すのは、 ``self.count`` を 0 にして、 :meth:`next` メソッドが ``self."
"count`` をインクリメントして返すようにすればできます。しかしながら、ある程度"
"複雑なジェネレータになってくると、同じことをするクラスを書くのは格段にややこ"
"しいことになります。 :file:`Lib/test/test_generators.py` にはもっと面白い例が"
"たくさん含まれています。一番単純な一つは、ジェネレータを再帰的に使ってツリー"
"を順繰りに横断する実装をするこれです (---訳注: ジェネレータは現在の最新 3.5 "
"までの間に 2 度大きな機能強化が行われているのですが、一つが 2.5 での PEP 342 "
"でこれは yield 「に」値を戻せるようにするものです。もう一つが 3.3 での PEP "
"380 で、これはサブジェネレータへの委譲 ``yield from <subgen>`` の追加でした。"
"ですのでこの 3.3 からの ``yield from`` を使うと下記例はもっとスッキリ書けま"
"す。---)::"

#: ../../whatsnew/2.3.rst:206
msgid ""
"# A recursive generator that generates Tree leaves in in-order.\n"
"def inorder(t):\n"
"    if t:\n"
"        for x in inorder(t.left):\n"
"            yield x\n"
"        yield t.label\n"
"        for x in inorder(t.right):\n"
"            yield x"
msgstr ""

#: ../../whatsnew/2.3.rst:215
msgid ""
"Two other examples in :file:`Lib/test/test_generators.py` produce solutions "
"for the N-Queens problem (placing $N$ queens on an $NxN$ chess board so that "
"no queen threatens another) and the Knight's Tour (a route that takes a "
"knight to every square of an $NxN$ chessboard without visiting any square "
"twice)."
msgstr ""
"ほかにも :file:`Lib/test/test_generators.py` には、N-Queens 問題 (N×N コマの"
"チェス盤に、互いに攻撃できないような配置で N 個のクイーンを置く) やナイト・ツ"
"アー (N×N 盤の全コマをナイトが一度ずつ通るような経路を探す) の解を出す例が"
"入っています。"

#: ../../whatsnew/2.3.rst:220
msgid ""
"The idea of generators comes from other programming languages, especially "
"Icon (https://www2.cs.arizona.edu/icon/), where the idea of generators is "
"central.  In Icon, every expression and function call behaves like a "
"generator.  One example from \"An Overview of the Icon Programming "
"Language\" at https://www2.cs.arizona.edu/icon/docs/ipd266.htm gives an idea "
"of what this looks like::"
msgstr ""
"ジェネレータの発想はほかのプログラミング言語、特に Icon (https://www2.cs."
"arizona.edu/icon/) から着想しています。Icon ではジェネレータが言語の中枢に"
"なっています。Icon では、あらゆる式と関数がジェネレータのように振舞います。 "
"https://www2.cs.arizona.edu/icon/docs/ipd266.htm の \"Icon プログラミング言語"
"の概要\" の一つの例が、これがどのようなものであるのかを教えてくれます::"

#: ../../whatsnew/2.3.rst:227
msgid ""
"sentence := \"Store it in the neighboring harbor\"\n"
"if (i := find(\"or\", sentence)) > 5 then write(i)"
msgstr ""

#: ../../whatsnew/2.3.rst:230
msgid ""
"In Icon the :func:`!find` function returns the indexes at which the "
"substring \"or\" is found: 3, 23, 33.  In the :keyword:`if` statement, ``i`` "
"is first assigned a value of 3, but 3 is less than 5, so the comparison "
"fails, and Icon retries it with the second value of 23.  23 is greater than "
"5, so the comparison now succeeds, and the code prints the value 23 to the "
"screen."
msgstr ""
"Icon では :func:`!find` 関数は部分文字列 \"or\" が見つかる位置 3, 23, 33 を返"
"します。 :keyword:`if` 文内では ``i`` には最初 3 が代入されますが、これは 3 "
"より小さいので比較は失敗し、Icon は次の値 23 を取り出します。 23 は 5 より大"
"きいので比較は成功し、コードは 23 をスクリーンに表示します。"

#: ../../whatsnew/2.3.rst:236
msgid ""
"Python doesn't go nearly as far as Icon in adopting generators as a central "
"concept.  Generators are considered part of the core Python language, but "
"learning or using them isn't compulsory; if they don't solve any problems "
"that you have, feel free to ignore them. One novel feature of Python's "
"interface as compared to Icon's is that a generator's state is represented "
"as a concrete object (the iterator) that can be passed around to other "
"functions or stored in a data structure."
msgstr ""
"Python では Icon がそうするほどにはジェネレータを中心的概念に置きません。ジェ"
"ネレータは Python 言語中核の新たな一面ではありますが、それらを学ぶのも使うの"
"も誰しも行うべきだというものでもなく、そしてこれで解決できない何か問題があれ"
"ば、忘れてしまっても良いものです。Icon と比較した特筆すべき Python インター"
"フェイスの機能はジェネレータの状態が具象オブジェクト (イテレータ) で表現され"
"ることであり、それは他の関数に渡せますし、データ構造に記憶しておくことも出来"
"ます。(---訳注: ジェネレータについてかなり控えめなのは、この時点で著者は将来"
"の拡張を既に見据えていたから? かもしれませんね。PEP 342 と PEP 380 により今や"
"ジェネレータはこの頃より遥かに高機能になっており、今ではきっと「こんなものな"
"くても困らない」なんて Python 使いはいないでしょう。---)"

#: ../../whatsnew/2.3.rst:247
msgid ":pep:`255` - Simple Generators"
msgstr ":pep:`255` - 単純なジェネレータ"

#: ../../whatsnew/2.3.rst:248
msgid ""
"Written by Neil Schemenauer, Tim Peters, Magnus Lie Hetland.  Implemented "
"mostly by Neil Schemenauer and Tim Peters, with other fixes from the Python "
"Labs crew."
msgstr ""
"Neil Schemenauer, Tim Peters, Magnus Lie Hetland により著されました。実装のほ"
"とんどは Neil Schemenauer と Tim Peters により行われ、 Python Labs クルーによ"
"り他の修正が行われました。"

#: ../../whatsnew/2.3.rst:257
msgid "PEP 263: Source Code Encodings"
msgstr "PEP 263: ソースコードのエンコーディング"

#: ../../whatsnew/2.3.rst:259
msgid ""
"Python source files can now be declared as being in different character set "
"encodings.  Encodings are declared by including a specially formatted "
"comment in the first or second line of the source file.  For example, a "
"UTF-8 file can be declared with::"
msgstr ""
"Python ソースファイルで、異なる文字セットエンコーディングを宣言出来るようにな"
"りました。エンコーディングはソースコードの 1 行目か 2 行目に特殊形式のコメン"
"トを含めることで宣言出来ます。 UTF-8 ファイルであればこのように宣言出来ます::"

#: ../../whatsnew/2.3.rst:264
msgid ""
"#!/usr/bin/env python\n"
"# -*- coding: UTF-8 -*-"
msgstr ""

#: ../../whatsnew/2.3.rst:267
msgid ""
"Without such an encoding declaration, the default encoding used is 7-bit "
"ASCII. Executing or importing modules that contain string literals with 8-"
"bit characters and have no encoding declaration will result in a :exc:"
"`DeprecationWarning` being signalled by Python 2.3; in 2.4 this will be a "
"syntax error."
msgstr ""
"このエンコーディング宣言がなければ、デフォルトの 7 ビット ASCII エンコーディ"
"ングが使われます(訳注: Python 3 からはデフォルトは utf-8 (PEP 3120))。8 ビッ"
"ト文字を含んでいるのにエンコーディング宣言がないモジュールの実行やインポート"
"を行うと、 Python 2.3 では :exc:`DeprecationWarning` を引き起こします; 2.4 で"
"はこれは構文エラーになる予定です(訳注: 実際には 2.4 ではこれは実現せず、2.5 "
"から)。"

#: ../../whatsnew/2.3.rst:273
msgid ""
"The encoding declaration only affects Unicode string literals, which will be "
"converted to Unicode using the specified encoding.  Note that Python "
"identifiers are still restricted to ASCII characters, so you can't have "
"variable names that use characters outside of the usual alphanumerics."
msgstr ""
"エンコーディング宣言は Unicode 文字列リテラルにのみ影響します。それらは指定し"
"たエンコーディングで Unicode 文字列に変換されます。Python 識別子は今でも "
"ASCII 文字列に制限されていることに注意してください。ですから普通の英数字範囲"
"外の文字を変数名に使うことは出来ません。"

#: ../../whatsnew/2.3.rst:281
msgid ":pep:`263` - Defining Python Source Code Encodings"
msgstr ":pep:`263` - Python ソースコードのエンコーディングを定義する"

#: ../../whatsnew/2.3.rst:282
msgid ""
"Written by Marc-André Lemburg and Martin von Löwis; implemented by Suzuki "
"Hisao and Martin von Löwis."
msgstr ""
"Marc-André Lemburg、 Martin von Löwis 著; Suzuki Hisao、 Martin von Löwis 実"
"装."

#: ../../whatsnew/2.3.rst:289
msgid "PEP 273: Importing Modules from ZIP Archives"
msgstr "PEP 273: Zip アーカイブからモジュールをインポートする"

#: ../../whatsnew/2.3.rst:291
msgid ""
"The new :mod:`zipimport` module adds support for importing modules from a "
"ZIP-format archive.  You don't need to import the module explicitly; it will "
"be automatically imported if a ZIP archive's filename is added to ``sys."
"path``. For example:"
msgstr ""
"新たなモジュール :mod:`zipimport` が、ZIP フォーマットの書庫からモジュールの"
"インポートをサポートします。 :mod:`zipimport` を明示的にインポートする必要は"
"ありません; ``sys.path`` に ZIP 形式書庫が追加されるとそれは自動的にインポー"
"トされます。例えば::"

#: ../../whatsnew/2.3.rst:296
msgid ""
"amk@nyman:~/src/python$ unzip -l /tmp/example.zip\n"
"Archive:  /tmp/example.zip\n"
"  Length     Date   Time    Name\n"
" --------    ----   ----    ----\n"
"     8467  11-26-02 22:30   jwzthreading.py\n"
" --------                   -------\n"
"     8467                   1 file\n"
"amk@nyman:~/src/python$ ./python\n"
"Python 2.3 (#1, Aug 1 2003, 19:54:32)\n"
">>> import sys\n"
">>> sys.path.insert(0, '/tmp/example.zip')  # Add .zip file to front of "
"path\n"
">>> import jwzthreading\n"
">>> jwzthreading.__file__\n"
"'/tmp/example.zip/jwzthreading.py'\n"
">>>"
msgstr ""

#: ../../whatsnew/2.3.rst:314
msgid ""
"An entry in ``sys.path`` can now be the filename of a ZIP archive. The ZIP "
"archive can contain any kind of files, but only files named :file:`\\*.py`, :"
"file:`\\*.pyc`, or :file:`\\*.pyo` can be imported.  If an archive only "
"contains :file:`\\*.py` files, Python will not attempt to modify the archive "
"by adding the corresponding :file:`\\*.pyc` file, meaning that if a ZIP "
"archive doesn't contain :file:`\\*.pyc` files, importing may be rather slow."
msgstr ""
"``sys.path`` には今や ZIP 書庫のファイル名も入れることが出来ます。ZIP アーカ"
"イブ内にはどんなファイルを置いてもかまいませんが、import できるのは :file:"
"`\\*.py`, :file:`\\*.pyc`, :file:`\\*.pyo` だけです。書庫に :file:`\\*.py` だ"
"けが含まれる場合には、Python は書庫を修正して対応する :file:`\\*.pyc` を作る"
"などということはしないので、 :file:`\\*.pyc` ファイルを含まない ZIP 書庫から"
"のインポートはやや遅いかもしれません。"

#: ../../whatsnew/2.3.rst:321
msgid ""
"A path within the archive can also be specified to only import from a "
"subdirectory; for example, the path :file:`/tmp/example.zip/lib/` would only "
"import from the :file:`lib/` subdirectory within the archive."
msgstr ""
"書庫内のパスをサブディレクトリ以下のみインポートするように指定出来ます; 例え"
"ば、パス :file:`/tmp/example.zip/lib/` はその書庫内の :file:`lib/` サブディレ"
"クトリだけからインポートします。"

#: ../../whatsnew/2.3.rst:328
msgid ":pep:`273` - Import Modules from Zip Archives"
msgstr ":pep:`273` - Zip アーカイブからモジュールをインポートする"

#: ../../whatsnew/2.3.rst:329
msgid ""
"Written by James C. Ahlstrom,  who also provided an implementation. Python "
"2.3 follows the specification in :pep:`273`,  but uses an implementation "
"written by Just van Rossum  that uses the import hooks described in :pep:"
"`302`. See section :ref:`section-pep302` for a description of the new import "
"hooks."
msgstr ""
"このモジュールの実装も行った、James C. Ahlstrom による PEP です。 Python 2.3 "
"は  :pep:`273` の仕様に従っていますが、 Just van Rossum の書いた、 :pep:"
"`302` に記述されているインポートフックによる実装を使っています。その新しいイ"
"ンポートフックについては  :ref:`section-pep302`  をみてください。"

#: ../../whatsnew/2.3.rst:338
msgid "PEP 277: Unicode file name support for Windows NT"
msgstr "PEP 277: Windows NT での Unicode ファイル名サポート"

#: ../../whatsnew/2.3.rst:340
msgid ""
"On Windows NT, 2000, and XP, the system stores file names as Unicode "
"strings. Traditionally, Python has represented file names as byte strings, "
"which is inadequate because it renders some file names inaccessible."
msgstr ""
"Windows NT, 2000, XP では、ファイルシステムはファイル名として Unicode 文字列"
"を使います。伝統的に Python はファイル名をバイト文字列として表現してきました"
"が、それはアクセス出来ないファイル名を表してしまう場合があって、不十分でし"
"た。"

#: ../../whatsnew/2.3.rst:344
msgid ""
"Python now allows using arbitrary Unicode strings (within the limitations of "
"the file system) for all functions that expect file names, most notably the :"
"func:`open` built-in function. If a Unicode string is passed to :func:`os."
"listdir`, Python now returns a list of Unicode strings.  A new function, :"
"func:`!os.getcwdu`, returns the current directory as a Unicode string."
msgstr ""
"Python はいまや (ファイルシステムの制約の範囲内での) 任意の Unicode 文字列"
"を :func:`open` 組み込み関数をはじめとするファイル名が期待される全ての関数で"
"許容します。 :func:`os.listdir` に Unicode 文字列が渡されれば、Python は今で"
"は Unicode 文字列のリストを返します。新しい関数 :func:`os.getcwdu` は "
"Unicode 文字列でカレントディレクトリを返します(訳注: ちなみに Python 3 での "
"Unicode 周りの大改造に伴いこの関数はなくなり、代わりに「あえてバイト列のほう"
"を返す」  が追加されています(:func:`!os.getcwdu` がもはや Unicode を返すの"
"で)。)。"

#: ../../whatsnew/2.3.rst:350
msgid ""
"Byte strings still work as file names, and on Windows Python will "
"transparently convert them to Unicode using the ``mbcs`` encoding."
msgstr ""
"ファイル名のバイト文字列はいまでも動きます。Windows 版 Python は透過的にそれ"
"らを Unicode に ``mbcs`` エンコーディングを使って変換します。"

#: ../../whatsnew/2.3.rst:353
msgid ""
"Other systems also allow Unicode strings as file names but convert them to "
"byte strings before passing them to the system, which can cause a :exc:"
"`UnicodeError` to be raised. Applications can test whether arbitrary Unicode "
"strings are supported as file names by checking :const:`os.path."
"supports_unicode_filenames`, a Boolean value."
msgstr ""

#: ../../whatsnew/2.3.rst:359
msgid "Under MacOS, :func:`os.listdir` may now return Unicode filenames."
msgstr ""
"MacOS では、 :func:`os.listdir` は Unicode ファイル名を返すようになっているで"
"しょう。"

#: ../../whatsnew/2.3.rst:364
msgid ":pep:`277` - Unicode file name support for Windows NT"
msgstr ":pep:`277` - Windows NT での Unicode ファイル名サポート"

#: ../../whatsnew/2.3.rst:365
msgid ""
"Written by Neil Hodgson; implemented by Neil Hodgson, Martin von Löwis, and "
"Mark Hammond."
msgstr "Neil Hodgson 著; 実装 Neil Hodgson, Martin von Löwis, Mark Hammond。"

#: ../../whatsnew/2.3.rst:375
msgid "PEP 278: Universal Newline Support"
msgstr "PEP 278: Universal Newline サポート"

#: ../../whatsnew/2.3.rst:377
msgid ""
"The three major operating systems used today are Microsoft Windows, Apple's "
"Macintosh OS, and the various Unix derivatives.  A minor irritation of cross-"
"platform work  is that these three platforms all use different characters to "
"mark the ends of lines in text files.  Unix uses the linefeed (ASCII "
"character 10), MacOS uses the carriage return (ASCII character 13), and "
"Windows uses a two-character sequence of a carriage return plus a newline."
msgstr ""
"今日では 3 つの主要なオペレーティングシステムが使われています。 Microsoft "
"Windows, Apple の Macintosh OS, さまざまな Unix 派生系です。テキストファイル"
"の行終端マークに使う文字がこれら 3 つ全てでそれぞれ違っていることが、クロスプ"
"ラットフォームのための仕事における小さな苛立ちです。  Unix が使うのはライン"
"フィード (ASCII 文字 10), MacOS が使うのはキャリッジリターン (ASCII 文字 "
"13),  Windows に至ってはキャリッジリターンとラインフィード 2 文字のシーケンス"
"を使います。"

#: ../../whatsnew/2.3.rst:384
msgid ""
"Python's file objects can now support end of line conventions other than the "
"one followed by the platform on which Python is running. Opening a file with "
"the mode ``'U'`` or ``'rU'`` will open a file for reading in :term:"
"`universal newlines` mode.  All three line ending conventions will be "
"translated to a ``'\\n'`` in the strings returned by the various file "
"methods such as :meth:`!read` and :meth:`!readline`."
msgstr ""
"Python のファイルオブジェクトが、動作しているプラットフォームに従わない行終端"
"変換をサポートするようになりました。ファイルのオープンにモード ``'U'`` や "
"``'rU'`` を使うと、 :term:`universal newlines` モードを使った読み込みとして"
"ファイルを開きます。これで :meth:`!read`, :meth:`!readline` などのファイルメ"
"ソッドが、 3 つどの行終端でも ``'\\n'`` という文字列に翻訳して返すようになり"
"ます。"

#: ../../whatsnew/2.3.rst:391
msgid ""
"Universal newline support is also used when importing modules and when "
"executing a file with the :func:`!execfile` function.  This means that "
"Python modules can be shared between all three operating systems without "
"needing to convert the line-endings."
msgstr ""
"universal newline サポートはモジュールのインポートと :func:`!execfile` 関数で"
"のファイル実行にも使われます。これで 3 つ全てのオペレーティングシステム間で行"
"終端変換の必要なく Python モジュールを共有出来ます。"

#: ../../whatsnew/2.3.rst:396
msgid ""
"This feature can be disabled when compiling Python by specifying the :option:"
"`!--without-universal-newlines` switch when running Python's :program:"
"`configure` script."
msgstr ""
"この機能は Python をソースからビルドする際に :program:`configure` スクリプト"
"に :option:`!--without-universal-newlines` スイッチ を付けることで無効に出来"
"ます。"

#: ../../whatsnew/2.3.rst:403
msgid ":pep:`278` - Universal Newline Support"
msgstr ":pep:`278` : Universal Newline サポート"

#: ../../whatsnew/2.3.rst:404
msgid "Written and implemented by Jack Jansen."
msgstr "Jack Jansen 著、実装"

#: ../../whatsnew/2.3.rst:412
msgid "PEP 279: enumerate()"
msgstr "PEP 279: enumerate()"

#: ../../whatsnew/2.3.rst:414
msgid ""
"A new built-in function, :func:`enumerate`, will make certain loops a bit "
"clearer.  ``enumerate(thing)``, where *thing* is either an iterator or a "
"sequence, returns an iterator that will return ``(0, thing[0])``, ``(1, "
"thing[1])``, ``(2, thing[2])``, and so forth."
msgstr ""
"新たな組み込み関数 :func:`enumerate` はある種のループ処理を少し簡潔にするもの"
"です。 *thing* がイテレータかシーケンスだとして、 ``enumerate(thing)`` は "
"``(0, thing[0])``, ``(1, thing[1])``, ``(2, thing[2])``, … を生成するイテレー"
"タを返します。"

#: ../../whatsnew/2.3.rst:419
msgid "A common idiom to change every element of a list looks like this::"
msgstr ""
"リストの全てを変更するためのよくあるイディオムはこのようなものでしょう::"

#: ../../whatsnew/2.3.rst:421
msgid ""
"for i in range(len(L)):\n"
"    item = L[i]\n"
"    # ... compute some result based on item ...\n"
"    L[i] = result"
msgstr ""

#: ../../whatsnew/2.3.rst:426
msgid "This can be rewritten using :func:`enumerate` as::"
msgstr "これは :func:`enumerate` を使ってこのように書き換えることが出来ます::"

#: ../../whatsnew/2.3.rst:428
msgid ""
"for i, item in enumerate(L):\n"
"    # ... compute some result based on item ...\n"
"    L[i] = result"
msgstr ""

#: ../../whatsnew/2.3.rst:435
msgid ":pep:`279` - The enumerate() built-in function"
msgstr ":pep:`279` - 組み込み関数 enumerate()"

#: ../../whatsnew/2.3.rst:436
msgid "Written and implemented by Raymond D. Hettinger."
msgstr "Raymond D. Hettinger 著、実装."

#: ../../whatsnew/2.3.rst:442
msgid "PEP 282: The logging Package"
msgstr "PEP 282: ロギングパッケージ"

#: ../../whatsnew/2.3.rst:444
msgid ""
"A standard package for writing logs, :mod:`logging`, has been added to "
"Python 2.3.  It provides a powerful and flexible mechanism for generating "
"logging output which can then be filtered and processed in various ways.  A "
"configuration file written in a standard format can be used to control the "
"logging behavior of a program.  Python includes handlers that will write log "
"records to standard error or to a file or socket, send them to the system "
"log, or even e-mail them to a particular address; of course, it's also "
"possible to write your own handler classes."
msgstr ""
"ログ記録のための標準パッケージ :mod:`logging` が Python 2.3 に追加されていま"
"す。それはログ出力生成の強力で柔軟なメカニズムを提供し、フィルタと加工を色々"
"な方法で行えます。標準フォーマットで書く設定ファイルで、プログラムのロギング"
"の振る舞いを制御出来ます。ログレコードを標準エラー出力やファイルやソケット、"
"システムログへの送信、あるいは e-mail 送信するようなハンドラが Python に含ま"
"れています。もちろん、あなた自身のハンドラクラスを書くことも出来ます。"

#: ../../whatsnew/2.3.rst:453
msgid ""
"The :class:`~logging.Logger` class is the primary class. Most application "
"code will deal with one or more :class:`~logging.Logger` objects, each one "
"used by a particular subsystem of the application. Each :class:`~logging."
"Logger` is identified by a name, and names are organized into a hierarchy "
"using ``.``  as the component separator. For example, you might have :class:"
"`~logging.Logger` instances named ``server``, ``server.auth`` and ``server."
"network``.  The latter two instances are below ``server`` in the hierarchy.  "
"This means that if you turn up the verbosity for ``server`` or direct "
"``server`` messages to a different handler, the changes will also apply to "
"records logged to ``server.auth`` and ``server.network``. There's also a "
"root :class:`~logging.Logger` that's the parent of all other loggers."
msgstr ""
":class:`~logging.Logger` が最も重要なクラスです。ほとんどのアプリケーション"
"コードは一つかそれ以上の :class:`~logging.Logger` オブジェクトを扱い、それぞ"
"れ一つはそのアプリケーションの特定のサブシステムで使われるでしょう。それぞれ"
"の :class:`~logging.Logger` は名前で識別され、名前は ``.`` をコンポーネントの"
"セパレータとして使う階層で体系化されます。例えば、 ``server``, ``server."
"auth``, ``server.network`` といった名前の :class:`~logging.Logger` インスタン"
"スを持つといった具合です。この例の後ろ 2 つは階層で ``server`` の下にありま"
"す。 ``server`` への冗長性を見つけた場合や ``server`` メッセージを直接異なる"
"ハンドラに向けた場合、変更は ``server.auth`` と ``server.network`` へのログ記"
"録にも適用されるということです。全てのほかのロガーの親となる、ルート :class:"
"`~logging.Logger` もあります。"

#: ../../whatsnew/2.3.rst:464
msgid ""
"For simple uses, the :mod:`logging` package contains some convenience "
"functions that always use the root log::"
msgstr ""
"単純な用法のために、 :mod:`logging` パッケージはいくつかの便利関数を含んでい"
"て、これは常にルートログを使います::"

#: ../../whatsnew/2.3.rst:467
msgid ""
"import logging\n"
"\n"
"logging.debug('Debugging information')\n"
"logging.info('Informational message')\n"
"logging.warning('Warning:config file %s not found', 'server.conf')\n"
"logging.error('Error occurred')\n"
"logging.critical('Critical error -- shutting down')"
msgstr ""

#: ../../whatsnew/2.3.rst:475 ../../whatsnew/2.3.rst:500
msgid "This produces the following output::"
msgstr "これは以下のような出力をします::"

#: ../../whatsnew/2.3.rst:477
msgid ""
"WARNING:root:Warning:config file server.conf not found\n"
"ERROR:root:Error occurred\n"
"CRITICAL:root:Critical error -- shutting down"
msgstr ""

#: ../../whatsnew/2.3.rst:481
msgid ""
"In the default configuration, informational and debugging messages are "
"suppressed and the output is sent to standard error.  You can enable the "
"display of informational and debugging messages by calling the :meth:"
"`~logging.Logger.setLevel` method on the root logger."
msgstr ""

#: ../../whatsnew/2.3.rst:486
msgid ""
"Notice the :func:`~logging.warning` call's use of string formatting "
"operators; all of the functions for logging messages take the arguments "
"``(msg, arg1, arg2, ...)`` and log the string resulting from ``msg % (arg1, "
"arg2, ...)``."
msgstr ""

#: ../../whatsnew/2.3.rst:490
msgid ""
"There's also an :func:`~logging.exception` function that records the most "
"recent traceback.  Any of the other functions will also record the traceback "
"if you specify a true value for the keyword argument *exc_info*. ::"
msgstr ""

#: ../../whatsnew/2.3.rst:494
msgid ""
"def f():\n"
"    try:    1/0\n"
"    except: logging.exception('Problem recorded')\n"
"\n"
"f()"
msgstr ""

#: ../../whatsnew/2.3.rst:502
msgid ""
"ERROR:root:Problem recorded\n"
"Traceback (most recent call last):\n"
"  File \"t.py\", line 6, in f\n"
"    1/0\n"
"ZeroDivisionError: integer division or modulo by zero"
msgstr ""

#: ../../whatsnew/2.3.rst:508
msgid ""
"Slightly more advanced programs will use a logger other than the root "
"logger. The ``getLogger(name)`` function is used to get a particular log, "
"creating it if it doesn't exist yet. ``getLogger(None)`` returns the root "
"logger. ::"
msgstr ""
"多少なりとも高度なプログラムでは、ルートロガー以上のロガーを使うでしょう。 "
"``getLogger(name)`` 関数は特定のロガーを取得するのに使います。その時点で存在"
"していなければ、作成されます。 ``getLogger(None)`` はルートロガーを返しま"
"す。::"

#: ../../whatsnew/2.3.rst:512
msgid ""
"log = logging.getLogger('server')\n"
" ...\n"
"log.info('Listening on port %i', port)\n"
" ...\n"
"log.critical('Disk full')\n"
" ..."
msgstr ""

#: ../../whatsnew/2.3.rst:519
msgid ""
"Log records are usually propagated up the hierarchy, so a message logged to "
"``server.auth`` is also seen by ``server`` and ``root``, but a :class:"
"`~logging.Logger` can prevent this by setting its :attr:`~logging.Logger."
"propagate` attribute to :const:`False`."
msgstr ""

#: ../../whatsnew/2.3.rst:523
msgid ""
"There are more classes provided by the :mod:`logging` package that can be "
"customized.  When a :class:`~logging.Logger` instance is told to log a "
"message, it creates a :class:`~logging.LogRecord` instance that is sent to "
"any number of different :class:`~logging.Handler` instances.  Loggers and "
"handlers can also have an attached list of filters, and each filter can "
"cause the :class:`~logging.LogRecord` to be ignored or can modify the record "
"before passing it along.  When they're finally output, :class:`~logging."
"LogRecord` instances are converted to text by a :class:`~logging.Formatter` "
"class.  All of these classes can be replaced by your own specially written "
"classes."
msgstr ""

#: ../../whatsnew/2.3.rst:533
msgid ""
"With all of these features the :mod:`logging` package should provide enough "
"flexibility for even the most complicated applications.  This is only an "
"incomplete overview of its features, so please see the package's reference "
"documentation for all of the details.  Reading :pep:`282` will also be "
"helpful."
msgstr ""
"これら全ての機能で :mod:`logging` パッケージは最も複雑なアプリケーションでさ"
"え、十分な柔軟性を提供しているはずです。ここではそれら機能の不完全な概要しか"
"示しませんでしたので、全ての詳細はパッケージのドキュメントを参照してくださ"
"い。 :pep:`282` を読むことも助けになるでしょう。(---訳注: 今ではクックブック"
"もあるのでそちらもどうぞ。---)"

#: ../../whatsnew/2.3.rst:541
msgid ":pep:`282` - A Logging System"
msgstr ":pep:`282` - ログシステム"

#: ../../whatsnew/2.3.rst:542
msgid "Written by Vinay Sajip and Trent Mick; implemented by Vinay Sajip."
msgstr "PEP 著: Vinay Sajip と Trent Mick; 実装: Vinay Sajip."

#: ../../whatsnew/2.3.rst:550
msgid "PEP 285: A Boolean Type"
msgstr "PEP 285: Boolean 型"

#: ../../whatsnew/2.3.rst:552
msgid ""
"A Boolean type was added to Python 2.3.  Two new constants were added to "
"the :mod:`!__builtin__` module, :const:`True` and :const:`False`.  (:const:"
"`True` and :const:`False` constants were added to the built-ins in Python "
"2.2.1, but the 2.2.1 versions are simply set to integer values of 1 and 0 "
"and aren't a different type.)"
msgstr ""

#: ../../whatsnew/2.3.rst:558
msgid ""
"The type object for this new type is named :class:`bool`; the constructor "
"for it takes any Python value and converts it to :const:`True` or :const:"
"`False`. ::"
msgstr ""
"この新しい型の型オブジェクトの名前は :class:`bool` です; これのコンストラクタ"
"は任意の Python 値を取り、 :const:`True` または :const:`False` に変換します::"

#: ../../whatsnew/2.3.rst:561
msgid ""
">>> bool(1)\n"
"True\n"
">>> bool(0)\n"
"False\n"
">>> bool([])\n"
"False\n"
">>> bool( (1,) )\n"
"True"
msgstr ""

#: ../../whatsnew/2.3.rst:570
msgid ""
"Most of the standard library modules and built-in functions have been "
"changed to return Booleans. ::"
msgstr ""
"標準ライブラリモジュールとビルトイン関数のほとんどが、そうすべきときには "
"Boolean を返すように変更されました::"

#: ../../whatsnew/2.3.rst:573
msgid ""
">>> obj = []\n"
">>> hasattr(obj, 'append')\n"
"True\n"
">>> isinstance(obj, list)\n"
"True\n"
">>> isinstance(obj, tuple)\n"
"False"
msgstr ""

#: ../../whatsnew/2.3.rst:581
msgid ""
"Python's Booleans were added with the primary goal of making code clearer.  "
"For example, if you're reading a function and encounter the statement "
"``return 1``, you might wonder whether the ``1`` represents a Boolean truth "
"value, an index, or a coefficient that multiplies some other quantity.  If "
"the statement is ``return True``, however, the meaning of the return value "
"is quite clear."
msgstr ""
"Python の Boolean はコードを明快にすることを主たる目標として追加されました。"
"例えばあなたがコードを読んでいて ``return 1`` に出くわした場合、あなたは考え"
"るはずです。この ``1`` は、真偽としての真値なのであろうか、それともインデクス"
"だろうか、はたまた何かほかの数量に掛ける係数だろうか、と。 ``return True`` で"
"あればその意味するところはかなり明らかです。"

#: ../../whatsnew/2.3.rst:587
msgid ""
"Python's Booleans were *not* added for the sake of strict type-checking.  A "
"very strict language such as Pascal would also prevent you performing "
"arithmetic with Booleans, and would require that the expression in an :"
"keyword:`if` statement always evaluate to a Boolean result.  Python is not "
"this strict and never will be, as :pep:`285` explicitly says.  This means "
"you can still use any expression in an :keyword:`!if` statement, even ones "
"that evaluate to a list or tuple or some random object.  The Boolean type is "
"a subclass of the :class:`int` class so that arithmetic using a Boolean "
"still works. ::"
msgstr ""
"Python の Boolean は、厳格な型チェックを目的として追加された *のではありませ"
"ん* 。Pascal のようなとても厳格な言語では、Boolean の数学演算も阻むでしょう"
"し、 :keyword:`if` ステートメントの式が必ず Boolean の結果に評価されなければ"
"ならないことを要求するでしょう。 Python はこの厳しさを今持ちませんし、 :pep:"
"`285` が名言するように、未来永劫持つことはありません。このことは、 :keyword:"
"`!if` ステートメントにこれからも任意の式を書けることを意味しますし、リストや"
"らタプルやら何かほかのデタラメなオブジェクトに評価されるものでも良いことを意"
"味します。Boolean 型は :class:`int` クラスのサブクラスであって、Boolean の算"
"術演算はこれからも動作します::"

#: ../../whatsnew/2.3.rst:596
msgid ""
">>> True + 1\n"
"2\n"
">>> False + 1\n"
"1\n"
">>> False * 75\n"
"0\n"
">>> True * 75\n"
"75"
msgstr ""

#: ../../whatsnew/2.3.rst:605
msgid ""
"To sum up :const:`True` and :const:`False` in a sentence: they're "
"alternative ways to spell the integer values 1 and 0, with the single "
"difference that :func:`str` and :func:`repr` return the strings ``'True'`` "
"and ``'False'`` instead of ``'1'`` and ``'0'``."
msgstr ""
":const:`True` と :const:`False` はぶっちゃけて言えば…: これらは整数値 1 と 0 "
"の別名だけれども唯一異なるのは :func:`str` と :func:`repr` が ``'1'`` と "
"``'0'`` ではなく ``'True'`` と ``'False'`` を返すことだけである。"

#: ../../whatsnew/2.3.rst:613
msgid ":pep:`285` - Adding a bool type"
msgstr ":pep:`285` - 真偽値型の追加"

#: ../../whatsnew/2.3.rst:614
msgid "Written and implemented by GvR."
msgstr "Guido van Rossum 著、実装"

#: ../../whatsnew/2.3.rst:620
msgid "PEP 293: Codec Error Handling Callbacks"
msgstr "PEP 293: コーデックエラーを処理するコールバック"

#: ../../whatsnew/2.3.rst:622
msgid ""
"When encoding a Unicode string into a byte string, unencodable characters "
"may be encountered.  So far, Python has allowed specifying the error "
"processing as either \"strict\" (raising :exc:`UnicodeError`), "
"\"ignore\" (skipping the character), or \"replace\" (using a question mark "
"in the output string), with \"strict\" being the default behavior. It may be "
"desirable to specify alternative processing of such errors, such as "
"inserting an XML character reference or HTML entity reference into the "
"converted string."
msgstr ""
"Unicode 文字列をバイト文字列にエンコードする際には、エンコード出来ない文字に"
"出会うことがあります。いまのところ Python は、そのエラー処理として "
"\"strict\" (:exc:`UnicodeError` を発生させる)、  \"ignore\" (その文字をスキッ"
"プする)、 \"replace\" (出力文字列ではクエッションマークに置換する)、のいずれ"
"か一つを指定出来て、 \"strict\" がデフォルトの振る舞いになっています。その種"
"のエラーのために、ほかの代わりとなる処理が望ましいかもしれません。例えば XML "
"や HTML の実体参照に置き換えるなどの。"

#: ../../whatsnew/2.3.rst:630
msgid ""
"Python now has a flexible framework to add different processing strategies.  "
"New error handlers can be added with :func:`codecs.register_error`, and "
"codecs then can access the error handler with :func:`codecs.lookup_error`. "
"An equivalent C API has been added for codecs written in C. The error "
"handler gets the necessary state information such as the string being "
"converted, the position in the string where the error was detected, and the "
"target encoding.  The handler can then either raise an exception or return a "
"replacement string."
msgstr ""
"Python は今や、異なる処理戦略を追加する柔軟なフレームワークを手にしました。新"
"しいエラーハンドラを :func:`codecs.register_error` で追加出来、コーデックは :"
"func:`codecs.lookup_error` を使ってそのエラーハンドラにアクセス出来ます。等価"
"な C API も C で書かれたコーデックのために追加されています。エラーハンドラ"
"は、変換すべき文字列、そのエラーが検出されたその文字列内での位置、ターゲット"
"エンコーディングのような必要な状態情報を受け取ります。ハンドラは例外を投げる"
"か、置換文字列を返せます。"

#: ../../whatsnew/2.3.rst:638
msgid ""
"Two additional error handlers have been implemented using this framework: "
"\"backslashreplace\" uses Python backslash quoting to represent unencodable "
"characters and \"xmlcharrefreplace\" emits XML character references."
msgstr ""
"このフレームワークを使って 2 つのエラーハンドラが実装されました: "
"\"backslashreplace\" はエンコード出来ない文字をバックスラッシュで引用し、 "
"\"xmlcharrefreplace\" は XML 文字参照を発行します。"

#: ../../whatsnew/2.3.rst:645
msgid ":pep:`293` - Codec Error Handling Callbacks"
msgstr ":pep:`293` - コーデックエラーを処理するコールバック"

#: ../../whatsnew/2.3.rst:646
msgid "Written and implemented by Walter Dörwald."
msgstr "Walter Dörwald 著、実装"

#: ../../whatsnew/2.3.rst:654
msgid "PEP 301: Package Index and Metadata for Distutils"
msgstr "PEP 301: パッケージインデクスと、 Distutils のためのメタデータ"

#: ../../whatsnew/2.3.rst:656
msgid ""
"Support for the long-requested Python catalog makes its first appearance in "
"2.3."
msgstr "長い間要望されてきた Python カタログのサポートが 2.3 で初登場です。"

#: ../../whatsnew/2.3.rst:658
msgid ""
"The heart of the catalog is the new Distutils :command:`register` command. "
"Running ``python setup.py register`` will collect the metadata describing a "
"package, such as its name, version, maintainer, description, &c., and send "
"it to a central catalog server.  The resulting catalog is available from "
"https://pypi.org."
msgstr ""
"カタログの心臓部は Distutils の新コマンド :command:`register` です。 "
"``python setup.py register`` を実行すると、名前、バージョン、メンテナ、説明、"
"ライセンスのようなパッケージ記述のメタデータを収集して、中央カタログサーバに"
"送信します。結果のカタログは https://pypi.org で利用可能です。"

#: ../../whatsnew/2.3.rst:664
msgid ""
"To make the catalog a bit more useful, a new optional *classifiers* keyword "
"argument has been added to the Distutils :func:`!setup` function.  A list of "
"`Trove <http://catb.org/~esr/trove/>`_-style strings can be supplied to help "
"classify the software."
msgstr ""

#: ../../whatsnew/2.3.rst:669
msgid ""
"Here's an example :file:`setup.py` with classifiers, written to be "
"compatible with older versions of the Distutils::"
msgstr ""
"以下は :file:`setup.py` に分類指定子 (classifier) を記述する例です。 "
"Distutils の古いバージョンと互換になるように書いています。::"

#: ../../whatsnew/2.3.rst:672
msgid ""
"from distutils import core\n"
"kw = {'name': \"Quixote\",\n"
"      'version': \"0.5.1\",\n"
"      'description': \"A highly Pythonic Web application framework\",\n"
"      # ...\n"
"      }\n"
"\n"
"if (hasattr(core, 'setup_keywords') and\n"
"    'classifiers' in core.setup_keywords):\n"
"    kw['classifiers'] = \\\n"
"        ['Topic :: Internet :: WWW/HTTP :: Dynamic Content',\n"
"         'Environment :: No Input/Output (Daemon)',\n"
"         'Intended Audience :: Developers'],\n"
"\n"
"core.setup(**kw)"
msgstr ""

#: ../../whatsnew/2.3.rst:688
msgid ""
"The full list of classifiers can be obtained by running  ``python setup.py "
"register --list-classifiers``."
msgstr ""
"classifier の完全なリストは ``python setup.py register --list-classifiers`` "
"と実行することで得ることが出来ます。"

#: ../../whatsnew/2.3.rst:694
msgid ":pep:`301` - Package Index and Metadata for Distutils"
msgstr ":pep:`301` - パッケージインデクスと、 Distutils のためのメタデータ"

#: ../../whatsnew/2.3.rst:695
msgid "Written and implemented by Richard Jones."
msgstr "Richard Jones 著、実装"

#: ../../whatsnew/2.3.rst:703
msgid "PEP 302: New Import Hooks"
msgstr "PEP 302: 新たなインポートフック"

#: ../../whatsnew/2.3.rst:705
msgid ""
"While it's been possible to write custom import hooks ever since the :mod:`!"
"ihooks` module was introduced in Python 1.3, no one has ever been really "
"happy with it because writing new import hooks is difficult and messy.  "
"There have been various proposed alternatives such as the :mod:`!imputil` "
"and :mod:`!iu` modules, but none of them has ever gained much acceptance, "
"and none of them were easily usable from C code."
msgstr ""
"カスタムなインポートフックを書くことは、Python 1.3 で :mod:`!ihooks` モジュー"
"ルが導入されたその日からずっと可能でした。それでも本当のところそれで幸せに"
"なった人は誰一人いません。それで新しいインポートフックを書くのが難しくてとっ"
"散らかっていたからです。 :mod:`!imputil` と :mod:`!iu` モジュール のような代"
"わりとなる色々な提案がありましたが、そのいずれも多くの賛同を得ることが出来た"
"ものはありませんし、そのいずれもが簡単に C コードから使うことが出来ませんでし"
"た。"

#: ../../whatsnew/2.3.rst:712
msgid ""
":pep:`302` borrows ideas from its predecessors, especially from Gordon "
"McMillan's :mod:`!iu` module.  Three new items  are added to the :mod:`sys` "
"module:"
msgstr ""
":pep:`302` はその先駆者、特に Gordon McMillan の :mod:`!iu` モジュールからア"
"イディアを借りています。3 つの新たなアイテムが :mod:`sys` モジュールに追加さ"
"れています:"

#: ../../whatsnew/2.3.rst:716
msgid ""
"``sys.path_hooks`` is a list of callable objects; most  often they'll be "
"classes.  Each callable takes a string containing a path and either returns "
"an importer object that will handle imports from this path or raises an :exc:"
"`ImportError` exception if it can't handle this path."
msgstr ""
"``sys.path_hooks`` は呼び出し可能オブジェクトのリストです。ほとんどの場合クラ"
"スになるでしょう。それぞれの呼び出し可能オブジェクトは、パスを含む文字列を受"
"け取って、このパスからインポートを処理するインポーターオブジェクトを返すか、"
"このパスを処理出来なければ :exc:`ImportError` を送出します。"

#: ../../whatsnew/2.3.rst:721
msgid ""
"``sys.path_importer_cache`` caches importer objects for each path, so ``sys."
"path_hooks`` will only need to be traversed once for each path."
msgstr ""
"``sys.path_importer_cache`` はそれぞれのパスごとのインポーターオブジェクトを"
"キャッシュしますので、 ``sys.path_hooks`` は個々のパスを一回だけ横断すれば良"
"いことになります。"

#: ../../whatsnew/2.3.rst:724
msgid ""
"``sys.meta_path`` is a list of importer objects that will be traversed "
"before ``sys.path`` is checked.  This list is initially empty, but user code "
"can add objects to it.  Additional built-in and frozen modules can be "
"imported by an object added to this list."
msgstr ""
"``sys.meta_path`` は ``sys.path`` がチェックされる前に横断させるインポーター"
"オブジェクトのリストです(訳注: ここだけ読むとわかりにくいですがライブラリリ"
"ファレンスを読めばわかります)。このリストは初期状態で空ですが、ユーザコードが"
"オブジェクトをそれに追加出来ます。追加のビルトインと凍結モジュールを、このリ"
"ストにオブジェクトを追加することによってインポートさせることが出来ます。"

#: ../../whatsnew/2.3.rst:729
msgid ""
"Importer objects must have a single method, ``find_module(fullname, "
"path=None)``.  *fullname* will be a module or package name, e.g. ``string`` "
"or ``distutils.core``.  :meth:`!find_module` must return a loader object "
"that has a single method, ``load_module(fullname)``, that creates and "
"returns the corresponding module object."
msgstr ""
"インポーターオブジェクトは一つのメソッド ``find_module(fullname, "
"path=None)`` を持たなければなりません。 *fullname* はモジュールかパッケージの"
"名前です。例えば ``string`` や ``distutils.core`` です。 :meth:`!"
"find_module` メソッドは一つのメソッド ``load_module(fullname)`` を持つロー"
"ダーオブジェクトを返さなければなりません。 ``load_module(fullname)`` では対応"
"するモジュールオブジェクトを生成して返します。"

#: ../../whatsnew/2.3.rst:735
msgid ""
"Pseudo-code for Python's new import logic, therefore, looks something like "
"this (simplified a bit; see :pep:`302` for the full details)::"
msgstr ""
"Python の新しいインポートのロジックは、なので、擬似コードで示すとだいたいこん"
"な感じです (少し単純化しています; 完全な詳細は :pep:`302` 参照)::"

#: ../../whatsnew/2.3.rst:738
msgid ""
"for mp in sys.meta_path:\n"
"    loader = mp(fullname)\n"
"    if loader is not None:\n"
"        <module> = loader.load_module(fullname)\n"
"\n"
"for path in sys.path:\n"
"    for hook in sys.path_hooks:\n"
"        try:\n"
"            importer = hook(path)\n"
"        except ImportError:\n"
"            # ImportError, so try the other path hooks\n"
"            pass\n"
"        else:\n"
"            loader = importer.find_module(fullname)\n"
"            <module> = loader.load_module(fullname)\n"
"\n"
"# Not found!\n"
"raise ImportError"
msgstr ""

#: ../../whatsnew/2.3.rst:760
msgid ":pep:`302` - New Import Hooks"
msgstr ":pep:`302` - 新たなインポートフック"

#: ../../whatsnew/2.3.rst:761
msgid ""
"Written by Just van Rossum and Paul Moore. Implemented by Just van Rossum."
msgstr "Just van Rossum、Paul Moore 著、実装 Just van Rossum。"

#: ../../whatsnew/2.3.rst:769
msgid "PEP 305: Comma-separated Files"
msgstr "PEP 305: カンマ区切り形式ファイル"

#: ../../whatsnew/2.3.rst:771
msgid ""
"Comma-separated files are a format frequently used for exporting data from "
"databases and spreadsheets.  Python 2.3 adds a parser for comma-separated "
"files."
msgstr ""
"カンマ区切りファイルは、データベースやスプレッドシートからのエキスポートのた"
"めに頻繁に使われるフォーマットです。Python 2.3 はカンマ区切りファイルのパーサ"
"を追加しました。"

#: ../../whatsnew/2.3.rst:774
msgid "Comma-separated format is deceptively simple at first glance::"
msgstr "カンマ区切りフォーマットは、ぱっと見で、簡単そうに見えます::"

#: ../../whatsnew/2.3.rst:776
msgid "Costs,150,200,3.95"
msgstr ""

#: ../../whatsnew/2.3.rst:778
msgid ""
"Read a line and call ``line.split(',')``: what could be simpler? But toss in "
"string data that can contain commas, and things get more complicated::"
msgstr ""
"行を読んで ``line.split(',')``: これほどに簡単なものはあるだろうか、って? で"
"すが、文字列データ内にカンマを含んだりすると、コトは複雑になります::"

#: ../../whatsnew/2.3.rst:781
msgid "\"Costs\",150,200,3.95,\"Includes taxes, shipping, and sundry items\""
msgstr ""

#: ../../whatsnew/2.3.rst:783
msgid ""
"A big ugly regular expression can parse this, but using the new  :mod:`csv` "
"package is much simpler::"
msgstr ""
"デカくて醜い正規表現でこれをパース出来るでしょうが、新登場の :mod:`csv` を使"
"えば遥かに単純になります::"

#: ../../whatsnew/2.3.rst:786
msgid ""
"import csv\n"
"\n"
"input = open('datafile', 'rb')\n"
"reader = csv.reader(input)\n"
"for line in reader:\n"
"    print line"
msgstr ""

#: ../../whatsnew/2.3.rst:793
msgid ""
"The :func:`~csv.reader` function takes a number of different options. The "
"field separator isn't limited to the comma and can be changed to any "
"character, and so can the quoting and line-ending characters."
msgstr ""

#: ../../whatsnew/2.3.rst:797
msgid ""
"Different dialects of comma-separated files can be defined and registered; "
"currently there are two dialects, both used by Microsoft Excel. A separate :"
"class:`csv.writer` class will generate comma-separated files from a "
"succession of tuples or lists, quoting strings that contain the delimiter."
msgstr ""
"カンマ区切りファイルの異なった方言を定義して登録出来ます。今のところ 2 つの方"
"言があって、両者とも Microsoft Excel で使われるものです。独立している :class:"
"`csv.writer` はタプルやリストの連続から、デリミタを含む文字列は引用符で囲みつ"
"つカンマ区切りファイルを生成します。"

#: ../../whatsnew/2.3.rst:805
msgid ":pep:`305` - CSV File API"
msgstr ":pep:`305` - CSV File API"

#: ../../whatsnew/2.3.rst:806
msgid ""
"Written and implemented  by Kevin Altis, Dave Cole, Andrew McNamara, Skip "
"Montanaro, Cliff Wells."
msgstr ""
"PEP 著と実装: Kevin Altis, Dave Cole, Andrew McNamara, Skip Montanaro, Cliff "
"Wells."

#: ../../whatsnew/2.3.rst:815
msgid "PEP 307: Pickle Enhancements"
msgstr "PEP 307: Pickle の機能拡張"

#: ../../whatsnew/2.3.rst:817
msgid ""
"The :mod:`pickle` and :mod:`!cPickle` modules received some attention during "
"the 2.3 development cycle.  In 2.2, new-style classes could be pickled "
"without difficulty, but they weren't pickled very compactly; :pep:`307` "
"quotes a trivial example where a new-style class results in a pickled string "
"three times longer than that for a classic class."
msgstr ""

#: ../../whatsnew/2.3.rst:823
msgid ""
"The solution was to invent a new pickle protocol.  The :func:`pickle.dumps` "
"function has supported a text-or-binary flag  for a long time.  In 2.3, this "
"flag is redefined from a Boolean to an integer: 0 is the old text-mode "
"pickle format, 1 is the old binary format, and now 2 is a new 2.3-specific "
"format.  A new constant, :const:`pickle.HIGHEST_PROTOCOL`, can be used to "
"select the fanciest protocol available."
msgstr ""
"解決方法として、新しい pickle プロトコルが発明されました。 :func:`pickle."
"dumps` 関数はずっと長い間、テキストとするのかバイナリとするのかについてはサ"
"ポートしていました。2.3 ではこのフラグは Boolean から整数に再定義されました: "
"0 は旧式のテキストモード pickle フォーマット、1 が同じく旧式のバイナリフォー"
"マット、そして 2 が今回の 2.3 から特有のフォーマットです。新しく追加された定"
"数 :const:`pickle.HIGHEST_PROTOCOL` を指定すると、最も望ましいものが選択され"
"ます。"

#: ../../whatsnew/2.3.rst:830
msgid ""
"Unpickling is no longer considered a safe operation.  2.2's :mod:`pickle` "
"provided hooks for trying to prevent unsafe classes from being unpickled "
"(specifically, a :attr:`!__safe_for_unpickling__` attribute), but none of "
"this code was ever audited and therefore it's all been ripped out in 2.3.  "
"You should not unpickle untrusted data in any version of Python."
msgstr ""

#: ../../whatsnew/2.3.rst:836
msgid ""
"To reduce the pickling overhead for new-style classes, a new interface for "
"customizing pickling was added using three special methods: :meth:`~object."
"__getstate__`, :meth:`~object.__setstate__`, and :meth:`~object."
"__getnewargs__`.  Consult :pep:`307` for the full semantics  of these "
"methods."
msgstr ""

#: ../../whatsnew/2.3.rst:841
msgid ""
"As a way to compress pickles yet further, it's now possible to use integer "
"codes instead of long strings to identify pickled classes. The Python "
"Software Foundation will maintain a list of standardized codes; there's also "
"a range of codes for private use.  Currently no codes have been specified."
msgstr ""
"pickle をもっとさらに圧縮する方法として、pickle されるクラスの身元特定のため"
"に長い文字列を使う代わりに整数コードを使えるようになっています。Python "
"Software Foundation は標準コードのリストを保守しています; プライベート使用の"
"ためのコード範囲もあります。現在のところ指定されているコードはありません。"

#: ../../whatsnew/2.3.rst:849
msgid ":pep:`307` - Extensions to the pickle protocol"
msgstr ":pep:`307` - pickle プロトコルの拡張"

#: ../../whatsnew/2.3.rst:850
msgid "Written and implemented  by Guido van Rossum and Tim Peters."
msgstr "著、実装: Guido van Rossum と Tim Peters "

#: ../../whatsnew/2.3.rst:858
msgid "Extended Slices"
msgstr "拡張スライス"

#: ../../whatsnew/2.3.rst:860
msgid ""
"Ever since Python 1.4, the slicing syntax has supported an optional third "
"\"step\" or \"stride\" argument.  For example, these are all legal Python "
"syntax: ``L[1:10:2]``, ``L[:-1:1]``, ``L[::-1]``.  This was added to Python "
"at the request of the developers of Numerical Python, which uses the third "
"argument extensively.  However, Python's built-in list, tuple, and string "
"sequence types have never supported this feature, raising a :exc:`TypeError` "
"if you tried it. Michael Hudson contributed a patch to fix this shortcoming."
msgstr ""
"Python 1.4 以来ずっと、スライシングの構文は省略可能な 3 つ目の引数 \"step\" "
"またの名を \"stride\" 、をサポートしていたのです。例えばこれらは全て合法な "
"Python 構文です: ``L[1:10:2]``, ``L[:-1:1]``, ``L[::-1]`` 。これはこの 3 つ目"
"の引数を大々的に使う Numerical Python 開発者によって要望されたことで Python "
"に追加されたものですが、Python ビルトインのリスト、タプル、文字列といったシー"
"ケンス型がこの機能をサポートすることはなく、これを試みると :exc:`TypeError` "
"を起こしていました。Michael Hudson がこの不徹底を修正するパッチを寄稿しまし"
"た。"

#: ../../whatsnew/2.3.rst:868
msgid ""
"For example, you can now easily extract the elements of a list that have "
"even indexes::"
msgstr "例えば、今やリストの偶数番目要素を簡単に取り出せます::"

#: ../../whatsnew/2.3.rst:871
msgid ""
">>> L = range(10)\n"
">>> L[::2]\n"
"[0, 2, 4, 6, 8]"
msgstr ""

#: ../../whatsnew/2.3.rst:875
msgid ""
"Negative values also work to make a copy of the same list in reverse order::"
msgstr "負の値では、同じリストの逆順コピーを作るように動作します::"

#: ../../whatsnew/2.3.rst:877
msgid ""
">>> L[::-1]\n"
"[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]"
msgstr ""

#: ../../whatsnew/2.3.rst:880
msgid "This also works for tuples, arrays, and strings::"
msgstr "これはタプル、配列、文字列に対しても使えます::"

#: ../../whatsnew/2.3.rst:882
msgid ""
">>> s='abcd'\n"
">>> s[::2]\n"
"'ac'\n"
">>> s[::-1]\n"
"'dcba'"
msgstr ""

#: ../../whatsnew/2.3.rst:888
msgid ""
"If you have a mutable sequence such as a list or an array you can assign to "
"or delete an extended slice, but there are some differences between "
"assignment to extended and regular slices.  Assignment to a regular slice "
"can be used to change the length of the sequence::"
msgstr ""
"リストや配列のような :term:`mutable` なシーケンスに対して、拡張スライスを代入"
"や削除に使えますが、拡張スライスと普通のスライスではいくつかの違いがありま"
"す。普通のスライスで代入を行えば、シーケンスの長さを変更出来ます (---訳注: 念"
"のため。Python 3 の range は list を直接返す関数ではなくジェネレータなので、"
"以下例は ``a = list(range(3))`` などとしないと動作しません。続く例でも同じで"
"す。---)::"

#: ../../whatsnew/2.3.rst:893
msgid ""
">>> a = range(3)\n"
">>> a\n"
"[0, 1, 2]\n"
">>> a[1:3] = [4, 5, 6]\n"
">>> a\n"
"[0, 4, 5, 6]"
msgstr ""

#: ../../whatsnew/2.3.rst:900
msgid ""
"Extended slices aren't this flexible.  When assigning to an extended slice, "
"the list on the right hand side of the statement must contain the same "
"number of items as the slice it is replacing::"
msgstr ""
"拡張スライスにはこの柔軟性はありません。拡張スライスを代入に使う際は、ステー"
"トメントの右辺のリストは、置換されるスライスとしての要素数と同数でなければな"
"りません::"

#: ../../whatsnew/2.3.rst:904
msgid ""
">>> a = range(4)\n"
">>> a\n"
"[0, 1, 2, 3]\n"
">>> a[::2]\n"
"[0, 2]\n"
">>> a[::2] = [0, -1]\n"
">>> a\n"
"[0, 1, -1, 3]\n"
">>> a[::2] = [0,1,2]\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in ?\n"
"ValueError: attempt to assign sequence of size 3 to extended slice of size 2"
msgstr ""

#: ../../whatsnew/2.3.rst:917
msgid "Deletion is more straightforward::"
msgstr "削除はもっと素直です::"

#: ../../whatsnew/2.3.rst:919
msgid ""
">>> a = range(4)\n"
">>> a\n"
"[0, 1, 2, 3]\n"
">>> a[::2]\n"
"[0, 2]\n"
">>> del a[::2]\n"
">>> a\n"
"[1, 3]"
msgstr ""

#: ../../whatsnew/2.3.rst:928
msgid ""
"One can also now pass slice objects to the :meth:`~object.__getitem__` "
"methods of the built-in sequences::"
msgstr ""

#: ../../whatsnew/2.3.rst:931
msgid ""
">>> range(10).__getitem__(slice(0, 5, 2))\n"
"[0, 2, 4]"
msgstr ""

#: ../../whatsnew/2.3.rst:934
msgid "Or use slice objects directly in subscripts::"
msgstr "あるいは直接 slice オブジェクトを添え字に使えます::"

#: ../../whatsnew/2.3.rst:936
msgid ""
">>> range(10)[slice(0, 5, 2)]\n"
"[0, 2, 4]"
msgstr ""

#: ../../whatsnew/2.3.rst:939
msgid ""
"To simplify implementing sequences that support extended slicing, slice "
"objects now have a method ``indices(length)`` which, given the length of a "
"sequence, returns a ``(start, stop, step)`` tuple that can be passed "
"directly to :func:`range`. :meth:`!indices` handles omitted and out-of-"
"bounds indices in a manner consistent with regular slices (and this "
"innocuous phrase hides a welter of confusing details!).  The method is "
"intended to be used like this::"
msgstr ""

#: ../../whatsnew/2.3.rst:946
msgid ""
"class FakeSeq:\n"
"    ...\n"
"    def calc_item(self, i):\n"
"        ...\n"
"    def __getitem__(self, item):\n"
"        if isinstance(item, slice):\n"
"            indices = item.indices(len(self))\n"
"            return FakeSeq([self.calc_item(i) for i in range(*indices)])\n"
"        else:\n"
"            return self.calc_item(i)"
msgstr ""

#: ../../whatsnew/2.3.rst:957
msgid ""
"From this example you can also see that the built-in :class:`slice` object "
"is now the type object for the slice type, and is no longer a function.  "
"This is consistent with Python 2.2, where :class:`int`, :class:`str`, etc., "
"underwent the same change."
msgstr ""
"ところでこの例からは、ビルトインの :class:`slice` オブジェクトが今では slice "
"型という型オブジェクトで、もう関数ではないことがわかるでしょう。これは、"
"Python 2.2 で :class:`int`, :class:`str` などに対して行われた同じ目的の修正と"
"一貫しています。"

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

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

#: ../../whatsnew/2.3.rst:970
msgid ""
"The :keyword:`yield` statement is now always a keyword, as described in "
"section :ref:`section-generators` of this document."
msgstr ""
":keyword:`yield` 文がこのドキュメントの :ref:`section-generators` で述べた通"
"り、キーワードになっています。"

#: ../../whatsnew/2.3.rst:973
msgid ""
"A new built-in function :func:`enumerate` was added, as described in "
"section :ref:`section-enumerate` of this document."
msgstr ""
"新たな組み込み関数 :func:`enumerate` が追加されました。このドキュメントの :"
"ref:`section-enumerate` で述べた通りです。"

#: ../../whatsnew/2.3.rst:976
msgid ""
"Two new constants, :const:`True` and :const:`False` were added along with "
"the built-in :class:`bool` type, as described in section :ref:`section-bool` "
"of this document."
msgstr ""
"新たな定数 :const:`True`,  :const:`False` がビルトイン :class:`bool` 型の追加"
"に伴い追加されました。このドキュメントの :ref:`section-bool` で述べた通りで"
"す。"

#: ../../whatsnew/2.3.rst:980
msgid ""
"The :func:`int` type constructor will now return a long integer instead of "
"raising an :exc:`OverflowError` when a string or floating-point number is "
"too large to fit into an integer.  This can lead to the paradoxical result "
"that ``isinstance(int(expression), int)`` is false, but that seems unlikely "
"to cause problems in practice."
msgstr ""
":func:`int` 型コンストラクタは、文字列や浮動小数点数を整数に収める際、それが"
"とても大き場合に  :exc:`OverflowError` を投げるのではなく長整数を返すように"
"なっています。これは ``isinstance(int(expression), int)`` が偽を返すかもしれ"
"ないという逆説的な結果をもたらし得ますが、これが実際に問題を起こすとはあまり"
"思えません。"

#: ../../whatsnew/2.3.rst:986
msgid ""
"Built-in types now support the extended slicing syntax, as described in "
"section :ref:`section-slices` of this document."
msgstr ""
"ビルトイン型が拡張スライス構文をサポートするようになりました。このドキュメン"
"トの :ref:`section-slices` で述べた通りです。"

#: ../../whatsnew/2.3.rst:989
msgid ""
"A new built-in function, ``sum(iterable, start=0)``,  adds up the numeric "
"items in the iterable object and returns their sum.  :func:`sum` only "
"accepts numbers, meaning that you can't use it to concatenate a bunch of "
"strings. (Contributed by Alex Martelli.)"
msgstr ""
"新規組み込み関数 ``sum(iterable, start=0)`` はイテラブル オブジェクト内の数値"
"アイテムを足し込んで総和を返します。 :func:`sum` は数値しか受け付けませんの"
"で、文字列群を連結するのには使えません。 (Contributed by Alex Martelli.)"

#: ../../whatsnew/2.3.rst:994
msgid ""
"``list.insert(pos, value)`` used to  insert *value* at the front of the list "
"when *pos* was negative.  The behaviour has now been changed to be "
"consistent with slice indexing, so when *pos* is -1 the value will be "
"inserted before the last element, and so forth."
msgstr ""
"``list.insert(pos, value)`` で *value* を先頭に追加するのに *pos* に負数が使"
"われてきました。この振る舞いはスライスのインデクシングとの一貫性のために変更"
"されました。つまり *pos* が -1 の場合は最終要素の前への追加、などとなります。"

#: ../../whatsnew/2.3.rst:999
msgid ""
"``list.index(value)``, which searches for *value*  within the list and "
"returns its index, now takes optional  *start* and *stop* arguments to limit "
"the search to  only part of the list."
msgstr ""
"``list.index(value)`` はリスト内から *value* を探してそのインデクスを返します"
"が、オプショナルな *start* と *stop* 引数を取って、リストの部分列からの検索が"
"可能になりました。"

#: ../../whatsnew/2.3.rst:1003
msgid ""
"Dictionaries have a new method, ``pop(key[, *default*])``, that returns the "
"value corresponding to *key* and removes that key/value pair from the "
"dictionary.  If the requested key isn't present in the dictionary, *default* "
"is returned if it's specified and :exc:`KeyError` raised if it isn't. ::"
msgstr ""
"辞書の新たなメソッド ``pop(key[, *default*])`` は、 *key* に対応する値を返し"
"て辞書からそのキー/値ペアを取り除きます。辞書内にそのキーが不在であれば、 "
"*default* が指定されていればそれを、そうでなければ :exc:`KeyError` を投げま"
"す。::"

#: ../../whatsnew/2.3.rst:1008
msgid ""
">>> d = {1:2}\n"
">>> d\n"
"{1: 2}\n"
">>> d.pop(4)\n"
"Traceback (most recent call last):\n"
"  File \"stdin\", line 1, in ?\n"
"KeyError: 4\n"
">>> d.pop(1)\n"
"2\n"
">>> d.pop(1)\n"
"Traceback (most recent call last):\n"
"  File \"stdin\", line 1, in ?\n"
"KeyError: 'pop(): dictionary is empty'\n"
">>> d\n"
"{}\n"
">>>"
msgstr ""

#: ../../whatsnew/2.3.rst:1025
msgid ""
"There's also a new class method,  ``dict.fromkeys(iterable, value)``, that "
"creates a dictionary with keys taken from the supplied iterator *iterable* "
"and all values set to *value*, defaulting to ``None``."
msgstr ""
"また、新しいメソッド ``dict.fromkeys(iterable, value)`` は、与えられたイテ"
"レータ *iterable* からキーを取り出しつつ全ての値を *value* にセットすることで"
"構築します。 *value* のデフォルトは ``None`` です。"

#: ../../whatsnew/2.3.rst:1029
msgid "(Patches contributed by Raymond Hettinger.)"
msgstr "(Patches contributed by Raymond Hettinger.)"

#: ../../whatsnew/2.3.rst:1031
msgid ""
"Also, the :func:`dict` constructor now accepts keyword arguments to simplify "
"creating small dictionaries::"
msgstr ""
"また、 :func:`dict` コンストラクタは小さな辞書を簡単に構築出来るよう、キー"
"ワード引数を受け付けるようになりました::"

#: ../../whatsnew/2.3.rst:1034
msgid ""
">>> dict(red=1, blue=2, green=3, black=4)\n"
"{'blue': 2, 'black': 4, 'green': 3, 'red': 1}"
msgstr ""

#: ../../whatsnew/2.3.rst:1037
msgid "(Contributed by Just van Rossum.)"
msgstr "(Contributed by Just van Rossum.)"

#: ../../whatsnew/2.3.rst:1039
msgid ""
"The :keyword:`assert` statement no longer checks the ``__debug__`` flag, so "
"you can no longer disable assertions by assigning to ``__debug__``. Running "
"Python with the :option:`-O` switch will still generate code that doesn't "
"execute any assertions."
msgstr ""
":keyword:`assert` ステートメントが ``__debug__`` フラグをチェックすることはも"
"うありません。このため、 ``__debug__`` に代入することによってアサーションを無"
"効にすることは出来ません。Python を :option:`-O` スイッチで起動により全てのア"
"サーションが実行されない点は、以前と変わりません。"

#: ../../whatsnew/2.3.rst:1044
msgid ""
"Most type objects are now callable, so you can use them to create new "
"objects such as functions, classes, and modules.  (This means that the :mod:"
"`!new` module can be deprecated in a future Python version, because you can "
"now use the type objects available in the :mod:`types` module.) For example, "
"you can create a new module object with the following code:"
msgstr ""
"ほとんどの型オブジェクトが今では呼び出し可能であり、なので関数、クラス、モ"
"ジュールのようなオブジェクトを新たに構築するのにそれを使えます。 (:mod:`!"
"new` モジュールはこれにより将来のバージョンの Python で撤廃される可能性があり"
"ます。 :mod:`types` モジュール内の型オブジェクトが使えるからです。 ---訳注: "
"2.6 で実際に撤廃されています。---) 例えば、新規モジュールオブジェクトは以下"
"コードで構築出来ます:"

#: ../../whatsnew/2.3.rst:1052
msgid ""
">>> import types\n"
">>> m = types.ModuleType('abc','docstring')\n"
">>> m\n"
"<module 'abc' (built-in)>\n"
">>> m.__doc__\n"
"'docstring'"
msgstr ""

#: ../../whatsnew/2.3.rst:1059
msgid ""
"A new warning, :exc:`PendingDeprecationWarning` was added to indicate "
"features which are in the process of being deprecated.  The warning will "
"*not* be printed by default.  To check for use of features that will be "
"deprecated in the future, supply :option:`-Walways::"
"PendingDeprecationWarning:: <-W>` on the command line or use :func:`warnings."
"filterwarnings`."
msgstr ""
"新たな警告 :exc:`PendingDeprecationWarning` が、将来廃止される予定のある機能"
"であることを示すために追加されました。この警告はデフォルトで *出力されません"
"* 。将来において廃止される予定の機能の使用をチェックするにはコマンドラインか"
"ら :option:`-Walways::PendingDeprecationWarning:: <-W>` を与えるか、 :func:"
"`warnings.filterwarnings` を使います。"

#: ../../whatsnew/2.3.rst:1065
msgid ""
"The process of deprecating string-based exceptions, as in ``raise \"Error "
"occurred\"``, has begun.  Raising a string will now trigger :exc:"
"`PendingDeprecationWarning`."
msgstr ""
"文字列ベースの例外、例えば ``raise \"Error occurred\"`` のようなもの、これは"
"廃止のための過程を開始しています。文字列を例外として投げると :exc:"
"`PendingDeprecationWarning` が発行されます。"

#: ../../whatsnew/2.3.rst:1069
msgid ""
"Using ``None`` as a variable name will now result in a :exc:`SyntaxWarning` "
"warning.  In a future version of Python, ``None`` may finally become a "
"keyword."
msgstr ""
"``None`` を変数名に使うと :exc:`SyntaxWarning` 警告を出すようになっています。"
"将来バージョンの Python では ``None`` はキーワードになります。"

#: ../../whatsnew/2.3.rst:1072
msgid ""
"The :meth:`!xreadlines` method of file objects, introduced in Python 2.1, is "
"no longer necessary because files now behave as their own iterator. :meth:`!"
"xreadlines` was originally introduced as a faster way to loop over all the "
"lines in a file, but now you can simply write ``for line in file_obj``. File "
"objects also have a new read-only :attr:`!encoding` attribute that gives the "
"encoding used by the file; Unicode strings written to the file will be "
"automatically  converted to bytes using the given encoding."
msgstr ""

#: ../../whatsnew/2.3.rst:1080
msgid ""
"The method resolution order used by new-style classes has changed, though "
"you'll only notice the difference if you have a really complicated "
"inheritance hierarchy.  Classic classes are unaffected by this change.  "
"Python 2.2 originally used a topological sort of a class's ancestors, but "
"2.3 now uses the C3 algorithm as described in the paper `\"A Monotonic "
"Superclass Linearization for Dylan\" <https://citeseerx.ist.psu.edu/viewdoc/"
"summary?doi=10.1.1.19.3910>`_. To understand the motivation for this "
"change,  read Michele Simionato's article :ref:`python_2.3_mro`, or read the "
"thread on python-dev starting with the message at https://mail.python.org/"
"pipermail/python-dev/2002-October/029035.html. Samuele Pedroni first pointed "
"out the problem and also implemented the fix by coding the C3 algorithm."
msgstr ""

#: ../../whatsnew/2.3.rst:1093
msgid ""
"Python runs multithreaded programs by switching between threads after "
"executing N bytecodes.  The default value for N has been increased from 10 "
"to 100 bytecodes, speeding up single-threaded applications by reducing the "
"switching overhead.  Some multithreaded applications may suffer slower "
"response time, but that's easily fixed by setting the limit back to a lower "
"number using ``sys.setcheckinterval(N)``. The limit can be retrieved with "
"the new :func:`!sys.getcheckinterval` function."
msgstr ""

#: ../../whatsnew/2.3.rst:1101
msgid ""
"One minor but far-reaching change is that the names of extension types "
"defined by the modules included with Python now contain the module and a "
"``'.'`` in front of the type name.  For example, in Python 2.2, if you "
"created a socket and printed its :attr:`!__class__`, you'd get this output::"
msgstr ""
"マイナーですが広範囲に渡る変更として、拡張型の名前の変更があります。Python と"
"一緒に含まれるモジュールで定義される拡張型の名前が、モジュール名と ``'.'`` が"
"型名に前置されるようになりました。例えば、Python 2.2 ではソケットオブジェクト"
"を作って :attr:`!__class__` を出力すると、このような出力だったでしょう::"

#: ../../whatsnew/2.3.rst:1106
msgid ""
">>> s = socket.socket()\n"
">>> s.__class__\n"
"<type 'socket'>"
msgstr ""

#: ../../whatsnew/2.3.rst:1110
msgid "In 2.3, you get this::"
msgstr "2.3 ではこうなります::"

#: ../../whatsnew/2.3.rst:1112
msgid ""
">>> s.__class__\n"
"<type '_socket.socket'>"
msgstr ""

#: ../../whatsnew/2.3.rst:1115
msgid ""
"One of the noted incompatibilities between old- and new-style classes has "
"been removed: you can now assign to the :attr:`~type.__name__` and :attr:"
"`~type.__bases__` attributes of new-style classes.  There are some "
"restrictions on what can be assigned to :attr:`!__bases__` along the lines "
"of those relating to assigning to an instance's :attr:`~object.__class__` "
"attribute."
msgstr ""

#: ../../whatsnew/2.3.rst:1125
msgid "String Changes"
msgstr "文字列に関する変更"

#: ../../whatsnew/2.3.rst:1127
msgid ""
"The :keyword:`in` operator now works differently for strings. Previously, "
"when evaluating ``X in Y`` where *X* and *Y* are strings, *X* could only be "
"a single character. That's now changed; *X* can be a string of any length, "
"and ``X in Y`` will return :const:`True` if *X* is a substring of *Y*.  If "
"*X* is the empty string, the result is always :const:`True`. ::"
msgstr ""
":keyword:`in` 演算子が文字列に対して違った振る舞いをするようになりました。以"
"前は *X* と *Y* が文字列の場合の ``X in Y`` は、 *X* は単一文字でなければなり"
"ませんでした。これが *X* はどんな長さでも良くなり、 ``X in Y`` は *X* が *Y* "
"のサブストリングであれば :const:`True` を返すように変更されました。 *X* が空"
"文字列の場合は結果は常に :const:`True` になります。 ::"

#: ../../whatsnew/2.3.rst:1133
msgid ""
">>> 'ab' in 'abcd'\n"
"True\n"
">>> 'ad' in 'abcd'\n"
"False\n"
">>> '' in 'abcd'\n"
"True"
msgstr ""

#: ../../whatsnew/2.3.rst:1140
msgid ""
"Note that this doesn't tell you where the substring starts; if you need that "
"information, use the :meth:`~str.find` string method."
msgstr ""
"これはサブストリングの開始位置を教えてくれるわけではないので、その情報が必要"
"であれば :meth:`~str.find` 文字列メソッドを使ってください。"

#: ../../whatsnew/2.3.rst:1143
msgid ""
"The :meth:`~str.strip`, :meth:`~str.lstrip`, and :meth:`~str.rstrip` string "
"methods now have an optional argument for specifying the characters to "
"strip.  The default is still to remove all whitespace characters::"
msgstr ""
":meth:`~str.strip`, :meth:`~str.lstrip`, :meth:`~str.rstrip` に、剥ぎ取る文字"
"を指定する省略可能な引数が追加されています。デフォルトは従来通り全ての空白文"
"字を削除します。::"

#: ../../whatsnew/2.3.rst:1147
msgid ""
">>> '   abc '.strip()\n"
"'abc'\n"
">>> '><><abc<><><>'.strip('<>')\n"
"'abc'\n"
">>> '><><abc<><><>\\n'.strip('<>')\n"
"'abc<><><>\\n'\n"
">>> u'\\u4000\\u4001abc\\u4000'.strip(u'\\u4000')\n"
"u'\\u4001abc'\n"
">>>"
msgstr ""

#: ../../whatsnew/2.3.rst:1157
msgid "(Suggested by Simon Brunning and implemented by Walter Dörwald.)"
msgstr "(Suggested by Simon Brunning and implemented by Walter Dörwald.)"

#: ../../whatsnew/2.3.rst:1159
msgid ""
"The :meth:`~str.startswith` and :meth:`~str.endswith` string methods now "
"accept negative numbers for the *start* and *end* parameters."
msgstr ""

#: ../../whatsnew/2.3.rst:1162
msgid ""
"Another new string method is :meth:`~str.zfill`, originally a function in "
"the :mod:`string` module.  :meth:`~str.zfill` pads a numeric string with "
"zeros on the left until it's the specified width. Note that the ``%`` "
"operator is still more flexible and powerful than :meth:`~str.zfill`. ::"
msgstr ""

#: ../../whatsnew/2.3.rst:1167
msgid ""
">>> '45'.zfill(4)\n"
"'0045'\n"
">>> '12345'.zfill(4)\n"
"'12345'\n"
">>> 'goofy'.zfill(6)\n"
"'0goofy'"
msgstr ""

#: ../../whatsnew/2.3.rst:1174
msgid "(Contributed by Walter Dörwald.)"
msgstr "(Contributed by Walter Dörwald.)"

#: ../../whatsnew/2.3.rst:1176
msgid ""
"A new type object, :class:`!basestring`, has been added. Both 8-bit strings "
"and Unicode strings inherit from this type, so ``isinstance(obj, "
"basestring)`` will return :const:`True` for either kind of string.  It's a "
"completely abstract type, so you can't create :class:`!basestring` instances."
msgstr ""

#: ../../whatsnew/2.3.rst:1181
msgid ""
"Interned strings are no longer immortal and will now be garbage-collected in "
"the usual way when the only reference to them is from the internal "
"dictionary of interned strings.  (Implemented by Oren Tirosh.)"
msgstr ""
"内部化した文字列はもう不死身ではないので、内部辞書からの参照が、参照している"
"唯一のものとなれば、普通にガーベージコレクト対象となります。 (Implemented by "
"Oren Tirosh.)"

#: ../../whatsnew/2.3.rst:1189
msgid "Optimizations"
msgstr "最適化"

#: ../../whatsnew/2.3.rst:1191
msgid ""
"The creation of new-style class instances has been made much faster; they're "
"now faster than classic classes!"
msgstr ""

#: ../../whatsnew/2.3.rst:1194
msgid ""
"The :meth:`~list.sort` method of list objects has been extensively rewritten "
"by Tim Peters, and the implementation is significantly faster."
msgstr ""

#: ../../whatsnew/2.3.rst:1197
msgid ""
"Multiplication of large long integers is now much faster thanks to an "
"implementation of Karatsuba multiplication, an algorithm that scales better "
"than the *O*\\ (*n*\\ :sup:`2`) required for the grade-school multiplication "
"algorithm.  (Original patch by Christopher A. Craig, and significantly "
"reworked by Tim Peters.)"
msgstr ""

#: ../../whatsnew/2.3.rst:1202
msgid ""
"The ``SET_LINENO`` opcode is now gone.  This may provide a small speed "
"increase, depending on your compiler's idiosyncrasies. See section :ref:"
"`23section-other` for a longer explanation. (Removed by Michael Hudson.)"
msgstr ""

#: ../../whatsnew/2.3.rst:1206
msgid ""
":func:`!xrange` objects now have their own iterator, making ``for i in "
"xrange(n)`` slightly faster than ``for i in range(n)``.  (Patch by Raymond "
"Hettinger.)"
msgstr ""

#: ../../whatsnew/2.3.rst:1210
msgid ""
"A number of small rearrangements have been made in various hotspots to "
"improve performance, such as inlining a function or removing some code.  "
"(Implemented mostly by GvR, but lots of people have contributed single "
"changes.)"
msgstr ""

#: ../../whatsnew/2.3.rst:1214
msgid ""
"The net result of the 2.3 optimizations is that Python 2.3 runs the  pystone "
"benchmark around 25% faster than Python 2.2."
msgstr ""

#: ../../whatsnew/2.3.rst:1221
msgid "New, Improved, and Deprecated Modules"
msgstr "新たなモジュール、改良されたモジュール、非推奨のモジュール"

#: ../../whatsnew/2.3.rst:1223
msgid ""
"As usual, Python's standard library received a number of enhancements and "
"bug fixes.  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 CVS "
"logs for all the details."
msgstr ""
"いつものように、Python の標準ライブラリには数多くの拡張とバグ修正がありまし"
"た。ここでは最も注目に値する変更について、モジュールの辞書順に列挙します。変"
"更の完全なリストについてはソースツリーの :file:`Misc/NEWS` を調べるか、あるい"
"は全ての詳細について CVS ログに目を通してみてください。"

#: ../../whatsnew/2.3.rst:1228
msgid ""
"The :mod:`array` module now supports arrays of Unicode characters using the "
"``'u'`` format character.  Arrays also now support using the ``+=`` "
"assignment operator to add another array's contents, and the ``*=`` "
"assignment operator to repeat an array. (Contributed by Jason Orendorff.)"
msgstr ""
":mod:`array` モジュールが ``'u'`` フォーマット文字を使った Unicode 文字の配列"
"をサポートするようになっています。配列はまた、 ``+=`` 代入演算子を使ってほか"
"の配列内容を加算すること、 ``*=`` 演算子を使って配列を繰り返すことが可能に"
"なっています。(Contributed by Jason Orendorff.)"

#: ../../whatsnew/2.3.rst:1233
msgid ""
"The :mod:`!bsddb` module has been replaced by version 4.1.6 of the `PyBSDDB "
"<https://pybsddb.sourceforge.net>`_ package, providing a more complete "
"interface to the transactional features of the BerkeleyDB library."
msgstr ""
":mod:`!bsddb` モジュールが `PyBSDDB <https://pybsddb.sourceforge.net>`_ バー"
"ジョン 4.1.6 によって置き換えられています。これは BerkeleyDB のトランザクショ"
"ンの機能へのより完全なインターフェースを提供します。"

#: ../../whatsnew/2.3.rst:1237
msgid ""
"The old version of the module has been renamed to  :mod:`!bsddb185` and is "
"no longer built automatically; you'll  have to edit :file:`Modules/Setup` to "
"enable it.  Note that the new :mod:`!bsddb` package is intended to be "
"compatible with the  old module, so be sure to file bugs if you discover any "
"incompatibilities. When upgrading to Python 2.3, if the new interpreter is "
"compiled with a new version of  the underlying BerkeleyDB library, you will "
"almost certainly have to convert your database files to the new version.  "
"You can do this fairly easily with the new scripts :file:`db2pickle.py` and :"
"file:`pickle2db.py` which you will find in the distribution's :file:`Tools/"
"scripts` directory.  If you've already been using the PyBSDDB package and "
"importing it as :mod:`!bsddb3`, you will have to change your ``import`` "
"statements to import it as :mod:`!bsddb`."
msgstr ""
"古いバージョンのモジュールは :mod:`!bsddb185` にリネームされて、自動的にはビ"
"ルドされません。有効にするには :file:`Modules/Setup` を編集する必要がありま"
"す。新しい :mod:`!bsddb` パッケージは古いモジュールと互換となるように意図され"
"ていますので、何か非互換を見つけたらファイルのバグを確認してください。Python "
"2.3 へのアップグレードの際、前提となる BerkeleyDB ライブラリの新バージョンで"
"インタープリタがコンパイルされるならば、ほぼ確実にあなたのデータベースは新"
"バージョンに変換しなければならないでしょう。ソース配布物の :file:`Tools/"
"scripts` ディレクトリの :file:`db2pickle.py` と :file:`pickle2db.py` スクリプ"
"トを使って、これをかなり簡単に行うことが出来ます。もし既に PyBSDDB パッケージ"
"を使っていて :mod:`!bsddb3` としてインポートしているならば、 :mod:`!bsddb` を"
"インポートするように ``import`` 文を変更する必要があります。"

#: ../../whatsnew/2.3.rst:1249
msgid ""
"The new :mod:`bz2` module is an interface to the bz2 data compression "
"library. bz2-compressed data is usually smaller than  corresponding :mod:"
"`zlib`\\ -compressed data. (Contributed by Gustavo Niemeyer.)"
msgstr ""
"新規の :mod:`bz2` モジュールは bz2 データ圧縮ライブラリへのインターフェイスで"
"す。bz2 圧縮データは普通 :mod:`zlib` 圧縮データよりも小さくなります。 "
"(Contributed by Gustavo Niemeyer.)"

#: ../../whatsnew/2.3.rst:1253
msgid ""
"A set of standard date/time types has been added in the new :mod:`datetime` "
"module.  See the following section for more details."
msgstr ""
"標準の日付時刻型が :mod:`datetime` モジュールとして追加されています。詳細はこ"
"のドキュメントの下の方に記述してありますのでそちらを参照して下さい。"

#: ../../whatsnew/2.3.rst:1256
msgid ""
"The Distutils :class:`!Extension` class now supports an extra constructor "
"argument named *depends* for listing additional source files that an "
"extension depends on.  This lets Distutils recompile the module if any of "
"the dependency files are modified.  For example, if :file:`sampmodule.c` "
"includes the header file :file:`sample.h`, you would create the :class:`!"
"Extension` object like this::"
msgstr ""

#: ../../whatsnew/2.3.rst:1263
msgid ""
"ext = Extension(\"samp\",\n"
"                sources=[\"sampmodule.c\"],\n"
"                depends=[\"sample.h\"])"
msgstr ""

#: ../../whatsnew/2.3.rst:1267
msgid ""
"Modifying :file:`sample.h` would then cause the module to be recompiled. "
"(Contributed by Jeremy Hylton.)"
msgstr ""
":file:`sample.h` を修正するとモジュールは再コンパイルされます。 (Contributed "
"by Jeremy Hylton.)"

#: ../../whatsnew/2.3.rst:1270
msgid ""
"Other minor changes to Distutils: it now checks for the :envvar:`CC`, :"
"envvar:`CFLAGS`, :envvar:`!CPP`, :envvar:`LDFLAGS`, and :envvar:`CPPFLAGS` "
"environment variables, using them to override the settings in Python's "
"configuration (contributed by Robert Weber)."
msgstr ""

#: ../../whatsnew/2.3.rst:1275
msgid ""
"Previously the :mod:`doctest` module would only search the docstrings of "
"public methods and functions for test cases, but it now also examines "
"private ones as well.  The :func:`~doctest.DocTestSuite` function creates a :"
"class:`unittest.TestSuite` object from a set of :mod:`doctest` tests."
msgstr ""

#: ../../whatsnew/2.3.rst:1280
msgid ""
"The new ``gc.get_referents(object)`` function returns a list of all the "
"objects referenced by *object*."
msgstr ""
"新しい関数 ``gc.get_referents(object)`` は *object* により参照されている全て"
"のオブジェクトのリストを返します。"

#: ../../whatsnew/2.3.rst:1283
msgid ""
"The :mod:`getopt` module gained a new function, :func:`~getopt.gnu_getopt`, "
"that supports the same arguments as the existing :func:`~getopt.getopt` "
"function but uses GNU-style scanning mode. The existing :func:`~getopt."
"getopt` stops processing options as soon as a non-option argument is "
"encountered, but in GNU-style mode processing continues, meaning that "
"options and arguments can be mixed.  For example::"
msgstr ""

#: ../../whatsnew/2.3.rst:1289
msgid ""
">>> getopt.getopt(['-f', 'filename', 'output', '-v'], 'f:v')\n"
"([('-f', 'filename')], ['output', '-v'])\n"
">>> getopt.gnu_getopt(['-f', 'filename', 'output', '-v'], 'f:v')\n"
"([('-f', 'filename'), ('-v', '')], ['output'])"
msgstr ""

#: ../../whatsnew/2.3.rst:1294
msgid "(Contributed by Peter Åstrand.)"
msgstr "(Contributed by Peter Åstrand.)"

#: ../../whatsnew/2.3.rst:1296
msgid ""
"The :mod:`grp`, :mod:`pwd`, and :mod:`resource` modules now return enhanced "
"tuples::"
msgstr ""
"モジュール :mod:`grp`, :mod:`pwd`, :mod:`resource` では拡張されたタプルを返す"
"ようになりました::"

#: ../../whatsnew/2.3.rst:1299
msgid ""
">>> import grp\n"
">>> g = grp.getgrnam('amk')\n"
">>> g.gr_name, g.gr_gid\n"
"('amk', 500)"
msgstr ""

#: ../../whatsnew/2.3.rst:1304
msgid "The :mod:`gzip` module can now handle files exceeding 2 GiB."
msgstr ""
":mod:`gzip` モジュールが 2 GiB を超えるファイルを扱えるようになっています。"

#: ../../whatsnew/2.3.rst:1306
msgid ""
"The new :mod:`heapq` module contains an implementation of a heap queue "
"algorithm.  A heap is an array-like data structure that keeps items in a "
"partially sorted order such that, for every index *k*, ``heap[k] <= "
"heap[2*k+1]`` and ``heap[k] <= heap[2*k+2]``.  This makes it quick to remove "
"the smallest item, and inserting a new item while maintaining the heap "
"property is *O*\\ (log *n*).  (See https://xlinux.nist.gov/dads//HTML/"
"priorityque.html for more information about the priority queue data "
"structure.)"
msgstr ""

#: ../../whatsnew/2.3.rst:1314
msgid ""
"The :mod:`heapq` module provides :func:`~heapq.heappush` and :func:`~heapq."
"heappop` functions for adding and removing items while maintaining the heap "
"property on top of some other mutable Python sequence type.  Here's an "
"example that uses a Python list::"
msgstr ""

#: ../../whatsnew/2.3.rst:1318
msgid ""
">>> import heapq\n"
">>> heap = []\n"
">>> for item in [3, 7, 5, 11, 1]:\n"
"...    heapq.heappush(heap, item)\n"
"...\n"
">>> heap\n"
"[1, 3, 5, 11, 7]\n"
">>> heapq.heappop(heap)\n"
"1\n"
">>> heapq.heappop(heap)\n"
"3\n"
">>> heap\n"
"[5, 7, 11]"
msgstr ""

#: ../../whatsnew/2.3.rst:1332
msgid "(Contributed by Kevin O'Connor.)"
msgstr "(Contributed by Kevin O'Connor.)"

#: ../../whatsnew/2.3.rst:1334
msgid ""
"The IDLE integrated development environment has been updated using the code "
"from the IDLEfork project (https://idlefork.sourceforge.net).  The most "
"notable feature is that the code being developed is now executed in a "
"subprocess, meaning that there's no longer any need for manual ``reload()`` "
"operations. IDLE's core code has been incorporated into the standard library "
"as the :mod:`idlelib` package."
msgstr ""

#: ../../whatsnew/2.3.rst:1340
msgid ""
"The :mod:`imaplib` module now supports IMAP over SSL. (Contributed by Piers "
"Lauder and Tino Lange.)"
msgstr ""
":mod:`imaplib` モジュールが  IMAP over SSL をサポートするようになりました. "
"(Contributed by Piers Lauder and Tino Lange.)"

#: ../../whatsnew/2.3.rst:1343
msgid ""
"The :mod:`itertools` contains a number of useful functions for use with "
"iterators, inspired by various functions provided by the ML and Haskell "
"languages.  For example, ``itertools.ifilter(predicate, iterator)`` returns "
"all elements in the iterator for which the function :func:`!predicate` "
"returns :const:`True`, and ``itertools.repeat(obj, N)`` returns ``obj`` *N* "
"times. There are a number of other functions in the module; see the "
"package's reference documentation for details. (Contributed by Raymond "
"Hettinger.)"
msgstr ""

#: ../../whatsnew/2.3.rst:1352
msgid ""
"Two new functions in the :mod:`math` module, ``degrees(rads)`` and "
"``radians(degs)``, convert between radians and degrees.  Other functions in "
"the :mod:`math` module such as :func:`math.sin` and :func:`math.cos` have "
"always required input values measured in radians.  Also, an optional *base* "
"argument was added to :func:`math.log` to make it easier to compute "
"logarithms for bases other than ``e`` and ``10``.  (Contributed by Raymond "
"Hettinger.)"
msgstr ""
":mod:`math` module の 2 つの新規関数 ``degrees(rads)`` と ``radians(degs)`` "
"は、ラジアンと度の間の変換を行います。 :mod:`math` モジュールの :func:`math."
"sin` や :func:`math.cos` などは常にラジアンでの入力が必要です。 :func:`math."
"log` 関数には底を指定するオプショナルの *base* 引数が追加されていて、 ``e`` "
"と ``10`` でない底の対数を計算するのが簡単になりました。 (Contributed by "
"Raymond Hettinger.)"

#: ../../whatsnew/2.3.rst:1359
msgid ""
"Several new POSIX functions (:func:`!getpgid`, :func:`!killpg`, :func:`!"
"lchown`, :func:`!loadavg`, :func:`!major`, :func:`!makedev`, :func:`!minor`, "
"and :func:`!mknod`) were added to the :mod:`posix` module that underlies "
"the :mod:`os` module. (Contributed by Gustavo Niemeyer, Geert Jansen, and "
"Denis S. Otkidach.)"
msgstr ""

#: ../../whatsnew/2.3.rst:1365
msgid ""
"In the :mod:`os` module, the :func:`!\\*stat` family of functions can now "
"report fractions of a second in a timestamp.  Such time stamps are "
"represented as floats, similar to the value returned by :func:`time.time`."
msgstr ""

#: ../../whatsnew/2.3.rst:1369
msgid ""
"During testing, it was found that some applications will break if time "
"stamps are floats.  For compatibility, when using the tuple interface of "
"the :class:`~os.stat_result` time stamps will be represented as integers. "
"When using named fields (a feature first introduced in Python 2.2), time "
"stamps are still represented as integers, unless :func:`!os."
"stat_float_times` is invoked to enable float return values::"
msgstr ""

#: ../../whatsnew/2.3.rst:1376
msgid ""
">>> os.stat(\"/tmp\").st_mtime\n"
"1034791200\n"
">>> os.stat_float_times(True)\n"
">>> os.stat(\"/tmp\").st_mtime\n"
"1034791200.6335014"
msgstr ""

#: ../../whatsnew/2.3.rst:1382
msgid "In Python 2.4, the default will change to always returning floats."
msgstr "Python 2.4 では、浮動小数点数を返すのがデフォルトとなります。"

#: ../../whatsnew/2.3.rst:1384
msgid ""
"Application developers should enable this feature only if all their "
"libraries work properly when confronted with floating-point time stamps, or "
"if they use the tuple API. If used, the feature should be activated on an "
"application level instead of trying to enable it on a per-use basis."
msgstr ""

#: ../../whatsnew/2.3.rst:1389
msgid ""
"The :mod:`optparse` module contains a new parser for command-line arguments "
"that can convert option values to a particular Python type  and will "
"automatically generate a usage message.  See the following section for  more "
"details."
msgstr ""
":mod:`optparse` モジュールに新たなコマンドライン引数パーサが追加されました。"
"これはオプション値を特定の Python 型に変換することが出来、また、自動的に使用"
"例メッセージを生成します。詳細はこのドキュメントの続くセクションを参照して下"
"さい。"

#: ../../whatsnew/2.3.rst:1394
msgid ""
"The old and never-documented :mod:`!linuxaudiodev` module has been "
"deprecated, and a new version named :mod:`!ossaudiodev` has been added.  The "
"module was renamed because the OSS sound drivers can be used on platforms "
"other than Linux, and the interface has also been tidied and brought up to "
"date in various ways. (Contributed by Greg Ward and Nicholas FitzRoy-Dale.)"
msgstr ""

#: ../../whatsnew/2.3.rst:1400
msgid ""
"The new :mod:`platform` module contains a number of functions that try to "
"determine various properties of the platform you're running on.  There are "
"functions for getting the architecture, CPU type, the Windows OS version, "
"and even the Linux distribution version. (Contributed by Marc-André Lemburg.)"
msgstr ""
"実行中のプラットフォームについての色々な特性を決定する数多くの関数を含む、新"
"規 :mod:`platform` モジュールが追加されました。アーキテクチャ、CPU タイプ、"
"Windows の OS バージョンや Linux ディストリビューションのバージョンなどを取得"
"できます。(Contributed by Marc-André Lemburg.)"

#: ../../whatsnew/2.3.rst:1405
msgid ""
"The parser objects provided by the :mod:`pyexpat <xml.parsers.expat>` module "
"can now optionally buffer character data, resulting in fewer calls to your "
"character data handler and therefore faster performance.  Setting the parser "
"object's :attr:`~xml.parsers.expat.xmlparser.buffer_text` attribute to :"
"const:`True` will enable buffering."
msgstr ""

#: ../../whatsnew/2.3.rst:1410
msgid ""
"The ``sample(population, k)`` function was added to the :mod:`random` "
"module.  *population* is a sequence or :class:`!xrange` object containing "
"the elements of a population, and :func:`~random.sample` chooses *k* "
"elements from the population without replacing chosen elements.  *k* can be "
"any value up to ``len(population)``. For example::"
msgstr ""

#: ../../whatsnew/2.3.rst:1416
msgid ""
">>> days = ['Mo', 'Tu', 'We', 'Th', 'Fr', 'St', 'Sn']\n"
">>> random.sample(days, 3)      # Choose 3 elements\n"
"['St', 'Sn', 'Th']\n"
">>> random.sample(days, 7)      # Choose 7 elements\n"
"['Tu', 'Th', 'Mo', 'We', 'St', 'Fr', 'Sn']\n"
">>> random.sample(days, 7)      # Choose 7 again\n"
"['We', 'Mo', 'Sn', 'Fr', 'Tu', 'St', 'Th']\n"
">>> random.sample(days, 8)      # Can't choose eight\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in ?\n"
"  File \"random.py\", line 414, in sample\n"
"      raise ValueError, \"sample larger than population\"\n"
"ValueError: sample larger than population\n"
">>> random.sample(xrange(1,10000,2), 10)   # Choose ten odd nos. under "
"10000\n"
"[3407, 3805, 1505, 7023, 2401, 2267, 9733, 3151, 8083, 9195]"
msgstr ""

#: ../../whatsnew/2.3.rst:1432
msgid ""
"The :mod:`random` module now uses a new algorithm, the Mersenne Twister, "
"implemented in C.  It's faster and more extensively studied than the "
"previous algorithm."
msgstr ""
":mod:`random` が C で実装された新しいアルゴリズムのメルセンヌ・ツイスタを使う"
"ようになりました。これは以前のアルゴリズムよりも高速で、より広く研究されてい"
"ます。"

#: ../../whatsnew/2.3.rst:1436
msgid "(All changes contributed by Raymond Hettinger.)"
msgstr "(All changes contributed by Raymond Hettinger.)"

#: ../../whatsnew/2.3.rst:1438
msgid ""
"The :mod:`readline` module also gained a number of new functions: :func:"
"`~readline.get_history_item`, :func:`~readline.get_current_history_length`, "
"and :func:`~readline.redisplay`."
msgstr ""

#: ../../whatsnew/2.3.rst:1442
msgid ""
"The :mod:`!rexec` and :mod:`!Bastion` modules have been declared dead, and "
"attempts to import them will fail with a :exc:`RuntimeError`.  New-style "
"classes provide new ways to break out of the restricted execution "
"environment provided by :mod:`!rexec`, and no one has interest in fixing "
"them or time to do so.  If you have applications using :mod:`!rexec`, "
"rewrite them to use something else."
msgstr ""

#: ../../whatsnew/2.3.rst:1448
msgid ""
"(Sticking with Python 2.2 or 2.1 will not make your applications any safer "
"because there are known bugs in the :mod:`!rexec` module in those versions.  "
"To repeat: if you're using :mod:`!rexec`, stop using it immediately.)"
msgstr ""

#: ../../whatsnew/2.3.rst:1452
msgid ""
"The :mod:`!rotor` module has been deprecated because the  algorithm it uses "
"for encryption is not believed to be secure.  If you need encryption, use "
"one of the several AES Python modules that are available separately."
msgstr ""

#: ../../whatsnew/2.3.rst:1456
msgid ""
"The :mod:`shutil` module gained a ``move(src, dest)`` function that "
"recursively moves a file or directory to a new location."
msgstr ""
":mod:`shutil` モジュールに ``move(src, dest)`` が追加されており、これはファイ"
"ルまたはディレクトリを新しい場所へ再帰的に移動します。"

#: ../../whatsnew/2.3.rst:1459
msgid ""
"Support for more advanced POSIX signal handling was added to the :mod:"
"`signal` but then removed again as it proved impossible to make it work "
"reliably across platforms."
msgstr ""

#: ../../whatsnew/2.3.rst:1463
msgid ""
"The :mod:`socket` module now supports timeouts.  You can call the "
"``settimeout(t)`` method on a socket object to set a timeout of *t* seconds. "
"Subsequent socket operations that take longer than *t* seconds to complete "
"will abort and raise a :exc:`socket.timeout` exception."
msgstr ""
":mod:`socket` モジュールがタイムアウトをサポートするようになりました。ソケッ"
"トオブジェクトの ``settimeout(t)`` メソッドに *t* 秒を与えることで行えます。"
"これに続くソケット操作が *t* 秒を超えて完了しない場合には操作は中断し、 :exc:"
"`socket.timeout` 例外を投げます。"

#: ../../whatsnew/2.3.rst:1468
msgid ""
"The original timeout implementation was by Tim O'Malley.  Michael Gilfix "
"integrated it into the Python :mod:`socket` module and shepherded it through "
"a lengthy review.  After the code was checked in, Guido van Rossum rewrote "
"parts of it.  (This is a good example of a collaborative development process "
"in action.)"
msgstr ""
"オリジナルのタイムアウト実装は Tim O'Malley によりなされました。Michael "
"Gilfix がこれを Python :mod:`socket` モジュールに統合し、長い長いレビューに導"
"きました。コードがチェックインされたのち、Guido van Rossum はそれを部分的に書"
"き換えました。(これは協調的開発プロセスの好例です。)"

#: ../../whatsnew/2.3.rst:1474
msgid ""
"On Windows, the :mod:`socket` module now ships with Secure  Sockets Layer "
"(SSL) support."
msgstr ""
"Windows での :mod:`socket` モジュールの Secure  Sockets Layer (SSL) サポート"
"が始まりました。"

#: ../../whatsnew/2.3.rst:1477
msgid ""
"The value of the C :c:macro:`!PYTHON_API_VERSION` macro is now exposed at "
"the Python level as ``sys.api_version``.  The current exception can be "
"cleared by calling the new :func:`!sys.exc_clear` function."
msgstr ""

#: ../../whatsnew/2.3.rst:1481
msgid ""
"The new :mod:`tarfile` module  allows reading from and writing to :program:"
"`tar`\\ -format archive files. (Contributed by Lars Gustäbel.)"
msgstr ""
"新モジュール :mod:`tarfile` で :program:`tar` 形式のアーカイブファイルの読み"
"書きが出来ます。 (Contributed by Lars Gustäbel.)"

#: ../../whatsnew/2.3.rst:1484
msgid ""
"The new :mod:`textwrap` module contains functions for wrapping strings "
"containing paragraphs of text.  The ``wrap(text, width)`` function takes a "
"string and returns a list containing the text split into lines of no more "
"than the chosen width.  The ``fill(text, width)`` function returns a single "
"string, reformatted to fit into lines no longer than the chosen width. (As "
"you can guess, :func:`~textwrap.fill` is built on top of :func:`~textwrap."
"wrap`.  For example::"
msgstr ""

#: ../../whatsnew/2.3.rst:1491
msgid ""
">>> import textwrap\n"
">>> paragraph = \"Not a whit, we defy augury: ... more text ...\"\n"
">>> textwrap.wrap(paragraph, 60)\n"
"[\"Not a whit, we defy augury: there's a special providence in\",\n"
" \"the fall of a sparrow. If it be now, 'tis not to come; if it\",\n"
" ...]\n"
">>> print textwrap.fill(paragraph, 35)\n"
"Not a whit, we defy augury: there's\n"
"a special providence in the fall of\n"
"a sparrow. If it be now, 'tis not\n"
"to come; if it be not to come, it\n"
"will be now; if it be not now, yet\n"
"it will come: the readiness is all.\n"
">>>"
msgstr ""

#: ../../whatsnew/2.3.rst:1506
msgid ""
"The module also contains a :class:`~textwrap.TextWrapper` class that "
"actually implements the text wrapping strategy.   Both the :class:`~textwrap."
"TextWrapper` class and the :func:`~textwrap.wrap` and :func:`~textwrap.fill` "
"functions support a number of additional keyword arguments for fine-tuning "
"the formatting; consult the module's documentation for details. (Contributed "
"by Greg Ward.)"
msgstr ""

#: ../../whatsnew/2.3.rst:1512
msgid ""
"The :mod:`!thread` and :mod:`threading` modules now have companion modules, :"
"mod:`!dummy_thread` and :mod:`!dummy_threading`, that provide a do-nothing "
"implementation of the :mod:`!thread` module's interface for platforms where "
"threads are not supported.  The intention is to simplify thread-aware "
"modules (ones that *don't* rely on threads to run) by putting the following "
"code at the top::"
msgstr ""

#: ../../whatsnew/2.3.rst:1519
msgid ""
"try:\n"
"    import threading as _threading\n"
"except ImportError:\n"
"    import dummy_threading as _threading"
msgstr ""

#: ../../whatsnew/2.3.rst:1524
msgid ""
"In this example, :mod:`!_threading` is used as the module name to make it "
"clear that the module being used is not necessarily the actual :mod:"
"`threading` module. Code can call functions and use classes in :mod:`!"
"_threading` whether or not threads are supported, avoiding an :keyword:`if` "
"statement and making the code slightly clearer.  This module will not "
"magically make multithreaded code run without threads; code that waits for "
"another thread to return or to do something will simply hang forever."
msgstr ""

#: ../../whatsnew/2.3.rst:1532
msgid ""
"The :mod:`time` module's :func:`~time.strptime` function has long been an "
"annoyance because it uses the platform C library's :func:`~time.strptime` "
"implementation, and different platforms sometimes have odd bugs.  Brett "
"Cannon contributed a portable implementation that's written in pure Python "
"and should behave identically on all platforms."
msgstr ""
":mod:`time` モジュールの :func:`~time.strptime` 関数は長いこと混乱の元でし"
"た。それがプラットフォームの C 関数 :func:`~time.strptime` を使い、異なったプ"
"ラットフォームごとに時折おかしなバグを持っていたからです。Brett Cannon は "
"pure Python で、全てのプラットフォームで全く同じに振舞うように書き直した実装"
"を寄稿しました。"

#: ../../whatsnew/2.3.rst:1538
msgid ""
"The new :mod:`timeit` module helps measure how long snippets of Python code "
"take to execute.  The :file:`timeit.py` file can be run directly from the "
"command line, or the module's :class:`~timeit.Timer` class can be imported "
"and used directly.  Here's a short example that figures out whether it's "
"faster to convert an 8-bit string to Unicode by appending an empty Unicode "
"string to it or by using the :func:`!unicode` function::"
msgstr ""
"新規モジュール :mod:`timeit` は、Python コードの断片 (スニペット) を実行する"
"のにかかる時間を計測します。ファイル :file:`timeit.py` は直接コマンドラインか"
"ら実行出来ますし、モジュールの :class:`~timeit.Timer` クラスをインポートして"
"直接使うことも出来ます。以下に、空の Unicode 文字列を追加することによって 8 "
"ビット文字列を Unicode に変換するのと :func:`!unicode` 関数を使うのとでいずれ"
"が高速なのかを把握するための短い例をお見せします::"

#: ../../whatsnew/2.3.rst:1545
msgid ""
"import timeit\n"
"\n"
"timer1 = timeit.Timer('unicode(\"abc\")')\n"
"timer2 = timeit.Timer('\"abc\" + u\"\"')\n"
"\n"
"# Run three trials\n"
"print timer1.repeat(repeat=3, number=100000)\n"
"print timer2.repeat(repeat=3, number=100000)\n"
"\n"
"# On my laptop this outputs:\n"
"# [0.36831796169281006, 0.37441694736480713, 0.35304892063140869]\n"
"# [0.17574405670166016, 0.18193507194519043, 0.17565798759460449]"
msgstr ""

#: ../../whatsnew/2.3.rst:1558
msgid ""
"The :mod:`!Tix` module has received various bug fixes and updates for the "
"current version of the Tix package."
msgstr ""
":mod:`!Tix` モジュールに色々バグ修正がなされ、Tix パッケージの現在バージョン"
"に更新されました。"

#: ../../whatsnew/2.3.rst:1561
msgid ""
"The :mod:`!Tkinter` module now works with a thread-enabled  version of Tcl. "
"Tcl's threading model requires that widgets only be accessed from the thread "
"in which they're created; accesses from another thread can cause Tcl to "
"panic.  For certain Tcl interfaces, :mod:`!Tkinter` will now automatically "
"avoid this  when a widget is accessed from a different thread by marshalling "
"a command, passing it to the correct thread, and waiting for the results.  "
"Other interfaces can't be handled automatically but :mod:`!Tkinter` will now "
"raise an exception on such an access so that you can at least find out about "
"the problem.  See https://mail.python.org/pipermail/python-dev/2002-"
"December/031107.html for a more detailed explanation of this change.  "
"(Implemented by Martin von Löwis.)"
msgstr ""
":mod:`!Tkinter` モジュールがスレッドを有効化した Tcl で動作するようになりまし"
"た。Tcl のスレッドモデルは、ウィジットはそれが作られたスレッドからのみアクセ"
"スされることを必要とします。ほかのスレッドからのアクセスは Tcl を混乱させま"
"す。ある特定の Tcl インターフェイスでは、 :mod:`!Tkinter` はウィジットがコマ"
"ンドの纏め上げによって異なるスレッドからアクセスされる際に、正しいスレッドに"
"向けて結果を待つことで自動的にこれを避けるようになりました。それ以外のイン"
"ターフェイスでは自動で処理は出来ませんが、 :mod:`!Tkinter` はそのようなアクセ"
"ス時に最低でもそれが問題とわかるよう例外を送出するようになっています。この変"
"更についての詳細な説明は https://mail.python.org/pipermail/python-dev/2002-"
"December/031107.html をみてください。(Implemented by Martin von Löwis.)"

#: ../../whatsnew/2.3.rst:1572
msgid ""
"Calling Tcl methods through :mod:`!_tkinter` no longer  returns only "
"strings. Instead, if Tcl returns other objects those objects are converted "
"to their Python equivalent, if one exists, or wrapped with a :class:`!"
"_tkinter.Tcl_Obj` object if no Python equivalent exists. This behavior can "
"be controlled through the :meth:`!wantobjects` method of :class:`!tkapp` "
"objects."
msgstr ""
":mod:`!_tkinter` を介した Tcl メソッド呼び出しは今では文字列だけを返すのでは"
"ありません。代わりに Tcl は対応する Python の等価なオブジェクトに変換されたオ"
"ブジェクトを返します。Python に等価なものがなければ :class:`!_tkinter."
"Tcl_Obj` で包んで返します。この振る舞いは :class:`!tkapp` オブジェクトの :"
"meth:`!wantobjects` メソッドで制御出来ます。"

#: ../../whatsnew/2.3.rst:1578
msgid ""
"When using :mod:`!_tkinter` through the :mod:`!Tkinter` module (as most "
"Tkinter applications will), this feature is always activated. It should not "
"cause compatibility problems, since Tkinter would always convert string "
"results to Python types where possible."
msgstr ""
"(ほとんどの Tkinter アプリケーションがそうするように) :mod:`!Tkinter` モ"
"ジュールを通して :mod:`!_tkinter` を使う際、この機能は常に有効になります。こ"
"れは互換性の問題を引き起こさないはずです。 Tkinter は可能な場合には文字列を "
"Python 型に常に変換していたからです。"

#: ../../whatsnew/2.3.rst:1583
msgid ""
"If any incompatibilities are found, the old behavior can be restored by "
"setting the :attr:`!wantobjects` variable in the :mod:`!Tkinter` module to "
"false before creating the first :class:`!tkapp` object. ::"
msgstr ""
"何か非互換性を見つけたら古い振る舞いに戻せます。最初の :class:`!tkapp` オブ"
"ジェクトを生成する前に :mod:`!Tkinter` モジュールの :attr:`!wantobjects` 変数"
"に偽をセットしてください::"

#: ../../whatsnew/2.3.rst:1587
msgid ""
"import Tkinter\n"
"Tkinter.wantobjects = 0"
msgstr ""

#: ../../whatsnew/2.3.rst:1590
msgid "Any breakage caused by this change should be reported as a bug."
msgstr ""
"ここで説明した変更によって何かアプリケーションの破壊があれば、バグとして報告"
"してください。"

#: ../../whatsnew/2.3.rst:1592
msgid ""
"The :mod:`!UserDict` module has a new :class:`!DictMixin` class which "
"defines all dictionary methods for classes that already have a minimum "
"mapping interface.  This greatly simplifies writing classes that need to be "
"substitutable for dictionaries, such as the classes in  the :mod:`shelve` "
"module."
msgstr ""
":mod:`!UserDict` モジュールに新しく :class:`!DictMixin` クラスが追加されまし"
"た。既に最小限のマッピングインターフェースを持っているクラスのために、全ての"
"辞書メソッドを定義します。これは、 :mod:`shelve` モジュール内のクラスのよう"
"な、辞書に置換可能である必要があるクラスの記述を大幅に単純化します。"

#: ../../whatsnew/2.3.rst:1598
msgid ""
"Adding the mix-in as a superclass provides the full dictionary interface "
"whenever the class defines :meth:`~object.__getitem__`, :meth:`~object."
"__setitem__`, :meth:`~object.__delitem__`, and :meth:`!keys`. For example::"
msgstr ""
"クラスがメソッド :meth:`~object.__getitem__`, :meth:`~object.__setitem__`, :"
"meth:`~object.__delitem__`, :meth:`!keys` を定義している場合にはいつでも、"
"スーパークラスとして mix-in を追加すると完全な辞書インターフェースになりま"
"す。例えば::"

#: ../../whatsnew/2.3.rst:1602
msgid ""
">>> import UserDict\n"
">>> class SeqDict(UserDict.DictMixin):\n"
"...     \"\"\"Dictionary lookalike implemented with lists.\"\"\"\n"
"...     def __init__(self):\n"
"...         self.keylist = []\n"
"...         self.valuelist = []\n"
"...     def __getitem__(self, key):\n"
"...         try:\n"
"...             i = self.keylist.index(key)\n"
"...         except ValueError:\n"
"...             raise KeyError\n"
"...         return self.valuelist[i]\n"
"...     def __setitem__(self, key, value):\n"
"...         try:\n"
"...             i = self.keylist.index(key)\n"
"...             self.valuelist[i] = value\n"
"...         except ValueError:\n"
"...             self.keylist.append(key)\n"
"...             self.valuelist.append(value)\n"
"...     def __delitem__(self, key):\n"
"...         try:\n"
"...             i = self.keylist.index(key)\n"
"...         except ValueError:\n"
"...             raise KeyError\n"
"...         self.keylist.pop(i)\n"
"...         self.valuelist.pop(i)\n"
"...     def keys(self):\n"
"...         return list(self.keylist)\n"
"...\n"
">>> s = SeqDict()\n"
">>> dir(s)      # See that other dictionary methods are implemented\n"
"['__cmp__', '__contains__', '__delitem__', '__doc__', '__getitem__',\n"
" '__init__', '__iter__', '__len__', '__module__', '__repr__',\n"
" '__setitem__', 'clear', 'get', 'has_key', 'items', 'iteritems',\n"
" 'iterkeys', 'itervalues', 'keylist', 'keys', 'pop', 'popitem',\n"
" 'setdefault', 'update', 'valuelist', 'values']"
msgstr ""

#: ../../whatsnew/2.3.rst:1639
msgid "(Contributed by Raymond Hettinger.)"
msgstr "(Contributed by Raymond Hettinger.)"

#: ../../whatsnew/2.3.rst:1641
msgid ""
"The DOM implementation in :mod:`xml.dom.minidom` can now generate XML output "
"in a particular encoding by providing an optional encoding argument to the :"
"meth:`~xml.dom.minidom.Node.toxml` and :meth:`~xml.dom.minidom.Node."
"toprettyxml` methods of DOM nodes."
msgstr ""

#: ../../whatsnew/2.3.rst:1645
msgid ""
"The :mod:`!xmlrpclib` module now supports an XML-RPC extension for handling "
"nil data values such as Python's ``None``.  Nil values are always supported "
"on unmarshalling an XML-RPC response.  To generate requests containing "
"``None``, you must supply a true value for the *allow_none* parameter when "
"creating a :class:`!Marshaller` instance."
msgstr ""
":mod:`!xmlrpclib` モジュールが、 Python の ``None`` のような nil データを処理"
"するための XML-RPC 拡張をサポートするようになりました。 nil 値は XML-RPC 応答"
"のアンマーシャルでいつでもサポートされます。 ``None`` を含んだリクエストを生"
"成するためには、 :class:`!Marshaller` のインスタンスを生成する際に "
"*allow_none* パラメータに真を与えなければなりません。"

#: ../../whatsnew/2.3.rst:1651
msgid ""
"The new :mod:`!DocXMLRPCServer` module allows writing self-documenting XML-"
"RPC servers. Run it in demo mode (as a program) to see it in action.   "
"Pointing the web browser to the RPC server produces pydoc-style "
"documentation; pointing xmlrpclib to the server allows invoking the actual "
"methods. (Contributed by Brian Quinlan.)"
msgstr ""
"新規モジュール :mod:`!DocXMLRPCServer` は、セルフ-ドキュメンティング XML-RPC "
"サーバを書くのに使えます。実際のところをみるためにはデモモード (つまりプログ"
"ラムとして) 実行してみてください。ウェブブラウザを RPC サーバに向ければ "
"pydoc スタイルのドキュメントを生成します。xmlrpclib をサーバに向ければ実際の"
"メソッドを呼び出せます。(Contributed by Brian Quinlan.)"

#: ../../whatsnew/2.3.rst:1657
msgid ""
"Support for internationalized domain names (RFCs 3454, 3490, 3491, and 3492) "
"has been added. The \"idna\" encoding can be used to convert between a "
"Unicode domain name and the ASCII-compatible encoding (ACE) of that name. ::"
msgstr ""
"internationalized domain names (RFC 3454, 3490, 3491, 3492) のサポートが追加"
"されました。Unicode ドメイン名とその名前の ASCII 互換エンコーディング "
"(ACE=ASCII-compatible encoding) の間の変換をするのに \"idna\" エンコーディン"
"グを使用出来ます::"

#: ../../whatsnew/2.3.rst:1661
msgid ""
">{}>{}> u\"www.Alliancefrançaise.nu\".encode(\"idna\")\n"
"'www.xn--alliancefranaise-npb.nu'"
msgstr ""

#: ../../whatsnew/2.3.rst:1664
msgid ""
"The :mod:`socket` module has also been extended to transparently convert "
"Unicode hostnames to the ACE version before passing them to the C library. "
"Modules that deal with hostnames such as :mod:`!httplib` and :mod:`ftplib`) "
"also support Unicode host names; :mod:`!httplib` also sends HTTP ``Host`` "
"headers using the ACE version of the domain name.  :mod:`urllib` supports "
"Unicode URLs with non-ASCII host names as long as the ``path`` part of the "
"URL is ASCII only."
msgstr ""
":mod:`socket` モジュールも、C ライブラリに渡す前に Unicode ホスト名を ACE "
"バージョンに透過的に変換するように拡張されています。 :mod:`!httplib` や :mod:"
"`ftplib` のようなホスト名を扱うモジュールも Unicode ホスト名をサポートしてい"
"ます; :mod:`!httplib` は HTTP ``Host`` ヘッダをドメイン名の ACE 版を使って送"
"信します。 :mod:`urllib` は URL の ``path`` 部分が ASCII のみである限り、非 "
"ASCII ホスト名を持つ Unicode URL をサポートします"

#: ../../whatsnew/2.3.rst:1672
msgid ""
"To implement this change, the :mod:`stringprep` module, the  "
"``mkstringprep`` tool and the ``punycode`` encoding have been added."
msgstr ""
"この変更の実装のために、 :mod:`stringprep` モジュール、 ``mkstringprep`` ツー"
"ル、 ``punycode`` エンコーディングが追加されました。"

#: ../../whatsnew/2.3.rst:1679
msgid "Date/Time Type"
msgstr "日付時刻型"

#: ../../whatsnew/2.3.rst:1681
msgid ""
"Date and time types suitable for expressing timestamps were added as the :"
"mod:`datetime` module.  The types don't support different calendars or many "
"fancy features, and just stick to the basics of representing time."
msgstr ""
"タイムスタンプとして使うのに相応しい日付と時刻の型が :mod:`datetime` モジュー"
"ルとして追加されました。これら型は異なるカレンダであるとか多くの洒落た機能を"
"サポートはせずに、時刻表現の基礎だけに集中するものです。"

#: ../../whatsnew/2.3.rst:1685
msgid ""
"The three primary types are: :class:`~datetime.date`, representing a day, "
"month, and year; :class:`~datetime.time`, consisting of hour, minute, and "
"second; and :class:`~datetime.datetime`, which contains all the attributes "
"of both :class:`~datetime.date` and :class:`~datetime.time`. There's also a :"
"class:`~datetime.timedelta` class representing differences between two "
"points in time, and time zone logic is implemented by classes inheriting "
"from the abstract :class:`~datetime.tzinfo` class."
msgstr ""
"3 つの基礎となるクラスがあり、 :class:`~datetime.date` は年・月・日を表現"
"し、 :class:`~datetime.time` は時・分・秒を、 :class:`~datetime.datetime` "
"が :class:`~datetime.date` と :class:`~datetime.time` の両方の属性すべてを持"
"ちます。また、 :class:`~datetime.timedelta` は 2 つの時刻の差を表現し、タイム"
"ゾーンのロジックは抽象クラス :class:`~datetime.tzinfo` から派生したクラスによ"
"り実装されます。"

#: ../../whatsnew/2.3.rst:1692
msgid ""
"You can create instances of :class:`~datetime.date` and :class:`~datetime."
"time` by either supplying keyword arguments to the appropriate constructor, "
"e.g. ``datetime.date(year=1972, month=10, day=15)``, or by using one of a "
"number of class methods.  For example, the :meth:`~datetime.date.today` "
"class method returns the current local date."
msgstr ""

#: ../../whatsnew/2.3.rst:1698
msgid ""
"Once created, instances of the date/time classes are all immutable. There "
"are a number of methods for producing formatted strings from objects::"
msgstr ""
"構築後の日付時刻クラスのインスタンスは全て :term:`immutable` です。オブジェク"
"トから書式文字列を生成する数多くのメソッドがあります::"

#: ../../whatsnew/2.3.rst:1701
msgid ""
">>> import datetime\n"
">>> now = datetime.datetime.now()\n"
">>> now.isoformat()\n"
"'2002-12-30T21:27:03.994956'\n"
">>> now.ctime()  # Only available on date, datetime\n"
"'Mon Dec 30 21:27:03 2002'\n"
">>> now.strftime('%Y %d %b')\n"
"'2002 30 Dec'"
msgstr ""

#: ../../whatsnew/2.3.rst:1710
msgid ""
"The :meth:`~datetime.datetime.replace` method allows modifying one or more "
"fields  of a :class:`~datetime.date` or :class:`~datetime.datetime` "
"instance, returning a new instance::"
msgstr ""

#: ../../whatsnew/2.3.rst:1713
msgid ""
">>> d = datetime.datetime.now()\n"
">>> d\n"
"datetime.datetime(2002, 12, 30, 22, 15, 38, 827738)\n"
">>> d.replace(year=2001, hour = 12)\n"
"datetime.datetime(2001, 12, 30, 12, 15, 38, 827738)\n"
">>>"
msgstr ""

#: ../../whatsnew/2.3.rst:1720
msgid ""
"Instances can be compared, hashed, and converted to strings (the result is "
"the same as that of :meth:`~datetime.datetime.isoformat`).  :class:"
"`~datetime.date` and :class:`~datetime.datetime` instances can be subtracted "
"from each other, and added to :class:`~datetime.timedelta` instances.  The "
"largest missing feature is that there's no standard library support for "
"parsing strings and getting back a :class:`~datetime.date` or :class:"
"`~datetime.datetime`."
msgstr ""
"インスタンスは比較可能で、ハッシュ出来、文字列に変換出来ます (結果は :meth:"
"`~datetime.datetime.isoformat` メソッドのものと同じです)。  と :class:"
"`~datetime.datetime` はお互いに減算演算が可能で、 :class:`~datetime."
"timedelta` インスタンスを加算することも出来ます。最も大きな不足機能としては、"
"文字列を解析して :class:`~datetime.date` や :class:`~datetime.datetime` へ戻"
"すための標準ライブラリサポートはありません。(---訳注: 2 点。「比較可能」の意"
"味は 2.3 から 2.4 で意味が変わっています。2.4 で :class:`~datetime.date` と :"
"class:`~datetime.datetime` の比較は出来なくなりました。2.3 では出来ていまし"
"た。文字列からの :class:`~datetime.datetime` 構築は 2.5 で :meth:`~datetime."
"strptime` が追加されています。---)"

#: ../../whatsnew/2.3.rst:1727
msgid ""
"For more information, refer to the module's reference documentation. "
"(Contributed by Tim Peters.)"
msgstr ""
"さらに詳しい情報については、モジュールのリファレンスドキュメントを参照してく"
"ださい。 (Contributed by Tim Peters.)"

#: ../../whatsnew/2.3.rst:1734
msgid "The optparse Module"
msgstr "optparse モジュール"

#: ../../whatsnew/2.3.rst:1736
msgid ""
"The :mod:`getopt` module provides simple parsing of command-line arguments.  "
"The new :mod:`optparse` module (originally named Optik) provides more "
"elaborate command-line parsing that follows the Unix conventions, "
"automatically creates the output for :option:`!--help`, and can perform "
"different actions for different options."
msgstr ""
":mod:`getopt` モジュールはコマンドライン引数の単純な解析を提供しています。新"
"規に追加された :mod:`optparse` モジュール (元々 Optik と呼ばれていたもので"
"す) は Unix の慣習に従ったもっと念入りなコマンドライン解析を行い、自動的に :"
"option:`!--help` のための出力をし、異なったオプションに対して異なったアクショ"
"ンを実行出来ます。 (---訳注: 2.7 以降は :mod:`optparse` よりも新しい :mod:"
"`argparse` を使ってください。---)"

#: ../../whatsnew/2.3.rst:1742
msgid ""
"You start by creating an instance of :class:`~optparse.OptionParser` and "
"telling it what your program's options are. ::"
msgstr ""
":class:`~optparse.OptionParser` インスタンスを作ることから始め、プログラムの"
"オプションがどんなであるかそれに対して教えてやります::"

#: ../../whatsnew/2.3.rst:1745
msgid ""
"import sys\n"
"from optparse import OptionParser\n"
"\n"
"op = OptionParser()\n"
"op.add_option('-i', '--input',\n"
"              action='store', type='string', dest='input',\n"
"              help='set input filename')\n"
"op.add_option('-l', '--length',\n"
"              action='store', type='int', dest='length',\n"
"              help='set maximum length of output')"
msgstr ""

#: ../../whatsnew/2.3.rst:1756
msgid ""
"Parsing a command line is then done by calling the :meth:`~optparse."
"OptionParser.parse_args` method. ::"
msgstr ""
"コマンドラインの解析は :meth:`~optparse.OptionParser.parse_args` メソッドを呼"
"び出すことで行います ::"

#: ../../whatsnew/2.3.rst:1758
msgid ""
"options, args = op.parse_args(sys.argv[1:])\n"
"print options\n"
"print args"
msgstr ""

#: ../../whatsnew/2.3.rst:1762
msgid ""
"This returns an object containing all of the option values, and a list of "
"strings containing the remaining arguments."
msgstr ""
"これは、全てのオプションの値を含んだオブジェクトと残った引数を含む文字列リス"
"トを返します。"

#: ../../whatsnew/2.3.rst:1765
msgid ""
"Invoking the script with the various arguments now works as you'd expect it "
"to. Note that the length argument is automatically converted to an integer."
msgstr ""
"色々な引数でこのスクリプトを実行すれば、あなたの期待するように動きます。この"
"例での *length* 引数が自動的に整数に変換されることに注目してください。"

#: ../../whatsnew/2.3.rst:1768
msgid ""
"$ ./python opt.py -i data arg1\n"
"<Values at 0x400cad4c: {'input': 'data', 'length': None}>\n"
"['arg1']\n"
"$ ./python opt.py --input=data --length=4\n"
"<Values at 0x400cad2c: {'input': 'data', 'length': 4}>\n"
"[]\n"
"$"
msgstr ""

#: ../../whatsnew/2.3.rst:1778
msgid "The help message is automatically generated for you:"
msgstr "ヘルプメッセージはあなたのために自動生成されます:"

#: ../../whatsnew/2.3.rst:1780
msgid ""
"$ ./python opt.py --help\n"
"usage: opt.py [options]\n"
"\n"
"options:\n"
"  -h, --help            show this help message and exit\n"
"  -iINPUT, --input=INPUT\n"
"                        set input filename\n"
"  -lLENGTH, --length=LENGTH\n"
"                        set maximum length of output\n"
"$"
msgstr ""

#: ../../whatsnew/2.3.rst:1793
msgid "See the module's documentation for more details."
msgstr "さらに詳しいことはモジュールのドキュメントを参照して下さい。"

#: ../../whatsnew/2.3.rst:1796
msgid ""
"Optik was written by Greg Ward, with suggestions from the readers of the "
"Getopt SIG."
msgstr ""
"Optik は Getopt SIG の読者からの示唆を受けてGreg Ward により書かれました。"

#: ../../whatsnew/2.3.rst:1805
msgid "Pymalloc: A Specialized Object Allocator"
msgstr "Pymalloc: 特殊化されたオブジェクトアロケータ"

#: ../../whatsnew/2.3.rst:1807
msgid ""
"Pymalloc, a specialized object allocator written by Vladimir Marangozov, was "
"a feature added to Python 2.1.  Pymalloc is intended to be faster than the "
"system :c:func:`malloc` and to have less memory overhead for allocation "
"patterns typical of Python programs. The allocator uses C's :c:func:`malloc` "
"function to get large pools of memory and then fulfills smaller memory "
"requests from these pools."
msgstr ""
"Pymalloc は Vladimir Marangozov により書かれ Python 2.1 で追加された、特殊化"
"されたオブジェクトアロケータです。Pymalloc は典型的な Python プログラムでのア"
"ロケーションのパターンにおいて、システムの :c:func:`malloc` よりも高速で省メ"
"モリであることを意図したものです。このアロケータは C の :c:func:`malloc` 関数"
"を大きなメモリプールを得るのに使い、それより小さなメモリ要求はこれらプールで"
"実現しています。"

#: ../../whatsnew/2.3.rst:1813
msgid ""
"In 2.1 and 2.2, pymalloc was an experimental feature and wasn't enabled by "
"default; you had to explicitly enable it when compiling Python by providing "
"the :option:`!--with-pymalloc` option to the :program:`configure` script.  "
"In 2.3, pymalloc has had further enhancements and is now enabled by default; "
"you'll have to supply :option:`!--without-pymalloc` to disable it."
msgstr ""
"2.1 と 2.2 ではこの機能は実験的な位置付けでありデフォルトでは有効ではありませ"
"んでした。これを有効にするには Python コンパイル時に :program:`configure` ス"
"クリプトに :option:`!--with-pymalloc` オプションを明示的に与える必要がありま"
"した。2.3 では pymalloc はさらに拡張され、また、デフォルトで有効になりまし"
"た。逆にこれを無効にするのに :option:`!--without-pymalloc` を与える必要があり"
"ます。"

#: ../../whatsnew/2.3.rst:1819
msgid ""
"This change is transparent to code written in Python; however, pymalloc may "
"expose bugs in C extensions.  Authors of C extension modules should test "
"their code with pymalloc enabled, because some incorrect code may cause core "
"dumps at runtime."
msgstr ""
"この変更は Python で書いたコードからは見えませんが、 pymalloc は C 拡張内のバ"
"グを露にするかもしれません。C 拡張の著者は pymalloc を有効にしてテストすべき"
"です。というのも、ある種の正しくないコードが実行時にコアダンプしうるからで"
"す。"

#: ../../whatsnew/2.3.rst:1824
msgid ""
"There's one particularly common error that causes problems.  There are a "
"number of memory allocation functions in Python's C API that have previously "
"just been aliases for the C library's :c:func:`malloc` and :c:func:`free`, "
"meaning that if you accidentally called mismatched functions the error "
"wouldn't be noticeable. When the object allocator is enabled, these "
"functions aren't aliases of :c:func:`malloc` and :c:func:`free` any more, "
"and calling the wrong function to free memory may get you a core dump.  For "
"example, if memory was allocated using :c:func:`PyObject_Malloc`, it has to "
"be freed using :c:func:`PyObject_Free`, not :c:func:`free`.  A few modules "
"included with Python fell afoul of this and had to be fixed; doubtless there "
"are more third-party modules that will have the same problem."
msgstr ""
"問題を起こすとりわけ一般的な誤りが一つあります。Python の C API 内には数多く"
"のメモリアロケーション関数がありますが、これは以前は単に C ライブラリの :c:"
"func:`malloc` と :c:func:`free` への別名であり、何かの間違いでミスマッチな関"
"数呼び出しをしても、誤りは気付かれないものでした。今回のこのオブジェクトアロ"
"ケータを有効化すると、これら関数は :c:func:`malloc` と :c:func:`free` への別"
"名ではまったくなくて、メモリ解放に誤った関数を呼び出すとコアダンプし得ます。"
"例えば :c:func:`PyObject_Malloc` を使って獲得したメモリは :c:func:`free` では"
"なく :c:func:`PyObject_Free` を使って解放する必要があります。Python に含まれ"
"るいくつかのモジュールがまさにこれに抵触し、修正の必要がありました。間違いな"
"く多くのサードパーティモジュールが同じ問題を抱えているでしょう。"

#: ../../whatsnew/2.3.rst:1836
msgid ""
"As part of this change, the confusing multiple interfaces for allocating "
"memory have been consolidated down into two API families. Memory allocated "
"with one family must not be manipulated with functions from the other "
"family.  There is one family for allocating chunks of memory and another "
"family of functions specifically for allocating Python objects."
msgstr ""
"この変更の一環として、メモリアロケーションのためのこんがらかった複数インター"
"フェイスが統合されて 2 つの API ファミリになりました。一方のファミリで獲得さ"
"れたメモリは他方の関数で操作されることは許されません。一方のファミリはメモリ"
"の塊を獲得するためのもので、もう一方は Python オブジェクトの獲得に特殊化され"
"たものです。"

#: ../../whatsnew/2.3.rst:1842
msgid ""
"To allocate and free an undistinguished chunk of memory use the \"raw "
"memory\" family: :c:func:`PyMem_Malloc`, :c:func:`PyMem_Realloc`, and :c:"
"func:`PyMem_Free`."
msgstr ""
"何某かの区別のないメモリの塊を獲得・解放するのには「生メモリ」ファミリを使い"
"ます: :c:func:`PyMem_Malloc`, :c:func:`PyMem_Realloc`, :c:func:`PyMem_Free`."

#: ../../whatsnew/2.3.rst:1845
msgid ""
"The \"object memory\" family is the interface to the pymalloc facility "
"described above and is biased towards a large number of \"small\" "
"allocations: :c:func:`PyObject_Malloc`, :c:func:`PyObject_Realloc`, and :c:"
"func:`PyObject_Free`."
msgstr ""
"「オブジェクトメモリ」ファミリは上述の pymalloc 機構へのインターフェイスであ"
"り、多数の「小さな」獲得をするための特化がされています: :c:func:"
"`PyObject_Malloc`, :c:func:`PyObject_Realloc`, :c:func:`PyObject_Free`."

#: ../../whatsnew/2.3.rst:1849
msgid ""
"To allocate and free Python objects, use the \"object\" family :c:macro:"
"`PyObject_New`, :c:macro:`PyObject_NewVar`, and :c:func:`PyObject_Del`."
msgstr ""
"Python オブジェクトの獲得と解放には「オブジェクト」ファミリ :c:macro:"
"`PyObject_New`, :c:macro:`PyObject_NewVar`, :c:func:`PyObject_Del` を使いま"
"す。"

#: ../../whatsnew/2.3.rst:1852
msgid ""
"Thanks to lots of work by Tim Peters, pymalloc in 2.3 also provides "
"debugging features to catch memory overwrites and doubled frees in both "
"extension modules and in the interpreter itself.  To enable this support, "
"compile a debugging version of the Python interpreter by running :program:"
"`configure` with :option:`!--with-pydebug`."
msgstr ""
"Tim Peters による多大な仕事のおかげで、 2.3 の pymalloc はデバッグ機能も提供"
"しています。これはメモリの上書き、二重解放に関して、拡張モジュールとインタプ"
"リタ自身について検出出来ます。このサポートを有効にするには :program:"
"`configure` スクリプトにオプション :option:`!--with-pydebug` を与えて Python "
"インタプリタをデバッグバージョンとしてコンパイルしてください。"

#: ../../whatsnew/2.3.rst:1858
msgid ""
"To aid extension writers, a header file :file:`Misc/pymemcompat.h` is "
"distributed with the source to Python 2.3 that allows Python extensions to "
"use the 2.3 interfaces to memory allocation while compiling against any "
"version of Python since 1.5.2.  You would copy the file from Python's source "
"distribution and bundle it with the source of your extension."
msgstr ""
"拡張の著者のために、Python 2.3 のソースとともにヘッダファイル :file:`Misc/"
"pymemcompat.h` が配布されています。これは Python 拡張に 2.3 インターフェイス"
"でのメモリ獲得を使えるようにするもので、1.5.2 以降の全てのバージョンに対して"
"コンパイル可能です。Python のソース配布物からファイルをコピーして、あなたの拡"
"張ソースにバンドル出来ます。"

#: ../../whatsnew/2.3.rst:1867
msgid "https://hg.python.org/cpython/file/default/Objects/obmalloc.c"
msgstr "https://hg.python.org/cpython/file/default/Objects/obmalloc.c"

#: ../../whatsnew/2.3.rst:1868
msgid ""
"For the full details of the pymalloc implementation, see the comments at the "
"top of the file :file:`Objects/obmalloc.c` in the Python source code. The "
"above link points to the file within the python.org SVN browser."
msgstr ""
"pymalloc 実装に関する完全な詳細については Python ソースコード内の :file:"
"`Objects/obmalloc.c` ファイルの先頭のコメントを参照してください。上のファイル"
"へのリンクは python.org の SVN ブラウザを指しています。"

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

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

#: ../../whatsnew/2.3.rst:1880
msgid ""
"The cycle detection implementation used by the garbage collection has proven "
"to be stable, so it's now been made mandatory.  You can no longer compile "
"Python without it, and the :option:`!--with-cycle-gc` switch to :program:"
"`configure` has been removed."
msgstr ""
"ガーベージコレクションで使われている循環の検出実装が安定であることがわかった"
"ため、必須とすることになりました。Python をこれなしでコンパイルすることはもう"
"出来ません。 :program:`configure` スクリプトの :option:`!--with-cycle-gc` ス"
"イッチは削除されました。"

#: ../../whatsnew/2.3.rst:1885
msgid ""
"Python can now optionally be built as a shared library (:file:`libpython2.3."
"so`) by supplying :option:`!--enable-shared` when running Python's :program:"
"`configure` script.  (Contributed by Ondrej Palkovsky.)"
msgstr ""
"Python がオプショナルでシェアドライブラリ (:file:`libpython2.3.so`) としてビ"
"ルド可能になりました。Python の :program:`configure` スクリプトに :option:"
"`!--enable-shared` オプションを与えることで可能です。 (Contributed by Ondrej "
"Palkovsky.)"

#: ../../whatsnew/2.3.rst:1889
msgid ""
"The :c:macro:`!DL_EXPORT` and :c:macro:`!DL_IMPORT` macros are now "
"deprecated. Initialization functions for Python extension modules should now "
"be declared using the new macro :c:macro:`PyMODINIT_FUNC`, while the Python "
"core will generally use the :c:macro:`!PyAPI_FUNC` and :c:macro:`!"
"PyAPI_DATA` macros."
msgstr ""
"マクロ :c:macro:`!DL_EXPORT` と :c:macro:`!DL_IMPORT` が非推奨となっていま"
"す。Python コアが一般的にマクロ :c:macro:`!PyAPI_FUNC` と :c:macro:`!"
"PyAPI_DATA` を使うのに対し、Python 拡張モジュールの初期化関数が新規マクロ :c:"
"macro:`PyMODINIT_FUNC` を使って宣言されなければならなくなりました。"

#: ../../whatsnew/2.3.rst:1894
msgid ""
"The interpreter can be compiled without any docstrings for the built-in "
"functions and modules by supplying :option:`!--without-doc-strings` to the :"
"program:`configure` script. This makes the Python executable about 10% "
"smaller, but will also mean that you can't get help for Python's built-ins.  "
"(Contributed by Gustavo Niemeyer.)"
msgstr ""
":program:`configure` スクリプトに :option:`!--without-doc-strings` オプション"
"を与えることで、ビルトイン関数とモジュールが docstring を持たないインタプリタ"
"としてコンパイル出来るようになりました。これは Python の実行形式ファイルを "
"10% 小さくしますが、もちろん Python ビルトインのヘルプが取得できないことにも"
"なります。 (Contributed by Gustavo Niemeyer.)"

#: ../../whatsnew/2.3.rst:1900
msgid ""
"The :c:func:`!PyArg_NoArgs` macro is now deprecated, and code that uses it "
"should be changed.  For Python 2.2 and later, the method definition table "
"can specify the :c:macro:`METH_NOARGS` flag, signalling that there are no "
"arguments, and the argument checking can then be removed.  If compatibility "
"with pre-2.2 versions of Python is important, the code could use "
"``PyArg_ParseTuple(args, \"\")`` instead, but this will be slower than "
"using :c:macro:`METH_NOARGS`."
msgstr ""
":c:func:`!PyArg_NoArgs` マクロが非推奨となったので、これを使っているコードは"
"修正しなければなりません。Python 2.2 以降ではメソッド定義テーブルでは引数を持"
"たず、引数チェックを省けることを示すのに :c:macro:`METH_NOARGS` フラグが使え"
"ます。2.2 以前の Python バージョンとの互換性が重要な場合には "
"``PyArg_ParseTuple(args, \"\")`` を代わりに使えますが、 :c:macro:"
"`METH_NOARGS` を使うより遅いです。"

#: ../../whatsnew/2.3.rst:1907
msgid ""
":c:func:`PyArg_ParseTuple` accepts new format characters for various sizes "
"of unsigned integers: ``B`` for :c:expr:`unsigned char`, ``H`` for :c:expr:"
"`unsigned short int`,  ``I`` for :c:expr:`unsigned int`,  and ``K`` for :c:"
"expr:`unsigned long long`."
msgstr ""
":c:func:`PyArg_ParseTuple` に符号なし整数の色々なサイズのためのフォーマット文"
"字が追加されました: :c:expr:`unsigned char` のための ``B``, :c:expr:"
"`unsigned short int` のための ``H``, :c:expr:`unsigned int` のための ``I``, :"
"c:expr:`unsigned long long` のための ``K``。"

#: ../../whatsnew/2.3.rst:1912
msgid ""
"A new function, ``PyObject_DelItemString(mapping, char *key)`` was added as "
"shorthand for ``PyObject_DelItem(mapping, PyString_New(key))``."
msgstr ""
"新規関数 ``PyObject_DelItemString(mapping, char *key)`` が "
"``PyObject_DelItem(mapping, PyString_New(key))`` の速記法として追加されまし"
"た。"

#: ../../whatsnew/2.3.rst:1915
msgid ""
"File objects now manage their internal string buffer differently, increasing "
"it exponentially when needed.  This results in the benchmark tests in :file:"
"`Lib/test/test_bufio.py` speeding up considerably (from 57 seconds to 1.7 "
"seconds, according to one measurement)."
msgstr ""
"ファイルオブジェクトの内部文字列バッファの管理が変更されて、必要な場合には指"
"数関数的に増やすようになりました。 :file:`Lib/test/test_bufio.py` 内のベンチ"
"マークテストの結果での速度向上は大幅なものです (ある一つの計測では 57 秒から "
"1.7 秒になりました)。"

#: ../../whatsnew/2.3.rst:1920
msgid ""
"It's now possible to define class and static methods for a C extension type "
"by setting either the :c:macro:`METH_CLASS` or :c:macro:`METH_STATIC` flags "
"in a method's :c:type:`PyMethodDef` structure."
msgstr ""

#: ../../whatsnew/2.3.rst:1924
msgid ""
"Python now includes a copy of the Expat XML parser's source code, removing "
"any dependence on a system version or local installation of Expat."
msgstr ""
"Python は Expat XML パーサのソースコードのコピーを丸抱えするようになり、これ"
"により Expat のシステムのバージョンやローカルにインストールされたものへの依存"
"がなくなっています。"

#: ../../whatsnew/2.3.rst:1927
msgid ""
"If you dynamically allocate type objects in your extension, you should be "
"aware of a change in the rules relating to the :attr:`~type.__module__` and :"
"attr:`~type.__name__` attributes.  In summary, you will want to ensure the "
"type's dictionary contains a ``'__module__'`` key; making the module name "
"the part of the type name leading up to the final period will no longer have "
"the desired effect.  For more detail, read the API reference documentation "
"or the  source."
msgstr ""

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

#: ../../whatsnew/2.3.rst:1940
msgid ""
"Support for a port to IBM's OS/2 using the EMX runtime environment was "
"merged into the main Python source tree.  EMX is a POSIX emulation layer "
"over the OS/2 system APIs.  The Python port for EMX tries to support all the "
"POSIX-like capability exposed by the EMX runtime, and mostly succeeds; :func:"
"`!fork` and :func:`fcntl` are restricted by the limitations of the "
"underlying emulation layer.  The standard OS/2 port, which uses IBM's Visual "
"Age compiler, also gained support for case-sensitive import semantics as "
"part of the integration of the EMX port into CVS.  (Contributed by Andrew "
"MacIntyre.)"
msgstr ""

#: ../../whatsnew/2.3.rst:1949
msgid ""
"On MacOS, most toolbox modules have been weaklinked to improve backward "
"compatibility.  This means that modules will no longer fail to load if a "
"single routine is missing on the current OS version. Instead calling the "
"missing routine will raise an exception. (Contributed by Jack Jansen.)"
msgstr ""

#: ../../whatsnew/2.3.rst:1954
msgid ""
"The RPM spec files, found in the :file:`Misc/RPM/` directory in the Python "
"source distribution, were updated for 2.3.  (Contributed by Sean "
"Reifschneider.)"
msgstr ""

#: ../../whatsnew/2.3.rst:1957
msgid ""
"Other new platforms now supported by Python include AtheOS (http://www."
"atheos.cx/), GNU/Hurd, and OpenVMS."
msgstr ""

#: ../../whatsnew/2.3.rst:1966
msgid "Other Changes and Fixes"
msgstr "その他の変更と修正"

#: ../../whatsnew/2.3.rst:1968
msgid ""
"As usual, there were a bunch of other improvements and bugfixes scattered "
"throughout the source tree.  A search through the CVS change logs finds "
"there were 523 patches applied and 514 bugs fixed between Python 2.2 and "
"2.3.  Both figures are likely to be underestimates."
msgstr ""
"いつものように、たくさんのほかの改善とバグフィックスがソースツリー全体に渡っ"
"て散らばっています。CVS 変更ログを検索すると、Python 2.2 から 2.3 にかけて適"
"用されたパッチは 523、バグ修正は 514 ありました。いずれも少なく見積もって、で"
"す。"

#: ../../whatsnew/2.3.rst:1973
msgid "Some of the more notable changes are:"
msgstr "ほかの、さらに特筆すべき変更のいくつかを挙げます:"

#: ../../whatsnew/2.3.rst:1975
msgid ""
"If the :envvar:`PYTHONINSPECT` environment variable is set, the Python "
"interpreter will enter the interactive prompt after running a Python "
"program, as if Python had been invoked with the :option:`-i` option. The "
"environment variable can be set before running the Python interpreter, or it "
"can be set by the Python program as part of its execution."
msgstr ""
"環境変数 :envvar:`PYTHONINSPECT` をセットしておくと、Python インタプリタが "
"Python プログラム実行後に対話モードに入ります。これは Python を :option:`-i` "
"で起動するのと同じです。環境変数は Python インタプリタ実行前にセットするか、"
"Python プログラムのその実行の一部としてセットすることが出来ます。"

#: ../../whatsnew/2.3.rst:1981
msgid ""
"The :file:`regrtest.py` script now provides a way to allow \"all resources "
"except *foo*.\"  A resource name passed to the :option:`!-u` option can now "
"be prefixed with a hyphen (``'-'``) to mean \"remove this resource.\"  For "
"example, the option '``-uall,-bsddb``' could be used to enable the use of "
"all resources except ``bsddb``."
msgstr ""
":file:`regrtest.py` スクリプトで「*foo* を除く全てのリソース」とする手段が出"
"来ました。 :option:`!-u` オプションにリソース名を渡すのにハイフン (``'-'``) "
"を前置すると「このリソースを除く」ことを意味します。例えば '``-uall,-"
"bsddb``' は ``bsddb`` を除く全てのリソースを有効にするのに使えます。"

#: ../../whatsnew/2.3.rst:1987
msgid ""
"The tools used to build the documentation now work under Cygwin as well as "
"Unix."
msgstr ""
"ドキュメントのビルドに使われるツールは今では Unix 同様に Cygwin でも動作しま"
"す。"

#: ../../whatsnew/2.3.rst:1990
msgid ""
"The ``SET_LINENO`` opcode has been removed.  Back in the mists of time, this "
"opcode was needed to produce line numbers in tracebacks and support trace "
"functions (for, e.g., :mod:`pdb`). Since Python 1.5, the line numbers in "
"tracebacks have been computed using a different mechanism that works with "
"\"python -O\".  For Python 2.3 Michael Hudson implemented a similar scheme "
"to determine when to call the trace function, removing the need for "
"``SET_LINENO`` entirely."
msgstr ""
"``SET_LINENO`` 命令コード (opcode) は削除されました。彼方の昔に戻れば、この命"
"令コードはトレースバック内で行番号を生成し、トレース関数をサポートするのに必"
"要でした (例えば :mod:`pdb` のために)。Python 1.5 より、トレースバック内の行"
"番号は \"python -O\" で働くための異なったメカニズムを用いて計算で求められてき"
"ました。2.3 のためには Michael Hudson がトレース関数を呼ぶのに決定する似た方"
"法を実装しましたので、 ``SET_LINENO`` の必要性は完全になくなりました。"

#: ../../whatsnew/2.3.rst:1998
msgid ""
"It would be difficult to detect any resulting difference from Python code, "
"apart from a slight speed up when Python is run without :option:`-O`."
msgstr ""
"Python コードから何か異なる結果を見つけるのは、 :option:`-O` なしで Python を"
"実行する際のわずかなスピードアップを別とすれば、困難かもしれません。"

#: ../../whatsnew/2.3.rst:2001
msgid ""
"C extensions that access the :attr:`~frame.f_lineno` field of frame objects "
"should instead call ``PyCode_Addr2Line(f->f_code, f->f_lasti)``. This will "
"have the added effect of making the code work as desired under \"python -O\" "
"in earlier versions of Python."
msgstr ""
"フレームオブジェクトの :attr:`~frame.f_lineno` フィールドにアクセスしている "
"C 拡張は、代わりに ``PyCode_Addr2Line(f->f_code, f->f_lasti)`` を呼び出すべき"
"です。これは以前の Python バージョンでも \"python -O\" のもとでコードが動作す"
"るのにも望ましい効果を持つでしょう。"

#: ../../whatsnew/2.3.rst:2006
msgid ""
"A nifty new feature is that trace functions can now assign to the :attr:"
"`~frame.f_lineno` attribute of frame objects, changing the line that will be "
"executed next.  A ``jump`` command has been added to the :mod:`pdb` debugger "
"taking advantage of this new feature. (Implemented by Richie Hindle.)"
msgstr ""
"気の利いた新機能としては、トレース関数は、今ではフレームオブジェクトの :attr:"
"`~frame.f_lineno` 属性を、次に実行される行に変更してセットします。 :mod:"
"`pdb` デバッガにはこの新機能の恩恵を受けて ``jump`` コマンドが追加されていま"
"す。 (Implemented by Richie Hindle.)"

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

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

#: ../../whatsnew/2.3.rst:2020
msgid ""
":keyword:`yield` is now always a keyword; if it's used as a variable name in "
"your code, a different name must be chosen."
msgstr ""
":keyword:`yield` は今では常にキーワードです。変数名として使っていたならば、別"
"の名前を選ぶ必要があります。"

#: ../../whatsnew/2.3.rst:2023
msgid ""
"For strings *X* and *Y*, ``X in Y`` now works if *X* is more than one "
"character long."
msgstr ""
"文字列 *X* と *Y* について、 ``X in Y`` は *X* が一文字以上の場合でも動作する"
"ようになりました。"

#: ../../whatsnew/2.3.rst:2026
msgid ""
"The :func:`int` type constructor will now return a long integer instead of "
"raising an :exc:`OverflowError` when a string or floating-point number is "
"too large to fit into an integer."
msgstr ""
":func:`int` 型コンストラクタは、文字列や浮動小数点数を整数に収める際、それが"
"とても大き場合に  :exc:`OverflowError` を投げるのではなく長整数を返すように"
"なっています。"

#: ../../whatsnew/2.3.rst:2030
msgid ""
"If you have Unicode strings that contain 8-bit characters, you must declare "
"the file's encoding (UTF-8, Latin-1, or whatever) by adding a comment to the "
"top of the file.  See section :ref:`section-encodings` for more information."
msgstr ""
"8 ビット文字を含んだ Unicode 文字列をソースコードに埋め込む場合、ファイルのエ"
"ンコーディング (UTF-8, Latin-1, あるいはほか何か) を、ファイルの先頭のコメン"
"トに宣言しなければなりません。 :ref:`section-encodings` を参照してください。"

#: ../../whatsnew/2.3.rst:2034
msgid ""
"Calling Tcl methods through :mod:`!_tkinter` no longer  returns only "
"strings. Instead, if Tcl returns other objects those objects are converted "
"to their Python equivalent, if one exists, or wrapped with a :class:`!"
"_tkinter.Tcl_Obj` object if no Python equivalent exists."
msgstr ""
":mod:`!_tkinter` を介した Tcl メソッド呼び出しは今では文字列だけを返すのでは"
"ありません。代わりに Tcl は対応する Python の等価なオブジェクトに変換されたオ"
"ブジェクトを返します。Python に等価なものがなければ :class:`!_tkinter."
"Tcl_Obj` で包んで返します。"

#: ../../whatsnew/2.3.rst:2039
msgid ""
"Large octal and hex literals such as ``0xffffffff`` now trigger a :exc:"
"`FutureWarning`. Currently they're stored as 32-bit numbers and result in a "
"negative value, but in Python 2.4 they'll become positive long integers."
msgstr ""
"``0xffffffff`` のような大きな値の 8 進、16 進リテラルで :exc:`FutureWarning` "
"が発行されます。2.3 ではこれは 32 ビットの値に格納されて結果は負の値になりま"
"すが、Python 2.4 ではこれは正の長整数になります。"

#: ../../whatsnew/2.3.rst:2043
msgid ""
"There are a few ways to fix this warning.  If you really need a positive "
"number, just add an ``L`` to the end of the literal.  If you're trying to "
"get a 32-bit integer with low bits set and have previously used an "
"expression such as ``~(1 << 31)``, it's probably clearest to start with all "
"bits set and clear the desired upper bits. For example, to clear just the "
"top bit (bit 31), you could write ``0xffffffffL &~(1L<<31)``."
msgstr ""
"この警告の修正をする方法が少しだけあります。本当に正の値が欲しいのであれば "
"``L`` をリテラルの最後に付けて下さい。32 ビット分だけの下位ビットセットで 32 "
"ビット整数を取り出したいのであれば、また、 ``~(1 << 31)`` のような式を使って"
"きたのであれば、おそらく全ビットをセットすることから始めて上位ビットをクリア"
"するのが最も簡明です。例えば最上位ビット (ビット 31) を単にクリアするには "
"``0xffffffffL &~(1L<<31)`` と書けます。(---訳注: 2 点。Python 3 サポートを検"
"討するならば ``L`` は付けないように。2.4 以降は警告もなしに長整数になります"
"し。もう一点はこのパラグラフ全体について。根本的に警告への対処の話をしてるよ"
"うで後半はほとんど本質でない話をしているので意味不明な文章になっています。本"
"当に 2.3 を使わなければならないのでない限り、この文章を真面目に理解しようとし"
"なくとも良いと思います(本質的な措置は ``L`` を付けることしかない、2.3 で"
"は)。---)"

#: ../../whatsnew/2.3.rst:2050
msgid "You can no longer disable assertions by assigning to ``__debug__``."
msgstr ""
"``__debug__`` に代入することでアサーションを無効にすることは出来なくなりまし"
"た。"

#: ../../whatsnew/2.3.rst:2052
msgid ""
"The Distutils :func:`!setup` function has gained various new keyword "
"arguments such as *depends*.  Old versions of the Distutils will abort if "
"passed unknown keywords.  A solution is to check for the presence of the "
"new :func:`!get_distutil_options` function in your :file:`setup.py` and only "
"uses the new keywords with a version of the Distutils that supports them::"
msgstr ""
"Distutils の :func:`!setup` 関数に *depends* のような色々な新しいキーワード引"
"数が追加されています。Distutils の古いバージョンでは未知のキーワードを渡すと"
"処理を中断してしまいます。新旧で動作させなければならないのであれば、 :file:"
"`setup.py` 内で :func:`!get_distutil_options` 関数の有無をチェックし、それら"
"をサポートするバージョンの Distutils でのみ新しいキーワード引数を使うようにし"
"てください::"

#: ../../whatsnew/2.3.rst:2058
msgid ""
"from distutils import core\n"
"\n"
"kw = {'sources': 'foo.c', ...}\n"
"if hasattr(core, 'get_distutil_options'):\n"
"    kw['depends'] = ['foo.h']\n"
"ext = Extension(**kw)"
msgstr ""

#: ../../whatsnew/2.3.rst:2065
msgid ""
"Using ``None`` as a variable name will now result in a :exc:`SyntaxWarning` "
"warning."
msgstr ""
"``None`` を変数名に使うと :exc:`SyntaxWarning` 警告を出すようになっています。"

#: ../../whatsnew/2.3.rst:2068
msgid ""
"Names of extension types defined by the modules included with Python now "
"contain the module and a ``'.'`` in front of the type name."
msgstr ""
"Python と一緒に含まれるモジュールで定義される拡張型の名前にモジュール名と "
"``'.'`` が型名の頭に付くようになっています。"

#: ../../whatsnew/2.3.rst:2077
msgid "Acknowledgements"
msgstr "謝辞"

#: ../../whatsnew/2.3.rst:2079
msgid ""
"The author would like to thank the following people for offering "
"suggestions, corrections and assistance with various drafts of this article: "
"Jeff Bauer, Simon Brunning, Brett Cannon, Michael Chermside, Andrew Dalke, "
"Scott David Daniels, Fred L. Drake, Jr., David Fraser,  Kelly Gerber, "
"Raymond Hettinger, Michael Hudson, Chris Lambert, Detlef Lannert, Martin von "
"Löwis, Andrew MacIntyre, Lalo Martins, Chad Netzer, Gustavo Niemeyer, Neal "
"Norwitz, Hans Nowak, Chris Reedy, Francesco Ricciardi, Vinay Sajip, Neil "
"Schemenauer, Roman Suzi, Jason Tishler, Just van Rossum."
msgstr ""
"著者は提案の申し出や修正、様々なこの記事の草稿の助けをしてくれた以下の人々に"
"感謝します:  Jeff Bauer, Simon Brunning, Brett Cannon, Michael Chermside, "
"Andrew Dalke, Scott David Daniels, Fred L. Drake, Jr., David Fraser, Kelly "
"Gerber, Raymond Hettinger, Michael Hudson, Chris Lambert, Detlef Lannert, "
"Martin von Löwis, Andrew MacIntyre, Lalo Martins, Chad Netzer, Gustavo "
"Niemeyer, Neal Norwitz, Hans Nowak, Chris Reedy, Francesco Ricciardi, Vinay "
"Sajip, Neil Schemenauer, Roman Suzi, Jason Tishler, Just van Rossum."

#: ../../whatsnew/2.3.rst:371
msgid "universal newlines"
msgstr "universal newlines"

#: ../../whatsnew/2.3.rst:371
msgid "What's new"
msgstr ""