Sözlük anahtarını yeniden adlandırma

Değerini yeni bir ada atamadan ve eski ad anahtarını kaldırmadan sözlük anahtarını yeniden adlandırmanın bir yolu var mı; ve dict anahtar / değer yoluyla yineleme olmadan?

OrderedDict durumunda, anahtarın konumunu korurken aynısını yapın.

Düzenli bir karar için şunları kullanabilirsiniz:

mydict[new_key] = mydict.pop(old_key)

Bir OrderedDict için, bir anlayış kullanarak tamamen yeni bir tane oluşturmanız gerektiğini düşünüyorum.

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

Bu sorunun sorulduğu gibi, anahtarın kendisinin değiştirilmesi pratik değildir çünkü dikt anahtarları genellikle sayılar, dizeler veya tuples gibi değişmez nesnelerdir. Anahtarı değiştirmeye çalışmak yerine, değeri yeni bir anahtara yeniden atamak ve eski anahtarı kaldırmak, python'da "yeniden adlandırma" yı nasıl elde edebileceğinizdir.

1 satırda en iyi yöntem:

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

Bir çek kullanarak newkey!=oldkey, bu şekilde şunları yapabilirsiniz:

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

Tüm sözlük anahtarlarını yeniden adlandırmanız durumunda:

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)

Bunu OrderedDict recipeRaymond Hettinger tarafından yazılmış ve bir renameyöntem eklemek için değiştirebilirsiniz , ancak bu karmaşık bir O (N) olacaktır:

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

Misal:

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

çıktı:

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

Benden birkaç kişi, bir .popastarda bir anahtar silme ve oluşturma hilesinden bahsetti .

Şahsen daha açık uygulamayı daha okunabilir buluyorum:

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

Yukarıdaki kod geri döner {'a': 1, 'c': 2}

Diğer cevaplar oldukça iyi.Ancak python3.6'da düzenli dict de sipariş var. Bu nedenle, anahtarın konumunu normal durumda tutmak zordur.

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

Python 3.6'da (ileriye doğru?) Aşağıdaki tek astarı tercih ederim

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

hangi üretir

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

printİpython konsolu / jupyter dizüstü bilgisayarın ifadesi olmadan sözlüğü seçtikleri sırada sunduğunu belirtmek gerekir ...

Orijinal sözlüğü değiştirmeyen bu işlevle geldim. Bu işlev aynı zamanda sözlüklerin listesini de destekler.

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

Anahtarları yeniden adlandırırken dict.pop () ile yukarıdaki @wim'in cevabını kullanıyorum, ama bir gotcha buldum. Eski anahtarların listesini dikte örneğinden tamamen ayırmadan anahtarları değiştirmek için dikte dolaşmak, yeni, değiştirilmiş anahtarları döngüye dönüştürmek ve bazı mevcut anahtarları kaçırmak.

Başlamak için şu şekilde yaptım:

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

Bu şekilde dikte boyunca bisiklete binmenin, sözlük değiştirmemesi gereken zamanlarda bile anahtarları bulmaya devam ettiğini, yani yeni anahtarları, değiştirdiklerimi buldum! (A) for döngüsünde kendi değiştirilmiş anahtarlarımı bulmaktan kaçınmak ve (b) bir nedenle döngü içinde bulunmayan bazı anahtarları bulmak için örnekleri birbirinden tamamen ayırmak gerekiyordu.

Bunu şimdi yapıyorum:

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

Değişen dikte referansından kurtulmak için my_dict.keys () öğesini bir listeye dönüştürmek gerekiyordu. Sadece my_dict.keys () kullanmak beni garip yan etkilerle, orijinal örneğe bağlı tuttu.

Birisinin yeni anahtarları içeren bir liste sağlayarak tüm anahtarları aynı anda yeniden adlandırmak istemesi durumunda:

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 Ben senin fonksiyonunu seviyorum. Tek bir çağrıda birden fazla anahtarı yeniden adlandırmak için bir değişiklik:

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

Anahtar k3'ü k4 olarak yeniden adlandırmak istediğinizi varsayalım:

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