Como remover uma chave de um dicionário Python?

Ao excluir uma chave de um dicionário, eu uso:

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

Existe uma maneira única de fazer isso?

Para excluir uma chave, independentemente de ela estar no dicionário, use o formato de dois argumentos dict.pop():

my_dict.pop('key', None)

Isso retornará my_dict[key]se keyexistir no dicionário e Nonecaso contrário. Se o segundo parâmetro não for especificado (ou seja my_dict.pop('key')) e keynão existir, a KeyErrorserá gerado.

Para excluir uma chave com garantia de existência, você também pode usar

del my_dict['key']

Isso aumentará a KeyErrorse a chave não estiver no dicionário.

Especificamente para responder "existe uma maneira única de fazer isso?"

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

... bem, você perguntou ;-)

Você deve considerar, no entanto, que essa maneira de excluir um objeto de a nãodict é atômica - é possível que 'key'possa estar presente my_dictdurante a ifinstrução, mas pode ser excluída antes da delexecução, caso em que delfalhará com a KeyError. Diante disso, seria mais seguro usardict.pop ou algo do tipo:

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

o que, é claro, definitivamente não é uma linha.

Levei algum tempo para descobrir o que exatamente my_dict.pop("key", None)está fazendo. Então, adicionarei isso como resposta para economizar tempo no Google:

pop(key[, default])

Se a chave estiver no dicionário, remova-a e retorne seu valor; caso contrário, retorne o padrão . Se o padrão não for fornecido e a chave não estiver no dicionário, a KeyErrorserá gerado.

Documentação

del my_dict[key]é um pouco mais rápido do que my_dict.pop(key)para remover uma chave de um dicionário quando a chave 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

Mas quando a chave não existe, if key in my_dict: del my_dict[key]é um pouco mais rápido que my_dict.pop(key, None). Ambos são pelo menos três vezes mais rápidos do que delem uma declaração 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

Se você precisar remover muitas chaves de um dicionário em uma linha de código, acho que usar map () é bastante sucinto e legível por Python:

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}

E se você precisar capturar erros nos quais você insere um valor que não está no dicionário, use lambda dentro de map () assim:

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

ou python3, você deve usar uma compreensão da lista:

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

Funciona. E 'e' não causou um erro, mesmo que o myDict não tenha uma chave 'e'.

Você pode usar uma compreensão de dicionário para criar um novo dicionário com essa chave removida:

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

Você pode excluir por condições. Nenhum erro se keynão existir.

Usando a palavra-chave "del":

del dict[key]

Podemos excluir uma chave de um dicionário Python pelas seguintes abordagens.

Usando a delpalavra - chave; é quase a mesma abordagem que você fez -

 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

Podemos fazer o seguinte:

Mas é preciso ter em mente que, nesse processo, na verdade, ele não excluirá nenhuma chave do dicionário, em vez de excluir a chave específica desse dicionário. Além disso, observei que ele retornava um dicionário que não tinha o mesmo pedido de myDict.

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

Se o rodarmos no shell, ele executará algo como {'five': 500, 'four': 400, 'three': 300, 'two': 200}- observe que não é o mesmo pedido que myDict. Novamente, se tentarmos imprimir myDict, podemos ver todas as chaves, incluindo as que foram excluídas do dicionário por essa abordagem. No entanto, podemos criar um novo dicionário atribuindo a seguinte instrução a uma variável:

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

Agora, se tentarmos imprimi-lo, seguirá a ordem dos pais:

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

Ou

Usando o pop()método

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

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

A diferença entre dele popé que, usando o pop()método, podemos realmente armazenar o valor da chave, se necessário, como o seguinte:

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

Bifurque esta essência para referência futura, se você achar isso útil.

Você pode usar o tratamento de exceções se quiser ser muito detalhado:

try: 
    del dict[key]

except KeyError: pass

Isso é mais lento, porém, que o pop()método, se a chave não existir.

my_dict.pop('key', None)

Não importa para algumas chaves, mas se você estiver fazendo isso repetidamente, o último método será uma aposta melhor.

A abordagem mais rápida é a seguinte:

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

Mas esse método é perigoso porque se 'key'for removido entre as duas linhas, a KeyErrorserá gerado.

Eu prefiro a versão imutável

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}

Outra maneira é usar a compreensão de itens () + dict

items () juntamente com a compreensão de ditado também pode nos ajudar a realizar a tarefa de exclusão do par de valores-chave, mas tem a desvantagem de não ser uma técnica de ditado local. Na verdade, um novo ditado se criado, exceto a chave que não queremos incluir.

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

Resultado:

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

Filtro único na chave

• retorne "key" e remova-o de my_dict se "key" existir em my_dict
• return None se "key" não existir em my_dict

isso mudará my_dictde lugar (mutável)

my_dict.pop('key', None)

Vários filtros nas teclas

gerar um novo ditado (imutável)

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