Python Language
Diccionario

Sintaxis

• mydict = {}
• mydict [k] = valor
• valor = mydict [k]
• valor = mydict.get (k)
• value = mydict.get (k, "default_value")

Parámetros

Observaciones

Accediendo a los valores de un diccionario.

dictionary = {"Hello": 1234, "World": 5678}
print(dictionary["Hello"])

El código anterior imprimirá 1234 .

La cadena "Hello" en este ejemplo se llama clave . Se utiliza para buscar un valor en el dict colocando la clave entre corchetes.

El número 1234 se ve después de los dos puntos respectivos en la definición de dict . Esto se llama el valor al que "Hello" asigna en este dict .

Buscar un valor como este con una clave que no existe KeyError una excepción KeyError , que KeyError ejecución si no se detecta. Si queremos acceder a un valor sin arriesgar un KeyError , podemos usar el método dictionary.get . Por defecto, si la clave no existe, el método devolverá None . Podemos pasarle un segundo valor para devolver en lugar de None en caso de una búsqueda fallida.

w = dictionary.get("whatever")
x = dictionary.get("whatever", "nuh-uh")

En este ejemplo, w obtendrá el valor None y x obtendrá el valor "nuh-uh" .

El constructor dict ()

El constructor dict() se puede utilizar para crear diccionarios a partir de argumentos de palabras clave, o desde una única iterable de pares clave-valor, o desde un diccionario único y argumentos de palabras clave.

dict(a=1, b=2, c=3)                   # {'a': 1, 'b': 2, 'c': 3}
dict([('d', 4), ('e', 5), ('f', 6)])  # {'d': 4, 'e': 5, 'f': 6}
dict([('a', 1)], b=2, c=3)            # {'a': 1, 'b': 2, 'c': 3}
dict({'a' : 1, 'b' : 2}, c=3)         # {'a': 1, 'b': 2, 'c': 3}

Evitar las excepciones de KeyError

Un error común cuando se usan diccionarios es acceder a una clave que no existe. Esto generalmente resulta en una excepción KeyError

mydict = {}
mydict['not there']

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'not there'

Una forma de evitar errores clave es utilizar el método dict.get , que le permite especificar un valor predeterminado para devolver en el caso de una clave ausente.

value = mydict.get(key, default_value)

Lo que devuelve mydict[key] si existe, pero de lo contrario devuelve default_value . Tenga en cuenta que esto no agrega key a mydict . Así que si desea conservar ese par de valores clave, se debe utilizar mydict.setdefault(key, default_value) , lo que almacenar el par de valores clave.

mydict = {}
print(mydict)
# {}
print(mydict.get("foo", "bar"))
# bar
print(mydict)
# {}
print(mydict.setdefault("foo", "bar"))
# bar
print(mydict)
# {'foo': 'bar'}

Una forma alternativa de lidiar con el problema es atrapar la excepción.

try:
    value = mydict[key]
except KeyError:
    value = default_value

También puede comprobar si la clave está in el diccionario.

if key in mydict:
    value = mydict[key]
else:
    value = default_value

Sin embargo, tenga en cuenta que, en entornos de subprocesos múltiples, es posible que la clave se elimine del diccionario después de la verificación, creando una condición de carrera en la que aún se puede lanzar la excepción.

Otra opción es usar una subclase de dict, collections.defaultdict, que tiene un default_factory para crear nuevas entradas en el dict cuando se le da una new_key.

Acceso a claves y valores.

Cuando se trabaja con diccionarios, a menudo es necesario acceder a todas las claves y valores del diccionario, ya sea en un bucle for , en una lista de comprensión, o simplemente como una lista simple.

Dado un diccionario como:

mydict = {
    'a': '1',
    'b': '2'
}

Puede obtener una lista de claves utilizando el método keys() :

print(mydict.keys())
# Python2: ['a', 'b']
# Python3: dict_keys(['b', 'a'])

Si, en cambio, desea una lista de valores, use el método de values() :

print(mydict.values())
# Python2: ['1', '2']
# Python3: dict_values(['2', '1'])

Si desea trabajar con la clave y su valor correspondiente, puede usar el método items() :

print(mydict.items())
# Python2: [('a', '1'), ('b', '2')]
# Python3: dict_items([('b', '2'), ('a', '1')])

NOTA: Debido a que un dict no está clasificado, las keys() , los values() y los items() no tienen orden de clasificación. Use sort() , sorted() o OrderedDict si le importa el orden en que regresan estos métodos.

Diferencia de Python 2/3: En Python 3, estos métodos devuelven objetos especiales iterables, no listas, y son el equivalente de los iterkeys() , itervalues() y iteritems() . Estos objetos se pueden usar como listas en su mayor parte, aunque hay algunas diferencias. Ver PEP 3106 para más detalles.

Introducción al Diccionario

Un diccionario es un ejemplo de un almacén de valores clave también conocido como Mapeo en Python. Le permite almacenar y recuperar elementos haciendo referencia a una clave. Como los diccionarios son referenciados por clave, tienen búsquedas muy rápidas. Como se utilizan principalmente para hacer referencia a elementos por clave, no están ordenados.

creando un dict

Los diccionarios se pueden iniciar de muchas maneras:

sintaxis literal

d = {}                        # empty dict
d = {'key': 'value'}          # dict with initial values

# Also unpacking one or multiple dictionaries with the literal syntax is possible

# makes a shallow copy of otherdict
d = {**otherdict}
# also updates the shallow copy with the contents of the yetanotherdict.
d = {**otherdict, **yetanotherdict}

comprensión de dictado

d = {k:v for k,v in [('key', 'value',)]}

Ver también: Comprensiones.

clase incorporada: dict()

d = dict()                    # emtpy dict
d = dict(key='value')         # explicit keyword arguments
d = dict([('key', 'value')])  # passing in a list of key/value pairs
# make a shallow copy of another dict (only possible if keys are only strings!)
d = dict(**otherdict)         

modificando un dict

Para agregar elementos a un diccionario, simplemente cree una nueva clave con un valor:

d['newkey'] = 42

También es posible agregar list y dictionary como valor:

d['new_list'] = [1, 2, 3]
d['new_dict'] = {'nested_dict': 1}

Para eliminar un elemento, elimine la clave del diccionario:

del d['newkey']

Diccionario con valores por defecto

Disponible en la biblioteca estándar como defaultdict

from collections import defaultdict

d = defaultdict(int)
d['key']                         # 0
d['key'] = 5
d['key']                         # 5

d = defaultdict(lambda: 'empty')
d['key']                         # 'empty'
d['key'] = 'full'
d['key']                         # 'full'

[*] Alternativamente, si debes usar la clase dict incorporada, using dict.setdefault() te permitirá crear un valor predeterminado cada vez que using dict.setdefault() a una clave que no existía antes:

>>> d = {}
{}
>>> d.setdefault('Another_key', []).append("This worked!")
>>> d
{'Another_key': ['This worked!']}

Tenga en cuenta que si tiene muchos valores para agregar, dict.setdefault() creará una nueva instancia del valor inicial (en este ejemplo a [] ) cada vez que se llame, lo que puede crear cargas de trabajo innecesarias.

[*] Python Cookbook, 3ª edición, por David Beazley y Brian K. Jones (O'Reilly). Derechos de autor 2013 David Beazley y Brian Jones, 978-1-449-34037-7.

Creando un diccionario ordenado

Puede crear un diccionario ordenado que seguirá un orden determinado al iterar sobre las claves en el diccionario.

Usa OrderedDict del módulo de collections . Esto siempre devolverá los elementos del diccionario en el orden de inserción original cuando se repita.

from collections import OrderedDict

d = OrderedDict()
d['first'] = 1
d['second'] = 2
d['third'] = 3
d['last'] = 4

# Outputs "first 1", "second 2", "third 3", "last 4"
for key in d:
    print(key, d[key])

Desempaquetando diccionarios usando el operador **

Puede utilizar el operador de desempaquetado de ** argumentos de palabras clave para entregar los pares clave-valor en un diccionario en los argumentos de una función. Un ejemplo simplificado de la documentación oficial :

>>>
>>> def parrot(voltage, state, action):
...     print("This parrot wouldn't", action, end=' ')
...     print("if you put", voltage, "volts through it.", end=' ')
...     print("E's", state, "!")
...
>>> d = {"voltage": "four million", "state": "bleedin' demised", "action": "VOOM"}
>>> parrot(**d)

This parrot wouldn't VOOM if you put four million volts through it. E's bleedin' demised !

A partir de Python 3.5, también puede utilizar esta sintaxis para fusionar un número arbitrario de objetos dict .

>>> fish = {'name': "Nemo", 'hands': "fins", 'special': "gills"}
>>> dog = {'name': "Clifford", 'hands': "paws", 'color': "red"}
>>> fishdog = {**fish, **dog}
>>> fishdog

{'hands': 'paws', 'color': 'red', 'name': 'Clifford', 'special': 'gills'}

Como lo demuestra este ejemplo, las claves duplicadas se asignan a su último valor (por ejemplo, "Clifford" reemplaza a "Nemo").

Fusionando diccionarios

Considere los siguientes diccionarios:

>>> fish = {'name': "Nemo", 'hands': "fins", 'special': "gills"}
>>> dog = {'name': "Clifford", 'hands': "paws", 'color': "red"}

Python 3.5+

>>> fishdog = {**fish, **dog}
>>> fishdog
{'hands': 'paws', 'color': 'red', 'name': 'Clifford', 'special': 'gills'}

Como lo demuestra este ejemplo, las claves duplicadas se asignan a su último valor (por ejemplo, "Clifford" reemplaza a "Nemo").

Python 3.3+

>>> from collections import ChainMap
>>> dict(ChainMap(fish, dog))
{'hands': 'fins', 'color': 'red', 'special': 'gills', 'name': 'Nemo'}

Con esta técnica, el valor más importante tiene prioridad para una clave dada en lugar de la última ("Clifford" se desecha a favor de "Nemo").

Python 2.x, 3.x

>>> from itertools import chain
>>> dict(chain(fish.items(), dog.items()))
{'hands': 'paws', 'color': 'red', 'name': 'Clifford', 'special': 'gills'}

Esto utiliza el último valor, como en la técnica basada en ** para la fusión ("Clifford" anula "Nemo").

>>> fish.update(dog)
>>> fish
{'color': 'red', 'hands': 'paws', 'name': 'Clifford', 'special': 'gills'}

dict.update utiliza el último dict para sobrescribir el anterior.

La coma final

Al igual que las listas y las tuplas, puede incluir una coma al final en su diccionario.

role = {"By day": "A typical programmer",
        "By night": "Still a typical programmer", }

El PEP 8 dicta que debe dejar un espacio entre la coma final y la llave de cierre.

Todas las combinaciones de valores de diccionario.

options = {
    "x": ["a", "b"],
    "y": [10, 20, 30]
}

Dado un diccionario como el que se muestra arriba, donde hay una lista que representa un conjunto de valores para explorar la clave correspondiente. Supongamos que desea explorar "x"="a" con "y"=10 , luego "x"="a" con "y"=10 , y así sucesivamente hasta que haya explorado todas las combinaciones posibles.

Puede crear una lista que devuelva todas estas combinaciones de valores utilizando el siguiente código.

import itertools

options = {
    "x": ["a", "b"],
    "y": [10, 20, 30]}

keys = options.keys()
values = (options[key] for key in keys)
combinations = [dict(zip(keys, combination)) for combination in itertools.product(*values)]
print combinations

Esto nos da la siguiente lista almacenada en las combinations variables:

[{'x': 'a', 'y': 10},
 {'x': 'b', 'y': 10},
 {'x': 'a', 'y': 20},
 {'x': 'b', 'y': 20},
 {'x': 'a', 'y': 30},
 {'x': 'b', 'y': 30}]

Iterando sobre un diccionario

Si utiliza un diccionario como iterador (por ejemplo, en una declaración for ), atraviesa las claves del diccionario. Por ejemplo:

d = {'a': 1, 'b': 2, 'c':3}
for key in d:
    print(key, d[key])
# c 3
# b 2
# a 1

Lo mismo es cierto cuando se usa en una comprensión.

print([key for key in d])
# ['c', 'b', 'a']

for key, value in d.items():
    print(key, value)
# c 3
# b 2
# a 1

for key, value in d.values():
    print(key, value)
    # 3
    # 2
    # 1

Creando un diccionario

Reglas para crear un diccionario:

• Cada clave debe ser única (de lo contrario, se anulará)
• Cada tecla tiene que ser hashable (puede usar el hash la función hash que, de lo contrario TypeError será lanzada)
• No hay un orden particular para las llaves.

# Creating and populating it with values
stock = {'eggs': 5, 'milk': 2}

# Or creating an empty dictionary
dictionary = {}

# And populating it after
dictionary['eggs'] = 5
dictionary['milk'] = 2

# Values can also be lists
mydict = {'a': [1, 2, 3], 'b': ['one', 'two', 'three']}

# Use list.append() method to add new elements to the values list
mydict['a'].append(4)   # => {'a': [1, 2, 3, 4], 'b': ['one', 'two', 'three']}
mydict['b'].append('four')  # => {'a': [1, 2, 3, 4], 'b': ['one', 'two', 'three', 'four']}

# We can also create a dictionary using a list of two-items tuples
iterable = [('eggs', 5), ('milk', 2)]
dictionary = dict(iterables)

# Or using keyword argument:
dictionary = dict(eggs=5, milk=2)

# Another way will be to use the dict.fromkeys:
dictionary = dict.fromkeys((milk, eggs))  # => {'milk': None, 'eggs': None}
dictionary = dict.fromkeys((milk, eggs), (2, 5))  # => {'milk': 2, 'eggs': 5}

Diccionarios ejemplo

Diccionarios mapean claves a valores.

car = {}
car["wheels"] = 4
car["color"] = "Red"
car["model"] = "Corvette"

Los valores del diccionario se pueden acceder por sus claves.

print "Little " + car["color"] + " " + car["model"] + "!"
# This would print out "Little Red Corvette!"    

Los diccionarios también se pueden crear en un estilo JSON:

car = {"wheels": 4, "color": "Red", "model": "Corvette"}

Los valores del diccionario se pueden iterar sobre:

for key in car:
  print key + ": " + car[key]

# wheels: 4
# color: Red
# model: Corvette