Question

我有一本这样的字典：

a = {(8, 9): [[0, 0], [4, 5]], (3, 4): [[1, 2], [6, 7]]}

我想从每个键的每个元素中减去值中嵌套列表的相应元素的总和，然后将键替换为结果。

例如：

new_key[0] = 8 - 0+4 = 4, new_key[1] = 9 - (0+5) = 4

因此，新密钥将变为(4, 4)，它将替换(8, 9)

我无法理解如何访问列表列表，这是键的值！

关于如何执行此操作的任何想法？

Answer 1

请参阅Access item in a list of lists，以获取对列表的索引。

对于您的具体情况，这应该可行

b = {(k[0]-v[0][0]-v[1][0], k[1]-v[0][1]-v[1][1]):v for k, v in a.items()}

Answer 2

for key in list(a.keys()):
    new_key = []
    new_key.append(key[0] - (a[key][0][0] + a[key][1][0]))
    new_key.append(key[1] - (a[key][0][1] + a[key][1][1]))
    a[new_key] = a.pop(key) # pop() returns the value

Answer 3

遍历字典以获取键和值并创建一个新的b。然后只需将a指向新字典b

a = {(8, 9): [[0, 0], [4, 5]], (3, 4): [[1, 2], [6, 7]]}
b = {}
for key, val in a.items():
    new_key = (key[0]-(val[0][0]+val[1][0]), key[1]-(val[0][1]+val[1][1]))
    b[new_key] = val
a = b
del b

Answer 4

尝试一下：

b = {}
for key, value in a.items():
    new_key = key[0]-(value[0][0]+value[1][0])
    new_key_1 = key[1]-(value[0][1]+value[1][1])
    u_key = (new_key, new_key_1)
    b[u_key]=value
print(b)

Answer 5

以下代码在任何大小的键元组（2、5、87，无论如何）下都能正常工作。

重命名字典键没有简单的方法，但是您可以插入一个新键并删除旧键。不建议这样做有以下几个原因：

为了安全起见，您需要进行检查以确保您没有做奇怪的事情，例如创建新密钥只是为了删除同一密钥
iterate over a dictionary while changing it

如果您需要字典结果，最安全的方法是根据a生成一个全新的字典，

如果要转置字典值，则要解决的问题会更容易。

计算新密钥后，(8, 9): [[0, 0], [4, 5]]应变为：

(8 - sum([0, 4]), 9 - sum([0, 5])): [[0, 0], [4, 5]]

现在看看移调有何帮助：

transposed([[0, 0], [4, 5]]) == [[0, 4], [0, 5]]

然后新的key[0]计算为：

key[0] - sum(transposed(values)[0])

和新的key[1]计算为：

key[1] - sum(transposed(values)[1])

因此转置使计算更容易。

Python词典不能将列表作为键（列表为not hashable），因此我将键构建为列表，然后将其转换为元组。

a = {
    (8, 9): [[0, 0], [4, 5]],
    (3, 4): [[1, 2], [6, 7]]
}

def transpose(m):
    return list(zip(*m))

results = {}
for source_keys, source_values in a.items():
    transposed_values = transpose(source_values)
    key = []
    for n, key_item in enumerate(source_keys):
        subtractables = sum(transposed_values[n])
        key.append(key_item - subtractables)
    results[tuple(key)] = source_values

print(results)

>>> python transpose.py
{(4, 4): [[0, 0], [4, 5]], (-4, -5): [[1, 2], [6, 7]]}

Answer 6

以下解决方案基于三个假设：

键是整数的迭代器
值是整数的可迭代项
每个值的内部可迭代长度与相应键的长度相同

实际上，这意味着值的长度可以是任何东西，只要它是2D列表，并且即使值在内部字典中匹配，即使在同一词典中，也可以具有不同长度的键尺寸。

您可能希望转置值以使总和易于计算。成语zip(*value)使您可以轻松完成此操作。然后将sum映射到该值上，然后从键的元素中减去结果。

要记住的另一件事是在迭代过程中替换密钥是一个非常糟糕的主意。最好创建一个全新的字典来保存更新的映射。

from operator import sub
from itertools import starmap

a = {(8, 9): [[0, 0], [4, 5]], (3, 4): [[1, 2], [6, 7]]}
b = {
    tuple(starmap(sub, zip(k, map(sum, zip(*v))))): v
    for k, v in a.items()
}

结果是

{(4, 4): [[0, 0], [4, 5]], (-4, -5): [[1, 2], [6, 7]]}

这里是一个IDEOne Link可以玩。

完整的循环看起来像这样：

b = {}
for k, v in a.items():
    vt = zip(*v)  # transposed values
    sums = map(sum, vt)  # sum of the 1st elements, 2nd elements, etc
    subs = zip(k, sums)  # match elements of key with sums to subtract
    diffs = starmap(sub, subs)  # subtract sums from key
    new_key = tuple(diffs)  # evaluate the generators
    b[new_key] = value

从键中减去字典值

6 个答案: