如何在python中更改字典中的列表值？

我有一本这样的字典

{'A':[[1,30],[40,50],[60,79]]
 'B':[[2,23],[26,43],[59,119]]
 'C':[[1,100],[149,167],[199,250]]
  ...                             }

我的最大值是600。是否可以计算每个列表中每个值之间的差异？ 最后，我可以得到一本这样的字典

 {'A':[[31,39],[51,59],[80,600]]
     'B':[[24,25],[44,58],[120,600]]
     'C':[[101,148],[168,198],[251,600]]
      ...                             
                                     }

让我解释一下最终输出是如何产生的。 原始数据为

'A':[[i1,i2],[i3,i4],[i5,i6]]

最大值为M

对于每个列表，最终输出如下

'A':[[(i2)+1,(i3)-1],[(i4)+1,(i5)-1],[(i6)+1,M]]

看来我需要一个for循环才能到达那里。但我不知道如何在字典中做到这一点。

你可以试试这个：

d1 = {'A':[[1,30],[40,50],[60,79]],
      'B':[[2,23],[26,43],[59,119]],
      'C':[[1,100],[149,167],[199,250]]}

def split_l(iterable, n):
    return [iterable[i:i+n] for i in range(0, len(iterable), n)] 

d2 = {k:split_l([val + (-1)**idx for idx, val in enumerate(sum(v, [])[1:])] + [600], 2) for k,v in d1.items()} 

或者以更可读的方式：

d2 = {}
for k, v in d1.items():
    flat_v = sum(v, [])[1:]

    for idx, __ in enumerate(flat_v):
        flat_v[idx] += (-1)**idx
    flat_v.append(600)

    split_v = [flat_v[i:i+2] for i in range(0, len(flat_v), 2)]
    d2[k] = split_v

结果:

import pprint
pprint.pprint(d2)

{'A'：[[31,39]，[51,59]，[80600]，
“B”：[24,25]，[44,58]，[120600]，
‘C’：[101148]，[168198]，[251600]}

您可以使用itertools.chain

>>> from itertools import chain
>>> d = {'A':[[1,30],[40,50],[60,79]], 'B':[[2,23],[26,43],[59,119]],}
>>> for key in d:
...     d[key] = zip(*[iter([each+((-1)**index) for index,each in enumerate(chain.from_iterable(d[key]))]+[600,])]*2)
...
>>> d
{'A': [(31, 39), (51, 59), (80, 600)], 'B': [(24, 25), (44, 58), (120, 600)]}

就是

>>> chain.from_iterable(d['A'])
<itertools.chain object at 0x7f6a9dd69950>
>>> list(chain.from_iterable(d['A']))
[31, 39, 51, 59, 80, 600]

>>> iter(each for each in enumerate(chain.from_iterable(d[key])))
<generator object <genexpr> at 0x7f6a9dd804b0>
>>> zip(*[iter(each for each in enumerate(chain.from_iterable(d[key])))]*2)
[((0, 2), (1, 23)), ((2, 26), (3, 43)), ((4, 59), (5, 119))]

>chain.from_iterable（d['A']）
>>>列表（链起始值（d['A']））
[31, 39, 51, 59, 80, 600]
>>>iter（每个用于枚举中的每个（链自可数（d[key]））
>>>zip（*[iter（每一个用于枚举中的每一个（chain.from_iterable（d[key]）））]*2）
[((0, 2), (1, 23)), ((2, 26), (3, 43)), ((4, 59), (5, 119))]

请记住，在python中，可以通过以下方式交换两个变量的值：

a, b = b, a

所以你的问题可以这样解决：

def my_func(a_dict, max):
    for row in a_dict.values():
        row[0][0], row[0][1], row[1][0], row[1][1], row[2][0], row[2][1] = \
        row[0][1]+1, row[1][0]-1, row[1][1]+1, row[2][0]-1, row[2][1]+1, max

需要注意的一点是，没有

返回…

字典是可变的，因此对字典的任何更改都将保留。
调用my_func后，传递给函数的字典将包含结果

---

更新
@MaximTitarenko告诉我，每行中的内部列表数量（row=与字典键关联的列表）可能会有所不同。 所以我写了另一个脚本，它在这种情况下起作用：

def make_result(a_dict, max):
    for row in a_dict.values():
        for index in range(len(row)-1):
            row[index][0] = row[index][1] + 1
            row[index][1] = row[index+1][0] -1
        row[-1][0] = row[-1][1] + 1
        row[-1][1] = max

---

你到底是如何从原始值得到期望值的？我不知道你所说的“计算每个列表中每个值之间的差异”是什么意思。我似乎无法做任何接近这一点的事情，并获得您的预期输出。Hi@KlausD. @trueCamelType I更新底部的问题。dictionary的每个值是否正好包含3个内部列表？如果每行中有500个元素会怎么样？问题中提到了@MaximTitarenko行格式，它正好包含三个内部列表：

[[（i2）+1，（i3）-1]，（i4）+1，（i5）-1]，（i6）+1，M]]

3个元素/行只是一个例子。更重要的是问题本身及其在一般情况下的解决办法