Dicionários em

Sobre Dicionários

Um dicionário (dict) em Python é uma estrutura de dados que associa chaves hashable a valores e é conhecido em outras linguagens de programação como uma tabela hash redimensionável, um hashmap ou um array associativo. Os dicionários são o único tipo de mapeamento embutido do Python.

As keys precisam ser hashable e únicas em todo o dicionário. Os tipos de chave podem incluir numbers, strs ou tuples (de valores imutáveis). Elas não podem conter estruturas de dados mutáveis, como lists, dicts ou sets. A partir do Python 3.7, a ordem das chaves de um dict é garantida como a ordem em que as entradas são inseridas.

Os values podem ser de qualquer tipo de dado ou estrutura. Os valores também podem ser aninhados arbitrariamente, então podem incluir listas de listas, subdicionários e outras estruturas de dados personalizadas ou compostas.

Dada uma key, os dicionários conseguem recuperar um value em tempo constante (em média), independentemente do número de entradas. Em comparação com procurar um valor dentro de uma list ou um array (sem saber a posição do index), um dict usa muito mais memória, mas a recuperação é muito mais rápida.

Os dicionários são especialmente úteis em cenários nos quais a coleção de itens é grande e precisa ser acessada e atualizada com frequência.

Construção de dicionários

Os dicionários podem ser criados de muitas formas diferentes, incluindo:

• Usando o método de classe fromkeys().
• Usando compreensões de dicionário.
• Mesclando dois dicionários por meio de desempacotamento (**).
• Mesclando dicionários com o operador | (update).
• Usando um laço para adicionar entradas iterativamente a um dict vazio criado antes.

Os dois métodos mais diretos são o construtor de dicionário e o literal de dicionário.

O construtor de dicionário

dict() (o construtor da classe dict) pode ser usado com qualquer iterável de pares key, value. Também pode ser chamado com uma série de argumentos <name>=<value>:

# Passing a list of key,value tuples.
>>> wombat = dict([('name', 'Wombat'),
...              ('speed', 23),
...              ('land_animal', True)])
{'name': 'Wombat', 'speed': 23, 'land_animal': True}


# Using key=value arguments.
>>> bear = dict(name="Black Bear",
...             speed=40,
...             land_animal=True)
{'name': 'Black Bear', 'speed': 40, 'land_animal': True}

A documentação sobre dicts apresenta outras variações e opções de uso do construtor.

Literais de dicionário

Um dicionário também pode ser escrito diretamente como um literal de dicionário, usando chaves ({}) que envolvem pares key : value. As entradas dentro das {} também podem aparecer em linhas separadas:

>>> whale = {"name": "Blue Whale", 
             "speed": 35, 
             "land_animal": False}
{'name': 'Blue Whale', 'speed': 35, 'land_animal': False}

>>> wombat = {'name': 'Wombat',
              'speed': 23,
              'land_animal': True,
              'color': 'Brindle'}

>>> wombat
{'name': 'Wombat', 'speed': 23, 'land_animal': True, 'color': 'Brindle'}

Dicionários aninhados

Os dicionários podem ser aninhados arbitrariamente:

animals = {
    "Real" : {
        "Winged" : {
            "Sparrow" : {'name': 'sparrow','speed': 12, 'land_animal': True},
            "Kestrel" : {'name': 'kestrel', 'speed': 15, 'land_animal': True}
           },
        "Legged" : {
            "Wombat" : {'name': 'Wombat', 'speed': 23, 'land_animal': True},
            "Black Bear": {'name': 'Black Bear', 'speed': 40, 'land_animal': True},
            "Polecat" : {'name': 'Polecat', 'speed': 15, 'land_animal': True}
           },
        "Other" :  {
            "Whale" : {'name': 'Blue Whale', 'speed': 35, 'land_animal': False},
            "Orca" : {'name': 'Orca', 'speed': 45, 'land_animal': False},
            "Snake" : {'name': 'Python', 'speed': 25, 'land_animal': True}
            }
        },
        
    "Imaginary": {
        "Winged" : {
            "Dragon" : {'name': 'Fire Dragon','speed': 100, 'land_animal': True},
            "Phoenix" : {'name': 'Phoenix', 'speed': 1500, 'land_animal': True}
            },
        "Legged" : {
            "Sphinx" : {'name': 'Sphinx','speed': 10, 'land_animal': True},
            "Minotaur" : {'name': 'Minotaur', 'speed': 5, 'land_animal': True}
            },
        "Other" :  {}
        }
   }

Acessando valores em um dict

Você pode acessar um value em um dicionário usando uma chave entre colchetes. Se a chave não existir no dicionário, um KeyError é lançado:

>>> bear["speed"]
40

>>> bear["color"]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'color'

Acessar uma entrada pelo método get(<key>, <default value>) pode evitar o KeyError:

>>> bear.get("color", 'not found')
'not found'

Acessando entradas de dicionários aninhados

Para acessar entradas em dicionários aninhados, use colchetes em sequência. Se uma determinada chave estiver faltando, o KeyError de sempre é lançado:

# Using the animals nested dictionary.
>>> animals["Real"]["winged"]["Kestrel"]["speed"]
15

>>> animals["Imaginary"]["winged"]["Kestrel"]["speed"]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'Kestrel'

Para evitar o KeyError, dá para usar .get(), mas as chamadas a .get() precisam ser encadeadas:

# Using the animals nested dictionary.
# Note the use of parenthesis to enable placing the 
# .get() calls on separate lines.
>>> (animals.get("Imaginary", {})
            .get("Legged", {})
            .get("Sphinx", {})
            .get("Color", "I have no idea!"))
'I have no idea!'

Alterando ou adicionando valores em um dicionário

Você pode alterar o value de uma entrada atribuindo à sua chave:

# Assigning the value "Grizzly Bear" to the name key.
>>> bear["name"] = "Grizzly Bear"
{'name': 'Grizzly Bear', 'speed': 40, 'land_animal': True}

>>> whale["speed"] = 25
{'name': 'Blue Whale', 'speed': 25, 'land_animal': False}

Novos pares key:value podem ser adicionados da mesma forma:

# Adding a new "color" key with a new "tawney" value.
>>> bear["color"] = 'tawney'
{'name': 'Grizzly Bear', 'speed': 40, 'land_animal': True, 'color': 'tawney'}

>>> whale["blowholes"] = 1
{'name': 'Blue Whale', 'speed': 25, 'land_animal': False, 'blowholes': 1}

Removendo entradas de um dicionário (pop e del)

Você pode usar o método <dict>.pop(<key>) para excluir uma entrada do dicionário. <dict>.pop() remove o par (key, value) e retorna o value para uso. Assim como <dict>.get(), <dict>.pop(<key>) aceita um segundo argumento (<dict>.pop(<key>, <default value>)) que será retornado se a key não for encontrada. Isso evita que um KeyError seja lançado:

# Using .pop() removes both the key and value, returning the value.
>>> bear.pop("name")
'Grizzly Bear'


# The "name" key is now removed from the dictionary.
# Attempting .pop() a second time will throw a KeyError.
>>> bear.pop("name")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'name'


# Using a default argument with .pop() will 
# prevent a KeyError from a missing key.
>>> bear.pop("name", "Unknown")
'Unknown'

Você também pode usar a instrução del para remover uma ou mais entradas. Um KeyError é lançado se a entrada a ser removida não for encontrada no dicionário:

>>> wombat = {'name': 'Wombat',
              'speed': 23,
              'land_animal': True,
              'color': 'Brindle',
              'talent': 'Singing',
              'size': 'small'}

# Remove a single entry from the dictionary.
>>> del wombat["color"]
>>> wombat
{'name': 'Wombat', 'speed': 23, 'land_animal': True, 'talent': 'Singing', 'size': 'small'}


# Remove multiple entries from the dictionary.
>>> del wombat["talent"], wombat["size"]
>>> wombat
{'name': 'Wombat', 'speed': 23, 'land_animal': True}


# Attempting a deletion of a non-existent key raises a KeyError
>>> del wombat["number_of_legs"]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'number_of_legs'

Percorrendo um dicionário com um laço

Percorrer um dicionário com for item in dict ou while item itera sobre as chaves por padrão. Você pode acessar os valores dentro do mesmo laço usando colchetes:

>>> for key in bear:
...     print((key, bear[key])) # <--This prints a tuple of (key, value).
('name', 'Black Bear')
('speed', 40)
('land_animal', True)

Você também pode usar o método .items(), que retorna tuplas (key, value):

# dict.items() forms (key, value tuples) that can be 
# unpacked and iterated over.
>>> for key, value in whale.items():
...     print(key, ":", value)
name : Blue Whale
speed : 25
land_animal : False
blowholes : 1

Da mesma forma, .keys() retorna as keys e .values() retorna os values.

Para uma explicação detalhada sobre dicionários em Python, a documentação oficial é um excelente ponto de partida, ou você também pode conferir o tutorial da W3-Schools.

Ampliando a funcionalidade dos dicionários: o módulo collections

O módulo collections adiciona funcionalidades especializadas aos tipos de dados de coleção padrão do Python (dict, set, list, tuple). Três das classes baseadas em dicionário mais úteis são:

• Counter conta os itens automaticamente e os retorna em um dict com os itens como chaves e suas contagens como valores.
• OrderedDict tem métodos especializados para organizar a ordem das entradas do dicionário.
• defaultdict usa um método de fábrica para definir um valor padrão caso uma key não seja encontrada ao tentar recuperar ou atribuir a uma entrada do dicionário.