Como posso adicionar novas chaves a um dicionário?


2623

É possível adicionar uma chave a um dicionário Python depois que ele foi criado?

Parece não ter um .add()método.


25
Se você está aqui tentando descobrir como adicionar uma chave e retornar um novo dicionário, você pode fazer isso em python3.5 +: {**mydict, 'new_key': new_val}.
precisa

Use a resposta aceita: d ['mynewkey'] = 'mynewvalue' ou você pode usar val = d.setdefault ('mynewkey', 'mynewvalue')
Ol 'Dawg

Respostas:


3403
d = {'key': 'value'}
print(d)
# {'key': 'value'}
d['mynewkey'] = 'mynewvalue'
print(d)
# {'key': 'value', 'mynewkey': 'mynewvalue'}

108
A explicação é: você cria um novo par de chave \ valor em um dicionário atribuindo um valor a essa chave. Se a chave não existir, é adicionada e aponta para esse valor. Se existir, o valor atual para o qual ele aponta é substituído.
R. Navega

9
Qual é a diferença entre this e the .update()method? Qual é melhor quando?
hegash

14
@hegash a d[key]=valsintaxe, pois é mais curta e pode manipular qualquer objeto como chave (desde que seja lavável) e define apenas um valor, enquanto que .update(key1=val1, key2=val2)é melhor se você deseja definir vários valores ao mesmo tempo, desde que as chaves são strings (uma vez que os kwargs são convertidos em strings). dict.updatetambém pode usar outro dicionário, mas eu pessoalmente prefiro não criar explicitamente um novo dicionário para atualizar outro.
22819 bgusach

experimentá-lo, aqui está um exemplo: repl.it/@SmaMa/Add-key-to-dict
Sma Ma

como posso adicionar um elemento em um dict aninhado. Como php$foo[ ] = [ . . . . ]
Juan-Kabbali 28/04

1044

Para adicionar várias chaves simultaneamente, use dict.update():

>>> x = {1:2}
>>> print(x)
{1: 2}

>>> d = {3:4, 5:6, 7:8}
>>> x.update(d)
>>> print(x)
{1: 2, 3: 4, 5: 6, 7: 8}

Para adicionar uma única chave, a resposta aceita possui menos sobrecarga computacional.


13
isso é muuuuito ineficiente para criar um dicionário apenas para atualizar uma chave. Faça isso apenas se você tiver mais de uma chave (pode haver um limite acima do qual é melhor criar um ditado)
Jean-François Fabre

10
@ Jean-FrançoisFabre Este é um código de exemplo. Você realmente não deve tratar as respostas como cobrindo todos os casos.
Robert Brisita 27/03/19

1
dá a impressão errada de que é a maneira preferida de adicionar uma chave.
Jean-François Fabre

@ Jean-FrançoisFabre Como a ordem do ditado é garantida no Python 3.7+ (e fornecida no 3.6+) , essa pode ser a maneira preferida de adicionar uma única chave quando a ordem é importante .
ingyhere 20/01

se você criar outra chave como x[-1] = 44o -1valor também está no final. De qualquer forma, a resposta foi editada e está muito melhor agora. A atualização com um dicionário é boa quando é provável que contenha muitos itens.
Jean-François Fabre

930

Sinto vontade de consolidar informações sobre dicionários Python:

Criando um dicionário vazio

data = {}
# OR
data = dict()

Criando um dicionário com valores iniciais

data = {'a': 1, 'b': 2, 'c': 3}
# OR
data = dict(a=1, b=2, c=3)
# OR
data = {k: v for k, v in (('a', 1), ('b',2), ('c',3))}

Inserindo / Atualizando um Único Valor

data['a'] = 1  # Updates if 'a' exists, else adds 'a'
# OR
data.update({'a': 1})
# OR
data.update(dict(a=1))
# OR
data.update(a=1)

Inserindo / Atualizando Vários Valores

data.update({'c':3,'d':4})  # Updates 'c' and adds 'd'

Criando um dicionário mesclado sem modificar originais

data3 = {}
data3.update(data)  # Modifies data3, not data
data3.update(data2)  # Modifies data3, not data2

Excluindo itens no dicionário

del data[key]  # Removes specific element in a dictionary
data.pop(key)  # Removes the key & returns the value
data.clear()  # Clears entire dictionary

Verifique se uma chave já está no dicionário

key in data

Iterar através de pares em um dicionário

for key in data: # Iterates just through the keys, ignoring the values
for key, value in d.items(): # Iterates through the pairs
for key in d.keys(): # Iterates just through key, ignoring the values
for value in d.values(): # Iterates just through value, ignoring the keys

Crie um dicionário a partir de duas listas

data = dict(zip(list_with_keys, list_with_values))

Novo no Python 3.5

Criando um dicionário mesclado sem modificar os originais:

Isso usa um novo nome de arquivo chamado desembalagem de dicionário .

data = {**data1, **data2, **data3}

Novo no Python 3.9

Atualizar ou adicionar valores para um dicionário existente

O operador de atualização |= agora trabalha para dicionários:

data |= {'c':3,'d':4}

Criando um dicionário mesclado sem modificar originais

O operador de mesclagem | agora trabalha para dicionários:

data = data1 | {'c':3,'d':4}

Sinta-se livre para adicionar mais!


145

"É possível adicionar uma chave a um dicionário Python depois que ele foi criado? Parece não ter um método .add ()."

Sim, é possível e ele possui um método que implementa isso, mas você não deseja usá-lo diretamente.

Para demonstrar como e como não usá-lo, vamos criar um dict vazio com o literal dict {}:

my_dict = {}

Prática recomendada 1: Notação subscrita

Para atualizar este ditado com uma única nova chave e valor, você pode usar a notação subscrita (consulte Mapeamentos aqui) que fornece a atribuição de itens:

my_dict['new key'] = 'new value'

my_dict é agora:

{'new key': 'new value'}

Prática recomendada 2: O updatemétodo - 2 maneiras

Nós também pode atualizar o dict com vários valores de forma eficiente, bem usando o updatemétodo . Podemos criar desnecessariamente um extra dictaqui, por isso esperamos que o nosso dictjá tenha sido criado e vindo de ou usado para outro propósito:

my_dict.update({'key 2': 'value 2', 'key 3': 'value 3'})

my_dict é agora:

{'key 2': 'value 2', 'key 3': 'value 3', 'new key': 'new value'}

Outra maneira eficiente de fazer isso com o método update é com argumentos de palavras-chave, mas como eles precisam ser legítimos em python, você não pode ter espaços ou símbolos especiais ou iniciar o nome com um número, mas muitos consideram isso uma maneira mais legível. para criar chaves para um ditado, e aqui certamente evitamos criar um extra desnecessário dict:

my_dict.update(foo='bar', foo2='baz')

e my_dicté agora:

{'key 2': 'value 2', 'key 3': 'value 3', 'new key': 'new value', 
 'foo': 'bar', 'foo2': 'baz'}

Portanto, agora abordamos três maneiras pitônicas de atualizar a dict.


Método mágico __setitem__, e por que deve ser evitado

Há outra maneira de atualizar um dictque você não deve usar, que usa o __setitem__método Aqui está um exemplo de como alguém pode usar o __setitem__método para adicionar um par de valores-chave a dicte uma demonstração do fraco desempenho de usá-lo:

>>> d = {}
>>> d.__setitem__('foo', 'bar')
>>> d
{'foo': 'bar'}


>>> def f():
...     d = {}
...     for i in xrange(100):
...         d['foo'] = i
... 
>>> def g():
...     d = {}
...     for i in xrange(100):
...         d.__setitem__('foo', i)
... 
>>> import timeit
>>> number = 100
>>> min(timeit.repeat(f, number=number))
0.0020880699157714844
>>> min(timeit.repeat(g, number=number))
0.005071878433227539

Portanto, vemos que o uso da notação subscrita é realmente muito mais rápido que o uso __setitem__. Fazer o Pythonic, isto é, usar a linguagem da maneira que ela deveria ser usada, geralmente é mais legível e eficiente em termos computacionais.


1
A diferença é bem menos acentuada em 2020 (na minha máquina, 1,35 ms de assinatura vs 2ms para d.__setitem__), embora a conclusão (e especialmente a última frase) permaneça sólida. A elevação da pesquisa do nome do método fora do loop reduziu o tempo para cerca de 1,65 ms; a diferença restante provavelmente se deve principalmente à sobrecarga inevitável do mecanismo de chamada Python.
holdenweb


58

Se você deseja adicionar um dicionário a um dicionário, pode fazê-lo dessa maneira.

Exemplo: adicione uma nova entrada ao seu dicionário e sub-dicionário

dictionary = {}
dictionary["new key"] = "some new entry" # add new dictionary entry
dictionary["dictionary_within_a_dictionary"] = {} # this is required by python
dictionary["dictionary_within_a_dictionary"]["sub_dict"] = {"other" : "dictionary"}
print (dictionary)

Resultado:

{'new key': 'some new entry', 'dictionary_within_a_dictionary': {'sub_dict': {'other': 'dictionarly'}}}

NOTA: O Python exige que você primeiro adicione uma sub

dictionary["dictionary_within_a_dictionary"] = {}

antes de adicionar entradas.


13
isso é tão irrelevante para a pergunta como a maioria dos comentários em php.net páginas de manual ...
Erik Kaplun

2
Nada para impedi-lo de fazer isso em uma linha: dictionary = {"dictionary_within_a_dictionary": {"sub_dict": {"other" : "dictionary"}}}(ou se dictionaryjá é um dicionário, dictionary["dictionary_within_a_dictionary"] = {"sub_dict": {"other" : "dictionary"}})
Chris

43

A sintaxe ortodoxa é d[key] = value, mas se o teclado estiver sem as chaves de colchete, você poderá:

d.__setitem__(key, value)

De fato, definição __getitem__e __setitem__métodos é como você pode fazer sua própria classe suportar a sintaxe entre colchetes. Consulte https://python.developpez.com/cours/DiveIntoPython/php/endiveintopython/object_oriented_framework/special_class_methods.php


16
Eu acharia extremamente difícil programar com python sem as teclas de suporte no meu teclado.
Bobort

2
Esta foi a única maneira que pude encontrar para definir valores de dicionário dentro de uma lista de compreensão. Obrigado
chris stevens

3
@chrisstevens se você quiser definir um valor em uma compreensão que um hack que eu usei é [a for a in my_dict if my_dict.update({'a': 1}) is None].
Jeremy Logan

Curioso ... isso (ou seja, faltando colchetes) é comum?
Aleister Tanek Javas Mraz 13/08/19

@chrisstevens @JeremyLogan Por que usar uma compreensão de lista quando você pode usar uma compreensão de ditado? {v: k for k, v in my_dict.items() if <some_conditional_check>}
ingyhere 20/01

36

Você pode criar um:

class myDict(dict):

    def __init__(self):
        self = dict()

    def add(self, key, value):
        self[key] = value

## example

myd = myDict()
myd.add('apples',6)
myd.add('bananas',3)
print(myd)

Dá:

>>> 
{'apples': 6, 'bananas': 3}

31

Esta pergunta popular aborda métodos funcionais de mesclar dicionários ae b.

Aqui estão alguns dos métodos mais simples (testados em Python 3) ...

c = dict( a, **b ) ## see also https://stackoverflow.com/q/2255878
c = dict( list(a.items()) + list(b.items()) )
c = dict( i for d in [a,b] for i in d.items() )

Nota: O primeiro método acima funciona apenas se as chaves bforem cadeias de caracteres.

Para adicionar ou modificar um único elemento , o bdicionário conteria apenas esse elemento ...

c = dict( a, **{'d':'dog'} ) ## returns a dictionary based on 'a'

Isso é equivalente a ...

def functional_dict_add( dictionary, key, value ):
   temp = dictionary.copy()
   temp[key] = value
   return temp

c = functional_dict_add( a, 'd', 'dog' )

8
Comentário interessante sobre o primeiro método do BDFL do Python ( aqui ).
Nobar

c = dict( a, **{'d':'dog'} )seria melhor escrito c = dict(a, d='dog'), desde que as chaves sejam conhecidas e não computadas.
holdenweb

21

Vamos fingir que você quer viver no mundo imutável e NÃO deseja modificar o original, mas deseja criar um novo dict que seja o resultado da adição de uma nova chave ao original.

No Python 3.5+, você pode:

params = {'a': 1, 'b': 2}
new_params = {**params, **{'c': 3}}

O equivalente em Python 2 é:

params = {'a': 1, 'b': 2}
new_params = dict(params, **{'c': 3})

Após um destes:

params ainda é igual a {'a': 1, 'b': 2}

e

new_params é igual a {'a': 1, 'b': 2, 'c': 3}

Haverá momentos em que você não deseja modificar o original (você deseja apenas o resultado da adição ao original). Acho isso uma alternativa refrescante ao seguinte:

params = {'a': 1, 'b': 2}
new_params = params.copy()
new_params['c'] = 3

ou

params = {'a': 1, 'b': 2}
new_params = params.copy()
new_params.update({'c': 3})

Referência: https://stackoverflow.com/a/2255892/514866


2
Em uma longa conversa com um colega de programação pró-funcional, um bom argumento foi levantado. Uma desvantagem da abordagem acima é que se alguém lendo o código não estiver familiarizado com o **Python (muitos não estão), não será óbvio o que está acontecendo. Há momentos em que você prefere uma abordagem menos funcional para melhor legibilidade.
Campeterson

5
Não podemos prever qual subconjunto da linguagem Python nossos leitores conhecem; portanto, é justo supor que eles conheçam toda a linguagem para pesquisar nos documentos as partes que não conhecem.
7308 Gabriel

17

Tantas respostas e ainda todo mundo esqueceu o nome estranho, o comportamento estranho e ainda assim útil dict.setdefault()

este

value = my_dict.setdefault(key, default)

basicamente faz isso:

try:
    value = my_dict[key]
except KeyError: # key not found
    value = my_dict[key] = default

por exemplo

>>> mydict = {'a':1, 'b':2, 'c':3}
>>> mydict.setdefault('d', 4)
4 # returns new value at mydict['d']
>>> print(mydict)
{'a':1, 'b':2, 'c':3, 'd':4} # a new key/value pair was indeed added
# but see what happens when trying it on an existing key...
>>> mydict.setdefault('a', 111)
1 # old value was returned
>>> print(mydict)
{'a':1, 'b':2, 'c':3, 'd':4} # existing key was ignored

5

Se você não está ingressando em dois dicionários, mas adicionando novos pares de valores-chave a um dicionário, usar a notação subscrita parece ser a melhor maneira.

import timeit

timeit.timeit('dictionary = {"karga": 1, "darga": 2}; dictionary.update({"aaa": 123123, "asd": 233})')
>> 0.49582505226135254

timeit.timeit('dictionary = {"karga": 1, "darga": 2}; dictionary["aaa"] = 123123; dictionary["asd"] = 233;')
>> 0.20782899856567383

No entanto, se você quiser adicionar, por exemplo, milhares de novos pares de valores-chave, considere usar o update()método


3

Eu acho que também seria útil apontar o Python collections módulo que consiste em muitas subclasses e invólucros úteis de dicionário que simplificam a adição e modificação de tipos de dados em um dicionário , especificamente defaultdict:

subclasse dict que chama uma função de fábrica para fornecer valores ausentes

Isso é particularmente útil se você estiver trabalhando com dicionários que sempre consistem nos mesmos tipos ou estruturas de dados, por exemplo, um dicionário de listas.

>>> from collections import defaultdict
>>> example = defaultdict(int)
>>> example['key'] += 1
>>> example['key']
defaultdict(<class 'int'>, {'key': 1})

Se a chave ainda não existir, defaultdictatribua o valor fornecido (no nosso caso 10) como o valor inicial ao dicionário (geralmente usado dentro de loops). Esta operação, portanto, faz duas coisas: adiciona uma nova chave a um dicionário (conforme a pergunta) e atribui o valor se a chave ainda não existir. Com o dicionário padrão, isso geraria um erro, pois a +=operação está tentando acessar um valor que ainda não existe:

>>> example = dict()
>>> example['key'] += 1
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'key'

Sem o uso de defaultdict, a quantidade de código para adicionar um novo elemento seria muito maior e talvez seja algo como:

# This type of code would often be inside a loop
if 'key' not in example:
    example['key'] = 0  # add key and initial value to dict; could also be a list
example['key'] += 1  # this is implementing a counter

defaultdict também pode ser usado com tipos de dados complexos, como list e set:

>>> example = defaultdict(list)
>>> example['key'].append(1)
>>> example
defaultdict(<class 'list'>, {'key': [1]})

Adicionar um elemento inicializa automaticamente a lista.


3

Aqui está outra maneira que eu não vi aqui:

>>> foo = dict(a=1,b=2)
>>> foo
{'a': 1, 'b': 2}
>>> goo = dict(c=3,**foo)
>>> goo
{'c': 3, 'a': 1, 'b': 2}

Você pode usar o construtor de dicionário e a expansão implícita para reconstruir um dicionário. Além disso, curiosamente, esse método pode ser usado para controlar a ordem posicional durante a construção do dicionário ( pós Python 3.6 ). De fato, a ordem de inserção é garantida para Python 3.7 e superior!

>>> foo = dict(a=1,b=2,c=3,d=4)
>>> new_dict = {k: v for k, v in list(foo.items())[:2]}
>>> new_dict
{'a': 1, 'b': 2}
>>> new_dict.update(newvalue=99)
>>> new_dict
{'a': 1, 'b': 2, 'newvalue': 99}
>>> new_dict.update({k: v for k, v in list(foo.items())[2:]})
>>> new_dict
{'a': 1, 'b': 2, 'newvalue': 99, 'c': 3, 'd': 4}
>>> 

O acima está usando a compreensão do dicionário.


2

primeiro para verificar se a chave já existe

a={1:2,3:4}
a.get(1)
2
a.get(5)
None

então você pode adicionar a nova chave e valor


0

adicione chave de dicionário, classe de valor.

class myDict(dict):

    def __init__(self):
        self = dict()

    def add(self, key, value):
        #self[key] = value # add new key and value overwriting any exiting same key
        if self.get(key)!=None:
            print('key', key, 'already used') # report if key already used
        self.setdefault(key, value) # if key exit do nothing


## example

myd = myDict()
name = "fred"

myd.add('apples',6)
print('\n', myd)
myd.add('bananas',3)
print('\n', myd)
myd.add('jack', 7)
print('\n', myd)
myd.add(name, myd)
print('\n', myd)
myd.add('apples', 23)
print('\n', myd)
myd.add(name, 2)
print(myd)
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.