python une Supprimer un élément d'un dictionnaire




supprimer un élément d'une liste python (11)

Appelez simplement del d ['key'].

Cependant, en production, il est toujours recommandé de vérifier si «clé» existe dans d.

if 'key' in d:
    del d['key']

Est-il possible de supprimer un élément d'un dictionnaire en Python?

Je sais que je peux juste appeler .pop sur le dictionnaire, mais cela renvoie l'élément qui a été supprimé. Ce que je cherche, c'est que quelque chose renvoie le dictionnaire moins l'élément en question.

À l'heure actuelle, j'ai une fonction d'aide qui accepte le dictionnaire en question en tant que paramètre, puis retourne un dictionnaire avec l'élément supprimé, Y at-il une solution plus élégante?


pop mute le dictionnaire.

 >>>lol = {"hello":"gdbye"}
 >>>lol.pop("hello")
    'gdbye'
 >>> lol
     {}

Si vous voulez conserver l'original, vous pouvez simplement le copier.


d = {1: 2, '2': 3, 5: 7}
del d[5]
print 'd = ', d

Résultat: d = {1: 2, '2': 3}


La déclaration del est ce que vous cherchez. Si vous avez un dictionnaire nommé foo avec une clé appelée 'bar', vous pouvez supprimer 'bar' de foo comme ceci:

del foo['bar']

Notez que cela modifie en permanence le dictionnaire en cours d'exploitation. Si vous voulez conserver le dictionnaire original, vous devrez en créer une copie à l'avance:

>>> foo = {'bar': 'baz'}
>>> fu = dict(foo)
>>> del foo['bar']
>>> print foo
{}
>>> print fu
{'bar': 'baz'}

L'appel dict fait une copie superficielle. Si vous voulez une copie en profondeur, utilisez copy.deepcopy .

Voici une méthode que vous pouvez copier et coller, pour votre commodité:

def minus_key(key, dictionary):
    shallow_copy = dict(dictionary)
    del shallow_copy[key]
    return shallow_copy

Il y a beaucoup de bonnes réponses, mais je tiens à souligner une chose.

Vous pouvez utiliser la méthode dict.pop() et une instruction del plus générique pour supprimer des éléments d'un dictionnaire. Ils ont tous deux muter le dictionnaire original, vous devez donc faire une copie (voir les détails ci-dessous).

Et tous les deux KeyError une 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 prendre soin de cela:

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 - fournir 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é en cours de suppression, vous pouvez fournir quelque chose, pas nécessaire. Bien qu'il puisse être que l'utilisation de del avec in contrôle est légèrement plus rapide en raison de pop() étant une fonction avec ses propres complications causant des frais généraux. Habituellement, ce n'est pas le cas, donc pop() avec une valeur par défaut est assez bon.

Comme pour la question principale, vous devrez faire une copie de votre dictionnaire, pour enregistrer le dictionnaire original et en avoir un nouveau sans que la clé soit supprimée.

D'autres personnes suggèrent ici de faire une copie complète (profonde) avec copy.deepcopy , ce qui pourrait être une overkill, une copie "normale" (shallow), en utilisant copy.copy() ou dict.copy() , pourrait être assez . Le dictionnaire conserve une référence à l'objet en tant que 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 retiré plus tard automatiquement par le garbage collector, s'il n'y a pas d'autres références pour cela dans la mémoire. Faire une copie en profondeur nécessite plus de calculs par rapport à une copie superficielle, donc cela diminue la performance 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.

Toutefois, si vous avez des objets modifiables 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 en profondeur.

Avec une 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}


L' instruction del supprime un élément:

del d[key]

Cependant, cela mute le dictionnaire existant de sorte que le contenu du dictionnaire change pour quelqu'un d'autre qui a une référence à la même instance. Pour retourner un nouveau dictionnaire, faites une copie du dictionnaire:

def removekey(d, key):
    r = dict(d)
    del r[key]
    return r

Le constructeur dict() effectue une copie superficielle . Pour faire une copie en profondeur, voir le module de copy .


>>> def delete_key(dict, key):
...     del dict[key]
...     return dict
... 
>>> test_dict = {'one': 1, 'two' : 2}
>>> print delete_key(test_dict, 'two')
{'one': 1}
>>>

cela ne fait aucune erreur de manipulation, il suppose que la clé est dans la dict, vous pouvez vouloir vérifier d'abord et raise si ce n'est pas


Je pense que votre solution est la meilleure façon de le faire. Mais si vous voulez une autre solution, vous pouvez créer un nouveau dictionnaire en utilisant les clés du vieux dictionnaire sans inclure votre clé spécifiée, comme ceci:

>>> a
{0: 'zero', 1: 'one', 2: 'two', 3: 'three'}
>>> {i:a[i] for i in a if i!=0}
{1: 'one', 2: 'two', 3: 'three'}

Voici une approche de conception de haut niveau:

def eraseElement(d,k):
    if isinstance(d, dict):
        if k in d:
            d.pop(k)
            print(d)
        else:
            print("Cannot find matching key")
    else:
        print("Not able to delete")


exp = {'A':34, 'B':55, 'C':87}
eraseElement(exp, 'C')

Je passe le dictionnaire et la clé que je veux dans ma fonction, valide si c'est un dictionnaire et si la clé est correcte, et si les deux existent, enlève la valeur du dictionnaire et imprime les restes.

Sortie: {'B': 55, 'A': 34}

J'espère que cela pourra aider!


Ci-dessous l'extrait de code vous aidera certainement, j'ai ajouté des commentaires dans chaque ligne qui vous aidera à comprendre le code.

def execute():
   dic = {'a':1,'b':2}
   dic2 = remove_key_from_dict(dic, 'b')  
   print(dict2)           # {'a': 1}
   print(dict)            # {'a':1,'b':2}

def remove_key_from_dict(dictionary_to_use, key_to_delete):
   copy_of_dict = dict(dictionary_to_use)     # creating clone/copy of the dictionary
   if key_to_delete in copy_of_dict :         # checking given key is present in the dictionary
       del copy_of_dict [key_to_delete]       # deleting the key from the dictionary 
   return copy_of_dict                        # returning the final dictionary

ou vous pouvez aussi utiliser dict.pop ()

d = {"a": 1, "b": 2}

res = d.pop("c")  # No `KeyError` here
print (res)       # this line will not execute

ou la meilleure approche est

res = d.pop("c", "key not found")
print (res)   # key not found
print (d)     # {"a": 1, "b": 2}

res = d.pop("b", "key not found")
print (res)   # 2
print (d)     # {"a": 1}




dictionary