Python 基于条件将列表切片为子列表

我想把这个数字列表切分：

num_list = [97, 122, 99, 98, 111, 112, 113, 100, 102] 

分为多个子列表。切片的条件是每个子列表中的数字应按递增顺序排列

因此最终结果如下所示：

 list_1 = [97, 122]
 list_2 = [99]
 list_3 = [98, 111, 112, 113]
 list_4 = [100, 102]

---

有谁能帮我解决这个问题吗？非常感谢

我很快就写了一种方法来实现这一点，我相信还有更有效的方法，但这至少是有效的：

num_list =[97, 122, 99, 98, 111, 112, 113, 100, 102]

arrays = [[num_list[0]]] # array of sub-arrays (starts with first value)
for i in range(1, len(num_list)): # go through each element after the first
    if num_list[i - 1] < num_list[i]: # If it's larger than the previous
        arrays[len(arrays) - 1].append(num_list[i]) # Add it to the last sub-array
    else: # otherwise
        arrays.append([num_list[i]]) # Make a new sub-array 
print(arrays)

num_list=[971229998111112113100102]
arrays=[[num_list[0]].#子数组的数组（从第一个值开始）
对于范围内的i（1，len（num_list））：#遍历第一个元素之后的每个元素
如果num_list[i-1]

---

希望这对您有所帮助：）

不建议创建数量可变的变量。使用列表或字典代替。下面是一个使用

dict

和生成器函数的示例：

from itertools import islice, zip_longest

def yield_lists(L):
    x = []
    for i, j in zip_longest(L, islice(L, 1, None), fillvalue=L[-1]):
        x.append(i)
        if i > j:
            yield x
            x = []
    yield x

num_list = [97, 122, 99, 98, 111, 112, 113, 100, 102]

res = dict(enumerate(yield_lists(num_list), 1))

结果：

{1: [97, 122],
 2: [99],
 3: [98, 111, 112, 113],
 4: [100, 102]}

---

例如，通过

res[2]

访问第二个列表这里有一个单线性Numpythonic方法：

np.split(arr, np.where(np.diff(arr) < 0)[0] + 1)

np.split（arr，np.where（np.diff（arr）<0）[0]+1）

或类似于numpy代码但效率较低的方法：

from operator import sub
from itertools import starmap
indices = [0] + [
                  i+1 for i, j in enumerate(list(
                        starmap(sub, zip(num_list[1:], num_list)))
                    ) if j < 0] + [len(num_list)
                ] + [len(num_list)]

result = [num_list[i:j] for i, j in zip(indices, indices[1:])]

来自操作员导入子系统
从itertools导入星图
指数=[0]+[
i+1表示枚举中的i，j（列表(
星图（sub，zip（num_list[1:]，num_list）））
)如果j<0]+[len（num_列表）
]+[len（num_列表）]
结果=[num_list[i:j]表示zip中的i，j（索引，索引[1:]）]

演示：

#Numpy
在[8]中：np.split（num_list，np.where）（np.diff（num_list）<0）[0]+1）
出[8]：
[数组（[97122]），
数组（[99]），
数组（[98111112113]），
数组（[100102]）]
#蟒蛇
In[42]：从操作员导入子对象
在[43]：从itertools导入星图
在[44]中：索引=[0]+[i+1表示枚举中的i，j（列表（星图（sub，zip（num_列表[1:]，num_列表））），如果j<0]+[len（num_列表）]
在[45]中：[num_list[i:j]表示i，j在zip中（索引，索引[1:]）]
出[45]：[97122]，[99]，[98111112113]，[100102]]

说明：

---

使用

np.diff（）

可以获得每个项目与其下一个项目的差异（直到最后一个元素）。然后，您可以使用numpy的矢量化特性来获得该差异为负值的位置的索引，这可以通过简单的比较和

np.where（）

完成。最后，您只需将索引传递到

np.split（）

，即可根据这些索引拆分数组。

这里所有的解决方案都很好。也许这一条对某些人来说更容易理解

def increasing(a, b):
    return a < b

def seq_split(lst, cond):
    sublst = [lst[0]]
    for item in lst[1:]:
        if cond(sublst[-1], item):
            sublst.append(item)
        else:
            yield sublst
            sublst = [item]
    if sublst:
        yield sublst

list(seq_split(num_list, increasing))

def增加（a，b）：
返回a

理想解决方案，Win的生成器出于好奇，

np.diff（num\u list）

数组的最后一个元素是什么？因为最后一个元素没有下一项。@Guimoute最后一个元素没有差异。我喜欢这种方法，它非常吸引人！但是，你能详细说明一下[0]+1部分吗？我不太明白这部分是如何工作的。@storluffarn

[0]

选择

np的第一个索引。其中

结果，因为它倾向于返回一个列表，它的长度等于传递给函数的数组的索引数（这里是

np.diff（num_list）<0

）。

+1

是因为

split

是如何工作的。我们添加了

+1

，在diff条件为真的索引之后进行拆分。非常感谢！

def increasing(a, b):
    return a < b

def seq_split(lst, cond):
    sublst = [lst[0]]
    for item in lst[1:]:
        if cond(sublst[-1], item):
            sublst.append(item)
        else:
            yield sublst
            sublst = [item]
    if sublst:
        yield sublst

list(seq_split(num_list, increasing))