Dicionários em

Sobre Dicionários

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

As keys têm de ser hashable e únicas em todo o dicionário. Os tipos de chave podem incluir numbers, strs ou tuples (de valores imutáveis). 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 é garantidamente a ordem pela qual as entradas são inseridas.

Os values podem ser de qualquer tipo ou estrutura de dados. Os valores também se podem aninhar arbitrariamente, pelo que podem incluir listas de listas, subdicionários e outras estruturas de dados personalizadas ou compostas.

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

Os dicionários são especialmente úteis em cenários em que a coleção de itens é grande e tem de ser acedida e atualizada com frequência.

Construção de dicionários

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

• Usar o método de classe fromkeys().
• Usar compreensões de dicionário.
• Juntar dois dicionários através de desempacotamento (**).
• Juntar dicionários através do operador | (update).
• Usar um ciclo para adicionar iterativamente entradas a um dict vazio criado previamente.

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

O construtor de dicionários

O 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 descreve variações e opções adicionais na utilização do construtor.

Literais de dicionário

Um dicionário também pode ser escrito diretamente como um literal de dicionário, usando chavetas ({}) que envolvem pares key : value. As entradas que estão 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" :  {}
        }
   }

Aceder a valores num dict

Podes aceder a um value num dicionário usando uma key entre parênteses retos. Se uma chave não existir no dicionário, é lançado um KeyError:

>>> bear["speed"]
40

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

Aceder a uma entrada através do método get(<key>, <default value>) pode evitar o KeyError:

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

Aceder a entradas de dicionários aninhados

Para aceder a entradas em dicionários aninhados, usa parênteses retos sucessivos. Se faltar uma determinada chave, é lançado o habitual KeyError:

# 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, pode usar-se o .get(), mas as chamadas a .get() têm de estar 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!'

Alterar ou adicionar valores a um dicionário

Podes alterar o value de uma entrada atribuindo à sua key:

# 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}

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

Podes usar o método <dict>.pop(<key>) para eliminar uma entrada do dicionário. O <dict>.pop() remove o par (key, value) e devolve o value para ser usado. Tal como o <dict>.get(), o <dict>.pop(<key>) aceita um segundo argumento (<dict>.pop(<key>, <default value>)) que será devolvido se a key não for encontrada. Isto evita que seja lançado um KeyError:

# 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'

Também podes usar a instrução del para remover uma ou mais entradas. É lançado um KeyError se a entrada a remover 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'

Percorrer e iterar um dicionário

Percorrer um dicionário com for item in dict ou while item itera sobre as keys por predefinição. Podes aceder aos values dentro do mesmo ciclo usando parênteses retos:

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

Também podes usar o método .items(), que devolve tuplos (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() devolve as keys e .values() devolve os values.

Para uma explicação detalhada dos dicionários em Python, a documentação oficial é um excelente ponto de partida, ou então podes consultar o tutorial da W3-Schools.

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

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

• Counter conta os itens automaticamente e devolve-os num dict com os itens como chaves e as 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 predefinido se uma key não for encontrada ao tentar obter ou atribuir uma entrada do dicionário.