單向連結串列：

class error(Exception):
    def __init__(self,msg):
        super(error,self).__init__()
        self.msg=msg
    def __str__(self):
        return self.msg    
class Node:
    def __init__(self,ele):
        self.ele=ele
        self.next=None
class mylist:
    def __init__(self,ele=None):
        self.index
 
=0
        self.pos=0
        if ele:
            self._head=Node(ele)
        else:
            self._head = None
    def __iter__(self):
        return self
    def __next__(self):
        if self.pos < self.length():
            self.pos += 1
            cursor = self._head
            current=cursor
            num 
 
= 0
            while cursor != None:
                current = cursor
                cursor = cursor.next
                num += 1
                if num == self.pos:
                    return current.ele
        else:
            raise StopIteration
    def empty(self):
        return  self._head==None
    
 
def add(self,item):
        node=Node(item)
        node.next=self._head
        self._head=node
    def length(self):
        cur=self._head
        num=0
        if cur:
            num+=1
            while cur.next:
                cur=cur.next
                num+=1
            return num
        else:
            return num      
    def append(self,item):
        node=Node(item)
        cursor=self._head
        if self.empty():
            self._head = node
        else:
            while cursor.next!= None:
                cursor = cursor.next
            cursor.next=node
    def pop(self):
        if self.empty():
            return None
        else:
            if self.length()==1:
                ele=self._head.ele
                self._head.ele=None
                return ele
            else:
                cur=self._head
                current=cur
                while cur.next!=None:
                    current=cur
                    cur=cur.next 
                    ele=cur.ele
                current.next=None
                return ele
    def insert(self,index,item):
        if index<0 or index>self.length():
            raise error("out of range")
        else:
            if index==0:
                self.add(item)
            elif index==self.length():
                self.append(item)
            else:
                node = Node(item)
                cur=self._head
                pre=0
                while pre<index-1:
                    cur=cur.next
                    pre+=1
                node.next=cur.next
                cur.next=node     
    def get(self,index):
        if index<0 or index>self.length()-1:
            raise error("out of range")
        else:
            num=0
            cur=self._head
            while num<index:
                cur=cur.next
                num+=1
            return cur.ele
    def remove(self,item):
        cur=self._head
        pre=None
        while cur!=None:
            if cur.ele==item:
                if pre==None:
                    self._head=cur.next
                else:    
                    pre.next=cur.next
                break    
            else:
                pre=cur
                cur=cur.next    
    def delete(self,index):
        if index<0 or index>self.length()-1:
            raise error("out of range")
        else:
            if index==0:
               self._head=self._head.next
            else:
                num=1
                current=self._head
                cur=current.next
                while num!=index:
                    current=cur
                    cur=current.next
                    num+=1
                current.next=cur.next
                cur.ele=None
                cur.next=None

棧：

class stack:
    def __init__(self):
        self._box=[]
    def empty(self):
        return self._box==[]
    def length(self):
        return len(self._box)
    def push(self,item):
        self._box.append(item)
    def pop(self):
        return self._box.pop()