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的運行時間最短。這個沒有具體去看，留待以后...
?

轉載于:https://www.cnblogs.com/lipx9527/p/11071427.html

總結

以上是生活随笔為你收集整理的python将某个列表按元素值分成多个子列表的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。