[Pythonjp-checkins] [python-doc-ja] push by songo****@gmail***** - レビュー: tutorial/datastructures.rst on 2011-03-05 02:30 GMT

アーカイブの一覧に戻る

pytho****@googl***** pytho****@googl*****
2011年 3月 5日 (土) 11:30:27 JST


Revision: 276aa2f47c
Author: INADA Naoki  <inada****@klab*****>
Date: Fri Mar  4 18:29:13 2011
Log: レビュー: tutorial/datastructures.rst
http://code.google.com/p/python-doc-ja/source/detail?r=276aa2f47c

Modified:
  /tutorial/datastructures.rst

=======================================
--- /tutorial/datastructures.rst	Sat Feb 26 03:11:54 2011
+++ /tutorial/datastructures.rst	Fri Mar  4 18:29:13 2011
@@ -4,7 +4,8 @@
  データ構造
  **********

-この章では、すでに学んだことについてより詳しく説明するとともに、いくつか新 
しいことを追加します。
+この章では、すでに学んだことについてより詳しく説明するとともに、いくつか
+新しいことを追加します。


  .. _tut-morelists:
@@ -12,7 +13,8 @@
  リスト型についてもう少し
  ========================

-リストデータ型には、他にもいくつかメソッドがあります。リストオブジェクトの 
すべてのメソッドを以下に示します:
+リストデータ型には、他にもいくつかメソッドがあります。リストオブジェクトの
+すべてのメソッドを以下に示します。

  .. method:: list.append(x)
     :noindex:
@@ -22,27 +24,33 @@
  .. method:: list.extend(L)
     :noindex:

-   指定したリスト中のすべての要素を対象のリストに追加し、リストを拡張しま 
す。 ``a[len(a):] = L`` と等価です。
+   指定したリスト中のすべての要素を対象のリストに追加し、リストを拡張しま 
す。
+   ``a[len(a):] = L`` と等価です。

  .. method:: list.insert(i, x)
     :noindex:

-   指定した位置に要素を挿入します。第 1 引数は、リストのインデクスで、その 
インデクスを持つ要素の直前に挿入が行われます。従って、
+   指定した位置に要素を挿入します。第 1 引数は、リストのインデクスで、
+   そのインデクスを持つ要素の直前に挿入が行われます。従って、
     ``a.insert(0, x)`` はリストの先頭に挿入を行います。
     また ``a.insert(len(a), x)`` は ``a.append(x)`` と等価です。

  .. method:: list.remove(x)
     :noindex:

-   リスト中で、値 *x* を持つ最初の要素を削除します。該当する項目がなければ 
エラーとなります。
+   リスト中で、値 *x* を持つ最初の要素を削除します。該当する項目がなければ
+   エラーとなります。

  .. method:: list.pop([i])
     :noindex:

-   リスト中の指定された位置にある要素をリストから削除して、その要素を返しま 
す。インデクスが指定されなければ、
-   ``a.pop()`` はリストの末尾の要素を削除して、返します。
-   この場合も要素は削除されます。 (メソッドの用法 (signature) で *i* の両側 
にある角括弧は、
-   この引数がオプションであることを表しているだけなので、角括弧を入力する必 
要はありません。この表記法は Python Library Reference の中で頻繁に見ることに 
なるでしょう。)
+   リスト中の指定された位置にある要素をリストから削除して、その要素を返しま 
す。
+   インデクスが指定されなければ、 ``a.pop()`` はリストの末尾の要素を削除し 
て
+   返します。
+   この場合も要素は削除されます。 (メソッドの用法 (signature) で *i* の
+   両側にある角括弧は、この引数がオプションであることを表しているだけなの 
で、
+   角括弧を入力する必要はありません。この表記法は Python Library Reference
+   の中で頻繁に見ることになるでしょう。)

  .. method:: list.index(x)
     :noindex:
@@ -65,7 +73,7 @@

     リストの要素を、インプレース演算で逆順にします。

-以下にリストのメソッドをほぼ全て使った例を示します:
+以下にリストのメソッドをほぼ全て使った例を示します。

  ::

@@ -96,9 +104,11 @@

  .. sectionauthor:: Ka-Ping Yee <ping****@lfw*****>

-リスト型のメソッドのおかげで、簡単にリストをスタックとして使えます。スタッ 
クでは、最後に追加された要素が最初に取り出されます ("last-in,
-first-out") 。スタックの一番上に要素を追加するには :meth:`append` を使いま 
す。スタックの一番上から要素を取り出すには
-:meth:`pop` をインデクスを指定せずに使います。例えば以下のようにします。
+リスト型のメソッドのおかげで、簡単にリストをスタックとして使えます。
+スタックでは、最後に追加された要素が最初に取り出されます ("last-in,  
first-out")。
+スタックの一番上に要素を追加するには :meth:`append` を使います。
+スタックの一番上から要素を取り出すには :meth:`pop` をインデクスを
+指定せずに使います。例えば以下のようにします。

  ::

@@ -126,7 +136,7 @@

  .. sectionauthor:: Ka-Ping Yee <ping****@lfw*****>

-ひとつの可能性として、リストをキュー (queue) として使うこともありえます。
+リストをキュー (queue) として使うことも可能です。
  この場合、最初に追加した要素を最初に取り出します ("first-in, first-out")。
  しかし、リストでは効率的にこの目的を達成することが出来ません。
  追加(append)や取り出し(pop)をリストの末尾に対しておこなうと速いのです 
が、
@@ -134,7 +144,8 @@
  (他の要素をひとつずつずらす必要があるからです)。

  キューの実装には、 :class:`collections.deque` を使うと良いでしょう。
-このクラスは良く設計されていて、高速な追加(append)と取り出し(pop)を両端 
に対して実現しています。例えば以下のようにします。
+このクラスは良く設計されていて、高速な追加(append)と取り出し(pop)を
+両端に対して実現しています。例えば以下のようにします。

  ::

@@ -152,14 +163,16 @@

  .. _tut-functional:

-実用的なプログラミングツール
+関数型のプログラミングツール
  ----------------------------

-組み込み関数には、リストで使うと非常に便利なものが三つありま 
す: :func:`filter`, :func:`map`, :func:`reduce` です。
+組み込み関数には、リストに対して使うと非常に便利なものが三つあります。
+:func:`filter`, :func:`map`, :func:`reduce` です。

  ``filter(function, sequence)`` は、シーケンス *sequence* 中の要素 *item* か 
ら、
-``function(item)`` が真となるような要素からなるシーケンスを返します。もし  
*sequence* が :class:`string` か
-:class:`tuple` なら、返り値も同じ型になります。そうでなけれ 
ば :class:`list` になります。
+``function(item)`` が真となるような要素からなるシーケンスを返します。
+もし *sequence* が :class:`string` か :class:`tuple` なら、返り値も
+同じ型になります。そうでなければ :class:`list` になります。
  例えば、いくつかの素数を計算するには以下のようにします。

  ::
@@ -170,7 +183,8 @@
     [5, 7, 11, 13, 17, 19, 23]

  ``map(function, sequence)`` は、シーケンス *sequence* の各要素 *item* に対 
して
-``function(item)`` を呼び出し、その戻り値からなるリストを返します。例えば、 
三乗された値の列を計算するには以下のようにします:
+``function(item)`` を呼び出し、その戻り値からなるリストを返します。
+例えば、三乗された値の列を計算するには以下のようにします。

  ::

@@ -179,6 +193,17 @@
     >>> map(cube, range(1, 11))
     [1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]

+.. More than one sequence may be passed; the function must then have as  
many
+   arguments as there are sequences and is called with the corresponding  
item from
+   each sequence (or ``None`` if some sequence is shorter than another).   
For
+   example::
+
+複数のシーケンスを渡すこともできます。その場合、第一引数の関数はシーケンス 
の
+数と等しい数の引数を受け取る必要があり、各シーケンスの値が渡されます。
+(幾つかのシーケンスが他のシーケンスよりも短かった場合は、その場所には  
``None``
+が渡されます。)
+例です。
+
  ::

     >>> seq = range(8)
@@ -187,9 +212,11 @@
     >>> map(add, seq, seq)
     [0, 2, 4, 6, 8, 10, 12, 14]

-``reduce(function, sequence)`` は単一の値を返します。この値は 2 つの引数を 
とる関数 *function* をシーケンス
-*sequence* の最初の二つの要素を引数として呼び出し、次にその結果とシーケンス 
の次の要素を引数にとり、以降これを繰り返すことで構成します。例えば、
-1 から 10 までの数の総和を計算するには以下のようにします:
+``reduce(function, sequence)`` は単一の値を返します。この値は 2 つの引数を
+とる関数 *function* をシーケンス *sequence* の最初の二つの要素を引数として
+呼び出し、次にその結果とシーケンスの次の要素を引数にとり、以降これを
+繰り返していきます。例えば、 1 から 10 までの数の総和を計算するには
+以下のようにします。

  ::

@@ -198,10 +225,14 @@
     >>> reduce(add, range(1, 11))
     55

-シーケンス中にただ一つしか要素がなければ、その値自体が返されます; シーケン 
スが空なら、例外が送出されます。
-
-3 つめの引数をわたして、初期値を指定することもできます。この場合、空のシー 
ケンスを渡すと初期値が返されます。それ以外の場合には、
-まず初期値とシーケンス中の最初の要素に対して関数が適用され、次いでその結果 
とシーケンスの次の要素に対して適用され、以降これが繰り返されます。例えば以下 
のようになります。
+シーケンス中にただ一つしか要素がなければ、その値自体が返されます。
+シーケンスが空なら、例外が送出されます。
+
+3 つめの引数をわたして、初期値を指定することもできます。この場合、
+空のシーケンスを渡すと初期値が返されます。それ以外の場合には、
+まず初期値とシーケンス中の最初の要素に対して関数が適用され、次いでその結果 
と
+シーケンスの次の要素に対して適用され、以降これが繰り返されます。
+例えば以下のようになります。

  ::

@@ -214,7 +245,8 @@
     >>> sum([])
     0

-(2.3 以降では) 実際には、上の例のように :func:`sum` を定義しないでくださ 
い: 数値の合計は広く必要とされている操作なので、すでに組み込み関数
+実際には、上の例のように :func:`sum` を定義しないでください。
+数値の合計は広く必要とされている操作なので、すでに組み込み関数
  ``sum(sequence)`` が提供されており、上の例と全く同様に動作します。

  .. versionadded:: 2.3
@@ -278,7 +310,8 @@
     上の例はまだ判りやすいですが、複雑な内包表記はすぐに読みにくくなってしま 
うので、
     その場合はループで書き下した方が良いでしょう。

-リストの内包表記は :func:`map` よりもはるかに柔軟性があり、複雑な式や入れ子 
になった関数でも利用できます。
+リストの内包表記は :func:`map` よりもはるかに柔軟性があり、
+複雑な式や入れ子になった関数でも利用できます。

  ::

@@ -289,9 +322,13 @@
  ネストしたリストの内包表記
  --------------------------
  もし望むなら、リストの内包表記はネストさせることができます。
-ネストしたリストの内包表記はとても強力な道具なのですが -- 全ての強力な道具 
がそうであるように -- とにかく気を付けて使う必要があります。
-
-1行を1つのリストに対応させた3つのリストからなるリストで、3行3列の行列を表現 
した例を考えます::
+ネストしたリストの内包表記はとても強力な道具なのですが
+-- 全ての強力な道具がそうであるように -- とにかく気を付けて使う必要がありま 
す。
+
+1行を1つのリストに対応させた3つのリストからなるリストで、3行3列の行列を
+表現した例を考えます。
+
+::

     >>> mat = [
     ...        [1, 2, 3],
@@ -299,16 +336,16 @@
     ...        [7, 8, 9],
     ...       ]

-ここで、行と列を入れ換えたいとしたときにリストの内包表記が使えます::
+ここで、行と列を入れ換えたいとしたときにリストの内包表記が使えます。 ::

      >>> print [[row[i] for row in mat] for i in [0, 1, 2]]
      [[1, 4, 7], [2, 5, 8], [3, 6, 9]]

-*ネストした* リストの内包表記は特に気を付けて使わなければなりません:
+*ネストした* リストの内包表記は特に気を付けて使わなければなりません。

      リストの内包表記を怖がらずにネストするためには、右から左へ読んでくださ 
い。

-このコードの断片のより冗長なバージョンを見ると処理の流れがはっきりします::
+このコードの断片のより冗長なバージョンを見ると処理の流れがはっきりしま 
す。 ::

      for i in [0, 1, 2]:
          for row in mat:
@@ -316,12 +353,13 @@
          print

  実際には複雑な流れの式よりも組み込み関数を使う方が良いです。
-この場合 :func:`zip` 関数が大きな仕事をしてくれるでしょう::
+この場合 :func:`zip` 関数が良い仕事をしてくれるでしょう。 ::

      >>> zip(*mat)
      [(1, 4, 7), (2, 5, 8), (3, 6, 9)]

-この行にあるアスタリスクの詳細については :ref:`tut-unpacking-arguments` を 
参照してください。
+この行にあるアスタリスクの詳細については :ref:`tut-unpacking-arguments`
+を参照してください。


  .. _tut-del:
@@ -329,9 +367,12 @@
  :keyword:`del` 文
  =================

-リストから要素を削除する際、値を指定する代わりにインデックスを指定する方法 
があります: それが :keyword:`del`
-文です。これは :meth:`pop` メソッドとちがい、値を返しません。
-:keyword:`del` 文はリストからスライスを除去したり、リスト全体を削除すること 
もできます (以前はスライスに空のリストを代入して行っていました)。例えば以下 
のようにします:
+リストから要素を削除する際、値を指定する代わりにインデックスを指定する方法 
が
+あります。それが :keyword:`del` 文です。これは :meth:`pop` メソッドと違い、
+値を返しません。
+:keyword:`del` 文はリストからスライスを除去したり、リスト全体を削除する
+こともできます(以前はスライスに空のリストを代入して行っていました)。
+例えば以下のようにします。

  ::

@@ -347,14 +388,14 @@
     >>> a
     []

-:keyword:`del` は変数全体の削除にも使えます:
+:keyword:`del` は変数全体の削除にも使えます。

  ::

     >>> del a

-この文の後で名前 ``a`` を参照すると、(別の値を ``a`` に代入するまで) エラー 
になります。 :keyword:`del` の別の用途について
-はまた後で取り上げます。
+この文の後で名前 ``a`` を参照すると、(別の値を ``a`` に代入するまで) エラー 
になります。
+:keyword:`del` の別の用途についてはまた後で取り上げます。


  .. _tut-tuples:
@@ -362,11 +403,13 @@
  タプルとシーケンス
  ==================

-リストや文字列には、インデクスやスライスを使った演算のように、数多くの共通 
の性質があることを見てきました。これらは *シーケンス (sequence)*
-データ型 (:ref:`typesseq` を参照) の二つの例です。Python はまだ
-進歩の過程にある言語なので、他のシーケンスデータ型が追加されるかもしれませ 
ん。標準のシーケンス型はもう一つあります: *タプル (tuple)* 型です。
-
-タプルはコンマで区切られたいくつかの値からなります。例えば以下のように書き 
ます:
+リストや文字列には、インデクスやスライスを使った演算のように、数多くの共通 
の
+性質があることを見てきました。これらは *シーケンス (sequence)* データ型
+(:ref:`typesseq` を参照) の二つの例です。
+Python はまだ進歩の過程にある言語なので、他のシーケンスデータ型が追加される
+かもしれません。標準のシーケンス型はもう一つあります: *タプル (tuple)* 型で 
す。
+
+タプルはコンマで区切られたいくつかの値からなります。例えば以下のように書き 
ます。

  ::

@@ -380,18 +423,24 @@
     >>> u
     ((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))

-ご覧のように、出力ではタプルは常に丸括弧で囲われています。これは、入れ子に 
なったタプルが正しく解釈されるようにするためです; 入力の際には
-丸括弧なしでもかまいませんが、結局 (タプルがより大きな式の一部分の場合) た 
いてい必要となります。
-
-タプルの用途はたくさんあります。例えば、(x, y) 座標対、データベースから取り 
出した従業員レコードなどです。タプルは文字列と同じく、変更不能です:
-タプルの個々の要素に代入を行うことはできません (スライスと連結を使って同じ 
効果を実現することはできますが)。リストのような変更可能な
-オブジェクトの入ったタプルを作成することもできます。
-
-問題は 0 個または 1 個の項目からなるタプルの構築です: これらの操作を行うた 
め、構文には特別な細工がされています。空のタプルは
-空の丸括弧ペアで構築できます; 一つの要素を持つタプルは、値の後ろにコンマを 
続ける (単一の値を丸括弧で囲むだけでは不十分です)
-ことで構築できます。美しくはないけれども、効果的です。例えば以下のようにし 
ます:
-
-::
+ご覧のように、出力ではタプルは常に丸括弧で囲われています。
+これは、入れ子になったタプルが正しく解釈されるようにするためです。
+入力の際には丸括弧なしでもかまいませんが、結局 (タプルがより大きな式の一部 
分の
+場合) 大抵必要となります。
+
+タプルの用途はたくさんあります。
+例えば、(x, y) 座標対、データベースから取り出した従業員レコードなどです。
+タプルは文字列と同じく、変更不能です。
+タプルの個々の要素に代入を行うことはできません (スライスと連結を使って同じ
+効果を実現することはできますが)。
+リストのような変更可能なオブジェクトの入ったタプルを作成することも可能で 
す。
+
+問題は 0 個または 1 個の項目からなるタプルの構築です。
+これらの操作を行うため、構文には特別な細工がされています。
+空のタプルは空の丸括弧ペアで構築できます。
+一つの要素を持つタプルは、値の後ろにコンマを続ける (単一の値を丸括弧で囲む
+だけでは不十分です) ことで構築できます。
+美しくはないけれども、効果的です。例えば以下のようにします。 ::

     >>> empty = ()
     >>> singleton = 'hello',    # <-- 末尾のコンマに注目
@@ -402,15 +451,19 @@
     >>> singleton
     ('hello',)

-文 ``t = 12345, 54321, 'hello!'`` は *タプルのパック (tuple packing)* の例 
です: 値 ``12345`` 、
-``54321`` 、および ``'hello!'`` が一つのタプルにパックされます。逆の演算も 
可能です:
+文 ``t = 12345, 54321, 'hello!'`` は *タプルのパック (tuple packing)* の例 
です。
+値 ``12345``, ``54321``, ``'hello!'`` が一つのタプルにパックされます。
+逆の演算も可能です。

  ::

     >>> x, y, z = t

-この操作は、 *シーケンスのアンパック (sequence unpacking)* とでも呼ぶべきも 
ので、右辺にあるシーケンスに働きます。シーケンスのアンパックでは、左辺に列挙 
されている
-変数が、右辺のシーケンスの長さと同じであることが要求されます。複数同時の代 
入が実はタプルのパックとシーケンスのアンパックを
+この操作は、 *シーケンスのアンパック (sequence unpacking)* とでも
+呼ぶべきもので、右辺には全てのシーケンス型を使うことができます。
+シーケンスのアンパックでは、左辺に列挙されている変数が、右辺のシーケンスの
+長さと同じであることが要求されます。
+複数同時の代入が実はタプルのパックとシーケンスのアンパックを
  組み合わせたものに過ぎないことに注意してください。

  .. XXX Add a bit on the difference between tuples and lists.
@@ -421,11 +474,12 @@
  集合型
  ======

-Python には、 *集合 (set)* を扱うためのデータ型もあります。集合とは、重複す 
る要素をもたない、順序づけられていない要素の集まりです。 Set
-オブジェクトは、結合 (union)、交差 (intersection)、差分 (difference)、対称 
差 (symmetric difference)
-といった数学的な演算もサポートしています。
-
-簡単なデモンストレーションを示します::
+Python には、 *集合 (set)* を扱うためのデータ型もあります。
+集合とは、重複する要素をもたない、順序づけられていない要素の集まりです。
+Set オブジェクトは、結合 (union)、交差 (intersection)、差分 (difference)、
+対称差 (symmetric difference)といった数学的な演算もサポートしています。
+
+簡単なデモンストレーションを示します。 ::

     >>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
     >>> fruit = set(basket)               # 重複のない集合を作成
@@ -457,26 +511,40 @@
  辞書
  ====

-もう一つ、有用な型が Python に組み込まれています。それは  *辞書  
(dictionary)*
-(:ref:`typesmapping` を参照)です。辞書は他の言語にも "連想記憶 (associated  
memory)" や "連想配列
-(associative array)" として存在することがあります。ある範囲の数でインデクス 
化されているシーケンスと異なり、辞書は *キー (key)*
-でインデクス化されています。このキーは何らかの変更不能な型になります; 文字 
列、数値、およびタプルは常にキーにすることができます; ただし、タプルに
-何らかの変更可能なオブジェクトが含まれている場合にはキーに使うことはできま 
せん。リストをキーとして使うことはできません。これは、リストに
-スライスやインデクス指定の代入を行ったり、 :meth:`append`  
や :meth:`extend` のようなメソッドを使うと、
-インプレースで変更することができるためです。
-
-辞書は順序付けのされていない *キー(key): 値(value)* のペアからなり、キーが  
(辞書の中で)
-一意でければならない、と考えると最もよいでしょう。波括弧 (brace) のペア:  
``{}`` は空の辞書を生成します。カンマで区切られた key:
-value のペアを波括弧ペアの間に入れると、辞書の初期値となる key: value が追 
加されます; この表現方法は出力時に辞書が書き出されるのと同じ方法です。
-
-辞書での主な操作は、ある値を何らかのキーを付けて記憶することと、キーを指定 
して値を取り出すことです。 ``del`` で key: value のペアを
-削除することもできます。すでに使われているキーを使って値を記憶すると、以前 
そのキーに関連づけられていた値は忘れ去られてしまいます。存在しないキーを使っ 
て
-値を取り出そうとするとエラーになります。
-
-辞書オブジェクトの :meth:`keys` メソッドは、辞書で使われている全てのキーか 
らなるリストを適当な順番で返します (リストをソート
-したいなら、このキーのリストに :meth:`sort` を使ってください)。ある単一の 
キーが辞書にあるかどうか調べるには、 :keyword:`in` キーワードを使います。
-
-以下に、辞書を使った小さな例を示します:
+もう一つ、有用な型が Python に組み込まれています。
+それは *辞書 (dictionary)* (:ref:`typesmapping` を参照)です。
+辞書は他の言語にも "連想記憶 (associated memory)" や "連想配列
+(associative array)" という名前で存在することがあります。
+ある範囲の数でインデクス化されているシーケンスと異なり、辞書は *キー (key)*
+でインデクス化されています。
+このキーは何らかの変更不能な型になります。文字列、数値は常にキーにすること 
が
+できます。
+タプルは、文字列、数値、その他のタプルのみを含む場合はキーにすることができ 
ます。
+直接、あるいは間接的に変更可能なオブジェクトを含むタプルはキーにできませ 
ん。
+リストをキーとして使うことはできません。
+これは、リストにスライスやインデクス指定の代入を行ったり、 :meth:`append`
+や :meth:`extend` のようなメソッドを使うと、インプレースで変更することが
+できるためです。
+
+辞書は順序付けのされていない *キー(key): 値(value)* のペアの集合であり、
+キーが (辞書の中で)一意でければならない、と考えるとよいでしょう。
+波括弧 (brace) のペア: ``{}`` は空の辞書を生成します。カンマで区切られた  
key:
+value のペアを波括弧ペアの間に入れると、辞書の初期値となる key: value
+が追加されます; この表現方法は出力時に辞書が書き出されるのと同じ方法です。
+
+辞書での主な操作は、ある値を何らかのキーを付けて記憶することと、
+キーを指定して値を取り出すことです。
+``del`` で key: value のペアを削除することもできます。
+すでに使われているキーを使って値を記憶すると、以前そのキーに関連づけられて 
いた
+値は忘れ去られてしまいます。
+存在しないキーを使って値を取り出そうとするとエラーになります。
+
+辞書オブジェクトの :meth:`keys` メソッドは、辞書で使われている全ての
+キーからなるリストを適当な順番で返します (ソートされたリストが欲しい場合 
は、
+このキーのリストに :meth:`sort` を使ってください)。
+ある単一のキーが辞書にあるかどうか調べるには、 :keyword:`in` キーワードを使 
います。
+
+以下に、辞書を使った簡単な例を示します。

  ::

@@ -495,8 +563,10 @@
     >>> 'guido' in tel
     True

-:func:`dict` コンストラクタは、キーと値のペアをタプルにしたものからなるリス 
トを使って直接辞書を生成します。キーと値のペアが
-あるパターンをなしているなら、リストの内包表現を使えばキーと値のリストをコ 
ンパクトに指定できます。
+:func:`dict` コンストラクタは、キーと値のペアのタプルを含むリストから辞書を
+生成します。
+キーと値のペアがあるパターンをなしているなら、リストの内包表現を使えば
+キーと値のリストをコンパクトに指定できます。

  ::

@@ -505,9 +575,11 @@
     >>> dict([(x, x**2) for x in (2, 4, 6)])     # リスト内包表現を利用
     {2: 4, 4: 16, 6: 36}

-チュートリアルの後部では、キー=値ペアを :func:`dict` コンストラクタに渡すた 
めに適したジェネレータ式について学習します。
-
-キーが単純な文字列の場合、キーワード引数を使って定義する方が単純な場合もあ 
ります。
+後ほど、 key, value ペアを :func:`dict` コンストラクタに渡すのにより適し 
た、
+ジェネレータ式について学習します。
+
+キーが単純な文字列の場合、キーワード引数を使って定義する方が単純な場合も
+あります。

  ::

@@ -520,7 +592,8 @@
  ループのテクニック
  ==================

-辞書の内容にわたってループを行う際、 :meth:`iteritems` メソッドを使うと、 
キーとそれに対応する値を同時に取り出せます。
+辞書に対してループを行う際、 :meth:`iteritems` メソッドを使うと、キーと
+それに対応する値を同時に取り出せます。

  ::

@@ -531,7 +604,8 @@
     gallahad the pure
     robin the brave

-シーケンスにわたるループを行う際、 :func:`enumerate` 関数を使うと、要素のイ 
ンデクスと要素を同時に取り出すことができます。
+シーケンスにわたるループを行う際、 :func:`enumerate` 関数を使うと、要素の
+インデックスと要素を同時に取り出すことができます。

  ::

@@ -542,7 +616,8 @@
     1 tac
     2 toe

-二つまたはそれ以上のシーケンス型を同時にループするために、関数 :func:`zip`  
を使って各要素をひと組みにすることができます。
+二つまたはそれ以上のシーケンス型を同時にループするために、関数 :func:`zip`
+を使って各要素をひと組みにすることができます。

  ::

@@ -555,7 +630,8 @@
     What is your quest?  It is the holy grail.
     What is your favorite color?  It is blue.

-シーケンスを逆方向に渡ってループするには、まずシーケンスの範囲を順方向に指 
定し、次いで関数 :func:`reversed` を呼び出します。
+シーケンスを逆方向に渡ってループするには、まずシーケンスの範囲を順方向に
+指定し、次いで関数 :func:`reversed` を呼び出します。

  ::

@@ -568,7 +644,8 @@
     3
     1

-シーケンスを並び順にループするには、 :func:`sorted` 関数を使います。この関 
数は元の配列を変更せず、並べ変え済みの新たな配列を返します。
+シーケンスをソートされた順序でループするには、 :func:`sorted` 関数を使いま 
す。
+この関数は元の配列を変更せず、ソート済みの新たな配列を返します。

  ::

@@ -587,22 +664,39 @@
  条件についてもう少し
  ====================

-``while`` や ``if`` 文で使った条件 (condiction) には、値の比較だけでなく、 
他の演算子も使うことができます、
-
-比較演算子 ``in`` および ``not in`` は、ある値があるシーケンス中に存在する 
か (または存在しないか) どうかを調べます。演算子
-``is``  および ``is not`` は、二つのオブジェクトが実際に同じオブジェクトで 
あるかどうかを調べます; この比較は、リストのような変更可能なオブジェクトにだ 
け意味があります。全ての比較演算子は同じ優先順位を持っており、ともに数値演算 
子よりも低い優先順位となります。
-
-比較は連鎖 (chain) させることができます。例えば、 ``a < b == c`` は、  
``a`` が ``b`` より小さく、かつ ``b`` と
-``c`` が等しいかどうか、をテストします。
-
-比較演算はブール演算子 ``and`` や ``or`` で組み合わせられます。また、比較演 
算 (あるいは何らかのブール式) の結果の否 (negate)
-は ``not`` でとれます。これらの演算子は全て、比較演算子よりも低い優先順位に 
なっています。 ``A and not B or C`` と ``(A
-and (not B)) or C `` が等価になるように、ブール演算子の中で、`` not `` の優 
先順位が最も高く、`` or`` が最も
-低くなっています。もちろん、丸括弧を使えば望みの組み合わせを表現できます。
-
-ブール演算子 ``and`` と ``or`` は、いわゆる *短絡 (short-circuit)* 演算子で 
す: これらの演算子の引数は
-左から右へと順に評価され、結果が確定した時点で評価を止めます。例えば、  
``A`` と ``C`` は真で ``B`` が偽のとき、 ``A and B and
-C `` は式 `` C`` を評価しません。一般に、短絡演算子の戻り値をブール値ではな 
くて一般的な値として用いると、値は最後に評価された引数になります。
+``while`` や ``if`` 文で使った条件 (condiction) には、値の比較だけでなく、
+他の演算子も使うことができます、
+
+比較演算子 ``in`` および ``not in`` は、ある値があるシーケンス中に存在する 
か
+(または存在しないか) どうかを調べます。
+演算子 ``is``  および ``is not`` は、二つのオブジェクトが実際に同じ
+オブジェクトであるかどうかを調べます。
+この比較は、リストのような変更可能なオブジェクトにだけ意味があります。
+全ての比較演算子は同じ優先順位を持っており、ともに数値演算子よりも低い
+優先順位となります。
+
+.. note::
+   訳注: ``is`` は、 ``is None`` のように、シングルトンの変更不能オブジェク 
トとの
+   比較に用いる場合もあります。(「変更可能なオブジェクトにだけ意味がありま 
す」の
+   部分を削除することを Doc-SIG に提案中。)
+
+比較は連結させることができます。例えば、 ``a < b == c`` は、 ``a`` が ``b``
+より小さく、かつ ``b`` と ``c`` が等しいかどうかをテストします。
+
+ブール演算子 ``and`` や ``or`` で比較演算を組み合わせることができます。
+そして、比較演算 (あるいは何らかのブール式) の結果の否定は ``not`` でとれま 
す。
+これらの演算子は全て、比較演算子よりも低い優先順位になっています。
+``A and not B or C`` と ``(A and (not B)) or C`` が等価になるように、
+ブール演算子の中で、 ``not`` の優先順位が最も高く、 ``or`` が最も低く
+なっています。もちろん、丸括弧を使えば望みの組み合わせを表現できます。
+
+ブール演算子 ``and`` と ``or`` は、いわゆる *短絡 (short-circuit)* 演算子で 
す。
+これらの演算子の引数は左から右へと順に評価され、結果が確定した時点で
+評価を止めます。
+例えば、 ``A`` と ``C`` は真で ``B`` が偽のとき、 ``A and B and C`` は式  
``C``
+を評価しません。
+一般に、短絡演算子の戻り値をブール値ではなくて一般的な値として用いると、
+値は最後に評価された引数になります。

  比較や他のブール式の結果を変数に代入することもできます。例えば、

@@ -613,8 +707,10 @@
     >>> non_null
     'Trondheim'

-Python では、C 言語と違って、式の内部で代入を行えないので注意してくださ 
い。 C 言語のプログラマは不満を呈するかもしれませんが、この仕様は、 C 言語
-プログラムで遭遇する、式の中で ``==`` のつもりで ``=`` とタイプしてしまうと 
いったありふれた問題を回避します。
+Python では、C 言語と違って、式の内部で代入を行えないので注意してください。
+C 言語のプログラマは不満に思うかもしれませんが、この仕様は、 C 言語プログラ 
ムで
+遭遇する、式の中で ``==`` のつもりで ``=`` とタイプしてしまうといったありふ 
れた
+問題を回避します。


  .. _tut-comparing:
@@ -622,12 +718,19 @@
  シーケンスとその他の型の比較
  ============================

-シーケンスオブジェクトは同じシーケンス型の他のオブジェクトと比較できます。 
比較には *辞書的な (lexicographical)* 順序が用いられます:
-まず、最初の二つの要素を比較し、その値が等しくなければその時点で比較結果が 
決まります。等しければ次の二つの要素を比較し、以降
-シーケンスの要素が尽きるまで続けます。比較しようとする二つの要素がいずれも 
同じシーケンス型であれば、そのシーケンス間での辞書比較を再帰的に行います。
-二つのシーケンスの全ての要素の比較結果が等しくなれば、シーケンスは等しいと 
みなされます。片方のシーケンスがもう一方の先頭部分にあたる部分シーケンス
-ならば、短い方のシーケンスが小さい (劣位の) シーケンスとみなされます。文字 
列に対する辞書的な順序づけには、個々の文字ごとに ASCII 順序を用います。
-以下に、同じ型のオブジェクトを持つシーケンス間での比較を行った例を示します:
+シーケンスオブジェクトは同じシーケンス型の他のオブジェクトと比較できます。
+比較には *辞書的な (lexicographical)* 順序が用いられます。
+まず、最初の二つの要素を比較し、その値が等しくなければその時点で比較結果が
+決まります。
+等しければ次の二つの要素を比較し、以降シーケンスの要素が尽きるまで続けま 
す。
+比較しようとする二つの要素がいずれも同じシーケンス型であれば、
+そのシーケンス間での辞書比較を再帰的に行います。
+二つのシーケンスの全ての要素の比較結果が等しくなれば、シーケンスは等しいと
+みなされます。
+片方のシーケンスがもう一方の先頭部分にあたる部分シーケンスならば、短い方の
+シーケンスが小さいシーケンスとみなされます。
+文字列に対する辞書的な順序づけには、個々の文字ごとに ASCII 順序を用います。
+以下に、同じ型のオブジェクトを持つシーケンス間での比較を行った例を示しま 
す。

  ::

@@ -639,12 +742,16 @@
     (1, 2, 3)             == (1.0, 2.0, 3.0)
     (1, 2, ('aa', 'ab'))   < (1, 2, ('abc', 'a'), 4)

-違う型のオブジェクト間の比較は認められていることに注意してください。比較結 
果は決定性がありますが、その決め方は、型は型の名前で順番づけられる、
-という恣意的なものです。従って、リスト (list) 型は常に文字列 (string) 型よ 
りも小さく、文字列型は常にタプル (tuple)
-よりも小さい、といった具合になります。 [#]_
-型混合の数値の比較は、数値そのものに従って比較されるので、例えば 0 は 0.0  
と等しい、という結果になります。
+違う型のオブジェクト間の比較は認められていることに注意してください。
+比較結果は決定性がありますが、その決め方は、型は型の名前で順番づけられる、
+という恣意的なものです。
+従って、リスト (list) 型は常に文字列 (string) 型よりも小さく、文字列型は
+常にタプル (tuple) よりも小さい、といった具合になります。 [#]_
+型混合の数値の比較は、数値そのものに従って比較されるので、例えば 0 は 0.0
+と等しい、という結果になります。

  .. rubric:: Footnotes

-.. [#] 異なる型のオブジェクトを比較するための規則を今後にわたって当てにして 
はなりません; Python 言語の将来のバージョンでは変更されるかもしれません。
-
+.. [#] 異なる型のオブジェクトを比較するための規則を今後にわたって当てにして 
はなりません。
+   Python 言語の将来のバージョンでは変更されるかもしれません。
+




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