ditar

dict é um tipo integrado que representa um mapeamento associativo ou um 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 tempo constante. Dicionários não congelados 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 construir 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. Duplicatas são permitidas: a primeira inserção de uma determinada chave determina a posição dela na sequência, e a última determina o 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 com as entradas especificadas, que são inseridas na ordem dos argumentos, posicionais antes dos nomeados. Assim como nas comprehensions, chaves duplicadas são permitidas.
4. 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 chave k em comum, o valor da chave do dicionário à direita (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

• clear
• get
• items
• keys
• pop
• popitem
• setdefault
• update
• values

limpar

None dict.clear()

Remove 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, falhe.

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 destrutivamente em um dicionário, como costuma ser usado em algoritmos de conjunto. 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 primeiro o dicionário com o argumento posicional opcional, pairs, e depois com os argumentos de palavra-chave opcionais. Se o argumento posicional estiver presente, ele precisará ser um dict, um iterável ou None. Se for um dict, os pares de chave-valor serão inseridos nele. Se for um iterável, ele vai fornecer uma sequência de pares (ou outros iteráveis de tamanho 2), cada um deles 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 e 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"]