python将某个列表按元素值分成多个子列表

1. 将原列表排序，当相邻元素不同时，对原列表进行切片。

def cutList1(orList):

    orList.sort()  # 列表排序。默认从小到大
    newList = []  # 空列表

    n = 0    # 每次切片的起点
    for k in range(len(orList)):
        if orList[k] == orList[-1]:  # 由于排过序，则当orList[k]等于列表最后一个元素值时，可以切片后退出循环
            newList.append(orList[n:])  # 从orList[k]取到最后
            break   # 退出循环
        if orList[k] != orList[k+1]:  # 由于排过序，相邻元素不等时，就表示切子列表的时候到了
            subList = orList[n:k+1]   # 切片
            newList.append(subList)
            n = k+1   # n用于储存每次切片的起点
    return newList

myList1 = [4, 2, 1, 2, 2, 1, 1, 5, 6, 5, 4]
print (cutList1(myList1))   # [[1, 1, 1], [2, 2, 2], [4, 4], [5, 5], [6]]

2. set去重先，之后计算每个元素在原列表的个数，接着直接按每个元素的个数生成新列表，最后放在一个大列表中

def cutList2(orList):

    newSeqAfterSet = set(orList)  # set去重。默认从小到大排序
    newList = []
    for k in newSeqAfterSet:
        kCount = orList.count(k)  # 计算每个元素在元列表中的个数
        kList = [k]*kCount  # 生成新列表
        newList.append(kList)
    return newList

myList2 = [4, 2, 1, 2, 2, 1, 1, 5, 6, 5, 4]
print (cutList2(myList2))   # [[1, 1, 1], [2, 2, 2], [4, 4], [5, 5], [6]]

3. 拿列表第一个元素出来，放在临时变量中，之后循环原列表，取出相同的值，之后移除这个元素...之后循环这个操作

def cutList3(orList):

    copyList = deepcopy(orList)  # copy列表用于移除元素，保持原列表完整性

    newList = []
    while 1:
        if copyList == []:  # copy列表为空时退出while循环
            break
        
        # 每次while循环都更新firstElement值，并将eleList重置为空
        firstElement = copyList[0]  # copy列表第一个元素
        eleList = []  # 子列表
        for ele in orList:
            if ele == firstElement:
                eleList.append(ele)  
                copyList.remove(ele) # 移除元素。for循环完成后，原列表和第一个元素相等的所有元素已经取出
                # 且从copy列表中移除了这些元素
        
        newList.append(eleList)  

    return newList

myList3 = [4, 2, 1, 2, 2, 1, 1, 5, 6, 5, 4]
print (cutList3(myList3))  # [[4, 4], [2, 2, 2], [1, 1, 1], [5, 5], [6]]

4. 从上面可以看出
　　4.1 方法1和2都将新生成的列表进行排序过，方法3则时按元素出现顺序排序
　　4.2 方法1会导致原列表被破环排序，使用前应该事先将其深复制一份
　　4.3 从效率上看，应该是方法2的运行时间最短。这个没有具体去看，留待以后...