Python Métodos de Dicionário

Esta é a página de consulta rápida dos métodos de dicionário: as funções que todo dicionário (dict) já traz, para ler valores sem erro, ver as chaves e os valores, acrescentar, juntar e remover. São 11. No fim estão também as operações com dicionários que não são métodos (d[chave], in, del, |). A explicação passo a passo começa na aula Dicionários.

Como ler as tabelas

Exemplo é o que você digitaria depois do >>> do modo interativo, uma linha depois da outra; Resultado é o que o Python 3.14.4 respondeu no computador da Ana.
Quase todos os exemplos usam os preços da padaria: precos = {"pão": 0.5, "leite": 4.0, "café": 18.9}. Cada par "pão": 0.5 é uma chave ("pão") e o seu valor (0.5).
Os dicionários guardam a ordem em que as chaves entraram, e os resultados aparecem sempre nessa ordem.
Quando o exemplo dá erro, o resultado mostra a última linha da mensagem do Python (em inglês).

O erro mais comum: a chave que não existe

Ler com colchetes uma chave que não está no dicionário dá KeyError. O método get lê sem esse risco:

$ python3 -q
>>> precos = {"pão": 0.5, "leite": 4.0, "café": 18.9}
>>> precos["mel"]
Traceback (most recent call last):
  File "<python-input-1>", line 1, in <module>
    precos["mel"]
    ~~~~~~^^^^^^^
KeyError: 'mel'
>>> precos.get("mel", 0)
0
>>> exit()

KeyError: 'mel' = "erro de chave: 'mel'": a mensagem é só o nome da chave que faltou. O get("mel", 0) devolveu o valor padrão 0 em vez de quebrar o programa.

Os 11 métodos, de relance

Método	O que faz	Muda o dicionário?	Devolve
`get(chave, padrão)`	lê um valor sem dar erro	não	o valor, ou o padrão
`keys()`	as chaves	não	uma "vista" das chaves
`values()`	os valores	não	uma "vista" dos valores
`items()`	os pares (chave, valor)	não	uma "vista" dos pares
`update(outro)`	acrescenta ou troca vários pares	sim	`None`
`setdefault(chave, padrão)`	lê; se a chave não existe, cria com o padrão	às vezes	o valor
`pop(chave)`	tira a chave	sim	o valor tirado
`popitem()`	tira o último par que entrou	sim	o par tirado
`clear()`	esvazia	sim	`None`
`copy()`	faz uma cópia	não	um dicionário novo
`dict.fromkeys(chaves, valor)`	cria um dicionário com essas chaves	(cria um novo)	um dicionário novo

Ler valores e ver as chaves

Escrita	O que faz	Exemplo	Resultado	Aula
`d[chave]`	O valor da chave (não é método).	`precos["leite"]`	`4.0`	Dicionários
	chave que não existe	`precos["mel"]`	`KeyError: 'mel'`
`get(chave)`	O valor, ou `None` se a chave não existe (sem erro).	`precos.get("leite")` `print(precos.get("mel"))`	`4.0` `None`	Dicionários
`get(chave, padrão)`	Com um valor padrão no lugar do `None`.	`precos.get("mel", 0)`	`0`
`keys()`	As chaves (keys).	`precos.keys()`	`dict_keys(['pão', 'leite', 'café'])`	Percorrendo um Dicionário
`values()`	Os valores (values).	`precos.values()`	`dict_values([0.5, 4.0, 18.9])`	Percorrendo um Dicionário
	somar os valores	`sum(precos.values())`	`23.4`
`items()`	Os pares chave e valor (items), cada um numa tupla.	`precos.items()`	`dict_items([('pão', 0.5), ('leite', 4.0), ('café', 18.9)])`	Percorrendo um Dicionário
	para virar uma lista de verdade	`list(precos.items())`	`[('pão', 0.5), ('leite', 4.0), ('café', 18.9)]`
`chave in d`	"Tem essa chave?" (procura só nas chaves!)	`"pão" in precos` `0.5 in precos`	`True` `False`	is e in
`valor in d.values()`	"Algum valor é esse?"	`0.5 in precos.values()`	`True`
`len(d)`	Quantos pares.	`len(precos)`	`3`

O que é uma "vista"

keys(), values() e items() não fazem uma cópia: são uma janela para o dicionário, que acompanha as mudanças nele. Dá para usá-las num for, com in, len, sum e sorted. Para ter uma lista de verdade (e usar [0], por exemplo), ponha dentro de list().

Acrescentar e trocar

Escrita	O que faz	Exemplo	Resultado	Aula
`d[chave] = valor`	Cria a chave, se ela não existe…	`estoque = {"pão": 30, "leite": 12}` `estoque["café"] = 5` `estoque`	`{'pão': 30, 'leite': 12, 'café': 5}`	Adicionando e Removendo Chaves
	…ou troca o valor, se existe	`estoque["pão"] = 25` `estoque`	`{'pão': 25, 'leite': 12, 'café': 5}`
`update(outro)`	Faz o mesmo para todos os pares de outro dicionário (update = "atualizar").	`estoque.update({"leite": 10, "ovo": 24})` `estoque`	`{'pão': 25, 'leite': 10, 'café': 5, 'ovo': 24}`	Adicionando e Removendo Chaves
	também com argumentos nomeados	`estoque.update(mel=3)` `estoque`	`{'pão': 25, 'leite': 10, 'café': 5, 'ovo': 24, 'mel': 3}`
`setdefault(chave, padrão)`	Se a chave não existe, cria com o padrão e devolve o padrão…	`estoque.setdefault("sal", 0)`	`0` (e agora `'sal': 0` está no fim do estoque)
	…se existe, só devolve o valor, sem trocar	`estoque.setdefault("pão", 99)`	`25` (o pão continua 25)

Remover

Escrita	O que faz	Exemplo	Resultado	Aula
`pop(chave)`	Tira a chave e devolve o valor dela.	`estoque = {"pão": 30, "leite": 12, "café": 5}` `estoque.pop("leite")` `estoque`	`12` `{'pão': 30, 'café': 5}`	Adicionando e Removendo Chaves
	chave que não existe	`estoque.pop("mel")`	`KeyError: 'mel'`
`pop(chave, padrão)`	Com padrão, não dá erro.	`estoque.pop("mel", None)`	(nada aparece: devolveu `None`)
`popitem()`	Tira o último par que entrou e o devolve como tupla.	`estoque = {"pão": 30, "leite": 12, "café": 5}` `estoque.popitem()` `estoque`	`('café', 5)` `{'pão': 30, 'leite': 12}`
	dicionário vazio	`{}.popitem()`	`KeyError: 'popitem(): dictionary is empty'`
`del d[chave]`	Não é método: apaga a chave, sem devolver.	`del estoque["pão"]` `estoque`	`{'leite': 12}`	Adicionando e Removendo Chaves
	chave que não existe	`del estoque["mel"]`	`KeyError: 'mel'`
`clear()`	Esvazia o dicionário.	`estoque.clear()` `estoque`	`{}`

Criar e copiar

Escrita	O que faz	Exemplo	Resultado	Aula
`dict.fromkeys(chaves, valor)`	Um dicionário novo, com todas as chaves valendo o mesmo. É chamado no tipo `dict`.	`dict.fromkeys(["Ana", "Bia", "Caio"], 0)`	`{'Ana': 0, 'Bia': 0, 'Caio': 0}`	Dicionários
	sem o valor, todas valem `None`	`dict.fromkeys("abc")`	`{'a': None, 'b': None, 'c': None}`
`dict(…)`	Cria com argumentos nomeados, com uma lista de pares ou com `zip`.	`dict(zip(["pão", "leite"], [0.5, 4.0]))`	`{'pão': 0.5, 'leite': 4.0}`	Funções Embutidas
`{chave: valor for …}`	Monta um dicionário a partir de um laço.	`{n: n * n for n in range(1, 5)}`	`{1: 1, 2: 4, 3: 9, 4: 16}`	Dict e Set Comprehension
`copy()`	Uma cópia: mudar a cópia não muda o original.	`a = {"pão": 0.5}` `b = a.copy()` `b["mel"] = 22.0` `a`, depois `b`	`{'pão': 0.5}` `{'pão': 0.5, 'mel': 22.0}`	Cópia Rasa e Cópia Profunda

fromkeys com uma lista como valor

Em dict.fromkeys(nomes, []), todas as chaves recebem a mesma lista: acrescentar algo na lista de uma acrescenta em todas. Com d = dict.fromkeys(["Ana", "Bia"], []) e depois d["Ana"].append(7), o d fica {'Ana': [7], 'Bia': [7]}. Para uma lista nova em cada chave, use {nome: [] for nome in nomes}.

Juntar e comparar

Escrita	O que faz	Exemplo	Resultado	Aula
`a \| b`	Um dicionário novo com os pares dos dois. Se a chave está nos dois, vale o de `b` (o da direita). O `a` não muda.	`loja = {"pão": 0.5, "leite": 4.0}` `promo = {"leite": 3.5, "mel": 22.0}` `loja \| promo`	`{'pão': 0.5, 'leite': 3.5, 'mel': 22.0}`	Adicionando e Removendo Chaves
`a \|= b`	O mesmo que `a.update(b)`: muda o `a`.	`loja \|= promo` `loja`	`{'pão': 0.5, 'leite': 3.5, 'mel': 22.0}`
`{a, b}`	O jeito mais antigo de fazer o `a \| b`.	`{{"a": 1}, {"b": 2}}`	`{'a': 1, 'b': 2}`	args e *kwargs
`a == b`	Mesmos pares? A ordem não importa.	`{"a": 1, "b": 2} == {"b": 2, "a": 1}`	`True`	Comparações

Percorrer e ordenar

Escrita	O que faz	Exemplo	Resultado	Aula
`for chave, valor in d.items():`	Passa por todos os pares.	`for nome, preco in precos.items():` `print(nome, preco)`	`pão 0.5` `leite 4.0` `café 18.9`	Percorrendo um Dicionário
`list(d)`	Percorrer o dicionário direto dá as chaves.	`list(precos)`	`['pão', 'leite', 'café']`
`reversed(d)`	As chaves, da última que entrou para a primeira.	`list(reversed(precos))`	`['café', 'leite', 'pão']`
`sorted(d)`	As chaves em ordem alfabética.	`sorted(precos)`	`['café', 'leite', 'pão']`	Ordenando Listas
`sorted(d.items(), key=…)`	Os pares, ordenados pelo valor.	`sorted(precos.items(), key=lambda par: par[1])`	`[('pão', 0.5), ('leite', 4.0), ('café', 18.9)]`	lambda
`max(d, key=d.get)`	A chave que tem o maior valor.	`max(precos, key=precos.get)`	`'café'`	Funções Embutidas
	não dá para mudar o tamanho do dicionário dentro do `for` que o percorre	`for k in precos:` `precos["novo"] = 1`	`RuntimeError: dictionary changed size during iteration`

Que valores podem ser chave?

Textos, números, True/False e tuplas (de valores que não mudam). Listas, dicionários e conjuntos não, porque podem mudar. No Python 3.14, a mensagem de erro ficou mais clara: {[1, 2]: "x"} dá TypeError: cannot use 'list' as a dict key (unhashable type: 'list') = "não dá para usar uma lista como chave de dicionário". 3.14 No 3.13, a mesma linha dizia só unhashable type: 'list'. Veja Mutável × Imutável.

Experimente

Missão: a Ana fez uma votação do lanche da turma e quer contar os votos. Rode e veja o KeyError: no primeiro voto, a chave 'pão' ainda não existe. Conserte a linha do laço usando contagem.get(voto, 0) no lugar de contagem[voto] (só do lado direito do =). A saída deve ser {'pão': 3, 'bolo': 2, 'café': 1}.

votos = ["pão", "bolo", "pão", "café", "pão", "bolo"]
contagem = {}
for voto in votos:
    contagem[voto] = contagem[voto] + 1
print(contagem)

votos = ["pão", "bolo", "pão", "café", "pão", "bolo"]
contagem = {}
for voto in votos:
    contagem[voto] = contagem.get(voto, 0) + 1
print(contagem)

No computador da Ana, o programa da missão, antes e depois do conserto:

$ python3 votos.py
Traceback (most recent call last):
  File "/home/ana/votos.py", line 4, in <module>
    contagem[voto] = contagem[voto] + 1
                     ~~~~~~~~^^^^^^
KeyError: 'pão'
$ python3 votos2.py
{'pão': 3, 'bolo': 2, 'café': 1}

Livre: o estoque da padaria. Acrescente produtos com update, tire outros com pop, troque "mel" por "pão" na última linha.

estoque = {"pão": 30, "leite": 12, "café": 5}
estoque.update({"leite": 10, "ovo": 24})
vendido = estoque.pop("café")
print("Café saiu do estoque:", vendido, "pacotes")
for produto, quantidade in estoque.items():
    print(f"{produto:<6} {quantidade:>3}")
print("Total de itens:", sum(estoque.values()))
print("Tem mel?", "mel" in estoque, "- quantidade:", estoque.get("mel", 0))

$ python3 estoque.py
Café saiu do estoque: 5 pacotes
pão     30
leite   10
ovo     24
Total de itens: 64
Tem mel? False - quantidade: 0

Resumo

Ler: d[chave] dá KeyError se a chave falta; d.get(chave, padrão) não dá.
Ver: keys(), values(), items() (este, no for chave, valor in d.items():). in procura só nas chaves.
Acrescentar e trocar: d[chave] = valor, update, |=; setdefault cria só se faltar.
Remover: pop(chave) devolve o valor; popitem() tira o último par; del d[chave]; clear().
Criar: dict.fromkeys, dict(zip(…)), dict comprehension; copiar com copy(); juntar com a | b.
Chaves precisam ser valores que não mudam: listas não podem ser chave.