Diccionarios en

Acerca de Diccionarios

Un diccionario (dict) en Python es una estructura de datos que asocia claves hashables a valores, y en otros lenguajes de programación se conoce como tabla hash redimensionable, hashmap o array asociativo. Los diccionarios son el único tipo de mapeo integrado de Python.

Las keys deben ser hashables y únicas en todo el diccionario. Los tipos de clave pueden incluir numbers, strs o tuples (de valores inmutables). No pueden contener estructuras de datos mutables como lists, dicts o sets. A partir de Python 3.7, se garantiza que el orden de las claves de un dict es el orden en que se insertan las entradas.

Los values pueden ser de cualquier tipo o estructura de datos. Los valores también pueden anidarse arbitrariamente, por lo que pueden incluir listas de listas, subdiccionarios y otras estructuras de datos personalizadas o compuestas.

Dada una key, los diccionarios pueden recuperar un value en un tiempo constante (de media) (independiente del número de entradas). En comparación con buscar un valor dentro de una list o un array (sin conocer la posición del index), un dict usa bastante más memoria, pero la recuperación es muy rápida.

Los diccionarios son especialmente útiles en escenarios en los que la colección de elementos es grande y hay que acceder a ella y actualizarla con frecuencia.

Construcción de diccionarios

Los diccionarios se pueden crear de muchas formas distintas, entre ellas:

• Usar el método de clase fromkeys().
• Usar comprensiones de diccionario.
• Fusionar dos diccionarios mediante desempaquetado (**).
• Fusionar diccionarios con el operador | (update).
• Usar un bucle para añadir entradas de forma iterativa a un dict vacío creado previamente.

Los dos métodos más directos son el constructor de diccionario y el literal de diccionario.

El constructor de diccionarios

Se puede usar dict() (el constructor de la clase dict) con cualquier iterable de pares key, value. También se puede llamar con una serie 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}

La documentación sobre los dict describe otras variaciones y opciones en el uso del constructor.

Literales de diccionario

Un diccionario también se puede escribir directamente como un literal de diccionario, usando llaves ({}) que encierran pares key : value. Las entradas encerradas entre las {} también pueden aparecer en líneas 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'}

Diccionarios anidados

Los diccionarios se pueden anidar 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" :  {}
        }
   }

Acceder a los valores de un dict

Puedes acceder a un value de un diccionario usando una clave entre corchetes. Si una clave no existe en el diccionario, se lanza un KeyError:

>>> bear["speed"]
40

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

Acceder a una entrada mediante el método get(<key>, <default value>) puede evitar el KeyError:

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

Acceder a entradas de diccionarios anidados

Para acceder a las entradas de diccionarios anidados, usa corchetes sucesivos. Si falta una clave concreta, se lanzará el 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 el KeyError, se puede usar .get(), pero las llamadas a .get() deben estar encadenadas:

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

Cambiar o añadir valores de un diccionario

Puedes cambiar el value de una entrada asignando a su clave:

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

Los nuevos pares key:value se pueden añadir de la misma 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}

Eliminar entradas de un diccionario (pop y del)

Puedes usar el método <dict>.pop(<key>) para eliminar una entrada de un diccionario. <dict>.pop() elimina el par (key, value) y devuelve el value para que lo uses. Igual que <dict>.get(), <dict>.pop(<key>) acepta un segundo argumento (<dict>.pop(<key>, <default value>)) que se devolverá si no se encuentra la key. Esto evita que se lance un 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'

También puedes usar la instrucción del para eliminar una o varias entradas. Se lanza un KeyError si la entrada que se quiere eliminar no se encuentra en el diccionario:

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

Recorrer o iterar un diccionario

Recorrer un diccionario con for item in dict o while item itera sobre las claves de forma predeterminada. Puedes acceder a los valores dentro del mismo bucle usando corchetes:

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

También puedes usar el método .items(), que devuelve 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

Del mismo modo, .keys() devuelve las keys y .values() devuelve los values.

Para obtener una explicación detallada de los diccionarios en Python, la documentación oficial es un excelente punto de partida; también puedes consultar el tutorial de W3-Schools.

Ampliar la funcionalidad de los diccionarios: el módulo collections

El módulo collections añade funcionalidad especializada a los tipos de datos estándar de Python basados en colecciones (dict, set, list, tuple). Tres de las clases basadas en diccionarios más útiles son:

• Counter cuenta elementos automáticamente y los devuelve en un dict con los elementos como claves y sus recuentos como valores.
• OrderedDict tiene métodos especializados para organizar el orden de las entradas de un diccionario.
• defaultdict usa un método de fábrica para establecer un valor predeterminado si no se encuentra una key al intentar recuperar o asignar una entrada del diccionario.