update - transformar objeto em dicionario python




Adicionar novas chaves a um dicionário? (9)

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

Sim, é possível, e tem um método que implementa isso, mas você não quer 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 dict com uma única nova chave e valor, você pode usar a notação subscrita (veja Mapeamentos aqui) que fornece a atribuição de itens:

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

my_dict é agora:

{'new key': 'new value'}

Melhor Prática 2: O método de update - 2 maneiras

Também podemos atualizar o dict com vários valores de forma eficiente usando o método de update . Podemos estar criando desnecessariamente um dict extra aqui, então esperamos que nosso dict já tenha sido criado e vindo de ou tenha sido usado para outra finalidade:

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 de atualização é com argumentos de palavra-chave, mas como eles precisam ser palavras python legítimas, 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 dict, e aqui nós certamente evitamos criar um dict extra desnecessário:

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'}

Então, agora nós cobrimos três formas de atualizar um dict Python.

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

Há outra maneira de atualizar um dict que você não deve usar, que usa o método __setitem__ . Veja um exemplo de como alguém pode usar o método __setitem__ para adicionar um par de valor-chave a um dict e uma demonstração do baixo 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

Então, vemos que usar a notação de subscrito é realmente muito mais rápido do que usar __setitem__ . Fazer o Pythonic, isto é, usar a linguagem da maneira que deveria ser usada, geralmente é mais legível e computacionalmente eficiente.

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



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 a possibilidade de usar o método update() .


Se você quiser adicionar um dicionário em um dicionário, poderá fazê-lo dessa maneira.

Exemplo: adicionar 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)

Saída:

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

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

dictionary["dictionary_within_a_dictionary"] = {}

antes de adicionar entradas.


Tantas respostas e ainda todo mundo esqueceu sobre o nome estranho, estranhamente comportado, e ainda assim acessível dict.setdefault()

este

value = my_dict.setdefault(key, default)

basicamente só 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

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

No Python 3.5+ você pode fazer:

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

O equivalente do Python 2 é:

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

Depois de 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ê só quer o resultado de adicionar ao original). Eu acho isso uma alternativa refrescante para o 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://.com/a/2255892/514866


Essa pergunta popular aborda métodos funcionais de mesclar dicionários a e b .

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

c = dict( a, **b ) ## see also https://.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 só funciona se as chaves em b forem strings.

Para adicionar ou modificar um único elemento , o dicionário b 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' )

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

dictionary[key] = value




dictionary