Python嵌套列表迭代处理：首元素重复且次元素不同时更新首元素

现有如下嵌套列表：

unq_act = [[15, 'F7'],
 [45, 'F7'],
 [17, 'F7'],
 [19, 'F7'],
 [49, 'F7'],
 [23, 'F7'],
 [2, 'F7'],
 [7, 'F7'],
 [11, 'F3'],
 [8, 'F7'],
 [5, 'F7'],
 [6, 'F3'],
 [9, 'F7'],
 [2, 'F7'],
 [7, 'F7'],
 [11, 'F3'],
 [8, 'F7'],
 [5, 'F7'],
 [6, 'F3'],
 [9, 'F7'],
 [2, 'F7'],
 [7, 'F7'],
 [11, 'F3'],
 [8, 'F7'],
 [5, 'F7'],
 [6, 'F3'],
 [9, 'F7'],
 [2, 'F7'],
 [7, 'F7'],
 [11, 'F3'],
 [8, 'F7'],
 [5, 'F7'],
 [6, 'F3'],
 [9, 'F7'],
 [2, 'F7'],
 [7, 'F7'],
 [11, 'F3'],
 [8, 'F7'],
 [5, 'F7'],
 [6, 'F3'],
 [9, 'F7'],
 [15, 'F17'],
 [45, 'F17'],
 [16, 'F7'],
 [46, 'F7'],
 [17, 'F7'],
 [18, 'F7'],
 [48, 'F7'],
 [23, 'F7']]

需求逻辑 #

• 迭代该嵌套列表，若某个子列表的首元素重复出现，检查同一首元素对应的次元素是否不同（例如15重复出现时，检查对应次元素是否不同）。
• 若满足上述条件，将该子列表的首元素加30进行更新，此过程需迭代执行：后续更新后的数值若仍满足条件（即存在相同数值但次元素不同的情况），则继续加30，直到无冲突为止。

期望结果 #

unq_act = [[15, 'F7'],
 [45, 'F7'],
 [17, 'F7'],
 [19, 'F7'],
 [49, 'F7'],
 [23, 'F7'],
 [2, 'F7'],
 [7, 'F7'],
 [11, 'F3'],
 [8, 'F7'],
 [5, 'F7'],
 [6, 'F3'],
 [9, 'F7'],
 [2, 'F7'],
 [7, 'F7'],
 [11, 'F3'],
 [8, 'F7'],
 [5, 'F7'],
 [6, 'F3'],
 [9, 'F7'],
 [2, 'F7'],
 [7, 'F7'],
 [11, 'F3'],
 [8, 'F7'],
 [5, 'F7'],
 [6, 'F3'],
 [9, 'F7'],
 [2, 'F7'],
 [7, 'F7'],
 [11, 'F3'],
 [8, 'F7'],
 [5, 'F7'],
 [6, 'F3'],
 [9, 'F7'],
 [2, 'F7'],
 [7, 'F7'],
 [11, 'F3'],
 [8, 'F7'],
 [5, 'F7'],
 [6, 'F3'],
 [9, 'F7'],
 [75, 'F17'],
 [105, 'F17'],
 [16, 'F7'],
 [46, 'F7'],
 [17, 'F7'],
 [18, 'F7'],
 [48, 'F7'],
 [23, 'F7']]

尝试的无效代码 #

for i in unq_act:
    for j in unq_act:
        if i[0] == j[0] and i[1] != j[1]:
            unq_act[unq_act.index(j)][0] == unq_act[unq_act.index(j)][0] + 30
            print(unq_act[unq_act.index(j)][0])

代码无效原因 #

1. 赋值错误：使用了==比较运算符而非=赋值运算符，导致数值根本没更新。
2. 索引定位错误：list.index()方法在列表存在多个相同元素时，只会返回第一个匹配项的索引，无法正确定位当前遍历的j元素。
3. 未处理迭代更新：现有逻辑只执行一次更新，没有循环检查更新后的数值是否仍存在冲突。

解决方案代码 #

# 用字典记录每个数值对应的所有次元素集合，以及出现的索引
value_map = {}
# 先遍历一次，收集数值对应的次元素和索引信息
for idx, (num, tag) in enumerate(unq_act):
    if num not in value_map:
        value_map[num] = {'tags': set(), 'indices': []}
    value_map[num]['tags'].add(tag)
    value_map[num]['indices'].append(idx)

# 处理存在冲突的数值
for num in list(value_map.keys()):
    data = value_map[num]
    # 当当前数值对应多个不同次元素时，循环更新
    while len(data['tags']) > 1:
        # 取出最后一个冲突元素的索引（匹配期望结果中更新后出现的项）
        idx = data['indices'].pop()
        old_num = num
        new_num = old_num + 30
        # 更新原列表中的数值
        unq_act[idx][0] = new_num
        # 将更新后的数值信息合并到字典中，继续检查冲突
        if new_num not in value_map:
            value_map[new_num] = {'tags': set(), 'indices': []}
        value_map[new_num]['tags'].add(unq_act[idx][1])
        value_map[new_num]['indices'].append(idx)
        # 更新当前追踪的数值为新数值，继续循环检查
        num = new_num
        data = value_map[num]

print(unq_act)

思路说明 #

1. 统计信息：通过字典value_map提前统计每个数值对应的所有次元素集合和出现索引，快速判断是否存在冲突。
2. 迭代更新：对存在冲突的数值，循环执行加30操作，每次更新后将新数值的信息合并到字典中，继续检查新数值是否还有冲突，直到该数值对应的次元素唯一为止。
3. 精准定位：通过索引列表直接操作原列表元素，避免index()方法的定位错误。

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