ditar

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 tempo constante. Os 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 produz 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: "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, ...} 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 produzirem o mesmo valor.
2. Uma compreensão de dicionário {k: v for vars in seq} produz um novo dicionário em que cada par de chave/valor é inserido na ordem de iteração do loop. Duplicados são permitidos: 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 que contém as entradas especificadas, que são inseridas na ordem dos argumentos, argumentos posicionais antes dos nomeados. Assim como nas compreensões, as chaves duplicadas são permitidas.
4. A expressão de união x | y produz 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 do lado direito (em outras palavras, y[k]) será o vencedor. 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
• 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, será o 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 procurada.
default	o padrão é None O valor padrão a ser usado (em vez de Nenhum) se a chave não for encontrada.

items

list dict.items()

Retorna a lista de tuplas de chave-valor:

{2: "a", 4: "b", 1: "c"}.items() == [(2, "a"), (4, "b"), (1, "c")]

keys

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, nada será removido e o valor default especificado será retornado. Se nenhum valor padrão for especificado, a operação 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 (key, value) par do dicionário. popitem é útil para iterar destrutivamente em um dicionário, como é usado com frequência 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 dela. Caso contrário, insira a chave com um valor de default e retorne default. default o padrão é 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 Nenhum. Se for um dicionário, os pares de chave/valor serão inseridos nele. Se for iterável, ele precisará fornecer uma sequência de pares (ou outros iteráveis de comprimento 2), cada um deles tratado como um par de 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"]