Zmień nazwę klucza słownika

Czy istnieje sposób zmiany nazwy klucza słownika bez ponownego przypisywania jego wartości do nowej nazwy i usuwania starego klucza nazwy; i bez iteracji po kluczu / wartości dict?

W przypadku OragedDict, zrób to samo, zachowując pozycję tego klucza.

Do zwykłego nagrania możesz użyć:

mydict[new_key] = mydict.pop(old_key)

Wydaje mi się, że w przypadku OrdersDict musisz zbudować zupełnie nowy, korzystając ze zrozumienia.

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

Modyfikacja samego klucza, jak wydaje się to pytanie, jest niepraktyczna, ponieważ klucze dict są zwykle niezmiennymi obiektami, takimi jak liczby, ciągi znaków lub krotki. Zamiast próbować modyfikować klucz, ponowne przypisanie wartości do nowego klucza i usunięcie starego klucza jest sposobem na osiągnięcie „zmiany nazwy” w pythonie.

najlepsza metoda w 1 linii:

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

Korzystając z czeku newkey!=oldkey, możesz w ten sposób:

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

W przypadku zmiany nazwy wszystkich kluczy słownika:

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)

Możesz użyć tego OrderedDict recipenapisanego przez Raymonda Hettingera i zmodyfikować go, aby dodać renamemetodę, ale będzie to złożoność 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

Przykład:

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

wynik:

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

Kilka osób przede mną wspomniało o .popsztuczce polegającej na usunięciu i utworzeniu klucza w jednym wierszu.

Osobiście uważam, że bardziej wyraźna implementacja jest bardziej czytelna:

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

Powyższy kod zwraca {'a': 1, 'c': 2}

Inne odpowiedzi są całkiem dobre, ale w python3.6 zwykły dict ma również porządek. Trudno więc utrzymać pozycję klucza w normalnym przypadku.

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

W Pythonie 3.6 (dalej?) Wybrałbym następującą linijkę

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

który produkuje

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

Warto zauważyć, że bez tej printinstrukcji notebook ipython console / jupyter prezentuje słownik w wybranej przez siebie kolejności ...

Wymyśliłem tę funkcję, która nie mutuje oryginalnego słownika. Ta funkcja obsługuje także listę słowników.

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

Korzystam z powyższej odpowiedzi @wim, z dict.pop () podczas zmiany nazw kluczy, ale znalazłem gotcha. Cykliczne przejście przez dykta w celu zmiany kluczy, bez oddzielania listy starych kluczy całkowicie od instancji dict, spowodowało cykliczne wprowadzanie nowych, zmienionych kluczy do pętli i brak niektórych istniejących kluczy.

Na początek zrobiłem to w ten sposób:

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

Odkryłem, że w ten sposób przechodząc przez dyktat, słownik ciągle znajdował klucze, nawet gdy nie powinien, tj. Nowe klucze, te, które zmieniłem! Musiałem całkowicie oddzielić instancje od siebie, aby (a) uniknąć znalezienia własnych zmienionych kluczy w pętli for i (b) znaleźć niektóre klucze, które z jakiegoś powodu nie zostały znalezione w pętli.

Robię to teraz:

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

Konwersja my_dict.keys () na listę była konieczna, aby uwolnić się od odniesienia do zmieniającego się dykta. Samo użycie my_dict.keys () utrzymywało mnie przywiązanym do oryginalnej instancji z dziwnymi efektami ubocznymi.

W przypadku, gdy ktoś chce zmienić nazwy wszystkich kluczy jednocześnie, podając listę z nowymi nazwami:

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 Podoba mi się twoja funkcja. Oto modyfikacja zmiany nazwy wielu kluczy w jednym wywołaniu:

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

Załóżmy, że chcesz zmienić nazwę klucza z k3 na k4:

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