Aprendizaje Profundo¶

Diplomado en Inteligencia Artificial y Aprendizaje Profundo¶

Diccionarios¶

Fuente: Pexels

Profesores¶

Alvaro Montenegro, PhD, ammontenegrod@unal.edu.co
Camilo José Torres Jiménez, Msc, cjtorresj@unal.edu.co
Daniel Montenegro, Msc, dextronomo@gmail.com

Asesora Medios y Marketing digital¶

Maria del Pilar Montenegro, pmontenegro88@gmail.com
Jessica López Mejía, jelopezme@unal.edu.co

Jefe Jurídica¶

Paula Andrea Guzmán, guzmancruz.paula@gmail.com

Coordinador Jurídico¶

David Fuentes, fuentesd065@gmail.com

Desarrolladores Principales¶

Dairo Moreno, damoralesj@unal.edu.co
Joan Castro, jocastroc@unal.edu.co
Bryan Riveros, briveros@unal.edu.co
Rosmer Vargas, rovargasc@unal.edu.co
Venus Puertas, vpuertasg@unal.edu.co

Expertos en Bases de Datos¶

Giovvani Barrera, udgiovanni@gmail.com
Camilo Chitivo, cchitivo@unal.edu.co

Introducción¶

En esta lección revisamos los conjuntos, los cuales son iterables que se basa en el paradigma clave-valor, que resultan esenciales para el tratamiento avanzado de datos. Un diccionario tiene una estructura casi idéntica a un archivo de tipo JSON, aunque son estructuras de datos diferentes. Por otro lado, si aprende manipular los diccionarios en Python, ya sabe el 95% de lo que son los archivos JSON.

Diccionarios ¶

Los diccionarios se distinguen por estar encapsulados en corchetes {} y poseer el concepto de clave, valor e ítem.

Consideraciones importantes:

En contraste con las listas, los elementos del diccionario no se acceden vía índices, sino vía claves (keys) que se definen.

Los diccionarios son objetos iterables, pero no son ordenados. Por esa razón no pueden ser accesados por un índice, como las listas y las tuplas.

Revisemos el siguiente ejemplo:

In [1]:

Rios = {
...     'Leticia' : 'Amazonas',
...     'Montería': 'Sinu',
...     'Bogotá'  : ['Bogotá', 'Tunjelito'],
...     'San Gil': 'Fonce',
...     'Honda'  : 'Magdalena'
... }

print(Rios)

{'Leticia': 'Amazonas', 'Montería': 'Sinu', 'Bogotá': ['Bogotá', 'Tunjelito'], 'San Gil': 'Fonce', 'Honda': 'Magdalena'}

El objeto Rios es un diccionario. Observe que la estructura del diccionario es

{clave:valor, clave:valor, ...}

En el ejemplo:

las claves son: 'Leticia', 'Montería', 'Bogotá', 'San Gil', 'Honda'.
Los respectivos valores son: 'Amazonas', 'Sinu', ['Bogotá', 'Tunjuelito'], 'Fonce', 'Magdalena'.

Note lo que ocurre cuando intentamos acceder por medio de índices (posiciones):

In [2]:

print(Rios[0])

---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
Cell In [2], line 1
----> 1 print(Rios[0])

KeyError: 0

In [5]:

print('Los rios de Montería son:', Rios['Montería'])
print('Los rios de Bogotá son:', Rios['Bogotá'])

Los rios de Montería son: Sinu
Los rios de Bogotá son: ['Bogotá', 'Tunjelito']

También es posible crear un diccionario usando la función por defecto (built-in) dict(), usando una lista de tuplas:

In [ ]:

my_dic=dict([
             ('Colores', ['Negro','Rojo','Azul']),
             ('Animales', 'Gato'),
             ('Calzado', ['Botas','Botines','Deportivos','Sandalias'])
            ])

print(my_dic)

{'Colores': ['Negro', 'Rojo', 'Azul'], 'Animales': 'Gato', 'Calzado': ['Botas', 'Botines', 'Deportivos', 'Sandalias']}

Veamos el tipo de dato que es un diccionario.

In [ ]:

print(type(my_dic))

<class 'dict'>

Veamos por ejemplo, los ítems que pertenecen a la llave Colores

In [ ]:

print(my_dic['Colores'])

['Negro', 'Rojo', 'Azul']

Una vez ingresado a los ítem del diccionario, en caso de ser listas, podemos acceder a sus elementos tal cual lo hacemos con las listas (por sus índices)

In [ ]:

print(my_dic['Colores'][1])

Rojo

In [ ]:

print('Ví pasar un',my_dic['Animales'],'con',my_dic['Calzado'][0],'de color',my_dic['Colores'][0])

Ví pasar un Gato con Botas de color Negro

Nota: Si las llaves son strings sencillas (sin espacios), también es posible definir un diccionario de la siguiente manera:

In [13]:

my_dic=dict(
             Colores = ['Negro','Rojo','Azul'],
             Animales= 'Gato',
             Calzado =['Botas','Botines','Deportivos','Sandalias']
            )

print(my_dic)

{'Colores': ['Negro', 'Rojo', 'Azul'], 'Animales': 'Gato', 'Calzado': ['Botas', 'Botines', 'Deportivos', 'Sandalias']}

Claro está, si se intenta acceder a una llave incorrecta, obtendremos el siguiente error:

In [ ]:

print(my_dic['Valor'])

---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
<ipython-input-35-fe7f2260447b> in <module>
----> 1 print(my_dic['Valor'])

KeyError: 'Valor'

Podemos agregar, modificar y eliminar valores de un diccionario:

Agregar ítems al diccionario¶

In [14]:

my_dic['Valor']=['20','50','12']
print(my_dic)

{'Colores': ['Negro', 'Rojo', 'Azul'], 'Animales': 'Gato', 'Calzado': ['Botas', 'Botines', 'Deportivos', 'Sandalias'], 'Valor': ['20', '50', '12']}

Modificar valores:¶

In [15]:

my_dic['Colores']='Negro'
print(my_dic)

{'Colores': 'Negro', 'Animales': 'Gato', 'Calzado': ['Botas', 'Botines', 'Deportivos', 'Sandalias'], 'Valor': ['20', '50', '12']}

Eliminar valores:¶

In [16]:

del my_dic['Valor']
print(my_dic)

{'Colores': 'Negro', 'Animales': 'Gato', 'Calzado': ['Botas', 'Botines', 'Deportivos', 'Sandalias']}

La razón por la cuál no es permitido acceder a los ítems de los diccionarios con índices, es porque los diccionarios no tienen orden. Adicionalmente valores numéricos pueden ser claves en un diccionario.

Las claves son inmutables en los diccionarios.

In [6]:

d = {135: 'Coco', 1: 'Urban_Sound8k', 2: 'Mnist', 3: 'CheXpert'}
print(d)

{135: 'Coco', 1: 'Urban_Sound8k', 2: 'Mnist', 3: 'CheXpert'}

In [7]:

d[135]

Out[7]:

'Coco'

Puede ser confuso al principio, confundir estas llaves con índices. Incluso se podría pensar en tomar rebanadas de él sin éxito o agregar valores como se hace en las listas:

In [8]:

d[0:2]

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In [8], line 1
----> 1 d[0:2]

TypeError: unhashable type: 'slice'

Ejercicio¶

Investigue que significa unhashable. Busque la función hash() y úsela en este contexto.

In [9]:

d.append('Yolo')

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
Cell In [9], line 1
----> 1 d.append('Yolo')

AttributeError: 'dict' object has no attribute 'append'

Propiedades de los diccionarios¶

Dinámicos¶

Este concepto es muy importante, pues resalta la capacidad de un diccionario en incrementar su tamaño sin generar error:

In [17]:

#Generar diccionario vacío
persona = {}
print(type(persona))

# Agregar llaves y sus definiciones (items)
persona['Nombre'] = 'Gengis'
persona['Apellido'] = 'Khan'
persona['Edad'] = 23
persona['Esposa'] = ['Börte Qatun','Yesugen','Qulan Qatun','Möge Qatun','Juerbiesu','Ibaqa Beki']
persona['Hijos'] = 'En estudio'
persona['Mascotas'] = {'Perro': 'Wahadi', 'Gato': 'Gotze','Leon':'Pichirilo'}

print(persona)
print('Hijos de',persona['Nombre'],':',persona['Hijos'])

<class 'dict'>
{'Nombre': 'Gengis', 'Apellido': 'Khan', 'Edad': 23, 'Esposa': ['Börte Qatun', 'Yesugen', 'Qulan Qatun', 'Möge Qatun', 'Juerbiesu', 'Ibaqa Beki'], 'Hijos': 'En estudio', 'Mascotas': {'Perro': 'Wahadi', 'Gato': 'Gotze', 'Leon': 'Pichirilo'}}
Hijos de Gengis : En estudio

{admonition}
:class: note
Del ejemplo anterior se puede observar que los diccionarios pueden contener diccionarios en su interior:

In [18]:

print(persona['Mascotas'])

{'Perro': 'Wahadi', 'Gato': 'Gotze', 'Leon': 'Pichirilo'}

In [19]:

print(persona['Mascotas']['Perro'])

Wahadi

Claves¶

No hay restricciones en la forma de definir las llaves:

In [ ]:

foo = {42: 'aaa', 2.78: 'bbb', False: 'cc'}

In [ ]:

foo[False]

Out[ ]:

'cc'

In [ ]:

d = {int: 1, float: 2, bool: 3}

d[int]

Out[ ]:

Sin embargo, las claves son únicases decir, no se pueden repetir:

In [11]:

foo = {42: 'aaa', 2.78: 'bbb', False: 'cc',False:'dodo'}
foo

Out[11]:

{42: 'aaa', 2.78: 'bbb', False: 'dodo'}

Ejercicio¶

Defina un diccionario de al menos 4 claves de tal manera que esas llaves sean tuplas. Acceda a cada elemento. ¿Puede hacer lo mismo para una clave que sea definida como lista o diccionario?

Operadores y Métodos:¶

Es posible utilizar algunos operadores sobre los diccionarios para verificar su estado (por ejemplo, si están o no están disponibles sin generar errores):

In [20]:

'Animales' in my_dic

Out[20]:

True

In [21]:

'Colores' not in my_dic

Out[21]:

False

También podemos usar lógica aristotélica (tablas de verdad) para chequear cosas sin tener errores:

In [ ]:

#my_dic['Valor']

In [ ]:

#'Valor' in my_dic and my_dic['Valor']

len() sobre diccionarios¶

In [22]:

print(my_dic)

print("\nEl diccionario tiene",len(my_dic),'ítems')

{'Colores': 'Negro', 'Animales': 'Gato', 'Calzado': ['Botas', 'Botines', 'Deportivos', 'Sandalias']}

El diccionario tiene 3 ítems

Métodos¶

d.clear()¶

In [ ]:

print(d)
d.clear()
print(d)

{<class 'int'>: 1, <class 'float'>: 2, <class 'bool'>: 3}
{}

Una vez ingresado a los ítem del diccionario, en caso de ser listas, podemos acceder a sus elementos tal cual lo hacemos con las listas (por sus índices)

d.get(<key>[, <default>])¶

In [23]:

print(my_dic.get('Colores'))

Negro

In [24]:

print(persona.get('Esposa'))

['Börte Qatun', 'Yesugen', 'Qulan Qatun', 'Möge Qatun', 'Juerbiesu', 'Ibaqa Beki']

items¶

In [25]:

print(my_dic.items())

dict_items([('Colores', 'Negro'), ('Animales', 'Gato'), ('Calzado', ['Botas', 'Botines', 'Deportivos', 'Sandalias'])])

In [ ]:

print(list(my_dic.items()))

[('Colores', 'Negro'), ('Animales', 'Gato'), ('Calzado', ['Botas', 'Botines', 'Deportivos', 'Sanadalias'])]

In [ ]:

list(my_dic.items())[0][1]

Out[ ]:

'Negro'

También existen otros métodos útiles. ¡Averigua para que sirve cada uno!

d.keys()
d.values()
d.pop(<key>[, <default>])
d.popitem()
d.update(<obj>)

Ejercicio¶

A partir de las siguientes líneas de código, entienda lo que hace cada uno de los métodos y cree sus propio ejemplo de mayor complejidad.

In [26]:

print(my_dic)

{'Colores': 'Negro', 'Animales': 'Gato', 'Calzado': ['Botas', 'Botines', 'Deportivos', 'Sandalias']}

In [27]:

print(my_dic.items())
print(my_dic.keys())
print(my_dic.values())
print(my_dic.pop('Colores'))
print(my_dic)
print(my_dic.popitem())
print(my_dic)
print(my_dic.update(persona))

dict_items([('Colores', 'Negro'), ('Animales', 'Gato'), ('Calzado', ['Botas', 'Botines', 'Deportivos', 'Sandalias'])])
dict_keys(['Colores', 'Animales', 'Calzado'])
dict_values(['Negro', 'Gato', ['Botas', 'Botines', 'Deportivos', 'Sandalias']])
Negro
{'Animales': 'Gato', 'Calzado': ['Botas', 'Botines', 'Deportivos', 'Sandalias']}
('Calzado', ['Botas', 'Botines', 'Deportivos', 'Sandalias'])
{'Animales': 'Gato'}
None

char2int¶

Como último ejemplo construimos un diccionario para el alfabeto, de tal manera que dado un caracter retorne un código asociado.

In [ ]:

alfabeto = 'abcdefghijklmnñopqrstuvwxyz'
alfaL = []
for j in alfabeto:
    alfaL.append(j)


char2int = {}
num = list(range(len(alfabeto)))

for car,val in zip(alfaL, num):
    char2int[car] = num[val]

print(char2int)
print('\n')
print('char2int[\'c\']=',char2int['c'])

{'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12, 'n': 13, 'ñ': 14, 'o': 15, 'p': 16, 'q': 17, 'r': 18, 's': 19, 't': 20, 'u': 21, 'v': 22, 'w': 23, 'x': 24, 'y': 25, 'z': 26}


char2int['c']= 2

Métodos de los diccionarios¶

Método	Descripción
clear()	Elimina todos los elementos del diccionario.
copy()	Devuelve una copia poco profunda del diccionario.
get(clave[,valor])	Devuelve el valor de la clave. Si no existe, devuelve el valor valor si se indica y si no, None.
items()	Devuelve una vista de los pares clave: valor del diccionario.
keys()	Devuelve una vista de las claves del diccionario.
pop(clave[,valor])	Devuelve el valor del elemento cuya clave es clave y elimina el elemento del diccionario. Si la clave no se encuentra, devuelve valor si se proporciona. Si la clave no se encuentra y no se indica valor, lanza la excepción KeyError.
popitem()	Devuelve un par (clave, valor) aleatorio del diccionario. Si el diccionario está vacío, lanza la excepción KeyError.
setdefault(clave[,valor])	Si la clave está en el diccionario, devuelve su valor. Si no lo está, inserta la clave con el valor valor y lo devuelve (si no se especifica valor, por defecto es None).
update(iterable)	Actualiza el diccionario con los pares clave: valor del iterable.
values()	Devuelve una vista de los valores del diccionario.

Tips para manipulación de diccionarios¶

Mezclar dos diccionarios¶

In [32]:

dict1 = {'a': 1, 'b': 2}
dict2 = {'c': 3, 'd': 4}

dict3 = {**dict1, **dict2}

print(dict3)

{'a': 1, 'b': 2, 'c': 3, 'd': 4}

Hacer la unión de dos diccionarios¶

Disponible desde Python 3.9

In [34]:

dict1 = {'a':1, 'b':2}
dict2 = {'c':3, 'b':4}

dict3 = dict1 | dict2
print(dict3)

{'a': 1, 'b': 4, 'c': 3}

Chequear si una clave existe en un diccionario¶

In [35]:

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

print('a' in dict1)
print('c' in dict1)

True
False

Remover un item de un diccionario¶

Revise las siguientes tres salidas y desarrolle su propio ejemplo.

In [36]:

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

print(dict1.pop('a'))
print(dict1.pop('c', 'Missing Key'))
print(dict1.pop('d'))

1
Missing Key

---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
Cell In [36], line 5
      3 print(dict1.pop('a'))
      4 print(dict1.pop('c', 'Missing Key'))
----> 5 print(dict1.pop('d'))

KeyError: 'd'

Diccionarios por comprensión¶

In [ ]:

dict1 = {i:i**2 for i in range(1,11)}
print(dict1)

{1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81, 10: 100}

Eliminar items vacios (None) en un diccionario¶

In [ ]:

dict1 = {'a': 'manzana', 'b': 'banano', 'c':None}

dict1 = {key:value for (key, value) in dict1.items() if value is not None}
print(dict1)

{'a': 'manzana', 'b': 'banano'}

Uso de `get` para acceder a un ítem en un diccionario¶

Observe que con el uso de get no se genera un error cuando se intenta accesar una clave que no existe. En ese caso se recibe el valor None. Por el contrario se accesa directamente por la clave, se obtiene un error si la clave no existe en el diccionario.

In [ ]:

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

print(dict1.get('c'))
print(dict1['c'])

# Returns: None
# Returns: KeyError

None

---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
<ipython-input-68-035bdafe920c> in <module>
      2 
      3 print(dict1.get('c'))
----> 4 print(dict1['c'])
      5 
      6 # Returns: None

KeyError: 'c'

Filtrar un diccionario¶

Se pueden obtener los ítems en un diccionario que cumplen con un criterio. En ejemplo se filtran las personas que miden 170 cm o más.

In [ ]:

alturas = {'John': 175, 'Luis': 150, 'Carlos': 155, 'María': 170}

alto = {key:value for (key, value) in alturas.items() if value >= 170}

print(tall)

{'John': 175, 'María': 170}

Iterando en un diccionario un diccionario¶

Vamos iterar a lo largo de un diccionario, primero por las claves y luego por los valores.

In [ ]:

# creamos el diccionario

salarios = {'León': 175, 'Luis': [150, 100], 'Carlos': 155, 'Angel': None}
print(salarios)

{'León': 175, 'Luis': [150, 100], 'Carlos': 155, 'Angel': None}

In [ ]:

# recorremos por claves

for salario in salarios:
    print(salario)

León
Luis
Carlos
Angel

In [ ]:

# de nuevo por claves
for persona in salarios.keys():
    print(persona)

León
Luis
Carlos
Angel

In [ ]:

# recorremos por valores
for salario in salarios.values():
    print(salario)

175
[150, 100]
155
None

Aprendizaje Profundo¶

Diplomado en Inteligencia Artificial y Aprendizaje Profundo¶

Diccionarios¶

Profesores¶

Asesora Medios y Marketing digital¶

Jefe Jurídica¶

Coordinador Jurídico¶

Desarrolladores Principales¶

Expertos en Bases de Datos¶

Introducción¶

Diccionarios ¶

Agregar ítems al diccionario¶

Modificar valores:¶

Eliminar valores:¶

Ejercicio¶

Propiedades de los diccionarios¶

Dinámicos¶

Claves¶

Ejercicio¶

Operadores y Métodos:¶

len() sobre diccionarios¶

Métodos¶

d.clear()¶

d.get(<key>[, <default>])¶

items¶

Ejercicio¶

char2int¶

Métodos de los diccionarios¶

Tips para manipulación de diccionarios¶

Mezclar dos diccionarios¶

Hacer la unión de dos diccionarios¶

Chequear si una clave existe en un diccionario¶

Remover un item de un diccionario¶

Diccionarios por comprensión¶

Eliminar items vacios (None) en un diccionario¶

Uso de get para acceder a un ítem en un diccionario¶

Filtrar un diccionario¶

Iterando en un diccionario un diccionario¶

Uso de `get` para acceder a un ítem en un diccionario¶