数据结构：链表（python版） 续：增加比较函数

题目：

基于元素相等操作“==”定义一个单链表的相等比较函数。另请基于字典序的概念，为链表定义大于，小于，大于等于，小于等于的判断

 class LList:

     """
     省略已实现部分
     """

     #根据索引获得该位置的元素
     def __getitem__(self, key):
         if not isinstance(key, int):
             raise TypeError
         if 0<=key<len(self):
             p = self._head
             num = -1
             while p:
                 num += 1
                 if key == num:
                     return p.elem
                 else:
                     p = p.next
         else:
             raise IndexError

     #判断两个列表是否相等 ==
     def __eq__(self, other):
         #两个都为空列表 则相等
         if len(self)==0 and len(other)==0:
             return True
         #两个列表元素个数相等 当每个元素都相等的情况下 两个列表相等
         elif len(self) == len(other):
             for i in range(len(self)):
                 if self[i] == other[i]:
                     pass
                 else:
                     return False
             #全部遍历完后则两个列表相等
             return True
         #两个列表元素个数不相等 返回Fasle
         else:
             return False
     #判断两个列表是否不相等 ！=
     def __ne__(self, other):
         if self.__eq__(other):
             return False
         else:
             return True
     # >
     def __gt__(self, other):
         l1 = len(self)
         l2 = len(other)
         if not isinstance(other, LList):
             raise TypeError
         # 1.len(self) = len(other)
         if l1 == l2:
             for i in range(l1):
                 if self[i] == other[i]:
                     continue
                 elif self[i] < other[i]:
                     return False
                 else:
                     return True
             #遍历完都相等的话说明两个列表相等 所以返回False
             return False
         # 2.len(self) > len(other)
         if l1 > l2:
             for i in range(l2):
                 if self[i] == other[i]:
                     continue
                 elif self[i] < other[i]:
                     return False
                 else:
                     return True
             #遍历完后前面的元素全部相等 则列表个数多的一方大
             #if self[l2-1] == other[l2-1]:
             return True
         # 3.len(self) < len(other)
         if l1 < l2:
             for i in range(l1):
                 if self[i] == other[i]:
                     continue
                 elif self[i] < other[i]:
                     return False
                 else:
                     return True
             #遍历完后前面的元素全部相等 则列表个数多的一方大
             #if self[l2-1] == other[l2-1]:
             return False
     # <
     def __lt__(self, other):
         #列表相等情况下>会返回False,则<这里判断会返回True,有错误.所以要考虑在==的情况下也为False
         if self.__gt__(other) or self.__eq__(other):
             return False
         else:
             return True
     # >=
     def __ge__(self, other):
         """
         if self.__eq__(other) or self.__gt__(other):
             return True
         else:
             return False
         """
         #大于等于和小于是完全相反的，所以可以依靠小于实现
         if self.__lt__(other):
             return False
         else:
             return True
     # <=
     def __le__(self, other):
         """
         if self.__eq__(other) or self.__lt__(other):
             return True
         else:
             return False
         """
         ##小于等于和大于是完全相反的，所以可以依靠大于实现
         if self.__gt__(other):
             return False
         else:
             return True