重命名字典键

Question

有没有办法重命名字典密钥，而无需将其值重新分配给新名称并删除旧名称密钥;并且没有迭代通过dict键/值？

如果是OrderedDict，也要保持该键的位置。

Answer 1

对于常规字典，您可以使用：

mydict[new_key] = mydict.pop(old_key)

对于OrderedDict，我认为你必须使用理解来构建一个全新的。

>>> OrderedDict(zip('123', 'abc'))
OrderedDict([('1', 'a'), ('2', 'b'), ('3', 'c')])
>>> oldkey, newkey = '2', 'potato'
>>> OrderedDict((newkey if k == oldkey else k, v) for k, v in _.viewitems())
OrderedDict([('1', 'a'), ('potato', 'b'), ('3', 'c')])

正如这个问题似乎要求修改密钥本身是不切实际的，因为dict密钥通常是不可变的对象，如数字，字符串或元组。而不是尝试修改密钥，将值重新分配给新密钥并删除旧密钥是如何在python中实现“重命名”。

Answer 2

一行中的最佳方法：

>>> d = {'test':[0,1,2]}
>>> d['test2'] = d.pop('test')
>>> d
{'test2': [0, 1, 2]}

Answer 3

使用newkey!=oldkey检查，您可以这样做：

if newkey!=oldkey:  
    dictionary[newkey] = dictionary[oldkey]
    del dictionary[oldkey]

Answer 4

您可以使用Raymond Hettinger编写的这个OrderedDict recipe并修改它以添加rename方法，但这将是O（N）的复杂性：

def rename(self,key,new_key):
    ind = self._keys.index(key)  #get the index of old key, O(N) operation
    self._keys[ind] = new_key    #replace old key with new key in self._keys
    self[new_key] = self[key]    #add the new key, this is added at the end of self._keys
    self._keys.pop(-1)           #pop the last item in self._keys

示例：

dic = OrderedDict((("a",1),("b",2),("c",3)))
print dic
dic.rename("a","foo")
dic.rename("b","bar")
dic["d"] = 5
dic.rename("d","spam")
for k,v in  dic.items():
    print k,v

<强>输出：

OrderedDict({'a': 1, 'b': 2, 'c': 3})
foo 1
bar 2
c 3
spam 5

Answer 5

在我之前的一些人提到要删除的.pop技巧并在单行中创建一个密钥。

我个人觉得更明确的实现更具可读性：

d = {'a': 1, 'b': 2}
v = d['b']
del d['b']
d['c'] = v

上面的代码返回{'a': 1, 'c': 2}

Answer 6

其他答案都很好。但是在python3.6中，常规字典也有顺序。因此，在正常情况下很难保持钥匙的位置。

def rename(old_dict,old_name,new_name):
    new_dict = {}
    for key,value in zip(old_dict.keys(),old_dict.values()):
        new_key = key if key != old_name else new_name
        new_dict[new_key] = old_dict[key]
    return new_dict

Answer 7

在Python 3.6（及更高版本？）中，我会选择以下一种代码

test = {'a': 1, 'old': 2, 'c': 3}
old_k = 'old'
new_k = 'new'
new_v = 4  # optional

print(dict((new_k, new_v) if k == old_k else (k, v) for k, v in test.items()))

产生

{'a': 1, 'new': 4, 'c': 3}

可能值得注意的是，如果没有print语句，则ipython console / jupyter笔记本将按其选择的顺序显示字典。

Answer 8

即使它的字典列表只是将其转换为字符串。

注意：确保您没有与键名相同的值。

可能为某人工作

import json
d = [{'a':1,'b':2},{'a':2,'b':3}]
d = json.loads(json.dumps(d).replace('"a"','"newKey"'))

Answer 9

重命名键时，我在上面使用@wim的答案和dict.pop（），但是发现了一个问题。遍历字典以更改键，而又不将旧键列表与dict实例完全分开，这导致将新的，更改后的键循环到循环中，并且丢失了一些现有键。

首先，我是这样做的：

for current_key in my_dict:
    new_key = current_key.replace(':','_')
    fixed_metadata[new_key] = fixed_metadata.pop(current_key)

我发现以这种方式遍历字典，字典即使在不应该的时候也一直在寻找键，即新的键，我已经更改过的键！我需要将实例完全分开，以（a）避免在for循环中找到自己更改的键，以及（b）由于某些原因而在循环中找不到某些键。

我现在正在这样做：

current_keys = list(my_dict.keys())
for current_key in current_keys:
    and so on...

有必要将my_dict.keys（）转换为列表，以摆脱对更改的dict的引用。仅仅使用my_dict.keys（）就能使我与原始实例保持联系，并产生奇怪的副作用。

Answer 10

如果有人想一次重命名所有密钥，并提供一个包含新名称的列表：

def rename_keys(dict_, new_keys):
    """
     new_keys: type List(), must match length of dict_
    """

    # dict_ = {oldK: value}
    # d1={oldK:newK,} maps old keys to the new ones:  
    d1 = dict( zip( list(dict_.keys()), new_keys) )

          # d1{oldK} == new_key 
    return {d1[oldK]: value for oldK, value in dict_.items()}

Answer 11

假设您要将密钥k3重命名为k4：

temp_dict = {'k1':'v1', 'k2':'v2', 'k3':'v3'}
temp_dict['k4']= temp_dict('k3')

Answer 12

如果重命名所有字典键：

dict = {'k1':'v1', 'k2':'v2', 'k3':'v3'}
new_keys = ['k4','k5','k6']

for key,n_key in zip(dict,new_keys):
    dict[n_key] = dict.pop(key)

Answer 13

@ helloswift123我喜欢您的功能。这是在单个调用中重命名多个键的修改：

def rename(d, keymap):
    """
    :param d: old dict
    :type d: dict
    :param keymap: [{:keys from-keys :values to-keys} keymap]
    :returns: new dict
    :rtype: dict
    """
    new_dict = {}
    for key, value in zip(d.keys(), d.values()):
        new_key = keymap.get(key, key)
        new_dict[new_key] = d[key]
    return new_dict

Answer 14

我想出了此功能，该功能不会使原始词典发生变异。此功能也支持字典列表。

import functools
from typing import Union, Dict, List


def rename_dict_keys(
    data: Union[Dict, List[Dict]], old_key: str, new_key: str
):
    """
    This function renames dictionary keys

    :param data:
    :param old_key:
    :param new_key:
    :return: Union[Dict, List[Dict]]
    """
    if isinstance(data, dict):
        res = {k: v for k, v in data.items() if k != old_key}
        try:
            res[new_key] = data[old_key]
        except KeyError:
            raise KeyError(
                "cannot rename key as old key '%s' is not present in data"
                % old_key
            )
        return res
    elif isinstance(data, list):
        return list(
            map(
                functools.partial(
                    rename_dict_keys, old_key=old_key, new_key=new_key
                ),
                data,
            )
        )
    raise ValueError("expected type List[Dict] or Dict got '%s' for data" % type(data))

Answer 15

我结合了上述线程中的一些答案，并提出了下面的解决方案。虽然它很简单，但它可以用作从字典中进行更复杂的键更新的构建块。

test_dict = {'a': 1, 'b': 2, 'c': 3}
print(test_dict)
# {'a': 1, 'b': 2, 'c': 3}
prefix = 'up'
def dict_key_update(json_file):    
    new_keys = []
    old_keys = []
    for i,(key,value) in enumerate(json_file.items()):
        old_keys.append(key)
        new_keys.append(str(prefix) + key) # i have updated by adding a prefix to the 
        # key
    for old_key, new_key in zip(old_keys,new_keys):
        print('old {}, new {}'.format(old_key, new_key))
        if new_key!=old_key:  
           json_file[new_key] = json_file.pop(old_key)
     return json_file

test_dict = dict_key_update(test_dict)
print(test_dict)
# {'upa': 1, 'upb': 2, 'upc': 3}