Python.use(better) #Vector: step10 -- def __iter__(self):

Python

‖記事一覧‖ Python.use(better)《Python3.1》

def __iter__(self):

《著》森こねこ、小粒ちゃん＋∞《監修》小泉ひよ子とタマゴ倶楽部
第０版♪2001/03/02 ● 第１版♪2003/05/25 ● 第２版♪2004/06/01 ● 第３版♪2009/02/28

課題を作成する過程を通して「数値演算」の理解を深めます。
※ Python1.5 で作成した例題を、Python3.1 で再構成しました。

事例：コードの解説

    class Vector(object):
        ...
        def __iter__(self):                            #1,2:
            for e in self.elements:
                yield e
        def __repr__(self):                            #3:
            return "(%s)"%", ".join(map(str, self))

        def __add__(v1, v2):                           #4:
            s = [e1+e2 for e1,e2 in zip(v1, v2)]
            return Vector(*s)
        
        def __neg__(self):                             #5:
            s = [-e for e in self]
            return Vector(*s)

        def __mul__(self, other):                      #6,7:
            if isinstance(other, Vector):
                return sum(e1*e2
                    for e1,e2 in zip(self, other))
            else:
                s = [e*other for e in self]
                return Vector(*s)
■ #1: メソッド：__iter__
        def __iter__(self):                 #@:
            ...

メソッド __iter__ は、ベクトルの各要素を順に参照する方法を規定します。

  • メソッド __iter__ を規定すると、インスタンス属性 self.elements に依存しない「抽象表現」が可能になります。

《Note》how/what：メソッド __iter__ は、インスタンス属性を介して、各要素を順に参照する方法を規定します。すると、他のメソッド群を実現するときに、「具体的な」方法（how）に依存しない、その目的（what）を端的に示す「抽象的な」表現が可能になります。

■ #2: ジェネレーター：yield
        def __iter__(self):                 #@:
            for e in self.elements:
                yield e

yield 文を利用すると、その関数/メソッドは「ジェネレーター」になります。

  • メソッド __iter__ が呼び出されるたびに、ベクトル self.elements の各要素 e を順にリターン値にします。
■ #3: メソッド：__repr__
    ## ---------------------------------------- before
        def __repr__(self):
            return "(%s)"%", ".join(map(str, self.elements))
    ## ---------------------------------------- after
        def __repr__(self):
            return "(%s)"%", ".join(map(str, self))

メソッド __repr__ は、オブジェクトに固有の文字列表現を規定します。

  • メソッド __iter__ が規定してあるので、単に self と記述するだけです。
■ #4: メソッド：__add__
    ## ---------------------------------------- before
        def __add__(v1, v2):
            s = [e1+e2 for e1,e2 in zip(v1.elements, v2.elements)]
            ...
    ## ---------------------------------------- after
        def __add__(v1, v2):
            s = [e1+e2 for e1,e2 in zip(v1, v2)]
            ...

メソッド __add__ は、２項演算子 + に呼応して、２つのベクトルの「和」を表わすインスタンスを生成します。

  • メソッド __iter__ が規定してあるので、単に v1,v2 と記述するだけです。
■ #5: メソッド：__neg__
    ## ---------------------------------------- before
        def __neg__(self):
            s = [-e for e in self.elements]
            ...
    ## ---------------------------------------- after
        def __neg__(self):
            s = [-e for e in self]
            ...

メソッド __neg__ は、単項演算子 - に呼応して、逆ベクトルを表わすインスタンスを生成します。

  • メソッド __iter__ が規定してあるので、単に self と記述するだけです。
■ #6: メソッド：__mul__
    ## ---------------------------------------- before
        def __mul__(v1, v2):
            if ...
                return sum(e1*e2
                    for e1,e2 in zip(v1.elements, v2.elements))
            else:
                s = [e*v2 for e in v1.elements]
                ...
    ## ---------------------------------------- after
        def __mul__(self, other):
            if ...
                return sum(e1*e2
                    for e1,e2 in zip(self, other))
            else:
                s = [e*other for e in self]
                ...

メソッド __add__ は、２項演算子 * に呼応して、

を生成します。

  • メソッド __iter__ が規定してあるので、単に self, other と記述するだけです。
■ #7: 組み込み関数：isinstance
    ## ---------------------------------------- before
        def __mul__(self, other):
            if hasattr(other, "elements"):
                ...
    ## ---------------------------------------- after
        def __mul__(self, other):                      #6,7:
            if isinstance(other, Vector):
                ...

組み込み関数 isinstance は、other が Vector のインスタンスかどうかを判定します。

  • isinstance を利用すると、インスタンス属性 self.elements に依存しない「抽象表現」が可能になります。

《Note》いつ導入すべきか：（課題演習という性質から）抽象表現の効能を体感してもらうために「あえて」メソッド __iter__ を導入しませんでした。早くからメソッド __iter__ を規定しておけば、作業がより軽減されたのは、言うまでもありません。

事例：モジュールを起動する

■ 全項目を確認する

全ステップの「項目」を確認するには、関数 do を利用します。

$ python -i vector.py
>>> do()
 0: step00 -- class Vector(object):
 1: step01 -- def __init__(self, *args):
 2: step02x -- def __add__(v1, v2):
 3: step03 -- return Vector(*s)
 4: step04 -- def __sub__(v1, v2):
 5: step05 -- def __neg__(self):
 6: step06 -- def __mul__(v1, v2):
 7: step07x -- sum(e1*e2 ...)
 8: step08x -- if hasattr(v2, "elements"):
 9: step09 -- def __rmul__(self, other):
10: step10 -- def __iter__(self):
11: step11x -- def __radd__(v1, v2):
12: step12x -- raise(TypeError(s))
13: step13 -- raise(TypeError(s))
14: step14 -- def _typeError(self, v1, v2, op):
>>>
■ 各項目を実行する

各ステップの「動作」を確認するには、関数 do に実引数を指定します。

>>> do(10)
>>> # -------------------------------------------------- step10
>>> v  = Vector(); v
()
>>> v1 = Vector(3,4); v1
(3, 4)
>>> v2 = Vector(5,-2); v2
(5, -2)
>>> v1+v2
(8, 2)
>>> v1-v2
(-2, 6)
>>> v2-v1
(2, -6)
>>> -v1
(-3, -4)
>>> -v2
(-5, 2)
>>> v1*v2
7
>>> v2*v1
7
>>> v1*3
(9, 12)
>>> v2*(-2)
(-10, 4)
>>> 3*v1
(9, 12)
>>> (-2)*v2
(-10, 4)
>>> 2+v1
TypeError: unsupported operand type(s) for +: 'int' and 'Vector'
>>> v2+5
AttributeError: 'int' object has no attribute 'elements'
>>> 2-v1
TypeError: unsupported operand type(s) for -: 'int' and 'Vector'
>>> v2-5
AttributeError: 'int' object has no attribute 'elements'
>>>

２つのインスタンス v1,v2 を生成するとともに、

  • ベクトルに任意の整数を掛け合わると、定数（スカラー）倍のベクトルが得られます。
  • 任意の整数にベクトルを掛け合わると、ベクトルの内積（スカラー積）が得られます。
■ 何が問題か
  • 任意の整数とベクトルとを加減しようとすると、例外 TypeError を生成します。
  • ベクトルと任意の整数とを加減しようとすると、例外 AttributeError を生成します。

例外 TypeError に伴うエラーメッセージからは、利用者に有意義な情報が得られます。ところが、例外 AttributeError に伴うエラーメッセージからは、利用者に有意義な情報が得られません。なぜなら、これらの情報は、メソッドの実現方法に依存するからです。

》こちらに移動中です《
↑TOP


関連記事

Last updated♪2009/11/24