Renombrar una clave de diccionario

¿Hay alguna forma de cambiar el nombre de una clave de diccionario, sin reasignar su valor a un nuevo nombre y eliminar la antigua clave de nombre; y sin iterar a través de la clave / valor dict?

En el caso de OrderedDict, haga lo mismo, manteniendo la posición de esa clave.

Para un dict regular, puede usar:

mydict[new_key] = mydict.pop(old_key)

Para un OrderedDict, creo que debes construir uno completamente nuevo usando una comprensión.

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

La modificación de la clave en sí, como parece ser esta pregunta, no es práctica porque las claves dict son generalmente objetos inmutables como números, cadenas o tuplas. En lugar de intentar modificar la clave, reasignar el valor a una nueva clave y eliminar la clave anterior es cómo puede lograr el "cambio de nombre" en python.

mejor método en 1 línea:

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

Usando un cheque para newkey!=oldkey, de esta manera puede hacer:

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

En caso de renombrar todas las teclas del diccionario:

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)

Puede usar esto OrderedDict recipeescrito por Raymond Hettinger y modificarlo para agregar un renamemétodo, pero esto será una O (N) en complejidad:

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

Ejemplo:

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

salida:

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

Algunas personas antes que yo mencionaron el .poptruco para eliminar y crear una clave en una sola línea.

Personalmente encuentro que la implementación más explícita es más legible:

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

El código anterior devuelve {'a': 1, 'c': 2}

Otras respuestas son bastante buenas, pero en python3.6, el dict regular también tiene orden. Por lo tanto, es difícil mantener la posición de la llave en el caso normal.

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

En Python 3.6 (¿en adelante?) Iría por el siguiente 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()))

que produce

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

Vale la pena señalar que sin la printdeclaración la consola ipython / notebook jupyter presenta el diccionario en el orden que elijan ...

Se me ocurrió esta función que no muta el diccionario original. Esta función también es compatible con la lista de diccionarios.

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

Estoy usando la respuesta de @wim anterior, con dict.pop () al cambiar el nombre de las teclas, pero encontré un problema. Al recorrer el dict para cambiar las claves, sin separar la lista de claves antiguas por completo de la instancia del dict, resultó en el ciclo de claves nuevas, cambiadas en el bucle y se perdieron algunas claves existentes.

Para empezar, lo hice de esta manera:

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

Descubrí que al recorrer el dict de esta manera, el diccionario seguía encontrando claves incluso cuando no debería, es decir, ¡las nuevas claves, las que había cambiado! Necesitaba separar las instancias completamente entre sí para (a) evitar encontrar mis propias claves cambiadas en el ciclo for, y (b) encontrar algunas claves que no se encontraban dentro del ciclo por alguna razón.

Estoy haciendo esto ahora:

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

Fue necesario convertir my_dict.keys () en una lista para liberarse de la referencia al cambio dict. Solo usando my_dict.keys () me mantuvo atado a la instancia original, con los extraños efectos secundarios.

En caso de que alguien quiera cambiar el nombre de todas las claves a la vez proporcionando una lista con los nuevos nombres:

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 Me gusta tu función. Aquí hay una modificación para cambiar el nombre de varias claves en una sola llamada:

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

Suponga que desea cambiar el nombre de la clave k3 a k4:

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