ditar

Informar um problema Ver a fonte Nightly · 7.3 · 7.2 · 7.1 · 7.0 · 6.5

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. Os dicionários não congelados são mutáveis e podem ser atualizados pela atribuição a d[k] ou pela chamada de 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, mas é afetada pela remoção e reinserção de uma chave. 

d = {0: "x", 2: "z", 1: "y"}
[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, "y"), (2, "b")]

Há quatro maneiras de criar um dicionário:

  1. 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.
  2. 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}
  3. 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 na compreensão, chaves duplicadas são permitidas.
  4. A expressão de união x | y gera um novo dicionário combinando dois dicionários atuais. Se os dois dicionários tiverem uma chave k 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()

Remova 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 obrigatório
A chave a ser buscada.
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()

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, vai falhar.

Parâmetros

Parâmetro Descrição
key obrigatório
A chave.
default o padrão é unbound
um valor padrão se a chave estiver ausente.

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 é frequentemente usado em algoritmos de conjuntos. 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 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 estiver ausente.

update

None dict.update(pairs=[], **kwargs)

Atualiza o dicionário primeiro com o argumento posicional opcional, 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 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 de 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 obrigatório
Dicionário de entradas adicionais.

values

list dict.values()

Retorna a lista de valores:
{2: "a", 4: "b", 1: "c"}.values() == ["a", "b", "c"]