从列表 Python 列表中的特定点循环答案

【问题标题】：Loop from a specific point in a list of lists Python从列表 Python 列表中的特定点循环
【发布时间】：2026-01-28 23:45:01
【问题描述】：

我想在特定点之后将现有列表列表的所有元素附加到新列表

m = [[1,2,3],[4,5,10],[6,2,1]]
specific point = m[0][2]
newlist = [3,4,5,10,6,2,1]

【问题讨论】：

子列表的大小是否相等？
是的，例如。全长为 2，或全长为 5

标签： python list nested-lists flatten

【解决方案1】：

这里有一些函数式方法可以有效地迭代您的数据。

如果子列表大小均匀，并且您知道从哪里开始提取元素的索引，请使用chain + islice：

from itertools import chain, islice
n = 3 # Sublist size.
i,j = 0,2
newlist = list(islice(chain.from_iterable(m), i*n + j, None))

如果您事先不知道子列表的大小，可以使用next 丢弃数据的第一部分。

V = chain.from_iterable(m)
next(v for v in V if v == m[i][j])
newlist = list(V)
newlist.insert(m[i][j], 0)

这假设在序列的前面没有相同的值。

【讨论】：

这些解决方案有点太高级了，我希望使用更基本的代码。不过还是谢谢

【解决方案2】：

您可以直接切掉第一个目标列表的其余部分，然后添加所有后续元素，例如：

m = [[1,2,3],[4,5,10],[6,2,1]]
y, x = 0, 2
new_list = m[y][x:] + [v for el in m[y+1:] for v in el]
# [3, 4, 5, 10, 6, 2, 1]

【讨论】：

【解决方案3】：

您可以在迭代中添加条件，并且仅基于该条件添加。一旦你达到了那个特定的指数，就让你的条件为真。像这样的：

m = [[1,2,3],[4,5,10],[6,2,1]]
specific_point = (0,2)
newlist = [3,4,5,10,6,2,1]


output = []
for i in range(len(m)):
    for j in range(len(m[i])):
        if (i,j) < specific_point:
            continue

        output.append(m[i][j])

输出：

[3, 4, 5, 10, 6, 2, 1]

【讨论】：

这似乎是最基本的方法，谢谢。我回家后会仔细检查它是否有效
您也可以将其滚动到列表组合中，例如：output = [v for y, r in enumerate(m) for x, v in enumerate(r) if (y, x) >= specific_point]...

【解决方案4】：

为什么不展平初始列表并从那里开始

flat_list = [item for sublist in m for item in sublist]

会返回 [1,2,3,4,5,10,6,2,1] 所以现在你真的在 flat_list[2:]

【讨论】：

在一个以specific_point为输入的函数中，即def find_value(m, specific_point)
对，但是一旦你展平列表，你所要做的就是根据特定点计算切片的第一个索引
只是指出，这将创建一个新的扁平列表，然后flat_list[:2] 将创建另一个带有切片元素的列表。
@vencaslac 你是对的，但这仅在 specific_point[0] 为 0 时有效。例如，如果特定点是 [2,1] 怎么样。
2xlen(sublist)+1

【解决方案5】：

大多数答案仅适用于这种特定形状的嵌套列表，但也可以创建一个适用于任何形状的嵌套列表的解决方案。

def flatten_from(sequence, path=[]):
    start = path.pop(0) if path else 0
    for item in sequence[start:]:
        if isinstance(item, (list, tuple)):
            yield from flatten_from(item, path)
        else:
            yield item

用问题中的例子

>>> list(flatten_from([[1, 2, 3], [4, 5, 10], [6, 2, 1]], [0, 2]))
[3, 4, 5, 10, 6, 2, 1]

它也适用于输入数据的任何形状和嵌套级别

m = [[1], [[2], [3, 4, 5, 6, 7]], 8, [9, [10, 11]]]

flatten_from(m, []))       # 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
flatten_from(m, [2])       # 8, 9, 10, 11
flatten_from(m, [1, 1, 3]) # 6, 7, 8, 9, 10, 11

不过，这有点像个混蛋算法。一方面，它使用了很好的函数式编程概念：递归和产量。

另一方面，它依赖于使用list.pop 改变路径参数的副作用，因此它不是一个纯函数。

【讨论】：

【解决方案6】：

以下解决方案适用于您的情况，您的数组仅限于列表列表，并且“子列表”的大小始终保持一致，即您的情况为“3”

m = [[1,2,3],[4,5,10],[6,2,1]]                                  #input 2D array
a, b = 0, 2                                                     #user input --> specific point a and b
flat_list_m = [item for firstlist in m for item in firstlist]   #flat the 2D list
print (flat_list_m[len(m[0])*a+b:])                             #print from specific position a and b, considering your sublist length is consistent throughout.

我希望这会有所帮助！ :)

【讨论】：