Đổi tên khóa từ điển

Có cách nào để đổi tên một khóa từ điển, mà không cần gán lại giá trị của nó thành một tên mới và loại bỏ khóa tên cũ; và không lặp lại thông qua khóa / giá trị dict?

Trong trường hợp OrderedDict, hãy làm tương tự, trong khi vẫn giữ vị trí của khóa đó.

Đối với một lệnh chính quy, bạn có thể sử dụng:

mydict[new_key] = mydict.pop(old_key)

Đối với một OrderedDict, tôi nghĩ bạn phải xây dựng một cái hoàn toàn mới bằng cách sử dụng một sự hiểu biết.

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

Tự sửa đổi khóa, vì câu hỏi này dường như đang được hỏi, là không thực tế vì các khóa chính thường là các đối tượng bất biến như số, chuỗi hoặc bộ dữ liệu. Thay vì cố gắng sửa đổi khóa, việc gán lại giá trị cho khóa mới và xóa khóa cũ là cách bạn có thể đạt được "đổi tên" trong python.

phương pháp tốt nhất trong 1 dòng:

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

Sử dụng kiểm tra newkey!=oldkey, theo cách này bạn có thể làm:

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

Trong trường hợp đổi tên tất cả các khóa từ điển:

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)

Bạn có thể sử dụng điều này OrderedDict recipeđược viết bởi Raymond Hettinger và sửa đổi nó để thêm một renamephương thức, nhưng điều này sẽ là một O (N) phức tạp:

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

Thí dụ:

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

đầu ra:

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

Một vài người trước tôi đã đề cập đến .popthủ thuật xóa và tạo khóa trong một lớp lót.

Cá nhân tôi thấy việc thực hiện rõ ràng hơn dễ đọc hơn:

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

Mã trên trả về {'a': 1, 'c': 2}

Các câu trả lời khác là khá tốt. Nhưng trong python3.6, dict thường cũng có thứ tự. Vì vậy, thật khó để giữ vị trí quan trọng trong trường hợp bình thường.

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

Trong Python 3.6 (trở đi?) Tôi sẽ sử dụng một lớp lót sau

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

sản xuất

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

Có thể đáng chú ý rằng không có printtuyên bố, máy tính xách tay ipython console / jupyter trình bày từ điển theo thứ tự lựa chọn của họ ...

Tôi đã đưa ra chức năng này mà không làm thay đổi từ điển gốc. Chức năng này cũng hỗ trợ danh sách từ điển.

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

Tôi đang sử dụng câu trả lời của @wim ở trên, với dict.pop () khi đổi tên các khóa, nhưng tôi đã tìm thấy một gotcha. Đạp xe qua dict để thay đổi các phím, mà không tách hoàn toàn danh sách các khóa cũ khỏi trường hợp dict, dẫn đến việc đạp xe mới, thay đổi các phím vào vòng lặp và thiếu một số khóa hiện có.

Để bắt đầu, tôi đã làm theo cách này:

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

Tôi thấy rằng đạp xe qua dict theo cách này, từ điển tiếp tục tìm khóa ngay cả khi không nên, tức là các khóa mới, những khóa tôi đã thay đổi! Tôi cần tách hoàn toàn các thể hiện với nhau để (a) tránh tìm khóa thay đổi của riêng tôi trong vòng lặp for và (b) tìm một số khóa không được tìm thấy trong vòng lặp vì một số lý do.

Tôi đang làm điều này bây giờ:

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

Việc chuyển đổi my_dict.keys () thành một danh sách là cần thiết để không bị tham chiếu đến lệnh thay đổi. Chỉ cần sử dụng my_dict.keys () đã giữ cho tôi gắn liền với phiên bản gốc, với các hiệu ứng phụ lạ.

Trong trường hợp ai đó muốn đổi tên tất cả các khóa cùng một lúc, cung cấp một danh sách với các tên mới:

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 Tôi thích chức năng của bạn. Đây là một sửa đổi để đổi tên nhiều khóa trong một cuộc gọi:

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

Giả sử bạn muốn đổi tên khóa k3 thành k4:

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