Respostas:
d = {'key': 'value'}
print(d)
# {'key': 'value'}
d['mynewkey'] = 'mynewvalue'
print(d)
# {'key': 'value', 'mynewkey': 'mynewvalue'}
.update()
method? Qual é melhor quando?
d[key]=val
sintaxe, 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.update
também pode usar outro dicionário, mas eu pessoalmente prefiro não criar explicitamente um novo dicionário para atualizar outro.
$foo[ ] = [ . . . . ]
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.
x[-1] = 44
o -1
valor 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.
Sinto vontade de consolidar informações sobre dicionários Python:
data = {}
# OR
data = dict()
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))}
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)
data.update({'c':3,'d':4}) # Updates 'c' and adds 'd'
data3 = {}
data3.update(data) # Modifies data3, not data
data3.update(data2) # Modifies data3, not data2
del data[key] # Removes specific element in a dictionary
data.pop(key) # Removes the key & returns the value
data.clear() # Clears entire dictionary
key in data
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
data = dict(zip(list_with_keys, list_with_values))
Isso usa um novo nome de arquivo chamado desembalagem de dicionário .
data = {**data1, **data2, **data3}
O operador de atualização |=
agora trabalha para dicionários:
data |= {'c':3,'d':4}
O operador de mesclagem |
agora trabalha para dicionários:
data = data1 | {'c':3,'d':4}
Sinta-se livre para adicionar mais!
"É 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 = {}
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'}
update
método - 2 maneirasNós também pode atualizar o dict com vários valores de forma eficiente, bem usando o update
método . Podemos criar desnecessariamente um extra dict
aqui, por isso esperamos que o nosso dict
já 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
.
__setitem__
, e por que deve ser evitadoHá outra maneira de atualizar um dict
que 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 dict
e 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.
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.
dictionary[key] = value
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.
dictionary = {"dictionary_within_a_dictionary": {"sub_dict": {"other" : "dictionary"}}}
(ou se dictionary
já é um dicionário, dictionary["dictionary_within_a_dictionary"] = {"sub_dict": {"other" : "dictionary"}}
)
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
[a for a in my_dict if my_dict.update({'a': 1}) is None]
.
{v: k for k, v in my_dict.items() if <some_conditional_check>}
Esta pergunta popular aborda métodos funcionais de mesclar dicionários a
e 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 b
forem cadeias de caracteres.
Para adicionar ou modificar um único elemento , o b
dicioná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' )
c = dict( a, **{'d':'dog'} )
seria melhor escrito c = dict(a, d='dog')
, desde que as chaves sejam conhecidas e não computadas.
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
**
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.
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
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
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, defaultdict
atribua 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.
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.
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
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)
{**mydict, 'new_key': new_val}
.