## Python 自定義陣列MyArray

 #!/usr/bin/env python 
    # -*- coding:utf-8 -*-
    class MyArray:
        '''all the element in this array must be numbers'''
    
        def __IsNumber(self, n):
            if not isinstance( n, (int, float, complex) ):
                return False
            return True
    
        def __init__(self, *args):
            if not args:
                self.__value = []
            else:
                for arg in args:
                    if not self.__IsNumber( arg ):
                        print( 'all the element in this array must be numbers' )
                        return
                self.__value = list( args )
    
        def __del__(self):
            del self.__value
    
        def __add__(self, n):
            if self.__IsNumber( n ):
                b = MyArray()
                b.__value = [item + n for item in self.__value]
                return b
            elif isinstance( n, MyArray ):
                if len( self.__value ) == len( n.__value ):
                    c = MyArray()
                    c.__value = [i + j for i, j in zip( self.__value, n.__value )]
                    return c
                else:
                    print( 'len not erual' )
            else:
                print( 'not support' )
    
        def __sub__(self, n):
            if not self.__IsNumber( n ):
                print( '-operating with', type( n ), 'and number type is not supported' )
                return
            b = MyArray()
            b.__value = [item - n for item in self.__value]
            return b
    
        def __mul__(self, n):
            if not self.__IsNumber( n ):
                print( '* operating with ', type( n ), 'and number type is not support' )
                return
            b = MyArray()
            b.__value = [item * n for item in self.__value]
            return b
    
        def __truediv__(self, n):
            if not self.__IsNumber( n ):
                print( r'/operating with', type( n ), 'and number type is not support' )
                return
            b = MyArray()
            b.__value = [item / n for item in self.__value]
            return b
    
        def __floorldiv__(self, n):
            if not isinstance( n, int ):
                print( n, 'is not integer' )
                return
            b = MyArray()
            b.__value = [item // n for item in self.__value]
            return b
    
        def __mod__(self, n):
            if not self.__IsNumber( n ):
                print( r'%operating with', type( n ), 'and number type is not support' )
                return
            b = MyArray()
            b.__value = [item % n for item in self.__value]
            return b
    
        def __pow__(self, n):
            if not self.__IsNumber( n ):
                print( '**operating with', type( n ), 'and number type is not support' )
                return
            b = MyArray()
            b.__value = [item ** n for item in self.__value]
            return b
    
        def __len__(self):
            return len( self.__value )
    
        def __repr__(self):
            return repr( self.__value )
    
        def append(self, n):
            if not self.__IsNumber( n ):
                print( 'only number can be appended ' )
                return
            self.__value.append( n )
    
        def __getitem__(self, item):
            lenth = len( self.__value )
            if isinstance( item,int
                           ) and 0 <= item <= lenth:
                return self.__value[item]
            elif isinstance( item, (list, tuple) ):
                for i in item:
                    if not (isinstance( i, int ) and 0 <= i < +lenth):
                        return 'index error'
                    result = []
                    for i in item:
                        result.append( self.__value[i] )
                    return result
                else:
                    return 'index error'
    
        def __setitem__(self, key, value):
            length = len( self.__value )
            if isinstance( key, int ) and 0 <= key <= length:
                self.__value[key] = value
            elif isinstance( key, (list, tuple) ):
                for i in key:
                    if not (isinstance( i, int ) and 0 <= i < length):
                        raise Exception( 'index eroor' )
                if isinstance( value, (list, tuple) ):
                    if len( key ) == length:
                        for i, v in enumerate( key ):
                            self.__value[v] = value[v]
                elif isinstance( value, (int, float, complex) ):
                    for i in key:
                        self.__value[i] = value
                else:
                    raise Exception( 'value error' )
            else:
                raise Exception( 'index eroor' )
    
        def __contains__(self, item):
            if item in self.__value:
                return True
            else:
                return False
    
        def dot(self, v):
            if not isinstance( v, MyArray ):
                print( v, 'must be an instance of MyArry' )
                return
            if len( v ) != len( self.__value ):
                print( 'The size muat be equal' )
                return
            return sum( i * j for i, j in zip( self.__value, v.__value ) )
    
        def __eq__(self, v):
            if not isinstance( (v, MyArray) ):
                print( v, 'must be an instance of MyArry' )
                return
            if self.__value == v.__value:
                return True
            else:
                return False
    
        def __lt__(self, other):
            if not isinstance( other, MyArray ):
                print( other, 'must ne an instance of MyArry' )
                return False
            if self.__value < other.__value:
                return True
    
    
    if __name__ == '__main__':
        print( 'please use me as a module' )
 

from MyArray import MyArray

 x = MyArray( 1, 2, 3, 4, 5, 6 )
 y = MyArray( 7, 8, 9, 10, 11, 12 )
 print( x )

 print( x ** 2 )
 print( x.dot( y ))
 print( x[3] )

測試結果： [1, 2, 3, 4, 5, 6] [1, 4, 9, 16, 25, 36] 217 4