dict é um tipo integrado que representa um mapeamento associativo ou dicionário. Um dicionário oferece suporte à indexação usando d[k]
e ao teste de associação de chaves usando k in d
. 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, ...}
gera 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 que contém as entradas especificadas, que são inseridas em ordem de argumento e argumentos posicionais antes de nomeados. Assim como na compreensão, 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 da chave do dicionário do lado direito (em outras palavras,y[k]
) vencerá. 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()
get
unknown dict.get(key, default=None)
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
|
default é None O valor padrão a ser usado (em vez de None) se a chave não for encontrada. |
itens
list dict.items()
{2: "a", 4: "b", 1: "c"}.items() == [(2, "a"), (4, "b"), (1, "c")]
chaves
list dict.keys()
{2: "a", 4: "b", 1: "c"}.keys() == [2, 4, 1]
pop
unknown dict.pop(key, default=unbound)
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 tiver sido 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()
(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)
key
estiver no dicionário, retorne o valor dele. Caso contrário, insira a chave com um valor de default
e retorne default
. O padrão de default
é None
.
Parâmetros
Parâmetro | Descrição |
---|---|
key
|
obrigatório A chave. |
default
|
O padrão é None um valor padrão se a chave não estiver presente. |
update
None
dict.update(pairs=[], **kwargs)
pairs
, e depois com os argumentos de palavra-chave opcionais.
Se o argumento posicional estiver presente, ele precisa ser um dicionário, iterável ou None.
Se for um dicionário, os pares de chave-valor serão inseridos nele. 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 de nome/valor seja inserido no 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()
{2: "a", 4: "b", 1: "c"}.values() == ["a", "b", "c"]