基于数组的数据结构

序列类型：列表类list、元组类tuple、字符串类str;都支持下标索引

计算机主存称为随机存储存储器，RAM；

sys.getsizeof(data)可以得到data所占的字节数；

#动态数组的实现
import ctypes #这以模块能创建底层数组
class Danamicarray:
    def __init__(self):
    
        self._n=0#长度
        self._capacity=1 #容纳能力
        self._A=self._make_array(self._capacity)#创建指定容量的数组A
    
   def __len__(self):
        return self._n
   def __getitem__(self,k):
       if not 0<=k<=self._n:
           raise IndexError('Invalid index')
       return self._A[k]
   def append(self,obj):
       if self._n==self._capacity:
           self._resize(2*self._capacity)#按两倍来扩容
       self._A[self._n]=obj
       self._n+=1
    def resize(self,c):#将容量扩展到c
        B=self._make_array(c)#从新定义尺寸的时候，系统会新建一个序列
        for k in range(self._n):
            B[k]=self._A(k)
        self._A=B
        self._capacity=c
        
    def _make_array(self,c)#新建一个容量为c的序列
        return (c*ctypes.py_object)()

元组比列表的内存利用效率更高，因为元组是固定不变的；

count方法，检索整个序列，然后返回第一次出现的位置，这个方法整个序列都会检索完

index 方法和 __contains__方法是从头开始检索，一旦出现则退出，因此最多检索n个；

append 是在最后插入元素，如果位置不够则扩容

insert 在固定位置插入元素，然后将其后面的元素依次向后移动，因此是n-k +1的时间复杂度，在开头插入耗时最多；

pop()删除最后一个元素，直接删除 为O（1)

pop(k)删除位置k的元素，然后将其后的元素依次迁移，因此删除第一个是最耗时的；

remove（‘s'） 删除指定的元素，而且只删除列表中第一次出现的位置，这个方法会从头开始检索，直到找到该值，然后将其后的元素依次前移，因此时间复杂度是固定的，为n

def remove(self,value):#remove方法
    for k in range(self._n):
        if self._A[k]==value:
            for j in range(k,self._n-1):
                self._A[j]=self._A[j+1]
            self._A[self._n-1]=None
            self._n-=1
            return 
    raise ValueError

data.extend([other]) 将列表加入到data 的尾部,该方法与：

for ele in other:

    data.append(ele) 效果一样，但是extend方法更高效，因为这种方法最多将底层数组扩容一次，但是append可能要多次扩容；

letter=''.join(a for a in doc if c.isalpha())
#使用生成器从一个字符串中寻找后生成新的字符串最高效

排序算法：

#将一个序列由大到小排序，将每一个元素与前面的元素相比，较小则放到前一个位置
A=[1,0,8,58,37,9,2,4,1,7]
for k in range(1,len(A)):
    cur=A[k]
    j=k
    while j>0 and A[j-1]>cur:
        A[j]=A[j-1]
        j-=1
    A[j]=cur
print(A)

class Caesaicipher:#对字符串类型的string实现凯撒密码的加密
    def __init__(self,shift):
        encoder=[None]*26
        decoder=[None]*26
        for k in range(26):
            encoder[k]=chr((k+shift)%26+ord('A'))#加密时对应的编码
            decoder[k]=chr((k-shift)%26+ord('A'))#解密时对应的编码
        self._forward=''.join(encoder)
        self._backward=''.join(decoder)
    def encrypt(self,message):
        return self._transform(message,self._forward)
    def decrypt(self,secret):
        return self._transform(secret,self._backward)
    def _transform(self,original,code):
        msg=list(original)
        for k in range(len(msg)):
            if msg[k].isupper():
                j=ord(msg[k])-ord('A')
                msg[k]=code[j]
            return ''.join(msg)
     
if __name__=='__main__':
    ciper=Caesaicipher(3)#设置shift是3
    message='HOWIUE EHVIOWV HVIOWV'
    coded=ciper.encrypt(message)
    print('secret is :',coded)
    answer=ciper.decrypt(coded)
    print('message is :',answer)

创建多维二维数组：

[[0]*3 for j in range(4)] #创建了一个4*3的二维数组