dict é um tipo integrado que representa um mapeamento associativo ou dicionário. Um dicionário é compatível com indexação usando d[k]
e testes de associação de chave usando k in d
. se ambas as operações levam um tempo constante. Dicionários descongelados são mutáveis e podem ser atualizados atribuindo a d[k]
ou chamando determinados métodos. Os dicionários são iteráveis. A iteração gera a sequência de chaves na ordem de inserção. A ordem de iteração não é afetada pela atualização do valor associado a uma chave existente, mas é afetada pela remoção e reinserção de uma chave.
d = {0: 0, 2: 2, 1: 1} [k for k in d] # [0, 2, 1] d.pop(2) d[0], d[2] = "a", "b" 0 in d, "a" in d # (True, False) [(k, v) for k, v in d.items()] # [(0, "a"), (1, 1), (2, "b")]
Há quatro maneiras de criar um dicionário:
- Uma expressão de dicionário
{k: v, ...}
produz um novo dicionário com as entradas de chave-valor especificadas, inseridas na ordem em que aparecem na expressão. A avaliação falha se duas expressões de chave gerarem o mesmo valor. - Uma compreensão de dicionário
{k: v for vars in seq}
gera um novo dicionário em que cada par de chave-valor é inserido na ordem de iteração do loop. Cópias são permitidas: a primeira inserção de uma determinada chave determina sua posição na sequência e a última determina seu valor associado.{k: v for k, v in (("a", 0), ("b", 1), ("a", 2))} # {"a": 2, "b": 1} {i: 2*i for i in range(3)} # {0: 0, 1: 2, 2: 4}
- Uma chamada para a função dict integrada retorna um dicionário contendo as entradas especificadas, que são inseridas na ordem dos argumentos, com os argumentos posicionais antes dos nomeados. Assim como nas compreensões, chaves duplicadas são permitidas.
- A expressão de união
x | y
gera um novo dicionário combinando dois dicionários existentes. Se os dois dicionários tiverem uma chavek
em comum, o valor do dicionário do lado direito da chave (ou seja,y[k]
) vai prevalecer. A variante|=
do operador de união modifica um dicionário no local. Exemplo:d = {"foo": "FOO", "bar": "BAR"} | {"foo": "FOO2", "baz": "BAZ"} # d == {"foo": "FOO2", "bar": "BAR", "baz": "BAZ"} d = {"a": 1, "b": 2} d |= {"b": 3, "c": 4} # d == {"a": 1, "b": 3, "c": 4}
Membros
limpar
None
dict.clear()
Remover todos os itens do dicionário.
get
unknown dict.get(key, default=None)Retorna o valor de
key
se key
estiver no dicionário. Caso contrário, retorna default
. Se default
não for fornecido, o padrão será None
para que esse método nunca gere um erro.
Parâmetros
Parâmetro | Descrição |
---|---|
key
|
required A chave a ser procurada. |
default
|
o padrão é None O valor padrão a ser usado (em vez de None) se a chave não for encontrada. |
itens
list dict.items()Retorna a lista de tuplas de chave-valor:
{2: "a", 4: "b", 1: "c"}.items() == [(2, "a"), (4, "b"), (1, "c")]
chaves
list dict.keys()Retorna a lista de chaves:
{2: "a", 4: "b", 1: "c"}.keys() == [2, 4, 1]
pop
unknown dict.pop(key, default=unbound)Remove um
key
do dicionário e retorna o valor associado. Se nenhuma entrada com essa chave for encontrada, não remova nada e retorne o valor default
especificado. Se nenhum valor padrão for especificado, a operação vai falhar.
Parâmetros
Parâmetro | Descrição |
---|---|
key
|
required A chave. |
default
|
O padrão é unbound um valor padrão se a chave não estiver presente. |
popitem
tuple dict.popitem()Remove e retorna o primeiro par
(key, value)
do dicionário. popitem
é útil para iterar de forma destrutiva em um dicionário, como é usado com frequência em algoritmos definidos. Se o dicionário estiver vazio, a chamada popitem
vai falhar.
setdefault
unknown dict.setdefault(key, default=None)Se
key
estiver no dicionário, retorne o valor dele. Caso contrário, insira uma chave com um valor default
e retorne default
. O padrão de default
é None
.
Parâmetros
Parâmetro | Descrição |
---|---|
key
|
required A chave. |
default
|
O padrão é None um valor padrão se a chave não estiver presente. |
update
None
dict.update(pairs=[], **kwargs)
Atualiza o dicionário primeiro com o argumento posicional opcional, pairs
, depois com os argumentos de palavra-chave opcionais
Se o argumento posicional estiver presente, ele precisará ser um dict, iterável ou None.
Se for um dict, seus pares de chave/valor são inseridos nesse dict. Se for iterável, ele precisa fornecer uma sequência de pares (ou outros iteráveis de comprimento 2), cada um dos quais é tratado como um par chave/valor a ser inserido.
Cada argumento de palavra-chave name=value
faz com que o par nome/valor seja inserido nesse dicionário.
Parâmetros
Parâmetro | Descrição |
---|---|
pairs
|
o padrão é [] Um dicionário ou uma lista de entradas. As entradas precisam ser tuplas ou listas com exatamente dois elementos: chave, valor. |
kwargs
|
required Dicionário de entradas adicionais. |
values
list dict.values()Retorna a lista de valores:
{2: "a", 4: "b", 1: "c"}.values() == ["a", "b", "c"]