2.0.po

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

#: ../../whatsnew/2.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://peps.python.org/.  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://peps.python.org/ で 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, :"
"samp:`\\\\u{HHHH}`, where *HHHH* is a 4-digit hexadecimal number from 0000 "
"to FFFF.  The existing :samp:`\\\\x{HH}` 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 文字は新しく追加されたエスケープシーケンスで書きます。 :samp:"
"`\\\\u{HHHH}` のように書き、 *HHHH* は 0000 から FFFF までの 4 桁の 16 進表記"
"数です。以前からあるエスケープシーケンス :samp:`\\\\x{HH}` も使えますし、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 customized 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 ``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 ""

#: ../../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 ""

#: ../../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:232
msgid ""
"import codecs\n"
"\n"
"unistr = u'\\u0660\\u2000ab ...'\n"
"\n"
"(UTF8_encode, UTF8_decode,\n"
" UTF8_streamreader, UTF8_streamwriter) = codecs.lookup('UTF-8')\n"
"\n"
"output = UTF8_streamwriter( open( '/tmp/output', 'wb') )\n"
"output.write( unistr )\n"
"output.close()"
msgstr ""

#: ../../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:245
msgid ""
"input = UTF8_streamreader( open( '/tmp/output', 'rb') )\n"
"print repr(input.read())\n"
"input.close()"
msgstr ""

#: ../../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:280
msgid ""
"# Given the list L, make a list of all strings\n"
"# containing the substring S.\n"
"sublist = filter( lambda s, substring=S:\n"
"                     string.find(s, substring) != -1,\n"
"                  L)"
msgstr ""

#: ../../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` expression knows what "
"substring is being searched for.  List comprehensions make this cleaner::"
msgstr ""
"Python のスコープ規則のために、 :keyword:`lambda` 式で作っている匿名関数にデ"
"フォルト引数を使い、これに検索対象の部分文字列を渡しています。リスト内包表記"
"はこれを明快にします::"

#: ../../whatsnew/2.0.rst:290
msgid "sublist = [ s for s in L if string.find(s, S) != -1 ]"
msgstr ""

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

#: ../../whatsnew/2.0.rst:294
msgid ""
"[ expression for expr in sequence1\n"
"             for expr2 in sequence2 ...\n"
"             for exprN in sequenceN\n"
"             if condition ]"
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:310
msgid ""
"for expr1 in sequence1:\n"
"    for expr2 in sequence2:\n"
"    ...\n"
"        for exprN in sequenceN:\n"
"             if (condition):\n"
"                  # Append the value of\n"
"                  # the expression to the\n"
"                  # resulting list."
msgstr ""

#: ../../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:324
msgid ""
"seq1 = 'abc'\n"
"seq2 = (1,2,3)\n"
">>> [ (x,y) for x in seq1 for y in seq2]\n"
"[('a', 1), ('a', 2), ('a', 3), ('b', 1), ('b', 2), ('b', 3), ('c', 1),\n"
"('c', 2), ('c', 3)]"
msgstr ""

#: ../../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:334
msgid ""
"# Syntax error\n"
"[ x,y for x in seq1 for y in seq2]\n"
"# Correct\n"
"[ (x,y) for x in seq1 for y in seq2]"
msgstr ""

#: ../../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 ""

#: ../../whatsnew/2.0.rst:367
msgid ""
"class Number:\n"
"    def __init__(self, value):\n"
"        self.value = value\n"
"    def __iadd__(self, increment):\n"
"        return Number( self.value + increment)\n"
"\n"
"n = Number(5)\n"
"n += 3\n"
"print n.value"
msgstr ""

#: ../../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 ""

#: ../../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 ""

#: ../../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:404
msgid ""
">>> 'andrew'.capitalize()\n"
"'Andrew'\n"
">>> 'hostname'.replace('os', 'linux')\n"
"'hlinuxtname'\n"
">>> 'moshe'.find('sh')\n"
"2"
msgstr ""

#: ../../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 ""

#: ../../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 ""

#: ../../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:452
msgid ""
"instance = SomeClass()\n"
"instance.myself = instance"
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 ""

#: ../../whatsnew/2.0.rst:513
msgid ""
"def f(*args, **kw):\n"
"    # args is a tuple of positional args,\n"
"    # kw is a dictionary of keyword args\n"
"    ..."
msgstr ""

#: ../../whatsnew/2.0.rst:518
msgid ""
"The ``print`` statement can now have its output directed to a file-like "
"object by following the ``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 ``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 ""

#: ../../whatsnew/2.0.rst:526
msgid "print >> sys.stderr, \"Warning: action field not supplied\""
msgstr ""

#: ../../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 ""

#: ../../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:554
msgid ""
"a = []\n"
"b = []\n"
"a.append(a)\n"
"b.append(b)"
msgstr ""

#: ../../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 ""

#: ../../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 https://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 ``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:590
msgid ""
"def f():\n"
"    print \"i=\",i\n"
"    i = i + 1\n"
"f()"
msgstr ""

#: ../../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 ""

#: ../../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 ""

#: ../../whatsnew/2.0.rst:628
msgid ""
"if dict.has_key( key ): return dict[key]\n"
"else:\n"
"    dict[key] = []\n"
"    return dict[key]"
msgstr ""

#: ../../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 ""

#: ../../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 :c: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 ""

#: ../../whatsnew/2.0.rst:673
msgid ""
"Some of the functions in the :mod:`socket` module are still forgiving in "
"this way.  For example, ``socket.connect( ('hostname', 25) )`` is the "
"correct form, passing a tuple representing an IP address, but ``socket."
"connect('hostname', 25)`` also works. :meth:`socket.connect_ex <socket."
"socket.connect_ex>` and :meth:`socket.bind <socket.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)`` も動作します。:meth:`socket.connect_ex "
"<socket.socket.connect_ex>` と :meth:`socket.bind <socket.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 ""

#: ../../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 ""

#: ../../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 ""

#: ../../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 :c: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 標準の :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 ""

#: ../../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: :c:func:"
"`PyModule_AddObject`, :c:func:`PyModule_AddIntConstant`, and :c: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 ""

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

#: ../../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:837
msgid ""
"from distutils.core import setup\n"
"setup (name = \"foo\", version = \"1.0\",\n"
"       py_modules = [\"module1\", \"module2\"])"
msgstr ""

#: ../../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:844
msgid ""
"from distutils.core import setup\n"
"setup (name = \"foo\", version = \"1.0\",\n"
"       packages = [\"package\", \"package.subpackage\"])"
msgstr ""

#: ../../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:851
msgid ""
"from distutils.core import setup, Extension\n"
"\n"
"expat_extension = Extension('xml.parsers.pyexpat',\n"
"     define_macros = [('XML_NS', None)],\n"
"     include_dirs = [ 'extensions/expat/xmltok',\n"
"                      'extensions/expat/xmlparse' ],\n"
"     sources = [ 'extensions/pyexpat.c',\n"
"                 'extensions/expat/xmltok/xmltok.c',\n"
"                 'extensions/expat/xmltok/xmlrole.c', ]\n"
"       )\n"
"setup (name = \"PyXML\", version = \"0.5.4\",\n"
"       ext_modules =[ expat_extension ] )"
msgstr ""

#: ../../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 ""

#: ../../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:`~xml.sax.handler.ContentHandler."
"startElement` and :meth:`~xml.sax.handler.ContentHandler.endElement` methods "
"are called for every starting and end tag encountered by the parser, the :"
"meth:`~xml.sax.handler.ContentHandler.characters` method is called for every "
"chunk of character data, and so forth."
msgstr ""

#: ../../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:916
msgid ""
"from xml import sax\n"
"\n"
"class SimpleHandler(sax.ContentHandler):\n"
"    def startElement(self, name, attrs):\n"
"        print 'Start of element:', name, attrs.keys()\n"
"\n"
"    def endElement(self, name):\n"
"        print 'End of element:', name\n"
"\n"
"# Create a parser object\n"
"parser = sax.make_parser()\n"
"\n"
"# Tell it what handler to use\n"
"handler = SimpleHandler()\n"
"parser.setContentHandler( handler )\n"
"\n"
"# Parse a file!\n"
"parser.parse( 'hamlet.xml' )"
msgstr ""

#: ../../whatsnew/2.0.rst:935
msgid ""
"For more information, consult the Python documentation, or the XML HOWTO at "
"https://pyxml.sourceforge.net/topics/howto/xml-howto.html."
msgstr ""

#: ../../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 ""

#: ../../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 ""

#: ../../whatsnew/2.0.rst:961
msgid ""
"from xml.dom import minidom\n"
"doc = minidom.parse('hamlet.xml')"
msgstr ""

#: ../../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 ""

#: ../../whatsnew/2.0.rst:973
msgid ""
"perslist = doc.getElementsByTagName( 'PERSONA' )\n"
"print perslist[0].toxml()\n"
"print perslist[1].toxml()"
msgstr ""

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

#: ../../whatsnew/2.0.rst:979
msgid ""
"<PERSONA>CLAUDIUS, king of Denmark. </PERSONA>\n"
"<PERSONA>HAMLET, son to the late, and nephew to the present king.</PERSONA>"
msgstr ""

#: ../../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:985
msgid ""
"root = doc.documentElement\n"
"\n"
"# Remove the first child\n"
"root.removeChild( root.childNodes[0] )\n"
"\n"
"# Move the new first child to the end\n"
"root.appendChild( root.childNodes[0] )\n"
"\n"
"# Insert the new first child (originally,\n"
"# the third child) before the 20th child.\n"
"root.insertBefore( root.childNodes[0], root.childNodes[20] )"
msgstr ""

#: ../../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 ""

#: ../../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 ""

#: ../../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 <configparser>`, :mod:`!cgi`, :mod:`calendar`, :mod:`posix`, :"
"mod:`readline`, :mod:`!xmllib`, :mod:`!aifc`, :mod:`!chunk`, :mod:`wave`, :"
"mod:`random`, :mod:`shelve`, and :mod:`!nntplib`.  Consult the CVS logs for "
"the exact patch-by-patch details."
msgstr ""

#: ../../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 <http>` "
"and :mod:`urllib` modules were also changed to support ``https://`` URLs, "
"though no one has implemented FTP or SMTP over SSL."
msgstr ""

#: ../../whatsnew/2.0.rst:1046
msgid ""
"The :mod:`httplib <http>` module has been rewritten by Greg Stein to support "
"HTTP/1.1."
msgstr ""

#: ../../whatsnew/2.0.rst:1048
msgid ""
"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 ""

#: ../../whatsnew/2.0.rst:1052
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 ""

#: ../../whatsnew/2.0.rst:1058
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:1065
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:1075
msgid "New modules"
msgstr "新しいモジュール"

#: ../../whatsnew/2.0.rst:1077
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:1081
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:1087
msgid ""
":mod:`codecs`, :mod:`!encodings`, :mod:`unicodedata`:  Added as part of the "
"new Unicode support."
msgstr ""

#: ../../whatsnew/2.0.rst:1090
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 ""

#: ../../whatsnew/2.0.rst:1094
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:1099
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 ""

#: ../../whatsnew/2.0.rst:1103
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:1109
msgid ""
":mod:`!pyexpat`: An interface to the Expat XML parser. (Contributed by Paul "
"Prescod.)"
msgstr ""

#: ../../whatsnew/2.0.rst:1112
msgid ""
":mod:`robotparser <urllib.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 ""

#: ../../whatsnew/2.0.rst:1118
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:1121
msgid ""
":mod:`!UserString`: A base class useful for deriving objects that behave "
"like strings."
msgstr ""

#: ../../whatsnew/2.0.rst:1124
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:1133
msgid ""
":mod:`_winreg <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 ""

#: ../../whatsnew/2.0.rst:1138
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:1143
msgid ""
":mod:`!imputil`: A module that provides a simpler way for writing customized "
"import hooks, in comparison to the existing :mod:`!ihooks` module.  "
"(Implemented by Greg Stein, with much discussion on python-dev along the "
"way.)"
msgstr ""

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

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

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

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

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

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

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

#: ../../whatsnew/2.0.rst:1178
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:1185
msgid "Deleted and Deprecated Modules"
msgstr "削除されたモジュール、非推奨となったモジュール"

#: ../../whatsnew/2.0.rst:1187
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 ""

#: ../../whatsnew/2.0.rst:1191
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 ""

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

#: ../../whatsnew/2.0.rst:1202
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."