2.0.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 1990-2021, Python Software Foundation
# This file is distributed under the same license as the Python package.
#
# Translators:
# tomo, 2017
# 秘湯 <xwhhsprings@gmail.com>, 2015-2016
msgid ""
msgstr ""
"Project-Id-Version: Python 2.7\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2021-01-01 01:01+0900\n"
"PO-Revision-Date: 2021-06-19 08:11+0000\n"
"Last-Translator: Mikami Akiko\n"
"Language-Team: Japanese (http://www.transifex.com/python-doc/python-27/"
"language/ja/)\n"
"Language: ja\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=1; plural=0;\n"

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

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

#: ../../whatsnew/2.0.rst:5
msgid "A.M. Kuchling and Moshe Zadka"
msgstr "A.M. Kuchling and Moshe Zadka"

#: ../../whatsnew/2.0.rst:13
msgid "Introduction"
msgstr "はじめに"

#: ../../whatsnew/2.0.rst:15
msgid ""
"A new release of Python, version 2.0, was released on October 16, 2000. This "
"article covers the exciting new features in 2.0, highlights some other "
"useful changes, and points out a few incompatible changes that may require "
"rewriting code."
msgstr ""
"新 Python リリース、バージョン 2.0 は、2000 年 10 月 16 日にリリースされまし"
"た。この記事では 2.0 のエキサイティングな新機能をカバーし、いくつかの有用な変"
"更点をハイライトし、少しの、コードの書き換えを要する互換性のない変更点につい"
"て指摘します。"

#: ../../whatsnew/2.0.rst:20
msgid ""
"Python's development never completely stops between releases, and a steady "
"flow of bug fixes and improvements are always being submitted. A host of "
"minor fixes, a few optimizations, additional docstrings, and better error "
"messages went into 2.0; to list them all would be impossible, but they're "
"certainly significant. Consult the publicly-available CVS logs if you want "
"to see the full list.  This progress is due to the five developers working "
"for  PythonLabs are now getting paid to spend their days fixing bugs, and "
"also due to the improved communication resulting  from moving to SourceForge."
msgstr ""
"Python の開発は、リリースとリリースの間で止まることはなく、バグフィックスと改"
"善はとめどなく、日夜提出されます。多くのマイナーフィックス、少しの最適化、ド"
"キュメンテーション文字列の追加、より良いエラーメッセージが 2.0 に仲間入りしま"
"した。これら全てを列挙するのは不可能ですが、それは確かに大事でしょう、全ての"
"リストを見たければ、公に入手可能な CVS ログを調べてください。この前進は、今や"
"バグ修正に日々を費やすことで報酬を受け取って PythonLabs のために働く 5 人の開"
"発者、それと SourceForge に移行した結果改善されたコミュニケーションのおかげで"
"す。"

#: ../../whatsnew/2.0.rst:33
msgid "What About Python 1.6?"
msgstr "Python 1.6 はいかがっすか?"

#: ../../whatsnew/2.0.rst:35
msgid ""
"Python 1.6 can be thought of as the Contractual Obligations Python release. "
"After the core development team left CNRI in May 2000, CNRI requested that a "
"1.6 release be created, containing all the work on Python that had been "
"performed at CNRI.  Python 1.6 therefore represents the state of the CVS "
"tree as of May 2000, with the most significant new feature being Unicode "
"support.  Development continued after May, of course, so the 1.6 tree "
"received a few fixes to ensure that it's forward-compatible with Python "
"2.0.  1.6 is therefore part of Python's evolution, and not a side branch."
msgstr ""
"Python 1.6 は「推定的義務」の Python リリースと考えることが出来ます。2000 年 "
"5 月にコア開発チームが CNRI を離れたあと、CNRI は Python にかかる作業全てが "
"CNRI で実施されることを含む 1.6 リリースが作成されることをリクエストしまし"
"た。それゆえ Python 1.6 は、最も重要な新機能としての Unicode サポートを含む、"
"2000 年 5 月の CVS ツリーの状態と同等です。開発はもちろん 5 月以降も継続され"
"ましたので、1.6 ツリーは Python 2.0 との前方互換を保障するために少しの修正を"
"受け取りました。1.6 はですから、Python の進化の一部であり、側枝ではありませ"
"ん。"

#: ../../whatsnew/2.0.rst:44
msgid ""
"So, should you take much interest in Python 1.6?  Probably not.  The "
"1.6final and 2.0beta1 releases were made on the same day (September 5, "
"2000), the plan being to finalize Python 2.0 within a month or so.  If you "
"have applications to maintain, there seems little point in breaking things "
"by moving to 1.6, fixing them, and then having another round of breakage "
"within a month by moving to 2.0; you're better off just going straight to "
"2.0.  Most of the really interesting features described in this document are "
"only in 2.0, because a lot of work was done between May and September."
msgstr ""
"では、あなたは Python 1.6 に興味を示すべきでしょうか? おそらく答えはノーで"
"す。1.6final と 2.0beta1 のリリースは同じ日に行われ (2000 年 9 月 5 日)、"
"Python 2.0 のファイナライズはその一ヶ月かそこらで行われるよう計画されました。"
"もしあなたが保守すべきアプリケーションを持っているならば、1.6 への移行には少"
"しばかりコードの破壊を伴うようです。つまりその修正を行い、一ヶ月の間に 2.0 へ"
"の移行による別の破壊ラウンドがやってきます。直接 2.0 に移行したほうが良いで"
"しょう。このドキュメントに記載する、ほとんどの面白い機能は 2.0 のみのものであ"
"り、なぜならほとんどの作業は、5 月から 9 月の間に行われたからなのです。"

#: ../../whatsnew/2.0.rst:57
msgid "New Development Process"
msgstr "新しい開発プロセス"

#: ../../whatsnew/2.0.rst:59
msgid ""
"The most important change in Python 2.0 may not be to the code at all, but "
"to how Python is developed: in May 2000 the Python developers began using "
"the tools made available by SourceForge for storing  source code, tracking "
"bug reports, and managing the queue of patch submissions.  To report bugs or "
"submit patches for Python 2.0, use the bug tracking and patch manager tools "
"available from Python's project page, located at https://sourceforge.net/"
"projects/python/."
msgstr ""
"Python 2.0 における最も重要な変化はコードに対するものではまったくなくて、"
"Python がどのように開発されるのかについてでしょう: 2000 年 5 月に Python 開発"
"者たちは、ソースコード格納、バグ報告の追跡、パッチ提出の待ち行列管理のための "
"SourceForge によって利用出来るようになったツールの使用を始めました。Python "
"2.0 ではバグ報告やパッチの提出には、Python プロジェクトページで利用可能なバグ"
"トラッキングとパッチ管理ツールを使ってください。 https://sourceforge.net/"
"projects/python/ にあります(訳注: 2015 年現在の状況は What's New in Python "
"2.6 参照)。"

#: ../../whatsnew/2.0.rst:66
msgid ""
"The most important of the services now hosted at SourceForge is the Python "
"CVS tree, the version-controlled repository containing the source code for "
"Python. Previously, there were roughly 7 or so people who had write access "
"to the CVS tree, and all patches had to be inspected and checked in by one "
"of the people on this short list. Obviously, this wasn't very scalable.  By "
"moving the CVS tree to SourceForge, it became possible to grant write access "
"to more people; as of September 2000 there were 27 people able to check in "
"changes, a fourfold increase.  This makes possible large-scale changes that "
"wouldn't be attempted if they'd have to be filtered through the small group "
"of core developers.  For example, one day Peter Schneider-Kamp took it into "
"his head to drop K&R C compatibility and convert the C source for Python to "
"ANSI C. After getting approval on the python-dev mailing list, he launched "
"into a flurry of checkins that lasted about a week, other developers joined "
"in to help, and the job was done.  If there were only 5 people with write "
"access, probably that task would have been viewed as \"nice, but not worth "
"the time and effort needed\" and it would never have gotten done."
msgstr ""
"SourceForge で現在ホストされているサービスの中で最も重要なのは Python CVS ツ"
"リーで、Python のソースコードを含む、バージョンコントロールされたレポジトリで"
"す。以前までは、CVS ツリーへの書き込み許可を持つ人々が 7 人ほどいて、全ての"
"パッチはその中の一人が精査とチェックをする必要がありました。明らかにこれはス"
"ケーラブルではありませんでした。CVS ツリーを SourceForge に移動することで、よ"
"り多くの人々に書き込み許可を与えることが可能になりました; 2000 年 9 月時点"
"で、27 人の人々が変更をチェックイン出来るようになっていました。これは 4 倍の"
"増加です。これは大規模な変更、これまでであれば小さなコア開発グループによる"
"フィルタを経由しなければならないために試みられなかったような、大規模な変更を"
"可能にしています。例えばある日 Peter Schneider-Kamp は K&R C 互換を落としてし"
"まうことを思い立ち、Python の C ソースを ANSI C に変換しました。python-dev "
"メーリングリストでの承認を得たのち、彼は立て続けにチェックインを開始しておよ"
"そ一週間ほどで終わらせ、ほかの開発者たちも手助けに参加し、そして作業は完了し"
"ました。書き込み許可が 5 人だけだったならば、おそらくそのタスクはこう見做され"
"たでしょう:「素晴らしい。けれども時間と労力に見合わない」。そして決して実現す"
"ることはなかったことでしょう。"

#: ../../whatsnew/2.0.rst:83
msgid ""
"The shift to using SourceForge's services has resulted in a remarkable "
"increase in the speed of development.  Patches now get submitted, commented "
"on, revised by people other than the original submitter, and bounced back "
"and forth between people until the patch is deemed worth checking in.  Bugs "
"are tracked in one central location and can be assigned to a specific person "
"for fixing, and we can count the number of open bugs to measure progress.  "
"This didn't come without a cost: developers now have more e-mail to deal "
"with, more mailing lists to follow, and special tools had to be written for "
"the new environment. For example, SourceForge sends default patch and bug "
"notification e-mail messages that are completely unhelpful, so Ka-Ping Yee "
"wrote an HTML screen-scraper that sends more useful messages."
msgstr ""
"SourceForge のサービスを使うことへのシフトは、開発の目覚しいスピードアップを"
"もたらしました。パッチはいまや、提出され、コメントされ、提出者以外の別人に"
"よって改定されて戻ってきて、などなどが、パッチがチェックインの価値があると判"
"断されるまで行われています。バグは唯一つの中央保管庫で追跡され、修正には特定"
"の誰かを割り当てることが出来、そして私たちはオープンバグを進捗の指標として考"
"えることが出来ます。これは代償なしでは達成しませんでした; 開発者には今や以前"
"よりもたくさんの処理すべき電子メールがあり、より多くメーリングリストに追従し"
"なければならず、そして新しい環境のための特別なツールを要しました。例えば、"
"SourceForge はデフォルトでパッチ提出とバグ報告を電子メールで通知しますが、こ"
"れは全く助けにならないもので、Ka-Ping Yee はもっと有用なメッセージを送信する"
"ための HTML スクリーンスクレイパを書きました。"

#: ../../whatsnew/2.0.rst:95
msgid ""
"The ease of adding code caused a few initial growing pains, such as code was "
"checked in before it was ready or without getting clear agreement from the "
"developer group.  The approval process that has emerged is somewhat similar "
"to that used by the Apache group. Developers can vote +1, +0, -0, or -1 on a "
"patch; +1 and -1 denote acceptance or rejection, while +0 and -0 mean the "
"developer is mostly indifferent to the change, though with a slight positive "
"or negative slant.  The most significant change from the Apache model is "
"that the voting is essentially advisory, letting Guido van Rossum, who has "
"Benevolent Dictator For Life status, know what the general opinion is. He "
"can still ignore the result of a vote, and approve or reject a change even "
"if the community disagrees with him."
msgstr ""
"簡単にコードを追加出来るようになったことは、当初少し苦痛を大きくしました。例"
"えばコードが不十分なままだったり、開発グループからのはっきりとした承諾のない"
"ままチェックインされたりするといったことです。浮上してきた承認プロセスは、"
"Apache グループが使っているようなものにいくらか似たものです。開発者たちは "
"+1, +0, -0, -1 というふうにパッチに投票できます; +1 と -1 は承諾、却下を表"
"し、+0 と -0 は、開発者は変更にほとんど興味がないけれどもやや肯定、否定の傾向"
"であることを意味します。Apache モデルからの最も大きな違いは、投票行為は本質的"
"に助言であって、優しい終身独裁者 Guido van Rossum 侯に大衆の民意を伝えるもの"
"であることです。彼は投票結果をそれでも無視出来ますし、コミュニティが異論を唱"
"えようが変更を承認したり却下したり出来ます。"

#: ../../whatsnew/2.0.rst:106
msgid ""
"Producing an actual patch is the last step in adding a new feature, and is "
"usually easy compared to the earlier task of coming up with a good design. "
"Discussions of new features can often explode into lengthy mailing list "
"threads, making the discussion hard to follow, and no one can read every "
"posting to python-dev.  Therefore, a relatively formal process has been set "
"up to write Python Enhancement Proposals (PEPs), modelled on the Internet "
"RFC process.  PEPs are draft documents that describe a proposed new feature, "
"and are continually revised until the community reaches a consensus, either "
"accepting or rejecting the proposal.  Quoting from the introduction to PEP "
"1, \"PEP Purpose and Guidelines\":"
msgstr ""
"実際のパッチの作成は新機能の追加での最後のステップであり、通常、良いデザイン"
"を工面する前のタスクと容易に比較出来ます。一方で新機能についての議論はしばし"
"ばメーリングリストでの長大なスレッドを巻き起こし、議論に追いつくのが大変にな"
"り、そして誰も python-dev の投稿全てを読めません。それゆえに、Python 拡張提"
"案 (Python Enhancement Proposals: PEPs)を書く、相対的に形式ばったプロセスが、"
"始動しました。インターネットの RFC をモデルにしたものです。PEPs は新機能提案"
"を記述した草案文書であり、コミュニティの合意として提案が承認されるか却下され"
"るまで継続的に改定されます。PEP 1 の導入部、\"PEP の目的とガイドライン\" から"
"引用します:"

#: ../../whatsnew/2.0.rst:120
msgid ""
"PEP stands for Python Enhancement Proposal.  A PEP is a design document "
"providing information to the Python community, or describing a new feature "
"for Python.  The PEP should provide a concise technical specification of the "
"feature and a rationale for the feature."
msgstr ""
"PEP は Python Enhancement Proposal を意味します。PEP は、Python コミュニティ"
"に対して情報を提供する、あるいは Python の新機能について記述する設計文書で"
"す。PEP は、機能についての技術的な仕様とその機能の論拠(理論)を簡潔に伝えるべ"
"きです。"

#: ../../whatsnew/2.0.rst:125
msgid ""
"We intend PEPs to be the primary mechanisms for proposing new features, for "
"collecting community input on an issue, and for documenting the design "
"decisions that have gone into Python.  The PEP author is responsible for "
"building consensus within the community and documenting dissenting opinions."
msgstr ""
"私たちは PEP が新機能提案にかかる、コミュニティによる問題提起の集積と Python "
"になされる設計決断の文書化のための最上位の機構となることを意図しています。"
"PEP の著者にはコミュニティ内の合意形成を行うこと、反対意見を文書化することの"
"責務があります。"

#: ../../whatsnew/2.0.rst:130
msgid ""
"Read the rest of PEP 1 for the details of the PEP editorial process, style, "
"and format.  PEPs are kept in the Python CVS tree on SourceForge, though "
"they're not part of the Python 2.0 distribution, and are also available in "
"HTML form from https://www.python.org/dev/peps/.  As of September 2000, "
"there are 25 PEPS, ranging from PEP 201, \"Lockstep Iteration\", to PEP 225, "
"\"Elementwise/Objectwise Operators\"."
msgstr ""
"PEP の編集に関するプロセス、様式、体裁についての詳細が PEP 1 の残りの部分に書"
"かれています。PEPs は SourceForge 上の Python CVS ツリーで営まれますが "
"Python 2.0 配布物の一部ではなく、 https://www.python.org/dev/peps/ で HTML 形"
"式で利用可能です。2000 年 9 月時点で PEP 201 の \"Lockstep Iteration\" から "
"PEP 225 の \"Elementwise/Objectwise Operators\" までの 25 の PEP があります。"

#: ../../whatsnew/2.0.rst:141
msgid "Unicode"
msgstr "Unicode"

#: ../../whatsnew/2.0.rst:143
msgid ""
"The largest new feature in Python 2.0 is a new fundamental data type: "
"Unicode strings.  Unicode uses 16-bit numbers to represent characters "
"instead of the 8-bit number used by ASCII, meaning that 65,536 distinct "
"characters can be supported."
msgstr ""
"Python 2.0 での最大の新機能は新しい基礎データ型、Unicode 文字列です。Unicode "
"は文字を表現するのに ASCII で使用される 8 ビット数の代わりに 16 ビットを使い"
"ます。これによって 65,536 の個別の文字がサポート出来ます。(---訳注: Unicode "
"の扱いはまず Python 2.2 で UCS4 が使えるように拡張され(つまり 32 ビットに拡"
"張)、Python 3 では Unicode が唯一の文字列型に変更されています。後者の変更点は"
"非常に大きいですが、クックブックの「Python 2 から Python 3 への移植」に比較的"
"よくまとめられています。---)"

#: ../../whatsnew/2.0.rst:148
msgid ""
"The final interface for Unicode support was arrived at through countless "
"often-stormy discussions on the python-dev mailing list, and mostly "
"implemented by Marc-André Lemburg, based on a Unicode string type "
"implementation by Fredrik Lundh.  A detailed explanation of the interface "
"was written up as :pep:`100`, \"Python Unicode Integration\". This article "
"will simply cover the most significant points about the Unicode interfaces."
msgstr ""
"最終的な Unicode サポートに関するインターフェイスは、python-dev メーリングリ"
"ストにおける数え切れない、時として嵐のような議論を経て、Fredrik Lundh によっ"
"て実装された Unicode 文字列型に基づいて、ほとんどが Marc-André Lemburg によっ"
"て実装されました。インターフェイスについての詳細な説明は :pep:`100` 「Python "
"Unicode の統合」に記述されました。今ここでは、Unicode インターフェイスについ"
"て、一番重要な点を単純にカバーするだけにしましょう。"

#: ../../whatsnew/2.0.rst:155
msgid ""
"In Python source code, Unicode strings are written as ``u\"string\"``.  "
"Arbitrary Unicode characters can be written using a new escape sequence, "
"``\\uHHHH``, where *HHHH* is a 4-digit hexadecimal number from 0000 to "
"FFFF.  The existing ``\\xHHHH`` escape sequence can also be used, and octal "
"escapes can be used for characters up to U+01FF, which is represented by "
"``\\777``."
msgstr ""
"Python ソースコード内では Unicode 文字列は ``u\"string\"`` のように書きます。"
"任意の Unicode 文字は新しく追加されたエスケープシーケンスで書きます。 "
"``\\uHHHH`` のように書き、 *HHHH* は 0000 から FFFF までの 4 桁の 16 進表記数"
"です。以前からあるエスケープシーケンス ``\\xHHHH`` も使えますし、8 進表記"
"も、 ``\\777`` で表現される U+01FF までの文字に使えます。"

#: ../../whatsnew/2.0.rst:161
msgid ""
"Unicode strings, just like regular strings, are an immutable sequence type. "
"They can be indexed and sliced, but not modified in place. Unicode strings "
"have an ``encode( [encoding] )`` method that returns an 8-bit string in the "
"desired encoding.  Encodings are named by strings, such as ``'ascii'``, "
"``'utf-8'``, ``'iso-8859-1'``, or whatever.  A codec API is defined for "
"implementing and registering new encodings that are then available "
"throughout a Python program. If an encoding isn't specified, the default "
"encoding is usually 7-bit ASCII, though it can be changed for your Python "
"installation by calling the ``sys.setdefaultencoding(encoding)`` function in "
"a customised version of :file:`site.py`."
msgstr ""
"Unicode 文字列は普通の文字列と全く似ていて、 :term:`immutable` なシーケンス型"
"です。添え字でアクセス出来、スライス出来ますが、インプレイスに変更することは"
"出来ません。Unicode 文字列は ``encode( [encoding] )`` メソッドを持っていて、"
"これは望みのエンコーディングでエンコードした 8 ビット文字列を返します。エン"
"コーディングは文字列で名前付けられていて、例えば ``'ascii'``, ``'utf-8'``, "
"``'iso-8859-1'`` のようなものです。コーデック API は、新しいエンコーディング"
"を実装し、Python プログラム全体を通して利用可能となるよう登録するために定義さ"
"れています。エンコーディングが指定されない場合はデフォルトのエンコーディング"
"は普通 7 ビット ASCII ですが、Python インストレーションにおいて、 :file:"
"`site.py` のカスタマイズ版内で ``sys.setdefaultencoding(encoding)`` を呼び出"
"すことで変更出来ます。"

#: ../../whatsnew/2.0.rst:172
msgid ""
"Combining 8-bit and Unicode strings always coerces to Unicode, using the "
"default ASCII encoding; the result of ``'a' + u'bc'`` is ``u'abc'``."
msgstr ""
"8 ビット文字列と Unicode 文字列を結合すると常に、デフォルトの ASCII エンコー"
"ディングを使って Unicode に型変換されます。 ``'a' + u'bc'`` の結果は "
"``u'abc'`` になります。"

#: ../../whatsnew/2.0.rst:175
msgid ""
"New built-in functions have been added, and existing built-ins modified to "
"support Unicode:"
msgstr ""
"新たなビルトイン関数が追加され、既存のビルトイン関数も Unicode サポートのため"
"に修正されました:"

#: ../../whatsnew/2.0.rst:178
msgid ""
"``unichr(ch)`` returns a Unicode string 1 character long, containing the "
"character *ch*."
msgstr ""
"``unichr(ch)`` は Unicode におけるコードが整数 *ch* になるような文字 1 文字か"
"らなる Unicode 文字列を返します。"

#: ../../whatsnew/2.0.rst:181
msgid ""
"``ord(u)``, where *u* is a 1-character regular or Unicode string, returns "
"the number of the character as an integer."
msgstr ""
"*u* が 1 文字の通常文字あるいは Unicode 文字として、 ``ord(u)`` はコードを整"
"数で返します。"

#: ../../whatsnew/2.0.rst:184
msgid ""
"``unicode(string [, encoding]  [, errors] )`` creates a Unicode string from "
"an 8-bit string.  ``encoding`` is a string naming the encoding to use. The "
"``errors`` parameter specifies the treatment of characters that are invalid "
"for the current encoding; passing ``'strict'`` as the value causes an "
"exception to be raised on any encoding error, while ``'ignore'`` causes "
"errors to be silently ignored and ``'replace'`` uses U+FFFD, the official "
"replacement character, in case of any problems."
msgstr ""
"``unicode(string [, encoding] [, errors] )`` は、8 ビット文字列から Unicode "
"文字列を作ります。 ``encoding`` は使用するエンコーディング名の文字列です。 "
"``errors`` パラメータは、現在エンコーディングにおいて不正な文字の扱いを指示し"
"ます; これに値として ``'strict'`` を渡すと全てのエンコーディングエラーに対"
"し、例外を引き起こします。 ``'ignore'`` を渡すとエラーは黙って無視されます。 "
"``'replace'`` を渡すと、全ての問題ケースで、公式な置き換え文字である U+FFFD "
"に置き換えます。"

#: ../../whatsnew/2.0.rst:192
msgid ""
"The :keyword:`exec` statement, and various built-ins such as ``eval()``, "
"``getattr()``, and ``setattr()`` will also accept Unicode strings as well as "
"regular strings.  (It's possible that the process of fixing this missed some "
"built-ins; if you find a built-in function that accepts strings but doesn't "
"accept Unicode strings at all, please report it as a bug.)"
msgstr ""
"``exec`` 文や　``eval()``, ``getattr()``, ``setattr()`` のような色々なビルト"
"インも、普通の文字列同様に Unicode 文字列を受け付けるようになりました。(この"
"修正をするプロセスをいくつかのビルトインで忘れている可能性もあります。文字列"
"を受け取るものが Unicode を全く受け取らないビルトインを見つけたら、バグとして"
"報告してください。)"

#: ../../whatsnew/2.0.rst:198
msgid ""
"A new module, :mod:`unicodedata`, provides an interface to Unicode character "
"properties.  For example, ``unicodedata.category(u'A')`` returns the 2-"
"character string 'Lu', the 'L' denoting it's a letter, and 'u' meaning that "
"it's uppercase. ``unicodedata.bidirectional(u'\\u0660')`` returns 'AN', "
"meaning that U+0660 is an Arabic number."
msgstr ""
"新規モジュール :mod:`unicodedata` は、Unicode 文字の特性へのインターフェイス"
"を提供します。例えば ``unicodedata.category(u'A')`` は 2 文字の文字列 'Lu' を"
"返しますが、これは、 'L' が letter を、 'u' が uppercase を表します。 "
"``unicodedata.bidirectional(u'\\u0660')`` は 'AN' を返し、これは U+0660 が "
"Arabic Number であることを表します。"

#: ../../whatsnew/2.0.rst:204
msgid ""
"The :mod:`codecs` module contains functions to look up existing encodings "
"and register new ones.  Unless you want to implement a new encoding, you'll "
"most often use the ``codecs.lookup(encoding)`` function, which returns a 4-"
"element tuple: ``(encode_func, decode_func, stream_reader, stream_writer)``."
msgstr ""
":mod:`codecs` モジュールには、既存のエンコーディングをルックアップする関数、"
"新しいエンコーディングを登録する関数が含まれます。新しいエンコーディングを実"
"装したいと思うのでない限りは、一番使うことになるのは ``codecs."
"lookup(encoding)`` でしょう。これは 4 要素のタプルを返します: "
"``(encode_func, decode_func, stream_reader, stream_writer)`` 。"

#: ../../whatsnew/2.0.rst:209
msgid ""
"*encode_func* is a function that takes a Unicode string, and returns a 2-"
"tuple ``(string, length)``.  *string* is an 8-bit string containing a "
"portion (perhaps all) of the Unicode string converted into the given "
"encoding, and *length* tells you how much of the Unicode string was "
"converted."
msgstr ""
"*encode_func* は、Unicode 文字列を受け取って 2 要素タプル ``(string, "
"length)`` を返す関数です。 *string* は、与えられたエンコーディングで Unicode "
"文字列を変換した部分 (おそらく全体) を含む 8 ビット文字列で、 *length* は何文"
"字の Unicode 文字列が変換されたかを伝えます。"

#: ../../whatsnew/2.0.rst:214
msgid ""
"*decode_func* is the opposite of *encode_func*, taking an 8-bit string and "
"returning a 2-tuple ``(ustring, length)``, consisting of the resulting "
"Unicode string *ustring* and the integer *length* telling how much of the 8-"
"bit string was consumed."
msgstr ""
"*decode_func* は *encode_func* の対となる関数で、8 ビット文字列を受け取って、"
"2 要素のタプル ``(ustring, length)`` を返します。 *ustring* が結果の Unicode "
"文字列で、整数 *length* が、8 ビット文字列何文字が消費されたかを表します。"

#: ../../whatsnew/2.0.rst:219
msgid ""
"*stream_reader* is a class that supports decoding input from a stream. "
"*stream_reader(file_obj)* returns an object that supports the :meth:`read`, :"
"meth:`readline`, and :meth:`readlines` methods.  These methods will all "
"translate from the given encoding and return Unicode strings."
msgstr ""
"*stream_reader* は、ストリームからの入力のデコードをサポートするクラスです。 "
"*stream_reader(file_obj)* はメソッド :meth:`read`, :meth:`readline`, :meth:"
"`readlines` をサポートするオブジェクトを返します。これらのメソッドは与えられ"
"たエンコーディングで全て変換して Unicode 文字列を返します。"

#: ../../whatsnew/2.0.rst:224
msgid ""
"*stream_writer*, similarly, is a class that supports encoding output to a "
"stream.  *stream_writer(file_obj)* returns an object that supports the :meth:"
"`write` and :meth:`writelines` methods.  These methods expect Unicode "
"strings, translating them to the given encoding on output."
msgstr ""
"*stream_writer* は同じように、ストリームへのエンコードした出力をサポートする"
"クラスです。 *stream_writer(file_obj)* はメソッド :meth:`write` と :meth:"
"`writelines` をサポートするオブジェクトを返します。これらメソッドは Unicode "
"文字列を期待して、それらを与えられたエンコーディングで変換して出力します。"

#: ../../whatsnew/2.0.rst:229
msgid ""
"For example, the following code writes a Unicode string into a file,  "
"encoding it as UTF-8::"
msgstr ""
"例えば以下のコードは Unicode 文字列を UTF-8 でエンコーディングしてファイルに"
"書きます::"

#: ../../whatsnew/2.0.rst:243
msgid "The following code would then read UTF-8 input from the file::"
msgstr "そして以下コードではファイルから UTF-8 で読めます::"

#: ../../whatsnew/2.0.rst:249
msgid ""
"Unicode-aware regular expressions are available through the :mod:`re` "
"module, which has a new underlying implementation called SRE written by "
"Fredrik Lundh of Secret Labs AB."
msgstr ""
":mod:`re` モジュールでは Unicode 対応した正規表現が利用可能で、これは新しい根"
"底となる SRE なる実装から成り、Secret Labs AB の Fredrik Lundh によって書かれ"
"ました。"

#: ../../whatsnew/2.0.rst:253
msgid ""
"A ``-U`` command line option was added which causes the Python compiler to "
"interpret all string literals as Unicode string literals. This is intended "
"to be used in testing and future-proofing your Python code, since some "
"future version of Python may drop support for 8-bit strings and provide only "
"Unicode strings."
msgstr ""
"Python コンパイラに全ての文字列リテラルを Unicode 文字列として解釈させるため"
"の ``-U`` コマンドラインオプションが追加されました。これはあなたの Python "
"コードのテストと将来の保障を意図しています。というのも、将来の Python バー"
"ジョンでは 8 ビット文字列のサポートがなくなって、Unicode 文字列だけとなる予定"
"だからです。 (---訳注: ここで言っている将来バージョンとは、結果的には Python "
"3 になりました。What's New での明記はないのですが ``-U`` オプションは Python "
"2.7 時点では存在していません。ですが同じことは 2.6 以降では ``from "
"__future__ import unicode_literals`` で出来ます。 ---)"

#: ../../whatsnew/2.0.rst:262
msgid "List Comprehensions"
msgstr "リストの内包表記"

#: ../../whatsnew/2.0.rst:264
msgid ""
"Lists are a workhorse data type in Python, and many programs manipulate a "
"list at some point.  Two common operations on lists are to loop over them, "
"and either pick out the elements that meet a certain criterion, or apply "
"some function to each element.  For example, given a list of strings, you "
"might want to pull out all the strings containing a given substring, or "
"strip off trailing whitespace from each line."
msgstr ""
"リストというのは Python の馬車馬データ型で、多くのプログラムがリストをいつか"
"は操るものです。リストの操作での 2 つのよくある操作は、それらについてループ"
"し、あるいは特定の基準に合致したものを取り出すか個々の要素にある関数を適用す"
"るかする、といったものです。例えば文字列のリストが与えられた場合、特定の部分"
"文字列を含む全ての文字列を引き抜いたり、あるいは各行から末尾の空白を取り除い"
"たりしたいでしょう。"

#: ../../whatsnew/2.0.rst:271
msgid ""
"The existing :func:`map` and :func:`filter` functions can be used for this "
"purpose, but they require a function as one of their arguments.  This is "
"fine if there's an existing built-in function that can be passed directly, "
"but if there isn't, you have to create a little function to do the required "
"work, and Python's scoping rules make the result ugly if the little function "
"needs additional information.  Take the first example in the previous "
"paragraph, finding all the strings in the list containing a given "
"substring.  You could write the following to do it::"
msgstr ""
"既にあった :func:`map` 関数、 :func:`filter` 関数がこの目的のためには使えます"
"が、それらにはその引数の一つに関数が必要です。何か既存のビルトイン関数で直接"
"渡せるものがあればよいのですが、これがない場合その必要とされる仕事をする小さ"
"な関数を作る必要があって、また、Python のスコープ規則によって、その小さな関数"
"が何かほかの情報を必要とする場合に醜いものになります。前パラグラフでの最初の"
"例を考えましょう。指定の部分文字列を含む文字列リストから全てを探す例です。こ"
"のように書けるでしょう::"

#: ../../whatsnew/2.0.rst:286
msgid ""
"Because of Python's scoping rules, a default argument is used so that the "
"anonymous function created by the :keyword:`lambda` statement knows what "
"substring is being searched for.  List comprehensions make this cleaner::"
msgstr ""
"Python のスコープ規則のために、 :keyword:`lambda` ステートメントで作っている"
"匿名関数にデフォルト引数を使い、これに検索対象の部分文字列を渡しています。リ"
"スト内包表記はこれを明快にします::"

#: ../../whatsnew/2.0.rst:292
msgid "List comprehensions have the form::"
msgstr "リスト内包表記は以下の形式を持ちます::"

#: ../../whatsnew/2.0.rst:299
msgid ""
"The :keyword:`for`...\\ :keyword:`in` clauses contain the sequences to be "
"iterated over.  The sequences do not have to be the same length, because "
"they are *not* iterated over in parallel, but from left to right; this is "
"explained more clearly in the following paragraphs.  The elements of the "
"generated list will be the successive values of *expression*.  The final :"
"keyword:`if` clause is optional; if present, *expression* is only evaluated "
"and added to the result if *condition* is true."
msgstr ""
":keyword:`for`...\\ :keyword:`in` 節はイテレートするシーケンスを含みます。"
"シーケンス群は同じ長さである必要はありません。それらは並列でイテレートされる "
"*のではなく* 左から右の順で周ります。続くパラグラフでもっとわかりやすく説明し"
"ます。生成されるリストの要素は一連の *expression* の値となります。最後の :"
"keyword:`if` 節はオプショナルです。これがあれば *expression* は *condition* "
"が真の場合にのみ評価・追加されます。"

#: ../../whatsnew/2.0.rst:307
msgid ""
"To make the semantics very clear, a list comprehension is equivalent to the "
"following Python code::"
msgstr ""
"セマンティクスについてとてもわかりやすく説明しておきましょう。リスト内包は以"
"下の Python コードと等価です::"

#: ../../whatsnew/2.0.rst:319
msgid ""
"This means that when there are multiple :keyword:`for`...\\ :keyword:`in` "
"clauses, the resulting list will be equal to the product of the lengths of "
"all the sequences.  If you have two lists of length 3, the output list is 9 "
"elements long::"
msgstr ""
"つまり、複数の :keyword:`for`...\\ :keyword:`in` 節があって ``if`` がないとき"
"の最終出力は、長さが各シーケンス長の積に等しくなるということです。長さ 3 のリ"
"スト二つなら、出力リストの長さは 9 要素です::"

#: ../../whatsnew/2.0.rst:330
msgid ""
"To avoid introducing an ambiguity into Python's grammar, if *expression* is "
"creating a tuple, it must be surrounded with parentheses.  The first list "
"comprehension below is a syntax error, while the second one is correct::"
msgstr ""
"Python の文法に曖昧さを紛れ込ませないように、*expression* でタプルを作るなら"
"括弧で囲わなくてはなりません。下にあるリスト内包表記で、最初のは構文エラーで"
"すが、二番目は有効です::"

#: ../../whatsnew/2.0.rst:339
msgid ""
"The idea of list comprehensions originally comes from the functional "
"programming language Haskell (https://www.haskell.org).  Greg Ewing argued "
"most effectively for adding them to Python and wrote the initial list "
"comprehension patch, which was then discussed for a seemingly endless time "
"on the python-dev mailing list and kept up-to-date by Skip Montanaro."
msgstr ""
"リスト内包表記のアイディアは、もともとは関数型プログラミング言語 Haskell "
"(https://www.haskell.org) に由来しています。Greg Ewing が Python にこれを追加"
"することを最も実際的に主張し、彼が最初のリスト内包のパッチを書きました。それ"
"は傍目には終わりのない議論が python-dev メーリングリストにて続き、Skip "
"Montanaro によって最新に保たれました。"

#: ../../whatsnew/2.0.rst:349
msgid "Augmented Assignment"
msgstr "累算代入 (Augmented Assignment)"

#: ../../whatsnew/2.0.rst:351
msgid ""
"Augmented assignment operators, another long-requested feature, have been "
"added to Python 2.0.  Augmented assignment operators include ``+=``, ``-=``, "
"``*=``, and so forth.  For example, the statement ``a += 2`` increments the "
"value of the variable  ``a`` by 2, equivalent to the slightly lengthier ``a "
"= a + 2``."
msgstr ""
"累算代入はもう一つの長らく待ち望まれた機能であり、Python 2.0 に追加されまし"
"た。累算代入演算子には  ``+=``, ``-=``, ``*=`` などがあります。例えばステート"
"メント ``a += 2`` は変数 ``a`` に 2 を加算し、これはちょっとだけ長い記述 ``a "
"= a + 2`` と同じです。"

#: ../../whatsnew/2.0.rst:356
msgid ""
"The full list of supported assignment operators is ``+=``, ``-=``, ``*=``, "
"``/=``, ``%=``, ``**=``, ``&=``, ``|=``, ``^=``, ``>>=``, and ``<<=``.  "
"Python classes can override the augmented assignment operators by defining "
"methods named :meth:`__iadd__`, :meth:`__isub__`, etc.  For example, the "
"following :class:`Number` class stores a number and supports using += to "
"create a new instance with an incremented value."
msgstr ""
"サポートされる累算代入演算子をぜんぶ列挙すれば、 ``+=``, ``-=``, ``*=``, ``/"
"=``, ``%=``, ``**=``, ``&=``, ``|=``, ``^=``, ``>>=``, ``<<=`` です。Python "
"のクラスは累算代入演算子をオーバライド出来ます。 :meth:`__iadd__`, :meth:"
"`__isub__` などのメソッドを定義することで行います。例えば、以下の :class:"
"`Number` クラスは数値を格納し、 ``+=`` を使って増分値で新たなインスタンスを作"
"ります。"

#: ../../whatsnew/2.0.rst:377
msgid ""
"The :meth:`__iadd__` special method is called with the value of the "
"increment, and should return a new instance with an appropriately modified "
"value; this return value is bound as the new value of the variable on the "
"left-hand side."
msgstr ""
"特殊メソッド :meth:`__iadd__` は増分値を引数に呼び出され、適切な修正された値"
"を持った新たなインスタンスを返さなければなりません。この戻り値は左辺の新しい"
"値として束縛されます。"

#: ../../whatsnew/2.0.rst:381
msgid ""
"Augmented assignment operators were first introduced in the C programming "
"language, and most C-derived languages, such as :program:`awk`, C++, Java, "
"Perl, and PHP also support them.  The augmented assignment patch was "
"implemented by Thomas Wouters."
msgstr ""
"累算代入演算子は最初に C 言語で導入されて、 :program:`awk`, C++, Java, Perl, "
"PHP といった C から派生した言語のほとんどでサポートされています。累算代入の"
"パッチは Thomas Wouters により実装されました。"

#: ../../whatsnew/2.0.rst:390
msgid "String Methods"
msgstr "文字列メソッド"

#: ../../whatsnew/2.0.rst:392
msgid ""
"Until now string-manipulation functionality was in the :mod:`string` module, "
"which was usually a front-end for the :mod:`strop` module written in C.  The "
"addition of Unicode posed a difficulty for the :mod:`strop` module, because "
"the functions would all need to be rewritten in order to accept either 8-bit "
"or Unicode strings.  For functions such as :func:`string.replace`, which "
"takes 3 string arguments, that means eight possible permutations, and "
"correspondingly complicated code."
msgstr ""
"今までは、文字列操作の機能については :mod:`string` モジュール内にあり、これは"
"普通 C で書かれたモジュール :mod:`strop` へのフロントエンドでした。 :mod:"
"`strop` モジュールへの Unicode サポートの追加には困難がありました。8 ビット文"
"字列と Unicode 文字列を受け付けるために全て書き直す必要があったからです。 :"
"func:`string.replace` のような関数は、これは 3 つの文字列引数を取るのであっ"
"て、このことは 8 通りの可能な組合せがあるということで、それに応じてコードが複"
"雑化するものでした。"

#: ../../whatsnew/2.0.rst:400
msgid ""
"Instead, Python 2.0 pushes the problem onto the string type, making string "
"manipulation functionality available through methods on both 8-bit strings "
"and Unicode strings.   ::"
msgstr ""
"代わりに、Python 2.0 は問題を文字列型に押し込み、文字列操作機能が 8 ビット文"
"字列と Unicode 文字列の両方のメソッドを通じて利用可能としました。"

#: ../../whatsnew/2.0.rst:411
msgid ""
"One thing that hasn't changed, a noteworthy April Fools' joke "
"notwithstanding, is that Python strings are immutable. Thus, the string "
"methods return new strings, and do not modify the string on which they "
"operate."
msgstr ""
"変わらない一つのこと、華やかなエイプリルフールのジョークではありませんが、そ"
"れは Python 文字列が :term:`immutable` だということです。ですので文字列メソッ"
"ドは新しい文字列を返し、それが操作する文字列を変更しません。"

#: ../../whatsnew/2.0.rst:415
msgid ""
"The old :mod:`string` module is still around for backwards compatibility, "
"but it mostly acts as a front-end to the new string methods."
msgstr ""
"古い :mod:`string` モジュールはまだ後方互換性のために残されますが、それはほと"
"んど新たな文字列メソッドへのフロントエンドとして振舞います。"

#: ../../whatsnew/2.0.rst:418
msgid ""
"Two methods which have no parallel in pre-2.0 versions, although they did "
"exist in JPython for quite some time, are :meth:`startswith` and :meth:"
"`endswith`. ``s.startswith(t)`` is equivalent to ``s[:len(t)] == t``, while "
"``s.endswith(t)`` is equivalent to ``s[-len(t):] == t``."
msgstr ""
"2.0 以前のバージョンでは共通で相当するものがなくて JPython にはかなり暫くの間"
"存在していたのが、2 つのメソッド :meth:`startswith` と :meth:`endswith` で"
"す。 ``s.startswith(t)`` は ``s[:len(t)] == t`` と等価、 ``s.endswith(t)`` "
"は ``s[-len(t):] == t`` と等価です。"

#: ../../whatsnew/2.0.rst:423
msgid ""
"One other method which deserves special mention is :meth:`join`.  The :meth:"
"`join` method of a string receives one parameter, a sequence of strings, and "
"is equivalent to the :func:`string.join` function from the old :mod:`string` "
"module, with the arguments reversed. In other words, ``s.join(seq)`` is "
"equivalent to the old ``string.join(seq, s)``."
msgstr ""
"特筆しなければならないもう一つ別のメソッドには :meth:`join` があります。文字"
"列の :meth:`join` メソッドは文字列のシーケンスを一つのパラメータとして受け取"
"りますが、これは古い :mod:`string` モジュールの :func:`string.join` と引数が"
"逆ですが同じです。つまり ``s.join(seq)`` と旧式 ``string.join(seq, s)`` が同"
"じです。(---訳注: 「引数が逆」はここだけ読むとわかりにくいかもしれません。"
"string モジュールから文字列メソッドへ置き換えるのにほかは第一引数が self に置"
"き換わっただけにみえるのに対しこれはそうではない、ということです。---)"

#: ../../whatsnew/2.0.rst:433
msgid "Garbage Collection of Cycles"
msgstr "循環参照のガベージコレクション"

#: ../../whatsnew/2.0.rst:435
msgid ""
"The C implementation of Python uses reference counting to implement garbage "
"collection.  Every Python object maintains a count of the number of "
"references pointing to itself, and adjusts the count as references are "
"created or destroyed.  Once the reference count reaches zero, the object is "
"no longer accessible, since you need to have a reference to an object to "
"access it, and if the count is zero, no references exist any longer."
msgstr ""
"Python の C 実装は、ガーベージコレクションの実装に参照カウントを使っていま"
"す。全ての Python オブジェクトは自身を参照している数を維持していて、参照が作"
"成されたり破壊されたりするカウントを調整しています。参照カウントがゼロになれ"
"ばそのオブジェクトにはもはやアクセス出来ません。あなたはそれにアクセスするた"
"めのオブジェクトへの参照を持つ必要がありますが、カウントがゼロならば参照はも"
"はや存在しないということです。"

#: ../../whatsnew/2.0.rst:442
msgid ""
"Reference counting has some pleasant properties: it's easy to understand and "
"implement, and the resulting implementation is portable, fairly fast, and "
"reacts well with other libraries that implement their own memory handling "
"schemes.  The major problem with reference counting is that it sometimes "
"doesn't realise that objects are no longer accessible, resulting in a memory "
"leak.  This happens when there are cycles of references."
msgstr ""
"参照カウントはある種望ましい特徴を持っています。それは理解しやすく、実装しや"
"すく、結果としての実装の移植性は高く、かなり高速であり、そして、独自のメモリ"
"処理方式を実装しているようなほかのライブラリと共にでも良く振舞います。参照カ"
"ウントの主要な問題点は、それが時々、オブジェクトにはもう到達不能であることに"
"気付かないので、結果としてメモリリークを引き起こすことです。これは参照の循環"
"がある場合に発生します。"

#: ../../whatsnew/2.0.rst:449
msgid ""
"Consider the simplest possible cycle,  a class instance which has a "
"reference to itself::"
msgstr ""
"最も単純な循環について考えてみます。クラスインスタンスが自身への参照を持つ場"
"合です::"

#: ../../whatsnew/2.0.rst:455
msgid ""
"After the above two lines of code have been executed, the reference count of "
"``instance`` is 2; one reference is from the variable named ``'instance'``, "
"and the other is from the ``myself`` attribute of the instance."
msgstr ""
"上の例の 2 行のコードが実行された後では、 ``instance`` の参照カウントは 2 で"
"す。参照の一つ目は ``'instance'`` と名付けられた変数からのもので、もう一つの"
"参照は、インスタンスの ``myself`` 属性から来るものです。"

#: ../../whatsnew/2.0.rst:459
msgid ""
"If the next line of code is ``del instance``, what happens?  The reference "
"count of ``instance`` is decreased by 1, so it has a reference count of 1; "
"the reference in the ``myself`` attribute still exists.  Yet the instance is "
"no longer accessible through Python code, and it could be deleted.  Several "
"objects can participate in a cycle if they have references to each other, "
"causing all of the objects to be leaked."
msgstr ""
"このあとに続くコードが ``del instance`` だとしたら、何が起こるでしょうか? "
"``instance`` の参照カウントは 1 減るので参照カウントは 1 になります。 "
"``myself`` 属性内の参照はいまだ存在します。けれどもインスタンスはもう Python "
"コードからは到達不能ですから、本来削除出来るはずです。お互いを参照しあうなら"
"ばいくつものオブジェクトが循環に参加しえるので、結果それら全てのオブジェクト"
"はリークしてしまいます。"

#: ../../whatsnew/2.0.rst:466
msgid ""
"Python 2.0 fixes this problem by periodically executing a cycle detection "
"algorithm which looks for inaccessible cycles and deletes the objects "
"involved. A new :mod:`gc` module provides functions to perform a garbage "
"collection, obtain debugging statistics, and tuning the collector's "
"parameters."
msgstr ""
"Python 2.0 はこの問題を、循環検出アルゴリズムを周期的に実行することにより"
"フィックスします。そのアルゴリズムは、到達不能な循環を探して関係するオブジェ"
"クトを削除します。新しく追加された :mod:`gc` モジュールは、ガーベージコレク"
"ションを実行する関数、デバッグのための統計情報を取得する関数、コレクタのパラ"
"メータを調整する関数を提供します。"

#: ../../whatsnew/2.0.rst:471
msgid ""
"Running the cycle detection algorithm takes some time, and therefore will "
"result in some additional overhead.  It is hoped that after we've gotten "
"experience with the cycle collection from using 2.0, Python 2.1 will be able "
"to minimize the overhead with careful tuning.  It's not yet obvious how much "
"performance is lost, because benchmarking this is tricky and depends "
"crucially on how often the program creates and destroys objects.  The "
"detection of cycles can be disabled when Python is compiled, if you can't "
"afford even a tiny speed penalty or suspect that the cycle collection is "
"buggy, by specifying the :option:`!--without-cycle-gc` switch when running "
"the :program:`configure` script."
msgstr ""
"循環検出アルゴリズムの実行はいくらかの時間がかかるので、結果として多少の追加"
"的なオーバヘッドがかかるでしょう。2.0 を使って循環のコレクションの経験を積ん"
"だのちに、 Python 2.1 では注意深い調整によりオーバヘッドを最小に出来ることが"
"望まれています。今のところパフォーマンスの損失がいかほどなのかは明らかではあ"
"りません。これはこれのベンチマークがトリッキーであり、プログラムがどれだけの"
"頻度でオブジェクトを構築・破棄するのかに大きく依存するからです。循環の検出は "
"Python コンパイル時に無効に出来ます。もしもあなたが小さな速度のペナルティでさ"
"えも許容出来ないであるとか、あるいは循環のコレクションがバギーであることを疑"
"うのであれば、 :program:`configure` スクリプト実行時に :option:`!--without-"
"cycle-gc` スイッチを与えることでそうすることが出来ます。 (---訳注: Python "
"2.3 でこの循環参照の GC は必須となり、 :option:`!--without-cycle-gc` 、 :"
"option:`!--with-cycle-gc` での有無効化は撤廃されました。---)"

#: ../../whatsnew/2.0.rst:482
msgid ""
"Several people tackled this problem and contributed to a solution.  An early "
"implementation of the cycle detection approach was written by Toby Kelsey.  "
"The current algorithm was suggested by Eric Tiedemann during a visit to "
"CNRI, and Guido van Rossum and Neil Schemenauer wrote two different "
"implementations, which were later integrated by Neil.  Lots of other people "
"offered suggestions along the way; the March 2000 archives of the python-dev "
"mailing list contain most of the relevant discussion, especially in the "
"threads titled \"Reference cycle collection for Python\" and \"Finalization "
"again\"."
msgstr ""
"何人かの人々がこの問題に体当たりで取り組み、解決に対する貢献をしました。循環"
"検出アプローチの初期の実装は、Toby Kelsey により書かれました。現在のアルゴリ"
"ズムは CNRI を訪れている間に Eric Tiedemann によって提案されて、Guido van "
"Rossum と Neil Schemenauer が別々の 2 つの実装を書いて、あとで Neil によって"
"統合されたものです。そこに至るまでにもほかの数多くの人々によって提案がなされ"
"ました。python-dev メーリングリストの 2000 年 3 月のアーカイブに、これに関す"
"るほとんどの議論が含まれています。特にタイトルが \"Reference cycle "
"collection for Python\" と \"Finalization again\" のスレッドです。"

#: ../../whatsnew/2.0.rst:495
msgid "Other Core Changes"
msgstr "その他の言語コアの変更"

#: ../../whatsnew/2.0.rst:497
msgid ""
"Various minor changes have been made to Python's syntax and built-in "
"functions. None of the changes are very far-reaching, but they're handy "
"conveniences."
msgstr ""
"Python 文法とビルトイン関数について、色々マイナーな変更がなされました。影響が"
"広範囲に及ぶものは一つもありませんが、手軽で便利なものです。"

#: ../../whatsnew/2.0.rst:502
msgid "Minor Language Changes"
msgstr "言語のマイナー変更"

#: ../../whatsnew/2.0.rst:504
msgid ""
"A new syntax makes it more convenient to call a given function with a tuple "
"of arguments and/or a dictionary of keyword arguments. In Python 1.5 and "
"earlier, you'd use the :func:`apply` built-in function: ``apply(f, args, "
"kw)`` calls the function :func:`f` with the argument tuple *args* and the "
"keyword arguments in the dictionary *kw*.  :func:`apply`  is the same in "
"2.0, but thanks to a patch from Greg Ewing, ``f(*args, **kw)`` is a shorter "
"and clearer way to achieve the same effect.  This syntax is symmetrical with "
"the syntax for defining functions::"
msgstr ""
"引数のタプルとキーワード引数の辞書の一方あるいは両方で関数を呼び出すのに、よ"
"り便利な構文が追加されました。Python 1.5 とそれ以前ではビルトイン関数 :func:"
"`apply` を使っていました: ``apply(f, args, kw)`` は引数タプル *args* と辞書 "
"*kw* に入れたキーワード引数で関数 :func:`f` を呼び出します。 :func:`apply` "
"は 2.0 でも同じですが、Greg Ewing によるパッチのおかげで、同じ効果を得るのに"
"より短くてわかりやすい ``f(*args, **kw)`` が使えます。この構文は以下のような"
"関数定義に呼応するものです::"

#: ../../whatsnew/2.0.rst:518
msgid ""
"The :keyword:`print` statement can now have its output directed to a file-"
"like object by following the :keyword:`print` with  ``>> file``, similar to "
"the redirection operator in Unix shells. Previously you'd either have to use "
"the :meth:`write` method of the file-like object, which lacks the "
"convenience and simplicity of :keyword:`print`, or you could assign a new "
"value to ``sys.stdout`` and then restore the old value.  For sending output "
"to standard error, it's much easier to write this::"
msgstr ""
"``print`` 文がUnix シェルのリダイレクト操作のように、 ``print`` に続けて "
"``>> file`` と書くことでその出力をファイルのように振舞うオブジェクトに向けら"
"れるようになりました。(---訳注: 念のため。Python 3 では print は文ではなく関"
"数になっており、これは移植性がありません。Python 2.6 以降であれば関数版の "
"print を使う(:pep:`3105`)か、ファイルオブジェクト自身のメソッドを使ってくださ"
"い。もしくは目的がログ出力であるならば、 :mod:`logging` パッケージの使用を検"
"討してください。---) 以前までは次のいずれかをする必要がありました。一つには"
"ファイルのように振舞うオブジェクトの :meth:`write` メソッドを呼び出すことであ"
"り、これは ``print`` が持つ便利さと単純さに欠けています。もう一つは ``sys."
"stdout`` に新しい値を代入し、あとで元の値に戻すというやり方です。標準エラー出"
"力に出力を送るのに、このように遥かに簡単に書くことが出来ます::"

#: ../../whatsnew/2.0.rst:528
msgid ""
"Modules can now be renamed on importing them, using the syntax ``import "
"module as name`` or ``from module import name as othername``.  The patch was "
"submitted by Thomas Wouters."
msgstr ""
"``import module as name`` または ``from module import name as othername`` と"
"いう構文を使って、インポートするモジュールの名前をリネーム出来るようになりま"
"した。パッチは Thomas Wouters が投稿しました。"

#: ../../whatsnew/2.0.rst:532
msgid ""
"A new format style is available when using the ``%`` operator; '%r' will "
"insert the :func:`repr` of its argument.  This was also added from symmetry "
"considerations, this time for symmetry with the existing '%s' format style, "
"which inserts the :func:`str` of its argument.  For example, ``'%r %s' % "
"('abc', 'abc')`` returns a string containing ``'abc' abc``."
msgstr ""
"``%`` 演算子を使う際に新しい書式化スタイルが利用可能です; '%r' はその引数の :"
"func:`repr` を挿入します。これは対称性の検討からも考えられました。今の場合は"
"既存の '%s' が引数の :func:`str` を挿入することに呼応するものです。例えば "
"``'%r %s' % ('abc', 'abc')`` は文字列 ``'abc' abc`` を返します。"

#: ../../whatsnew/2.0.rst:538
msgid ""
"Previously there was no way to implement a class that overrode Python's "
"built-in :keyword:`in` operator and implemented a custom version.  ``obj in "
"seq`` returns true if *obj* is present in the sequence *seq*; Python "
"computes this by simply trying every index of the sequence until either "
"*obj* is found or an :exc:`IndexError` is encountered.  Moshe Zadka "
"contributed a patch which adds a :meth:`__contains__` magic method for "
"providing a custom implementation for :keyword:`in`. Additionally, new built-"
"in objects written in C can define what :keyword:`in` means for them via a "
"new slot in the sequence protocol."
msgstr ""
"これまでは、Python ビルトインの :keyword:`in` 演算子をオーバライドして新たに"
"カスタムバージョンを実装するための手段はありませんでした。 ``obj in seq`` は"
"シーケンス *seq* に *obj* が見つかれば真を返しますが、Python はシーケンスの全"
"ての添え字で単純に *obj* が見つかるか :exc:`IndexError` に出会うかするまで全"
"て試すだけです。Moshe Zadka は、 :keyword:`in` のためのカスタム実装を提供する"
"ための特殊メソッド :meth:`__contains__` を追加するパッチを寄稿しました。加え"
"て、C で書かれる新しいビルトインオブジェクトは、シーケンスプロトコルの新しい"
"スロットを通して :keyword:`in` がどのような意味を持つかを定義出来るようになっ"
"ています。"

#: ../../whatsnew/2.0.rst:547
msgid ""
"Earlier versions of Python used a recursive algorithm for deleting objects. "
"Deeply nested data structures could cause the interpreter to fill up the C "
"stack and crash; Christian Tismer rewrote the deletion logic to fix this "
"problem.  On a related note, comparing recursive objects recursed infinitely "
"and crashed; Jeremy Hylton rewrote the code to no longer crash, producing a "
"useful result instead.  For example, after this code::"
msgstr ""
"以前のバージョンの Python では、オブジェクトの削除に再帰するアルゴリズムを"
"使っていました。データ構造が深くネストしている場合、インタプリタが C のスタッ"
"クを使い果たしてクラッシュしていました。Christian Tismer はこの問題をフィック"
"スする削除ロジックに書き直しました。これに関係する注目すべきものとしては、再"
"帰するオブジェクトの比較が無限再帰してクラッシュしていたのを、Jeremy Hylton "
"が書き直してクラッシュしないようにして、有用な結果を生成するようにしたことで"
"す。例えば以下コード::"

#: ../../whatsnew/2.0.rst:559
msgid ""
"The comparison ``a==b`` returns true, because the two recursive data "
"structures are isomorphic. See the thread \"trashcan and PR#7\" in the April "
"2000 archives of the python-dev mailing list for the discussion leading up "
"to this implementation, and some useful relevant links.    Note that "
"comparisons can now also raise exceptions. In earlier versions of Python, a "
"comparison operation such as ``cmp(a,b)`` would always produce an answer, "
"even if a user-defined :meth:`__cmp__` method encountered an error, since "
"the resulting exception would simply be silently swallowed."
msgstr ""
"これに対して比較 ``a==b`` は、2つの再帰データ構造が同型であるので真を返しま"
"す (---訳注: 詳細はわかりませんが、現在の Python 2.7、Python 3 ではこれは "
"\"RuntimeError: maximum recursion depth exceeded in comparison\" になります "
"---)。python-dev メーリングリストのアーカイブの 2000 年 4 月のスレッド "
"\"trashcan and PR#7\" に、この実装に導いた議論といくつかの関連する有用なリン"
"クがあります。また、比較は今では例外を投げることも出来ます。以前のバージョン"
"の Python では ``cmp(a,b)`` のような比較操作は、ユーザ定義の :meth:`__cmp__` "
"メソッドがエラーを起こそうがそれ黙殺された上で、必ず何かの答えを出していまし"
"た。"

#: ../../whatsnew/2.0.rst:571
msgid ""
"Work has been done on porting Python to 64-bit Windows on the Itanium "
"processor, mostly by Trent Mick of ActiveState.  (Confusingly, ``sys."
"platform`` is still ``'win32'`` on Win64 because it seems that for ease of "
"porting, MS Visual C++ treats code as 32 bit on Itanium.) PythonWin also "
"supports Windows CE; see the Python CE page at http://pythonce.sourceforge."
"net/ for more information."
msgstr ""

#: ../../whatsnew/2.0.rst:577
msgid ""
"Another new platform is Darwin/MacOS X; initial support for it is in Python "
"2.0. Dynamic loading works, if you specify \"configure --with-dyld --with-"
"suffix=.x\". Consult the README in the Python source distribution for more "
"instructions."
msgstr ""

#: ../../whatsnew/2.0.rst:581
msgid ""
"An attempt has been made to alleviate one of Python's warts, the often-"
"confusing :exc:`NameError` exception when code refers to a local variable "
"before the variable has been assigned a value.  For example, the following "
"code raises an exception on the :keyword:`print` statement in both 1.5.2 and "
"2.0; in 1.5.2 a :exc:`NameError` exception is raised, while 2.0 raises a "
"new :exc:`UnboundLocalError` exception. :exc:`UnboundLocalError` is a "
"subclass of :exc:`NameError`, so any existing code that expects :exc:"
"`NameError` to be raised should still work. ::"
msgstr ""
"変数に値が割り当てられる前にローカル変数を参照するコードにおいて、 :exc:"
"`NameError` 例外はよく混乱するものであり、この欠点を軽減する試みがなされまし"
"た。例えば下に挙げるコードは ``print`` 文で 1.5.2 と 2.0 の両方で例外が発生し"
"ますが、1.5.2 は :exc:`NameError` 例外が、2.0 では新規の例外 :exc:"
"`UnboundLocalError` が投げられます。 :exc:`UnboundLocalError` は :exc:"
"`NameError` のサブクラスですので :exc:`NameError` が投げられることを想定する"
"既存のコードはそのまま動作するはずです。::"

#: ../../whatsnew/2.0.rst:595
msgid ""
"Two new exceptions, :exc:`TabError` and :exc:`IndentationError`, have been "
"introduced.  They're both subclasses of :exc:`SyntaxError`, and are raised "
"when Python code is found to be improperly indented."
msgstr ""
"2 つの新規例外 :exc:`TabError` と :exc:`IndentationError` が導入されました。"
"これらはともに :exc:`SyntaxError` のサブクラスで、Python コードに不適切なイン"
"デントが見つかると送出されます。"

#: ../../whatsnew/2.0.rst:601
msgid "Changes to Built-in Functions"
msgstr "ビルトイン関数の変更"

#: ../../whatsnew/2.0.rst:603
msgid ""
"A new built-in, ``zip(seq1, seq2, ...)``, has been added.  :func:`zip` "
"returns a list of tuples where each tuple contains the i-th element from "
"each of the argument sequences.  The difference between :func:`zip` and "
"``map(None, seq1, seq2)`` is that :func:`map` pads the sequences with "
"``None`` if the sequences aren't all of the same length, while :func:`zip` "
"truncates the returned list to the length of the shortest argument sequence."
msgstr ""
"新しいビルトイン関数 ``zip(seq1, seq2, ...)`` が追加されました。 :func:`zip` "
"はタプルのリストを返します。それぞれは、引数のシーケンスのそれぞれの i 番目要"
"素たちを含むタプルです。 :func:`zip` と ``map(None, seq1, seq2)`` の違い"
"は、 :func:`map` はシーケンスが同じ長さを持たない場合に ``None`` が埋められる"
"のに対し、 :func:`zip` は返すリストの長さを、引数のシーケンスの最も短い長さに"
"切り詰めます。"

#: ../../whatsnew/2.0.rst:610
msgid ""
"The :func:`int` and :func:`long` functions now accept an optional \"base\" "
"parameter when the first argument is a string. ``int('123', 10)`` returns "
"123, while ``int('123', 16)`` returns 291.  ``int(123, 16)`` raises a :exc:"
"`TypeError` exception with the message \"can't convert non-string with "
"explicit base\"."
msgstr ""
":func:`int` と :func:`long` が、最初の引数が文字列である場合に「base (基数)」"
"パラメータを受け付けるようになりました。 ``int('123', 10)`` は 123 を返し、 "
"``int('123', 16)`` は 291 を返します。 ``int(123, 16)`` はメッセージ \"can't "
"convert non-string with explicit base\" を伴った :exc:`TypeError` 例外を送出"
"します。"

#: ../../whatsnew/2.0.rst:616
msgid ""
"A new variable holding more detailed version information has been added to "
"the :mod:`sys` module.  ``sys.version_info`` is a tuple ``(major, minor, "
"micro, level, serial)`` For example, in a hypothetical 2.0.1beta1, ``sys."
"version_info`` would be ``(2, 0, 1, 'beta', 1)``. *level* is a string such "
"as ``\"alpha\"``, ``\"beta\"``, or ``\"final\"`` for a final release."
msgstr ""
":mod:`sys` モジュールに、これまでより詳細なバージョン情報を持つ変数が追加され"
"ました。 ``sys.version_info`` はタプル ``(major, minor, micro, level, "
"serial)`` です。例えば仮に 2.0.1beta1 というバージョンだったとすれば、 ``sys."
"version_info`` は ``(2, 0, 1, 'beta', 1)`` となるでしょう。 *level* は "
"``\"alpha\"`` や ``\"beta\"`` といった文字列で、最終リリースでは "
"``\"final\"`` です。(---訳注: Python 2.7 で名前付きタプルになっています。ま"
"た、その属性名では level ではなく releaselevel です。---)"

#: ../../whatsnew/2.0.rst:622
msgid ""
"Dictionaries have an odd new method, ``setdefault(key, default)``, which "
"behaves similarly to the existing :meth:`get` method.  However, if the key "
"is missing, :meth:`setdefault` both returns the value of *default* as :meth:"
"`get` would do, and also inserts it into the dictionary as the value for "
"*key*.  Thus, the following lines of code::"
msgstr ""
"辞書に、ちょっと風変わりなメソッド ``setdefault(key, default)`` が追加されま"
"した。これは既存の :meth:`get` メソッドに似た振る舞いをします。ですが、キーが"
"存在してない場合に :meth:`setdefault` は :meth:`get` がそうするように "
"*default* を返しつつ、同時に辞書にキー *key* の値として追加もします。ですから"
"以下コード::"

#: ../../whatsnew/2.0.rst:633
msgid ""
"can be reduced to a single ``return dict.setdefault(key, [])`` statement."
msgstr ""
"は、単一の ``return dict.setdefault(key, [])`` ステートメントだけで書けます。"

#: ../../whatsnew/2.0.rst:635
msgid ""
"The interpreter sets a maximum recursion depth in order to catch runaway "
"recursion before filling the C stack and causing a core dump or GPF.. "
"Previously this limit was fixed when you compiled Python, but in 2.0 the "
"maximum recursion depth can be read and modified using :func:`sys."
"getrecursionlimit` and :func:`sys.setrecursionlimit`. The default value is "
"1000, and a rough maximum value for a given platform can be found by running "
"a new script, :file:`Misc/find_recursionlimit.py`."
msgstr ""
"再帰の暴走を C のスタックが埋め尽くされてコアダンプしたり GPF (訳注: General "
"Protection Fault) する前に捕捉するために、インタプリタは最大の再帰の深さを"
"セットします。以前まではこの制限は Python コンパイル時点で決めてしまっていま"
"したが、2.0 では最大の再帰の深さは :func:`sys.getrecursionlimit` と :func:"
"`sys.setrecursionlimit` を使って読み取れ、修正出来ます。このデフォルトは "
"1000 です。また、当該プラットフォームでのおよその最大値は、新たに追加されたス"
"クリプト :file:`Misc/find_recursionlimit.py` を実行することで知ることが出来ま"
"す。"

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

#: ../../whatsnew/2.0.rst:649
msgid ""
"New Python releases try hard to be compatible with previous releases, and "
"the record has been pretty good.  However, some changes are considered "
"useful enough, usually because they fix initial design decisions that turned "
"out to be actively mistaken, that breaking backward compatibility can't "
"always be avoided. This section lists the changes in Python 2.0 that may "
"cause old Python code to break."
msgstr ""
"新しい Python リリースは以前のリリースとの互換性を保つために苦心しています"
"し、その記録はかなり良くなされてきました。ですがいくつかの変更に関しては、大"
"抵は大きな誤りであると判明した初期デザインを修正するという理由で、後方互換性"
"を破壊することを必ずしも回避せずに有用性が検討されています。このセクションで"
"は Python 2.0 において、古い Python コードを破壊するかもしれない変更点につい"
"て列挙します。"

#: ../../whatsnew/2.0.rst:656
msgid ""
"The change which will probably break the most code is tightening up the "
"arguments accepted by some methods.  Some methods would take multiple "
"arguments and treat them as a tuple, particularly various list methods such "
"as :meth:`append` and :meth:`insert`. In earlier versions of Python, if "
"``L`` is a list, ``L.append( 1,2 )`` appends the tuple ``(1,2)`` to the "
"list.  In Python 2.0 this causes a :exc:`TypeError` exception to be raised, "
"with the message: 'append requires exactly 1 argument; 2 given'.  The fix is "
"to simply add an extra set of parentheses to pass both values as a tuple:  "
"``L.append( (1,2) )``."
msgstr ""
"おそらくほとんどのコードを破壊する変更は、ある種のメソッドで受け付けられる引"
"数に関して厳しくなることです。ある種のメソッドは複数の引数を取ってそれらをタ"
"プルとして扱っていたでしょう。特に :meth:`append` や :meth:`insert` といった"
"リストの色々なメソッドです。以前のバージョンの Python では、 ``L`` がリストと"
"して、 ``L.append( 1,2 )`` はタプル ``(1,2)`` をリストに追加していました。"
"Python 2.0 ではこれはメッセージ 'append requires exactly 1 argument; 2 "
"given' を持つ :exc:`TypeError` を引き起こします。期待通りになるよう修正するに"
"は単に、両方の値がタプルとして渡るように追加の括弧を付けます: ``L."
"append( (1,2) )`` 。"

#: ../../whatsnew/2.0.rst:665
msgid ""
"The earlier versions of these methods were more forgiving because they used "
"an old function in Python's C interface to parse their arguments; 2.0 "
"modernizes them to use :func:`PyArg_ParseTuple`, the current argument "
"parsing function, which provides more helpful error messages and treats "
"multi-argument calls as errors.  If you absolutely must use 2.0 but can't "
"fix your code, you can edit :file:`Objects/listobject.c` and define the "
"preprocessor symbol ``NO_STRICT_LIST_APPEND`` to preserve the old behaviour; "
"this isn't recommended."
msgstr ""
"それらメソッドの以前のバージョンがもっと寛容だったのは、その引数の解析のため"
"の Python の C インターフェイスで古い関数を使っていたからです。2.0 ではそれら"
"を、引数解析関数 :func:`PyArg_ParseTuple` を使って現代化していて、これはより"
"助けとなるエラーメッセージを提供しつつ複数引数での呼び出しをエラーとして扱い"
"ます。もしも完全に 2.0 を使わなければならないのにあなたのコードを修正出来ない"
"のであれば、 :file:`Objects/listobject.c` を編集してプリプロセッサシンボル "
"``NO_STRICT_LIST_APPEND`` を定義することで、古い振る舞いに戻せます。これはお"
"奨め出来ません。(---訳注: いつ消えたのかはわかりませんが 2.7 ではもちろん "
"``NO_STRICT_LIST_APPEND`` の ifdef は入っていません。---)"

#: ../../whatsnew/2.0.rst:673
msgid ""
"Some of the functions in the :mod:`socket` module are still forgiving in "
"this way.  For example, :func:`socket.connect( ('hostname', 25) )` is the "
"correct form, passing a tuple representing an IP address, but :func:`socket."
"connect( 'hostname', 25 )` also works. :func:`socket.connect_ex` and :func:"
"`socket.bind` are similarly easy-going.  2.0alpha1 tightened these functions "
"up, but because the documentation actually used the erroneous multiple "
"argument form, many people wrote code which would break with the stricter "
"checking.  GvR backed out the changes in the face of public reaction, so for "
"the :mod:`socket` module, the documentation was fixed and the multiple "
"argument form is simply marked as deprecated; it *will* be tightened up "
"again in a future Python version."
msgstr ""
":mod:`socket` モジュールのいくつかの関数についてはまだこの方法が許されていま"
"す。例えば ``socket.connect( ('hostname', 25) )`` が正しい形式なのですが、 "
"``socket.connect( 'hostname', 25 )`` も動作します。 :func:`socket."
"connect_ex` と :func:`socket.bind` も同じようにおおらかです。2.0alpha1 がそれ"
"ら関数を厳しくしたのですが、ドキュメントが実際には複数引数を取る形式で誤って"
"書かれたために、多くの人々がその厳しくなったチェックに違反してしまうコードを"
"書いてしまいました。GvR はその変更を、市民たちの反応を受けて元に戻し、 :mod:"
"`socket` モジュールについてはドキュメントは修正されて、複数引数形式は非推奨と"
"してマークするに留められました。将来バージョンの Python においてこれはもう一"
"度厳しく *なります* 。 (---訳注: What's New からは読み取れませんが少なくとも "
"2.7 では単一引数でしか渡せません。つまり明示的にタプルにして渡す必要がありま"
"す。---)"

#: ../../whatsnew/2.0.rst:684
msgid ""
"The ``\\x`` escape in string literals now takes exactly 2 hex digits.  "
"Previously it would consume all the hex digits following the 'x' and take "
"the lowest 8 bits of the result, so ``\\x123456`` was equivalent to "
"``\\x56``."
msgstr ""
"文字列リテラル内の ``\\x`` エスケープは、正確に 2 桁の 16 進表記文字になりま"
"した。以前は 'x' に続く 16 進表記文字全てを消費して最後の 8 ビットを使ってい"
"たため、 ``\\x123456`` は ``\\x56`` と同じでした。"

#: ../../whatsnew/2.0.rst:688
msgid ""
"The :exc:`AttributeError` and :exc:`NameError` exceptions have a more "
"friendly error message, whose text will be something like ``'Spam' instance "
"has no attribute 'eggs'`` or ``name 'eggs' is not defined``.  Previously the "
"error message was just the missing attribute name ``eggs``, and code written "
"to take advantage of this fact will break in 2.0."
msgstr ""
"例外 :exc:`AttributeError` と :exc:`NameError` がよりフレンドリなエラーメッ"
"セージを持つようになっています。それらのテキストは ``'Spam' instance has no "
"attribute 'eggs'`` や ``name 'eggs' is not defined`` のようなものになります。"
"以前まではエラーメッセージは存在しない属性名 ``eggs`` だけでしたので、この事"
"実に便乗して書かれたコードは 2.0 では壊れます。"

#: ../../whatsnew/2.0.rst:694
msgid ""
"Some work has been done to make integers and long integers a bit more "
"interchangeable.  In 1.5.2, large-file support was added for Solaris, to "
"allow reading files larger than 2 GiB; this made the :meth:`tell` method of "
"file objects return a long integer instead of a regular integer.  Some code "
"would subtract two file offsets and attempt to use the result to multiply a "
"sequence or slice a string, but this raised a :exc:`TypeError`.  In 2.0, "
"long integers can be used to multiply or slice a sequence, and it'll behave "
"as you'd intuitively expect it to; ``3L * 'abc'`` produces 'abcabcabc', and "
"``(0,1,2,3)[2L:4L]`` produces (2,3). Long integers can also be used in "
"various contexts where previously only integers were accepted, such as in "
"the :meth:`seek` method of file objects, and in the formats supported by the "
"``%`` operator (``%d``, ``%i``, ``%x``, etc.).  For example, ``\"%d\" % "
"2L**64`` will produce the string ``18446744073709551616``."
msgstr ""
"整数と長整数をもう少しだけ相互変換可能にするためのいくつかの仕事がなされまし"
"た。1.5.2 で、Solaris のためにラージファイルのサポートが追加されました。これ"
"は 2 GiB より大きなファイルを読めるようにするものです。これによりファイルオブ"
"ジェクトの :meth:`tell` メソッドが、整数ではなく長整数を返すようになりまし"
"た。ある種のコードは 2 つのファイルオフセットの減算をしたり、結果をシーケンス"
"の積算や文字列のスライスに使おうと試みますが、これは :exc:`TypeError` となっ"
"ていました。2.0 では長整数はシーケンスの積算やスライスに使えて、それは直感に"
"反しない振る舞いをします。 ``3L * 'abc'`` は 'abcabcabc' を生成しますし、 "
"``(0,1,2,3)[2L:4L]`` は (2,3) です。長整数は以前ならば普通の整数だけが許可さ"
"れていた様々な文脈で使えます。例えばファイルオブジェクトの :meth:`seek` メ"
"ソッドもですし、 ``%`` 演算子による書式化 (``%d``, ``%i``, ``%x``, など) もで"
"す。例えば ``\"%d\" % 2L**64`` は ``18446744073709551616`` を生成するでしょ"
"う。 (---訳注: 長整数の扱いはこのあとも Python 3 までの間に :pep:`237` 「長整"
"数と整数の一体化」などを経て少しずつ区別がなくされていきました。 ---)"

#: ../../whatsnew/2.0.rst:708
msgid ""
"The subtlest long integer change of all is that the :func:`str` of a long "
"integer no longer has a trailing 'L' character, though :func:`repr` still "
"includes it.  The 'L' annoyed many people who wanted to print long integers "
"that looked just like regular integers, since they had to go out of their "
"way to chop off the character.  This is no longer a problem in 2.0, but code "
"which does ``str(longval)[:-1]`` and assumes the 'L' is there, will now lose "
"the final digit."
msgstr ""
"一番微妙な長整数についての変更は、長整数を :func:`str` してももはや末尾の "
"'L' 文字が付かないことです。 :func:`repr` では今でも付くのにも関わらずです。 "
"'L' は長整数を普通の整数と全く同じように印字したい多くの人々を悩ませてきまし"
"た。それを各々自分なりの手段で取り除く必要があったからです。これはもう 2.0 で"
"は問題でなくなりましたが、 'L' が付くことをあてにして ``str(longval)[:-1]`` "
"とするコードが今度は数値の最後の桁を失ってしまいます。"

#: ../../whatsnew/2.0.rst:716
msgid ""
"Taking the :func:`repr` of a float now uses a different formatting precision "
"than :func:`str`.  :func:`repr` uses ``%.17g`` format string for C's :func:"
"`sprintf`, while :func:`str` uses ``%.12g`` as before.  The effect is that :"
"func:`repr` may occasionally show more decimal places than  :func:`str`, for "
"certain numbers.  For example, the number 8.1 can't be represented exactly "
"in binary, so ``repr(8.1)`` is ``'8.0999999999999996'``, while str(8.1) is "
"``'8.1'``."
msgstr ""
"浮動小数点数についての :func:`repr` が :func:`str` とは異なる精度でフォーマッ"
"トするようになりました。 :func:`repr` は C の :func:`sprintf` の書式文字列 "
"``%.17g`` を使い、 :func:`str` はこれまでと同じで ``%.12g`` を使います。その"
"影響で、 :func:`repr` では時折ある種の数では :func:`str` よりも小数点以下をよ"
"り多く出力することがあります。例えば 8.1 は正確に 2 進数で表現出来ないので、 "
"``repr(8.1)`` は ``'8.0999999999999996'`` となり、 str(8.1) は ``'8.1'`` とな"
"ります。(---訳注: 精度がこれら2つで違うことについては今でも同じですが 2.7 に"
"至るまでに浮動小数点数の扱い含め色々変更されているため、2.7 時点での "
"``repr(8.1)`` は ``'8.1'`` になります。まず現在の Python は単純に :func:"
"`sprintf` を使っているのではなくもう少しだけ複雑なことをします。見かけ上は "
"``%.16g`` を使っているようにみえると思います。完全な詳細は :file:`Objects/"
"floatobject.c` を参照して下さい。---)"

#: ../../whatsnew/2.0.rst:724
msgid ""
"The ``-X`` command-line option, which turned all standard exceptions into "
"strings instead of classes, has been removed; the standard exceptions will "
"now always be classes.  The :mod:`exceptions` module containing the standard "
"exceptions was translated from Python to a built-in C module, written by "
"Barry Warsaw and Fredrik Lundh."
msgstr ""
"コマンドラインオプション ``-X`` を使って標準例外をクラスではなく文字列にする"
"機能は削除されました。標準例外は今では常にクラスです。標準例外を含んでいる :"
"mod:`exceptions` モジュールは Python からビルトインの C モジュールに変換され"
"ました。これは Barry Warsaw と Fredrik Lundh によって書かれました。"

#: ../../whatsnew/2.0.rst:740
msgid "Extending/Embedding Changes"
msgstr "拡張と埋め込みについての変更"

#: ../../whatsnew/2.0.rst:742
msgid ""
"Some of the changes are under the covers, and will only be apparent to "
"people writing C extension modules or embedding a Python interpreter in a "
"larger application.  If you aren't dealing with Python's C API, you can "
"safely skip this section."
msgstr ""
"いくつかの変更点については覆いが被されていて、C 拡張モジュールや大きなアプリ"
"ケーションでの Python インタプリタの埋め込みを書く人々からしか見えないもので"
"す。Python C API を扱う必要がないのであれば、このセクションは読み飛ばして差し"
"支えありません。"

#: ../../whatsnew/2.0.rst:747
msgid ""
"The version number of the Python C API was incremented, so C extensions "
"compiled for 1.5.2 must be recompiled in order to work with 2.0.  On "
"Windows, it's not possible for Python 2.0 to import a third party extension "
"built for Python 1.5.x due to how Windows DLLs work, so Python will raise an "
"exception and the import will fail."
msgstr ""
"Python C API のバージョン番号がインクリメントされたので、1.5.2 でコンパイルさ"
"れた C 拡張は 2.0 で動作させるために再コンパイルしなければなりません。"
"Windows では Python 1.5.x でビルドされたサードパーティ拡張を Python 2.0 でイ"
"ンポートすることは、Windows の DLL の仕組みのために、出来ません。その場合 "
"Python は例外を投げ、インポートは失敗します。(---訳注: この文章、おかしなこと"
"を言っているので一応…。おそらく「Windows の一般市民は C コンパイラを持ってい"
"ない」ことが著者の頭にあって、手が滑っているのだと思います。DLL の動作の仕組"
"みが問題となるのは事実ですが、本質的には Windows 云々はあまり関係ないです。"
"API が変わるか ABI が変わるならプラットフォームに関係なくリコンパイルは常に必"
"要です。 ---)"

#: ../../whatsnew/2.0.rst:753
msgid ""
"Users of Jim Fulton's ExtensionClass module will be pleased to find out that "
"hooks have been added so that ExtensionClasses are now supported by :func:"
"`isinstance` and :func:`issubclass`. This means you no longer have to "
"remember to write code such as ``if type(obj) == myExtensionClass``, but can "
"use the more natural ``if isinstance(obj, myExtensionClass)``."
msgstr ""

#: ../../whatsnew/2.0.rst:759
msgid ""
"The :file:`Python/importdl.c` file, which was a mass of #ifdefs to support "
"dynamic loading on many different platforms, was cleaned up and reorganised "
"by Greg Stein.  :file:`importdl.c` is now quite small, and platform-specific "
"code has been moved into a bunch of :file:`Python/dynload_\\*.c` files.  "
"Another cleanup: there were also a number of :file:`my\\*.h` files in the "
"Include/ directory that held various portability hacks; they've been merged "
"into a single file, :file:`Include/pyport.h`."
msgstr ""
":file:`Python/importdl.c` ファイルが多くの異なるプラットフォームの動的ロード"
"をサポートするのに大量の #ifdef だらけになっていたのを、Greg Stein が掃除して"
"再編成しました。 :file:`importdl.c` は今ではとても小さくなり、プラットフォー"
"ム依存のコードは :file:`Python/dynload_\\*.c` ファイル群の束にそれぞれ移動し"
"ました。もう一つの掃除。include/ ディレクトリ内で色々な移植性のためのハックを"
"施すためのたくさんの :file:`my\\*.h` ファイルたちが、単一の :file:`Include/"
"pyport.h` にマージされました。"

#: ../../whatsnew/2.0.rst:767
msgid ""
"Vladimir Marangozov's long-awaited malloc restructuring was completed, to "
"make it easy to have the Python interpreter use a custom allocator instead "
"of C's standard :func:`malloc`.  For documentation, read the comments in :"
"file:`Include/pymem.h` and :file:`Include/objimpl.h`.  For the lengthy "
"discussions during which the interface was hammered out, see the Web "
"archives of the 'patches' and 'python-dev' lists at python.org."
msgstr ""
"Vladimir Marangozov の手による、待ち望まれた malloc の再編成が完了しました。"
"これは Python インタプリタが C 標準の :func:`malloc` の代わりにカスタムアロ"
"ケータを使うことを容易にするものです。ドキュメントについては :file:`Include/"
"pymem.h` と :file:`Include/objimpl.h` のコメントを読んで下さい。インターフェ"
"イスが決着するまでの間の長い長い議論については python.org の 'patches' と "
"'python-dev' リストのウェブアーカイブをみてください。(---訳注: この件について"
"の続きの話が  What's New in Python 2.3 に Pymalloc として少しわかりやすく記述"
"されています。---)"

#: ../../whatsnew/2.0.rst:774
msgid ""
"Recent versions of the GUSI development environment for MacOS support POSIX "
"threads.  Therefore, Python's POSIX threading support now works on the "
"Macintosh.  Threading support using the user-space GNU ``pth`` library was "
"also contributed."
msgstr ""
"MacOS の GUSI 開発環境の最近のバージョンは POSIX スレッドをサポートしていま"
"す。ですので Python の POSIX スレッディングのサポートは今では Macintosh で動"
"作します。ユーザ空間での GNU ``pth`` ライブラリを使ったスレッディングサポート"
"も寄稿されました。"

#: ../../whatsnew/2.0.rst:779
msgid ""
"Threading support on Windows was enhanced, too.  Windows supports thread "
"locks that use kernel objects only in case of contention; in the common case "
"when there's no contention, they use simpler functions which are an order of "
"magnitude faster.  A threaded version of Python 1.5.2 on NT is twice as slow "
"as an unthreaded version; with the 2.0 changes, the difference is only 10%.  "
"These improvements were contributed by Yakov Markovitch."
msgstr ""
"Windows でのスレッディングサポートも拡張されました。Windows は、競合がある"
"ケースでのみカーネルオブジェクトを使うスレッドロックをサポートしています。競"
"合がない普通のケースではそれらはより単純な関数を使い、これは段違いに高速で"
"す。NT での Python 1.5.2 版でスレッド化すると、非スレッド版の 2 倍遅くなりま"
"すが、2.0 に変えるとその差はたった 10% です。これらの改善は Yakov Markovitch "
"の貢献によるものです。"

#: ../../whatsnew/2.0.rst:786
msgid ""
"Python 2.0's source now uses only ANSI C prototypes, so compiling Python now "
"requires an ANSI C compiler, and can no longer be done using a compiler that "
"only supports K&R C."
msgstr ""
"Python 2.0 のソースが ANSI C プロトタイプだけを使うようになったので、Python "
"のコンパイルには ANSI C コンパイラが必須になりました。K&R C しかサポートしな"
"いコンパイラではもうコンパイル出来ません。"

#: ../../whatsnew/2.0.rst:790
msgid ""
"Previously the Python virtual machine used 16-bit numbers in its bytecode, "
"limiting the size of source files.  In particular, this affected the maximum "
"size of literal lists and dictionaries in Python source; occasionally people "
"who are generating Python code would run into this limit.  A patch by "
"Charles G. Waldman raises the limit from ``2^16`` to ``2^{32}``."
msgstr ""
"以前は、Python 仮想マシンはそのバイトコードに 16 ビットの数値を使って、ソース"
"ファイルのサイズを制限していました。特にこれは、Python ソースのリテラルのリス"
"トと辞書の最大サイズに影響していました。時々 Python コードを生成する人たち"
"が、この制限に遭遇していました。Charles G. Waldman によるパッチで、この制限"
"が ``2^16`` から ``2^{32}`` に引き上げられました。"

#: ../../whatsnew/2.0.rst:796
msgid ""
"Three new convenience functions intended for adding constants to a module's "
"dictionary at module initialization time were added: :func:"
"`PyModule_AddObject`, :func:`PyModule_AddIntConstant`, and :func:"
"`PyModule_AddStringConstant`.  Each of these functions takes a module "
"object, a null-terminated C string containing the name to be added, and a "
"third argument for the value to be assigned to the name.  This third "
"argument is, respectively, a Python object, a C long, or a C string."
msgstr ""
"モジュール初期化時に、モジュールの辞書に定数を追加することを意図した新しい 3 "
"つの関数が追加されました: :func:`PyModule_AddObject`, :func:"
"`PyModule_AddIntConstant`, and :func:`PyModule_AddStringConstant` です。これ"
"ら関数のそれぞれは、モジュールオブジェクトと、追加されるべき名前を含む null "
"終端の C 文字列と、その名前に代入される値の、3 つの引数を取ります。3 つ目の引"
"数は Python オブジェクトか、C の long か、C 文字列です。"

#: ../../whatsnew/2.0.rst:804
msgid ""
"A wrapper API was added for Unix-style signal handlers. :func:`PyOS_getsig` "
"gets a signal handler and :func:`PyOS_setsig` will set a new handler."
msgstr ""
"Unix スタイルのシグナルハンドラへのラッパー関数が追加されました。 :func:"
"`PyOS_getsig` でシグナルハンドラを取得し、 :func:`PyOS_setsig` で新しいハンド"
"ラをセットします。"

#: ../../whatsnew/2.0.rst:811
msgid "Distutils: Making Modules Easy to Install"
msgstr "Distutils: モジュールの簡単インストール"

#: ../../whatsnew/2.0.rst:813
msgid ""
"Before Python 2.0, installing modules was a tedious affair -- there was no "
"way to figure out automatically where Python is installed, or what compiler "
"options to use for extension modules.  Software authors had to go through an "
"arduous ritual of editing Makefiles and configuration files, which only "
"really work on Unix and leave Windows and MacOS unsupported.  Python users "
"faced wildly differing installation instructions which varied between "
"different extension packages, which made administering a Python installation "
"something of  a chore."
msgstr ""
"Python 2.0 以前は、モジュールのインストールは退屈な作業でした -- Python がど"
"こにインストールされているかや拡張モジュールのコンパイルに必要なオプションを"
"自動的に知る方法はありませんでした。ソフトウェアの作者は Makefile と設定ファ"
"イル群の編集という大変な労力を要する儀式を通過しなければならないのに、それは"
"実際には Unix だけのためであって Windows と MacOS のサポートを置き去りにする"
"ものでした。Python ユーザは全く異なったインストール命令に直面していました。そ"
"れは拡張パッケージごとに異なり、Python インストールをある種つまらない作業とし"
"ていました。"

#: ../../whatsnew/2.0.rst:821
msgid ""
"The SIG for distribution utilities, shepherded by Greg Ward, has created the "
"Distutils, a system to make package installation much easier.  They form "
"the :mod:`distutils` package, a new part of Python's standard library. In "
"the best case, installing a Python module from source will require the same "
"steps: first you simply mean unpack the tarball or zip archive, and the run "
"\"``python setup.py install``\".  The platform will be automatically "
"detected, the compiler will be recognized, C extension modules will be "
"compiled, and the distribution installed into the proper directory.  "
"Optional command-line arguments provide more control over the installation "
"process, the distutils package offers many places to override defaults -- "
"separating the build from the install, building or installing in non-default "
"directories, and more."
msgstr ""
"配布のためのユーティリティについての SIG (---訳注: Python Special Interest "
"Groups ---) が Greg Ward に主導されて、パッケージのインストールを格段に簡単に"
"する Distutils を作りました。これにより :mod:`distutils` パッケージが、"
"Python 標準ライブラリの新しい一部として形成されました。最良の場合にはソースか"
"ら Python モジュールをインストールするのにはいつでも同じステップだけが必要で"
"す: まずは単に tarball あるいは zip アーカイブを展開し、その後 \"``python "
"setup.py install``\" を実行します。プラットフォームは自動的に検出されて、コン"
"パイラが認識され、C 拡張モジュールがコンパイルされ、配布物が適切なディレクト"
"リにインストールされます。オプショナルなコマンドライン引数がインストール過程"
"についてより細かな制御を提供します。 distutils パッケージはデフォルトを上書き"
"して別のことを出来る多くのポイントを持っています -- インストールとビルドを"
"別々に行ったり、ビルドやインストールをデフォルトでないディレクトリに行った"
"り、などです。"

#: ../../whatsnew/2.0.rst:833
msgid ""
"In order to use the Distutils, you need to write a :file:`setup.py` script.  "
"For the simple case, when the software contains only .py files, a minimal :"
"file:`setup.py` can be just a few lines long::"
msgstr ""
"Distutils を使うには :file:`setup.py` スクリプトを書く必要があります。単純な"
"ケースでは、ソフトウェアが .py ファイルだけを含む場合、最小限の :file:`setup."
"py` は数行足らずで書けます::"

#: ../../whatsnew/2.0.rst:841
msgid ""
"The :file:`setup.py` file isn't much more complicated if the software "
"consists of a few packages::"
msgstr ""
":file:`setup.py` ファイルは、ソフトウェアが少しのパッケージで構成される場合は"
"これより大きく複雑になることはありません::"

#: ../../whatsnew/2.0.rst:848
msgid ""
"A C extension can be the most complicated case; here's an example taken from "
"the PyXML package::"
msgstr ""
"C 拡張が最も複雑なケースになりえます。以下は PyXML パッケージからもってきた例"
"です::"

#: ../../whatsnew/2.0.rst:864
msgid ""
"The Distutils can also take care of creating source and binary "
"distributions. The \"sdist\" command, run by \"``python setup.py sdist``', "
"builds a source distribution such as :file:`foo-1.0.tar.gz`. Adding new "
"commands isn't difficult, \"bdist_rpm\" and \"bdist_wininst\" commands have "
"already been contributed to create an RPM distribution and a Windows "
"installer for the software, respectively.  Commands to create other "
"distribution formats such as Debian packages and Solaris :file:`.pkg` files "
"are in various stages of development."
msgstr ""
"Distutils ではソース配布物、バイナリ配布物の作成の面倒もみてくれます。 "
"\"sdist\" コマンドは \"``python setup.py sdist``\" を実行することで起動し、こ"
"れは :file:`foo-1.0.tar.gz` のようなソース配布物を作ります。新しいコマンドを"
"作るのは難しくありません。コマンド \"bdist_rpm\" と \"bdist_wininst\" が既に"
"寄稿されていて、各々 RPM 配布物の作成、Windows インストーラの作成を行います。"
"Debian パッケージや Solaris の :file:`.pkg` のようなほかの配布フォーマットを"
"作成するコマンドについての開発ステージは様々です。"

#: ../../whatsnew/2.0.rst:873
msgid ""
"All this is documented in a new manual, *Distributing Python Modules*, that "
"joins the basic set of Python documentation."
msgstr ""
"これら全ては、 Python ドキュメントの基本的なセットとして追加されたマニュアル "
"*Python モジュールの配布* にドキュメントされています。"

#: ../../whatsnew/2.0.rst:880
msgid "XML Modules"
msgstr "XML モジュール"

#: ../../whatsnew/2.0.rst:882
msgid ""
"Python 1.5.2 included a simple XML parser in the form of the :mod:`xmllib` "
"module, contributed by Sjoerd Mullender.  Since 1.5.2's release, two "
"different interfaces for processing XML have become common: SAX2 (version 2 "
"of the Simple API for XML) provides an event-driven interface with some "
"similarities to :mod:`xmllib`, and the DOM (Document Object Model) provides "
"a tree-based interface, transforming an XML document into a tree of nodes "
"that can be traversed and modified.  Python 2.0 includes a SAX2 interface "
"and a stripped-down DOM interface as part of the :mod:`xml` package. Here we "
"will give a brief overview of these new interfaces; consult the Python "
"documentation or the source code for complete details. The Python XML SIG is "
"also working on improved documentation."
msgstr ""
"Python 1.5.2 では、 Sjoerd Mullender の手による単純な XML パーサが、 :mod:"
"`xmllib` モジュールの形で追加されました。1.5.2 でのリリース以降で、2 つの異"
"なった XML 処理のインターフェイスが一般的になりました。SAX2 (「Simple API "
"for XML」のバージョン 2) はいくらか :mod:`xmllib` に似た、イベントドリブンの"
"インターフェイスを提供し、DOM (「Document Object Model］) は XML ドキュメント"
"を、横断したり修正できるノードのツリーに変換する、木構造ベースのインターフェ"
"イスを提供します。Python 2.0 では SAX2 インターフェイスと必要最小限の DOM イ"
"ンターフェイスが、 :mod:`xml` パッケージの一部として追加されました。ここでは"
"それら新規インターフェイスについての簡単な概要について書きます。完全な詳細に"
"ついては Python ドキュメントかソースコードを参照してください。Python XML SIG "
"ではドキュメントの改善についても作業中です。"

#: ../../whatsnew/2.0.rst:896
msgid "SAX2 Support"
msgstr "SAX2 サポート"

#: ../../whatsnew/2.0.rst:898
msgid ""
"SAX defines an event-driven interface for parsing XML.  To use SAX, you must "
"write a SAX handler class.  Handler classes inherit from various classes "
"provided by SAX, and override various methods that will then be called by "
"the XML parser.  For example, the :meth:`startElement` and :meth:"
"`endElement` methods are called for every starting and end tag encountered "
"by the parser, the :meth:`characters` method is called for every chunk of "
"character data, and so forth."
msgstr ""
"SAX は、XML のパースのイベントドリブンなインターフェイスを定義しています。"
"SAX を利用するには、SAX ハンドラクラスを書く必要があります。ハンドラクラスは "
"SAX により提供される様々なクラスから派生し、XML パーサから呼び出される様々な"
"メソッドをオーバライドします。例えば、メソッド :meth:`startElement` と :meth:"
"`endElement` はパーサによって開始・終了タグが検出されるたびに呼び出され、 :"
"meth:`characters` メソッドは文字データの塊 (chunk) ごとに呼び出される、といっ"
"た具合です。"

#: ../../whatsnew/2.0.rst:906
msgid ""
"The advantage of the event-driven approach is that the whole document "
"doesn't have to be resident in memory at any one time, which matters if you "
"are processing really huge documents.  However, writing the SAX handler "
"class can get very complicated if you're trying to modify the document "
"structure in some elaborate way."
msgstr ""
"イベントドリブンのアプローチはドキュメント全体をいっときにメモリに持たなくて"
"良い点で有利であり、ドキュメントが本当に巨大であるものを処理する際にはこれは"
"重要です。ですが SAX ハンドラクラスを記述することは、ドキュメント構造を変更し"
"ようとする場合にはある種入り組んだものとなって、とても複雑になりえます。"

#: ../../whatsnew/2.0.rst:912
msgid ""
"For example, this little example program defines a handler that prints a "
"message for every starting and ending tag, and then parses the file :file:"
"`hamlet.xml` using it::"
msgstr ""
"以下の小さな実例プログラムでは、全ての開始・終了タグでメッセージを印字するハ"
"ンドラを定義して、ファイル :file:`hamlet.xml` をそのハンドラを使ってパースし"
"ています::"

#: ../../whatsnew/2.0.rst:935
msgid ""
"For more information, consult the Python documentation, or the XML HOWTO at "
"http://pyxml.sourceforge.net/topics/howto/xml-howto.html."
msgstr ""
"もっと詳しい情報については Python ドキュメントを調べるか、 http://pyxml."
"sourceforge.net/topics/howto/xml-howto.html にある XML HOWTO をご覧ください。"

#: ../../whatsnew/2.0.rst:940
msgid "DOM Support"
msgstr "DOM サポート"

#: ../../whatsnew/2.0.rst:942
msgid ""
"The Document Object Model is a tree-based representation for an XML "
"document.  A top-level :class:`Document` instance is the root of the tree, "
"and has a single child which is the top-level :class:`Element` instance. "
"This :class:`Element` has children nodes representing character data and any "
"sub-elements, which may have further children of their own, and so forth.  "
"Using the DOM you can traverse the resulting tree any way you like, access "
"element and attribute values, insert and delete nodes, and convert the tree "
"back into XML."
msgstr ""
"Document Object Model は XML ドキュメントの木構造ベースの表現です。トップレベ"
"ルの :class:`Document` インスタンスは木の根で、これはトップレベルの :class:"
"`Element` インスタンス一つを子に持ちます。 :class:`Element` は、文字データや"
"らほかのサブ要素を子ノードとして持ち、それら子ノードがさらに子を持つ、といっ"
"た具合です。DOM を使って、好きなように結果木を横断し、要素や属性値にアクセス"
"し、ノードを追加したり削除したりし、そして木を XML に戻せます。"

#: ../../whatsnew/2.0.rst:950
msgid ""
"The DOM is useful for modifying XML documents, because you can create a DOM "
"tree, modify it by adding new nodes or rearranging subtrees, and then "
"produce a new XML document as output.  You can also construct a DOM tree "
"manually and convert it to XML, which can be a more flexible way of "
"producing XML output than simply writing ``<tag1>``...\\ ``</tag1>`` to a "
"file."
msgstr ""
"DOM は XML ドキュメントを修正するのに有用です。というのも DOM ツリーは作成出"
"来、新規ノードを追加したりサブツリーを再編成したりすることで修正出来、出力と"
"して新たな XML ドキュメントを生成出来るからです。DOM ツリーを手動で構築して "
"XML に変換することも出来ます。これにより単純に ``<tag1>``...\\ ``</tag1>`` を"
"ファイルに書くよりも柔軟性の高い方法で XML 出力を生成出来ます。"

#: ../../whatsnew/2.0.rst:956
msgid ""
"The DOM implementation included with Python lives in the :mod:`xml.dom."
"minidom` module.  It's a lightweight implementation of the Level 1 DOM with "
"support for XML namespaces.  The  :func:`parse` and :func:`parseString` "
"convenience functions are provided for generating a DOM tree::"
msgstr ""
"Python の DOM 実装は :mod:`xml.dom.minidom` モジュールにあります。これは XML "
"名前空間サポートを持つレベル 1 DOM の軽量実装です。コンビニエンス関数 :func:"
"`parse` と :func:`parseString` が DOM ツリーの生成のために提供されています::"

#: ../../whatsnew/2.0.rst:964
msgid ""
"``doc`` is a :class:`Document` instance.  :class:`Document`, like all the "
"other DOM classes such as :class:`Element` and :class:`Text`, is a subclass "
"of the :class:`Node` base class.  All the nodes in a DOM tree therefore "
"support certain common methods, such as :meth:`toxml` which returns a string "
"containing the XML representation of the node and its children.  Each class "
"also has special methods of its own; for example, :class:`Element` and :"
"class:`Document` instances have a method to find all child elements with a "
"given tag name. Continuing from the previous 2-line example::"
msgstr ""
"``doc`` が :class:`Document` のインスタンスです。DOM の全てのクラス、例えば :"
"class:`Element` や :class:`Text` などや、 :class:`Document` も、基底クラス :"
"class:`Node` のサブクラスです。ですので DOM ツリー内の全てのノードはある共通"
"のメソッドを持ちます。例えば :meth:`toxml` はそのノードとその子の XML 表現を"
"含む文字列を返します。それぞれのクラスにはそれ自身の特別なメソッドも持ちま"
"す。例えば :class:`Element` と :class:`Document` のインスタンスは指定したタグ"
"名で全ての子要素を検索するメソッドを持っています。先ほどの例の 2 行からの続き"
"です::"

#: ../../whatsnew/2.0.rst:977
msgid "For the *Hamlet* XML file, the above few lines output::"
msgstr "*Hamlet* XML ファイルに対して上の例は以下のような出力をします::"

#: ../../whatsnew/2.0.rst:982
msgid ""
"The root element of the document is available as ``doc.documentElement``, "
"and its children can be easily modified by deleting, adding, or removing "
"nodes::"
msgstr ""
"ドキュメントのルートエレメントは ``doc.documentElement`` として取得出来、その"
"子は簡単に、ノードを削除したり追加したりすることで修正出来ます::"

#: ../../whatsnew/2.0.rst:997
msgid ""
"Again, I will refer you to the Python documentation for a complete listing "
"of the different :class:`Node` classes and their various methods."
msgstr ""
"繰り返しになりますが、ほかの異なった :class:`Node` クラスやらそれらの色々なメ"
"ソッドやらの完全なリストについては、Python ドキュメントを参照して下さい。"

#: ../../whatsnew/2.0.rst:1002
msgid "Relationship to PyXML"
msgstr "PyXML との関係"

#: ../../whatsnew/2.0.rst:1004
msgid ""
"The XML Special Interest Group has been working on XML-related Python code "
"for a while.  Its code distribution, called PyXML, is available from the "
"SIG's Web pages at https://www.python.org/community/sigs/current/xml-sig. "
"The PyXML distribution also used the package name ``xml``.  If you've "
"written programs that used PyXML, you're probably wondering about its "
"compatibility with the 2.0 :mod:`xml` package."
msgstr ""
"XML Special Interest Group は、しばらくの間、XML 関連の Python コードに取り組"
"んできました。 そのコードのディストリビューションは PyXML と呼ばれ、SIG の "
"Web ページ https://www.python.org/community/sigs/current/xml-sig から入手でき"
"ます。PyXML ディストリビューションは ``xml`` というパッケージ名も使っていまし"
"た。 もしあなたがPyXMLを使ったプログラムを書いたことがあれば、2.0の :mod:"
"`xml` パッケージとの互換性が気になるのではないでしょうか。"

#: ../../whatsnew/2.0.rst:1010
msgid ""
"The answer is that Python 2.0's :mod:`xml` package isn't compatible with "
"PyXML, but can be made compatible by installing a recent version PyXML.  "
"Many applications can get by with the XML support that is included with "
"Python 2.0, but more complicated applications will require that the full "
"PyXML package will be installed.  When installed, PyXML versions 0.6.0 or "
"greater will replace the :mod:`xml` package shipped with Python, and will be "
"a strict superset of the standard package, adding a bunch of additional "
"features.  Some of the additional features in PyXML include:"
msgstr ""
"結論として、Python 2.0 の :mod:`xml` パッケージは PyXML と互換性がありませ"
"ん。ですが、直近バージョンの PyXML をインストールすることで互換性を持たせるこ"
"とができます。 多くのアプリケーションは Python 2.0 に含まれる XML サポートで"
"十分ですが、より複雑なアプリケーションは完全なPyXML パッケージをインストール"
"する必要があります。 インストールされた PyXML バージョン 0.6.0 以上は、"
"Python に同梱されている :mod:`xml` パッケージを置き換え、標準パッケージの厳密"
"なスーパーセットとなり、多くの追加機能が追加されます。 PyXML の追加機能には次"
"のようなものがあります。"

#: ../../whatsnew/2.0.rst:1019
msgid "4DOM, a full DOM implementation from FourThought, Inc."
msgstr ""

#: ../../whatsnew/2.0.rst:1021
msgid "The xmlproc validating parser, written by Lars Marius Garshol."
msgstr ""

#: ../../whatsnew/2.0.rst:1023
msgid "The :mod:`sgmlop` parser accelerator module, written by Fredrik Lundh."
msgstr ""

#: ../../whatsnew/2.0.rst:1029
msgid "Module changes"
msgstr "更新されたモジュール"

#: ../../whatsnew/2.0.rst:1031
msgid ""
"Lots of improvements and bugfixes were made to Python's extensive standard "
"library; some of the affected modules include :mod:`readline`, :mod:"
"`ConfigParser`, :mod:`cgi`, :mod:`calendar`, :mod:`posix`, :mod:`readline`, :"
"mod:`xmllib`, :mod:`aifc`, :mod:`chunk, wave`, :mod:`random`, :mod:`shelve`, "
"and :mod:`nntplib`.  Consult the CVS logs for the exact patch-by-patch "
"details."
msgstr ""
"Python 標準ライブラリに、広範囲に渡ってたくさんの改善とバグフィクスが行われま"
"した。この影響を受けたモジュールとしては :mod:`readline`, :mod:"
"`ConfigParser`, :mod:`cgi`, :mod:`calendar`, :mod:`posix`, :mod:`readline`, :"
"mod:`xmllib`, :mod:`aifc`, :mod:`chunk, wave`, :mod:`random`, :mod:"
"`shelve`, :mod:`nntplib` があります。パッチごとにどのような改造が行われたのか"
"の詳細は CVS ログを調べてください。"

#: ../../whatsnew/2.0.rst:1037
msgid ""
"Brian Gallew contributed OpenSSL support for the :mod:`socket` module.  "
"OpenSSL is an implementation of the Secure Socket Layer, which encrypts the "
"data being sent over a socket.  When compiling Python, you can edit :file:"
"`Modules/Setup` to include SSL support, which adds an additional function to "
"the :mod:`socket` module: ``socket.ssl(socket, keyfile, certfile)``, which "
"takes a socket object and returns an SSL socket.  The :mod:`httplib` and :"
"mod:`urllib` modules were also changed to support ``https://`` URLs, though "
"no one has implemented FTP or SMTP over SSL."
msgstr ""
"Brian Gallew が :mod:`socket` モジュールについての OpenSSL サポートを寄稿しま"
"した。OpenSSL はセキュアソケットレイヤーの実装の一つで、ソケットを通じて送信"
"されるデータの暗号化を行います。Python コンパイル時に :file:`Modules/Setup` "
"を SSL サポートを含むように編集することで :mod:`socket` モジュールに追加機能"
"を有効に出来ます: ``socket.ssl(socket, keyfile, certfile)`` はソケットオブ"
"ジェクトを取り、SSL ソケットを返します。モジュール :mod:`httplib` と :mod:"
"`urllib` も ``https://`` をサポートするように変更されましたが、SSL 経由の "
"FTP と SMTP は実装されていません。 (---訳注: Python 2.1 (:pep:`229`) 以降か"
"ら :file:`Modules/Setup` を編集する必要はなくなっています。ソケットを SSL で"
"ラップするインターフェイスは今では(特に 2.7 のメンテナンスリリースで)もっと進"
"化しています。ドキュメントを参照して下さい。SMTP over SSL は Python 2.2 でサ"
"ポートされました。FTP については Python 2.7 で FTP_TLS がサポートされまし"
"た。 ---)"

#: ../../whatsnew/2.0.rst:1046
msgid ""
"The :mod:`httplib` module has been rewritten by Greg Stein to support "
"HTTP/1.1. Backward compatibility with the 1.5 version of :mod:`httplib` is "
"provided, though using HTTP/1.1 features such as pipelining will require "
"rewriting code to use a different set of interfaces."
msgstr ""
":mod:`httplib` モジュールが、HTTP/1.1 をサポートするように Greg Stein により"
"書き直されました。1.5 バージョンでの :mod:`httplib` との後方互換性は提供され"
"ていますが、パイプライン化のような HTTP/1.1 機能を使うには、これまでとは違っ"
"たインターフェイス集合を使ってコードを書き直す必要があります。"

#: ../../whatsnew/2.0.rst:1051
msgid ""
"The :mod:`Tkinter` module now supports Tcl/Tk version 8.1, 8.2, or 8.3, and "
"support for the older 7.x versions has been dropped.  The Tkinter module now "
"supports displaying Unicode strings in Tk widgets. Also, Fredrik Lundh "
"contributed an optimization which makes operations like ``create_line`` and "
"``create_polygon`` much faster, especially when using lots of coordinates."
msgstr ""
":mod:`Tkinter` モジュールが Tcl/Tk バージョン 8.1, 8.2, 8.3 をサポートするよ"
"うになり、また、古い 7.x バージョンのサポートは取りやめられました。Tkinter モ"
"ジュールが Tk ウィジットでの Unicode 文字列表示をサポートするようになりまし"
"た。また、Fredrik Lundh は ``create_line`` や ``create_polygon`` のような操作"
"を大きく高速化する最適化を寄稿しました。これは特にたくさんの座標系を使用して"
"いる場合に効きます。"

#: ../../whatsnew/2.0.rst:1057
msgid ""
"The :mod:`curses` module has been greatly extended, starting from Oliver "
"Andrich's enhanced version, to provide many additional functions from "
"ncurses and SYSV curses, such as colour, alternative character set support, "
"pads, and mouse support.  This means the module is no longer compatible with "
"operating systems that only have BSD curses, but there don't seem to be any "
"currently maintained OSes that fall into this category."
msgstr ""
":mod:`curses` モジュールが、Oliver Andrich による拡張版をもとに大規模に拡張さ"
"れ、ncurses と SYSV curses からの多くの追加機能、例えば色付きの表示、別の文字"
"集合サポート、パッド、マウスサポートなどをサポートするようになりました。この"
"ことは、モジュールが BSD curses だけしか持っていない OS とは互換性が無いこと"
"を意味しますが、現在メンテナンスされている OS でそういう類のものは無さそうで"
"す。"

#: ../../whatsnew/2.0.rst:1064
msgid ""
"As mentioned in the earlier discussion of 2.0's Unicode support, the "
"underlying implementation of the regular expressions provided by the :mod:"
"`re` module has been changed.  SRE, a new regular expression engine written "
"by Fredrik Lundh and partially funded by Hewlett Packard, supports matching "
"against both 8-bit strings and Unicode strings."
msgstr ""
"2.0 の Unicode サポートについて前述したように、 :mod:`re` モジュールで提供さ"
"れる正規表現の根底となる実装が変更されました。SRE は新しい正規表現エンジン"
"で、Fredrik Lundh によって書かれ、部分的に Hewlett Packard 社により寄贈されま"
"した。これは 8 ビット文字列と Unicode 文字列両方に合致するようサポートされて"
"います。"

#: ../../whatsnew/2.0.rst:1074
msgid "New modules"
msgstr "新しいモジュール"

#: ../../whatsnew/2.0.rst:1076
msgid ""
"A number of new modules were added.  We'll simply list them with brief "
"descriptions; consult the 2.0 documentation for the details of a particular "
"module."
msgstr ""
"数多くのモジュールが新しく追加されました。ここではそれらを短い説明とともに列"
"挙するだけにします。特定のモジュールの詳細は 2.0 のドキュメントを調べてくださ"
"い。"

#: ../../whatsnew/2.0.rst:1080
msgid ""
":mod:`atexit`:  For registering functions to be called before the Python "
"interpreter exits. Code that currently sets ``sys.exitfunc`` directly should "
"be changed to  use the :mod:`atexit` module instead, importing :mod:`atexit` "
"and calling :func:`atexit.register` with  the function to be called on exit. "
"(Contributed by Skip Montanaro.)"
msgstr ""
":mod:`atexit`: Python インタプリタが終了する前に呼び出す関数を登録します。こ"
"れまで ``sys.exitfunc`` に直接セットしてきたコードは  :mod:`atexit` モジュー"
"ルを代わりに用いるように修正してください。 :mod:`atexit` をインポートし、 :"
"func:`atexit.register` で終了時に呼び出す関数を登録します。(Contributed by "
"Skip Montanaro.)"

#: ../../whatsnew/2.0.rst:1086
msgid ""
":mod:`codecs`, :mod:`encodings`, :mod:`unicodedata`:  Added as part of the "
"new Unicode support."
msgstr ""
":mod:`codecs`, :mod:`encodings`, :mod:`unicodedata`: 新しい Unicode サポート"
"の一環で追加されました。"

#: ../../whatsnew/2.0.rst:1089
msgid ""
":mod:`filecmp`: Supersedes the old :mod:`cmp`, :mod:`cmpcache` and :mod:"
"`dircmp` modules, which have now become deprecated. (Contributed by Gordon "
"MacMillan and Moshe Zadka.)"
msgstr ""
":mod:`filecmp`: :mod:`cmp`, :mod:`cmpcache`, :mod:`dircmp` に取って代わるモ"
"ジュールです。このためそれらは非推奨となりました。(Contributed by Gordon "
"MacMillan and Moshe Zadka.)"

#: ../../whatsnew/2.0.rst:1093
msgid ""
":mod:`gettext`: This module provides internationalization (I18N) and "
"localization (L10N) support for Python programs by providing an interface to "
"the GNU gettext message catalog library. (Integrated by Barry Warsaw, from "
"separate contributions by Martin  von Löwis, Peter Funk, and James "
"Henstridge.)"
msgstr ""
":mod:`gettext`: このモジュールは Python プログラムに、GNU gettext メッセージ"
"カタログライブラリへのインターフェイスを提供することで国際化 "
"(I18N=internationalization) と地域化 (L10N=localization) サポートをもたらしま"
"す。 (Integrated by Barry Warsaw, from separate contributions by Martin von "
"Löwis, Peter Funk, and James Henstridge.)"

#: ../../whatsnew/2.0.rst:1098
msgid ""
":mod:`linuxaudiodev`: Support for the :file:`/dev/audio` device on Linux, a "
"twin to the existing :mod:`sunaudiodev` module. (Contributed by Peter Bosch, "
"with fixes by Jeremy Hylton.)"
msgstr ""
":mod:`linuxaudiodev`: Linux の :file:`/dev/audio` デバイスサポートであり、既"
"に存在している :mod:`sunaudiodev` モジュールの双子です。 (Contributed by "
"Peter Bosch, with fixes by Jeremy Hylton.)"

#: ../../whatsnew/2.0.rst:1102
msgid ""
":mod:`mmap`: An interface to memory-mapped files on both Windows and Unix.  "
"A file's contents can be mapped directly into memory, at which point it "
"behaves like a mutable string, so its contents can be read and modified.  "
"They can even be passed to functions that expect ordinary strings, such as "
"the :mod:`re` module. (Contributed by Sam Rushing, with some extensions by A."
"M. Kuchling.)"
msgstr ""
":mod:`mmap`: Windows、Unix 両方でのメモリマップドファイルへのインターフェイス"
"です。ファイル内容をメモリに直接マッピング出来、それは :term:`mutable` な文字"
"列であるかのように振る舞い、これにより読み書き出来ます。それらは例えば :mod:"
"`re` モジュールのような普通は文字列を期待するような関数にさえも渡せます。"
"(Contributed by Sam Rushing, with some extensions by A.M. Kuchling.)"

#: ../../whatsnew/2.0.rst:1108
msgid ""
":mod:`pyexpat`: An interface to the Expat XML parser. (Contributed by Paul "
"Prescod.)"
msgstr ""
":mod:`pyexpat`: Expat XML パーサへのインターフェイスです。 (Contributed by "
"Paul Prescod.)"

#: ../../whatsnew/2.0.rst:1111
msgid ""
":mod:`robotparser`: Parse a :file:`robots.txt` file, which is used for "
"writing Web spiders that politely avoid certain areas of a Web site.  The "
"parser accepts the contents of a :file:`robots.txt` file, builds a set of "
"rules from it, and can then answer questions about the fetchability of a "
"given URL.  (Contributed by Skip Montanaro.)"
msgstr ""
":mod:`robotparser`: ウェブサイトの特定の領域を礼儀正しく避けるウェブスパイダ"
"を書くのに使われる :file:`robots.txt` を解析します。パーサは :file:`robots."
"txt` ファイルの中身を受け取ってそこからルールのセットを構築して、その上で指定"
"した URL がフェッチ可能であるかどうかについての質問の答えを返します。"
"(Contributed by Skip Montanaro.)"

#: ../../whatsnew/2.0.rst:1117
msgid ""
":mod:`tabnanny`: A module/script to  check Python source code for ambiguous "
"indentation. (Contributed by Tim Peters.)"
msgstr ""
":mod:`tabnanny`: Python ソースコードが曖昧なインデントになっていないかを"
"チェックするモジュール/スクリプトです。 (Contributed by Tim Peters.)"

#: ../../whatsnew/2.0.rst:1120
msgid ""
":mod:`UserString`: A base class useful for deriving objects that behave like "
"strings."
msgstr ""
":mod:`UserString`: 文字列のように振る舞う派生オブジェクトを作るのに有用な基底"
"クラスです。"

#: ../../whatsnew/2.0.rst:1123
msgid ""
":mod:`webbrowser`: A module that provides a platform independent way to "
"launch a web browser on a specific URL. For each platform, various browsers "
"are tried in a specific order. The user can alter which browser is launched "
"by setting the *BROWSER* environment variable.  (Originally inspired by Eric "
"S. Raymond's patch to :mod:`urllib` which added similar functionality, but "
"the final module comes from code originally  implemented by Fred Drake as :"
"file:`Tools/idle/BrowserControl.py`, and adapted for the standard library by "
"Fred.)"
msgstr ""
":mod:`webbrowser`: 指定した URL で、プラットフォームに依存しない方法でウェブ"
"ブラウザを起動するモジュールです。個々のプラットフォームにおいて様々なブラウ"
"ザが特定の順序で試されます。ユーザはどのブラウザを起動するかを環境変数 "
"*BROWSER* をセットすることで変更出来ます。(元々は Eric S. Raymond による :"
"mod:`urllib` への、同じ機能追加をするパッチに触発されましたが、最終的なモ"
"ジュールは Fred Drake が元々 :file:`Tools/idle/BrowserControl.py` として実装"
"したものに由来し、Fred が標準ライブラリに適合させました。)"

#: ../../whatsnew/2.0.rst:1132
msgid ""
":mod:`_winreg`: An interface to the Windows registry.  :mod:`_winreg` is an "
"adaptation of functions that have been part of PythonWin since 1995, but has "
"now been added to the core  distribution, and enhanced to support Unicode. :"
"mod:`_winreg` was written by Bill Tutt and Mark Hammond."
msgstr ""
":mod:`_winreg`: Windows のレジストリへのインターフェイスです。 :mod:"
"`_winreg` は 1995 年より PythonWin の一部であった関数群の改作で、これが "
"Unicode サポートの拡張をしてコア配布物に追加されました。 :mod:`_winreg` は "
"Bill Tutt と Mark Hammond により書かれました。"

#: ../../whatsnew/2.0.rst:1137
msgid ""
":mod:`zipfile`: A module for reading and writing ZIP-format archives.  These "
"are archives produced by :program:`PKZIP` on DOS/Windows or :program:`zip` "
"on Unix, not to be confused with :program:`gzip`\\ -format files (which are "
"supported by the :mod:`gzip` module) (Contributed by James C. Ahlstrom.)"
msgstr ""
":mod:`zipfile`: ZIP 形式アーカイブの読み書きのためのモジュールです。DOS/"
"Windows での :program:`PKZIP` や Unix での :program:`zip` により生成される"
"アーカイブで、 :program:`gzip` 形式とは混同しないで下さい (こちらは :mod:"
"`gzip` モジュールによってサポートされています)。(Contributed by James C. "
"Ahlstrom.)"

#: ../../whatsnew/2.0.rst:1142
msgid ""
":mod:`imputil`: A module that provides a simpler way for writing customised "
"import hooks, in comparison to the existing :mod:`ihooks` module.  "
"(Implemented by Greg Stein, with much discussion on python-dev along the "
"way.)"
msgstr ""
":mod:`imputil`: 既にあった :mod:`ihooks` モジュールと較べて簡単な方法でカスタ"
"ムなインポートフックを書くことが出来るモジュールです。(Implemented by Greg "
"Stein, with much discussion on python-dev along the way.)"

#: ../../whatsnew/2.0.rst:1150
msgid "IDLE Improvements"
msgstr "IDLE の改善"

#: ../../whatsnew/2.0.rst:1152
msgid ""
"IDLE is the official Python cross-platform IDE, written using Tkinter. "
"Python 2.0 includes IDLE 0.6, which adds a number of new features and "
"improvements.  A partial list:"
msgstr ""
"IDLE は公式の Python のクロスプラットフォームな IDE で、 Tkinter を使って書か"
"れています。Python 2.0 では IDLE 0.6 を含めました。これは多くの新機能追加と改"
"善がなされています。以下はその一部です::"

#: ../../whatsnew/2.0.rst:1156
msgid ""
"UI improvements and optimizations, especially in the area of syntax "
"highlighting and auto-indentation."
msgstr ""
"UI の、特にシンタクスハイライトと自動インデントの領域において、改善と最適化が"
"なされました。"

#: ../../whatsnew/2.0.rst:1159
msgid ""
"The class browser now shows more information, such as the top level "
"functions in a module."
msgstr ""
"クラスブラウザで、例えばモジュール内のトップレベル関数のような、より多くの情"
"報をみることが出来るようになりました。"

#: ../../whatsnew/2.0.rst:1162
msgid ""
"Tab width is now a user settable option. When opening an existing Python "
"file, IDLE automatically detects the indentation conventions, and adapts."
msgstr ""
"タブ幅をユーザ制御出来るようになりました。既存の Python ファイルを操作する際"
"には、IDLE は自動的にインデントの慣習を検知してそれに合わせます。"

#: ../../whatsnew/2.0.rst:1165
msgid ""
"There is now support for calling browsers on various platforms, used to open "
"the Python documentation in a browser."
msgstr ""
"色々なプラットフォームでブラウザの呼び出しがサポートされています。これを使っ"
"て、ブラウザで Python ドキュメントを開きます。"

#: ../../whatsnew/2.0.rst:1168
msgid ""
"IDLE now has a command line, which is largely similar to  the vanilla Python "
"interpreter."
msgstr ""
"IDLE がコマンドラインを持つようになりました。これは普通の Python インタプリタ"
"に大きく似せてあります。"

#: ../../whatsnew/2.0.rst:1171
msgid "Call tips were added in many places."
msgstr "色々な場所でコンテキストヘルプが出るようになっています。"

#: ../../whatsnew/2.0.rst:1173
msgid "IDLE can now be installed as a package."
msgstr "IDLE は今ではパッケージとしてインストール出来ます。"

#: ../../whatsnew/2.0.rst:1175
msgid "In the editor window, there is now a line/column bar at the bottom."
msgstr "エディタウィンドウ内では、下部に行/桁を表示するようになっています。"

#: ../../whatsnew/2.0.rst:1177
msgid ""
"Three new keystroke commands: Check module (:kbd:`Alt-F5`), Import module (:"
"kbd:`F5`) and Run script (:kbd:`Ctrl-F5`)."
msgstr ""
"新たな 3 つのキーストロークコマンド: モジュールのチェック (:kbd:`Alt-F5`)、モ"
"ジュールのインポート (:kbd:`F5`)、スクリプト実行 (:kbd:`Ctrl-F5`)."

#: ../../whatsnew/2.0.rst:1184
msgid "Deleted and Deprecated Modules"
msgstr "削除されたモジュール、非推奨となったモジュール"

#: ../../whatsnew/2.0.rst:1186
msgid ""
"A few modules have been dropped because they're obsolete, or because there "
"are now better ways to do the same thing.  The :mod:`stdwin` module is gone; "
"it was for a platform-independent windowing toolkit that's no longer "
"developed."
msgstr ""
"少しのモジュールはそれが廃れたり、同じことをするもっと良い手段があるために削"
"除されました。 :mod:`stdwin` はなくなりました。これはプラットフォーム非依存の"
"ウィンドウツールキットで、今ではもう開発されていません。"

#: ../../whatsnew/2.0.rst:1190
msgid ""
"A number of modules have been moved to the :file:`lib-old` subdirectory: :"
"mod:`cmp`, :mod:`cmpcache`, :mod:`dircmp`, :mod:`dump`,  :mod:`find`, :mod:"
"`grep`, :mod:`packmail`,  :mod:`poly`, :mod:`util`, :mod:`whatsound`, :mod:"
"`zmod`.  If you have code which relies on a module  that's been moved to :"
"file:`lib-old`, you can simply add that directory to ``sys.path``   to get "
"them back, but you're encouraged to update any code that uses these modules."
msgstr ""
"数多くのモジュールが :file:`lib-old` サブディレクトリに移動されました:  :mod:"
"`cmp`, :mod:`cmpcache`, :mod:`dircmp`, :mod:`dump`, :mod:`find`, :mod:"
"`grep`, :mod:`packmail`, :mod:`poly`, :mod:`util`, :mod:`whatsound`, :mod:"
"`zmod` 。 :file:`lib-old` に移動されたモジュールに依存するコードを持っている"
"のであれば ``sys.path`` にこれを単に追加出来ますが、それらモジュールを使って"
"いるあらゆるコードは更新した方が良いです。(---訳注: :file:`lib-old` は "
"Python 2.5 で完全に削除されました。---)"

#: ../../whatsnew/2.0.rst:1199
msgid "Acknowledgements"
msgstr "謝辞"

#: ../../whatsnew/2.0.rst:1201
msgid ""
"The authors would like to thank the following people for offering "
"suggestions on various drafts of this article: David Bolen, Mark Hammond, "
"Gregg Hauser, Jeremy Hylton, Fredrik Lundh, Detlef Lannert, Aahz Maruch, "
"Skip Montanaro, Vladimir Marangozov, Tobias Polzin, Guido van Rossum, Neil "
"Schemenauer, and Russ Schmidt."
msgstr ""
"著者は提案の申し出や修正、様々なこの記事の草稿の助けをしてくれた以下の人々に"
"感謝します:  David Bolen, Mark Hammond, Gregg Hauser, Jeremy Hylton, Fredrik "
"Lundh, Detlef Lannert, Aahz Maruch, Skip Montanaro, Vladimir Marangozov, "
"Tobias Polzin, Guido van Rossum, Neil Schemenauer, and Russ Schmidt."