사전 키 이름 바꾸기

값을 새 이름으로 재 할당하고 이전 이름 ​​키를 제거하지 않고 사전 키 이름을 바꾸는 방법이 있습니까? dict 키 / 값을 반복하지 않고?

OrderedDict의 경우 키 위치를 유지하면서 동일하게 수행하십시오.

정기 dict의 경우 다음을 사용할 수 있습니다.

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 키는 일반적 으로 숫자, 문자열 또는 튜플과 같은 변경 불가능한 객체 이므로 키 자체를 수정하는 것은이 질문이하는 것처럼 보이지 않습니다 . 키를 수정하는 대신 값을 새 키에 다시 할당하고 이전 키를 제거하는 것이 파이썬에서 "이름 바꾸기"를 달성하는 방법입니다.

한 줄에 가장 좋은 방법 :

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

check for를 사용하면 다음 newkey!=oldkey과 같은 작업을 수행 할 수 있습니다.

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

모든 사전 키의 이름을 바꾸는 경우 :

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

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

OrderedDict recipeRaymond Hettinger가 작성한 것을 사용 하고 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

저의 몇몇 사람들 .pop은 하나의 라이너에서 키를 삭제하고 생성하는 트릭을 언급했습니다 .

개인적으로보다 명확한 구현이 더 읽기 쉽습니다.

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

위의 코드는 {'a': 1, 'c': 2}

다른 답변은 꽤 좋지만 python3.6에서는 일반 dict에도 순서가 있습니다. 따라서 정상적인 경우에는 키의 위치를 ​​유지하기가 어렵습니다.

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

파이썬 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 콘솔 / jupyter 노트북은 선택한 순서대로 사전을 제시 한다는 점에 주목할 가치가 있습니다 .

원래 사전을 변경하지 않는이 기능을 생각해 냈습니다. 이 기능은 사전 목록도 지원합니다.

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))

키의 이름을 바꿀 때 dict.pop ()과 함께 위의 @wim 대답을 사용하고 있지만 문제가 있습니다. dict 인스턴스에서 이전 키 목록을 완전히 분리하지 않고 dict를 통해 키를 변경하면 새로운 키가 순환되고 루프로 변경되어 기존 키가 누락되었습니다.

우선, 나는 이렇게했다 :

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

나는 이런 식으로 dict을 통해 순환하는 것을 발견했다. 사전은 그것이 바뀌지 않아야 할 때조차도 키를 찾는 것을 발견했다. (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 ()를 사용하면 이상한 부작용으로 원래 인스턴스에 묶여 있습니다.

누군가가 한 번에 모든 키의 이름을 바꾸고 싶다면 새로운 이름으로 목록을 제공하십시오.

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()}

@ 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

키 k3의 이름을 k4로 바꾸고 싶다고 가정하십시오.

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