Renommer une clé de dictionnaire

Existe-t-il un moyen de renommer une clé de dictionnaire sans réaffecter sa valeur à un nouveau nom et supprimer l'ancienne clé de nom; et sans itérer via la clé / valeur dict?

En cas de OrderedDict, faites de même, tout en conservant la position de cette clé.

Pour un dict régulier, vous pouvez utiliser:

mydict[new_key] = mydict.pop(old_key)

Pour un OrderedDict, je pense que vous devez en construire un entièrement nouveau en utilisant une compréhension.

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

Modifier la clé elle-même, comme cette question semble se poser, n'est pas pratique car les clés dict sont généralement des objets immuables tels que des nombres, des chaînes ou des tuples. Au lieu d'essayer de modifier la clé, réaffecter la valeur à une nouvelle clé et supprimer l'ancienne clé est de savoir comment vous pouvez obtenir le "renommer" en python.

meilleure méthode en 1 ligne:

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

En utilisant un chèque pour newkey!=oldkey, vous pouvez ainsi:

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

En cas de renommage de toutes les clés du dictionnaire:

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)

Vous pouvez utiliser ceci OrderedDict recipeécrit par Raymond Hettinger et le modifier pour ajouter une renameméthode, mais cela va être un O (N) en complexité:

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

Exemple:

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

production:

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

Quelques personnes avant moi ont mentionné l' .popastuce pour supprimer et créer une clé dans une ligne.

Personnellement, je trouve la mise en œuvre plus explicite plus lisible:

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

Le code ci-dessus renvoie {'a': 1, 'c': 2}

Les autres réponses sont plutôt bonnes, mais en python3.6, le dict régulier a également de l'ordre. Il est donc difficile de conserver la position de la clé dans un cas 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 (à partir de maintenant?), Je choisirais le one-liner suivant

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

qui produit

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

Il peut être intéressant de noter que sans la printdéclaration, le bloc-notes console / jupyter ipython présente le dictionnaire dans l'ordre de leur choix ...

J'ai trouvé cette fonction qui ne mute pas le dictionnaire d'origine. Cette fonction prend également en charge la liste des dictionnaires.

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

J'utilise la réponse de @wim ci-dessus, avec dict.pop () lors du changement de nom des clés, mais j'ai trouvé un problème. Faire défiler le dict pour changer les clés, sans séparer complètement la liste des anciennes clés de l'instance de dict, a entraîné le cyclage de nouvelles clés modifiées dans la boucle et la disparition de certaines clés existantes.

Pour commencer, je l'ai fait de cette façon:

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

J'ai trouvé qu'en parcourant le dict de cette manière, le dictionnaire continuait à trouver des clés même quand ce n'était pas le cas, c'est-à-dire les nouvelles clés, celles que j'avais changées! Je devais séparer complètement les instances les unes des autres pour (a) éviter de trouver mes propres clés modifiées dans la boucle for, et (b) trouver des clés qui n'étaient pas trouvées dans la boucle pour une raison quelconque.

Je fais ça maintenant:

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

La conversion de my_dict.keys () en une liste était nécessaire pour se libérer de la référence au dict changeant. Le simple fait d'utiliser my_dict.keys () m'a gardé lié à l'instance d'origine, avec les effets secondaires étranges.

Dans le cas où quelqu'un souhaite renommer toutes les clés à la fois en fournissant une liste avec les nouveaux noms:

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 J'aime votre fonction. Voici une modification pour renommer plusieurs clés en un seul appel:

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

Supposons que vous souhaitiez renommer la clé k3 en k4:

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