Diccionarios.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Diccionarios en Python\n",
    "\n",
    "## Descripción: \n",
    "Este notebook esta considerado para explicar diccionarios que utilizan `key` de tipo cadena de caracteres. \n",
    "\n",
    "## Autores: \n",
    "* Erika Muñoz : [emunozto](https://www.github.com/emunozto)\n",
    "* Jose Nandez : [jnandez](https://www.github.com/jnandez)\n",
    "\n",
    "## Introduccion:\n",
    "Un diccionario es una estructura de datos que nos permite almacenar enteros, strings y listas. La cualidad más\n",
    "importante de los diccionarios es que nos permiten relacionar e identificar a cada elemento por un `key`. Una forma de pensar un diccionario es un listado de parejas de `key: value`, separadas por coma `,`.\n",
    "Las `key` (o claves) que son de tipo `str` (o cadenas de caracteres) deben ser especificadas mediante un `'`. Los `value` de un diccionario pueden ser enteros, string, o listas.\n",
    "Para definir un diccionario se utilizan `{ }`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Definición de un diccionario\n",
    "estudiante = {'nombre':'Erika', 'edad':20, 'cursos':['matematicas', 'fisica', 'computacion']}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para acceder a un elemento del diccionario se llama a su clave"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20\n"
     ]
    }
   ],
   "source": [
    "print(diccionario['edad']) #el value es un entero"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Erika\n"
     ]
    }
   ],
   "source": [
    "print(diccionario['nombre']) # el value es un string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['matematicas', 'fisica', 'computacion']\n"
     ]
    }
   ],
   "source": [
    "print(diccionario['cursos']) #el value es una lista"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para acceder a cada elemento de la lista `cursos` se utilizan sus indices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "computacion\n"
     ]
    }
   ],
   "source": [
    "print(diccionario['cursos'][2]) # en Python el índice empieza en 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos imprimir todo el diccionario a la vez con un ciclo `for`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nombre : Erika\n",
      "edad : 20\n",
      "cursos : ['matematicas', 'fisica', 'computacion']\n"
     ]
    }
   ],
   "source": [
    "for key in diccionario:\n",
    "    print (key, ':', diccionario[key])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos obtener la cantidad de elementos en el diccionario"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(estudiante)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos obtener los `keys` y`values` en el diccionario"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['nombre', 'edad', 'cursos'])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "estudiante.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_values(['Erika', 20, ['matematicas', 'fisica', 'computacion']])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "estudiante.values()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los diccionarios en Python tambien tienen otros metodos que pueden ser llamados con"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_items([('nombre', 'Erika'), ('edad', 20), ('cursos', ['matematicas', 'fisica', 'computacion'])])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "estudiante.items() # devuelve tuplas del tipo ('key,'value')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "estudiante.get('edad') # el método get recibe como parametro una key y devuelve el valor asociado.  get('key')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Em método `.fromkeys()` nos permite cambiar manipular los valores asociados a las `keys` introducidas sin cambiar el diccionario original"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'nombre': 1000, 'edad': 1000, 'cursos': 1000}\n"
     ]
    }
   ],
   "source": [
    "test = estudiante.fromkeys(['nombre', 'edad', 'cursos'],1000) #fromkeys(['key1','key2'],valor). Este metodo \n",
    "#recibe keys y un valor, el cual reemplazara el valor relacionado a las keys especificadas.\n",
    "print(test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El método `pop` pops out o recibe un `key` y devuelve su valor, pero elimina esta pareja del diccionario original"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'nombre': 'Erika', 'edad': 20, 'cursos': ['matematicas', 'fisica', 'computacion']}\n"
     ]
    }
   ],
   "source": [
    "print(estudiante)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "estudiante.pop('edad')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'nombre': 'Erika', 'cursos': ['matematicas', 'fisica', 'computacion']}\n"
     ]
    }
   ],
   "source": [
    "print(estudiante)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es útil cuando definimos nuevos diccionarios basados en los que contienen mas información."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El metodo `.setdefault()` nos permite agreggar parejas de `'key':value` a nuestro diccionario"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2019"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "estudiante.setdefault('ciclo',2019)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'nombre': 'Erika', 'cursos': ['matematicas', 'fisica', 'computacion'], 'ciclo': 2019}\n"
     ]
    }
   ],
   "source": [
    "print(estudiante)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También se puede utilizar de forma general, similar a `.get()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [],
   "source": [
    "estudiante.setdefault('ciclo')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Consideremos adjuntar dos diccionarios con el método `.update()`.\n",
    "Primero definimos el nuevo diccionario a anexar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [],
   "source": [
    "estudiante2 = {'calificaciones': [9,10,9], 'area': 'ciencias', 'beca': 'si'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [],
   "source": [
    "estudiante.update(estudiante2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'nombre': 'Erika',\n",
       " 'edad': 20,\n",
       " 'cursos': ['matematicas', 'fisica', 'computacion'],\n",
       " 'area': 'ciencias',\n",
       " 'calificaciones': [9, 10, 9],\n",
       " 'beca': 'si'}"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "estudiante"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Este método agrega los valores del segundo diccionario si las `keys` no se encuentra en el primer diccionario, como en el ejemplo anterior. Si las `keys` se encuentran repetidas entonces se reescribira el valor de esta.\n",
    "\n",
    "si las `keys` del segundo diccionario no se encuentran en el primer diccionario entonces se anexaran los valores como en el ejemplo anterior, de lo contrario, si se encuentra repetida entonces se reescribira el valor de esa `key`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'nombre': 'Luis',\n",
       " 'edad': 21,\n",
       " 'cursos': ['matematicas', 'fisica', 'computacion'],\n",
       " 'area': 'ciencias',\n",
       " 'calificaciones': [9, 10, 9],\n",
       " 'beca': 'si'}"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "estudiante3 = {'nombre':'Luis', 'edad': 21}\n",
    "estudiante.update(estudiante3)\n",
    "estudiante"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}