[Pythonjp-checkins] [python-doc-ja] 2 new revisions pushed by hinac****@gmail***** on 2011-11-06 16:20 GMT

アーカイブの一覧に戻る

pytho****@googl***** pytho****@googl*****
2011年 11月 7日 (月) 01:21:07 JST


2 new revisions:

Revision: 2d699f50a835
Author:   Arihiro TAKASE <hinac****@gmail*****>
Date:     Sun Nov  6 08:09:46 2011
Log:      差分翻訳 2.7.2 library/functions, stdtypes
http://code.google.com/p/python-doc-ja/source/detail?r=2d699f50a835

Revision: 67214ab13c06
Author:   Arihiro TAKASE <hinac****@gmail*****>
Date:     Sun Nov  6 08:20:24 2011
Log:      merge
http://code.google.com/p/python-doc-ja/source/detail?r=67214ab13c06

==============================================================================
Revision: 2d699f50a835
Author:   Arihiro TAKASE <hinac****@gmail*****>
Date:     Sun Nov  6 08:09:46 2011
Log:      差分翻訳 2.7.2 library/functions, stdtypes
http://code.google.com/p/python-doc-ja/source/detail?r=2d699f50a835

Modified:
  /faq/design.rst
  /faq/extending.rst
  /faq/general.rst
  /faq/gui.rst
  /faq/installed.rst
  /library/functions.rst
  /library/stdtypes.rst

=======================================
--- /faq/design.rst	Sat Mar 19 08:59:41 2011
+++ /faq/design.rst	Sun Nov  6 08:09:46 2011
@@ -1,89 +1,86 @@
-======================
-Design and History FAQ
-======================
-
-Why does Python use indentation for grouping of statements?
------------------------------------------------------------
-
-Guido van Rossum believes that using indentation for grouping is extremely
-elegant and contributes a lot to the clarity of the average Python program.
-Most people learn to love this feature after a while.
-
-Since there are no begin/end brackets there cannot be a disagreement  
between
-grouping perceived by the parser and the human reader.  Occasionally C
-programmers will encounter a fragment of code like this::
+==================
+デザインと歴史 FAQ
+==================
+
+Python はなぜ文のグループ化にインデンテーションを使うのですか?
+---------------------------------------------------------------
+
+Guido van Rossum の信じるところによれば、インデントによるグループ化は
+非常にエレガントで、平均的な Python プログラムを大いに読みやすくします。
+しばらくすればほとんどの人はこの特徴を気に入るようになります。
+
+begin/end の括りがないので、構文解析器と人間の読者の間にグループ化の
+解釈の違いは起こりえません。時折、C のプログラマはこのようなコード片に
+出くわします::

     if (x <= y)
             x++;
             y--;
     z++;

-Only the ``x++`` statement is executed if the condition is true, but the
-indentation leads you to believe otherwise.  Even experienced C  
programmers will
-sometimes stare at it a long time wondering why ``y`` is being decremented  
even
-for ``x > y``.
-
-Because there are no begin/end brackets, Python is much less prone to
-coding-style conflicts.  In C there are many different ways to place the  
braces.
-If you're used to reading and writing code that uses one style, you will  
feel at
-least slightly uneasy when reading (or being required to write) another  
style.
-
-Many coding styles place begin/end brackets on a line by themself.  This  
makes
-programs considerably longer and wastes valuable screen space, making it  
harder
-to get a good overview of a program.  Ideally, a function should fit on one
-screen (say, 20-30 lines).  20 lines of Python can do a lot more work than  
20
-lines of C.  This is not solely due to the lack of begin/end brackets --  
the
-lack of declarations and the high-level data types are also responsible --  
but
-the indentation-based syntax certainly helps.
+この条件文が真の時のみ実行されるのは ``x++`` 文だけですが、
+このインデンテーションでは誤解を招きます。経験を積んだ C プログラマでさえ、
+``y`` が ``x > y`` の時にもデクリメントされるのはなぜか分からず
+長いこと立ち止まることがあるでしょう。
+
+begin/end の括りがないので、Python はコーディングスタイルの対立が非常に
+起こりにくくなります。C では多様なカッコの置き方があります。
+一つのスタイルでのコードの読み書きに慣れてしまうと、他のスタイルを
+読むとき (あるいは書かなくてはならないとき) にむずむずするでしょう。
+
+多くのコーディングスタイルは begin/end の括りにそれぞれ一行を使います。
+これではプログラムは冗長になって画面を浪費し、プログラムの見通しが
+悪くなります。一つの関数は一画面 (例えば 20 - 30 行) に収めるのが理想です。
+20 行の Python は20行の C よりもはるかに多くのことができます。
+これは begin/end の括りがないからだけではありません -- 宣言が
+不要なことや高レベルなデータ型もその理由です -- が、
+インデンテーションに基づく構文は確かに役に立っています。


-Why am I getting strange results with simple arithmetic operations?
--------------------------------------------------------------------
-
-See the next question.
+なぜ単純な算術演算が奇妙な結果になるのですか?
+----------------------------------------------
+
+次の質問を参照してください。


-Why are floating point calculations so inaccurate?
---------------------------------------------------
-
-People are often very surprised by results like this::
+なぜ浮動小数点演算はこれほど不正確なのですか?
+----------------------------------------------
+
+このような結果は、よく驚かれたり Python のバグであると考えられたりします::

     >>> 1.2 - 1.0
     0.199999999999999996

-and think it is a bug in Python. It's not.  This has nothing to do with  
Python,
-but with how the underlying C platform handles floating point numbers, and
-ultimately with the inaccuracies introduced when writing down numbers as a
-string of a fixed number of digits.
-
-The internal representation of floating point numbers uses a fixed number  
of
-binary digits to represent a decimal number.  Some decimal numbers can't be
-represented exactly in binary, resulting in small roundoff errors.
-
-In decimal math, there are many numbers that can't be represented with a  
fixed
-number of decimal digits, e.g.  1/3 = 0.3333333333.......
-
-In base 2, 1/2 = 0.1, 1/4 = 0.01, 1/8 = 0.001, etc.  .2 equals 2/10 equals  
1/5,
-resulting in the binary fractional number 0.001100110011001...
-
-Floating point numbers only have 32 or 64 bits of precision, so the digits  
are
-cut off at some point, and the resulting number is 0.199999999999999996 in
-decimal, not 0.2.
-
-A floating point number's ``repr()`` function prints as many digits are
-necessary to make ``eval(repr(f)) == f`` true for any float f.  The  
``str()``
-function prints fewer digits and this often results in the more sensible  
number
-that was probably intended::
+でもこれはバグではありません。これは Python ではなく、その基底にある C の
+プラットフォームによる浮動小数点数の扱い方の問題で、
+究極には数を固定長の桁に書き下す際に生じたものです。
+
+浮動小数点数の内部表現では一定数の二進数で十進数を示します。
+二進数では正確に表せない十進数もあり、僅かな丸め誤差を生じます。
+
+十進数演算では、1/3 = 0.3333333333....... など、固定長の十進数では
+表せない数がたくさんあります。
+
+基数が 2 のとき、1/2 = 0.1、1/4 = 0.01、1/8 = 0.001、などになります。
+.2 は 2/10 と等しく、1/5 と等しいので、二進数の分数で
+0.001100110011001... になります。
+
+浮動小数点数には 32 か 64 ビットの精度しかないので、ある桁で
+切り捨てられ、十進数表示で 0.2 ではなく 0.199999999999999996 となります。
+
+浮動小数点数の ``repr()`` 関数はすべての浮動小数点数 f に対して
+``eval(repr(f)) == f`` が真となるのに必要なだけの桁を表示します。
+``str()`` 関数はそれより少ない桁を表示するので、より意図を汲んだ
+感覚的な数を得やすいです::

     >>> 0.2
     0.20000000000000001
     >>> print 0.2
     0.2

-One of the consequences of this is that it is error-prone to compare the  
result
-of some computation to a float with ``==``. Tiny inaccuracies may mean that
-``==`` fails.  Instead, you have to check that the difference between the  
two
-numbers is less than a certain threshold::
+その結果、\ ``==`` による浮動小数点の演算結果の比較は間違いやすいです。
+僅かな不正確さだけで ``==`` が間違うこともあります。その代わりに、
+二つの数間の差があるしきい値よりも小さいことを調べなくてはなりません::

     epsilon = 0.0000000000001  # Tiny allowed error
     expected_result = 0.4
@@ -91,71 +88,69 @@
     if expected_result-epsilon <= computation() <= expected_result+epsilon:
         ...

-Please see the chapter on :ref:`floating point arithmetic <tut-fp-issues>`  
in
-the Python tutorial for more information.
+詳しくは、Python チュートリアルの :ref:`floating point arithmetic
+<tut-fp-issues>` の章を参照してください。


-Why are Python strings immutable?
----------------------------------
-
-There are several advantages.
-
-One is performance: knowing that a string is immutable means we can  
allocate
-space for it at creation time, and the storage requirements are fixed and
-unchanging.  This is also one of the reasons for the distinction between  
tuples
-and lists.
-
-Another advantage is that strings in Python are considered as "elemental"  
as
-numbers.  No amount of activity will change the value 8 to anything else,  
and in
-Python, no amount of activity will change the string "eight" to anything  
else.
+なぜ Python の文字列はイミュータブルなのですか?
+------------------------------------------------
+
+これにはいくつかの利点があります。
+
+一つはパフォーマンスです。文字列がイミュータブルなら、
+生成時に領域を割り当てることができるので、必要な記憶域は固定されて、
+変更されません。これはタプルとリストを区別する理由の一つでもあります。
+
+別の利点は、Python で文字列が数と同じくらい "基本的" なものと
+考えられることです。8 という値を他の何かに変える手段が無いように、
+文字列 "eight" を他の何かに変える手段も無いのです。


  .. _why-self:

-Why must 'self' be used explicitly in method definitions and calls?
--------------------------------------------------------------------
-
-The idea was borrowed from Modula-3.  It turns out to be very useful, for a
-variety of reasons.
-
-First, it's more obvious that you are using a method or instance attribute
-instead of a local variable.  Reading ``self.x`` or ``self.meth()`` makes  
it
-absolutely clear that an instance variable or method is used even if you  
don't
-know the class definition by heart.  In C++, you can sort of tell by the  
lack of
-a local variable declaration (assuming globals are rare or easily  
recognizable)
--- but in Python, there are no local variable declarations, so you'd have  
to
-look up the class definition to be sure.  Some C++ and Java coding  
standards
-call for instance attributes to have an ``m_`` prefix, so this  
explicitness is
-still useful in those languages, too.
-
-Second, it means that no special syntax is necessary if you want to  
explicitly
-reference or call the method from a particular class.  In C++, if you want  
to
-use a method from a base class which is overridden in a derived class, you  
have
-to use the ``::`` operator -- in Python you can write
-``baseclass.methodname(self, <argument list>)``.  This is particularly  
useful
-for :meth:`__init__` methods, and in general in cases where a derived class
-method wants to extend the base class method of the same name and thus has  
to
-call the base class method somehow.
-
-Finally, for instance variables it solves a syntactic problem with  
assignment:
-since local variables in Python are (by definition!) those variables to  
which a
-value is assigned in a function body (and that aren't explicitly declared
-global), there has to be some way to tell the interpreter that an  
assignment was
-meant to assign to an instance variable instead of to a local variable,  
and it
-should preferably be syntactic (for efficiency reasons).  C++ does this  
through
-declarations, but Python doesn't have declarations and it would be a pity  
having
-to introduce them just for this purpose.  Using the explicit ``self.var``  
solves
-this nicely.  Similarly, for using instance variables, having to write
-``self.var`` means that references to unqualified names inside a method  
don't
-have to search the instance's directories.  To put it another way, local
-variables and instance variables live in two different namespaces, and you  
need
-to tell Python which namespace to use.
+なぜメソッドの定義や呼び出しにおいて 'self' を明示しなければならないのです 
か?
+------------------------------------------------------------------------------
+
+このアイデアは Modula-3 から取り入れられました。
+これは様々な理由からとても便利だと言えます。
+
+まず、扱っているのがローカル変数ではなく、メソッドやインスタンス属性なのだ 
と
+分かりやすいです。\ ``self.x`` や ``self.meth()`` と書いてあれば、
+そのクラスの定義を憶えていなくても、それがインスタンス変数や
+メソッドであることは明白です。C++ では、(グローバルは滅多にないし、
+簡単に判別できるので) ローカル変数宣言されていないことから
+ある程度わかるでしょう。-- しかし Python にはローカル変数宣言がないので、
+クラス定義を調べて確かめなくてはなりません。C++ や Java の
+コーディングスタンダードに、インスタンス属性に
+``m_`` 接頭辞をつけるものがあるように、この明示性は
+それらの言語でも役に立ちます。
+
+第二に、特定のクラスからメソッドを明示的に参照や呼び出ししたい時に、
+特別な構文が必要なくなります。C++ では、派生クラスでオーバーライドされた
+基底クラスからメソッドを使うには、\ ``::`` 演算子を使わなければなりません。
+-- Python では、\ ``baseclass.methodname(self, <argument list>)`` と書けま 
す。
+これは特に、\ :meth:`__init__` メソッドに便利ですし、派生クラスのメソッド 
が、
+基底クラスにある同じ名前のメソッドを拡張するために、
+基底クラスのメソッドをどうにかして呼び出したい時にも便利です。
+
+最後に、インスタンス変数の、代入の構文の問題を解決できます。
+Python のローカル変数は、関数の中で (global が明示的に宣言されることなく)
+値が代入された変数 (と定義されています!) なので、インタプリタには、代入が
+ローカル変数にではなくインスタンス変数にされたのだと判断する方法が
+必要で、構文を見るだけで分かる方が (効率が) 良いのです。
+C++ ではその区別を宣言時に行いますが、Python では宣言がないので、
+この方法でしか区別できなかったら残念です。\ ``self.var`` を明示すれば
+しっくりきます。同様に、インスタンス変数を使うためにも ``self.var`` と
+書かなければならないので、メソッドの中の self が付いていない名前への参照 
は、
+そのインスタンスのディレクトリを検索するまでもなくローカル変数とわかりま 
す。
+別の言い方をすれば、ローカル変数とインスタンス変数は二つの異なる名前空間に
+存在し、Python にどちらの名前空間を使うかを伝えなくてはならないのです。


-Why can't I use an assignment in an expression?
------------------------------------------------
-
-Many people used to C or Perl complain that they want to use this C idiom:
+式中で代入ができないのはなぜですか?
+------------------------------------
+
+C や Perl に慣れた多くの人は、C のこの慣用句を使いたいと訴えます:

  .. code-block:: c

@@ -163,7 +158,7 @@
         // do something with line
     }

-where in Python you're forced to write this::
+Python ではこう書かなくてはなりません::

     while True:
         line = f.readline()
@@ -171,8 +166,8 @@
             break
         ... # do something with line

-The reason for not allowing assignment in Python expressions is a common,
-hard-to-find bug in those other languages, caused by this construct:
+Python の式中での代入を許さない理由は、この構造によって起こる
+他の言語ではありがちで見つけづらいバグです:

  .. code-block:: c

@@ -183,122 +178,110 @@
          // code that only works for nonzero x
      }

-The error is a simple typo: ``x = 0``, which assigns 0 to the variable  
``x``,
-was written while the comparison ``x == 0`` is certainly what was intended.
-
-Many alternatives have been proposed.  Most are hacks that save some  
typing but
-use arbitrary or cryptic syntax or keywords, and fail the simple criterion  
for
-language change proposals: it should intuitively suggest the proper  
meaning to a
-human reader who has not yet been introduced to the construct.
-
-An interesting phenomenon is that most experienced Python programmers  
recognize
-the ``while True`` idiom and don't seem to be missing the assignment in
-expression construct much; it's only newcomers who express a strong desire  
to
-add this to the language.
-
-There's an alternative way of spelling this that seems attractive but is
-generally less robust than the "while True" solution::
+このエラーは単純なタイプミスで、 本当にやりたかったのは ``x == 0`` の
+比較ですが、\ ``x = 0`` と書いてしまい、変数 ``x`` に 0 を代入しています。
+
+提案された代替案はたくさんあります。多くの案はタイプ数を少し節約しますが、
+勝手だったり意味不明だったりする構文や予約語を使い、言語変更の提案の
+簡潔さの基準を満たしていません。構造の説明をされていない人間の
+読者に、正しい意味を直感的に示す物であるべきです。
+
+面白いことに、熟練した Python プログラマは ``while True`` というイディオム 
を
+受け入れていて、式構造中の代入がなくてもそれほど苦労しないようです。
+Python にそれを強く求めるのは新人だけです。
+
+以下の方法でもこれを綴ることができて、魅力的そうですが、
+堅牢さでは "while True" を使う方法に劣ることが多いです::

     line = f.readline()
     while line:
         ... # do something with line...
         line = f.readline()

-The problem with this is that if you change your mind about exactly how  
you get
-the next line (e.g. you want to change it into ``sys.stdin.readline()``)  
you
-have to remember to change two places in your program -- the second  
occurrence
-is hidden at the bottom of the loop.
-
-The best approach is to use iterators, making it possible to loop through
-objects using the ``for`` statement.  For example, in the current version  
of
-Python file objects support the iterator protocol, so you can now write  
simply::
+この方法の問題は、次の行を取得する方法を変えたくなったとき
+(``sys.stdin.readline()`` に変更したい時など) にプログラムの
+二箇所を変えなくてはならないことです --
+二つ目の場所はループの最後に隠れています。
+
+一番いいのはイテレータを使って、\ ``for`` 文でオブジェクトを通して
+ループさせることです。例えば、
+:term:`ファイルオブジェクト <file object>` はイテレータプロトコルを
+サポートしているので、単純にこう書けます::

     for line in f:
         ... # do something with line...



-Why does Python use methods for some functionality (e.g. list.index()) but  
functions for other (e.g. len(list))?
-----------------------------------------------------------------------------------------------------------------
-
-The major reason is history. Functions were used for those operations that  
were
-generic for a group of types and which were intended to work even for  
objects
-that didn't have methods at all (e.g. tuples).  It is also convenient to  
have a
-function that can readily be applied to an amorphous collection of objects  
when
-you use the functional features of Python (``map()``, ``apply()`` et al).
-
-In fact, implementing ``len()``, ``max()``, ``min()`` as a built-in  
function is
-actually less code than implementing them as methods for each type.  One  
can
-quibble about individual cases but it's a part of Python, and it's too  
late to
-make such fundamental changes now. The functions have to remain to avoid  
massive
-code breakage.
+Python にメソッドを使う機能 (list.index()等) と関数を使う機能  
(list.index()等) があるのはなぜですか?
+-----------------------------------------------------------------------------------------------------
+
+歴史上の経緯が主な理由です。関数は型のグループに共通で、
+メソッドを持たないオブジェクト(タプル等)にも適用できるようにした操作に
+使われていました。オブジェクトの無定形な集合に容易に適用できる関数が
+あることは、Python の関数的機能 (``map()``\ 、\ ``apply()`` 等) を
+使うときにも便利です。
+
+実際、\ ``len()``\ 、\ ``max()``\ 、\ ``min()`` を組み込み関数として実装す 
ることで、
+それぞれの型のメソッドとして実装するより少ないコードで済みます。
+個々のケースについては粗探しのしようがありますが、Python の一部であるし、
+根本的な変更をするには遅すぎます。これらの関数は、
+大規模なコードの破壊を避けるために残す必要があります。

  .. XXX talk about protocols?

  .. note::

-   For string operations, Python has moved from external functions (the
-   ``string`` module) to methods.  However, ``len()`` is still a function.
+   Python の文字列演算は、外部の関数からメソッド (``string`` モジュール)
+   に移行しました。しかし、\ ``len()`` は関数のままです。


-Why is join() a string method instead of a list or tuple method?
-----------------------------------------------------------------
-
-Strings became much more like other standard types starting in Python 1.6,  
when
-methods were added which give the same functionality that has always been
-available using the functions of the string module.  Most of these new  
methods
-have been widely accepted, but the one which appears to make some  
programmers
-feel uncomfortable is::
+join() がリストやタプルのメソッドではなく文字列のメソッドなのはなぜですか?
+---------------------------------------------------------------------------
+
+文字列は Python 1.6 からメソッドが追加され、他の標準型と同じような
+機能が string モジュールの関数でいつでも使えるようになったことで、
+他の標準型に大きく近づきました。その新しいメソッドの多くは
+広く受け入れられましたが、一部のプログラマに不快を
+感じさせていると思われるものがこれで::

     ", ".join(['1', '2', '4', '8', '16'])

-which gives the result::
+結果はこうなります::

     "1, 2, 4, 8, 16"

-There are two common arguments against this usage.
-
-The first runs along the lines of: "It looks really ugly using a method of  
a
-string literal (string constant)", to which the answer is that it might,  
but a
-string literal is just a fixed value. If the methods are to be allowed on  
names
-bound to strings there is no logical reason to make them unavailable on
-literals.
-
-The second objection is typically cast as: "I am really telling a sequence  
to
-join its members together with a string constant".  Sadly, you aren't.   
For some
-reason there seems to be much less difficulty with  
having :meth:`~str.split` as
-a string method, since in that case it is easy to see that ::
+この使い方には二つの議論があります。
+
+一つ目は、「文字列リテラル (文字列定数) のメソッドを使うのは醜すぎる」と
+いうようなものです。確かにそうかも知れませんが、文字列リテラルは
+単なる固定された値に過ぎないというのが答えです。文字列に束縛された名前に
+メソッドが許されるなら、リテラルに使えないようにする理由はないでしょう。
+
+二つ目の反対理由は、典型的には「シーケンスを文字列定数で結合させようと
+しているのだ」というものです。残念ながら、そうではないのです。
+いくつかの理由から :meth:`~str.split` を
+文字列のメソッドとしておいた方がはるかに簡単です。
+これを見ると分かりやすいでしょう::

     "1, 2, 4, 8, 16".split(", ")

-is an instruction to a string literal to return the substrings delimited  
by the
-given separator (or, by default, arbitrary runs of white space).  In this  
case a
-Unicode string returns a list of Unicode strings, an ASCII string returns  
a list
-of ASCII strings, and everyone is happy.
-
-:meth:`~str.join` is a string method because in using it you are telling  
the
-separator string to iterate over a sequence of strings and insert itself  
between
-adjacent elements.  This method can be used with any argument which obeys  
the
-rules for sequence objects, including any new classes you might define  
yourself.
-
-Because this is a string method it can work for Unicode strings as well as  
plain
-ASCII strings.  If ``join()`` were a method of the sequence types then the
-sequence types would have to decide which type of string to return  
depending on
-the type of the separator.
-
-.. XXX remove next paragraph eventually
-
-If none of these arguments persuade you, then for the moment you can  
continue to
-use the ``join()`` function from the string module, which allows you to  
write ::
-
-   string.join(['1', '2', '4', '8', '16'], ", ")
-
-
-How fast are exceptions?
-------------------------
-
-A try/except block is extremely efficient.  Actually catching an exception  
is
-expensive.  In versions of Python prior to 2.0 it was common to use this  
idiom::
+これは文字列リテラルに与えられた分離子 (デフォルトでは空白文字) によって
+区切られた部分文字列を返すように指示しています。
+
+:meth:`~str.join` は、セパレータ文字列に、文字列のシーケンスを
+イテレートして隣り合う要素の間に自身を挿入するように指示しているので、
+文字列のメソッドです。このメソッドは、
+独自に定義された新しいクラスを含め、シーケンスの規則を
+満たすいかなる引数にも使えます。バイト列や可変バイト列オブジェクトにも
+同様のメソッドがあります。
+
+
+例外はどれくらい速いのですか?
+------------------------------
+
+try/except ブロックは極端に効率がいいです。実際に例外を補足するのは高価で 
す。
+Python 2.0 より前のバージョンでは、このイディオムが一般的でした::

     try:
         value = mydict[key]
@@ -306,8 +289,8 @@
         mydict[key] = getvalue(key)
         value = mydict[key]

-This only made sense when you expected the dict to have the key almost all  
the
-time.  If that wasn't the case, you coded it like this::
+これは、辞書がほとんどの場合にキーを持っていると予想できるときにのみ
+意味をなします。そうでなければ、このように書きます::

     if mydict.has_key(key):
         value = mydict[key]
@@ -317,21 +300,20 @@

  .. note::

-   In Python 2.0 and higher, you can code this as ``value =
-   mydict.setdefault(key, getvalue(key))``.
+   Python 2.0 以降では、\ ``value = mydict.setdefault(key, getvalue(key))``
+   のように書くことができます。


-Why isn't there a switch or case statement in Python?
------------------------------------------------------
-
-You can do this easily enough with a sequence of ``if... elif... elif...  
else``.
-There have been some proposals for switch statement syntax, but there is no
-consensus (yet) on whether and how to do range tests.  See :pep:`275` for
-complete details and the current status.
-
-For cases where you need to choose from a very large number of  
possibilities,
-you can create a dictionary mapping case values to functions to call.  For
-example::
+Python に switch や case 文がないのはなぜですか?
+-------------------------------------------------
+
+``if... elif... elif... else`` の繰り返しで簡単に同じことができます。
+switch 文の構文に関する提案が幾つかありましたが、範囲検定をするべきか、
+あるいはどのようにするべきかについての合意は (まだ) 得られていません。
+現在の状況の完全な詳細は :pep:`275` を参照してください。
+
+非常に大きな数の選択肢から選ぶとき、値を呼び出す関数に対応づける辞書を
+作れます。例えば::

     def function_1(...):
         ...
@@ -343,8 +325,8 @@
     func = functions[value]
     func()

-For calling methods on objects, you can simplify yet further by using the
-:func:`getattr` built-in to retrieve methods with a particular name::
+オブジェクトのメソッドを呼び出すには、さらに単純に
+:func:`getattr` 組み込み関数で特定の名前のメソッドを検索することが出来ま 
す::

     def visit_a(self, ...):
         ...
@@ -355,275 +337,283 @@
         method = getattr(self, method_name)
         method()

-It's suggested that you use a prefix for the method names, such as  
``visit_`` in
-this example.  Without such a prefix, if values are coming from an  
untrusted
-source, an attacker would be able to call any method on your object.
+メソッドの名前にこの例の `visit_`` のような接頭辞を使うことを勧めます。
+このような接頭辞がないと、信頼できないソースから値が与えられたときに、
+オブジェクトの任意のメソッドを呼び出す攻撃をされる可能性があります。


-Can't you emulate threads in the interpreter instead of relying on an  
OS-specific thread implementation?
---------------------------------------------------------------------------------------------------------
-
-Answer 1: Unfortunately, the interpreter pushes at least one C stack frame  
for
-each Python stack frame.  Also, extensions can call back into Python at  
almost
-random moments.  Therefore, a complete threads implementation requires  
thread
-support for C.
-
-Answer 2: Fortunately, there is `Stackless Python  
<http://www.stackless.com>`_,
-which has a completely redesigned interpreter loop that avoids the C stack.
-It's still experimental but looks very promising.  Although it is binary
-compatible with standard Python, it's still unclear whether Stackless will  
make
-it into the core -- maybe it's just too revolutionary.
+OS 特有のスレッド実装に依らずにインタプリタでスレッドをエミュレートすること 
はできないのですか?
+-----------------------------------------------------------------------------------------------
+
+答 1: 残念なことに、インタプリタは Python のスタックフレームごとに
+少なくとも一つの C のスタックフレームを push します。同様に、
+拡張もほとんどランダムなときに Python にコールバックすることがあります。
+よって、完全なスレッド実装には C のスレッドサポートが必要です。
+
+答 2: 幸運なことに、完全に C スタックを使わないように再設計された
+インタプリタ `Stackless Python <http://www.stackless.com>`_ があります。
+まだ実験的なものですが、将来性がありそうです。これは標準の
+Python とバイナリ互換ですが、スタックレスの中核となるかどうかは
+まだわかりません -- これはあまりに革命的すぎるかもしれません。


-Why can't lambda forms contain statements?
-------------------------------------------
-
-Python lambda forms cannot contain statements because Python's syntactic
-framework can't handle statements nested inside expressions.  However, in
-Python, this is not a serious problem.  Unlike lambda forms in other  
languages,
-where they add functionality, Python lambdas are only a shorthand notation  
if
-you're too lazy to define a function.
-
-Functions are already first class objects in Python, and can be declared  
in a
-local scope.  Therefore the only advantage of using a lambda form instead  
of a
-locally-defined function is that you don't need to invent a name for the
-function -- but that's just a local variable to which the function object  
(which
-is exactly the same type of object that a lambda form yields) is assigned!
+ラムダ式が文を含めないのはなぜですか?
+--------------------------------------
+
+Python の構文的な枠組みでは式の中にネストされた文を扱えないため、
+Python のラムダ式は文を含めません。しかし、Python ではこれは深刻な
+問題ではありません。他の言語でのラムダ式が機能性を追加するものであるのと
+違い、Python でのラムダは関数を定義するのが面倒なときの
+速記法に過ぎません。
+
+Python では関数はもとからファーストクラスオブジェクトであり、
+ローカルなスコープで宣言できます。よって、ローカルに宣言される
+関数ではなくラムダ式を使う利点はただ一つ、関数の名前を
+考えなくてもいいことです - でもその関数オブジェクトが代入されるのは
+(ラムダ式が名前を空けたのとまさに同じ型のオブジェクトである)
+ローカル変数です!


-Can Python be compiled to machine code, C or some other language?
------------------------------------------------------------------
-
-Not easily.  Python's high level data types, dynamic typing of objects and
-run-time invocation of the interpreter (using :func:`eval`  
or :keyword:`exec`)
-together mean that a "compiled" Python program would probably consist  
mostly of
-calls into the Python run-time system, even for seemingly simple  
operations like
-``x+1``.
-
-Several projects described in the Python newsgroup or at past `Python
-conferences <http://python.org/community/workshops/>`_ have shown that this
-approach is feasible, although the speedups reached so far are only modest
-(e.g. 2x).  Jython uses the same strategy for compiling to Java bytecode.   
(Jim
-Hugunin has demonstrated that in combination with whole-program analysis,
-speedups of 1000x are feasible for small demo programs.  See the  
proceedings
-from the `1997 Python conference
-<http://python.org/workshops/1997-10/proceedings/>`_ for more information.)
-
-Internally, Python source code is always translated into a bytecode
-representation, and this bytecode is then executed by the Python virtual
-machine.  In order to avoid the overhead of repeatedly parsing and  
translating
-modules that rarely change, this byte code is written into a file whose  
name
-ends in ".pyc" whenever a module is parsed.  When the corresponding .py  
file is
-changed, it is parsed and translated again and the .pyc file is rewritten.
-
-There is no performance difference once the .pyc file has been loaded, as  
the
-bytecode read from the .pyc file is exactly the same as the bytecode  
created by
-direct translation.  The only difference is that loading code from a .pyc  
file
-is faster than parsing and translating a .py file, so the presence of
-precompiled .pyc files improves the start-up time of Python scripts.  If
-desired, the Lib/compileall.py module can be used to create valid .pyc  
files for
-a given set of modules.
-
-Note that the main script executed by Python, even if its filename ends  
in .py,
-is not compiled to a .pyc file.  It is compiled to bytecode, but the  
bytecode is
-not saved to a file.  Usually main scripts are quite short, so this  
doesn't cost
-much speed.
+Python は C やその他の言語のように機械語にコンパイルできますか?
+----------------------------------------------------------------
+
+簡単にはできません。Python の高水準データ型、動的な型付け、(:func:`eval` や
+:func:`exec` を使った) インタプリタの実行時呼び出しがあるということは、
+「コンパイルされた」Python のプログラムのほとんどが、\ ``x+1`` のような
+一見簡単な演算でさえ、Python のランタイムシステムへの呼び出しで
+成り立っているであろうことを意味します。
+
+Python ニュースグループや過去の
+`Python conferences <http://python.org/community/workshops/>`_ で
+説明されたいくつかのプロジェクトを見ると、現在の速度の向上は
+緩やかでしかない (たとえば 2 倍) ですが、このやり方はうまくいきそうです。
+Jython は Java バイトコードにコンパイルするという同様の方法を使っています。
+(Jim Hugunin の論証によれば、プログラム全体の解析と組み合わせることで、
+小さなデモプログラムでは 1000 倍の速度向上が見込めます。詳しくは
+`1997 Python conference  
<http://python.org/workshops/1997-10/proceedings/>`_
+の議事録を参照してください。)
+
+内部的には、Python のソースコードはいつもバイトコード表現に
+翻訳されていて、そのバイトコードが Python の仮想マシンによって
+実行されます。めったに変更されないモジュールの解析が繰り返されることによる
+オーバーヘッドを避けるため、このバイトコードはモジュールが解析されるたびに
+名前が ".pic" で終わるファイルに書きこまれます。対応する .py ファイルが
+変更されたとき、そのファイルは再び解析および翻訳されて
+.pyc ファイルは書き直されます。
+
+一旦 .pyc ファイルが読み込まれればパフォーマンスの差はなく、
+.pyc ファイルから読み込まれたバイトコードも、直接の変換により
+生成されたバイトコードも全く同じです。唯一の違いは、.pyc ファイルから
+コードを読み込むのは .py ファイルを解析して翻訳するのよりも速いことなので、
+予めコンパイルされた .pyc ファイルがあると Python スクリプトの起動時間が
+改善します。必要なら、 Lib/compileall.py モジュールで、
+与えられたモジュール群の適切な .pyc ファイルを生成できます。
+
+なお、Python によって実行されるメインスクリプトは、たとえそのファイル名が
+.py で終わっていても、.pyc ファイルにコンパイルされません。
+バイトコードには変換されますが、そのバイトコードはファイルに保存されませ 
ん。
+たいていメインスクリプトはとても短いので、
+これでも大きく速度を落とすことにはなりません。

  .. XXX check which of these projects are still alive

-There are also several programs which make it easier to intermingle Python  
and C
-code in various ways to increase performance.  See, for example, `Psyco
-<http://psyco.sourceforge.net/>`_, `Pyrex
-<http://www.cosc.canterbury.ac.nz/~greg/python/Pyrex/>`_, `PyInline
-<http://pyinline.sourceforge.net/>`_, `Py2Cmod
-<http://sourceforge.net/projects/py2cmod/>`_, and `Weave
-<http://www.scipy.org/Weave>`_.
+Python と C のコードを様々な方法で混合して簡単にパフォーマンスを
+向上させるプログラムがいくつかあります。例えば
+`Psyco <http://psyco.sourceforge.net/>`_\ 、
+`Pyrex <http://www.cosc.canterbury.ac.nz/~greg/python/Pyrex/>`_\ 、
+`PyInline <http://pyinline.sourceforge.net/>`_\ 、
+`Py2Cmod <http://sourceforge.net/projects/py2cmod/>`_\ 、
+`Weave <http://www.scipy.org/Weave>`_
+を参照してください。


-How does Python manage memory?
-------------------------------
-
-The details of Python memory management depend on the implementation.  The
-standard C implementation of Python uses reference counting to detect
-inaccessible objects, and another mechanism to collect reference cycles,
-periodically executing a cycle detection algorithm which looks for  
inaccessible
-cycles and deletes the objects involved. The :mod:`gc` module provides  
functions
-to perform a garbage collection, obtain debugging statistics, and tune the
-collector's parameters.
-
-Jython relies on the Java runtime so the JVM's garbage collector is used.   
This
-difference can cause some subtle porting problems if your Python code  
depends on
-the behavior of the reference counting implementation.
-
-.. XXX relevant for Python 2.6?
-
-Sometimes objects get stuck in tracebacks temporarily and hence are not
-deallocated when you might expect.  Clear the tracebacks with::
-
-   import sys
-   sys.exc_clear()
-   sys.exc_traceback = sys.last_traceback = None
-
-Tracebacks are used for reporting errors, implementing debuggers and  
related
-things.  They contain a portion of the program state extracted during the
-handling of an exception (usually the most recent exception).
-
-In the absence of circularities and tracebacks, Python programs do not  
need to
-manage memory explicitly.
-
-Why doesn't Python use a more traditional garbage collection scheme?  For  
one
-thing, this is not a C standard feature and hence it's not portable.   
(Yes, we
-know about the Boehm GC library.  It has bits of assembler code for *most*
-common platforms, not for all of them, and although it is mostly  
transparent, it
-isn't completely transparent; patches are required to get Python to work  
with
-it.)
-
-Traditional GC also becomes a problem when Python is embedded into other
-applications.  While in a standalone Python it's fine to replace the  
standard
-malloc() and free() with versions provided by the GC library, an  
application
-embedding Python may want to have its *own* substitute for malloc() and  
free(),
-and may not want Python's.  Right now, Python works with anything that
-implements malloc() and free() properly.
-
-In Jython, the following code (which is fine in CPython) will probably run  
out
-of file descriptors long before it runs out of memory::
+Python はメモリをどのように管理するのですか?
+---------------------------------------------
+
+Python のメモリ管理の詳細は実装に依ります。Python の標準の C 実装は
+参照カウントを使って、アクセスできないオブジェクトを探します。
+また別のメカニズムも使って参照サイクルを集めます。これは
+サイクル検出アルゴリズムを定期的に実行し、アクセスできないサイクルを探し、
+それに含まれるオブジェクトを削除します。\ :mod:`gc` モジュールの
+関数で、ガベージコレクションを実行し、デバッグ統計を取得し、
+コレクタのパラメタを変更できます。
+
+Jython は Java ランタイムに頼るので、JVM のガベージコレクタが使われます。
+Python のコードが参照カウントの実装の振る舞いに依るとき、
+この違いが微妙な移植問題を起こすことがあります。
+
+.. XXX relevant for Python 3?
+
+   Sometimes objects get stuck in tracebacks temporarily and hence are not
+   deallocated when you might expect.  Clear the tracebacks with::
+
+      import sys
+      sys.exc_clear()
+      sys.exc_traceback = sys.last_traceback = None
+
+   Tracebacks are used for reporting errors, implementing debuggers and  
related
+   things.  They contain a portion of the program state extracted during  
the
+   handling of an exception (usually the most recent exception).
+
+循環性がなければ、Python プログラムはメモリを明示的に
+管理する必要はありません。
+
+なぜ Python は伝統的なガベージコレクション体系を使わないのでしょうか?
+まず、それは C の標準的な機能ではないのでポータブルではありません。
+(Boehm GC を例に取りましょう。これには *most* 有名なプラットフォームのため 
の
+アセンブリコードが含まれますが、全てには対応していませんし、
+ほとんど transparent ですが、完全に transparent ではありません。
+Python を対応させるにはパッチが必要です。)
+
+伝統的な GC は Python が他のアプリケーションに実装されるときにも
+問題となります。スタンドアロンの Python で動く限りでは、
+標準の malloc() と free() を GC ライブラリから提供されるものに置き換えても
+問題ありませんが、Python を実装したアプリケーションは Python の
+ものではない *独自の* 代替品を使おうとするかもしれません。
+現在のようにすることで、Python は malloc() と free() が
+適切に実装されている限りどんなものにも対応させられます。
+
+Jython では、以下の (CPython では通る) コードはおそらく、
+メモリを使い切るより遥かに前にファイルディスクリプタを使い果たすでしょう::

     for file in very_long_list_of_files:
         f = open(file)
         c = f.read(1)

-Using the current reference counting and destructor scheme, each new  
assignment
-to f closes the previous file.  Using GC, this is not guaranteed.  If you  
want
-to write code that will work with any Python implementation, you should
-explicitly close the file or use the :keyword:`with` statement; this will  
work
-regardless of GC::
+現在の参照カウントとデストラクタのスキームを使えば、
+f への新しい代入ごとに前のファイルは閉じられます。GC を使うのでは、
+これは保証されません。どんな Python の実装にも適用できるコードを書くには、
+明示的にファイルを閉じるか、\ :keyword:`with` 文を使いましょう。これは GC  
に
+関係なく働きます::

     for file in very_long_list_of_files:
         with open(file) as f:
             c = f.read(1)


-Why isn't all memory freed when Python exits?
----------------------------------------------
-
-Objects referenced from the global namespaces of Python modules are not  
always
-deallocated when Python exits.  This may happen if there are circular
-references.  There are also certain bits of memory that are allocated by  
the C
-library that are impossible to free (e.g. a tool like Purify will complain  
about
-these).  Python is, however, aggressive about cleaning up memory on exit  
and
-does try to destroy every single object.
-
-If you want to force Python to delete certain things on deallocation use  
the
-:mod:`atexit` module to run a function that will force those deletions.
+なぜ Python の終了時にすべてのメモリが開放されるわけではないのですか?
+----------------------------------------------------------------------
+
+Python モジュールのグローバルな名前空間から参照されるオブジェクトは、
+Python の終了時にメモリの割り当てを解除されるとは限りません。
+これは、循環参照があるときに起こりえます。開放できない C ライブラリ
+(例えば、Purify のようなツールなどが当てはまります) によって
+割り当てられたいくらかのメモリも含まれます。しかし、Python は終了時に
+メモリをクリーンアップすることには積極的で、
+全ての各個オブジェクトを破棄しようとします。
+
+再割り当て時に Python が特定のものを削除するように強制したいときは、
+:mod:`atexit` モジュールを使って削除を強制する関数を実行してください。


-Why are there separate tuple and list data types?
--------------------------------------------------
-
-Lists and tuples, while similar in many respects, are generally used in
-fundamentally different ways.  Tuples can be thought of as being similar to
-Pascal records or C structs; they're small collections of related data  
which may
-be of different types which are operated on as a group.  For example, a
-Cartesian coordinate is appropriately represented as a tuple of two or  
three
-numbers.
-
-Lists, on the other hand, are more like arrays in other languages.  They  
tend to
-hold a varying number of objects all of which have the same type and which  
are
-operated on one-by-one.  For example, ``os.listdir('.')`` returns a list of
-strings representing the files in the current directory.  Functions which
-operate on this output would generally not break if you added another file  
or
-two to the directory.
-
-Tuples are immutable, meaning that once a tuple has been created, you can't
-replace any of its elements with a new value.  Lists are mutable, meaning  
that
-you can always change a list's elements.  Only immutable elements can be  
used as
-dictionary keys, and hence only tuples and not lists can be used as keys.
+なぜタプルとリストという別のデータ型が用意されているのですか?
+--------------------------------------------------------------
+
+リストとタプルは、多くの点で似ていますが、一般には本質的に異なる方法で
+使われます。タプルは、Pascal のレコードや C の構造体と同様なものと
+考えられます。型が異なっても良い関連するデータの小さな集合で、
+グループとして演算されます。例えば、デカルト座標は 2 つや 3 つの数の
+タプルとして適切に表せます。
+
+一方、リストは、もっと他の言語の配列に近いものです。全て同じ型の
+可変数のオブジェクトを持ち、それらが一つ一つ演算される傾向にあります。
+例えば、\ ``os.listdir('.')`` はカレントディレクトリ内にある
+ファイルの文字列表現のリストを返します。この出力を演算する関数は一般に、
+ディレクトリに一つや二つの別のファイルを加えても壊れません。
+
+タプルはイミュータブルなので、一度タプルが生成されたら、
+そのどの要素も新しい値に置き換えられません。リストはミュータブルなので、
+リストの要素はいつでも変更できます。イミュータブルな要素だけが
+辞書のキーとして使えるので、リストではなくタプルだけがキーとして使えます。


-How are lists implemented?
---------------------------
-
-Python's lists are really variable-length arrays, not Lisp-style linked  
lists.
-The implementation uses a contiguous array of references to other objects,  
and
-keeps a pointer to this array and the array's length in a list head  
structure.
-
-This makes indexing a list ``a[i]`` an operation whose cost is independent  
of
-the size of the list or the value of the index.
-
-When items are appended or inserted, the array of references is resized.   
Some
-cleverness is applied to improve the performance of appending items  
repeatedly;
-when the array must be grown, some extra space is allocated so the next few
-times don't require an actual resize.
+リストはどのように実装されているのですか?
+------------------------------------------
+
+Python のリストは真の可変長配列であり、Lisp スタイルの連結リストでは
+ありません。この実装は、他のオブジェクトへの参照の連続した配列を使い、
+リストの頭部構造にこの配列へのポインタと配列の長さを保持します。
+
+これにより、リストのインデクシング ``a[i]`` は、リストの大きさやインデクス 
の値に依存しないコストで演算できます。
+
+要素が追加または挿入されるとき、この参照の配列は大きさが変更されます。
+要素追加の繰り返しのパフォーマンスを上げるために、少し工夫されています。
+配列が大きくなるとき、次の何回かは実際に大きさを変更する必要がないように、
+いくらかの追加の領域が割り当てられます。


-How are dictionaries implemented?
----------------------------------
-
-Python's dictionaries are implemented as resizable hash tables.  Compared  
to
-B-trees, this gives better performance for lookup (the most common  
operation by
-far) under most circumstances, and the implementation is simpler.
-
-Dictionaries work by computing a hash code for each key stored in the  
dictionary
-using the :func:`hash` built-in function.  The hash code varies widely  
depending
-on the key; for example, "Python" hashes to -539294296 while "python", a  
string
-that differs by a single bit, hashes to 1142331976.  The hash code is then  
used
-to calculate a location in an internal array where the value will be  
stored.
-Assuming that you're storing keys that all have different hash values, this
-means that dictionaries take constant time -- O(1), in computer science  
notation
--- to retrieve a key.  It also means that no sorted order of the keys is
-maintained, and traversing the array as the ``.keys()`` and ``.items()``  
do will
-output the dictionary's content in some arbitrary jumbled order.
+辞書はどのように実装されているのですか?
+----------------------------------------
+
+Python の辞書は大きさを変更できるハッシュテーブルとして実装されています。
+B 木にコンパイルされることで、ほとんどの条件下で (特に一般的な演算である)
+探索のパフォーマンスが良くなりますし、実装も単純です。
+
+辞書は、 :func:`hash` ビルトイン関数で、辞書に保存されているそれぞれの
+キーに対応するハッシュコードを計算して働きます。このハッシュコードはキーに
+大きく依存します。例えば、"Python" のハッシュ値は -539294296 ですが、
+ビットが一つ違うだけの文字列 "python" のハッシュ値は 1142331976 です。
+そしてこのハッシュコードは、内部配列での値が保存される位置を
+計算するために使われます。保存しているキーのハッシュ値が異なるとすれば、
+一定の時間 - コンピュータサイエンスの記法で言えば O(1) - でキーを
+検索できることになります。また、キーのいかなる並び順も
+保たれていないことにもなり、配列を ``.keys()`` や ``.items()`` として
+横断すると、辞書の内容が任意の混乱した順序で出力されます。


-Why must dictionary keys be immutable?
---------------------------------------
-
-The hash table implementation of dictionaries uses a hash value calculated  
from
-the key value to find the key.  If the key were a mutable object, its value
-could change, and thus its hash could also change.  But since whoever  
changes
-the key object can't tell that it was being used as a dictionary key, it  
can't
-move the entry around in the dictionary.  Then, when you try to look up  
the same
-object in the dictionary it won't be found because its hash value is  
different.
-If you tried to look up the old value it wouldn't be found either, because  
the
-value of the object found in that hash bin would be different.
-
-If you want a dictionary indexed with a list, simply convert the list to a  
tuple
-first; the function ``tuple(L)`` creates a tuple with the same entries as  
the
-list ``L``.  Tuples are immutable and can therefore be used as dictionary  
keys.
-
-Some unacceptable solutions that have been proposed:
-
-- Hash lists by their address (object ID).  This doesn't work because if  
you
-  construct a new list with the same value it won't be found; e.g.::
+なぜ辞書のキーはイミュータブルでなくてはならないのですか?
+----------------------------------------------------------
+
+辞書のハッシュテーブルの実装は、キーを見つけるために、
+キーから計算されたハッシュ値を使っています。もしキーがミュータブルな
+オブジェクトだったら、その値は変えられ、それによりハッシュ値も
***The diff for this file has been truncated for email.***
=======================================
--- /faq/extending.rst	Sat Mar 19 08:59:41 2011
+++ /faq/extending.rst	Sun Nov  6 08:09:46 2011
@@ -1,131 +1,132 @@
-=======================
-Extending/Embedding FAQ
-=======================
+==================
+拡張と埋め込み FAQ
+==================

  .. contents::

  .. highlight:: c


-Can I create my own functions in C?
------------------------------------
-
-Yes, you can create built-in modules containing functions, variables,  
exceptions
-and even new types in C.  This is explained in the document
-:ref:`extending-index`.
-
-Most intermediate or advanced Python books will also cover this topic.
+C で独自の関数を作ることはできますか?
+--------------------------------------
+
+はい。関数、変数、例外、そして新しいタイプまで含んだビルトインモジュールを
+C で作れます。これはドキュメント :ref:`extending-index` で説明されていま 
す。
+
+ほとんどの中級から上級の Python 本もこの話題を扱っています。


-Can I create my own functions in C++?
--------------------------------------
-
-Yes, using the C compatibility features found in C++.  Place ``extern "C" {
-... }`` around the Python include files and put ``extern "C"`` before each
-function that is going to be called by the Python interpreter.  Global or  
static
-C++ objects with constructors are probably not a good idea.
+C++ で独自の関数を作ることはできますか?
+----------------------------------------
+
+はい。C++ 内にある C 互換機能を使ってできます。\ ``extern "C" { ... }`` で
+Python のインクルードファイルを囲み、\ ``extern "C"`` を
+Python インタプリタから呼ぶ各関数の前に置いてください。
+グローバルや静的な C++ オブジェクトの構造体を持つものは良くないでしょう。


  .. _c-wrapper-software:

-Writing C is hard; are there any alternatives?
+C を書くのは大変です。他の方法はありませんか?
  ----------------------------------------------

-There are a number of alternatives to writing your own C extensions,  
depending
-on what you're trying to do.
+独自の C 拡張を書くための別のやり方は、目的によっていくつかあります。

  .. XXX make sure these all work; mention Cython

-If you need more speed, `Psyco <http://psyco.sourceforge.net/>`_ generates  
x86
-assembly code from Python bytecode.  You can use Psyco to compile the most
-time-critical functions in your code, and gain a significant improvement  
with
-very little effort, as long as you're running on a machine with an
-x86-compatible processor.
-
-`Pyrex <http://www.cosc.canterbury.ac.nz/~greg/python/Pyrex/>`_ is a  
compiler
-that accepts a slightly modified form of Python and generates the  
corresponding
-C code.  Pyrex makes it possible to write an extension without having to  
learn
-Python's C API.
-
-If you need to interface to some C or C++ library for which no Python  
extension
-currently exists, you can try wrapping the library's data types and  
functions
-with a tool such as `SWIG <http://www.swig.org>`_.  `SIP
-<http://www.riverbankcomputing.co.uk/software/sip/>`__, `CXX
-<http://cxx.sourceforge.net/>`_ `Boost
-<http://www.boost.org/libs/python/doc/index.html>`_, or `Weave
-<http://www.scipy.org/Weave>`_ are also alternatives for wrapping
-C++ libraries.
+速度が必要なら、\ `Psyco <http://psyco.sourceforge.net/>`_ は
+Python バイトコードから x86 アセンブリコードを生成します。
+Psyco でコードの最も時間制約が厳しい関数群をコンパイルすれば、
+x-86 互換のプロセッサ上で動かす限り、わずかな手間で著しい改善ができます。
+
+`Pyrex <http://www.cosc.canterbury.ac.nz/~greg/python/Pyrex/>`_ は、
+わずかに変形した Python を受け取り、対応する C コードを生成します。
+Cython や Pyrex を使えば Python の C API を習得することなく拡張を書けます。
+
+今のところ Python 拡張が存在しないような C や C++ ライブラリへの
+インタフェースが必要なら、\ `SWIG <http://www.swig.org>`_ のようなツール 
で、
+そのライブラリのデータ型のラッピングを図れます。
+`SIP <http://www.riverbankcomputing.co.uk/software/sip/>`_\ 、
+`CXX <http://cxx.sourceforge.net/>`_\ 、
+`Boost <http://www.boost.org/libs/python/doc/index.html>`_\ 、
+`Weave <http://www.scipy.org/Weave>`_
+でも C++ ライブラリをラッピングできます。


-How can I execute arbitrary Python statements from C?
------------------------------------------------------
-
-The highest-level function to do this is :cfunc:`PyRun_SimpleString` which  
takes
-a single string argument to be executed in the context of the module
-``__main__`` and returns 0 for success and -1 when an exception occurred
-(including ``SyntaxError``).  If you want more control, use
-:cfunc:`PyRun_String`; see the source for :cfunc:`PyRun_SimpleString` in
-``Python/pythonrun.c``.
+C から任意の Python 文を実行するにはどうしますか?
+--------------------------------------------------
+
+これを行う最高水準の関数は :c:func:`PyRun_SimpleString` で、
+一つの文字列引数を取り、モジュール ``__main__`` のコンテキストでそれを実行 
し、
+成功なら 0、例外 (``SyntaxError`` を含む) が発生したら -1 を返します。
+更に制御したければ、\ :c:func:`PyRun_String`  を使ってください。
+ソースは ``Python/pythonrun.c`` の ':c:func:`PyRun_SimpleString` を
+参照してください。


-How can I evaluate an arbitrary Python expression from C?
----------------------------------------------------------
-
-Call the function :cfunc:`PyRun_String` from the previous question with the
-start symbol :cdata:`Py_eval_input`; it parses an expression, evaluates it  
and
-returns its value.
+C から任意の Python 式を評価するにはどうしますか?
+--------------------------------------------------
+
+先の質問の :c:func:`PyRun_String` を、スタートシンボル
+:c:data:`Py_eval_input` を渡して呼び出してください。これは式を解析し、
+評価してその値を返します。


-How do I extract C values from a Python object?
------------------------------------------------
-
-That depends on the object's type.  If it's a tuple, :cfunc:`PyTuple_Size`
-returns its length and :cfunc:`PyTuple_GetItem` returns the item at a  
specified
-index.  Lists have similar functions, :cfunc:`PyListSize` and
-:cfunc:`PyList_GetItem`.
-
-For strings, :cfunc:`PyString_Size` returns its length and
-:cfunc:`PyString_AsString` a pointer to its value.  Note that Python  
strings may
-contain null bytes so C's :cfunc:`strlen` should not be used.
-
-To test the type of an object, first make sure it isn't *NULL*, and then  
use
-:cfunc:`PyString_Check`, :cfunc:`PyTuple_Check`, :cfunc:`PyList_Check`,  
etc.
-
-There is also a high-level API to Python objects which is provided by the
-so-called 'abstract' interface -- read ``Include/abstract.h`` for further
-details.  It allows interfacing with any kind of Python sequence using  
calls
-like :cfunc:`PySequence_Length`, :cfunc:`PySequence_GetItem`, etc.)  as  
well as
-many other useful protocols.
+Python オブジェクトから C の値を展開するにはどうしますか?
+----------------------------------------------------------
+
+オブジェクトの型に依ります。タプルなら、\ :c:func:`PyTuple_Size` が長さを返 
し、
+:c:func:`PyTuple_GetItem` が指定されたインデックスの要素を返します。
+リストにも同様の関数 :c:func:`PyList_Size` と :c:func:`PyList_GetItem` があ 
ります。
+
+文字列なら、\ :c:func:`PyString_Size` が長さを、
+:c:func:`PyString_AsString` がその値への
+ポインタを返します。なお、Python の文字列には null バイトが含まれている
+可能性があるので、C の :c:func:`strlen` は使うべきではありません。
+
+オブジェクトの型を確かめるには、まず *NULL*  ではないことを確かめてから、
+:c:func:`PyString_Check`\ 、\ :c:func:`PyTuple_Check`\ 、 
\ :c:func:`PyList_Check` などを
+使ってください。
+
+Python オブジェクトへの高レベルな API には、
+いわゆる 'abstract' インタフェースが提供するものもあります。
+機能の詳細は ``Include/abstract.h`` を読んでください。これで、
+:c:func:`PySequence_Length` や :c:func:`PySequence_GetItem` などの
+呼び出しであらゆるタイプの Python シーケンスのインタフェースができますし、
+その他多くの役立つプロトコルもできます。


-How do I use Py_BuildValue() to create a tuple of arbitrary length?
--------------------------------------------------------------------
-
-You can't.  Use ``t = PyTuple_New(n)`` instead, and fill it with objects  
using
-``PyTuple_SetItem(t, i, o)`` -- note that this "eats" a reference count of
-``o``, so you have to :cfunc:`Py_INCREF` it.  Lists have similar functions
-``PyList_New(n)`` and ``PyList_SetItem(l, i, o)``.  Note that you *must*  
set all
-the tuple items to some value before you pass the tuple to Python code --
-``PyTuple_New(n)`` initializes them to NULL, which isn't a valid Python  
value.
+Py_BuildValue() で任意長のタプルを作るにはどうしますか?
+--------------------------------------------------------
+
+できません。代わりに ``t = PyTuple_New(n)`` を使い、
+``PyTuple_SetItem(t, i, o)`` でオブジェクトを埋めてください --
+なお、これは ``o`` のリファレンスカウントを"食う"ので、
+:c:func:`Py_INCREF` しなければなりません。リストにも同様の
+関数 ``PyList_New(n)`` と ``PyList_SetItem(l, i, o)`` があります。
+なお、タプルは Python コードに渡される前に *必ず* すべての値が
+設定されていなければなリません -- ``PyTuple_New(n)`` は各要素を
+初期化して NULL にしますが、これは Python の適切な値ではありません。


-How do I call an object's method from C?
-----------------------------------------
-
-The :cfunc:`PyObject_CallMethod` function can be used to call an arbitrary
-method of an object.  The parameters are the object, the name of the  
method to
-call, a format string like that used with :cfunc:`Py_BuildValue`, and the
-argument values::
+C からオブジェクトのメソッドを呼び出すにはどうしますか?
+--------------------------------------------------------
+
+:c:func:`PyObject_CallMethod` 関数でオブジェクトの任意のメソッドを呼び出せ 
ます。
+パラメタは、オブジェクト、呼び出すメソッドの名前、
+:c:func:`Py_BuildValue` で
+使われるようなフォーマット文字列、そして引数です::

     PyObject *
     PyObject_CallMethod(PyObject *object, char *method_name,
                         char *arg_format, ...);

-This works for any object that has methods -- whether built-in or  
user-defined.
-You are responsible for eventually :cfunc:`Py_DECREF`\ 'ing the return  
value.
-
-To call, e.g., a file object's "seek" method with arguments 10, 0  
(assuming the
-file object pointer is "f")::
+これはメソッドを持ついかなるオブジェクトにも有効で、組み込みかユーザ定義か 
は
+関係ありません。返り値に対して :c:func:`Py_DECREF` する必要が
+あることもあります。
+
+例えば、あるファイルオブジェクトの "seek" メソッドを
+10, 0 を引数として呼ぶとき (ファイルオブジェクトのポインタを "f" とします 
)::

     res = PyObject_CallMethod(f, "seek", "(ii)", 10, 0);
     if (res == NULL) {
@@ -135,23 +136,23 @@
             Py_DECREF(res);
     }

-Note that since :cfunc:`PyObject_CallObject` *always* wants a tuple for the
-argument list, to call a function without arguments, pass "()" for the  
format,
-and to call a function with one argument, surround the argument in  
parentheses,
-e.g. "(i)".
+なお、\ :c:func:`PyObject_CallObject` の引数リストには *常に* タプルが必要 
です。
+関数を引数なしで呼び出すには、フォーマットに "()" を渡し、
+関数を一つの引数で呼び出すには、関数を括弧でくくって例えば
+"(i)" としてください。


-How do I catch the output from PyErr_Print() (or anything that prints to  
stdout/stderr)?
-----------------------------------------------------------------------------------------
-
-In Python code, define an object that supports the ``write()`` method.   
Assign
-this object to :data:`sys.stdout` and :data:`sys.stderr`.  Call  
print_error, or
-just allow the standard traceback mechanism to work. Then, the output will  
go
-wherever your ``write()`` method sends it.
-
-The easiest way to do this is to use the StringIO class in the standard  
library.
-
-Sample code and use for catching stdout:
+PyErr_Print() (その他 stdout/stderr に印字するもの) からの出力を受け取るに 
はどうしますか?
+----------------------------------------------------------------------------------------------
+
+Python コード内で、\ ``write()`` メソッドをサポートするオブジェクトを
+定義してください。そのオブジェクトを :data:`sys.stdout`  
と :data:`sys.stderr`
+に代入してください。print_error を呼び出すか、単に標準のトレースバック機構 
を
+作動させてください。そうすれば、出力は ``write()`` が送る任意の所に行きま 
す。
+
+最も簡単な方法は、標準ライブラリの StringIO クラスを使うことです。
+
+サンプルコードと出力の受け取り例:

     >>> class StdoutCatcher:
     ...     def __init__(self):
@@ -168,59 +169,60 @@
     hello world!


-How do I access a module written in Python from C?
---------------------------------------------------
-
-You can get a pointer to the module object as follows::
+C から Python で書かれたモジュールにアクセスするにはどうしますか?
+------------------------------------------------------------------
+
+以下のようにモジュールオブジェクトへのポインタを得られます::

     module = PyImport_ImportModule("<modulename>");

-If the module hasn't been imported yet (i.e. it is not yet present in
-:data:`sys.modules`), this initializes the module; otherwise it simply  
returns
-the value of ``sys.modules["<modulename>"]``.  Note that it doesn't enter  
the
-module into any namespace -- it only ensures it has been initialized and is
-stored in :data:`sys.modules`.
-
-You can then access the module's attributes (i.e. any name defined in the
-module) as follows::
+そのモジュールがまだインポートされていない (つまり、まだ
+:data:`sys.modules` に現れていない) なら、これはモジュールを初期化します。
+そうでなければ、単純に ``sys.modules["<modulename>"]``  の値を返します。
+なお、これはモジュールをいかなる名前空間にも代入しません。
+これはモジュールが初期化されて ':data:`sys.modules` に保管されていることを
+保証するだけです。
+
+これで、モジュールの属性 (つまり、モジュールで定義された任意の名前) に
+以下のようにアクセスできるようになります::

     attr = PyObject_GetAttrString(module, "<attrname>");

-Calling :cfunc:`PyObject_SetAttrString` to assign to variables in the  
module
-also works.
+:c:func:`PyObject_SetAttrString` を呼んでモジュールの変数に
+代入することもできます。


-How do I interface to C++ objects from Python?
-----------------------------------------------
-
-Depending on your requirements, there are many approaches.  To do this  
manually,
-begin by reading :ref:`the "Extending and Embedding" document
-<extending-index>`.  Realize that for the Python run-time system, there  
isn't a
-whole lot of difference between C and C++ -- so the strategy of building a  
new
-Python type around a C structure (pointer) type will also work for C++  
objects.
-
-For C++ libraries, see :ref:`c-wrapper-software`.
+Python から C++ へインタフェースするにはどうしますか?
+------------------------------------------------------
+
+やりたいことに応じて、いろいろな方法があります。手動でやるなら、
+:ref:`"拡張と埋め込み" ドキュメント <extending-index>` を
+読むことから始めてください。なお、Python ランタイムシステムにとっては、
+C と C++ はあまり変わりません。だから、C 構造体 (ポインタ )型に基づいて
+新しい Python の型を構築する方針は C++ オブジェクトに対しても有効です。
+
+C++ ライブラリに関しては、\ :ref:`c-wrapper-software` を参照してください。


-I added a module using the Setup file and the make fails; why?
---------------------------------------------------------------
-
-Setup must end in a newline, if there is no newline there, the build  
process
-fails.  (Fixing this requires some ugly shell script hackery, and this bug  
is so
-minor that it doesn't seem worth the effort.)
+セットアップファイルでモジュールを追加しようとしたらメイクに失敗しました。 
なぜですか?
+--------------------------------------------------------------------------------------
+
+セットアップは改行で終わらなければならなくて、改行がないと、
+ビルド工程は失敗します。(これを直すには、ある種の醜いシェルスクリプトハック 
が
+必要ですが、このバグは小さいものですから努力に見合う価値はないでしょう。)


-How do I debug an extension?
-----------------------------
-
-When using GDB with dynamically loaded extensions, you can't set a  
breakpoint in
-your extension until your extension is loaded.
-
-In your ``.gdbinit`` file (or interactively), add the command::
+拡張をデバッグするにはどうしますか?
+------------------------------------
+
+動的にロードされた拡張に GDB を使うとき、拡張がロードされるまで
+ブレークポイントを設定してはいけません。
+
+``.gdbinit`` ファイルに(または対話的に)、このコマンドを加えてください::

     br _PyImport_LoadDynamicModule

-Then, when you run GDB::
+そして、GDB を起動するときに::

     $ gdb /local/bin/python
     gdb) run myscript.py
@@ -229,56 +231,57 @@
     gdb) br myfunction.c:50
     gdb) continue

-I want to compile a Python module on my Linux system, but some files are  
missing. Why?
---------------------------------------------------------------------------------------
-
-Most packaged versions of Python don't include the
-:file:`/usr/lib/python2.{x}/config/` directory, which contains various  
files
-required for compiling Python extensions.
-
-For Red Hat, install the python-devel RPM to get the necessary files.
-
-For Debian, run ``apt-get install python-dev``.
+Linux システムで Python モジュールをコンパイルしたいのですが、見つからない 
ファイルがあります。なぜですか?
+----------------------------------------------------------------------------------------------------------
+
+Python の多くのパッケージバージョンには、Python 拡張をコンパイルするのに必 
要な
+様々なファイルを含む :file:`/usr/lib/python2.{x}/config/` ディレクトリが
+含まれていません。
+
+Red Hat では、Python RPM をインストールして必要なファイルを得てください。
+
+Debian では、\ ``apt-get install python-dev`` を実行してください。


-What does "SystemError: _PyImport_FixupExtension: module yourmodule not  
loaded" mean?
--------------------------------------------------------------------------------------
-
-This means that you have created an extension module named "yourmodule",  
but
-your module init function does not initialize with that name.
-
-Every module init function will have a line similar to::
+"SystemError: _PyImport_FixupExtension: module yourmodule not loaded" とは 
どういう意味ですか?
+----------------------------------------------------------------------------------------------
+
+これは、"yourmodule" という名前の拡張モジュールが生成されたけれど、
+モジュールの init 関数がその名前で初期化しないという意味です。
+
+全てのモジュールの init 関数には次のような行があるでしょう::

     module = Py_InitModule("yourmodule", yourmodule_functions);

-If the string passed to this function is not the same name as your  
extension
-module, the :exc:`SystemError` exception will be raised.
+この関数に渡された文字列が拡張モジュールと同じ名前でない場合、
+:exc:`SystemError` 例外が発生します。


-How do I tell "incomplete input" from "invalid input"?
-------------------------------------------------------
-
-Sometimes you want to emulate the Python interactive interpreter's  
behavior,
-where it gives you a continuation prompt when the input is incomplete  
(e.g. you
-typed the start of an "if" statement or you didn't close your parentheses  
or
-triple string quotes), but it gives you a syntax error message immediately  
when
-the input is invalid.
-
-In Python you can use the :mod:`codeop` module, which approximates the  
parser's
-behavior sufficiently.  IDLE uses this, for example.
-
-The easiest way to do it in C is to call :cfunc:`PyRun_InteractiveLoop`  
(perhaps
-in a separate thread) and let the Python interpreter handle the input for
-you. You can also set the :cfunc:`PyOS_ReadlineFunctionPointer` to point  
at your
-custom input function. See ``Modules/readline.c`` and  
``Parser/myreadline.c``
-for more hints.
-
-However sometimes you have to run the embedded Python interpreter in the  
same
-thread as your rest application and you can't allow the
-:cfunc:`PyRun_InteractiveLoop` to stop while waiting for user input.  The  
one
-solution then is to call :cfunc:`PyParser_ParseString` and test for  
``e.error``
-equal to ``E_EOF``, which means the input is incomplete).  Here's a sample  
code
-fragment, untested, inspired by code from Alex Farber::
+"不完全 (incomplete) な入力" と "不適切 (invalid) な入力" を区別するにはど 
うしますか?
+--------------------------------------------------------------------------------------
+
+Python インタラクティブインタプリタでは、入力が不完全なとき (例えば、
+"if" 文の始まりをタイプした時や、カッコや三重文字列引用符を閉じていない時な 
ど)
+には継続プロンプトを与えられますが、入力が不適切であるときには
+即座に構文エラーメッセージが与えられます。このようなふるまいを
+模倣したいことがあります。
+
+Python では構文解析器のふるまいに十分に近い :mod:`codeop` モジュールが
+使えます。例えば IDLE がこれを使っています。
+
+これを C で行う最も簡単な方法は、\ :c:func:`PyRun_InteractiveLoop` を
+(必要ならば別のスレッドで) 呼び出し、Python インタプリタにあなたの
+入力を扱わせることです。独自の入力関数を指定するのに
+:c:func:`PyOS_ReadlineFunctionPointer` を設定することもできます。
+詳しいヒントは、\ ``Modules/readline.c`` や ``Parser/myreadline.c`` を
+参照してください。
+
+しかし、組み込みの Python インタプリタを他のアプリケーションと
+同じスレッドで実行することが必要で、\ :c:func:`PyRun_InteractiveLoop` で
+ユーザの入力を待っている間止められないこともあります。
+このような場合の解決策の一つは、\ :c:func:`PyParser_ParseString` を呼んで
+``e.error`` と ``E_EOF`` が等しいこと、つまり入力が不完全であることを
+確かめることです。これは、Alex Farber のコードを参考にした、コード片の例で 
す::

     #include <Python.h>
     #include <node.h>
@@ -306,14 +309,16 @@
       return 1;
     }

-Another solution is trying to compile the received string with
-:cfunc:`Py_CompileString`. If it compiles without errors, try to execute  
the
-returned code object by calling :cfunc:`PyEval_EvalCode`. Otherwise save  
the
-input for later. If the compilation fails, find out if it's an error or  
just
-more input is required - by extracting the message string from the  
exception
-tuple and comparing it to the string "unexpected EOF while parsing".  Here  
is a
-complete example using the GNU readline library (you may want to ignore
-**SIGINT** while calling readline())::
+別の解決策は、受け取られた文字列を :c:func:`Py_CompileString` で
+コンパイルすることを試みることです。エラー無くコンパイルされたら、
+返されたコードオブジェクトを :c:func:`PyEval_EvalCode` を呼んで
+実行することを試みてください。そうでなければ、
+入力を後のために保存してください。コンパイルが失敗したなら、
+それがエラーなのか入力の続きが求められているだけなのか調べてください。
+そのためには、例外タプルからメッセージ文字列を展開し、それを文字列
+"unexpected EOF while parsing" と比較します。ここに GNU readline library を
+使った完全な例があります (readline() を読んでいる間は **SIGINT** を
+無視したいかもしれません)::

     #include <stdio.h>
     #include <readline.h>
@@ -426,45 +431,46 @@
     }


-How do I find undefined g++ symbols __builtin_new or __pure_virtual?
---------------------------------------------------------------------
-
-To dynamically load g++ extension modules, you must recompile Python,  
relink it
-using g++ (change LINKCC in the Python Modules Makefile), and link your
-extension module using g++ (e.g., ``g++ -shared -o mymodule.so  
mymodule.o``).
+未定義の g++ シンボル __builtin_new や __pure_virtual を見つけるにはどうし 
ますか?
+----------------------------------------------------------------------------------
+
+g++ モジュールを動的にロードするには、Python を再コンパイルし、
+それを g++ で再リンク (Python Modules Makefile 内の LINKCC を変更) し、
+拡張を g++ でリンク (例えば ``g++ -shared -o mymodule.so mymodule.o``)
+しなければなりません。


-Can I create an object class with some methods implemented in C and others  
in Python (e.g. through inheritance)?
-----------------------------------------------------------------------------------------------------------------
-
-In Python 2.2, you can inherit from built-in classes such as :class:`int`,
-:class:`list`, :class:`dict`, etc.
+メソッドのいくつかは C で、その他は Python で実装されたオブジェクトクラス 
を (継承などで) 作ることはできますか?
+---------------------------------------------------------------------------------------------------------------
+
+Python 2.2 では、\ :class:`int`\ 、\ :class:`list`\ 、\ :class:`dict` など 
の
+ビルトインクラスから継承できます。

  The Boost Python Library (BPL,  
http://www.boost.org/libs/python/doc/index.html)
-provides a way of doing this from C++ (i.e. you can inherit from an  
extension
-class written in C++ using the BPL).
+を使えば、これを C++ からできます。
+(すなわち、BPL を使って C++ で書かれた拡張クラスを継承できます).


-When importing module X, why do I get "undefined symbol: PyUnicodeUCS2*"?
--------------------------------------------------------------------------
-
-You are using a version of Python that uses a 4-byte representation for  
Unicode
-characters, but some C extension module you are importing was compiled  
using a
-Python that uses a 2-byte representation for Unicode characters (the  
default).
-
-If instead the name of the undefined symbol starts with ``PyUnicodeUCS4``,  
the
-problem is the reverse: Python was built using 2-byte Unicode characters,  
and
-the extension module was compiled using a Python with 4-byte Unicode  
characters.
-
-This can easily occur when using pre-built extension packages.  RedHat  
Linux
-7.x, in particular, provided a "python2" binary that is compiled with  
4-byte
-Unicode.  This only causes the link failure if the extension uses any of  
the
-``PyUnicode_*()`` functions.  It is also a problem if an extension uses  
any of
-the Unicode-related format specifiers for :cfunc:`Py_BuildValue` (or  
similar) or
-parameter specifications for :cfunc:`PyArg_ParseTuple`.
-
-You can check the size of the Unicode character a Python interpreter is  
using by
-checking the value of sys.maxunicode:
+モジュール X をインポートした時に "undefined symbol: PyUnicodeUCS2*" と言わ 
れるのはなぜですか?
+-----------------------------------------------------------------------------------------------
+
+あなたは Unicode 文字に 4 バイト表現を使う Python のバージョンを
+使っていますが、インポートされた C 拡張モジュールに Unicode 文字に
+(デフォルトの) 2 バイト表現を使う Python でコンパイルされたものがあります。
+
+未定義のシンボルの名前が ``PyUnicodeUCS4`` で始まるのなら、
+逆の問題です: Python は 2 バイト Unicode 文字でビルトされていて、
+拡張モジュールは 4 バイト Unicode 文字の Python でコンパイルされています。
+
+これはあらかじめビルドされた拡張パッケージを使っているときに起こりやすいで 
す。
+とりわけ、RedHat Linux 7.x は 4 バイトユニコードでコンパイルされた
+"python2" バイナリを提供しました。これは拡張が ``PyUnicode_*()`` 関数の
+どれかを使っているとリンクの失敗を起こすだけです。拡張が Unicode に関連する
+:c:func:`Py_BuildValue` (等)へのフォーマット指定 
や :c:func:`PyArg_ParseTuple`
+へのパラメタ指定を何かしら含んでいても問題になります。
+
+Python インタプリタが使っている Unicode 文字のサイズは、
+sys.maxunicode の値を調べることで確かめられます:

     >>> import sys
     >>> if sys.maxunicode > 65535:
@@ -472,8 +478,6 @@
     ... else:
     ...     print 'UCS2 build'

-The only way to solve this problem is to use extension modules compiled  
with a
-Python binary built using the same size for Unicode characters.
-
-
-
+この問題を解決する唯一の方法は、Unicode 文字に同じサイズを使ってビルドされ 
た
+Python バイナリでコンパイルされた拡張モジュールを使うことです。
+
=======================================
--- /faq/general.rst	Sat Mar 19 08:59:41 2011
+++ /faq/general.rst	Sun Nov  6 08:09:46 2011
@@ -1,399 +1,401 @@
  :tocdepth: 2

-==================
-General Python FAQ
-==================
+===============
+一般 Python FAQ
+===============

  .. contents::

-General Information
-===================
-
-What is Python?
----------------
-
-Python is an interpreted, interactive, object-oriented programming  
language.  It
-incorporates modules, exceptions, dynamic typing, very high level dynamic  
data
-types, and classes.  Python combines remarkable power with very clear  
syntax.
-It has interfaces to many system calls and libraries, as well as to various
-window systems, and is extensible in C or C++.  It is also usable as an
-extension language for applications that need a programmable interface.
-Finally, Python is portable: it runs on many Unix variants, on the Mac,  
and on
-PCs under MS-DOS, Windows, Windows NT, and OS/2.
-
-To find out more, start with :ref:`tutorial-index`.  The `Beginner's Guide  
to
-Python <http://wiki.python.org/moin/BeginnersGuide>`_ links to other
-introductory tutorials and resources for learning Python.
+一般情報
+========
+
+Python とは何ですか?
+---------------------
+
+Python は、インタプリタ形式の、対話的な、
+オブジェクト指向プログラミング言語です。この言語には、モジュール、例外、
+動的な型付け、超高水準の動的なデータ型、およびクラスが取り入れられていま 
す。
+Python は驚くべきパワーと非常に分かりやすい文法を持ち合わせています。
+そして、多くのシステムコールやライブラリへだけでなく、
+様々なウィンドウシステムへのインタフェースがあり、
+C や C++ で拡張することもできます。また、プログラム可能なインタフェースが
+必要なアプリケーションのための拡張言語としても利用できます。
+最後に、Python はポータブルです。多くの Unix バリアント、
+Mac、そして MS-DOS、Windows、Windows NT、OS/2 上の PC で動かすことができま 
す。
+
+さらに知りたければ、\ :ref:`tutorial-index` から始めましょう。他にも、
+`Beginner's Guide to Python <http://wiki.python.org/moin/BeginnersGuide>`_
+から、Python 学習のための入門用チュートリアルやリソースを参照できます。。


-What is the Python Software Foundation?
----------------------------------------
-
-The Python Software Foundation is an independent non-profit organization  
that
-holds the copyright on Python versions 2.1 and newer.  The PSF's mission  
is to
-advance open source technology related to the Python programming language  
and to
-publicize the use of Python.  The PSF's home page is at
-http://www.python.org/psf/.
-
-Donations to the PSF are tax-exempt in the US.  If you use Python and find  
it
-helpful, please contribute via `the PSF donation page
-<http://www.python.org/psf/donations/>`_.
+Python Software Foundation とは何ですか?
+-----------------------------------------
+
+Python Software Foundation は、Python バージョン 2.1 以降の
+著作権を保持する独立の非営利組織です。PSF の任務は、Python
+プログラミング言語に関するオープンソース技術を進め、
+Python の使用を広めることです。PSF のホームページが
+http://www.python.org/psf/ にあります。
+
+PSF への寄付は米国で免税されています。Python を利用して役立ったと感じたら、
+`the PSF donation page <http://www.python.org/psf/donations/>`_
+で貢献をお願いします。


-Are there copyright restrictions on the use of Python?
-------------------------------------------------------
-
-You can do anything you want with the source, as long as you leave the
-copyrights in and display those copyrights in any documentation about  
Python
-that you produce.  If you honor the copyright rules, it's OK to use Python  
for
-commercial use, to sell copies of Python in source or binary form  
(modified or
-unmodified), or to sell products that incorporate Python in some form.  We  
would
-still like to know about all commercial use of Python, of course.
-
-See `the PSF license page <http://python.org/psf/license/>`_ to find  
further
-explanations and a link to the full text of the license.
-
-The Python logo is trademarked, and in certain cases permission is  
required to
-use it.  Consult `the Trademark Usage Policy
-<http://www.python.org/psf/trademarks/>`__ for more information.
+Python を使うのに著作権の制限はありますか?
+-------------------------------------------
+
+あなたが作成する Python に関するドキュメントのすべてに著作権を残し、
+それらの著作権を表示する限り、ソースコードをどのように扱ってもかまいませ 
ん。
+この著作権規則を尊重する限り、商用に Python を利用しても、
+ソースあるいはバイナリ形式で(変更の有無にかかわらず) Python の
+コピーを販売しても、Python が何らかの形で組み込まれた製品を
+販売してかまいません。もちろん、Python のあらゆる商業用途についても同様で 
す。
+
+ライセンスのより詳しい説明と全文へのリンクは
+`the PSF license page <http://python.org/psf/license/>`_ を参照してくださ 
い。
+
+Python のロゴは商標登録されていて、使用に許可が必要な場合があります。
+詳しい情報は `the Trademark Usage Policy
+<http://www.python.org/psf/trademarks/>`__ を参照してください。


-Why was Python created in the first place?
-------------------------------------------
-
-Here's a *very* brief summary of what started it all, written by Guido van
-Rossum:
-
-   I had extensive experience with implementing an interpreted language in  
the
-   ABC group at CWI, and from working with this group I had learned a lot  
about
-   language design.  This is the origin of many Python features, including  
the
-   use of indentation for statement grouping and the inclusion of
-   very-high-level data types (although the details are all different in
-   Python).
-
-   I had a number of gripes about the ABC language, but also liked many of  
its
-   features.  It was impossible to extend the ABC language (or its
-   implementation) to remedy my complaints -- in fact its lack of  
extensibility
-   was one of its biggest problems.  I had some experience with using  
Modula-2+
-   and talked with the designers of Modula-3 and read the Modula-3 report.
-   Modula-3 is the origin of the syntax and semantics used for exceptions,  
and
-   some other Python features.
-
-   I was working in the Amoeba distributed operating system group at CWI.   
We
-   needed a better way to do system administration than by writing either C
-   programs or Bourne shell scripts, since Amoeba had its own system call
-   interface which wasn't easily accessible from the Bourne shell.  My
-   experience with error handling in Amoeba made me acutely aware of the
-   importance of exceptions as a programming language feature.
-
-   It occurred to me that a scripting language with a syntax like ABC but  
with
-   access to the Amoeba system calls would fill the need.  I realized that  
it
-   would be foolish to write an Amoeba-specific language, so I decided  
that I
-   needed a language that was generally extensible.
-
-   During the 1989 Christmas holidays, I had a lot of time on my hand, so I
-   decided to give it a try.  During the next year, while still mostly  
working
-   on it in my own time, Python was used in the Amoeba project with  
increasing
-   success, and the feedback from colleagues made me add many early
-   improvements.
-
-   In February 1991, after just over a year of development, I decided to  
post to
-   USENET.  The rest is in the ``Misc/HISTORY`` file.
+Python が誕生したきっかけは何ですか?
+-------------------------------------
+
+Guido van Rossum による、すべてのきっかけの *非常に* 簡潔な概要は
+以下のとおりです:
+
+   私は CWI の ABC グループでインタプリタ言語を実装する幅広い経験をしてい 
て、
+   そこで共に働くことで言語設計に関して大いに学びました。
+   これが文のグループ化へのインデントの使用や超高水準のデータ型の包含など、
+   (詳細は Python では全く異なりますが)
+   Python の多くの特徴のもととなっています。
+
+   私は ABC 言語に対して多くの不満を持っていましたが、
+   同時に特徴の多くが好きでもありました。ABC 言語 (やその実装 )を拡張して
+   私の不満を解消することは不可能でした (実際、拡張性の欠如は
+   大きな問題だったのです)。私は Modula-2+ を使用することでいくらかの
+   経験を積み、Modula-3 のデザイナーと話して Modula-3 のレポートを
+   読みました。Modula-3 は例外処理に使う構文や語義、
+   その他いくつかの Python の特徴の起源です。
+
+   私は CWI で Amoeba 分散オペレーティングシステムのグループで働いていまし 
た。
+   Amoeba のシステムコールインタフェースにはボーンシェルから
+   アクセスしにくかったので、C プログラムやボーンシェルスクリプトを
+   書くよりも良いシステム管理の方法が必要でした。Amoeba の
+   エラー処理の経験から、プログラミング言語の機能としての例外の
+   重要さを強く意識するようになりました。
+
+   ABC のような構文と Amoeba のようなシステムコールを合わせ持った
+   スクリプト言語が必要だろうと思いつきました。Amoeba 専用の言語を
+   書くのは愚かであるだろうと気づき、一般に拡張できるような
+   言語を求めることに決めました。
+
+   1989 年のクリスマス休暇の間、自由な時間がたくさんできたので、
+   その言語を実際に作ってみることにしました。翌年の間、
+   勤務時間以外はほとんどその開発に費やし、Python は
+   Amoeba プロジェクトのなかで成果を重ね、
+   同僚からのフィードバックは私の開発を大いに加速させてくれました。
+
+   1991 年 2 月、1 年間と少しの開発を経て、USENET に投稿することにしまし 
た。
+   それは ``Misc/HISTORY`` ファイルに残っています。


-What is Python good for?
-------------------------
-
-Python is a high-level general-purpose programming language that can be  
applied
-to many different classes of problems.
-
-The language comes with a large standard library that covers areas such as
-string processing (regular expressions, Unicode, calculating differences  
between
-files), Internet protocols (HTTP, FTP, SMTP, XML-RPC, POP, IMAP, CGI
-programming), software engineering (unit testing, logging, profiling,  
parsing
-Python code), and operating system interfaces (system calls, filesystems,  
TCP/IP
-sockets).  Look at the table of contents for :ref:`library-index` to get  
an idea
-of what's available.  A wide variety of third-party extensions are also
-available.  Consult `the Python Package Index  
<http://pypi.python.org/pypi>`_ to
-find packages of interest to you.
+Python は何をするのに向いていますか?
+-------------------------------------
+
+Python は、多岐にわたる問題に適用できる高水準な汎用プログラム言語です。
+
+この言語は、文字列処理(正規表現、Unicode、ファイル間の差分の計算)、
+インターネットプロトコル(HTTP、FTP、SMTP、XML-RPC、POP、IMAP、
+CGI プログラミング)、ソフトウェアエンジニアリング(Python コードの
+ユニットテスト、ロギング、プロファイリング、解析)、
+オペレーティングシステムインタフェース(システムコール、ファイルシステム、
+TCP/IP ソケット) のような領域をカバーする大規模な標準ライブラリから
+成り立っています。何ができるかを知るには :ref:`library-index` の
+一覧を参照してください。また、様々なサードパーティの拡張も使えます。
+`the Python Package Index <http://pypi.python.org/pypi>`_ から
+興味のあるパッケージを探してみましょう。


-How does the Python version numbering scheme work?
---------------------------------------------------
-
-Python versions are numbered A.B.C or A.B.  A is the major version number  
-- it
-is only incremented for really major changes in the language.  B is the  
minor
-version number, incremented for less earth-shattering changes.  C is the
-micro-level -- it is incremented for each bugfix release.  See :pep:`6`  
for more
-information about bugfix releases.
-
-Not all releases are bugfix releases.  In the run-up to a new major  
release, a
-series of development releases are made, denoted as alpha, beta, or release
-candidate.  Alphas are early releases in which interfaces aren't yet  
finalized;
-it's not unexpected to see an interface change between two alpha releases.
-Betas are more stable, preserving existing interfaces but possibly adding  
new
-modules, and release candidates are frozen, making no changes except as  
needed
-to fix critical bugs.
-
-Alpha, beta and release candidate versions have an additional suffix.  The
-suffix for an alpha version is "aN" for some small number N, the suffix  
for a
-beta version is "bN" for some small number N, and the suffix for a release
-candidate version is "cN" for some small number N.  In other words, all  
versions
-labeled 2.0aN precede the versions labeled 2.0bN, which precede versions  
labeled
-2.0cN, and *those* precede 2.0.
-
-You may also find version numbers with a "+" suffix, e.g. "2.2+".  These  
are
-unreleased versions, built directly from the Subversion trunk.  In  
practice,
-after a final minor release is made, the Subversion trunk is incremented  
to the
-next minor version, which becomes the "a0" version,
-e.g. "2.4a0".
-
-See also the documentation for ``sys.version``, ``sys.hexversion``, and
-``sys.version_info``.
+Python のバージョン番号の仕組みはどうなっているのですか?
+---------------------------------------------------------
+
+Python のバージョン番号は A.B.C や A.B のように付けられています。
+A はメジャーバージョン番号で、言語の本当に重要な変更の時のみ増やされます。
+B はマイナーバージョン番号で、そこまでは大きくない変更の時に増やされます。
+C はマイクロレベルで、バグフィックスリリースの度に増やされます。
+バグフィックスリリースに関する詳細は :pep:`6` を参照してください。
+
+すべてのリリースがバグフィックスリリースであるというわけではありません。
+メジャーリリースへの準備段階では、一連の開発リリースが作られ、
+アルファ版、ベータ版、またはリリース候補と名付けられます。
+アルファ版はインタフェースが確定されないうちにリリースされる早期リリース 
で、
+2つのアルファリリース間でインタフェースが変わるかもしれません。
+ベータ版はもっと安定していて、現存のインタフェースは保存されますが
+新しいモジュールが追加されるかもしれません。リリース候補は固まったもので、
+致命的なバグを直すのでなければ変更されません。
+
+アルファ、ベータ、リリース候補の各バージョンには接尾語が追加されます。
+N をなにか小さい番号として、アルファ版の接尾語は "aN" 、
+ベータ版の接尾語は "bN" 、リリース候補の接尾語は "cN" です。
+つまり、バージョン 2.0aN、バージョン 2.0bN、バージョン 2.0cN、
+バージョン 2.0 の順にリリースされることになります。
+
+また、"2.2+" のように "+" 接尾語が付いたバージョン番号もあります。
+これは未発表のバージョンで、Subversion トランクから直接組み立てられていま 
す。
+実際、最後のマイナーリリースができた後、Subversion トランクは
+"2.4a0" のように "a0" がつく次のマイナーバージョンになります。
+
+``sys.version``\ 、\ ``sys.hexversion``\ 、\ ``sys.version_info`` について 
の
+ドキュメントも参照してください。


-How do I obtain a copy of the Python source?
---------------------------------------------
-
-The latest Python source distribution is always available from python.org,  
at
-http://www.python.org/download/.  The latest development sources can be  
obtained
-via anonymous Subversion at http://svn.python.org/projects/python/trunk.
-
-The source distribution is a gzipped tar file containing the complete C  
source,
-Sphinx-formatted documentation, Python library modules, example programs,  
and
-several useful pieces of freely distributable software.  The source will  
compile
-and run out of the box on most UNIX platforms.
+Python のソースのコピーはどこで手に入りますか?
+-----------------------------------------------
+
+最新の Python ソースは python.org (http://www.python.org/download/) から
+いつでも手に入れることができます。最新の開発版ソースは
+http://svn.python.org/projects/python/trunk の匿名
+Subversion から手に入れることができます。
+
+ソースは gzip された tar ファイルで配布され、完全な C のソース、
+Sphinx によりフォーマットされたドキュメント、Python ライブラリモジュール、
+サンプルプログラム、そしていくつかの役立つ配布自由なソフトウェアを
+含んでいます。このソースはほとんどの UNIX プラットフォームで
+そのままコンパイルして動かせます。

  .. XXX update link once the dev faq is relocated

-Consult the `Developer FAQ <http://www.python.org/dev/faq/>`__ for more
-information on getting the source code and compiling it.
+ソースコードを手に入れてコンパイルすることの詳しい情報は
+`開発者 FAQ <http://www.python.org/dev/faq/>`__ を参照してください。


-How do I get documentation on Python?
--------------------------------------
+Python のドキュメントはどこで手に入りますか?
+---------------------------------------------

  .. XXX mention py3k

-The standard documentation for the current stable version of Python is  
available
-at http://docs.python.org/.  PDF, plain text, and downloadable HTML  
versions are
-also available at http://docs.python.org/download.html.
-
-The documentation is written in reStructuredText and processed by `the  
Sphinx
-documentation tool <http://sphinx.pocoo.org/>`__.  The reStructuredText  
source
-for the documentation is part of the Python source distribution.
+Python の現行の安定バージョンの標準ドキュメントは http://docs.python.org/  
から
+利用できます。また、PDF、プレーンテキスト、ダウンロードできる HTML 版も
+http://docs.python.org/download.html から利用できます。
+
+このドキュメントは reStructuredText で書かれ、\ `the Sphinx documentation  
tool
+<http://sphinx.pocoo.org/>`__ で構成されました。このドキュメントに使われた
+reStructuredText のソースは Python のソース配布に含まれます。


-I've never programmed before. Is there a Python tutorial?
----------------------------------------------------------
-
-There are numerous tutorials and books available.  The standard  
documentation
-includes :ref:`tutorial-index`.
-
-Consult `the Beginner's Guide  
<http://wiki.python.org/moin/BeginnersGuide>`_ to
-find information for beginning Python programmers, including lists of  
tutorials.
+プログラミングをしたことがないのですが、 Python のチュートリアルはあります 
か?
+------------------------------------------------------------------------------
+
+膨大な量の役に立つチュートリアルや書籍があります。標準のドキュメントには
+:ref:`tutorial-index` などがあります。
+
+Python プログラム初心者のための情報のチュートリアルのリストは `the  
Beginner's
+Guide <http://wiki.python.org/moin/BeginnersGuide>`_ を参照してください。


-Is there a newsgroup or mailing list devoted to Python?
--------------------------------------------------------
-
-There is a newsgroup, :newsgroup:`comp.lang.python`, and a mailing list,
-`python-list <http://mail.python.org/mailman/listinfo/python-list>`_.  The
-newsgroup and mailing list are gatewayed into each other -- if you can  
read news
-it's unnecessary to subscribe to the mailing list.
-:newsgroup:`comp.lang.python` is high-traffic, receiving hundreds of  
postings
-every day, and Usenet readers are often more able to cope with this volume.
-
-Announcements of new software releases and events can be found in
-comp.lang.python.announce, a low-traffic moderated list that receives  
about five
-postings per day.  It's available as `the python-announce mailing list
-<http://mail.python.org/mailman/listinfo/python-announce-list>`_.
-
-More info about other mailing lists and newsgroups
-can be found at http://www.python.org/community/lists/.
+Python のためのニュースグループやメーリングリストはありますか?
+---------------------------------------------------------------
+
+ニュースグループ :newsgroup:`comp.lang.python` やメーリングリスト
+`python-list <http://mail.python.org/mailman/listinfo/python-list>`_
+があります。ニュースグループとメーリングリストは互いに接続されていて、
+ニュースを購読すればメーリングリストに参加する必要はありません。
+:newsgroup:`comp.lang.python` は一日に数百のポスティングを受ける高い
+トラフィックで、USENET 読者は多くの場合、このボリュームに応えることができま 
す。
+
+新しいソフトウェアリリースとイベントの告知は comp.lang.python.announce で
+見つけられます。これは 一日に 5 ポスティング程度を受ける低トラフィックの
+手頃なメーリングリストです。\ `the python-announce mailing list
+<http://mail.python.org/mailman/listinfo/python-announce-list>`_
+から利用可能です。
+
+その他のメーリングリストやニュースグループについての詳しい情報は
+http://www.python.org/community/lists/ にあります。


-How do I get a beta test version of Python?
--------------------------------------------
-
-Alpha and beta releases are available from  
http://www.python.org/download/.  All
-releases are announced on the comp.lang.python and  
comp.lang.python.announce
-newsgroups and on the Python home page at http://www.python.org/; an RSS  
feed of
-news is available.
+Python のベータテスト版はどこで手に入りますか?
+-----------------------------------------------
+
+アルファ/ベータリリースは http://www.python.org/download/ で手に入ります。
+リリースはすべて comp.lang.python や comp.lang.python.announce の
+ニュースグループと Python ホームページ http://www.python.org/ で
+告知され、PSS ニュースフィードが使えます。

  .. XXX update link once the dev faq is relocated

-You can also access the development version of Python through Subversion.   
See
-http://www.python.org/dev/faq/ for details.
+Subversion から開発版を手に入れることもできます。
+詳細は http://www.python.org/dev/faq/ を参照してください。


-How do I submit bug reports and patches for Python?
----------------------------------------------------
-
-To report a bug or submit a patch, please use the Roundup installation at
-http://bugs.python.org/.
-
-You must have a Roundup account to report bugs; this makes it possible for  
us to
-contact you if we have follow-up questions.  It will also enable Roundup  
to send
-you updates as we act on your bug. If you had previously used SourceForge  
to
-report bugs to Python, you can obtain your Roundup password through  
Roundup's
-`password reset procedure  
<http://bugs.python.org/user?@template=forgotten>`_.
+Python のバグ報告やパッチを上げるにはどうしたら良いですか?
+-----------------------------------------------------------
+
+バグの報告やパッチの投稿には、\ http://bugs.python.org/ から
+Roundup installation を利用してください。
+
+バグ報告には Roundup アカウントが必要です (こちらから関連する質問を
+させて頂くため、またバグを解決したときにアップデート版を送るため)。
+以前バグ報告に SourceForge を使っていたことがあるなら、Roundup の
+`password reset procedure  
<http://bugs.python.org/user?@template=forgotten>`_
+から Roundup のパスワードを取得することができます。

  .. XXX adapt link to dev guide

-For more information on how Python is developed, consult `the Python  
Developer's
-Guide <http://python.org/dev/>`_.
+Python 開発の工程について、詳しくは `the Python Developer's
+Guide <http://python.org/dev/>`_ を参照してください。


-Are there any published articles about Python that I can reference?
--------------------------------------------------------------------
-
-It's probably best to cite your favorite book about Python.
-
-The very first article about Python was written in 1991 and is now quite
-outdated.
+Python について発行された記事を何か参照できますか?
+---------------------------------------------------
+
+Python に関するあなたの愛読書を引用するのが一番でしょう。
+
+Python に関する一番初めの記事はとても古く、1991年に書かれています。

      Guido van Rossum and Jelke de Boer, "Interactively Testing Remote  
Servers
      Using the Python Programming Language", CWI Quarterly, Volume 4, Issue  
4
      (December 1991), Amsterdam, pp 283-303.


-Are there any books on Python?
-------------------------------
-
-Yes, there are many, and more are being published.  See the python.org  
wiki at
-http://wiki.python.org/moin/PythonBooks for a list.
-
-You can also search online bookstores for "Python" and filter out the Monty
-Python references; or perhaps search for "Python" and "language".
+Python の本はありますか?
+-------------------------
+
+はい、たくさんあり、そのほとんどは現在も出版されています。
+リストは python.org wiki http://wiki.python.org/moin/PythonBooks にありま 
す。
+
+また、オンライン書店で "Python" で検索し、Monty Python をフィルタで
+除外してもいいです (または、"Python" と "言語" で検索してください)。


-Where in the world is www.python.org located?
----------------------------------------------
-
-It's currently in Amsterdam, graciously hosted by `XS4ALL
-<http://www.xs4all.nl>`_.  Thanks to Thomas Wouters for his work in  
arranging
-python.org's hosting.
+www.python.org は世界のどこにあるのですか?
+-------------------------------------------
+
+現在、アムステルダムの `XS4ALL <http://www.xs4all.nl>`_ に優雅に
+迎えられています。python.org のホスティングの手配に関して、
+Thomas Wouters 氏に感謝いたします。


-Why is it called Python?
-------------------------
-
-When he began implementing Python, Guido van Rossum was also reading the
-published scripts from `"Monty Python's Flying Circus"
-<http://pythonline.com/>`__, a BBC comedy series from the 1970s.  Van  
Rossum
-thought he needed a name that was short, unique, and slightly mysterious,  
so he
-decided to call the language Python.
+なぜ Python という名前なのですか?
+----------------------------------
+
+Python の開発が始まった頃、Guido van Rossum は 1970 年代に始まった BBC の
+コメディシリーズ `"Monty Python's Flying Circus"  
<http://pythonline.com/>`__ の
+スクリプト集を読んでいました。Van Rossum は、短くて、ユニークで、
+少しミステリアスな名前が欲しかったので、この言語の名前を Python と
+呼ぶことにしたのです。


-Do I have to like "Monty Python's Flying Circus"?
--------------------------------------------------
-
-No, but it helps.  :)
+『空飛ぶモンティ・パイソン』を好きでなくてはいけませんか?
+----------------------------------------------------------
+
+いいえ。でも、好きになってくれるといいな。:)


-Python in the real world
-========================
-
-How stable is Python?
----------------------
-
-Very stable.  New, stable releases have been coming out roughly every 6 to  
18
-months since 1991, and this seems likely to continue.  Currently there are
-usually around 18 months between major releases.
-
-The developers issue "bugfix" releases of older versions, so the stability  
of
-existing releases gradually improves.  Bugfix releases, indicated by a  
third
-component of the version number (e.g. 2.5.3, 2.6.2), are managed for  
stability;
-only fixes for known problems are included in a bugfix release, and it's
-guaranteed that interfaces will remain the same throughout a series of  
bugfix
-releases.
-
-The latest stable releases can always be found on the `Python download page
-<http://python.org/download/>`_.  There are two recommended  
production-ready
-versions at this point in time, because at the moment there are two  
branches of
-stable releases: 2.x and 3.x.  Python 3.x may be less useful than 2.x,  
since
-currently there is more third party software available for Python 2 than  
for
-Python 3.  Python 2 code will generally not run unchanged in Python 3.
+現実世界での Python
+===================
+
+Python はどれくらい安定していますか?
+-------------------------------------
+
+とても安定しています。1991 年以来新しい安定リリースはおよそ 6 から 8 ヶ月毎 
に
+出されていて、このペースが続きそうです。現在、主要なリリースはたいてい
+約 18 ヶ月毎に出されています。
+
+開発者が旧バージョンの "bugfix" リリースを公開するので、現行のリリースの
+安定性は徐々に向上していきます。バグフィックスリリースは
+、バージョン番号の 3 番目の成分によって示され(例: 2.5.3、2.6.2)、
+安定性に配慮されています。バグフィックスリリースには既知の問題への
+修正だけが含まれ、一連のバグフィックスリリースで同じインタフェースが
+保たれることが保証されているのです。
+
+最新の安定版は `Python download page <http://python.org/download/>`_ から
+いつでも手に入れることができます。現在、安定版に 2 つのブランチがあるので、
+推奨の実用版には 2.x と 3.x の2つがあります。現時点では Python 2 の方が
+Python 3 より多くのサードパーティソフトに対応しているので、Python 3.x は
+Python 2.x より使いづらいかもしれません。Python 2 のコードは基本的に
+そのままでは Python 3 で動かすことができません。


-How many people are using Python?
----------------------------------
-
-There are probably tens of thousands of users, though it's difficult to  
obtain
-an exact count.
-
-Python is available for free download, so there are no sales figures, and  
it's
-available from many different sites and packaged with many Linux  
distributions,
-so download statistics don't tell the whole story either.
-
-The comp.lang.python newsgroup is very active, but not all Python users  
post to
-the group or even read it.
+どれくらいの人が Python を使っていますか?
+------------------------------------------
+
+正確な人数を調べるのは難しいですが、おそらく数万人のユーザーがいるでしょ 
う。
+
+Python は自由にダウンロード可能なので、売上高がなく、多数のサイトから利用で 
き、
+多くの Linux ディストーションに同梱されているので、ダウンロード統計から
+全体の状況を知ることはできません。
+
+comp.lang.python ニュースグループはとても活発ですが、
+すべての Python ユーザーが投稿するわけではなく、読みすらしない人もいます。


-Have any significant projects been done in Python?
---------------------------------------------------
-
-See http://python.org/about/success for a list of projects that use Python.
-Consulting the proceedings for `past Python conferences
-<http://python.org/community/workshops/>`_ will reveal contributions from  
many
-different companies and organizations.
-
-High-profile Python projects include `the Mailman mailing list manager
-<http://www.list.org>`_ and `the Zope application server
-<http://www.zope.org>`_.  Several Linux distributions, most notably `Red  
Hat
-<http://www.redhat.com>`_, have written part or all of their installer and
-system administration software in Python.  Companies that use Python  
internally
-include Google, Yahoo, and Lucasfilm Ltd.
+Python で行われた大きなプロジェクトはありますか?
+-------------------------------------------------
+
+Python を利用しているプロジェクトのリストは  
http://python.org/about/success を
+参照してください。\ `past Python conferences
+<http://python.org/community/workshops/>`_ から議事録を参照すると、
+多くの会社や組織の貢献がわかるでしょう。
+
+注目されている Python のプロジェクトは `the Mailman mailing list manager
+<http://www.list.org>`_ や `the Zope application server
+<http://www.zope.org>`_ などです。\ `Red Hat
+<http://www.redhat.com>`_ をはじめとするいくつかの Linux ディストーションの
+インストーラやシステムアドミニストレーションソフトウェアは、一部や全部が
+Python で書かれています。内部で Python を利用している企業には、
+Google、Yahoo、Lucasfilm Ltd. などがあります。


-What new developments are expected for Python in the future?
-------------------------------------------------------------
-
-See http://www.python.org/dev/peps/ for the Python Enhancement Proposals
-(PEPs). PEPs are design documents describing a suggested new feature for  
Python,
-providing a concise technical specification and a rationale.  Look for a  
PEP
-titled "Python X.Y Release Schedule", where X.Y is a version that hasn't  
been
-publicly released yet.
-
-New development is discussed on `the python-dev mailing list
-<http://mail.python.org/mailman/listinfo/python-dev/>`_.
+将来 Python にどのような新しい開発が期待されますか?
+----------------------------------------------------
+
+Python Enhancement Proposals (PEPs) http://www.python.org/dev/peps/ を
+参照してください。PEPs は Python に提案された新機能について書かれた設計書 
で、
+簡潔な技術仕様と原理が提供されています。"Python X.Y Release Schedule"
+(X.Y はまだリリースされていないバージョン) を探してください。
+
+新しい開発については `the python-dev mailing list
+<http://mail.python.org/mailman/listinfo/python-dev/>`_ で議論されていま 
す。


-Is it reasonable to propose incompatible changes to Python?
------------------------------------------------------------
-
-In general, no.  There are already millions of lines of Python code around  
the
-world, so any change in the language that invalidates more than a very  
small
-fraction of existing programs has to be frowned upon.  Even if you can  
provide a
-conversion program, there's still the problem of updating all  
documentation;
-many books have been written about Python, and we don't want to invalidate  
them
-all at a single stroke.
-
-Providing a gradual upgrade path is necessary if a feature has to be  
changed.
-:pep:`5` describes the procedure followed for introducing  
backward-incompatible
-changes while minimizing disruption for users.
+Python の互換性を無くすような提案をしてもいいのですか?
+-------------------------------------------------------
+
+一般的には、してはいけません。世界中にすでに何百万行もの Python コードが
+あるので、既存のプログラムのどんなに僅かな部分でも無効にしてしまうような
+言語仕様の変更も認められてはなりません。コンバートするプログラムが出来てさ 
え、
+すべてのドキュメントをアップデートしなければならないという問題があります。
+Python に関する多くの本が出版されているので、それらを一発で不適切に
+するようなことはしたくないです。
+
+仕様を変えなければならないのなら、緩やかなアップグレード計画が
+組まれなくてはなりません。\ :pep:`5` で、ユーザーの受ける分裂を最小限にしな 
がら
+後方互換性のない変更を行うために従うべき手順について説明しています。


-Is Python Y2K (Year 2000) Compliant?
-------------------------------------
+Python は 2000 年問題に対応できますか?
+---------------------------------------

  .. remove this question?

-As of August, 2003 no major problems have been reported and Y2K compliance  
seems
-to be a non-issue.
-
-Python does very few date calculations and for those it does perform  
relies on
-the C library functions.  Python generally represents times either as  
seconds
-since 1970 or as a ``(year, month, day, ...)`` tuple where the year is  
expressed
-with four digits, which makes Y2K bugs unlikely.  So as long as your C  
library
-is okay, Python should be okay.  Of course, it's possible that a particular
-application written in Python makes assumptions about 2-digit years.
-
-Because Python is available free of charge, there are no absolute  
guarantees.
-If there *are* unforeseen problems, liability is the user's problem rather  
than
-the developers', and there is nobody you can sue for damages.  The Python
-copyright notice contains the following disclaimer:
+2003年8月現在、重大な問題は全く報告されていないので、
+2000 年問題は気にする必要はないように思われます。
+
+Python は日付の計算とその実行でほんの少しだけ C ライブラリの関数に
+依存しています。Python は一般的に時間を 1970 年以来の秒か
+``(year, month, day, ...)`` タプルの年を 4 桁で表したもので表すので、
+2000 年問題のバグは起こらないでしょう。ですから C ライブラリに問題がなけれ 
ば、
+Python にも問題がないはずです。もちろん、Python で書かれたある種の
+アプリケーションが 2 桁で表された年を誤って解釈することは
+あるかもしれません。
+
+Python は無料で提供されているので、絶対の保証はありません。
+予期せぬ問題が *あれば*\ 、開発者の責任というよりはユーザーの責任であり、
+損害賠償を求める相手は誰もいません。Python の著作権表示には
+以下の注意書きが含まれています:

      4. PSF is making Python 2.3 available to Licensee on an "AS IS"
      basis.  PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR  
IMPLIED.  BY
@@ -407,47 +409,46 @@
      A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON 2.3,
      OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.

-The good news is that *if* you encounter a problem, you have full source
-available to track it down and fix it.  This is one advantage of an open  
source
-programming environment.
+嬉しいことに、 *もし* 問題にいきあたっても、その問題を探し出して
+修理するために完全なソースを使うことができます。
+これはオープンソースプログラミング環境の利点の1つです。


-Is Python a good language for beginning programmers?
-----------------------------------------------------
-
-Yes.
-
-It is still common to start students with a procedural and statically typed
-language such as Pascal, C, or a subset of C++ or Java.  Students may be  
better
-served by learning Python as their first language.  Python has a very  
simple and
-consistent syntax and a large standard library and, most importantly, using
-Python in a beginning programming course lets students concentrate on  
important
-programming skills such as problem decomposition and data type design.   
With
-Python, students can be quickly introduced to basic concepts such as loops  
and
-procedures.  They can probably even work with user-defined objects in  
their very
-first course.
-
-For a student who has never programmed before, using a statically typed  
language
-seems unnatural.  It presents additional complexity that the student must  
master
-and slows the pace of the course.  The students are trying to learn to  
think
-like a computer, decompose problems, design consistent interfaces, and
-encapsulate data.  While learning to use a statically typed language is
-important in the long term, it is not necessarily the best topic to  
address in
-the students' first programming course.
-
-Many other aspects of Python make it a good first language.  Like Java,  
Python
-has a large standard library so that students can be assigned programming
-projects very early in the course that *do* something.  Assignments aren't
-restricted to the standard four-function calculator and check balancing
-programs.  By using the standard library, students can gain the  
satisfaction of
-working on realistic applications as they learn the fundamentals of  
programming.
-Using the standard library also teaches students about code reuse.   
Third-party
-modules such as PyGame are also helpful in extending the students' reach.
-
-Python's interactive interpreter enables students to test language features
-while they're programming.  They can keep a window with the interpreter  
running
-while they enter their program's source in another window.  If they can't
-remember the methods for a list, they can do something like this::
+Python は初心者プログラマに向いている言語ですか?
+-------------------------------------------------
+
+はい。
+
+未だにプログラミング初学者にとって一般的なのは、Pascal、C、C++ のサブセッ 
ト、
+Java など、手続き型の静的型付けの言語です。生徒にとっては、
+第一の言語として Python を学ぶのが役に立つでしょう。Python には非常に簡潔で
+一貫した構文と大きな標準ライブラリがあります。そして一番重要なことに、
+初心者プログラミングのコースで Python を学ぶことで、生徒は問題の分析や
+データ型の設計など、重要なプログラミングスキルに集中することができるので 
す。
+Python なら、生徒はループや手続きなどの基本概念をすぐに取り入れられます。
+最初の課程でいきなりユーザ定義のオブジェクトを操ることさえできるでしょう。
+
+プログラミングをしたことがない初心者にとって、静的型付け言語を使うのは
+不自然に思われます。習得すべき内容はより複雑になり、学習のペースが
+遅くなってしまいます。生徒は、コンピュータのように思考し、問題を分析し、
+一貫したインタフェースを設計して、データをカプセル化することを
+学ぶことになります。長期的に見れば静的型付け言語を学ぶことは重要ですが、
+それが最初のプログラミングの授業で学ぶべき最高の話題とは限りません。
+
+Python の良いところは他にもたくさんあります。Python には、Java のように
+大きな標準ライブラリがあり、生徒が何かを *する* 段階で非常に早く
+プログラミングプロジェクトに参加できるようになります。宿題は標準の
+四則演算機や平均を求めるプログラムに限定されません。標準ライブラリを
+使用することで、生徒はプログラミングの原理を学びながら現実的な
+アプリケーションに取り組む満足感を得ることができます。また、
+標準ライブラリの使用からコードの再利用を学ぶことができます。
+PyGame などのサードパーティモジュールもまた手が届く範囲を広げるのに役立ちま 
す。
+
+Python のインタラクティブインタプリタによって、プログラミングをしながら、
+言語機能を確認することができます。別のウィンドウでプログラムのソースに
+入っている間、ウィンドウでインタプリタを起動させたままに
+しておくことができます。リストのメソッドを思い出せないときは、
+例えばこのようにできます::

     >>> L = []
     >>> dir(L)
@@ -462,51 +463,53 @@
     >>> L
     [1]

-With the interpreter, documentation is never far from the student as he's
-programming.
-
-There are also good IDEs for Python.  IDLE is a cross-platform IDE for  
Python
-that is written in Python using Tkinter.  PythonWin is a Windows-specific  
IDE.
-Emacs users will be happy to know that there is a very good Python mode for
-Emacs.  All of these programming environments provide syntax highlighting,
-auto-indenting, and access to the interactive interpreter while coding.   
Consult
-http://www.python.org/editors/ for a full list of Python editing  
environments.
-
-If you want to discuss Python's use in education, you may be interested in
-joining `the edu-sig mailing list
-<http://python.org/community/sigs/current/edu-sig>`_.
+インタプリタがあれば、プログラミングをしている間にドキュメントは
+生徒のそばを離れません。
+
+Python のための良い IDE もあります。IDLE は Python で Tkinter を使って
+書かれたクロスプラットフォーム IDE です。PythonWin は Windows 専用の
+IDE です。Emacs には、ユーザにとって幸運なことに、素晴らしい Python モード 
が
+あります。これらすべてのプログラミング環境から、シンタックスハイライト、
+オートインデント、コーディング中のインタラクティブインタプリタへのアクセス 
が
+使えます。 http://www.python.org/editors/ から Python 編集環境の
+一覧を参照してください。
+
+Python の教育における利用についての議論がしたいなら、\ `the edu-sig  
mailing list
+<http://python.org/community/sigs/current/edu-sig>`_ に参加するとよいでしょ 
う。


-Upgrading Python
-================
-
-What is this bsddb185 module my application keeps complaining about?
---------------------------------------------------------------------
+Python のアップグレード
+=======================
+
+私のアプリケーションに使われている bsddb185 モジュールは何が問題とされてい 
ますか?
+----------------------------------------------------------------------------------

  .. XXX remove this question?

-Starting with Python2.3, the distribution includes the `PyBSDDB package
-<http://pybsddb.sf.net/>` as a replacement for the old bsddb module.  It
-includes functions which provide backward compatibility at the API level,  
but
-requires a newer version of the underlying `Berkeley DB
-<http://www.sleepycat.com>`_ library.  Files created with the older bsddb  
module
-can't be opened directly using the new module.
-
-Using your old version of Python and a pair of scripts which are part of  
Python
-2.3 (db2pickle.py and pickle2db.py, in the Tools/scripts directory) you can
-convert your old database files to the new format.  Using your old Python
-version, run the db2pickle.py script to convert it to a pickle, e.g.::
+Python2.3 から、配布時に古い bsddb モジュールの代わりに `PyBSDDB package
+<http://pybsddb.sf.net/>`_ が含まれるようになりました。このモジュールは
+API レベルでは後方互換性を保っていますが、基本となる `Berkeley DB
+<http://www.sleepycat.com>`_ ライブラリは新しいものが必要となります。
+古い bsddb モジュールで作られたファイルは新しいモジュールで
+直接開くことができません。
+
+古いバージョンの Python と Python 2.3 の一部である2つのスクリプト
+(Tools/scripts ディレクトリの db2pickle.py と pickle2db.py) を使用して、
+古いデータベースファイルを新しいフォーマットにコンバートすることができま 
す。
+古いバージョンの Python を使って、スクリプトを pickle に変換するために
+db2pickle.py スクリプトを起動してください。例えば::

     python2.2 <pathto>/db2pickley.py database.db database.pck

-Rename your database file::
+データベースファイルを改名してください::

     mv database.db olddatabase.db

-Now convert the pickle file to a new format database::
+そして、 pickle ファイルを新しいフォーマットのデータベースに変換してくださ 
い::

     python <pathto>/pickle2db.py database.db database.pck

-The precise commands you use will vary depending on the particulars of your
-installation.  For full details about operation of these two scripts check  
the
-doc string at the start of each one.
+入力すべき正確なコマンドは、あなたのインストールの詳細によって変わります。
+これら 2 つのスクリプトの命令の詳細は、それぞれの最初にある
+doc string を確認してください。
+
=======================================
--- /faq/gui.rst	Sat Mar 19 08:59:41 2011
+++ /faq/gui.rst	Sun Nov  6 08:09:46 2011
@@ -1,164 +1,173 @@
  :tocdepth: 2

-==========================
-Graphic User Interface FAQ
-==========================
+====================================
+グラフィックユーザインタフェース FAQ
+====================================

  .. contents::

-General GUI Questions
-=====================
-
-What platform-independent GUI toolkits exist for Python?
---------------------------------------------------------
-
-Depending on what platform(s) you are aiming at, there are several.
+一般的な GUI の質問
+===================
+
+Python のプラットフォーム非依存の GUI ツールキットには何がありますか?
+----------------------------------------------------------------------
+
+目的のプラットフォーム (群) が何かによって、いくつかあります。

  .. XXX check links

  Tkinter
  '''''''

-Standard builds of Python include an object-oriented interface to the  
Tcl/Tk
-widget set, called Tkinter.  This is probably the easiest to install and  
use.
-For more info about Tk, including pointers to the source, see the Tcl/Tk  
home
-page at http://www.tcl.tk.  Tcl/Tk is fully portable to the MacOS,  
Windows, and
-Unix platforms.
+Python の標準的なビルドには、Tkinter という
+Tcl/Tk ウィジェットセットのオブジェクト指向インタフェースが含まれています。
+これが最も簡単にインストールして使えるでしょう。ソースへのポインタなど、
+Tk に関する詳しい情報は、\ `Tcl/Tk home page <http://www.tcl.tk>`_ を
+参照してください。Tcl/Tk は、MacOS、Windows、Unix プラットフォームに
+完全にポータブルです。

  wxWidgets
  '''''''''

-wxWidgets is a GUI class library written in C++ that's a portable
-interface to various platform-specific libraries, and that has a
-Python interface called `wxPython <http://www.wxpython.org>`__.
-
-wxWidgets preserves the look and feel of the
-underlying graphics toolkit, and has a large set of widgets and
-collection of GDI classes.  See `the wxWidgets page
-<http://www.wxwidgets.org>`_ for more details.
-
-wxWidgets supports Windows and MacOS; on Unix variants,
-it supports both GTk+ and Motif toolkits.
+wxWidgets は、C++ で書かれたフリーでポータブルなGUI クラスライブラリで、
+各プラットフォームのネイティブなルックアンドフィールを
+提供し、\ `wxPython <http://www.wxpython.org>`__ という Python
+インタフェースがあります。
+
+wxPython は、基になるグラフィックスツールキットのルックアンドフィールを
+提供し、大量のウィジェットや GDI クラスを備えています。
+詳細は、\ `the wxWidgets page <http://www.wxwidgets.org>`_ を
+参照してください。
+
+wxWidgets は、Windows と MacOS をサポートしています。
+Unix バリアントでは、GTk+ と Motif toolkits のどちらもサポートしています。

  Qt
  '''

-There are bindings available for the Qt toolkit (`PyQt
-<http://www.riverbankcomputing.co.uk/software/pyqt/>`_) and for KDE  
(`PyKDE <http://www.riverbankcomputing.co.uk/software/pykde/intro>`__).  If
-you're writing open source software, you don't need to pay for PyQt, but  
if you
-want to write proprietary applications, you must buy a PyQt license from
-`Riverbank Computing <http://www.riverbankcomputing.co.uk>`_ and (up to Qt  
4.4;
-Qt 4.5 upwards is licensed under the LGPL license) a Qt license from  
`Trolltech
-<http://www.trolltech.com>`_.
+Qt ツールキットで利用できるバインディング (`PyQt
+<http://www.riverbankcomputing.co.uk/software/pyqt/>`_)
+や、KDE 利用できるバインディング (`PyKDE
+<http://www.riverbankcomputing.co.uk/software/pykde/intro>`_) があります。
+オープンソースソフトウェアを書くには、PyQt に支払いをする必要はありません 
が、
+プロプライエタリなアプリケーションを書くためには `Riverbank Computing
+<http://www.riverbankcomputing.co.uk/software/pyqt/license>`_ から
+PyQt ライセンスを、また、Qt 4.4 までは `Trolltech
+<http://www.trolltech.com>`_ から Qt ライセンスを購入しなければなりません。
+(Qt 4.5 以降は LGPL ライセンスが適用されています。)

  Gtk+
  ''''

-PyGtk bindings for the `Gtk+ toolkit <http://www.gtk.org>`_ have been
-implemented by James Henstridge; see <http://www.pygtk.org>.
+`Gtk+ toolkit <http://www.gtk.org>`_ 用の PyGtk バインディングが
+James Henstridge によって実装されています。\ <http://www.pygtk.org>
+を参照してください。

  FLTK
  ''''

-Python bindings for `the FLTK toolkit <http://www.fltk.org>`_, a simple yet
-powerful and mature cross-platform windowing system, are available from  
`the
-PyFLTK project <http://pyfltk.sourceforge.net>`_.
+簡潔かつ強力で成熟したクロスプラットフォームウィンドウシステム
+`the FLTK toolkit <http://www.fltk.org>`_ の Python バインディングが
+`the PyFLTK project <http://pyfltk.sourceforge.net/>`_ から利用できます。


  FOX
  '''

-A wrapper for `the FOX toolkit <http://www.fox-toolkit.org/>`_ called `FXpy
-<http://fxpy.sourceforge.net/>`_ is available.  FOX supports both Unix  
variants
-and Windows.
+`the FOX toolkit <http://www.fox-toolkit.org/>`_ のラッパ `FXpy
+<http://fxpy.sourceforge.net/>`_ が利用できます。FOX は Unix バリアントと
+Windows の両方をサポートします。


  OpenGL
  ''''''

-For OpenGL bindings, see `PyOpenGL <http://pyopengl.sourceforge.net>`_.
+OpenGL のバインディングは、\ `PyOpenGL <http://pyopengl.sourceforge.net>`_
+を参照してください。


-What platform-specific GUI toolkits exist for Python?
------------------------------------------------------
-
-`The Mac port <http://python.org/download/mac>`_ by Jack Jansen has a rich  
and
-ever-growing set of modules that support the native Mac toolbox calls.   
The port
-supports MacOS X's Carbon libraries.
-
-By installing the `PyObjc Objective-C bridge
-<http://pyobjc.sourceforge.net>`_, Python programs can use MacOS X's
-Cocoa libraries. See the documentation that comes with the Mac port.
-
-:ref:`Pythonwin <windows-faq>` by Mark Hammond includes an interface to the
-Microsoft Foundation Classes and a Python programming environment
-that's written mostly in Python using the MFC classes.
+Python のプラットフォーム固有の GUI ツールキットには何がありますか?
+--------------------------------------------------------------------
+
+Jack Jansen による `The Mac port <http://python.org/download/mac>`_ には、
+ネイティブ Mac ツールボックスコールをサポートする豊富で発展中のモジュール群 
が
+あります。このポートは MacOS X の Carbon ライブラリをサポートしています。
+
+`PyObjc Objective-C bridge <http://pyobjc.sourceforge.net>`_ を
+インストールすることによって、Python プログラマは MacOS X の
+Cocoa ライブラリを使うことができます。Mac port に付属するドキュメントを
+参照してください。
+
+Mark Hammond による :ref:`Pythonwin <windows-faq>` には、
+Microsoft Foundation Class のインタフェースと Python プログラミング環境が
+含まれています。


-Tkinter questions
-=================
-
-How do I freeze Tkinter applications?
--------------------------------------
-
-Freeze is a tool to create stand-alone applications.  When freezing Tkinter
-applications, the applications will not be truly stand-alone, as the  
application
-will still need the Tcl and Tk libraries.
-
-One solution is to ship the application with the Tcl and Tk libraries, and  
point
-to them at run-time using the :envvar:`TCL_LIBRARY`  
and :envvar:`TK_LIBRARY`
-environment variables.
-
-To get truly stand-alone applications, the Tcl scripts that form the  
library
-have to be integrated into the application as well. One tool supporting  
that is
-SAM (stand-alone modules), which is part of the Tix distribution
-(http://tix.sourceforge.net/).
-
-Build Tix with SAM enabled, perform the appropriate call to
-:cfunc:`Tclsam_init`, etc. inside Python's
-:file:`Modules/tkappinit.c`, and link with libtclsam and libtksam (you
-might include the Tix libraries as well).
+Tkinter の質問
+==============
+
+Tkinter アプリケーションを凍結するにはどうしますか?
+----------------------------------------------------
+
+Freeze はスタンドアロンアプリケーションを生成するツールです。
+Tkinter アプリケーションを凍結するとき、それは Tcl と Tk ライブラリを
+必要とするので、真のスタンドアロンにはなりません。
+
+一つの解決策は、アプリケーションに Tcl と Tk ライブラリを同梱し、
+環境変数 :envvar:`TCL_LIBRARY` と :envvar:`TK_LIBRARY` でランタイムに
+指定することです。
+
+真にスタンドアロンなアプリケーションにするためには、ライブラリを成す
+Tcl スクリプトもアプリケーションに統合されていなければなりません。
+それをサポートするツールの一つは SAM (stand-alone modules) で、
+Tix ディストリビューション (http://tix.sourceforge.net/) の一部です。
+
+SAM を有効にするように Tix をビルドして、Python  
の :file:`Modules/tkappinit.c`
+内部の :c:func:`Tclsam_init` 等への適切なコールを実行し、libtclsam と
+libtksam にリンクしてください (Tix ライブラリを含んでも良いです)。


-Can I have Tk events handled while waiting for I/O?
----------------------------------------------------
-
-Yes, and you don't even need threads!  But you'll have to restructure your  
I/O
-code a bit.  Tk has the equivalent of Xt's :cfunc:`XtAddInput()` call,  
which allows you
-to register a callback function which will be called from the Tk mainloop  
when
-I/O is possible on a file descriptor.  Here's what you need::
+I/O を待つ間に扱われる Tk イベントを作れますか?
+------------------------------------------------
+
+はい、スレッドさえ必要ありません!  ただし、I/O コードを少し
+再構成しなければなりません。Tk には Xt の :cfunc:`XtAddInput()` コールと
+同等なものがあるので、ファイルディスクリプタ上で I/O が可能なときに
+Tk メインループから呼ばれるコールバック関数を登録できます。
+このようにすればいいです::

     from Tkinter import tkinter
     tkinter.createfilehandler(file, mask, callback)

-The file may be a Python file or socket object (actually, anything with a
-fileno() method), or an integer file descriptor.  The mask is one of the
-constants tkinter.READABLE or tkinter.WRITABLE.  The callback is called as
-follows::
+file には Python ファイルかソケットオブジェクト(実際には、fileno() メソッド 
を
+持った何か)、または整数のファイルディスクリプタを指定できます。
+mask は定数 tkinter.READABLE または tkinter.WRITABLE のどちらかです。
+callback は以下のように呼び出されます::

     callback(file, mask)

-You must unregister the callback when you're done, using ::
+callback が完了したら、次のように登録を解除しなければなりません::

     tkinter.deletefilehandler(file)

-Note: since you don't know *how many bytes* are available for reading, you  
can't
-use the Python file object's read or readline methods, since these will  
insist
-on reading a predefined number of bytes.  For sockets, the :meth:`recv` or
-:meth:`recvfrom` methods will work fine; for other files, use
-``os.read(file.fileno(), maxbytecount)``.
+ノート: 読み込みに使える *バイト数* がわからないので、指定されたバイト数を
+読み込む Python のファイルオブジェクトの read や readline メソッドを
+使うことはできません。ソケットには、\ :meth:`recv` や :meth:`recvfrom` メソ 
ッドを
+使うといいです。その他のファイルには、\ ``os.read(file.fileno(),  
maxbytecount)``
+を使ってください。


-I can't get key bindings to work in Tkinter: why?
--------------------------------------------------
-
-An often-heard complaint is that event handlers bound to events with the
-:meth:`bind` method don't get handled even when the appropriate key is  
pressed.
-
-The most common cause is that the widget to which the binding applies  
doesn't
-have "keyboard focus".  Check out the Tk documentation for the focus  
command.
-Usually a widget is given the keyboard focus by clicking in it (but not for
-labels; see the takefocus option).
+Tkinter で働くキーバインディングが得られません。なぜですか?
+------------------------------------------------------------
+
+:meth:`bind` メソッドでイベントに結び付けられたイベントハンドラが、
+適切なキーが押されたときにさえハンドルされないという苦情がよく聞かれます。
+
+最も一般的な原因は、バインディングが適用されるウィジェットが
+"キーボードフォーカス" を持たないことです。Tk ドキュメントで
+フォーカスコマンドを確認してください。通常はウィジェットの中を
+クリックすることでキーボードフォーカスを与えられます (ただしラベルには
+与えられません。takefocus オプションを参照してください)。



=======================================
--- /faq/installed.rst	Sat Mar 19 08:59:41 2011
+++ /faq/installed.rst	Sun Nov  6 08:09:46 2011
@@ -1,53 +1,60 @@
-=============================================
-"Why is Python Installed on my Computer?" FAQ
-=============================================
-
-What is Python?
----------------
-
-Python is a programming language.  It's used for many different  
applications.
-It's used in some high schools and colleges as an introductory programming
-language because Python is easy to learn, but it's also used by  
professional
-software developers at places such as Google, NASA, and Lucasfilm Ltd.
-
-If you wish to learn more about Python, start with the `Beginner's Guide to
-Python <http://wiki.python.org/moin/BeginnersGuide>`_.
+======================================================================
+"なぜ Python が私のコンピュータにインストールされているのですか?" FAQ
+======================================================================
+
+Python とは何ですか?
+---------------------
+
+Python はプログラミング言語の一つです。Python は様々なアプリケーションに
+使われています。Python は習得しやすいので、一部の高校や大学で入門用の
+プログラミング言語として使われています。一方で、Google、NASA、Lucasfilm  
Ltd.
+のような組織でプロフェッショナルなソフトウェア開発者にも使われています。
+
+Python についてもっと詳しく知りたいなら、\ `Beginner's Guide to Python
+<http://wiki.python.org/moin/BeginnersGuide>`_ から始めましょう。


-Why is Python installed on my machine?
---------------------------------------
-
-If you find Python installed on your system but don't remember installing  
it,
-there are several possible ways it could have gotten there.
-
-* Perhaps another user on the computer wanted to learn programming and  
installed
-  it; you'll have to figure out who's been using the machine and might have
-  installed it.
-* A third-party application installed on the machine might have been  
written in
-  Python and included a Python installation.  For a home computer, the most
-  common such application is `PySol <http://pysolfc.sourceforge.net/>`_, a
-  solitaire game that includes over 1000 different games and variations.
-* Some Windows machines also have Python installed.  At this writing we're  
aware
-  of computers from Hewlett-Packard and Compaq that include Python.   
Apparently
-  some of HP/Compaq's administrative tools are written in Python.
-* All Apple computers running Mac OS X have Python installed; it's  
included in
-  the base installation.
+なぜ Python が私のマシンにインストールされているのですか?
+----------------------------------------------------------
+
+インストールした覚えがないのに Python があなたのシステムに
+インストールされているとしたら、その理由にはいくつかの可能性があります。
+
+* もしかしたら、コンピュータの他のユーザがプログラミングを学ぶために
+  インストールしたのかもしれません。誰がそのマシンを使っていて Python を
+  インストールしたか知る必要があります。
+* マシンにインストールされているサードパーティのアプリケーションが、
+  Python で書かれていて Python のインストールを含んでいるかもしれません。
+  家庭用のコンピュータでは、そのようなアプリケーションで一番有名なものは、
+  1000 種類以上のゲームやバリエーションを含むソリティアゲーム、\
+  `PySol <http://pysolfc.sourceforge.net/>`_ です。
+  GUI プログラムからネットワークサーバと管理スクリプトまで、
+  そのようなアプリケーションはたくさんあります。
+* Windows マシンにも Python がインストールされたものがあります。
+  この執筆時点で Hewlett-Packard や Compaq が Python を
+  組み込んでいることを確認しています。
+* Mac OS X や Linux ディストリビューションのいくつかなど、
+  多くの Unix 互換オペレーティングシステムに Python が
+  デフォルトでインストールされています。
+  標準インストールに Python が含まれているのです。


-Can I delete Python?
---------------------
-
-That depends on where Python came from.
-
-If someone installed it deliberately, you can remove it without hurting
-anything.  On Windows, use the Add/Remove Programs icon in the Control  
Panel.
-
-If Python was installed by a third-party application, you can also remove  
it,
-but that application will no longer work.  You should use that  
application's
-uninstaller rather than removing Python directly.
-
-If Python came with your operating system, removing it is not  
recommended.  If
-you remove it, whatever tools were written in Python will no longer run,  
and
-some of them might be important to you.  Reinstalling the whole system  
would
-then be required to fix things again.
-
+ython を削除してもいいですか?
+------------------------------
+
+Python をどこから手に入れたかによります。
+
+誰かが Python を意図してダウンロードしたのであれば、何の問題もなく
+削除することができます。Windows では、コントロールパネルのプログラムの
+追加と削除を使ってください。
+
+Python がサードパーティのアプリケーションによってインストールされたなら、
+同様に削除できますが、そのアプリケーションは動作しなくなります。
+Python のディレクトリを削除するのではなく、
+そのアプリケーションのアンインストーラーを使うべきです。
+
+Python がオペレーティングシステムに含まれて来たなら、削除はお勧めできませ 
ん。
+削除してしまうと、Python で書かれたプログラムは全く動かなくなり、
+その中には重要なものが含まれているかもしれません。
+その場合、修復にはシステム全体の再インストールが必要になるでしょう。
+
=======================================
--- /library/functions.rst	Wed Jun 22 06:42:21 2011
+++ /library/functions.rst	Sun Nov  6 08:09:46 2011
@@ -6,6 +6,27 @@
  Python インタプリタは数多くの組み込み関数を持っていて、いつでも利用す
  ることができます。それらの関数をアルファベット順に挙げます。

+===================  =================  ==================   
=================  ====================
+..                   ..                 Built-in  
Functions  ..                 ..
+===================  =================  ==================   
=================  ====================
+:func:`abs`          :func:`divmod`     :func:`input`       :func:`open`       :func:`staticmethod`
+:func:`all`          :func:`enumerate`  :func:`int`         :func:`ord`        :func:`str`
+:func:`any`          :func:`eval`       :func:`isinstance`  :func:`pow`        :func:`sum`
+:func:`basestring`   :func:`execfile`   :func:`issubclass`  :func:`print`      :func:`super`
+:func:`bin`          :func:`file`       :func:`iter`        :func:`property`   :func:`tuple`
+:func:`bool`         :func:`filter`     :func:`len`         :func:`range`      :func:`type`
+:func:`bytearray`    :func:`float`      :func:`list`        :func:`raw_input`  :func:`unichr`
+:func:`callable`     :func:`format`     :func:`locals`      :func:`reduce`     :func:`unicode`
+:func:`chr`          :func:`frozenset`  :func:`long`        :func:`reload`     :func:`vars`
+:func:`classmethod`  :func:`getattr`    :func:`map`         :func:`repr`       :func:`xrange`
+:func:`cmp`          :func:`globals`    :func:`max`         :func:`reversed`   :func:`zip`
+:func:`compile`      :func:`hasattr`    :func:`memoryview`  :func:`round`      :func:`__import__`
+:func:`complex`      :func:`hash`       :func:`min`         :func:`set`        :func:`apply`
+:func:`delattr`      :func:`help`       :func:`next`        :func:`setattr`    :func:`buffer`
+:func:`dict`         :func:`hex`        :func:`object`      :func:`slice`      :func:`coerce`
+:func:`dir`          :func:`id`         :func:`oct`         :func:`sorted`     :func:`intern`
+===================  =================  ==================   
=================  ====================
+

  .. function:: abs(x)

@@ -82,6 +103,33 @@
        引数が与えられなかった場合、この関数は :const:`False` を返します。


+.. function:: bytearray([source[, encoding[, errors]]])
+
+   新しいバイトの配列を返します。:class:`bytearray` 型は範囲 0 <= x < 256  
の
+   整数のミュータブルなシーケンスです。これは、:ref:`typesseq-mutable` で
+   書かれているような、ミュータブルなシーケンスの通常のメソッドのほとんどを
+   持ちますし、:ref:`string-methods` にあるような、:class:`str` 型が持つ
+   メソッドのほとんども持っています。
+
+   オプションの *source* パラメタは、配列をいくつかの異なる方法で
+   初期化するのに使われます。
+
+   * これが *文字列* なら、*encoding* (と、オプションの *errors*) パラメタ 
も
+     与えなければなりません。このとき :func:`bytearray` は文字列を
+     :meth:`str.encode` でバイト列に変換して返します。
+
+   * これが *整数* なら、配列はそのサイズになり、null バイトで
+     初期化されます。
+
+   * これが *バッファ* インタフェースに適合するオブジェクトなら、
+     そのオブジェクトの読み込み専用バッファがバイト配列の初期化に使われま 
す。
+
+   * これが *イテラブル* なら、それは範囲 ``0 <= x < 256`` 内の整数の
+     イテラブルであることが必要で、それらが配列の初期の内容になります。
+
+   引数がなければ、長さ 0 の配列が生成されます。
+
+
  .. function:: callable(object)

     引数 *object* が呼び出し可能オブジェクトであれば、 :const:`True` を
@@ -185,11 +233,10 @@

     .. note::

-      複数行にわたるコードをコンパイルする場合、
-      行末を単一の改行文字 (``'\n'``) で表現しなければいけません、
-      さらに入力は少なくとも一つの改行文字で終端していなければいけません。
-      もし行末が ``'\r\n'`` で表現されていれば、
-      :meth:`str.replace` を使って ``'\n'`` に置き換えて下さい。
+      複数行に渡るコードの文字列を ``'single'`` や ``'eval'`` モードで
+      コンパイルするとき、入力は少なくともひとつの改行文字で
+      終端されなければなりません。これは :mod:`code` モジュールで、文が
+      不完全か完全かをわかりやすくするためです。

     .. versionadded:: 2.3
        *flags* と *dont_inherit* 引数が追加されました。
@@ -197,6 +244,10 @@
     .. versionadded:: 2.6
        AST オブジェクトのコンパイルをサポートしました。

+   .. versionchanged:: 2.7
+      Windows や Mac の改行文字を使えるようになりました。また、``'exec'``
+      モードで改行文字は必要なくなりました。*optimize* パラメタを追加しまし 
た。
+

  .. function:: complex([real[, imag]])

@@ -293,7 +344,7 @@

  .. function:: divmod(a, b)

-   2 つの (複素数でない) 数値を引数として取り、長除法を行ってその商と
+   2 つの (複素数でない) 数値を引数として取り、整数の除法を行ったときの商と
     剰余からなるペアを返します。被演算子が型混合である場合、 2 進算術演
     算子での規則が適用されます。通常の整数と長整数の場合、結果は  ``(a
     // b, a % b)`` と同じです。浮動小数点数の場合、結果は ``(q, a %
@@ -369,6 +420,9 @@
     ローバルおよびローカルな辞書を返すので、 :func:`eval` や
     :func:`execfile` で使うことができます。

+   リテラルだけを含む式の文字列を安全に評価できる関数、
+   :func:`ast.literal_eval` も参照してください。
+

  .. function:: execfile(filename[, globals[, locals]])

@@ -622,7 +676,7 @@
  .. function:: issubclass(class, classinfo)

     *class* が *classinfo* の (直接または間接的な) サブクラスである場合
-   に真を返します。クラスはそのクラス自体のサブクラスと *clasinfo* は
+   に真を返します。クラスはそれ自身のサブクラスとみなされます。 *clasinfo*  
は
     クラスオブジェクトからなるタプルでもよく、この場合には *classinfo*
     のすべてのエントリが調べられます。その他の場合では、例外
     :exc:`TypeError` が送出されます。
@@ -733,6 +787,13 @@
        オプションの *key* 引数が追加されました.


+.. function:: memoryview(obj)
+   :noindex:
+
+   与えられたオブジェクトから作られた "メモリビュー" オブジェクトを返しま 
す。
+   詳しくは :ref:`typememoryview` を参照してください。
+
+
  .. function:: min(iterable[, args...][key])

     引数が *iterable* だけの場合、空でないシーケンス (文字列、タプルま
@@ -932,8 +993,8 @@
                del self._x
            x = property(getx, setx, delx, "I'm the 'x' property.")

-   もし *c* が *C* のインスタンスならば、 ``c.x`` は getter を呼び出しま 
す、
-   ``c.x = value`` は setter と ``del c.x`` を呼び出します。
+   もし *c* が *C* のインスタンスならば、 ``c.x`` は getter を呼び出し、
+   ``c.x = value`` は setter を、``del c.x`` は deleter を呼び出します。

     *doc* がもし与えられたならばそれがプロパティ属性のドキュメント文字
     列になります。与えられない場合、プロパティは *fget* のドキュメント
@@ -1156,6 +1217,13 @@
     ``round(0.5)`` は ``1.0`` になり、 ``round(-0.5)`` は ``-1.0`` に
     なります)。

+   .. note::
+
+      浮動小数点数に対する :func:`round` の振る舞いは意外なものかもしれませ 
ん:
+      例えば、``round(2.675, 2)'' は予想通りの ``2.68`` ではなく
+      ``2.67`` を与えます。これはバグではありません: これはほとんどの
+      少数が浮動小数点数で正確に表せないことの結果です。詳しくは
+      :ref:`tut-fp-issues` を参照してください。

  .. function:: set([iterable])
     :noindex:
@@ -1225,9 +1293,9 @@
     一般的に、 *key* および *reverse* の変換プロセスは同等の *cmp* 関数
     を指定するより早く動作します。これは *key* および *reverse* がそれ
     ぞれの要素に一度だけ触れる間に、 *cmp* はリストのそれぞれの要素に対
-   して複数回呼ばれることによるものです。旧式の *cmp* 関数を、 *key*
-   関数に変換する方法は、 `CmpToKey recipe in the ASPN cookbook
-   <http://code.activestate.com/recipes/576653/>`_ を参照下さい。
+   して複数回呼ばれることによるものです。
+   旧式の *cmp* 関数を *key* 関数に変換するに 
は :func:`functools.cmp_to_key`
+   を使用してください。

     並ベ替えの例と簡潔なチュートリアルとして、 `Sorting HowTo
     <http://wiki.python.org/moin/HowTo/Sorting/>`_ を参照して下さい。
@@ -1285,50 +1353,47 @@

  .. function:: sum(iterable[, start])

-   *start* と *iterable* の要素を左から右へ加算してゆき、総和を返しま
+   *start* と *iterable* の要素を左から右へ合計し、総和を返しま
     す。 *start* はデフォルトで ``0`` です。 *iterable* の要素は通常は
-   数値で、文字列であってはなりません。文字列からなるシーケンスを結合
-   する高速かつ正しい方法は ``''.join(sequence)`` です。
-   ``sum(range(n), m)`` は ``reduce(operator.add, range(n), m)`` と同
-   等です。浮動小数点数を拡張精度で加算するには、 :func:`math.fsum` を
-   参照下さい。
-
-   .. versionadded:: 2.3
-
-
-.. function:: super(type[, object-or-type])
-
-   メソッド呼び出しを *type* クラスの親か兄弟クラスに移譲する、プロキシ
-   オブジェクトを返します。これはクラスの中から、オーバーライドされた
-   継承メソッドにアクセスするのに便利です。探索の順序は、 *type* 自身が
-   飛ばされるのを除いて、 :func:`getattr` と同じです。
-
-   *type* の :attr:`__mro__` 属性は、 :func:`getattr` と :func:`super`
-   の両方で使われるメソッド探索順序を格納しています。
-   この属性は動的で、継承の階層構造が更新されれば随時変化します。
-
-   2つめの引数が省略されているとき、返されるスーパーオブジェクトは未束縛で 
す。
-   2つめの引数がオブジェクトであれば、 ``isinstance(obj, type)`` は真に
-   なります。2つめの引数が型であれば、 ``issubclass(type2, type)`` は真に
-   なります。(これはクラスメソッドにとって役に立つでしょう)。
-
-   .. note::
-      :func:`super` は、新スタイルクラス(:term:`new-style class`)でのみ
-      機能します。
-
-   *super* の典型的なユースケースは2種類あります。
-   クラスが単一継承である場合、 *super* は親クラスを、名前を明示することな 
く
-   参照することができます。
-   これはコードのメンテナンス性を向上します。この用途の *super* は他の
-   プログラミング言語で見られるものと同じです。
-
-   2つめの典型的なユースケースは、動的な実行環境下で協調的な多重継承をサ 
ポート
-   するためのものです。この用途は Python 特有のもので、単一の継承しかサポー 
ト
-   しない言語や、静的なコンパイルが必要となる言語では見られないものです。
-   これは "diamond diagrams" において、複数の基底クラスが同じメソッドを実装 
する
-   ことを可能とします。良い設計は、すべてのこのメソッドが同じ呼び出し規約を 
持つ
-   ことを要求します(呼び出しが実行時に決定されることや、クラスの階層の変更 
に
-   対応させることや、実行時に優先される未知の兄弟クラスに対応することのため 
です)。
+   数値で、start の値は文字列であってはなりません。
+
+   使う場面によっては、:func:`sum` よりもいい選択肢があります。
+   文字列からなるシーケンスを結合する高速かつ望ましい方法は
+   ``''.join(sequence)`` を呼ぶことです。浮動小数点数値を
+   拡張された精度で加算するには、
+   :func:`math.fsum` を参照下さい。一連のイテラブルを
+   連結するには、:func:`itertools.chain` の使用を考えてください。
+
+.. function:: super([type[, object-or-type]])
+
+   メソッドの呼び出しを *type* の親または兄弟クラスに委譲する、プロキシオ
+   ブジェクトを返します。これはクラスの中でオーバーライドされた継承メ
+   ソッドにアクセスするのに便利です。探索の順序は、 *type* 自身が飛ば
+   されるのをのぞいて :func:`getattr` と同じです。
+
+   *type* の :attr:`__mro__` 属性は、:func:`getattr` と :func:`super` の
+   両方で使われる、メソッド解決の探索順序を列記します。
+   この属性は動的で、継承の階層構造が更新されれば、随時変化します。
+
+   第 2 引数が省かれたなら、返されるスーパーオブジェクトは
+   束縛されません。第 2 引数がオブジェクトであれば、
+   ``isinstance(obj, type)`` は真でなければなりません。第 2 引数が型であれ 
ば、
+   ``issubclass(type2, type)`` は真でなければなりません
+   (これはクラスメソッドに役に立つでしょう)。
+
+   *super* の典型的な用途は 2 つあります。単一の継承をしている
+   クラス階層構造では、*super* は名前を明示することなく親クラスを参照するの 
に
+   使え、これでコードはメンテナンスしやすくなります。この用途の
+   *super* は他のプログラミング言語で見られるものと近い方向性です。
+
+   2 つ目の用途は、動的な実行環境下での複数の継承の共同をサポートする
+   ことです。この用途は Python 特有で、静的にコンパイルされる
+   言語や、単一の継承しかサポートしない言語では見られないものです。
+   これは複数の基底クラスが同じメソッドを実装する "diamond diagram"
+   を実装できるようにします。良い設計のために、このメソッドがすべての
+   場合に同じ形式で呼び出せるべきです (呼び出しの順序が実行時に
+   決定されることや、順序がクラスの階層の変更に対応することや、
+   その順序には実行時まで未知の兄弟クラスが含まれえることが理由です)。

     両方のケースにおいて、典型的なスーパークラスの呼び出しはこのように
     なるでしょう。 ::
@@ -1487,7 +1552,7 @@
        の "short" 整数型) に制限しており、要素数がネイティブの C long
        型の範囲内に収まるよう要求しています。もし大きな範囲が必要ならば、
        別の実装である :mod:`itertools` モジュールの、
-      ``takewhile(lambda x: x<stop, (start+i*step for i in count()))``
+      ``islice(count(start, step), (stop-start+step-1+2*(step<0))//step)``
        を使うのが巧い方法かも知れません。


=======================================
--- /library/stdtypes.rst	Fri May 13 06:42:55 2011
+++ /library/stdtypes.rst	Sun Nov  6 08:09:46 2011
@@ -23,7 +23,7 @@
  .. index:: statement: print

  演算によっては、複数の型でサポートされているものがあります; 特に、ほぼ
-全てのオブジェクトについて、比較、真値テスト、 (:func:`repr` 関数や、
+全てのオブジェクトについて、比較、真理値テスト、 (:func:`repr` 関数や、
  わずかに異なる :func:`str` 関数による) 文字列への変換を行うことができ
  ます。オブジェクトが :func:`print` 関数によって書かれていると、後の方の
  文字列への変換が暗黙に行われます。
@@ -31,8 +31,8 @@

  .. _truth:

-真値テスト
-==========
+真理値テスト
+============

  .. index::
     statement: if
@@ -42,7 +42,7 @@
     single: false

  どのオブジェクトも :keyword:`if` または :keyword:`while` 条件文の中や、
-以下のブール演算における被演算子として真値テストを行うことができます。
+以下のブール演算における被演算子として真理値テストを行うことができます。
  以下の値は偽であると見なされます:

    .. index:: single: None (Built-in object)
@@ -90,16 +90,16 @@

  以下にブール演算子を示します。優先度の低いものから順に並んでいます。:

-+-------------+----------------------------------------+------+
+-------------+----------------------------------------+------+
  | 演算        | 結果                                   | 注釈 |
-+=============+========================================+======+
+=============+========================================+======+
  | ``x or y``  | *x* が偽なら *y*, そうでなければ *x*   | \(1) |
-+-------------+----------------------------------------+------+
+-------------+----------------------------------------+------+
  | ``x and y`` | *x* が偽なら *x*, そうでなければ *y*   | \(2) |
-+-------------+----------------------------------------+------+
+-------------+----------------------------------------+------+
  | ``not x``   | *x* が偽なら ``True``, そうでなければ  | \(3) |
  |             | ``False``                              |      |
-+-------------+----------------------------------------+------+
+-------------+----------------------------------------+------+

  .. index::
     operator: and
@@ -142,38 +142,31 @@
  比較演算は全てのオブジェクトでサポートされています。比較演算子は全て
  同じ演算優先度を持っています (ブール演算より高い演算優先度です)。
  比較は任意の形で連鎖させることができます; 例えば、 ``x < y <= z`` は
-``x < y および  y <= z`` と等価で、違うのは *y* が一度だけしか評価され
+``x < y and y <= z`` と等価で、違うのは *y* が一度だけしか評価され
  ないということです (どちらの場合でも、 ``x < y`` が偽となった場合には
  *z* は評価されません)。

  以下のテーブルに比較演算をまとめます:

-+------------+--------------------------+------+
-| 演算       | 意味                     | 注釈 |
-+============+==========================+======+
-| ``<``      | より小さい               |      |
-+------------+--------------------------+------+
-| ``<=``     | 以下                     |      |
-+------------+--------------------------+------+
-| ``>``      | より大きい               |      |
-+------------+--------------------------+------+
-| ``>=``     | 以上                     |      |
-+------------+--------------------------+------+
-| ``==``     | 等しい                   |      |
-+------------+--------------------------+------+
-| ``!=``     | 等しくない               | \(1) |
-+------------+--------------------------+------+
-| ``is``     | 同一のオブジェクトである |      |
-+------------+--------------------------+------+
-| ``is not`` | 同一のオブジェクトでない |      |
-+------------+--------------------------+------+
-
-注釈:
-
-(1)
-   ``!=`` は ``<>`` のように書くこともできますが、これは後方互換のため
-   に残された古い書き方です。新しいコードでは常に ``!=`` を使うべきで
-   す。
++------------+--------------------------+
+| 演算       | 意味                     |
++============+==========================+
+| ``<``      | より小さい               |
++------------+--------------------------+
+| ``<=``     | 以下                     |
++------------+--------------------------+
+| ``>``      | より大きい               |
++------------+--------------------------+
+| ``>=``     | 以上                     |
++------------+--------------------------+
+| ``==``     | 等しい                   |
++------------+--------------------------+
+| ``!=``     | 等しくない               |
++------------+--------------------------+
+| ``is``     | 同一のオブジェクトである |
++------------+--------------------------+
+| ``is not`` | 同一のオブジェクトでない |
++------------+--------------------------+

  .. index::
     pair: object; numeric
@@ -231,13 +224,16 @@
  :dfn:`整数型` とも呼ばれます) は C言語の :c:type:`long` 型を使って実装され
  ており、少なくとも 32 ビットの精度があります (``sys.maxint`` は常に通
  常の整数の各プラットフォームにおける最大値にセットされており、最小値は
-``-sys.maxint - 1`` になります)。長整数型には桁数の制限がありません。
-浮動小数点型は C言語の :c:type:`double` 型を使って実装されています。
-浮動小数点型の精度は利用しているコンピュータによって異なります。
-
-複素数型は実数部と虚数部を持ち、それぞれの C では :c:type:`double` を使っ
-て実装されています。複素数 *z* から実数および虚数部を取り出すには、
-``z.real`` および ``z.imag`` を使います。
+``-sys.maxint - 1`` になります)。
+長整数型には精度の制限がありません。
+浮動小数点型はたいていは C の :c:type:`double` を使って実装されています;
+あなたのプログラムが動作するマシンでの浮動小数点型の精度と内部表現は、
+:data:`sys.float_info` から利用できます。
+複素数型は実部と虚部を持ち、それぞれ浮動小数点数です。
+複素数 *z* から実部および虚部を取り出すには、
+``z.real`` および ``z.imag`` を使ってください。
+(標準ライブラリには、追加の数値型、分数を保持する :mod:`fractions` や、
+ユーザ定義の精度の浮動小数点数を保持する :mod:`decimal` があります。)

  .. index::
     pair: numeric; literals
@@ -360,7 +356,10 @@
     複素数の切り詰め除算演算子、モジュロ演算子、および :func:`divmod` 。

     .. deprecated:: 2.3
-      適切であれば、 :func:`abs` を使って浮動小数点に変換してください。
+      複素数の切り詰め除算演算子、モジュロ演算子、および :func:`divmod`
+      関数は、複素数には定義されなくなりました。
+      複素数型には使えません。適切なら代わりに :func:`abs` で浮動小数点型に
+      変換してください。

  (5)
     整数の除算とも呼ばれます。結果の値は整数ですが、整数型(int)とは限りませ 
ん。
@@ -379,19 +378,19 @@
  全ての :class:`numbers.Real` 型 (:class:`int`, :class:`long`,およ
  び、 :class:`float`) は以下の演算を含みます。 :

-+--------------------+------------------------------------------------+--------+
+--------------------+------------------------------------------------+--------+
  | 演算               | 結果                                           | 備 
考   |
-+====================+================================================+========+
+====================+================================================+========+
  | ``math.trunc(x)``  | *x* 整数に切り捨てます。                        
|        |
-+--------------------+------------------------------------------------+--------+
+--------------------+------------------------------------------------+--------+
  | ``round(x[, n])``  | *x* n 桁に丸めます。                            
|        |
  |                    | 丸め方は偶数丸めです。                          
|        |
  |                    | n が省略されれば 0 がデフォルトとなります。     
|        |
-+--------------------+------------------------------------------------+--------+
+--------------------+------------------------------------------------+--------+
  | ``math.floor(x)``  | *x* 以下の最大の整数を浮動少数点数で返します。  
|        |
-+--------------------+------------------------------------------------+--------+
+--------------------+------------------------------------------------+--------+
  | ``math.ceil(x)``   | *x* 以上の最小の整数を浮動小数点数で返します。  
|        |
-+--------------------+------------------------------------------------+--------+
+--------------------+------------------------------------------------+--------+

  .. XXXJH exceptions: overflow (when? what operations?) zerodivision

@@ -452,18 +451,66 @@
     *n* ビットの右シフトは、 ``pow(2, n)`` による除算と等価です。


+Additional Methods on Integer Types
+-----------------------------------
+
+整数型は :class:`numbers.Integral`  :term:`abstract base class` を実装しま 
す。
+さらに、追加のメソッドを一つ提供します。
+
+.. method:: int.bit_length()
+.. method:: long.bit_length()
+
+    整数を、符号と先頭の 0 は除いて二進法で表すために
+    必要なビットの数を返します::
+
+        >>> n = -37
+        >>> bin(n)
+        '-0b100101'
+        >>> n.bit_length()
+        6
+
+    正確には、 ``x`` が非 0 なら、``x.bit_length()`` は
+    ``2**(k-1) <= abs(x) < 2**k`` を満たす唯一の正の整数 ``k`` です。
+    同様に、``abs(x)`` が十分小さくて対数を適切に丸められるとき、
+    ``k = 1 + int(log(abs(x), 2))`` です。
+    ``x`` が 0 なら、``x.bit_length()`` は ``0`` を返します。
+
+    以下と等価です::
+
+        def bit_length(self):
+            s = bin(self)       # binary representation:  bin(-37)  
--> '-0b100101'
+            s = s.lstrip('-0b') # remove leading zeros and minus sign
+            return len(s)       # len('100101') --> 6
+
+    .. versionadded:: 2.7
+
+
  浮動小数点数に対する追加のメソッド
  ----------------------------------

-浮動小数点数型は、いくつか追加のメソッドを持ちます。
+浮動小数点数型は、:class:`numbers.Real` 抽象基底クラス
+(:term:`abstract base class`)
+を実装しています。浮動小数点型はまた、以下の追加のメソッドを持ちます。

  .. method:: float.as_integer_ratio()

-    比が元の浮動小数点数と同じになる、一対の整数を返します。分母が正の
-    数になります。無限大に対しては、 :exc:`OverflowError` を送出し、非
-    数(NaN)に対しては :exc:`ValueError` を送出します。
-
-    .. versionadded:: 2.6
+   比が元の浮動小数点数とちょうど同じで分母が正である、一対の整数を返しま 
す。
+   無限大に対しては、 :exc:`OverflowError` を、非
+   数 (NaN) に対しては :exc:`ValueError` を送出します。
+
+   .. versionadded:: 2.6
+
+.. method:: float.is_integer()
+
+   浮動小数点数インスタンスが有限の整数値なら ``True`` を、
+   そうでなければ ``False`` を返します::
+
+      >>> (-2.0).is_integer()
+      True
+      >>> (3.2).is_integer()
+      False
+
+   .. versionadded:: 2.6

  16 進表記の文字列へ、または、 16 進表記からの変換をサポートするメ
  ソッドは二つあります。 Python の浮動小数点数は内部的には2進数で保持さ
@@ -603,11 +650,16 @@

  .. _typesseq:

-シーケンス 
型 :class:`str`, :class:`unicode`, :class:`list`, :class:`tuple`, :class:`buffer`, :class:`xrange`
-============================================================================================================
-
-組み込み型には 6 つのシーケンス型があります: 文字列、ユニコード文字列、
-リスト、タプル、バッファ、そして xrange オブジェクトです。
+Sequence Types  
--- :class:`str`, :class:`unicode`, :class:`list`, :class:`tuple`, :class:`bytearray`, :class:`buffer`, :class:`xrange`
+======================================================================================================================================
+シーケンス型  
--- :class:`str`, :class:`unicode`, :class:`list`, :class:`tuple`, :class:`bytearray`, :class:`buffer`, :class:`xrange`
+====================================================================================================================================
+
+There are seven sequence types: strings, Unicode strings, lists, tuples,
+bytearrays, buffers, and xrange objects.
+シーケンス型には 7 つあります: 文字列、Unicode 文字列、リスト、タプル、
+、バイト配列 (bytearray)、バッファ、
+そして xrange オブジェクトです。

  他のコンテナ型については、組み込みクラスの :class:`dict` および
  :class:`set` を参照下さい。
@@ -618,6 +670,7 @@
     object: Unicode
     object: tuple
     object: list
+   object: bytearray
     object: buffer
     object: xrange

@@ -633,6 +686,8 @@
  タプルでは、例えば ``(d,)`` のように、要素の後ろにコンマをつけなけれ
  ばなりません。

+バイト配列は、組み込み関数 :func:`bytearray` で構成されます。
+
  バッファオブジェクトは Python の構文上では直接サポートされていませんが、
  組み込み関数 :func:`buffer` で生成することができます。バッファオブジェ
  クトは結合や反復をサポートしていません。
@@ -678,6 +733,10 @@
   
+------------------+---------------------------------------------+----------+
  | ``max(s)``       | *s* の最大の要素                             
|          |
   
+------------------+---------------------------------------------+----------+
+| ``s.index(i)``   | *s* 中で最初に *i* が現れる場所のインデクス  
|          |
++------------------+---------------------------------------------+----------+
+| ``s.count(i)``   | *s* 中に *i* が現れる数                      
|          |
++------------------+---------------------------------------------+----------+

  シーケンス型は比較演算子もサポートします。特にタプルとリストは相当する
  要素による辞書編集方式的に比較されます。つまり、等しいということは、ふ
@@ -784,8 +843,9 @@

  .. index:: pair: string; methods

-以下は 8 ビット文字列および Unicode オブジェクトでサポートされるメソッ
-ドです。これらのメソッドはキーワード引数をとらないことに注意して下さい。
+Below ar8-bit 文字列と Unicode オブジェクトは、どちらも以下に挙げるメソッド 
に
+対応しています。この中には、:class:`bytearray` オブジェクトで使えるものも
+あります。

  さらに、 Python の文字列は :ref:`typesseq` に記載されるシーケンス型の
  メソッドもサポートします。
@@ -833,6 +893,8 @@
     .. versionchanged:: 2.3
        その他のエラーハンドリングスキーマがサポートされました.

+   .. versionchanged:: 2.7
+      Support for keyword arguments added.

  .. method:: str.encode([encoding[,errors]])

@@ -881,6 +943,14 @@
     ス表記と同様に解釈されます。 *sub* が見つからなかった場合 ``-1``
     を返します。

+   .. note::
+
+      :meth:`~str.find` メソッドは、*sub* の位置を知りたいときにのみ
+      使うべきです。*sub* が部分文字列であるかどうかのみを調べるには、
+      :keyword:`in` 演算子を使ってください::
+
+         >>> 'Py' in 'Python'
+         True

  .. method:: str.format(*args, **kwargs)

@@ -1310,8 +1380,8 @@
  字 ``'%'`` の直後にくるようにしたものが含まれていなければ *なりません*
  。マップキーはフォーマット化したい値をマップから選び出します。例えば:

-   >>> print '%(language)s has %(#)03d quote types.' % \
-   ...       {'language': "Python", "#": 2}
+   >>> print '%(language)s has %(number)03d quote types.' % \
+   ...       {"language": "Python", "number": 2}
     Python has 002 quote types.

  この場合、 ``*`` 指定子をフォーマットに含めてはいけません (``*`` 指定
@@ -1425,16 +1495,15 @@

  .. XXX Examples?

-
-安全上の理由から、浮動小数点数の精度は 50 桁でクリップされます;  絶対
-値が 1e50 を超える値の ``%f`` による変換は ``%g`` 変換で置換されます
-[#]_ その他のエラーは例外を送出します。
+.. versionchanged:: 2.7
+   絶対値が 1e50 を超える数の ``%f`` 変換は、``%g`` による変換に
+   置き換えられなくなりました。

  .. index::
     module: string
     module: re

-その他の文字列操作は標準モジュール :mod:`string`  および :mod:`re`. で
+その他の文字列操作は標準モジュール :mod:`string`  および :mod:`re` で
  定義されています。


@@ -1464,12 +1533,31 @@
     triple: mutable; sequence; types
     object: list

-リストオブジェクトはオブジェクト自体の変更を可能にする追加の操作をサポー
-トします。他の変更可能なシーケンス型 (を言語に追加する場合) も、それら
-の操作をサポートしなければなりません。文字列およびタプルは変更不可能な
-シーケンス型です: これらのオブジェクトは一度生成されたらそのオブジェク
-ト自体を変更することができません。以下の操作は変更可能なシーケンス型で
-定義されています (ここで *x* は任意のオブジェクトとします):
+リストとバイト配列 (:class:`bytearray`) オブジェクトは、
+オブジェクトをインプレースに変更できるように
+する追加の操作をサポートします。他のミュータブルなシーケンス型
+(を言語に追加するとき) も、それらの操作をサポートするべきです。
+文字列およびタプルはイミュータブルなシーケンス型です:
+これらのオブジェクトは一度生成されたら変更できません。
+ミュータブルなシーケンス型では以下の操作が定義されています
+(ここで *x* は任意のオブジェクトとします)。
+
+.. index::
+   triple: operations on; sequence; types
+   triple: operations on; list; type
+   pair: subscript; assignment
+   pair: slice; assignment
+   pair: extended slice; assignment
+   statement: del
+   single: append() (list method)
+   single: extend() (list method)
+   single: count() (list method)
+   single: index() (list method)
+   single: insert() (list method)
+   single: pop() (list method)
+   single: remove() (list method)
+   single: reverse() (list method)
+   single: sort() (list method)

   
+------------------------------+--------------------------------------------+---------------------+
  | 操作                         | 結 
果                                       | 注釈                |
@@ -1509,23 +1597,6 @@
  | reverse]]])``                 
|                                            |                     |
   
+------------------------------+--------------------------------------------+---------------------+

-.. index::
-   triple: operations on; sequence; types
-   triple: operations on; list; type
-   pair: subscript; assignment
-   pair: slice; assignment
-   pair: extended slice; assignment
-   statement: del
-   single: append() (list method)
-   single: extend() (list method)
-   single: count() (list method)
-   single: index() (list method)
-   single: insert() (list method)
-   single: pop() (list method)
-   single: remove() (list method)
-   single: reverse() (list method)
-   single: sort() (list method)
-
  Notes:

  (1)
@@ -1590,6 +1661,8 @@
     を指定するより早く動作します。これは *key* および *reverse* がそれ
     ぞれの要素に一度だけ触れる間に、 *cmp* はリストのそれぞれの要素に対
     して複数回呼ばれることによるものです。
+   旧式の *cmp* 関数を *key* 関数に変換するに 
は :func:`functools.cmp_to_key`
+   を使用してください。

     .. versionchanged:: 2.3
        ``None`` を渡すのと、 *cmp* を省略した場合とで、同等に扱うサポートを 
追加.
@@ -1641,9 +1714,13 @@
  ります。 :class:`set` は変更可能な --- :meth:`add` や :meth:`remove`
  のようなメソッドを使って内容を変更できます。変更可能なため、ハッシュ値
  を持たず、また辞書のキーや他のsetの要素として用いることができません。
-:class:`frozenset` 型は変更不能であり、ハッシュ化可能で --- 一度作成さ
-れると内容を改変することができません。そのため辞書のキーや他のsetの要素
-として用いることができます。
+:class:`frozenset` 型はイミュータブルで、ハッシュ化可能
+(:term:`hashable`) です --- 作成後に内容を改変できません。
+そのため、辞書のキーや他の集合の要素として使えます。
+
+Python 2.7 では、空でない set (frozenset ではない) は、:class:`set`
+コンストラクタに加え、要素を波カッコ中にカンマで区切って
+列挙することでも生成できます。例: ``{'jack', 'sjoerd'}``。

  両方のクラスのコンストラクタの働きは同じです:

@@ -1897,16 +1974,13 @@
     キーワード引数が与えられた場合、キーワード自身がその値として辞書型
     に加えられます。もしキーがポジション引数において、キーワード引数を
     規定した場合、キーワードに値が割り当てられ辞書に追加されます。例え
-   ば以下は全て ``{"one": 2, "two": 3}`` と等しい辞書型インスタンスを
+   ば以下は全て ``{"one": 1, "two": 2}`` と等しい辞書型インスタンスを
     返します :

-   * ``dict(one=2, two=3)``
-
-   * ``dict({'one': 2, 'two': 3})``
-
-   * ``dict(zip(('one', 'two'), (2, 3)))``
-
-   * ``dict([['two', 3], ['one', 2]])``
+   * ``dict(one=1, two=2)``
+   * ``dict({'one': 1, 'two': 2})``
+   * ``dict(zip(('one', 'two'), (1, 2)))``
+   * ``dict([['two', 2], ['one', 1]])``

     最初の例では、 Python の識別子として有効なキーに対してのみ機能しま
     す ; 他の例はキーとして有効なものであればいかなるキーに対しても機能
@@ -2091,6 +2165,123 @@

        辞書の値のリストのコピーを返します。 :meth:`dict.items` の Note
        も参照下さい。
+
+   .. method:: viewitems()
+
+      辞書の要素 (``(key, value)`` の対) の新しいビューを返します。
+      ビューオブジェクトのドキュメントは下を参照してください。
+
+      .. versionadded:: 2.7
+
+   .. method:: viewkeys()
+
+      辞書のキーの新しいビューを返します。
+      ビューオブジェクトのドキュメントは下を参照してください。
+
+      .. versionadded:: 2.7
+
+   .. method:: viewvalues()
+
+      辞書の値の新しいビューを返します。
+      ビューオブジェクトのドキュメントは下を参照してください。
+
+      .. versionadded:: 2.7
+
+
+.. _dict-views:
+
+辞書ビューオブジェクト
+----------------------
+
+:meth:`dict.keys`、:meth:`dict.values`、:meth:`dict.items` によって
+返されるオブジェクトは、*ビューオブジェクト* です。これらは、辞書の項目の
+動的なビューを提供し、辞書が変更された時、ビューはその変更を反映します。
+
+辞書ビューを通して反復することで、対応するデータを産出できます。
+また、帰属検査をサポートしています。
+
+.. describe:: len(dictview)
+
+   辞書の項目数を返します。
+
+.. describe:: iter(dictview)
+
+   辞書のキー、値、または (``(key, value)`` のタプルとして表される) 要素に
+   渡るイテレータを返します。
+
+   キーと値のリストは任意の順序で反復されますが、ランダムではなく、
+   Python の実装によって変わり、辞書への挿入や削除の履歴に依存します。
+   キー、値、要素のビューを通して、辞書の変更を挟まずにイテレート
+   されたら、その要素の順序は完全に一致します。
+   これにより、 ``(value, key)`` の対を
+   :func:`zip` で作成できます: ``pairs = zip(d.values(), d.keys())``。
+   同じリストを作成する他の方法は、
+   ``pairs = [(v, k) for (k, v) in d.items()]`` です。
+
+   辞書の項目の追加や削除中にビューをイテレートすると、:exc:`RuntimeError`
+   を送出したり、すべての項目に渡ってイテレートできなかったりします。
+
+.. describe:: x in dictview
+
+   *x* が下にある辞書のキー、値、または要素 (要素の場合、*x* は
+   ``(key, value)`` タプルであるべきです) にあるとき ``True`` を返します。
+
+
+キーのビューは、項目が一意的でハッシュ可能であるという点で、集合に似ていま 
す。
+すべての値がハッシュ可能なら、``(key, value)`` の対も一意的で
+ハッシュ可能であり、要素のビューも集合に似ています。(値のビューは、
+要素が一般に一意的でないことから、集合に似ているとは考えられません。)
+ですから、これらの集合演算が利用できます。
+("other" は別のビューか集合です):
+
+.. describe:: dictview & other
+
+   辞書ビューと別のオブジェクトの共通部分を新しい集合として返します。
+
+.. describe:: dictview | other
+
+   辞書ビューと別のオブジェクトの合併集合を新しい集合として返します。
+
+.. describe:: dictview - other
+
+   辞書ビューと別のオブジェクトの差集合 (*dictview* に属して *other* に
+   属さないすべての要素) を新しい集合として返します。
+
+.. describe:: dictview ^ other
+
+   辞書ビューと別のオブジェクトの対称差 (*dictview* と *other* のどちらかに
+   属すが両方には属さないすべての要素) を新しい集合として返します。
+
+
+辞書ビューの使用法の例::
+
+   >>> dishes = {'eggs': 2, 'sausage': 1, 'bacon': 1, 'spam': 500}
+   >>> keys = dishes.viewkeys()
+   >>> values = dishes.viewvalues()
+
+   >>> # iteration
+   >>> n = 0
+   >>> for val in values:
+   ...     n += val
+   >>> print(n)
+   504
+
+   >>> # keys and values are iterated over in the same order
+   >>> list(keys)
+   ['eggs', 'bacon', 'sausage', 'spam']
+   >>> list(values)
+   [2, 1, 1, 500]
+
+   >>> # view objects are dynamic and reflect dict changes
+   >>> del dishes['eggs']
+   >>> del dishes['sausage']
+   >>> list(keys)
+   ['spam', 'bacon']
+
+   >>> # set operations
+   >>> keys & {'eggs', 'bacon', 'salad'}
+   {'bacon'}
+


  .. _bltin-file-objects:
@@ -2238,13 +2429,12 @@

  .. method:: file.readline([size])

-   ファイルから一行を読み出します。末尾の改行文字は文字列中に残されま
-   す(ですが、ファイルが不完全な行で終わっている場合は何も残らないか
-   もしれません)。
-   [#]_ 引数 *size* が指定されていて負数でない場合、 (末尾の改行を含め
-   て) 読み込む最大のバイト数です。この場合、不完全な行が返されるかも
-   しれません。空文字列が返されるのは、直後に EOF に到達した場合 *だけ*
-   です。
+   ファイルから一行全部を読み込みます。終末の改行文字は文字列に残ります
+   (しかし、ファイルが不完全な行で終わっていたら、存在しないかもしれません 
)。[#]_
+   *size* 引数が与えられ、負でなければ、それが (終末の改行文字を含む)
+   最大バイト数となり、不完全な行でも返されます。*size* が 0 でなければ、
+   空の文字列が返されるのは、即座に EOF に到達したとき *だけ* です。
+

     .. note::

@@ -2392,15 +2582,14 @@

  .. attribute:: file.newlines

-   Python をビルドするとき、 :option:`--with-universal-newlines` オプ
-   ションが :program:`configure` に指定された場合 (デフォルト)、この読
-   み出し専用の属性が存在します。一般的な改行に変換する読み出しモード
-   で開かれたファイルにおいて、この属性はファイルの読み出し中に遭遇し
-   た改行コードを追跡します。取り得る値は ``'\r'``, ``'\n'``,
-   ``'\r\n'``, ``None``  (不明または、まだ改行していない)、見つかった
-   全ての改行文字を含むタプルのいずれかです。最後のタプルは、複数の改
-   行慣例に遭遇したことを示します。一般的な改行文字を使う読み出しモー
-   ドで開かれていないファイルの場合、この属性の値は ``None`` です。
+   Python がユニバーサル改行モードを (デフォルトどおり) 有効にして
+   ビルドされているなら、この読み込み専用属性が存在し、ファイルが
+   ユニバーサル改行モードで開かれたファイルで、ファイルの読み込み中に
+   あった改行の種類を記録します。取り得る値は、``'\r'``, ``'\n'``,  
``'\r\n'``,
+   ``None`` (不明であるか、まだ改行を読み込んでいない)、または、複数の
+   改行方式の種類が存在したことを表す、見つかったすべての改行の種類を含む
+   タプルです。ユニバーサル改行モードで開かれたのでないファイルに対しては、
+   この属性の値は ``None`` になります。


  .. attribute:: file.softspace
@@ -2421,6 +2610,119 @@
        はできません。


+.. _typememoryview:
+
+メモリビュー型
+==============
+
+:class:`memoryview` オブジェクトは、Python コードが
+バッファプロトコルをコピーすることなく
+対応しているオブジェクトの内部データにアクセス出来るようにします。
+メモリは通常、単純なバイト列として解釈されます。
+
+.. class:: memoryview(obj)
+
+   *obj* を参照する :class:`memoryview` を作成します。*obj* は
+   バッファプロトコルをサポートしていなければなりません。
+   バッファプロトコルをサポートする組み込みオブジェクトには、
+   :class:`str` 、:class:`bytearray` などがあります
+   (ただし、 :class:`unicode` は違います)。
+
+   :class:`memoryview` には *要素* の概念があり、それが起源のオブジェクト
+   *obj* によって扱われる原子的なメモリの単位になります。
+   多くの単純なオブジェクト、例えば :class:`str` や :class:`bytearray` で 
は、
+   要素は単バイトになりますが、他のサードパーティの型では、
+   要素はより大きくなりえます。
+
+   ``len(view)`` は、メモリビュー *view* の要素の総数を返します。
+   :class:`~memoryview.itemsize` 属性は、一つの要素内のバイト数を与えます。
+
+   :class:`memoryview` はスライスしてデータを晒すことに対応しています。
+   一つのインデクスを取ると、一つの要素を :class:`str` オブジェクトとして
+   返します。完全なスライシングは部分ビューになります::
+
+      >>> v = memoryview('abcefg')
+      >>> v[1]
+      'b'
+      >>> v[-1]
+      'g'
+      >>> v[1:4]
+      <memory at 0x77ab28>
+      >>> v[1:4].tobytes()
+      'bce'
+
+   メモリビューが基にしているオブジェクトがデータの変更に対応していれば、
+   メモリビューはスライス代入に対応します::
+
+      >>> data = bytearray('abcefg')
+      >>> v = memoryview(data)
+      >>> v.readonly
+      False
+      >>> v[0] = 'z'
+      >>> data
+      bytearray(b'zbcefg')
+      >>> v[1:4] = '123'
+      >>> data
+      bytearray(b'z123fg')
+      >>> v[2] = 'spam'
+      Traceback (most recent call last):
+        File "<stdin>", line 1, in <module>
+      ValueError: cannot modify size of memoryview object
+
+   この通り、メモリビューオブジェクトの長さは変えられません。
+
+   :class:`memoryview` には 2 つのメソッドがあります。
+
+   .. method:: tobytes()
+
+      バッファ中のデータをバイト文字列 (クラス :class:`str` のオブジェクト)
+      として返します::
+
+         >>> m = memoryview("abc")
+         >>> m.tobytes()
+         'abc'
+
+   .. method:: tolist()
+
+      バッファ中のデータを整数のリストとして返します::
+
+         >>> memoryview("abc").tolist()
+         [97, 98, 99]
+
+   読み込み専用の属性もいくつか使えます:
+
+   .. attribute:: format
+
+      ビューのそれぞれの要素に対する、(:mod:`struct` モジュールのスタイルで 
の)
+      フォーマットを含む文字列です。
+      デフォルトは ``'B'`` で、単純なバイト文字列です。
+
+   .. attribute:: itemsize
+
+      メモリビューのそれぞれの要素のバイト数です。
+
+   .. attribute:: shape
+
+      メモリの形状を N 次元配列として与える、長さ :attr:`ndim` の整数の
+      タプルです。
+
+   .. attribute:: ndim
+
+      メモリが表す多次元配列が何次元かを示す整数です。
+
+   .. attribute:: strides
+
+      配列のそれぞれの次元に対して、それぞれの要素にアクセスするのに必要な
+      バイト数を表す、長さ :attr:`ndim` の整数のタプルです。
+
+   .. attribute:: readonly
+
+      メモリが読み込み専用かを表すブールです。
+
+   .. memoryview.suboffsets は C にしか役立たなさそうなので、
+      ドキュメント化されていません。
+
+
  .. _typecontextmanager:

  コンテキストマネージャ型
@@ -2682,7 +2984,7 @@
  数値処理のコンテキスト (例えば算術演算子の引数として使われた場合) では、
  これらはそれぞれ 0 および 1 と同様に振舞います。
  任意の値に対して真偽値を変換できる場合、組み込み関数 :func:`bool` は値
-をブール値にキャストするのに使われます (真値テストの節を参照してくださ
+をブール値にキャストするのに使われます (真理値テストの節を参照してくださ
  い) 。

  .. index::
@@ -2788,11 +3090,6 @@
     たいタプルを唯一の要素とする単一のタプルを *values* に与えなくては
     なりません。

-.. [#] この範囲に関する値はかなり適当なものです。この仕様は、正しい使
-   い方では障害とならず、かつ特定のマシンにおける浮動小数点数の正確な
-   精度を知らなくても、際限なく長くて意味のない数字からなる文字列を印
-   字しないですむようにするためのものです。
-
  .. [#] 改行を残す利点は、空の文字列が返ると EOF を示し、紛らわしくなく
     なるからです。また、ファイルの最後の行が改行で終わっているかそうで
     ない (ありえることです!) か (例えば、ファイルを行単位で読みながらそ

==============================================================================
Revision: 67214ab13c06
Author:   Arihiro TAKASE <hinac****@gmail*****>
Date:     Sun Nov  6 08:20:24 2011
Log:      merge
http://code.google.com/p/python-doc-ja/source/detail?r=67214ab13c06




Pythonjp-checkins メーリングリストの案内
アーカイブの一覧に戻る