Diccionarios en Python (Mapas) – dicts

Diccionarios en Python

Los diccionarios en Python están por todas partes. Se encuentran incluidos como tipo básico pero conforman el sistema en muchas de sus partes.

Los diccionarios se utilizan para mapear claves con valores uno a uno.

¿Qué es un diccionario en Python?

En muchos lenguajes de programación se presenta este concepto como mapas. Los diccionarios o mapas son colecciones de pares de valores.

Por un lado está la clave y por otro lado el valor que tiene esa clave, y tienen las siguientes características:

  • Las claves son únicas en cada diccionario.
  • Las claves tienen que poder ser hasheables.
  • Los valores pueden ser de cualquier tipo en Python.
  • Se pueden componer diccionarios de diccionarios.
  • No existe límite de espacio para guardar diccionarios (salvo el límite físico de la máquina).

¿Cómo crear diccionarios en Python?

Para crear diccionarios en Python se puede utilizar:

  • El constructor dict y argumentos. Ej: dict(color='Azul', num=4)
  • Constructor dict y pares de valores. Ej: dict([('color', 'Azul'), ('num', 4)])
  • Usando un literal de pares separados por ':' y rodeado por {}. Ej: {'color': 'Azul', 'num': 4}

A continuación se muestran ejemplos de diccionarios en Python:

>>> dict(width=4, members=['1', False], name='Pepe')
{'width': 4, 'members': ['1', False], 'name': 'Pepe'}
>>> dict()
{}
>>> {'1': 'primero', '2': 'segundo', 'tercero': 4 * 5 * 6}
{'1': 'primero', '2': 'segundo', 'tercero': 120}
>>> {str(x): x + 1 for x in range(5)}
{'0': 1, '1': 2, '2': 3, '3': 4, '4': 5}
>>> dict(enumerate(range(5), start=10))
{10: 0, 11: 1, 12: 2, 13: 3, 14: 4}
>>> [(x, chr(x)) for x, idx in enumerate(range(5), start=65)]
[(65, 'A'), (66, 'B'), (67, 'C'), (68, 'D'), (69, 'E')]
>>> letters = [(x, chr(x)) for x, idx in enumerate(range(5), start=65)]
>>> dict(letters)
{65: 'A', 66: 'B', 67: 'C', 68: 'D', 69: 'E'}

Como se puede ver en los ejemplos, el tipo de los valores puede ser variable y cualquier tipo de dato.

Orden en diccionarios

Los mapas en cualquier lenguaje de programación se implementan sin orden pero desde la versión 3.5, en Python los diccionarios están ordenados.

Esto significa que mantienen el orden de inserción:

>>> dict(a=1, b=2, c=3, d=4)
{'a': 1, 'b': 2, 'c': 3, 'd': 4}
>>> dd = dict(a=1, b=2, c=3, d=4)
>>> dd
{'a': 1, 'b': 2, 'c': 3, 'd': 4}
>>> dd['b'] = 'Hi'
>>> dd
{'a': 1, 'b': 'Hi', 'c': 3, 'd': 4}
>>> del dd['c']
>>> dd
{'a': 1, 'b': 'Hi', 'd': 4}
>>> list(dd.keys())
['a', 'b', 'd']

Diccionarios en Python vs Mapas en Java

En Java existen diferentes tipos de mapas pero el más parecido a los diccionarios de Python sería HashMap.

Dado que Java tiene un tipado estático, es necesario definir los tipos antes de poder usar la variable, y tampoco se pueden cambiar el tipo fácilmente una vez inicializados.

HashMap<String, List<String>> map =  new HashMap<String, List<String>>();
map.put("animales", Arrays.asList("perro", "gato");
map.put("arboles", Arrays.asList("pino", "roble", "haya");

Y a continuación se puede ver la misma estructura e inicialización en Python:

>>> {'animales': ['perro', 'gato'],
...  'arboles': ['pino', 'roble', 'haya']}
{'animales': ['perro', 'gato'], 'arboles': ['pino', 'roble', 'haya']}

Como se puede apreciar es muchisimo más descriptivo, claro y simple el código en Python.

Convertir objetos JavaScript a diccionarios y viceversa – json

En JavaScript se utilizan objetos de forma común y dado el gran uso que se hace de web, Python soporta de forma nativa la conversión entre objetos Javascript (JSON – JavaScript Object Notation) a diccionarios en Python.

El módulo encargado para estas transformaciones se llama json y se puede utilizar como se ve a continuación:

>>> dd = {'param1': None, 'enabled': True, 'quantity': 45}
>>> dd
{'param1': None, 'enabled': True, 'quantity': 45}
>>> json.dumps(dd)
'{"param1": null, "enabled": true, "quantity": 45}'
>>> json.loads('{"response": "content corrected", "statusCode": 204}')
{'response': 'content corrected', 'statusCode': 204}
>>> ld = json.loads('{"response": "content corrected", "statusCode": 204}')
>>> type(ld)
<class 'dict'>
>>> ld
{'response': 'content corrected', 'statusCode': 204}

Métodos disponibles sobre dict

A continuación se muestran los métodos disponibles para diccionarios:

>>> dir(dict)
['__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', 
'__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', 
'__hash__', '__init__', '__init_subclass__', '__ior__', '__iter__', '__le__', '__len__', 
'__lt__', '__ne__', '__new__', '__or__', '__reduce__', '__reduce_ex__', '__repr__', 
'__reversed__', '__ror__', '__setattr__', '__setitem__', '__sizeof__', '__str__', 
'__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 
'popitem', 'setdefault', 'update', 'values']
MétodoDescripciónEjemplo
clearElimina todos los elementos del diccionario.dict.clear()
copyDevuelve una copia del diccionario.dict.copy()
fromkeysCrea un nuevo diccionario desde una lista de claves y opcionalmente el valor como segundo argumento.>>> dict.fromkeys([89, 2], True)
{89: True, 2: True}
getDevuelve el valor asociado a una clave o un valor por defecto si no se encuentra la clave.# dict.get()
>>> {1: True, 2: False}.get(2)
False
>>> {1: True, 2: False}.get(8)
>>> {1: True, 2: False}.get(8, 'Nothing')
'Nothing'
itemsDevuelve los elementos del diccionario en forma de pares de elementos.# dict.items()
>>> dd.items()
dict_items([('marca', 'Honda'), ('tipo', 'Moto'), ('cc', 599)])
keysDevuelve las claves del diccionario.# dict.keys()
>>> dd.keys()
dict_keys(['marca', 'tipo', 'cc'])
popElimina un elemento por clave del diccionario y lo devuelve.# dict.pop()
>>> dd.pop('cc')
599
>> dd
{'marca': 'Honda', 'tipo': 'Moto'}
popitemElimina un elemento del diccionario, devolviendo la pareja como la clave y el valor.# dict.popitem()
>>> dd.popitem()
('cc', 599)
>>> dd.popitem()
('tipo', 'Moto')
>>> dd
{'marca': 'Honda'}
setdefaultPermite insertar un valor con un valor por defecto como segundo argumento.# dict.setdefault()
>>> dd.setdefault('color', 'Red')
'Red'
>>> dd
{'marca': 'Honda', 'tipo': 'Moto', 'cc': 599, 'color': 'Red'}
updatePermite actualizar el diccionario pasando un diccionario como argumento.# dict.update()
>>> dd.update({3: 'Pepe', 'cc': 125})
>>> dd
{'marca': 'Honda', 'tipo': 'Moto', 'cc': 125, 3: 'Pepe'}
valuesDevuelve los valores del diccionario.# dict.values()
>>> dd.values()
dict_values(['Honda', 'Moto', 599])

Operaciones sobre diccionarios

A continuación, se muestran ejemplos de cómo utilizar los métodos disponibles para cadenas de caracteres en Python.

Claves de diccionarios – Python keys

Para obtener las claves de un diccionario se utiliza el método keys:

>>> dd = dict(marca='Honda', tipo='Moto', cc=599)
>>> dd.keys()
dict_keys(['marca', 'tipo', 'cc'])
>>> for x in dd.keys():
...     print(x)
... 
marca
tipo
cc
>>> for x in dd:
...     print(x)
... 
marca
tipo
cc
>>> list(dd.keys())
['marca', 'tipo', 'cc']

Valores en diccionarios – Python values

Para obtener las valores de las claves de un diccionario se utiliza el método values:

>>> dd = dict(marca='Honda', tipo='Moto', cc=599)
>>> dd.values()
dict_values(['Honda', 'Moto', 599])
>>> for x in dd.values():
...     print(x)
... 
Honda
Moto
599
>>> list(dd.values())
['Honda', 'Moto', 599]

Comprobar elementos en diccionarios – in dict

Se pueden acceder tanto a los valores como a las claves de los diccionarios en Python.

>>> dd = dict(marca='Honda', tipo='Moto', cc=599)
>>> if 'tipo' in dd.keys():
...     print(dd['tipo'])
... 
Moto
>>> if 'Honda' in dd.values():
...     print('Buena moto esa ;)')
... 
Buena moto esa ;)

Cabe destacar que la busqueda en las claves es rápida porque tiene complejidad constante, pero no es igual para los valores, por lo que hay que tenerlo en cuenta en diccionarios grandes.

Iterar sobre diccionarios

>>> dd = dict(marca='Honda', tipo='Moto', cc=599)
>>> for k in dd.keys():
...     print(f'key: {k} con valor: {dd[k]}')
... 
key: marca con valor: Honda
key: tipo con valor: Moto
key: cc con valor: 599
>>> for k, v in dd.items():
...     print(f'key: {k} con valor: {v}')
... 
key: marca con valor: Honda
key: tipo con valor: Moto
key: cc con valor: 599

Libros recomendados para aprender Python

Estos son los libros que pueden ayudarte a aprender Python, aprender a programar, tipos de datos, algoritmia y mucho más.

Disponible en:

Compartir

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

Información básica sobre protección de datos Ver más

  • Responsable Oscar Ramirez.
  • Finalidad Moderar los comentarios. Responder las consultas.
  • Legitimación Su consentimiento.
  • Destinatarios  ionos.
  • Derechos Acceder, rectificar y suprimir los datos.

Publicar un comentario