如何用Pythonic方案按kubernetes_pod_name序列拆分字典列表

现有包含多个字典的列表l1，每个字典包含kubernetes_pod_name、resolution_ms、value字段。需要将其转换为嵌套列表，每一组包含完整的kubernetes_pod_name值序列（如1、2、3、4），当序列重复时自动拆分，用于后续数据展示。

原列表示例：

l1 = [
    {"kubernetes_pod_name": "1", "resolution_ms": 10, "value": 100},
    {"kubernetes_pod_name": "2", "resolution_ms": 10, "value": 200},
    {"kubernetes_pod_name": "3", "resolution_ms": 10, "value": 300},
    {"kubernetes_pod_name": "4", "resolution_ms": 10, "value": 400},
    {"kubernetes_pod_name": "1", "resolution_ms": 10, "value": 102},
    {"kubernetes_pod_name": "2", "resolution_ms": 10, "value": 302},
    {"kubernetes_pod_name": "3", "resolution_ms": 10, "value": 567},
    {"kubernetes_pod_name": "4", "resolution_ms": 10, "value": 850},
    # ... 更多元素
]

期望转换后的嵌套列表示例：

result = [
    [
        {"kubernetes_pod_name": "1", "resolution_ms": 10, "value": 100},
        {"kubernetes_pod_name": "2", "resolution_ms": 10, "value": 200},
        {"kubernetes_pod_name": "3", "resolution_ms": 10, "value": 300},
        {"kubernetes_pod_name": "4", "resolution_ms": 10, "value": 400}
    ],
    [
        {"kubernetes_pod_name": "1", "resolution_ms": 10, "value": 102},
        {"kubernetes_pod_name": "2", "resolution_ms": 10, "value": 302},
        {"kubernetes_pod_name": "3", "resolution_ms": 10, "value": 567},
        {"kubernetes_pod_name": "4", "resolution_ms": 10, "value": 850}
    ]
    # ... 更多分组
]

方法1：基于起始标记的分组（适合固定以"1"开头的序列） #

利用迭代器遍历列表，每次遇到kubernetes_pod_name为"1"的元素就开启新分组，收集后续元素直到下一个"1"出现：

def group_pod_sequences(lst):
    it = iter(lst)
    result = []
    while True:
        try:
            current_group = []
            # 取出起始元素并加入分组
            first_item = next(it)
            current_group.append(first_item)
            # 收集后续元素，直到遇到下一个起始标记
            for item in it:
                if item["kubernetes_pod_name"] == "1":
                    # 将该元素放回迭代器，供下一轮处理
                    it = [item] + list(it)
                    break
                current_group.append(item)
            result.append(current_group)
        except StopIteration:
            break
    return result

# 调用示例
result = group_pod_sequences(l1)

方法2：基于预期序列的通用分组（支持自定义序列） #

如果你的pod名称序列不是固定的1-4，可以先定义预期的序列顺序，按序列循环匹配分组：

from itertools import cycle

def group_by_sequence(lst, expected_sequence):
    seq_cycle = cycle(expected_sequence)
    result = []
    current_group = []
    expected_next = next(seq_cycle)
    
    for item in lst:
        pod_name = item["kubernetes_pod_name"]
        if pod_name == expected_next:
            current_group.append(item)
            expected_next = next(seq_cycle)
            # 当当前组长度等于预期序列长度时，完成一组
            if len(current_group) == len(expected_sequence):
                result.append(current_group)
                current_group = []
                # 重置序列循环，准备下一组
                seq_cycle = cycle(expected_sequence)
                expected_next = next(seq_cycle)
    # 可选：如果有未完成的分组，是否保留（根据需求调整）
    if current_group:
        result.append(current_group)
    return result

# 调用示例，指定预期序列为["1","2","3","4"]
result = group_by_sequence(l1, ["1","2","3","4"])

方法3：使用itertools.groupby分组（基于分组编号） #

先给每个元素分配分组编号（每遇到一个"1"就递增编号），再用groupby按编号分组：

from itertools import groupby

def group_pod_sequences_groupby(lst):
    group_num = 0
    groups_info = []
    # 给每个元素标记所属分组编号
    for item in lst:
        if item["kubernetes_pod_name"] == "1":
            group_num += 1
        groups_info.append( (group_num, item) )
    # 按分组编号聚合
    result = []
    for _, group in groupby(groups_info, key=lambda x: x[0]):
        result.append( [item for _, item in group] )
    return result

# 调用示例
result = group_pod_sequences_groupby(l1)

内容的提问来源于stack exchange，提问作者James Xu