2.4.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:
# Arihiro TAKASE, 2023
# tomo, 2023
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.13\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2025-02-14 14:17+0000\n"
"PO-Revision-Date: 2021-06-28 01:51+0000\n"
"Last-Translator: tomo, 2023\n"
"Language-Team: Japanese (https://app.transifex.com/python-doc/teams/5390/"
"ja/)\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Language: ja\n"
"Plural-Forms: nplurals=1; plural=0;\n"

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

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

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

#: ../../whatsnew/2.4.rst:14
msgid ""
"This article explains the new features in Python 2.4.1, released on March "
"30, 2005."
msgstr ""
"この文書は 2005 年 3 月 30 日にリリースされた Python 2.4.1 の新機能について解"
"説します。 "

#: ../../whatsnew/2.4.rst:17
msgid ""
"Python 2.4 is a medium-sized release.  It doesn't introduce as many changes "
"as the radical Python 2.2, but introduces more features than the "
"conservative 2.3 release.  The most significant new language features are "
"function decorators and generator expressions; most other changes are to the "
"standard library."
msgstr ""
"Python 2.4 は、真ん中サイズ、のリリースです。急進的だった Python 2.2 ほどには"
"多くの変更をしていませんが、保守的だった 2.3 よりは多くの機能を導入していま"
"す。新しい言語機能で最も重要なのが、関数デコレータとジェネレータ式です。ほか"
"のほとんどの変更は標準ライブラリに対するものです。"

#: ../../whatsnew/2.4.rst:22
msgid ""
"According to the CVS change logs, there were 481 patches applied and 502 "
"bugs fixed between Python 2.3 and 2.4.  Both figures are likely to be "
"underestimates."
msgstr ""
"Python 2.3 から 2.4 の CVS 変更ログによれば、適用されたパッチは 481、フィック"
"スされたバグは 502 ありました。ともに、少なく見積もって、です。"

#: ../../whatsnew/2.4.rst:25
msgid ""
"This article doesn't attempt to provide a complete specification of every "
"single new feature, but instead provides a brief introduction to each "
"feature.  For full details, you should refer to the documentation for Python "
"2.4, such as the Python Library Reference and the Python Reference Manual.  "
"Often you will be referred to the PEP for a particular new feature for "
"explanations of the implementation and design rationale."
msgstr ""
"このドキュメントは個々の新機能の完全な詳細を提供するのではなくて、簡易な概要"
"を提供することを目的にしています。完全な詳細が知りたければ、 Python ライブラ"
"リリファレンス、Python リファレンスマニュアルのような Python 2.4 のドキュメン"
"トを参照してください。多くの場合個別の新機能についての実装の説明やデザインの"
"根拠については PEP に託されています。"

#: ../../whatsnew/2.4.rst:36
msgid "PEP 218: Built-In Set Objects"
msgstr "PEP 218: ビルトインの集合オブジェクト"

#: ../../whatsnew/2.4.rst:38
msgid ""
"Python 2.3 introduced the :mod:`sets` module.  C implementations of set data "
"types have now been added to the Python core as two new built-in types, "
"``set(iterable)`` and ``frozenset(iterable)``.  They provide high speed "
"operations for membership testing, for eliminating duplicates from "
"sequences, and for mathematical operations like unions, intersections, "
"differences, and symmetric differences. ::"
msgstr ""
"Python 2.3 では :mod:`sets` モジュールを導入しました。集合データ型の C 実装"
"が Python コアに新たに、2 つの新しいビルトイン型 ``set(iterable)`` と "
"``frozenset(iterable)`` として追加されています。これらは要素が集合に属してい"
"るかのメンバシップテスト、シーケンスからの重複の削除、それに和集合 (union)、"
"共通集合 (intersection)、 差 (difference)、対称差 (symmetric difference) と"
"いった数学演算を高速に行います::"

#: ../../whatsnew/2.4.rst:45
msgid ""
">>> a = set('abracadabra')              # form a set from a string\n"
">>> 'z' in a                            # fast membership testing\n"
"False\n"
">>> a                                   # unique letters in a\n"
"set(['a', 'r', 'b', 'c', 'd'])\n"
">>> ''.join(a)                          # convert back into a string\n"
"'arbcd'\n"
"\n"
">>> b = set('alacazam')                 # form a second set\n"
">>> a - b                               # letters in a but not in b\n"
"set(['r', 'd', 'b'])\n"
">>> a | b                               # letters in either a or b\n"
"set(['a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'])\n"
">>> a & b                               # letters in both a and b\n"
"set(['a', 'c'])\n"
">>> a ^ b                               # letters in a or b but not both\n"
"set(['r', 'd', 'b', 'm', 'z', 'l'])\n"
"\n"
">>> a.add('z')                          # add a new element\n"
">>> a.update('wxy')                     # add multiple new elements\n"
">>> a\n"
"set(['a', 'c', 'b', 'd', 'r', 'w', 'y', 'x', 'z'])\n"
">>> a.remove('x')                       # take one element out\n"
">>> a\n"
"set(['a', 'c', 'b', 'd', 'r', 'w', 'y', 'z'])"
msgstr ""

#: ../../whatsnew/2.4.rst:71
msgid ""
"The :func:`frozenset` type is an immutable version of :func:`set`. Since it "
"is immutable and hashable, it may be used as a dictionary key or as a member "
"of another set."
msgstr ""
":func:`frozenset` 型は :func:`set` の :term:`immutable` 版です。 immutable か"
"つハッシュ可能なので、辞書のキーやほかの set のメンバとして使えるでしょう。"

#: ../../whatsnew/2.4.rst:75
msgid ""
"The :mod:`sets` module remains in the standard library, and may be useful if "
"you wish to subclass the :class:`Set` or :class:`ImmutableSet` classes.  "
"There are currently no plans to deprecate the module."
msgstr ""
"2.3 で追加された :mod:`sets` モジュールは標準ライブラリに残されていて、 :"
"class:`Set` や :class:`ImmutableSet` をサブクラス化したければ便利かもしれませ"
"ん。今のところこれを撤廃する予定はありません。(---訳注: :mod:`sets` モジュー"
"ルは 2.6 で非推奨となっています。---)"

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

#: ../../whatsnew/2.4.rst:83
msgid ""
"Originally proposed by Greg Wilson and ultimately implemented by Raymond "
"Hettinger."
msgstr ""
"元々は Greg Wilson によって提案され、完全な実装は Raymond Hettinger によって"
"なされました。"

#: ../../whatsnew/2.4.rst:90
msgid "PEP 237: Unifying Long Integers and Integers"
msgstr "PEP 237: 長整数と整数を一体化していく"

#: ../../whatsnew/2.4.rst:92
msgid ""
"The lengthy transition process for this PEP, begun in Python 2.2, takes "
"another step forward in Python 2.4.  In 2.3, certain integer operations that "
"would behave differently after int/long unification triggered :exc:"
"`FutureWarning` warnings and returned values limited to 32 or 64 bits "
"(depending on your platform).  In 2.4, these expressions no longer produce a "
"warning and instead produce a different result that's usually a long integer."
msgstr ""
"この PEP の非常に長期に渡る移行は Python 2.2 に始まり、Python 2.4 でさらにも"
"う一歩前進しています。2.3 では int/long の一体化後に異なる振る舞いをする整数"
"演算をすると :exc:`FutureWarning` 警告を出して、結果の値は (プラットフォーム"
"依存で) 32 ビットまたは 64 ビットに制限していました。2.4 ではこれらの式はもう"
"警告は出さず、代わりにいつでも(2.3 とは違った)長整数となる結果をはじき出しま"
"す。"

#: ../../whatsnew/2.4.rst:99
msgid ""
"The problematic expressions are primarily left shifts and lengthy "
"hexadecimal and octal constants.  For example, ``2 << 32`` results in a "
"warning in 2.3, evaluating to 0 on 32-bit platforms.  In Python 2.4, this "
"expression now returns the correct answer, 8589934592."
msgstr ""
"問題を起こしうる式は主として左シフトで、そして長い 16 進リテラルと 8 進リテラ"
"ルです。例えば ``2 << 32`` は 2.3 では警告とともに 32 ビットプラットフォーム"
"では結果は 0 になります。Python 2.4 ではこの式は正しい答えの 8589934592 にな"
"ります。"

#: ../../whatsnew/2.4.rst:107
msgid ":pep:`237` - Unifying Long Integers and Integers"
msgstr ":pep:`237` - 長整数と整数を一体化していく"

#: ../../whatsnew/2.4.rst:108
msgid ""
"Original PEP written by Moshe Zadka and GvR.  The changes for 2.4 were "
"implemented by  Kalle Svensson."
msgstr ""
"オリジナルの PEP は Moshe Zadka と GvR (Guido van Rossum) によって書かれまし"
"た。.2.4 での変更については Kalle Svensson によって実装されました。"

#: ../../whatsnew/2.4.rst:115
msgid "PEP 289: Generator Expressions"
msgstr "PEP 289: ジェネレータ式"

#: ../../whatsnew/2.4.rst:117
msgid ""
"The iterator feature introduced in Python 2.2 and the :mod:`itertools` "
"module make it easier to write programs that loop through large data sets "
"without having the entire data set in memory at one time.  List "
"comprehensions don't fit into this picture very well because they produce a "
"Python list object containing all of the items.  This unavoidably pulls all "
"of the objects into memory, which can be a problem if your data set is very "
"large.  When trying to write a functionally styled program, it would be "
"natural to write something like::"
msgstr ""

#: ../../whatsnew/2.4.rst:125
msgid ""
"links = [link for link in get_all_links() if not link.followed]\n"
"for link in links:\n"
"    ..."
msgstr ""

#: ../../whatsnew/2.4.rst:129
msgid "instead of  ::"
msgstr "こうではなく  ::"

#: ../../whatsnew/2.4.rst:131
msgid ""
"for link in get_all_links():\n"
"    if link.followed:\n"
"        continue\n"
"    ..."
msgstr ""

#: ../../whatsnew/2.4.rst:136
msgid ""
"The first form is more concise and perhaps more readable, but if you're "
"dealing with a large number of link objects you'd have to write the second "
"form to avoid having all link objects in memory at the same time."
msgstr ""
"最初の形の方が簡潔でおそらく読みやすいですが、扱っているのがとても多くのリン"
"クオブジェクトであるならば、全てのリンクオブジェクトが一気にメモリに載らない"
"ように二つ目の形で書く必要がありました。"

#: ../../whatsnew/2.4.rst:140
msgid ""
"Generator expressions work similarly to list comprehensions but don't "
"materialize the entire list; instead they create a generator that will "
"return elements one by one.  The above example could be written as::"
msgstr ""
"ジェネレータ式はリスト内包と似た動作をしますが、リスト全体を実体化しません; "
"代わりにそれは、要素を一つずつ返すジェネレータを返します。上述の例はこう書け"
"ます::"

#: ../../whatsnew/2.4.rst:144
msgid ""
"links = (link for link in get_all_links() if not link.followed)\n"
"for link in links:\n"
"    ..."
msgstr ""

#: ../../whatsnew/2.4.rst:148
msgid ""
"Generator expressions always have to be written inside parentheses, as in "
"the above example.  The parentheses signalling a function call also count, "
"so if you want to create an iterator that will be immediately passed to a "
"function you could write::"
msgstr ""
"上の例でのように、ジェネレータ式は常に括弧の中に書かなければなりません。関数"
"呼び出しを囲む括弧もそれに含まれるので、関数にそのまま渡すイテレータを作りた"
"ければこれで良いです::"

#: ../../whatsnew/2.4.rst:153
msgid "print sum(obj.count for obj in list_all_objects())"
msgstr ""

#: ../../whatsnew/2.4.rst:155
msgid ""
"Generator expressions differ from list comprehensions in various small ways. "
"Most notably, the loop variable (*obj* in the above example) is not "
"accessible outside of the generator expression.  List comprehensions leave "
"the variable assigned to its last value; future versions of Python will "
"change this, making list comprehensions match generator expressions in this "
"respect."
msgstr ""
"ジェネレータ式はリスト内包とは色々小さい点で違います。最も顕著なのはループ変"
"数 (上の例での *obj*) がジェネレータ式の外からアクセス不能なことです。リスト"
"内包はループの制御変数が最後に代入された値で残ります; 将来のバージョンの "
"Python では、この振る舞いはリスト内包がこの点でジェネレータ式と同じになるよう"
"に変更されます。 (---訳注: Python 2.7 でもリスト内包のこの振る舞いは変わって"
"おらず、警告ともなりません。制御変数が内包のスコープ外で可視でなくなったのは "
"Python 3.0 からです。---)"

#: ../../whatsnew/2.4.rst:164
msgid ":pep:`289` - Generator Expressions"
msgstr ":pep:`289` - ジェネレータ式"

#: ../../whatsnew/2.4.rst:165
msgid ""
"Proposed by Raymond Hettinger and implemented by Jiwon Seo with early "
"efforts steered by Hye-Shik Chang."
msgstr ""
"Raymond Hettinger によって提案され、Hye-Shik Chang に導かれた早期の尽力によっ"
"て Jiwon Seo により実装されました。"

#: ../../whatsnew/2.4.rst:172
msgid "PEP 292: Simpler String Substitutions"
msgstr "PEP 292: より単純な文字列置換 (string substitution)"

#: ../../whatsnew/2.4.rst:174
msgid ""
"Some new classes in the standard library provide an alternative mechanism "
"for substituting variables into strings; this style of substitution may be "
"better for applications where untrained users need to edit templates."
msgstr ""
"標準ライブラリに、文字列を変数で置換するための代替メカニズムをもたらす新しい"
"くつかのクラスが追加されました; この置換のスタイルは、訓練されていないユーザ"
"がテンプレートを編集する必要があるようなアプリケーションにとって、より良いも"
"のでしょう。"

#: ../../whatsnew/2.4.rst:178
msgid "The usual way of substituting variables by name is the ``%`` operator::"
msgstr "変数置換を名前で行うためのいつもの方法は ``%`` 演算子です::"

#: ../../whatsnew/2.4.rst:180
msgid ""
">>> '%(page)i: %(title)s' % {'page':2, 'title': 'The Best of Times'}\n"
"'2: The Best of Times'"
msgstr ""

#: ../../whatsnew/2.4.rst:183
msgid ""
"When writing the template string, it can be easy to forget the ``i`` or "
"``s`` after the closing parenthesis.  This isn't a big problem if the "
"template is in a Python module, because you run the code, get an "
"\"Unsupported format character\" :exc:`ValueError`, and fix the problem.  "
"However, consider an application such as Mailman where template strings or "
"translations are being edited by users who aren't aware of the Python "
"language.  The format string's syntax is complicated to explain to such "
"users, and if they make a mistake, it's difficult to provide helpful "
"feedback to them."
msgstr ""
"テンプレート文字列を書くのに、閉じ括弧のあとの ``i`` や ``s`` を忘れやすいで"
"す。これはそのテンプレートが Python モジュール内にあるなら大問題でもありませ"
"ん。コードを実行し、「サポートされないフォーマット文字 (unsupported format "
"character)」な :exc:`ValueError` を喰らい、問題を直すだけのことです。ですが、"
"例えば Mailman のようなアプリケーションを考えてみてください。テンプレート文字"
"列や翻訳は、Python 言語について承知していないユーザが編集するのです。フォー"
"マット文字列の構文はそのようなユーザに説明するには複雑で、彼らが間違いをやら"
"かした場合には、親切なフィードバックを彼らに与えるのは難しいのです。"

#: ../../whatsnew/2.4.rst:192
msgid ""
"PEP 292 adds a :class:`Template` class to the :mod:`string` module that uses "
"``$`` to indicate a substitution::"
msgstr ""
"PEP 292 は :mod:`string` モジュールに :class:`Template` クラスを追加します。"
"これは置換を指示するのに ``$`` を使います::"

#: ../../whatsnew/2.4.rst:195
msgid ""
">>> import string\n"
">>> t = string.Template('$page: $title')\n"
">>> t.substitute({'page':2, 'title': 'The Best of Times'})\n"
"'2: The Best of Times'"
msgstr ""

#: ../../whatsnew/2.4.rst:200
msgid ""
"If a key is missing from the dictionary, the :meth:`substitute` method will "
"raise a :exc:`KeyError`.  There's also a :meth:`safe_substitute` method that "
"ignores missing keys::"
msgstr ""
"辞書にキーが見つからない場合、 :meth:`substitute` メソッドは :exc:`KeyError` "
"を送出します。 :meth:`safe_substitute` メソッドもあり、これはキー不在を無視し"
"ます::"

#: ../../whatsnew/2.4.rst:204
msgid ""
">>> t = string.Template('$page: $title')\n"
">>> t.safe_substitute({'page':3})\n"
"'3: $title'"
msgstr ""

#: ../../whatsnew/2.4.rst:211
msgid ":pep:`292` - Simpler String Substitutions"
msgstr ":pep:`292` - より単純な文字列置換 (string substitution)"

#: ../../whatsnew/2.4.rst:212
msgid "Written and implemented  by Barry Warsaw."
msgstr "Barry Warsaw 著、実装"

#: ../../whatsnew/2.4.rst:218
msgid "PEP 318: Decorators for Functions and Methods"
msgstr "PEP 318: 関数とメソッドのためのデコレータ"

#: ../../whatsnew/2.4.rst:220
msgid ""
"Python 2.2 extended Python's object model by adding static methods and class "
"methods, but it didn't extend Python's syntax to provide any new way of "
"defining static or class methods.  Instead, you had to write a :keyword:"
"`def` statement in the usual way, and pass the resulting method to a :func:"
"`staticmethod` or :func:`classmethod` function that would wrap up the "
"function as a method of the new type. Your code would look like this::"
msgstr ""
"Python 2.2 は Python オブジェクトモデルを静的メソッド、クラスメソッドを追加す"
"ることで拡張はしましたが、それらを定義する新たな手段を提供するような Python "
"構文の拡張はしませんでした。このため、 :keyword:`def` でメソッドは普通に書い"
"たのち、新型メソッドとしての関数へ仕立て上げる :func:`staticmethod` または :"
"func:`classmethod` にその結果のメソッドを渡す、という手順を取る必要がありまし"
"た。このような具合でした::"

#: ../../whatsnew/2.4.rst:227
msgid ""
"class C:\n"
"   def meth (cls):\n"
"       ...\n"
"\n"
"   meth = classmethod(meth)   # Rebind name to wrapped-up class method"
msgstr ""

#: ../../whatsnew/2.4.rst:233
msgid ""
"If the method was very long, it would be easy to miss or forget the :func:"
"`classmethod` invocation after the function body."
msgstr ""
"メソッドがとても長かったりすると、関数のボディの後ろの :func:`classmethod` 呼"
"び出しは見失ったり忘れたりしやすいものでした。"

#: ../../whatsnew/2.4.rst:236
msgid ""
"The intention was always to add some syntax to make such definitions more "
"readable, but at the time of 2.2's release a good syntax was not obvious.  "
"Today a good syntax *still* isn't obvious but users are asking for easier "
"access to the feature; a new syntactic feature has been added to meet this "
"need."
msgstr ""
"そのような定義をもっと読みやすくするために何か構文を追加する、という意図は常"
"にありましたが、2.2 のリリース時点では良い構文は明らかではありませんでした。"
"本日時点でさえ *いまだ* 明らかとは言えませんが、ユーザは静的メソッドとクラス"
"メソッドを簡単に手にする手段を注文し続けています; 新たな構文的機能はこの要求"
"に合うように追加されました。"

#: ../../whatsnew/2.4.rst:241
msgid ""
"The new feature is called \"function decorators\".  The name comes from the "
"idea that :func:`classmethod`, :func:`staticmethod`, and friends are storing "
"additional information on a function object; they're *decorating* functions "
"with more details."
msgstr ""
"この新たな機能は「関数デコレータ (function decorators)」と呼ばれます。この名"
"前は :func:`classmethod`, :func:`staticmethod`, とその仲間たちが関数オブジェ"
"クトに追加的な情報を保存することから着想を得たものです; それらは関数をより多"
"くの詳細で *デコレート (修飾) している* というわけです。"

#: ../../whatsnew/2.4.rst:246
msgid ""
"The notation borrows from Java and uses the ``'@'`` character as an "
"indicator. Using the new syntax, the example above would be written::"
msgstr ""
"記法は Java より拝借して ``'@'`` 文字を指示子として使います。この新たな構文を"
"使うと、上記の例はこのように書けます::"

#: ../../whatsnew/2.4.rst:249
msgid ""
"class C:\n"
"\n"
"   @classmethod\n"
"   def meth (cls):\n"
"       ..."
msgstr ""

#: ../../whatsnew/2.4.rst:256
msgid ""
"The ``@classmethod`` is shorthand for the ``meth=classmethod(meth)`` "
"assignment. More generally, if you have the following::"
msgstr ""
"``@classmethod`` は ``meth=classmethod(meth)`` 代入の速記法です。より一般的に"
"は、このように書けば…:"

#: ../../whatsnew/2.4.rst:259
msgid ""
"@A\n"
"@B\n"
"@C\n"
"def f ():\n"
"    ..."
msgstr ""

#: ../../whatsnew/2.4.rst:265
msgid "It's equivalent to the following pre-decorator code::"
msgstr "これはデコレータ前史の以下コードと等価です::"

#: ../../whatsnew/2.4.rst:267
msgid ""
"def f(): ...\n"
"f = A(B(C(f)))"
msgstr ""

#: ../../whatsnew/2.4.rst:270
msgid ""
"Decorators must come on the line before a function definition, one decorator "
"per line, and can't be on the same line as the def statement, meaning that "
"``@A def f(): ...`` is illegal.  You can only decorate function definitions, "
"either at the module level or inside a class; you can't decorate class "
"definitions."
msgstr ""
"デコレータは関数定義の前になければなりません。一行ごとに一つのデコレータで"
"す。 def ステートメントと同じ行にあってはダメです。つまり ``@A def f(): ..."
"`` は不正です。モジュールレベルかクラス内の関数定義のみをデコレート出来ます; "
"クラス定義はデコレート出来ません。(--- 訳注: クラス定義のデコレータは Python "
"2.6 で追加されました (PEP 3129) 。---)"

#: ../../whatsnew/2.4.rst:275
msgid ""
"A decorator is just a function that takes the function to be decorated as an "
"argument and returns either the same function or some new object.  The "
"return value of the decorator need not be callable (though it typically is), "
"unless further decorators will be applied to the result.  It's easy to write "
"your own decorators.  The following simple example just sets an attribute on "
"the function object::"
msgstr ""
"デコレータはただの関数です。引数としてデコレートされる関数を取り、同じ関数か"
"何か新しいオブジェクトを返すだけの。結果がほかのデコレータ適用されるの出ない"
"限りは、デコレータの戻り値は呼び出し可能である必要はありません (普通はそうで"
"すが)。あなた自身のデコレータを書くのは簡単です。続く単純な例は、関数オブジェ"
"クトに単に属性をセットするだけのものです::"

#: ../../whatsnew/2.4.rst:282
msgid ""
">>> def deco(func):\n"
"...    func.attr = 'decorated'\n"
"...    return func\n"
"...\n"
">>> @deco\n"
"... def f(): pass\n"
"...\n"
">>> f\n"
"<function f at 0x402ef0d4>\n"
">>> f.attr\n"
"'decorated'\n"
">>>"
msgstr ""

#: ../../whatsnew/2.4.rst:295
msgid ""
"As a slightly more realistic example, the following decorator checks that "
"the supplied argument is an integer::"
msgstr ""
"もう少しだけ現実的な例として、続く例ではデコレータに、与えられた引数が整数か"
"どうかチェックさせてみます::"

#: ../../whatsnew/2.4.rst:298
msgid ""
"def require_int (func):\n"
"    def wrapper (arg):\n"
"        assert isinstance(arg, int)\n"
"        return func(arg)\n"
"\n"
"    return wrapper\n"
"\n"
"@require_int\n"
"def p1 (arg):\n"
"    print arg\n"
"\n"
"@require_int\n"
"def p2(arg):\n"
"    print arg*2"
msgstr ""

#: ../../whatsnew/2.4.rst:313
msgid ""
"An example in :pep:`318` contains a fancier version of this idea that lets "
"you both specify the required type and check the returned type."
msgstr ""
":pep:`318` にある例はこのアイディアのもっと凝った版が含まれていて、それは要求"
"型の指定と戻り値のチェックの両方が出来ます。"

#: ../../whatsnew/2.4.rst:316
msgid ""
"Decorator functions can take arguments.  If arguments are supplied, your "
"decorator function is called with only those arguments and must return a new "
"decorator function; this function must take a single function and return a "
"function, as previously described.  In other words, ``@A @B @C(args)`` "
"becomes::"
msgstr ""
"デコレータ関数は引数を取ることが出来ます。引数が与えられた場合、あなたのデコ"
"レータ関数はそれら引数のみで呼び出され、そして新しいデコレータを返さなければ"
"なりません; この関数は単一の関数を取らなければならず、前述のように関数を返さ"
"なければなりません。言い換えると、 ``@A @B @C(args)`` はこうなります::"

#: ../../whatsnew/2.4.rst:321
msgid ""
"def f(): ...\n"
"_deco = C(args)\n"
"f = A(B(_deco(f)))"
msgstr ""

#: ../../whatsnew/2.4.rst:325
msgid ""
"Getting this right can be slightly brain-bending, but it's not too difficult."
msgstr ""
"これが正しいと理解するには少しばかり頭をひねる必要がありますが、難しすぎるこ"
"とはありません。"

#: ../../whatsnew/2.4.rst:327
msgid ""
"A small related change makes the :attr:`func_name <function.__name__>` "
"attribute of functions writable.  This attribute is used to display function "
"names in tracebacks, so decorators should change the name of any new "
"function that's constructed and returned."
msgstr ""

#: ../../whatsnew/2.4.rst:336
msgid ":pep:`318` - Decorators for Functions, Methods and Classes"
msgstr ":pep:`318` - 関数、メソッド、クラスのためのデコレータ"

#: ../../whatsnew/2.4.rst:337
msgid ""
"Written  by Kevin D. Smith, Jim Jewett, and Skip Montanaro.  Several people "
"wrote patches implementing function decorators, but the one that was "
"actually checked in was patch #979728, written by Mark Russell."
msgstr ""
"Kevin D. Smith, Jim Jewett, Skip Montanaro により著されました。数多くの人々が"
"関数デコレータ実装のパッチを書きましたが、実際にチェックインされたものは "
"Mark Russell が書いた #979728 でした。"

#: ../../whatsnew/2.4.rst:341
msgid "https://wiki.python.org/moin/PythonDecoratorLibrary"
msgstr "https://wiki.python.org/moin/PythonDecoratorLibrary"

#: ../../whatsnew/2.4.rst:342
msgid "This Wiki page contains several examples of decorators."
msgstr "数多くのデコレータ例を含む Wiki ページ。"

#: ../../whatsnew/2.4.rst:348
msgid "PEP 322: Reverse Iteration"
msgstr "PEP 322: 逆順のイテレーション"

#: ../../whatsnew/2.4.rst:350
msgid ""
"A new built-in function, ``reversed(seq)``, takes a sequence and returns an "
"iterator that loops over the elements of the sequence  in reverse order.   ::"
msgstr ""
"新しいビルトイン関数 ``reversed(seq)`` は、シーケンスを受け取って、シーケンス"
"の要素を逆順にループするイテレータを返します::"

#: ../../whatsnew/2.4.rst:353
msgid ""
">>> for i in reversed(xrange(1,4)):\n"
"...    print i\n"
"...\n"
"3\n"
"2\n"
"1"
msgstr ""

#: ../../whatsnew/2.4.rst:360
msgid ""
"Compared to extended slicing, such as ``range(1,4)[::-1]``, :func:`reversed` "
"is easier to read, runs faster, and uses substantially less memory."
msgstr ""
"``range(1,4)[::-1]`` のようにする拡張スライスでのやり方に比較して :func:"
"`reversed` は読みやすく、実行が高速で、大体の場合はメモリ使用が少なく済みま"
"す。"

#: ../../whatsnew/2.4.rst:363
msgid ""
"Note that :func:`reversed` only accepts sequences, not arbitrary iterators.  "
"If you want to reverse an iterator, first convert it to  a list with :func:"
"`list`. ::"
msgstr ""
":func:`reversed` は任意のイテレータは受け付けず、シーケンスのみ受け付けること"
"に注意してください。イテレータを逆順にしたければ、最初に :func:`list` でリス"
"トに変換してください::"

#: ../../whatsnew/2.4.rst:367
msgid ""
">>> input = open('/etc/passwd', 'r')\n"
">>> for line in reversed(list(input)):\n"
"...   print line\n"
"...\n"
"root:*:0:0:System Administrator:/var/root:/bin/tcsh\n"
"  ..."
msgstr ""

#: ../../whatsnew/2.4.rst:377
msgid ":pep:`322` - Reverse Iteration"
msgstr ":pep:`322`  - 逆順のイテレーション"

#: ../../whatsnew/2.4.rst:378
msgid "Written and implemented by Raymond Hettinger."
msgstr "Raymond Hettinger 著、実装."

#: ../../whatsnew/2.4.rst:384
msgid "PEP 324: New subprocess Module"
msgstr "PEP 324: 新しい subprocess モジュール"

#: ../../whatsnew/2.4.rst:386
msgid ""
"The standard library provides a number of ways to execute a subprocess, "
"offering different features and different levels of complexity. ``os."
"system(command)`` is easy to use, but slow (it runs a shell process which "
"executes the command) and dangerous (you have to be careful about escaping "
"the shell's metacharacters).  The :mod:`!popen2` module offers classes that "
"can capture standard output and standard error from the subprocess, but the "
"naming is confusing.  The :mod:`subprocess` module cleans  this up, "
"providing a unified interface that offers all the features you might need."
msgstr ""

#: ../../whatsnew/2.4.rst:395
msgid ""
"Instead of :mod:`!popen2`'s collection of classes, :mod:`subprocess` "
"contains a single class called :class:`subprocess.Popen`  whose constructor "
"supports a number of different keyword arguments. ::"
msgstr ""

#: ../../whatsnew/2.4.rst:399
msgid ""
"class Popen(args, bufsize=0, executable=None,\n"
"            stdin=None, stdout=None, stderr=None,\n"
"            preexec_fn=None, close_fds=False, shell=False,\n"
"            cwd=None, env=None, universal_newlines=False,\n"
"            startupinfo=None, creationflags=0):"
msgstr ""

#: ../../whatsnew/2.4.rst:405
msgid ""
"*args* is commonly a sequence of strings that will be the arguments to the "
"program executed as the subprocess.  (If the *shell* argument is true, "
"*args* can be a string which will then be passed on to the shell for "
"interpretation, just as :func:`os.system` does.)"
msgstr ""
"*args* は普通は文字列のシーケンスで、サブプロセスとして実行するプログラムへの"
"引数群となります。 (*shell* 引数が真の場合は *args* はシェルに解釈を任せるた"
"めに渡す文字列に出来、つまりこの場合 :func:`os.system` と同じことをします。)"

#: ../../whatsnew/2.4.rst:410
msgid ""
"*stdin*, *stdout*, and *stderr* specify what the subprocess's input, output, "
"and error streams will be.  You can provide a file object or a file "
"descriptor, or you can use the constant ``subprocess.PIPE`` to create a pipe "
"between the subprocess and the parent."
msgstr ""
"*stdin*, *stdout*, *stderr* はサブプロセスの入力・出力・エラーのストリームを"
"指定します。ファイルオブジェクトかファイル記述子を渡すことが出来ます。あるい"
"は定数 ``subprocess.PIPE`` を渡してサブプロセスと親とのパイプを作成することが"
"出来ます。"

#: ../../whatsnew/2.4.rst:418
msgid "The constructor has a number of handy options:"
msgstr "コンストラクタには多くの便利なオプションがあります:"

#: ../../whatsnew/2.4.rst:420
msgid ""
"*close_fds* requests that all file descriptors be closed before running the "
"subprocess."
msgstr ""
"*close_fds* はサブプロセス実行前に全てのファイル記述子をクローズすることを要"
"求します。"

#: ../../whatsnew/2.4.rst:423
msgid ""
"*cwd* specifies the working directory in which the subprocess will be "
"executed (defaulting to whatever the parent's working directory is)."
msgstr ""
"*cwd* はサブプロセスを実行する作業ディレクトリを指定します (デフォルトは親の"
"作業ディレクトリです)。"

#: ../../whatsnew/2.4.rst:426
msgid "*env* is a dictionary specifying environment variables."
msgstr "*env* は環境変数を指定する辞書です。"

#: ../../whatsnew/2.4.rst:428
msgid ""
"*preexec_fn* is a function that gets called before the child is started."
msgstr "*preexec_fn* は子が開始する前に呼び出される関数です。"

#: ../../whatsnew/2.4.rst:430
msgid ""
"*universal_newlines* opens the child's input and output using Python's :term:"
"`universal newlines` feature."
msgstr ""
"*universal_newlines* で、子の入出力を、Python の :term:`universal newlines` "
"機能で開きます。"

#: ../../whatsnew/2.4.rst:433
msgid ""
"Once you've created the :class:`Popen` instance,  you can call its :meth:"
"`wait` method to pause until the subprocess has exited, :meth:`poll` to "
"check if it's exited without pausing,  or ``communicate(data)`` to send the "
"string *data* to the subprocess's standard input.   ``communicate(data)``  "
"then reads any data that the subprocess has sent to its standard output  or "
"standard error, returning a tuple ``(stdout_data, stderr_data)``."
msgstr ""
":class:`Popen` インスタンスを作ってしまえば、あとはサブプロセスが終了するまで"
"停止するために :meth:`wait` メソッド呼び出すことが出来、停止することなく終了"
"をチェックするのに :meth:`poll` メソッドを呼び出すことが出来、あるいは "
"``communicate(data)`` を呼び出して、子の標準入力に *data* を送信することが出"
"来ます。 ``communicate(data)`` はサブプロセスが送信する標準出力と標準エラー出"
"力を読み込み、タプル ``(stdout_data, stderr_data)`` を返します。"

#: ../../whatsnew/2.4.rst:440
msgid ""
":func:`call` is a shortcut that passes its arguments along to the :class:"
"`Popen` constructor, waits for the command to complete, and returns the "
"status code of the subprocess.  It can serve as a safer analog to :func:`os."
"system`::"
msgstr ""
":func:`call` は :class:`Popen` コンストラクタにその引数を流し込むショートカッ"
"トで、コマンドが終了するまで待ち、サブプロセスの終了コードを返します。これ"
"は :func:`os.system` に対する安全な置き換えとなりえます::"

#: ../../whatsnew/2.4.rst:444
msgid ""
"sts = subprocess.call(['dpkg', '-i', '/tmp/new-package.deb'])\n"
"if sts == 0:\n"
"    # Success\n"
"    ...\n"
"else:\n"
"    # dpkg returned an error\n"
"    ..."
msgstr ""

#: ../../whatsnew/2.4.rst:452
msgid ""
"The command is invoked without use of the shell.  If you really do want to  "
"use the shell, you can add ``shell=True`` as a keyword argument and provide "
"a string instead of a sequence::"
msgstr ""
"コマンドはシェルを使うことなく呼び出されます。もしシェルを本当に使いたいので"
"あればキーワード引数として ``shell=True`` を与えた上でシーケンスの代わりに文"
"字列を与えることが出来ます::"

#: ../../whatsnew/2.4.rst:456
msgid "sts = subprocess.call('dpkg -i /tmp/new-package.deb', shell=True)"
msgstr ""

#: ../../whatsnew/2.4.rst:458
msgid ""
"The PEP takes various examples of shell and Python code and shows how they'd "
"be translated into Python code that uses :mod:`subprocess`.  Reading this "
"section of the PEP is highly recommended."
msgstr ""
"PEP にはシェルと Python コードの様々な例が採られていて、シェルスクリプトをい"
"かにして :mod:`subprocess` を用いて Python コードに変換するかを示しています。"
"PEP のこのセクションを読むことを強くお勧めします。"

#: ../../whatsnew/2.4.rst:465
msgid ":pep:`324` - subprocess - New process module"
msgstr ":pep:`324` - subprocess - プロセスのための新たなモジュール"

#: ../../whatsnew/2.4.rst:466
msgid ""
"Written and implemented by Peter Åstrand, with assistance from Fredrik Lundh "
"and others."
msgstr ""
"Fredrik Lundh 他によるサポートによって、Peter Åstrand により PEP 著と実装が行"
"われました。"

#: ../../whatsnew/2.4.rst:473
msgid "PEP 327: Decimal Data Type"
msgstr "PEP 327: Decimal データ型"

#: ../../whatsnew/2.4.rst:475
msgid ""
"Python has always supported floating-point (FP) numbers, based on the "
"underlying C :c:expr:`double` type, as a data type.  However, while most "
"programming languages provide a floating-point type, many people (even "
"programmers) are unaware that floating-point numbers don't represent certain "
"decimal fractions accurately.  The new :class:`Decimal` type can represent "
"these fractions accurately, up to a user-specified precision limit."
msgstr ""

#: ../../whatsnew/2.4.rst:484
msgid "Why is Decimal needed?"
msgstr "なぜ Decimal が必要なのか?"

#: ../../whatsnew/2.4.rst:486
msgid ""
"The limitations arise from the representation used for floating-point "
"numbers. FP numbers are made up of three components:"
msgstr ""
"浮動小数点数が使う表現方法に起因する制約があります。浮動小数点数は 3 つの構成"
"要素から成ります:"

#: ../../whatsnew/2.4.rst:489
msgid "The sign, which is positive or negative."
msgstr "符号(sign)。正または負。"

#: ../../whatsnew/2.4.rst:491
msgid ""
"The mantissa, which is a single-digit binary number   followed by a "
"fractional part.  For example, ``1.01`` in base-2 notation is ``1 + 0/2 + "
"1/4``, or 1.25 in decimal notation."
msgstr ""
"仮数部(mantissa)。一桁の 2 進値に端数部が続きます。例えば 2 進数で ``1.01`` "
"は ``1 + 0/2 + 1/4`` で 10 進表記で 1.25 です。"

#: ../../whatsnew/2.4.rst:495
msgid ""
"The exponent, which tells where the decimal point is located in the number "
"represented."
msgstr "指数部(exponent)。小数点がその数値のどこに位置するかを表します。"

#: ../../whatsnew/2.4.rst:498
msgid ""
"For example, the number 1.25 has positive sign, a mantissa value of 1.01 (in "
"binary), and an exponent of 0 (the decimal point doesn't need to be "
"shifted). The number 5 has the same sign and mantissa, but the exponent is 2 "
"because the mantissa is multiplied by 4 (2 to the power of the exponent 2); "
"1.25 \\* 4 equals 5."
msgstr ""
"例えば 1.25 は、正の符号を持ち、仮数部の値は (2 進数で) 1.01 で、指数部は 0 "
"です (小数点は移動の必要がありません)。5 は同じ符号と仮数部を持ち、指数部は、"
"仮数部が 4 倍なので 2 (2 を底とする 2 の 冪乗) です; 1.25 \\* 4 は 5 です。"

#: ../../whatsnew/2.4.rst:504
msgid ""
"Modern systems usually provide floating-point support that conforms to a "
"standard called IEEE 754.  C's :c:expr:`double` type is usually implemented "
"as a 64-bit IEEE 754 number, which uses 52 bits of space for the mantissa.  "
"This means that numbers can only be specified to 52 bits of precision.  If "
"you're trying to represent numbers whose expansion repeats endlessly, the "
"expansion is cut off after 52 bits. Unfortunately, most software needs to "
"produce output in base 10, and common fractions in base 10 are often "
"repeating decimals in binary. For example, 1.1 decimal is binary "
"``1.0001100110011 ...``; .1 = 1/16 + 1/32 + 1/256 plus an infinite number of "
"additional terms.  IEEE 754 has to chop off that infinitely repeated decimal "
"after 52 digits, so the representation is slightly inaccurate."
msgstr ""

#: ../../whatsnew/2.4.rst:516
msgid "Sometimes you can see this inaccuracy when the number is printed::"
msgstr "ときどきあなたはこの不正確さを、数値を表示する際に目にするでしょう::"

#: ../../whatsnew/2.4.rst:518
msgid ""
">>> 1.1\n"
"1.1000000000000001"
msgstr ""

#: ../../whatsnew/2.4.rst:521
msgid ""
"The inaccuracy isn't always visible when you print the number because the FP-"
"to-decimal-string conversion is provided by the C library, and most C "
"libraries try to produce sensible output.  Even if it's not displayed, "
"however, the inaccuracy is still there and subsequent operations can magnify "
"the error."
msgstr ""
"この不正確さは数値を表示する際にいつでも目に見えるわけではありません。浮動小"
"数点数から文字列への変換が C ライブラリによって提供されていて、C ライブラリの"
"ほとんどが賢明な出力を生成しようと頑張っているからです。それが表示されないに"
"しても、不正確さはそれでも存在していて、後続の計算への誤差が大きくなりえま"
"す。"

#: ../../whatsnew/2.4.rst:526
msgid ""
"For many applications this doesn't matter.  If I'm plotting points and "
"displaying them on my monitor, the difference between 1.1 and "
"1.1000000000000001 is too small to be visible.  Reports often limit output "
"to a certain number of decimal places, and if you round the number to two or "
"three or even eight decimal places, the error is never apparent.  However, "
"for applications where it does matter,  it's a lot of work to implement your "
"own custom arithmetic routines."
msgstr ""
"多くのアプリケーションではこれは重要ではありません。モニタにプロットして表示"
"するのに 1.1 と 1.1000000000000001 の差は小さすぎて見えません。大抵は出力を一"
"定の桁位置までに制限して出力するものですし、2 やら 3 やら 8 桁などの位置で丸"
"めたりすれば誤差は決して露わにはなりません。ですがそれが重要なアプリケーショ"
"ンにとっては、あなた自身のカスタム数学ルーチンのための実装作業は膨大になりま"
"す。"

#: ../../whatsnew/2.4.rst:534
msgid "Hence, the :class:`Decimal` type was created."
msgstr "こうして :class:`Decimal` 型が作られました。"

#: ../../whatsnew/2.4.rst:538
msgid "The :class:`Decimal` type"
msgstr ":class:`Decimal` 型"

#: ../../whatsnew/2.4.rst:540
msgid ""
"A new module, :mod:`decimal`, was added to Python's standard library.  It "
"contains two classes, :class:`Decimal` and :class:`Context`.  :class:"
"`Decimal` instances represent numbers, and :class:`Context` instances are "
"used to wrap up various settings such as the precision and default rounding "
"mode."
msgstr ""
"新しいモジュール :mod:`decimal` が Python 標準ライブラリに追加されました。こ"
"れには 2 つのクラス :class:`Decimal`, :class:`Context` を含みます。 :class:"
"`Decimal` インスタンスは数値を表現し、 :class:`Context` インスタンスは、精度"
"やデフォルトの丸めモードなどのさまざまな設定をまとめるのに使われます。"

#: ../../whatsnew/2.4.rst:545
msgid ""
":class:`Decimal` instances are immutable, like regular Python integers and "
"FP numbers; once it's been created, you can't change the value an instance "
"represents.  :class:`Decimal` instances can be created from integers or "
"strings::"
msgstr ""
":class:`Decimal` のインスタンスは普通の Python 整数や浮動小数点数のように :"
"term:`immutable` です。 :class:`Decimal` のインスタンスは整数や文字列から構築"
"出来ます::"

#: ../../whatsnew/2.4.rst:550
msgid ""
">>> import decimal\n"
">>> decimal.Decimal(1972)\n"
"Decimal(\"1972\")\n"
">>> decimal.Decimal(\"1.1\")\n"
"Decimal(\"1.1\")"
msgstr ""

#: ../../whatsnew/2.4.rst:556
msgid ""
"You can also provide tuples containing the sign, the mantissa represented  "
"as a tuple of decimal digits, and the exponent::"
msgstr ""
"符号(sign)、10進数値のタプルで表した仮数部(mantissa)、指数部(exponent)を含ん"
"だタプルを渡すことも出来ます::"

#: ../../whatsnew/2.4.rst:559
msgid ""
">>> decimal.Decimal((1, (1, 4, 7, 5), -2))\n"
"Decimal(\"-14.75\")"
msgstr ""

#: ../../whatsnew/2.4.rst:562
msgid ""
"Cautionary note: the sign bit is a Boolean value, so 0 is positive and 1 is "
"negative."
msgstr "注意: 符号ビットは負符号の有無なので、 0 が正、1  が負です。"

#: ../../whatsnew/2.4.rst:565
msgid ""
"Converting from floating-point numbers poses a bit of a problem: should the "
"FP number representing 1.1 turn into the decimal number for exactly 1.1, or "
"for 1.1 plus whatever inaccuracies are introduced? The decision was to dodge "
"the issue and leave such a conversion out of the API.  Instead, you should "
"convert the floating-point number into a string using the desired precision "
"and pass the string to the :class:`Decimal` constructor::"
msgstr ""
"浮動小数点数からの変換は少々問題です: 1.1 を表現する浮動小数点数は 10 進数値"
"の正確な 1.1 に変換すべきでしょうか、それとも 1.1 が持つどんな不正確さもその"
"まま持ち込むべきでしょうか? 決定は、問題をはぐらかして、その種の変換を API の"
"範疇外とする、というものでした。代わりにあなたは浮動小数点数を望みの精度で文"
"字列に変換して、その文字列を :class:`Decimal` コンストラクタに渡す必要があり"
"ます::"

#: ../../whatsnew/2.4.rst:572
msgid ""
">>> f = 1.1\n"
">>> decimal.Decimal(str(f))\n"
"Decimal(\"1.1\")\n"
">>> decimal.Decimal('%.12f' % f)\n"
"Decimal(\"1.100000000000\")"
msgstr ""

#: ../../whatsnew/2.4.rst:578
msgid ""
"Once you have :class:`Decimal` instances, you can perform the usual "
"mathematical operations on them.  One limitation: exponentiation requires an "
"integer exponent::"
msgstr ""
"いったん :class:`Decimal` を手にしてしまえばあとは普通の数学演算が使えます。"
"制約の一つ: べき乗には整数の指数しか使えません::"

#: ../../whatsnew/2.4.rst:582
msgid ""
">>> a = decimal.Decimal('35.72')\n"
">>> b = decimal.Decimal('1.73')\n"
">>> a+b\n"
"Decimal(\"37.45\")\n"
">>> a-b\n"
"Decimal(\"33.99\")\n"
">>> a*b\n"
"Decimal(\"61.7956\")\n"
">>> a/b\n"
"Decimal(\"20.64739884393063583815028902\")\n"
">>> a ** 2\n"
"Decimal(\"1275.9184\")\n"
">>> a**b\n"
"Traceback (most recent call last):\n"
"  ...\n"
"decimal.InvalidOperation: x ** (non-integer)"
msgstr ""

#: ../../whatsnew/2.4.rst:599
msgid ""
"You can combine :class:`Decimal` instances with integers, but not with "
"floating-point numbers::"
msgstr ""
":class:`Decimal` インスタンスと整数は混ぜて使えますが、浮動小数点数とは出来ま"
"せん::"

#: ../../whatsnew/2.4.rst:602
msgid ""
">>> a + 4\n"
"Decimal(\"39.72\")\n"
">>> a + 4.5\n"
"Traceback (most recent call last):\n"
"  ...\n"
"TypeError: You can interact Decimal only with int, long or Decimal data "
"types.\n"
">>>"
msgstr ""

#: ../../whatsnew/2.4.rst:610
msgid ""
":class:`Decimal` numbers can be used with the :mod:`math` and :mod:`cmath` "
"modules, but note that they'll be immediately converted to  floating-point "
"numbers before the operation is performed, resulting in a possible loss of "
"precision and accuracy.  You'll also get back a regular floating-point "
"number and not a :class:`Decimal`.   ::"
msgstr ""
":class:`Decimal` 数を :mod:`math`, :mod:`cmath` モジュールで使うことは出来ま"
"すが、演算実行前にその場で浮動小数点数に変換されて、結果精度と正確性を失う可"
"能性があります。戻り値は普通の浮動小数点数であって :class:`Decimal` ではあり"
"ません::"

#: ../../whatsnew/2.4.rst:616
msgid ""
">>> import math, cmath\n"
">>> d = decimal.Decimal('123456789012.345')\n"
">>> math.sqrt(d)\n"
"351364.18288201344\n"
">>> cmath.sqrt(-d)\n"
"351364.18288201344j"
msgstr ""

#: ../../whatsnew/2.4.rst:623
msgid ""
":class:`Decimal` instances have a :meth:`sqrt` method that returns a :class:"
"`Decimal`, but if you need other things such as trigonometric functions "
"you'll have to implement them. ::"
msgstr ""
":class:`Decimal` インスタンスは :class:`Decimal` インスタンスを返す :meth:"
"`sqrt` メソッドを持っていますが、三角関数のようななにかほかのことが必要な場合"
"は、それらを実装する必要があるでしょう。::"

#: ../../whatsnew/2.4.rst:627
msgid ""
">>> d.sqrt()\n"
"Decimal(\"351364.1828820134592177245001\")"
msgstr ""

#: ../../whatsnew/2.4.rst:632
msgid "The :class:`Context` type"
msgstr ":class:`Context` 型"

#: ../../whatsnew/2.4.rst:634
msgid ""
"Instances of the :class:`Context` class encapsulate several settings for "
"decimal operations:"
msgstr ""
":class:`Context` クラスのインスタンスは decimal 演算についてのいくつかの設定"
"をカプセル化しています:"

#: ../../whatsnew/2.4.rst:637
msgid ":attr:`prec` is the precision, the number of decimal places."
msgstr ":attr:`prec` は精度で、小数桁数です。"

#: ../../whatsnew/2.4.rst:639
msgid ""
":attr:`rounding` specifies the rounding mode.  The :mod:`decimal` module has "
"constants for the various possibilities: :const:`ROUND_DOWN`, :const:"
"`ROUND_CEILING`,  :const:`ROUND_HALF_EVEN`, and various others."
msgstr ""
":attr:`rounding` は丸めのモードを指定します。 :mod:`decimal` にはこの値に渡せ"
"る定数が定義されています: :const:`ROUND_DOWN`, :const:`ROUND_CEILING`, :"
"const:`ROUND_HALF_EVEN`, それに色々。"

#: ../../whatsnew/2.4.rst:643
msgid ""
":attr:`traps` is a dictionary specifying what happens on encountering "
"certain error conditions: either  an exception is raised or  a value is "
"returned.  Some examples of error conditions are division by zero, loss of "
"precision, and overflow."
msgstr ""
":attr:`traps` は特定のエラー状態に出会った場合に何が起こるべきかを指定する辞"
"書です: 例外を発生させるか値を返すかどちらかです。いくつかのエラー状態の例と"
"しては、ゼロ除算、精度損失、オーバーフローがあります。"

#: ../../whatsnew/2.4.rst:648
msgid ""
"There's a thread-local default context available by calling :func:"
"`getcontext`; you can change the properties of this context to alter the "
"default precision, rounding, or trap handling.  The following example shows "
"the effect of changing the precision of the default context::"
msgstr ""
"スレッドローカルなデフォルトのコンテキストを、 :func:`getcontext` を呼び出す"
"ことで利用出来ます; デフォルトの精度、丸めモード、トラップ処理に代えてこのコ"
"ンテキストのプロパティを変更出来ます。続く例はデフォルトコンテキストの精度を"
"変更する効果についてお見せします::"

#: ../../whatsnew/2.4.rst:653
msgid ""
">>> decimal.getcontext().prec\n"
"28\n"
">>> decimal.Decimal(1) / decimal.Decimal(7)\n"
"Decimal(\"0.1428571428571428571428571429\")\n"
">>> decimal.getcontext().prec = 9\n"
">>> decimal.Decimal(1) / decimal.Decimal(7)\n"
"Decimal(\"0.142857143\")"
msgstr ""

#: ../../whatsnew/2.4.rst:661
msgid ""
"The default action for error conditions is selectable; the module can either "
"return a special value such as infinity or not-a-number, or exceptions can "
"be raised::"
msgstr ""
"エラー状態の場合のデフォルトアクションを選択出来ます; モジュールは無限大"
"(infinity)あるいは非数(not-a-number: NaN)を返すか、例外を投げるかです::"

#: ../../whatsnew/2.4.rst:665
msgid ""
">>> decimal.Decimal(1) / decimal.Decimal(0)\n"
"Traceback (most recent call last):\n"
"  ...\n"
"decimal.DivisionByZero: x / 0\n"
">>> decimal.getcontext().traps[decimal.DivisionByZero] = False\n"
">>> decimal.Decimal(1) / decimal.Decimal(0)\n"
"Decimal(\"Infinity\")\n"
">>>"
msgstr ""

#: ../../whatsnew/2.4.rst:674
msgid ""
"The :class:`Context` instance also has various methods for formatting  "
"numbers such as :meth:`to_eng_string` and :meth:`to_sci_string`."
msgstr ""
":class:`Context` インスタンスは :meth:`to_eng_string`, :meth:`to_sci_string` "
"のような、数値の書式化のための色々なメソッドも持っています。"

#: ../../whatsnew/2.4.rst:677
msgid ""
"For more information, see the documentation for the :mod:`decimal` module, "
"which includes a quick-start tutorial and a reference."
msgstr ""
"さらに詳しく知りたければ :mod:`decimal` モジュールのドキュメントを読んで下さ"
"い。これには簡単に始められるチュートリアルとリファレンスが入っています。"

#: ../../whatsnew/2.4.rst:683
msgid ":pep:`327` - Decimal Data Type"
msgstr ":pep:`327` - Decimal データ型"

#: ../../whatsnew/2.4.rst:684
msgid ""
"Written by Facundo Batista and implemented by Facundo Batista, Eric Price, "
"Raymond Hettinger, Aahz, and Tim Peters."
msgstr ""
"Facundo Batista によって著され、Facundo Batista, Eric Price, Raymond "
"Hettinger, Aahz,  Tim Peters らによって実装されました。"

#: ../../whatsnew/2.4.rst:687
msgid ""
"`http://www.lahey.com/float.htm <https://web.archive.org/web/20230604072523/"
"http://www.lahey.com/float.htm>`__"
msgstr ""

#: ../../whatsnew/2.4.rst:688
msgid ""
"The article uses Fortran code to illustrate many of the problems that "
"floating-point inaccuracy can cause."
msgstr ""
"この記事は浮動小数点数の不正確さが起こりうるたくさんの問題について、Fortran "
"コードを使って解説しています。"

#: ../../whatsnew/2.4.rst:691
msgid "https://speleotrove.com/decimal/"
msgstr ""

#: ../../whatsnew/2.4.rst:692
msgid ""
"A description of a decimal-based representation.  This representation is "
"being proposed as a standard, and underlies the new Python decimal type.  "
"Much of this material was written by Mike Cowlishaw, designer of the Rexx "
"language."
msgstr ""
"10 進数ベースの表現についての記述です(訳注: decimal-based は小数ベースとも "
"10 進数ベースとも取れるのですが、後者にしておきました)。この表現方法は標準と"
"して提案されていて、この Python の decimal 型の基礎になっています。この題材の"
"多くが Rexx 言語設計者である Mike Cowlishaw によって著されました。"

#: ../../whatsnew/2.4.rst:700
msgid "PEP 328: Multi-line Imports"
msgstr "PEP 328: マルチラインインポート"

#: ../../whatsnew/2.4.rst:702
msgid ""
"One language change is a small syntactic tweak aimed at making it easier to "
"import many names from a module.  In a ``from module import names`` "
"statement, *names* is a sequence of names separated by commas.  If the "
"sequence is  very long, you can either write multiple imports from the same "
"module, or you can use backslashes to escape the line endings like this::"
msgstr ""
"言語の変更の一つは小さな文法的な微調整で、モジュールからたくさんの名前をイン"
"ポートするのを簡単にするためのものです。 ``from module import names`` 文にお"
"いて、 *names* はカンマ区切りのシーケンスです。シーケンスがとても長くなった場"
"合、同じモジュールからのインポート文を何度も書くか、行末をバックスラッシュで"
"エスケープするかするでしょう、このように::"

#: ../../whatsnew/2.4.rst:708
msgid ""
"from SimpleXMLRPCServer import SimpleXMLRPCServer,\\\n"
"            SimpleXMLRPCRequestHandler,\\\n"
"            CGIXMLRPCRequestHandler,\\\n"
"            resolve_dotted_attribute"
msgstr ""

#: ../../whatsnew/2.4.rst:713
msgid ""
"The syntactic change in Python 2.4 simply allows putting the names within "
"parentheses.  Python ignores newlines within a parenthesized expression, so "
"the backslashes are no longer needed::"
msgstr ""
"Python 2.4 での文法的な変更は、単純に names を丸括弧で囲んでも良い、とするだ"
"けのものです。Python は丸括弧内の改行を無視しますので、バックスラッシュはもう"
"必要ありません::"

#: ../../whatsnew/2.4.rst:717
msgid ""
"from SimpleXMLRPCServer import (SimpleXMLRPCServer,\n"
"                                SimpleXMLRPCRequestHandler,\n"
"                                CGIXMLRPCRequestHandler,\n"
"                                resolve_dotted_attribute)"
msgstr ""

#: ../../whatsnew/2.4.rst:722
msgid ""
"The PEP also proposes that all :keyword:`import` statements be absolute "
"imports, with a leading ``.`` character to indicate a relative import.  This "
"part of the PEP was not implemented for Python 2.4, but was completed for "
"Python 2.5."
msgstr ""
"その PEP は、全ての :keyword:`import` 文が絶対インポートであること、相対イン"
"ポートであることを示すには ``.`` 文字で開始すること、の提案もしています。PEP "
"のこの部分は Python 2.4 では実装されていませんが、 Python 2.5 向けには完了し"
"ています。"

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

#: ../../whatsnew/2.4.rst:730
msgid "Written by Aahz.  Multi-line imports were implemented by Dima Dorfman."
msgstr "Aahz 著.  Multi-line imports は Dima Dorfman により実装。"

#: ../../whatsnew/2.4.rst:736
msgid "PEP 331: Locale-Independent Float/String Conversions"
msgstr "PEP 331: Locale に依存しない Float/String 変換"

#: ../../whatsnew/2.4.rst:738
msgid ""
"The :mod:`locale` modules lets Python software select various conversions "
"and display conventions that are localized to a particular country or "
"language. However, the module was careful to not change the numeric locale "
"because various functions in Python's implementation required that the "
"numeric locale remain set to the ``'C'`` locale.  Often this was because the "
"code was using the C library's :c:func:`atof` function."
msgstr ""
":mod:`locale` モジュールにより、Python ソフトウェアは特定の国や言語の地域化を"
"する色々な変換や表示の変換を選択出来ます。ところがこのモジュールは、数値ロ"
"ケールを変更しないように気を配らなければなりませんでした。というのも Python "
"内の色んな関数実装が、数値ロケールが ``'C'`` ロケールにセットされたままである"
"ことを必要としていたからです。しばしばこれは、コードが C ライブラリの :c:"
"func:`atof` 関数を使っていることに原因がありました。"

#: ../../whatsnew/2.4.rst:745
msgid ""
"Not setting the numeric locale caused trouble for extensions that used third-"
"party C libraries, however, because they wouldn't have the correct locale "
"set. The motivating example was GTK+, whose user interface widgets weren't "
"displaying numbers in the current locale."
msgstr ""

#: ../../whatsnew/2.4.rst:750
msgid ""
"The solution described in the PEP is to add three new functions to the "
"Python API that perform ASCII-only conversions, ignoring the locale setting:"
msgstr ""
"この PEP に記述された解法は、ロケール設定を無視して ASCII のみの変換を実施す"
"る 3 つの新しい Python API 関数を追加することです:"

#: ../../whatsnew/2.4.rst:753
msgid ""
"``PyOS_ascii_strtod(str, ptr)``  and ``PyOS_ascii_atof(str, ptr)`` both "
"convert a string to a C :c:expr:`double`."
msgstr ""

#: ../../whatsnew/2.4.rst:756
msgid ""
"``PyOS_ascii_formatd(buffer, buf_len, format, d)`` converts a :c:expr:"
"`double` to an ASCII string."
msgstr ""

#: ../../whatsnew/2.4.rst:759
msgid ""
"The code for these functions came from the GLib library (`https://developer-"
"old.gnome.org/glib/2.26/ <http://web.archive.org/web/20210306104320/https://"
"developer.gnome.org/glib/2.26/>`__), whose developers kindly relicensed the "
"relevant functions and donated them to the Python Software Foundation.  The :"
"mod:`locale` module  can now change the numeric locale, letting extensions "
"such as GTK+  produce the correct results."
msgstr ""

#: ../../whatsnew/2.4.rst:768
msgid ":pep:`331` - Locale-Independent Float/String Conversions"
msgstr ":pep:`331` - Locale に依存しない Float/String 変換"

#: ../../whatsnew/2.4.rst:769
msgid "Written by Christian R. Reis, and implemented by Gustavo Carneiro."
msgstr "Christian R. Reis 著, 実装 Gustavo Carneiro."

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

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

#: ../../whatsnew/2.4.rst:779
msgid "Decorators for functions and methods were added (:pep:`318`)."
msgstr "関数とメソッドのためのデコレータが追加されました。 (:pep:`318`)."

#: ../../whatsnew/2.4.rst:781
msgid ""
"Built-in :func:`set` and :func:`frozenset` types were  added (:pep:`218`). "
"Other new built-ins include the ``reversed(seq)`` function (:pep:`322`)."
msgstr ""
"ビルトインの :func:`set` 型と :func:`frozenset` 型が追加されました (:pep:"
"`218`)。ほか新たなビルトイン関数 ``reversed(seq)`` 関数が追加されました (:"
"pep:`322`)。"

#: ../../whatsnew/2.4.rst:784
msgid "Generator expressions were added (:pep:`289`)."
msgstr "ジェネレータ式が追加されました (:pep:`289`)."

#: ../../whatsnew/2.4.rst:786
msgid ""
"Certain numeric expressions no longer return values restricted to 32 or 64 "
"bits (:pep:`237`)."
msgstr ""
"いくらかの数値式は、もう 32 ビットや 64 ビットに制限されません (:pep:`237`)."

#: ../../whatsnew/2.4.rst:789
msgid ""
"You can now put parentheses around the list of names in a ``from module "
"import names`` statement (:pep:`328`)."
msgstr ""
"``from module import names`` ステートメントにおいて、 *names* を括弧で囲むこ"
"とが出来るようになりました (:pep:`328`)."

#: ../../whatsnew/2.4.rst:792
msgid ""
"The :meth:`dict.update` method now accepts the same argument forms as the :"
"class:`dict` constructor.  This includes any mapping, any iterable of key/"
"value pairs, and keyword arguments. (Contributed by Raymond Hettinger.)"
msgstr ""
":meth:`dict.update` メソッドが :class:`dict` コンストラクタと同じ形式の引数を"
"取れるようになりました。これには任意のマッピング、キー/値ペアのイテラブルと"
"キーワード引数を含みます。 (Contributed by Raymond Hettinger.)"

#: ../../whatsnew/2.4.rst:796
msgid ""
"The string methods :meth:`ljust`, :meth:`rjust`, and :meth:`center` now take "
"an optional argument for specifying a fill character other than a space. "
"(Contributed by Raymond Hettinger.)"
msgstr ""
"文字列の :meth:`ljust`, :meth:`rjust`, :meth:`center` メソッドで空白以外の埋"
"め文字を省略可能引数で指定出来るようになりました。 (Contributed by Raymond "
"Hettinger.)"

#: ../../whatsnew/2.4.rst:800
msgid ""
"Strings also gained an :meth:`rsplit` method that works like the :meth:"
"`split` method but splits from the end of the string.   (Contributed by Sean "
"Reifschneider.) ::"
msgstr ""
"ほかに、文字列には :meth:`rsplit` メソッドも追加されています。これは :meth:"
"`split` メソッドと似た動きをしますが、後ろから順に分割します (Contributed by "
"Sean Reifschneider.) ::"

#: ../../whatsnew/2.4.rst:804
msgid ""
">>> 'www.python.org'.split('.', 1)\n"
"['www', 'python.org']\n"
"'www.python.org'.rsplit('.', 1)\n"
"['www.python', 'org']"
msgstr ""

#: ../../whatsnew/2.4.rst:809
msgid ""
"Three keyword parameters, *cmp*, *key*, and *reverse*, were added to the :"
"meth:`sort` method of lists. These parameters make some common usages of :"
"meth:`sort` simpler. All of these parameters are optional."
msgstr ""
"リストの :meth:`sort` メソッドに 3 つのキーワード引数 *cmp*, *key*, "
"*reverse* が追加されています。これらパラメータは :meth:`sort` のある種の用法"
"を単純にします。これらは全て省略可能です。"

#: ../../whatsnew/2.4.rst:813
msgid ""
"For the *cmp* parameter, the value should be a comparison function that "
"takes two parameters and returns -1, 0, or +1 depending on how the "
"parameters compare. This function will then be used to sort the list.  "
"Previously this was the only parameter that could be provided to :meth:"
"`sort`."
msgstr ""
"*cmp* パラメータには比較関数を渡します。これは 2 つのパラメータを取り、パラ"
"メータの比較結果に応じて -1, 0, +1 のいずれかを返します。この関数はリストの"
"ソートに使われます。これまでの :meth:`sort` に唯一許されていたのがこの *cmp* "
"パラメータでした。"

#: ../../whatsnew/2.4.rst:818
msgid ""
"*key* should be a single-parameter function that takes a list element and "
"returns a comparison key for the element.  The list is then sorted using the "
"comparison keys.  The following example sorts a list case-insensitively::"
msgstr ""
"*key* には単一パラメータ関数を渡します。これはリスト要素を受け取り、要素の比"
"較キーを返す関数です。リストはその比較キーを使ってソートされます。続く例はリ"
"ストを大文字小文字区別なく並び替えます::"

#: ../../whatsnew/2.4.rst:822
msgid ""
">>> L = ['A', 'b', 'c', 'D']\n"
">>> L.sort()                 # Case-sensitive sort\n"
">>> L\n"
"['A', 'D', 'b', 'c']\n"
">>> # Using 'key' parameter to sort list\n"
">>> L.sort(key=lambda x: x.lower())\n"
">>> L\n"
"['A', 'b', 'c', 'D']\n"
">>> # Old-fashioned way\n"
">>> L.sort(cmp=lambda x,y: cmp(x.lower(), y.lower()))\n"
">>> L\n"
"['A', 'b', 'c', 'D']"
msgstr ""

#: ../../whatsnew/2.4.rst:835
msgid ""
"The last example, which uses the *cmp* parameter, is the old way to perform "
"a case-insensitive sort.  It works but is slower than using a *key* "
"parameter. Using *key* calls :meth:`lower` method once for each element in "
"the list while using *cmp* will call it twice for each comparison, so using "
"*key* saves on invocations of the :meth:`lower` method."
msgstr ""
"例の最後のものは *cmp* パラメータを使っています。これが大文字小文字区別のない"
"並び替えの昔ながらの方法です。むろん動きます。が、 *key* パラメータでのやり方"
"より遅いです。 *cmp* では :meth:`lower` メソッド呼び出しが比較ごとなので要素"
"ごとに 2 回呼び出すことになりますが、 *key* だと呼び出しはそれぞれの要素ごと"
"に :meth:`lower` 呼び出しを一回だけで済ませられます。"

#: ../../whatsnew/2.4.rst:841
msgid ""
"For simple key functions and comparison functions, it is often possible to "
"avoid a :keyword:`lambda` expression by using an unbound method instead.  "
"For example, the above case-insensitive sort is best written as::"
msgstr ""
"単純なキー関数や比較関数には、しばしば :keyword:`lambda` 関数を避けて非束縛メ"
"ソッドを使えます。例えば上記の大文字小文字によらない並べ替えはこのように書く"
"のが最善です::"

#: ../../whatsnew/2.4.rst:845
msgid ""
">>> L.sort(key=str.lower)\n"
">>> L\n"
"['A', 'b', 'c', 'D']"
msgstr ""

#: ../../whatsnew/2.4.rst:849
msgid ""
"Finally, the *reverse* parameter takes a Boolean value.  If the value is "
"true, the list will be sorted into reverse order. Instead of ``L.sort(); L."
"reverse()``, you can now write ``L.sort(reverse=True)``."
msgstr ""
"最後の *reverse* パラメータはブーリアン値を取ります。真ならばリストは逆順に"
"ソートされます。 ``L.sort(); L.reverse()`` と書く代わりにこれからは ``L."
"sort(reverse=True)`` と書けます。"

#: ../../whatsnew/2.4.rst:853
msgid ""
"The results of sorting are now guaranteed to be stable.  This means that two "
"entries with equal keys will be returned in the same order as they were "
"input. For example, you can sort a list of people by name, and then sort the "
"list by age, resulting in a list sorted by age where people with the same "
"age are in name-sorted order."
msgstr ""
"ソートの結果がステーブル(安定)であることが保障されるようになりました。つまり "
"2 つの要素が同列である場合、入力と同じ順序が保たれます。例えば人物リストを名"
"前でソートしたのちに年齢でソートすると結果は、年齢でソートされていますが同年"
"齢の人物は名前順です。"

#: ../../whatsnew/2.4.rst:859
msgid "(All changes to :meth:`sort` contributed by Raymond Hettinger.)"
msgstr "(All changes to :meth:`sort` contributed by Raymond Hettinger.)"

#: ../../whatsnew/2.4.rst:861
msgid ""
"There is a new built-in function ``sorted(iterable)`` that works like the in-"
"place :meth:`list.sort` method but can be used in expressions.  The "
"differences are:"
msgstr ""
"新たに追加されたビルトイン関数 ``sorted(iterable)`` はインプレイスなメソッ"
"ド :meth:`list.sort` と似た振る舞いをしますが、式内で使えます。違いは:"

#: ../../whatsnew/2.4.rst:865
msgid "the input may be any iterable;"
msgstr "入力には任意のイテラブルを取れます;"

#: ../../whatsnew/2.4.rst:867
msgid "a newly formed copy is sorted, leaving the original intact; and"
msgstr ""
"新しく構築されたコピーをソートし、オリジナルは無傷のままにします; そして"

#: ../../whatsnew/2.4.rst:869
msgid "the expression returns the new sorted copy"
msgstr "式として新しいソート済みコピーを返します。"

#: ../../whatsnew/2.4.rst:873
msgid ""
">>> L = [9,7,8,3,2,4,1,6,5]\n"
">>> [10+i for i in sorted(L)]       # usable in a list comprehension\n"
"[11, 12, 13, 14, 15, 16, 17, 18, 19]\n"
">>> L                               # original is left unchanged\n"
"[9,7,8,3,2,4,1,6,5]\n"
">>> sorted('Monty Python')          # any iterable may be an input\n"
"[' ', 'M', 'P', 'h', 'n', 'n', 'o', 'o', 't', 't', 'y', 'y']\n"
"\n"
">>> # List the contents of a dict sorted by key values\n"
">>> colormap = dict(red=1, blue=2, green=3, black=4, yellow=5)\n"
">>> for k, v in sorted(colormap.iteritems()):\n"
"...     print k, v\n"
"...\n"
"black 4\n"
"blue 2\n"
"green 3\n"
"red 1\n"
"yellow 5"
msgstr ""

#: ../../whatsnew/2.4.rst:892 ../../whatsnew/2.4.rst:920
#: ../../whatsnew/2.4.rst:1213
msgid "(Contributed by Raymond Hettinger.)"
msgstr "(Contributed by Raymond Hettinger.)"

#: ../../whatsnew/2.4.rst:894 ../../whatsnew/2.4.rst:1520
msgid ""
"Integer operations will no longer trigger an :exc:`OverflowWarning`. The :"
"exc:`OverflowWarning` warning will disappear in Python 2.5."
msgstr ""
"整数演算はもはや :exc:`OverflowWarning` は引き起こしません。 :exc:"
"`OverflowWarning` 警告は Python 2.5 で撤廃されます。"

#: ../../whatsnew/2.4.rst:897
msgid ""
"The interpreter gained a new switch, :option:`-m`, that takes a name, "
"searches for the corresponding  module on ``sys.path``, and runs the module "
"as a script. For example,  you can now run the Python profiler with ``python "
"-m profile``. (Contributed by Nick Coghlan.)"
msgstr ""
"インタプリタに新たに :option:`-m` スイッチが加わりました。これは名前を取り、 "
"``sys.path`` にある対応するモジュールを検索し、そしてそのモジュールをスクリプ"
"トとして実行します。たとえば Python プロファイラを ``python -m profile`` で起"
"動することが出来るようになりました。 (Contributed by Nick Coghlan.)"

#: ../../whatsnew/2.4.rst:902
msgid ""
"The ``eval(expr, globals, locals)`` and ``execfile(filename, globals, "
"locals)`` functions and the ``exec`` statement now accept any mapping type "
"for the *locals* parameter.  Previously this had to be a regular Python "
"dictionary.  (Contributed by Raymond Hettinger.)"
msgstr ""
"``eval(expr, globals, locals)`` 関数と ``execfile(filename, globals, "
"locals)`` 関数、 ``exec`` 文が *locals* パラメータに任意のマッピング型を受け"
"取れるようになりました。以前は正規の Python 辞書である必要がありました。 "
"(Contributed by Raymond Hettinger.)"

#: ../../whatsnew/2.4.rst:907
msgid ""
"The :func:`zip` built-in function and :func:`itertools.izip` now return an "
"empty list if called with no arguments. Previously they raised a :exc:"
"`TypeError` exception.  This makes them more suitable for use with variable "
"length argument lists::"
msgstr ""
"ビルトイン関数の :func:`zip` と :func:`itertools.izip` が引数なしで呼ばれた場"
"合に空リストを返すようになりました。以前は :exc:`TypeError` 例外でした。これ"
"により可変引数リストをこなしやすくなります::"

#: ../../whatsnew/2.4.rst:912
msgid ""
">>> def transpose(array):\n"
"...    return zip(*array)\n"
"...\n"
">>> transpose([(1,2,3), (4,5,6)])\n"
"[(1, 4), (2, 5), (3, 6)]\n"
">>> transpose([])\n"
"[]"
msgstr ""

#: ../../whatsnew/2.4.rst:922
msgid ""
"Encountering a failure while importing a module no longer leaves a partially "
"initialized module object in ``sys.modules``.  The incomplete module object "
"left behind would fool further imports of the same module into succeeding, "
"leading to confusing errors.   (Fixed by Tim Peters.)"
msgstr ""

#: ../../whatsnew/2.4.rst:927
msgid ""
":const:`None` is now a constant; code that binds a new value to  the name "
"``None`` is now a syntax error. (Contributed by Raymond Hettinger.)"
msgstr ""
":const:`None` が定数になっています。 ``None`` という名前に新しい値を割り当て"
"ようとするコードは、今では構文エラーになります。 (Contributed by Raymond "
"Hettinger.)"

#: ../../whatsnew/2.4.rst:934
msgid "Optimizations"
msgstr "最適化"

#: ../../whatsnew/2.4.rst:936
msgid ""
"The inner loops for list and tuple slicing were optimized and now run about "
"one-third faster.  The inner loops for dictionaries were also optimized, "
"resulting in performance boosts for :meth:`keys`, :meth:`values`, :meth:"
"`items`, :meth:`iterkeys`, :meth:`itervalues`, and :meth:`iteritems`. "
"(Contributed by Raymond Hettinger.)"
msgstr ""

#: ../../whatsnew/2.4.rst:942
msgid ""
"The machinery for growing and shrinking lists was optimized for speed and "
"for space efficiency.  Appending and popping from lists now runs faster due "
"to more efficient code paths and less frequent use of the underlying system :"
"c:func:`realloc`.  List comprehensions also benefit.   :meth:`list.extend` "
"was also optimized and no longer converts its argument into a temporary list "
"before extending the base list.  (Contributed by Raymond Hettinger.)"
msgstr ""

#: ../../whatsnew/2.4.rst:949
msgid ""
":func:`list`, :func:`tuple`, :func:`map`, :func:`filter`, and :func:`zip` "
"now run several times faster with non-sequence arguments that supply a :meth:"
"`__len__` method.  (Contributed by Raymond Hettinger.)"
msgstr ""

#: ../../whatsnew/2.4.rst:953
msgid ""
"The methods :meth:`list.__getitem__`, :meth:`dict.__getitem__`, and :meth:"
"`dict.__contains__` are now implemented as :class:`method_descriptor` "
"objects rather than :class:`wrapper_descriptor` objects.  This form of  "
"access doubles their performance and makes them more suitable for use as "
"arguments to functionals: ``map(mydict.__getitem__, keylist)``. (Contributed "
"by Raymond Hettinger.)"
msgstr ""

#: ../../whatsnew/2.4.rst:960
msgid ""
"Added a new opcode, ``LIST_APPEND``, that simplifies the generated bytecode "
"for list comprehensions and speeds them up by about a third.  (Contributed "
"by Raymond Hettinger.)"
msgstr ""

#: ../../whatsnew/2.4.rst:964
msgid ""
"The peephole bytecode optimizer has been improved to  produce shorter, "
"faster bytecode; remarkably, the resulting bytecode is  more readable.  "
"(Enhanced by Raymond Hettinger.)"
msgstr ""

#: ../../whatsnew/2.4.rst:968
msgid ""
"String concatenations in statements of the form ``s = s + \"abc\"`` and ``s "
"+= \"abc\"`` are now performed more efficiently in certain circumstances.  "
"This optimization won't be present in other Python implementations such as "
"Jython, so you shouldn't rely on it; using the :meth:`join` method of "
"strings is still recommended when you want to efficiently glue a large "
"number of strings together. (Contributed by Armin Rigo.)"
msgstr ""

#: ../../whatsnew/2.4.rst:975
msgid ""
"The net result of the 2.4 optimizations is that Python 2.4 runs the pystone "
"benchmark around 5% faster than Python 2.3 and 35% faster than Python 2.2. "
"(pystone is not a particularly good benchmark, but it's the most commonly "
"used measurement of Python's performance.  Your own applications may show "
"greater or smaller benefits from Python 2.4.)"
msgstr ""

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

#: ../../whatsnew/2.4.rst:993
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.4.rst:998
msgid ""
"The :mod:`!asyncore` module's :func:`!loop` function now has a *count* "
"parameter that lets you perform a limited number of passes through the "
"polling loop.  The default is still to loop forever."
msgstr ""

#: ../../whatsnew/2.4.rst:1002
msgid ""
"The :mod:`base64` module now has more complete :rfc:`3548` support for "
"Base64, Base32, and Base16 encoding and decoding, including optional case "
"folding and optional alternative alphabets. (Contributed by Barry Warsaw.)"
msgstr ""

#: ../../whatsnew/2.4.rst:1006
msgid ""
"The :mod:`bisect` module now has an underlying C implementation for improved "
"performance. (Contributed by Dmitry Vasiliev.)"
msgstr ""
":mod:`bisect` モジュールが性能改善のために C 実装を使うようになりました。 "
"(Contributed by Dmitry Vasiliev.)"

#: ../../whatsnew/2.4.rst:1009
msgid ""
"The CJKCodecs collections of East Asian codecs, maintained by Hye-Shik "
"Chang, was integrated into 2.4.   The new encodings are:"
msgstr ""
"Hye-Shik Chang によって保守されている東アジアのコーデックの CJKCodecs コレク"
"ションが Python 2.4 に統合されました。新たなエンコーディングは:"

#: ../../whatsnew/2.4.rst:1012
msgid "Chinese (PRC): gb2312, gbk, gb18030, big5hkscs, hz"
msgstr "Chinese (PRC): gb2312, gbk, gb18030, big5hkscs, hz"

#: ../../whatsnew/2.4.rst:1014
msgid "Chinese (ROC): big5, cp950"
msgstr "Chinese (ROC): big5, cp950"

#: ../../whatsnew/2.4.rst:1016
msgid "Japanese: cp932, euc-jis-2004, euc-jp, euc-jisx0213, iso-2022-jp,"
msgstr "Japanese: cp932, euc-jis-2004, euc-jp, euc-jisx0213, iso-2022-jp,"

#: ../../whatsnew/2.4.rst:1017
msgid ""
"iso-2022-jp-1, iso-2022-jp-2, iso-2022-jp-3, iso-2022-jp-ext, iso-2022-"
"jp-2004, shift-jis, shift-jisx0213, shift-jis-2004"
msgstr ""
"iso-2022-jp-1, iso-2022-jp-2, iso-2022-jp-3, iso-2022-jp-ext, iso-2022-"
"jp-2004, shift-jis, shift-jisx0213, shift-jis-2004"

#: ../../whatsnew/2.4.rst:1020
msgid "Korean: cp949, euc-kr, johab, iso-2022-kr"
msgstr "Korean: cp949, euc-kr, johab, iso-2022-kr"

#: ../../whatsnew/2.4.rst:1022
msgid ""
"Some other new encodings were added: HP Roman8,  ISO_8859-11, ISO_8859-16, "
"PCTP-154, and TIS-620."
msgstr ""
"ほか、新たなエンコーディングが追加されています: HP Roman8,  ISO_8859-11, "
"ISO_8859-16, PCTP-154, TIS-620."

#: ../../whatsnew/2.4.rst:1025
msgid ""
"The UTF-8 and UTF-16 codecs now cope better with receiving partial input. "
"Previously the :class:`StreamReader` class would try to read more data, "
"making it impossible to resume decoding from the stream.  The :meth:`read` "
"method will now return as much data as it can and future calls will resume "
"decoding where previous ones left off.  (Implemented by Walter Dörwald.)"
msgstr ""
"UTF-8, UTF-16 コーデックが部分的な入力を受け取った場合により上手に処理するよ"
"うになりました。以前は :class:`StreamReader` クラスは不足データを読み出そうと"
"試みるために、それがストリームからデコード処理を再開することを不可能にしてい"
"ました。 :meth:`read` メソッドは今ではそのとき読めているデータを返し、次の呼"
"び出しで以前の読み残しのデコード処理から再開します。(Implemented by Walter "
"Dörwald.)"

#: ../../whatsnew/2.4.rst:1031
msgid ""
"There is a new :mod:`collections` module for  various specialized collection "
"datatypes.  Currently it contains just one type, :class:`deque`, a double-"
"ended queue that supports efficiently adding and removing elements from "
"either end::"
msgstr ""

#: ../../whatsnew/2.4.rst:1036
msgid ""
">>> from collections import deque\n"
">>> d = deque('ghi')        # make a new deque with three items\n"
">>> d.append('j')           # add a new entry to the right side\n"
">>> d.appendleft('f')       # add a new entry to the left side\n"
">>> d                       # show the representation of the deque\n"
"deque(['f', 'g', 'h', 'i', 'j'])\n"
">>> d.pop()                 # return and remove the rightmost item\n"
"'j'\n"
">>> d.popleft()             # return and remove the leftmost item\n"
"'f'\n"
">>> list(d)                 # list the contents of the deque\n"
"['g', 'h', 'i']\n"
">>> 'h' in d                # search the deque\n"
"True"
msgstr ""

#: ../../whatsnew/2.4.rst:1051
msgid ""
"Several modules, such as the :mod:`Queue` and :mod:`threading` modules, now "
"take advantage of :class:`collections.deque` for improved performance.  "
"(Contributed by Raymond Hettinger.)"
msgstr ""
":mod:`Queue` や :mod:`threading` のようないくつかのモジュールで、 :class:"
"`collections.deque` を生かして性能改善を成し遂げています。 (Contributed by "
"Raymond Hettinger.)"

#: ../../whatsnew/2.4.rst:1055
msgid ""
"The :mod:`ConfigParser <configparser>` classes have been enhanced slightly. "
"The :meth:`~configparser.ConfigParser.read` method now returns a list of the "
"files that were successfully parsed, and the :meth:`~configparser."
"ConfigParser.set` method raises :exc:`TypeError` if passed a *value* "
"argument that isn't a string.   (Contributed by John Belmonte and David "
"Goodger.)"
msgstr ""

#: ../../whatsnew/2.4.rst:1060
msgid ""
"The :mod:`curses` module now supports the ncurses extension :func:"
"`use_default_colors`.  On platforms where the terminal supports "
"transparency, this makes it possible to use a transparent background. "
"(Contributed by Jörg Lehmann.)"
msgstr ""
":mod:`curses` モジュールが ncurses 拡張の :func:`use_default_colors` をサポー"
"トするようになりました。透明性をサポートするターミナルを持つプラットフォーム"
"ならば、このことで透明背景に出来ます。 (Contributed by Jörg Lehmann.)"

#: ../../whatsnew/2.4.rst:1065
msgid ""
"The :mod:`difflib` module now includes an :class:`HtmlDiff` class that "
"creates an HTML table showing a side by side comparison of two versions of a "
"text. (Contributed by Dan Gass.)"
msgstr ""
":mod:`difflib` モジュールに :class:`HtmlDiff` クラスが追加されています。これ"
"は対象テキストをサイドバイサイドで視覚化する HTML テーブルを作ります。 "
"(Contributed by Dan Gass.)"

#: ../../whatsnew/2.4.rst:1069
msgid ""
"The :mod:`email` package was updated to version 3.0,  which dropped various "
"deprecated APIs and removes support for Python versions earlier than 2.3.  "
"The 3.0 version of the package uses a new incremental parser for MIME "
"messages, available in the :mod:`email.FeedParser` module.  The new parser "
"doesn't require reading the entire message into memory, and doesn't raise "
"exceptions if a message is malformed; instead it records any problems in "
"the  :attr:`defect` attribute of the message.  (Developed by Anthony Baxter, "
"Barry Warsaw, Thomas Wouters, and others.)"
msgstr ""
":mod:`email` パッケージがバージョン 3.0 に更新されています。多くの非推奨だっ"
"た API が削除され、Python 2.3 以前のバージョンへのサポートが削除されていま"
"す。パッケージのバージョン 3.0 は MIME メッセージについての漸増的な新パーサを"
"使います。これは :mod:`email.FeedParser` モジュールで利用可能です。この新パー"
"サはメモリ内に全てのメッセージを読み込んでおく必要がなく、メッセージが不正で"
"あっても例外は投げません; 代わりにメッセージの全ての問題についてを :attr:"
"`defect` 属性に記録します。 (Developed by Anthony Baxter, Barry Warsaw, "
"Thomas Wouters, and others.)"

#: ../../whatsnew/2.4.rst:1078
msgid ""
"The :mod:`heapq` module has been converted to C.  The resulting tenfold "
"improvement in speed makes the module suitable for handling high volumes of "
"data.  In addition, the module has two new functions :func:`nlargest` and :"
"func:`nsmallest` that use heaps to find the N largest or smallest values in "
"a dataset without the expense of a full sort.  (Contributed by Raymond "
"Hettinger.)"
msgstr ""
":mod:`heapq` モジュールは C に変換されました。性能改善は 10 倍となり、モ"
"ジュールはより大きなデータを扱うのに相応しいものになりました。加えて、モ"
"ジュールには新しく 2 つの関数が追加されました。それは :func:`nlargest` と :"
"func:`nsmallest` で、データセット内の大きいものから N 番目まで、小さいものか"
"ら N 番目までを、高価な完全なソートを要することなく取り出すのに使います。"
"(Contributed by Raymond Hettinger.)"

#: ../../whatsnew/2.4.rst:1084
msgid ""
"The :mod:`httplib <http>` module now contains constants for HTTP status "
"codes defined in various HTTP-related RFC documents.  Constants have names "
"such as :const:`OK`, :const:`CREATED`, :const:`CONTINUE`, and :const:"
"`MOVED_PERMANENTLY`; use pydoc to get a full list.  (Contributed by Andrew "
"Eland.)"
msgstr ""

#: ../../whatsnew/2.4.rst:1090
msgid ""
"The :mod:`imaplib` module now supports IMAP's THREAD command (contributed by "
"Yves Dionne) and new :meth:`deleteacl` and :meth:`myrights` methods "
"(contributed by Arnaud Mazin)."
msgstr ""
":mod:`imaplib` モジュールが IMAP の THREAD コマンドをサポートするようになりま"
"した。 (contributed by Yves Dionne) また、 :meth:`deleteacl` メソッドと :"
"meth:`myrights` メソッドが追加されました。 (contributed by Arnaud Mazin)."

#: ../../whatsnew/2.4.rst:1094
msgid ""
"The :mod:`itertools` module gained a ``groupby(iterable[, *func*])`` "
"function. *iterable* is something that can be iterated over to return a "
"stream of elements, and the optional *func* parameter is a function that "
"takes an element and returns a key value; if omitted, the key is simply the "
"element itself.  :func:`groupby` then groups the elements into subsequences "
"which have matching values of the key, and returns a series of 2-tuples "
"containing the key value and an iterator over the subsequence."
msgstr ""
":mod:`itertools` モジュールに ``groupby(iterable[, *func*])`` 関数が追加され"
"ました。 *iterable* は何か要素のストリームを返すものをイテレート出来るもの"
"で、省略可能な *func* パラメータは要素を取ってキー値を返す関数です。省略され"
"ればキーは要素自身です。 :func:`groupby` は要素群をキー値の合致ごとサブシーケ"
"ンスにグループ化して、キー値とサブシーケンスに対するイテレータを組とする 2 要"
"素タプルのシリーズを返します。"

#: ../../whatsnew/2.4.rst:1102
msgid ""
"Here's an example to make this clearer.  The *key* function simply returns "
"whether a number is even or odd, so the result of :func:`groupby` is to "
"return consecutive runs of odd or even numbers. ::"
msgstr ""
"例をお見せするのが早いでしょう。ここでは *key* 関数は単に数値が偶数か奇数かを"
"返すだけです。 :func:`groupby` の結果は偶数または奇数の一連の流れを返します::"

#: ../../whatsnew/2.4.rst:1106
msgid ""
">>> import itertools\n"
">>> L = [2, 4, 6, 7, 8, 9, 11, 12, 14]\n"
">>> for key_val, it in itertools.groupby(L, lambda x: x % 2):\n"
"...    print key_val, list(it)\n"
"...\n"
"0 [2, 4, 6]\n"
"1 [7]\n"
"0 [8]\n"
"1 [9, 11]\n"
"0 [12, 14]\n"
">>>"
msgstr ""

#: ../../whatsnew/2.4.rst:1118
msgid ""
":func:`groupby` is typically used with sorted input.  The logic for :func:"
"`groupby` is similar to the Unix ``uniq`` filter which makes it handy for "
"eliminating, counting, or identifying duplicate elements::"
msgstr ""
":func:`groupby` は典型的にはソート済み入力に使います。 :func:`groupby` のロ"
"ジックは除外、数え上げ、重複要素の特定を手軽に行う Unix の ``uniq`` フィルタ"
"に似ています::"

#: ../../whatsnew/2.4.rst:1122
msgid ""
">>> word = 'abracadabra'\n"
">>> letters = sorted(word)   # Turn string into a sorted list of letters\n"
">>> letters\n"
"['a', 'a', 'a', 'a', 'a', 'b', 'b', 'c', 'd', 'r', 'r']\n"
">>> for k, g in itertools.groupby(letters):\n"
"...    print k, list(g)\n"
"...\n"
"a ['a', 'a', 'a', 'a', 'a']\n"
"b ['b', 'b']\n"
"c ['c']\n"
"d ['d']\n"
"r ['r', 'r']\n"
">>> # List unique letters\n"
">>> [k for k, g in groupby(letters)]\n"
"['a', 'b', 'c', 'd', 'r']\n"
">>> # Count letter occurrences\n"
">>> [(k, len(list(g))) for k, g in groupby(letters)]\n"
"[('a', 5), ('b', 2), ('c', 1), ('d', 1), ('r', 2)]"
msgstr ""

#: ../../whatsnew/2.4.rst:1141
msgid "(Contributed by Hye-Shik Chang.)"
msgstr "(Contributed by Hye-Shik Chang.)"

#: ../../whatsnew/2.4.rst:1143
msgid ""
":mod:`itertools` also gained a function named ``tee(iterator, N)`` that "
"returns *N* independent iterators that replicate *iterator*.  If *N* is "
"omitted, the default is 2. ::"
msgstr ""
":mod:`itertools` には ``tee(iterator, N)`` という新たな関数も追加されていま"
"す。これは *iterator* の、独立した *N* 個の複製イテレータを返します。 *N* は"
"省略されればデフォルトは 2 です。::"

#: ../../whatsnew/2.4.rst:1147
msgid ""
">>> L = [1,2,3]\n"
">>> i1, i2 = itertools.tee(L)\n"
">>> i1,i2\n"
"(<itertools.tee object at 0x402c2080>, <itertools.tee object at "
"0x402c2090>)\n"
">>> list(i1)               # Run the first iterator to exhaustion\n"
"[1, 2, 3]\n"
">>> list(i2)               # Run the second iterator to exhaustion\n"
"[1, 2, 3]"
msgstr ""

#: ../../whatsnew/2.4.rst:1156
msgid ""
"Note that :func:`tee` has to keep copies of the values returned  by the "
"iterator; in the worst case, it may need to keep all of them.   This should "
"therefore be used carefully if the leading iterator can run far ahead of the "
"trailing iterator in a long stream of inputs. If the separation is large, "
"then you might as well use  :func:`list` instead.  When the iterators track "
"closely with one another, :func:`tee` is ideal.  Possible applications "
"include bookmarking, windowing, or lookahead iterators. (Contributed by "
"Raymond Hettinger.)"
msgstr ""
":func:`tee` がイテレータから返される値のコピーを維持する必要があることに注意"
"してください。最悪の場合はそれら全てを維持する必要があるかもしれません。です"
"のでこれは長丁場の入力に対して、先行するイテレータが後続のイテレータの遥か先"
"を突っ走れる場合には注意深く使わなければなりません。その分断が大きいようであ"
"れば、 :func:`list` を代わりに使うほうが良いかもしれません。イテレータたちが"
"相互に近い場所を追跡する場合は :func:`tee` は理想的です。ブックマーク、ウィン"
"ドウ処理、あるいは先読みイテレータといったものに適用出来るのではないでしょう"
"か。 (Contributed by Raymond Hettinger.)"

#: ../../whatsnew/2.4.rst:1165
msgid ""
"A number of functions were added to the :mod:`locale`  module, such as :func:"
"`bind_textdomain_codeset` to specify a particular encoding and a family of :"
"func:`!l\\*gettext` functions that return messages in the chosen encoding. "
"(Contributed by Gustavo Niemeyer.)"
msgstr ""

#: ../../whatsnew/2.4.rst:1170
msgid ""
"Some keyword arguments were added to the :mod:`logging` package's :func:"
"`basicConfig` function to simplify log configuration.  The default behavior "
"is to log messages to standard error, but various keyword arguments can be "
"specified to log to a particular file, change the logging format, or set the "
"logging level. For example::"
msgstr ""
":mod:`logging` パッケージの :func:`basicConfig` 関数に、ログ設定を簡単にする"
"いくつかのキーワード引数が追加されました。デフォルトの振る舞いはログメッセー"
"ジを標準エラー出力に出力することですが、様々なキーワード引数でログを特定の"
"ファイルに書いたり、ログのフォーマットを変えたり、ロギングのレベルを変えたり"
"出来ます。例えば::"

#: ../../whatsnew/2.4.rst:1176
msgid ""
"import logging\n"
"logging.basicConfig(filename='/var/log/application.log',\n"
"    level=0,  # Log all messages\n"
"    format='%(levelname):%(process):%(thread):%(message)')"
msgstr ""

#: ../../whatsnew/2.4.rst:1181
msgid ""
"Other additions to the :mod:`logging` package include a ``log(level, msg)`` "
"convenience method, as well as a :class:`TimedRotatingFileHandler` class "
"that rotates its log files at a timed interval.  The module already had :"
"class:`RotatingFileHandler`, which rotated logs once the file exceeded a "
"certain size.  Both classes derive from a new :class:`BaseRotatingHandler` "
"class that can be used to implement other rotating handlers."
msgstr ""
"ほかの :mod:`logging` パッケージへの追加としては、 便利メソッド ``log(level, "
"msg)`` や、ログファイルを時間間隔でローテートするクラス :class:"
"`TimedRotatingFileHandler` などがあります。モジュールには元々 :class:"
"`RotatingFileHandler` が含まれており、こちらはファイルが特定のサイズを超過し"
"た場合にローテートするものです。両クラスとも新しく導出された :class:"
"`BaseRotatingHandler` 基底クラスから派生していて、これはまた別のローテートす"
"るハンドラを実装するのに使えます。"

#: ../../whatsnew/2.4.rst:1188
msgid "(Changes implemented by Vinay Sajip.)"
msgstr "(Changes implemented by Vinay Sajip.)"

#: ../../whatsnew/2.4.rst:1190
msgid ""
"The :mod:`marshal` module now shares interned strings on unpacking a  data "
"structure.  This may shrink the size of certain pickle strings, but the "
"primary effect is to make :file:`.pyc` files significantly smaller. "
"(Contributed by Martin von Löwis.)"
msgstr ""
":mod:`marshal` モジュールが、データ構造のアンパックで内部化した文字列を共有す"
"るようになりました。これはある種の pickle 文字列のサイズを切り詰めるでしょう"
"が、主要な効能は :file:`.pyc` ファイルが顕著に小さくなることです。"
"(Contributed by Martin von Löwis.)"

#: ../../whatsnew/2.4.rst:1195
msgid ""
"The :mod:`!nntplib` module's :class:`NNTP` class gained :meth:`description` "
"and :meth:`descriptions` methods to retrieve  newsgroup descriptions for a "
"single group or for a range of groups. (Contributed by Jürgen A. Erhard.)"
msgstr ""

#: ../../whatsnew/2.4.rst:1199
msgid ""
"Two new functions were added to the :mod:`operator` module, "
"``attrgetter(attr)`` and ``itemgetter(index)``. Both functions return "
"callables that take a single argument and return the corresponding attribute "
"or item; these callables make excellent data extractors when used with :func:"
"`map` or :func:`sorted`.  For example::"
msgstr ""
":mod:`operator` モジュールに 2 つの関数 ``attrgetter(attr)`` と "
"``itemgetter(index)`` が追加されています。両関数ともに、単一引数を取ってそれ"
"に対応する属性かアイテムを返す呼び出し可能オブジェクトを返します。これら呼び"
"出し可能オブジェクトは :func:`map` や :func:`sorted` とともに使う際の優れた"
"データ抽出器になります。例えば::"

#: ../../whatsnew/2.4.rst:1205
msgid ""
">>> L = [('c', 2), ('d', 1), ('a', 4), ('b', 3)]\n"
">>> map(operator.itemgetter(0), L)\n"
"['c', 'd', 'a', 'b']\n"
">>> map(operator.itemgetter(1), L)\n"
"[2, 1, 4, 3]\n"
">>> sorted(L, key=operator.itemgetter(1)) # Sort list by second tuple item\n"
"[('d', 1), ('c', 2), ('b', 3), ('a', 4)]"
msgstr ""

#: ../../whatsnew/2.4.rst:1215
msgid ""
"The :mod:`optparse` module was updated in various ways.  The module now "
"passes its messages through :func:`gettext.gettext`, making it possible to "
"internationalize Optik's help and error messages.  Help messages for options "
"can now include the string ``'%default'``, which will be replaced by the "
"option's default value.  (Contributed by Greg Ward.)"
msgstr ""
":mod:`optparse` モジュールが色々更新されました。モジュールはメッセージを :"
"func:`gettext.gettext` を通して Optik のヘルプとエラーメッセージを国際化する"
"のを可能にしています。オプションのヘルプメッセージは文字列 ``'%default'`` を"
"含めることが出来るようになっており、これはオプションのデフォルト値に置換され"
"ます。(Contributed by Greg Ward.)"

#: ../../whatsnew/2.4.rst:1221
msgid ""
"The long-term plan is to deprecate the :mod:`!rfc822` module in some future "
"Python release in favor of the :mod:`email` package. To this end, the :func:"
"`email.Utils.formatdate <email.utils.formatdate>` function has been changed "
"to make it usable as a replacement for :func:`!rfc822.formatdate`.  You may "
"want to write new e-mail processing code with this in mind.  (Change "
"implemented by Anthony Baxter.)"
msgstr ""

#: ../../whatsnew/2.4.rst:1227
msgid ""
"A new ``urandom(n)`` function was added to the :mod:`os` module, returning a "
"string containing *n* bytes of random data.  This function provides access "
"to platform-specific sources of randomness such as :file:`/dev/urandom` on "
"Linux or the Windows CryptoAPI.  (Contributed by Trevor Perrin.)"
msgstr ""
":mod:`os` モジュールに ``urandom(n)`` が追加されました。これは *n* バイトの乱"
"数データを含む文字列を返します。この関数はプラットフォーム固有の乱数発生源に"
"アクセスします。例えば Linux での :file:`/dev/urandom` や Windows での "
"CryptoAPI です。 (Contributed by Trevor Perrin.)"

#: ../../whatsnew/2.4.rst:1232
msgid ""
"Another new function: ``os.path.lexists(path)``  returns true if the file "
"specified by *path* exists, whether or not it's a symbolic link.  This "
"differs from the existing ``os.path.exists(path)`` function, which returns "
"false if *path* is a symlink that points to a destination that doesn't "
"exist. (Contributed by Beni Cherniavsky.)"
msgstr ""
"もう一つの新規関数 ``os.path.lexists(path)`` は *path* によって指定されたファ"
"イルがそれがシンボリックリンクかどうかによらず、存在している場合に真を返しま"
"す。これは、既存の ``os.path.exists(path)`` 関数が *path* がシンボリックリン"
"クでその指し先が存在しない場合に偽を返すのとは異なります。 (Contributed by "
"Beni Cherniavsky.)"

#: ../../whatsnew/2.4.rst:1238
msgid ""
"A new :func:`getsid` function was added to the :mod:`posix` module that "
"underlies the :mod:`os` module. (Contributed by J. Raynor.)"
msgstr ""
":mod:`os` モジュールの下層にある :mod:`posix` モジュールに :func:`getsid` 関"
"数が追加されました。 (Contributed by J. Raynor.)"

#: ../../whatsnew/2.4.rst:1241
msgid ""
"The :mod:`poplib` module now supports POP over SSL.  (Contributed by Hector "
"Urtubia.)"
msgstr ""
":mod:`poplib` モジュールが  POP over SSL をサポートするようになりました.  "
"(Contributed by Hector Urtubia.)"

#: ../../whatsnew/2.4.rst:1244
msgid ""
"The :mod:`profile` module can now profile C extension functions. "
"(Contributed by Nick Bastin.)"
msgstr ""
":mod:`profile` モジュールが C 拡張の関数をプロファイル出来るようになりまし"
"た。 (Contributed by Nick Bastin.)"

#: ../../whatsnew/2.4.rst:1247
msgid ""
"The :mod:`random` module has a new method called ``getrandbits(N)`` that "
"returns a long integer *N* bits in length.  The existing :meth:`randrange` "
"method now uses :meth:`getrandbits` where appropriate, making generation of "
"arbitrarily large random numbers more efficient.  (Contributed by Raymond "
"Hettinger.)"
msgstr ""
":mod:`random` モジュールに、 ``getrandbits(N)`` 関数が追加されました。 *N* "
"ビット長の長整数を返します。既存の :meth:`randrange` メソッドは :meth:"
"`getrandbits` を適切な場所で使うようになり、任意の大きな乱数値生成をより効果"
"的にしています。 (Contributed by Raymond Hettinger.)"

#: ../../whatsnew/2.4.rst:1253
msgid ""
"The regular expression language accepted by the :mod:`re` module was "
"extended with simple conditional expressions, written as ``(?(group)A|B)``.  "
"*group* is either a numeric group ID or a group name defined with ``(?"
"P<group>...)`` earlier in the expression.  If the specified group matched, "
"the regular expression pattern *A* will be tested against the string; if the "
"group didn't match, the pattern *B* will be used instead. (Contributed by "
"Gustavo Niemeyer.)"
msgstr ""
":mod:`re` モジュールの正規表現言語が拡張されて、単純な条件式 ``(?(group)A|"
"B)`` を書けるようになっています。 *group* は数値グループ ID か正規表現内で "
"``(?P<group>...)`` で定義したグループ名のどちらかです。指定したグループが合致"
"した場合は、正規表現パターン *A* が文字列に対してテストされ、そうでなければパ"
"ターン *B* が代わりに試されます。(Contributed by Gustavo Niemeyer.)"

#: ../../whatsnew/2.4.rst:1260
msgid ""
"The :mod:`re` module is also no longer recursive, thanks to a massive amount "
"of work by Gustavo Niemeyer.  In a recursive regular expression engine, "
"certain patterns result in a large amount of C stack space being consumed, "
"and it was possible to overflow the stack. For example, if you matched a "
"30000-byte string of ``a`` characters against the expression ``(a|b)+``, one "
"stack frame was consumed per character.  Python 2.3 tried to check for stack "
"overflow and raise a :exc:`RuntimeError` exception, but certain patterns "
"could sidestep the checking and if you were unlucky Python could segfault. "
"Python 2.4's regular expression engine can match this pattern without "
"problems."
msgstr ""
":mod:`re` モジュールはもう再帰をすることはありません。Gustavo Niemeyer による"
"膨大な量の仕事のおかげです。再帰する正規表現エンジンでは、ある種のパターンで"
"は大量の C スタック空間を消費し、スタックのオーバーフローを起こすことがありま"
"した。例えば表現 ``(a|b)+`` が文字 ``a`` から成る 3 万バイトの文字列に対して"
"マッチすると、一文字ごとに一つのスタックフレームを消費していました。Python "
"2.3 ではスタックオーバーフローのチェックを試みて :exc:`RuntimeError` を投げよ"
"うとしましたが、ある種のパターンではチェックをすり抜けてしまって、運が悪いと"
"セグメンテーション違反を起こしていました。Python 2.4 の正規表現エンジンではこ"
"のパターンと問題を起こすことなくマッチ出来ます。"

#: ../../whatsnew/2.4.rst:1270
msgid ""
"The :mod:`signal` module now performs tighter error-checking on the "
"parameters to the :func:`signal.signal` function.  For example, you can't "
"set a handler on the :const:`SIGKILL` signal; previous versions of Python "
"would quietly accept this, but 2.4 will raise a :exc:`RuntimeError` "
"exception."
msgstr ""
":mod:`signal` モジュールで、 :func:`signal.signal` へのパラメータのエラー"
"チェックを厳しくしています。例えば :const:`SIGKILL` シグナルへのハンドラは"
"セット出来ません。以前のバージョンの Python ではこれを黙って受け容れていまし"
"たが、2.4 では :exc:`RuntimeError` を投げます。"

#: ../../whatsnew/2.4.rst:1275
msgid ""
"Two new functions were added to the :mod:`socket` module. :func:`socketpair` "
"returns a pair of connected sockets and ``getservbyport(port)`` looks up the "
"service name for a given port number. (Contributed by Dave Cole and Barry "
"Warsaw.)"
msgstr ""
":mod:`socket` モジュールに 2 つ新しい関数が追加されています。 :func:"
"`socketpair` 関数は接続したソケットのペアを返し、 ``getservbyport(port)`` は"
"与えたポート番号からサービス名を探して返します。(Contributed by Dave Cole "
"and Barry Warsaw.)"

#: ../../whatsnew/2.4.rst:1280
msgid ""
"The :func:`sys.exitfunc` function has been deprecated.  Code should be using "
"the existing :mod:`atexit` module, which correctly handles calling multiple "
"exit functions.  Eventually :func:`sys.exitfunc` will become a purely "
"internal interface, accessed only by :mod:`atexit`."
msgstr ""
":func:`sys.exitfunc` 関数は非推奨となりました。コードは既存の :mod:`atexit` "
"モジュールを使うべきです。これは複数の終了関数呼び出しを正しく処理出来ます。"
"結果的には :func:`sys.exitfunc` は純粋に :mod:`atexit` のみから使われる内部イ"
"ンターフェイスとなるでしょう。"

#: ../../whatsnew/2.4.rst:1285
msgid ""
"The :mod:`tarfile` module now generates GNU-format tar files by default. "
"(Contributed by Lars Gustäbel.)"
msgstr ""
":mod:`tarfile` モジュールがデフォルトで GNU フォーマットを生成するようになっ"
"ています。 (Contributed by Lars Gustäbel.)"

#: ../../whatsnew/2.4.rst:1288
msgid ""
"The :mod:`threading` module now has an elegantly simple way to support "
"thread-local data.  The module contains a :class:`local` class whose "
"attribute values are local to different threads. ::"
msgstr ""
":mod:`threading` モジュールで、スレッドローカルなデータのサポートについて、品"
"の良い単純な方法でサポート出来ました。モジュールは :class:`local` クラスを"
"持っており、その属性値は異なるスレッドごとにローカルになります::"

#: ../../whatsnew/2.4.rst:1292
msgid ""
"import threading\n"
"\n"
"data = threading.local()\n"
"data.number = 42\n"
"data.url = ('www.python.org', 80)"
msgstr ""

#: ../../whatsnew/2.4.rst:1298
msgid ""
"Other threads can assign and retrieve their own values for the :attr:"
"`number` and :attr:`url` attributes.  You can subclass :class:`local` to "
"initialize attributes or to add methods. (Contributed by Jim Fulton.)"
msgstr ""
"この場合他のスレッドは :attr:`number` 属性、 :attr:`url` 属性に自身の値を代"
"入、抽出出来ます。 :class:`local` クラスは属性初期化であるとかメソッドの追加"
"のためにサブクラス化することも出来ます。 (Contributed by Jim Fulton.)"

#: ../../whatsnew/2.4.rst:1302
msgid ""
"The :mod:`timeit` module now automatically disables periodic garbage "
"collection during the timing loop.  This change makes consecutive timings "
"more comparable.  (Contributed by Raymond Hettinger.)"
msgstr ""
":mod:`timeit` モジュールはループを計測中は周期的なガーベージコレクションを自"
"動で無効化するようになりました。この変更により、繰り返しの計測の比較がやりや"
"すくなります。 (Contributed by Raymond Hettinger.)"

#: ../../whatsnew/2.4.rst:1306
msgid ""
"The :mod:`weakref` module now supports a wider variety of objects including "
"Python functions, class instances, sets, frozensets, deques, arrays, files, "
"sockets, and regular expression pattern objects. (Contributed by Raymond "
"Hettinger.)"
msgstr ""
":mod:`weakref` モジュールがサポートするオブジェクトが非常に幅広くなりました。"
"これには Python 関数、クラスインスタンス, set, frozenset, deque, array と正規"
"表現パターンオブジェクトが含まれます。(Contributed by Raymond Hettinger.)"

#: ../../whatsnew/2.4.rst:1311
msgid ""
"The :mod:`xmlrpclib <xmlrpc.client>` module now supports a multi-call "
"extension for transmitting multiple XML-RPC calls in a single HTTP "
"operation. (Contributed by Brian Quinlan.)"
msgstr ""

#: ../../whatsnew/2.4.rst:1315
msgid ""
"The :mod:`mpz`, :mod:`rotor`, and :mod:`xreadlines` modules have  been "
"removed."
msgstr ""
":mod:`mpz`, :mod:`rotor`,  :mod:`xreadlines`  モジュールは削除されました。"

#: ../../whatsnew/2.4.rst:1324
msgid "cookielib"
msgstr "cookielib"

#: ../../whatsnew/2.4.rst:1326
msgid ""
"The :mod:`cookielib <http.cookiejar>` library supports client-side handling "
"for HTTP cookies, mirroring the :mod:`Cookie <http.cookies>` module's server-"
"side cookie support. Cookies are stored in cookie jars; the library "
"transparently stores cookies offered by the web server in the cookie jar, "
"and fetches the cookie from the jar when connecting to the server. As in web "
"browsers, policy objects control whether cookies are accepted or not."
msgstr ""

#: ../../whatsnew/2.4.rst:1333
msgid ""
"In order to store cookies across sessions, two implementations of cookie "
"jars are provided: one that stores cookies in the Netscape format so "
"applications can use the Mozilla or Lynx cookie files, and one that stores "
"cookies in the same format as the Perl libwww library."
msgstr ""
"セッションを跨いでクッキーを記憶するために、2 つのクッキー瓶実装が提供されて"
"います。一つは Netscape フォーマットでクッキーを記憶するのでアプリケーション"
"は Mozilla か Lynx のクッキーファイルを使え、もう一つは Perl の libwww ライブ"
"ラリと同じフォーマットでクッキーを記憶します。"

#: ../../whatsnew/2.4.rst:1338
msgid ""
":mod:`urllib2 <urllib.request>` has been changed to interact with :mod:"
"`cookielib <http.cookiejar>`: :class:`HTTPCookieProcessor` manages a cookie "
"jar that is used when accessing URLs."
msgstr ""

#: ../../whatsnew/2.4.rst:1342
msgid "This module was contributed by John J. Lee."
msgstr "このモジュールは John J. Lee により寄稿されました。"

#: ../../whatsnew/2.4.rst:1348
msgid "doctest"
msgstr "doctest"

#: ../../whatsnew/2.4.rst:1350
msgid ""
"The :mod:`doctest` module underwent considerable refactoring thanks to "
"Edward Loper and Tim Peters.  Testing can still be as simple as running :"
"func:`doctest.testmod`, but the refactorings allow customizing the module's "
"operation in various ways"
msgstr ""
"Edward Loper と Tim Peters のおかげにより、 :mod:`doctest` モジュールに注目に"
"値するリファクタリングが入りました。テストはこれまで通り単純に :func:"
"`doctest.testmod` を実行するすることで行えますが、リファクタリングはモジュー"
"ルの操作をカスタマイズする色々な手段を提供してくれます。"

#: ../../whatsnew/2.4.rst:1355
msgid ""
"The new :class:`DocTestFinder` class extracts the tests from a given  "
"object's docstrings::"
msgstr ""
"新規クラス :class:`DocTestFinder` は指定したオブジェクトの docstring からテス"
"トを抽出します::"

#: ../../whatsnew/2.4.rst:1358
msgid ""
"def f (x, y):\n"
"    \"\"\">>> f(2,2)\n"
"4\n"
">>> f(3,2)\n"
"6\n"
"    \"\"\"\n"
"    return x*y\n"
"\n"
"finder = doctest.DocTestFinder()\n"
"\n"
"# Get list of DocTest instances\n"
"tests = finder.find(f)"
msgstr ""

#: ../../whatsnew/2.4.rst:1371
msgid ""
"The new :class:`DocTestRunner` class then runs individual tests and can "
"produce a summary of the results::"
msgstr ""
"新規クラス :class:`DocTestRunner` はテストを個々に実行し、結果の要約を生成出"
"来ます::"

#: ../../whatsnew/2.4.rst:1374
msgid ""
"runner = doctest.DocTestRunner()\n"
"for t in tests:\n"
"    tried, failed = runner.run(t)\n"
"\n"
"runner.summarize(verbose=1)"
msgstr ""

#: ../../whatsnew/2.4.rst:1380
msgid "The above example produces the following output::"
msgstr "上の例はこのような出力を生成します::"

#: ../../whatsnew/2.4.rst:1382
msgid ""
"1 items passed all tests:\n"
"   2 tests in f\n"
"2 tests in 1 items.\n"
"2 passed and 0 failed.\n"
"Test passed."
msgstr ""

#: ../../whatsnew/2.4.rst:1388
msgid ""
":class:`DocTestRunner` uses an instance of the :class:`OutputChecker` class "
"to compare the expected output with the actual output.  This class takes a "
"number of different flags that customize its behaviour; ambitious users can "
"also write a completely new subclass of :class:`OutputChecker`."
msgstr ""
":class:`DocTestRunner` は実際の出力と結果の期待値の比較に、 :class:"
"`OutputChecker` のインスタンスを使います。このクラスはその振る舞いをカスタマ"
"イズする色々なフラグを取ります。意欲的なユーザであれば :class:"
"`OutputChecker` の完全な新しいサブクラスも書けます。"

#: ../../whatsnew/2.4.rst:1393
msgid ""
"The default output checker provides a number of handy features. For example, "
"with the :const:`doctest.ELLIPSIS` option flag, an ellipsis (``...``) in the "
"expected output matches any substring,  making it easier to accommodate "
"outputs that vary in minor ways::"
msgstr ""
"デフォルトの出力チェッカーは多くのお手軽機能を持っています。例えば :const:"
"`doctest.ELLIPSIS` オプションフラグは、出力の期待値内での省略記号 (``...``) "
"と任意文字列を一致するとみなし、瑣末な部分が変化するような出力に簡単に適合す"
"るように出来ます::"

#: ../../whatsnew/2.4.rst:1398
msgid ""
"def o (n):\n"
"    \"\"\">>> o(1)\n"
"<__main__.C instance at 0x...>\n"
">>>\n"
"\"\"\""
msgstr ""

#: ../../whatsnew/2.4.rst:1404
msgid "Another special string, ``<BLANKLINE>``, matches a blank line::"
msgstr "もう一つの特殊文字列 ``<BLANKLINE>`` は空行に合致します::"

#: ../../whatsnew/2.4.rst:1406
msgid ""
"def p (n):\n"
"    \"\"\">>> p(1)\n"
"<BLANKLINE>\n"
">>>\n"
"\"\"\""
msgstr ""

#: ../../whatsnew/2.4.rst:1412
msgid ""
"Another new capability is producing a diff-style display of the output by "
"specifying the :const:`doctest.REPORT_UDIFF` (unified diffs), :const:"
"`doctest.REPORT_CDIFF` (context diffs), or :const:`doctest.REPORT_NDIFF` "
"(delta-style) option flags.  For example::"
msgstr ""
"もう一つの新機能は出力の diff スタイル出力で、オプションフラグに :const:"
"`doctest.REPORT_UDIFF` (unified diffs), :const:`doctest.REPORT_CDIFF` "
"(context diffs), :const:`doctest.REPORT_NDIFF` (delta-style) を指定することで"
"利用出来ます。例えば以下があるとして::"

#: ../../whatsnew/2.4.rst:1417
msgid ""
"def g (n):\n"
"    \"\"\">>> g(4)\n"
"here\n"
"is\n"
"a\n"
"lengthy\n"
">>>\"\"\"\n"
"    L = 'here is a rather lengthy list of words'.split()\n"
"    for word in L[:n]:\n"
"        print word"
msgstr ""

#: ../../whatsnew/2.4.rst:1428
msgid ""
"Running the above function's tests with :const:`doctest.REPORT_UDIFF` "
"specified, you get the following output:"
msgstr ""

#: ../../whatsnew/2.4.rst:1431
msgid ""
"**********************************************************************\n"
"File \"t.py\", line 15, in g\n"
"Failed example:\n"
"    g(4)\n"
"Differences (unified diff with -expected +actual):\n"
"    @@ -2,3 +2,3 @@\n"
"     is\n"
"     a\n"
"    -lengthy\n"
"    +rather\n"
"**********************************************************************"
msgstr ""

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

#: ../../whatsnew/2.4.rst:1451
msgid "Some of the changes to Python's build process and to the C API are:"
msgstr "Python のビルド過程と C API の変更は以下の通りです:"

#: ../../whatsnew/2.4.rst:1453
msgid ""
"Three new convenience macros were added for common return values from "
"extension functions: :c:macro:`Py_RETURN_NONE`, :c:macro:`Py_RETURN_TRUE`, "
"and :c:macro:`Py_RETURN_FALSE`. (Contributed by Brett Cannon.)"
msgstr ""
"拡張関数からの戻り値として一般的に使うための 3 つの便利なマクロが追加されてい"
"ます: :c:macro:`Py_RETURN_NONE`, :c:macro:`Py_RETURN_TRUE`, :c:macro:"
"`Py_RETURN_FALSE` (Contributed by Brett Cannon.)"

#: ../../whatsnew/2.4.rst:1457
msgid ""
"Another new macro, :c:macro:`Py_CLEAR`,  decreases the reference count of "
"*obj* and sets *obj* to the null pointer.  (Contributed by Jim Fulton.)"
msgstr ""

#: ../../whatsnew/2.4.rst:1460
msgid ""
"A new function, ``PyTuple_Pack(N, obj1, obj2, ..., objN)``, constructs "
"tuples from a variable length argument list of Python objects.  (Contributed "
"by Raymond Hettinger.)"
msgstr ""
"新規関数 ``PyTuple_Pack(N, obj1, obj2, ..., objN)`` は Python オブジェクトの"
"可変長引数リストからタプルを構築します。 (Contributed by Raymond Hettinger.)"

#: ../../whatsnew/2.4.rst:1464
msgid ""
"A new function, ``PyDict_Contains(d, k)``, implements fast dictionary "
"lookups without masking exceptions raised during the look-up process. "
"(Contributed by Raymond Hettinger.)"
msgstr ""
"新規関数 ``PyDict_Contains(d, k)`` は、処理内で起こる例外のマスキングなしでの"
"高速なルックアップを実装しています。 (Contributed by Raymond Hettinger.)"

#: ../../whatsnew/2.4.rst:1468
msgid ""
"The :c:expr:`Py_IS_NAN(X)` macro returns 1 if  its float or double argument "
"*X* is a NaN.   (Contributed by Tim Peters.)"
msgstr ""

#: ../../whatsnew/2.4.rst:1471
msgid ""
"C code can avoid unnecessary locking by using the new :c:func:`!"
"PyEval_ThreadsInitialized` function to tell  if any thread operations have "
"been performed.  If this function  returns false, no lock operations are "
"needed. (Contributed by Nick Coghlan.)"
msgstr ""

#: ../../whatsnew/2.4.rst:1476
msgid ""
"A new function, :c:func:`PyArg_VaParseTupleAndKeywords`, is the same as :c:"
"func:`PyArg_ParseTupleAndKeywords` but takes a  :c:type:`va_list` instead of "
"a number of arguments. (Contributed by Greg Chapman.)"
msgstr ""
"新規関数 :c:func:`PyArg_VaParseTupleAndKeywords` は :c:func:"
"`PyArg_ParseTupleAndKeywords` と同じですが、たくさんの引数の代わりに :c:type:"
"`va_list` を取ることだけが違います。(Contributed by Greg Chapman.)"

#: ../../whatsnew/2.4.rst:1480
msgid ""
"A new method flag, :c:macro:`METH_COEXIST`, allows a function defined in "
"slots to co-exist with a :c:type:`PyCFunction` having the same name.  This "
"can halve the access time for a method such as :meth:`set.__contains__`.  "
"(Contributed by Raymond Hettinger.)"
msgstr ""

#: ../../whatsnew/2.4.rst:1485
msgid ""
"Python can now be built with additional profiling for the interpreter "
"itself, intended as an aid to people developing the Python core.  Providing :"
"option:`!--enable-profiling` to the :program:`configure` script will let you "
"profile the interpreter with :program:`gprof`, and providing the :option:`!--"
"with-tsc` switch enables profiling using the Pentium's Time-Stamp-Counter "
"register.  Note that the :option:`!--with-tsc` switch is slightly misnamed, "
"because the profiling feature also works on the PowerPC platform, though "
"that processor architecture doesn't call that register \"the TSC "
"register\".  (Contributed by Jeremy Hylton.)"
msgstr ""

#: ../../whatsnew/2.4.rst:1495
msgid ""
"The :c:type:`!tracebackobject` type has been renamed to :c:type:"
"`PyTracebackObject`."
msgstr ""

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

#: ../../whatsnew/2.4.rst:1504
msgid ""
"The Windows port now builds under MSVC++ 7.1 as well as version 6. "
"(Contributed by Martin von Löwis.)"
msgstr ""
"Windows ポートは MSVC++ 6 と 7.1 でビルド出来ます。 (Contributed by Martin "
"von Löwis.)"

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

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

#: ../../whatsnew/2.4.rst:1516
msgid ""
"Left shifts and hexadecimal/octal constants that are too  large no longer "
"trigger a :exc:`FutureWarning` and return  a value limited to 32 or 64 bits; "
"instead they return a long integer."
msgstr ""
"大き過ぎる値を持つ左シフトと 16 進/ 8 進定数が :exc:`FutureWarning` を引き起"
"こした上で 32 ビットまたは 64 ビットに制限される、という振る舞いはもうしませ"
"ん。代わりに長整数を返します。"

#: ../../whatsnew/2.4.rst:1523
msgid ""
"The :func:`zip` built-in function and :func:`itertools.izip` now return  an "
"empty list instead of raising a :exc:`TypeError` exception if called with no "
"arguments."
msgstr ""
"ビルトイン関数の :func:`zip` と :func:`itertools.izip` が引数なしで呼ばれた場"
"合に、 :exc:`TypeError` 例外を起こすのではなく空リストを返すようになりまし"
"た。"

#: ../../whatsnew/2.4.rst:1527
msgid ""
"You can no longer compare the :class:`date` and :class:`~datetime.datetime` "
"instances provided by the :mod:`datetime` module.  Two  instances of "
"different classes will now always be unequal, and  relative comparisons "
"(``<``, ``>``) will raise a :exc:`TypeError`."
msgstr ""

#: ../../whatsnew/2.4.rst:1532
msgid ""
":func:`!dircache.listdir` now passes exceptions to the caller instead of "
"returning empty lists."
msgstr ""

#: ../../whatsnew/2.4.rst:1535
msgid ""
":func:`LexicalHandler.startDTD` used to receive the public and system IDs in "
"the wrong order.  This has been corrected; applications relying on the wrong "
"order need to be fixed."
msgstr ""
":func:`LexicalHandler.startDTD` はパブリックでシステムの ID を間違った順序で"
"受け取っていました。これは修正されました; この間違った順序に依存したアプリ"
"ケーションは修正しなければなりません。"

#: ../../whatsnew/2.4.rst:1539
msgid ""
":func:`fcntl.ioctl` now warns if the *mutate*  argument is omitted and "
"relevant."
msgstr ""
":func:`fcntl.ioctl` は *mutate_flag* 引数が省略されて問題に関係がある場合は警"
"告を出します。"

#: ../../whatsnew/2.4.rst:1542
msgid ""
"The :mod:`tarfile` module now generates GNU-format tar files by default."
msgstr ""
":mod:`tarfile` モジュールがデフォルトで GNU フォーマットを生成するようになっ"
"ています。"

#: ../../whatsnew/2.4.rst:1544
msgid ""
"Encountering a failure while importing a module no longer leaves a partially "
"initialized module object in ``sys.modules``."
msgstr ""

#: ../../whatsnew/2.4.rst:1547
msgid ""
":const:`None` is now a constant; code that binds a new value to  the name "
"``None`` is now a syntax error."
msgstr ""
":const:`None` が定数になっています。 ``None`` という名前に新しい値を割り当て"
"ようとするコードは、今では構文エラーになります。"

#: ../../whatsnew/2.4.rst:1550
msgid ""
"The :func:`signals.signal` function now raises a :exc:`RuntimeError` "
"exception for certain illegal values; previously these errors would pass "
"silently.  For example, you can no longer set a handler on the :const:"
"`SIGKILL` signal."
msgstr ""
":func:`signals.signal` 関数は、ある種の不正な値では :exc:`RuntimeError` を投"
"げるようになっています。以前はこれらエラーは黙って通していました。例えばも"
"う :const:`SIGKILL` へはハンドラは渡せません。"

#: ../../whatsnew/2.4.rst:1560
msgid "Acknowledgements"
msgstr "謝辞"

#: ../../whatsnew/2.4.rst:1562
msgid ""
"The author would like to thank the following people for offering "
"suggestions, corrections and assistance with various drafts of this article: "
"Koray Can, Hye-Shik Chang, Michael Dyck, Raymond Hettinger, Brian Hurt, "
"Hamish Lawson, Fredrik Lundh, Sean Reifschneider, Sadruddin Rejeb."
msgstr ""
"著者は提案の申し出や修正、様々なこの記事の草稿の助けをしてくれた以下の人々に"
"感謝します: Koray Can, Hye-Shik Chang, Michael Dyck, Raymond Hettinger, "
"Brian Hurt, Hamish Lawson, Fredrik Lundh, Sean Reifschneider, Sadruddin "
"Rejeb."

#: ../../whatsnew/2.4.rst:415
msgid "universal newlines"
msgstr "universal newlines"

#: ../../whatsnew/2.4.rst:415
msgid "What's new"
msgstr ""