Programación-Python/Cuadernos/py_0090_Diccionarios.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "04b97205",
   "metadata": {},
   "source": [
    "# <span style=\"color:#F72585\"><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": "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)"
   ]
  }
 ],
 "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}