Python 自定义数组MyArray、实现数组运算操作

## Python 自定义数组MyArray类，重写Array类

创建myarry.py文件
MyArray.py

#!/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' )

定义测试文件helloworld.py

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