Il y a beaucoup de bonnes réponses, mais je tiens à souligner une chose.
Vous pouvez utiliser à la fois la dict.pop()
méthode et une instruction plus génériquedel
pour supprimer des éléments d'un dictionnaire. Ils mutent tous les deux le dictionnaire d'origine, vous devez donc en faire une copie (voir les détails ci-dessous).
Et les deux lèveront un KeyError
si la clé que vous leur fournissez n'est pas présente dans le dictionnaire:
key_to_remove = "c"
d = {"a": 1, "b": 2}
del d[key_to_remove] # Raises `KeyError: 'c'`
et
key_to_remove = "c"
d = {"a": 1, "b": 2}
d.pop(key_to_remove) # Raises `KeyError: 'c'`
Vous devez vous en occuper:
en capturant l'exception:
key_to_remove = "c"
d = {"a": 1, "b": 2}
try:
del d[key_to_remove]
except KeyError as ex:
print("No such key: '%s'" % ex.message)
et
key_to_remove = "c"
d = {"a": 1, "b": 2}
try:
d.pop(key_to_remove)
except KeyError as ex:
print("No such key: '%s'" % ex.message)
en effectuant une vérification:
key_to_remove = "c"
d = {"a": 1, "b": 2}
if key_to_remove in d:
del d[key_to_remove]
et
key_to_remove = "c"
d = {"a": 1, "b": 2}
if key_to_remove in d:
d.pop(key_to_remove)
mais avec pop()
il y a aussi un moyen beaucoup plus concis - fournissez la valeur de retour par défaut:
key_to_remove = "c"
d = {"a": 1, "b": 2}
d.pop(key_to_remove, None) # No `KeyError` here
Sauf si vous utilisez pop()
pour obtenir la valeur d'une clé supprimée, vous pouvez fournir quoi que ce soit, non nécessaire None
. Bien qu'il soit possible que l'utilisation del
avec in
vérification soit légèrement plus rapide en raison du fait qu'elle pop()
est une fonction avec ses propres complications entraînant des frais généraux. Habituellement, ce n'est pas le cas, donc pop()
avec une valeur par défaut, c'est assez bon.
Quant à la question principale, vous devrez faire une copie de votre dictionnaire, pour enregistrer le dictionnaire d'origine et en avoir un nouveau sans que la clé ne soit supprimée.
D'autres personnes suggèrent ici de faire une copie complète (profonde) avec copy.deepcopy()
, ce qui pourrait être une exagération, une copie "normale" (peu profonde), en utilisant copy.copy()
oudict.copy()
, pourrait être suffisant. Le dictionnaire conserve une référence à l'objet comme valeur pour une clé. Ainsi, lorsque vous supprimez une clé d'un dictionnaire, cette référence est supprimée, pas l'objet référencé. L'objet lui-même peut être supprimé plus tard automatiquement par le garbage collector, s'il n'y a pas d'autres références pour lui dans la mémoire. Faire une copie complète nécessite plus de calculs par rapport à une copie superficielle, donc cela diminue les performances du code en faisant la copie, en gaspillant de la mémoire et en fournissant plus de travail au GC, parfois une copie superficielle suffit.
Cependant, si vous avez des objets mutables en tant que valeurs de dictionnaire et prévoyez de les modifier plus tard dans le dictionnaire renvoyé sans la clé, vous devez effectuer une copie complète.
Avec copie superficielle:
def get_dict_wo_key(dictionary, key):
"""Returns a **shallow** copy of the dictionary without a key."""
_dict = dictionary.copy()
_dict.pop(key, None)
return _dict
d = {"a": [1, 2, 3], "b": 2, "c": 3}
key_to_remove = "c"
new_d = get_dict_wo_key(d, key_to_remove)
print(d) # {"a": [1, 2, 3], "b": 2, "c": 3}
print(new_d) # {"a": [1, 2, 3], "b": 2}
new_d["a"].append(100)
print(d) # {"a": [1, 2, 3, 100], "b": 2, "c": 3}
print(new_d) # {"a": [1, 2, 3, 100], "b": 2}
new_d["b"] = 2222
print(d) # {"a": [1, 2, 3, 100], "b": 2, "c": 3}
print(new_d) # {"a": [1, 2, 3, 100], "b": 2222}
Avec copie profonde:
from copy import deepcopy
def get_dict_wo_key(dictionary, key):
"""Returns a **deep** copy of the dictionary without a key."""
_dict = deepcopy(dictionary)
_dict.pop(key, None)
return _dict
d = {"a": [1, 2, 3], "b": 2, "c": 3}
key_to_remove = "c"
new_d = get_dict_wo_key(d, key_to_remove)
print(d) # {"a": [1, 2, 3], "b": 2, "c": 3}
print(new_d) # {"a": [1, 2, 3], "b": 2}
new_d["a"].append(100)
print(d) # {"a": [1, 2, 3], "b": 2, "c": 3}
print(new_d) # {"a": [1, 2, 3, 100], "b": 2}
new_d["b"] = 2222
print(d) # {"a": [1, 2, 3], "b": 2, "c": 3}
print(new_d) # {"a": [1, 2, 3, 100], "b": 2222}