【数据结构实践】手把手带你实现 Python 自定义数组

引言

无论是任何语言，数组或者类似数组的数据结构永远是计算机编程语言不可或缺的基本数据结构,有了数组的存在更有利于我们的程序对数据的存储和操作.本文将从面向对象的入手,实现自定义数组类,实现数组的基本操作和运算等功能

数组的定义

1、数组（Array）是有序的元素序列。若将有限个类型相同的变量的集合命名，那么这个名称为数组名。

2、组成数组的各个变量称为数组的分量，也称为数组的元素，有时也称为下标变量。

3、用于区分数组的各个元素的数字编号称为下标。数组是在程序设计中，为了处理方便， 把具有相同类型的若干元素按有序的形式组织起来的一种形式。这些有序排列的同类数据元素的集合称为数组。也就是说数组是存储相同类型数据的集合

什么是面向对象

面向对象是一种软件开发方法,面向对象的概念和应用已经超越了程序设计和软件开发。面向对象中的对象，通常是指客观世界中存在的对象，这个对象具有唯一性，对象之间各不相同，各有各的特点，每一一个对象都有运动的规律和内部状态。对象与对象之间是可以相互联系、相互作用的。另外，对象也可以是一个抽象的事物。

1、对象( Object): -一个抽象概念，表示任意存在的事物。现实世界中，随处可见的一一种事物就是对象，对象是事物存在的实体。对象通常被划分为两个部分，即静态部分与动态部分。 静态部分通常被称为这个对象的属性，任何对象都具有自身属性，这些属性不仅是客观存在的。而且是不能被忽略的，如人的姓名,年龄等等。动态部分指的是对象的行为，即对象执行的动作，如人可以跑步。

2、类(Class):封装对象的属性和行为的获体。反过来说，具有相同属性和行为的一类实体被称为类。

Python中类的定义如下：

class ClassName：#类名使用大驼峰法，即首字母大写
  #类的语句块
  如类的成员属性...
  类的方法...	

当我们创建完类之后,接着就是类的使用,使用前需要对类进行实例化

比如有个Dog类

class Dog:
    def __init__(self, name):
        self.name = name

# 类的实例化如下
d1 = Dog("小北")

面向对象程序设计的特点:封装、继承和多态

封装:面向对象编程的核心，也是将对象的属性和行为封装起来的载体。类通常会对客尸隐臧其实现细节，这就是封装的思想。封装通过限制只有特定类的对象，访问这一 特定类的成员，而它们通常利用接口实现消息的传人和传出。采用封装思想保证了类的内部数据结构的完整性，使用该类的用户不能直接看到类中的数据结构，而只能执行类允许公开的数据，这样就可以避免外部对内部数据的影响，提高了程序的可维护性。

继承:在某种情况下，一个类会有子类，子类比原本的类要更加具体化。例如，犬这个类会有它的子类--拉布拉多犬,猎犬和泰迪犬等。“小北”可能就是哈士奇犬的一个实例。 子类会继承父类的属性和行为，并且也包含它们自己的特有属性。我们假设犬类有一个行为叫作吠叫，还有一一个属性叫作毛色，它的子类会继承这些行为和属性。综上所述，继承是实现重复利用的重要手段， 子类通过继承， 复用了父类的实现和行为，同时又添加了子类特有的属性和行为。

多态:由继承产生的不同的类，其对象对同一消息会做出不同的响应。子类继承父类特征的同时，也具备了自己的特征，并且能够实现不同的效果，这就是多态化结果。

这里只是简单唠唠面向对象的基本概念。我之前写过的一篇文章《梦回战国，领略两千多年前公孙龙如何将面向对象运用得炉火纯青》有关于面向对象的详细介绍，感兴趣的同学可参考参考。

自定义数组的实现步骤

使用python实现自定义数组,以及实现数组中的各种运算:

1. 保证输入值为数字元素,通过isinstance()函数判断数据类型

2. 初始化__init__函数,对输入的数据进行存储

3. 重构数组的运算方法

4. 添加数组类的类方法

代码实现

创建MyNArrays类,以及定义元素类过滤方法

class MyNArrays:
    #过滤非数字类型的元素
    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 elements must be numbers')
                    return
            self.__value = list(args)
            
    @property
    def getValue(self):
        return self.__value
    
    #析构函数，释放内部封装的列表
    def __del__(self):
        del self.__value
        
    #重载运算符+
    def __add__(self, other):
        #数组中每个元素都与数字other相加，或者两个数组相加，会得到一个新数组
        if self.___isNumber(other):
            #数组与数字other相加
            b = MyNArrays()
            b.__value = [item + other for item in self.__value]
            return b
          
        elif isinstance(other,MyNArrays):
          
            #两个数组对应元素相加
            if (len(other.__value) == len(self.__value)):
                c = MyNArrays()
                c.__value = [i+j for i,j in zip(self.__value,other.__value)]
                return c
              
            else:
                print('Lenght no equal')
                
        else:
            print('Not supported')
            
    #重载运算符-
    def __sub__(self, other):
        # 数组元素与数字other做减法，得到一个新数组
        pass
    
    #重载运算符*
    def __mul__(self, other):
        #数组元素与数字other做乘法，或者两个数组相乘，得到一个新数组
        pass
    
    def __truediv__(self, other):
        pass
    
    def __floordiv__(self, other):
        pass
    
    def __pow__(self, power, modulo=None):
        pass
    
    def __mod__(self, other):
        pass
    
    #重载数组len，支持对象直接使用len()方法
    def __len__(self):
        return len(self.__value)
    
    #支持使用print()函数查看对象的值
    def __str__(self):
        return str(self.__value)
    
    def __contains__(self, n):
        if n in self.__value:
                return True
        return False
    
    def dot(self,v):
        if not isinstance(v,MyNArrays):
            print('must be an instance of MyNArrays.')
            return
        if len(v)!=len(self.__value):
            print('size must be equal.')
            return
        
        return sum([i*j for i,j in zip(self.__value,v.__value)])
    
    #让本类具有修改数组元素的功能
    def __setitem__(self, key, value):
        length = len(self.__value)
        if isinstance(key,int) and  0<= key <length:
            self.__value[key]=value
            
        else:
            return 'index error'
    #获取数组元素   
    def __getitem__(self, key):
        length = len(self.__value)
        if isinstance(key, int) and 0<= key <length:
            return self.__value[key]
        
        else:
            return 'index error'
          
    #向数组中添加元素   
    def append(self,n):
        if isinstance(n,(int,float)):
            self.__value.append(n)
        else:
            print('isinstance error')
            
    def __repr__(self):
        return repr(self.__value)

注:重载运算中用到zip()函数用于将可迭代对象作为参数,将对象中对应的元素打包成元组,然后返回由这些元组组成的列表

完成了自定义数组类的定义.接下来就是对类的调用.是骡子是马拉出来溜溜

创建数组:

a=MyNArrays(1,2,3,4,5,6)
b=MyNArrays(7,8,9,10,11,12)

print('数组a：',a)
print('数组b：',b)

执行结果:

数组a： [1, 2, 3, 4, 5, 6]
数组b： [7, 8, 9, 10, 11, 12]

数组的运算:

print('a+b：',a+b)

print('a和b的内积为：', a.dot(b))

执行结果:

a+b： [8, 10, 12, 14, 16, 18]
a和b的内积为： 217

数组的增删改查操作

print('2是否为a的元素：',2 in a)
a.append(17)
print('a添加元素17：',a)
print('查看a的第3各元素值：',a[2])
a[6]=15
print('修改最后一项值为15：',a)

执行结果:

2是否为a的元素： True
a添加元素17： [1, 2, 3, 4, 5, 6, 17]
查看a的第3各元素值： 3
修改最后一项值为15： [1, 2, 3, 4, 5, 6, 15]