Comment supprimer une clé d'un dictionnaire Python?

Lors de la suppression d'une clé d'un dictionnaire, j'utilise:

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

Y a-t-il une façon unique de procéder?

Pour supprimer une clé, qu'elle se trouve dans le dictionnaire ou non, utilisez la forme à deux arguments de dict.pop():

my_dict.pop('key', None)

Cela retournera my_dict[key]s'il keyexiste dans le dictionnaire, et Nonesinon. Si le deuxième paramètre n'est pas spécifié (c'est-à-dire. my_dict.pop('key')) Et keyn'existe pas, a KeyErrorest levé.

Pour supprimer une clé dont l'existence est garantie, vous pouvez également utiliser

del my_dict['key']

Cela soulèvera un KeyErrorsi la clé n'est pas dans le dictionnaire.

Spécifiquement pour répondre "y a-t-il une façon de faire cela sur une ligne?"

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

... eh bien, vous avez demandé ;-)

Vous devez considérer, cependant, que cette façon de supprimer un objet de a dictn'est pas atomique - il est possible qu'elle 'key'se trouve my_dictpendant l' ifinstruction, mais peut être supprimée avant l' delexécution, auquel cas delelle échouera avec a KeyError. Compte tenu de cela, il serait plus sûr d' utiliserdict.pop soit quelque chose du genre

try:
    del my_dict['key']
except KeyError:
    pass

qui, bien sûr, n'est certainement pas un vol simple.

Il m'a fallu un certain temps pour comprendre ce qui se passe exactement my_dict.pop("key", None). Je vais donc ajouter ceci comme réponse pour gagner du temps sur Google:

pop(key[, default])

Si la clé est dans le dictionnaire, supprimez-la et retournez sa valeur, sinon retournez par défaut . Si la valeur par défaut n'est pas indiquée et que la clé n'est pas dans le dictionnaire, un KeyErrorest levé.

Documentation

del my_dict[key]est légèrement plus rapide que my_dict.pop(key)pour supprimer une clé d'un dictionnaire lorsque la clé existe

>>> import timeit
>>> setup = "d = {i: i for i in range(100000)}"

>>> timeit.timeit("del d[3]", setup=setup, number=1)
1.79e-06
>>> timeit.timeit("d.pop(3)", setup=setup, number=1)
2.09e-06
>>> timeit.timeit("d2 = {key: val for key, val in d.items() if key != 3}", setup=setup, number=1)
0.00786

Mais lorsque la clé n'existe pas, if key in my_dict: del my_dict[key]c'est légèrement plus rapide que my_dict.pop(key, None). Les deux sont au moins trois fois plus rapides que deldans une instruction try/ except:

>>> timeit.timeit("if 'missing key' in d: del d['missing key']", setup=setup)
0.0229
>>> timeit.timeit("d.pop('missing key', None)", setup=setup)
0.0426
>>> try_except = """
... try:
...     del d['missing key']
... except KeyError:
...     pass
... """
>>> timeit.timeit(try_except, setup=setup)
0.133

Si vous devez supprimer un grand nombre de clés d'un dictionnaire sur une seule ligne de code, je pense que l'utilisation de map () est assez succincte et lisible en Pythonic:

myDict = {'a':1,'b':2,'c':3,'d':4}
map(myDict.pop, ['a','c']) # The list of keys to remove
>>> myDict
{'b': 2, 'd': 4}

Et si vous avez besoin de détecter des erreurs lorsque vous entrez une valeur qui n'est pas dans le dictionnaire, utilisez lambda à l'intérieur de map () comme ceci:

map(lambda x: myDict.pop(x,None), ['a', 'c', 'e'])
[1, 3, None] # pop returns
>>> myDict
{'b': 2, 'd': 4}

ou dans python3, vous devez utiliser une liste de compréhension à la place:

[myDict.pop(x, None) for x in ['a', 'c', 'e']]

Ça marche. Et «e» n'a pas causé d'erreur, même si myDict n'avait pas de clé «e».

Vous pouvez utiliser une compréhension de dictionnaire pour créer un nouveau dictionnaire avec cette clé supprimée:

>>> my_dict = {k: v for k, v in my_dict.items() if k != 'key'}

Vous pouvez supprimer par conditions. Aucune erreur s'il keyn'existe pas.

Utilisation du mot clé "del":

del dict[key]

Nous pouvons supprimer une clé d'un dictionnaire Python par les approches suivantes.

En utilisant le delmot - clé; c'est presque la même approche que vous l'avez fait -

 myDict = {'one': 100, 'two': 200, 'three': 300 }
 print(myDict)  # {'one': 100, 'two': 200, 'three': 300}
 if myDict.get('one') : del myDict['one']
 print(myDict)  # {'two': 200, 'three': 300}

Ou

Nous pouvons faire comme suit:

Mais il faut garder à l'esprit que, dans ce processus, il ne supprimera aucune clé du dictionnaire plutôt que d' exclure une clé spécifique de ce dictionnaire. De plus, j'ai observé qu'il renvoyait un dictionnaire qui n'était pas commandé de la même manière que myDict.

myDict = {'one': 100, 'two': 200, 'three': 300, 'four': 400, 'five': 500}
{key:value for key, value in myDict.items() if key != 'one'}

Si nous l'exécutons dans le shell, il exécutera quelque chose comme {'five': 500, 'four': 400, 'three': 300, 'two': 200}- notez que ce n'est pas le même ordre que myDict. Encore une fois, si nous essayons d'imprimer myDict, nous pouvons voir toutes les clés, y compris celles que nous avons exclues du dictionnaire par cette approche. Cependant, nous pouvons créer un nouveau dictionnaire en affectant l'instruction suivante à une variable:

var = {key:value for key, value in myDict.items() if key != 'one'}

Maintenant, si nous essayons de l'imprimer, il suivra l'ordre des parents:

print(var) # {'two': 200, 'three': 300, 'four': 400, 'five': 500}

Ou

Utilisation de la pop()méthode.

myDict = {'one': 100, 'two': 200, 'three': 300}
print(myDict)

if myDict.get('one') : myDict.pop('one')
print(myDict)  # {'two': 200, 'three': 300}

La différence entre delet popest que, en utilisant la pop()méthode, nous pouvons réellement stocker la valeur de la clé si nécessaire, comme suit:

myDict = {'one': 100, 'two': 200, 'three': 300}
if myDict.get('one') : var = myDict.pop('one')
print(myDict) # {'two': 200, 'three': 300}
print(var)    # 100

Fourchez cet élément pour référence future, si vous trouvez cela utile.

Vous pouvez utiliser la gestion des exceptions si vous voulez être très bavard:

try: 
    del dict[key]

except KeyError: pass

Cependant, c'est plus lent que la pop()méthode, si la clé n'existe pas.

my_dict.pop('key', None)

Cela n'aura pas d'importance pour quelques clés, mais si vous faites cela à plusieurs reprises, alors la dernière méthode est une meilleure mise.

L'approche la plus rapide est la suivante:

if 'key' in dict: 
    del myDict['key']

Mais cette méthode est dangereuse car si elle 'key'est supprimée entre les deux lignes, un KeyErrorsera levé.

Je préfère la version immuable

foo = {
    1:1,
    2:2,
    3:3
}
removeKeys = [1,2]
def woKeys(dct, keyIter):
    return {
        k:v
        for k,v in dct.items() if k not in keyIter
    }

>>> print(woKeys(foo, removeKeys))
{3: 3}
>>> print(foo)
{1: 1, 2: 2, 3: 3}

Une autre méthode consiste à utiliser items () + compréhension du dict

items () couplé à la compréhension de dict peut également nous aider à réaliser la tâche de suppression de paire clé-valeur, mais il présente l'inconvénient de ne pas être une technique de dict en place. En fait, un nouveau dict si créé à l'exception de la clé que nous ne souhaitons pas inclure.

test_dict = {"sai" : 22, "kiran" : 21, "vinod" : 21, "sangam" : 21} 

# Printing dictionary before removal 
print ("dictionary before performing remove is : " + str(test_dict)) 

# Using items() + dict comprehension to remove a dict. pair 
# removes  vinod
new_dict = {key:val for key, val in test_dict.items() if key != 'vinod'} 

# Printing dictionary after removal 
print ("dictionary after remove is : " + str(new_dict)) 

Production:

dictionary before performing remove is : {'sai': 22, 'kiran': 21, 'vinod': 21, 'sangam': 21}
dictionary after remove is : {'sai': 22, 'kiran': 21, 'sangam': 21}

Filtre unique sur clé

• retourner "clé" et la supprimer de my_dict si "clé" existe dans my_dict
• retourne Aucun si "clé" n'existe pas dans mon_dict

cela va changer my_dicten place (mutable)

my_dict.pop('key', None)

Plusieurs filtres sur les touches

générer un nouveau dict (immuable)

dic1 = {
    "x":1,
    "y": 2,
    "z": 3
}

def func1(item):
    return  item[0]!= "x" and item[0] != "y"

print(
    dict(
        filter(
            lambda item: item[0] != "x" and item[0] != "y", 
            dic1.items()
            )
    )
)