基本数据类型就是：整型、浮点型、字符串型

列表元组等是高级的数据类型；

内存是用来 存储数据，并直接跟CPU连接，即CPU读取内存里面的内容；内存的基本单位是以字节来存储单元的，一共字节是八位；计算机的存储空间是作为一个整体的空间，这个空间以字节来作为最小的存储单元，每个字节是由八位构成，当计算机需要寻找存储空间的某元素的时候，会根据字节的编号寻 找，即每次 能读取八个位也就是一共字节，对于三十二位的计算机，一共基本整型需要占四个字节，例如对于一个整型  int a =1,在计算机内部以二进制存储，占四个字节每个字节八位，其中前三个字节的八个位都存的0，最后一共字节前七个位存的0，最后一个位存的1，这样就完成了整型1在计算机里面的存储；

字符（char），一个字符占一个字节

一个列表是以顺序表的形式存储，即第一个元素存储之后，紧接着第二个元素开始存储，这样找出了第一个元素的位置，后面元素的位置也就相应的找出来了；操作系统会一次性给出列表所需的内存，以整体给出；

因此编号从0 开始，其实就是位置在第一个初始位置的偏移量，第一个位置偏移0，第二个位置偏移1，

当列表中 存储的是不同类型的数据形式的时候，则不能按照上面的顺序表来计算了；

因此需要用地址来存取，即存储元素的位置的编号，每个地址的大小不一样，根据元素大小来确定其大小，但是每一个地址的大小一样，都是四个字节       地址指向需要存的数据      ，这种方法叫做元素外置的方法；

综上所述，顺序表有两种基本的形式，内置和外置，其中内置是直接存取元素，外置是先存数据的位置，在通过位置找到其对应 的元素；

python已经对顺序表进行封装，不需要自行设置；

通常顺序表还会有一个表头信息，表头信息包含容量和元素个数

链表：

链表是每出现一个数据就申请相应的空间存储起来，各元素之间的存储是无序的，然后让每一个存储数据的位置多出一部分，这一部分存储指向下一个数据的位置内容，从而形成链表；这种方式不会先计算整个数据结构所需的存储空间的，而是出现一个存储一个；即需要两个位置，第一个叫数据区，第二个叫链接区；链表和顺序表统称为线性表；最后一个位置的链接区指向空；

python中等号只是说明一个指向，等号左边的内容指向右边的内容

#视频课程内容
#定义一个节点的代码
class Node(object):#顶一个一个节点
    def __init__(self,element):
        self.element=element
        self.next=None#此时节点还没有串起来，因此指向None，
'''
node=node1
node=node2#实现链表中各个节点的的传递
'''
class Singlelinklist(object):#此时的单链表就是一个新的数据类型，这个数据类型含有一些数据，同时支持以下几种访问的方法
    def __init__(self,node=None):#不传入node的时候是空的链表
        self._head=node#新定义的单链表中包含的元素是节点，里面包括元素内容和next
        #且是一个私有属性，即只能内部访问，即单链表中的元素是内部私有属性
    def is_empty(self):
        return self._head==None
    def length(self):
        cur=self._head#用来移动遍历节点
        count=0#用来记录数量
        while cur != None:
            count+=1
            cur=cur.next
        return count
    def travel(self):
        cur=self._head
        while cur!=None:
            print(cur.element,end='  ')
            cur=cur.next
    def append(self,item):#尾部添加元素
        node=Node(item)
        cur=self._head
        if self.is_empty():
            self._head=node
        else:
            while cur.next!=None:
               cur=cur.next
            cur.next=node
    def add(self,item):#在头部增加元素
        node=Node(item)
        if self.is_empty():
            self._head=node
        else:
            node.next=self._head
            self._head=node 
    def insert(self,pos,item):#在指定位置添加元素,在pos之前加入
        node=Node(item)
        #通过定义前一个节点pre来达到插入的效果
        if pos <=0:
            self.add(item)
        elif pos >self.length()-1 :
            self.append(item)
        else:
            pre=self._head
            count=0
            while count<pos-1:
                count+=1
                pre=pre.next
            node.next=pre.next
            pre.next=node
            
    def remove(self,item):
        if not self.is_empty():
            pre=self._head
            if pre.element==item:
                self._head=pre.next            
            else:
                while  pre.next.element!=item:
                    pre=pre.next
                cur=pre.next
                pre.next=cur.next
            return self.travel()
        else:
            raise ValueError("item don't exist")
    def search(self,item):
        cur=self._head
        while cur!=None:
            if cur.element==item:
                return True
            else:
                cur=cur.next
        return False 
if __name__=='__main__':
        ll=Singlelinklist() #构建了一个空的单链表，里面有_head属性
        print(ll.is_empty())
        print(ll.length())
        ll.append(1)
        ll.append(2)
        ll.append(3)
        ll.length()
        ll.add(8)
        ll.insert(-1,5)
        ll.travel()
        print('\n')
        ll.remove(2)

#双向链表

class Doublelinklist(Singlelinklist):#继承单链表的长度、是否位空、遍历以及查找这几种方法
       def __init__(self,node=None):
           self._head=node
           self.__next=None
           self.__prev=None
#这些标注了的方法可以重新定义，也可以继承
#       def is_empty(self):
#           return self._head==None
#       def length(self):
#           cur=self._head#用来移动遍历节点
#           count=0#用来记录数量
#           while cur != None:
#              count+=1
#              cur=cur.next
#           return count
#       def travel(self):
#           cur=self._head
#           while cur!=None:
#              print(cur.element,end='  ')
#              cur=cur.next
       def  add(self,item):#头部插入元素
           node=Node(item)
           node.next=self._head#建立向后索引的指针
           self._head=node#定义新的头节点
           node.next.prev=node#向前添加指针
       def append(self,item):#在链表的尾部添加元素
           node=Node(item)
           if self.is_empty():
               self._head=node
           else:
               cur=self._head
               while cur.next !=None:
                   cur=cur.next
               cur.next=node
               node.prev=cur
       def  insert(self,pos,item):#在指定位置插入
           node=Node(item)
           if self.is_empty():
               self._head=node
           elif pos==self.length()-1:
               self.append(item)            
           else:
               cur=self._head
               count=0
               while count<pos:#这种算法还是需要从头节点开始遍历到指定位置
                   cur=cur.next
                   count+=1
               cur.prev.next=node
               node.prev=cur.prev
               node.next=cur
               cur.prev=node
              
               
       def remove(self,item):
           cur=self._head
#           pre=None
#           while cur!=None:
#               if cur.element==item:
#                   if cur==self._head:
#                       self._head=cur.next
#                   else:
#                       pre.next=cur.next
#                   break
#               else:
#                   pre=cur
#                   cur=cur.next         
           if cur.next==None:#序列为空的时候
               return None
           else:
               while cur !=None:
                   if cur.element==item:
                       if cur==self._head:
                           self._head=cur.next
                       elif  cur.next==None:
                           cur.prev.next=None
                       else:
                           cur.prev.next=cur.next
                           cur.next.prev=cur.prev
                       break
                   else:
                       cur=cur.next
           return self.travel()
#       def search(self,item):
#           cur=self._head
#           while cur!= None:
#                if cur.element==item:#由于定义node的时候已经调用了Node类，故已经有了ele属性
#                    return True
#                else:
#                    cur=cur.next
#           return False                                
        
if __name__=='__main__':
        ll=Doublelinklist() #构建了一个空的单链表，里面有_head属性
        print(ll.length())
        #print(ll.is_empty)
        ll.append(1)
        ll.append(2)
        ll.append(3)
        ll.add(8)
        ll.insert(1,5)
        ll.travel()
        print('\n')
        ll.remove(2)

单向循环链表

  #单向循环链表
class Singlelinklist(object):#此时的单链表就是一个新的数据类型，这个数据类型含有一些数据，同时支持以下几种访问的方法
    def __init__(self,node=None):#不传入node的时候是空的链表
        self._head=node
        if node:#如果传入了一个节点，需要回到它本身
             node.next=node
    def is_empty(self):
        return self._head==None
    def length(self):
        cur=self._head#用来移动遍历节点
        if self.is_empty():
            return 0
        count=1#用来记录数量
        while cur.next != self._head:#尾节点判别需要修改
            count+=1
            cur=cur.next
        return count
    def travel(self):
        cur=self._head
        while cur.next!=self._head:
            print(cur.element,end='  ')
            cur=cur.next
        print(cur.element)#最后一个节点需要单独打印
        
    def append(self,item):#尾部添加元素
        node=Node(item)
        cur=self._head
        if self.is_empty():
            self._head=node
            node.next=node
        else:
            while cur.next!=self._head:
               cur=cur.next
            cur.next=node
            node.next=self._head
            
    def add(self,item):#在头部增加元素
        node=Node(item)
        if self.is_empty():
            self._head=node
            node.next=node
        else:
            cur=self._head
            while cur.next != self._head:
                cur=cur.next
            cur.next=node    
            node.next=self._head
            self._head=node 
            
    def insert(self,pos,item):#在指定位置添加元素,在pos之前加入
        node=Node(item)
        #通过定义前一个节点pre来达到插入的效果
        if pos <=0:
            self.add(item)
        elif pos >self.length()-1 :
            self.append(item)
        else:
            pre=self._head
            count=0
            while count<pos-1:
                count+=1
                pre=pre.next
            node.next=pre.next
            pre.next=node
            
    def remove(self,item):
        if not self.is_empty():
            pre=self._head
            cur=self._head
            prex=None
            if self._head.element==item:                
                self._head=None
                return None
            while cur.next != self._head:
                prex=cur
                cur=cur.next
            if pre.element==item:  #头节点              
                cur.next=pre.next
                self._head=pre.next
                return self.travel()
            elif cur.element==item:#尾节点
                prex.next=self._head           
            else:
                while  pre.next.element!=item:
                    pre=pre.next
                cur=pre.next
                pre.next=cur.next
            return self.travel()
        else:
            raise ValueError("item doesn't exist")
          
    def search(self,item):
        if self.is_empty():
            return False
        cur=self._head
        while cur.next != self._head :
            if cur.element==item:
                return True
            else:
                cur=cur.next
        if cur.element==item:
            return True
        else:
            return False        
 
#方法必须带上括号，属性不需要带上括号        
if __name__=='__main__':
        ll=Singlelinklist() #构建了一个空的单链表，里面有_head属性        
        print(ll.length())
        print(ll.is_empty())
        
        print(ll.search(5))        
        ll.append(1)
        ll.remove(1)
        ll.append(2)
        ll.append(3)
        ll.add(8)
        ll.insert(1,5)
        ll.travel()
        print('\n')
        ll.remove(3)
        print(ll.search(5))  

在面向对象的编程中，如果希望某个类中的属性只能通过类里面定义的方法来访问，而不能直接由类的实例访问属性，则将类定义成私有变量，即名称前加入两个下划线，如果要通过外部访问，那么这个私有变量的名称在内部已经变成了  下划线+类名+双下划线+属性名