Python.use(better) #課題:ベクトル演算《クラス版》《source code》

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

《余録》課題:ベクトル演算《クラス版》

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

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

課題:ソースコード

#! /usr/bin/env python
# coding: utf-8
## ----------------------------------------
##
## (C) Copyright 2000-2009, 小粒ちゃん《監修》小泉ひよ子とタマゴ倶楽部
##
## ----------------------------------------
# ..+....1....+....2....+....3....+....4....+....5....+....6....+....7....+....8
"""
>>> None

>>> ## ----------------------------------------
>>> None
version: #1.0.34
"""
## ----------------------------------------
def step00():
    """class Vector(object):"""

    class Vector(object):
        pass

    ## ----------------------------------------
    local = locals()
    ex_vector0(local)

## ----------------------------------------
def step01():
    """def __init__(self, *args):"""

    class Vector(object):
        def __init__(self, *args):
            self.elements = list(args)
        def __repr__(self):
            return "(%s)"%", ".join(map(str, self.elements))

    ## ----------------------------------------
    local = locals()
    ex_vector1(local)

## ----------------------------------------
def step02x():
    """def __add__(v1, v2):"""

    class Vector(object):
        def __init__(self, *args):
            self.elements = list(args)
        def __repr__(self):
            return "(%s)"%", ".join(map(str,self.elements))

        def __add__(v1, v2):
            s = []
            for e1,e2 in zip(v1.elements, v2.elements):
                s.append(e1+e2)
            return Vector(s)

    ## ----------------------------------------
    local = locals()
    ex_vector2(local)

## ----------------------------------------
def step03():
    """return Vector(*s)"""

    class Vector(object):
        def __init__(self, *args):
            self.elements = list(args)
        def __repr__(self):
            return "(%s)"%", ".join(map(str,self.elements))

        def __add__(v1, v2):
            s = [e1+e2 for e1,e2 in zip(v1.elements, v2.elements)]
            return Vector(*s)

    ## ----------------------------------------
    local = locals()
    ex_vector2(local)

## ----------------------------------------
def step04():
    """def __sub__(v1, v2):"""

    class Vector(object):
        def __init__(self, *args):
            self.elements = list(args)
        def __repr__(self):
            return "(%s)"%", ".join(map(str,self.elements))

        def __add__(v1, v2):
            s = [e1+e2 for e1,e2 in zip(v1.elements, v2.elements)]
            return Vector(*s)
        def __sub__(v1, v2):
            s = [e1-e2 for e1,e2 in zip(v1.elements, v2.elements)]
            return Vector(*s)

    ## ----------------------------------------
    local = locals()
    ex_vector3(local)

## ----------------------------------------
def step05():
    """def __neg__(self):"""

    class Vector(object):
        def __init__(self, *args):
            self.elements = list(args)
        def __repr__(self):
            return "(%s)"%", ".join(map(str,self.elements))

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

    ## ----------------------------------------
    local = locals()
    ex_vector4(local)

## ----------------------------------------
def step06():
    """def __mul__(v1, v2):"""

    class Vector(object):
        def __init__(self, *args):
            self.elements = list(args)
        def __repr__(self):
            return "(%s)"%", ".join(map(str,self.elements))

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

        def __mul__(v1, v2):
            s = 0
            for e1,e2 in zip(v1.elements, v2.elements):
                s += e1*e2
            return s

    ## ----------------------------------------
    local = locals()
    ex_vector5(local)

## ----------------------------------------
def step07x():
    """sum(e1*e2 ...)"""

    class Vector(object):
        def __init__(self, *args):
            self.elements = list(args)
        def __repr__(self):
            return "(%s)"%", ".join(map(str,self.elements))

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

        def __mul__(v1, v2):
            return sum(e1*e2
                for e1,e2 in zip(v1.elements, v2.elements))            

    ## ----------------------------------------
    local = locals()
    ex_vector6(local)

## ----------------------------------------
def step08x():
    """if hasattr(v2, "elements"):"""

    class Vector(object):
        def __init__(self, *args):
            self.elements = list(args)
        def __repr__(self):
            return "(%s)"%", ".join(map(str,self.elements))

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

        def __mul__(v1, v2):
            if hasattr(v2, "elements"):
                return sum(e1*e2
                    for e1,e2 in zip(v1.elements, v2.elements))
            else:
                s = [e*v2 for e in v1.elements]
                return Vector(*s)

    ## ----------------------------------------
    local = locals()
    ex_vector7(local)

## ----------------------------------------
def step09():
    """def __rmul__(self, other):"""

    class Vector(object):
        def __init__(self, *args):
            self.elements = list(args)
        def __repr__(self):
            return "(%s)"%", ".join(map(str,self.elements))

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

        def __mul__(self, other):
            if hasattr(other, "elements"):
                return sum(e1*e2
                    for e1,e2 in zip(self.elements, other.elements))
            else:
                s = [e*other for e in self.elements]
                return Vector(*s)
        def __rmul__(self, other):
            return self*other

    ## ----------------------------------------
    local = locals()
    ex_vector8(local)

## ----------------------------------------
def step10():
    """def __iter__(self):"""

    class Vector(object):
        def __init__(self, *args):
            self.elements = list(args)
        def __iter__(self):                 #@:
            for e in self.elements:
                yield e
        def __repr__(self):
            return "(%s)"%", ".join(map(str,self))

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

        def __mul__(self, other):
            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)
        def __rmul__(self, other):
            return self*other

    ## ----------------------------------------
    local = locals()
    ex_vector8(local)

## ----------------------------------------
def step11x():
    """def __radd__(self, other):"""

    class Vector(object):
        def __init__(self, *args):
            self.elements = list(args)
        def __iter__(self):                 #@:
            for e in self.elements:
                yield e
        def __repr__(self):
            return "(%s)"%", ".join(map(str,self))

        def __add__(v1, v2):
            s = [e1+e2 for e1,e2 in zip(v1, v2)]
            return Vector(*s)
        def __radd__(self, other):          #@:
            return self+other

        def __sub__(v1, v2):
            return v1+(-v2)
        def __neg__(self):
            s = [-e for e in self]
            return Vector(*s)

        def __mul__(self, other):
            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)
        def __rmul__(self, other):
            return self*other

    ## ----------------------------------------
    local = locals()
    ex_vector8(local)

## ----------------------------------------
def step12x():
    """raise(TypeError(s))"""

    class Vector(object):
        def __init__(self, *args):
            self.elements = list(args)
        def __iter__(self):                 #@:
            for e in self.elements:
                yield e
        def __repr__(self):
            return "(%s)"%", ".join(map(str,self))

        # TypeError: unsupported operand type(s) for +: 'int' and 'Vector'
        def __add__(self, other):
            if isinstance(other, Vector):
                s = [e1+e2 for e1,e2 in zip(self, other)]
                return Vector(*s)
            else:
                s = "unsupported operand type(s) for +: %r and %r"%(
                    self.__class__.__name__,
                    other.__class__.__name__,
                    )
                raise(TypeError(s))
        def __radd__(self, other):          #@:
            return self+other

        def __sub__(v1, v2):
            return v1+(-v2)
        def __neg__(self):
            s = [-e for e in self]
            return Vector(*s)

        def __mul__(v1, v2):
            if isinstance(v2, Vector):
                return sum(e1*e2
                    for e1,e2 in zip(v1, v2))
            else:
                s = [e*v2 for e in v1]
                return Vector(*s)
        def __rmul__(v1, v2):
            return v1*v2

    ## ----------------------------------------
    local = locals()
    ex_vector8(local)

## ----------------------------------------
def step13():
    """raise(TypeError(s))"""

    class Vector(object):
        def __init__(self, *args):
            self.elements = list(args)
        def __iter__(self):                 #@:
            for e in self.elements:
                yield e
        def __repr__(self):
            return "(%s)"%", ".join(map(str,self))

        # TypeError: unsupported operand type(s) for +: 'int' and 'Vector'
        def __add__(self, other):
            if isinstance(other, Vector):
                s = [e1+e2 for e1,e2 in zip(self, other)]
                return Vector(*s)
            else:
                s = "unsupported operand type(s) for +: %r and %r"%(
                    self.__class__.__name__,
                    other.__class__.__name__,
                    )
                raise(TypeError(s))
        def __radd__(self, other):          #@:
            if isinstance(other, Vector):
                return self+other
            else:
                s = "unsupported operand type(s) for +: %r and %r"%(
                    other.__class__.__name__,
                    self.__class__.__name__,
                    )
                raise(TypeError(s))

        def __sub__(v1, v2):
            return v1+(-v2)
        def __neg__(self):
            s = [-e for e in self]
            return Vector(*s)

        def __mul__(self, other):
            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)
        def __rmul__(self, other):
            return self*other

    ## ----------------------------------------
    local = locals()
    ex_vector8(local)

## ----------------------------------------
def step14():
    """def _typeError(self, v1, v2, op):"""

    class Vector(object):
        def __init__(self, *args):
            self.elements = list(args)
        def __iter__(self):                 #@:
            for e in self.elements:
                yield e
        def __repr__(self):
            return "(%s)"%", ".join(map(str,self))

        ## ----------------------------------------
        def __add__(self, other):
            if isinstance(other, Vector):
                s = [e1+e2 for e1,e2 in zip(self, other)]
                return Vector(*s)
            else:
                self._typeError(self, other, "+")
        def __radd__(self, other):                   #@:
            if isinstance(other, Vector):
                return self+other
            else:
                self._typeError(other, self, "+")

        ## ----------------------------------------
        def __sub__(self, other):
            if isinstance(other, Vector):
                return self+(-other)
            else:
                self._typeError(self, other, "-")
        def __rsub__(self, other):
            if isinstance(other, Vector):
                return self-other
            else:
                self._typeError(other, self, "-")

        ## ----------------------------------------
        def __neg__(self):
            s = [-e for e in self]
            return Vector(*s)

        ## ----------------------------------------
        def __mul__(self, other):
            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)
        def __rmul__(self, other):
            return self*other

        ## ----------------------------------------
        # TypeError: unsupported operand type(s) for +: 'int' and 'Vector'
        _error = "unsupported operand type(s) for %s: %r and %r"

        def _typeError(self, v1, v2, op):
            s = self._error%(op, self._name(v1), self._name(v2))
            raise(TypeError(s))
        def _name(self, obj):
            return obj.__class__.__name__

    ## ----------------------------------------
    local = locals()
    ex_vector8(local)

## ----------------------------------------
## ----------------------------------------
def ex_vector0(local):                      #@:
    source = '''
v = Vector(); v
'''.split("\n")

    do_it(source, local)

## ----------------------------------------
def ex_vector1(local):                      #@:
    ex_vector0(local)

    source = '''
v1 = Vector(3,4); v1
'''.split("\n")

    do_it(source, local)

## ----------------------------------------
def ex_vector2(local):                      #@:
    ex_vector1(local)

    source = '''
v2 = Vector(5,-2); v2
v1+v2
'''.split("\n")

    do_it(source, local)

## ----------------------------------------
def ex_vector3(local):                        #@:
    ex_vector2(local)

    source = '''
v1-v2
v2-v1
'''.split("\n")

    do_it(source, local)

## ----------------------------------------
def ex_vector4(local):                        #@:
    ex_vector3(local)

    source = '''
-v1
-v2
'''.split("\n")

    do_it(source, local)

## ----------------------------------------
def ex_vector5(local):                        #@:
    ex_vector4(local)

    source = '''
v1*v2
v2*v1
'''.split("\n")

    do_it(source, local)

## ----------------------------------------
def ex_vector6(local):                        #@:
    ex_vector5(local)

    source = '''
v1*3
v2*(-2)
'''.split("\n")

    do_it(source, local)

## ----------------------------------------
def ex_vector7(local):                        #@:
    ex_vector6(local)

    source = '''
3*v1
(-2)*v2
'''.split("\n")

    do_it(source, local)

## ----------------------------------------
def ex_vector8(local):                        #@:
    ex_vector7(local)

    source = '''
2+v1
v2+5
2-v1
v2-5
'''.split("\n")

    do_it(source, local)

## ----------------------------------------
def do_it(source, local):
    for e in source[1:-1]:
        try:
            print_(e, local)
        except AttributeError as error:
            print("AttributeError:", error)
        except TypeError as error:
            print("TypeError:", error)

## ----------------------------------------
def print_(source, local, mode="single"):
    print(">>>",source)
    eval(compile(source,"",mode),globals(),local)

## ========================================
s = "step"
DIR = [e for e in dir() if e.startswith(s)]
DIR = dict*1
DIR = list(DIR.items()); DIR.sort()

def ex():
    n = (len(DIR)-1)//10+1
    for k,v in DIR:
        source = '''
x = eval("%%s.__doc__"%%v)
print("%%%dd: %%s -- %%s"%%(k,v,x))
'''%n
        eval(compile(source,"","exec"))

def do_all():
    for k,v in DIR: do(k)

def do(k=None):
    if k is None: ex(); return
    try:
        k,v = DIR[k]
        print(">>> #","-"*50,v)
        eval("%s()"%v)
    except IndexError:
        print("(x_x) too bad ... %s"%k)

## ----------------------------------------
from time import ctime

def time_stamp():
    print("="*24)
    print(ctime())
    print("="*24)

## ----------------------------------------
from doctest import testmod

if __name__=='__main__':
    time_stamp()
    testmod()

## ========================================
    class Vector(object):
        def __init__(self, *args):
            self.elements = list(args)
        def __iter__(self):                 #@:
            for e in self.elements:
                yield e
        def __repr__(self):
            return "(%s)"%", ".join(map(str,self))

        ## ----------------------------------------
        def __add__(self, other):
            if isinstance(other, Vector):
                s = [e1+e2 for e1,e2 in zip(self, other)]
                return Vector(*s)
            else:
                self._typeError(self, other, "+")
        def __radd__(self, other):                   #@:
            if isinstance(other, Vector):
                return self+other
            else:
                self._typeError(other, self, "+")

        ## ----------------------------------------
        def __sub__(self, other):
            if isinstance(other, Vector):
                return self+(-other)
            else:
                self._typeError(self, other, "-")
        def __rsub__(self, other):
            if isinstance(other, Vector):
                return self-other
            else:
                self._typeError(other, self, "-")

        ## ----------------------------------------
        def __neg__(self):
            s = [-e for e in self]
            return Vector(*s)

        ## ----------------------------------------
        def __mul__(self, other):
            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)
        def __rmul__(self, other):
            return self*other

        ## ----------------------------------------
        # TypeError: unsupported operand type(s) for +: 'int' and 'Vector'
        _error = "unsupported operand type(s) for %s: %r and %r"

        def _typeError(self, v1, v2, op):
            s = self._error%(op, self._name(v1), self._name(v2))
            raise(TypeError(s))
        def _name(self, obj):
            return obj.__class__.__name__

## ========================================

TOP


関連記事

Last updated♪2009/12/02

*1:i,e) for i,e in enumerate(DIR