{
"cells": [
{
"cell_type": "markdown",
"id": "ee00f5ad-157b-411c-b460-cd42c80de692",
"metadata": {},
"source": [
"<figure>\n",
"<img src=\"../Imagenes/logo-final-ap.png\" width=\"80\" height=\"80\" align=\"left\"/> \n",
"</figure>\n",
"\n",
"# <span style=\"color:#4361EE\"><left>Aprendizaje Profundo</left></span>"
]
},
{
"cell_type": "markdown",
"id": "54c39c57-aabd-4111-86ec-29bd9e10167f",
"metadata": {},
"source": [
"# <span style=\"color:red\"><center>Diplomado en Inteligencia Artificial y Aprendizaje Profundo</center></span>"
]
},
{
"cell_type": "markdown",
"id": "04b97205",
"metadata": {},
"source": [
"# <span style=\"color:green\"><center>Diccionarios</center></span>\n"
]
},
{
"cell_type": "markdown",
"id": "1894a340",
"metadata": {},
"source": [
"<figure>\n",
"<center>\n",
"<img src=\"https://raw.githubusercontent.com/AprendizajeProfundo/Alejandria/main/Archivos_Generales/Imagenes/Diccionario.jpg\" width=\"600\" height=\"400\" align=\"center\" /> \n",
"</center> \n",
"</figure>\n",
"<center>\n",
"\n",
"Fuente: [Pexels](https://www.pexels.com/es-es/foto/diccionario-de-texto-en-efecto-bokeh-267669/)\n",
"\n",
"</center>\n"
]
},
{
"cell_type": "markdown",
"id": "cd60e44d",
"metadata": {},
"source": [
"## <span style=\"color:#4361EE\">Profesores</span>"
]
},
{
"cell_type": "markdown",
"id": "4dcdd021",
"metadata": {},
"source": [
"1. Alvaro Montenegro, PhD, ammontenegrod@unal.edu.co\n",
"1. Camilo José Torres Jiménez, Msc, cjtorresj@unal.edu.co\n",
"1. Daniel Montenegro, Msc, dextronomo@gmail.com "
]
},
{
"cell_type": "markdown",
"id": "1e149ea9",
"metadata": {},
"source": [
"## <span style=\"color:#4361EE\">Asesora Medios y Marketing digital</span>"
]
},
{
"cell_type": "markdown",
"id": "bedabf45",
"metadata": {},
"source": [
"4. Maria del Pilar Montenegro, pmontenegro88@gmail.com\n",
"5. Jessica López Mejía, jelopezme@unal.edu.co"
]
},
{
"cell_type": "markdown",
"id": "e35cf6f5",
"metadata": {},
"source": [
"## <span style=\"color:#4361EE\">Jefe Jurídica</span>"
]
},
{
"cell_type": "markdown",
"id": "3ae28633",
"metadata": {},
"source": [
"6. Paula Andrea Guzmán, guzmancruz.paula@gmail.com"
]
},
{
"cell_type": "markdown",
"id": "101df433",
"metadata": {},
"source": [
"## <span style=\"color:#4361EE\">Coordinador Jurídico</span>"
]
},
{
"cell_type": "markdown",
"id": "55d3d6fc",
"metadata": {},
"source": [
"7. David Fuentes, fuentesd065@gmail.com"
]
},
{
"cell_type": "markdown",
"id": "6517a8b4",
"metadata": {},
"source": [
"## <span style=\"color:#4361EE\">Desarrolladores Principales</span>"
]
},
{
"cell_type": "markdown",
"id": "314b19df",
"metadata": {},
"source": [
"8. Dairo Moreno, damoralesj@unal.edu.co\n",
"9. Joan Castro, jocastroc@unal.edu.co\n",
"10. Bryan Riveros, briveros@unal.edu.co\n",
"11. Rosmer Vargas, rovargasc@unal.edu.co\n",
"12. Venus Puertas, vpuertasg@unal.edu.co"
]
},
{
"cell_type": "markdown",
"id": "18dd69a0",
"metadata": {},
"source": [
"## <span style=\"color:#4361EE\">Expertos en Bases de Datos</span>"
]
},
{
"cell_type": "markdown",
"id": "d92a5029",
"metadata": {},
"source": [
"13. Giovvani Barrera, udgiovanni@gmail.com\n",
"14. Camilo Chitivo, cchitivo@unal.edu.co"
]
},
{
"cell_type": "markdown",
"id": "public-tuition",
"metadata": {},
"source": [
"## <span style=\"color:#4361EE\">Introducción</span>"
]
},
{
"cell_type": "markdown",
"id": "settled-heavy",
"metadata": {
"colab_type": "text",
"id": "Qwzm74tvByHP"
},
"source": [
"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](https://es.wikipedia.org/wiki/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."
]
},
{
"cell_type": "markdown",
"id": "global-daily",
"metadata": {},
"source": [
"## <span style=\"color:#4361EE\">Diccionarios </span>"
]
},
{
"cell_type": "markdown",
"id": "radio-woman",
"metadata": {},
"source": [
"Los diccionarios se distinguen por estar encapsulados en corchetes {} y poseer el concepto de clave, valor e ítem.\n",
"\n",
"**Consideraciones importantes:**\n",
"\n",
"En **contraste con las listas**, los elementos del diccionario no se acceden vía índices, sino vía claves (**keys**) que se definen. \n",
"\n",
"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.\n",
"\n",
"Revisemos el siguiente ejemplo:"
]
},
{
"cell_type": "code",
"execution_count": 1,
"id": "loose-genius",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{'Leticia': 'Amazonas', 'Montería': 'Sinu', 'Bogotá': ['Bogotá', 'Tunjelito'], 'San Gil': 'Fonce', 'Honda': 'Magdalena'}\n"
]
}
],
"source": [
"Rios = {\n",
"... 'Leticia' : 'Amazonas',\n",
"... 'Montería': 'Sinu',\n",
"... 'Bogotá' : ['Bogotá', 'Tunjelito'],\n",
"... 'San Gil': 'Fonce',\n",
"... 'Honda' : 'Magdalena'\n",
"... }\n",
"\n",
"print(Rios)"
]
},
{
"cell_type": "markdown",
"id": "172c99bb-685c-4e55-8f67-42172dd74427",
"metadata": {},
"source": [
"El objeto *Rios* es un diccionario. Observe que la estructura del diccionario es\n",
"\n",
"+ {clave:valor, clave:valor, ...}\n",
"\n",
"En el ejemplo:\n",
"\n",
"* las claves son: 'Leticia', 'Montería', 'Bogotá', 'San Gil', 'Honda'. \n",
"* Los respectivos valores son: 'Amazonas', 'Sinu', ['Bogotá', 'Tunjuelito'], 'Fonce', 'Magdalena'."
]
},
{
"cell_type": "markdown",
"id": "scheduled-champion",
"metadata": {},
"source": [
"Note lo que ocurre cuando intentamos acceder por medio de índices (posiciones):"
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "extreme-suffering",
"metadata": {},
"outputs": [
{
"ename": "KeyError",
"evalue": "0",
"output_type": "error",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)",
"Cell \u001b[0;32mIn [2], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[43mRios\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m)\n",
"\u001b[0;31mKeyError\u001b[0m: 0"
]
}
],
"source": [
"print(Rios[0])"
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "df4d01a4-2b39-4855-a23e-b8b811c58023",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Los rios de Montería son: Sinu\n",
"Los rios de Bogotá son: ['Bogotá', 'Tunjelito']\n"
]
}
],
"source": [
"print('Los rios de Montería son:', Rios['Montería'])\n",
"print('Los rios de Bogotá son:', Rios['Bogotá'])"
]
},
{
"cell_type": "markdown",
"id": "exempt-buddy",
"metadata": {},
"source": [
"También es posible crear un diccionario usando la función por defecto (built-in) `dict()`, usando una lista de tuplas:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "bacterial-bracelet",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{'Colores': ['Negro', 'Rojo', 'Azul'], 'Animales': 'Gato', 'Calzado': ['Botas', 'Botines', 'Deportivos', 'Sandalias']}\n"
]
}
],
"source": [
"my_dic=dict([\n",
" ('Colores', ['Negro','Rojo','Azul']),\n",
" ('Animales', 'Gato'),\n",
" ('Calzado', ['Botas','Botines','Deportivos','Sandalias'])\n",
" ])\n",
"\n",
"print(my_dic)"
]
},
{
"cell_type": "markdown",
"id": "alike-guest",
"metadata": {},
"source": [
"Veamos el tipo de dato que es un diccionario."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "controversial-cache",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"<class 'dict'>\n"
]
}
],
"source": [
"print(type(my_dic))"
]
},
{
"cell_type": "markdown",
"id": "electoral-efficiency",
"metadata": {},
"source": [
"Veamos por ejemplo, los ítems que pertenecen a la llave **Colores**"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "fantastic-decision",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['Negro', 'Rojo', 'Azul']\n"
]
}
],
"source": [
"print(my_dic['Colores'])\n"
]
},
{
"cell_type": "markdown",
"id": "substantial-swift",
"metadata": {},
"source": [
"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)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "digital-leadership",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Rojo\n"
]
}
],
"source": [
"print(my_dic['Colores'][1])"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "sunrise-martin",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Ví pasar un Gato con Botas de color Negro\n"
]
}
],
"source": [
"print('Ví pasar un',my_dic['Animales'],'con',my_dic['Calzado'][0],'de color',my_dic['Colores'][0])"
]
},
{
"cell_type": "markdown",
"id": "smaller-irish",
"metadata": {},
"source": [
"**Nota:** Si las llaves son strings sencillas (sin espacios), también es posible definir un diccionario de la siguiente manera:"
]
},
{
"cell_type": "code",
"execution_count": 13,
"id": "subtle-radical",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{'Colores': ['Negro', 'Rojo', 'Azul'], 'Animales': 'Gato', 'Calzado': ['Botas', 'Botines', 'Deportivos', 'Sandalias']}\n"
]
}
],
"source": [
"my_dic=dict(\n",
" Colores = ['Negro','Rojo','Azul'],\n",
" Animales= 'Gato',\n",
" Calzado =['Botas','Botines','Deportivos','Sandalias']\n",
" )\n",
"\n",
"print(my_dic)"
]
},
{
"cell_type": "markdown",
"id": "caring-tennis",
"metadata": {},
"source": [
"Claro está, si se intenta acceder a una llave incorrecta, obtendremos el siguiente error:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "supported-loading",
"metadata": {},
"outputs": [
{
"ename": "KeyError",
"evalue": "'Valor'",
"output_type": "error",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)",
"\u001b[0;32m<ipython-input-35-fe7f2260447b>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmy_dic\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'Valor'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
"\u001b[0;31mKeyError\u001b[0m: 'Valor'"
]
}
],
"source": [
"print(my_dic['Valor'])"
]
},
{
"cell_type": "markdown",
"id": "recognized-server",
"metadata": {},
"source": [
"Podemos agregar, modificar y eliminar valores de un diccionario:"
]
},
{
"cell_type": "markdown",
"id": "accomplished-bennett",
"metadata": {},
"source": [
"### <span style=\"color:#4CC9F0\">Agregar ítems al diccionario</span>\n"
]
},
{
"cell_type": "code",
"execution_count": 14,
"id": "focused-hunger",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{'Colores': ['Negro', 'Rojo', 'Azul'], 'Animales': 'Gato', 'Calzado': ['Botas', 'Botines', 'Deportivos', 'Sandalias'], 'Valor': ['20', '50', '12']}\n"
]
}
],
"source": [
"my_dic['Valor']=['20','50','12']\n",
"print(my_dic)"
]
},
{
"cell_type": "markdown",
"id": "accompanied-memphis",
"metadata": {},
"source": [
"### <span style=\"color:#4CC9F0\">Modificar valores:</span>\n"
]
},
{
"cell_type": "code",
"execution_count": 15,
"id": "ruled-berlin",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{'Colores': 'Negro', 'Animales': 'Gato', 'Calzado': ['Botas', 'Botines', 'Deportivos', 'Sandalias'], 'Valor': ['20', '50', '12']}\n"
]
}
],
"source": [
"my_dic['Colores']='Negro'\n",
"print(my_dic)"
]
},
{
"cell_type": "markdown",
"id": "pleasant-arnold",
"metadata": {},
"source": [
"### <span style=\"color:#4CC9F0\">Eliminar valores:</span>\n"
]
},
{
"cell_type": "code",
"execution_count": 16,
"id": "thermal-venezuela",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{'Colores': 'Negro', 'Animales': 'Gato', 'Calzado': ['Botas', 'Botines', 'Deportivos', 'Sandalias']}\n"
]
}
],
"source": [
"del my_dic['Valor']\n",
"print(my_dic)"
]
},
{
"cell_type": "markdown",
"id": "registered-batch",
"metadata": {},
"source": [
"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.\n",
"\n",
"Las `claves son inmutables` en los diccionarios."
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "induced-terror",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{135: 'Coco', 1: 'Urban_Sound8k', 2: 'Mnist', 3: 'CheXpert'}\n"
]
}
],
"source": [
"d = {135: 'Coco', 1: 'Urban_Sound8k', 2: 'Mnist', 3: 'CheXpert'}\n",
"print(d)"
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "genetic-component",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'Coco'"
]
},
"execution_count": 7,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"d[135]"
]
},
{
"cell_type": "markdown",
"id": "engaged-unemployment",
"metadata": {},
"source": [
"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:"
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "forced-spice",
"metadata": {},
"outputs": [
{
"ename": "TypeError",
"evalue": "unhashable type: 'slice'",
"output_type": "error",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)",
"Cell \u001b[0;32mIn [8], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43md\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m:\u001b[49m\u001b[38;5;241;43m2\u001b[39;49m\u001b[43m]\u001b[49m\n",
"\u001b[0;31mTypeError\u001b[0m: unhashable type: 'slice'"
]
}
],
"source": [
"d[0:2]"
]
},
{
"cell_type": "markdown",
"id": "d9f73727",
"metadata": {},
"source": [
"### <span style=\"color:#4CC9F0\">Ejercicio</span>\n"
]
},
{
"cell_type": "markdown",
"id": "wooden-syntax",
"metadata": {},
"source": [
"Investigue que significa unhashable. Busque la función `hash()` y úsela en este contexto."
]
},
{
"cell_type": "code",
"execution_count": 9,
"id": "prepared-meeting",
"metadata": {},
"outputs": [
{
"ename": "AttributeError",
"evalue": "'dict' object has no attribute 'append'",
"output_type": "error",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)",
"Cell \u001b[0;32mIn [9], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43md\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mappend\u001b[49m(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mYolo\u001b[39m\u001b[38;5;124m'\u001b[39m)\n",
"\u001b[0;31mAttributeError\u001b[0m: 'dict' object has no attribute 'append'"
]
}
],
"source": [
"d.append('Yolo')"
]
},
{
"cell_type": "markdown",
"id": "7f5040a7",
"metadata": {},
"source": [
"### <span style=\"color:#4CC9F0\">Propiedades de los diccionarios</span>\n"
]
},
{
"cell_type": "markdown",
"id": "architectural-district",
"metadata": {},
"source": [
"#### <span style=\"color:#4CC9F0\">Dinámicos</span>\n"
]
},
{
"cell_type": "markdown",
"id": "constant-lawrence",
"metadata": {},
"source": [
"Este concepto es muy importante, pues resalta la capacidad de un diccionario en incrementar su tamaño sin generar error:"
]
},
{
"cell_type": "code",
"execution_count": 17,
"id": "brazilian-eight",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"<class 'dict'>\n",
"{'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'}}\n",
"Hijos de Gengis : En estudio\n"
]
}
],
"source": [
"#Generar diccionario vacío\n",
"persona = {}\n",
"print(type(persona))\n",
"\n",
"# Agregar llaves y sus definiciones (items)\n",
"persona['Nombre'] = 'Gengis'\n",
"persona['Apellido'] = 'Khan'\n",
"persona['Edad'] = 23\n",
"persona['Esposa'] = ['Börte Qatun','Yesugen','Qulan Qatun','Möge Qatun','Juerbiesu','Ibaqa Beki']\n",
"persona['Hijos'] = 'En estudio'\n",
"persona['Mascotas'] = {'Perro': 'Wahadi', 'Gato': 'Gotze','Leon':'Pichirilo'}\n",
"\n",
"print(persona)\n",
"print('Hijos de',persona['Nombre'],':',persona['Hijos'])"
]
},
{
"cell_type": "markdown",
"id": "07b1c73c",
"metadata": {},
"source": [
"```{admonition} Nota\n",
":class: note\n",
"Del ejemplo anterior se puede observar que los diccionarios pueden contener diccionarios en su interior:\n",
"```\n"
]
},
{
"cell_type": "code",
"execution_count": 18,
"id": "micro-airline",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{'Perro': 'Wahadi', 'Gato': 'Gotze', 'Leon': 'Pichirilo'}\n"
]
}
],
"source": [
"print(persona['Mascotas'])"
]
},
{
"cell_type": "code",
"execution_count": 19,
"id": "limiting-occasion",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Wahadi\n"
]
}
],
"source": [
"print(persona['Mascotas']['Perro'])"
]
},
{
"cell_type": "markdown",
"id": "77fe8d91",
"metadata": {},
"source": [
"#### <span style=\"color:#4CC9F0\">Claves</span>\n"
]
},
{
"cell_type": "markdown",
"id": "adopted-davis",
"metadata": {},
"source": [
"No hay restricciones en la forma de definir las llaves:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "lucky-receiver",
"metadata": {},
"outputs": [],
"source": [
"foo = {42: 'aaa', 2.78: 'bbb', False: 'cc'}"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "collaborative-phenomenon",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'cc'"
]
},
"execution_count": 45,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"foo[False]"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "removed-memory",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"1"
]
},
"execution_count": 46,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"d = {int: 1, float: 2, bool: 3}\n",
"\n",
"d[int]"
]
},
{
"cell_type": "markdown",
"id": "introductory-memorabilia",
"metadata": {},
"source": [
"Sin embargo, las claves son únicases decir, no se pueden repetir:"
]
},
{
"cell_type": "code",
"execution_count": 11,
"id": "cloudy-ideal",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"{42: 'aaa', 2.78: 'bbb', False: 'dodo'}"
]
},
"execution_count": 11,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"foo = {42: 'aaa', 2.78: 'bbb', False: 'cc',False:'dodo'}\n",
"foo"
]
},
{
"cell_type": "markdown",
"id": "61f4d609",
"metadata": {},
"source": [
"### <span style=\"color:#4CC9F0\">Ejercicio</span>\n"
]
},
{
"cell_type": "markdown",
"id": "31cec6c5-e4d5-49aa-a6db-7c5efa891c99",
"metadata": {},
"source": [
"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?"
]
},
{
"cell_type": "markdown",
"id": "8632df1d",
"metadata": {},
"source": [
"### <span style=\"color:#4CC9F0\">Operadores y Métodos:</span>\n"
]
},
{
"cell_type": "markdown",
"id": "facial-provincial",
"metadata": {},
"source": [
"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):"
]
},
{
"cell_type": "code",
"execution_count": 20,
"id": "reported-norwegian",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"True"
]
},
"execution_count": 20,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"'Animales' in my_dic"
]
},
{
"cell_type": "code",
"execution_count": 21,
"id": "comfortable-fence",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"False"
]
},
"execution_count": 21,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"'Colores' not in my_dic"
]
},
{
"cell_type": "markdown",
"id": "descending-magazine",
"metadata": {},
"source": [
"También podemos usar lógica aristotélica (tablas de verdad) para chequear cosas sin tener errores:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "subsequent-first",
"metadata": {},
"outputs": [],
"source": [
"#my_dic['Valor']"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "solid-diagnosis",
"metadata": {},
"outputs": [],
"source": [
"#'Valor' in my_dic and my_dic['Valor']"
]
},
{
"cell_type": "markdown",
"id": "80cd5f41",
"metadata": {},
"source": [
"#### <span style=\"color:#4CC9F0\">len() sobre diccionarios</span>\n"
]
},
{
"cell_type": "code",
"execution_count": 22,
"id": "wrapped-checklist",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{'Colores': 'Negro', 'Animales': 'Gato', 'Calzado': ['Botas', 'Botines', 'Deportivos', 'Sandalias']}\n",
"\n",
"El diccionario tiene 3 ítems\n"
]
}
],
"source": [
"print(my_dic)\n",
"\n",
"print(\"\\nEl diccionario tiene\",len(my_dic),'ítems')"
]
},
{
"cell_type": "markdown",
"id": "5c88ff90",
"metadata": {},
"source": [
"#### <span style=\"color:#4CC9F0\">Métodos</span>\n"
]
},
{
"cell_type": "markdown",
"id": "sharp-chambers",
"metadata": {},
"source": [
"##### d.clear()"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "spanish-indie",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{<class 'int'>: 1, <class 'float'>: 2, <class 'bool'>: 3}\n",
"{}\n"
]
}
],
"source": [
"print(d)\n",
"d.clear()\n",
"print(d)"
]
},
{
"cell_type": "markdown",
"id": "light-liquid",
"metadata": {},
"source": [
"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)"
]
},
{
"cell_type": "markdown",
"id": "intelligent-mumbai",
"metadata": {},
"source": [
"##### d.get(\\<key>[, \\<default>])"
]
},
{
"cell_type": "code",
"execution_count": 23,
"id": "adequate-surgery",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Negro\n"
]
}
],
"source": [
"print(my_dic.get('Colores'))"
]
},
{
"cell_type": "code",
"execution_count": 24,
"id": "temporal-suspect",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['Börte Qatun', 'Yesugen', 'Qulan Qatun', 'Möge Qatun', 'Juerbiesu', 'Ibaqa Beki']\n"
]
}
],
"source": [
"print(persona.get('Esposa'))"
]
},
{
"cell_type": "markdown",
"id": "5cea60f6",
"metadata": {},
"source": [
"### <span style=\"color:#4CC9F0\">items</span>\n"
]
},
{
"cell_type": "code",
"execution_count": 25,
"id": "qualified-distribution",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"dict_items([('Colores', 'Negro'), ('Animales', 'Gato'), ('Calzado', ['Botas', 'Botines', 'Deportivos', 'Sandalias'])])\n"
]
}
],
"source": [
"print(my_dic.items())"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "spanish-denver",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[('Colores', 'Negro'), ('Animales', 'Gato'), ('Calzado', ['Botas', 'Botines', 'Deportivos', 'Sanadalias'])]\n"
]
}
],
"source": [
"print(list(my_dic.items()))"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "separated-strengthening",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'Negro'"
]
},
"execution_count": 56,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"list(my_dic.items())[0][1]"
]
},
{
"cell_type": "markdown",
"id": "apart-yellow",
"metadata": {},
"source": [
"También existen otros métodos útiles. ¡Averigua para que sirve cada uno!\n",
"\n",
"- **d.keys()**\n",
"- **d.values()**\n",
"- **d.pop(\\<key>[, \\<default>])**\n",
"- **d.popitem()**\n",
"- **d.update(\\<obj>)**"
]
},
{
"cell_type": "markdown",
"id": "4939da28-31de-415d-8924-7ef087f7479f",
"metadata": {},
"source": [
"### <span style=\"color:#4CC9F0\">Ejercicio</span>\n"
]
},
{
"cell_type": "markdown",
"id": "c1ca71dd-3070-440d-bd50-9254448e34af",
"metadata": {},
"source": [
"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."
]
},
{
"cell_type": "code",
"execution_count": 26,
"id": "aggregate-recycling",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{'Colores': 'Negro', 'Animales': 'Gato', 'Calzado': ['Botas', 'Botines', 'Deportivos', 'Sandalias']}\n"
]
}
],
"source": [
"print(my_dic)"
]
},
{
"cell_type": "code",
"execution_count": 27,
"id": "passing-attack",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"dict_items([('Colores', 'Negro'), ('Animales', 'Gato'), ('Calzado', ['Botas', 'Botines', 'Deportivos', 'Sandalias'])])\n",
"dict_keys(['Colores', 'Animales', 'Calzado'])\n",
"dict_values(['Negro', 'Gato', ['Botas', 'Botines', 'Deportivos', 'Sandalias']])\n",
"Negro\n",
"{'Animales': 'Gato', 'Calzado': ['Botas', 'Botines', 'Deportivos', 'Sandalias']}\n",
"('Calzado', ['Botas', 'Botines', 'Deportivos', 'Sandalias'])\n",
"{'Animales': 'Gato'}\n",
"None\n"
]
}
],
"source": [
"print(my_dic.items())\n",
"print(my_dic.keys())\n",
"print(my_dic.values())\n",
"print(my_dic.pop('Colores'))\n",
"print(my_dic)\n",
"print(my_dic.popitem())\n",
"print(my_dic)\n",
"print(my_dic.update(persona))"
]
},
{
"cell_type": "markdown",
"id": "7d53096d",
"metadata": {},
"source": [
"### <span style=\"color:#4CC9F0\">char2int</span>\n"
]
},
{
"cell_type": "markdown",
"id": "fifteen-unemployment",
"metadata": {},
"source": [
"Como último ejemplo construimos un diccionario para el alfabeto, de tal manera que dado un caracter retorne un código asociado."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "frozen-better",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{'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}\n",
"\n",
"\n",
"char2int['c']= 2\n"
]
}
],
"source": [
"alfabeto = 'abcdefghijklmnñopqrstuvwxyz'\n",
"alfaL = []\n",
"for j in alfabeto:\n",
" alfaL.append(j)\n",
"\n",
"\n",
"char2int = {}\n",
"num = list(range(len(alfabeto)))\n",
"\n",
"for car,val in zip(alfaL, num):\n",
" char2int[car] = num[val]\n",
"\n",
"print(char2int)\n",
"print('\\n')\n",
"print('char2int[\\'c\\']=',char2int['c'])"
]
},
{
"cell_type": "markdown",
"id": "63ec2ddd",
"metadata": {},
"source": [
"### <span style=\"color:#4CC9F0\">Métodos de los diccionarios</span>\n"
]
},
{
"cell_type": "markdown",
"id": "understood-entrepreneur",
"metadata": {},
"source": [
"|Método|Descripción |\n",
"|---|---|\n",
"|clear()|Elimina todos los elementos del diccionario.|\n",
"|copy()|Devuelve una copia poco profunda del diccionario.|\n",
"|get(clave[,valor])|Devuelve el valor de la clave. Si no existe, devuelve el valor valor si se indica y si no, None.|\n",
"|items()|Devuelve una vista de los pares clave: valor del diccionario.|\n",
"|keys()|Devuelve una vista de las claves del diccionario.|\n",
"|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.|\n",
"|popitem()|Devuelve un par (clave, valor) aleatorio del diccionario. Si el diccionario está vacío, lanza la excepción KeyError.|\n",
"|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).|\n",
"|update(iterable)|Actualiza el diccionario con los pares clave: valor del iterable.|\n",
"|values()|Devuelve una vista de los valores del diccionario.|"
]
},
{
"cell_type": "markdown",
"id": "1bafbd82-9ad1-49ad-83eb-ea58b35f0e39",
"metadata": {},
"source": [
"### <span style=\"color:#4CC9F0\">Tips para manipulación de diccionarios</span>"
]
},
{
"cell_type": "markdown",
"id": "5b6f5c10-e3c8-4ef2-9f5c-bedaea4a64cb",
"metadata": {},
"source": [
"#### <span style=\"color:#4CC9F0\">Mezclar dos diccionarios</span>"
]
},
{
"cell_type": "code",
"execution_count": 32,
"id": "2a0fc09d-589c-4054-9da1-33b866690c35",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{'a': 1, 'b': 2, 'c': 3, 'd': 4}\n"
]
}
],
"source": [
"dict1 = {'a': 1, 'b': 2}\n",
"dict2 = {'c': 3, 'd': 4}\n",
"\n",
"dict3 = {**dict1, **dict2}\n",
"\n",
"print(dict3)"
]
},
{
"cell_type": "markdown",
"id": "f144490a-5bb1-4db3-985b-e05aefea7c27",
"metadata": {},
"source": [
"#### <span style=\"color:#4CC9F0\">Hacer la unión de dos diccionarios</span> "
]
},
{
"cell_type": "markdown",
"id": "06e98fd7-42dd-439b-817e-b3e12f0948bb",
"metadata": {},
"source": [
"Disponible desde Python 3.9"
]
},
{
"cell_type": "code",
"execution_count": 34,
"id": "1fc9c99c-3d44-46f2-ab55-e6efb134bb84",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{'a': 1, 'b': 4, 'c': 3}\n"
]
}
],
"source": [
"dict1 = {'a':1, 'b':2}\n",
"dict2 = {'c':3, 'b':4}\n",
"\n",
"dict3 = dict1 | dict2\n",
"print(dict3)"
]
},
{
"cell_type": "markdown",
"id": "889825db-48f1-4fc1-b752-56c05228c5c2",
"metadata": {},
"source": [
"#### <span style=\"color:#4CC9F0\">Chequear si una clave existe en un diccionario</span> "
]
},
{
"cell_type": "code",
"execution_count": 35,
"id": "7f3c6443-9843-469e-baad-31dc33c106bd",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"True\n",
"False\n"
]
}
],
"source": [
"dict1 = {'a': 1, 'b': 2}\n",
"\n",
"print('a' in dict1)\n",
"print('c' in dict1)\n"
]
},
{
"cell_type": "markdown",
"id": "e548c8d0-72dd-4023-9795-fb055ddb457e",
"metadata": {
"tags": []
},
"source": [
"#### <span style=\"color:#4CC9F0\"> Remover un item de un diccionario</span> "
]
},
{
"cell_type": "markdown",
"id": "687ba235-0718-408b-b129-1a46f24506a8",
"metadata": {},
"source": [
"Revise las siguientes tres salidas y desarrolle su propio ejemplo."
]
},
{
"cell_type": "code",
"execution_count": 36,
"id": "20c4f99e-1b56-4930-9740-59cbc77839ca",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1\n",
"Missing Key\n"
]
},
{
"ename": "KeyError",
"evalue": "'d'",
"output_type": "error",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)",
"Cell \u001b[0;32mIn [36], line 5\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[38;5;28mprint\u001b[39m(dict1\u001b[38;5;241m.\u001b[39mpop(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124ma\u001b[39m\u001b[38;5;124m'\u001b[39m))\n\u001b[1;32m 4\u001b[0m \u001b[38;5;28mprint\u001b[39m(dict1\u001b[38;5;241m.\u001b[39mpop(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mc\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mMissing Key\u001b[39m\u001b[38;5;124m'\u001b[39m))\n\u001b[0;32m----> 5\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[43mdict1\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpop\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43md\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m)\n",
"\u001b[0;31mKeyError\u001b[0m: 'd'"
]
}
],
"source": [
"dict1 = {'a': 1, 'b': 2}\n",
"\n",
"print(dict1.pop('a'))\n",
"print(dict1.pop('c', 'Missing Key'))\n",
"print(dict1.pop('d'))"
]
},
{
"cell_type": "markdown",
"id": "013ba041-f46b-42d5-932a-da86431991d3",
"metadata": {},
"source": [
"#### <span style=\"color:#4CC9F0\">Diccionarios por comprensión</span> "
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "6c4b2ed1-4763-4c60-a6fb-f41c5050fd81",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81, 10: 100}\n"
]
}
],
"source": [
"dict1 = {i:i**2 for i in range(1,11)}\n",
"print(dict1)"
]
},
{
"cell_type": "markdown",
"id": "3f539f75-2491-400d-8a9b-96444b183b4f",
"metadata": {},
"source": [
"#### <span style=\"color:#4CC9F0\">Eliminar items vacios (None) en un diccionario</span> "
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "d6a8e274-7ac9-416c-a34f-dc61ee1678d9",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{'a': 'manzana', 'b': 'banano'}\n"
]
}
],
"source": [
"dict1 = {'a': 'manzana', 'b': 'banano', 'c':None}\n",
"\n",
"dict1 = {key:value for (key, value) in dict1.items() if value is not None}\n",
"print(dict1)\n"
]
},
{
"cell_type": "markdown",
"id": "d8d97029-665f-45a5-b94d-7c2589cf4b79",
"metadata": {},
"source": [
"#### <span style=\"color:#4CC9F0\">Uso de `get` para acceder a un ítem en un diccionario</span> "
]
},
{
"cell_type": "markdown",
"id": "6371585c-e099-4246-bc17-b1c975b2cf13",
"metadata": {},
"source": [
"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."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "04a99c19-8e55-4399-9540-0c71845685b7",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"None\n"
]
},
{
"ename": "KeyError",
"evalue": "'c'",
"output_type": "error",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)",
"\u001b[0;32m<ipython-input-68-035bdafe920c>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdict1\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'c'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdict1\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'c'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0;31m# Returns: None\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
"\u001b[0;31mKeyError\u001b[0m: 'c'"
]
}
],
"source": [
"dict1 = {'a':1, 'b':2}\n",
"\n",
"print(dict1.get('c'))\n",
"print(dict1['c'])\n",
"\n",
"# Returns: None\n",
"# Returns: KeyError"
]
},
{
"cell_type": "markdown",
"id": "86134d4b-9415-4bea-a4b5-96e8af18cb93",
"metadata": {},
"source": [
"#### <span style=\"color:#4CC9F0\">Filtrar un diccionario</span> "
]
},
{
"cell_type": "markdown",
"id": "a5094c7d-66a8-41e5-a428-9afd1202ff74",
"metadata": {},
"source": [
"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."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "df1f2832-db85-4eca-8a96-0e8bb0767ef7",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{'John': 175, 'María': 170}\n"
]
}
],
"source": [
"\n",
"alturas = {'John': 175, 'Luis': 150, 'Carlos': 155, 'María': 170}\n",
"\n",
"alto = {key:value for (key, value) in alturas.items() if value >= 170}\n",
"\n",
"print(tall)"
]
},
{
"cell_type": "markdown",
"id": "e49600b8-a079-460c-84f7-06913f9f2a5b",
"metadata": {},
"source": [
"#### <span style=\"color:#4CC9F0\"> Iterando en un diccionario un diccionario</span> "
]
},
{
"cell_type": "markdown",
"id": "36cca3c1-cc83-45c8-b2f5-ea69bbf84182",
"metadata": {},
"source": [
"Vamos iterar a lo largo de un diccionario, primero por las claves y luego por los valores."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "e59e5623-ae17-4823-87b1-e010f073db56",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{'León': 175, 'Luis': [150, 100], 'Carlos': 155, 'Angel': None}\n"
]
}
],
"source": [
"# creamos el diccionario\n",
"\n",
"salarios = {'León': 175, 'Luis': [150, 100], 'Carlos': 155, 'Angel': None}\n",
"print(salarios)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "f623f60c-2c98-4c64-a362-5442595d8c93",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"León\n",
"Luis\n",
"Carlos\n",
"Angel\n"
]
}
],
"source": [
"# recorremos por claves\n",
"\n",
"for salario in salarios:\n",
" print(salario)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "ddc0cc62-bc1b-4286-86b9-3ab2a650d677",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"León\n",
"Luis\n",
"Carlos\n",
"Angel\n"
]
}
],
"source": [
"# de nuevo por claves\n",
"for persona in salarios.keys():\n",
" print(persona)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "52b41338-d286-4bb0-820d-cb72b76b283a",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"175\n",
"[150, 100]\n",
"155\n",
"None\n"
]
}
],
"source": [
"# recorremos por valores\n",
"for salario in salarios.values():\n",
" print(salario)"
]
},
{
"cell_type": "markdown",
"id": "d6b0e21e-452a-4728-befe-d7b08ed51af1",
"metadata": {},
"source": [
"<figure>\n",
"<img src=\"../Imagenes/logo-final-ap.png\" width=\"80\" height=\"80\" align=\"right\"/> \n",
"</figure>"
]
}
],
"metadata": {
"interpreter": {
"hash": "cf92aa13fedf815d5c8dd192b8d835913fde3e8bc926b2a0ad6cc74ef2ba3ca2"
},
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.10.9"
}
},
"nbformat": 4,
"nbformat_minor": 5
}