Rinomina una chiave del dizionario

C'è un modo per rinominare una chiave del dizionario, senza riassegnare il suo valore a un nuovo nome e rimuovere la vecchia chiave del nome; e senza iterare tramite chiave / valore dict?

Nel caso di OrderedDict, fai lo stesso, mantenendo la posizione di quella chiave.

Per un regolare dict, è possibile utilizzare:

mydict[new_key] = mydict.pop(old_key)

Per un OrderedDict, penso che tu debba costruirne uno completamente nuovo usando una comprensione.

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

Modificare la chiave stessa, come sembra porsi questa domanda, non è pratico perché le chiavi dict sono di solito oggetti immutabili come numeri, stringhe o tuple. Invece di provare a modificare la chiave, riassegnare il valore a una nuova chiave e rimuovere la vecchia chiave è come è possibile ottenere la "rinomina" in Python.

metodo migliore in 1 riga:

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

Usando un controllo per newkey!=oldkey, in questo modo puoi fare:

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

In caso di rinominare tutte le chiavi del dizionario:

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)

Puoi usare questo OrderedDict recipescritto da Raymond Hettinger e modificarlo per aggiungere un renamemetodo, ma sarà una O (N) in complessità:

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

Esempio:

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

produzione:

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

Alcune persone prima di me hanno menzionato il .poptrucco per eliminare e creare una chiave in una riga.

Personalmente trovo più leggibile l'implementazione più esplicita:

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

Il codice sopra riportato ritorna {'a': 1, 'c': 2}

Altre risposte sono piuttosto buone, ma in python3.6 anche il dict regolare ha un ordine. Quindi è difficile mantenere la posizione della chiave nel caso normale.

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

In Python 3.6 (in poi?) Sceglierei il seguente one-liner

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

che produce

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

Vale la pena notare che senza l' printaffermazione la console ipython / notebook jupyter presentano il dizionario in un ordine di loro scelta ...

Mi è venuta in mente questa funzione che non muta il dizionario originale. Questa funzione supporta anche l'elenco dei dizionari.

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

Sto usando la risposta di @wim sopra, con dict.pop () quando ho rinominato le chiavi, ma ho trovato un gotcha. Scorrendo il dict per cambiare le chiavi, senza separare completamente l'elenco delle vecchie chiavi dall'istanza di dict, si è verificato il ciclaggio di nuove chiavi, le chiavi sono state cambiate nel loop e mancano alcune chiavi esistenti.

Per cominciare, l'ho fatto in questo modo:

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

Ho scoperto che in questo modo il dizionario continuava a cercare le chiavi anche quando non avrebbe dovuto, cioè le nuove chiavi, quelle che avevo cambiato! Avevo bisogno di separare completamente le istanze l'una dall'altra per (a) evitare di trovare le mie chiavi modificate nel ciclo for, e (b) trovare alcune chiavi che non erano state trovate nel ciclo per qualche motivo.

Lo sto facendo ora:

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

La conversione di my_dict.keys () in un elenco era necessaria per liberarsi del riferimento al dict in evoluzione. Il solo utilizzo di my_dict.keys () mi ha tenuto legato all'istanza originale, con gli strani effetti collaterali.

Nel caso in cui qualcuno desideri rinominare tutte le chiavi contemporaneamente fornendo un elenco con i nuovi nomi:

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 Mi piace la tua funzione. Ecco una modifica per rinominare più chiavi in ​​una singola chiamata:

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

Supponiamo di voler rinominare la chiave da k3 a k4:

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